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

better test for using super

Browse Source
This commit is contained in:
Niko Matsakis 2015-07-20 13:02:15 -04:00
parent 9f4c82cf36
commit 91dc00aa89
8 changed files with 4711 additions and 4472 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

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

@ -31,11 +31,13 @@ mod __parse__Items {
#![allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports)]
use util::tok::Tok;
extern crate lalrpop_util as __lalrpop_util;
use self::__lalrpop_util::ParseError as __ParseError;
pub enum __Nonterminal<> {
_40_3c(usize),
_40_3e(usize),
____Items(Vec<(usize, usize)>),
_40_3c(usize),
Spanned_3c_22_2b_22_3e((usize, usize)),
Items(Vec<(usize, usize)>),
}
@ -59,8 +61,8 @@ mod __parse__Items {
// "-" -> Reduce(@< = => Lookahead;)
// EOF -> Reduce(@< = => Lookahead;)
//
// @< -> S1
// Items -> S2
// Items -> S1
// @< -> S2
pub fn __state0<
__TOKENS: Iterator<Item=(usize, Tok, usize)>,
>(
@ -90,11 +92,11 @@ mod __parse__Items {
loop {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::_40_3c(__nt) => {
__Nonterminal::Items(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0));
}
__Nonterminal::Items(__nt) => {
__Nonterminal::_40_3c(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
}
@ -106,61 +108,6 @@ mod __parse__Items {
}
// State 1
// @> = (*) [EOF]
// @> = (*) ["+"]
// @> = (*) ["-"]
// Items = @< (*) @> [EOF]
// Items = @< (*) @> ["+"]
// Items = @< (*) @> ["-"]
//
// "-" -> Reduce(@> = => Lookbehind;)
// EOF -> 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 {
Some((_, Tok::Minus(..), _)) => {
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));
}
Some((_, Tok::Plus(..), _)) => {
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<"+"> ["+"]
@ -175,11 +122,11 @@ mod __parse__Items {
//
// EOF -> Reduce(__Items = Items => Call(ActionFn(0));)
// "+" -> Reduce(@< = => Lookahead;)
// "-" -> Shift(S6)
// "-" -> Shift(S4)
//
// Spanned<"+"> -> S4
// Spanned<"+"> -> S3
// @< -> S5
pub fn __state2<
pub fn __state1<
__TOKENS: Iterator<Item=(usize, Tok, usize)>,
>(
__lookbehind: Option<usize>,
@ -194,7 +141,7 @@ mod __parse__Items {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state6(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
__result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
None => {
let __sym0 = __sym0.take().unwrap();
@ -214,7 +161,7 @@ mod __parse__Items {
match __nt {
__Nonterminal::Spanned_3c_22_2b_22_3e(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
__Nonterminal::_40_3c(__nt) => {
let __sym1 = &mut Some(__nt);
@ -228,61 +175,71 @@ mod __parse__Items {
return Ok(__result);
}
// State 3
// Items = @< @> (*) [EOF]
// Items = @< @> (*) ["+"]
// Items = @< @> (*) ["-"]
// State 2
// @> = (*) [EOF]
// @> = (*) ["+"]
// @> = (*) ["-"]
// Items = @< (*) @> [EOF]
// Items = @< (*) @> ["+"]
// Items = @< (*) @> ["-"]
//
// "+" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// "-" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// EOF -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// "+" -> Reduce(@> = => Lookbehind;)
// EOF -> Reduce(@> = => Lookbehind;)
// "-" -> Reduce(@> = => Lookbehind;)
//
pub fn __state3<
// @> -> S6
pub fn __state2<
__TOKENS: Iterator<Item=(usize, Tok, usize)>,
>(
__lookbehind: Option<usize>,
__lookahead: Option<(usize, Tok, usize)>,
__tokens: &mut __TOKENS,
__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::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)));
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__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)));
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!(__state6(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
}
}
}
return Ok(__result);
}
// State 4
// State 3
// Items = Items Spanned<"+"> (*) [EOF]
// Items = Items Spanned<"+"> (*) ["+"]
// Items = Items Spanned<"+"> (*) ["-"]
//
// "-" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// "+" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// "-" -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
// EOF -> Reduce(Items = Items, Spanned<"+"> => Call(ActionFn(2));)
//
pub fn __state4<
pub fn __state3<
__TOKENS: Iterator<Item=(usize, Tok, usize)>,
>(
__lookbehind: Option<usize>,
@ -294,13 +251,13 @@ mod __parse__Items {
{
let mut __result: (Option<usize>, Option<(usize, Tok, usize)>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Minus(..), _)) => {
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::Plus(..), _)) => {
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action2(__sym0, __sym1);
@ -318,6 +275,51 @@ mod __parse__Items {
}
}
// State 4
// 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 __state4<
__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 5
// Spanned<"+"> = @< (*) "+" @> [EOF]
// Spanned<"+"> = @< (*) "+" @> ["+"]
@ -350,13 +352,13 @@ mod __parse__Items {
}
// State 6
// Items = Items "-" (*) [EOF]
// Items = Items "-" (*) ["+"]
// Items = Items "-" (*) ["-"]
// Items = @< @> (*) [EOF]
// Items = @< @> (*) ["+"]
// Items = @< @> (*) ["-"]
//
// "+" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// EOF -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// "-" -> Reduce(Items = Items, "-" => Call(ActionFn(3));)
// EOF -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// "+" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
// "-" -> Reduce(Items = @<, @> => Call(ActionFn(1));)
//
pub fn __state6<
__TOKENS: Iterator<Item=(usize, Tok, usize)>,
@ -364,28 +366,28 @@ mod __parse__Items {
__lookbehind: Option<usize>,
__lookahead: Option<(usize, Tok, usize)>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Vec<(usize, usize)>>,
__sym1: &mut Option<Tok>,
__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::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);
let __nt = super::__action1(__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::__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::__action3(__sym0, __sym1);
let __nt = super::__action1(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::Items(__nt)));
}
_ => {
@ -402,9 +404,9 @@ mod __parse__Items {
// Spanned<"+"> = @< "+" (*) @> ["+"]
// Spanned<"+"> = @< "+" (*) @> ["-"]
//
// EOF -> Reduce(@> = => Lookbehind;)
// "-" -> Reduce(@> = => Lookbehind;)
// "+" -> Reduce(@> = => Lookbehind;)
// EOF -> Reduce(@> = => Lookbehind;)
//
// @> -> S8
pub fn __state7<
@ -419,6 +421,10 @@ 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::_40_3e(__nt));
}
Some((_, Tok::Minus(..), _)) => {
let __nt = ::std::clone::Clone::clone(&__lookbehind).unwrap_or_default();
__result = (__lookbehind, __lookahead, __Nonterminal::_40_3e(__nt));
@ -427,10 +433,6 @@ mod __parse__Items {
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));
}
_ => {
return Err(__lookahead);
}
@ -455,9 +457,9 @@ mod __parse__Items {
// Spanned<"+"> = @< "+" @> (*) ["+"]
// Spanned<"+"> = @< "+" @> (*) ["-"]
//
// "-" -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
// EOF -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
// "+" -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
// "-" -> Reduce(Spanned<"+"> = @<, "+", @> => Call(ActionFn(4));)
//
pub fn __state8<
__TOKENS: Iterator<Item=(usize, Tok, usize)>,
@ -472,6 +474,13 @@ mod __parse__Items {
{
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)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
@ -486,13 +495,6 @@ 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);
}

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

@ -1,8 +1,23 @@
mod expr;
mod expr_arena;
mod expr_arena_ast;
mod loc;
/// demonstration from the Greene text; one of the simplest grammars
/// that still ensures we get parse tree correct
mod sub;
/// more interesting demonstration of parsing full expressions
mod expr;
/// test that passes in lifetime/type/formal parameters and threads
/// them through, building an AST from the result
mod expr_arena;
/// definitions of the AST
mod expr_arena_ast;
/// test that exercises locations and spans
mod loc;
/// test that uses `super` in paths in various places
mod use_super;
mod util;
/// This constant is here so that some of the generator parsers can
@ -98,3 +113,8 @@ fn loc_empty() {
util::test_loc(|v| loc::parse_Items(v), "", vec![(0, 0)]);
}
#[test]
fn use_super_test1() {
util::test(|v| use_super::parse_S(v), "()", 0);
}

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

@ -32,12 +32,14 @@ mod __parse__S {
#![allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports)]
use util::tok::Tok;
extern crate lalrpop_util as __lalrpop_util;
use self::__lalrpop_util::ParseError as __ParseError;
pub enum __Nonterminal<> {
E(i32),
S(i32),
T(i32),
S(i32),
____S(i32),
E(i32),
}
// State 0
@ -52,12 +54,12 @@ mod __parse__S {
// T = (*) "Num" ["-"]
// __S = (*) S [EOF]
//
// "(" -> Shift(S5)
// "Num" -> Shift(S2)
// "Num" -> Shift(S5)
// "(" -> Shift(S4)
//
// E -> S1
// T -> S3
// S -> S4
// T -> S2
// S -> S3
pub fn __state0<
__TOKENS: Iterator<Item=((), Tok, ())>,
>(
@ -68,17 +70,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 __sym0 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym0));
}
Some((_, Tok::Num(__tok0), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym0 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
__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 = __tokens.next();
__result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0));
}
_ => {
return Err(__lookahead);
@ -93,11 +95,11 @@ mod __parse__S {
}
__Nonterminal::T(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0));
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
}
__Nonterminal::S(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym0));
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
@ -111,8 +113,8 @@ mod __parse__S {
// E = E (*) "-" T ["-"]
// S = E (*) [EOF]
//
// "-" -> Shift(S6)
// EOF -> Reduce(S = E => Call(ActionFn(1));)
// "-" -> Shift(S6)
//
pub fn __state1<
__TOKENS: Iterator<Item=((), Tok, ())>,
@ -144,11 +146,11 @@ mod __parse__S {
}
// State 2
// T = "Num" (*) [EOF]
// T = "Num" (*) ["-"]
// E = T (*) [EOF]
// E = T (*) ["-"]
//
// "-" -> Reduce(T = "Num" => Call(ActionFn(4));)
// EOF -> Reduce(T = "Num" => Call(ActionFn(4));)
// EOF -> Reduce(E = T => Call(ActionFn(3));)
// "-" -> Reduce(E = T => Call(ActionFn(3));)
//
pub fn __state2<
__TOKENS: Iterator<Item=((), Tok, ())>,
@ -161,15 +163,15 @@ mod __parse__S {
{
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)));
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(__lookahead);
@ -178,45 +180,11 @@ mod __parse__S {
}
// State 3
// E = T (*) [EOF]
// E = T (*) ["-"]
//
// EOF -> Reduce(E = T => Call(ActionFn(3));)
// "-" -> Reduce(E = T => Call(ActionFn(3));)
//
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 {
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(__lookahead);
}
}
}
// State 4
// __S = S (*) [EOF]
//
// EOF -> Reduce(__S = S => Call(ActionFn(0));)
//
pub fn __state4<
pub fn __state3<
__TOKENS: Iterator<Item=((), Tok, ())>,
>(
__lookbehind: Option<()>,
@ -238,7 +206,7 @@ mod __parse__S {
}
}
// State 5
// State 4
// E = (*) E "-" T [")"]
// E = (*) E "-" T ["-"]
// E = (*) T [")"]
@ -251,11 +219,11 @@ mod __parse__S {
// T = (*) "Num" ["-"]
//
// "(" -> Shift(S10)
// "Num" -> Shift(S7)
// "Num" -> Shift(S8)
//
// E -> S8
// T -> S9
pub fn __state5<
// T -> S7
// E -> S9
pub fn __state4<
__TOKENS: Iterator<Item=((), Tok, ())>,
>(
__lookbehind: Option<()>,
@ -276,7 +244,7 @@ mod __parse__S {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym1));
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
return Err(__lookahead);
@ -285,13 +253,13 @@ mod __parse__S {
while __sym0.is_some() {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::E(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
__Nonterminal::T(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym1));
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym1));
}
__Nonterminal::E(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
@ -301,6 +269,40 @@ mod __parse__S {
return Ok(__result);
}
// State 5
// T = "Num" (*) [EOF]
// T = "Num" (*) ["-"]
//
// EOF -> Reduce(T = "Num" => Call(ActionFn(4));)
// "-" -> Reduce(T = "Num" => Call(ActionFn(4));)
//
pub fn __state5<
__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 {
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action4(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 6
// E = E "-" (*) T [EOF]
// E = E "-" (*) T ["-"]
@ -309,8 +311,8 @@ mod __parse__S {
// T = (*) "Num" [EOF]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S2)
// "(" -> Shift(S5)
// "(" -> Shift(S4)
// "Num" -> Shift(S5)
//
// T -> S11
pub fn __state6<
@ -325,16 +327,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 __sym2 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym2));
}
Some((_, __tok @ Tok::LParen(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state4(__lookbehind, __lookahead, __tokens, __sym2));
}
Some((_, Tok::Num(__tok0), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state5(__lookbehind, __lookahead, __tokens, __sym2));
}
_ => {
@ -357,13 +359,47 @@ mod __parse__S {
}
// State 7
// E = T (*) [")"]
// E = T (*) ["-"]
//
// "-" -> Reduce(E = T => Call(ActionFn(3));)
// ")" -> Reduce(E = T => Call(ActionFn(3));)
//
pub fn __state7<
__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)));
}
Some((_, Tok::RParen(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action3(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::E(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 8
// T = "Num" (*) [")"]
// T = "Num" (*) ["-"]
//
// "-" -> Reduce(T = "Num" => Call(ActionFn(4));)
// ")" -> Reduce(T = "Num" => Call(ActionFn(4));)
//
pub fn __state7<
pub fn __state8<
__TOKENS: Iterator<Item=((), Tok, ())>,
>(
__lookbehind: Option<()>,
@ -390,7 +426,7 @@ mod __parse__S {
}
}
// State 8
// State 9
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [EOF]
@ -399,7 +435,7 @@ mod __parse__S {
// ")" -> Shift(S13)
// "-" -> Shift(S12)
//
pub fn __state8<
pub fn __state9<
__TOKENS: Iterator<Item=((), Tok, ())>,
>(
__lookbehind: Option<()>,
@ -430,40 +466,6 @@ mod __parse__S {
return Ok(__result);
}
// State 9
// E = T (*) [")"]
// E = T (*) ["-"]
//
// ")" -> Reduce(E = T => Call(ActionFn(3));)
// "-" -> Reduce(E = T => Call(ActionFn(3));)
//
pub fn __state9<
__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::RParen(..), _)) => {
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(__lookahead);
}
}
}
// State 10
// E = (*) E "-" T [")"]
// E = (*) E "-" T ["-"]
@ -476,10 +478,10 @@ mod __parse__S {
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S7)
// "(" -> Shift(S10)
// "Num" -> Shift(S8)
//
// T -> S9
// T -> S7
// E -> S14
pub fn __state10<
__TOKENS: Iterator<Item=((), Tok, ())>,
@ -492,18 +494,18 @@ 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 = __tokens.next();
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym1));
}
Some((_, __tok @ Tok::LParen(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state10(__lookbehind, __lookahead, __tokens, __sym1));
}
Some((_, Tok::Num(__tok0), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym1));
}
_ => {
return Err(__lookahead);
}
@ -513,7 +515,7 @@ mod __parse__S {
match __nt {
__Nonterminal::T(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state9(__lookbehind, __lookahead, __tokens, __sym1));
__result = try!(__state7(__lookbehind, __lookahead, __tokens, __sym1));
}
__Nonterminal::E(__nt) => {
let __sym1 = &mut Some(__nt);
@ -531,8 +533,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<
__TOKENS: Iterator<Item=((), Tok, ())>,
@ -547,14 +549,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();
@ -575,8 +577,8 @@ mod __parse__S {
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S7)
// "(" -> Shift(S10)
// "Num" -> Shift(S8)
//
// T -> S15
pub fn __state12<
@ -591,18 +593,18 @@ 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 = __tokens.next();
__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 = __tokens.next();
__result = try!(__state10(__lookbehind, __lookahead, __tokens, __sym2));
}
Some((_, Tok::Num(__tok0), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym2 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state8(__lookbehind, __lookahead, __tokens, __sym2));
}
_ => {
return Err(__lookahead);
}
@ -626,8 +628,8 @@ mod __parse__S {
// T = "(" E ")" (*) [EOF]
// T = "(" E ")" (*) ["-"]
//
// "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
// EOF -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
// "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
//
pub fn __state13<
__TOKENS: Iterator<Item=((), Tok, ())>,
@ -642,14 +644,14 @@ mod __parse__S {
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, Tok::Minus(..), _)) => {
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__action5(__sym0, __sym1, __sym2);
return Ok((__lookbehind, __lookahead, __Nonterminal::T(__nt)));
}
None => {
Some((_, Tok::Minus(..), _)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();

14
lalrpop-test/src/use_super.lalrpop Normal file
View File

@ -0,0 +1,14 @@
grammar;
use super::util::tok::Tok;
extern token {
enum Tok {
"(" => Tok::LParen(..),
")" => Tok::RParen(..),
}
}
pub S: i32 = {
"(" ")" => super::ZERO;
};

185
lalrpop-test/src/use_super.rs Normal file
View File

@ -0,0 +1,185 @@
#![allow(unused_imports)]
use super::util::tok::Tok;
#[allow(non_snake_case)]
pub fn parse_S<
__TOKENS: IntoIterator<Item=Tok>,
>(
__tokens: __TOKENS,
) -> Result<i32, Option<Tok>>
{
let mut __tokens = __tokens.into_iter();
let mut __tokens = __tokens.map(|t| ((), t, ()));
let __lookahead = __tokens.next();
match __parse__S::__state0(None, __lookahead, &mut __tokens) {
Err(None) => {
Err(None)
}
Err(Some(__lookahead)) => {
Err(Some(__lookahead.1))
}
Ok((_, Some(__lookahead), _)) => {
Err(Some(__lookahead.1))
}
Ok((_, None, __parse__S::__Nonterminal::____S(__nt))) => {
Ok(__nt)
}
Ok(_) => unreachable!(),
}
}
mod __parse__S {
#![allow(non_snake_case, non_camel_case_types, unused_mut, unused_variables, unused_imports)]
use super::super::util::tok::Tok;
extern crate lalrpop_util as __lalrpop_util;
use self::__lalrpop_util::ParseError as __ParseError;
pub enum __Nonterminal<> {
S(i32),
____S(i32),
}
// State 0
// S = (*) "(" ")" [EOF]
// __S = (*) S [EOF]
//
// "(" -> Shift(S2)
//
// S -> S1
pub fn __state0<
__TOKENS: Iterator<Item=((), Tok, ())>,
>(
__lookbehind: Option<()>,
__lookahead: Option<((), Tok, ())>,
__tokens: &mut __TOKENS,
) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), Option<((), Tok, ())>>
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::LParen(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym0 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state2(__lookbehind, __lookahead, __tokens, __sym0));
}
_ => {
return Err(__lookahead);
}
}
loop {
let (__lookbehind, __lookahead, __nt) = __result;
match __nt {
__Nonterminal::S(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state1(__lookbehind, __lookahead, __tokens, __sym0));
}
_ => {
return Ok((__lookbehind, __lookahead, __nt));
}
}
}
}
// State 1
// __S = S (*) [EOF]
//
// EOF -> Reduce(__S = S => Call(ActionFn(0));)
//
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 {
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__action0(__sym0);
return Ok((__lookbehind, __lookahead, __Nonterminal::____S(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 2
// S = "(" (*) ")" [EOF]
//
// ")" -> Shift(S3)
//
pub fn __state2<
__TOKENS: Iterator<Item=((), Tok, ())>,
>(
__lookbehind: Option<()>,
__lookahead: Option<((), Tok, ())>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), Option<((), Tok, ())>>
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
Some((_, __tok @ Tok::RParen(..), __loc)) => {
let mut __lookbehind = Some(__loc);
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state3(__lookbehind, __lookahead, __tokens, __sym0, __sym1));
}
_ => {
return Err(__lookahead);
}
}
return Ok(__result);
}
// State 3
// S = "(" ")" (*) [EOF]
//
// EOF -> Reduce(S = "(", ")" => Call(ActionFn(1));)
//
pub fn __state3<
__TOKENS: Iterator<Item=((), Tok, ())>,
>(
__lookbehind: Option<()>,
__lookahead: Option<((), Tok, ())>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
__sym1: &mut Option<Tok>,
) -> Result<(Option<()>, Option<((), Tok, ())>, __Nonterminal<>), Option<((), Tok, ())>>
{
let mut __result: (Option<()>, Option<((), Tok, ())>, __Nonterminal<>);
match __lookahead {
None => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __nt = super::__action1(__sym0, __sym1);
return Ok((__lookbehind, __lookahead, __Nonterminal::S(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
}
pub fn __action0<
>(
__0: i32,
) -> i32
{
(__0)
}
pub fn __action1<
>(
__0: Tok,
__1: Tok,
) -> i32
{
super::ZERO
}

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

@ -84,9 +84,21 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
}
fn write_uses(&mut self) -> io::Result<()> {
// things the user wrote
for u in &self.grammar.uses {
rust!(self.out, "use {};", u);
if u.starts_with("super::") {
rust!(self.out, "use super::{};", u);
} else {
rust!(self.out, "use {};", u);
}
}
// stuff that we plan to use
rust!(self.out, "extern crate lalrpop_util as {}lalrpop_util;",
self.prefix);
rust!(self.out, "use self::{}lalrpop_util::ParseError as {}ParseError;",
self.prefix, self.prefix);
Ok(())
}