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

change the behavior of @< and friends so that instead of supplying

Browse Source 
`None`, they use `Default::default`. You can always give an option
yourself if that's what you want, after all, but most of the time
it's kind of annoying!
This commit is contained in:
Niko Matsakis 2015-07-20 05:36:52 -04:00
parent ae37f374cc
commit 2383a021c9
8 changed files with 3385 additions and 3262 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

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

@ -11,8 +11,8 @@ extern token {
}
}
pub Items: Vec<(Option<usize>, Option<usize>)> = {
=> vec![];
pub Items: Vec<(usize, usize)> = {
<@<> <@>> => vec![(<>)];
<v:Items> <e:Spanned<"+">> => {
let mut v = v;
@ -23,6 +23,6 @@ pub Items: Vec<(Option<usize>, Option<usize>)> = {
<v:Items> "-" => v;
};
Spanned<T>: (Option<usize>, Option<usize>) = {
Spanned<T>: (usize, usize) = {
<@<> T <@>> => (<>);
};

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

@ -6,7 +6,7 @@ pub fn parse_Items<
__TOKENS: IntoIterator<Item=(usize,Tok,usize)>,
>(
__tokens: __TOKENS,
) -> Result<(Option<(usize,Tok,usize)>, Vec<(Option<usize>, Option<usize>)>), Option<(usize,Tok,usize)>>
) -> Result<(Option<(usize,Tok,usize)>, Vec<(usize, usize)>), Option<(usize,Tok,usize)>>
{
let mut __tokens = __tokens.into_iter();
let __lookahead = __tokens.next();
@ -22,17 +22,20 @@ mod __parse__Items {
use util::tok::Tok;
pub enum __Nonterminal<> {
Items(Vec<(Option<usize>, Option<usize>)>),
_40_3e(::std::option::Option<usize>),
_40_3c(::std::option::Option<usize>),
____Items(Vec<(Option<usize>, Option<usize>)>),
Spanned_3c_22_2b_22_3e((Option<usize>, Option<usize>)),
_40_3e(usize),
____Items(Vec<(usize, usize)>),
Items(Vec<(usize, usize)>),
Spanned_3c_22_2b_22_3e((usize, usize)),
_40_3c(usize),
}
// State 0
// Items = (*) [EOF]
// Items = (*) ["+"]
// Items = (*) ["-"]
// @< = (*) [EOF]
// @< = (*) ["+"]
// @< = (*) ["-"]
// Items = (*) @< @> [EOF]
// Items = (*) @< @> ["+"]
// Items = (*) @< @> ["-"]
// Items = (*) Items Spanned<"+"> [EOF]
// Items = (*) Items Spanned<"+"> ["+"]
// Items = (*) Items Spanned<"+"> ["-"]
@ -41,11 +44,12 @@ mod __parse__Items {
// Items = (*) Items "-" ["-"]
// __Items = (*) Items [EOF]
//
// "-" -> Reduce(Items = => Call(ActionFn(1));)
// "+" -> Reduce(Items = => Call(ActionFn(1));)
// EOF -> Reduce(Items = => Call(ActionFn(1));)
// EOF -> Reduce(@< = => Lookahead;)
// "-" -> Reduce(@< = => Lookahead;)
// "+" -> Reduce(@< = => Lookahead;)
//
// Items -> S1
// Items -> S2
// @< -> S1
pub fn __state0<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
>(
@ -56,17 +60,17 @@ mod __parse__Items {
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
match __lookahead {
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));
}
Some((_, Tok::Minus(..), _)) => {
let __nt = super::__action1();
__result = (__lookbehind, __lookahead, __Nonterminal::Items(__nt));
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 = super::__action1();
__result = (__lookbehind, __lookahead, __Nonterminal::Items(__nt));
}
None => {
let __nt = super::__action1();
__result = (__lookbehind, __lookahead, __Nonterminal::Items(__nt));
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));
}
_ => {
return Err(__lookahead);
@ -76,6 +80,10 @@ mod __parse__Items {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__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));
}
@ -87,6 +95,61 @@ mod __parse__Items {
}
// State 1
// @> = (*) [EOF]
// @> = (*) ["+"]
// @> = (*) ["-"]
// Items = @< (*) @> [EOF]
// Items = @< (*) @> ["+"]
// Items = @< (*) @> ["-"]
//
// EOF -> Reduce(@> = => Lookbehind;)
// "+" -> Reduce(@> = => Lookbehind;)
// "-" -> Reduce(@> = => Lookbehind;)
//
// @> -> S3
pub fn __state1<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<usize>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
{
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::_40_3e(__nt));
}
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));
}
_ => {
return Err(__lookahead);
}
}
while __sym0.is_some() {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::_40_3e(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
}
}
}
return Ok(__result);
}
// State 2
// @< = (*) ["+"]
// Items = Items (*) Spanned<"+"> [EOF]
// Items = Items (*) Spanned<"+"> ["+"]
@ -99,19 +162,19 @@ mod __parse__Items {
// Spanned<"+"> = (*) @< "+" @> ["-"]
// __Items = Items (*) [EOF]
//
// "+" -> Reduce(@< = => Lookahead;)
// "-" -> Shift(S5)
// EOF -> Reduce(__Items = Items => Call(ActionFn(0));)
// "-" -> Shift(S2)
// "+" -> Reduce(@< = => Lookahead;)
//
// @< -> S6
// Spanned<"+"> -> S4
// @< -> S3
pub fn __state1<
pub fn __state2<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Vec<(Option<usize>, Option<usize>)>>,
__sym0: &mut Option<Vec<(usize, usize)>>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
@ -120,17 +183,17 @@ mod __parse__Items {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
Some((_, Tok::Plus(..), _)) => {
let __nt = __lookahead.as_ref().map(|o| ::std::clone::Clone::clone(&o.0));
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3c(__nt));
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action0(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::____Items(__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));
}
_ => {
return Err(__lookahead);
}
@ -138,14 +201,14 @@ mod __parse__Items {
while __sym0.is_some() {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::_40_3c(__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!(__state4(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
__Nonterminal::_40_3c(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
}
@ -154,57 +217,14 @@ mod __parse__Items {
return Ok(__result);
}
// State 2
// Items = Items "-" (*) [EOF]
// Items = Items "-" (*) ["+"]
// Items = Items "-" (*) ["-"]
//
// "-" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// "+" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// EOF -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
//
pub fn __state2<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Vec<(Option<usize>, Option<usize>)>>,
__sym1: &mut Option<Tok>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
{
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::__action3(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
Some((_, Tok::Plus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action3(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action3(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 3
// Spanned<"+"> = @< (*) "+" @> [EOF]
// Spanned<"+"> = @< (*) "+" @> ["+"]
// Spanned<"+"> = @< (*) "+" @> ["-"]
// Items = @< @> (*) [EOF]
// Items = @< @> (*) ["+"]
// Items = @< @> (*) ["-"]
//
// "+" -> Shift(S5)
// "+" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// "-" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// EOF -> Reduce(Items = @<, @> => Call(ActionFn(1));)
//
pub fn __state3<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
@ -212,22 +232,34 @@ mod __parse__Items {
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<::std::option::Option<usize>>,
__sym0: &mut Option<usize>,
__sym1: &mut Option<usize>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Plus(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
Some((_, Tok::Plus(..), _)) => {
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(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action1(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action1(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
_ => {
return Err(__lookahead);
}
}
return Ok(__result);
}
// State 4
@ -235,8 +267,8 @@ mod __parse__Items {
// Items = Items Spanned<"+"> (*) ["+"]
// Items = Items Spanned<"+"> (*) ["-"]
//
// EOF -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// "-" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// EOF -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// "+" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
//
pub fn __state4<
@ -245,19 +277,19 @@ mod __parse__Items {
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Vec<(Option<usize>, Option<usize>)>>,
__sym1: &mut Option<(Option<usize>, Option<usize>)>,
__sym0: &mut Option<Vec<(usize, usize)>>,
__sym1: &mut Option<(usize, usize)>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
{
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 __nt = super::__action2(__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::__action2(__sym0, __sym1);
@ -276,6 +308,82 @@ mod __parse__Items {
}
// State 5
// Items = Items "-" (*) [EOF]
// Items = Items "-" (*) ["+"]
// Items = Items "-" (*) ["-"]
//
// EOF -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// "-" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// "+" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
//
pub fn __state5<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Vec<(usize, usize)>>,
__sym1: &mut Option<Tok>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
match __lookahead {
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action3(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action3(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
Some((_, Tok::Plus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action3(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 6
// Spanned<"+"> = @< (*) "+" @> [EOF]
// Spanned<"+"> = @< (*) "+" @> ["+"]
// Spanned<"+"> = @< (*) "+" @> ["-"]
//
// "+" -> Shift(S7)
//
pub fn __state6<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<usize>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::Plus(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
_ => {
return Err(__lookahead);
}
}
return Ok(__result);
}
// State 7
// @> = (*) [EOF]
// @> = (*) ["+"]
// @> = (*) ["-"]
@ -284,32 +392,32 @@ mod __parse__Items {
// Spanned<"+"> = @< "+" (*) @> ["-"]
//
// EOF -> Reduce(@> = => Lookbehind;)
// "+" -> Reduce(@> = => Lookbehind;)
// "-" -> Reduce(@> = => Lookbehind;)
// "+" -> Reduce(@> = => Lookbehind;)
//
// @> -> S6
pub fn __state5<
// @> -> S8
pub fn __state7<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<::std::option::Option<usize>>,
__sym0: &mut Option<usize>,
__sym1: &mut Option<Tok>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
{
let mut __result: (Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>);
match __lookahead {
None => {
let __nt = ::std::clone::Clone::clone(&__lookbehind);
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
}
Some((_, Tok::Plus(..), _)) => {
let __nt = ::std::clone::Clone::clone(&__lookbehind);
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);
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
}
Some((_, Tok::Plus(..), _)) => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
}
_ => {
@ -321,7 +429,7 @@ mod __parse__Items {
match __nt {
__Nonterminal::_40_3e(__nt) => {
let __sym2 = &mut Some(__nt);
__result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
@ -331,35 +439,28 @@ mod __parse__Items {
return Ok(__result);
}
// State 6
// State 8
// Spanned<"+"> = @< "+" @> (*) [EOF]
// Spanned<"+"> = @< "+" @> (*) ["+"]
// Spanned<"+"> = @< "+" @> (*) ["-"]
//
// "-" -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
// "+" -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
// EOF -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
// "-" -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
//
pub fn __state6<
pub fn __state8<
__TOKENS: Iterator<Item=(usize,Tok,usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize,Tok,usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<::std::option::Option<usize>>,
__sym0: &mut Option<usize>,
__sym1: &mut Option<Tok>,
__sym2: &mut Option<::std::option::Option<usize>>,
__sym2: &mut Option<usize>,
) -> Result<(Option<usize>, Option<(usize,Tok,usize)>, __Nonterminal<>), Option<(usize,Tok,usize)>>
{
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 __sym2 = __sym2.take().unwrap();
let __nt = super::__action4(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::Spanned_3c_22_2b_22_3e(__nt)));
}
Some((_, Tok::Plus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
@ -374,6 +475,13 @@ 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(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action4(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::Spanned_3c_22_2b_22_3e(__nt)));
}
_ => {
return Err(__lookahead);
}
@ -383,24 +491,26 @@ mod __parse__Items {
pub fn __action0<
>(
__0: Vec<(Option<usize>, Option<usize>)>,
) -> Vec<(Option<usize>, Option<usize>)>
__0: Vec<(usize, usize)>,
) -> Vec<(usize, usize)>
{
(__0)
}
pub fn __action1<
>(
) -> Vec<(Option<usize>, Option<usize>)>
__0: usize,
__1: usize,
) -> Vec<(usize, usize)>
{
vec![]
vec![(__0, __1)]
}
pub fn __action2<
>(
v: Vec<(Option<usize>, Option<usize>)>,
e: (Option<usize>, Option<usize>),
) -> Vec<(Option<usize>, Option<usize>)>
v: Vec<(usize, usize)>,
e: (usize, usize),
) -> Vec<(usize, usize)>
{
{
let mut v = v;
@ -411,19 +521,19 @@ pub fn __action2<
pub fn __action3<
>(
v: Vec<(Option<usize>, Option<usize>)>,
v: Vec<(usize, usize)>,
_: Tok,
) -> Vec<(Option<usize>, Option<usize>)>
) -> Vec<(usize, usize)>
{
v
}
pub fn __action4<
>(
__0: ::std::option::Option<usize>,
__0: usize,
_: Tok,
__1: ::std::option::Option<usize>,
) -> (Option<usize>, Option<usize>)
__1: usize,
) -> (usize, usize)
{
(__0, __1)
}

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

@ -77,9 +77,10 @@ fn expr_arena_test2() {
#[test]
fn loc_test1() {
let expected = vec![(Some(4), Some(5)),
(Some(8), Some(9)),
(Some(16), Some(17))];
let expected = vec![(0, 0),
(4, 5),
(8, 9),
(16, 17)];
util::test_loc(|v| loc::parse_Items(v), "--+-+---+", expected);
// 000001111
// 024680246
@ -87,6 +88,13 @@ fn loc_test1() {
#[test]
fn loc_test2() {
util::test_loc(|v| loc::parse_Items(v), "+", vec![(Some(0), Some(1))]);
util::test_loc(|v| loc::parse_Items(v), "+", vec![(0, 0),
(0, 1)]);
}
#[test]
fn loc_empty() {
// test what happens when `@<` and `@>` are invoked on an empty input
util::test_loc(|v| loc::parse_Items(v), "", vec![(0, 0)]);
}

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

@ -23,9 +23,9 @@ mod __parse__S {
pub enum __Nonterminal<> {
____S(i32),
S(i32),
T(i32),
E(i32),
S(i32),
}
// State 0
@ -40,12 +40,12 @@ mod __parse__S {
// T = (*) "Num" ["-"]
// __S = (*) S [EOF]
//
// "Num" -> Shift(S5)
// "(" -> Shift(S4)
// "(" -> Shift(S2)
// "Num" -> Shift(S3)
//
// S -> S2
// T -> S1
// E -> S3
// S -> S1
// E -> S4
// T -> S5
pub fn __state0<
__TOKENS: Iterator<Item=Tok>,
>(
@ -56,17 +56,17 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::Num(__tok0)) => {
let mut __lookbehind = None;
let mut __sym0 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0));
}
Some(__tok @ Tok::LParen(..)) => {
let mut __lookbehind = None;
let mut __sym0 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0));
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
}
Some(Tok::Num(__tok0)) => {
let mut __lookbehind = None;
let mut __sym0 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0));
}
_ => {
return Err(__lookahead);
@ -76,16 +76,16 @@ mod __parse__S {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::S(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
}
__Nonterminal::T(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0));
}
__Nonterminal::E(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0));
__result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0));
}
__Nonterminal::T(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
@ -95,45 +95,11 @@ mod __parse__S {
}
// State 1
// E = T (*) [EOF]
// E = T (*) ["-"]
//
// "-" -> Reduce(E = T => Call(ActionFn(3));)
// EOF -> Reduce(E = T => Call(ActionFn(3));)
//
pub fn __state1<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
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)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 2
// __S = S (*) [EOF]
//
// EOF -> Reduce(__S = S => Call(ActionFn(0));)
//
pub fn __state2<
pub fn __state1<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
@ -155,44 +121,7 @@ mod __parse__S {
}
}
// State 3
// E = E (*) "-" T [EOF]
// E = E (*) "-" T ["-"]
// S = E (*) [EOF]
//
// EOF -> Reduce(S = E => Call(ActionFn(1));)
// "-" -> Shift(S6)
//
pub fn __state3<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::Minus(..)) => {
let mut __lookbehind = None;
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action1(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::S(__nt)));
}
_ => {
return Err(__lookahead);
}
}
return Ok(__result);
}
// State 4
// State 2
// E = (*) E "-" T [")"]
// E = (*) E "-" T ["-"]
// E = (*) T [")"]
@ -204,12 +133,12 @@ mod __parse__S {
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S10)
// "(" -> Shift(S9)
// "Num" -> Shift(S9)
// "(" -> Shift(S8)
//
// E -> S8
// T -> S7
pub fn __state4<
// E -> S7
// T -> S6
pub fn __state2<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
@ -224,13 +153,13 @@ mod __parse__S {
let mut __lookbehind = None;
let mut __sym1 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state10(__lookbehind, __lookahead, __tokens, __sym1));
__result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym1));
}
Some(__tok @ Tok::LParen(..)) => {
let mut __lookbehind = None;
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym1));
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
return Err(__lookahead);
@ -241,11 +170,11 @@ mod __parse__S {
match __nt {
__Nonterminal::E(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
__Nonterminal::T(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym1));
__result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
@ -255,12 +184,83 @@ mod __parse__S {
return Ok(__result);
}
// State 5
// State 3
// T = "Num" (*) [EOF]
// T = "Num" (*) ["-"]
//
// EOF -> Reduce(T = "Num" => Call(ActionFn(4));)
// "-" -> Reduce(T = "Num" => Call(ActionFn(4));)
// EOF -> Reduce(T = "Num" => Call(ActionFn(4));)
//
pub fn __state3<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
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)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 4
// E = E (*) "-" T [EOF]
// E = E (*) "-" T ["-"]
// S = E (*) [EOF]
//
// EOF -> Reduce(S = E => Call(ActionFn(1));)
// "-" -> Shift(S10)
//
pub fn __state4<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::Minus(..)) => {
let mut __lookbehind = None;
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state10(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action1(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::S(__nt)));
}
_ => {
return Err(__lookahead);
}
}
return Ok(__result);
}
// State 5
// E = T (*) [EOF]
// E = T (*) ["-"]
//
// "-" -> Reduce(E = T => Call(ActionFn(3));)
// EOF -> Reduce(E = T => Call(ActionFn(3));)
//
pub fn __state5<
__TOKENS: Iterator<Item=Tok>,
@ -273,15 +273,15 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
Some(Tok::Minus(..)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
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)));
}
_ => {
return Err(__lookahead);
@ -290,68 +290,13 @@ mod __parse__S {
}
// State 6
// E = E "-" (*) T [EOF]
// E = E "-" (*) T ["-"]
// T = (*) "(" E ")" [EOF]
// T = (*) "(" E ")" ["-"]
// T = (*) "Num" [EOF]
// T = (*) "Num" ["-"]
//
// "(" -> Shift(S4)
// "Num" -> Shift(S5)
//
// T -> S11
pub fn __state6<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
__sym1: &mut Option<Tok>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::LParen(..)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym2));
}
Some(Tok::Num(__tok0)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym2));
}
_ => {
return Err(__lookahead);
}
}
while __sym1.is_some() {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::T(__nt) => {
let __sym2 = &mut Some(__nt);
__result = try!(__state11(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
}
}
}
return Ok(__result);
}
// State 7
// E = T (*) [")"]
// E = T (*) ["-"]
//
// "-" -> Reduce(E = T => Call(ActionFn(3));)
// ")" -> Reduce(E = T => Call(ActionFn(3));)
//
pub fn __state7<
pub fn __state6<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
@ -378,16 +323,16 @@ mod __parse__S {
}
}
// State 8
// State 7
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [EOF]
// T = "(" E (*) ")" ["-"]
//
// "-" -> Shift(S12)
// ")" -> Shift(S13)
// "-" -> Shift(S11)
// ")" -> Shift(S12)
//
pub fn __state8<
pub fn __state7<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
@ -403,13 +348,13 @@ mod __parse__S {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state12(__lookbehind, __lookahead, __tokens, __sym1, __sym2));
__result = try!(__state11(__lookbehind, __lookahead, __tokens, __sym1, __sym2));
}
Some(__tok @ Tok::RParen(..)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state13(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
__result = try!(__state12(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
}
_ => {
return Err(__lookahead);
@ -418,7 +363,7 @@ mod __parse__S {
return Ok(__result);
}
// State 9
// State 8
// E = (*) E "-" T [")"]
// E = (*) E "-" T ["-"]
// E = (*) T [")"]
@ -430,12 +375,12 @@ mod __parse__S {
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "(" -> Shift(S9)
// "Num" -> Shift(S10)
// "Num" -> Shift(S9)
// "(" -> Shift(S8)
//
// E -> S14
// T -> S7
pub fn __state9<
// E -> S13
// T -> S6
pub fn __state8<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
@ -446,17 +391,17 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::LParen(..)) => {
let mut __lookbehind = None;
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym1));
}
Some(Tok::Num(__tok0)) => {
let mut __lookbehind = None;
let mut __sym1 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state10(__lookbehind, __lookahead, __tokens, __sym1));
__result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym1));
}
Some(__tok @ Tok::LParen(..)) => {
let mut __lookbehind = None;
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
return Err(__lookahead);
@ -467,11 +412,11 @@ mod __parse__S {
match __nt {
__Nonterminal::E(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state14(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
__result = try!(__state13(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
__Nonterminal::T(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym1));
__result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
@ -481,14 +426,14 @@ mod __parse__S {
return Ok(__result);
}
// State 10
// State 9
// T = "Num" (*) [")"]
// T = "Num" (*) ["-"]
//
// "-" -> Reduce(T = "Num" => Call(ActionFn(4));)
// ")" -> Reduce(T = "Num" => Call(ActionFn(4));)
//
pub fn __state10<
pub fn __state9<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
@ -515,59 +460,19 @@ mod __parse__S {
}
}
// State 11
// E = E "-" T (*) [EOF]
// E = E "-" T (*) ["-"]
//
// "-" -> Reduce(E = E, "-", T => Call(ActionFn(2));)
// EOF -> Reduce(E = E, "-", T => Call(ActionFn(2));)
//
pub fn __state11<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
__sym1: &mut Option<Tok>,
__sym2: &mut Option<i32>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::Minus(..)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action2(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action2(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 12
// E = E "-" (*) T [")"]
// State 10
// E = E "-" (*) T [EOF]
// E = E "-" (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" [EOF]
// T = (*) "(" E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" [EOF]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S10)
// "(" -> Shift(S9)
// "Num" -> Shift(S3)
// "(" -> Shift(S2)
//
// T -> S15
pub fn __state12<
// T -> S14
pub fn __state10<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
@ -583,12 +488,67 @@ mod __parse__S {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state10(__lookbehind, __lookahead, __tokens, __sym2));
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym2));
}
Some(__tok @ Tok::LParen(..)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym2));
}
_ => {
return Err(__lookahead);
}
}
while __sym1.is_some() {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::T(__nt) => {
let __sym2 = &mut Some(__nt);
__result = try!(__state14(__lookbehind, __lookahead, __tokens, __sym0, __sym1, __sym2));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
}
}
}
return Ok(__result);
}
// State 11
// E = E "-" (*) T [")"]
// E = E "-" (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "(" -> Shift(S8)
// "Num" -> Shift(S9)
//
// T -> S15
pub fn __state11<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
__sym1: &mut Option<Tok>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::LParen(..)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym2));
}
Some(Tok::Num(__tok0)) => {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym2));
}
_ => {
@ -610,14 +570,14 @@ mod __parse__S {
return Ok(__result);
}
// State 13
// State 12
// T = "(" E ")" (*) [EOF]
// T = "(" E ")" (*) ["-"]
//
// "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
// EOF -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
//
pub fn __state13<
pub fn __state12<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
@ -650,16 +610,16 @@ mod __parse__S {
}
}
// State 14
// State 13
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [")"]
// T = "(" E (*) ")" ["-"]
//
// ")" -> Shift(S16)
// "-" -> Shift(S12)
// "-" -> Shift(S11)
//
pub fn __state14<
pub fn __state13<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
@ -681,7 +641,7 @@ mod __parse__S {
let mut __lookbehind = None;
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state12(__lookbehind, __lookahead, __tokens, __sym1, __sym2));
__result = try!(__state11(__lookbehind, __lookahead, __tokens, __sym1, __sym2));
}
_ => {
return Err(__lookahead);
@ -690,6 +650,46 @@ mod __parse__S {
return Ok(__result);
}
// State 14
// E = E "-" T (*) [EOF]
// E = E "-" T (*) ["-"]
//
// "-" -> Reduce(E = E, "-", T => Call(ActionFn(2));)
// EOF -> Reduce(E = E, "-", T => Call(ActionFn(2));)
//
pub fn __state14<
__TOKENS: Iterator<Item=Tok>,
>(
__lookbehind: Option<()>,
__lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
__sym1: &mut Option<Tok>,
__sym2: &mut Option<i32>,
) -> Result<(Option<()>, Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::Minus(..)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action2(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action2(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 15
// E = E "-" T (*) [")"]
// E = E "-" T (*) ["-"]
@ -734,8 +734,8 @@ mod __parse__S {
// T = "(" E ")" (*) [")"]
// T = "(" E ")" (*) ["-"]
//
// "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
// ")" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
// "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
//
pub fn __state16<
__TOKENS: Iterator<Item=Tok>,
@ -750,14 +750,14 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::Minus(..)) => {
Some(Tok::RParen(..)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action5(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
Some(Tok::RParen(..)) => {
Some(Tok::Minus(..)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();

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

@ -248,17 +248,26 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
}
ActionKind::Lookahead => {
// take the lookahead, if any; otherwise, we are
// at EOF, so taker the lookbehind (end of last
// pushed token); if that is missing too, then
// supply default.
debug_assert!(self.types.opt_terminal_loc_type().is_some());
rust!(self.out,
"let {}nt = {}lookahead.as_ref().map(\
|o| ::std::clone::Clone::clone(&o.0));",
self.prefix, self.prefix);
"let {}nt = \
{}lookahead.as_ref()\
.map(|o| ::std::clone::Clone::clone(&o.0))\
.or_else(|| ::std::clone::Clone::clone(&{}lookbehind))\
.unwrap_or_default();",
self.prefix, self.prefix, self.prefix);
}
ActionKind::Lookbehind => {
// take lookbehind or supply default.
debug_assert!(self.types.opt_terminal_loc_type().is_some());
rust!(self.out,
"let {}nt = ::std::clone::Clone::clone(&{}lookbehind);",
"let {}nt = ::std::clone::Clone::clone(&{}lookbehind)\
.unwrap_or_default();",
self.prefix, self.prefix);
}
}

6
lalrpop/src/normalize/tyinfer/mod.rs
View File

@ -230,11 +230,7 @@ impl<'grammar> TypeInferencer<'grammar> {
AlternativeAction::User(&ActionKind::Lookahead) |
AlternativeAction::User(&ActionKind::Lookbehind) => {
let loc_type = self.types.opt_terminal_loc_type().unwrap().clone();
Ok(TypeRepr::Nominal(NominalTypeRepr {
path: Path::option(),
types: vec![loc_type]
}))
Ok(self.types.opt_terminal_loc_type().unwrap().clone())
}
AlternativeAction::Default(Symbols::Named(ref syms)) => {