fluencelabs/lalrpop
1
0
Fork 0
mirror of https://github.com/fluencelabs/lalrpop synced 2025-03-16 17:00:53 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #44 from fhahn/recent-nightly

Browse Source 
Do not use (..) for empty enum variants, closes #43
This commit is contained in:
Niko Matsakis 2015-12-09 18:26:35 -05:00
commit 218d6e4df9
21 changed files with 2538 additions and 2520 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lalrpop-snap/src/lr1/ascent.rs
View File

@ -548,7 +548,7 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
lb_name, self.prefix);
rust!(self.out, "let mut {} = &mut Some(({}));",
let_name, pattern_names.connect(", "));
let_name, pattern_names.join(", "));
Ok(())
}

2
lalrpop-snap/src/normalize/lower/mod.rs
View File

@ -256,7 +256,7 @@ impl LowerState {
symbols.len());
let name_str = intern::read(|interner| {
let name_strs: Vec<_> = names.iter().map(|&n| interner.data(n)).collect();
name_strs.connect(", ")
name_strs.join(", ")
});
let action = action.replace("<>", &name_str);
r::ActionFnDefn {

3944
lalrpop-snap/src/parser/lrgrammar.rs
View File

File diff suppressed because it is too large Load Diff

4
lalrpop-test/src/error.lalrpop
View File

@ -8,8 +8,8 @@ extern {
type Error = char;
enum Tok {
"-" => Tok::Minus(..),
"+" => Tok::Plus(..)
"-" => Tok::Minus,
"+" => Tok::Plus
}
}

16
lalrpop-test/src/error.rs
View File

@ -71,8 +71,8 @@ mod __parse__Items {
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __nt = super::__action1(&__lookbehind, &__lookahead);
__result = (__lookbehind, __lookahead, __Nonterminal::Items(__nt));
}
@ -121,12 +121,12 @@ mod __parse__Items {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Plus(..), __loc)) => {
Some((_, __tok @ Tok::Plus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state2(__lookbehind, __tokens, __sym0, __sym1));
}
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state3(__lookbehind, __tokens, __sym0, __sym1));
@ -172,8 +172,8 @@ mod __parse__Items {
};
match __lookahead {
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = try!(super::__action2(__sym0, __sym1, &__lookbehind, &__lookahead));
@ -214,8 +214,8 @@ mod __parse__Items {
};
match __lookahead {
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = try!(super::__action3(__sym0, __sym1, &__lookbehind, &__lookahead));

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

@ -4,12 +4,12 @@ use util::tok::Tok;
extern {
enum Tok {
"(" => Tok::LParen(..),
")" => Tok::RParen(..),
"-" => Tok::Minus(..),
"+" => Tok::Plus(..),
"*" => Tok::Times(..),
"/" => Tok::Div(..),
"(" => Tok::LParen,
")" => Tok::RParen,
"-" => Tok::Minus,
"+" => Tok::Plus,
"*" => Tok::Times,
"/" => Tok::Div,
Num => Tok::Num(<i32>),
}
}

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

@ -99,7 +99,7 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym0 = &mut Some((__tok));
__result = try!(__state4(scale, __lookbehind, __tokens, __sym0));
@ -163,12 +163,12 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Plus(..), __loc)) => {
Some((_, __tok @ Tok::Plus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state6(scale, __lookbehind, __tokens, __sym0, __sym1));
}
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state7(scale, __lookbehind, __tokens, __sym0, __sym1));
@ -221,19 +221,19 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state8(scale, __lookbehind, __tokens, __sym0, __sym1));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state9(scale, __lookbehind, __tokens, __sym0, __sym1));
}
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(scale, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt)));
@ -274,10 +274,10 @@ mod __parse__Expr {
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
None |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action6(scale, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt)));
@ -354,7 +354,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state13(scale, __lookbehind, __tokens, __sym1));
@ -424,10 +424,10 @@ mod __parse__Expr {
};
match __lookahead {
None |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action7(scale, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt)));
@ -493,7 +493,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state4(scale, __lookbehind, __tokens, __sym2));
@ -581,7 +581,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state4(scale, __lookbehind, __tokens, __sym2));
@ -655,7 +655,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state4(scale, __lookbehind, __tokens, __sym2));
@ -725,7 +725,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state4(scale, __lookbehind, __tokens, __sym2));
@ -787,17 +787,17 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::RParen(..), __loc)) => {
Some((_, __tok @ Tok::RParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state19(scale, __lookbehind, __tokens, __sym0, __sym1, __sym2));
}
Some((_, __tok @ Tok::Plus(..), __loc)) => {
Some((_, __tok @ Tok::Plus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state20(scale, __lookbehind, __tokens, __sym1, __sym2));
}
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state21(scale, __lookbehind, __tokens, __sym1, __sym2));
@ -845,19 +845,19 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state22(scale, __lookbehind, __tokens, __sym0, __sym1));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state23(scale, __lookbehind, __tokens, __sym0, __sym1));
}
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(scale, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt)));
@ -897,11 +897,11 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action6(scale, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt)));
@ -978,7 +978,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state13(scale, __lookbehind, __tokens, __sym1));
@ -1047,11 +1047,11 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action7(scale, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt)));
@ -1100,19 +1100,19 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state8(scale, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state9(scale, __lookbehind, __tokens, __sym2, __sym3));
}
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1164,19 +1164,19 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state8(scale, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state9(scale, __lookbehind, __tokens, __sym2, __sym3));
}
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1221,10 +1221,10 @@ mod __parse__Expr {
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
None |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1268,10 +1268,10 @@ mod __parse__Expr {
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
None |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1319,10 +1319,10 @@ mod __parse__Expr {
};
match __lookahead {
None |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1390,7 +1390,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state13(scale, __lookbehind, __tokens, __sym2));
@ -1478,7 +1478,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state13(scale, __lookbehind, __tokens, __sym2));
@ -1552,7 +1552,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state13(scale, __lookbehind, __tokens, __sym2));
@ -1622,7 +1622,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state13(scale, __lookbehind, __tokens, __sym2));
@ -1684,17 +1684,17 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::RParen(..), __loc)) => {
Some((_, __tok @ Tok::RParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state29(scale, __lookbehind, __tokens, __sym0, __sym1, __sym2));
}
Some((_, __tok @ Tok::Plus(..), __loc)) => {
Some((_, __tok @ Tok::Plus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state20(scale, __lookbehind, __tokens, __sym1, __sym2));
}
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state21(scale, __lookbehind, __tokens, __sym1, __sym2));
@ -1744,19 +1744,19 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state22(scale, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state23(scale, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1808,19 +1808,19 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state22(scale, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state23(scale, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1864,11 +1864,11 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1911,11 +1911,11 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1962,11 +1962,11 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();

14
lalrpop-test/src/expr_arena.lalrpop
View File

@ -7,13 +7,13 @@ extern {
type Location = usize;
enum Tok {
"(" => Tok::LParen(..),
")" => Tok::RParen(..),
"-" => Tok::Minus(..),
"+" => Tok::Plus(..),
"*" => Tok::Times(..),
"/" => Tok::Div(..),
"," => Tok::Comma(..),
"(" => Tok::LParen,
")" => Tok::RParen,
"-" => Tok::Minus,
"+" => Tok::Plus,
"*" => Tok::Times,
"/" => Tok::Div,
"," => Tok::Comma,
Num => Tok::Num(<i32>)
}
}

408
lalrpop-test/src/expr_arena.rs
View File

@ -114,12 +114,12 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym0 = &mut Some((__tok));
__result = try!(__state4(arena, __lookbehind, __tokens, __sym0));
}
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym0 = &mut Some((__tok));
__result = try!(__state5(arena, __lookbehind, __tokens, __sym0));
@ -184,12 +184,12 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::Plus(..), __loc)) => {
Some((_, __tok @ Tok::Plus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state7(arena, __lookbehind, __tokens, __sym0, __sym1));
}
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state8(arena, __lookbehind, __tokens, __sym0, __sym1));
@ -243,19 +243,19 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state9(arena, __lookbehind, __tokens, __sym0, __sym1));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state10(arena, __lookbehind, __tokens, __sym0, __sym1));
}
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(arena, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt)));
@ -297,10 +297,10 @@ mod __parse__Expr {
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
None |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action7(arena, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt)));
@ -384,12 +384,12 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state14(arena, __lookbehind, __tokens, __sym1));
}
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state15(arena, __lookbehind, __tokens, __sym1));
@ -455,7 +455,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state17(arena, __lookbehind, __tokens, __sym0, __sym1));
@ -501,10 +501,10 @@ mod __parse__Expr {
};
match __lookahead {
None |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action8(arena, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt)));
@ -577,12 +577,12 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state4(arena, __lookbehind, __tokens, __sym2));
}
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state5(arena, __lookbehind, __tokens, __sym2));
@ -677,12 +677,12 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state4(arena, __lookbehind, __tokens, __sym2));
}
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state5(arena, __lookbehind, __tokens, __sym2));
@ -757,7 +757,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state4(arena, __lookbehind, __tokens, __sym2));
@ -828,7 +828,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state4(arena, __lookbehind, __tokens, __sym2));
@ -891,17 +891,17 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::RParen(..), __loc)) => {
Some((_, __tok @ Tok::RParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state22(arena, __lookbehind, __tokens, __sym0, __sym1, __sym2));
}
Some((_, __tok @ Tok::Plus(..), __loc)) => {
Some((_, __tok @ Tok::Plus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state23(arena, __lookbehind, __tokens, __sym1, __sym2));
}
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state24(arena, __lookbehind, __tokens, __sym1, __sym2));
@ -950,19 +950,19 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state25(arena, __lookbehind, __tokens, __sym0, __sym1));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state26(arena, __lookbehind, __tokens, __sym0, __sym1));
}
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(arena, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt)));
@ -1003,11 +1003,11 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action7(arena, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt)));
@ -1091,12 +1091,12 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state14(arena, __lookbehind, __tokens, __sym1));
}
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state15(arena, __lookbehind, __tokens, __sym1));
@ -1162,7 +1162,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state28(arena, __lookbehind, __tokens, __sym0, __sym1));
@ -1207,11 +1207,11 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action8(arena, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt)));
@ -1320,12 +1320,12 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state34(arena, __lookbehind, __tokens, __sym2));
}
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state35(arena, __lookbehind, __tokens, __sym2));
@ -1335,7 +1335,7 @@ mod __parse__Expr {
let mut __sym2 = &mut Some((__tok0));
__result = try!(__state36(arena, __lookbehind, __tokens, __sym2));
}
Some((_, Tok::RParen(..), _)) => {
Some((_, Tok::RParen, _)) => {
let __nt = super::__action23(arena, &__lookbehind, &__lookahead);
__result = (__lookbehind, __lookahead, __Nonterminal::Comma_3cExpr_3e(__nt));
}
@ -1413,19 +1413,19 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state9(arena, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state10(arena, __lookbehind, __tokens, __sym2, __sym3));
}
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1478,19 +1478,19 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state9(arena, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state10(arena, __lookbehind, __tokens, __sym2, __sym3));
}
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1536,10 +1536,10 @@ mod __parse__Expr {
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
None |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1584,10 +1584,10 @@ mod __parse__Expr {
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
None |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1636,10 +1636,10 @@ mod __parse__Expr {
};
match __lookahead {
None |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1714,12 +1714,12 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state14(arena, __lookbehind, __tokens, __sym2));
}
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state15(arena, __lookbehind, __tokens, __sym2));
@ -1814,12 +1814,12 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state14(arena, __lookbehind, __tokens, __sym2));
}
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state15(arena, __lookbehind, __tokens, __sym2));
@ -1894,7 +1894,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state14(arena, __lookbehind, __tokens, __sym2));
@ -1965,7 +1965,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state14(arena, __lookbehind, __tokens, __sym2));
@ -2028,17 +2028,17 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::RParen(..), __loc)) => {
Some((_, __tok @ Tok::RParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state41(arena, __lookbehind, __tokens, __sym0, __sym1, __sym2));
}
Some((_, __tok @ Tok::Plus(..), __loc)) => {
Some((_, __tok @ Tok::Plus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state23(arena, __lookbehind, __tokens, __sym1, __sym2));
}
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state24(arena, __lookbehind, __tokens, __sym1, __sym2));
@ -2148,12 +2148,12 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state34(arena, __lookbehind, __tokens, __sym2));
}
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state35(arena, __lookbehind, __tokens, __sym2));
@ -2163,7 +2163,7 @@ mod __parse__Expr {
let mut __sym2 = &mut Some((__tok0));
__result = try!(__state36(arena, __lookbehind, __tokens, __sym2));
}
Some((_, Tok::RParen(..), _)) => {
Some((_, Tok::RParen, _)) => {
let __nt = super::__action23(arena, &__lookbehind, &__lookahead);
__result = (__lookbehind, __lookahead, __Nonterminal::Comma_3cExpr_3e(__nt));
}
@ -2282,12 +2282,12 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state34(arena, __lookbehind, __tokens, __sym1));
}
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state35(arena, __lookbehind, __tokens, __sym1));
@ -2297,7 +2297,7 @@ mod __parse__Expr {
let mut __sym1 = &mut Some((__tok0));
__result = try!(__state36(arena, __lookbehind, __tokens, __sym1));
}
Some((_, Tok::RParen(..), _)) => {
Some((_, Tok::RParen, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action25(arena, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Comma_3cExpr_3e(__nt)));
@ -2356,7 +2356,7 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::RParen(..), __loc)) => {
Some((_, __tok @ Tok::RParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state44(arena, __lookbehind, __tokens, __sym0, __sym1, __sym2, __sym3));
@ -2404,22 +2404,22 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::Plus(..), __loc)) => {
Some((_, __tok @ Tok::Plus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state45(arena, __lookbehind, __tokens, __sym0, __sym1));
}
Some((_, __tok @ Tok::Comma(..), __loc)) => {
Some((_, __tok @ Tok::Comma, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state46(arena, __lookbehind, __tokens, __sym0, __sym1));
}
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state47(arena, __lookbehind, __tokens, __sym0, __sym1));
}
Some((_, Tok::RParen(..), _)) => {
Some((_, Tok::RParen, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action22(arena, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Comma_3cExpr_3e(__nt)));
@ -2472,20 +2472,20 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state48(arena, __lookbehind, __tokens, __sym0, __sym1));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state49(arena, __lookbehind, __tokens, __sym0, __sym1));
}
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Comma(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Comma, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(arena, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt)));
@ -2528,12 +2528,12 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Comma(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Comma, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action7(arena, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt)));
@ -2618,12 +2618,12 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state14(arena, __lookbehind, __tokens, __sym1));
}
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state15(arena, __lookbehind, __tokens, __sym1));
@ -2690,7 +2690,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state51(arena, __lookbehind, __tokens, __sym0, __sym1));
@ -2737,12 +2737,12 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Comma(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Comma, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action8(arena, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt)));
@ -2792,19 +2792,19 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state25(arena, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state26(arena, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -2857,19 +2857,19 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state25(arena, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state26(arena, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -2914,11 +2914,11 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -2962,11 +2962,11 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -3014,11 +3014,11 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -3058,7 +3058,7 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::RParen(..), __loc)) => {
Some((_, __tok @ Tok::RParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state52(arena, __lookbehind, __tokens, __sym0, __sym1, __sym2, __sym3));
@ -3107,22 +3107,22 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::Plus(..), __loc)) => {
Some((_, __tok @ Tok::Plus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state45(arena, __lookbehind, __tokens, __sym1, __sym2));
}
Some((_, __tok @ Tok::Comma(..), __loc)) => {
Some((_, __tok @ Tok::Comma, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state53(arena, __lookbehind, __tokens, __sym0, __sym1, __sym2));
}
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state47(arena, __lookbehind, __tokens, __sym1, __sym2));
}
Some((_, Tok::RParen(..), _)) => {
Some((_, Tok::RParen, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action24(arena, __sym0, __sym1, &__lookbehind, &__lookahead);
@ -3172,10 +3172,10 @@ mod __parse__Expr {
};
match __lookahead {
None |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -3258,12 +3258,12 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state34(arena, __lookbehind, __tokens, __sym2));
}
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state35(arena, __lookbehind, __tokens, __sym2));
@ -3328,9 +3328,9 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, Tok::LParen(..), _)) |
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::LParen, _)) |
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Num(_), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
@ -3412,12 +3412,12 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state34(arena, __lookbehind, __tokens, __sym2));
}
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state35(arena, __lookbehind, __tokens, __sym2));
@ -3495,7 +3495,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state34(arena, __lookbehind, __tokens, __sym2));
@ -3569,7 +3569,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state34(arena, __lookbehind, __tokens, __sym2));
@ -3633,17 +3633,17 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::RParen(..), __loc)) => {
Some((_, __tok @ Tok::RParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state58(arena, __lookbehind, __tokens, __sym0, __sym1, __sym2));
}
Some((_, __tok @ Tok::Plus(..), __loc)) => {
Some((_, __tok @ Tok::Plus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state23(arena, __lookbehind, __tokens, __sym1, __sym2));
}
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state24(arena, __lookbehind, __tokens, __sym1, __sym2));
@ -3754,12 +3754,12 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state34(arena, __lookbehind, __tokens, __sym2));
}
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state35(arena, __lookbehind, __tokens, __sym2));
@ -3769,7 +3769,7 @@ mod __parse__Expr {
let mut __sym2 = &mut Some((__tok0));
__result = try!(__state36(arena, __lookbehind, __tokens, __sym2));
}
Some((_, Tok::RParen(..), _)) => {
Some((_, Tok::RParen, _)) => {
let __nt = super::__action23(arena, &__lookbehind, &__lookahead);
__result = (__lookbehind, __lookahead, __Nonterminal::Comma_3cExpr_3e(__nt));
}
@ -3844,11 +3844,11 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -3895,9 +3895,9 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, Tok::LParen(..), _)) |
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::LParen, _)) |
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Num(_), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
@ -3954,20 +3954,20 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state48(arena, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state49(arena, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Comma(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Comma, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -4024,20 +4024,20 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state48(arena, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state49(arena, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Comma(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Comma, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -4084,12 +4084,12 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Comma(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Comma, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -4135,12 +4135,12 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Comma(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Comma, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -4190,12 +4190,12 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Comma(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Comma, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -4236,7 +4236,7 @@ mod __parse__Expr {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<'ast>);
match __lookahead {
Some((_, __tok @ Tok::RParen(..), __loc)) => {
Some((_, __tok @ Tok::RParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state60(arena, __lookbehind, __tokens, __sym0, __sym1, __sym2, __sym3));
@ -4286,12 +4286,12 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Comma(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Comma, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();

190
lalrpop-test/src/expr_generic.rs
View File

@ -154,7 +154,7 @@ mod __parse__Expr {
// Expr = Expr (*) "-" Factor ["-"]
// __Expr = Expr (*) [EOF]
//
// EOF -> Reduce(__Expr = Expr => Call(ActionFn(0));)
// EOF -> Reduce(__Expr = Expr => ActionFn(0);)
// "+" -> Shift(S6)
// "-" -> Shift(S7)
//
@ -185,7 +185,7 @@ mod __parse__Expr {
}
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action0(input, __sym0);
let __nt = super::__action0(input, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::____Expr(__nt)));
}
_ => {
@ -213,10 +213,10 @@ mod __parse__Expr {
// Factor = Factor (*) "/" Term ["-"]
// Factor = Factor (*) "/" Term ["/"]
//
// EOF -> Reduce(Expr = Factor => Call(ActionFn(3));)
// EOF -> Reduce(Expr = Factor => ActionFn(3);)
// "*" -> Shift(S8)
// "+" -> Reduce(Expr = Factor => Call(ActionFn(3));)
// "-" -> Reduce(Expr = Factor => Call(ActionFn(3));)
// "+" -> Reduce(Expr = Factor => ActionFn(3);)
// "-" -> Reduce(Expr = Factor => ActionFn(3);)
// "/" -> Shift(S9)
//
pub fn __state2<
@ -248,7 +248,7 @@ mod __parse__Expr {
Some((_, (3, _), _)) |
Some((_, (4, _), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(input, __sym0);
let __nt = super::__action3(input, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt)));
}
_ => {
@ -268,11 +268,11 @@ 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));)
// "/" -> Reduce(Factor = Term => Call(ActionFn(6));)
// EOF -> Reduce(Factor = Term => ActionFn(6);)
// "*" -> Reduce(Factor = Term => ActionFn(6);)
// "+" -> Reduce(Factor = Term => ActionFn(6);)
// "-" -> Reduce(Factor = Term => ActionFn(6);)
// "/" -> Reduce(Factor = Term => ActionFn(6);)
//
pub fn __state3<
'input,
@ -295,7 +295,7 @@ mod __parse__Expr {
Some((_, (4, _), _)) |
Some((_, (5, _), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action6(input, __sym0);
let __nt = super::__action6(input, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt)));
}
_ => {
@ -420,11 +420,11 @@ mod __parse__Expr {
// Term = r#"[0-9]+"# (*) ["-"]
// Term = r#"[0-9]+"# (*) ["/"]
//
// EOF -> Reduce(Term = r#"[0-9]+"# => Call(ActionFn(7));)
// "*" -> Reduce(Term = r#"[0-9]+"# => Call(ActionFn(7));)
// "+" -> Reduce(Term = r#"[0-9]+"# => Call(ActionFn(7));)
// "-" -> Reduce(Term = r#"[0-9]+"# => Call(ActionFn(7));)
// "/" -> Reduce(Term = r#"[0-9]+"# => Call(ActionFn(7));)
// EOF -> Reduce(Term = r#"[0-9]+"# => ActionFn(7);)
// "*" -> Reduce(Term = r#"[0-9]+"# => ActionFn(7);)
// "+" -> Reduce(Term = r#"[0-9]+"# => ActionFn(7);)
// "-" -> Reduce(Term = r#"[0-9]+"# => ActionFn(7);)
// "/" -> Reduce(Term = r#"[0-9]+"# => ActionFn(7);)
//
pub fn __state5<
'input,
@ -451,7 +451,7 @@ mod __parse__Expr {
Some((_, (4, _), _)) |
Some((_, (5, _), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action7(input, __sym0);
let __nt = super::__action7(input, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt)));
}
_ => {
@ -864,10 +864,10 @@ mod __parse__Expr {
// Factor = Factor (*) "/" Term ["-"]
// Factor = Factor (*) "/" Term ["/"]
//
// ")" -> Reduce(Expr = Factor => Call(ActionFn(3));)
// ")" -> Reduce(Expr = Factor => ActionFn(3);)
// "*" -> Shift(S22)
// "+" -> Reduce(Expr = Factor => Call(ActionFn(3));)
// "-" -> Reduce(Expr = Factor => Call(ActionFn(3));)
// "+" -> Reduce(Expr = Factor => ActionFn(3);)
// "-" -> Reduce(Expr = Factor => ActionFn(3);)
// "/" -> Shift(S23)
//
pub fn __state11<
@ -899,7 +899,7 @@ mod __parse__Expr {
Some((_, (3, _), _)) |
Some((_, (4, _), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(input, __sym0);
let __nt = super::__action3(input, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt)));
}
_ => {
@ -919,11 +919,11 @@ mod __parse__Expr {
// Factor = Term (*) ["-"]
// Factor = Term (*) ["/"]
//
// ")" -> 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));)
// ")" -> Reduce(Factor = Term => ActionFn(6);)
// "*" -> Reduce(Factor = Term => ActionFn(6);)
// "+" -> Reduce(Factor = Term => ActionFn(6);)
// "-" -> Reduce(Factor = Term => ActionFn(6);)
// "/" -> Reduce(Factor = Term => ActionFn(6);)
//
pub fn __state12<
'input,
@ -946,7 +946,7 @@ mod __parse__Expr {
Some((_, (4, _), _)) |
Some((_, (5, _), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action6(input, __sym0);
let __nt = super::__action6(input, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt)));
}
_ => {
@ -1071,11 +1071,11 @@ mod __parse__Expr {
// Term = r#"[0-9]+"# (*) ["-"]
// Term = r#"[0-9]+"# (*) ["/"]
//
// ")" -> Reduce(Term = r#"[0-9]+"# => Call(ActionFn(7));)
// "*" -> Reduce(Term = r#"[0-9]+"# => Call(ActionFn(7));)
// "+" -> Reduce(Term = r#"[0-9]+"# => Call(ActionFn(7));)
// "-" -> Reduce(Term = r#"[0-9]+"# => Call(ActionFn(7));)
// "/" -> Reduce(Term = r#"[0-9]+"# => Call(ActionFn(7));)
// ")" -> Reduce(Term = r#"[0-9]+"# => ActionFn(7);)
// "*" -> Reduce(Term = r#"[0-9]+"# => ActionFn(7);)
// "+" -> Reduce(Term = r#"[0-9]+"# => ActionFn(7);)
// "-" -> Reduce(Term = r#"[0-9]+"# => ActionFn(7);)
// "/" -> Reduce(Term = r#"[0-9]+"# => ActionFn(7);)
//
pub fn __state14<
'input,
@ -1102,7 +1102,7 @@ mod __parse__Expr {
Some((_, (4, _), _)) |
Some((_, (5, _), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action7(input, __sym0);
let __nt = super::__action7(input, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt)));
}
_ => {
@ -1129,10 +1129,10 @@ mod __parse__Expr {
// Factor = Factor (*) "/" Term ["-"]
// Factor = Factor (*) "/" Term ["/"]
//
// EOF -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));)
// EOF -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);)
// "*" -> Shift(S8)
// "+" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));)
// "-" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));)
// "+" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);)
// "-" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);)
// "/" -> Shift(S9)
//
pub fn __state15<
@ -1168,7 +1168,7 @@ mod __parse__Expr {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action2(input, __sym0, __sym1, __sym2);
let __nt = super::__action2(input, __sym0, __sym1, __sym2, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt)));
}
_ => {
@ -1196,10 +1196,10 @@ mod __parse__Expr {
// Factor = Factor (*) "/" Term ["-"]
// Factor = Factor (*) "/" Term ["/"]
//
// EOF -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));)
// EOF -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);)
// "*" -> Shift(S8)
// "+" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));)
// "-" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));)
// "+" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);)
// "-" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);)
// "/" -> Shift(S9)
//
pub fn __state16<
@ -1235,7 +1235,7 @@ mod __parse__Expr {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action1(input, __sym0, __sym1, __sym2);
let __nt = super::__action1(input, __sym0, __sym1, __sym2, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt)));
}
_ => {
@ -1255,11 +1255,11 @@ mod __parse__Expr {
// Factor = Factor "*" Term (*) ["-"]
// Factor = Factor "*" Term (*) ["/"]
//
// 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));)
// "/" -> Reduce(Factor = Factor, "*", Term => Call(ActionFn(4));)
// EOF -> Reduce(Factor = Factor, "*", Term => ActionFn(4);)
// "*" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);)
// "+" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);)
// "-" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);)
// "/" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);)
//
pub fn __state17<
'input,
@ -1286,7 +1286,7 @@ mod __parse__Expr {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action4(input, __sym0, __sym1, __sym2);
let __nt = super::__action4(input, __sym0, __sym1, __sym2, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt)));
}
_ => {
@ -1305,11 +1305,11 @@ mod __parse__Expr {
// 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));)
// EOF -> Reduce(Factor = Factor, "/", Term => ActionFn(5);)
// "*" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);)
// "+" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);)
// "-" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);)
// "/" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);)
//
pub fn __state18<
'input,
@ -1336,7 +1336,7 @@ mod __parse__Expr {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action5(input, __sym0, __sym1, __sym2);
let __nt = super::__action5(input, __sym0, __sym1, __sym2, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt)));
}
_ => {
@ -1355,11 +1355,11 @@ mod __parse__Expr {
// Term = "(" Expr ")" (*) ["-"]
// Term = "(" Expr ")" (*) ["/"]
//
// 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));)
// EOF -> Reduce(Term = "(", Expr, ")" => ActionFn(8);)
// "*" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);)
// "+" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);)
// "-" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);)
// "/" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);)
//
pub fn __state19<
'input,
@ -1390,7 +1390,7 @@ mod __parse__Expr {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action8(input, __sym0, __sym1, __sym2);
let __nt = super::__action8(input, __sym0, __sym1, __sym2, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt)));
}
_ => {
@ -1803,10 +1803,10 @@ mod __parse__Expr {
// Factor = Factor (*) "/" Term ["-"]
// Factor = Factor (*) "/" Term ["/"]
//
// ")" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));)
// ")" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);)
// "*" -> Shift(S22)
// "+" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));)
// "-" -> Reduce(Expr = Expr, "+", Factor => Call(ActionFn(2));)
// "+" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);)
// "-" -> Reduce(Expr = Expr, "+", Factor => ActionFn(2);)
// "/" -> Shift(S23)
//
pub fn __state25<
@ -1842,7 +1842,7 @@ mod __parse__Expr {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action2(input, __sym0, __sym1, __sym2);
let __nt = super::__action2(input, __sym0, __sym1, __sym2, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt)));
}
_ => {
@ -1870,10 +1870,10 @@ mod __parse__Expr {
// Factor = Factor (*) "/" Term ["-"]
// Factor = Factor (*) "/" Term ["/"]
//
// ")" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));)
// ")" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);)
// "*" -> Shift(S22)
// "+" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));)
// "-" -> Reduce(Expr = Expr, "-", Factor => Call(ActionFn(1));)
// "+" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);)
// "-" -> Reduce(Expr = Expr, "-", Factor => ActionFn(1);)
// "/" -> Shift(S23)
//
pub fn __state26<
@ -1909,7 +1909,7 @@ mod __parse__Expr {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action1(input, __sym0, __sym1, __sym2);
let __nt = super::__action1(input, __sym0, __sym1, __sym2, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt)));
}
_ => {
@ -1929,11 +1929,11 @@ mod __parse__Expr {
// 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 => ActionFn(4);)
// "*" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);)
// "+" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);)
// "-" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);)
// "/" -> Reduce(Factor = Factor, "*", Term => ActionFn(4);)
//
pub fn __state27<
'input,
@ -1960,7 +1960,7 @@ mod __parse__Expr {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action4(input, __sym0, __sym1, __sym2);
let __nt = super::__action4(input, __sym0, __sym1, __sym2, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt)));
}
_ => {
@ -1979,11 +1979,11 @@ mod __parse__Expr {
// 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));)
// ")" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);)
// "*" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);)
// "+" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);)
// "-" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);)
// "/" -> Reduce(Factor = Factor, "/", Term => ActionFn(5);)
//
pub fn __state28<
'input,
@ -2010,7 +2010,7 @@ mod __parse__Expr {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action5(input, __sym0, __sym1, __sym2);
let __nt = super::__action5(input, __sym0, __sym1, __sym2, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt)));
}
_ => {
@ -2029,11 +2029,11 @@ mod __parse__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));)
// ")" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);)
// "*" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);)
// "+" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);)
// "-" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);)
// "/" -> Reduce(Term = "(", Expr, ")" => ActionFn(8);)
//
pub fn __state29<
'input,
@ -2064,7 +2064,7 @@ mod __parse__Expr {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action8(input, __sym0, __sym1, __sym2);
let __nt = super::__action8(input, __sym0, __sym1, __sym2, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt)));
}
_ => {
@ -2340,6 +2340,8 @@ pub fn __action0<
>(
input: &'input str,
__0: F,
__lookbehind: &Option<usize>,
__lookahead: &Option<(usize, (usize, &'input str), usize)>,
) -> F where
F: Debug + FromStr + Sub<Output=F> + Add<Output=F> + Mul<Output=F> + Div<Output=F>,
{
@ -2354,6 +2356,8 @@ pub fn __action1<
l: F,
_: &'input str,
r: F,
__lookbehind: &Option<usize>,
__lookahead: &Option<(usize, (usize, &'input str), usize)>,
) -> F where
F: Debug + FromStr + Sub<Output=F> + Add<Output=F> + Mul<Output=F> + Div<Output=F>,
{
@ -2368,6 +2372,8 @@ pub fn __action2<
l: F,
_: &'input str,
r: F,
__lookbehind: &Option<usize>,
__lookahead: &Option<(usize, (usize, &'input str), usize)>,
) -> F where
F: Debug + FromStr + Sub<Output=F> + Add<Output=F> + Mul<Output=F> + Div<Output=F>,
{
@ -2380,6 +2386,8 @@ pub fn __action3<
>(
input: &'input str,
__0: F,
__lookbehind: &Option<usize>,
__lookahead: &Option<(usize, (usize, &'input str), usize)>,
) -> F where
F: Debug + FromStr + Sub<Output=F> + Add<Output=F> + Mul<Output=F> + Div<Output=F>,
{
@ -2394,6 +2402,8 @@ pub fn __action4<
l: F,
_: &'input str,
r: F,
__lookbehind: &Option<usize>,
__lookahead: &Option<(usize, (usize, &'input str), usize)>,
) -> F where
F: Debug + FromStr + Sub<Output=F> + Add<Output=F> + Mul<Output=F> + Div<Output=F>,
{
@ -2408,6 +2418,8 @@ pub fn __action5<
l: F,
_: &'input str,
r: F,
__lookbehind: &Option<usize>,
__lookahead: &Option<(usize, (usize, &'input str), usize)>,
) -> F where
F: Debug + FromStr + Sub<Output=F> + Add<Output=F> + Mul<Output=F> + Div<Output=F>,
{
@ -2420,6 +2432,8 @@ pub fn __action6<
>(
input: &'input str,
__0: F,
__lookbehind: &Option<usize>,
__lookahead: &Option<(usize, (usize, &'input str), usize)>,
) -> F where
F: Debug + FromStr + Sub<Output=F> + Add<Output=F> + Mul<Output=F> + Div<Output=F>,
{
@ -2432,6 +2446,8 @@ pub fn __action7<
>(
input: &'input str,
n: &'input str,
__lookbehind: &Option<usize>,
__lookahead: &Option<(usize, (usize, &'input str), usize)>,
) -> F where
F: Debug + FromStr + Sub<Output=F> + Add<Output=F> + Mul<Output=F> + Div<Output=F>,
{
@ -2446,6 +2462,8 @@ pub fn __action8<
_: &'input str,
__0: F,
_: &'input str,
__lookbehind: &Option<usize>,
__lookahead: &Option<(usize, (usize, &'input str), usize)>,
) -> F where
F: Debug + FromStr + Sub<Output=F> + Add<Output=F> + Mul<Output=F> + Div<Output=F>,
{

12
lalrpop-test/src/expr_lalr.lalrpop
View File

@ -4,12 +4,12 @@ use util::tok::Tok;
extern {
enum Tok {
"(" => Tok::LParen(..),
")" => Tok::RParen(..),
"-" => Tok::Minus(..),
"+" => Tok::Plus(..),
"*" => Tok::Times(..),
"/" => Tok::Div(..),
"(" => Tok::LParen,
")" => Tok::RParen,
"-" => Tok::Minus,
"+" => Tok::Plus,
"*" => Tok::Times,
"/" => Tok::Div,
Num => Tok::Num(<i32>)
}
}

102
lalrpop-test/src/expr_lalr.rs
View File

@ -99,7 +99,7 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym0 = &mut Some((__tok));
__result = try!(__state4(scale, __lookbehind, __tokens, __sym0));
@ -163,12 +163,12 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Plus(..), __loc)) => {
Some((_, __tok @ Tok::Plus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state6(scale, __lookbehind, __tokens, __sym0, __sym1));
}
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state7(scale, __lookbehind, __tokens, __sym0, __sym1));
@ -235,20 +235,20 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state8(scale, __lookbehind, __tokens, __sym0, __sym1));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state9(scale, __lookbehind, __tokens, __sym0, __sym1));
}
None |
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(scale, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Expr(__nt)));
@ -295,11 +295,11 @@ mod __parse__Expr {
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
None |
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action6(scale, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Factor(__nt)));
@ -415,7 +415,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state4(scale, __lookbehind, __tokens, __sym1));
@ -491,11 +491,11 @@ mod __parse__Expr {
};
match __lookahead {
None |
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action7(scale, __sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::Term(__nt)));
@ -589,7 +589,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state4(scale, __lookbehind, __tokens, __sym2));
@ -705,7 +705,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state4(scale, __lookbehind, __tokens, __sym2));
@ -794,7 +794,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state4(scale, __lookbehind, __tokens, __sym2));
@ -879,7 +879,7 @@ mod __parse__Expr {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state4(scale, __lookbehind, __tokens, __sym2));
@ -952,17 +952,17 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::RParen(..), __loc)) => {
Some((_, __tok @ Tok::RParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state15(scale, __lookbehind, __tokens, __sym0, __sym1, __sym2));
}
Some((_, __tok @ Tok::Plus(..), __loc)) => {
Some((_, __tok @ Tok::Plus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state6(scale, __lookbehind, __tokens, __sym1, __sym2));
}
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state7(scale, __lookbehind, __tokens, __sym1, __sym2));
@ -1026,20 +1026,20 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state8(scale, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state9(scale, __lookbehind, __tokens, __sym2, __sym3));
}
None |
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1105,20 +1105,20 @@ mod __parse__Expr {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Times(..), __loc)) => {
Some((_, __tok @ Tok::Times, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state8(scale, __lookbehind, __tokens, __sym2, __sym3));
}
Some((_, __tok @ Tok::Div(..), __loc)) => {
Some((_, __tok @ Tok::Div, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym3 = &mut Some((__tok));
__result = try!(__state9(scale, __lookbehind, __tokens, __sym2, __sym3));
}
None |
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1169,11 +1169,11 @@ mod __parse__Expr {
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
None |
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1223,11 +1223,11 @@ mod __parse__Expr {
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
None |
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -1281,11 +1281,11 @@ mod __parse__Expr {
};
match __lookahead {
None |
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Times(..), _)) |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) |
Some((_, Tok::Div(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Times, _)) |
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) |
Some((_, Tok::Div, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();

4
lalrpop-test/src/loc.lalrpop
View File

@ -6,8 +6,8 @@ extern {
type Location = usize;
enum Tok {
"-" => Tok::Minus(..),
"+" => Tok::Plus(..)
"-" => Tok::Minus,
"+" => Tok::Plus
}
}

34
lalrpop-test/src/loc.rs
View File

@ -76,8 +76,8 @@ mod __parse__Items {
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __nt = super::__action6(&__lookbehind, &__lookahead);
__result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
}
@ -131,8 +131,8 @@ mod __parse__Items {
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __nt = super::__action5(&__lookbehind, &__lookahead);
__result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
}
@ -188,12 +188,12 @@ mod __parse__Items {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state6(__lookbehind, __tokens, __sym0, __sym1));
}
Some((_, Tok::Plus(..), _)) => {
Some((_, Tok::Plus, _)) => {
let __nt = super::__action6(&__lookbehind, &__lookahead);
__result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
}
@ -250,8 +250,8 @@ mod __parse__Items {
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action1(__sym0, __sym1, &__lookbehind, &__lookahead);
@ -284,7 +284,7 @@ mod __parse__Items {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Plus(..), __loc)) => {
Some((_, __tok @ Tok::Plus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state7(__lookbehind, __tokens, __sym0, __sym1));
@ -321,8 +321,8 @@ mod __parse__Items {
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action2(__sym0, __sym1, &__lookbehind, &__lookahead);
@ -363,8 +363,8 @@ mod __parse__Items {
};
match __lookahead {
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action3(__sym0, __sym1, &__lookbehind, &__lookahead);
@ -409,8 +409,8 @@ mod __parse__Items {
};
match __lookahead {
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __nt = super::__action5(&__lookbehind, &__lookahead);
__result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
}
@ -459,8 +459,8 @@ mod __parse__Items {
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
None |
Some((_, Tok::Plus(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Plus, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();

6
lalrpop-test/src/sub.lalrpop
View File

@ -4,9 +4,9 @@ use util::tok::Tok;
extern {
enum Tok {
"(" => Tok::LParen(..),
")" => Tok::RParen(..),
"-" => Tok::Minus(..),
"(" => Tok::LParen,
")" => Tok::RParen,
"-" => Tok::Minus,
Num => Tok::Num(<i32>),
}
}

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

@ -71,7 +71,7 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym0 = &mut Some((__tok));
__result = try!(__state4(__lookbehind, __tokens, __sym0));
@ -129,7 +129,7 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state6(__lookbehind, __tokens, __sym0, __sym1));
@ -198,7 +198,7 @@ mod __parse__S {
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
None |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(__sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
@ -244,7 +244,7 @@ mod __parse__S {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state9(__lookbehind, __tokens, __sym1));
@ -303,7 +303,7 @@ mod __parse__S {
};
match __lookahead {
None |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
@ -345,7 +345,7 @@ mod __parse__S {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state4(__lookbehind, __tokens, __sym2));
@ -398,12 +398,12 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::RParen(..), __loc)) => {
Some((_, __tok @ Tok::RParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state12(__lookbehind, __tokens, __sym0, __sym1, __sym2));
}
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state13(__lookbehind, __tokens, __sym1, __sym2));
@ -436,8 +436,8 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(__sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
@ -483,7 +483,7 @@ mod __parse__S {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state9(__lookbehind, __tokens, __sym1));
@ -541,8 +541,8 @@ mod __parse__S {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0, &__lookbehind, &__lookahead);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
@ -577,7 +577,7 @@ mod __parse__S {
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
None |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -618,7 +618,7 @@ mod __parse__S {
};
match __lookahead {
None |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -662,7 +662,7 @@ mod __parse__S {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state9(__lookbehind, __tokens, __sym2));
@ -715,12 +715,12 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::RParen(..), __loc)) => {
Some((_, __tok @ Tok::RParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state16(__lookbehind, __tokens, __sym0, __sym1, __sym2));
}
Some((_, __tok @ Tok::Minus(..), __loc)) => {
Some((_, __tok @ Tok::Minus, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
__result = try!(__state13(__lookbehind, __tokens, __sym1, __sym2));
@ -755,8 +755,8 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -796,8 +796,8 @@ mod __parse__S {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, Tok::RParen(..), _)) |
Some((_, Tok::Minus(..), _)) => {
Some((_, Tok::RParen, _)) |
Some((_, Tok::Minus, _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();

4
lalrpop-test/src/use_super.lalrpop
View File

@ -4,8 +4,8 @@ use super::util::tok::Tok;
extern {
enum Tok {
"(" => Tok::LParen(..),
")" => Tok::RParen(..),
"(" => Tok::LParen,
")" => Tok::RParen,
}
}

4
lalrpop-test/src/use_super.rs
View File

@ -58,7 +58,7 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
Some((_, __tok @ Tok::LParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym0 = &mut Some((__tok));
__result = try!(__state2(__lookbehind, __tokens, __sym0));
@ -134,7 +134,7 @@ mod __parse__S {
Some(Err(e)) => return Err(__ParseError::User { error: e }),
};
match __lookahead {
Some((_, __tok @ Tok::RParen(..), __loc)) => {
Some((_, __tok @ Tok::RParen, __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
__result = try!(__state3(__lookbehind, __tokens, __sym0, __sym1));

2
lalrpop/src/lr1/ascent.rs
View File

@ -528,7 +528,7 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
lb_name, self.prefix);
rust!(self.out, "let mut {} = &mut Some(({}));",
let_name, pattern_names.connect(", "));
let_name, pattern_names.join(", "));
Ok(())
}

2
lalrpop/src/normalize/lower/mod.rs
View File

@ -283,7 +283,7 @@ impl LowerState {
symbols.len());
let name_str = intern::read(|interner| {
let name_strs: Vec<_> = names.iter().map(|&n| interner.data(n)).collect();
name_strs.connect(", ")
name_strs.join(", ")
});
let action = action.replace("<>", &name_str);
r::ActionFnDefn {

70
lalrpop/src/parser/lrgrammar.lalrpop
View File

@ -336,13 +336,13 @@ extern {
type Location = usize;
type Error = tok::Error;
enum Tok<'input> {
"enum" => Tok::Enum(..),
"extern" => Tok::Extern(..),
"grammar" => Tok::Grammar(..),
"if" => Tok::If(..),
"mut" => Tok::Mut(..),
"pub" => Tok::Pub(..),
"type" => Tok::Type(..),
"enum" => Tok::Enum,
"extern" => Tok::Extern,
"grammar" => Tok::Grammar,
"if" => Tok::If,
"mut" => Tok::Mut,
"pub" => Tok::Pub,
"type" => Tok::Type,
"use" => Tok::Use(<&'input str>),
"where" => Tok::Where(<Vec<&'input str>>),
@ -353,36 +353,36 @@ extern {
"StringLiteral" => Tok::StringLiteral(<&'input str>),
"RegexLiteral" => Tok::RegexLiteral(<&'input str>),
"&" => Tok::Ampersand(..),
"!=" => Tok::BangEquals(..),
"!~" => Tok::BangTilde(..),
":" => Tok::Colon(..),
"::" => Tok::ColonColon(..),
"," => Tok::Comma(..),
".." => Tok::DotDot(..),
"=" => Tok::Equals(..),
"==" => Tok::EqualsEquals(..),
"&" => Tok::Ampersand,
"!=" => Tok::BangEquals,
"!~" => Tok::BangTilde,
":" => Tok::Colon,
"::" => Tok::ColonColon,
"," => Tok::Comma,
".." => Tok::DotDot,
"=" => Tok::Equals,
"==" => Tok::EqualsEquals,
"=>" => Tok::EqualsGreaterThanCode(<&'input str>),
"=>?" => Tok::EqualsGreaterThanQuestionCode(<&'input str>),
"=>@L" => Tok::EqualsGreaterThanLookahead(..),
"=>@R" => Tok::EqualsGreaterThanLookbehind(..),
">" => Tok::GreaterThan(..),
"#" => Tok::Hash(..),
"{" => Tok::LeftBrace(..),
"[" => Tok::LeftBracket(..),
"(" => Tok::LeftParen(..),
"<" => Tok::LessThan(..),
"@L" => Tok::Lookahead(..),
"@R" => Tok::Lookbehind(..),
"+" => Tok::Plus(..),
"?" => Tok::Question(..),
"}" => Tok::RightBrace(..),
"]" => Tok::RightBracket(..),
")" => Tok::RightParen(..),
";" => Tok::Semi(..),
"*" => Tok::Star(..),
"~~" => Tok::TildeTilde(..),
"_" => Tok::Underscore(..),
"=>@L" => Tok::EqualsGreaterThanLookahead,
"=>@R" => Tok::EqualsGreaterThanLookbehind,
">" => Tok::GreaterThan,
"#" => Tok::Hash,
"{" => Tok::LeftBrace,
"[" => Tok::LeftBracket,
"(" => Tok::LeftParen,
"<" => Tok::LessThan,
"@L" => Tok::Lookahead,
"@R" => Tok::Lookbehind,
"+" => Tok::Plus,
"?" => Tok::Question,
"}" => Tok::RightBrace,
"]" => Tok::RightBracket,
")" => Tok::RightParen,
";" => Tok::Semi,
"*" => Tok::Star,
"~~" => Tok::TildeTilde,
"_" => Tok::Underscore,
}
}