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

change parse_Foo so that it expects to consume entire input;

Browse Source 
later we'll make a version called `resume_Foo` or something that
lets you supply the initial state (lookbehind, lookahead, etc)
in its entirety
This commit is contained in:
Niko Matsakis 2015-07-20 05:43:07 -04:00
parent 2383a021c9
commit 8d1fed1e25
6 changed files with 4263 additions and 4238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

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

@ -6,12 +6,18 @@ pub fn parse_Items<
__TOKENS: IntoIterator<Item=(usize,Tok,usize)>,
>(
__tokens: __TOKENS,
) -> Result<(Option<(usize,Tok,usize)>, 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)) => Ok((__lookahead, __nt)),
(_, __lookahead, __parse__Items::__Nonterminal::____Items(__nt)) => {
if __lookahead.is_some() {
Err(__lookahead)
} else {
Ok(__nt)
}
}
_ => unreachable!(),
}
}
@ -22,11 +28,11 @@ mod __parse__Items {
use util::tok::Tok;
pub enum __Nonterminal<> {
_40_3e(usize),
____Items(Vec<(usize, usize)>),
Items(Vec<(usize, usize)>),
____Items(Vec<(usize, usize)>),
Spanned_3c_22_2b_22_3e((usize, usize)),
_40_3c(usize),
_40_3e(usize),
}
// State 0
@ -45,11 +51,11 @@ mod __parse__Items {
// __Items = (*) Items [EOF]
//
// EOF -> Reduce(@< = => Lookahead;)
// "-" -> Reduce(@< = => Lookahead;)
// "+" -> Reduce(@< = => Lookahead;)
// "-" -> Reduce(@< = => Lookahead;)
//
// Items -> S2
// @< -> S1
// @< -> S2
// Items -> S1
pub fn __state0<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
>(
@ -64,11 +70,11 @@ 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));
}
Some((_, Tok::Minus(..), _)) => {
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));
}
Some((_, Tok::Plus(..), _)) => {
Some((_, Tok::Minus(..), _)) => {
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));
}
@ -79,11 +85,11 @@ mod __parse__Items {
loop {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::Items(__nt) => {
__Nonterminal::_40_3c(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
}
__Nonterminal::_40_3c(__nt) => {
__Nonterminal::Items(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0));
}
@ -95,6 +101,74 @@ 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]
// @> = (*) ["+"]
// @> = (*) ["-"]
@ -106,8 +180,8 @@ mod __parse__Items {
// "+" -> Reduce(@> = => Lookbehind;)
// "-" -> Reduce(@> = => Lookbehind;)
//
// @> -> S3
pub fn __state1<
// @> -> S6
pub fn __state2<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
>(
__lookbehind: Option<usize>,
@ -139,75 +213,7 @@ mod __parse__Items {
match __nt {
__Nonterminal::_40_3e(__nt) => {
let __sym1 = &mut Some(__nt);
__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]
//
// "-" -> Shift(S5)
// EOF -> Reduce(__Items = Items => Call(ActionFn(0));)
// "+" -> Reduce(@< = => Lookahead;)
//
// @< -> S6
// Spanned<"+"> -> S4
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!(__state5(__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::_40_3c(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym1));
}
__Nonterminal::Spanned_3c_22_2b_22_3e(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
__result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
@ -218,105 +224,15 @@ mod __parse__Items {
}
// State 3
// Items = @< @> (*) [EOF]
// Items = @< @> (*) ["+"]
// Items = @< @> (*) ["-"]
//
// "+" -> 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)>,
>(
__lookbehind: Option<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)>>
{
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::__action1(__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);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 4
// Items = Items Spanned<"+"> (*) [EOF]
// Items = Items Spanned<"+"> (*) ["+"]
// Items = Items Spanned<"+"> (*) ["-"]
//
// "-" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// EOF -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// "+" -> 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)));
}
None => {
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)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 5
// Items = Items "-" (*) [EOF]
// Items = Items "-" (*) ["+"]
// Items = Items "-" (*) ["-"]
//
// EOF -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// "-" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// EOF -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// "+" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
//
pub fn __state5<
pub fn __state3<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
>(
__lookbehind: Option<usize>,
@ -328,13 +244,13 @@ mod __parse__Items {
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
match __lookahead {
None => {
Some((_, Tok::Minus(..), _)) => {
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::Minus(..), _)) => {
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action3(__sym0, __sym1);
@ -352,14 +268,14 @@ mod __parse__Items {
}
}
// State 6
// State 4
// Spanned<"+"> = @< (*) "+" @> [EOF]
// Spanned<"+"> = @< (*) "+" @> ["+"]
// Spanned<"+"> = @< (*) "+" @> ["-"]
//
// "+" -> Shift(S7)
//
pub fn __state6<
pub fn __state4<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
>(
__lookbehind: Option<usize>,
@ -383,6 +299,96 @@ 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 = @< @> (*) ["-"]
//
// "-" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// EOF -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// "+" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
//
pub fn __state6<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
>(
__lookbehind: Option<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)>>
{
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::__action1(__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);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
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)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 7
// @> = (*) [EOF]
// @> = (*) ["+"]
@ -391,8 +397,8 @@ mod __parse__Items {
// Spanned<"+"> = @< "+" (*) @> ["+"]
// Spanned<"+"> = @< "+" (*) @> ["-"]
//
// EOF -> Reduce(@> = => Lookbehind;)
// "-" -> Reduce(@> = => Lookbehind;)
// EOF -> Reduce(@> = => Lookbehind;)
// "+" -> Reduce(@> = => Lookbehind;)
//
// @> -> S8
@ -408,11 +414,11 @@ mod __parse__Items {
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
match __lookahead {
None => {
Some((_, Tok::Minus(..), _)) => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
}
Some((_, Tok::Minus(..), _)) => {
None => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
}
@ -445,8 +451,8 @@ mod __parse__Items {
// Spanned<"+"> = @< "+" @> (*) ["-"]
//
// "+" -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
// EOF -> 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)>,
@ -468,14 +474,14 @@ mod __parse__Items {
let __nt = super::__action4(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::Spanned_3c_22_2b_22_3e(__nt)));
}
None => {
Some((_, Tok::Minus(..), _)) => {
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::Minus(..), _)) => {
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();

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

@ -6,12 +6,18 @@ pub fn parse_S<
__TOKENS: IntoIterator<Item=Tok>,
>(
__tokens: __TOKENS,
) -> Result<(Option<Tok>, i32), Option<Tok>>
) -> Result<i32, Option<Tok>>
{
let mut __tokens = __tokens.into_iter();
let __lookahead = __tokens.next();
match try!(__parse__S::__state0(None, __lookahead, &mut __tokens)) {
(_, __lookahead, __parse__S::__Nonterminal::____S(__nt)) => Ok((__lookahead, __nt)),
(_, __lookahead, __parse__S::__Nonterminal::____S(__nt)) => {
if __lookahead.is_some() {
Err(__lookahead)
} else {
Ok(__nt)
}
}
_ => unreachable!(),
}
}
@ -22,10 +28,10 @@ mod __parse__S {
use util::tok::Tok;
pub enum __Nonterminal<> {
____S(i32),
T(i32),
E(i32),
S(i32),
____S(i32),
T(i32),
}
// State 0
@ -40,12 +46,12 @@ mod __parse__S {
// T = (*) "Num" ["-"]
// __S = (*) S [EOF]
//
// "(" -> Shift(S2)
// "Num" -> Shift(S3)
// "Num" -> Shift(S5)
// "(" -> Shift(S3)
//
// S -> S1
// T -> S2
// E -> S4
// T -> S5
pub fn __state0<
__TOKENS: Iterator<Item=Tok>,
>(
@ -56,16 +62,16 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::LParen(..)) => {
let mut __lookbehind = None;
let mut __sym0 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
}
Some(Tok::Num(__tok0)) => {
let mut __lookbehind = None;
let mut __sym0 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0));
}
Some(__tok @ Tok::LParen(..)) => {
let mut __lookbehind = None;
let mut __sym0 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0));
}
_ => {
@ -79,14 +85,14 @@ mod __parse__S {
let __sym0 = &mut Some(__nt);
__result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0));
}
__Nonterminal::T(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
}
__Nonterminal::E(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0));
}
__Nonterminal::T(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
}
@ -122,77 +128,14 @@ mod __parse__S {
}
// State 2
// E = (*) E "-" T [")"]
// E = (*) E "-" T ["-"]
// E = (*) T [")"]
// E = (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = "(" (*) E ")" [EOF]
// T = "(" (*) E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
// E = T (*) [EOF]
// E = T (*) ["-"]
//
// "Num" -> Shift(S9)
// "(" -> Shift(S8)
// "-" -> Reduce(E = T => Call(ActionFn(3));)
// EOF -> Reduce(E = T => Call(ActionFn(3));)
//
// E -> S7
// T -> S6
pub fn __state2<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::Num(__tok0)) => {
let mut __lookbehind = None;
let mut __sym1 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym1));
}
Some(__tok @ Tok::LParen(..)) => {
let mut __lookbehind = None;
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
return Err(__lookahead);
}
}
while __sym0.is_some() {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::E(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
__Nonterminal::T(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
}
}
}
return Ok(__result);
}
// State 3
// T = "Num" (*) [EOF]
// T = "Num" (*) ["-"]
//
// "-" -> Reduce(T = "Num" => Call(ActionFn(4));)
// EOF -> Reduce(T = "Num" => Call(ActionFn(4));)
//
pub fn __state3<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
@ -204,13 +147,13 @@ mod __parse__S {
match __lookahead {
Some(Tok::Minus(..)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
let __nt = super::__action3(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
let __nt = super::__action3(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
_ => {
return Err(__lookahead);
@ -218,6 +161,69 @@ mod __parse__S {
}
}
// State 3
// E = (*) E "-" T [")"]
// E = (*) E "-" T ["-"]
// E = (*) T [")"]
// E = (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = "(" (*) E ")" [EOF]
// T = "(" (*) E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "(" -> Shift(S7)
// "Num" -> Shift(S9)
//
// T -> S6
// E -> S8
pub fn __state3<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::LParen(..)) => {
let mut __lookbehind = None;
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym1));
}
Some(Tok::Num(__tok0)) => {
let mut __lookbehind = None;
let mut __sym1 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
return Err(__lookahead);
}
}
while __sym0.is_some() {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::T(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym1));
}
__Nonterminal::E(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
}
}
}
return Ok(__result);
}
// State 4
// E = E (*) "-" T [EOF]
// E = E (*) "-" T ["-"]
@ -256,11 +262,11 @@ mod __parse__S {
}
// State 5
// E = T (*) [EOF]
// E = T (*) ["-"]
// T = "Num" (*) [EOF]
// T = "Num" (*) ["-"]
//
// "-" -> Reduce(E = T => Call(ActionFn(3));)
// EOF -> Reduce(E = T => Call(ActionFn(3));)
// "-" -> Reduce(T = "Num" => Call(ActionFn(4));)
// EOF -> Reduce(T = "Num" => Call(ActionFn(4));)
//
pub fn __state5<
__TOKENS: Iterator<Item=Tok>,
@ -275,13 +281,13 @@ mod __parse__S {
match __lookahead {
Some(Tok::Minus(..)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
_ => {
return Err(__lookahead);
@ -324,46 +330,6 @@ mod __parse__S {
}
// State 7
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [EOF]
// T = "(" E (*) ")" ["-"]
//
// "-" -> Shift(S11)
// ")" -> Shift(S12)
//
pub fn __state7<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
__sym1: &mut Option<i32>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::Minus(..)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state11(__lookbehind, __lookahead, __tokens, __sym1, __sym2));
}
Some(__tok @ Tok::RParen(..)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state12(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
}
_ => {
return Err(__lookahead);
}
}
return Ok(__result);
}
// State 8
// E = (*) E "-" T [")"]
// E = (*) E "-" T ["-"]
// E = (*) T [")"]
@ -376,11 +342,11 @@ mod __parse__S {
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S9)
// "(" -> Shift(S8)
// "(" -> Shift(S7)
//
// E -> S13
// T -> S6
pub fn __state8<
// E -> S11
pub fn __state7<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
@ -401,7 +367,7 @@ mod __parse__S {
let mut __lookbehind = None;
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym1));
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
return Err(__lookahead);
@ -410,14 +376,14 @@ mod __parse__S {
while __sym0.is_some() {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::E(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state13(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
__Nonterminal::T(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym1));
}
__Nonterminal::E(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state11(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
}
@ -426,6 +392,46 @@ mod __parse__S {
return Ok(__result);
}
// State 8
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [EOF]
// T = "(" E (*) ")" ["-"]
//
// "-" -> Shift(S12)
// ")" -> Shift(S13)
//
pub fn __state8<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
__sym1: &mut Option<i32>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::Minus(..)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state12(__lookbehind, __lookahead, __tokens, __sym1, __sym2));
}
Some(__tok @ Tok::RParen(..)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state13(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
}
_ => {
return Err(__lookahead);
}
}
return Ok(__result);
}
// State 9
// T = "Num" (*) [")"]
// T = "Num" (*) ["-"]
@ -468,8 +474,8 @@ mod __parse__S {
// T = (*) "Num" [EOF]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S3)
// "(" -> Shift(S2)
// "(" -> Shift(S3)
// "Num" -> Shift(S5)
//
// T -> S14
pub fn __state10<
@ -484,17 +490,17 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::Num(__tok0)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym2));
}
Some(__tok @ Tok::LParen(..)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym2));
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym2));
}
Some(Tok::Num(__tok0)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym2));
}
_ => {
return Err(__lookahead);
@ -516,110 +522,15 @@ mod __parse__S {
}
// State 11
// E = E "-" (*) T [")"]
// E = E "-" (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "(" -> Shift(S8)
// "Num" -> Shift(S9)
//
// T -> S15
pub fn __state11<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
__sym1: &mut Option<Tok>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::LParen(..)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym2));
}
Some(Tok::Num(__tok0)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym2));
}
_ => {
return Err(__lookahead);
}
}
while __sym1.is_some() {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::T(__nt) => {
let __sym2 = &mut Some(__nt);
__result = try!(__state15(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
}
}
}
return Ok(__result);
}
// State 12
// T = "(" E ")" (*) [EOF]
// T = "(" E ")" (*) ["-"]
//
// "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
// EOF -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
//
pub fn __state12<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
__sym1: &mut Option<i32>,
__sym2: &mut Option<Tok>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::Minus(..)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action5(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action5(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 13
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [")"]
// T = "(" E (*) ")" ["-"]
//
// ")" -> Shift(S16)
// "-" -> Shift(S11)
// ")" -> Shift(S15)
// "-" -> Shift(S12)
//
pub fn __state13<
pub fn __state11<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
@ -635,13 +546,13 @@ mod __parse__S {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state16(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
__result = try!(__state15(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
}
Some(__tok @ Tok::Minus(..)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state11(__lookbehind, __lookahead, __tokens, __sym1, __sym2));
__result = try!(__state12(__lookbehind, __lookahead, __tokens, __sym1, __sym2));
}
_ => {
return Err(__lookahead);
@ -650,12 +561,107 @@ mod __parse__S {
return Ok(__result);
}
// State 12
// E = E "-" (*) T [")"]
// E = E "-" (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S9)
// "(" -> Shift(S7)
//
// T -> S16
pub fn __state12<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
__sym1: &mut Option<Tok>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::Num(__tok0)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym2));
}
Some(__tok @ Tok::LParen(..)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym2));
}
_ => {
return Err(__lookahead);
}
}
while __sym1.is_some() {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::T(__nt) => {
let __sym2 = &mut Some(__nt);
__result = try!(__state16(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
}
}
}
return Ok(__result);
}
// State 13
// T = "(" E ")" (*) [EOF]
// T = "(" E ")" (*) ["-"]
//
// EOF -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
// "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
//
pub fn __state13<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
__sym1: &mut Option<i32>,
__sym2: &mut Option<Tok>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action5(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
Some(Tok::Minus(..)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action5(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 14
// E = E "-" T (*) [EOF]
// E = E "-" T (*) ["-"]
//
// "-" -> Reduce(E = E, "-", T => Call(ActionFn(2));)
// EOF -> Reduce(E = E, "-", T => Call(ActionFn(2));)
// "-" -> Reduce(E = E, "-", T => Call(ActionFn(2));)
//
pub fn __state14<
__TOKENS: Iterator<Item=Tok>,
@ -670,14 +676,14 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::Minus(..)) => {
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action2(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
None => {
Some(Tok::Minus(..)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -691,13 +697,53 @@ mod __parse__S {
}
// State 15
// T = "(" E ")" (*) [")"]
// T = "(" E ")" (*) ["-"]
//
// "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
// ")" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
//
pub fn __state15<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
__sym1: &mut Option<i32>,
__sym2: &mut Option<Tok>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::Minus(..)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action5(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
Some(Tok::RParen(..)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action5(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 16
// E = E "-" T (*) [")"]
// E = E "-" T (*) ["-"]
//
// ")" -> Reduce(E = E, "-", T => Call(ActionFn(2));)
// "-" -> Reduce(E = E, "-", T => Call(ActionFn(2));)
//
pub fn __state15<
pub fn __state16<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
@ -729,46 +775,6 @@ mod __parse__S {
}
}
}
// State 16
// T = "(" E ")" (*) [")"]
// T = "(" E ")" (*) ["-"]
//
// ")" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
// "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
//
pub fn __state16<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
__sym1: &mut Option<i32>,
__sym2: &mut Option<Tok>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::RParen(..)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action5(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
Some(Tok::Minus(..)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action5(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
}
pub fn __action0<

19
lalrpop-test/src/util/mod.rs
View File

@ -9,7 +9,7 @@ pub mod tok;
pub fn test<R:Debug+Eq,F>(parse_fn: F,
input: &str,
expected: R)
where F: FnOnce(Vec<Tok>) -> Result<(Option<Tok>,R),Option<Tok>>
where F: FnOnce(Vec<Tok>) -> Result<R,Option<Tok>>
{
// create tokens
let tokens = tok::tokenize(input);
@ -17,11 +17,8 @@ pub fn test<R:Debug+Eq,F>(parse_fn: F,
// filter to tokens
let tokens = tokens.into_iter().map(|(_, tok, _)| tok).collect();
// parse
let (lookahead, r) = parse_fn(tokens).unwrap();
// expect input to be completely consumed
assert!(lookahead.is_none(), "input not completely consumed");
// parse, expecting input to be totally consumed
let r = parse_fn(tokens).unwrap();
// expect output to be correct
assert!(r == expected, "parsing {:?}, got {:#?}, expected {:#?}", input, r, expected);
@ -30,17 +27,13 @@ pub fn test<R:Debug+Eq,F>(parse_fn: F,
pub fn test_loc<R:Debug+Eq,F>(parse_fn: F,
input: &str,
expected: R)
where F: FnOnce(Vec<(usize, Tok, usize)>) -> Result<(Option<(usize, Tok, usize)>,R),
Option<(usize, Tok, usize)>>
where F: FnOnce(Vec<(usize, Tok, usize)>) -> Result<R, Option<(usize, Tok, usize)>>
{
// create tokens
let tokens = tok::tokenize(input);
// parse
let (lookahead, r) = parse_fn(tokens).unwrap();
// expect input to be completely consumed
assert!(lookahead.is_none(), "input not completely consumed");
// parse, expecting input to be totally consumed
let r = parse_fn(tokens).unwrap();
// expect output to be correct
assert!(r == expected, "parsing {:?}, got {:#?}, expected {:#?}", input, r, expected);

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

@ -103,6 +103,9 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
Ok(())
}
// Generates a function `parse_Foo` that will parse an entire
// 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();
rust!(self.out, "#[allow(non_snake_case)]");
@ -111,8 +114,8 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
format!("parse_{}", self.user_start_symbol),
vec![format!("{}TOKENS: IntoIterator<Item={}>", self.prefix, item_type)],
vec![format!("{}tokens: {}TOKENS", self.prefix, self.prefix)],
format!("Result<(Option<{}>, {}), Option<{}>>",
item_type, self.types.nonterminal_type(self.start_symbol), item_type),
format!("Result<{}, Option<{}>>",
self.types.nonterminal_type(self.start_symbol), item_type),
vec![]));
rust!(self.out, "{{");
rust!(self.out, "let mut {}tokens = {}tokens.into_iter();", self.prefix, self.prefix);
@ -120,10 +123,15 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
rust!(self.out, "match try!({}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)) => \
Ok(({}lookahead, {}nt)),",
rust!(self.out, "(_, {}lookahead, {}parse{}::{}Nonterminal::{}({}nt)) => {{",
self.prefix, self.prefix, self.start_symbol, self.prefix, Escape(self.start_symbol),
self.prefix, self.prefix, self.prefix);
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!(),");
rust!(self.out, "}}");
rust!(self.out, "}}");