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

Rename @< and @> to @L and @R

Browse Source
This commit is contained in:
Niko Matsakis 2015-07-21 06:50:41 -04:00
parent b08e0cfe17
commit 69a881d4a5
15 changed files with 3733 additions and 3733 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

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

@ -12,7 +12,7 @@ extern token {
}
pub Items: Vec<(usize, usize)> = {
<@<> <@>> => vec![(<>)];
<@L> <@R> => vec![(<>)];
<v:Items> <e:Spanned<"+">> => {
let mut v = v;
@ -24,5 +24,5 @@ pub Items: Vec<(usize, usize)> = {
};
Spanned<T>: (usize, usize) = {
<@<> T <@>> => (<>);
<@L> T <@R> => (<>);
};

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

@ -34,20 +34,20 @@ mod __parse__Items {
use super::__ToTriple;
pub enum __Nonterminal<> {
Spanned_3c_22_2b_22_3e((usize, usize)),
_40_3e(usize),
____Items(Vec<(usize, usize)>),
_40_3c(usize),
Items(Vec<(usize, usize)>),
Spanned_3c_22_2b_22_3e((usize, usize)),
_40L(usize),
_40R(usize),
}
// State 0
// @< = (*) [EOF]
// @< = (*) ["+"]
// @< = (*) ["-"]
// Items = (*) @< @> [EOF]
// Items = (*) @< @> ["+"]
// Items = (*) @< @> ["-"]
// @L = (*) [EOF]
// @L = (*) ["+"]
// @L = (*) ["-"]
// Items = (*) @L @R [EOF]
// Items = (*) @L @R ["+"]
// Items = (*) @L @R ["-"]
// Items = (*) Items Spanned<"+"> [EOF]
// Items = (*) Items Spanned<"+"> ["+"]
// Items = (*) Items Spanned<"+"> ["-"]
@ -56,12 +56,12 @@ mod __parse__Items {
// Items = (*) Items "-" ["-"]
// __Items = (*) Items [EOF]
//
// "-" -> Reduce(@< = => Lookahead;)
// "+" -> Reduce(@< = => Lookahead;)
// EOF -> Reduce(@< = => Lookahead;)
// "-" -> Reduce(@L = => Lookahead;)
// EOF -> Reduce(@L = => Lookahead;)
// "+" -> Reduce(@L = => Lookahead;)
//
// @L -> S1
// Items -> S2
// @< -> S1
pub fn __state0<
__ERROR,
__TOKENS: Iterator<Item=Result<(usize, Tok, usize),__ERROR>>,
@ -75,15 +75,15 @@ mod __parse__Items {
match __lookahead {
Some((_, Tok::Minus(..), _)) => {
let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
}
Some((_, Tok::Plus(..), _)) => {
let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
__result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
}
None => {
let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
__result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
}
Some((_, Tok::Plus(..), _)) => {
let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
@ -95,14 +95,14 @@ mod __parse__Items {
loop {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::_40L(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0));
}
__Nonterminal::Items(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
}
__Nonterminal::_40_3c(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
}
@ -111,18 +111,18 @@ mod __parse__Items {
}
// State 1
// @> = (*) [EOF]
// @> = (*) ["+"]
// @> = (*) ["-"]
// Items = @< (*) @> [EOF]
// Items = @< (*) @> ["+"]
// Items = @< (*) @> ["-"]
// @R = (*) [EOF]
// @R = (*) ["+"]
// @R = (*) ["-"]
// Items = @L (*) @R [EOF]
// Items = @L (*) @R ["+"]
// Items = @L (*) @R ["-"]
//
// "-" -> Reduce(@> = => Lookbehind;)
// "+" -> Reduce(@> = => Lookbehind;)
// EOF -> Reduce(@> = => Lookbehind;)
// EOF -> Reduce(@R = => Lookbehind;)
// "-" -> Reduce(@R = => Lookbehind;)
// "+" -> Reduce(@R = => Lookbehind;)
//
// @> -> S3
// @R -> S3
pub fn __state1<
__ERROR,
__TOKENS: Iterator<Item=Result<(usize, Tok, usize),__ERROR>>,
@ -135,17 +135,17 @@ mod __parse__Items {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
None => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
}
Some((_, Tok::Minus(..), _)) => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
__result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
}
Some((_, Tok::Plus(..), _)) => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
}
None => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
__result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
@ -157,7 +157,7 @@ mod __parse__Items {
while __sym0.is_some() {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::_40_3e(__nt) => {
__Nonterminal::_40R(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
@ -170,24 +170,24 @@ mod __parse__Items {
}
// State 2
// @< = (*) ["+"]
// @L = (*) ["+"]
// Items = Items (*) Spanned<"+"> [EOF]
// Items = Items (*) Spanned<"+"> ["+"]
// Items = Items (*) Spanned<"+"> ["-"]
// Items = Items (*) "-" [EOF]
// Items = Items (*) "-" ["+"]
// Items = Items (*) "-" ["-"]
// Spanned<"+"> = (*) @< "+" @> [EOF]
// Spanned<"+"> = (*) @< "+" @> ["+"]
// Spanned<"+"> = (*) @< "+" @> ["-"]
// Spanned<"+"> = (*) @L "+" @R [EOF]
// Spanned<"+"> = (*) @L "+" @R ["+"]
// Spanned<"+"> = (*) @L "+" @R ["-"]
// __Items = Items (*) [EOF]
//
// "-" -> Shift(S4)
// "+" -> Reduce(@< = => Lookahead;)
// "+" -> Reduce(@L = => Lookahead;)
// EOF -> Reduce(__Items = Items => Call(ActionFn(0));)
// "-" -> Shift(S4)
//
// Spanned<"+"> -> S6
// @< -> S5
// @L -> S6
// Spanned<"+"> -> S5
pub fn __state2<
__ERROR,
__TOKENS: Iterator<Item=Result<(usize, Tok, usize),__ERROR>>,
@ -208,7 +208,7 @@ mod __parse__Items {
}
Some((_, Tok::Plus(..), _)) => {
let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0)).or_else(|| ::std::clone::Clone::clone(&__lookbehind)).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
__result = (__lookbehind, __lookahead, __Nonterminal::_40L(__nt));
}
None => {
let __sym0 = __sym0.take().unwrap();
@ -225,13 +225,13 @@ mod __parse__Items {
while __sym0.is_some() {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::_40L(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym1));
}
__Nonterminal::Spanned_3c_22_2b_22_3e(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
__Nonterminal::_40_3c(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym1));
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
@ -242,13 +242,13 @@ mod __parse__Items {
}
// State 3
// Items = @< @> (*) [EOF]
// Items = @< @> (*) ["+"]
// Items = @< @> (*) ["-"]
// Items = @L @R (*) [EOF]
// Items = @L @R (*) ["+"]
// Items = @L @R (*) ["-"]
//
// "+" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// EOF -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// "-" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// "+" -> Reduce(Items = @L, @R => Call(ActionFn(1));)
// "-" -> Reduce(Items = @L, @R => Call(ActionFn(1));)
// EOF -> Reduce(Items = @L, @R => Call(ActionFn(1));)
//
pub fn __state3<
__ERROR,
@ -269,13 +269,13 @@ mod __parse__Items {
let __nt = super::__action1(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
None => {
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action1(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
Some((_, Tok::Minus(..), _)) => {
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action1(__sym0, __sym1);
@ -295,9 +295,9 @@ mod __parse__Items {
// Items = Items "-" (*) ["+"]
// Items = Items "-" (*) ["-"]
//
// EOF -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// "-" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// "+" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// "-" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// EOF -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
//
pub fn __state4<
__ERROR,
@ -312,7 +312,7 @@ mod __parse__Items {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
None => {
Some((_, Tok::Plus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action3(__sym0, __sym1);
@ -324,7 +324,7 @@ mod __parse__Items {
let __nt = super::__action3(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
Some((_, Tok::Plus(..), _)) => {
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action3(__sym0, __sym1);
@ -340,13 +340,62 @@ mod __parse__Items {
}
// State 5
// Spanned<"+"> = @< (*) "+" @> [EOF]
// Spanned<"+"> = @< (*) "+" @> ["+"]
// Spanned<"+"> = @< (*) "+" @> ["-"]
// Items = Items Spanned<"+"> (*) [EOF]
// Items = Items Spanned<"+"> (*) ["+"]
// Items = Items Spanned<"+"> (*) ["-"]
//
// "-" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// "+" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// EOF -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
//
pub fn __state5<
__ERROR,
__TOKENS: Iterator<Item=Result<(usize, Tok, usize),__ERROR>>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize, Tok, usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Vec<(usize, usize)>>,
__sym1: &mut Option<(usize, usize)>,
) -> Result<(Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError<usize,Tok,__ERROR>>
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action2(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
Some((_, Tok::Plus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action2(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action2(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
token: __lookahead,
expected: vec![],
});
}
}
}
// State 6
// Spanned<"+"> = @L (*) "+" @R [EOF]
// Spanned<"+"> = @L (*) "+" @R ["+"]
// Spanned<"+"> = @L (*) "+" @R ["-"]
//
// "+" -> Shift(S7)
//
pub fn __state5<
pub fn __state6<
__ERROR,
__TOKENS: Iterator<Item=Result<(usize, Tok, usize),__ERROR>>,
>(
@ -374,68 +423,19 @@ mod __parse__Items {
return Ok(__result);
}
// State 6
// Items = Items Spanned<"+"> (*) [EOF]
// Items = Items Spanned<"+"> (*) ["+"]
// Items = Items Spanned<"+"> (*) ["-"]
//
// "+" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// "-" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// EOF -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
//
pub fn __state6<
__ERROR,
__TOKENS: Iterator<Item=Result<(usize, Tok, usize),__ERROR>>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize, Tok, usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Vec<(usize, usize)>>,
__sym1: &mut Option<(usize, usize)>,
) -> Result<(Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>), __ParseError<usize,Tok,__ERROR>>
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Plus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action2(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action2(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action2(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
token: __lookahead,
expected: vec![],
});
}
}
}
// State 7
// @> = (*) [EOF]
// @> = (*) ["+"]
// @> = (*) ["-"]
// Spanned<"+"> = @< "+" (*) @> [EOF]
// Spanned<"+"> = @< "+" (*) @> ["+"]
// Spanned<"+"> = @< "+" (*) @> ["-"]
// @R = (*) [EOF]
// @R = (*) ["+"]
// @R = (*) ["-"]
// Spanned<"+"> = @L "+" (*) @R [EOF]
// Spanned<"+"> = @L "+" (*) @R ["+"]
// Spanned<"+"> = @L "+" (*) @R ["-"]
//
// "+" -> Reduce(@> = => Lookbehind;)
// "-" -> Reduce(@> = => Lookbehind;)
// EOF -> Reduce(@> = => Lookbehind;)
// "-" -> Reduce(@R = => Lookbehind;)
// "+" -> Reduce(@R = => Lookbehind;)
// EOF -> Reduce(@R = => Lookbehind;)
//
// @> -> S8
// @R -> S8
pub fn __state7<
__ERROR,
__TOKENS: Iterator<Item=Result<(usize, Tok, usize),__ERROR>>,
@ -449,17 +449,17 @@ mod __parse__Items {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Plus(..), _)) => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
}
Some((_, Tok::Minus(..), _)) => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
__result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
}
Some((_, Tok::Plus(..), _)) => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
}
None => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
__result = (__lookbehind, __lookahead, __Nonterminal::_40R(__nt));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
@ -471,7 +471,7 @@ mod __parse__Items {
while __sym1.is_some() {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::_40_3e(__nt) => {
__Nonterminal::_40R(__nt) => {
let __sym2 = &mut Some(__nt);
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
}
@ -484,13 +484,13 @@ mod __parse__Items {
}
// State 8
// Spanned<"+"> = @< "+" @> (*) [EOF]
// Spanned<"+"> = @< "+" @> (*) ["+"]
// Spanned<"+"> = @< "+" @> (*) ["-"]
// Spanned<"+"> = @L "+" @R (*) [EOF]
// Spanned<"+"> = @L "+" @R (*) ["+"]
// Spanned<"+"> = @L "+" @R (*) ["-"]
//
// EOF -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
// "+" -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
// "-" -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
// "-" -> Reduce(Spanned<"+"> = @L, "+", @R => Call(ActionFn(4));)
// "+" -> Reduce(Spanned<"+"> = @L, "+", @R => Call(ActionFn(4));)
// EOF -> Reduce(Spanned<"+"> = @L, "+", @R => Call(ActionFn(4));)
//
pub fn __state8<
__ERROR,
@ -506,7 +506,7 @@ mod __parse__Items {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
None => {
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -520,7 +520,7 @@ mod __parse__Items {
let __nt = super::__action4(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::Spanned_3c_22_2b_22_3e(__nt)));
}
Some((_, Tok::Minus(..), _)) => {
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();

2
lalrpop-test/src/main.rs
View File

@ -111,7 +111,7 @@ fn loc_test2() {
#[test]
fn loc_empty() {
// test what happens when `@<` and `@>` are invoked on an empty input
// test what happens when `@L` and `@R` are invoked on an empty input
util::test_loc(|v| loc::parse_Items(v), "", vec![(0, 0)]);
}

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

@ -34,10 +34,10 @@ mod __parse__S {
use super::__ToTriple;
pub enum __Nonterminal<> {
S(i32),
____S(i32),
T(i32),
S(i32),
E(i32),
____S(i32),
}
// State 0
@ -52,12 +52,12 @@ mod __parse__S {
// T = (*) "Num" ["-"]
// __S = (*) S [EOF]
//
// "Num" -> Shift(S5)
// "(" -> Shift(S4)
// "(" -> Shift(S3)
// "Num" -> Shift(S1)
//
// T -> S1
// S -> S2
// E -> S3
// S -> S5
// E -> S2
// T -> S4
pub fn __state0<
__ERROR,
__TOKENS: Iterator<Item=Result<((), Tok, ()),__ERROR>>,
@ -69,17 +69,17 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Num(__tok0), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym0 = &mut Some((__tok0));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0));
}
Some((_, __tok @ Tok::LParen(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym0 = &mut Some((__tok));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0));
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0));
}
Some((_, Tok::Num(__tok0), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym0 = &mut Some((__tok0));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
@ -91,17 +91,17 @@ mod __parse__S {
loop {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::T(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0));
}
__Nonterminal::S(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0));
}
__Nonterminal::E(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0));
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
}
__Nonterminal::T(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
@ -111,11 +111,11 @@ mod __parse__S {
}
// State 1
// E = T (*) [EOF]
// E = T (*) ["-"]
// T = "Num" (*) [EOF]
// T = "Num" (*) ["-"]
//
// "-" -> Reduce(E = T => Call(ActionFn(3));)
// EOF -> Reduce(E = T => Call(ActionFn(3));)
// EOF -> Reduce(T = "Num" => Call(ActionFn(4));)
// "-" -> Reduce(T = "Num" => Call(ActionFn(4));)
//
pub fn __state1<
__ERROR,
@ -129,15 +129,15 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
@ -149,37 +149,6 @@ mod __parse__S {
}
// State 2
// __S = S (*) [EOF]
//
// EOF -> Reduce(__S = S => Call(ActionFn(0));)
//
pub fn __state2<
__ERROR,
__TOKENS: Iterator<Item=Result<((), Tok, ()),__ERROR>>,
>(
__lookbehind: Option<()>,
__lookahead: Option<((), Tok, ())>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>>
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action0(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::____S(__nt)));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
token: __lookahead,
expected: vec![],
});
}
}
}
// State 3
// E = E (*) "-" T [EOF]
// E = E (*) "-" T ["-"]
// S = E (*) [EOF]
@ -187,7 +156,7 @@ mod __parse__S {
// "-" -> Shift(S6)
// EOF -> Reduce(S = E => Call(ActionFn(1));)
//
pub fn __state3<
pub fn __state2<
__ERROR,
__TOKENS: Iterator<Item=Result<((), Tok, ()),__ERROR>>,
>(
@ -220,7 +189,7 @@ mod __parse__S {
return Ok(__result);
}
// State 4
// State 3
// E = (*) E "-" T [")"]
// E = (*) E "-" T ["-"]
// E = (*) T [")"]
@ -232,12 +201,12 @@ mod __parse__S {
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S10)
// "(" -> Shift(S7)
// "(" -> Shift(S8)
// "Num" -> Shift(S7)
//
// T -> S8
// T -> S10
// E -> S9
pub fn __state4<
pub fn __state3<
__ERROR,
__TOKENS: Iterator<Item=Result<((), Tok, ()),__ERROR>>,
>(
@ -249,16 +218,16 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Num(__tok0), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok0));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state10(__lookbehind, __lookahead, __tokens, __sym1));
}
Some((_, __tok @ Tok::LParen(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym1));
}
Some((_, Tok::Num(__tok0), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok0));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
@ -273,7 +242,7 @@ mod __parse__S {
match __nt {
__Nonterminal::T(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym1));
__result = try!(__state10(__lookbehind, __lookahead, __tokens, __sym1));
}
__Nonterminal::E(__nt) => {
let __sym1 = &mut Some(__nt);
@ -287,12 +256,48 @@ mod __parse__S {
return Ok(__result);
}
// State 5
// T = "Num" (*) [EOF]
// T = "Num" (*) ["-"]
// State 4
// E = T (*) [EOF]
// E = T (*) ["-"]
//
// EOF -> Reduce(T = "Num" => Call(ActionFn(4));)
// "-" -> Reduce(T = "Num" => Call(ActionFn(4));)
// EOF -> Reduce(E = T => Call(ActionFn(3));)
// "-" -> Reduce(E = T => Call(ActionFn(3));)
//
pub fn __state4<
__ERROR,
__TOKENS: Iterator<Item=Result<((), Tok, ()),__ERROR>>,
>(
__lookbehind: Option<()>,
__lookahead: Option<((), Tok, ())>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>>
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
token: __lookahead,
expected: vec![],
});
}
}
}
// State 5
// __S = S (*) [EOF]
//
// EOF -> Reduce(__S = S => Call(ActionFn(0));)
//
pub fn __state5<
__ERROR,
@ -308,13 +313,8 @@ mod __parse__S {
match __lookahead {
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
let __nt = super::__action0(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::____S(__nt)));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
@ -333,8 +333,8 @@ mod __parse__S {
// T = (*) "Num" [EOF]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S5)
// "(" -> Shift(S4)
// "(" -> Shift(S3)
// "Num" -> Shift(S1)
//
// T -> S11
pub fn __state6<
@ -350,17 +350,17 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Num(__tok0), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok0));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym2));
}
Some((_, __tok @ Tok::LParen(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym2));
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym2));
}
Some((_, Tok::Num(__tok0), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok0));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym2));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
@ -385,6 +385,44 @@ mod __parse__S {
}
// State 7
// T = "Num" (*) [")"]
// T = "Num" (*) ["-"]
//
// "-" -> Reduce(T = "Num" => Call(ActionFn(4));)
// ")" -> Reduce(T = "Num" => Call(ActionFn(4));)
//
pub fn __state7<
__ERROR,
__TOKENS: Iterator<Item=Result<((), Tok, ()),__ERROR>>,
>(
__lookbehind: Option<()>,
__lookahead: Option<((), Tok, ())>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>>
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
Some((_, Tok::RParen(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
token: __lookahead,
expected: vec![],
});
}
}
}
// State 8
// E = (*) E "-" T [")"]
// E = (*) E "-" T ["-"]
// E = (*) T [")"]
@ -396,12 +434,12 @@ mod __parse__S {
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "(" -> Shift(S7)
// "Num" -> Shift(S10)
// "(" -> Shift(S8)
// "Num" -> Shift(S7)
//
// E -> S12
// T -> S8
pub fn __state7<
// T -> S10
pub fn __state8<
__ERROR,
__TOKENS: Iterator<Item=Result<((), Tok, ()),__ERROR>>,
>(
@ -417,13 +455,13 @@ mod __parse__S {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym1));
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym1));
}
Some((_, Tok::Num(__tok0), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok0));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state10(__lookbehind, __lookahead, __tokens, __sym1));
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
@ -441,7 +479,7 @@ mod __parse__S {
}
__Nonterminal::T(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym1));
__result = try!(__state10(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
@ -451,52 +489,14 @@ mod __parse__S {
return Ok(__result);
}
// State 8
// E = T (*) [")"]
// E = T (*) ["-"]
//
// "-" -> Reduce(E = T => Call(ActionFn(3));)
// ")" -> Reduce(E = T => Call(ActionFn(3));)
//
pub fn __state8<
__ERROR,
__TOKENS: Iterator<Item=Result<((), Tok, ()),__ERROR>>,
>(
__lookbehind: Option<()>,
__lookahead: Option<((), Tok, ())>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>>
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
Some((_, Tok::RParen(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
token: __lookahead,
expected: vec![],
});
}
}
}
// State 9
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [EOF]
// T = "(" E (*) ")" ["-"]
//
// ")" -> Shift(S14)
// "-" -> Shift(S13)
// ")" -> Shift(S14)
//
pub fn __state9<
__ERROR,
@ -511,18 +511,18 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::RParen(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state14(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
}
Some((_, __tok @ Tok::Minus(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state13(__lookbehind, __lookahead, __tokens, __sym1, __sym2));
}
Some((_, __tok @ Tok::RParen(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state14(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
token: __lookahead,
@ -534,11 +534,11 @@ mod __parse__S {
}
// State 10
// T = "Num" (*) [")"]
// T = "Num" (*) ["-"]
// E = T (*) [")"]
// E = T (*) ["-"]
//
// "-" -> Reduce(T = "Num" => Call(ActionFn(4));)
// ")" -> Reduce(T = "Num" => Call(ActionFn(4));)
// "-" -> Reduce(E = T => Call(ActionFn(3));)
// ")" -> Reduce(E = T => Call(ActionFn(3));)
//
pub fn __state10<
__ERROR,
@ -554,13 +554,13 @@ mod __parse__S {
match __lookahead {
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
let __nt = super::__action3(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
Some((_, Tok::RParen(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
let __nt = super::__action3(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
@ -575,8 +575,8 @@ mod __parse__S {
// E = E "-" T (*) [EOF]
// E = E "-" T (*) ["-"]
//
// EOF -> Reduce(E = E, "-", T => Call(ActionFn(2));)
// "-" -> Reduce(E = E, "-", T => Call(ActionFn(2));)
// EOF -> Reduce(E = E, "-", T => Call(ActionFn(2));)
//
pub fn __state11<
__ERROR,
@ -592,14 +592,14 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
None => {
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action2(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
Some((_, Tok::Minus(..), _)) => {
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -667,8 +667,8 @@ mod __parse__S {
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "(" -> Shift(S7)
// "Num" -> Shift(S10)
// "Num" -> Shift(S7)
// "(" -> Shift(S8)
//
// T -> S16
pub fn __state13<
@ -684,17 +684,17 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym2));
}
Some((_, Tok::Num(__tok0), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok0));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state10(__lookbehind, __lookahead, __tokens, __sym2));
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym2));
}
Some((_, __tok @ Tok::LParen(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym2));
}
_ => {
return Err(__ParseError::UnrecognizedToken {

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

@ -34,17 +34,17 @@ mod __parse__S {
use super::__ToTriple;
pub enum __Nonterminal<> {
____S(i32),
S(i32),
____S(i32),
}
// State 0
// S = (*) "(" ")" [EOF]
// __S = (*) S [EOF]
//
// "(" -> Shift(S1)
// "(" -> Shift(S2)
//
// S -> S2
// S -> S1
pub fn __state0<
__ERROR,
__TOKENS: Iterator<Item=Result<((), Tok, ()),__ERROR>>,
@ -60,7 +60,7 @@ mod __parse__S {
let mut __lookbehind = Some(__loc);
let mut __sym0 = &mut Some((__tok));
let __lookahead = match __tokens.next() { Some(Ok(v)) => Some(v), None => None, Some(Err(e)) => return Err(__ParseError::User { error: e }) };
__result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0));
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
@ -74,7 +74,7 @@ mod __parse__S {
match __nt {
__Nonterminal::S(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
__result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
@ -84,11 +84,42 @@ mod __parse__S {
}
// State 1
// __S = S (*) [EOF]
//
// EOF -> Reduce(__S = S => Call(ActionFn(0));)
//
pub fn __state1<
__ERROR,
__TOKENS: Iterator<Item=Result<((), Tok, ()),__ERROR>>,
>(
__lookbehind: Option<()>,
__lookahead: Option<((), Tok, ())>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>>
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action0(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::____S(__nt)));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
token: __lookahead,
expected: vec![],
});
}
}
}
// State 2
// S = "(" (*) ")" [EOF]
//
// ")" -> Shift(S3)
//
pub fn __state1<
pub fn __state2<
__ERROR,
__TOKENS: Iterator<Item=Result<((), Tok, ()),__ERROR>>,
>(
@ -116,37 +147,6 @@ mod __parse__S {
return Ok(__result);
}
// State 2
// __S = S (*) [EOF]
//
// EOF -> Reduce(__S = S => Call(ActionFn(0));)
//
pub fn __state2<
__ERROR,
__TOKENS: Iterator<Item=Result<((), Tok, ()),__ERROR>>,
>(
__lookbehind: Option<()>,
__lookahead: Option<((), Tok, ())>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), __ParseError<(),Tok,__ERROR>>
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action0(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::____S(__nt)));
}
_ => {
return Err(__ParseError::UnrecognizedToken {
token: __lookahead,
expected: vec![],
});
}
}
}
// State 3
// S = "(" ")" (*) [EOF]
//

8
lalrpop/src/grammar/parse_tree.rs
View File

@ -190,10 +190,10 @@ pub enum SymbolKind {
// x:X
Name(InternedString, Box<Symbol>),
// @<
// @L
Lookahead,
// @>
// @R
Lookbehind,
}
@ -322,9 +322,9 @@ impl Display for SymbolKind {
SymbolKind::Name(n, ref s) =>
write!(fmt, "{}:{}", n, s),
SymbolKind::Lookahead =>
write!(fmt, "@<"),
write!(fmt, "@L"),
SymbolKind::Lookbehind =>
write!(fmt, "@>"),
write!(fmt, "@R"),
}
}
}

4
lalrpop/src/normalize/macro_expand/mod.rs
View File

@ -79,10 +79,10 @@ impl MacroExpander {
items.push(try!(self.expand_repeat_symbol(sym.span, *repeat))),
SymbolKind::Lookahead =>
items.push(try!(self.expand_lookaround_symbol(
sym.span, "@<", ActionKind::Lookahead))),
sym.span, "@L", ActionKind::Lookahead))),
SymbolKind::Lookbehind =>
items.push(try!(self.expand_lookaround_symbol(
sym.span, "@>", ActionKind::Lookbehind))),
sym.span, "@R", ActionKind::Lookbehind))),
_ =>
assert!(false, "don't know how to expand `{:?}`", sym)
}

6
lalrpop/src/normalize/macro_expand/test.rs
View File

@ -76,15 +76,15 @@ grammar;
fn test_lookahead() {
let grammar = parser::parse_grammar(r#"
grammar;
Expr = @<;
Expr = @L;
"#).unwrap();
let actual = expand_macros(grammar).unwrap();
let expected = parser::parse_grammar(r#"
grammar;
Expr = `@<`;
`@<` = =>@<;
Expr = `@L`;
`@L` = =>@L;
"#).unwrap();
compare(actual, expected);

4
lalrpop/src/normalize/tyinfer/test.rs
View File

@ -132,7 +132,7 @@ fn test_lookahead() {
compare(r#"
grammar;
extern token { type Location = usize; enum Tok { } }
A = @<;
A = @L;
"#, vec![
("A", "::std::option::Option<usize>"),
])
@ -145,7 +145,7 @@ fn test_spanned_macro() {
extern token { type Location = usize; enum Tok { } }
A = Spanned<"Foo">;
Spanned<T>: (Option<usize>, Option<usize>) = {
<@<> T <@>> => (<>);
<@L> T <@R> => (<>);
};
"#, vec![
("A", "(Option<usize>, Option<usize>)"),

2
lalrpop/src/normalize/validate/test.rs
View File

@ -76,7 +76,7 @@ fn dup_assoc_type() {
fn lookahead_without_loc_type() {
check_err(
r#"lookahead/lookbehind require you to declare the type of a location"#,
r#"grammar; extern token { enum Tok { } } Foo = >>>@<<<<;"#);
r#"grammar; extern token { enum Tok { } } Foo = >>>@L<<<;"#);
}
#[test]

8
lalrpop/src/parser/mod.rs
View File

@ -116,10 +116,10 @@ rusty_peg! {
("=>" <b:CODE>) => ActionKind::User(b);
LOOKAHEAD_ACTION: ActionKind =
("=>@<") => ActionKind::Lookahead;
("=>@L") => ActionKind::Lookahead;
LOOKBEHIND_ACTION: ActionKind =
("=>@>") => ActionKind::Lookbehind;
("=>@R") => ActionKind::Lookbehind;
// Conditions
@ -194,12 +194,12 @@ rusty_peg! {
};
LOOKAHEAD_SYMBOL: Symbol =
(<lo:POSL> "@<" <hi:POSR>) => {
(<lo:POSL> "@L" <hi:POSR>) => {
Symbol::new(Span(lo, hi), SymbolKind::Lookahead)
};
LOOKBEHIND_SYMBOL: Symbol =
(<lo:POSL> "@>" <hi:POSR>) => {
(<lo:POSL> "@R" <hi:POSR>) => {
Symbol::new(Span(lo, hi), SymbolKind::Lookbehind)
};

4
lalrpop/src/parser/test.rs
View File

@ -126,8 +126,8 @@ fn macro_symbols() {
#[test]
fn lookaround() {
super::parse_symbol(r#"@<"#).unwrap();
super::parse_symbol(r#"@>"#).unwrap();
super::parse_symbol(r#"@L"#).unwrap();
super::parse_symbol(r#"@R"#).unwrap();
}
#[test]

12
lalrpop/src/tok/mod.rs
View File

@ -54,8 +54,8 @@ pub enum Tok<'input> {
LeftBracket,
LeftParen,
LessThan,
Lookahead, // @<
Lookbehind, // @>
Lookahead, // @L
Lookbehind, // @R
Plus,
Question,
RightBrace,
@ -113,17 +113,17 @@ impl<'input> Tokenizer<'input> {
// we've seen =>, now we have to choose between:
//
// => code
// =>@<
// =>@>
// =>@L
// =>@R
let idx1 = match self.lookahead {
Some((_, '@')) => {
match self.bump() {
Some((idx2, '<')) => {
Some((idx2, 'L')) => {
self.bump();
return Ok((idx0, EqualsGreaterThanLookahead, idx2+1));
}
Some((idx2, '>')) => {
Some((idx2, 'R')) => {
self.bump();
return Ok((idx0, EqualsGreaterThanLookbehind, idx2+1));
}