From 8f14f9a3f3d86061827972ccf30c9482742fd2dd Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 14 Jul 2015 12:48:54 -0400 Subject: [PATCH] structure to be more friendly to adding parameters --- lalrpop-test/src/expr.rs | 1813 ++++++++++++++++++---------------- lalrpop-test/src/sub.rs | 625 ++++++------ lalrpop-test/src/util/tok.rs | 9 - lalrpop/src/lr1/ascent.rs | 22 +- 4 files changed, 1277 insertions(+), 1192 deletions(-) diff --git a/lalrpop-test/src/expr.rs b/lalrpop-test/src/expr.rs index b089731..c8da8a1 100644 --- a/lalrpop-test/src/expr.rs +++ b/lalrpop-test/src/expr.rs @@ -1,10 +1,11 @@ use util::tok::Tok; #[allow(non_snake_case)] -pub fn parse_Expr<__TOKENS: IntoIterator>( - __tokens: __TOKENS) - -> Result<(Option, i32), Option> -{ +pub fn parse_Expr< + __TOKENS: IntoIterator, +>( + __tokens: __TOKENS, +) -> Result<(Option, i32), Option> { let mut __tokens = __tokens.into_iter(); let __lookahead = __tokens.next(); match try!(__parse__Expr::__state0(__lookahead, &mut __tokens)) { @@ -19,10 +20,10 @@ mod __parse__Expr { use util::tok::Tok; pub enum __Nonterminal { - Factor(i32), - Term(i32), - __Expr(i32), Expr(i32), + Term(i32), + Factor(i32), + __Expr(i32), } // State 0 @@ -63,12 +64,14 @@ mod __parse__Expr { // __Expr = (*) Expr [EOF] // // "(" -> Shift(S1) - // "Num" -> Shift(S5) + // "Num" -> Shift(S2) // - // Term -> S2 - // Expr -> S4 - // Factor -> S3 - pub fn __state0<__TOKENS: Iterator>( + // Expr -> S3 + // Factor -> S4 + // Term -> S5 + pub fn __state0< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, ) -> Result<(Option, __Nonterminal), Option> { @@ -82,7 +85,7 @@ mod __parse__Expr { Some(Tok::Num(__tok0)) => { let mut __sym0 = &mut Some((__tok0)); let __lookahead = __tokens.next(); - __result = try!(__state5(__lookahead, __tokens, __sym0)); + __result = try!(__state2(__lookahead, __tokens, __sym0)); } _ => { return Err(__lookahead); @@ -91,17 +94,17 @@ mod __parse__Expr { loop { let (__lookahead, __nt) = __result; match __nt { - __Nonterminal::Term(__nt) => { - let __sym0 = &mut Some(__nt); - __result = try!(__state2(__lookahead, __tokens, __sym0)); - } __Nonterminal::Expr(__nt) => { let __sym0 = &mut Some(__nt); - __result = try!(__state4(__lookahead, __tokens, __sym0)); + __result = try!(__state3(__lookahead, __tokens, __sym0)); } __Nonterminal::Factor(__nt) => { let __sym0 = &mut Some(__nt); - __result = try!(__state3(__lookahead, __tokens, __sym0)); + __result = try!(__state4(__lookahead, __tokens, __sym0)); + } + __Nonterminal::Term(__nt) => { + let __sym0 = &mut Some(__nt); + __result = try!(__state5(__lookahead, __tokens, __sym0)); } _ => { return Ok((__lookahead, __nt)); @@ -152,12 +155,14 @@ mod __parse__Expr { // Term = (*) "Num" ["/"] // // "(" -> Shift(S8) - // "Num" -> Shift(S7) + // "Num" -> Shift(S9) // - // Expr -> S9 + // Expr -> S10 + // Factor -> S7 // Term -> S6 - // Factor -> S10 - pub fn __state1<__TOKENS: Iterator>( + pub fn __state1< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -172,7 +177,7 @@ mod __parse__Expr { Some(Tok::Num(__tok0)) => { let mut __sym1 = &mut Some((__tok0)); let __lookahead = __tokens.next(); - __result = try!(__state7(__lookahead, __tokens, __sym1)); + __result = try!(__state9(__lookahead, __tokens, __sym1)); } _ => { return Err(__lookahead); @@ -183,16 +188,16 @@ mod __parse__Expr { match __nt { __Nonterminal::Expr(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state9(__lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state10(__lookahead, __tokens, __sym0, __sym1)); + } + __Nonterminal::Factor(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state7(__lookahead, __tokens, __sym1)); } __Nonterminal::Term(__nt) => { let __sym1 = &mut Some(__nt); __result = try!(__state6(__lookahead, __tokens, __sym1)); } - __Nonterminal::Factor(__nt) => { - let __sym1 = &mut Some(__nt); - __result = try!(__state10(__lookahead, __tokens, __sym1)); - } _ => { return Ok((__lookahead, __nt)); } @@ -202,19 +207,21 @@ mod __parse__Expr { } // State 2 - // Factor = Term (*) [EOF] - // Factor = Term (*) ["*"] - // Factor = Term (*) ["+"] - // Factor = Term (*) ["-"] - // Factor = Term (*) ["/"] + // Term = "Num" (*) [EOF] + // Term = "Num" (*) ["*"] + // Term = "Num" (*) ["+"] + // Term = "Num" (*) ["-"] + // Term = "Num" (*) ["/"] // - // EOF -> Reduce(Factor = Term => ActionFn(6);) - // "/" -> Reduce(Factor = Term => ActionFn(6);) - // "+" -> Reduce(Factor = Term => ActionFn(6);) - // "-" -> Reduce(Factor = Term => ActionFn(6);) - // "*" -> Reduce(Factor = Term => ActionFn(6);) + // EOF -> Reduce(Term = "Num" => ActionFn(7);) + // "/" -> Reduce(Term = "Num" => ActionFn(7);) + // "*" -> Reduce(Term = "Num" => ActionFn(7);) + // "-" -> Reduce(Term = "Num" => ActionFn(7);) + // "+" -> Reduce(Term = "Num" => ActionFn(7);) // - pub fn __state2<__TOKENS: Iterator>( + pub fn __state2< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -223,28 +230,28 @@ mod __parse__Expr { match __lookahead { None => { let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action6(__sym0); - return Ok((__lookahead, __Nonterminal::Factor(__nt))); + let __nt = super::__action7(__sym0); + return Ok((__lookahead, __Nonterminal::Term(__nt))); } Some(Tok::Div(..)) => { let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action6(__sym0); - return Ok((__lookahead, __Nonterminal::Factor(__nt))); - } - Some(Tok::Plus(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action6(__sym0); - return Ok((__lookahead, __Nonterminal::Factor(__nt))); - } - Some(Tok::Minus(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action6(__sym0); - return Ok((__lookahead, __Nonterminal::Factor(__nt))); + let __nt = super::__action7(__sym0); + return Ok((__lookahead, __Nonterminal::Term(__nt))); } Some(Tok::Times(..)) => { let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action6(__sym0); - return Ok((__lookahead, __Nonterminal::Factor(__nt))); + let __nt = super::__action7(__sym0); + return Ok((__lookahead, __Nonterminal::Term(__nt))); + } + Some(Tok::Minus(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(__sym0); + return Ok((__lookahead, __Nonterminal::Term(__nt))); + } + Some(Tok::Plus(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(__sym0); + return Ok((__lookahead, __Nonterminal::Term(__nt))); } _ => { return Err(__lookahead); @@ -253,6 +260,50 @@ mod __parse__Expr { } // State 3 + // Expr = Expr (*) "+" Factor [EOF] + // Expr = Expr (*) "+" Factor ["+"] + // Expr = Expr (*) "+" Factor ["-"] + // Expr = Expr (*) "-" Factor [EOF] + // Expr = Expr (*) "-" Factor ["+"] + // Expr = Expr (*) "-" Factor ["-"] + // __Expr = Expr (*) [EOF] + // + // "+" -> Shift(S11) + // EOF -> Reduce(__Expr = Expr => ActionFn(0);) + // "-" -> Shift(S12) + // + pub fn __state3< + __TOKENS: Iterator, + >( + mut __lookahead: Option, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __Nonterminal); + match __lookahead { + Some(__tok @ Tok::Plus(..)) => { + let mut __sym1 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state11(__lookahead, __tokens, __sym0, __sym1)); + } + Some(__tok @ Tok::Minus(..)) => { + let mut __sym1 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state12(__lookahead, __tokens, __sym0, __sym1)); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action0(__sym0); + return Ok((__lookahead, __Nonterminal::__Expr(__nt))); + } + _ => { + return Err(__lookahead); + } + } + return Ok(__result); + } + + // State 4 // Expr = Factor (*) [EOF] // Expr = Factor (*) ["+"] // Expr = Factor (*) ["-"] @@ -267,13 +318,15 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["-"] // Factor = Factor (*) "/" Term ["/"] // - // "/" -> Shift(S12) - // "+" -> Reduce(Expr = Factor => ActionFn(3);) - // "-" -> Reduce(Expr = Factor => ActionFn(3);) // EOF -> Reduce(Expr = Factor => ActionFn(3);) - // "*" -> Shift(S11) + // "+" -> Reduce(Expr = Factor => ActionFn(3);) + // "/" -> Shift(S14) + // "*" -> Shift(S13) + // "-" -> Reduce(Expr = Factor => ActionFn(3);) // - pub fn __state3<__TOKENS: Iterator>( + pub fn __state4< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -283,12 +336,17 @@ mod __parse__Expr { Some(__tok @ Tok::Div(..)) => { let mut __sym1 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state12(__lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state14(__lookahead, __tokens, __sym0, __sym1)); } Some(__tok @ Tok::Times(..)) => { let mut __sym1 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state11(__lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state13(__lookahead, __tokens, __sym0, __sym1)); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(__sym0); + return Ok((__lookahead, __Nonterminal::Expr(__nt))); } Some(Tok::Plus(..)) => { let __sym0 = __sym0.take().unwrap(); @@ -300,53 +358,6 @@ mod __parse__Expr { let __nt = super::__action3(__sym0); return Ok((__lookahead, __Nonterminal::Expr(__nt))); } - None => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(__sym0); - return Ok((__lookahead, __Nonterminal::Expr(__nt))); - } - _ => { - return Err(__lookahead); - } - } - return Ok(__result); - } - - // State 4 - // Expr = Expr (*) "+" Factor [EOF] - // Expr = Expr (*) "+" Factor ["+"] - // Expr = Expr (*) "+" Factor ["-"] - // Expr = Expr (*) "-" Factor [EOF] - // Expr = Expr (*) "-" Factor ["+"] - // Expr = Expr (*) "-" Factor ["-"] - // __Expr = Expr (*) [EOF] - // - // "-" -> Shift(S14) - // EOF -> Reduce(__Expr = Expr => ActionFn(0);) - // "+" -> Shift(S13) - // - pub fn __state4<__TOKENS: Iterator>( - mut __lookahead: Option, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut __result: (Option, __Nonterminal); - match __lookahead { - Some(__tok @ Tok::Minus(..)) => { - let mut __sym1 = &mut Some(__tok); - let __lookahead = __tokens.next(); - __result = try!(__state14(__lookahead, __tokens, __sym0, __sym1)); - } - Some(__tok @ Tok::Plus(..)) => { - let mut __sym1 = &mut Some(__tok); - let __lookahead = __tokens.next(); - __result = try!(__state13(__lookahead, __tokens, __sym0, __sym1)); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action0(__sym0); - return Ok((__lookahead, __Nonterminal::__Expr(__nt))); - } _ => { return Err(__lookahead); } @@ -355,19 +366,21 @@ mod __parse__Expr { } // State 5 - // Term = "Num" (*) [EOF] - // Term = "Num" (*) ["*"] - // Term = "Num" (*) ["+"] - // Term = "Num" (*) ["-"] - // Term = "Num" (*) ["/"] + // Factor = Term (*) [EOF] + // Factor = Term (*) ["*"] + // Factor = Term (*) ["+"] + // Factor = Term (*) ["-"] + // Factor = Term (*) ["/"] // - // EOF -> Reduce(Term = "Num" => ActionFn(7);) - // "*" -> Reduce(Term = "Num" => ActionFn(7);) - // "+" -> Reduce(Term = "Num" => ActionFn(7);) - // "-" -> Reduce(Term = "Num" => ActionFn(7);) - // "/" -> Reduce(Term = "Num" => ActionFn(7);) + // EOF -> Reduce(Factor = Term => ActionFn(6);) + // "+" -> Reduce(Factor = Term => ActionFn(6);) + // "*" -> Reduce(Factor = Term => ActionFn(6);) + // "/" -> Reduce(Factor = Term => ActionFn(6);) + // "-" -> Reduce(Factor = Term => ActionFn(6);) // - pub fn __state5<__TOKENS: Iterator>( + pub fn __state5< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -376,28 +389,28 @@ mod __parse__Expr { match __lookahead { None => { let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(__sym0); - return Ok((__lookahead, __Nonterminal::Term(__nt))); - } - Some(Tok::Times(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(__sym0); - return Ok((__lookahead, __Nonterminal::Term(__nt))); + let __nt = super::__action6(__sym0); + return Ok((__lookahead, __Nonterminal::Factor(__nt))); } Some(Tok::Plus(..)) => { let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(__sym0); - return Ok((__lookahead, __Nonterminal::Term(__nt))); + let __nt = super::__action6(__sym0); + return Ok((__lookahead, __Nonterminal::Factor(__nt))); } - Some(Tok::Minus(..)) => { + Some(Tok::Times(..)) => { let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(__sym0); - return Ok((__lookahead, __Nonterminal::Term(__nt))); + let __nt = super::__action6(__sym0); + return Ok((__lookahead, __Nonterminal::Factor(__nt))); } Some(Tok::Div(..)) => { let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(__sym0); - return Ok((__lookahead, __Nonterminal::Term(__nt))); + let __nt = super::__action6(__sym0); + return Ok((__lookahead, __Nonterminal::Factor(__nt))); + } + Some(Tok::Minus(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action6(__sym0); + return Ok((__lookahead, __Nonterminal::Factor(__nt))); } _ => { return Err(__lookahead); @@ -412,40 +425,42 @@ mod __parse__Expr { // Factor = Term (*) ["-"] // Factor = Term (*) ["/"] // - // "*" -> Reduce(Factor = Term => ActionFn(6);) - // "/" -> Reduce(Factor = Term => ActionFn(6);) // ")" -> Reduce(Factor = Term => ActionFn(6);) - // "-" -> Reduce(Factor = Term => ActionFn(6);) // "+" -> Reduce(Factor = Term => ActionFn(6);) + // "*" -> Reduce(Factor = Term => ActionFn(6);) + // "-" -> Reduce(Factor = Term => ActionFn(6);) + // "/" -> Reduce(Factor = Term => ActionFn(6);) // - pub fn __state6<__TOKENS: Iterator>( + pub fn __state6< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __Nonterminal); match __lookahead { - Some(Tok::Times(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action6(__sym0); - return Ok((__lookahead, __Nonterminal::Factor(__nt))); - } - Some(Tok::Div(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action6(__sym0); - return Ok((__lookahead, __Nonterminal::Factor(__nt))); - } Some(Tok::RParen(..)) => { let __sym0 = __sym0.take().unwrap(); let __nt = super::__action6(__sym0); return Ok((__lookahead, __Nonterminal::Factor(__nt))); } + Some(Tok::Plus(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action6(__sym0); + return Ok((__lookahead, __Nonterminal::Factor(__nt))); + } + Some(Tok::Times(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action6(__sym0); + return Ok((__lookahead, __Nonterminal::Factor(__nt))); + } Some(Tok::Minus(..)) => { let __sym0 = __sym0.take().unwrap(); let __nt = super::__action6(__sym0); return Ok((__lookahead, __Nonterminal::Factor(__nt))); } - Some(Tok::Plus(..)) => { + Some(Tok::Div(..)) => { let __sym0 = __sym0.take().unwrap(); let __nt = super::__action6(__sym0); return Ok((__lookahead, __Nonterminal::Factor(__nt))); @@ -457,54 +472,65 @@ mod __parse__Expr { } // State 7 - // Term = "Num" (*) [")"] - // Term = "Num" (*) ["*"] - // Term = "Num" (*) ["+"] - // Term = "Num" (*) ["-"] - // Term = "Num" (*) ["/"] + // Expr = Factor (*) [")"] + // Expr = Factor (*) ["+"] + // Expr = Factor (*) ["-"] + // Factor = Factor (*) "*" Term [")"] + // Factor = Factor (*) "*" Term ["*"] + // Factor = Factor (*) "*" Term ["+"] + // Factor = Factor (*) "*" Term ["-"] + // Factor = Factor (*) "*" Term ["/"] + // Factor = Factor (*) "/" Term [")"] + // Factor = Factor (*) "/" Term ["*"] + // Factor = Factor (*) "/" Term ["+"] + // Factor = Factor (*) "/" Term ["-"] + // Factor = Factor (*) "/" Term ["/"] // - // ")" -> Reduce(Term = "Num" => ActionFn(7);) - // "-" -> Reduce(Term = "Num" => ActionFn(7);) - // "/" -> Reduce(Term = "Num" => ActionFn(7);) - // "*" -> Reduce(Term = "Num" => ActionFn(7);) - // "+" -> Reduce(Term = "Num" => ActionFn(7);) + // ")" -> Reduce(Expr = Factor => ActionFn(3);) + // "-" -> Reduce(Expr = Factor => ActionFn(3);) + // "+" -> Reduce(Expr = Factor => ActionFn(3);) + // "/" -> Shift(S16) + // "*" -> Shift(S15) // - pub fn __state7<__TOKENS: Iterator>( + pub fn __state7< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __Nonterminal); match __lookahead { + Some(__tok @ Tok::Div(..)) => { + let mut __sym1 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state16(__lookahead, __tokens, __sym0, __sym1)); + } + Some(__tok @ Tok::Times(..)) => { + let mut __sym1 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state15(__lookahead, __tokens, __sym0, __sym1)); + } Some(Tok::RParen(..)) => { let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(__sym0); - return Ok((__lookahead, __Nonterminal::Term(__nt))); + let __nt = super::__action3(__sym0); + return Ok((__lookahead, __Nonterminal::Expr(__nt))); } Some(Tok::Minus(..)) => { let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(__sym0); - return Ok((__lookahead, __Nonterminal::Term(__nt))); - } - Some(Tok::Div(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(__sym0); - return Ok((__lookahead, __Nonterminal::Term(__nt))); - } - Some(Tok::Times(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(__sym0); - return Ok((__lookahead, __Nonterminal::Term(__nt))); + let __nt = super::__action3(__sym0); + return Ok((__lookahead, __Nonterminal::Expr(__nt))); } Some(Tok::Plus(..)) => { let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(__sym0); - return Ok((__lookahead, __Nonterminal::Term(__nt))); + let __nt = super::__action3(__sym0); + return Ok((__lookahead, __Nonterminal::Expr(__nt))); } _ => { return Err(__lookahead); } } + return Ok(__result); } // State 8 @@ -548,29 +574,31 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // + // "Num" -> Shift(S9) // "(" -> Shift(S8) - // "Num" -> Shift(S7) // + // Expr -> S17 + // Factor -> S7 // Term -> S6 - // Factor -> S10 - // Expr -> S15 - pub fn __state8<__TOKENS: Iterator>( + pub fn __state8< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __Nonterminal); match __lookahead { + Some(Tok::Num(__tok0)) => { + let mut __sym1 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state9(__lookahead, __tokens, __sym1)); + } Some(__tok @ Tok::LParen(..)) => { let mut __sym1 = &mut Some(__tok); let __lookahead = __tokens.next(); __result = try!(__state8(__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); } @@ -578,17 +606,17 @@ mod __parse__Expr { while __sym0.is_some() { let (__lookahead, __nt) = __result; match __nt { - __Nonterminal::Term(__nt) => { + __Nonterminal::Expr(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state6(__lookahead, __tokens, __sym1)); + __result = try!(__state17(__lookahead, __tokens, __sym0, __sym1)); } __Nonterminal::Factor(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state10(__lookahead, __tokens, __sym1)); + __result = try!(__state7(__lookahead, __tokens, __sym1)); } - __Nonterminal::Expr(__nt) => { + __Nonterminal::Term(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state15(__lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state6(__lookahead, __tokens, __sym1)); } _ => { return Ok((__lookahead, __nt)); @@ -599,6 +627,59 @@ mod __parse__Expr { } // State 9 + // Term = "Num" (*) [")"] + // Term = "Num" (*) ["*"] + // Term = "Num" (*) ["+"] + // Term = "Num" (*) ["-"] + // Term = "Num" (*) ["/"] + // + // "*" -> Reduce(Term = "Num" => ActionFn(7);) + // "+" -> Reduce(Term = "Num" => ActionFn(7);) + // "/" -> Reduce(Term = "Num" => ActionFn(7);) + // ")" -> Reduce(Term = "Num" => ActionFn(7);) + // "-" -> Reduce(Term = "Num" => ActionFn(7);) + // + pub fn __state9< + __TOKENS: Iterator, + >( + mut __lookahead: Option, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __Nonterminal); + match __lookahead { + Some(Tok::Times(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(__sym0); + return Ok((__lookahead, __Nonterminal::Term(__nt))); + } + Some(Tok::Plus(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(__sym0); + return Ok((__lookahead, __Nonterminal::Term(__nt))); + } + Some(Tok::Div(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(__sym0); + return Ok((__lookahead, __Nonterminal::Term(__nt))); + } + Some(Tok::RParen(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(__sym0); + return Ok((__lookahead, __Nonterminal::Term(__nt))); + } + Some(Tok::Minus(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(__sym0); + return Ok((__lookahead, __Nonterminal::Term(__nt))); + } + _ => { + return Err(__lookahead); + } + } + } + + // State 10 // Expr = Expr (*) "+" Factor [")"] // Expr = Expr (*) "+" Factor ["+"] // Expr = Expr (*) "+" Factor ["-"] @@ -611,11 +692,13 @@ mod __parse__Expr { // Term = "(" Expr (*) ")" ["-"] // Term = "(" Expr (*) ")" ["/"] // - // ")" -> Shift(S17) - // "-" -> Shift(S16) - // "+" -> Shift(S18) + // "-" -> Shift(S18) + // ")" -> Shift(S19) + // "+" -> Shift(S20) // - pub fn __state9<__TOKENS: Iterator>( + pub fn __state10< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -623,80 +706,20 @@ mod __parse__Expr { ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __Nonterminal); match __lookahead { - Some(__tok @ Tok::RParen(..)) => { - let mut __sym2 = &mut Some(__tok); - let __lookahead = __tokens.next(); - __result = try!(__state17(__lookahead, __tokens, __sym0, __sym1, __sym2)); - } Some(__tok @ Tok::Minus(..)) => { - let mut __sym2 = &mut Some(__tok); - let __lookahead = __tokens.next(); - __result = try!(__state16(__lookahead, __tokens, __sym1, __sym2)); - } - Some(__tok @ Tok::Plus(..)) => { let mut __sym2 = &mut Some(__tok); let __lookahead = __tokens.next(); __result = try!(__state18(__lookahead, __tokens, __sym1, __sym2)); } - _ => { - return Err(__lookahead); - } - } - return Ok(__result); - } - - // State 10 - // Expr = Factor (*) [")"] - // Expr = Factor (*) ["+"] - // Expr = Factor (*) ["-"] - // Factor = Factor (*) "*" Term [")"] - // Factor = Factor (*) "*" Term ["*"] - // Factor = Factor (*) "*" Term ["+"] - // Factor = Factor (*) "*" Term ["-"] - // Factor = Factor (*) "*" Term ["/"] - // Factor = Factor (*) "/" Term [")"] - // Factor = Factor (*) "/" Term ["*"] - // Factor = Factor (*) "/" Term ["+"] - // Factor = Factor (*) "/" Term ["-"] - // Factor = Factor (*) "/" Term ["/"] - // - // ")" -> Reduce(Expr = Factor => ActionFn(3);) - // "+" -> Reduce(Expr = Factor => ActionFn(3);) - // "*" -> Shift(S19) - // "-" -> Reduce(Expr = Factor => ActionFn(3);) - // "/" -> Shift(S20) - // - pub fn __state10<__TOKENS: Iterator>( - mut __lookahead: Option, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut __result: (Option, __Nonterminal); - match __lookahead { - Some(__tok @ Tok::Times(..)) => { - let mut __sym1 = &mut Some(__tok); + Some(__tok @ Tok::RParen(..)) => { + let mut __sym2 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state19(__lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state19(__lookahead, __tokens, __sym0, __sym1, __sym2)); } - Some(__tok @ Tok::Div(..)) => { - let mut __sym1 = &mut Some(__tok); + Some(__tok @ Tok::Plus(..)) => { + let mut __sym2 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state20(__lookahead, __tokens, __sym0, __sym1)); - } - Some(Tok::RParen(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(__sym0); - return Ok((__lookahead, __Nonterminal::Expr(__nt))); - } - Some(Tok::Plus(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(__sym0); - return Ok((__lookahead, __Nonterminal::Expr(__nt))); - } - Some(Tok::Minus(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(__sym0); - return Ok((__lookahead, __Nonterminal::Expr(__nt))); + __result = try!(__state20(__lookahead, __tokens, __sym1, __sym2)); } _ => { return Err(__lookahead); @@ -706,122 +729,6 @@ mod __parse__Expr { } // State 11 - // Factor = Factor "*" (*) Term [EOF] - // Factor = Factor "*" (*) Term ["*"] - // Factor = Factor "*" (*) Term ["+"] - // Factor = Factor "*" (*) Term ["-"] - // Factor = Factor "*" (*) Term ["/"] - // Term = (*) "(" Expr ")" [EOF] - // Term = (*) "(" Expr ")" ["*"] - // Term = (*) "(" Expr ")" ["+"] - // Term = (*) "(" Expr ")" ["-"] - // Term = (*) "(" Expr ")" ["/"] - // Term = (*) "Num" [EOF] - // Term = (*) "Num" ["*"] - // Term = (*) "Num" ["+"] - // Term = (*) "Num" ["-"] - // Term = (*) "Num" ["/"] - // - // "(" -> Shift(S1) - // "Num" -> Shift(S5) - // - // Term -> S21 - pub fn __state11<__TOKENS: Iterator>( - mut __lookahead: Option, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut __result: (Option, __Nonterminal); - match __lookahead { - Some(__tok @ Tok::LParen(..)) => { - let mut __sym2 = &mut Some(__tok); - let __lookahead = __tokens.next(); - __result = try!(__state1(__lookahead, __tokens, __sym2)); - } - Some(Tok::Num(__tok0)) => { - let mut __sym2 = &mut Some((__tok0)); - let __lookahead = __tokens.next(); - __result = try!(__state5(__lookahead, __tokens, __sym2)); - } - _ => { - return Err(__lookahead); - } - } - while __sym1.is_some() { - let (__lookahead, __nt) = __result; - match __nt { - __Nonterminal::Term(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state21(__lookahead, __tokens, __sym0, __sym1, __sym2)); - } - _ => { - return Ok((__lookahead, __nt)); - } - } - } - return Ok(__result); - } - - // State 12 - // Factor = Factor "/" (*) Term [EOF] - // Factor = Factor "/" (*) Term ["*"] - // Factor = Factor "/" (*) Term ["+"] - // Factor = Factor "/" (*) Term ["-"] - // Factor = Factor "/" (*) Term ["/"] - // Term = (*) "(" Expr ")" [EOF] - // Term = (*) "(" Expr ")" ["*"] - // Term = (*) "(" Expr ")" ["+"] - // Term = (*) "(" Expr ")" ["-"] - // Term = (*) "(" Expr ")" ["/"] - // Term = (*) "Num" [EOF] - // Term = (*) "Num" ["*"] - // Term = (*) "Num" ["+"] - // Term = (*) "Num" ["-"] - // Term = (*) "Num" ["/"] - // - // "(" -> Shift(S1) - // "Num" -> Shift(S5) - // - // Term -> S22 - pub fn __state12<__TOKENS: Iterator>( - mut __lookahead: Option, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut __result: (Option, __Nonterminal); - match __lookahead { - Some(__tok @ Tok::LParen(..)) => { - let mut __sym2 = &mut Some(__tok); - let __lookahead = __tokens.next(); - __result = try!(__state1(__lookahead, __tokens, __sym2)); - } - Some(Tok::Num(__tok0)) => { - let mut __sym2 = &mut Some((__tok0)); - let __lookahead = __tokens.next(); - __result = try!(__state5(__lookahead, __tokens, __sym2)); - } - _ => { - return Err(__lookahead); - } - } - while __sym1.is_some() { - let (__lookahead, __nt) = __result; - match __nt { - __Nonterminal::Term(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state22(__lookahead, __tokens, __sym0, __sym1, __sym2)); - } - _ => { - return Ok((__lookahead, __nt)); - } - } - } - return Ok(__result); - } - - // State 13 // Expr = Expr "+" (*) Factor [EOF] // Expr = Expr "+" (*) Factor ["+"] // Expr = Expr "+" (*) Factor ["-"] @@ -852,11 +759,13 @@ mod __parse__Expr { // Term = (*) "Num" ["/"] // // "(" -> Shift(S1) - // "Num" -> Shift(S5) + // "Num" -> Shift(S2) // - // Factor -> S23 - // Term -> S2 - pub fn __state13<__TOKENS: Iterator>( + // Term -> S5 + // Factor -> S21 + pub fn __state11< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -872,7 +781,7 @@ mod __parse__Expr { Some(Tok::Num(__tok0)) => { let mut __sym2 = &mut Some((__tok0)); let __lookahead = __tokens.next(); - __result = try!(__state5(__lookahead, __tokens, __sym2)); + __result = try!(__state2(__lookahead, __tokens, __sym2)); } _ => { return Err(__lookahead); @@ -881,13 +790,13 @@ mod __parse__Expr { while __sym1.is_some() { let (__lookahead, __nt) = __result; match __nt { - __Nonterminal::Factor(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state23(__lookahead, __tokens, __sym0, __sym1, __sym2)); - } __Nonterminal::Term(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state2(__lookahead, __tokens, __sym2)); + __result = try!(__state5(__lookahead, __tokens, __sym2)); + } + __Nonterminal::Factor(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state21(__lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { return Ok((__lookahead, __nt)); @@ -897,7 +806,7 @@ mod __parse__Expr { return Ok(__result); } - // State 14 + // State 12 // Expr = Expr "-" (*) Factor [EOF] // Expr = Expr "-" (*) Factor ["+"] // Expr = Expr "-" (*) Factor ["-"] @@ -927,12 +836,14 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "Num" -> Shift(S5) + // "Num" -> Shift(S2) // "(" -> Shift(S1) // - // Factor -> S24 - // Term -> S2 - pub fn __state14<__TOKENS: Iterator>( + // Term -> S5 + // Factor -> S22 + pub fn __state12< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -943,7 +854,7 @@ mod __parse__Expr { Some(Tok::Num(__tok0)) => { let mut __sym2 = &mut Some((__tok0)); let __lookahead = __tokens.next(); - __result = try!(__state5(__lookahead, __tokens, __sym2)); + __result = try!(__state2(__lookahead, __tokens, __sym2)); } Some(__tok @ Tok::LParen(..)) => { let mut __sym2 = &mut Some(__tok); @@ -957,13 +868,133 @@ mod __parse__Expr { while __sym1.is_some() { let (__lookahead, __nt) = __result; match __nt { - __Nonterminal::Factor(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state24(__lookahead, __tokens, __sym0, __sym1, __sym2)); - } __Nonterminal::Term(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state2(__lookahead, __tokens, __sym2)); + __result = try!(__state5(__lookahead, __tokens, __sym2)); + } + __Nonterminal::Factor(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state22(__lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookahead, __nt)); + } + } + } + return Ok(__result); + } + + // State 13 + // Factor = Factor "*" (*) Term [EOF] + // Factor = Factor "*" (*) Term ["*"] + // Factor = Factor "*" (*) Term ["+"] + // Factor = Factor "*" (*) Term ["-"] + // Factor = Factor "*" (*) Term ["/"] + // Term = (*) "(" Expr ")" [EOF] + // Term = (*) "(" Expr ")" ["*"] + // Term = (*) "(" Expr ")" ["+"] + // Term = (*) "(" Expr ")" ["-"] + // Term = (*) "(" Expr ")" ["/"] + // Term = (*) "Num" [EOF] + // Term = (*) "Num" ["*"] + // Term = (*) "Num" ["+"] + // Term = (*) "Num" ["-"] + // Term = (*) "Num" ["/"] + // + // "Num" -> Shift(S2) + // "(" -> Shift(S1) + // + // Term -> S23 + pub fn __state13< + __TOKENS: Iterator, + >( + mut __lookahead: Option, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __Nonterminal); + match __lookahead { + Some(Tok::Num(__tok0)) => { + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state2(__lookahead, __tokens, __sym2)); + } + Some(__tok @ Tok::LParen(..)) => { + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state1(__lookahead, __tokens, __sym2)); + } + _ => { + return Err(__lookahead); + } + } + while __sym1.is_some() { + let (__lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state23(__lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookahead, __nt)); + } + } + } + return Ok(__result); + } + + // State 14 + // Factor = Factor "/" (*) Term [EOF] + // Factor = Factor "/" (*) Term ["*"] + // Factor = Factor "/" (*) Term ["+"] + // Factor = Factor "/" (*) Term ["-"] + // Factor = Factor "/" (*) Term ["/"] + // Term = (*) "(" Expr ")" [EOF] + // Term = (*) "(" Expr ")" ["*"] + // Term = (*) "(" Expr ")" ["+"] + // Term = (*) "(" Expr ")" ["-"] + // Term = (*) "(" Expr ")" ["/"] + // Term = (*) "Num" [EOF] + // Term = (*) "Num" ["*"] + // Term = (*) "Num" ["+"] + // Term = (*) "Num" ["-"] + // Term = (*) "Num" ["/"] + // + // "Num" -> Shift(S2) + // "(" -> Shift(S1) + // + // Term -> S24 + pub fn __state14< + __TOKENS: Iterator, + >( + mut __lookahead: Option, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __Nonterminal); + match __lookahead { + Some(Tok::Num(__tok0)) => { + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state2(__lookahead, __tokens, __sym2)); + } + Some(__tok @ Tok::LParen(..)) => { + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state1(__lookahead, __tokens, __sym2)); + } + _ => { + return Err(__lookahead); + } + } + while __sym1.is_some() { + let (__lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state24(__lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { return Ok((__lookahead, __nt)); @@ -974,6 +1005,126 @@ mod __parse__Expr { } // State 15 + // Factor = Factor "*" (*) Term [")"] + // Factor = Factor "*" (*) Term ["*"] + // Factor = Factor "*" (*) Term ["+"] + // Factor = Factor "*" (*) Term ["-"] + // Factor = Factor "*" (*) Term ["/"] + // Term = (*) "(" Expr ")" [")"] + // Term = (*) "(" Expr ")" ["*"] + // Term = (*) "(" Expr ")" ["+"] + // Term = (*) "(" Expr ")" ["-"] + // Term = (*) "(" Expr ")" ["/"] + // Term = (*) "Num" [")"] + // Term = (*) "Num" ["*"] + // Term = (*) "Num" ["+"] + // Term = (*) "Num" ["-"] + // Term = (*) "Num" ["/"] + // + // "(" -> Shift(S8) + // "Num" -> Shift(S9) + // + // Term -> S25 + pub fn __state15< + __TOKENS: Iterator, + >( + mut __lookahead: Option, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __Nonterminal); + match __lookahead { + Some(__tok @ Tok::LParen(..)) => { + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state8(__lookahead, __tokens, __sym2)); + } + Some(Tok::Num(__tok0)) => { + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state9(__lookahead, __tokens, __sym2)); + } + _ => { + return Err(__lookahead); + } + } + while __sym1.is_some() { + let (__lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state25(__lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookahead, __nt)); + } + } + } + return Ok(__result); + } + + // State 16 + // Factor = Factor "/" (*) Term [")"] + // Factor = Factor "/" (*) Term ["*"] + // Factor = Factor "/" (*) Term ["+"] + // Factor = Factor "/" (*) Term ["-"] + // Factor = Factor "/" (*) Term ["/"] + // Term = (*) "(" Expr ")" [")"] + // Term = (*) "(" Expr ")" ["*"] + // Term = (*) "(" Expr ")" ["+"] + // Term = (*) "(" Expr ")" ["-"] + // Term = (*) "(" Expr ")" ["/"] + // Term = (*) "Num" [")"] + // Term = (*) "Num" ["*"] + // Term = (*) "Num" ["+"] + // Term = (*) "Num" ["-"] + // Term = (*) "Num" ["/"] + // + // "Num" -> Shift(S9) + // "(" -> Shift(S8) + // + // Term -> S26 + pub fn __state16< + __TOKENS: Iterator, + >( + mut __lookahead: Option, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __Nonterminal); + match __lookahead { + Some(Tok::Num(__tok0)) => { + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state9(__lookahead, __tokens, __sym2)); + } + Some(__tok @ Tok::LParen(..)) => { + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state8(__lookahead, __tokens, __sym2)); + } + _ => { + return Err(__lookahead); + } + } + while __sym1.is_some() { + let (__lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state26(__lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookahead, __nt)); + } + } + } + return Ok(__result); + } + + // State 17 // Expr = Expr (*) "+" Factor [")"] // Expr = Expr (*) "+" Factor ["+"] // Expr = Expr (*) "+" Factor ["-"] @@ -986,11 +1137,13 @@ mod __parse__Expr { // Term = "(" Expr (*) ")" ["-"] // Term = "(" Expr (*) ")" ["/"] // - // "-" -> Shift(S16) - // ")" -> Shift(S25) - // "+" -> Shift(S18) + // ")" -> Shift(S27) + // "-" -> Shift(S18) + // "+" -> Shift(S20) // - pub fn __state15<__TOKENS: Iterator>( + pub fn __state17< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -998,20 +1151,20 @@ mod __parse__Expr { ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __Nonterminal); match __lookahead { - Some(__tok @ Tok::Minus(..)) => { - let mut __sym2 = &mut Some(__tok); - let __lookahead = __tokens.next(); - __result = try!(__state16(__lookahead, __tokens, __sym1, __sym2)); - } Some(__tok @ Tok::RParen(..)) => { let mut __sym2 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state25(__lookahead, __tokens, __sym0, __sym1, __sym2)); + __result = try!(__state27(__lookahead, __tokens, __sym0, __sym1, __sym2)); + } + Some(__tok @ Tok::Minus(..)) => { + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state18(__lookahead, __tokens, __sym1, __sym2)); } Some(__tok @ Tok::Plus(..)) => { let mut __sym2 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state18(__lookahead, __tokens, __sym1, __sym2)); + __result = try!(__state20(__lookahead, __tokens, __sym1, __sym2)); } _ => { return Err(__lookahead); @@ -1020,7 +1173,7 @@ mod __parse__Expr { return Ok(__result); } - // State 16 + // State 18 // Expr = Expr "-" (*) Factor [")"] // Expr = Expr "-" (*) Factor ["+"] // Expr = Expr "-" (*) Factor ["-"] @@ -1050,12 +1203,14 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // + // "Num" -> Shift(S9) // "(" -> Shift(S8) - // "Num" -> Shift(S7) // // Term -> S6 - // Factor -> S26 - pub fn __state16<__TOKENS: Iterator>( + // Factor -> S28 + pub fn __state18< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -1063,16 +1218,16 @@ mod __parse__Expr { ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __Nonterminal); match __lookahead { + Some(Tok::Num(__tok0)) => { + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state9(__lookahead, __tokens, __sym2)); + } Some(__tok @ Tok::LParen(..)) => { let mut __sym2 = &mut Some(__tok); let __lookahead = __tokens.next(); __result = try!(__state8(__lookahead, __tokens, __sym2)); } - Some(Tok::Num(__tok0)) => { - let mut __sym2 = &mut Some((__tok0)); - let __lookahead = __tokens.next(); - __result = try!(__state7(__lookahead, __tokens, __sym2)); - } _ => { return Err(__lookahead); } @@ -1086,7 +1241,7 @@ mod __parse__Expr { } __Nonterminal::Factor(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state26(__lookahead, __tokens, __sym0, __sym1, __sym2)); + __result = try!(__state28(__lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { return Ok((__lookahead, __nt)); @@ -1096,20 +1251,22 @@ mod __parse__Expr { return Ok(__result); } - // State 17 + // State 19 // Term = "(" Expr ")" (*) [EOF] // Term = "(" Expr ")" (*) ["*"] // Term = "(" Expr ")" (*) ["+"] // Term = "(" Expr ")" (*) ["-"] // Term = "(" Expr ")" (*) ["/"] // - // "+" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) // "-" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) // "/" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) - // EOF -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) + // "+" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) // "*" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) + // EOF -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) // - pub fn __state17<__TOKENS: Iterator>( + pub fn __state19< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -1118,13 +1275,6 @@ mod __parse__Expr { ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __Nonterminal); match __lookahead { - Some(Tok::Plus(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action8(__sym0, __sym1, __sym2); - return Ok((__lookahead, __Nonterminal::Term(__nt))); - } Some(Tok::Minus(..)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); @@ -1139,7 +1289,7 @@ mod __parse__Expr { let __nt = super::__action8(__sym0, __sym1, __sym2); return Ok((__lookahead, __Nonterminal::Term(__nt))); } - None => { + Some(Tok::Plus(..)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); @@ -1153,13 +1303,20 @@ mod __parse__Expr { let __nt = super::__action8(__sym0, __sym1, __sym2); return Ok((__lookahead, __Nonterminal::Term(__nt))); } + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action8(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::Term(__nt))); + } _ => { return Err(__lookahead); } } } - // State 18 + // State 20 // Expr = Expr "+" (*) Factor [")"] // Expr = Expr "+" (*) Factor ["+"] // Expr = Expr "+" (*) Factor ["-"] @@ -1189,12 +1346,14 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "Num" -> Shift(S7) + // "Num" -> Shift(S9) // "(" -> Shift(S8) // - // Factor -> S27 // Term -> S6 - pub fn __state18<__TOKENS: Iterator>( + // Factor -> S29 + pub fn __state20< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -1205,7 +1364,7 @@ mod __parse__Expr { Some(Tok::Num(__tok0)) => { let mut __sym2 = &mut Some((__tok0)); let __lookahead = __tokens.next(); - __result = try!(__state7(__lookahead, __tokens, __sym2)); + __result = try!(__state9(__lookahead, __tokens, __sym2)); } Some(__tok @ Tok::LParen(..)) => { let mut __sym2 = &mut Some(__tok); @@ -1219,127 +1378,11 @@ mod __parse__Expr { while __sym1.is_some() { let (__lookahead, __nt) = __result; match __nt { - __Nonterminal::Factor(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state27(__lookahead, __tokens, __sym0, __sym1, __sym2)); - } __Nonterminal::Term(__nt) => { let __sym2 = &mut Some(__nt); __result = try!(__state6(__lookahead, __tokens, __sym2)); } - _ => { - return Ok((__lookahead, __nt)); - } - } - } - return Ok(__result); - } - - // State 19 - // Factor = Factor "*" (*) Term [")"] - // Factor = Factor "*" (*) Term ["*"] - // Factor = Factor "*" (*) Term ["+"] - // Factor = Factor "*" (*) Term ["-"] - // Factor = Factor "*" (*) Term ["/"] - // Term = (*) "(" Expr ")" [")"] - // Term = (*) "(" Expr ")" ["*"] - // Term = (*) "(" Expr ")" ["+"] - // Term = (*) "(" Expr ")" ["-"] - // Term = (*) "(" Expr ")" ["/"] - // Term = (*) "Num" [")"] - // Term = (*) "Num" ["*"] - // Term = (*) "Num" ["+"] - // Term = (*) "Num" ["-"] - // Term = (*) "Num" ["/"] - // - // "Num" -> Shift(S7) - // "(" -> Shift(S8) - // - // Term -> S28 - pub fn __state19<__TOKENS: Iterator>( - mut __lookahead: Option, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut __result: (Option, __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!(__state8(__lookahead, __tokens, __sym2)); - } - _ => { - return Err(__lookahead); - } - } - while __sym1.is_some() { - let (__lookahead, __nt) = __result; - match __nt { - __Nonterminal::Term(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state28(__lookahead, __tokens, __sym0, __sym1, __sym2)); - } - _ => { - return Ok((__lookahead, __nt)); - } - } - } - return Ok(__result); - } - - // State 20 - // Factor = Factor "/" (*) Term [")"] - // Factor = Factor "/" (*) Term ["*"] - // Factor = Factor "/" (*) Term ["+"] - // Factor = Factor "/" (*) Term ["-"] - // Factor = Factor "/" (*) Term ["/"] - // Term = (*) "(" Expr ")" [")"] - // Term = (*) "(" Expr ")" ["*"] - // Term = (*) "(" Expr ")" ["+"] - // Term = (*) "(" Expr ")" ["-"] - // Term = (*) "(" Expr ")" ["/"] - // Term = (*) "Num" [")"] - // Term = (*) "Num" ["*"] - // Term = (*) "Num" ["+"] - // Term = (*) "Num" ["-"] - // Term = (*) "Num" ["/"] - // - // "(" -> Shift(S8) - // "Num" -> Shift(S7) - // - // Term -> S29 - pub fn __state20<__TOKENS: Iterator>( - mut __lookahead: Option, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut __result: (Option, __Nonterminal); - match __lookahead { - Some(__tok @ Tok::LParen(..)) => { - let mut __sym2 = &mut Some(__tok); - let __lookahead = __tokens.next(); - __result = try!(__state8(__lookahead, __tokens, __sym2)); - } - Some(Tok::Num(__tok0)) => { - let mut __sym2 = &mut Some((__tok0)); - let __lookahead = __tokens.next(); - __result = try!(__state7(__lookahead, __tokens, __sym2)); - } - _ => { - return Err(__lookahead); - } - } - while __sym1.is_some() { - let (__lookahead, __nt) = __result; - match __nt { - __Nonterminal::Term(__nt) => { + __Nonterminal::Factor(__nt) => { let __sym2 = &mut Some(__nt); __result = try!(__state29(__lookahead, __tokens, __sym0, __sym1, __sym2)); } @@ -1352,132 +1395,6 @@ mod __parse__Expr { } // State 21 - // Factor = Factor "*" Term (*) [EOF] - // Factor = Factor "*" Term (*) ["*"] - // Factor = Factor "*" Term (*) ["+"] - // Factor = Factor "*" Term (*) ["-"] - // Factor = Factor "*" Term (*) ["/"] - // - // EOF -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) - // "*" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) - // "-" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) - // "/" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) - // "+" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) - // - pub fn __state21<__TOKENS: Iterator>( - mut __lookahead: Option, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut __result: (Option, __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((__lookahead, __Nonterminal::Factor(__nt))); - } - Some(Tok::Times(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action4(__sym0, __sym1, __sym2); - return Ok((__lookahead, __Nonterminal::Factor(__nt))); - } - 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((__lookahead, __Nonterminal::Factor(__nt))); - } - Some(Tok::Div(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action4(__sym0, __sym1, __sym2); - return Ok((__lookahead, __Nonterminal::Factor(__nt))); - } - Some(Tok::Plus(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action4(__sym0, __sym1, __sym2); - return Ok((__lookahead, __Nonterminal::Factor(__nt))); - } - _ => { - return Err(__lookahead); - } - } - } - - // State 22 - // Factor = Factor "/" Term (*) [EOF] - // Factor = Factor "/" Term (*) ["*"] - // Factor = Factor "/" Term (*) ["+"] - // Factor = Factor "/" Term (*) ["-"] - // Factor = Factor "/" Term (*) ["/"] - // - // "+" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) - // "*" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) - // "/" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) - // "-" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) - // EOF -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) - // - pub fn __state22<__TOKENS: Iterator>( - mut __lookahead: Option, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut __result: (Option, __Nonterminal); - match __lookahead { - Some(Tok::Plus(..)) => { - 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::Factor(__nt))); - } - Some(Tok::Times(..)) => { - 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::Factor(__nt))); - } - Some(Tok::Div(..)) => { - 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::Factor(__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::Factor(__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::Factor(__nt))); - } - _ => { - return Err(__lookahead); - } - } - } - - // State 23 // Expr = Expr "+" Factor (*) [EOF] // Expr = Expr "+" Factor (*) ["+"] // Expr = Expr "+" Factor (*) ["-"] @@ -1493,12 +1410,14 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["/"] // // "+" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) - // "/" -> Shift(S12) // EOF -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) + // "*" -> Shift(S13) + // "/" -> Shift(S14) // "-" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) - // "*" -> Shift(S11) // - pub fn __state23<__TOKENS: Iterator>( + pub fn __state21< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -1507,15 +1426,15 @@ mod __parse__Expr { ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __Nonterminal); match __lookahead { - Some(__tok @ Tok::Div(..)) => { - let mut __sym3 = &mut Some(__tok); - let __lookahead = __tokens.next(); - __result = try!(__state12(__lookahead, __tokens, __sym2, __sym3)); - } Some(__tok @ Tok::Times(..)) => { let mut __sym3 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state11(__lookahead, __tokens, __sym2, __sym3)); + __result = try!(__state13(__lookahead, __tokens, __sym2, __sym3)); + } + Some(__tok @ Tok::Div(..)) => { + let mut __sym3 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state14(__lookahead, __tokens, __sym2, __sym3)); } Some(Tok::Plus(..)) => { let __sym0 = __sym0.take().unwrap(); @@ -1545,7 +1464,7 @@ mod __parse__Expr { return Ok(__result); } - // State 24 + // State 22 // Expr = Expr "-" Factor (*) [EOF] // Expr = Expr "-" Factor (*) ["+"] // Expr = Expr "-" Factor (*) ["-"] @@ -1560,13 +1479,15 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["-"] // Factor = Factor (*) "/" Term ["/"] // + // EOF -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) // "+" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) // "-" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) - // "/" -> Shift(S12) - // EOF -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) - // "*" -> Shift(S11) + // "/" -> Shift(S14) + // "*" -> Shift(S13) // - pub fn __state24<__TOKENS: Iterator>( + pub fn __state22< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -1578,12 +1499,19 @@ mod __parse__Expr { Some(__tok @ Tok::Div(..)) => { let mut __sym3 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state12(__lookahead, __tokens, __sym2, __sym3)); + __result = try!(__state14(__lookahead, __tokens, __sym2, __sym3)); } Some(__tok @ Tok::Times(..)) => { let mut __sym3 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state11(__lookahead, __tokens, __sym2, __sym3)); + __result = try!(__state13(__lookahead, __tokens, __sym2, __sym3)); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action1(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::Expr(__nt))); } Some(Tok::Plus(..)) => { let __sym0 = __sym0.take().unwrap(); @@ -1599,13 +1527,6 @@ mod __parse__Expr { let __nt = super::__action1(__sym0, __sym1, __sym2); return Ok((__lookahead, __Nonterminal::Expr(__nt))); } - None => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action1(__sym0, __sym1, __sym2); - return Ok((__lookahead, __Nonterminal::Expr(__nt))); - } _ => { return Err(__lookahead); } @@ -1613,20 +1534,282 @@ mod __parse__Expr { return Ok(__result); } + // State 23 + // Factor = Factor "*" Term (*) [EOF] + // Factor = Factor "*" Term (*) ["*"] + // Factor = Factor "*" Term (*) ["+"] + // Factor = Factor "*" Term (*) ["-"] + // Factor = Factor "*" Term (*) ["/"] + // + // "-" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) + // "/" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) + // "*" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) + // EOF -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) + // "+" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) + // + pub fn __state23< + __TOKENS: Iterator, + >( + mut __lookahead: Option, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __Nonterminal); + match __lookahead { + 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((__lookahead, __Nonterminal::Factor(__nt))); + } + Some(Tok::Div(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action4(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::Factor(__nt))); + } + Some(Tok::Times(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action4(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::Factor(__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((__lookahead, __Nonterminal::Factor(__nt))); + } + Some(Tok::Plus(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action4(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::Factor(__nt))); + } + _ => { + return Err(__lookahead); + } + } + } + + // State 24 + // Factor = Factor "/" Term (*) [EOF] + // Factor = Factor "/" Term (*) ["*"] + // Factor = Factor "/" Term (*) ["+"] + // Factor = Factor "/" Term (*) ["-"] + // Factor = Factor "/" Term (*) ["/"] + // + // "/" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) + // "-" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) + // EOF -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) + // "+" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) + // "*" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) + // + pub fn __state24< + __TOKENS: Iterator, + >( + mut __lookahead: Option, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __Nonterminal); + match __lookahead { + Some(Tok::Div(..)) => { + 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::Factor(__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::Factor(__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::Factor(__nt))); + } + Some(Tok::Plus(..)) => { + 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::Factor(__nt))); + } + Some(Tok::Times(..)) => { + 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::Factor(__nt))); + } + _ => { + return Err(__lookahead); + } + } + } + // State 25 + // Factor = Factor "*" Term (*) [")"] + // Factor = Factor "*" Term (*) ["*"] + // Factor = Factor "*" Term (*) ["+"] + // Factor = Factor "*" Term (*) ["-"] + // Factor = Factor "*" Term (*) ["/"] + // + // ")" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) + // "+" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) + // "-" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) + // "/" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) + // "*" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) + // + pub fn __state25< + __TOKENS: Iterator, + >( + mut __lookahead: Option, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __Nonterminal); + match __lookahead { + Some(Tok::RParen(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action4(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::Factor(__nt))); + } + Some(Tok::Plus(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action4(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::Factor(__nt))); + } + 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((__lookahead, __Nonterminal::Factor(__nt))); + } + Some(Tok::Div(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action4(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::Factor(__nt))); + } + Some(Tok::Times(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action4(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::Factor(__nt))); + } + _ => { + return Err(__lookahead); + } + } + } + + // State 26 + // Factor = Factor "/" Term (*) [")"] + // Factor = Factor "/" Term (*) ["*"] + // Factor = Factor "/" Term (*) ["+"] + // Factor = Factor "/" Term (*) ["-"] + // Factor = Factor "/" Term (*) ["/"] + // + // "/" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) + // "*" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) + // ")" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) + // "+" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) + // "-" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) + // + pub fn __state26< + __TOKENS: Iterator, + >( + mut __lookahead: Option, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __Nonterminal); + match __lookahead { + Some(Tok::Div(..)) => { + 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::Factor(__nt))); + } + Some(Tok::Times(..)) => { + 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::Factor(__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((__lookahead, __Nonterminal::Factor(__nt))); + } + Some(Tok::Plus(..)) => { + 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::Factor(__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::Factor(__nt))); + } + _ => { + return Err(__lookahead); + } + } + } + + // State 27 // Term = "(" Expr ")" (*) [")"] // Term = "(" Expr ")" (*) ["*"] // Term = "(" Expr ")" (*) ["+"] // Term = "(" Expr ")" (*) ["-"] // Term = "(" Expr ")" (*) ["/"] // - // "+" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) - // "/" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) - // "-" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) - // ")" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) // "*" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) + // "+" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) + // ")" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) + // "-" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) + // "/" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);) // - pub fn __state25<__TOKENS: Iterator>( + pub fn __state27< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -1635,6 +1818,13 @@ mod __parse__Expr { ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __Nonterminal); match __lookahead { + Some(Tok::Times(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action8(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::Term(__nt))); + } Some(Tok::Plus(..)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); @@ -1642,20 +1832,6 @@ mod __parse__Expr { let __nt = super::__action8(__sym0, __sym1, __sym2); return Ok((__lookahead, __Nonterminal::Term(__nt))); } - Some(Tok::Div(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action8(__sym0, __sym1, __sym2); - return Ok((__lookahead, __Nonterminal::Term(__nt))); - } - Some(Tok::Minus(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action8(__sym0, __sym1, __sym2); - return Ok((__lookahead, __Nonterminal::Term(__nt))); - } Some(Tok::RParen(..)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); @@ -1663,7 +1839,14 @@ mod __parse__Expr { let __nt = super::__action8(__sym0, __sym1, __sym2); return Ok((__lookahead, __Nonterminal::Term(__nt))); } - Some(Tok::Times(..)) => { + Some(Tok::Minus(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action8(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::Term(__nt))); + } + Some(Tok::Div(..)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); @@ -1676,7 +1859,7 @@ mod __parse__Expr { } } - // State 26 + // State 28 // Expr = Expr "-" Factor (*) [")"] // Expr = Expr "-" Factor (*) ["+"] // Expr = Expr "-" Factor (*) ["-"] @@ -1691,13 +1874,15 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["-"] // Factor = Factor (*) "/" Term ["/"] // - // "+" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) - // "*" -> Shift(S19) - // "/" -> Shift(S20) - // "-" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) // ")" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) + // "+" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) + // "-" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) + // "*" -> Shift(S15) + // "/" -> Shift(S16) // - pub fn __state26<__TOKENS: Iterator>( + pub fn __state28< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -1709,12 +1894,19 @@ mod __parse__Expr { Some(__tok @ Tok::Times(..)) => { let mut __sym3 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state19(__lookahead, __tokens, __sym2, __sym3)); + __result = try!(__state15(__lookahead, __tokens, __sym2, __sym3)); } Some(__tok @ Tok::Div(..)) => { let mut __sym3 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state20(__lookahead, __tokens, __sym2, __sym3)); + __result = try!(__state16(__lookahead, __tokens, __sym2, __sym3)); + } + Some(Tok::RParen(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action1(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::Expr(__nt))); } Some(Tok::Plus(..)) => { let __sym0 = __sym0.take().unwrap(); @@ -1730,13 +1922,6 @@ mod __parse__Expr { let __nt = super::__action1(__sym0, __sym1, __sym2); return Ok((__lookahead, __Nonterminal::Expr(__nt))); } - Some(Tok::RParen(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action1(__sym0, __sym1, __sym2); - return Ok((__lookahead, __Nonterminal::Expr(__nt))); - } _ => { return Err(__lookahead); } @@ -1744,7 +1929,7 @@ mod __parse__Expr { return Ok(__result); } - // State 27 + // State 29 // Expr = Expr "+" Factor (*) [")"] // Expr = Expr "+" Factor (*) ["+"] // Expr = Expr "+" Factor (*) ["-"] @@ -1760,12 +1945,14 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["/"] // // "+" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) - // "*" -> Shift(S19) - // ")" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) - // "/" -> Shift(S20) // "-" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) + // "/" -> Shift(S16) + // ")" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) + // "*" -> Shift(S15) // - pub fn __state27<__TOKENS: Iterator>( + pub fn __state29< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -1774,15 +1961,15 @@ mod __parse__Expr { ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __Nonterminal); match __lookahead { - Some(__tok @ Tok::Times(..)) => { - let mut __sym3 = &mut Some(__tok); - let __lookahead = __tokens.next(); - __result = try!(__state19(__lookahead, __tokens, __sym2, __sym3)); - } Some(__tok @ Tok::Div(..)) => { let mut __sym3 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state20(__lookahead, __tokens, __sym2, __sym3)); + __result = try!(__state16(__lookahead, __tokens, __sym2, __sym3)); + } + Some(__tok @ Tok::Times(..)) => { + let mut __sym3 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state15(__lookahead, __tokens, __sym2, __sym3)); } Some(Tok::Plus(..)) => { let __sym0 = __sym0.take().unwrap(); @@ -1791,14 +1978,14 @@ mod __parse__Expr { let __nt = super::__action2(__sym0, __sym1, __sym2); return Ok((__lookahead, __Nonterminal::Expr(__nt))); } - Some(Tok::RParen(..)) => { + Some(Tok::Minus(..)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); let __nt = super::__action2(__sym0, __sym1, __sym2); return Ok((__lookahead, __Nonterminal::Expr(__nt))); } - Some(Tok::Minus(..)) => { + Some(Tok::RParen(..)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); @@ -1811,132 +1998,6 @@ mod __parse__Expr { } return Ok(__result); } - - // State 28 - // Factor = Factor "*" Term (*) [")"] - // Factor = Factor "*" Term (*) ["*"] - // Factor = Factor "*" Term (*) ["+"] - // Factor = Factor "*" Term (*) ["-"] - // Factor = Factor "*" Term (*) ["/"] - // - // "-" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) - // "+" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) - // ")" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) - // "*" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) - // "/" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) - // - pub fn __state28<__TOKENS: Iterator>( - mut __lookahead: Option, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut __result: (Option, __Nonterminal); - match __lookahead { - 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((__lookahead, __Nonterminal::Factor(__nt))); - } - Some(Tok::Plus(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action4(__sym0, __sym1, __sym2); - return Ok((__lookahead, __Nonterminal::Factor(__nt))); - } - Some(Tok::RParen(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action4(__sym0, __sym1, __sym2); - return Ok((__lookahead, __Nonterminal::Factor(__nt))); - } - Some(Tok::Times(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action4(__sym0, __sym1, __sym2); - return Ok((__lookahead, __Nonterminal::Factor(__nt))); - } - Some(Tok::Div(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action4(__sym0, __sym1, __sym2); - return Ok((__lookahead, __Nonterminal::Factor(__nt))); - } - _ => { - return Err(__lookahead); - } - } - } - - // State 29 - // Factor = Factor "/" Term (*) [")"] - // Factor = Factor "/" Term (*) ["*"] - // Factor = Factor "/" Term (*) ["+"] - // Factor = Factor "/" Term (*) ["-"] - // Factor = Factor "/" Term (*) ["/"] - // - // "-" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) - // "*" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) - // "+" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) - // ")" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) - // "/" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) - // - pub fn __state29<__TOKENS: Iterator>( - mut __lookahead: Option, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut __result: (Option, __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::Factor(__nt))); - } - Some(Tok::Times(..)) => { - 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::Factor(__nt))); - } - Some(Tok::Plus(..)) => { - 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::Factor(__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((__lookahead, __Nonterminal::Factor(__nt))); - } - Some(Tok::Div(..)) => { - 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::Factor(__nt))); - } - _ => { - return Err(__lookahead); - } - } - } } fn __action0( __0: i32, diff --git a/lalrpop-test/src/sub.rs b/lalrpop-test/src/sub.rs index 15ad303..a33f4e4 100644 --- a/lalrpop-test/src/sub.rs +++ b/lalrpop-test/src/sub.rs @@ -1,10 +1,11 @@ use util::tok::Tok; #[allow(non_snake_case)] -pub fn parse_S<__TOKENS: IntoIterator>( - __tokens: __TOKENS) - -> Result<(Option, i32), Option> -{ +pub fn parse_S< + __TOKENS: IntoIterator, +>( + __tokens: __TOKENS, +) -> Result<(Option, i32), Option> { let mut __tokens = __tokens.into_iter(); let __lookahead = __tokens.next(); match try!(__parse__S::__state0(__lookahead, &mut __tokens)) { @@ -20,9 +21,9 @@ mod __parse__S { pub enum __Nonterminal { E(i32), - S(i32), - __S(i32), T(i32), + __S(i32), + S(i32), } // State 0 @@ -37,13 +38,15 @@ mod __parse__S { // T = (*) "Num" ["-"] // __S = (*) S [EOF] // - // "(" -> Shift(S1) - // "Num" -> Shift(S5) + // "(" -> Shift(S5) + // "Num" -> Shift(S3) // - // T -> S4 // S -> S2 - // E -> S3 - pub fn __state0<__TOKENS: Iterator>( + // E -> S4 + // T -> S1 + pub fn __state0< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, ) -> Result<(Option, __Nonterminal), Option> { @@ -52,12 +55,12 @@ mod __parse__S { Some(__tok @ Tok::LParen(..)) => { let mut __sym0 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state1(__lookahead, __tokens, __sym0)); + __result = try!(__state5(__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)); } _ => { return Err(__lookahead); @@ -66,17 +69,17 @@ mod __parse__S { loop { let (__lookahead, __nt) = __result; match __nt { - __Nonterminal::T(__nt) => { - let __sym0 = &mut Some(__nt); - __result = try!(__state4(__lookahead, __tokens, __sym0)); - } __Nonterminal::S(__nt) => { let __sym0 = &mut Some(__nt); __result = try!(__state2(__lookahead, __tokens, __sym0)); } __Nonterminal::E(__nt) => { let __sym0 = &mut Some(__nt); - __result = try!(__state3(__lookahead, __tokens, __sym0)); + __result = try!(__state4(__lookahead, __tokens, __sym0)); + } + __Nonterminal::T(__nt) => { + let __sym0 = &mut Some(__nt); + __result = try!(__state1(__lookahead, __tokens, __sym0)); } _ => { return Ok((__lookahead, __nt)); @@ -86,60 +89,35 @@ mod __parse__S { } // State 1 - // 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 (*) ["-"] // - // "(" -> Shift(S6) - // "Num" -> Shift(S8) + // "-" -> Reduce(E = T => ActionFn(3);) + // EOF -> Reduce(E = T => ActionFn(3);) // - // T -> S7 - // E -> S9 - pub fn __state1<__TOKENS: Iterator>( + pub fn __state1< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, - __sym0: &mut Option, + __sym0: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __Nonterminal); match __lookahead { - Some(__tok @ Tok::LParen(..)) => { - let mut __sym1 = &mut Some(__tok); - let __lookahead = __tokens.next(); - __result = try!(__state6(__lookahead, __tokens, __sym1)); + Some(Tok::Minus(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(__sym0); + return Ok((__lookahead, __Nonterminal::E(__nt))); } - Some(Tok::Num(__tok0)) => { - let mut __sym1 = &mut Some((__tok0)); - let __lookahead = __tokens.next(); - __result = try!(__state8(__lookahead, __tokens, __sym1)); + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(__sym0); + return Ok((__lookahead, __Nonterminal::E(__nt))); } _ => { return Err(__lookahead); } } - while __sym0.is_some() { - let (__lookahead, __nt) = __result; - match __nt { - __Nonterminal::T(__nt) => { - let __sym1 = &mut Some(__nt); - __result = try!(__state7(__lookahead, __tokens, __sym1)); - } - __Nonterminal::E(__nt) => { - let __sym1 = &mut Some(__nt); - __result = try!(__state9(__lookahead, __tokens, __sym0, __sym1)); - } - _ => { - return Ok((__lookahead, __nt)); - } - } - } - return Ok(__result); } // State 2 @@ -147,7 +125,9 @@ mod __parse__S { // // EOF -> Reduce(__S = S => ActionFn(0);) // - pub fn __state2<__TOKENS: Iterator>( + pub fn __state2< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -166,14 +146,48 @@ mod __parse__S { } // State 3 + // T = "Num" (*) [EOF] + // T = "Num" (*) ["-"] + // + // "-" -> Reduce(T = "Num" => ActionFn(4);) + // EOF -> Reduce(T = "Num" => ActionFn(4);) + // + pub fn __state3< + __TOKENS: Iterator, + >( + mut __lookahead: Option, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __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 // E = E (*) "-" T [EOF] // E = E (*) "-" T ["-"] // S = E (*) [EOF] // - // "-" -> Shift(S10) + // "-" -> Shift(S6) // EOF -> Reduce(S = E => ActionFn(1);) // - pub fn __state3<__TOKENS: Iterator>( + pub fn __state4< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -183,7 +197,7 @@ mod __parse__S { Some(__tok @ Tok::Minus(..)) => { let mut __sym1 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state10(__lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state6(__lookahead, __tokens, __sym0, __sym1)); } None => { let __sym0 = __sym0.take().unwrap(); @@ -197,99 +211,41 @@ mod __parse__S { return Ok(__result); } - // State 4 - // E = T (*) [EOF] - // E = T (*) ["-"] - // - // EOF -> Reduce(E = T => ActionFn(3);) - // "-" -> Reduce(E = T => ActionFn(3);) - // - pub fn __state4<__TOKENS: Iterator>( - mut __lookahead: Option, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut __result: (Option, __Nonterminal); - match __lookahead { - None => { - let __sym0 = __sym0.take().unwrap(); - 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); - } - } - } - // State 5 - // T = "Num" (*) [EOF] - // T = "Num" (*) ["-"] - // - // "-" -> Reduce(T = "Num" => ActionFn(4);) - // EOF -> Reduce(T = "Num" => ActionFn(4);) - // - pub fn __state5<__TOKENS: Iterator>( - mut __lookahead: Option, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut __result: (Option, __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 [")"] // E = (*) E "-" T ["-"] // E = (*) T [")"] // E = (*) T ["-"] // T = (*) "(" E ")" [")"] // T = (*) "(" E ")" ["-"] - // T = "(" (*) E ")" [")"] + // T = "(" (*) E ")" [EOF] // T = "(" (*) E ")" ["-"] // T = (*) "Num" [")"] // T = (*) "Num" ["-"] // - // "Num" -> Shift(S8) - // "(" -> Shift(S6) + // "(" -> Shift(S10) + // "Num" -> Shift(S9) // - // E -> S11 // T -> S7 - pub fn __state6<__TOKENS: Iterator>( + // E -> S8 + pub fn __state5< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __Nonterminal); match __lookahead { - Some(Tok::Num(__tok0)) => { - let mut __sym1 = &mut Some((__tok0)); - let __lookahead = __tokens.next(); - __result = try!(__state8(__lookahead, __tokens, __sym1)); - } Some(__tok @ Tok::LParen(..)) => { let mut __sym1 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state6(__lookahead, __tokens, __sym1)); + __result = try!(__state10(__lookahead, __tokens, __sym1)); + } + Some(Tok::Num(__tok0)) => { + let mut __sym1 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state9(__lookahead, __tokens, __sym1)); } _ => { return Err(__lookahead); @@ -298,14 +254,65 @@ mod __parse__S { while __sym0.is_some() { let (__lookahead, __nt) = __result; match __nt { - __Nonterminal::E(__nt) => { - let __sym1 = &mut Some(__nt); - __result = try!(__state11(__lookahead, __tokens, __sym0, __sym1)); - } __Nonterminal::T(__nt) => { let __sym1 = &mut Some(__nt); __result = try!(__state7(__lookahead, __tokens, __sym1)); } + __Nonterminal::E(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state8(__lookahead, __tokens, __sym0, __sym1)); + } + _ => { + return Ok((__lookahead, __nt)); + } + } + } + return Ok(__result); + } + + // State 6 + // E = E "-" (*) T [EOF] + // E = E "-" (*) T ["-"] + // T = (*) "(" E ")" [EOF] + // T = (*) "(" E ")" ["-"] + // T = (*) "Num" [EOF] + // T = (*) "Num" ["-"] + // + // "Num" -> Shift(S3) + // "(" -> Shift(S5) + // + // T -> S11 + pub fn __state6< + __TOKENS: Iterator, + >( + mut __lookahead: Option, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __Nonterminal); + match __lookahead { + Some(Tok::Num(__tok0)) => { + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state3(__lookahead, __tokens, __sym2)); + } + Some(__tok @ Tok::LParen(..)) => { + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state5(__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!(__state11(__lookahead, __tokens, __sym0, __sym1, __sym2)); + } _ => { return Ok((__lookahead, __nt)); } @@ -321,7 +328,9 @@ mod __parse__S { // ")" -> Reduce(E = T => ActionFn(3);) // "-" -> Reduce(E = T => ActionFn(3);) // - pub fn __state7<__TOKENS: Iterator>( + pub fn __state7< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -345,13 +354,51 @@ mod __parse__S { } // State 8 + // E = E (*) "-" T [")"] + // E = E (*) "-" T ["-"] + // T = "(" E (*) ")" [EOF] + // T = "(" E (*) ")" ["-"] + // + // ")" -> Shift(S12) + // "-" -> Shift(S13) + // + pub fn __state8< + __TOKENS: Iterator, + >( + mut __lookahead: Option, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __Nonterminal); + match __lookahead { + Some(__tok @ Tok::RParen(..)) => { + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state12(__lookahead, __tokens, __sym0, __sym1, __sym2)); + } + Some(__tok @ Tok::Minus(..)) => { + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state13(__lookahead, __tokens, __sym1, __sym2)); + } + _ => { + return Err(__lookahead); + } + } + return Ok(__result); + } + + // State 9 // T = "Num" (*) [")"] // T = "Num" (*) ["-"] // // ")" -> Reduce(T = "Num" => ActionFn(4);) // "-" -> Reduce(T = "Num" => ActionFn(4);) // - pub fn __state8<__TOKENS: Iterator>( + pub fn __state9< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -374,80 +421,56 @@ mod __parse__S { } } - // State 9 - // E = E (*) "-" T [")"] - // E = E (*) "-" T ["-"] - // T = "(" E (*) ")" [EOF] - // T = "(" E (*) ")" ["-"] + // 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(S12) - // ")" -> Shift(S13) + // "(" -> Shift(S10) + // "Num" -> Shift(S9) // - pub fn __state9<__TOKENS: Iterator>( + // E -> S14 + // T -> S7 + pub fn __state10< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, - __sym1: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut __result: (Option, __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 [EOF] - // E = E "-" (*) T ["-"] - // T = (*) "(" E ")" [EOF] - // T = (*) "(" E ")" ["-"] - // T = (*) "Num" [EOF] - // T = (*) "Num" ["-"] - // - // "(" -> Shift(S1) - // "Num" -> Shift(S5) - // - // T -> S14 - pub fn __state10<__TOKENS: Iterator>( - mut __lookahead: Option, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __Nonterminal); match __lookahead { Some(__tok @ Tok::LParen(..)) => { - let mut __sym2 = &mut Some(__tok); + let mut __sym1 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state1(__lookahead, __tokens, __sym2)); + __result = try!(__state10(__lookahead, __tokens, __sym1)); } Some(Tok::Num(__tok0)) => { - let mut __sym2 = &mut Some((__tok0)); + let mut __sym1 = &mut Some((__tok0)); let __lookahead = __tokens.next(); - __result = try!(__state5(__lookahead, __tokens, __sym2)); + __result = try!(__state9(__lookahead, __tokens, __sym1)); } _ => { return Err(__lookahead); } } - while __sym1.is_some() { + 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 __sym2 = &mut Some(__nt); - __result = try!(__state14(__lookahead, __tokens, __sym0, __sym1, __sym2)); + let __sym1 = &mut Some(__nt); + __result = try!(__state7(__lookahead, __tokens, __sym1)); } _ => { return Ok((__lookahead, __nt)); @@ -458,40 +481,82 @@ mod __parse__S { } // State 11 - // E = E (*) "-" T [")"] - // E = E (*) "-" T ["-"] - // T = "(" E (*) ")" [")"] - // T = "(" E (*) ")" ["-"] + // E = E "-" T (*) [EOF] + // E = E "-" T (*) ["-"] // - // "-" -> Shift(S12) - // ")" -> Shift(S15) + // "-" -> Reduce(E = E, "-", T => ActionFn(2);) + // EOF -> Reduce(E = E, "-", T => ActionFn(2);) // - pub fn __state11<__TOKENS: Iterator>( + pub fn __state11< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __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::Minus(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action2(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::E(__nt))); } - Some(__tok @ Tok::RParen(..)) => { - let mut __sym2 = &mut Some(__tok); - let __lookahead = __tokens.next(); - __result = try!(__state15(__lookahead, __tokens, __sym0, __sym1, __sym2)); + 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((__lookahead, __Nonterminal::E(__nt))); } _ => { return Err(__lookahead); } } - return Ok(__result); } // State 12 + // T = "(" E ")" (*) [EOF] + // T = "(" E ")" (*) ["-"] + // + // EOF -> Reduce(T = "(", E, ")" => ActionFn(5);) + // "-" -> Reduce(T = "(", E, ")" => ActionFn(5);) + // + pub fn __state12< + __TOKENS: Iterator, + >( + mut __lookahead: Option, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __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 13 // E = E "-" (*) T [")"] // E = E "-" (*) T ["-"] // T = (*) "(" E ")" [")"] @@ -499,11 +564,13 @@ mod __parse__S { // T = (*) "Num" [")"] // T = (*) "Num" ["-"] // - // "Num" -> Shift(S8) - // "(" -> Shift(S6) + // "Num" -> Shift(S9) + // "(" -> Shift(S10) // - // T -> S16 - pub fn __state12<__TOKENS: Iterator>( + // T -> S15 + pub fn __state13< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -514,12 +581,12 @@ mod __parse__S { Some(Tok::Num(__tok0)) => { let mut __sym2 = &mut Some((__tok0)); let __lookahead = __tokens.next(); - __result = try!(__state8(__lookahead, __tokens, __sym2)); + __result = try!(__state9(__lookahead, __tokens, __sym2)); } Some(__tok @ Tok::LParen(..)) => { let mut __sym2 = &mut Some(__tok); let __lookahead = __tokens.next(); - __result = try!(__state6(__lookahead, __tokens, __sym2)); + __result = try!(__state10(__lookahead, __tokens, __sym2)); } _ => { return Err(__lookahead); @@ -530,7 +597,7 @@ mod __parse__S { match __nt { __Nonterminal::T(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state16(__lookahead, __tokens, __sym0, __sym1, __sym2)); + __result = try!(__state15(__lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { return Ok((__lookahead, __nt)); @@ -540,50 +607,52 @@ mod __parse__S { return Ok(__result); } - // State 13 - // T = "(" E ")" (*) [EOF] - // T = "(" E ")" (*) ["-"] + // State 14 + // E = E (*) "-" T [")"] + // E = E (*) "-" T ["-"] + // T = "(" E (*) ")" [")"] + // T = "(" E (*) ")" ["-"] // - // EOF -> Reduce(T = "(", E, ")" => ActionFn(5);) - // "-" -> Reduce(T = "(", E, ")" => ActionFn(5);) + // "-" -> Shift(S13) + // ")" -> Shift(S16) // - pub fn __state13<__TOKENS: Iterator>( + pub fn __state14< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - __sym2: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __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 @ Tok::Minus(..)) => { + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state13(__lookahead, __tokens, __sym1, __sym2)); } - 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))); + 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] + // State 15 + // E = E "-" T (*) [")"] // E = E "-" T (*) ["-"] // // "-" -> Reduce(E = E, "-", T => ActionFn(2);) - // EOF -> Reduce(E = E, "-", T => ActionFn(2);) + // ")" -> Reduce(E = E, "-", T => ActionFn(2);) // - pub fn __state14<__TOKENS: Iterator>( + pub fn __state15< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, __sym0: &mut Option, @@ -599,7 +668,7 @@ mod __parse__S { let __nt = super::__action2(__sym0, __sym1, __sym2); return Ok((__lookahead, __Nonterminal::E(__nt))); } - None => { + Some(Tok::RParen(..)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); @@ -612,71 +681,37 @@ mod __parse__S { } } - // State 15 - // T = "(" E ")" (*) [")"] - // T = "(" E ")" (*) ["-"] - // - // ")" -> Reduce(T = "(", E, ")" => ActionFn(5);) - // "-" -> Reduce(T = "(", E, ")" => ActionFn(5);) - // - pub fn __state15<__TOKENS: Iterator>( - mut __lookahead: Option, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut __result: (Option, __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((__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 16 - // E = E "-" T (*) [")"] - // E = E "-" T (*) ["-"] + // T = "(" E ")" (*) [")"] + // T = "(" E ")" (*) ["-"] // - // "-" -> Reduce(E = E, "-", T => ActionFn(2);) - // ")" -> Reduce(E = E, "-", T => ActionFn(2);) + // ")" -> Reduce(T = "(", E, ")" => ActionFn(5);) + // "-" -> Reduce(T = "(", E, ")" => ActionFn(5);) // - pub fn __state16<__TOKENS: Iterator>( + pub fn __state16< + __TOKENS: Iterator, + >( mut __lookahead: Option, __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option, + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { let mut __result: (Option, __Nonterminal); match __lookahead { - Some(Tok::Minus(..)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action2(__sym0, __sym1, __sym2); - return Ok((__lookahead, __Nonterminal::E(__nt))); - } Some(Tok::RParen(..)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action2(__sym0, __sym1, __sym2); - return Ok((__lookahead, __Nonterminal::E(__nt))); + 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); diff --git a/lalrpop-test/src/util/tok.rs b/lalrpop-test/src/util/tok.rs index ca1ae32..424612c 100644 --- a/lalrpop-test/src/util/tok.rs +++ b/lalrpop-test/src/util/tok.rs @@ -11,15 +11,6 @@ pub enum Tok { Div, } -impl Tok { - pub fn as_num(&self) -> i32 { - match *self { - Tok::Num(x) => x, - _ => panic!("as_num invoked with non-number"), - } - } -} - // simplest and stupidest possible tokenizer pub fn tokenize(s: &str) -> Vec { let mut tokens = vec![]; diff --git a/lalrpop/src/lr1/ascent.rs b/lalrpop/src/lr1/ascent.rs index 836acde..84a6521 100644 --- a/lalrpop/src/lr1/ascent.rs +++ b/lalrpop/src/lr1/ascent.rs @@ -104,14 +104,12 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { fn write_start_fn(&mut self) -> io::Result<()> { let terminal_type = self.types.terminal_enum_type(); rust!(self.out, "#[allow(non_snake_case)]"); - rust!(self.out, "pub fn parse_{}<{}TOKENS: IntoIterator>(", - self.user_start_symbol, self.prefix, terminal_type); - rust!(self.out, "{}tokens: {}TOKENS)", self.prefix, self.prefix); - rust!(self.out, "-> Result<(Option<{}>, {}), Option<{}>>", - terminal_type, - self.types.nonterminal_type(self.start_symbol), - terminal_type); - rust!(self.out, "{{"); + rust!(self.out, "pub fn parse_{}<", self.user_start_symbol); + rust!(self.out, " {}TOKENS: IntoIterator,", self.prefix, terminal_type); + rust!(self.out, ">("); + rust!(self.out, "{}tokens: {}TOKENS,", self.prefix, self.prefix); + rust!(self.out, ") -> Result<(Option<{}>, {}), Option<{}>> {{", + terminal_type, self.types.nonterminal_type(self.start_symbol), terminal_type); rust!(self.out, "let mut {}tokens = {}tokens.into_iter();", self.prefix, self.prefix); rust!(self.out, "let {}lookahead = {}tokens.next();", self.prefix, self.prefix); rust!(self.out, "match try!({}parse{}::{}state0({}lookahead, &mut {}tokens)) {{", @@ -149,10 +147,10 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { // set to true if goto actions are worth generating let mut fallthrough = false; - rust!(self.out, "pub fn {}state{}<{}TOKENS: Iterator>(", - self.prefix, this_index.0, self.prefix, terminal_type); - rust!(self.out, "mut {}lookahead: Option<{}>,", - self.prefix, terminal_type); + rust!(self.out, "pub fn {}state{}<", self.prefix, this_index.0); + rust!(self.out, " {}TOKENS: Iterator,", self.prefix, terminal_type); + rust!(self.out, ">("); + rust!(self.out, "mut {}lookahead: Option<{}>,", self.prefix, terminal_type); rust!(self.out, "{}tokens: &mut {}TOKENS,", self.prefix, self.prefix); for i in 0..this_prefix.len() { rust!(self.out, "{}sym{}: &mut Option<{}>,",