From 1bbfb9d76446f24c023ade42361cfca09dc79473 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 21 Jul 2015 12:45:38 -0400 Subject: [PATCH] let users specify fallible rules (and the error type) --- lalrpop-test/src/error.lalrpop | 28 + lalrpop-test/src/error.rs | 301 ++ lalrpop-test/src/expr.rs | 2513 +++++++------- lalrpop-test/src/expr_arena.rs | 4436 ++++++++++++------------- lalrpop-test/src/loc.rs | 294 +- lalrpop-test/src/main.rs | 14 + lalrpop-test/src/sub.rs | 776 +++-- lalrpop-test/src/use_super.rs | 93 +- lalrpop-test/src/util/mod.rs | 10 + lalrpop-util/src/lib.rs | 6 + lalrpop/src/build/mod.rs | 39 +- lalrpop/src/grammar/parse_tree.rs | 4 + lalrpop/src/grammar/repr.rs | 10 + lalrpop/src/lr1/ascent.rs | 35 +- lalrpop/src/normalize/lower/mod.rs | 13 +- lalrpop/src/normalize/tyinfer/mod.rs | 10 +- lalrpop/src/normalize/validate/mod.rs | 2 +- lalrpop/src/parser/mod.rs | 6 +- 18 files changed, 4437 insertions(+), 4153 deletions(-) create mode 100644 lalrpop-test/src/error.lalrpop create mode 100644 lalrpop-test/src/error.rs diff --git a/lalrpop-test/src/error.lalrpop b/lalrpop-test/src/error.lalrpop new file mode 100644 index 0000000..0315822 --- /dev/null +++ b/lalrpop-test/src/error.lalrpop @@ -0,0 +1,28 @@ +use util::tok::Tok; +use lalrpop_util::ParseError; + +grammar; + +extern token { + type Location = usize; + type Error = char; + + enum Tok { + "-" => Tok::Minus(..), + "+" => Tok::Plus(..) + } +} + +pub Items: Vec<(usize, usize)> = { + => vec![]; + + Items "+" =>? { + Err(ParseError::User { error: '+' }) + }; + + "-" =>? Ok(v); +}; + +Spanned: (usize, usize) = { + <@L> T <@R> => (<>); +}; diff --git a/lalrpop-test/src/error.rs b/lalrpop-test/src/error.rs new file mode 100644 index 0000000..05de9d9 --- /dev/null +++ b/lalrpop-test/src/error.rs @@ -0,0 +1,301 @@ +#![allow(unused_imports)] +use util::tok::Tok; +use lalrpop_util::ParseError; +extern crate lalrpop_util as __lalrpop_util; +use self::__lalrpop_util::ParseError as __ParseError; +#[allow(non_snake_case)] +pub fn parse_Items< + __TOKEN: __ToTriple, + __TOKENS: IntoIterator, +>( + __tokens: __TOKENS, +) -> Result, __ParseError> +{ + let mut __tokens = __tokens.into_iter(); + let mut __tokens = __tokens.map(|t| __ToTriple::to_triple(t)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + match try!(__parse__Items::__state0(None, __lookahead, &mut __tokens)) { + (_, Some(__lookahead), _) => { + Err(__ParseError::ExtraToken { token: __lookahead }) + } + (_, None, __parse__Items::__Nonterminal::____Items(__nt)) => { + Ok(__nt) + } + _ => unreachable!(), + } +} + +mod __parse__Items { + #![allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports)] + + use util::tok::Tok; + use lalrpop_util::ParseError; + extern crate lalrpop_util as __lalrpop_util; + use self::__lalrpop_util::ParseError as __ParseError; + use super::__ToTriple; + + pub enum __Nonterminal<> { + ____Items(Vec<(usize, usize)>), + Items(Vec<(usize, usize)>), + } + + // State 0 + // Items = (*) [EOF] + // Items = (*) ["+"] + // Items = (*) ["-"] + // Items = (*) Items "+" [EOF] + // Items = (*) Items "+" ["+"] + // Items = (*) Items "+" ["-"] + // Items = (*) Items "-" [EOF] + // Items = (*) Items "-" ["+"] + // Items = (*) Items "-" ["-"] + // __Items = (*) Items [EOF] + // + // EOF -> Reduce(Items = => Call(ActionFn(1));) + // "+" -> Reduce(Items = => Call(ActionFn(1));) + // "-" -> Reduce(Items = => Call(ActionFn(1));) + // + // Items -> S1 + pub fn __state0< + __TOKENS: Iterator>, + >( + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<>); + match __lookahead { + None => { + let __nt = super::__action1(); + __result = (__lookbehind, __lookahead, __Nonterminal::Items(__nt)); + } + Some((_, Tok::Plus(..), _)) => { + let __nt = super::__action1(); + __result = (__lookbehind, __lookahead, __Nonterminal::Items(__nt)); + } + Some((_, Tok::Minus(..), _)) => { + let __nt = super::__action1(); + __result = (__lookbehind, __lookahead, __Nonterminal::Items(__nt)); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + loop { + let (__lookbehind, __lookahead, __nt) = __result; + match __nt { + __Nonterminal::Items(__nt) => { + let __sym0 = &mut Some(__nt); + __result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0)); + } + _ => { + return Ok((__lookbehind, __lookahead, __nt)); + } + } + } + } + + // State 1 + // Items = Items (*) "+" [EOF] + // Items = Items (*) "+" ["+"] + // Items = Items (*) "+" ["-"] + // Items = Items (*) "-" [EOF] + // Items = Items (*) "-" ["+"] + // Items = Items (*) "-" ["-"] + // __Items = Items (*) [EOF] + // + // "-" -> Shift(S3) + // "+" -> Shift(S2) + // EOF -> Reduce(__Items = Items => Call(ActionFn(0));) + // + pub fn __state1< + __TOKENS: Iterator>, + >( + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option>, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<>); + match __lookahead { + Some((_, __tok @ Tok::Minus(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } + Some((_, __tok @ Tok::Plus(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action0(__sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::____Items(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + return Ok(__result); + } + + // State 2 + // Items = Items "+" (*) [EOF] + // Items = Items "+" (*) ["+"] + // Items = Items "+" (*) ["-"] + // + // "-" -> Reduce(Items = Items, "+" => TryCall(ActionFn(2));) + // "+" -> Reduce(Items = Items, "+" => TryCall(ActionFn(2));) + // EOF -> Reduce(Items = Items, "+" => TryCall(ActionFn(2));) + // + pub fn __state2< + __TOKENS: Iterator>, + >( + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option>, + __sym1: &mut Option, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<>); + match __lookahead { + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = try!(super::__action2(__sym0, __sym1)); + return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); + } + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = try!(super::__action2(__sym0, __sym1)); + return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = try!(super::__action2(__sym0, __sym1)); + return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 3 + // Items = Items "-" (*) [EOF] + // Items = Items "-" (*) ["+"] + // Items = Items "-" (*) ["-"] + // + // "-" -> Reduce(Items = Items, "-" => TryCall(ActionFn(3));) + // EOF -> Reduce(Items = Items, "-" => TryCall(ActionFn(3));) + // "+" -> Reduce(Items = Items, "-" => TryCall(ActionFn(3));) + // + pub fn __state3< + __TOKENS: Iterator>, + >( + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option>, + __sym1: &mut Option, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<>); + match __lookahead { + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = try!(super::__action3(__sym0, __sym1)); + return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = try!(super::__action3(__sym0, __sym1)); + return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); + } + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = try!(super::__action3(__sym0, __sym1)); + return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } +} + +pub fn __action0< +>( + __0: Vec<(usize, usize)>, +) -> Vec<(usize, usize)> +{ + (__0) +} + +pub fn __action1< +>( +) -> Vec<(usize, usize)> +{ + vec![] +} + +pub fn __action2< +>( + __0: Vec<(usize, usize)>, + __1: Tok, +) -> Result,__ParseError> +{ + { + Err(ParseError::User { error: '+' }) + } +} + +pub fn __action3< +>( + v: Vec<(usize, usize)>, + _: Tok, +) -> Result,__ParseError> +{ + Ok(v) +} + +pub trait __ToTriple { + type Error; + fn to_triple(value: Self) -> Result<(usize,Tok,usize),Self::Error>; +} + +impl __ToTriple for (usize, Tok, usize) { + type Error = char; + fn to_triple(value: Self) -> Result<(usize,Tok,usize),char> { + Ok(value) + } +} +impl __ToTriple for Result<(usize, Tok, usize),ERROR> { + type Error = ERROR; + fn to_triple(value: Self) -> Result<(usize,Tok,usize),ERROR> { + value + } +} diff --git a/lalrpop-test/src/expr.rs b/lalrpop-test/src/expr.rs index 58b4f32..509b2a0 100644 --- a/lalrpop-test/src/expr.rs +++ b/lalrpop-test/src/expr.rs @@ -5,13 +5,12 @@ extern crate lalrpop_util as __lalrpop_util; use self::__lalrpop_util::ParseError as __ParseError; #[allow(non_snake_case)] pub fn parse_Expr< - __ERROR, - __TOKEN: __ToTriple, + __TOKEN: __ToTriple, __TOKENS: IntoIterator, >( scale: i32, __tokens: __TOKENS, -) -> Result> +) -> Result> { let mut __tokens = __tokens.into_iter(); let mut __tokens = __tokens.map(|t| __ToTriple::to_triple(t)); @@ -36,10 +35,10 @@ mod __parse__Expr { use super::__ToTriple; pub enum __Nonterminal<> { - Term(i32), Expr(i32), - Factor(i32), + Term(i32), ____Expr(i32), + Factor(i32), } // State 0 @@ -79,35 +78,34 @@ mod __parse__Expr { // Term = (*) "Num" ["/"] // __Expr = (*) Expr [EOF] // - // "(" -> Shift(S2) - // "Num" -> Shift(S4) + // "Num" -> Shift(S3) + // "(" -> Shift(S5) // + // Expr -> S2 // Term -> S1 - // Expr -> S5 - // Factor -> S3 + // Factor -> S4 pub fn __state0< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, __tok @ Tok::LParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym0 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state2(scale, __lookbehind, __lookahead, __tokens, __sym0)); - } Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym0 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state4(scale, __lookbehind, __lookahead, __tokens, __sym0)); + __result = try!(__state3(scale, __lookbehind, __lookahead, __tokens, __sym0)); + } + Some((_, __tok @ Tok::LParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym0 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state5(scale, __lookbehind, __lookahead, __tokens, __sym0)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -119,17 +117,17 @@ mod __parse__Expr { loop { let (__lookbehind, __lookahead, __nt) = __result; match __nt { + __Nonterminal::Expr(__nt) => { + let __sym0 = &mut Some(__nt); + __result = try!(__state2(scale, __lookbehind, __lookahead, __tokens, __sym0)); + } __Nonterminal::Term(__nt) => { let __sym0 = &mut Some(__nt); __result = try!(__state1(scale, __lookbehind, __lookahead, __tokens, __sym0)); } - __Nonterminal::Expr(__nt) => { - let __sym0 = &mut Some(__nt); - __result = try!(__state5(scale, __lookbehind, __lookahead, __tokens, __sym0)); - } __Nonterminal::Factor(__nt) => { let __sym0 = &mut Some(__nt); - __result = try!(__state3(scale, __lookbehind, __lookahead, __tokens, __sym0)); + __result = try!(__state4(scale, __lookbehind, __lookahead, __tokens, __sym0)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -145,36 +143,35 @@ mod __parse__Expr { // Factor = Term (*) ["-"] // Factor = Term (*) ["/"] // - // EOF -> Reduce(Factor = Term => Call(ActionFn(6));) - // "/" -> Reduce(Factor = Term => Call(ActionFn(6));) // "*" -> Reduce(Factor = Term => Call(ActionFn(6));) - // "+" -> Reduce(Factor = Term => Call(ActionFn(6));) + // EOF -> Reduce(Factor = Term => Call(ActionFn(6));) // "-" -> Reduce(Factor = Term => Call(ActionFn(6));) + // "+" -> Reduce(Factor = Term => Call(ActionFn(6));) + // "/" -> Reduce(Factor = Term => Call(ActionFn(6));) // pub fn __state1< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { + Some((_, Tok::Times(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action6(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } None => { let __sym0 = __sym0.take().unwrap(); let __nt = super::__action6(scale, __sym0); return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } - Some((_, Tok::Div(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action6(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Times(..), _)) => { + Some((_, Tok::Minus(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __nt = super::__action6(scale, __sym0); return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); @@ -184,7 +181,7 @@ mod __parse__Expr { let __nt = super::__action6(scale, __sym0); return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } - Some((_, Tok::Minus(..), _)) => { + Some((_, Tok::Div(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __nt = super::__action6(scale, __sym0); return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); @@ -199,6 +196,187 @@ mod __parse__Expr { } // State 2 + // Expr = Expr (*) "+" Factor [EOF] + // Expr = Expr (*) "+" Factor ["+"] + // Expr = Expr (*) "+" Factor ["-"] + // Expr = Expr (*) "-" Factor [EOF] + // Expr = Expr (*) "-" Factor ["+"] + // Expr = Expr (*) "-" Factor ["-"] + // __Expr = Expr (*) [EOF] + // + // "+" -> Shift(S7) + // EOF -> Reduce(__Expr = Expr => Call(ActionFn(0));) + // "-" -> Shift(S6) + // + pub fn __state2< + __TOKENS: Iterator>, + >( + scale: i32, + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); + match __lookahead { + Some((_, __tok @ Tok::Plus(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state7(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } + Some((_, __tok @ Tok::Minus(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state6(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action0(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::____Expr(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + return Ok(__result); + } + + // State 3 + // Term = "Num" (*) [EOF] + // Term = "Num" (*) ["*"] + // Term = "Num" (*) ["+"] + // Term = "Num" (*) ["-"] + // Term = "Num" (*) ["/"] + // + // "+" -> Reduce(Term = "Num" => Call(ActionFn(7));) + // "/" -> Reduce(Term = "Num" => Call(ActionFn(7));) + // "*" -> Reduce(Term = "Num" => Call(ActionFn(7));) + // "-" -> Reduce(Term = "Num" => Call(ActionFn(7));) + // EOF -> Reduce(Term = "Num" => Call(ActionFn(7));) + // + pub fn __state3< + __TOKENS: Iterator>, + >( + scale: i32, + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); + match __lookahead { + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + Some((_, Tok::Div(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + Some((_, Tok::Times(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 4 + // Expr = Factor (*) [EOF] + // Expr = Factor (*) ["+"] + // 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) + // "/" -> Shift(S9) + // EOF -> Reduce(Expr = Factor => Call(ActionFn(3));) + // "+" -> Reduce(Expr = Factor => Call(ActionFn(3));) + // "-" -> Reduce(Expr = Factor => Call(ActionFn(3));) + // + pub fn __state4< + __TOKENS: Iterator>, + >( + scale: i32, + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); + match __lookahead { + Some((_, __tok @ Tok::Times(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state8(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } + Some((_, __tok @ Tok::Div(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state9(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + return Ok(__result); + } + + // State 5 // Expr = (*) Expr "+" Factor [")"] // Expr = (*) Expr "+" Factor ["+"] // Expr = (*) Expr "+" Factor ["-"] @@ -239,36 +417,35 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "Num" -> Shift(S8) - // "(" -> Shift(S9) + // "(" -> Shift(S10) + // "Num" -> Shift(S11) // - // Factor -> S6 - // Expr -> S10 - // Term -> S7 - pub fn __state2< - __ERROR, - __TOKENS: Iterator>, + // Expr -> S12 + // Term -> S13 + // Factor -> S14 + pub fn __state5< + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, Tok::Num(__tok0), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok0)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state8(scale, __lookbehind, __lookahead, __tokens, __sym1)); - } Some((_, __tok @ Tok::LParen(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state9(scale, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state10(scale, __lookbehind, __lookahead, __tokens, __sym1)); + } + Some((_, Tok::Num(__tok0), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok0)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state11(scale, __lookbehind, __lookahead, __tokens, __sym1)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -280,17 +457,17 @@ mod __parse__Expr { while __sym0.is_some() { let (__lookbehind, __lookahead, __nt) = __result; match __nt { - __Nonterminal::Factor(__nt) => { - let __sym1 = &mut Some(__nt); - __result = try!(__state6(scale, __lookbehind, __lookahead, __tokens, __sym1)); - } __Nonterminal::Expr(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state10(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state12(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); } __Nonterminal::Term(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state7(scale, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state13(scale, __lookbehind, __lookahead, __tokens, __sym1)); + } + __Nonterminal::Factor(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state14(scale, __lookbehind, __lookahead, __tokens, __sym1)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -300,250 +477,65 @@ mod __parse__Expr { return Ok(__result); } - // State 3 - // Expr = Factor (*) [EOF] - // Expr = Factor (*) ["+"] - // 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(S12) - // "/" -> Shift(S11) - // EOF -> Reduce(Expr = Factor => Call(ActionFn(3));) - // "-" -> Reduce(Expr = Factor => Call(ActionFn(3));) - // "+" -> Reduce(Expr = Factor => Call(ActionFn(3));) - // - pub fn __state3< - __ERROR, - __TOKENS: Iterator>, - >( - scale: i32, - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); - match __lookahead { - Some((_, __tok @ Tok::Times(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state12(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); - } - Some((_, __tok @ Tok::Div(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state11(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); - } - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); - } - Some((_, Tok::Plus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - return Ok(__result); - } - - // State 4 - // Term = "Num" (*) [EOF] - // Term = "Num" (*) ["*"] - // Term = "Num" (*) ["+"] - // Term = "Num" (*) ["-"] - // Term = "Num" (*) ["/"] - // - // EOF -> Reduce(Term = "Num" => Call(ActionFn(7));) - // "/" -> Reduce(Term = "Num" => Call(ActionFn(7));) - // "*" -> Reduce(Term = "Num" => Call(ActionFn(7));) - // "-" -> Reduce(Term = "Num" => Call(ActionFn(7));) - // "+" -> Reduce(Term = "Num" => Call(ActionFn(7));) - // - pub fn __state4< - __ERROR, - __TOKENS: Iterator>, - >( - scale: i32, - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); - match __lookahead { - None => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - Some((_, Tok::Div(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - Some((_, Tok::Times(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - Some((_, Tok::Plus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 5 - // Expr = Expr (*) "+" Factor [EOF] - // Expr = Expr (*) "+" Factor ["+"] - // Expr = Expr (*) "+" Factor ["-"] - // Expr = Expr (*) "-" Factor [EOF] - // Expr = Expr (*) "-" Factor ["+"] - // Expr = Expr (*) "-" Factor ["-"] - // __Expr = Expr (*) [EOF] - // - // "+" -> Shift(S13) - // "-" -> Shift(S14) - // EOF -> Reduce(__Expr = Expr => Call(ActionFn(0));) - // - pub fn __state5< - __ERROR, - __TOKENS: Iterator>, - >( - scale: i32, - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); - match __lookahead { - Some((_, __tok @ Tok::Plus(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state13(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); - } - Some((_, __tok @ Tok::Minus(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state14(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action0(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::____Expr(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - return Ok(__result); - } - // State 6 - // Expr = Factor (*) [")"] - // Expr = Factor (*) ["+"] - // Expr = Factor (*) ["-"] - // Factor = Factor (*) "*" Term [")"] - // Factor = Factor (*) "*" Term ["*"] - // Factor = Factor (*) "*" Term ["+"] - // Factor = Factor (*) "*" Term ["-"] - // Factor = Factor (*) "*" Term ["/"] - // Factor = Factor (*) "/" Term [")"] - // Factor = Factor (*) "/" Term ["*"] - // Factor = Factor (*) "/" Term ["+"] - // Factor = Factor (*) "/" Term ["-"] - // Factor = Factor (*) "/" Term ["/"] + // 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" ["/"] // - // "-" -> Reduce(Expr = Factor => Call(ActionFn(3));) - // ")" -> Reduce(Expr = Factor => Call(ActionFn(3));) - // "+" -> Reduce(Expr = Factor => Call(ActionFn(3));) - // "/" -> Shift(S15) - // "*" -> Shift(S16) + // "(" -> Shift(S5) + // "Num" -> Shift(S3) // + // Factor -> S15 + // Term -> S1 pub fn __state6< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + __sym1: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, __tok @ Tok::Div(..), __loc)) => { + Some((_, __tok @ Tok::LParen(..), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); + let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state15(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state5(scale, __lookbehind, __lookahead, __tokens, __sym2)); } - Some((_, __tok @ Tok::Times(..), __loc)) => { + Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); + let mut __sym2 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state16(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); - } - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); - } - Some((_, Tok::RParen(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); - } - Some((_, Tok::Plus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + __result = try!(__state3(scale, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -552,59 +544,84 @@ mod __parse__Expr { }); } } + while __sym1.is_some() { + let (__lookbehind, __lookahead, __nt) = __result; + match __nt { + __Nonterminal::Factor(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state15(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + } + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state1(scale, __lookbehind, __lookahead, __tokens, __sym2)); + } + _ => { + return Ok((__lookbehind, __lookahead, __nt)); + } + } + } return Ok(__result); } // State 7 - // Factor = Term (*) [")"] - // Factor = Term (*) ["*"] - // Factor = Term (*) ["+"] - // Factor = Term (*) ["-"] - // Factor = Term (*) ["/"] + // 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" ["/"] // - // "*" -> Reduce(Factor = Term => Call(ActionFn(6));) - // ")" -> Reduce(Factor = Term => Call(ActionFn(6));) - // "-" -> Reduce(Factor = Term => Call(ActionFn(6));) - // "/" -> Reduce(Factor = Term => Call(ActionFn(6));) - // "+" -> Reduce(Factor = Term => Call(ActionFn(6));) + // "(" -> Shift(S5) + // "Num" -> Shift(S3) // + // Term -> S1 + // Factor -> S16 pub fn __state7< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + __sym1: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, Tok::Times(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action6(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + Some((_, __tok @ Tok::LParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state5(scale, __lookbehind, __lookahead, __tokens, __sym2)); } - Some((_, Tok::RParen(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action6(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action6(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Div(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action6(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Plus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action6(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + Some((_, Tok::Num(__tok0), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state3(scale, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -613,58 +630,70 @@ mod __parse__Expr { }); } } + while __sym1.is_some() { + let (__lookbehind, __lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state1(scale, __lookbehind, __lookahead, __tokens, __sym2)); + } + __Nonterminal::Factor(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state16(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookbehind, __lookahead, __nt)); + } + } + } + return Ok(__result); } // State 8 - // Term = "Num" (*) [")"] - // Term = "Num" (*) ["*"] - // Term = "Num" (*) ["+"] - // Term = "Num" (*) ["-"] - // Term = "Num" (*) ["/"] + // 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" ["/"] // - // "/" -> Reduce(Term = "Num" => Call(ActionFn(7));) - // "+" -> Reduce(Term = "Num" => Call(ActionFn(7));) - // "-" -> Reduce(Term = "Num" => Call(ActionFn(7));) - // ")" -> Reduce(Term = "Num" => Call(ActionFn(7));) - // "*" -> Reduce(Term = "Num" => Call(ActionFn(7));) + // "(" -> Shift(S5) + // "Num" -> Shift(S3) // + // Term -> S17 pub fn __state8< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + __sym1: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, Tok::Div(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + Some((_, __tok @ Tok::LParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state5(scale, __lookbehind, __lookahead, __tokens, __sym2)); } - Some((_, Tok::Plus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - Some((_, Tok::RParen(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - Some((_, Tok::Times(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(scale, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + Some((_, Tok::Num(__tok0), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state3(scale, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -673,9 +702,90 @@ mod __parse__Expr { }); } } + while __sym1.is_some() { + let (__lookbehind, __lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state17(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookbehind, __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" ["/"] + // + // "(" -> Shift(S5) + // "Num" -> Shift(S3) + // + // Term -> S18 + pub fn __state9< + __TOKENS: Iterator>, + >( + scale: i32, + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); + match __lookahead { + Some((_, __tok @ Tok::LParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state5(scale, __lookbehind, __lookahead, __tokens, __sym2)); + } + Some((_, Tok::Num(__tok0), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state3(scale, __lookbehind, __lookahead, __tokens, __sym2)); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + while __sym1.is_some() { + let (__lookbehind, __lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state18(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookbehind, __lookahead, __nt)); + } + } + } + return Ok(__result); + } + + // State 10 // Expr = (*) Expr "+" Factor [")"] // Expr = (*) Expr "+" Factor ["+"] // Expr = (*) Expr "+" Factor ["-"] @@ -716,36 +826,35 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "Num" -> Shift(S8) - // "(" -> Shift(S9) + // "(" -> Shift(S10) + // "Num" -> Shift(S11) // - // Term -> S7 - // Expr -> S17 - // Factor -> S6 - pub fn __state9< - __ERROR, - __TOKENS: Iterator>, + // Expr -> S19 + // Factor -> S14 + // Term -> S13 + pub fn __state10< + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, Tok::Num(__tok0), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok0)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state8(scale, __lookbehind, __lookahead, __tokens, __sym1)); - } Some((_, __tok @ Tok::LParen(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state9(scale, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state10(scale, __lookbehind, __lookahead, __tokens, __sym1)); + } + Some((_, Tok::Num(__tok0), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok0)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state11(scale, __lookbehind, __lookahead, __tokens, __sym1)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -757,17 +866,17 @@ mod __parse__Expr { while __sym0.is_some() { let (__lookbehind, __lookahead, __nt) = __result; match __nt { - __Nonterminal::Term(__nt) => { - let __sym1 = &mut Some(__nt); - __result = try!(__state7(scale, __lookbehind, __lookahead, __tokens, __sym1)); - } __Nonterminal::Expr(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state17(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state19(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); } __Nonterminal::Factor(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state6(scale, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state14(scale, __lookbehind, __lookahead, __tokens, __sym1)); + } + __Nonterminal::Term(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state13(scale, __lookbehind, __lookahead, __tokens, __sym1)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -777,7 +886,66 @@ mod __parse__Expr { return Ok(__result); } - // State 10 + // State 11 + // Term = "Num" (*) [")"] + // Term = "Num" (*) ["*"] + // Term = "Num" (*) ["+"] + // Term = "Num" (*) ["-"] + // Term = "Num" (*) ["/"] + // + // "/" -> Reduce(Term = "Num" => Call(ActionFn(7));) + // "*" -> Reduce(Term = "Num" => Call(ActionFn(7));) + // "+" -> Reduce(Term = "Num" => Call(ActionFn(7));) + // ")" -> Reduce(Term = "Num" => Call(ActionFn(7));) + // "-" -> Reduce(Term = "Num" => Call(ActionFn(7));) + // + pub fn __state11< + __TOKENS: Iterator>, + >( + scale: i32, + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); + match __lookahead { + Some((_, Tok::Div(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + Some((_, Tok::Times(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + Some((_, Tok::RParen(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 12 // Expr = Expr (*) "+" Factor [")"] // Expr = Expr (*) "+" Factor ["+"] // Expr = Expr (*) "+" Factor ["-"] @@ -790,13 +958,12 @@ mod __parse__Expr { // Term = "(" Expr (*) ")" ["-"] // Term = "(" Expr (*) ")" ["/"] // - // "-" -> Shift(S18) - // "+" -> Shift(S20) - // ")" -> Shift(S19) + // ")" -> Shift(S22) + // "+" -> Shift(S21) + // "-" -> Shift(S20) // - pub fn __state10< - __ERROR, - __TOKENS: Iterator>, + pub fn __state12< + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, @@ -804,28 +971,28 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, __tok @ Tok::Minus(..), __loc)) => { + Some((_, __tok @ Tok::RParen(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state18(scale, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); + __result = try!(__state22(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); } Some((_, __tok @ Tok::Plus(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state21(scale, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); + } + Some((_, __tok @ Tok::Minus(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; __result = try!(__state20(scale, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); } - Some((_, __tok @ Tok::RParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state19(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } _ => { return Err(__ParseError::UnrecognizedToken { token: __lookahead, @@ -836,204 +1003,55 @@ mod __parse__Expr { return Ok(__result); } - // State 11 - // Factor = Factor "/" (*) Term [EOF] - // Factor = Factor "/" (*) Term ["*"] - // Factor = Factor "/" (*) Term ["+"] - // Factor = Factor "/" (*) Term ["-"] - // Factor = Factor "/" (*) Term ["/"] - // Term = (*) "(" Expr ")" [EOF] - // Term = (*) "(" Expr ")" ["*"] - // Term = (*) "(" Expr ")" ["+"] - // Term = (*) "(" Expr ")" ["-"] - // Term = (*) "(" Expr ")" ["/"] - // Term = (*) "Num" [EOF] - // Term = (*) "Num" ["*"] - // Term = (*) "Num" ["+"] - // Term = (*) "Num" ["-"] - // Term = (*) "Num" ["/"] - // - // "Num" -> Shift(S4) - // "(" -> Shift(S2) - // - // Term -> S21 - pub fn __state11< - __ERROR, - __TOKENS: Iterator>, - >( - scale: i32, - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); - match __lookahead { - Some((_, Tok::Num(__tok0), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok0)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state4(scale, __lookbehind, __lookahead, __tokens, __sym2)); - } - Some((_, __tok @ Tok::LParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state2(scale, __lookbehind, __lookahead, __tokens, __sym2)); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - while __sym1.is_some() { - let (__lookbehind, __lookahead, __nt) = __result; - match __nt { - __Nonterminal::Term(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state21(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - _ => { - return Ok((__lookbehind, __lookahead, __nt)); - } - } - } - return Ok(__result); - } - - // State 12 - // Factor = Factor "*" (*) Term [EOF] - // Factor = Factor "*" (*) Term ["*"] - // Factor = Factor "*" (*) Term ["+"] - // Factor = Factor "*" (*) Term ["-"] - // Factor = Factor "*" (*) Term ["/"] - // Term = (*) "(" Expr ")" [EOF] - // Term = (*) "(" Expr ")" ["*"] - // Term = (*) "(" Expr ")" ["+"] - // Term = (*) "(" Expr ")" ["-"] - // Term = (*) "(" Expr ")" ["/"] - // Term = (*) "Num" [EOF] - // Term = (*) "Num" ["*"] - // Term = (*) "Num" ["+"] - // Term = (*) "Num" ["-"] - // Term = (*) "Num" ["/"] - // - // "(" -> Shift(S2) - // "Num" -> Shift(S4) - // - // Term -> S22 - pub fn __state12< - __ERROR, - __TOKENS: Iterator>, - >( - scale: i32, - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); - match __lookahead { - Some((_, __tok @ Tok::LParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state2(scale, __lookbehind, __lookahead, __tokens, __sym2)); - } - Some((_, Tok::Num(__tok0), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok0)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state4(scale, __lookbehind, __lookahead, __tokens, __sym2)); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - while __sym1.is_some() { - let (__lookbehind, __lookahead, __nt) = __result; - match __nt { - __Nonterminal::Term(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state22(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - _ => { - return Ok((__lookbehind, __lookahead, __nt)); - } - } - } - return Ok(__result); - } - // State 13 - // 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" ["/"] + // Factor = Term (*) [")"] + // Factor = Term (*) ["*"] + // Factor = Term (*) ["+"] + // Factor = Term (*) ["-"] + // Factor = Term (*) ["/"] // - // "(" -> Shift(S2) - // "Num" -> Shift(S4) + // ")" -> Reduce(Factor = Term => Call(ActionFn(6));) + // "*" -> Reduce(Factor = Term => Call(ActionFn(6));) + // "-" -> Reduce(Factor = Term => Call(ActionFn(6));) + // "/" -> Reduce(Factor = Term => Call(ActionFn(6));) + // "+" -> Reduce(Factor = Term => Call(ActionFn(6));) // - // Factor -> S23 - // Term -> S1 pub fn __state13< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, - __sym1: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, __tok @ Tok::LParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state2(scale, __lookbehind, __lookahead, __tokens, __sym2)); + Some((_, Tok::RParen(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action6(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } - Some((_, Tok::Num(__tok0), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok0)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state4(scale, __lookbehind, __lookahead, __tokens, __sym2)); + Some((_, Tok::Times(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action6(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action6(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + Some((_, Tok::Div(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action6(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action6(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -1042,85 +1060,67 @@ mod __parse__Expr { }); } } - while __sym1.is_some() { - let (__lookbehind, __lookahead, __nt) = __result; - match __nt { - __Nonterminal::Factor(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state23(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - __Nonterminal::Term(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state1(scale, __lookbehind, __lookahead, __tokens, __sym2)); - } - _ => { - return Ok((__lookbehind, __lookahead, __nt)); - } - } - } - return Ok(__result); } // State 14 - // 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" ["/"] + // Expr = Factor (*) [")"] + // Expr = Factor (*) ["+"] + // Expr = Factor (*) ["-"] + // Factor = Factor (*) "*" Term [")"] + // Factor = Factor (*) "*" Term ["*"] + // Factor = Factor (*) "*" Term ["+"] + // Factor = Factor (*) "*" Term ["-"] + // Factor = Factor (*) "*" Term ["/"] + // Factor = Factor (*) "/" Term [")"] + // Factor = Factor (*) "/" Term ["*"] + // Factor = Factor (*) "/" Term ["+"] + // Factor = Factor (*) "/" Term ["-"] + // Factor = Factor (*) "/" Term ["/"] // - // "(" -> Shift(S2) - // "Num" -> Shift(S4) + // "*" -> Shift(S24) + // "/" -> Shift(S23) + // "+" -> Reduce(Expr = Factor => Call(ActionFn(3));) + // "-" -> Reduce(Expr = Factor => Call(ActionFn(3));) + // ")" -> Reduce(Expr = Factor => Call(ActionFn(3));) // - // Factor -> S24 - // Term -> S1 pub fn __state14< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, - __sym1: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, __tok @ Tok::LParen(..), __loc)) => { + Some((_, __tok @ Tok::Times(..), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); + let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state2(scale, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state24(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); } - Some((_, Tok::Num(__tok0), __loc)) => { + Some((_, __tok @ Tok::Div(..), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok0)); + let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state4(scale, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state23(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + Some((_, Tok::RParen(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(scale, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -1129,49 +1129,32 @@ mod __parse__Expr { }); } } - while __sym1.is_some() { - let (__lookbehind, __lookahead, __nt) = __result; - match __nt { - __Nonterminal::Factor(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state24(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - __Nonterminal::Term(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state1(scale, __lookbehind, __lookahead, __tokens, __sym2)); - } - _ => { - return Ok((__lookbehind, __lookahead, __nt)); - } - } - } return Ok(__result); } // State 15 - // Factor = Factor "/" (*) Term [")"] - // Factor = Factor "/" (*) Term ["*"] - // Factor = Factor "/" (*) Term ["+"] - // Factor = Factor "/" (*) Term ["-"] - // Factor = Factor "/" (*) Term ["/"] - // Term = (*) "(" Expr ")" [")"] - // Term = (*) "(" Expr ")" ["*"] - // Term = (*) "(" Expr ")" ["+"] - // Term = (*) "(" Expr ")" ["-"] - // Term = (*) "(" Expr ")" ["/"] - // Term = (*) "Num" [")"] - // Term = (*) "Num" ["*"] - // Term = (*) "Num" ["+"] - // Term = (*) "Num" ["-"] - // Term = (*) "Num" ["/"] + // 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 ["/"] // - // "Num" -> Shift(S8) - // "(" -> Shift(S9) + // "/" -> Shift(S9) + // "+" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) + // "-" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) + // "*" -> Shift(S8) + // EOF -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) // - // Term -> S25 pub fn __state15< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, @@ -1179,21 +1162,43 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + __sym2: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, Tok::Num(__tok0), __loc)) => { + Some((_, __tok @ Tok::Div(..), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok0)); + let mut __sym3 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state8(scale, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state9(scale, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); } - Some((_, __tok @ Tok::LParen(..), __loc)) => { + Some((_, __tok @ Tok::Times(..), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); + let mut __sym3 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state9(scale, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state8(scale, __lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action1(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -1202,45 +1207,32 @@ mod __parse__Expr { }); } } - while __sym1.is_some() { - let (__lookbehind, __lookahead, __nt) = __result; - match __nt { - __Nonterminal::Term(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state25(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - _ => { - return Ok((__lookbehind, __lookahead, __nt)); - } - } - } return Ok(__result); } // State 16 - // Factor = Factor "*" (*) Term [")"] - // Factor = Factor "*" (*) Term ["*"] - // Factor = Factor "*" (*) Term ["+"] - // Factor = Factor "*" (*) Term ["-"] - // Factor = Factor "*" (*) Term ["/"] - // Term = (*) "(" Expr ")" [")"] - // Term = (*) "(" Expr ")" ["*"] - // Term = (*) "(" Expr ")" ["+"] - // Term = (*) "(" Expr ")" ["-"] - // Term = (*) "(" Expr ")" ["/"] - // Term = (*) "Num" [")"] - // Term = (*) "Num" ["*"] - // Term = (*) "Num" ["+"] - // Term = (*) "Num" ["-"] - // Term = (*) "Num" ["/"] + // 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 ["/"] // - // "Num" -> Shift(S8) - // "(" -> Shift(S9) + // "+" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) + // "/" -> Shift(S9) + // "*" -> Shift(S8) + // EOF -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) + // "-" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) // - // Term -> S26 pub fn __state16< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, @@ -1248,21 +1240,43 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + __sym2: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, Tok::Num(__tok0), __loc)) => { + Some((_, __tok @ Tok::Div(..), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok0)); + let mut __sym3 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state8(scale, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state9(scale, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); } - Some((_, __tok @ Tok::LParen(..), __loc)) => { + Some((_, __tok @ Tok::Times(..), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); + let mut __sym3 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state9(scale, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state8(scale, __lookbehind, __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::__action2(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action2(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -1271,22 +1285,152 @@ mod __parse__Expr { }); } } - while __sym1.is_some() { - let (__lookbehind, __lookahead, __nt) = __result; - match __nt { - __Nonterminal::Term(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state26(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - _ => { - return Ok((__lookbehind, __lookahead, __nt)); - } - } - } 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 => Call(ActionFn(4));) + // EOF -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "+" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "*" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "-" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // + pub fn __state17< + __TOKENS: Iterator>, + >( + scale: i32, + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action4(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 18 + // Factor = Factor "/" Term (*) [EOF] + // Factor = Factor "/" Term (*) ["*"] + // Factor = Factor "/" Term (*) ["+"] + // Factor = Factor "/" Term (*) ["-"] + // Factor = Factor "/" Term (*) ["/"] + // + // EOF -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "+" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "*" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "-" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "/" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // + pub fn __state18< + __TOKENS: Iterator>, + >( + scale: i32, + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); + match __lookahead { + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action5(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 19 // Expr = Expr (*) "+" Factor [")"] // Expr = Expr (*) "+" Factor ["+"] // Expr = Expr (*) "+" Factor ["-"] @@ -1299,13 +1443,12 @@ mod __parse__Expr { // Term = "(" Expr (*) ")" ["-"] // Term = "(" Expr (*) ")" ["/"] // - // "-" -> Shift(S18) - // ")" -> Shift(S27) - // "+" -> Shift(S20) + // "+" -> Shift(S21) + // "-" -> Shift(S20) + // ")" -> Shift(S25) // - pub fn __state17< - __ERROR, - __TOKENS: Iterator>, + pub fn __state19< + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, @@ -1313,27 +1456,27 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { + Some((_, __tok @ Tok::Plus(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state21(scale, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); + } Some((_, __tok @ Tok::Minus(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state18(scale, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); + __result = try!(__state20(scale, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); } Some((_, __tok @ Tok::RParen(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state27(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - Some((_, __tok @ Tok::Plus(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state20(scale, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); + __result = try!(__state25(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -1345,7 +1488,7 @@ mod __parse__Expr { return Ok(__result); } - // State 18 + // State 20 // Expr = Expr "-" (*) Factor [")"] // Expr = Expr "-" (*) Factor ["+"] // Expr = Expr "-" (*) Factor ["-"] @@ -1375,14 +1518,13 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "Num" -> Shift(S8) - // "(" -> Shift(S9) + // "(" -> Shift(S10) + // "Num" -> Shift(S11) // - // Factor -> S28 - // Term -> S7 - pub fn __state18< - __ERROR, - __TOKENS: Iterator>, + // Term -> S13 + // Factor -> S26 + pub fn __state20< + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, @@ -1390,21 +1532,21 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, Tok::Num(__tok0), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok0)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state8(scale, __lookbehind, __lookahead, __tokens, __sym2)); - } Some((_, __tok @ Tok::LParen(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state9(scale, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state10(scale, __lookbehind, __lookahead, __tokens, __sym2)); + } + Some((_, Tok::Num(__tok0), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state11(scale, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -1416,13 +1558,13 @@ mod __parse__Expr { while __sym1.is_some() { let (__lookbehind, __lookahead, __nt) = __result; match __nt { - __Nonterminal::Factor(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state28(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } __Nonterminal::Term(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state7(scale, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state13(scale, __lookbehind, __lookahead, __tokens, __sym2)); + } + __Nonterminal::Factor(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state26(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -1432,79 +1574,7 @@ mod __parse__Expr { return Ok(__result); } - // State 19 - // Term = "(" Expr ")" (*) [EOF] - // Term = "(" Expr ")" (*) ["*"] - // Term = "(" Expr ")" (*) ["+"] - // Term = "(" Expr ")" (*) ["-"] - // Term = "(" Expr ")" (*) ["/"] - // - // "-" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) - // "*" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) - // "/" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) - // "+" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) - // EOF -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) - // - pub fn __state19< - __ERROR, - __TOKENS: Iterator>, - >( - scale: i32, - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); - match __lookahead { - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action8(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action8(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 20 + // State 21 // Expr = Expr "+" (*) Factor [")"] // Expr = Expr "+" (*) Factor ["+"] // Expr = Expr "+" (*) Factor ["-"] @@ -1534,14 +1604,13 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "(" -> Shift(S9) - // "Num" -> Shift(S8) + // "(" -> Shift(S10) + // "Num" -> Shift(S11) // - // Term -> S7 - // Factor -> S29 - pub fn __state20< - __ERROR, - __TOKENS: Iterator>, + // Term -> S13 + // Factor -> S27 + pub fn __state21< + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, @@ -1549,7 +1618,7 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { @@ -1557,13 +1626,13 @@ mod __parse__Expr { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state9(scale, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state10(scale, __lookbehind, __lookahead, __tokens, __sym2)); } Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state8(scale, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state11(scale, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -1577,11 +1646,11 @@ mod __parse__Expr { match __nt { __Nonterminal::Term(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state7(scale, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state13(scale, __lookbehind, __lookahead, __tokens, __sym2)); } __Nonterminal::Factor(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state29(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + __result = try!(__state27(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -1591,140 +1660,67 @@ mod __parse__Expr { return Ok(__result); } - // State 21 - // Factor = Factor "/" Term (*) [EOF] - // Factor = Factor "/" Term (*) ["*"] - // Factor = Factor "/" Term (*) ["+"] - // Factor = Factor "/" Term (*) ["-"] - // Factor = Factor "/" Term (*) ["/"] - // - // "*" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "+" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "-" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "/" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // EOF -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // - pub fn __state21< - __ERROR, - __TOKENS: Iterator>, - >( - scale: i32, - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action5(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - // State 22 - // 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 ")" (*) ["/"] // - // "*" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "+" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // EOF -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "-" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "/" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // EOF -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) + // "*" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) + // "+" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) + // "/" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) + // "-" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) // pub fn __state22< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action8(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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::__action4(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + let __nt = super::__action8(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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::__action4(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action4(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + let __nt = super::__action8(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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::__action4(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + let __nt = super::__action8(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -1736,29 +1732,28 @@ mod __parse__Expr { } // State 23 - // 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 = 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" ["/"] // - // "-" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) - // "+" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) - // "*" -> Shift(S12) - // "/" -> Shift(S11) - // EOF -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) + // "(" -> Shift(S10) + // "Num" -> Shift(S11) // + // Term -> S28 pub fn __state23< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, @@ -1766,43 +1761,21 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, __tok @ Tok::Times(..), __loc)) => { + Some((_, __tok @ Tok::LParen(..), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym3 = &mut Some((__tok)); + let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state12(scale, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); + __result = try!(__state10(scale, __lookbehind, __lookahead, __tokens, __sym2)); } - Some((_, __tok @ Tok::Div(..), __loc)) => { + Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym3 = &mut Some((__tok)); + let mut __sym2 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state11(scale, __lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action2(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + __result = try!(__state11(scale, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -1811,33 +1784,44 @@ mod __parse__Expr { }); } } + while __sym1.is_some() { + let (__lookbehind, __lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state28(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookbehind, __lookahead, __nt)); + } + } + } return Ok(__result); } // State 24 - // 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 = 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" ["/"] // - // "+" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) - // "*" -> Shift(S12) - // "/" -> Shift(S11) - // EOF -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) - // "-" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) + // "(" -> Shift(S10) + // "Num" -> Shift(S11) // + // Term -> S29 pub fn __state24< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, @@ -1845,43 +1829,21 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, __tok @ Tok::Times(..), __loc)) => { + Some((_, __tok @ Tok::LParen(..), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym3 = &mut Some((__tok)); + let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state12(scale, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); + __result = try!(__state10(scale, __lookbehind, __lookahead, __tokens, __sym2)); } - Some((_, __tok @ Tok::Div(..), __loc)) => { + Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym3 = &mut Some((__tok)); + let mut __sym2 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state11(scale, __lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action1(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + __result = try!(__state11(scale, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -1890,34 +1852,45 @@ mod __parse__Expr { }); } } + while __sym1.is_some() { + let (__lookbehind, __lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state29(scale, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookbehind, __lookahead, __nt)); + } + } + } return Ok(__result); } // State 25 - // 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 ")" (*) ["/"] // - // "-" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "+" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // ")" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "*" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "/" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "-" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) + // "*" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) + // "+" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) + // ")" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) + // "/" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) // pub fn __state25< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { @@ -1925,36 +1898,36 @@ mod __parse__Expr { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action5(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + let __nt = super::__action8(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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::__action5(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + let __nt = super::__action8(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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::__action5(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + let __nt = super::__action8(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -1966,150 +1939,6 @@ mod __parse__Expr { } // State 26 - // Factor = Factor "*" Term (*) [")"] - // Factor = Factor "*" Term (*) ["*"] - // Factor = Factor "*" Term (*) ["+"] - // Factor = Factor "*" Term (*) ["-"] - // Factor = Factor "*" Term (*) ["/"] - // - // "*" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // ")" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "/" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "+" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "-" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // - pub fn __state26< - __ERROR, - __TOKENS: Iterator>, - >( - scale: i32, - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); - match __lookahead { - Some((_, Tok::Times(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action4(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 27 - // Term = "(" Expr ")" (*) [")"] - // Term = "(" Expr ")" (*) ["*"] - // Term = "(" Expr ")" (*) ["+"] - // Term = "(" Expr ")" (*) ["-"] - // Term = "(" Expr ")" (*) ["/"] - // - // "+" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) - // ")" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) - // "/" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) - // "*" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) - // "-" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(8));) - // - pub fn __state27< - __ERROR, - __TOKENS: Iterator>, - >( - scale: i32, - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); - match __lookahead { - Some((_, Tok::Plus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action8(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 28 // Expr = Expr "-" Factor (*) [")"] // Expr = Expr "-" Factor (*) ["+"] // Expr = Expr "-" Factor (*) ["-"] @@ -2124,15 +1953,14 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["-"] // Factor = Factor (*) "/" Term ["/"] // - // "*" -> Shift(S16) - // "+" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) - // "/" -> Shift(S15) + // "/" -> Shift(S23) + // "*" -> Shift(S24) // ")" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) + // "+" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) // "-" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) // - pub fn __state28< - __ERROR, - __TOKENS: Iterator>, + pub fn __state26< + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, @@ -2141,30 +1969,30 @@ mod __parse__Expr { __sym0: &mut Option, __sym1: &mut Option, __sym2: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, __tok @ Tok::Times(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym3 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state16(scale, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); - } Some((_, __tok @ Tok::Div(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym3 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state15(scale, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); + __result = try!(__state23(scale, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); } - Some((_, Tok::Plus(..), _)) => { + Some((_, __tok @ Tok::Times(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym3 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state24(scale, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); + } + Some((_, Tok::RParen(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); let __nt = super::__action1(scale, __sym0, __sym1, __sym2); return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); } - Some((_, Tok::RParen(..), _)) => { + Some((_, Tok::Plus(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); @@ -2188,7 +2016,7 @@ mod __parse__Expr { return Ok(__result); } - // State 29 + // State 27 // Expr = Expr "+" Factor (*) [")"] // Expr = Expr "+" Factor (*) ["+"] // Expr = Expr "+" Factor (*) ["-"] @@ -2203,15 +2031,14 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["-"] // Factor = Factor (*) "/" Term ["/"] // - // "*" -> Shift(S16) // "-" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) - // "+" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) // ")" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) - // "/" -> Shift(S15) + // "+" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) + // "/" -> Shift(S23) + // "*" -> Shift(S24) // - pub fn __state29< - __ERROR, - __TOKENS: Iterator>, + pub fn __state27< + __TOKENS: Iterator>, >( scale: i32, __lookbehind: Option<()>, @@ -2220,21 +2047,21 @@ mod __parse__Expr { __sym0: &mut Option, __sym1: &mut Option, __sym2: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, __tok @ Tok::Times(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym3 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state16(scale, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); - } Some((_, __tok @ Tok::Div(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym3 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state15(scale, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); + __result = try!(__state23(scale, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); + } + Some((_, __tok @ Tok::Times(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym3 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state24(scale, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); } Some((_, Tok::Minus(..), _)) => { let __sym0 = __sym0.take().unwrap(); @@ -2243,14 +2070,14 @@ mod __parse__Expr { let __nt = super::__action2(scale, __sym0, __sym1, __sym2); return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); } - Some((_, Tok::Plus(..), _)) => { + Some((_, Tok::RParen(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); let __nt = super::__action2(scale, __sym0, __sym1, __sym2); return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); } - Some((_, Tok::RParen(..), _)) => { + Some((_, Tok::Plus(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); @@ -2266,6 +2093,148 @@ mod __parse__Expr { } return Ok(__result); } + + // State 28 + // Factor = Factor "/" Term (*) [")"] + // Factor = Factor "/" Term (*) ["*"] + // Factor = Factor "/" Term (*) ["+"] + // Factor = Factor "/" Term (*) ["-"] + // Factor = Factor "/" Term (*) ["/"] + // + // "+" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "/" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "*" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "-" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // ")" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // + pub fn __state28< + __TOKENS: Iterator>, + >( + scale: i32, + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 29 + // Factor = Factor "*" Term (*) [")"] + // Factor = Factor "*" Term (*) ["*"] + // Factor = Factor "*" Term (*) ["+"] + // Factor = Factor "*" Term (*) ["-"] + // Factor = Factor "*" Term (*) ["/"] + // + // "+" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "-" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "/" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // ")" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "*" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // + pub fn __state29< + __TOKENS: Iterator>, + >( + scale: i32, + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); + match __lookahead { + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action4(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(scale, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } } pub fn __action0< diff --git a/lalrpop-test/src/expr_arena.rs b/lalrpop-test/src/expr_arena.rs index f8c3ea2..6e231d7 100644 --- a/lalrpop-test/src/expr_arena.rs +++ b/lalrpop-test/src/expr_arena.rs @@ -7,13 +7,12 @@ use self::__lalrpop_util::ParseError as __ParseError; #[allow(non_snake_case)] pub fn parse_Expr< 'ast, - __ERROR, - __TOKEN: __ToTriple, + __TOKEN: __ToTriple, __TOKENS: IntoIterator, >( arena: &'ast Arena<'ast>, __tokens: __TOKENS, -) -> Result<&'ast Node<'ast>, __ParseError> +) -> Result<&'ast Node<'ast>, __ParseError> { let mut __tokens = __tokens.into_iter(); let mut __tokens = __tokens.map(|t| __ToTriple::to_triple(t)); @@ -39,14 +38,14 @@ mod __parse__Expr { use super::__ToTriple; pub enum __Nonterminal<'ast, > { - Expr(&'ast Node<'ast>), - Comma_3cExpr_3e(Vec<&'ast Node<'ast>>), - Factor(&'ast Node<'ast>), - _28_3cExpr_3e_20_22_2c_22_29(&'ast Node<'ast>), - Term(&'ast Node<'ast>), - Expr_3f(::std::option::Option<&'ast Node<'ast>>), ____Expr(&'ast Node<'ast>), + Comma_3cExpr_3e(Vec<&'ast Node<'ast>>), _28_3cExpr_3e_20_22_2c_22_29_2a(::std::vec::Vec<&'ast Node<'ast>>), + Expr_3f(::std::option::Option<&'ast Node<'ast>>), + Expr(&'ast Node<'ast>), + Factor(&'ast Node<'ast>), + Term(&'ast Node<'ast>), + _28_3cExpr_3e_20_22_2c_22_29(&'ast Node<'ast>), } // State 0 @@ -91,43 +90,42 @@ mod __parse__Expr { // Term = (*) "Num" ["/"] // __Expr = (*) Expr [EOF] // - // "Num" -> Shift(S4) - // "(" -> Shift(S5) - // "*" -> Shift(S2) + // "(" -> Shift(S4) + // "*" -> Shift(S1) + // "Num" -> Shift(S3) // - // Term -> S1 - // Expr -> S6 - // Factor -> S3 + // Term -> S2 + // Expr -> S5 + // Factor -> S6 pub fn __state0< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, Tok::Num(__tok0), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym0 = &mut Some((__tok0)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state4(arena, __lookbehind, __lookahead, __tokens, __sym0)); - } Some((_, __tok @ Tok::LParen(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym0 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state5(arena, __lookbehind, __lookahead, __tokens, __sym0)); + __result = try!(__state4(arena, __lookbehind, __lookahead, __tokens, __sym0)); } Some((_, __tok @ Tok::Times(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym0 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state2(arena, __lookbehind, __lookahead, __tokens, __sym0)); + __result = try!(__state1(arena, __lookbehind, __lookahead, __tokens, __sym0)); + } + Some((_, Tok::Num(__tok0), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym0 = &mut Some((__tok0)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state3(arena, __lookbehind, __lookahead, __tokens, __sym0)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -141,15 +139,15 @@ mod __parse__Expr { match __nt { __Nonterminal::Term(__nt) => { let __sym0 = &mut Some(__nt); - __result = try!(__state1(arena, __lookbehind, __lookahead, __tokens, __sym0)); + __result = try!(__state2(arena, __lookbehind, __lookahead, __tokens, __sym0)); } __Nonterminal::Expr(__nt) => { let __sym0 = &mut Some(__nt); - __result = try!(__state6(arena, __lookbehind, __lookahead, __tokens, __sym0)); + __result = try!(__state5(arena, __lookbehind, __lookahead, __tokens, __sym0)); } __Nonterminal::Factor(__nt) => { let __sym0 = &mut Some(__nt); - __result = try!(__state3(arena, __lookbehind, __lookahead, __tokens, __sym0)); + __result = try!(__state6(arena, __lookbehind, __lookahead, __tokens, __sym0)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -159,67 +157,6 @@ mod __parse__Expr { } // State 1 - // Factor = Term (*) [EOF] - // Factor = Term (*) ["*"] - // Factor = Term (*) ["+"] - // Factor = Term (*) ["-"] - // Factor = Term (*) ["/"] - // - // "*" -> Reduce(Factor = Term => Call(ActionFn(7));) - // "/" -> Reduce(Factor = Term => Call(ActionFn(7));) - // EOF -> Reduce(Factor = Term => Call(ActionFn(7));) - // "+" -> Reduce(Factor = Term => Call(ActionFn(7));) - // "-" -> Reduce(Factor = Term => Call(ActionFn(7));) - // - pub fn __state1< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, Tok::Times(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Div(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Plus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 2 // Factor = "*" (*) "(" Comma ")" [EOF] // Factor = "*" (*) "(" Comma ")" ["*"] // Factor = "*" (*) "(" Comma ")" ["+"] @@ -228,17 +165,16 @@ mod __parse__Expr { // // "(" -> Shift(S7) // - pub fn __state2< + pub fn __state1< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { @@ -258,67 +194,56 @@ mod __parse__Expr { return Ok(__result); } - // State 3 - // Expr = Factor (*) [EOF] - // Expr = Factor (*) ["+"] - // 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 ["/"] + // State 2 + // Factor = Term (*) [EOF] + // Factor = Term (*) ["*"] + // Factor = Term (*) ["+"] + // Factor = Term (*) ["-"] + // Factor = Term (*) ["/"] // - // "*" -> Shift(S9) - // "+" -> Reduce(Expr = Factor => Call(ActionFn(3));) - // "-" -> Reduce(Expr = Factor => Call(ActionFn(3));) - // "/" -> Shift(S8) - // EOF -> Reduce(Expr = Factor => Call(ActionFn(3));) + // EOF -> Reduce(Factor = Term => Call(ActionFn(7));) + // "+" -> Reduce(Factor = Term => Call(ActionFn(7));) + // "/" -> Reduce(Factor = Term => Call(ActionFn(7));) + // "*" -> Reduce(Factor = Term => Call(ActionFn(7));) + // "-" -> Reduce(Factor = Term => Call(ActionFn(7));) // - pub fn __state3< + pub fn __state2< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, __tok @ Tok::Times(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state9(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); - } - Some((_, __tok @ Tok::Div(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state8(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } Some((_, Tok::Plus(..), _)) => { let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + let __nt = super::__action7(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + Some((_, Tok::Div(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + Some((_, Tok::Times(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } Some((_, Tok::Minus(..), _)) => { let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + let __nt = super::__action7(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -327,41 +252,34 @@ mod __parse__Expr { }); } } - return Ok(__result); } - // State 4 + // State 3 // Term = "Num" (*) [EOF] // Term = "Num" (*) ["*"] // Term = "Num" (*) ["+"] // Term = "Num" (*) ["-"] // Term = "Num" (*) ["/"] // - // "*" -> Reduce(Term = "Num" => Call(ActionFn(8));) // "-" -> Reduce(Term = "Num" => Call(ActionFn(8));) // "+" -> Reduce(Term = "Num" => Call(ActionFn(8));) - // EOF -> Reduce(Term = "Num" => Call(ActionFn(8));) + // "*" -> Reduce(Term = "Num" => Call(ActionFn(8));) // "/" -> Reduce(Term = "Num" => Call(ActionFn(8));) + // EOF -> Reduce(Term = "Num" => Call(ActionFn(8));) // - pub fn __state4< + pub fn __state3< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, Tok::Times(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action8(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } Some((_, Tok::Minus(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __nt = super::__action8(arena, __sym0); @@ -372,7 +290,7 @@ mod __parse__Expr { let __nt = super::__action8(arena, __sym0); return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); } - None => { + Some((_, Tok::Times(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __nt = super::__action8(arena, __sym0); return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); @@ -382,6 +300,11 @@ mod __parse__Expr { let __nt = super::__action8(arena, __sym0); return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); } + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action8(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } _ => { return Err(__ParseError::UnrecognizedToken { token: __lookahead, @@ -391,7 +314,7 @@ mod __parse__Expr { } } - // State 5 + // State 4 // Expr = (*) Expr "+" Factor [")"] // Expr = (*) Expr "+" Factor ["+"] // Expr = (*) Expr "+" Factor ["-"] @@ -437,24 +360,23 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "(" -> Shift(S15) - // "Num" -> Shift(S13) + // "(" -> Shift(S11) // "*" -> Shift(S12) + // "Num" -> Shift(S9) // - // Expr -> S11 - // Factor -> S10 - // Term -> S14 - pub fn __state5< + // Term -> S8 + // Factor -> S13 + // Expr -> S10 + pub fn __state4< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { @@ -462,13 +384,7 @@ mod __parse__Expr { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state15(arena, __lookbehind, __lookahead, __tokens, __sym1)); - } - Some((_, Tok::Num(__tok0), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok0)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state13(arena, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state11(arena, __lookbehind, __lookahead, __tokens, __sym1)); } Some((_, __tok @ Tok::Times(..), __loc)) => { let mut __lookbehind = Some(__loc); @@ -476,6 +392,12 @@ mod __parse__Expr { let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; __result = try!(__state12(arena, __lookbehind, __lookahead, __tokens, __sym1)); } + Some((_, Tok::Num(__tok0), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok0)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state9(arena, __lookbehind, __lookahead, __tokens, __sym1)); + } _ => { return Err(__ParseError::UnrecognizedToken { token: __lookahead, @@ -486,17 +408,17 @@ mod __parse__Expr { while __sym0.is_some() { let (__lookbehind, __lookahead, __nt) = __result; match __nt { - __Nonterminal::Expr(__nt) => { + __Nonterminal::Term(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state11(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state8(arena, __lookbehind, __lookahead, __tokens, __sym1)); } __Nonterminal::Factor(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state10(arena, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state13(arena, __lookbehind, __lookahead, __tokens, __sym1)); } - __Nonterminal::Term(__nt) => { + __Nonterminal::Expr(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state14(arena, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state10(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -506,7 +428,7 @@ mod __parse__Expr { return Ok(__result); } - // State 6 + // State 5 // Expr = Expr (*) "+" Factor [EOF] // Expr = Expr (*) "+" Factor ["+"] // Expr = Expr (*) "+" Factor ["-"] @@ -515,35 +437,34 @@ mod __parse__Expr { // Expr = Expr (*) "-" Factor ["-"] // __Expr = Expr (*) [EOF] // - // "-" -> Shift(S16) + // "+" -> Shift(S14) // EOF -> Reduce(__Expr = Expr => Call(ActionFn(0));) - // "+" -> Shift(S17) + // "-" -> Shift(S15) // - pub fn __state6< + pub fn __state5< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, __tok @ Tok::Minus(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state16(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); - } Some((_, __tok @ Tok::Plus(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state17(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state14(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } + Some((_, __tok @ Tok::Minus(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state15(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); } None => { let __sym0 = __sym0.take().unwrap(); @@ -560,6 +481,77 @@ mod __parse__Expr { return Ok(__result); } + // State 6 + // Expr = Factor (*) [EOF] + // Expr = Factor (*) ["+"] + // 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(S17) + // "+" -> Reduce(Expr = Factor => Call(ActionFn(3));) + // "*" -> Shift(S16) + // EOF -> Reduce(Expr = Factor => Call(ActionFn(3));) + // "-" -> Reduce(Expr = Factor => Call(ActionFn(3));) + // + pub fn __state6< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option<&'ast Node<'ast>>, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, __tok @ Tok::Div(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state17(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } + Some((_, __tok @ Tok::Times(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state16(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + return Ok(__result); + } + // State 7 // ( ",")* = (*) ["("] // ( ",")* = (*) [")"] @@ -576,17 +568,16 @@ mod __parse__Expr { // Factor = "*" "(" (*) Comma ")" ["-"] // Factor = "*" "(" (*) Comma ")" ["/"] // - // ")" -> Reduce(( ",")* = => Call(ActionFn(13));) // "*" -> Reduce(( ",")* = => Call(ActionFn(13));) - // "Num" -> Reduce(( ",")* = => Call(ActionFn(13));) // "(" -> Reduce(( ",")* = => Call(ActionFn(13));) + // ")" -> Reduce(( ",")* = => Call(ActionFn(13));) + // "Num" -> Reduce(( ",")* = => Call(ActionFn(13));) // - // ( ",")* -> S18 - // Comma -> S19 + // ( ",")* -> S19 + // Comma -> S18 pub fn __state7< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -594,23 +585,23 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, Tok::RParen(..), _)) => { - let __nt = super::__action13(arena, ); - __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt)); - } Some((_, Tok::Times(..), _)) => { let __nt = super::__action13(arena, ); __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt)); } - Some((_, Tok::Num(_), _)) => { + Some((_, Tok::LParen(..), _)) => { let __nt = super::__action13(arena, ); __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt)); } - Some((_, Tok::LParen(..), _)) => { + Some((_, Tok::RParen(..), _)) => { + let __nt = super::__action13(arena, ); + __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt)); + } + Some((_, Tok::Num(_), _)) => { let __nt = super::__action13(arena, ); __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt)); } @@ -626,11 +617,11 @@ mod __parse__Expr { match __nt { __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state18(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state19(arena, __lookbehind, __lookahead, __tokens, __sym2)); } __Nonterminal::Comma_3cExpr_3e(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state19(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + __result = try!(__state18(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -641,206 +632,55 @@ mod __parse__Expr { } // State 8 - // 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" ["/"] + // Factor = Term (*) [")"] + // Factor = Term (*) ["*"] + // Factor = Term (*) ["+"] + // Factor = Term (*) ["-"] + // Factor = Term (*) ["/"] // - // "Num" -> Shift(S4) - // "(" -> Shift(S5) + // "*" -> Reduce(Factor = Term => Call(ActionFn(7));) + // "/" -> Reduce(Factor = Term => Call(ActionFn(7));) + // "+" -> Reduce(Factor = Term => Call(ActionFn(7));) + // ")" -> Reduce(Factor = Term => Call(ActionFn(7));) + // "-" -> Reduce(Factor = Term => Call(ActionFn(7));) // - // Term -> S20 pub fn __state8< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option<&'ast Node<'ast>>, - __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, Tok::Num(__tok0), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok0)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state4(arena, __lookbehind, __lookahead, __tokens, __sym2)); + Some((_, Tok::Times(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } - Some((_, __tok @ Tok::LParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state5(arena, __lookbehind, __lookahead, __tokens, __sym2)); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - while __sym1.is_some() { - let (__lookbehind, __lookahead, __nt) = __result; - match __nt { - __Nonterminal::Term(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state20(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - _ => { - return Ok((__lookbehind, __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" ["/"] - // - // "(" -> Shift(S5) - // "Num" -> Shift(S4) - // - // Term -> S21 - pub fn __state9< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option<&'ast Node<'ast>>, - __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, __tok @ Tok::LParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state5(arena, __lookbehind, __lookahead, __tokens, __sym2)); - } - Some((_, Tok::Num(__tok0), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok0)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state4(arena, __lookbehind, __lookahead, __tokens, __sym2)); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - while __sym1.is_some() { - let (__lookbehind, __lookahead, __nt) = __result; - match __nt { - __Nonterminal::Term(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state21(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - _ => { - return Ok((__lookbehind, __lookahead, __nt)); - } - } - } - return Ok(__result); - } - - // State 10 - // Expr = Factor (*) [")"] - // Expr = Factor (*) ["+"] - // Expr = Factor (*) ["-"] - // Factor = Factor (*) "*" Term [")"] - // Factor = Factor (*) "*" Term ["*"] - // Factor = Factor (*) "*" Term ["+"] - // Factor = Factor (*) "*" Term ["-"] - // Factor = Factor (*) "*" Term ["/"] - // Factor = Factor (*) "/" Term [")"] - // Factor = Factor (*) "/" Term ["*"] - // Factor = Factor (*) "/" Term ["+"] - // Factor = Factor (*) "/" Term ["-"] - // Factor = Factor (*) "/" Term ["/"] - // - // "*" -> Shift(S22) - // "/" -> Shift(S23) - // "+" -> Reduce(Expr = Factor => Call(ActionFn(3));) - // "-" -> Reduce(Expr = Factor => Call(ActionFn(3));) - // ")" -> Reduce(Expr = Factor => Call(ActionFn(3));) - // - pub fn __state10< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, __tok @ Tok::Times(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state22(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); - } - Some((_, __tok @ Tok::Div(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state23(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + Some((_, Tok::Div(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } Some((_, Tok::Plus(..), _)) => { let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); - } - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + let __nt = super::__action7(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } Some((_, Tok::RParen(..), _)) => { let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + let __nt = super::__action7(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -849,10 +689,69 @@ mod __parse__Expr { }); } } - return Ok(__result); } - // State 11 + // State 9 + // Term = "Num" (*) [")"] + // Term = "Num" (*) ["*"] + // Term = "Num" (*) ["+"] + // Term = "Num" (*) ["-"] + // Term = "Num" (*) ["/"] + // + // "*" -> Reduce(Term = "Num" => Call(ActionFn(8));) + // "/" -> Reduce(Term = "Num" => Call(ActionFn(8));) + // ")" -> Reduce(Term = "Num" => Call(ActionFn(8));) + // "-" -> Reduce(Term = "Num" => Call(ActionFn(8));) + // "+" -> Reduce(Term = "Num" => Call(ActionFn(8));) + // + pub fn __state9< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, Tok::Times(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action8(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + Some((_, Tok::Div(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action8(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + Some((_, Tok::RParen(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action8(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action8(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action8(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 10 // Expr = Expr (*) "+" Factor [")"] // Expr = Expr (*) "+" Factor ["+"] // Expr = Expr (*) "+" Factor ["-"] @@ -865,14 +764,13 @@ mod __parse__Expr { // Term = "(" Expr (*) ")" ["-"] // Term = "(" Expr (*) ")" ["/"] // - // "+" -> Shift(S25) - // "-" -> Shift(S24) - // ")" -> Shift(S26) + // "+" -> Shift(S20) + // "-" -> Shift(S21) + // ")" -> Shift(S22) // - pub fn __state11< + pub fn __state10< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -880,7 +778,7 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { @@ -888,19 +786,19 @@ mod __parse__Expr { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state25(arena, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); + __result = try!(__state20(arena, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); } Some((_, __tok @ Tok::Minus(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state24(arena, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); + __result = try!(__state21(arena, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); } Some((_, __tok @ Tok::RParen(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state26(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + __result = try!(__state22(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -912,168 +810,7 @@ mod __parse__Expr { return Ok(__result); } - // State 12 - // Factor = "*" (*) "(" Comma ")" [")"] - // Factor = "*" (*) "(" Comma ")" ["*"] - // Factor = "*" (*) "(" Comma ")" ["+"] - // Factor = "*" (*) "(" Comma ")" ["-"] - // Factor = "*" (*) "(" Comma ")" ["/"] - // - // "(" -> Shift(S27) - // - pub fn __state12< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, __tok @ Tok::LParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state27(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - return Ok(__result); - } - - // State 13 - // Term = "Num" (*) [")"] - // Term = "Num" (*) ["*"] - // Term = "Num" (*) ["+"] - // Term = "Num" (*) ["-"] - // Term = "Num" (*) ["/"] - // - // "+" -> Reduce(Term = "Num" => Call(ActionFn(8));) - // "/" -> Reduce(Term = "Num" => Call(ActionFn(8));) - // ")" -> Reduce(Term = "Num" => Call(ActionFn(8));) - // "-" -> Reduce(Term = "Num" => Call(ActionFn(8));) - // "*" -> Reduce(Term = "Num" => Call(ActionFn(8));) - // - pub fn __state13< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, Tok::Plus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action8(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - Some((_, Tok::Div(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action8(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - Some((_, Tok::RParen(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action8(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action8(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - Some((_, Tok::Times(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action8(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 14 - // Factor = Term (*) [")"] - // Factor = Term (*) ["*"] - // Factor = Term (*) ["+"] - // Factor = Term (*) ["-"] - // Factor = Term (*) ["/"] - // - // "*" -> Reduce(Factor = Term => Call(ActionFn(7));) - // "-" -> Reduce(Factor = Term => Call(ActionFn(7));) - // "/" -> Reduce(Factor = Term => Call(ActionFn(7));) - // ")" -> Reduce(Factor = Term => Call(ActionFn(7));) - // "+" -> Reduce(Factor = Term => Call(ActionFn(7));) - // - pub fn __state14< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, Tok::Times(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Div(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::RParen(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Plus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 15 + // State 11 // Expr = (*) Expr "+" Factor [")"] // Expr = (*) Expr "+" Factor ["+"] // Expr = (*) Expr "+" Factor ["-"] @@ -1119,24 +856,23 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "Num" -> Shift(S13) - // "(" -> Shift(S15) + // "Num" -> Shift(S9) + // "(" -> Shift(S11) // "*" -> Shift(S12) // - // Expr -> S28 - // Term -> S14 - // Factor -> S10 - pub fn __state15< + // Factor -> S13 + // Term -> S8 + // Expr -> S23 + pub fn __state11< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { @@ -1144,13 +880,13 @@ mod __parse__Expr { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state13(arena, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state9(arena, __lookbehind, __lookahead, __tokens, __sym1)); } Some((_, __tok @ Tok::LParen(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state15(arena, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state11(arena, __lookbehind, __lookahead, __tokens, __sym1)); } Some((_, __tok @ Tok::Times(..), __loc)) => { let mut __lookbehind = Some(__loc); @@ -1168,17 +904,17 @@ mod __parse__Expr { while __sym0.is_some() { let (__lookbehind, __lookahead, __nt) = __result; match __nt { - __Nonterminal::Expr(__nt) => { + __Nonterminal::Factor(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state28(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state13(arena, __lookbehind, __lookahead, __tokens, __sym1)); } __Nonterminal::Term(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state14(arena, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state8(arena, __lookbehind, __lookahead, __tokens, __sym1)); } - __Nonterminal::Factor(__nt) => { + __Nonterminal::Expr(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state10(arena, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state23(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -1188,79 +924,33 @@ mod __parse__Expr { 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 ["/"] - // Factor = (*) Term [EOF] - // Factor = (*) Term ["*"] - // Factor = (*) Term ["+"] - // Factor = (*) Term ["-"] - // Factor = (*) Term ["/"] - // Factor = (*) "*" "(" Comma ")" [EOF] - // Factor = (*) "*" "(" Comma ")" ["*"] - // Factor = (*) "*" "(" Comma ")" ["+"] - // Factor = (*) "*" "(" Comma ")" ["-"] - // Factor = (*) "*" "(" Comma ")" ["/"] - // Term = (*) "(" Expr ")" [EOF] - // Term = (*) "(" Expr ")" ["*"] - // Term = (*) "(" Expr ")" ["+"] - // Term = (*) "(" Expr ")" ["-"] - // Term = (*) "(" Expr ")" ["/"] - // Term = (*) "Num" [EOF] - // Term = (*) "Num" ["*"] - // Term = (*) "Num" ["+"] - // Term = (*) "Num" ["-"] - // Term = (*) "Num" ["/"] + // State 12 + // Factor = "*" (*) "(" Comma ")" [")"] + // Factor = "*" (*) "(" Comma ")" ["*"] + // Factor = "*" (*) "(" Comma ")" ["+"] + // Factor = "*" (*) "(" Comma ")" ["-"] + // Factor = "*" (*) "(" Comma ")" ["/"] // - // "*" -> Shift(S2) - // "(" -> Shift(S5) - // "Num" -> Shift(S4) + // "(" -> Shift(S24) // - // Factor -> S29 - // Term -> S1 - pub fn __state16< + pub fn __state12< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, - __sym0: &mut Option<&'ast Node<'ast>>, - __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + __sym0: &mut Option, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, __tok @ Tok::Times(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state2(arena, __lookbehind, __lookahead, __tokens, __sym2)); - } Some((_, __tok @ Tok::LParen(..), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); + let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state5(arena, __lookbehind, __lookahead, __tokens, __sym2)); - } - Some((_, Tok::Num(__tok0), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok0)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state4(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state24(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -1269,26 +959,81 @@ mod __parse__Expr { }); } } - while __sym1.is_some() { - let (__lookbehind, __lookahead, __nt) = __result; - match __nt { - __Nonterminal::Factor(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state29(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - __Nonterminal::Term(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state1(arena, __lookbehind, __lookahead, __tokens, __sym2)); - } - _ => { - return Ok((__lookbehind, __lookahead, __nt)); - } + return Ok(__result); + } + + // State 13 + // Expr = Factor (*) [")"] + // Expr = Factor (*) ["+"] + // Expr = Factor (*) ["-"] + // Factor = Factor (*) "*" Term [")"] + // Factor = Factor (*) "*" Term ["*"] + // Factor = Factor (*) "*" Term ["+"] + // Factor = Factor (*) "*" Term ["-"] + // Factor = Factor (*) "*" Term ["/"] + // Factor = Factor (*) "/" Term [")"] + // Factor = Factor (*) "/" Term ["*"] + // Factor = Factor (*) "/" Term ["+"] + // Factor = Factor (*) "/" Term ["-"] + // Factor = Factor (*) "/" Term ["/"] + // + // "+" -> Reduce(Expr = Factor => Call(ActionFn(3));) + // "/" -> Shift(S25) + // "-" -> Reduce(Expr = Factor => Call(ActionFn(3));) + // ")" -> Reduce(Expr = Factor => Call(ActionFn(3));) + // "*" -> Shift(S26) + // + pub fn __state13< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option<&'ast Node<'ast>>, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, __tok @ Tok::Div(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state25(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } + Some((_, __tok @ Tok::Times(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state26(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + Some((_, Tok::RParen(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); } } return Ok(__result); } - // State 17 + // State 14 // Expr = Expr "+" (*) Factor [EOF] // Expr = Expr "+" (*) Factor ["+"] // Expr = Expr "+" (*) Factor ["-"] @@ -1323,16 +1068,15 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "(" -> Shift(S5) - // "*" -> Shift(S2) - // "Num" -> Shift(S4) + // "*" -> Shift(S1) + // "(" -> Shift(S4) + // "Num" -> Shift(S3) // - // Factor -> S30 - // Term -> S1 - pub fn __state17< + // Factor -> S27 + // Term -> S2 + pub fn __state14< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -1340,27 +1084,27 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option<&'ast Node<'ast>>, __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, __tok @ Tok::LParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state5(arena, __lookbehind, __lookahead, __tokens, __sym2)); - } Some((_, __tok @ Tok::Times(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state2(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state1(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } + Some((_, __tok @ Tok::LParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state4(arena, __lookbehind, __lookahead, __tokens, __sym2)); } Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state4(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state3(arena, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -1374,11 +1118,248 @@ mod __parse__Expr { match __nt { __Nonterminal::Factor(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state30(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + __result = try!(__state27(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); } __Nonterminal::Term(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state1(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state2(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } + _ => { + return Ok((__lookbehind, __lookahead, __nt)); + } + } + } + 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 ["/"] + // Factor = (*) Term [EOF] + // Factor = (*) Term ["*"] + // Factor = (*) Term ["+"] + // Factor = (*) Term ["-"] + // Factor = (*) Term ["/"] + // Factor = (*) "*" "(" Comma ")" [EOF] + // Factor = (*) "*" "(" Comma ")" ["*"] + // Factor = (*) "*" "(" Comma ")" ["+"] + // Factor = (*) "*" "(" Comma ")" ["-"] + // Factor = (*) "*" "(" Comma ")" ["/"] + // Term = (*) "(" Expr ")" [EOF] + // Term = (*) "(" Expr ")" ["*"] + // Term = (*) "(" Expr ")" ["+"] + // Term = (*) "(" Expr ")" ["-"] + // Term = (*) "(" Expr ")" ["/"] + // Term = (*) "Num" [EOF] + // Term = (*) "Num" ["*"] + // Term = (*) "Num" ["+"] + // Term = (*) "Num" ["-"] + // Term = (*) "Num" ["/"] + // + // "Num" -> Shift(S3) + // "(" -> Shift(S4) + // "*" -> Shift(S1) + // + // Term -> S2 + // Factor -> S28 + pub fn __state15< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option<&'ast Node<'ast>>, + __sym1: &mut Option, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, Tok::Num(__tok0), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state3(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } + Some((_, __tok @ Tok::LParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state4(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } + Some((_, __tok @ Tok::Times(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state1(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + while __sym1.is_some() { + let (__lookbehind, __lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state2(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } + __Nonterminal::Factor(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state28(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookbehind, __lookahead, __nt)); + } + } + } + return Ok(__result); + } + + // State 16 + // Factor = Factor "*" (*) Term [EOF] + // Factor = Factor "*" (*) Term ["*"] + // Factor = Factor "*" (*) Term ["+"] + // Factor = Factor "*" (*) Term ["-"] + // Factor = Factor "*" (*) Term ["/"] + // Term = (*) "(" Expr ")" [EOF] + // Term = (*) "(" Expr ")" ["*"] + // Term = (*) "(" Expr ")" ["+"] + // Term = (*) "(" Expr ")" ["-"] + // Term = (*) "(" Expr ")" ["/"] + // Term = (*) "Num" [EOF] + // Term = (*) "Num" ["*"] + // Term = (*) "Num" ["+"] + // Term = (*) "Num" ["-"] + // Term = (*) "Num" ["/"] + // + // "(" -> Shift(S4) + // "Num" -> Shift(S3) + // + // Term -> S29 + pub fn __state16< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option<&'ast Node<'ast>>, + __sym1: &mut Option, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, __tok @ Tok::LParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state4(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } + Some((_, Tok::Num(__tok0), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state3(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + while __sym1.is_some() { + let (__lookbehind, __lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state29(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookbehind, __lookahead, __nt)); + } + } + } + return Ok(__result); + } + + // State 17 + // 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(S3) + // "(" -> Shift(S4) + // + // Term -> S30 + pub fn __state17< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option<&'ast Node<'ast>>, + __sym1: &mut Option, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, Tok::Num(__tok0), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state3(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } + Some((_, __tok @ Tok::LParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state4(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + while __sym1.is_some() { + let (__lookbehind, __lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state30(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -1389,6 +1370,46 @@ mod __parse__Expr { } // State 18 + // Factor = "*" "(" Comma (*) ")" [EOF] + // Factor = "*" "(" Comma (*) ")" ["*"] + // Factor = "*" "(" Comma (*) ")" ["+"] + // Factor = "*" "(" Comma (*) ")" ["-"] + // Factor = "*" "(" Comma (*) ")" ["/"] + // + // ")" -> Shift(S31) + // + pub fn __state18< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option>>, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, __tok @ Tok::RParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym3 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state31(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3)); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + return Ok(__result); + } + + // State 19 // ( ",") = (*) Expr "," ["("] // ( ",") = (*) Expr "," [")"] // ( ",") = (*) Expr "," ["*"] @@ -1449,47 +1470,46 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "(" -> Shift(S35) - // ")" -> Reduce(Expr? = => Call(ActionFn(12));) // "Num" -> Shift(S32) - // "*" -> Shift(S37) + // "(" -> Shift(S38) + // "*" -> Shift(S34) + // ")" -> Reduce(Expr? = => Call(ActionFn(12));) // - // ( ",") -> S36 + // Term -> S35 // Expr -> S33 - // Term -> S34 - // Expr? -> S31 - // Factor -> S38 - pub fn __state18< + // Expr? -> S37 + // Factor -> S39 + // ( ",") -> S36 + pub fn __state19< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option<::std::vec::Vec<&'ast Node<'ast>>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, __tok @ Tok::LParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state35(arena, __lookbehind, __lookahead, __tokens, __sym1)); - } Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; __result = try!(__state32(arena, __lookbehind, __lookahead, __tokens, __sym1)); } + Some((_, __tok @ Tok::LParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state38(arena, __lookbehind, __lookahead, __tokens, __sym1)); + } Some((_, __tok @ Tok::Times(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state37(arena, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state34(arena, __lookbehind, __lookahead, __tokens, __sym1)); } Some((_, Tok::RParen(..), _)) => { let __nt = super::__action12(arena, ); @@ -1505,25 +1525,25 @@ mod __parse__Expr { while __sym0.is_some() { let (__lookbehind, __lookahead, __nt) = __result; match __nt { - __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29(__nt) => { + __Nonterminal::Term(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state36(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state35(arena, __lookbehind, __lookahead, __tokens, __sym1)); } __Nonterminal::Expr(__nt) => { let __sym1 = &mut Some(__nt); __result = try!(__state33(arena, __lookbehind, __lookahead, __tokens, __sym1)); } - __Nonterminal::Term(__nt) => { - let __sym1 = &mut Some(__nt); - __result = try!(__state34(arena, __lookbehind, __lookahead, __tokens, __sym1)); - } __Nonterminal::Expr_3f(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state31(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state37(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); } __Nonterminal::Factor(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state38(arena, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state39(arena, __lookbehind, __lookahead, __tokens, __sym1)); + } + __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state36(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -1533,199 +1553,30 @@ mod __parse__Expr { return Ok(__result); } - // State 19 - // Factor = "*" "(" Comma (*) ")" [EOF] - // Factor = "*" "(" Comma (*) ")" ["*"] - // Factor = "*" "(" Comma (*) ")" ["+"] - // Factor = "*" "(" Comma (*) ")" ["-"] - // Factor = "*" "(" Comma (*) ")" ["/"] - // - // ")" -> Shift(S39) - // - pub fn __state19< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, __tok @ Tok::RParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym3 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state39(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2, __sym3)); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - return Ok(__result); - } - // State 20 - // Factor = Factor "/" Term (*) [EOF] - // Factor = Factor "/" Term (*) ["*"] - // Factor = Factor "/" Term (*) ["+"] - // Factor = Factor "/" Term (*) ["-"] - // Factor = Factor "/" Term (*) ["/"] - // - // "+" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "/" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "*" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // EOF -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "-" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // - pub fn __state20< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option<&'ast Node<'ast>>, - __sym1: &mut Option, - __sym2: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, Tok::Plus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action5(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action5(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 21 - // Factor = Factor "*" Term (*) [EOF] - // Factor = Factor "*" Term (*) ["*"] - // Factor = Factor "*" Term (*) ["+"] - // Factor = Factor "*" Term (*) ["-"] - // Factor = Factor "*" Term (*) ["/"] - // - // "-" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "/" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // EOF -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "+" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "*" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // - pub fn __state21< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option<&'ast Node<'ast>>, - __sym1: &mut Option, - __sym2: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action4(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action4(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 22 - // Factor = Factor "*" (*) Term [")"] - // Factor = Factor "*" (*) Term ["*"] - // Factor = Factor "*" (*) Term ["+"] - // Factor = Factor "*" (*) Term ["-"] - // Factor = Factor "*" (*) Term ["/"] + // Expr = Expr "+" (*) Factor [")"] + // Expr = Expr "+" (*) Factor ["+"] + // Expr = Expr "+" (*) Factor ["-"] + // Factor = (*) Factor "*" Term [")"] + // Factor = (*) Factor "*" Term ["*"] + // Factor = (*) Factor "*" Term ["+"] + // Factor = (*) Factor "*" Term ["-"] + // Factor = (*) Factor "*" Term ["/"] + // Factor = (*) Factor "/" Term [")"] + // Factor = (*) Factor "/" Term ["*"] + // Factor = (*) Factor "/" Term ["+"] + // Factor = (*) Factor "/" Term ["-"] + // Factor = (*) Factor "/" Term ["/"] + // Factor = (*) Term [")"] + // Factor = (*) Term ["*"] + // Factor = (*) Term ["+"] + // Factor = (*) Term ["-"] + // Factor = (*) Term ["/"] + // Factor = (*) "*" "(" Comma ")" [")"] + // Factor = (*) "*" "(" Comma ")" ["*"] + // Factor = (*) "*" "(" Comma ")" ["+"] + // Factor = (*) "*" "(" Comma ")" ["-"] + // Factor = (*) "*" "(" Comma ")" ["/"] // Term = (*) "(" Expr ")" [")"] // Term = (*) "(" Expr ")" ["*"] // Term = (*) "(" Expr ")" ["+"] @@ -1737,14 +1588,15 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "(" -> Shift(S15) - // "Num" -> Shift(S13) + // "*" -> Shift(S12) + // "(" -> Shift(S11) + // "Num" -> Shift(S9) // - // Term -> S40 - pub fn __state22< + // Factor -> S40 + // Term -> S8 + pub fn __state20< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -1752,21 +1604,27 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option<&'ast Node<'ast>>, __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { + Some((_, __tok @ Tok::Times(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state12(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } Some((_, __tok @ Tok::LParen(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state15(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state11(arena, __lookbehind, __lookahead, __tokens, __sym2)); } Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state13(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state9(arena, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -1778,79 +1636,13 @@ mod __parse__Expr { while __sym1.is_some() { let (__lookbehind, __lookahead, __nt) = __result; match __nt { - __Nonterminal::Term(__nt) => { + __Nonterminal::Factor(__nt) => { let __sym2 = &mut Some(__nt); __result = try!(__state40(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); } - _ => { - return Ok((__lookbehind, __lookahead, __nt)); - } - } - } - return Ok(__result); - } - - // State 23 - // 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(S15) - // "Num" -> Shift(S13) - // - // Term -> S41 - pub fn __state23< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option<&'ast Node<'ast>>, - __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, __tok @ Tok::LParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state15(arena, __lookbehind, __lookahead, __tokens, __sym2)); - } - Some((_, Tok::Num(__tok0), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok0)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state13(arena, __lookbehind, __lookahead, __tokens, __sym2)); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - while __sym1.is_some() { - let (__lookbehind, __lookahead, __nt) = __result; - match __nt { __Nonterminal::Term(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state41(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + __result = try!(__state8(arena, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -1860,7 +1652,7 @@ mod __parse__Expr { return Ok(__result); } - // State 24 + // State 21 // Expr = Expr "-" (*) Factor [")"] // Expr = Expr "-" (*) Factor ["+"] // Expr = Expr "-" (*) Factor ["-"] @@ -1896,15 +1688,14 @@ mod __parse__Expr { // Term = (*) "Num" ["/"] // // "*" -> Shift(S12) - // "(" -> Shift(S15) - // "Num" -> Shift(S13) + // "(" -> Shift(S11) + // "Num" -> Shift(S9) // - // Factor -> S42 - // Term -> S14 - pub fn __state24< + // Factor -> S41 + // Term -> S8 + pub fn __state21< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -1912,7 +1703,7 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option<&'ast Node<'ast>>, __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { @@ -1926,13 +1717,13 @@ mod __parse__Expr { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state15(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state11(arena, __lookbehind, __lookahead, __tokens, __sym2)); } Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state13(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state9(arena, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -1946,11 +1737,11 @@ mod __parse__Expr { match __nt { __Nonterminal::Factor(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state42(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + __result = try!(__state41(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); } __Nonterminal::Term(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state14(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state8(arena, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -1960,123 +1751,22 @@ mod __parse__Expr { return Ok(__result); } - // State 25 - // Expr = Expr "+" (*) Factor [")"] - // Expr = Expr "+" (*) Factor ["+"] - // Expr = Expr "+" (*) Factor ["-"] - // Factor = (*) Factor "*" Term [")"] - // Factor = (*) Factor "*" Term ["*"] - // Factor = (*) Factor "*" Term ["+"] - // Factor = (*) Factor "*" Term ["-"] - // Factor = (*) Factor "*" Term ["/"] - // Factor = (*) Factor "/" Term [")"] - // Factor = (*) Factor "/" Term ["*"] - // Factor = (*) Factor "/" Term ["+"] - // Factor = (*) Factor "/" Term ["-"] - // Factor = (*) Factor "/" Term ["/"] - // Factor = (*) Term [")"] - // Factor = (*) Term ["*"] - // Factor = (*) Term ["+"] - // Factor = (*) Term ["-"] - // Factor = (*) Term ["/"] - // Factor = (*) "*" "(" Comma ")" [")"] - // Factor = (*) "*" "(" Comma ")" ["*"] - // Factor = (*) "*" "(" Comma ")" ["+"] - // Factor = (*) "*" "(" Comma ")" ["-"] - // Factor = (*) "*" "(" Comma ")" ["/"] - // Term = (*) "(" Expr ")" [")"] - // Term = (*) "(" Expr ")" ["*"] - // Term = (*) "(" Expr ")" ["+"] - // Term = (*) "(" Expr ")" ["-"] - // Term = (*) "(" Expr ")" ["/"] - // Term = (*) "Num" [")"] - // Term = (*) "Num" ["*"] - // Term = (*) "Num" ["+"] - // Term = (*) "Num" ["-"] - // Term = (*) "Num" ["/"] - // - // "Num" -> Shift(S13) - // "*" -> Shift(S12) - // "(" -> Shift(S15) - // - // Term -> S14 - // Factor -> S43 - pub fn __state25< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option<&'ast Node<'ast>>, - __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, Tok::Num(__tok0), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok0)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state13(arena, __lookbehind, __lookahead, __tokens, __sym2)); - } - Some((_, __tok @ Tok::Times(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state12(arena, __lookbehind, __lookahead, __tokens, __sym2)); - } - Some((_, __tok @ Tok::LParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state15(arena, __lookbehind, __lookahead, __tokens, __sym2)); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - while __sym1.is_some() { - let (__lookbehind, __lookahead, __nt) = __result; - match __nt { - __Nonterminal::Term(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state14(arena, __lookbehind, __lookahead, __tokens, __sym2)); - } - __Nonterminal::Factor(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state43(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - _ => { - return Ok((__lookbehind, __lookahead, __nt)); - } - } - } - return Ok(__result); - } - - // State 26 + // State 22 // Term = "(" Expr ")" (*) [EOF] // Term = "(" Expr ")" (*) ["*"] // Term = "(" Expr ")" (*) ["+"] // Term = "(" Expr ")" (*) ["-"] // Term = "(" Expr ")" (*) ["/"] // - // "/" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) - // "-" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) // "+" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) // "*" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) + // "/" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) // EOF -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) + // "-" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) // - pub fn __state26< + pub fn __state22< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -2085,24 +1775,10 @@ mod __parse__Expr { __sym0: &mut Option, __sym1: &mut Option<&'ast Node<'ast>>, __sym2: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, Tok::Div(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action9(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } Some((_, Tok::Plus(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); @@ -2117,6 +1793,13 @@ mod __parse__Expr { let __nt = super::__action9(arena, __sym0, __sym1, __sym2); return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } None => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); @@ -2124,6 +1807,13 @@ mod __parse__Expr { let __nt = super::__action9(arena, __sym0, __sym1, __sym2); return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } _ => { return Err(__ParseError::UnrecognizedToken { token: __lookahead, @@ -2133,7 +1823,66 @@ mod __parse__Expr { } } - // State 27 + // State 23 + // Expr = Expr (*) "+" Factor [")"] + // Expr = Expr (*) "+" Factor ["+"] + // Expr = Expr (*) "+" Factor ["-"] + // Expr = Expr (*) "-" Factor [")"] + // Expr = Expr (*) "-" Factor ["+"] + // Expr = Expr (*) "-" Factor ["-"] + // Term = "(" Expr (*) ")" [")"] + // Term = "(" Expr (*) ")" ["*"] + // Term = "(" Expr (*) ")" ["+"] + // Term = "(" Expr (*) ")" ["-"] + // Term = "(" Expr (*) ")" ["/"] + // + // "+" -> Shift(S20) + // "-" -> Shift(S21) + // ")" -> Shift(S42) + // + pub fn __state23< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option<&'ast Node<'ast>>, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, __tok @ Tok::Plus(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state20(arena, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); + } + Some((_, __tok @ Tok::Minus(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state21(arena, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); + } + Some((_, __tok @ Tok::RParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state42(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + return Ok(__result); + } + + // State 24 // ( ",")* = (*) ["("] // ( ",")* = (*) [")"] // ( ",")* = (*) ["*"] @@ -2149,17 +1898,16 @@ mod __parse__Expr { // Factor = "*" "(" (*) Comma ")" ["-"] // Factor = "*" "(" (*) Comma ")" ["/"] // - // "*" -> Reduce(( ",")* = => Call(ActionFn(13));) // ")" -> Reduce(( ",")* = => Call(ActionFn(13));) // "(" -> Reduce(( ",")* = => Call(ActionFn(13));) // "Num" -> Reduce(( ",")* = => Call(ActionFn(13));) + // "*" -> Reduce(( ",")* = => Call(ActionFn(13));) // - // Comma -> S44 - // ( ",")* -> S18 - pub fn __state27< + // ( ",")* -> S19 + // Comma -> S43 + pub fn __state24< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -2167,14 +1915,10 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, Tok::Times(..), _)) => { - let __nt = super::__action13(arena, ); - __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt)); - } Some((_, Tok::RParen(..), _)) => { let __nt = super::__action13(arena, ); __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt)); @@ -2187,6 +1931,10 @@ mod __parse__Expr { let __nt = super::__action13(arena, ); __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt)); } + Some((_, Tok::Times(..), _)) => { + let __nt = super::__action13(arena, ); + __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt)); + } _ => { return Err(__ParseError::UnrecognizedToken { token: __lookahead, @@ -2197,13 +1945,13 @@ mod __parse__Expr { while __sym1.is_some() { let (__lookbehind, __lookahead, __nt) = __result; match __nt { - __Nonterminal::Comma_3cExpr_3e(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state44(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state18(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state19(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } + __Nonterminal::Comma_3cExpr_3e(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state43(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -2213,91 +1961,30 @@ mod __parse__Expr { return Ok(__result); } - // State 28 - // Expr = Expr (*) "+" Factor [")"] - // Expr = Expr (*) "+" Factor ["+"] - // Expr = Expr (*) "+" Factor ["-"] - // Expr = Expr (*) "-" Factor [")"] - // Expr = Expr (*) "-" Factor ["+"] - // Expr = Expr (*) "-" Factor ["-"] - // Term = "(" Expr (*) ")" [")"] - // Term = "(" Expr (*) ")" ["*"] - // Term = "(" Expr (*) ")" ["+"] - // Term = "(" Expr (*) ")" ["-"] - // Term = "(" Expr (*) ")" ["/"] + // State 25 + // 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(S25) - // ")" -> Shift(S45) - // "-" -> Shift(S24) + // "Num" -> Shift(S9) + // "(" -> Shift(S11) // - pub fn __state28< + // Term -> S44 + pub fn __state25< 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, __tok @ Tok::Plus(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state25(arena, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); - } - Some((_, __tok @ Tok::RParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state45(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - Some((_, __tok @ Tok::Minus(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state24(arena, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - return Ok(__result); - } - - // State 29 - // 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 => Call(ActionFn(1));) - // EOF -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) - // "+" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) - // "/" -> Shift(S8) - // "*" -> Shift(S9) - // - pub fn __state29< - 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -2305,43 +1992,21 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option<&'ast Node<'ast>>, __sym1: &mut Option, - __sym2: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, __tok @ Tok::Div(..), __loc)) => { + Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym3 = &mut Some((__tok)); + let mut __sym2 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state8(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); + __result = try!(__state9(arena, __lookbehind, __lookahead, __tokens, __sym2)); } - Some((_, __tok @ Tok::Times(..), __loc)) => { + Some((_, __tok @ Tok::LParen(..), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym3 = &mut Some((__tok)); + let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state9(arena, __lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action1(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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::__action1(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + __result = try!(__state11(arena, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -2350,10 +2015,91 @@ mod __parse__Expr { }); } } + while __sym1.is_some() { + let (__lookbehind, __lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state44(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookbehind, __lookahead, __nt)); + } + } + } return Ok(__result); } - // State 30 + // State 26 + // 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(S11) + // "Num" -> Shift(S9) + // + // Term -> S45 + pub fn __state26< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option<&'ast Node<'ast>>, + __sym1: &mut Option, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, __tok @ Tok::LParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state11(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } + Some((_, Tok::Num(__tok0), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state9(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + while __sym1.is_some() { + let (__lookbehind, __lookahead, __nt) = __result; + match __nt { + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state45(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookbehind, __lookahead, __nt)); + } + } + } + return Ok(__result); + } + + // State 27 // Expr = Expr "+" Factor (*) [EOF] // Expr = Expr "+" Factor (*) ["+"] // Expr = Expr "+" Factor (*) ["-"] @@ -2368,16 +2114,15 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["-"] // Factor = Factor (*) "/" Term ["/"] // - // EOF -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) - // "/" -> Shift(S8) - // "*" -> Shift(S9) // "+" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) // "-" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) + // "/" -> Shift(S17) + // EOF -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) + // "*" -> Shift(S16) // - pub fn __state30< + pub fn __state27< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -2386,7 +2131,7 @@ mod __parse__Expr { __sym0: &mut Option<&'ast Node<'ast>>, __sym1: &mut Option, __sym2: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { @@ -2394,20 +2139,13 @@ mod __parse__Expr { let mut __lookbehind = Some(__loc); let mut __sym3 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state8(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); + __result = try!(__state17(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); } Some((_, __tok @ Tok::Times(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym3 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state9(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action2(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + __result = try!(__state16(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); } Some((_, Tok::Plus(..), _)) => { let __sym0 = __sym0.take().unwrap(); @@ -2423,6 +2161,13 @@ mod __parse__Expr { let __nt = super::__action2(arena, __sym0, __sym1, __sym2); return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); } + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action2(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } _ => { return Err(__ParseError::UnrecognizedToken { token: __lookahead, @@ -2433,31 +2178,297 @@ mod __parse__Expr { return Ok(__result); } - // State 31 - // Comma = ( ",")* Expr? (*) [")"] + // State 28 + // 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(Comma = ( ",")*, Expr? => Call(ActionFn(10));) + // "+" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) + // "*" -> Shift(S16) + // "-" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) + // EOF -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) + // "/" -> Shift(S17) // - pub fn __state31< + pub fn __state28< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, - __sym0: &mut Option<::std::vec::Vec<&'ast Node<'ast>>>, - __sym1: &mut Option<::std::option::Option<&'ast Node<'ast>>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + __sym0: &mut Option<&'ast Node<'ast>>, + __sym1: &mut Option, + __sym2: &mut Option<&'ast Node<'ast>>, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, Tok::RParen(..), _)) => { + Some((_, __tok @ Tok::Times(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym3 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state16(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); + } + Some((_, __tok @ Tok::Div(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym3 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state17(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); + } + Some((_, Tok::Plus(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); - let __nt = super::__action10(arena, __sym0, __sym1); - return Ok((__lookbehind, __lookahead, __Nonterminal::Comma_3cExpr_3e(__nt))); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action1(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action1(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + return Ok(__result); + } + + // State 29 + // Factor = Factor "*" Term (*) [EOF] + // Factor = Factor "*" Term (*) ["*"] + // Factor = Factor "*" Term (*) ["+"] + // Factor = Factor "*" Term (*) ["-"] + // Factor = Factor "*" Term (*) ["/"] + // + // "/" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "*" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "-" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // EOF -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "+" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // + pub fn __state29< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option<&'ast Node<'ast>>, + __sym1: &mut Option, + __sym2: &mut Option<&'ast Node<'ast>>, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, Tok::Div(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action4(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action4(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 30 + // Factor = Factor "/" Term (*) [EOF] + // Factor = Factor "/" Term (*) ["*"] + // Factor = Factor "/" Term (*) ["+"] + // Factor = Factor "/" Term (*) ["-"] + // Factor = Factor "/" Term (*) ["/"] + // + // "+" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "/" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "-" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // EOF -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "*" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // + pub fn __state30< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option<&'ast Node<'ast>>, + __sym1: &mut Option, + __sym2: &mut Option<&'ast Node<'ast>>, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action5(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action5(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 31 + // Factor = "*" "(" Comma ")" (*) [EOF] + // Factor = "*" "(" Comma ")" (*) ["*"] + // Factor = "*" "(" Comma ")" (*) ["+"] + // Factor = "*" "(" Comma ")" (*) ["-"] + // Factor = "*" "(" Comma ")" (*) ["/"] + // + // EOF -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) + // "*" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) + // "/" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) + // "+" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) + // "-" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) + // + pub fn __state31< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option>>, + __sym3: &mut Option, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __sym3 = __sym3.take().unwrap(); + let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + Some((_, Tok::Times(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __sym3 = __sym3.take().unwrap(); + let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + Some((_, Tok::Div(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __sym3 = __sym3.take().unwrap(); + let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __sym3 = __sym3.take().unwrap(); + let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __sym3 = __sym3.take().unwrap(); + let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -2476,27 +2487,31 @@ mod __parse__Expr { // Term = "Num" (*) ["-"] // Term = "Num" (*) ["/"] // + // "+" -> Reduce(Term = "Num" => Call(ActionFn(8));) // "/" -> Reduce(Term = "Num" => Call(ActionFn(8));) // "*" -> Reduce(Term = "Num" => Call(ActionFn(8));) // ")" -> Reduce(Term = "Num" => Call(ActionFn(8));) - // "," -> Reduce(Term = "Num" => Call(ActionFn(8));) // "-" -> Reduce(Term = "Num" => Call(ActionFn(8));) - // "+" -> Reduce(Term = "Num" => Call(ActionFn(8));) + // "," -> Reduce(Term = "Num" => Call(ActionFn(8));) // pub fn __state32< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action8(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } Some((_, Tok::Div(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __nt = super::__action8(arena, __sym0); @@ -2512,17 +2527,12 @@ mod __parse__Expr { let __nt = super::__action8(arena, __sym0); return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); } - Some((_, Tok::Comma(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action8(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } Some((_, Tok::Minus(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __nt = super::__action8(arena, __sym0); return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); } - Some((_, Tok::Plus(..), _)) => { + Some((_, Tok::Comma(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __nt = super::__action8(arena, __sym0); return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); @@ -2551,43 +2561,42 @@ mod __parse__Expr { // Expr = Expr (*) "-" Factor ["-"] // Expr? = Expr (*) [")"] // - // "," -> Shift(S47) - // ")" -> Reduce(Expr? = Expr => Call(ActionFn(11));) // "-" -> Shift(S48) - // "+" -> Shift(S46) + // "," -> Shift(S46) + // "+" -> Shift(S47) + // ")" -> Reduce(Expr? = Expr => Call(ActionFn(11));) // pub fn __state33< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, __tok @ Tok::Comma(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state47(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); - } Some((_, __tok @ Tok::Minus(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; __result = try!(__state48(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); } - Some((_, __tok @ Tok::Plus(..), __loc)) => { + Some((_, __tok @ Tok::Comma(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; __result = try!(__state46(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); } + Some((_, __tok @ Tok::Plus(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state47(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } Some((_, Tok::RParen(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __nt = super::__action11(arena, __sym0); @@ -2604,6 +2613,45 @@ mod __parse__Expr { } // State 34 + // Factor = "*" (*) "(" Comma ")" [")"] + // Factor = "*" (*) "(" Comma ")" ["*"] + // Factor = "*" (*) "(" Comma ")" ["+"] + // Factor = "*" (*) "(" Comma ")" [","] + // Factor = "*" (*) "(" Comma ")" ["-"] + // Factor = "*" (*) "(" Comma ")" ["/"] + // + // "(" -> Shift(S49) + // + pub fn __state34< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, __tok @ Tok::LParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state49(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + return Ok(__result); + } + + // State 35 // Factor = Term (*) [")"] // Factor = Term (*) ["*"] // Factor = Term (*) ["+"] @@ -2612,23 +2660,22 @@ mod __parse__Expr { // Factor = Term (*) ["/"] // // "+" -> Reduce(Factor = Term => Call(ActionFn(7));) - // "/" -> Reduce(Factor = Term => Call(ActionFn(7));) - // ")" -> Reduce(Factor = Term => Call(ActionFn(7));) - // "*" -> Reduce(Factor = Term => Call(ActionFn(7));) // "-" -> Reduce(Factor = Term => Call(ActionFn(7));) // "," -> Reduce(Factor = Term => Call(ActionFn(7));) + // "/" -> Reduce(Factor = Term => Call(ActionFn(7));) + // "*" -> Reduce(Factor = Term => Call(ActionFn(7));) + // ")" -> Reduce(Factor = Term => Call(ActionFn(7));) // - pub fn __state34< + pub fn __state35< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { @@ -2637,21 +2684,6 @@ mod __parse__Expr { let __nt = super::__action7(arena, __sym0); return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } - Some((_, Tok::Div(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::RParen(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Times(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action7(arena, __sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } Some((_, Tok::Minus(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __nt = super::__action7(arena, __sym0); @@ -2662,6 +2694,21 @@ mod __parse__Expr { let __nt = super::__action7(arena, __sym0); return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } + Some((_, Tok::Div(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + Some((_, Tok::Times(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + Some((_, Tok::RParen(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action7(arena, __sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } _ => { return Err(__ParseError::UnrecognizedToken { token: __lookahead, @@ -2671,7 +2718,99 @@ mod __parse__Expr { } } - // State 35 + // State 36 + // ( ",")* = ( ",")* ( ",") (*) ["("] + // ( ",")* = ( ",")* ( ",") (*) [")"] + // ( ",")* = ( ",")* ( ",") (*) ["*"] + // ( ",")* = ( ",")* ( ",") (*) ["Num"] + // + // "*" -> Reduce(( ",")* = ( ",")*, ( ",") => Call(ActionFn(14));) + // "(" -> Reduce(( ",")* = ( ",")*, ( ",") => Call(ActionFn(14));) + // ")" -> Reduce(( ",")* = ( ",")*, ( ",") => Call(ActionFn(14));) + // "Num" -> Reduce(( ",")* = ( ",")*, ( ",") => Call(ActionFn(14));) + // + pub fn __state36< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option<::std::vec::Vec<&'ast Node<'ast>>>, + __sym1: &mut Option<&'ast Node<'ast>>, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, Tok::Times(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = super::__action14(arena, __sym0, __sym1); + return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt))); + } + Some((_, Tok::LParen(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = super::__action14(arena, __sym0, __sym1); + return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt))); + } + Some((_, Tok::RParen(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = super::__action14(arena, __sym0, __sym1); + return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt))); + } + Some((_, Tok::Num(_), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = super::__action14(arena, __sym0, __sym1); + return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 37 + // Comma = ( ",")* Expr? (*) [")"] + // + // ")" -> Reduce(Comma = ( ",")*, Expr? => Call(ActionFn(10));) + // + pub fn __state37< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option<::std::vec::Vec<&'ast Node<'ast>>>, + __sym1: &mut Option<::std::option::Option<&'ast Node<'ast>>>, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, Tok::RParen(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = super::__action10(arena, __sym0, __sym1); + return Ok((__lookbehind, __lookahead, __Nonterminal::Comma_3cExpr_3e(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 38 // Expr = (*) Expr "+" Factor [")"] // Expr = (*) Expr "+" Factor ["+"] // Expr = (*) Expr "+" Factor ["-"] @@ -2718,44 +2857,43 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // + // "Num" -> Shift(S9) + // "(" -> Shift(S11) // "*" -> Shift(S12) - // "Num" -> Shift(S13) - // "(" -> Shift(S15) // - // Term -> S14 - // Factor -> S10 - // Expr -> S49 - pub fn __state35< + // Factor -> S13 + // Term -> S8 + // Expr -> S50 + pub fn __state38< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, __tok @ Tok::Times(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state12(arena, __lookbehind, __lookahead, __tokens, __sym1)); - } Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state13(arena, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state9(arena, __lookbehind, __lookahead, __tokens, __sym1)); } Some((_, __tok @ Tok::LParen(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state15(arena, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state11(arena, __lookbehind, __lookahead, __tokens, __sym1)); + } + Some((_, __tok @ Tok::Times(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state12(arena, __lookbehind, __lookahead, __tokens, __sym1)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -2767,17 +2905,17 @@ mod __parse__Expr { while __sym0.is_some() { let (__lookbehind, __lookahead, __nt) = __result; match __nt { - __Nonterminal::Term(__nt) => { - let __sym1 = &mut Some(__nt); - __result = try!(__state14(arena, __lookbehind, __lookahead, __tokens, __sym1)); - } __Nonterminal::Factor(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state10(arena, __lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state13(arena, __lookbehind, __lookahead, __tokens, __sym1)); + } + __Nonterminal::Term(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state8(arena, __lookbehind, __lookahead, __tokens, __sym1)); } __Nonterminal::Expr(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state49(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state50(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -2787,106 +2925,7 @@ mod __parse__Expr { return Ok(__result); } - // State 36 - // ( ",")* = ( ",")* ( ",") (*) ["("] - // ( ",")* = ( ",")* ( ",") (*) [")"] - // ( ",")* = ( ",")* ( ",") (*) ["*"] - // ( ",")* = ( ",")* ( ",") (*) ["Num"] - // - // "Num" -> Reduce(( ",")* = ( ",")*, ( ",") => Call(ActionFn(14));) - // "*" -> Reduce(( ",")* = ( ",")*, ( ",") => Call(ActionFn(14));) - // "(" -> Reduce(( ",")* = ( ",")*, ( ",") => Call(ActionFn(14));) - // ")" -> Reduce(( ",")* = ( ",")*, ( ",") => Call(ActionFn(14));) - // - pub fn __state36< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option<::std::vec::Vec<&'ast Node<'ast>>>, - __sym1: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, Tok::Num(_), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __nt = super::__action14(arena, __sym0, __sym1); - return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt))); - } - Some((_, Tok::Times(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __nt = super::__action14(arena, __sym0, __sym1); - return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt))); - } - Some((_, Tok::LParen(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __nt = super::__action14(arena, __sym0, __sym1); - return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt))); - } - Some((_, Tok::RParen(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __nt = super::__action14(arena, __sym0, __sym1); - return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 37 - // Factor = "*" (*) "(" Comma ")" [")"] - // Factor = "*" (*) "(" Comma ")" ["*"] - // Factor = "*" (*) "(" Comma ")" ["+"] - // Factor = "*" (*) "(" Comma ")" [","] - // Factor = "*" (*) "(" Comma ")" ["-"] - // Factor = "*" (*) "(" Comma ")" ["/"] - // - // "(" -> Shift(S50) - // - pub fn __state37< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, __tok @ Tok::LParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state50(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - return Ok(__result); - } - - // State 38 + // State 39 // Expr = Factor (*) [")"] // Expr = Factor (*) ["+"] // Expr = Factor (*) [","] @@ -2906,22 +2945,21 @@ mod __parse__Expr { // // "+" -> Reduce(Expr = Factor => Call(ActionFn(3));) // "," -> Reduce(Expr = Factor => Call(ActionFn(3));) - // "/" -> Shift(S51) // ")" -> Reduce(Expr = Factor => Call(ActionFn(3));) - // "*" -> Shift(S52) + // "/" -> Shift(S52) + // "*" -> Shift(S51) // "-" -> Reduce(Expr = Factor => Call(ActionFn(3));) // - pub fn __state38< + pub fn __state39< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { @@ -2929,13 +2967,13 @@ mod __parse__Expr { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state51(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state52(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); } Some((_, __tok @ Tok::Times(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state52(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state51(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1)); } Some((_, Tok::Plus(..), _)) => { let __sym0 = __sym0.take().unwrap(); @@ -2967,312 +3005,7 @@ mod __parse__Expr { return Ok(__result); } - // State 39 - // Factor = "*" "(" Comma ")" (*) [EOF] - // Factor = "*" "(" Comma ")" (*) ["*"] - // Factor = "*" "(" Comma ")" (*) ["+"] - // Factor = "*" "(" Comma ")" (*) ["-"] - // Factor = "*" "(" Comma ")" (*) ["/"] - // - // "+" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) - // EOF -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) - // "-" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) - // "/" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) - // "*" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) - // - pub fn __state39< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option>>, - __sym3: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, Tok::Plus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __sym3 = __sym3.take().unwrap(); - let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __sym3 = __sym3.take().unwrap(); - let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __sym3 = __sym3.take().unwrap(); - let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Div(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __sym3 = __sym3.take().unwrap(); - let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Times(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __sym3 = __sym3.take().unwrap(); - let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - // State 40 - // Factor = Factor "*" Term (*) [")"] - // Factor = Factor "*" Term (*) ["*"] - // Factor = Factor "*" Term (*) ["+"] - // Factor = Factor "*" Term (*) ["-"] - // Factor = Factor "*" Term (*) ["/"] - // - // "*" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "+" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "/" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "-" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // ")" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // - pub fn __state40< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option<&'ast Node<'ast>>, - __sym1: &mut Option, - __sym2: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, Tok::Times(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action4(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 41 - // Factor = Factor "/" Term (*) [")"] - // Factor = Factor "/" Term (*) ["*"] - // Factor = Factor "/" Term (*) ["+"] - // Factor = Factor "/" Term (*) ["-"] - // Factor = Factor "/" Term (*) ["/"] - // - // ")" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "+" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "/" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "-" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "*" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // - pub fn __state41< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option<&'ast Node<'ast>>, - __sym1: &mut Option, - __sym2: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, Tok::RParen(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action5(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 42 - // Expr = Expr "-" Factor (*) [")"] - // Expr = Expr "-" Factor (*) ["+"] - // Expr = Expr "-" Factor (*) ["-"] - // Factor = Factor (*) "*" Term [")"] - // Factor = Factor (*) "*" Term ["*"] - // Factor = Factor (*) "*" Term ["+"] - // Factor = Factor (*) "*" Term ["-"] - // Factor = Factor (*) "*" Term ["/"] - // Factor = Factor (*) "/" Term [")"] - // Factor = Factor (*) "/" Term ["*"] - // Factor = Factor (*) "/" Term ["+"] - // Factor = Factor (*) "/" Term ["-"] - // Factor = Factor (*) "/" Term ["/"] - // - // ")" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) - // "*" -> Shift(S22) - // "/" -> Shift(S23) - // "-" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) - // "+" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) - // - pub fn __state42< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option<&'ast Node<'ast>>, - __sym1: &mut Option, - __sym2: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, __tok @ Tok::Times(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym3 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state22(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); - } - Some((_, __tok @ Tok::Div(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym3 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state23(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); - } - Some((_, Tok::RParen(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action1(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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::__action1(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - return Ok(__result); - } - - // State 43 // Expr = Expr "+" Factor (*) [")"] // Expr = Expr "+" Factor (*) ["+"] // Expr = Expr "+" Factor (*) ["-"] @@ -3287,16 +3020,15 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["-"] // Factor = Factor (*) "/" Term ["/"] // - // "/" -> Shift(S23) - // "*" -> Shift(S22) - // "-" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) - // "+" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) // ")" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) + // "+" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) + // "*" -> Shift(S26) + // "/" -> Shift(S25) + // "-" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) // - pub fn __state43< + pub fn __state40< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -3305,23 +3037,23 @@ mod __parse__Expr { __sym0: &mut Option<&'ast Node<'ast>>, __sym1: &mut Option, __sym2: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, __tok @ Tok::Div(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym3 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state23(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); - } Some((_, __tok @ Tok::Times(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym3 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state22(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); + __result = try!(__state26(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); } - Some((_, Tok::Minus(..), _)) => { + Some((_, __tok @ Tok::Div(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym3 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state25(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); + } + Some((_, Tok::RParen(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); @@ -3335,7 +3067,7 @@ mod __parse__Expr { let __nt = super::__action2(arena, __sym0, __sym1, __sym2); return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); } - Some((_, Tok::RParen(..), _)) => { + Some((_, Tok::Minus(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); @@ -3352,7 +3084,158 @@ mod __parse__Expr { return Ok(__result); } - // State 44 + // State 41 + // Expr = Expr "-" Factor (*) [")"] + // Expr = Expr "-" Factor (*) ["+"] + // Expr = Expr "-" Factor (*) ["-"] + // Factor = Factor (*) "*" Term [")"] + // Factor = Factor (*) "*" Term ["*"] + // Factor = Factor (*) "*" Term ["+"] + // Factor = Factor (*) "*" Term ["-"] + // Factor = Factor (*) "*" Term ["/"] + // Factor = Factor (*) "/" Term [")"] + // Factor = Factor (*) "/" Term ["*"] + // Factor = Factor (*) "/" Term ["+"] + // Factor = Factor (*) "/" Term ["-"] + // Factor = Factor (*) "/" Term ["/"] + // + // "*" -> Shift(S26) + // "+" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) + // "-" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) + // "/" -> Shift(S25) + // ")" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) + // + pub fn __state41< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option<&'ast Node<'ast>>, + __sym1: &mut Option, + __sym2: &mut Option<&'ast Node<'ast>>, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, __tok @ Tok::Times(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym3 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state26(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); + } + Some((_, __tok @ Tok::Div(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym3 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state25(arena, __lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + return Ok(__result); + } + + // State 42 + // Term = "(" Expr ")" (*) [")"] + // Term = "(" Expr ")" (*) ["*"] + // Term = "(" Expr ")" (*) ["+"] + // Term = "(" Expr ")" (*) ["-"] + // Term = "(" Expr ")" (*) ["/"] + // + // "/" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) + // ")" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) + // "+" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) + // "-" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) + // "*" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) + // + pub fn __state42< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option<&'ast Node<'ast>>, + __sym2: &mut Option, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, Tok::Div(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action9(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 43 // Factor = "*" "(" Comma (*) ")" [")"] // Factor = "*" "(" Comma (*) ")" ["*"] // Factor = "*" "(" Comma (*) ")" ["+"] @@ -3361,10 +3244,9 @@ mod __parse__Expr { // // ")" -> Shift(S53) // - pub fn __state44< + pub fn __state43< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -3373,7 +3255,7 @@ mod __parse__Expr { __sym0: &mut Option, __sym1: &mut Option, __sym2: &mut Option>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { @@ -3393,69 +3275,140 @@ mod __parse__Expr { return Ok(__result); } - // State 45 - // Term = "(" Expr ")" (*) [")"] - // Term = "(" Expr ")" (*) ["*"] - // Term = "(" Expr ")" (*) ["+"] - // Term = "(" Expr ")" (*) ["-"] - // Term = "(" Expr ")" (*) ["/"] + // State 44 + // Factor = Factor "/" Term (*) [")"] + // Factor = Factor "/" Term (*) ["*"] + // Factor = Factor "/" Term (*) ["+"] + // Factor = Factor "/" Term (*) ["-"] + // Factor = Factor "/" Term (*) ["/"] // - // "/" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) - // ")" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) - // "-" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) - // "+" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) - // "*" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) + // "-" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "*" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // ")" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "+" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "/" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) // - pub fn __state45< + pub fn __state44< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option<&'ast Node<'ast>>, - __sym2: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + __sym0: &mut Option<&'ast Node<'ast>>, + __sym1: &mut Option, + __sym2: &mut Option<&'ast Node<'ast>>, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, Tok::Div(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action9(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + let __nt = super::__action5(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + let __nt = super::__action5(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 45 + // Factor = Factor "*" Term (*) [")"] + // Factor = Factor "*" Term (*) ["*"] + // Factor = Factor "*" Term (*) ["+"] + // Factor = Factor "*" Term (*) ["-"] + // Factor = Factor "*" Term (*) ["/"] + // + // "*" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "-" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "+" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // ")" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "/" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // + pub fn __state45< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option<&'ast Node<'ast>>, + __sym1: &mut Option, + __sym2: &mut Option<&'ast Node<'ast>>, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, Tok::Times(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action4(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -3467,6 +3420,64 @@ mod __parse__Expr { } // State 46 + // ( ",") = Expr "," (*) ["("] + // ( ",") = Expr "," (*) [")"] + // ( ",") = Expr "," (*) ["*"] + // ( ",") = Expr "," (*) ["Num"] + // + // "(" -> Reduce(( ",") = Expr, "," => Call(ActionFn(15));) + // "Num" -> Reduce(( ",") = Expr, "," => Call(ActionFn(15));) + // ")" -> Reduce(( ",") = Expr, "," => Call(ActionFn(15));) + // "*" -> Reduce(( ",") = Expr, "," => Call(ActionFn(15));) + // + pub fn __state46< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option<&'ast Node<'ast>>, + __sym1: &mut Option, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, Tok::LParen(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = super::__action15(arena, __sym0, __sym1); + return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29(__nt))); + } + Some((_, Tok::Num(_), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = super::__action15(arena, __sym0, __sym1); + return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29(__nt))); + } + Some((_, Tok::RParen(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = super::__action15(arena, __sym0, __sym1); + return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29(__nt))); + } + Some((_, Tok::Times(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = super::__action15(arena, __sym0, __sym1); + return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 47 // Expr = Expr "+" (*) Factor [")"] // Expr = Expr "+" (*) Factor ["+"] // Expr = Expr "+" (*) Factor [","] @@ -3508,16 +3519,15 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // - // "*" -> Shift(S37) - // "(" -> Shift(S35) + // "*" -> Shift(S34) + // "(" -> Shift(S38) // "Num" -> Shift(S32) // - // Term -> S34 // Factor -> S54 - pub fn __state46< + // Term -> S35 + pub fn __state47< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -3525,7 +3535,7 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option<&'ast Node<'ast>>, __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { @@ -3533,13 +3543,13 @@ mod __parse__Expr { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state37(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state34(arena, __lookbehind, __lookahead, __tokens, __sym2)); } Some((_, __tok @ Tok::LParen(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state35(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state38(arena, __lookbehind, __lookahead, __tokens, __sym2)); } Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); @@ -3557,14 +3567,14 @@ mod __parse__Expr { while __sym1.is_some() { let (__lookbehind, __lookahead, __nt) = __result; match __nt { - __Nonterminal::Term(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state34(arena, __lookbehind, __lookahead, __tokens, __sym2)); - } __Nonterminal::Factor(__nt) => { let __sym2 = &mut Some(__nt); __result = try!(__state54(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); } + __Nonterminal::Term(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state35(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } _ => { return Ok((__lookbehind, __lookahead, __nt)); } @@ -3573,65 +3583,6 @@ mod __parse__Expr { return Ok(__result); } - // State 47 - // ( ",") = Expr "," (*) ["("] - // ( ",") = Expr "," (*) [")"] - // ( ",") = Expr "," (*) ["*"] - // ( ",") = Expr "," (*) ["Num"] - // - // "Num" -> Reduce(( ",") = Expr, "," => Call(ActionFn(15));) - // "(" -> Reduce(( ",") = Expr, "," => Call(ActionFn(15));) - // ")" -> Reduce(( ",") = Expr, "," => Call(ActionFn(15));) - // "*" -> Reduce(( ",") = Expr, "," => Call(ActionFn(15));) - // - pub fn __state47< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option<&'ast Node<'ast>>, - __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, Tok::Num(_), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __nt = super::__action15(arena, __sym0, __sym1); - return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29(__nt))); - } - Some((_, Tok::LParen(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __nt = super::__action15(arena, __sym0, __sym1); - return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29(__nt))); - } - Some((_, Tok::RParen(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __nt = super::__action15(arena, __sym0, __sym1); - return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29(__nt))); - } - Some((_, Tok::Times(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __nt = super::__action15(arena, __sym0, __sym1); - return Ok((__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - // State 48 // Expr = Expr "-" (*) Factor [")"] // Expr = Expr "-" (*) Factor ["+"] @@ -3674,16 +3625,15 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // + // "(" -> Shift(S38) + // "*" -> Shift(S34) // "Num" -> Shift(S32) - // "*" -> Shift(S37) - // "(" -> Shift(S35) // // Factor -> S55 - // Term -> S34 + // Term -> S35 pub fn __state48< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -3691,27 +3641,27 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option<&'ast Node<'ast>>, __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, Tok::Num(__tok0), __loc)) => { + Some((_, __tok @ Tok::LParen(..), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok0)); + let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state32(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state38(arena, __lookbehind, __lookahead, __tokens, __sym2)); } Some((_, __tok @ Tok::Times(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state37(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state34(arena, __lookbehind, __lookahead, __tokens, __sym2)); } - Some((_, __tok @ Tok::LParen(..), __loc)) => { + Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); + let mut __sym2 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state35(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state32(arena, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -3729,7 +3679,7 @@ mod __parse__Expr { } __Nonterminal::Term(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state34(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state35(arena, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -3740,67 +3690,6 @@ mod __parse__Expr { } // State 49 - // Expr = Expr (*) "+" Factor [")"] - // Expr = Expr (*) "+" Factor ["+"] - // Expr = Expr (*) "+" Factor ["-"] - // Expr = Expr (*) "-" Factor [")"] - // Expr = Expr (*) "-" Factor ["+"] - // Expr = Expr (*) "-" Factor ["-"] - // Term = "(" Expr (*) ")" [")"] - // Term = "(" Expr (*) ")" ["*"] - // Term = "(" Expr (*) ")" ["+"] - // Term = "(" Expr (*) ")" [","] - // Term = "(" Expr (*) ")" ["-"] - // Term = "(" Expr (*) ")" ["/"] - // - // "+" -> Shift(S25) - // ")" -> Shift(S56) - // "-" -> Shift(S24) - // - pub fn __state49< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, __tok @ Tok::Plus(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state25(arena, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); - } - Some((_, __tok @ Tok::RParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state56(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - Some((_, __tok @ Tok::Minus(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state24(arena, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - return Ok(__result); - } - - // State 50 // ( ",")* = (*) ["("] // ( ",")* = (*) [")"] // ( ",")* = (*) ["*"] @@ -3817,17 +3706,16 @@ mod __parse__Expr { // Factor = "*" "(" (*) Comma ")" ["-"] // Factor = "*" "(" (*) Comma ")" ["/"] // - // "*" -> Reduce(( ",")* = => Call(ActionFn(13));) // ")" -> Reduce(( ",")* = => Call(ActionFn(13));) - // "(" -> Reduce(( ",")* = => Call(ActionFn(13));) + // "*" -> Reduce(( ",")* = => Call(ActionFn(13));) // "Num" -> Reduce(( ",")* = => Call(ActionFn(13));) + // "(" -> Reduce(( ",")* = => Call(ActionFn(13));) // - // Comma -> S57 - // ( ",")* -> S18 - pub fn __state50< + // ( ",")* -> S19 + // Comma -> S56 + pub fn __state49< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -3835,19 +3723,15 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, Tok::Times(..), _)) => { - let __nt = super::__action13(arena, ); - __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt)); - } Some((_, Tok::RParen(..), _)) => { let __nt = super::__action13(arena, ); __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt)); } - Some((_, Tok::LParen(..), _)) => { + Some((_, Tok::Times(..), _)) => { let __nt = super::__action13(arena, ); __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt)); } @@ -3855,6 +3739,10 @@ mod __parse__Expr { let __nt = super::__action13(arena, ); __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt)); } + Some((_, Tok::LParen(..), _)) => { + let __nt = super::__action13(arena, ); + __result = (__lookbehind, __lookahead, __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt)); + } _ => { return Err(__ParseError::UnrecognizedToken { token: __lookahead, @@ -3865,13 +3753,13 @@ mod __parse__Expr { while __sym1.is_some() { let (__lookbehind, __lookahead, __nt) = __result; match __nt { - __Nonterminal::Comma_3cExpr_3e(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state57(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } __Nonterminal::_28_3cExpr_3e_20_22_2c_22_29_2a(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state18(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state19(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } + __Nonterminal::Comma_3cExpr_3e(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state56(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -3881,13 +3769,73 @@ mod __parse__Expr { return Ok(__result); } + // State 50 + // Expr = Expr (*) "+" Factor [")"] + // Expr = Expr (*) "+" Factor ["+"] + // Expr = Expr (*) "+" Factor ["-"] + // Expr = Expr (*) "-" Factor [")"] + // Expr = Expr (*) "-" Factor ["+"] + // Expr = Expr (*) "-" Factor ["-"] + // Term = "(" Expr (*) ")" [")"] + // Term = "(" Expr (*) ")" ["*"] + // Term = "(" Expr (*) ")" ["+"] + // Term = "(" Expr (*) ")" [","] + // Term = "(" Expr (*) ")" ["-"] + // Term = "(" Expr (*) ")" ["/"] + // + // "-" -> Shift(S21) + // "+" -> Shift(S20) + // ")" -> Shift(S57) + // + pub fn __state50< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option<&'ast Node<'ast>>, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, __tok @ Tok::Minus(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state21(arena, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); + } + Some((_, __tok @ Tok::Plus(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state20(arena, __lookbehind, __lookahead, __tokens, __sym1, __sym2)); + } + Some((_, __tok @ Tok::RParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state57(arena, __lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + return Ok(__result); + } + // State 51 - // Factor = Factor "/" (*) Term [")"] - // Factor = Factor "/" (*) Term ["*"] - // Factor = Factor "/" (*) Term ["+"] - // Factor = Factor "/" (*) Term [","] - // Factor = Factor "/" (*) Term ["-"] - // Factor = Factor "/" (*) Term ["/"] + // Factor = Factor "*" (*) Term [")"] + // Factor = Factor "*" (*) Term ["*"] + // Factor = Factor "*" (*) Term ["+"] + // Factor = Factor "*" (*) Term [","] + // Factor = Factor "*" (*) Term ["-"] + // Factor = Factor "*" (*) Term ["/"] // Term = (*) "(" Expr ")" [")"] // Term = (*) "(" Expr ")" ["*"] // Term = (*) "(" Expr ")" ["+"] @@ -3901,14 +3849,13 @@ mod __parse__Expr { // Term = (*) "Num" ["-"] // Term = (*) "Num" ["/"] // + // "(" -> Shift(S38) // "Num" -> Shift(S32) - // "(" -> Shift(S35) // // Term -> S58 pub fn __state51< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -3916,22 +3863,22 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option<&'ast Node<'ast>>, __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { + Some((_, __tok @ Tok::LParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state38(arena, __lookbehind, __lookahead, __tokens, __sym2)); + } Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; __result = try!(__state32(arena, __lookbehind, __lookahead, __tokens, __sym2)); } - Some((_, __tok @ Tok::LParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state35(arena, __lookbehind, __lookahead, __tokens, __sym2)); - } _ => { return Err(__ParseError::UnrecognizedToken { token: __lookahead, @@ -3955,12 +3902,12 @@ mod __parse__Expr { } // State 52 - // Factor = Factor "*" (*) Term [")"] - // Factor = Factor "*" (*) Term ["*"] - // Factor = Factor "*" (*) Term ["+"] - // Factor = Factor "*" (*) Term [","] - // Factor = Factor "*" (*) Term ["-"] - // Factor = Factor "*" (*) Term ["/"] + // Factor = Factor "/" (*) Term [")"] + // Factor = Factor "/" (*) Term ["*"] + // Factor = Factor "/" (*) Term ["+"] + // Factor = Factor "/" (*) Term [","] + // Factor = Factor "/" (*) Term ["-"] + // Factor = Factor "/" (*) Term ["/"] // Term = (*) "(" Expr ")" [")"] // Term = (*) "(" Expr ")" ["*"] // Term = (*) "(" Expr ")" ["+"] @@ -3975,13 +3922,12 @@ mod __parse__Expr { // Term = (*) "Num" ["/"] // // "Num" -> Shift(S32) - // "(" -> Shift(S35) + // "(" -> Shift(S38) // // Term -> S59 pub fn __state52< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -3989,7 +3935,7 @@ mod __parse__Expr { __tokens: &mut __TOKENS, __sym0: &mut Option<&'ast Node<'ast>>, __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { @@ -4003,7 +3949,7 @@ mod __parse__Expr { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state35(arena, __lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state38(arena, __lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -4034,16 +3980,15 @@ mod __parse__Expr { // Factor = "*" "(" Comma ")" (*) ["-"] // Factor = "*" "(" Comma ")" (*) ["/"] // + // "/" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) + // "+" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) // "*" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) // ")" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) // "-" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) - // "/" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) - // "+" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) // pub fn __state53< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -4053,10 +3998,26 @@ mod __parse__Expr { __sym1: &mut Option, __sym2: &mut Option>>, __sym3: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { + Some((_, Tok::Div(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __sym3 = __sym3.take().unwrap(); + let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __sym3 = __sym3.take().unwrap(); + let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } Some((_, Tok::Times(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); @@ -4081,22 +4042,6 @@ mod __parse__Expr { let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } - Some((_, Tok::Div(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __sym3 = __sym3.take().unwrap(); - let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Plus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __sym3 = __sym3.take().unwrap(); - let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } _ => { return Err(__ParseError::UnrecognizedToken { token: __lookahead, @@ -4124,17 +4069,16 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["-"] // Factor = Factor (*) "/" Term ["/"] // - // "/" -> Shift(S51) - // "+" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) - // "*" -> Shift(S52) - // ")" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) // "," -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) + // "+" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) // "-" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) + // "*" -> Shift(S51) + // "/" -> Shift(S52) + // ")" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));) // pub fn __state54< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -4143,36 +4087,22 @@ mod __parse__Expr { __sym0: &mut Option<&'ast Node<'ast>>, __sym1: &mut Option, __sym2: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, __tok @ Tok::Div(..), __loc)) => { + Some((_, __tok @ Tok::Times(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym3 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; __result = try!(__state51(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); } - Some((_, __tok @ Tok::Times(..), __loc)) => { + Some((_, __tok @ Tok::Div(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym3 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; __result = try!(__state52(arena, __lookbehind, __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::__action2(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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::__action2(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); - } Some((_, Tok::Comma(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); @@ -4180,6 +4110,13 @@ mod __parse__Expr { let __nt = super::__action2(arena, __sym0, __sym1, __sym2); return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } Some((_, Tok::Minus(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); @@ -4187,6 +4124,13 @@ mod __parse__Expr { let __nt = super::__action2(arena, __sym0, __sym1, __sym2); return Ok((__lookbehind, __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::__action2(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } _ => { return Err(__ParseError::UnrecognizedToken { token: __lookahead, @@ -4215,17 +4159,16 @@ mod __parse__Expr { // Factor = Factor (*) "/" Term ["-"] // Factor = Factor (*) "/" Term ["/"] // - // "+" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) - // "-" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) - // "/" -> Shift(S51) - // ")" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) // "," -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) - // "*" -> Shift(S52) + // "*" -> Shift(S51) + // ")" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) + // "+" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) + // "/" -> Shift(S52) + // "-" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));) // pub fn __state55< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -4234,30 +4177,23 @@ mod __parse__Expr { __sym0: &mut Option<&'ast Node<'ast>>, __sym1: &mut Option, __sym2: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, __tok @ Tok::Div(..), __loc)) => { + Some((_, __tok @ Tok::Times(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym3 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; __result = try!(__state51(arena, __lookbehind, __lookahead, __tokens, __sym2, __sym3)); } - Some((_, __tok @ Tok::Times(..), __loc)) => { + Some((_, __tok @ Tok::Div(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym3 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; __result = try!(__state52(arena, __lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); - } - Some((_, Tok::Minus(..), _)) => { + Some((_, Tok::Comma(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); @@ -4271,7 +4207,14 @@ mod __parse__Expr { let __nt = super::__action1(arena, __sym0, __sym1, __sym2); return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); } - Some((_, Tok::Comma(..), _)) => { + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action1(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt))); + } + Some((_, Tok::Minus(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); @@ -4289,88 +4232,6 @@ mod __parse__Expr { } // State 56 - // Term = "(" Expr ")" (*) [")"] - // Term = "(" Expr ")" (*) ["*"] - // Term = "(" Expr ")" (*) ["+"] - // Term = "(" Expr ")" (*) [","] - // Term = "(" Expr ")" (*) ["-"] - // Term = "(" Expr ")" (*) ["/"] - // - // ")" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) - // "+" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) - // "," -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) - // "*" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) - // "/" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) - // "-" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) - // - pub fn __state56< - 'ast, - __ERROR, - __TOKENS: Iterator>, - >( - arena: &'ast Arena<'ast>, - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option<&'ast Node<'ast>>, - __sym2: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); - match __lookahead { - Some((_, Tok::RParen(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action9(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - Some((_, Tok::Comma(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action9(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 57 // Factor = "*" "(" Comma (*) ")" [")"] // Factor = "*" "(" Comma (*) ")" ["*"] // Factor = "*" "(" Comma (*) ")" ["+"] @@ -4380,10 +4241,9 @@ mod __parse__Expr { // // ")" -> Shift(S60) // - pub fn __state57< + pub fn __state56< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -4392,7 +4252,7 @@ mod __parse__Expr { __sym0: &mut Option, __sym1: &mut Option, __sym2: &mut Option>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { @@ -4412,25 +4272,105 @@ mod __parse__Expr { return Ok(__result); } - // State 58 - // Factor = Factor "/" Term (*) [")"] - // Factor = Factor "/" Term (*) ["*"] - // Factor = Factor "/" Term (*) ["+"] - // Factor = Factor "/" Term (*) [","] - // Factor = Factor "/" Term (*) ["-"] - // Factor = Factor "/" Term (*) ["/"] + // State 57 + // Term = "(" Expr ")" (*) [")"] + // Term = "(" Expr ")" (*) ["*"] + // Term = "(" Expr ")" (*) ["+"] + // Term = "(" Expr ")" (*) [","] + // Term = "(" Expr ")" (*) ["-"] + // Term = "(" Expr ")" (*) ["/"] // - // "*" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "-" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "/" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // ")" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "+" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) - // "," -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "+" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) + // "/" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) + // "," -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) + // ")" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) + // "*" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) + // "-" -> Reduce(Term = "(", Expr, ")" => Call(ActionFn(9));) + // + pub fn __state57< + 'ast, + __TOKENS: Iterator>, + >( + arena: &'ast Arena<'ast>, + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option<&'ast Node<'ast>>, + __sym2: &mut Option, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); + match __lookahead { + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action9(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + Some((_, Tok::Comma(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action9(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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::__action9(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 58 + // Factor = Factor "*" Term (*) [")"] + // Factor = Factor "*" Term (*) ["*"] + // Factor = Factor "*" Term (*) ["+"] + // Factor = Factor "*" Term (*) [","] + // Factor = Factor "*" Term (*) ["-"] + // Factor = Factor "*" Term (*) ["/"] + // + // "*" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "," -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "-" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "+" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // ")" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "/" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) // pub fn __state58< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -4439,7 +4379,7 @@ mod __parse__Expr { __sym0: &mut Option<&'ast Node<'ast>>, __sym1: &mut Option, __sym2: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { @@ -4447,42 +4387,42 @@ mod __parse__Expr { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action5(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + let __nt = super::__action4(arena, __sym0, __sym1, __sym2); return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } Some((_, Tok::Comma(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action5(arena, __sym0, __sym1, __sym2); + let __nt = super::__action4(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } _ => { @@ -4495,24 +4435,23 @@ mod __parse__Expr { } // State 59 - // Factor = Factor "*" Term (*) [")"] - // Factor = Factor "*" Term (*) ["*"] - // Factor = Factor "*" Term (*) ["+"] - // Factor = Factor "*" Term (*) [","] - // Factor = Factor "*" Term (*) ["-"] - // Factor = Factor "*" Term (*) ["/"] + // Factor = Factor "/" Term (*) [")"] + // Factor = Factor "/" Term (*) ["*"] + // Factor = Factor "/" Term (*) ["+"] + // Factor = Factor "/" Term (*) [","] + // Factor = Factor "/" Term (*) ["-"] + // Factor = Factor "/" Term (*) ["/"] // - // "*" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "+" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "-" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "," -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // ")" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) - // "/" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));) + // "/" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "," -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "+" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "*" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // "-" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) + // ")" -> Reduce(Factor = Factor, "/", Term => Call(ActionFn(5));) // pub fn __state59< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -4521,50 +4460,50 @@ mod __parse__Expr { __sym0: &mut Option<&'ast Node<'ast>>, __sym1: &mut Option, __sym2: &mut Option<&'ast Node<'ast>>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { - Some((_, Tok::Times(..), _)) => { + Some((_, Tok::Div(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action4(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + let __nt = super::__action5(arena, __sym0, __sym1, __sym2); return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } Some((_, Tok::Comma(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action4(arena, __sym0, __sym1, __sym2); + let __nt = super::__action5(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); - return Ok((__lookbehind, __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(arena, __sym0, __sym1, __sym2); + let __nt = super::__action5(arena, __sym0, __sym1, __sym2); return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } _ => { @@ -4585,16 +4524,15 @@ mod __parse__Expr { // Factor = "*" "(" Comma ")" (*) ["/"] // // ")" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) - // "+" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) - // "*" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) // "/" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) - // "," -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) + // "*" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) // "-" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) + // "," -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) + // "+" -> Reduce(Factor = "*", "(", Comma, ")" => Call(ActionFn(6));) // pub fn __state60< 'ast, - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( arena: &'ast Arena<'ast>, __lookbehind: Option, @@ -4604,7 +4542,7 @@ mod __parse__Expr { __sym1: &mut Option, __sym2: &mut Option>>, __sym3: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<'ast, >); match __lookahead { @@ -4616,22 +4554,6 @@ mod __parse__Expr { let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } - Some((_, Tok::Plus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __sym3 = __sym3.take().unwrap(); - let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } - Some((_, Tok::Times(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __sym3 = __sym3.take().unwrap(); - let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); - return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); - } Some((_, Tok::Div(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); @@ -4640,7 +4562,7 @@ mod __parse__Expr { let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } - Some((_, Tok::Comma(..), _)) => { + Some((_, Tok::Times(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); @@ -4656,6 +4578,22 @@ mod __parse__Expr { let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); } + Some((_, Tok::Comma(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __sym3 = __sym3.take().unwrap(); + let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __sym3 = __sym3.take().unwrap(); + let __nt = super::__action6(arena, __sym0, __sym1, __sym2, __sym3); + return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt))); + } _ => { return Err(__ParseError::UnrecognizedToken { token: __lookahead, diff --git a/lalrpop-test/src/loc.rs b/lalrpop-test/src/loc.rs index 9fc60f6..c8b4f81 100644 --- a/lalrpop-test/src/loc.rs +++ b/lalrpop-test/src/loc.rs @@ -4,12 +4,11 @@ extern crate lalrpop_util as __lalrpop_util; use self::__lalrpop_util::ParseError as __ParseError; #[allow(non_snake_case)] pub fn parse_Items< - __ERROR, - __TOKEN: __ToTriple, + __TOKEN: __ToTriple, __TOKENS: IntoIterator, >( __tokens: __TOKENS, -) -> Result, __ParseError> +) -> Result, __ParseError> { let mut __tokens = __tokens.into_iter(); let mut __tokens = __tokens.map(|t| __ToTriple::to_triple(t)); @@ -34,11 +33,11 @@ mod __parse__Items { use super::__ToTriple; pub enum __Nonterminal<> { - ____Items(Vec<(usize, usize)>), - Items(Vec<(usize, usize)>), Spanned_3c_22_2b_22_3e((usize, usize)), - _40L(usize), + Items(Vec<(usize, usize)>), _40R(usize), + _40L(usize), + ____Items(Vec<(usize, usize)>), } // State 0 @@ -60,16 +59,15 @@ mod __parse__Items { // EOF -> Reduce(@L = => Lookahead;) // "+" -> Reduce(@L = => Lookahead;) // - // @L -> S1 // Items -> S2 + // @L -> S1 pub fn __state0< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<>); match __lookahead { @@ -95,14 +93,14 @@ mod __parse__Items { loop { let (__lookbehind, __lookahead, __nt) = __result; match __nt { - __Nonterminal::_40L(__nt) => { - let __sym0 = &mut Some(__nt); - __result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0)); - } __Nonterminal::Items(__nt) => { let __sym0 = &mut Some(__nt); __result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0)); } + __Nonterminal::_40L(__nt) => { + let __sym0 = &mut Some(__nt); + __result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0)); + } _ => { return Ok((__lookbehind, __lookahead, __nt)); } @@ -118,24 +116,23 @@ mod __parse__Items { // Items = @L (*) @R ["+"] // Items = @L (*) @R ["-"] // - // EOF -> Reduce(@R = => Lookbehind;) - // "-" -> Reduce(@R = => Lookbehind;) // "+" -> Reduce(@R = => Lookbehind;) + // "-" -> Reduce(@R = => Lookbehind;) + // EOF -> Reduce(@R = => Lookbehind;) // // @R -> S3 pub fn __state1< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<>); match __lookahead { - None => { + Some((_, Tok::Plus(..), _)) => { let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default(); __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt)); } @@ -143,7 +140,7 @@ mod __parse__Items { let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default(); __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt)); } - Some((_, Tok::Plus(..), _)) => { + None => { let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default(); __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt)); } @@ -183,20 +180,19 @@ mod __parse__Items { // __Items = Items (*) [EOF] // // "+" -> Reduce(@L = => Lookahead;) + // "-" -> Shift(S6) // EOF -> Reduce(__Items = Items => Call(ActionFn(0));) - // "-" -> Shift(S4) // - // @L -> S6 // Spanned<"+"> -> S5 + // @L -> S4 pub fn __state2< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<>); match __lookahead { @@ -204,7 +200,7 @@ mod __parse__Items { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym0, __sym1)); } Some((_, Tok::Plus(..), _)) => { let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default(); @@ -225,14 +221,14 @@ mod __parse__Items { while __sym0.is_some() { let (__lookbehind, __lookahead, __nt) = __result; match __nt { - __Nonterminal::_40L(__nt) => { - let __sym1 = &mut Some(__nt); - __result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym1)); - } __Nonterminal::Spanned_3c_22_2b_22_3e(__nt) => { let __sym1 = &mut Some(__nt); __result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0, __sym1)); } + __Nonterminal::_40L(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym1)); + } _ => { return Ok((__lookbehind, __lookahead, __nt)); } @@ -246,24 +242,23 @@ mod __parse__Items { // Items = @L @R (*) ["+"] // Items = @L @R (*) ["-"] // - // "+" -> Reduce(Items = @L, @R => Call(ActionFn(1));) - // "-" -> Reduce(Items = @L, @R => Call(ActionFn(1));) // EOF -> Reduce(Items = @L, @R => Call(ActionFn(1));) + // "-" -> Reduce(Items = @L, @R => Call(ActionFn(1));) + // "+" -> Reduce(Items = @L, @R => Call(ActionFn(1));) // pub fn __state3< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<>); match __lookahead { - Some((_, Tok::Plus(..), _)) => { + None => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __nt = super::__action1(__sym0, __sym1); @@ -275,7 +270,7 @@ mod __parse__Items { let __nt = super::__action1(__sym0, __sym1); return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); } - None => { + Some((_, Tok::Plus(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __nt = super::__action1(__sym0, __sym1); @@ -291,119 +286,20 @@ mod __parse__Items { } // State 4 - // Items = Items "-" (*) [EOF] - // Items = Items "-" (*) ["+"] - // Items = Items "-" (*) ["-"] - // - // "+" -> Reduce(Items = Items, "-" => Call(ActionFn(3));) - // "-" -> Reduce(Items = Items, "-" => Call(ActionFn(3));) - // EOF -> Reduce(Items = Items, "-" => Call(ActionFn(3));) - // - pub fn __state4< - __ERROR, - __TOKENS: Iterator>, - >( - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option>, - __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<>); - match __lookahead { - Some((_, Tok::Plus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __nt = super::__action3(__sym0, __sym1); - return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); - } - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __nt = super::__action3(__sym0, __sym1); - return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __nt = super::__action3(__sym0, __sym1); - return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 5 - // Items = Items Spanned<"+"> (*) [EOF] - // Items = Items Spanned<"+"> (*) ["+"] - // Items = Items Spanned<"+"> (*) ["-"] - // - // "-" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));) - // "+" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));) - // EOF -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));) - // - pub fn __state5< - __ERROR, - __TOKENS: Iterator>, - >( - __lookbehind: Option, - __lookahead: Option<(usize, Tok, usize)>, - __tokens: &mut __TOKENS, - __sym0: &mut Option>, - __sym1: &mut Option<(usize, usize)>, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> - { - let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<>); - match __lookahead { - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __nt = super::__action2(__sym0, __sym1); - return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); - } - Some((_, Tok::Plus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __nt = super::__action2(__sym0, __sym1); - return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __nt = super::__action2(__sym0, __sym1); - return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 6 // Spanned<"+"> = @L (*) "+" @R [EOF] // Spanned<"+"> = @L (*) "+" @R ["+"] // Spanned<"+"> = @L (*) "+" @R ["-"] // // "+" -> Shift(S7) // - pub fn __state6< - __ERROR, - __TOKENS: Iterator>, + pub fn __state4< + __TOKENS: Iterator>, >( __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<>); match __lookahead { @@ -423,6 +319,102 @@ mod __parse__Items { return Ok(__result); } + // State 5 + // Items = Items Spanned<"+"> (*) [EOF] + // Items = Items Spanned<"+"> (*) ["+"] + // Items = Items Spanned<"+"> (*) ["-"] + // + // EOF -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));) + // "-" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));) + // "+" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));) + // + pub fn __state5< + __TOKENS: Iterator>, + >( + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option>, + __sym1: &mut Option<(usize, usize)>, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<>); + match __lookahead { + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = super::__action2(__sym0, __sym1); + return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); + } + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = super::__action2(__sym0, __sym1); + return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); + } + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = super::__action2(__sym0, __sym1); + return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 6 + // Items = Items "-" (*) [EOF] + // Items = Items "-" (*) ["+"] + // Items = Items "-" (*) ["-"] + // + // "-" -> Reduce(Items = Items, "-" => Call(ActionFn(3));) + // EOF -> Reduce(Items = Items, "-" => Call(ActionFn(3));) + // "+" -> Reduce(Items = Items, "-" => Call(ActionFn(3));) + // + pub fn __state6< + __TOKENS: Iterator>, + >( + __lookbehind: Option, + __lookahead: Option<(usize, Tok, usize)>, + __tokens: &mut __TOKENS, + __sym0: &mut Option>, + __sym1: &mut Option, + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> + { + let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<>); + match __lookahead { + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = super::__action3(__sym0, __sym1); + return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = super::__action3(__sym0, __sym1); + return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); + } + Some((_, Tok::Plus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __nt = super::__action3(__sym0, __sym1); + return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + // State 7 // @R = (*) [EOF] // @R = (*) ["+"] @@ -432,20 +424,19 @@ mod __parse__Items { // Spanned<"+"> = @L "+" (*) @R ["-"] // // "-" -> Reduce(@R = => Lookbehind;) - // "+" -> Reduce(@R = => Lookbehind;) // EOF -> Reduce(@R = => Lookbehind;) + // "+" -> Reduce(@R = => Lookbehind;) // // @R -> S8 pub fn __state7< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<>); match __lookahead { @@ -453,11 +444,11 @@ mod __parse__Items { let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default(); __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt)); } - Some((_, Tok::Plus(..), _)) => { + None => { let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default(); __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt)); } - None => { + Some((_, Tok::Plus(..), _)) => { let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default(); __result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt)); } @@ -489,12 +480,11 @@ mod __parse__Items { // Spanned<"+"> = @L "+" @R (*) ["-"] // // "-" -> Reduce(Spanned<"+"> = @L, "+", @R => Call(ActionFn(4));) - // "+" -> Reduce(Spanned<"+"> = @L, "+", @R => Call(ActionFn(4));) // EOF -> Reduce(Spanned<"+"> = @L, "+", @R => Call(ActionFn(4));) + // "+" -> Reduce(Spanned<"+"> = @L, "+", @R => Call(ActionFn(4));) // pub fn __state8< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( __lookbehind: Option, __lookahead: Option<(usize, Tok, usize)>, @@ -502,7 +492,7 @@ mod __parse__Items { __sym0: &mut Option, __sym1: &mut Option, __sym2: &mut Option, - ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> + ) -> Result<(Option, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError> { let mut __result: (Option, Option<(usize, Tok, usize)>, __Nonterminal<>); match __lookahead { @@ -513,14 +503,14 @@ mod __parse__Items { let __nt = super::__action4(__sym0, __sym1, __sym2); return Ok((__lookbehind, __lookahead, __Nonterminal::Spanned_3c_22_2b_22_3e(__nt))); } - Some((_, Tok::Plus(..), _)) => { + 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((__lookbehind, __lookahead, __Nonterminal::Spanned_3c_22_2b_22_3e(__nt))); } - None => { + Some((_, Tok::Plus(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); diff --git a/lalrpop-test/src/main.rs b/lalrpop-test/src/main.rs index 2f4d43d..7fff51c 100644 --- a/lalrpop-test/src/main.rs +++ b/lalrpop-test/src/main.rs @@ -20,6 +20,9 @@ mod loc; /// test that uses `super` in paths in various places mod use_super; +/// test that exercises locations and spans +mod error; + mod util; /// This constant is here so that some of the generator parsers can @@ -120,3 +123,14 @@ fn use_super_test1() { util::test(|v| use_super::parse_S(v), "()", 0); } +#[test] +fn error_test1() { + use lalrpop_util::ParseError; + match util::test_err_gen(error::parse_Items, "---+") { + Err(ParseError::User { error: '+' }) => { /* OK! */ } + r => { + panic!("unexpected response from parser: {:?}", r); + } + } +} + diff --git a/lalrpop-test/src/sub.rs b/lalrpop-test/src/sub.rs index 9084637..8c53d6e 100644 --- a/lalrpop-test/src/sub.rs +++ b/lalrpop-test/src/sub.rs @@ -4,12 +4,11 @@ extern crate lalrpop_util as __lalrpop_util; use self::__lalrpop_util::ParseError as __ParseError; #[allow(non_snake_case)] pub fn parse_S< - __ERROR, - __TOKEN: __ToTriple, + __TOKEN: __ToTriple, __TOKENS: IntoIterator, >( __tokens: __TOKENS, -) -> Result> +) -> Result> { let mut __tokens = __tokens.into_iter(); let mut __tokens = __tokens.map(|t| __ToTriple::to_triple(t)); @@ -34,10 +33,10 @@ mod __parse__S { use super::__ToTriple; pub enum __Nonterminal<> { - T(i32), - S(i32), E(i32), + T(i32), ____S(i32), + S(i32), } // State 0 @@ -52,20 +51,19 @@ mod __parse__S { // T = (*) "Num" ["-"] // __S = (*) S [EOF] // - // "(" -> Shift(S3) - // "Num" -> Shift(S1) + // "(" -> Shift(S1) + // "Num" -> Shift(S3) // + // E -> S4 // S -> S5 - // E -> S2 - // T -> S4 + // T -> S2 pub fn __state0< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { @@ -73,13 +71,13 @@ mod __parse__S { let mut __lookbehind = Some(__loc); let mut __sym0 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0)); + __result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0)); } Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym0 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0)); + __result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -91,17 +89,17 @@ mod __parse__S { loop { let (__lookbehind, __lookahead, __nt) = __result; match __nt { + __Nonterminal::E(__nt) => { + let __sym0 = &mut Some(__nt); + __result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0)); + } __Nonterminal::S(__nt) => { let __sym0 = &mut Some(__nt); __result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0)); } - __Nonterminal::E(__nt) => { - let __sym0 = &mut Some(__nt); - __result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0)); - } __Nonterminal::T(__nt) => { let __sym0 = &mut Some(__nt); - __result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0)); + __result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -111,85 +109,6 @@ mod __parse__S { } // State 1 - // T = "Num" (*) [EOF] - // T = "Num" (*) ["-"] - // - // EOF -> Reduce(T = "Num" => Call(ActionFn(4));) - // "-" -> Reduce(T = "Num" => Call(ActionFn(4));) - // - pub fn __state1< - __ERROR, - __TOKENS: Iterator>, - >( - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); - match __lookahead { - None => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action4(__sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt))); - } - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action4(__sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 2 - // E = E (*) "-" T [EOF] - // E = E (*) "-" T ["-"] - // S = E (*) [EOF] - // - // "-" -> Shift(S6) - // EOF -> Reduce(S = E => Call(ActionFn(1));) - // - pub fn __state2< - __ERROR, - __TOKENS: Iterator>, - >( - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); - match __lookahead { - Some((_, __tok @ Tok::Minus(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym0, __sym1)); - } - None => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action1(__sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::S(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - return Ok(__result); - } - - // State 3 // E = (*) E "-" T [")"] // E = (*) E "-" T ["-"] // E = (*) T [")"] @@ -201,20 +120,19 @@ mod __parse__S { // T = (*) "Num" [")"] // T = (*) "Num" ["-"] // - // "(" -> Shift(S8) + // "(" -> Shift(S9) // "Num" -> Shift(S7) // - // T -> S10 - // E -> S9 - pub fn __state3< - __ERROR, - __TOKENS: Iterator>, + // E -> S8 + // T -> S6 + pub fn __state1< + __TOKENS: Iterator>, >( __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { @@ -222,7 +140,7 @@ mod __parse__S { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym1)); } Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); @@ -240,13 +158,13 @@ mod __parse__S { while __sym0.is_some() { let (__lookbehind, __lookahead, __nt) = __result; match __nt { - __Nonterminal::T(__nt) => { - let __sym1 = &mut Some(__nt); - __result = try!(__state10(__lookbehind, __lookahead, __tokens, __sym1)); - } __Nonterminal::E(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } + __Nonterminal::T(__nt) => { + let __sym1 = &mut Some(__nt); + __result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym1)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -256,31 +174,30 @@ mod __parse__S { return Ok(__result); } - // State 4 + // State 2 // E = T (*) [EOF] // E = T (*) ["-"] // - // EOF -> Reduce(E = T => Call(ActionFn(3));) // "-" -> Reduce(E = T => Call(ActionFn(3));) + // EOF -> Reduce(E = T => Call(ActionFn(3));) // - pub fn __state4< - __ERROR, - __TOKENS: Iterator>, + pub fn __state2< + __TOKENS: Iterator>, >( __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - None => { + Some((_, Tok::Minus(..), _)) => { let __sym0 = __sym0.take().unwrap(); let __nt = super::__action3(__sym0); return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt))); } - Some((_, Tok::Minus(..), _)) => { + None => { let __sym0 = __sym0.take().unwrap(); let __nt = super::__action3(__sym0); return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt))); @@ -294,20 +211,96 @@ mod __parse__S { } } + // State 3 + // T = "Num" (*) [EOF] + // T = "Num" (*) ["-"] + // + // EOF -> Reduce(T = "Num" => Call(ActionFn(4));) + // "-" -> Reduce(T = "Num" => Call(ActionFn(4));) + // + pub fn __state3< + __TOKENS: Iterator>, + >( + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); + match __lookahead { + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action4(__sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt))); + } + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action4(__sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 4 + // E = E (*) "-" T [EOF] + // E = E (*) "-" T ["-"] + // S = E (*) [EOF] + // + // EOF -> Reduce(S = E => Call(ActionFn(1));) + // "-" -> Shift(S10) + // + pub fn __state4< + __TOKENS: Iterator>, + >( + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); + match __lookahead { + Some((_, __tok @ Tok::Minus(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state10(__lookbehind, __lookahead, __tokens, __sym0, __sym1)); + } + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action1(__sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::S(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + return Ok(__result); + } + // State 5 // __S = S (*) [EOF] // // EOF -> Reduce(__S = S => Call(ActionFn(0));) // pub fn __state5< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { @@ -326,41 +319,32 @@ mod __parse__S { } // State 6 - // E = E "-" (*) T [EOF] - // E = E "-" (*) T ["-"] - // T = (*) "(" E ")" [EOF] - // T = (*) "(" E ")" ["-"] - // T = (*) "Num" [EOF] - // T = (*) "Num" ["-"] + // E = T (*) [")"] + // E = T (*) ["-"] // - // "(" -> Shift(S3) - // "Num" -> Shift(S1) + // "-" -> Reduce(E = T => Call(ActionFn(3));) + // ")" -> Reduce(E = T => Call(ActionFn(3));) // - // T -> S11 pub fn __state6< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, - __sym1: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, __tok @ Tok::LParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym2)); + Some((_, Tok::Minus(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(__sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt))); } - Some((_, Tok::Num(__tok0), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok0)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym2)); + Some((_, Tok::RParen(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action3(__sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt))); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -369,19 +353,6 @@ mod __parse__S { }); } } - while __sym1.is_some() { - let (__lookbehind, __lookahead, __nt) = __result; - match __nt { - __Nonterminal::T(__nt) => { - let __sym2 = &mut Some(__nt); - __result = try!(__state11(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - _ => { - return Ok((__lookbehind, __lookahead, __nt)); - } - } - } - return Ok(__result); } // State 7 @@ -392,14 +363,13 @@ mod __parse__S { // ")" -> Reduce(T = "Num" => Call(ActionFn(4));) // pub fn __state7< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { @@ -423,6 +393,49 @@ mod __parse__S { } // State 8 + // E = E (*) "-" T [")"] + // E = E (*) "-" T ["-"] + // T = "(" E (*) ")" [EOF] + // T = "(" E (*) ")" ["-"] + // + // ")" -> Shift(S12) + // "-" -> Shift(S11) + // + pub fn __state8< + __TOKENS: Iterator>, + >( + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); + match __lookahead { + Some((_, __tok @ Tok::RParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state12(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + } + Some((_, __tok @ Tok::Minus(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state11(__lookbehind, __lookahead, __tokens, __sym1, __sym2)); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + return Ok(__result); + } + + // State 9 // E = (*) E "-" T [")"] // E = (*) E "-" T ["-"] // E = (*) T [")"] @@ -434,35 +447,34 @@ mod __parse__S { // T = (*) "Num" [")"] // T = (*) "Num" ["-"] // - // "(" -> Shift(S8) // "Num" -> Shift(S7) + // "(" -> Shift(S9) // - // E -> S12 - // T -> S10 - pub fn __state8< - __ERROR, - __TOKENS: Iterator>, + // E -> S13 + // T -> S6 + pub fn __state9< + __TOKENS: Iterator>, >( __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, __tok @ Tok::LParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym1 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym1)); - } Some((_, Tok::Num(__tok0), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym1 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; __result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym1)); } + Some((_, __tok @ Tok::LParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym1 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym1)); + } _ => { return Err(__ParseError::UnrecognizedToken { token: __lookahead, @@ -475,11 +487,11 @@ mod __parse__S { match __nt { __Nonterminal::E(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state12(__lookbehind, __lookahead, __tokens, __sym0, __sym1)); + __result = try!(__state13(__lookbehind, __lookahead, __tokens, __sym0, __sym1)); } __Nonterminal::T(__nt) => { let __sym1 = &mut Some(__nt); - __result = try!(__state10(__lookbehind, __lookahead, __tokens, __sym1)); + __result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym1)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -489,198 +501,27 @@ mod __parse__S { return Ok(__result); } - // State 9 - // E = E (*) "-" T [")"] - // E = E (*) "-" T ["-"] - // T = "(" E (*) ")" [EOF] - // T = "(" E (*) ")" ["-"] - // - // "-" -> Shift(S13) - // ")" -> Shift(S14) - // - pub fn __state9< - __ERROR, - __TOKENS: Iterator>, - >( - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); - match __lookahead { - Some((_, __tok @ Tok::Minus(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state13(__lookbehind, __lookahead, __tokens, __sym1, __sym2)); - } - Some((_, __tok @ Tok::RParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state14(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - return Ok(__result); - } - // State 10 - // E = T (*) [")"] - // E = T (*) ["-"] - // - // "-" -> Reduce(E = T => Call(ActionFn(3));) - // ")" -> Reduce(E = T => Call(ActionFn(3));) - // - pub fn __state10< - __ERROR, - __TOKENS: Iterator>, - >( - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); - match __lookahead { - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(__sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt))); - } - Some((_, Tok::RParen(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action3(__sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 11 - // E = E "-" T (*) [EOF] - // E = E "-" T (*) ["-"] - // - // "-" -> Reduce(E = E, "-", T => Call(ActionFn(2));) - // EOF -> Reduce(E = E, "-", T => Call(ActionFn(2));) - // - pub fn __state11< - __ERROR, - __TOKENS: Iterator>, - >( - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); - match __lookahead { - Some((_, Tok::Minus(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action2(__sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::E(__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((__lookbehind, __lookahead, __Nonterminal::E(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 12 - // E = E (*) "-" T [")"] - // E = E (*) "-" T ["-"] - // T = "(" E (*) ")" [")"] - // T = "(" E (*) ")" ["-"] - // - // ")" -> Shift(S15) - // "-" -> Shift(S13) - // - pub fn __state12< - __ERROR, - __TOKENS: Iterator>, - >( - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); - match __lookahead { - Some((_, __tok @ Tok::RParen(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state15(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); - } - Some((_, __tok @ Tok::Minus(..), __loc)) => { - let mut __lookbehind = Some(__loc); - let mut __sym2 = &mut Some((__tok)); - let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state13(__lookbehind, __lookahead, __tokens, __sym1, __sym2)); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - return Ok(__result); - } - - // State 13 - // E = E "-" (*) T [")"] + // E = E "-" (*) T [EOF] // E = E "-" (*) T ["-"] - // T = (*) "(" E ")" [")"] + // T = (*) "(" E ")" [EOF] // T = (*) "(" E ")" ["-"] - // T = (*) "Num" [")"] + // T = (*) "Num" [EOF] // T = (*) "Num" ["-"] // - // "Num" -> Shift(S7) - // "(" -> Shift(S8) + // "Num" -> Shift(S3) + // "(" -> Shift(S1) // - // T -> S16 - pub fn __state13< - __ERROR, - __TOKENS: Iterator>, + // T -> S14 + pub fn __state10< + __TOKENS: Iterator>, >( __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { @@ -688,13 +529,13 @@ mod __parse__S { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok0)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym2)); } Some((_, __tok @ Tok::LParen(..), __loc)) => { let mut __lookbehind = Some(__loc); let mut __sym2 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym2)); + __result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym2)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -708,7 +549,7 @@ mod __parse__S { match __nt { __Nonterminal::T(__nt) => { let __sym2 = &mut Some(__nt); - __result = try!(__state16(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + __result = try!(__state14(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -718,16 +559,73 @@ mod __parse__S { return Ok(__result); } - // State 14 + // State 11 + // E = E "-" (*) T [")"] + // E = E "-" (*) T ["-"] + // T = (*) "(" E ")" [")"] + // T = (*) "(" E ")" ["-"] + // T = (*) "Num" [")"] + // T = (*) "Num" ["-"] + // + // "(" -> Shift(S9) + // "Num" -> Shift(S7) + // + // T -> S15 + pub fn __state11< + __TOKENS: Iterator>, + >( + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); + match __lookahead { + Some((_, __tok @ Tok::LParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym2)); + } + Some((_, Tok::Num(__tok0), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok0)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym2)); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + while __sym1.is_some() { + let (__lookbehind, __lookahead, __nt) = __result; + match __nt { + __Nonterminal::T(__nt) => { + let __sym2 = &mut Some(__nt); + __result = try!(__state15(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + } + _ => { + return Ok((__lookbehind, __lookahead, __nt)); + } + } + } + return Ok(__result); + } + + // State 12 // T = "(" E ")" (*) [EOF] // T = "(" E ")" (*) ["-"] // // EOF -> Reduce(T = "(", E, ")" => Call(ActionFn(5));) // "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));) // - pub fn __state14< - __ERROR, - __TOKENS: Iterator>, + pub fn __state12< + __TOKENS: Iterator>, >( __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, @@ -735,7 +633,7 @@ mod __parse__S { __sym0: &mut Option, __sym1: &mut Option, __sym2: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { @@ -762,24 +660,109 @@ mod __parse__S { } } - // State 15 - // T = "(" E ")" (*) [")"] - // T = "(" E ")" (*) ["-"] + // State 13 + // E = E (*) "-" T [")"] + // E = E (*) "-" T ["-"] + // T = "(" E (*) ")" [")"] + // T = "(" E (*) ")" ["-"] // - // "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));) - // ")" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));) + // ")" -> Shift(S16) + // "-" -> Shift(S11) // - pub fn __state15< - __ERROR, - __TOKENS: Iterator>, + pub fn __state13< + __TOKENS: Iterator>, >( __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); + match __lookahead { + Some((_, __tok @ Tok::RParen(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state16(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2)); + } + Some((_, __tok @ Tok::Minus(..), __loc)) => { + let mut __lookbehind = Some(__loc); + let mut __sym2 = &mut Some((__tok)); + let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; + __result = try!(__state11(__lookbehind, __lookahead, __tokens, __sym1, __sym2)); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + return Ok(__result); + } + + // State 14 + // E = E "-" T (*) [EOF] + // E = E "-" T (*) ["-"] + // + // EOF -> Reduce(E = E, "-", T => Call(ActionFn(2));) + // "-" -> Reduce(E = E, "-", T => Call(ActionFn(2));) + // + pub fn __state14< + __TOKENS: Iterator>, + >( + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); + match __lookahead { + None => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action2(__sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::E(__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((__lookbehind, __lookahead, __Nonterminal::E(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + + // State 15 + // E = E "-" T (*) [")"] + // E = E "-" T (*) ["-"] + // + // "-" -> Reduce(E = E, "-", T => Call(ActionFn(2));) + // ")" -> Reduce(E = E, "-", T => Call(ActionFn(2));) + // + pub fn __state15< + __TOKENS: Iterator>, + >( + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { @@ -787,15 +770,15 @@ mod __parse__S { let __sym0 = __sym0.take().unwrap(); let __sym1 = __sym1.take().unwrap(); let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action5(__sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt))); + let __nt = super::__action2(__sym0, __sym1, __sym2); + return Ok((__lookbehind, __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((__lookbehind, __lookahead, __Nonterminal::T(__nt))); + let __nt = super::__action2(__sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt))); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -807,39 +790,38 @@ mod __parse__S { } // State 16 - // E = E "-" T (*) [")"] - // E = E "-" T (*) ["-"] + // T = "(" E ")" (*) [")"] + // T = "(" E ")" (*) ["-"] // - // ")" -> Reduce(E = E, "-", T => Call(ActionFn(2));) - // "-" -> Reduce(E = E, "-", T => Call(ActionFn(2));) + // "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));) + // ")" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));) // pub fn __state16< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, - __sym0: &mut Option, - __sym1: &mut Option, - __sym2: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + __sym0: &mut Option, + __sym1: &mut Option, + __sym2: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { - Some((_, Tok::RParen(..), _)) => { - let __sym0 = __sym0.take().unwrap(); - let __sym1 = __sym1.take().unwrap(); - let __sym2 = __sym2.take().unwrap(); - let __nt = super::__action2(__sym0, __sym1, __sym2); - return Ok((__lookbehind, __lookahead, __Nonterminal::E(__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((__lookbehind, __lookahead, __Nonterminal::E(__nt))); + let __nt = super::__action5(__sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt))); + } + Some((_, Tok::RParen(..), _)) => { + let __sym0 = __sym0.take().unwrap(); + let __sym1 = __sym1.take().unwrap(); + let __sym2 = __sym2.take().unwrap(); + let __nt = super::__action5(__sym0, __sym1, __sym2); + return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt))); } _ => { return Err(__ParseError::UnrecognizedToken { diff --git a/lalrpop-test/src/use_super.rs b/lalrpop-test/src/use_super.rs index bfccd97..2114c14 100644 --- a/lalrpop-test/src/use_super.rs +++ b/lalrpop-test/src/use_super.rs @@ -4,12 +4,11 @@ extern crate lalrpop_util as __lalrpop_util; use self::__lalrpop_util::ParseError as __ParseError; #[allow(non_snake_case)] pub fn parse_S< - __ERROR, - __TOKEN: __ToTriple, + __TOKEN: __ToTriple, __TOKENS: IntoIterator, >( __tokens: __TOKENS, -) -> Result> +) -> Result> { let mut __tokens = __tokens.into_iter(); let mut __tokens = __tokens.map(|t| __ToTriple::to_triple(t)); @@ -34,25 +33,24 @@ mod __parse__S { use super::__ToTriple; pub enum __Nonterminal<> { - S(i32), ____S(i32), + S(i32), } // State 0 // S = (*) "(" ")" [EOF] // __S = (*) S [EOF] // - // "(" -> Shift(S2) + // "(" -> Shift(S1) // - // S -> S1 + // S -> S2 pub fn __state0< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { @@ -60,7 +58,7 @@ mod __parse__S { let mut __lookbehind = Some(__loc); let mut __sym0 = &mut Some((__tok)); let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) }; - __result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0)); + __result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0)); } _ => { return Err(__ParseError::UnrecognizedToken { @@ -74,7 +72,7 @@ mod __parse__S { match __nt { __Nonterminal::S(__nt) => { let __sym0 = &mut Some(__nt); - __result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0)); + __result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0)); } _ => { return Ok((__lookbehind, __lookahead, __nt)); @@ -84,50 +82,18 @@ mod __parse__S { } // State 1 - // __S = S (*) [EOF] - // - // EOF -> Reduce(__S = S => Call(ActionFn(0));) - // - pub fn __state1< - __ERROR, - __TOKENS: Iterator>, - >( - __lookbehind: Option<()>, - __lookahead: Option<((), Tok, ())>, - __tokens: &mut __TOKENS, - __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> - { - let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); - match __lookahead { - None => { - let __sym0 = __sym0.take().unwrap(); - let __nt = super::__action0(__sym0); - return Ok((__lookbehind, __lookahead, __Nonterminal::____S(__nt))); - } - _ => { - return Err(__ParseError::UnrecognizedToken { - token: __lookahead, - expected: vec![], - }); - } - } - } - - // State 2 // S = "(" (*) ")" [EOF] // // ")" -> Shift(S3) // - pub fn __state2< - __ERROR, - __TOKENS: Iterator>, + pub fn __state1< + __TOKENS: Iterator>, >( __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { @@ -147,21 +113,50 @@ mod __parse__S { return Ok(__result); } + // State 2 + // __S = S (*) [EOF] + // + // EOF -> Reduce(__S = S => Call(ActionFn(0));) + // + pub fn __state2< + __TOKENS: Iterator>, + >( + __lookbehind: Option<()>, + __lookahead: Option<((), Tok, ())>, + __tokens: &mut __TOKENS, + __sym0: &mut Option, + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> + { + let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); + match __lookahead { + None => { + let __sym0 = __sym0.take().unwrap(); + let __nt = super::__action0(__sym0); + return Ok((__lookbehind, __lookahead, __Nonterminal::____S(__nt))); + } + _ => { + return Err(__ParseError::UnrecognizedToken { + token: __lookahead, + expected: vec![], + }); + } + } + } + // State 3 // S = "(" ")" (*) [EOF] // // EOF -> Reduce(S = "(", ")" => Call(ActionFn(1));) // pub fn __state3< - __ERROR, - __TOKENS: Iterator>, + __TOKENS: Iterator>, >( __lookbehind: Option<()>, __lookahead: Option<((), Tok, ())>, __tokens: &mut __TOKENS, __sym0: &mut Option, __sym1: &mut Option, - ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>> + ) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,()>> { let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>); match __lookahead { diff --git a/lalrpop-test/src/util/mod.rs b/lalrpop-test/src/util/mod.rs index 6bf49b4..59c26d1 100644 --- a/lalrpop-test/src/util/mod.rs +++ b/lalrpop-test/src/util/mod.rs @@ -39,3 +39,13 @@ pub fn test_loc(parse_fn: F, // expect output to be correct assert!(r == expected, "parsing {:?}, got {:#?}, expected {:#?}", input, r, expected); } + +pub fn test_err_gen(parse_fn: F, input: &str) -> R + where F: FnOnce(Vec<(usize, Tok, usize)>) -> R +{ + // create tokens + let tokens = tok::tokenize(input); + + // parse, expecting input to be totally consumed + parse_fn(tokens) +} diff --git a/lalrpop-util/src/lib.rs b/lalrpop-util/src/lib.rs index 30ceff9..8822214 100644 --- a/lalrpop-util/src/lib.rs +++ b/lalrpop-util/src/lib.rs @@ -44,6 +44,7 @@ pub enum ParseError { /// A richer alternative to `Message`, error objects offer more /// information and reflection. ErrorObject { + span: Option<(L, L)>, error: Box, }, @@ -53,3 +54,8 @@ pub enum ParseError { }, } +impl ParseError { + pub fn message(text: String) -> ParseError { + ParseError::Message { message: text } + } +} diff --git a/lalrpop/src/build/mod.rs b/lalrpop/src/build/mod.rs index 335abca..3c6c7e8 100644 --- a/lalrpop/src/build/mod.rs +++ b/lalrpop/src/build/mod.rs @@ -162,6 +162,18 @@ fn emit_action_code(grammar: &r::Grammar, { for (i, defn) in grammar.action_fn_defns.iter().enumerate() { rust!(rust, ""); + + let ret_type = if defn.fallible { + format!("Result<{},{}ParseError<{},{},{}>>", + defn.ret_type, + grammar.prefix, + grammar.types.terminal_loc_type(), + grammar.types.terminal_enum_type(), + grammar.types.error_type()) + } else { + format!("{}", defn.ret_type) + }; + try!(rust.write_pub_fn_header( grammar, format!("{}action{}", grammar.prefix, i), @@ -170,7 +182,7 @@ fn emit_action_code(grammar: &r::Grammar, .zip(defn.arg_types.iter()) .map(|(p, t)| format!("{}: {}", p, t)) .collect(), - format!("{}", defn.ret_type), + ret_type, vec![])); rust!(rust, "{{"); rust!(rust, "{}", defn.code); @@ -186,42 +198,43 @@ fn emit_to_triple_trait(grammar: &r::Grammar, #![allow(non_snake_case)] let L = grammar.types.terminal_loc_type(); - let E = grammar.types.terminal_enum_type(); + let T = grammar.types.terminal_enum_type(); + let E = grammar.types.error_type(); rust!(rust, ""); rust!(rust, "pub trait {}ToTriple {{", grammar.prefix); rust!(rust, "type Error;"); - rust!(rust, "fn to_triple(value: Self) -> Result<({},{},{}),Self::Error>;", L, E, L); + rust!(rust, "fn to_triple(value: Self) -> Result<({},{},{}),Self::Error>;", L, T, L); rust!(rust, "}}"); rust!(rust, ""); if grammar.types.opt_terminal_loc_type().is_some() { rust!(rust, "impl {}ToTriple for ({}, {}, {}) {{", - grammar.prefix, L, E, L); - rust!(rust, "type Error = ();"); - rust!(rust, "fn to_triple(value: Self) -> Result<({},{},{}),()> {{", L, E, L); + grammar.prefix, L, T, L); + rust!(rust, "type Error = {};", E); + rust!(rust, "fn to_triple(value: Self) -> Result<({},{},{}),{}> {{", L, T, L, E); rust!(rust, "Ok(value)"); rust!(rust, "}}"); rust!(rust, "}}"); rust!(rust, "impl {}ToTriple for Result<({}, {}, {}),ERROR> {{", - grammar.prefix, L, E, L); + grammar.prefix, L, T, L); rust!(rust, "type Error = ERROR;"); - rust!(rust, "fn to_triple(value: Self) -> Result<({},{},{}),ERROR> {{", L, E, L); + rust!(rust, "fn to_triple(value: Self) -> Result<({},{},{}),ERROR> {{", L, T, L); rust!(rust, "value"); rust!(rust, "}}"); rust!(rust, "}}"); } else { - rust!(rust, "impl {}ToTriple for {} {{", grammar.prefix, E); - rust!(rust, "type Error = ();"); - rust!(rust, "fn to_triple(value: Self) -> Result<((),{},()),()> {{", E); + rust!(rust, "impl {}ToTriple for {} {{", grammar.prefix, T); + rust!(rust, "type Error = {};", E); + rust!(rust, "fn to_triple(value: Self) -> Result<((),{},()),{}> {{", T, E); rust!(rust, "Ok(((), value, ()))"); rust!(rust, "}}"); rust!(rust, "}}"); - rust!(rust, "impl {}ToTriple for Result<({}),ERROR> {{", grammar.prefix, E); + rust!(rust, "impl {}ToTriple for Result<({}),ERROR> {{", grammar.prefix, T); rust!(rust, "type Error = ERROR;"); - rust!(rust, "fn to_triple(value: Self) -> Result<((),{},()),ERROR> {{", E); + rust!(rust, "fn to_triple(value: Self) -> Result<((),{},()),ERROR> {{", T); rust!(rust, "value.map(|v| ((), v, ()))"); rust!(rust, "}}"); rust!(rust, "}}"); diff --git a/lalrpop/src/grammar/parse_tree.rs b/lalrpop/src/grammar/parse_tree.rs index df29967..ba93b6d 100644 --- a/lalrpop/src/grammar/parse_tree.rs +++ b/lalrpop/src/grammar/parse_tree.rs @@ -48,6 +48,9 @@ pub struct AssociatedType { /// Recognized associated type for the token location pub const LOCATION: &'static str = "Location"; +/// Recognized associated type for custom errors +pub const ERROR: &'static str = "Error"; + #[derive(Clone, Debug, PartialEq, Eq)] pub struct EnumToken { pub type_name: TypeRef, @@ -134,6 +137,7 @@ pub struct Alternative { #[derive(Clone, Debug, PartialEq, Eq)] pub enum ActionKind { User(String), + Fallible(String), Lookahead, Lookbehind, } diff --git a/lalrpop/src/grammar/repr.rs b/lalrpop/src/grammar/repr.rs index e34641d..e0c46e7 100644 --- a/lalrpop/src/grammar/repr.rs +++ b/lalrpop/src/grammar/repr.rs @@ -74,6 +74,7 @@ pub enum Symbol { pub enum ActionKind { // execute code provided by the user Call(ActionFn), + TryCall(ActionFn), Lookahead, Lookbehind, } @@ -83,6 +84,7 @@ pub struct ActionFnDefn { pub arg_patterns: Vec, pub arg_types: Vec, pub ret_type: TypeRepr, + pub fallible: bool, pub code: String, } @@ -108,6 +110,7 @@ pub struct NominalTypeRepr { pub struct Types { terminal_enum_type: NominalTypeRepr, terminal_loc_type: Option, + error_type: Option, default_terminal_type: TypeRepr, terminal_types: Map, nonterminal_types: Map @@ -115,9 +118,11 @@ pub struct Types { impl Types { pub fn new(terminal_loc_type: Option, + error_type: Option, terminal_enum_type: NominalTypeRepr) -> Types { Types { terminal_loc_type: terminal_loc_type, + error_type: error_type, terminal_enum_type: terminal_enum_type.clone(), terminal_types: map(), default_terminal_type: TypeRepr::Nominal(terminal_enum_type), @@ -145,6 +150,11 @@ impl Types { .unwrap_or_else(|| TypeRepr::Tuple(vec![])) } + pub fn error_type(&self) -> TypeRepr { + self.error_type.clone() + .unwrap_or_else(|| TypeRepr::Tuple(vec![])) + } + pub fn terminal_type(&self, id: TerminalString) -> &TypeRepr { self.terminal_types.get(&id).unwrap_or(&self.default_terminal_type) } diff --git a/lalrpop/src/lr1/ascent.rs b/lalrpop/src/lr1/ascent.rs index 5c3bd68..fd5c58a 100644 --- a/lalrpop/src/lr1/ascent.rs +++ b/lalrpop/src/lr1/ascent.rs @@ -110,20 +110,20 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { // input as `Foo`. An error is reported if the entire input is not // consumed. fn write_start_fn(&mut self) -> io::Result<()> { - let error_type = self.error_type(); + let error_type = self.types.error_type(); + let parse_error_type = self.parse_error_type(); rust!(self.out, "#[allow(non_snake_case)]"); try!(self.out.write_pub_fn_header( self.grammar, format!("parse_{}", self.user_start_symbol), - vec![format!("{}ERROR", self.prefix), - format!("{}TOKEN: {}ToTriple", - self.prefix, self.prefix, self.prefix), + vec![format!("{}TOKEN: {}ToTriple", + self.prefix, self.prefix, error_type), format!("{}TOKENS: IntoIterator", self.prefix, self.prefix)], vec![format!("{}tokens: {}TOKENS", self.prefix, self.prefix)], format!("Result<{}, {}>", self.types.nonterminal_type(self.start_symbol), - error_type), + parse_error_type), vec![])); rust!(self.out, "{{"); @@ -164,7 +164,8 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { let this_prefix = self.state_prefixes[this_index.0]; let loc_type = self.types.terminal_loc_type(); let triple_type = self.triple_type(); - let error_type = self.error_type(); + let parse_error_type = self.parse_error_type(); + let error_type = self.types.error_type(); // Leave a comment explaining what this state is. rust!(self.out, "// State {}", this_index.0); @@ -196,15 +197,14 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { try!(self.out.write_pub_fn_header( self.grammar, format!("{}state{}", self.prefix, this_index.0), - vec![format!("{}ERROR", self.prefix), - format!("{}TOKENS: Iterator>", - self.prefix, triple_type, self.prefix)], + vec![format!("{}TOKENS: Iterator>", + self.prefix, triple_type, error_type)], base_args.into_iter().chain(sym_args).collect(), format!("Result<(Option<{}>, Option<{}>, {}Nonterminal<{}>), {}>", loc_type, triple_type, self.prefix, self.grammar.user_type_parameter_refs(), - error_type), + parse_error_type), vec![])); rust!(self.out, "{{"); @@ -275,6 +275,15 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { Sep(", ", &transfer_syms)) } + ActionKind::TryCall(action_fn) => { + rust!(self.out, "let {}nt = try!(super::{}action{}({}{}));", + self.prefix, + self.prefix, + action_fn.index(), + self.grammar.user_parameter_refs(), + Sep(", ", &transfer_syms)) + } + ActionKind::Lookahead => { // take the lookahead, if any; otherwise, we are // at EOF, so taker the lookbehind (end of last @@ -455,12 +464,12 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> { self.types.triple_type() } - fn error_type(&mut self) -> String { - format!("{}ParseError<{},{},{}ERROR>", + fn parse_error_type(&mut self) -> String { + format!("{}ParseError<{},{},{}>", self.prefix, self.types.terminal_loc_type(), self.types.terminal_enum_type(), - self.prefix) + self.types.error_type()) } fn next_token(&mut self, tokens: &str) -> String { diff --git a/lalrpop/src/normalize/lower/mod.rs b/lalrpop/src/normalize/lower/mod.rs index 7c72452..d6f42c3 100644 --- a/lalrpop/src/normalize/lower/mod.rs +++ b/lalrpop/src/normalize/lower/mod.rs @@ -125,7 +125,7 @@ impl LowerState { pt::SymbolKind::Nonterminal(fake_name))] }; let symbols = vec![r::Symbol::Nonterminal(nt.name)]; - let action_fn = self.action_fn(nt_type, &expr, &symbols, None); + let action_fn = self.action_fn(nt_type, false, &expr, &symbols, None); self.productions.push(r::Production { nonterminal: fake_name, symbols: symbols, @@ -150,11 +150,15 @@ impl LowerState { Some(pt::ActionKind::Lookbehind) => r::ActionKind::Lookbehind, Some(pt::ActionKind::User(string)) => { - let action_fn = self.action_fn(nt_type, &expr, &symbols, Some(string)); + let action_fn = self.action_fn(nt_type, false, &expr, &symbols, Some(string)); r::ActionKind::Call(action_fn) } + Some(pt::ActionKind::Fallible(string)) => { + let action_fn = self.action_fn(nt_type, true, &expr, &symbols, Some(string)); + r::ActionKind::TryCall(action_fn) + } None => { - let action_fn = self.action_fn(nt_type, &expr, &symbols, None); + let action_fn = self.action_fn(nt_type, false, &expr, &symbols, None); r::ActionKind::Call(action_fn) } } @@ -162,6 +166,7 @@ impl LowerState { fn action_fn(&mut self, nt_type: r::TypeRepr, + fallible: bool, expr: &pt::ExprSymbol, symbols: &[r::Symbol], action: Option) @@ -192,6 +197,7 @@ impl LowerState { arg_patterns: arg_patterns, arg_types: arg_types, ret_type: nt_type, + fallible: fallible, code: action } } @@ -211,6 +217,7 @@ impl LowerState { arg_patterns: arg_patterns, arg_types: arg_types, ret_type: nt_type, + fallible: fallible, code: action } } diff --git a/lalrpop/src/normalize/tyinfer/mod.rs b/lalrpop/src/normalize/tyinfer/mod.rs index 06f45ec..b027ddc 100644 --- a/lalrpop/src/normalize/tyinfer/mod.rs +++ b/lalrpop/src/normalize/tyinfer/mod.rs @@ -3,7 +3,7 @@ use super::norm_util::{self, AlternativeAction, Symbols}; use std::collections::{HashMap}; use grammar::parse_tree::{ActionKind, Alternative, - ExternToken, + ERROR, ExternToken, Grammar, GrammarItem, LOCATION, NonterminalData, NonterminalString, @@ -65,12 +65,15 @@ impl<'grammar> TypeInferencer<'grammar> { let loc_type = extern_token.associated_type(intern(LOCATION)) .map(|tr| tr.type_ref.type_repr()); + let error_type = extern_token.associated_type(intern(ERROR)) + .map(|tr| tr.type_ref.type_repr()); + let enum_type = match extern_token.enum_token.type_name.type_repr() { TypeRepr::Nominal(data) => data, _ => panic!("enum token without nominal type passed validation") }; - let mut types = Types::new(loc_type, enum_type); + let mut types = Types::new(loc_type, error_type, enum_type); // For each defined conversion, figure out the type of the // terminal and enter it into `types` by hand if it is not the @@ -224,7 +227,8 @@ impl<'grammar> TypeInferencer<'grammar> { fn alternative_type(&mut self, alt: &Alternative) -> NormResult { match norm_util::analyze_action(alt) { - AlternativeAction::User(&ActionKind::User(_)) => { + AlternativeAction::User(&ActionKind::User(_)) | + AlternativeAction::User(&ActionKind::Fallible(_)) => { return_err!(alt.span, "cannot infer types if there is custom action code"); } diff --git a/lalrpop/src/normalize/validate/mod.rs b/lalrpop/src/normalize/validate/mod.rs index 65df0ca..f4e79f7 100644 --- a/lalrpop/src/normalize/validate/mod.rs +++ b/lalrpop/src/normalize/validate/mod.rs @@ -79,7 +79,7 @@ impl<'grammar> Validator<'grammar> { "multiple extern token definitions are not permitted"); } - let allowed_names = vec![intern(LOCATION)]; + let allowed_names = vec![intern(LOCATION), intern(ERROR)]; let mut new_names = set(); for associated_type in &data.associated_types { if !allowed_names.contains(&associated_type.type_name) { diff --git a/lalrpop/src/parser/mod.rs b/lalrpop/src/parser/mod.rs index 0d15b59..7249bca 100644 --- a/lalrpop/src/parser/mod.rs +++ b/lalrpop/src/parser/mod.rs @@ -110,11 +110,15 @@ rusty_peg! { IF_COND: Condition = ("if" ) => c; - ACTION: ActionKind = (LOOKAHEAD_ACTION / LOOKBEHIND_ACTION / USER_ACTION); + ACTION: ActionKind = + (LOOKAHEAD_ACTION / LOOKBEHIND_ACTION / FALLIBLE_USER_ACTION / USER_ACTION); USER_ACTION: ActionKind = ("=>" ) => ActionKind::User(b); + FALLIBLE_USER_ACTION: ActionKind = + ("=>?" ) => ActionKind::Fallible(b); + LOOKAHEAD_ACTION: ActionKind = ("=>@L") => ActionKind::Lookahead;