fluencelabs/lalrpop
1
0
Fork 0
mirror of https://github.com/fluencelabs/lalrpop synced 2025-04-05 09:41:04 +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

2
lalrpop-test/src/expr.lalrpop

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

1782
lalrpop-test/src/expr.rs

File diff suppressed because it is too large Load Diff

732
lalrpop-test/src/sub.rs

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