fluencelabs/lalrpop
1
0
Fork 0
mirror of https://github.com/fluencelabs/lalrpop synced 2025-03-16 17:00:53 +00:00
Code Issues Projects Releases Wiki Activity

refactor how we handle locations so that it is only the parse_FOO

Browse Source 
function that does the adaptation for optional location information (is
optional location information even worth it, or should we just default
to `()`)?
This commit is contained in:
Niko Matsakis 2015-07-20 06:18:39 -04:00
parent 8d1fed1e25
commit 9f4c82cf36
7 changed files with 4492 additions and 4446 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2412
lalrpop-test/src/expr.rs
View File

File diff suppressed because it is too large Load Diff

5183
lalrpop-test/src/expr_arena.rs
View File

File diff suppressed because it is too large Load Diff

429
lalrpop-test/src/loc.rs
View File

@ -3,22 +3,27 @@ use util::tok::Tok;
#[allow(non_snake_case)]
pub fn parse_Items<
__TOKENS: IntoIterator<Item=(usize,Tok,usize)>,
__TOKENS: IntoIterator<Item=(usize, Tok, usize)>,
>(
__tokens: __TOKENS,
) -> Result<Vec<(usize, usize)>, Option<(usize,Tok,usize)>>
) -> Result<Vec<(usize, usize)>, Option<(usize, Tok, usize)>>
{
let mut __tokens = __tokens.into_iter();
let __lookahead = __tokens.next();
match try!(__parse__Items::__state0(None, __lookahead, &mut __tokens)) {
(_, __lookahead, __parse__Items::__Nonterminal::____Items(__nt)) => {
if __lookahead.is_some() {
Err(__lookahead)
} else {
Ok(__nt)
}
match __parse__Items::__state0(None, __lookahead, &mut __tokens) {
Err(None) => {
Err(None)
}
_ => unreachable!(),
Err(Some(__lookahead)) => {
Err(Some(__lookahead))
}
Ok((_, Some(__lookahead), _)) => {
Err(Some(__lookahead))
}
Ok((_, None, __parse__Items::__Nonterminal::____Items(__nt))) => {
Ok(__nt)
}
Ok(_) => unreachable!(),
}
}
@ -28,11 +33,11 @@ mod __parse__Items {
use util::tok::Tok;
pub enum __Nonterminal<> {
Items(Vec<(usize, usize)>),
____Items(Vec<(usize, usize)>),
Spanned_3c_22_2b_22_3e((usize, usize)),
_40_3c(usize),
_40_3e(usize),
____Items(Vec<(usize, usize)>),
Spanned_3c_22_2b_22_3e((usize, usize)),
Items(Vec<(usize, usize)>),
}
// State 0
@ -50,26 +55,22 @@ mod __parse__Items {
// Items = (*) Items "-" ["-"]
// __Items = (*) Items [EOF]
//
// EOF -> Reduce(@< = => Lookahead;)
// "+" -> Reduce(@< = => Lookahead;)
// "-" -> Reduce(@< = => Lookahead;)
// EOF -> Reduce(@< = => Lookahead;)
//
// @< -> S2
// Items -> S1
// @< -> S1
// Items -> S2
pub fn __state0<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
__TOKENS: Iterator<Item=(usize, Tok, usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__lookahead: Option<(usize, Tok, usize)>,
__tokens: &mut __TOKENS,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
) -> Result<(Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>), Option<(usize, Tok, usize)>>
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
None => {
let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
}
Some((_, Tok::Plus(..), _)) => {
let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
@ -78,6 +79,10 @@ mod __parse__Items {
let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
}
None => {
let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
}
_ => {
return Err(__lookahead);
}
@ -87,11 +92,11 @@ mod __parse__Items {
match __nt {
__Nonterminal::_40_3c(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
__result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0));
}
__Nonterminal::Items(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0));
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
@ -101,74 +106,6 @@ mod __parse__Items {
}
// State 1
// @< = (*) ["+"]
// Items = Items (*) Spanned<"+"> [EOF]
// Items = Items (*) Spanned<"+"> ["+"]
// Items = Items (*) Spanned<"+"> ["-"]
// Items = Items (*) "-" [EOF]
// Items = Items (*) "-" ["+"]
// Items = Items (*) "-" ["-"]
// Spanned<"+"> = (*) @< "+" @> [EOF]
// Spanned<"+"> = (*) @< "+" @> ["+"]
// Spanned<"+"> = (*) @< "+" @> ["-"]
// __Items = Items (*) [EOF]
//
// "+" -> Reduce(@< = => Lookahead;)
// EOF -> Reduce(__Items = Items => Call(ActionFn(0));)
// "-" -> Shift(S3)
//
// Spanned<"+"> -> S5
// @< -> S4
pub fn __state1<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Vec<(usize, usize)>>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Minus(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
Some((_, Tok::Plus(..), _)) => {
let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action0(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::____Items(__nt)));
}
_ => {
return Err(__lookahead);
}
}
while __sym0.is_some() {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::Spanned_3c_22_2b_22_3e(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
__Nonterminal::_40_3c(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
}
}
}
return Ok(__result);
}
// State 2
// @> = (*) [EOF]
// @> = (*) ["+"]
// @> = (*) ["-"]
@ -176,22 +113,26 @@ mod __parse__Items {
// Items = @< (*) @> ["+"]
// Items = @< (*) @> ["-"]
//
// "-" -> Reduce(@> = => Lookbehind;)
// EOF -> Reduce(@> = => Lookbehind;)
// "+" -> Reduce(@> = => Lookbehind;)
// "-" -> Reduce(@> = => Lookbehind;)
//
// @> -> S6
pub fn __state2<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
// @> -> S3
pub fn __state1<
__TOKENS: Iterator<Item=(usize, Tok, usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__lookahead: Option<(usize, Tok, usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<usize>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
) -> Result<(Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>), Option<(usize, Tok, usize)>>
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Minus(..), _)) => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
}
None => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
@ -200,10 +141,6 @@ mod __parse__Items {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
}
Some((_, Tok::Minus(..), _)) => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
}
_ => {
return Err(__lookahead);
}
@ -213,7 +150,75 @@ mod __parse__Items {
match __nt {
__Nonterminal::_40_3e(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
}
}
}
return Ok(__result);
}
// State 2
// @< = (*) ["+"]
// Items = Items (*) Spanned<"+"> [EOF]
// Items = Items (*) Spanned<"+"> ["+"]
// Items = Items (*) Spanned<"+"> ["-"]
// Items = Items (*) "-" [EOF]
// Items = Items (*) "-" ["+"]
// Items = Items (*) "-" ["-"]
// Spanned<"+"> = (*) @< "+" @> [EOF]
// Spanned<"+"> = (*) @< "+" @> ["+"]
// Spanned<"+"> = (*) @< "+" @> ["-"]
// __Items = Items (*) [EOF]
//
// EOF -> Reduce(__Items = Items => Call(ActionFn(0));)
// "+" -> Reduce(@< = => Lookahead;)
// "-" -> Shift(S6)
//
// Spanned<"+"> -> S4
// @< -> S5
pub fn __state2<
__TOKENS: Iterator<Item=(usize, Tok, usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize, Tok, usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Vec<(usize, usize)>>,
) -> Result<(Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>), Option<(usize, Tok, usize)>>
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Minus(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action0(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::____Items(__nt)));
}
Some((_, Tok::Plus(..), _)) => {
let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
}
_ => {
return Err(__lookahead);
}
}
while __sym0.is_some() {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::Spanned_3c_22_2b_22_3e(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
__Nonterminal::_40_3c(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
@ -224,42 +229,42 @@ mod __parse__Items {
}
// State 3
// Items = Items "-" (*) [EOF]
// Items = Items "-" (*) ["+"]
// Items = Items "-" (*) ["-"]
// Items = @< @> (*) [EOF]
// Items = @< @> (*) ["+"]
// Items = @< @> (*) ["-"]
//
// "-" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// EOF -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// "+" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// "+" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// "-" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// EOF -> Reduce(Items = @<, @> => Call(ActionFn(1));)
//
pub fn __state3<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
__TOKENS: Iterator<Item=(usize, Tok, usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__lookahead: Option<(usize, Tok, usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Vec<(usize, usize)>>,
__sym1: &mut Option<Tok>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
__sym0: &mut Option<usize>,
__sym1: &mut Option<usize>,
) -> Result<(Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>), Option<(usize, Tok, usize)>>
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Plus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action1(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action3(__sym0, __sym1);
let __nt = super::__action1(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action3(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
Some((_, Tok::Plus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action3(__sym0, __sym1);
let __nt = super::__action1(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
_ => {
@ -269,22 +274,67 @@ mod __parse__Items {
}
// State 4
// Items = Items Spanned<"+"> (*) [EOF]
// Items = Items Spanned<"+"> (*) ["+"]
// Items = Items Spanned<"+"> (*) ["-"]
//
// "-" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// "+" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// EOF -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
//
pub fn __state4<
__TOKENS: Iterator<Item=(usize, Tok, usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize, Tok, usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Vec<(usize, usize)>>,
__sym1: &mut Option<(usize, usize)>,
) -> Result<(Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>), Option<(usize, Tok, usize)>>
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action2(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
Some((_, Tok::Plus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action2(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action2(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 5
// Spanned<"+"> = @< (*) "+" @> [EOF]
// Spanned<"+"> = @< (*) "+" @> ["+"]
// Spanned<"+"> = @< (*) "+" @> ["-"]
//
// "+" -> Shift(S7)
//
pub fn __state4<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
pub fn __state5<
__TOKENS: Iterator<Item=(usize, Tok, usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__lookahead: Option<(usize, Tok, usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<usize>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
) -> Result<(Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>), Option<(usize, Tok, usize)>>
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Plus(..), __loc)) => {
let mut __lookbehind = Some(__loc);
@ -299,88 +349,43 @@ mod __parse__Items {
return Ok(__result);
}
// State 5
// Items = Items Spanned<"+"> (*) [EOF]
// Items = Items Spanned<"+"> (*) ["+"]
// Items = Items Spanned<"+"> (*) ["-"]
//
// "+" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// "-" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// EOF -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
//
pub fn __state5<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Vec<(usize, usize)>>,
__sym1: &mut Option<(usize, usize)>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Plus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action2(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action2(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action2(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 6
// Items = @< @> (*) [EOF]
// Items = @< @> (*) ["+"]
// Items = @< @> (*) ["-"]
// Items = Items "-" (*) [EOF]
// Items = Items "-" (*) ["+"]
// Items = Items "-" (*) ["-"]
//
// "-" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// EOF -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// "+" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// "+" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// EOF -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// "-" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
//
pub fn __state6<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
__TOKENS: Iterator<Item=(usize, Tok, usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__lookahead: Option<(usize, Tok, usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<usize>,
__sym1: &mut Option<usize>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
__sym0: &mut Option<Vec<(usize, usize)>>,
__sym1: &mut Option<Tok>,
) -> Result<(Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>), Option<(usize, Tok, usize)>>
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action1(__sym0, __sym1);
let __nt = super::__action3(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action1(__sym0, __sym1);
let __nt = super::__action3(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
Some((_, Tok::Plus(..), _)) => {
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action1(__sym0, __sym1);
let __nt = super::__action3(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
_ => {
@ -398,31 +403,31 @@ mod __parse__Items {
// Spanned<"+"> = @< "+" (*) @> ["-"]
//
// "-" -> Reduce(@> = => Lookbehind;)
// EOF -> Reduce(@> = => Lookbehind;)
// "+" -> Reduce(@> = => Lookbehind;)
// EOF -> Reduce(@> = => Lookbehind;)
//
// @> -> S8
pub fn __state7<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
__TOKENS: Iterator<Item=(usize, Tok, usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__lookahead: Option<(usize, Tok, usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<usize>,
__sym1: &mut Option<Tok>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
) -> Result<(Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>), Option<(usize, Tok, usize)>>
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Minus(..), _)) => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
}
None => {
Some((_, Tok::Plus(..), _)) => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
}
Some((_, Tok::Plus(..), _)) => {
None => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
}
@ -450,23 +455,30 @@ mod __parse__Items {
// Spanned<"+"> = @< "+" @> (*) ["+"]
// Spanned<"+"> = @< "+" @> (*) ["-"]
//
// EOF -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
// "+" -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
// "-" -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
// EOF -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
//
pub fn __state8<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
__TOKENS: Iterator<Item=(usize, Tok, usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__lookahead: Option<(usize, Tok, usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<usize>,
__sym1: &mut Option<Tok>,
__sym2: &mut Option<usize>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
) -> Result<(Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>), Option<(usize, Tok, usize)>>
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action4(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::Spanned_3c_22_2b_22_3e(__nt)));
}
Some((_, Tok::Plus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
@ -481,13 +493,6 @@ mod __parse__Items {
let __nt = super::__action4(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::Spanned_3c_22_2b_22_3e(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action4(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::Spanned_3c_22_2b_22_3e(__nt)));
}
_ => {
return Err(__lookahead);
}

784
lalrpop-test/src/sub.rs
View File

File diff suppressed because it is too large Load Diff

1
lalrpop/src/build/mod.rs
View File

@ -179,4 +179,3 @@ fn emit_action_code<W:Write>(grammar: &r::Grammar,
}
Ok(())
}

13
lalrpop/src/grammar/repr.rs
View File

@ -140,6 +140,11 @@ impl Types {
self.terminal_loc_type.as_ref()
}
pub fn terminal_loc_type(&self) -> TypeRepr {
self.terminal_loc_type.clone()
.unwrap_or_else(|| TypeRepr::Tuple(vec![]))
}
pub fn terminal_type(&self, id: TerminalString) -> &TypeRepr {
self.terminal_types.get(&id).unwrap_or(&self.default_terminal_type)
}
@ -151,6 +156,14 @@ impl Types {
pub fn nonterminal_type(&self, id: NonterminalString) -> &TypeRepr {
&self.nonterminal_types[&id]
}
pub fn triple_type(&self) -> TypeRepr {
let enum_type = self.terminal_enum_type();
let location_type = self.terminal_loc_type();
TypeRepr::Tuple(vec![location_type.clone(),
TypeRepr::Nominal(enum_type.clone()),
location_type])
}
}
impl Display for Parameter {

116
lalrpop/src/lr1/ascent.rs
View File

@ -2,7 +2,11 @@
//!
//! [recursive ascent]: https://en.wikipedia.org/wiki/Recursive_ascent_parser
use grammar::repr::{ActionKind, Grammar, NonterminalString, Symbol, TerminalString, Types};
use grammar::repr::{ActionKind,
Grammar,
NonterminalString,
Symbol,
TerminalString, TypeRepr, Types};
use lr1::{Lookahead, State, StateIndex};
use rust::RustWrite;
use std::io::{self, Write};
@ -107,32 +111,66 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
// input as `Foo`. An error is reported if the entire input is not
// consumed.
fn write_start_fn(&mut self) -> io::Result<()> {
let item_type = self.iterator_item_type();
let triple_type = self.triple_type();
let user_token_type = match self.types.opt_terminal_loc_type() {
Some(_) => format!("{}", triple_type),
None => format!("{}", self.types.terminal_enum_type())
};
rust!(self.out, "#[allow(non_snake_case)]");
try!(self.out.write_pub_fn_header(
self.grammar,
format!("parse_{}", self.user_start_symbol),
vec![format!("{}TOKENS: IntoIterator<Item={}>", self.prefix, item_type)],
vec![format!("{}TOKENS: IntoIterator<Item={}>", self.prefix, user_token_type)],
vec![format!("{}tokens: {}TOKENS", self.prefix, self.prefix)],
format!("Result<{}, Option<{}>>",
self.types.nonterminal_type(self.start_symbol), item_type),
self.types.nonterminal_type(self.start_symbol), user_token_type),
vec![]));
rust!(self.out, "{{");
// create input iterator, inserting `()` for locations if no location was given
rust!(self.out, "let mut {}tokens = {}tokens.into_iter();", self.prefix, self.prefix);
match self.types.opt_terminal_loc_type() {
Some(_) => { }
None => { rust!(self.out, "let mut {}tokens = {}tokens.map(|t| ((), t, ()));",
self.prefix, self.prefix); }
}
rust!(self.out, "let {}lookahead = {}tokens.next();", self.prefix, self.prefix);
rust!(self.out, "match try!({}parse{}::{}state0({}None, {}lookahead, &mut {}tokens)) {{",
rust!(self.out, "match {}parse{}::{}state0({}None, {}lookahead, &mut {}tokens) {{",
self.prefix, self.start_symbol, self.prefix,
self.grammar.user_parameter_refs(), self.prefix, self.prefix);
rust!(self.out, "(_, {}lookahead, {}parse{}::{}Nonterminal::{}({}nt)) => {{",
self.prefix, self.prefix, self.start_symbol, self.prefix, Escape(self.start_symbol),
let transformed_lookahead = match self.types.opt_terminal_loc_type() {
Some(_) => format!("{}lookahead", self.prefix),
None => format!("{}lookahead.1", self.prefix),
};
// unexpected EOF?
rust!(self.out, "Err(None) => {{");
rust!(self.out, "Err(None)");
rust!(self.out, "}}");
// unexpected token during parsing?
rust!(self.out, "Err(Some({}lookahead)) => {{", self.prefix);
rust!(self.out, "Err(Some({}))", transformed_lookahead);
rust!(self.out, "}}");
// extra tokens?
rust!(self.out, "Ok((_, Some({}lookahead), _)) => {{", self.prefix);
rust!(self.out, "Err(Some({}))", transformed_lookahead);
rust!(self.out, "}}");
// otherwise, we expect to see only the goal terminal
rust!(self.out, "Ok((_, None, {}parse{}::{}Nonterminal::{}({}nt))) => {{",
self.prefix, self.start_symbol, self.prefix, Escape(self.start_symbol),
self.prefix);
rust!(self.out, "if {}lookahead.is_some() {{", self.prefix);
rust!(self.out, "Err({}lookahead)", self.prefix); // extra tokens
rust!(self.out, "}} else {{");
rust!(self.out, "Ok({}nt)", self.prefix);
rust!(self.out, "}}");
rust!(self.out, "}}");
rust!(self.out, "_ => unreachable!(),");
// nothing else should be possible
rust!(self.out, "Ok(_) => unreachable!(),");
rust!(self.out, "}}");
rust!(self.out, "}}");
@ -142,11 +180,8 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
fn write_state_fn(&mut self, this_index: StateIndex) -> io::Result<()> {
let this_state = &self.states[this_index.0];
let this_prefix = self.state_prefixes[this_index.0];
let loc_type = match self.types.opt_terminal_loc_type() {
Some(t) => format!("{}", t),
None => format!("()"),
};
let item_type = self.iterator_item_type();
let loc_type = self.types.terminal_loc_type();
let triple_type = self.triple_type();
// Leave a comment explaining what this state is.
rust!(self.out, "// State {}", this_index.0);
@ -167,7 +202,7 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
let base_args =
vec![format!("{}lookbehind: Option<{}>", self.prefix, loc_type),
format!("{}lookahead: Option<{}>", self.prefix, item_type),
format!("{}lookahead: Option<{}>", self.prefix, triple_type),
format!("{}tokens: &mut {}TOKENS", self.prefix, self.prefix)];
let sym_args: Vec<_> =
(0..this_prefix.len())
@ -178,18 +213,18 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
try!(self.out.write_pub_fn_header(
self.grammar,
format!("{}state{}", self.prefix, this_index.0),
vec![format!("{}TOKENS: Iterator<Item={}>", self.prefix, item_type)],
vec![format!("{}TOKENS: Iterator<Item={}>", self.prefix, triple_type)],
base_args.into_iter().chain(sym_args).collect(),
format!("Result<(Option<{}>, Option<{}>, {}Nonterminal<{}>), Option<{}>>",
loc_type,
item_type, self.prefix,
triple_type, self.prefix,
self.grammar.user_type_parameter_refs(),
item_type),
triple_type),
vec![]));
rust!(self.out, "{{");
rust!(self.out, "let mut {}result: (Option<{}>, Option<{}>, {}Nonterminal<{}>);",
self.prefix, loc_type, item_type, self.prefix,
self.prefix, loc_type, triple_type, self.prefix,
self.grammar.user_type_parameter_refs());
rust!(self.out, "match {}lookahead {{", self.prefix);
@ -260,7 +295,6 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
// at EOF, so taker the lookbehind (end of last
// pushed token); if that is missing too, then
// supply default.
debug_assert!(self.types.opt_terminal_loc_type().is_some());
rust!(self.out,
"let {}nt = \
{}lookahead.as_ref()\
@ -272,7 +306,6 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
ActionKind::Lookbehind => {
// take lookbehind or supply default.
debug_assert!(self.types.opt_terminal_loc_type().is_some());
rust!(self.out,
"let {}nt = ::std::clone::Clone::clone(&{}lookbehind)\
.unwrap_or_default();",
@ -391,9 +424,7 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
.map(&mut |_| "_");
let mut pattern = format!("{}", pattern);
if self.types.opt_terminal_loc_type().is_some() {
pattern = format!("(_, {}, _)", pattern);
}
pattern = format!("(_, {}, _)", pattern);
rust!(self.out, "Some({}) => {{", pattern);
Ok(())
@ -418,18 +449,13 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
pattern_names.push(format!("{}tok", self.prefix));
pattern = format!("{}tok @ {}", self.prefix, pattern);
}
if self.types.opt_terminal_loc_type().is_some() {
pattern = format!("(_, {}, {}loc)", pattern, self.prefix);
}
pattern = format!("(_, {}, {}loc)", pattern, self.prefix);
rust!(self.out, "Some({}) => {{", pattern);
if self.types.opt_terminal_loc_type().is_some() {
rust!(self.out, "let mut {} = Some({}loc);",
lb_name, self.prefix);
} else {
rust!(self.out, "let mut {} = None;", lb_name);
}
rust!(self.out, "let mut {} = Some({}loc);",
lb_name, self.prefix);
rust!(self.out, "let mut {} = &mut Some(({}));",
let_name, pattern_names.connect(", "));
@ -437,22 +463,8 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
Ok(())
}
/// Returns the type of things we are iterating over. This will
/// depend on whether the user specified a location type `L`
/// or just an enum type `E`:
///
/// - `(L,E,L)` if a location type is specified,
/// - `E` otherwise.
fn iterator_item_type(&mut self) -> String {
let enum_type = self.types.terminal_enum_type();
match self.types.opt_terminal_loc_type() {
Some(loc_type) => {
format!("({},{},{})", loc_type, enum_type, loc_type)
}
None => {
format!("{}", enum_type)
}
}
fn triple_type(&mut self) -> TypeRepr {
self.types.triple_type()
}
}