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

Fix expr.lalropo

Browse Source
This commit is contained in:
Niko Matsakis 2015-07-12 09:04:24 -04:00
parent 4921ddbfc2
commit 1102b26390
3 changed files with 1258 additions and 1258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lalrpop-test/src/expr.lalrpop
View File

@ -26,7 +26,7 @@ grammar {
};
Term = {
<n:"Num">;
<"Num">;
"(" <Expr> ")";
};
}

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

File diff suppressed because it is too large Load Diff

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

@ -19,10 +19,10 @@ mod __parse__S {
use util::tok::Tok;
pub enum __Nonterminal {
S(i32),
T(i32),
E(i32),
__S(i32),
S(i32),
}
// State 0
@ -37,27 +37,27 @@ mod __parse__S {
// T = (*) "Num" ["-"]
// __S = (*) S [EOF]
//
// "(" -> Shift(S3)
// "Num" -> Shift(S5)
// "Num" -> Shift(S3)
// "(" -> Shift(S2)
//
// S -> S2
// E -> S1
// T -> S4
// T -> S1
// S -> S4
// E -> S5
pub fn __state0<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(__tok @ Tok::LParen(..)) => {
let mut sym0 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state3(lookahead, tokens, sym0));
}
Some(Tok::Num(__tok0)) => {
let mut sym0 = &mut Some((__tok0));
let lookahead = tokens.next();
result = try!(__state5(lookahead, tokens, sym0));
result = try!(__state3(lookahead, tokens, sym0));
}
Some(__tok @ Tok::LParen(..)) => {
let mut sym0 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state2(lookahead, tokens, sym0));
}
_ => {
return Err(lookahead);
@ -66,18 +66,18 @@ mod __parse__S {
loop {
let (lookahead, nt) = result;
match nt {
__Nonterminal::S(nt) => {
let sym0 = &mut Some(nt);
result = try!(__state2(lookahead, tokens, sym0));
}
__Nonterminal::E(nt) => {
__Nonterminal::T(nt) => {
let sym0 = &mut Some(nt);
result = try!(__state1(lookahead, tokens, sym0));
}
__Nonterminal::T(nt) => {
__Nonterminal::S(nt) => {
let sym0 = &mut Some(nt);
result = try!(__state4(lookahead, tokens, sym0));
}
__Nonterminal::E(nt) => {
let sym0 = &mut Some(nt);
result = try!(__state5(lookahead, tokens, sym0));
}
_ => {
return Ok((lookahead, nt));
}
@ -86,12 +86,11 @@ mod __parse__S {
}
// State 1
// E = E (*) "-" T [EOF]
// E = E (*) "-" T ["-"]
// S = E (*) [EOF]
// E = T (*) [EOF]
// E = T (*) ["-"]
//
// "-" -> Shift(S6)
// EOF -> Reduce(S = E => ActionFn(1);)
// EOF -> Reduce(E = T => ActionFn(3);)
// "-" -> Reduce(E = T => ActionFn(3);)
//
pub fn __state1<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
@ -100,29 +99,115 @@ mod __parse__S {
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(__tok @ Tok::Minus(..)) => {
let mut sym1 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state6(lookahead, tokens, sym0, sym1));
}
None => {
let sym0 = sym0.take().unwrap();
let nt = super::__action1(sym0);
return Ok((lookahead, __Nonterminal::S(nt)));
let nt = super::__action3(sym0);
return Ok((lookahead, __Nonterminal::E(nt)));
}
Some(Tok::Minus(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action3(sym0);
return Ok((lookahead, __Nonterminal::E(nt)));
}
_ => {
return Err(lookahead);
}
}
return Ok(result);
}
// 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" ["-"]
//
// "(" -> Shift(S7)
// "Num" -> Shift(S8)
//
// E -> S6
// T -> S9
pub fn __state2<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<Tok>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(__tok @ Tok::LParen(..)) => {
let mut sym1 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state7(lookahead, tokens, sym1));
}
Some(Tok::Num(__tok0)) => {
let mut sym1 = &mut Some((__tok0));
let lookahead = tokens.next();
result = try!(__state8(lookahead, tokens, sym1));
}
_ => {
return Err(lookahead);
}
}
while sym0.is_some() {
let (lookahead, nt) = result;
match nt {
__Nonterminal::E(nt) => {
let sym1 = &mut Some(nt);
result = try!(__state6(lookahead, tokens, sym0, sym1));
}
__Nonterminal::T(nt) => {
let sym1 = &mut Some(nt);
result = try!(__state9(lookahead, tokens, sym1));
}
_ => {
return Ok((lookahead, nt));
}
}
}
return Ok(result);
}
// State 3
// T = "Num" (*) [EOF]
// T = "Num" (*) ["-"]
//
// "-" -> Reduce(T = "Num" => ActionFn(4);)
// EOF -> Reduce(T = "Num" => ActionFn(4);)
//
pub fn __state3<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(Tok::Minus(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
}
None => {
let sym0 = sym0.take().unwrap();
let nt = super::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
}
_ => {
return Err(lookahead);
}
}
}
// State 4
// __S = S (*) [EOF]
//
// EOF -> Reduce(__S = S => ActionFn(0);)
//
pub fn __state2<TOKENS: Iterator<Item=Tok>>(
pub fn __state4<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
@ -140,24 +225,90 @@ mod __parse__S {
}
}
// State 3
// State 5
// E = E (*) "-" T [EOF]
// E = E (*) "-" T ["-"]
// S = E (*) [EOF]
//
// EOF -> Reduce(S = E => ActionFn(1);)
// "-" -> Shift(S10)
//
pub fn __state5<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(__tok @ Tok::Minus(..)) => {
let mut sym1 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state10(lookahead, tokens, sym0, sym1));
}
None => {
let sym0 = sym0.take().unwrap();
let nt = super::__action1(sym0);
return Ok((lookahead, __Nonterminal::S(nt)));
}
_ => {
return Err(lookahead);
}
}
return Ok(result);
}
// State 6
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [EOF]
// T = "(" E (*) ")" ["-"]
//
// "-" -> Shift(S11)
// ")" -> Shift(S12)
//
pub fn __state6<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<Tok>,
sym1: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(__tok @ Tok::Minus(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state11(lookahead, tokens, sym1, sym2));
}
Some(__tok @ Tok::RParen(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state12(lookahead, tokens, sym0, sym1, sym2));
}
_ => {
return Err(lookahead);
}
}
return Ok(result);
}
// State 7
// E = (*) E "-" T [")"]
// E = (*) E "-" T ["-"]
// E = (*) T [")"]
// E = (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = "(" (*) E ")" [EOF]
// T = "(" (*) E ")" [")"]
// T = "(" (*) E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S7)
// "(" -> Shift(S10)
// "Num" -> Shift(S8)
// "(" -> Shift(S7)
//
// T -> S8
// E -> S9
pub fn __state3<TOKENS: Iterator<Item=Tok>>(
// E -> S13
// T -> S9
pub fn __state7<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<Tok>,
@ -167,12 +318,12 @@ mod __parse__S {
Some(Tok::Num(__tok0)) => {
let mut sym1 = &mut Some((__tok0));
let lookahead = tokens.next();
result = try!(__state7(lookahead, tokens, sym1));
result = try!(__state8(lookahead, tokens, sym1));
}
Some(__tok @ Tok::LParen(..)) => {
let mut sym1 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state10(lookahead, tokens, sym1));
result = try!(__state7(lookahead, tokens, sym1));
}
_ => {
return Err(lookahead);
@ -181,13 +332,13 @@ mod __parse__S {
while sym0.is_some() {
let (lookahead, nt) = result;
match nt {
__Nonterminal::T(nt) => {
let sym1 = &mut Some(nt);
result = try!(__state8(lookahead, tokens, sym1));
}
__Nonterminal::E(nt) => {
let sym1 = &mut Some(nt);
result = try!(__state9(lookahead, tokens, sym0, sym1));
result = try!(__state13(lookahead, tokens, sym0, sym1));
}
__Nonterminal::T(nt) => {
let sym1 = &mut Some(nt);
result = try!(__state9(lookahead, tokens, sym1));
}
_ => {
return Ok((lookahead, nt));
@ -197,14 +348,44 @@ mod __parse__S {
return Ok(result);
}
// State 4
// E = T (*) [EOF]
// State 8
// T = "Num" (*) [")"]
// T = "Num" (*) ["-"]
//
// ")" -> Reduce(T = "Num" => ActionFn(4);)
// "-" -> Reduce(T = "Num" => ActionFn(4);)
//
pub fn __state8<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(Tok::RParen(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
}
Some(Tok::Minus(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
}
_ => {
return Err(lookahead);
}
}
}
// State 9
// E = T (*) [")"]
// E = T (*) ["-"]
//
// "-" -> Reduce(E = T => ActionFn(3);)
// EOF -> Reduce(E = T => ActionFn(3);)
// ")" -> Reduce(E = T => ActionFn(3);)
//
pub fn __state4<TOKENS: Iterator<Item=Tok>>(
pub fn __state9<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
@ -216,7 +397,7 @@ mod __parse__S {
let nt = super::__action3(sym0);
return Ok((lookahead, __Nonterminal::E(nt)));
}
None => {
Some(Tok::RParen(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action3(sym0);
return Ok((lookahead, __Nonterminal::E(nt)));
@ -227,37 +408,7 @@ mod __parse__S {
}
}
// State 5
// T = "Num" (*) [EOF]
// T = "Num" (*) ["-"]
//
// "-" -> Reduce(T = "Num" => ActionFn(4);)
// EOF -> Reduce(T = "Num" => ActionFn(4);)
//
pub fn __state5<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(Tok::Minus(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
}
None => {
let sym0 = sym0.take().unwrap();
let nt = super::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
}
_ => {
return Err(lookahead);
}
}
}
// State 6
// State 10
// E = E "-" (*) T [EOF]
// E = E "-" (*) T ["-"]
// T = (*) "(" E ")" [EOF]
@ -265,11 +416,11 @@ mod __parse__S {
// T = (*) "Num" [EOF]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S5)
// "(" -> Shift(S3)
// "(" -> Shift(S2)
// "Num" -> Shift(S3)
//
// T -> S11
pub fn __state6<TOKENS: Iterator<Item=Tok>>(
// T -> S14
pub fn __state10<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
@ -277,14 +428,14 @@ mod __parse__S {
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(Tok::Num(__tok0)) => {
let mut sym2 = &mut Some((__tok0));
let lookahead = tokens.next();
result = try!(__state5(lookahead, tokens, sym2));
}
Some(__tok @ Tok::LParen(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state2(lookahead, tokens, sym2));
}
Some(Tok::Num(__tok0)) => {
let mut sym2 = &mut Some((__tok0));
let lookahead = tokens.next();
result = try!(__state3(lookahead, tokens, sym2));
}
_ => {
@ -296,158 +447,7 @@ mod __parse__S {
match nt {
__Nonterminal::T(nt) => {
let sym2 = &mut Some(nt);
result = try!(__state11(lookahead, tokens, sym0, sym1, sym2));
}
_ => {
return Ok((lookahead, nt));
}
}
}
return Ok(result);
}
// State 7
// T = "Num" (*) [")"]
// T = "Num" (*) ["-"]
//
// "-" -> Reduce(T = "Num" => ActionFn(4);)
// ")" -> Reduce(T = "Num" => ActionFn(4);)
//
pub fn __state7<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(Tok::Minus(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
}
Some(Tok::RParen(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
}
_ => {
return Err(lookahead);
}
}
}
// State 8
// E = T (*) [")"]
// E = T (*) ["-"]
//
// "-" -> Reduce(E = T => ActionFn(3);)
// ")" -> Reduce(E = T => ActionFn(3);)
//
pub fn __state8<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(Tok::Minus(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action3(sym0);
return Ok((lookahead, __Nonterminal::E(nt)));
}
Some(Tok::RParen(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action3(sym0);
return Ok((lookahead, __Nonterminal::E(nt)));
}
_ => {
return Err(lookahead);
}
}
}
// State 9
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [EOF]
// T = "(" E (*) ")" ["-"]
//
// "-" -> Shift(S12)
// ")" -> Shift(S13)
//
pub fn __state9<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<Tok>,
sym1: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(__tok @ Tok::Minus(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state12(lookahead, tokens, sym1, sym2));
}
Some(__tok @ Tok::RParen(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state13(lookahead, tokens, sym0, sym1, sym2));
}
_ => {
return Err(lookahead);
}
}
return Ok(result);
}
// State 10
// E = (*) E "-" T [")"]
// E = (*) E "-" T ["-"]
// E = (*) T [")"]
// E = (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = "(" (*) E ")" [")"]
// T = "(" (*) E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "(" -> Shift(S10)
// "Num" -> Shift(S7)
//
// E -> S14
// T -> S8
pub fn __state10<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<Tok>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(__tok @ Tok::LParen(..)) => {
let mut sym1 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state10(lookahead, tokens, sym1));
}
Some(Tok::Num(__tok0)) => {
let mut sym1 = &mut Some((__tok0));
let lookahead = tokens.next();
result = try!(__state7(lookahead, tokens, sym1));
}
_ => {
return Err(lookahead);
}
}
while sym0.is_some() {
let (lookahead, nt) = result;
match nt {
__Nonterminal::E(nt) => {
let sym1 = &mut Some(nt);
result = try!(__state14(lookahead, tokens, sym0, sym1));
}
__Nonterminal::T(nt) => {
let sym1 = &mut Some(nt);
result = try!(__state8(lookahead, tokens, sym1));
result = try!(__state14(lookahead, tokens, sym0, sym1, sym2));
}
_ => {
return Ok((lookahead, nt));
@ -458,13 +458,132 @@ mod __parse__S {
}
// State 11
// E = E "-" (*) T [")"]
// E = E "-" (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "(" -> Shift(S7)
// "Num" -> Shift(S8)
//
// T -> S15
pub fn __state11<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
sym1: &mut Option<Tok>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(__tok @ Tok::LParen(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state7(lookahead, tokens, sym2));
}
Some(Tok::Num(__tok0)) => {
let mut sym2 = &mut Some((__tok0));
let lookahead = tokens.next();
result = try!(__state8(lookahead, tokens, sym2));
}
_ => {
return Err(lookahead);
}
}
while sym1.is_some() {
let (lookahead, nt) = result;
match nt {
__Nonterminal::T(nt) => {
let sym2 = &mut Some(nt);
result = try!(__state15(lookahead, tokens, sym0, sym1, sym2));
}
_ => {
return Ok((lookahead, nt));
}
}
}
return Ok(result);
}
// State 12
// T = "(" E ")" (*) [EOF]
// T = "(" E ")" (*) ["-"]
//
// "-" -> Reduce(T = "(", E, ")" => ActionFn(5);)
// EOF -> Reduce(T = "(", E, ")" => ActionFn(5);)
//
pub fn __state12<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<Tok>,
sym1: &mut Option<i32>,
sym2: &mut Option<Tok>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (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((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((lookahead, __Nonterminal::T(nt)));
}
_ => {
return Err(lookahead);
}
}
}
// State 13
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [")"]
// T = "(" E (*) ")" ["-"]
//
// "-" -> Shift(S11)
// ")" -> Shift(S16)
//
pub fn __state13<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<Tok>,
sym1: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(__tok @ Tok::Minus(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state11(lookahead, tokens, sym1, sym2));
}
Some(__tok @ Tok::RParen(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state16(lookahead, tokens, sym0, sym1, sym2));
}
_ => {
return Err(lookahead);
}
}
return Ok(result);
}
// State 14
// E = E "-" T (*) [EOF]
// E = E "-" T (*) ["-"]
//
// EOF -> Reduce(E = E, "-", T => ActionFn(2);)
// "-" -> Reduce(E = E, "-", T => ActionFn(2);)
//
pub fn __state11<TOKENS: Iterator<Item=Tok>>(
pub fn __state14<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
@ -493,125 +612,6 @@ mod __parse__S {
}
}
// State 12
// E = E "-" (*) T [")"]
// E = E "-" (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S7)
// "(" -> Shift(S10)
//
// T -> S15
pub fn __state12<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
sym1: &mut Option<Tok>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(Tok::Num(__tok0)) => {
let mut sym2 = &mut Some((__tok0));
let lookahead = tokens.next();
result = try!(__state7(lookahead, tokens, sym2));
}
Some(__tok @ Tok::LParen(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state10(lookahead, tokens, sym2));
}
_ => {
return Err(lookahead);
}
}
while sym1.is_some() {
let (lookahead, nt) = result;
match nt {
__Nonterminal::T(nt) => {
let sym2 = &mut Some(nt);
result = try!(__state15(lookahead, tokens, sym0, sym1, sym2));
}
_ => {
return Ok((lookahead, nt));
}
}
}
return Ok(result);
}
// State 13
// T = "(" E ")" (*) [EOF]
// T = "(" E ")" (*) ["-"]
//
// EOF -> Reduce(T = "(", E, ")" => ActionFn(5);)
// "-" -> Reduce(T = "(", E, ")" => ActionFn(5);)
//
pub fn __state13<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<Tok>,
sym1: &mut Option<i32>,
sym2: &mut Option<Tok>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (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((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((lookahead, __Nonterminal::T(nt)));
}
_ => {
return Err(lookahead);
}
}
}
// State 14
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [")"]
// T = "(" E (*) ")" ["-"]
//
// "-" -> Shift(S12)
// ")" -> Shift(S16)
//
pub fn __state14<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<Tok>,
sym1: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(__tok @ Tok::Minus(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state12(lookahead, tokens, sym1, sym2));
}
Some(__tok @ Tok::RParen(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state16(lookahead, tokens, sym0, sym1, sym2));
}
_ => {
return Err(lookahead);
}
}
return Ok(result);
}
// State 15
// E = E "-" T (*) [")"]
// E = E "-" T (*) ["-"]
@ -652,8 +652,8 @@ mod __parse__S {
// T = "(" E ")" (*) [")"]
// T = "(" E ")" (*) ["-"]
//
// "-" -> Reduce(T = "(", E, ")" => ActionFn(5);)
// ")" -> Reduce(T = "(", E, ")" => ActionFn(5);)
// "-" -> Reduce(T = "(", E, ")" => ActionFn(5);)
//
pub fn __state16<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
@ -664,14 +664,14 @@ mod __parse__S {
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(Tok::Minus(..)) => {
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((lookahead, __Nonterminal::T(nt)));
}
Some(Tok::RParen(..)) => {
Some(Tok::Minus(..)) => {
let sym0 = sym0.take().unwrap();
let sym1 = sym1.take().unwrap();
let sym2 = sym2.take().unwrap();