From a4d2444950f08c898fd797d14344760168dd4975 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 14 Jul 2015 11:45:51 -0400 Subject: [PATCH] add more prefixing, I think to all identifiers this time --- lalrpop-test/src/expr.rs | 2338 ++++++++++++++++++------------------- lalrpop-test/src/sub.rs | 876 +++++++------- lalrpop/src/lr1/ascent.rs | 71 +- 3 files changed, 1647 insertions(+), 1638 deletions(-) diff --git a/lalrpop-test/src/expr.rs b/lalrpop-test/src/expr.rs index c9b1068..218e154 100644 --- a/lalrpop-test/src/expr.rs +++ b/lalrpop-test/src/expr.rs @@ -20,8 +20,8 @@ mod __parse__Expr { pub enum __Nonterminal { Term(i32), - __Expr(i32), Expr(i32), + __Expr(i32), Factor(i32), } @@ -62,49 +62,49 @@ mod __parse__Expr { // Term = (*) "Num" ["/"] // __Expr = (*) Expr [EOF] // - // "Num" -> Shift(S5) - // "(" -> Shift(S4) + // "Num" -> Shift(S4) + // "(" -> Shift(S3) // // Factor -> S2 // Expr -> S1 - // Term -> S3 + // Term -> S5 pub fn __state0>( - mut lookahead: Option, - tokens: &mut TOKENS, + mut __lookahead: Option, + __tokens: &mut TOKENS, ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(Tok::Num(__tok0)) => { - let mut sym0 = &mut Some((__tok0)); - let lookahead = tokens.next(); - result = try!(__state5(lookahead, tokens, sym0)); + let mut __sym0 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state4(__lookahead, __tokens, __sym0)); } Some(__tok @ Tok::LParen(..)) => { - let mut sym0 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state4(lookahead, tokens, sym0)); + let mut __sym0 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state3(__lookahead, __tokens, __sym0)); } _ => { - return Err(lookahead); + return Err(__lookahead); } } loop { - let (lookahead, nt) = result; - match nt { - __Nonterminal::Factor(nt) => { - let sym0 = &mut Some(nt); - result = try!(__state2(lookahead, tokens, sym0)); + let (__lookahead, __nt) = __result; + match __nt { + __Nonterminal::Factor(__nt) => { + let __sym0 = &mut Some(__nt); + __result = try!(__state2(__lookahead, __tokens, __sym0)); } - __Nonterminal::Expr(nt) => { - let sym0 = &mut Some(nt); - result = try!(__state1(lookahead, tokens, sym0)); + __Nonterminal::Expr(__nt) => { + let __sym0 = &mut Some(__nt); + __result = try!(__state1(__lookahead, __tokens, __sym0)); } - __Nonterminal::Term(nt) => { - let sym0 = &mut Some(nt); - result = try!(__state3(lookahead, tokens, sym0)); + __Nonterminal::Term(__nt) => { + let __sym0 = &mut Some(__nt); + __result = try!(__state5(__lookahead, __tokens, __sym0)); } _ => { - return Ok((lookahead, nt)); + return Ok((__lookahead, __nt)); } } } @@ -119,37 +119,37 @@ mod __parse__Expr { // Expr = Expr (*) "-" Factor ["-"] // __Expr = Expr (*) [EOF] // + // "-" -> Shift(S6) + // "+" -> Shift(S7) // EOF -> Reduce(__Expr = Expr => ActionFn(0);) - // "+" -> Shift(S6) - // "-" -> Shift(S7) // pub fn __state1>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, + 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!(__state6(lookahead, tokens, sym0, sym1)); - } + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(__tok @ Tok::Minus(..)) => { - let mut sym1 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state7(lookahead, tokens, sym0, sym1)); + let mut __sym1 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state6(__lookahead, __tokens, __sym0, __sym1)); + } + Some(__tok @ Tok::Plus(..)) => { + let mut __sym1 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state7(__lookahead, __tokens, __sym0, __sym1)); } None => { - let sym0 = sym0.take().unwrap(); - let nt = super::__action0(sym0); - return Ok((lookahead, __Nonterminal::__Expr(nt))); + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action0(__sym0); + return Ok((__lookahead, __Nonterminal::__Expr(__nt))); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - return Ok(result); + return Ok(__result); } // State 2 @@ -167,103 +167,52 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["-"] // Factor = Factor (*) "/" Term ["/"] // - // "+" -> Reduce(Expr = Factor => ActionFn(3);) - // "*" -> Shift(S8) - // "/" -> Shift(S9) // EOF -> Reduce(Expr = Factor => ActionFn(3);) + // "/" -> Shift(S8) + // "+" -> Reduce(Expr = Factor => ActionFn(3);) + // "*" -> Shift(S9) // "-" -> Reduce(Expr = Factor => ActionFn(3);) // pub fn __state2>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, + 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); - let lookahead = tokens.next(); - result = try!(__state8(lookahead, tokens, sym0, sym1)); - } + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(__tok @ Tok::Div(..)) => { - let mut sym1 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state9(lookahead, tokens, sym0, sym1)); + let mut __sym1 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state8(__lookahead, __tokens, __sym0, __sym1)); } - Some(Tok::Plus(..)) => { - let sym0 = sym0.take().unwrap(); - let nt = super::__action3(sym0); - return Ok((lookahead, __Nonterminal::Expr(nt))); + Some(__tok @ Tok::Times(..)) => { + let mut __sym1 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state9(__lookahead, __tokens, __sym0, __sym1)); } None => { - let sym0 = sym0.take().unwrap(); - let nt = super::__action3(sym0); - return Ok((lookahead, __Nonterminal::Expr(nt))); + 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))); + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(__sym0); + return Ok((__lookahead, __Nonterminal::Expr(__nt))); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - return Ok(result); + return Ok(__result); } // State 3 - // Factor = Term (*) [EOF] - // Factor = Term (*) ["*"] - // Factor = Term (*) ["+"] - // Factor = Term (*) ["-"] - // Factor = Term (*) ["/"] - // - // "*" -> Reduce(Factor = Term => ActionFn(6);) - // "-" -> Reduce(Factor = Term => ActionFn(6);) - // "+" -> Reduce(Factor = Term => ActionFn(6);) - // EOF -> Reduce(Factor = Term => ActionFn(6);) - // "/" -> Reduce(Factor = Term => ActionFn(6);) - // - pub fn __state3>( - 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::Minus(..)) => { - 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))); - } - None => { - 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))); - } - _ => { - return Err(lookahead); - } - } - } - - // State 4 // Expr = (*) Expr "+" Factor [")"] // Expr = (*) Expr "+" Factor ["+"] // Expr = (*) Expr "+" Factor ["-"] @@ -307,54 +256,54 @@ mod __parse__Expr { // "(" -> Shift(S14) // "Num" -> Shift(S12) // - // Expr -> S11 - // Term -> S13 - // Factor -> S10 - pub fn __state4>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, + // Factor -> S11 + // Term -> S10 + // Expr -> S13 + pub fn __state3>( + mut __lookahead: Option, + __tokens: &mut TOKENS, + __sym0: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(__tok @ Tok::LParen(..)) => { - let mut sym1 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state14(lookahead, tokens, sym1)); + let mut __sym1 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state14(__lookahead, __tokens, __sym1)); } Some(Tok::Num(__tok0)) => { - let mut sym1 = &mut Some((__tok0)); - let lookahead = tokens.next(); - result = try!(__state12(lookahead, tokens, sym1)); + let mut __sym1 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state12(__lookahead, __tokens, __sym1)); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - while sym0.is_some() { - let (lookahead, nt) = result; - match nt { - __Nonterminal::Expr(nt) => { - let sym1 = &mut Some(nt); - result = try!(__state11(lookahead, tokens, sym0, sym1)); + while __sym0.is_some() { + let (__lookahead, __nt) = __result; + match __nt { + __Nonterminal::Factor(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state11(__lookahead, __tokens, __sym1)); } - __Nonterminal::Term(nt) => { - let sym1 = &mut Some(nt); - result = try!(__state13(lookahead, tokens, sym1)); + __Nonterminal::Term(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state10(__lookahead, __tokens, __sym1)); } - __Nonterminal::Factor(nt) => { - let sym1 = &mut Some(nt); - result = try!(__state10(lookahead, tokens, sym1)); + __Nonterminal::Expr(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state13(__lookahead, __tokens, __sym0, __sym1)); } _ => { - return Ok((lookahead, nt)); + return Ok((__lookahead, __nt)); } } } - return Ok(result); + return Ok(__result); } - // State 5 + // State 4 // Term = "Num" (*) [EOF] // Term = "Num" (*) ["*"] // Term = "Num" (*) ["+"] @@ -363,125 +312,100 @@ mod __parse__Expr { // // "*" -> Reduce(Term = "Num" => ActionFn(7);) // "/" -> Reduce(Term = "Num" => ActionFn(7);) + // "+" -> Reduce(Term = "Num" => ActionFn(7);) // "-" -> Reduce(Term = "Num" => ActionFn(7);) // EOF -> Reduce(Term = "Num" => ActionFn(7);) - // "+" -> Reduce(Term = "Num" => ActionFn(7);) // - pub fn __state5>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, + pub fn __state4>( + mut __lookahead: Option, + __tokens: &mut TOKENS, + __sym0: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { + 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))); + 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::Minus(..)) => { - let sym0 = sym0.take().unwrap(); - let nt = super::__action7(sym0); - return Ok((lookahead, __Nonterminal::Term(nt))); - } - None => { - let sym0 = sym0.take().unwrap(); - let nt = super::__action7(sym0); - return Ok((lookahead, __Nonterminal::Term(nt))); + 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))); + 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))); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(__sym0); + return Ok((__lookahead, __Nonterminal::Term(__nt))); } _ => { - return Err(lookahead); + return Err(__lookahead); + } + } + } + + // State 5 + // Factor = Term (*) [EOF] + // Factor = Term (*) ["*"] + // Factor = Term (*) ["+"] + // Factor = Term (*) ["-"] + // Factor = Term (*) ["/"] + // + // "/" -> Reduce(Factor = Term => ActionFn(6);) + // "+" -> Reduce(Factor = Term => ActionFn(6);) + // "*" -> Reduce(Factor = Term => ActionFn(6);) + // "-" -> Reduce(Factor = Term => ActionFn(6);) + // EOF -> Reduce(Factor = Term => ActionFn(6);) + // + pub fn __state5>( + mut __lookahead: Option, + __tokens: &mut TOKENS, + __sym0: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __Nonterminal); + match __lookahead { + 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::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))); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action6(__sym0); + return Ok((__lookahead, __Nonterminal::Factor(__nt))); + } + _ => { + return Err(__lookahead); } } } // State 6 - // Expr = Expr "+" (*) Factor [EOF] - // Expr = Expr "+" (*) Factor ["+"] - // Expr = Expr "+" (*) Factor ["-"] - // Factor = (*) Factor "*" Term [EOF] - // Factor = (*) Factor "*" Term ["*"] - // Factor = (*) Factor "*" Term ["+"] - // Factor = (*) Factor "*" Term ["-"] - // Factor = (*) Factor "*" Term ["/"] - // Factor = (*) Factor "/" Term [EOF] - // Factor = (*) Factor "/" Term ["*"] - // Factor = (*) Factor "/" Term ["+"] - // Factor = (*) Factor "/" Term ["-"] - // Factor = (*) Factor "/" Term ["/"] - // Factor = (*) Term [EOF] - // Factor = (*) Term ["*"] - // Factor = (*) Term ["+"] - // Factor = (*) Term ["-"] - // 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(S4) - // "Num" -> Shift(S5) - // - // Factor -> S15 - // Term -> S3 - pub fn __state6>( - 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!(__state4(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::Factor(nt) => { - let sym2 = &mut Some(nt); - result = try!(__state15(lookahead, tokens, sym0, sym1, sym2)); - } - __Nonterminal::Term(nt) => { - let sym2 = &mut Some(nt); - result = try!(__state3(lookahead, tokens, sym2)); - } - _ => { - return Ok((lookahead, nt)); - } - } - } - return Ok(result); - } - - // State 7 // Expr = Expr "-" (*) Factor [EOF] // Expr = Expr "-" (*) Factor ["+"] // Expr = Expr "-" (*) Factor ["-"] @@ -511,58 +435,71 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "Num" -> Shift(S5) - // "(" -> Shift(S4) + // "Num" -> Shift(S4) + // "(" -> Shift(S3) // - // Factor -> S16 - // Term -> S3 - pub fn __state7>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, + // Factor -> S15 + // Term -> S5 + pub fn __state6>( + mut __lookahead: Option, + __tokens: &mut TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(Tok::Num(__tok0)) => { - let mut sym2 = &mut Some((__tok0)); - let lookahead = tokens.next(); - result = try!(__state5(lookahead, tokens, sym2)); + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state4(__lookahead, __tokens, __sym2)); } Some(__tok @ Tok::LParen(..)) => { - let mut sym2 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state4(lookahead, tokens, sym2)); + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state3(__lookahead, __tokens, __sym2)); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - while sym1.is_some() { - let (lookahead, nt) = result; - match nt { - __Nonterminal::Factor(nt) => { - let sym2 = &mut Some(nt); - result = try!(__state16(lookahead, tokens, sym0, sym1, sym2)); + while __sym1.is_some() { + let (__lookahead, __nt) = __result; + match __nt { + __Nonterminal::Factor(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state15(__lookahead, __tokens, __sym0, __sym1, __sym2)); } - __Nonterminal::Term(nt) => { - let sym2 = &mut Some(nt); - result = try!(__state3(lookahead, tokens, sym2)); + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state5(__lookahead, __tokens, __sym2)); } _ => { - return Ok((lookahead, nt)); + return Ok((__lookahead, __nt)); } } } - return Ok(result); + return Ok(__result); } - // State 8 - // Factor = Factor "*" (*) Term [EOF] - // Factor = Factor "*" (*) Term ["*"] - // Factor = Factor "*" (*) Term ["+"] - // Factor = Factor "*" (*) Term ["-"] - // Factor = Factor "*" (*) Term ["/"] + // State 7 + // Expr = Expr "+" (*) Factor [EOF] + // Expr = Expr "+" (*) Factor ["+"] + // Expr = Expr "+" (*) Factor ["-"] + // Factor = (*) Factor "*" Term [EOF] + // Factor = (*) Factor "*" Term ["*"] + // Factor = (*) Factor "*" Term ["+"] + // Factor = (*) Factor "*" Term ["-"] + // Factor = (*) Factor "*" Term ["/"] + // Factor = (*) Factor "/" Term [EOF] + // Factor = (*) Factor "/" Term ["*"] + // Factor = (*) Factor "/" Term ["+"] + // Factor = (*) Factor "/" Term ["-"] + // Factor = (*) Factor "/" Term ["/"] + // Factor = (*) Term [EOF] + // Factor = (*) Term ["*"] + // Factor = (*) Term ["+"] + // Factor = (*) Term ["-"] + // Factor = (*) Term ["/"] // Term = (*) "(" Expr ")" [EOF] // Term = (*) "(" Expr ")" ["*"] // Term = (*) "(" Expr ")" ["+"] @@ -574,48 +511,53 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "Num" -> Shift(S5) - // "(" -> Shift(S4) + // "Num" -> Shift(S4) + // "(" -> Shift(S3) // - // Term -> S17 - pub fn __state8>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, + // Term -> S5 + // Factor -> S16 + pub fn __state7>( + mut __lookahead: Option, + __tokens: &mut TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(Tok::Num(__tok0)) => { - let mut sym2 = &mut Some((__tok0)); - let lookahead = tokens.next(); - result = try!(__state5(lookahead, tokens, sym2)); + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state4(__lookahead, __tokens, __sym2)); } Some(__tok @ Tok::LParen(..)) => { - let mut sym2 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state4(lookahead, tokens, sym2)); + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state3(__lookahead, __tokens, __sym2)); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - while sym1.is_some() { - let (lookahead, nt) = result; - match nt { - __Nonterminal::Term(nt) => { - let sym2 = &mut Some(nt); - result = try!(__state17(lookahead, tokens, sym0, sym1, sym2)); + while __sym1.is_some() { + let (__lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state5(__lookahead, __tokens, __sym2)); + } + __Nonterminal::Factor(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state16(__lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { - return Ok((lookahead, nt)); + return Ok((__lookahead, __nt)); } } } - return Ok(result); + return Ok(__result); } - // State 9 + // State 8 // Factor = Factor "/" (*) Term [EOF] // Factor = Factor "/" (*) Term ["*"] // Factor = Factor "/" (*) Term ["+"] @@ -632,48 +574,157 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "(" -> Shift(S4) - // "Num" -> Shift(S5) + // "Num" -> Shift(S4) + // "(" -> Shift(S3) + // + // Term -> S17 + pub fn __state8>( + 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!(__state4(__lookahead, __tokens, __sym2)); + } + Some(__tok @ Tok::LParen(..)) => { + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state3(__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!(__state17(__lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookahead, __nt)); + } + } + } + return Ok(__result); + } + + // State 9 + // 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(S4) + // "(" -> Shift(S3) // // Term -> S18 pub fn __state9>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, + 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!(__state4(lookahead, tokens, sym2)); - } + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(Tok::Num(__tok0)) => { - let mut sym2 = &mut Some((__tok0)); - let lookahead = tokens.next(); - result = try!(__state5(lookahead, tokens, sym2)); + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state4(__lookahead, __tokens, __sym2)); + } + Some(__tok @ Tok::LParen(..)) => { + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state3(__lookahead, __tokens, __sym2)); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - while sym1.is_some() { - let (lookahead, nt) = result; - match nt { - __Nonterminal::Term(nt) => { - let sym2 = &mut Some(nt); - result = try!(__state18(lookahead, tokens, sym0, sym1, sym2)); + while __sym1.is_some() { + let (__lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state18(__lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { - return Ok((lookahead, nt)); + return Ok((__lookahead, __nt)); } } } - return Ok(result); + return Ok(__result); } // State 10 + // Factor = Term (*) [")"] + // Factor = Term (*) ["*"] + // Factor = Term (*) ["+"] + // 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);) + // + pub fn __state10>( + 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::__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::RParen(..)) => { + 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::Plus(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action6(__sym0); + return Ok((__lookahead, __Nonterminal::Factor(__nt))); + } + _ => { + return Err(__lookahead); + } + } + } + + // State 11 // Expr = Factor (*) [")"] // Expr = Factor (*) ["+"] // Expr = Factor (*) ["-"] @@ -688,52 +739,103 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["-"] // Factor = Factor (*) "/" Term ["/"] // - // "-" -> Reduce(Expr = Factor => ActionFn(3);) - // "/" -> Shift(S19) - // "+" -> Reduce(Expr = Factor => ActionFn(3);) - // "*" -> Shift(S20) // ")" -> Reduce(Expr = Factor => ActionFn(3);) + // "+" -> Reduce(Expr = Factor => ActionFn(3);) + // "/" -> Shift(S20) + // "*" -> Shift(S19) + // "-" -> Reduce(Expr = Factor => ActionFn(3);) // - pub fn __state10>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, + pub fn __state11>( + mut __lookahead: Option, + __tokens: &mut TOKENS, + __sym0: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(__tok @ Tok::Div(..)) => { - let mut sym1 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state19(lookahead, tokens, sym0, sym1)); + let mut __sym1 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state20(__lookahead, __tokens, __sym0, __sym1)); } Some(__tok @ Tok::Times(..)) => { - let mut sym1 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state20(lookahead, tokens, sym0, sym1)); - } - Some(Tok::Minus(..)) => { - 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))); + let mut __sym1 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state19(__lookahead, __tokens, __sym0, __sym1)); } Some(Tok::RParen(..)) => { - let sym0 = sym0.take().unwrap(); - let nt = super::__action3(sym0); - return Ok((lookahead, __Nonterminal::Expr(nt))); + 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))); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - return Ok(result); + return Ok(__result); } - // State 11 + // State 12 + // 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 __state12>( + mut __lookahead: Option, + __tokens: &mut TOKENS, + __sym0: &mut Option, + ) -> Result<(Option, __Nonterminal), Option> { + let mut __result: (Option, __Nonterminal); + match __lookahead { + Some(Tok::RParen(..)) => { + 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))); + } + 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::Minus(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(__sym0); + return Ok((__lookahead, __Nonterminal::Term(__nt))); + } + _ => { + return Err(__lookahead); + } + } + } + + // State 13 // Expr = Expr (*) "+" Factor [")"] // Expr = Expr (*) "+" Factor ["+"] // Expr = Expr (*) "+" Factor ["-"] @@ -746,140 +848,38 @@ mod __parse__Expr { // Term = "(" Expr (*) ")" ["-"] // Term = "(" Expr (*) ")" ["/"] // - // "-" -> Shift(S21) - // ")" -> Shift(S22) + // ")" -> Shift(S21) + // "-" -> Shift(S22) // "+" -> Shift(S23) // - pub fn __state11>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, + pub fn __state13>( + 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!(__state21(lookahead, tokens, sym1, sym2)); - } + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(__tok @ Tok::RParen(..)) => { - let mut sym2 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state22(lookahead, tokens, sym0, sym1, sym2)); + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state21(__lookahead, __tokens, __sym0, __sym1, __sym2)); + } + Some(__tok @ Tok::Minus(..)) => { + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state22(__lookahead, __tokens, __sym1, __sym2)); } Some(__tok @ Tok::Plus(..)) => { - let mut sym2 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state23(lookahead, tokens, sym1, sym2)); + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state23(__lookahead, __tokens, __sym1, __sym2)); } _ => { - return Err(lookahead); - } - } - return Ok(result); - } - - // State 12 - // 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 __state12>( - 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::__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::Plus(..)) => { - 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))); - } - _ => { - return Err(lookahead); - } - } - } - - // State 13 - // Factor = Term (*) [")"] - // Factor = Term (*) ["*"] - // Factor = Term (*) ["+"] - // 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);) - // - pub fn __state13>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { - Some(Tok::Div(..)) => { - 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(..)) => { - 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))); - } - _ => { - return Err(lookahead); + return Err(__lookahead); } } + return Ok(__result); } // State 14 @@ -926,122 +926,54 @@ mod __parse__Expr { // "Num" -> Shift(S12) // "(" -> Shift(S14) // + // Factor -> S11 + // Term -> S10 // Expr -> S24 - // Factor -> S10 - // Term -> S13 pub fn __state14>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, + mut __lookahead: Option, + __tokens: &mut TOKENS, + __sym0: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(Tok::Num(__tok0)) => { - let mut sym1 = &mut Some((__tok0)); - let lookahead = tokens.next(); - result = try!(__state12(lookahead, tokens, sym1)); + let mut __sym1 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state12(__lookahead, __tokens, __sym1)); } Some(__tok @ Tok::LParen(..)) => { - let mut sym1 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state14(lookahead, tokens, sym1)); + let mut __sym1 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state14(__lookahead, __tokens, __sym1)); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - while sym0.is_some() { - let (lookahead, nt) = result; - match nt { - __Nonterminal::Expr(nt) => { - let sym1 = &mut Some(nt); - result = try!(__state24(lookahead, tokens, sym0, sym1)); + while __sym0.is_some() { + let (__lookahead, __nt) = __result; + match __nt { + __Nonterminal::Factor(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state11(__lookahead, __tokens, __sym1)); } - __Nonterminal::Factor(nt) => { - let sym1 = &mut Some(nt); - result = try!(__state10(lookahead, tokens, sym1)); + __Nonterminal::Term(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state10(__lookahead, __tokens, __sym1)); } - __Nonterminal::Term(nt) => { - let sym1 = &mut Some(nt); - result = try!(__state13(lookahead, tokens, sym1)); + __Nonterminal::Expr(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state24(__lookahead, __tokens, __sym0, __sym1)); } _ => { - return Ok((lookahead, nt)); + return Ok((__lookahead, __nt)); } } } - return Ok(result); + return Ok(__result); } // State 15 - // Expr = Expr "+" Factor (*) [EOF] - // Expr = Expr "+" Factor (*) ["+"] - // Expr = Expr "+" Factor (*) ["-"] - // Factor = Factor (*) "*" Term [EOF] - // Factor = Factor (*) "*" Term ["*"] - // Factor = Factor (*) "*" Term ["+"] - // Factor = Factor (*) "*" Term ["-"] - // Factor = Factor (*) "*" Term ["/"] - // Factor = Factor (*) "/" Term [EOF] - // Factor = Factor (*) "/" Term ["*"] - // Factor = Factor (*) "/" Term ["+"] - // Factor = Factor (*) "/" Term ["-"] - // Factor = Factor (*) "/" Term ["/"] - // - // "*" -> Shift(S8) - // "-" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) - // "+" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) - // EOF -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) - // "/" -> Shift(S9) - // - pub fn __state15>( - 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 @ Tok::Times(..)) => { - let mut sym3 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state8(lookahead, tokens, sym2, sym3)); - } - Some(__tok @ Tok::Div(..)) => { - let mut sym3 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state9(lookahead, tokens, sym2, sym3)); - } - 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::Plus(..)) => { - 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))); - } - 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::Expr(nt))); - } - _ => { - return Err(lookahead); - } - } - return Ok(result); - } - - // State 16 // Expr = Expr "-" Factor (*) [EOF] // Expr = Expr "-" Factor (*) ["+"] // Expr = Expr "-" Factor (*) ["-"] @@ -1056,60 +988,191 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["-"] // Factor = Factor (*) "/" Term ["/"] // - // "/" -> Shift(S9) - // "*" -> Shift(S8) - // EOF -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) // "+" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) + // "*" -> Shift(S9) + // EOF -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) // "-" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) + // "/" -> Shift(S8) // - pub fn __state16>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, - sym2: &mut Option, + pub fn __state15>( + 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 @ Tok::Div(..)) => { - let mut sym3 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state9(lookahead, tokens, sym2, sym3)); - } + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(__tok @ Tok::Times(..)) => { - let mut sym3 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state8(lookahead, tokens, sym2, sym3)); + let mut __sym3 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state9(__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 @ Tok::Div(..)) => { + let mut __sym3 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state8(__lookahead, __tokens, __sym2, __sym3)); } Some(Tok::Plus(..)) => { - 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))); + 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))); + } + 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::Minus(..)) => { - 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))); + 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); + return Err(__lookahead); } } - return Ok(result); + return Ok(__result); + } + + // State 16 + // Expr = Expr "+" Factor (*) [EOF] + // Expr = Expr "+" Factor (*) ["+"] + // Expr = Expr "+" Factor (*) ["-"] + // Factor = Factor (*) "*" Term [EOF] + // Factor = Factor (*) "*" Term ["*"] + // Factor = Factor (*) "*" Term ["+"] + // Factor = Factor (*) "*" Term ["-"] + // Factor = Factor (*) "*" Term ["/"] + // Factor = Factor (*) "/" Term [EOF] + // Factor = Factor (*) "/" Term ["*"] + // Factor = Factor (*) "/" Term ["+"] + // Factor = Factor (*) "/" Term ["-"] + // Factor = Factor (*) "/" Term ["/"] + // + // "-" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) + // "*" -> Shift(S9) + // "+" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) + // EOF -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) + // "/" -> Shift(S8) + // + pub fn __state16>( + 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 @ Tok::Times(..)) => { + let mut __sym3 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state9(__lookahead, __tokens, __sym2, __sym3)); + } + Some(__tok @ Tok::Div(..)) => { + let mut __sym3 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state8(__lookahead, __tokens, __sym2, __sym3)); + } + 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::Plus(..)) => { + 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))); + } + 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::Expr(__nt))); + } + _ => { + return Err(__lookahead); + } + } + return Ok(__result); } // State 17 + // 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 __state17>( + 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::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))); + } + 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 18 // Factor = Factor "*" Term (*) [EOF] // Factor = Factor "*" Term (*) ["*"] // Factor = Factor "*" Term (*) ["+"] @@ -1118,182 +1181,61 @@ mod __parse__Expr { // // 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);) // "*" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) // - pub fn __state17>( - 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::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::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 18 - // 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);) - // EOF -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) - // "/" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);) - // pub fn __state18>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, - sym2: &mut Option, + 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))); + 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::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))); - } - 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))); + 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::__action5(sym0, sym1, sym2); - return Ok((lookahead, __Nonterminal::Factor(nt))); + 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::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); + return Err(__lookahead); } } } // 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(S12) - // "(" -> Shift(S14) - // - // Term -> S25 - pub fn __state19>( - 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!(__state12(lookahead, tokens, sym2)); - } - Some(__tok @ Tok::LParen(..)) => { - let mut sym2 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state14(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 20 // Factor = Factor "*" (*) Term [")"] // Factor = Factor "*" (*) Term ["*"] // Factor = Factor "*" (*) Term ["+"] @@ -1313,45 +1255,166 @@ mod __parse__Expr { // "Num" -> Shift(S12) // "(" -> Shift(S14) // - // Term -> S26 - pub fn __state20>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, + // Term -> S25 + pub fn __state19>( + mut __lookahead: Option, + __tokens: &mut TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(Tok::Num(__tok0)) => { - let mut sym2 = &mut Some((__tok0)); - let lookahead = tokens.next(); - result = try!(__state12(lookahead, tokens, sym2)); + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state12(__lookahead, __tokens, __sym2)); } Some(__tok @ Tok::LParen(..)) => { - let mut sym2 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state14(lookahead, tokens, sym2)); + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state14(__lookahead, __tokens, __sym2)); } _ => { - return Err(lookahead); + 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)); + 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((__lookahead, __nt)); } } } - return Ok(result); + 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(S14) + // "Num" -> Shift(S12) + // + // Term -> S26 + pub fn __state20>( + 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!(__state14(__lookahead, __tokens, __sym2)); + } + Some(Tok::Num(__tok0)) => { + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state12(__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 21 + // Term = "(" Expr ")" (*) [EOF] + // Term = "(" Expr ")" (*) ["*"] + // Term = "(" Expr ")" (*) ["+"] + // Term = "(" Expr ")" (*) ["-"] + // Term = "(" Expr ")" (*) ["/"] + // + // "*" -> 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);) + // + pub fn __state21>( + 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::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::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))); + } + 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))); + } + 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(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action8(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::Term(__nt))); + } + _ => { + return Err(__lookahead); + } + } + } + + // State 22 // Expr = Expr "-" (*) Factor [")"] // Expr = Expr "-" (*) Factor ["+"] // Expr = Expr "-" (*) Factor ["-"] @@ -1385,109 +1448,46 @@ mod __parse__Expr { // "Num" -> Shift(S12) // // Factor -> S27 - // Term -> S13 - pub fn __state21>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, + // Term -> S10 + pub fn __state22>( + mut __lookahead: Option, + __tokens: &mut TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(__tok @ Tok::LParen(..)) => { - let mut sym2 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state14(lookahead, tokens, sym2)); + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state14(__lookahead, __tokens, __sym2)); } Some(Tok::Num(__tok0)) => { - let mut sym2 = &mut Some((__tok0)); - let lookahead = tokens.next(); - result = try!(__state12(lookahead, tokens, sym2)); + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state12(__lookahead, __tokens, __sym2)); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - 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)); + 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!(__state13(lookahead, tokens, sym2)); + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state10(__lookahead, __tokens, __sym2)); } _ => { - return Ok((lookahead, nt)); + return Ok((__lookahead, __nt)); } } } - return Ok(result); - } - - // State 22 - // 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);) - // - pub fn __state22>( - 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::__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::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))); - } - 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))); - } - 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))); - } - _ => { - return Err(lookahead); - } - } + return Ok(__result); } // State 23 @@ -1520,50 +1520,50 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "Num" -> Shift(S12) // "(" -> Shift(S14) + // "Num" -> Shift(S12) // + // Term -> S10 // Factor -> S28 - // Term -> S13 pub fn __state23>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, + 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!(__state12(lookahead, tokens, sym2)); - } + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(__tok @ Tok::LParen(..)) => { - let mut sym2 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state14(lookahead, tokens, sym2)); + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state14(__lookahead, __tokens, __sym2)); + } + Some(Tok::Num(__tok0)) => { + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state12(__lookahead, __tokens, __sym2)); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - while sym1.is_some() { - let (lookahead, nt) = result; - match nt { - __Nonterminal::Factor(nt) => { - let sym2 = &mut Some(nt); - result = try!(__state28(lookahead, tokens, sym0, sym1, sym2)); + while __sym1.is_some() { + let (__lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state10(__lookahead, __tokens, __sym2)); } - __Nonterminal::Term(nt) => { - let sym2 = &mut Some(nt); - result = try!(__state13(lookahead, tokens, sym2)); + __Nonterminal::Factor(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state28(__lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { - return Ok((lookahead, nt)); + return Ok((__lookahead, __nt)); } } } - return Ok(result); + return Ok(__result); } // State 24 @@ -1579,162 +1579,162 @@ mod __parse__Expr { // Term = "(" Expr (*) ")" ["-"] // Term = "(" Expr (*) ")" ["/"] // - // ")" -> Shift(S29) // "+" -> Shift(S23) - // "-" -> Shift(S21) + // ")" -> Shift(S29) + // "-" -> Shift(S22) // pub fn __state24>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, + 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!(__state29(lookahead, tokens, sym0, sym1, sym2)); - } + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(__tok @ Tok::Plus(..)) => { - let mut sym2 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state23(lookahead, tokens, sym1, sym2)); + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state23(__lookahead, __tokens, __sym1, __sym2)); + } + Some(__tok @ Tok::RParen(..)) => { + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state29(__lookahead, __tokens, __sym0, __sym1, __sym2)); } Some(__tok @ Tok::Minus(..)) => { - let mut sym2 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state21(lookahead, tokens, sym1, sym2)); + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state22(__lookahead, __tokens, __sym1, __sym2)); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - return Ok(result); + return Ok(__result); } // State 25 - // 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 __state25>( - 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::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::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::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 26 // 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);) + // "*" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) // "+" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);) // - pub fn __state26>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, - sym2: &mut Option, + pub fn __state25>( + 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))); - } + 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::__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))); + 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))); + 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::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::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))); + 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); + 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>( + 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::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::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::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); } } } @@ -1754,57 +1754,57 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["-"] // Factor = Factor (*) "/" Term ["/"] // - // "-" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) - // ")" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) // "+" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) - // "/" -> Shift(S19) - // "*" -> Shift(S20) + // "*" -> Shift(S19) + // "/" -> Shift(S20) + // ")" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) + // "-" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);) // pub fn __state27>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, - sym2: &mut Option, + 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 @ Tok::Div(..)) => { - let mut sym3 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state19(lookahead, tokens, sym2, sym3)); - } + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(__tok @ Tok::Times(..)) => { - let mut sym3 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state20(lookahead, tokens, sym2, sym3)); + let mut __sym3 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state19(__lookahead, __tokens, __sym2, __sym3)); } - Some(Tok::Minus(..)) => { - 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::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 @ Tok::Div(..)) => { + let mut __sym3 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state20(__lookahead, __tokens, __sym2, __sym3)); } Some(Tok::Plus(..)) => { - 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))); + 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::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::Minus(..)) => { + 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); + return Err(__lookahead); } } - return Ok(result); + return Ok(__result); } // State 28 @@ -1822,57 +1822,57 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["-"] // Factor = Factor (*) "/" Term ["/"] // - // "/" -> Shift(S19) + // "/" -> Shift(S20) // ")" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) - // "*" -> Shift(S20) - // "+" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) + // "*" -> Shift(S19) // "-" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) + // "+" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);) // pub fn __state28>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, - sym2: &mut Option, + 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 { + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(__tok @ Tok::Div(..)) => { - let mut sym3 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state19(lookahead, tokens, sym2, sym3)); + let mut __sym3 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state20(__lookahead, __tokens, __sym2, __sym3)); } Some(__tok @ Tok::Times(..)) => { - let mut sym3 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state20(lookahead, tokens, sym2, sym3)); + let mut __sym3 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state19(__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::__action2(sym0, sym1, sym2); - return Ok((lookahead, __Nonterminal::Expr(nt))); - } - Some(Tok::Plus(..)) => { - 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))); + 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(..)) => { - 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))); + 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::Plus(..)) => { + 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))); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - return Ok(result); + return Ok(__result); } // State 29 @@ -1884,56 +1884,56 @@ mod __parse__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);) // pub fn __state29>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, - sym2: &mut Option, + 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 { + 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::__action8(sym0, sym1, sym2); - return Ok((lookahead, __Nonterminal::Term(nt))); + 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::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::RParen(..)) => { - 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))); + 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(); - let sym2 = sym2.take().unwrap(); - let nt = super::__action8(sym0, sym1, sym2); - return Ok((lookahead, __Nonterminal::Term(nt))); + 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(); + 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))); + 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); + return Err(__lookahead); } } } diff --git a/lalrpop-test/src/sub.rs b/lalrpop-test/src/sub.rs index d89d51c..0d7c9f7 100644 --- a/lalrpop-test/src/sub.rs +++ b/lalrpop-test/src/sub.rs @@ -19,10 +19,10 @@ mod __parse__S { use util::tok::Tok; pub enum __Nonterminal { - S(i32), - E(i32), __S(i32), T(i32), + E(i32), + S(i32), } // State 0 @@ -37,110 +37,85 @@ mod __parse__S { // T = (*) "Num" ["-"] // __S = (*) S [EOF] // - // "(" -> Shift(S3) - // "Num" -> Shift(S4) + // "(" -> Shift(S2) + // "Num" -> Shift(S1) // - // E -> S2 - // S -> S1 - // T -> S5 + // S -> S4 + // E -> S5 + // T -> S3 pub fn __state0>( - mut lookahead: Option, - tokens: &mut TOKENS, + mut __lookahead: Option, + __tokens: &mut TOKENS, ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(__tok @ Tok::LParen(..)) => { - let mut sym0 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state3(lookahead, tokens, sym0)); + let mut __sym0 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state2(__lookahead, __tokens, __sym0)); } Some(Tok::Num(__tok0)) => { - let mut sym0 = &mut Some((__tok0)); - let lookahead = tokens.next(); - result = try!(__state4(lookahead, tokens, sym0)); + let mut __sym0 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state1(__lookahead, __tokens, __sym0)); } _ => { - return Err(lookahead); + return Err(__lookahead); } } loop { - let (lookahead, nt) = result; - match nt { - __Nonterminal::E(nt) => { - let sym0 = &mut Some(nt); - result = try!(__state2(lookahead, tokens, sym0)); + let (__lookahead, __nt) = __result; + match __nt { + __Nonterminal::S(__nt) => { + let __sym0 = &mut Some(__nt); + __result = try!(__state4(__lookahead, __tokens, __sym0)); } - __Nonterminal::S(nt) => { - let sym0 = &mut Some(nt); - result = try!(__state1(lookahead, tokens, sym0)); + __Nonterminal::E(__nt) => { + let __sym0 = &mut Some(__nt); + __result = try!(__state5(__lookahead, __tokens, __sym0)); } - __Nonterminal::T(nt) => { - let sym0 = &mut Some(nt); - result = try!(__state5(lookahead, tokens, sym0)); + __Nonterminal::T(__nt) => { + let __sym0 = &mut Some(__nt); + __result = try!(__state3(__lookahead, __tokens, __sym0)); } _ => { - return Ok((lookahead, nt)); + return Ok((__lookahead, __nt)); } } } } // State 1 - // __S = S (*) [EOF] + // T = "Num" (*) [EOF] + // T = "Num" (*) ["-"] // - // EOF -> Reduce(__S = S => ActionFn(0);) + // "-" -> Reduce(T = "Num" => ActionFn(4);) + // EOF -> Reduce(T = "Num" => ActionFn(4);) // pub fn __state1>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, + mut __lookahead: Option, + __tokens: &mut TOKENS, + __sym0: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { + 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::__action0(sym0); - return Ok((lookahead, __Nonterminal::__S(nt))); + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action4(__sym0); + return Ok((__lookahead, __Nonterminal::T(__nt))); } _ => { - return Err(lookahead); + return Err(__lookahead); } } } // State 2 - // E = E (*) "-" T [EOF] - // E = E (*) "-" T ["-"] - // S = E (*) [EOF] - // - // EOF -> Reduce(S = E => ActionFn(1);) - // "-" -> Shift(S6) - // - pub fn __state2>( - 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!(__state6(lookahead, tokens, sym0, sym1)); - } - None => { - let sym0 = sym0.take().unwrap(); - let nt = super::__action1(sym0); - return Ok((lookahead, __Nonterminal::S(nt))); - } - _ => { - return Err(lookahead); - } - } - return Ok(result); - } - - // State 3 // E = (*) E "-" T [")"] // E = (*) E "-" T ["-"] // E = (*) T [")"] @@ -152,225 +127,137 @@ mod __parse__S { // T = (*) "Num" [")"] // T = (*) "Num" ["-"] // - // "Num" -> Shift(S7) - // "(" -> Shift(S9) + // "Num" -> Shift(S8) + // "(" -> Shift(S6) // - // T -> S10 - // E -> S8 - pub fn __state3>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, + // E -> S9 + // T -> S7 + pub fn __state2>( + mut __lookahead: Option, + __tokens: &mut TOKENS, + __sym0: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(Tok::Num(__tok0)) => { - let mut sym1 = &mut Some((__tok0)); - let lookahead = tokens.next(); - result = try!(__state7(lookahead, tokens, sym1)); + 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!(__state9(lookahead, tokens, sym1)); + let mut __sym1 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state6(__lookahead, __tokens, __sym1)); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - while sym0.is_some() { - let (lookahead, nt) = result; - match nt { - __Nonterminal::T(nt) => { - let sym1 = &mut Some(nt); - result = try!(__state10(lookahead, tokens, sym1)); + while __sym0.is_some() { + let (__lookahead, __nt) = __result; + match __nt { + __Nonterminal::E(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state9(__lookahead, __tokens, __sym0, __sym1)); } - __Nonterminal::E(nt) => { - let sym1 = &mut Some(nt); - result = try!(__state8(lookahead, tokens, sym0, sym1)); + __Nonterminal::T(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state7(__lookahead, __tokens, __sym1)); } _ => { - return Ok((lookahead, nt)); + return Ok((__lookahead, __nt)); } } } - return Ok(result); + return Ok(__result); + } + + // State 3 + // E = T (*) [EOF] + // E = T (*) ["-"] + // + // "-" -> Reduce(E = T => ActionFn(3);) + // EOF -> Reduce(E = T => ActionFn(3);) + // + pub fn __state3>( + 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::__action3(__sym0); + return Ok((__lookahead, __Nonterminal::E(__nt))); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(__sym0); + return Ok((__lookahead, __Nonterminal::E(__nt))); + } + _ => { + return Err(__lookahead); + } + } } // State 4 - // T = "Num" (*) [EOF] - // T = "Num" (*) ["-"] + // __S = S (*) [EOF] // - // "-" -> Reduce(T = "Num" => ActionFn(4);) - // EOF -> Reduce(T = "Num" => ActionFn(4);) + // EOF -> Reduce(__S = S => ActionFn(0);) // pub fn __state4>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, + 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))); - } + let mut __result: (Option, __Nonterminal); + match __lookahead { None => { - let sym0 = sym0.take().unwrap(); - let nt = super::__action4(sym0); - return Ok((lookahead, __Nonterminal::T(nt))); + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action0(__sym0); + return Ok((__lookahead, __Nonterminal::__S(__nt))); } _ => { - return Err(lookahead); + return Err(__lookahead); } } } // State 5 - // E = T (*) [EOF] - // E = T (*) ["-"] + // E = E (*) "-" T [EOF] + // E = E (*) "-" T ["-"] + // S = E (*) [EOF] // - // EOF -> Reduce(E = T => ActionFn(3);) - // "-" -> Reduce(E = T => ActionFn(3);) + // EOF -> Reduce(S = E => ActionFn(1);) + // "-" -> Shift(S10) // pub fn __state5>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, + 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))); + let mut __result: (Option, __Nonterminal); + match __lookahead { + Some(__tok @ Tok::Minus(..)) => { + let mut __sym1 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state10(__lookahead, __tokens, __sym0, __sym1)); } - Some(Tok::Minus(..)) => { - let sym0 = sym0.take().unwrap(); - let nt = super::__action3(sym0); - return Ok((lookahead, __Nonterminal::E(nt))); + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action1(__sym0); + return Ok((__lookahead, __Nonterminal::S(__nt))); } _ => { - return Err(lookahead); + return Err(__lookahead); } } + return Ok(__result); } // State 6 - // E = E "-" (*) T [EOF] - // E = E "-" (*) T ["-"] - // T = (*) "(" E ")" [EOF] - // T = (*) "(" E ")" ["-"] - // T = (*) "Num" [EOF] - // T = (*) "Num" ["-"] - // - // "Num" -> Shift(S4) - // "(" -> Shift(S3) - // - // T -> S11 - pub fn __state6>( - 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!(__state4(lookahead, tokens, sym2)); - } - Some(__tok @ Tok::LParen(..)) => { - let mut sym2 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state3(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)); - } - } - } - return Ok(result); - } - - // State 7 - // T = "Num" (*) [")"] - // T = "Num" (*) ["-"] - // - // ")" -> Reduce(T = "Num" => ActionFn(4);) - // "-" -> Reduce(T = "Num" => ActionFn(4);) - // - pub fn __state7>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { - Some(Tok::RParen(..)) => { - let sym0 = sym0.take().unwrap(); - let nt = super::__action4(sym0); - return Ok((lookahead, __Nonterminal::T(nt))); - } - Some(Tok::Minus(..)) => { - let sym0 = sym0.take().unwrap(); - let nt = super::__action4(sym0); - return Ok((lookahead, __Nonterminal::T(nt))); - } - _ => { - return Err(lookahead); - } - } - } - - // State 8 - // E = E (*) "-" T [")"] - // E = E (*) "-" T ["-"] - // T = "(" E (*) ")" [EOF] - // T = "(" E (*) ")" ["-"] - // - // ")" -> Shift(S13) - // "-" -> Shift(S12) - // - pub fn __state8>( - 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!(__state13(lookahead, tokens, sym0, sym1, sym2)); - } - Some(__tok @ Tok::Minus(..)) => { - let mut sym2 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state12(lookahead, tokens, sym1, sym2)); - } - _ => { - return Err(lookahead); - } - } - return Ok(result); - } - - // State 9 // E = (*) E "-" T [")"] // E = (*) E "-" T ["-"] // E = (*) T [")"] @@ -382,117 +269,228 @@ mod __parse__S { // T = (*) "Num" [")"] // T = (*) "Num" ["-"] // - // "(" -> Shift(S9) - // "Num" -> Shift(S7) + // "(" -> Shift(S6) + // "Num" -> Shift(S8) // - // T -> S10 - // E -> S14 - pub fn __state9>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, + // T -> S7 + // E -> S11 + pub fn __state6>( + mut __lookahead: Option, + __tokens: &mut TOKENS, + __sym0: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(__tok @ Tok::LParen(..)) => { - let mut sym1 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state9(lookahead, tokens, sym1)); + let mut __sym1 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state6(__lookahead, __tokens, __sym1)); } Some(Tok::Num(__tok0)) => { - let mut sym1 = &mut Some((__tok0)); - let lookahead = tokens.next(); - result = try!(__state7(lookahead, tokens, sym1)); + let mut __sym1 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state8(__lookahead, __tokens, __sym1)); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - while sym0.is_some() { - let (lookahead, nt) = result; - match nt { - __Nonterminal::T(nt) => { - let sym1 = &mut Some(nt); - result = try!(__state10(lookahead, tokens, sym1)); + 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!(__state14(lookahead, tokens, sym0, sym1)); + __Nonterminal::E(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state11(__lookahead, __tokens, __sym0, __sym1)); } _ => { - return Ok((lookahead, nt)); + return Ok((__lookahead, __nt)); } } } - return Ok(result); + return Ok(__result); } - // State 10 + // State 7 // E = T (*) [")"] // E = T (*) ["-"] // // "-" -> Reduce(E = T => ActionFn(3);) // ")" -> Reduce(E = T => ActionFn(3);) // - pub fn __state10>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, + pub fn __state7>( + mut __lookahead: Option, + __tokens: &mut TOKENS, + __sym0: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { + let mut __result: (Option, __Nonterminal); + match __lookahead { Some(Tok::Minus(..)) => { - let sym0 = sym0.take().unwrap(); - let nt = super::__action3(sym0); - return Ok((lookahead, __Nonterminal::E(nt))); + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(__sym0); + return Ok((__lookahead, __Nonterminal::E(__nt))); } Some(Tok::RParen(..)) => { - let sym0 = sym0.take().unwrap(); - let nt = super::__action3(sym0); - return Ok((lookahead, __Nonterminal::E(nt))); + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(__sym0); + return Ok((__lookahead, __Nonterminal::E(__nt))); } _ => { - return Err(lookahead); + return Err(__lookahead); } } } - // State 11 - // E = E "-" T (*) [EOF] - // E = E "-" T (*) ["-"] + // State 8 + // T = "Num" (*) [")"] + // T = "Num" (*) ["-"] // - // EOF -> Reduce(E = E, "-", T => ActionFn(2);) - // "-" -> Reduce(E = E, "-", T => ActionFn(2);) + // ")" -> Reduce(T = "Num" => ActionFn(4);) + // "-" -> Reduce(T = "Num" => ActionFn(4);) // - pub fn __state11>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, - sym2: &mut Option, + pub fn __state8>( + 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 sym1 = sym1.take().unwrap(); - let sym2 = sym2.take().unwrap(); - let nt = super::__action2(sym0, sym1, sym2); - return Ok((lookahead, __Nonterminal::E(nt))); + let mut __result: (Option, __Nonterminal); + match __lookahead { + Some(Tok::RParen(..)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action4(__sym0); + return Ok((__lookahead, __Nonterminal::T(__nt))); } Some(Tok::Minus(..)) => { - let sym0 = sym0.take().unwrap(); - let sym1 = sym1.take().unwrap(); - let sym2 = sym2.take().unwrap(); - let nt = super::__action2(sym0, sym1, sym2); - return Ok((lookahead, __Nonterminal::E(nt))); + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action4(__sym0); + return Ok((__lookahead, __Nonterminal::T(__nt))); } _ => { - return Err(lookahead); + return Err(__lookahead); } } } + // State 9 + // E = E (*) "-" T [")"] + // E = E (*) "-" T ["-"] + // T = "(" E (*) ")" [EOF] + // T = "(" E (*) ")" ["-"] + // + // ")" -> Shift(S13) + // "-" -> Shift(S12) + // + pub fn __state9>( + 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!(__state13(__lookahead, __tokens, __sym0, __sym1, __sym2)); + } + Some(__tok @ Tok::Minus(..)) => { + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state12(__lookahead, __tokens, __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" ["-"] + // + // "Num" -> Shift(S1) + // "(" -> Shift(S2) + // + // T -> S14 + pub fn __state10>( + 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!(__state1(__lookahead, __tokens, __sym2)); + } + Some(__tok @ Tok::LParen(..)) => { + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state2(__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!(__state14(__lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookahead, __nt)); + } + } + } + return Ok(__result); + } + + // State 11 + // E = E (*) "-" T [")"] + // E = E (*) "-" T ["-"] + // T = "(" E (*) ")" [")"] + // T = "(" E (*) ")" ["-"] + // + // "-" -> Shift(S12) + // ")" -> Shift(S15) + // + pub fn __state11>( + 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!(__state15(__lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Err(__lookahead); + } + } + return Ok(__result); + } + // State 12 // E = E "-" (*) T [")"] // E = E "-" (*) T ["-"] @@ -501,185 +499,187 @@ mod __parse__S { // T = (*) "Num" [")"] // T = (*) "Num" ["-"] // - // "Num" -> Shift(S7) - // "(" -> Shift(S9) + // "Num" -> Shift(S8) + // "(" -> Shift(S6) // - // T -> S15 + // T -> S16 pub fn __state12>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, + mut __lookahead: Option, + __tokens: &mut TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, ) -> Result<(Option, __Nonterminal), Option> { - let mut result: (Option, __Nonterminal); - match lookahead { + 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)); + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = __tokens.next(); + __result = try!(__state8(__lookahead, __tokens, __sym2)); } Some(__tok @ Tok::LParen(..)) => { - let mut sym2 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state9(lookahead, tokens, sym2)); + let mut __sym2 = &mut Some(__tok); + let __lookahead = __tokens.next(); + __result = try!(__state6(__lookahead, __tokens, __sym2)); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - while sym1.is_some() { - let (lookahead, nt) = result; - match nt { - __Nonterminal::T(nt) => { - let sym2 = &mut Some(nt); - result = try!(__state15(lookahead, tokens, sym0, sym1, sym2)); + while __sym1.is_some() { + let (__lookahead, __nt) = __result; + match __nt { + __Nonterminal::T(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state16(__lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { - return Ok((lookahead, nt)); + return Ok((__lookahead, __nt)); } } } - return Ok(result); + return Ok(__result); } // State 13 // T = "(" E ")" (*) [EOF] // T = "(" E ")" (*) ["-"] // - // EOF -> Reduce(T = "(", E, ")" => ActionFn(5);) // "-" -> Reduce(T = "(", E, ")" => ActionFn(5);) + // EOF -> Reduce(T = "(", E, ")" => ActionFn(5);) // pub fn __state13>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, - sym2: &mut Option, + 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))); - } + 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::T(nt))); + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action5(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::T(__nt))); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action5(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::T(__nt))); } _ => { - return Err(lookahead); + return Err(__lookahead); } } } // State 14 - // E = E (*) "-" T [")"] - // E = E (*) "-" T ["-"] - // T = "(" E (*) ")" [")"] - // T = "(" E (*) ")" ["-"] + // E = E "-" T (*) [EOF] + // E = E "-" T (*) ["-"] // - // ")" -> Shift(S16) - // "-" -> Shift(S12) + // EOF -> Reduce(E = E, "-", T => ActionFn(2);) + // "-" -> Reduce(E = E, "-", T => ActionFn(2);) // pub fn __state14>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, + 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 @ Tok::RParen(..)) => { - let mut sym2 = &mut Some(__tok); - let lookahead = tokens.next(); - result = try!(__state16(lookahead, tokens, sym0, sym1, sym2)); + 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::__action2(__sym0, __sym1, __sym2); + return Ok((__lookahead, __Nonterminal::E(__nt))); } - 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))); } _ => { - return Err(lookahead); + return Err(__lookahead); } } - return Ok(result); } // State 15 + // T = "(" E ")" (*) [")"] + // T = "(" E ")" (*) ["-"] + // + // ")" -> Reduce(T = "(", E, ")" => ActionFn(5);) + // "-" -> Reduce(T = "(", E, ")" => ActionFn(5);) + // + pub fn __state15>( + 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 (*) ["-"] // // "-" -> Reduce(E = E, "-", T => ActionFn(2);) // ")" -> Reduce(E = E, "-", T => ActionFn(2);) // - pub fn __state15>( - 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::__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))); - } - _ => { - return Err(lookahead); - } - } - } - - // State 16 - // T = "(" E ")" (*) [")"] - // T = "(" E ")" (*) ["-"] - // - // "-" -> Reduce(T = "(", E, ")" => ActionFn(5);) - // ")" -> Reduce(T = "(", E, ")" => ActionFn(5);) - // pub fn __state16>( - mut lookahead: Option, - tokens: &mut TOKENS, - sym0: &mut Option, - sym1: &mut Option, - sym2: &mut Option, + 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 { + 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::T(nt))); + 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::__action5(sym0, sym1, sym2); - return Ok((lookahead, __Nonterminal::T(nt))); + 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 Err(__lookahead); } } } diff --git a/lalrpop/src/lr1/ascent.rs b/lalrpop/src/lr1/ascent.rs index 7521c0e..e41bded 100644 --- a/lalrpop/src/lr1/ascent.rs +++ b/lalrpop/src/lr1/ascent.rs @@ -151,20 +151,20 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { rust!(self.out, "pub fn {}state{}>(", self.prefix, this_index.0, terminal_type); - rust!(self.out, "mut lookahead: Option<{}>,", - terminal_type); - rust!(self.out, "tokens: &mut TOKENS,"); + rust!(self.out, "mut {}lookahead: Option<{}>,", + self.prefix, terminal_type); + rust!(self.out, "{}tokens: &mut TOKENS,", self.prefix); for i in 0..this_prefix.len() { - rust!(self.out, "sym{}: &mut Option<{}>,", - i, this_prefix[i].ty(&self.types)); + rust!(self.out, "{}sym{}: &mut Option<{}>,", + self.prefix, i, this_prefix[i].ty(&self.types)); } rust!(self.out, ") -> Result<(Option<{}>, {}Nonterminal), Option<{}>> {{", terminal_type, self.prefix, terminal_type); - rust!(self.out, "let mut result: (Option<{}>, {}Nonterminal);", - terminal_type, self.prefix); + rust!(self.out, "let mut {}result: (Option<{}>, {}Nonterminal);", + self.prefix, terminal_type, self.prefix); - rust!(self.out, "match lookahead {{"); + rust!(self.out, "match {}lookahead {{", self.prefix); // first emit shifts: for (token, next_index) in @@ -172,19 +172,22 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { .filter_map(|(token, action)| action.shift().map(|n| (token, n))) { match *token { - Lookahead::Terminal(s) => - try!(self.consume_terminal(s, format!("sym{}", this_prefix.len()))), + Lookahead::Terminal(s) => { + let sym_name = format!("{}sym{}", self.prefix, this_prefix.len()); + try!(self.consume_terminal(s, sym_name)) + } Lookahead::EOF => unreachable!("should never have to shift EOF") } // "shift" the lookahead onto the "stack" by taking its address - rust!(self.out, "let lookahead = tokens.next();"); + rust!(self.out, "let {}lookahead = {}tokens.next();", + self.prefix, self.prefix); // transition to the new state let transition = self.transition(this_prefix, next_index, "lookahead", "tokens"); - rust!(self.out, "result = {};", transition); + rust!(self.out, "{}result = {};", self.prefix, transition); rust!(self.out, "}}"); fallthrough = true; @@ -213,20 +216,21 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { } // invoke the action code - rust!(self.out, "let nt = super::{}action{}({});", - self.grammar.prefix, + rust!(self.out, "let {}nt = super::{}action{}({});", + self.prefix, + self.prefix, production.action_fn.index(), Sep(", ", &transfer_syms)); // wrap up the result along with the (unused) lookahead if !transfer_syms.is_empty() { // if we popped anything off of the stack, then this frame is done - rust!(self.out, "return Ok((lookahead, {}Nonterminal::{}(nt)));", - self.prefix, production.nonterminal); + rust!(self.out, "return Ok(({}lookahead, {}Nonterminal::{}({}nt)));", + self.prefix, self.prefix, production.nonterminal, self.prefix); } else { // otherwise, pop back - rust!(self.out, "result = (lookahead, {}Nonterminal::{}(nt));", - self.prefix, production.nonterminal); + rust!(self.out, "result = ({}lookahead, {}Nonterminal::{}({}nt));", + self.prefix, self.prefix, production.nonterminal, self.prefix); fallthrough = true; } @@ -235,7 +239,7 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { // if we hit this, the next token is not recognized, so generate an error rust!(self.out, "_ => {{"); - rust!(self.out, "return Err(lookahead);"); + rust!(self.out, "return Err({}lookahead);", self.prefix); rust!(self.out, "}}"); rust!(self.out, "}}"); // match @@ -243,19 +247,21 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { // finally, emit gotos (if relevant) if fallthrough && !this_state.gotos.is_empty() { if this_prefix.len() > 0 { - rust!(self.out, "while sym{}.is_some() {{", this_prefix.len() - 1); + rust!(self.out, "while {}sym{}.is_some() {{", self.prefix, this_prefix.len() - 1); } else { rust!(self.out, "loop {{"); } - rust!(self.out, "let (lookahead, nt) = result;"); + rust!(self.out, "let ({}lookahead, {}nt) = {}result;", + self.prefix, self.prefix, self.prefix); - rust!(self.out, "match nt {{"); + rust!(self.out, "match {}nt {{", self.prefix); for (&nt, &next_index) in &this_state.gotos { - rust!(self.out, "{}Nonterminal::{}(nt) => {{", self.prefix, nt); - rust!(self.out, "let sym{} = &mut Some(nt);", this_prefix.len()); + rust!(self.out, "{}Nonterminal::{}({}nt) => {{", self.prefix, nt, self.prefix); + rust!(self.out, "let {}sym{} = &mut Some({}nt);", + self.prefix, this_prefix.len(), self.prefix); let transition = self.transition(this_prefix, next_index, "lookahead", "tokens"); - rust!(self.out, "result = {};", transition); + rust!(self.out, "{}result = {};", self.prefix, transition); rust!(self.out, "}}"); } @@ -263,7 +269,7 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { // indicates parse successfully completed, so just bail out if this_state.gotos.len() != self.grammar.productions.keys().len() { rust!(self.out, "_ => {{"); - rust!(self.out, "return Ok((lookahead, nt));"); + rust!(self.out, "return Ok(({}lookahead, {}nt));", self.prefix, self.prefix); rust!(self.out, "}}"); } @@ -272,10 +278,10 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { rust!(self.out, "}}"); // while/loop if this_prefix.len() > 0 { - rust!(self.out, "return Ok(result);"); + rust!(self.out, "return Ok({}result);", self.prefix); } } else if fallthrough { - rust!(self.out, "return Ok(result);"); + rust!(self.out, "return Ok({}result);", self.prefix); } rust!(self.out, "}}"); // fn @@ -284,7 +290,7 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { } fn pop_syms(&self, depth: usize, to_pop: usize) -> Vec { - (depth-to_pop .. depth).map(|i| format!("sym{}", i)).collect() + (depth-to_pop .. depth).map(|i| format!("{}sym{}", self.prefix, i)).collect() } fn transition(&self, @@ -306,8 +312,11 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { let transfer_syms = self.pop_syms(n, m); // invoke next state, transferring the top `m` tokens - format!("try!({}state{}({}, {}, {}))", - self.prefix, next_index.0, lookahead, tokens, Sep(", ", &transfer_syms)) + format!("try!({}state{}({}{}, {}{}, {}))", + self.prefix, next_index.0, + self.prefix, lookahead, + self.prefix, tokens, + Sep(", ", &transfer_syms)) } /// Emit a pattern that matches `id` but doesn't extract any data.