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

modify recursive ascent to expect (loc, enum, loc) when a location type

Browse Source 
is specified, and modify test tokenizer to provide it
This commit is contained in:
Niko Matsakis 2015-07-17 09:07:13 -04:00
parent 7b31c3eed6
commit fad838a361
9 changed files with 3664 additions and 3609 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

File diff suppressed because it is too large Load Diff

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

@ -4,7 +4,7 @@ use util::tok::Tok;
grammar<'ast>(arena: &'ast Arena<'ast>);
extern token {
type Location = u32;
type Location = usize;
enum Tok {
"(" => Tok::LParen(..),

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

File diff suppressed because it is too large Load Diff

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

@ -54,7 +54,7 @@ fn expr_arena_test1() {
arena.alloc(Node::Value(22)),
arena.alloc(Node::Value(3)))),
arena.alloc(Node::Value(6))));
util::test(|v| expr_arena::parse_Expr(&arena, v), "22 * 3 - 6", expected);
util::test_loc(|v| expr_arena::parse_Expr(&arena, v), "22 * 3 - 6", expected);
}
#[test]
@ -66,7 +66,7 @@ fn expr_arena_test2() {
vec![arena.alloc(Node::Value(22)),
arena.alloc(Node::Value(3)),
arena.alloc(Node::Value(6))]));;
util::test(|v| expr_arena::parse_Expr(&arena, v), "*(22, 3, 6)", expected);
util::test(|v| expr_arena::parse_Expr(&arena, v), "*(22, 3, 6,)", expected);
util::test_loc(|v| expr_arena::parse_Expr(&arena, v), "*(22, 3, 6)", expected);
util::test_loc(|v| expr_arena::parse_Expr(&arena, v), "*(22, 3, 6,)", expected);
}

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

@ -22,10 +22,10 @@ mod __parse__S {
use util::tok::Tok;
pub enum __Nonterminal<> {
S(i32),
____S(i32),
E(i32),
T(i32),
____S(i32),
S(i32),
}
// State 0
@ -40,12 +40,12 @@ mod __parse__S {
// T = (*) "Num" ["-"]
// __S = (*) S [EOF]
//
// "(" -> Shift(S5)
// "Num" -> Shift(S4)
// "(" -> Shift(S5)
//
// E -> S1
// T -> S2
// S -> S3
// E -> S3
// T -> S1
// S -> S2
pub fn __state0<
__TOKENS: Iterator<Item=Tok>,
>(
@ -55,16 +55,16 @@ mod __parse__S {
{
let mut __result: (Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::LParen(..)) => {
let mut __sym0 = &mut Some(__tok);
let __lookahead = __tokens.next();
__result = try!(__state5(__lookahead, __tokens, __sym0));
}
Some(Tok::Num(__tok0)) => {
let mut __sym0 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state4(__lookahead, __tokens, __sym0));
}
Some(__tok @ Tok::LParen(..)) => {
let mut __sym0 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state5(__lookahead, __tokens, __sym0));
}
_ => {
return Err(__lookahead);
}
@ -74,15 +74,15 @@ mod __parse__S {
match __nt {
__Nonterminal::E(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state1(__lookahead, __tokens, __sym0));
__result = try!(__state3(__lookahead, __tokens, __sym0));
}
__Nonterminal::T(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state2(__lookahead, __tokens, __sym0));
__result = try!(__state1(__lookahead, __tokens, __sym0));
}
__Nonterminal::S(__nt) => {
let __sym0 = &mut Some(__nt);
__result = try!(__state3(__lookahead, __tokens, __sym0));
__result = try!(__state2(__lookahead, __tokens, __sym0));
}
_ => {
return Ok((__lookahead, __nt));
@ -92,12 +92,11 @@ mod __parse__S {
}
// State 1
// E = E (*) "-" T [EOF]
// E = E (*) "-" T ["-"]
// S = E (*) [EOF]
// E = T (*) [EOF]
// E = T (*) ["-"]
//
// EOF -> Reduce(S = E => ActionFn(1);)
// "-" -> Shift(S6)
// EOF -> Reduce(E = T => Call(ActionFn(3));)
// "-" -> Reduce(E = T => Call(ActionFn(3));)
//
pub fn __state1<
__TOKENS: Iterator<Item=Tok>,
@ -109,62 +108,28 @@ mod __parse__S {
{
let mut __result: (Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::Minus(..)) => {
let mut __sym1 = &mut Some(__tok);
let __lookahead = __tokens.next();
__result = try!(__state6(__lookahead, __tokens, __sym0, __sym1));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__actions::__action1(__sym0);
return Ok((__lookahead, __Nonterminal::S(__nt)));
let __nt = super::__actions::__action3(__sym0);
return Ok((__lookahead, __Nonterminal::E(__nt)));
}
_ => {
return Err(__lookahead);
}
}
return Ok(__result);
}
// State 2
// E = T (*) [EOF]
// E = T (*) ["-"]
//
// "-" -> Reduce(E = T => ActionFn(3);)
// EOF -> Reduce(E = T => ActionFn(3);)
//
pub fn __state2<
__TOKENS: Iterator<Item=Tok>,
>(
mut __lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::Minus(..)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__actions::__action3(__sym0);
return Ok((__lookahead, __Nonterminal::E(__nt)));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__actions::__action3(__sym0);
return Ok((__lookahead, __Nonterminal::E(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
// State 3
// State 2
// __S = S (*) [EOF]
//
// EOF -> Reduce(__S = S => ActionFn(0);)
// EOF -> Reduce(__S = S => Call(ActionFn(0));)
//
pub fn __state3<
pub fn __state2<
__TOKENS: Iterator<Item=Tok>,
>(
mut __lookahead: Option<Tok>,
@ -185,12 +150,47 @@ 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>,
>(
mut __lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::Minus(..)) => {
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state6(__lookahead, __tokens, __sym0, __sym1));
}
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__actions::__action1(__sym0);
return Ok((__lookahead, __Nonterminal::S(__nt)));
}
_ => {
return Err(__lookahead);
}
}
return Ok(__result);
}
// State 4
// T = "Num" (*) [EOF]
// T = "Num" (*) ["-"]
//
// "-" -> Reduce(T = "Num" => ActionFn(4);)
// EOF -> Reduce(T = "Num" => ActionFn(4);)
// EOF -> Reduce(T = "Num" => Call(ActionFn(4));)
// "-" -> Reduce(T = "Num" => Call(ActionFn(4));)
//
pub fn __state4<
__TOKENS: Iterator<Item=Tok>,
@ -202,12 +202,12 @@ mod __parse__S {
{
let mut __result: (Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::Minus(..)) => {
None => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__actions::__action4(__sym0);
return Ok((__lookahead, __Nonterminal::T(__nt)));
}
None => {
Some(Tok::Minus(..)) => {
let __sym0 = __sym0.take().unwrap();
let __nt = super::__actions::__action4(__sym0);
return Ok((__lookahead, __Nonterminal::T(__nt)));
@ -233,8 +233,8 @@ mod __parse__S {
// "(" -> Shift(S8)
// "Num" -> Shift(S10)
//
// T -> S7
// E -> S9
// T -> S9
// E -> S7
pub fn __state5<
__TOKENS: Iterator<Item=Tok>,
>(
@ -246,7 +246,7 @@ mod __parse__S {
let mut __result: (Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::LParen(..)) => {
let mut __sym1 = &mut Some(__tok);
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state8(__lookahead, __tokens, __sym1));
}
@ -264,11 +264,11 @@ mod __parse__S {
match __nt {
__Nonterminal::T(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state7(__lookahead, __tokens, __sym1));
__result = try!(__state9(__lookahead, __tokens, __sym1));
}
__Nonterminal::E(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state9(__lookahead, __tokens, __sym0, __sym1));
__result = try!(__state7(__lookahead, __tokens, __sym0, __sym1));
}
_ => {
return Ok((__lookahead, __nt));
@ -286,8 +286,8 @@ mod __parse__S {
// T = (*) "Num" [EOF]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S4)
// "(" -> Shift(S5)
// "Num" -> Shift(S4)
//
// T -> S11
pub fn __state6<
@ -301,16 +301,16 @@ mod __parse__S {
{
let mut __result: (Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::LParen(..)) => {
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state5(__lookahead, __tokens, __sym2));
}
Some(Tok::Num(__tok0)) => {
let mut __sym2 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state4(__lookahead, __tokens, __sym2));
}
Some(__tok @ Tok::LParen(..)) => {
let mut __sym2 = &mut Some(__tok);
let __lookahead = __tokens.next();
__result = try!(__state5(__lookahead, __tokens, __sym2));
}
_ => {
return Err(__lookahead);
}
@ -331,13 +331,110 @@ mod __parse__S {
}
// State 7
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [EOF]
// T = "(" E (*) ")" ["-"]
//
// "-" -> Shift(S12)
// ")" -> Shift(S13)
//
pub fn __state7<
__TOKENS: Iterator<Item=Tok>,
>(
mut __lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
__sym1: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::Minus(..)) => {
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state12(__lookahead, __tokens, __sym1, __sym2));
}
Some(__tok @ Tok::RParen(..)) => {
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state13(__lookahead, __tokens, __sym0, __sym1, __sym2));
}
_ => {
return Err(__lookahead);
}
}
return Ok(__result);
}
// State 8
// E = (*) E "-" T [")"]
// E = (*) E "-" T ["-"]
// E = (*) T [")"]
// E = (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = "(" (*) E ")" [")"]
// T = "(" (*) E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "(" -> Shift(S8)
// "Num" -> Shift(S10)
//
// T -> S9
// E -> S14
pub fn __state8<
__TOKENS: Iterator<Item=Tok>,
>(
mut __lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
) -> Result<(Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::LParen(..)) => {
let mut __sym1 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state8(__lookahead, __tokens, __sym1));
}
Some(Tok::Num(__tok0)) => {
let mut __sym1 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state10(__lookahead, __tokens, __sym1));
}
_ => {
return Err(__lookahead);
}
}
while __sym0.is_some() {
let (__lookahead, __nt) = __result;
match __nt {
__Nonterminal::T(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state9(__lookahead, __tokens, __sym1));
}
__Nonterminal::E(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state14(__lookahead, __tokens, __sym0, __sym1));
}
_ => {
return Ok((__lookahead, __nt));
}
}
}
return Ok(__result);
}
// State 9
// E = T (*) [")"]
// E = T (*) ["-"]
//
// ")" -> Reduce(E = T => ActionFn(3);)
// "-" -> Reduce(E = T => ActionFn(3);)
// ")" -> Reduce(E = T => Call(ActionFn(3));)
// "-" -> Reduce(E = T => Call(ActionFn(3));)
//
pub fn __state7<
pub fn __state9<
__TOKENS: Iterator<Item=Tok>,
>(
mut __lookahead: Option<Tok>,
@ -363,109 +460,12 @@ mod __parse__S {
}
}
// State 8
// E = (*) E "-" T [")"]
// E = (*) E "-" T ["-"]
// E = (*) T [")"]
// E = (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = "(" (*) E ")" [")"]
// T = "(" (*) E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S10)
// "(" -> Shift(S8)
//
// E -> S12
// T -> S7
pub fn __state8<
__TOKENS: Iterator<Item=Tok>,
>(
mut __lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
) -> Result<(Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::Num(__tok0)) => {
let mut __sym1 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state10(__lookahead, __tokens, __sym1));
}
Some(__tok @ Tok::LParen(..)) => {
let mut __sym1 = &mut Some(__tok);
let __lookahead = __tokens.next();
__result = try!(__state8(__lookahead, __tokens, __sym1));
}
_ => {
return Err(__lookahead);
}
}
while __sym0.is_some() {
let (__lookahead, __nt) = __result;
match __nt {
__Nonterminal::E(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state12(__lookahead, __tokens, __sym0, __sym1));
}
__Nonterminal::T(__nt) => {
let __sym1 = &mut Some(__nt);
__result = try!(__state7(__lookahead, __tokens, __sym1));
}
_ => {
return Ok((__lookahead, __nt));
}
}
}
return Ok(__result);
}
// State 9
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [EOF]
// T = "(" E (*) ")" ["-"]
//
// "-" -> Shift(S14)
// ")" -> Shift(S13)
//
pub fn __state9<
__TOKENS: Iterator<Item=Tok>,
>(
mut __lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
__sym1: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::Minus(..)) => {
let mut __sym2 = &mut Some(__tok);
let __lookahead = __tokens.next();
__result = try!(__state14(__lookahead, __tokens, __sym1, __sym2));
}
Some(__tok @ Tok::RParen(..)) => {
let mut __sym2 = &mut Some(__tok);
let __lookahead = __tokens.next();
__result = try!(__state13(__lookahead, __tokens, __sym0, __sym1, __sym2));
}
_ => {
return Err(__lookahead);
}
}
return Ok(__result);
}
// State 10
// T = "Num" (*) [")"]
// T = "Num" (*) ["-"]
//
// ")" -> Reduce(T = "Num" => ActionFn(4);)
// "-" -> Reduce(T = "Num" => ActionFn(4);)
// ")" -> Reduce(T = "Num" => Call(ActionFn(4));)
// "-" -> Reduce(T = "Num" => Call(ActionFn(4));)
//
pub fn __state10<
__TOKENS: Iterator<Item=Tok>,
@ -497,8 +497,8 @@ mod __parse__S {
// E = E "-" T (*) [EOF]
// E = E "-" T (*) ["-"]
//
// "-" -> Reduce(E = E, "-", T => ActionFn(2);)
// EOF -> Reduce(E = E, "-", T => ActionFn(2);)
// EOF -> Reduce(E = E, "-", T => Call(ActionFn(2));)
// "-" -> Reduce(E = E, "-", T => Call(ActionFn(2));)
//
pub fn __state11<
__TOKENS: Iterator<Item=Tok>,
@ -512,14 +512,14 @@ mod __parse__S {
{
let mut __result: (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::__actions::__action2(__sym0, __sym1, __sym2);
return Ok((__lookahead, __Nonterminal::E(__nt)));
}
None => {
Some(Tok::Minus(..)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
@ -533,39 +533,54 @@ mod __parse__S {
}
// State 12
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [")"]
// T = "(" E (*) ")" ["-"]
// E = E "-" (*) T [")"]
// E = E "-" (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// ")" -> Shift(S15)
// "-" -> Shift(S14)
// "Num" -> Shift(S10)
// "(" -> Shift(S8)
//
// T -> S15
pub fn __state12<
__TOKENS: Iterator<Item=Tok>,
>(
mut __lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
__sym1: &mut Option<i32>,
__sym0: &mut Option<i32>,
__sym1: &mut Option<Tok>,
) -> Result<(Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(__tok @ Tok::RParen(..)) => {
let mut __sym2 = &mut Some(__tok);
Some(Tok::Num(__tok0)) => {
let mut __sym2 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state15(__lookahead, __tokens, __sym0, __sym1, __sym2));
__result = try!(__state10(__lookahead, __tokens, __sym2));
}
Some(__tok @ Tok::Minus(..)) => {
let mut __sym2 = &mut Some(__tok);
Some(__tok @ Tok::LParen(..)) => {
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state14(__lookahead, __tokens, __sym1, __sym2));
__result = try!(__state8(__lookahead, __tokens, __sym2));
}
_ => {
return Err(__lookahead);
}
}
while __sym1.is_some() {
let (__lookahead, __nt) = __result;
match __nt {
__Nonterminal::T(__nt) => {
let __sym2 = &mut Some(__nt);
__result = try!(__state15(__lookahead, __tokens, __sym0, __sym1, __sym2));
}
_ => {
return Ok((__lookahead, __nt));
}
}
}
return Ok(__result);
}
@ -573,8 +588,8 @@ mod __parse__S {
// T = "(" E ")" (*) [EOF]
// T = "(" E ")" (*) ["-"]
//
// "-" -> Reduce(T = "(", E, ")" => ActionFn(5);)
// EOF -> Reduce(T = "(", E, ")" => ActionFn(5);)
// "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
// EOF -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
//
pub fn __state13<
__TOKENS: Iterator<Item=Tok>,
@ -609,104 +624,50 @@ mod __parse__S {
}
// State 14
// E = E "-" (*) T [")"]
// E = E "-" (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [")"]
// T = "(" E (*) ")" ["-"]
//
// "Num" -> Shift(S10)
// "(" -> Shift(S8)
// "-" -> Shift(S12)
// ")" -> Shift(S16)
//
// T -> S16
pub fn __state14<
__TOKENS: Iterator<Item=Tok>,
>(
mut __lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<i32>,
__sym1: &mut Option<Tok>,
) -> Result<(Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::Num(__tok0)) => {
let mut __sym2 = &mut Some((__tok0));
let __lookahead = __tokens.next();
__result = try!(__state10(__lookahead, __tokens, __sym2));
}
Some(__tok @ Tok::LParen(..)) => {
let mut __sym2 = &mut Some(__tok);
let __lookahead = __tokens.next();
__result = try!(__state8(__lookahead, __tokens, __sym2));
}
_ => {
return Err(__lookahead);
}
}
while __sym1.is_some() {
let (__lookahead, __nt) = __result;
match __nt {
__Nonterminal::T(__nt) => {
let __sym2 = &mut Some(__nt);
__result = try!(__state16(__lookahead, __tokens, __sym0, __sym1, __sym2));
}
_ => {
return Ok((__lookahead, __nt));
}
}
}
return Ok(__result);
}
// State 15
// T = "(" E ")" (*) [")"]
// T = "(" E ")" (*) ["-"]
//
// ")" -> Reduce(T = "(", E, ")" => ActionFn(5);)
// "-" -> Reduce(T = "(", E, ")" => ActionFn(5);)
//
pub fn __state15<
__TOKENS: Iterator<Item=Tok>,
>(
mut __lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
__sym1: &mut Option<i32>,
__sym2: &mut Option<Tok>,
) -> Result<(Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (Option<Tok>, __Nonterminal<>);
match __lookahead {
Some(Tok::RParen(..)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__actions::__action5(__sym0, __sym1, __sym2);
return Ok((__lookahead, __Nonterminal::T(__nt)));
Some(__tok @ Tok::Minus(..)) => {
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state12(__lookahead, __tokens, __sym1, __sym2));
}
Some(Tok::Minus(..)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__actions::__action5(__sym0, __sym1, __sym2);
return Ok((__lookahead, __Nonterminal::T(__nt)));
Some(__tok @ Tok::RParen(..)) => {
let mut __sym2 = &mut Some((__tok));
let __lookahead = __tokens.next();
__result = try!(__state16(__lookahead, __tokens, __sym0, __sym1, __sym2));
}
_ => {
return Err(__lookahead);
}
}
return Ok(__result);
}
// State 16
// State 15
// E = E "-" T (*) [")"]
// E = E "-" T (*) ["-"]
//
// "-" -> Reduce(E = E, "-", T => ActionFn(2);)
// ")" -> Reduce(E = E, "-", T => ActionFn(2);)
// "-" -> Reduce(E = E, "-", T => Call(ActionFn(2));)
// ")" -> Reduce(E = E, "-", T => Call(ActionFn(2));)
//
pub fn __state16<
pub fn __state15<
__TOKENS: Iterator<Item=Tok>,
>(
mut __lookahead: Option<Tok>,
@ -737,6 +698,45 @@ mod __parse__S {
}
}
}
// State 16
// T = "(" E ")" (*) [")"]
// T = "(" E ")" (*) ["-"]
//
// "-" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
// ")" -> Reduce(T = "(", E, ")" => Call(ActionFn(5));)
//
pub fn __state16<
__TOKENS: Iterator<Item=Tok>,
>(
mut __lookahead: Option<Tok>,
__tokens: &mut __TOKENS,
__sym0: &mut Option<Tok>,
__sym1: &mut Option<i32>,
__sym2: &mut Option<Tok>,
) -> Result<(Option<Tok>, __Nonterminal<>), Option<Tok>>
{
let mut __result: (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::__actions::__action5(__sym0, __sym1, __sym2);
return Ok((__lookahead, __Nonterminal::T(__nt)));
}
Some(Tok::RParen(..)) => {
let __sym0 = __sym0.take().unwrap();
let __sym1 = __sym1.take().unwrap();
let __sym2 = __sym2.take().unwrap();
let __nt = super::__actions::__action5(__sym0, __sym1, __sym2);
return Ok((__lookahead, __Nonterminal::T(__nt)));
}
_ => {
return Err(__lookahead);
}
}
}
}
mod __actions {

22
lalrpop-test/src/util/mod.rs
View File

@ -14,6 +14,28 @@ pub fn test<R:Debug+Eq,F>(parse_fn: F,
// create tokens
let tokens = tok::tokenize(input);
// filter to tokens
let tokens = tokens.into_iter().map(|(_, tok, _)| tok).collect();
// parse
let (lookahead, r) = parse_fn(tokens).unwrap();
// expect input to be completely consumed
assert!(lookahead.is_none(), "input not completely consumed");
// expect output to be correct
assert!(r == expected, "parsing {:?}, got {:#?}, expected {:#?}", input, r, expected);
}
pub fn test_loc<R:Debug+Eq,F>(parse_fn: F,
input: &str,
expected: R)
where F: FnOnce(Vec<(usize, Tok, usize)>) -> Result<(Option<(usize, Tok, usize)>,R),
Option<(usize, Tok, usize)>>
{
// create tokens
let tokens = tok::tokenize(input);
// parse
let (lookahead, r) = parse_fn(tokens).unwrap();

31
lalrpop-test/src/util/tok.rs
View File

@ -13,25 +13,26 @@ pub enum Tok {
}
// simplest and stupidest possible tokenizer
pub fn tokenize(s: &str) -> Vec<Tok> {
pub fn tokenize(s: &str) -> Vec<(usize, Tok, usize)> {
let mut tokens = vec![];
let mut chars = s.chars();
let mut chars = s.char_indices();
let mut lookahead = chars.next();
while let Some(c) = lookahead {
while let Some((pos, c)) = lookahead {
// skip whitespace characters
if !c.is_whitespace() {
match c {
'(' => tokens.push(Tok::LParen),
')' => tokens.push(Tok::RParen),
'-' => tokens.push(Tok::Minus),
'+' => tokens.push(Tok::Plus),
'*' => tokens.push(Tok::Times),
',' => tokens.push(Tok::Comma),
'/' => tokens.push(Tok::Div),
'(' => tokens.push((pos, Tok::LParen, pos+1)),
')' => tokens.push((pos, Tok::RParen, pos+1)),
'-' => tokens.push((pos, Tok::Minus, pos+1)),
'+' => tokens.push((pos, Tok::Plus, pos+1)),
'*' => tokens.push((pos, Tok::Times, pos+1)),
',' => tokens.push((pos, Tok::Comma, pos+1)),
'/' => tokens.push((pos, Tok::Div, pos+1)),
_ if c.is_digit(10) => {
let (tmp, next) = take_while(c, &mut chars, |c| c.is_digit(10));
lookahead = next;
tokens.push(Tok::Num(i32::from_str(&tmp).unwrap()));
let end = lookahead.map(|(pos, _)| pos).unwrap_or(s.len());
tokens.push((pos, Tok::Num(i32::from_str(&tmp).unwrap()), end));
continue;
}
_ => {
@ -46,16 +47,16 @@ pub fn tokenize(s: &str) -> Vec<Tok> {
tokens
}
fn take_while<C,F>(c0: char, chars: &mut C, f: F) -> (String, Option<char>)
where C: Iterator<Item=char>, F: Fn(char) -> bool
fn take_while<C,F>(c0: char, chars: &mut C, f: F) -> (String, Option<(usize, char)>)
where C: Iterator<Item=(usize, char)>, F: Fn(char) -> bool
{
let mut buf = String::new();
buf.push(c0);
while let Some(c) = chars.next() {
while let Some((pos, c)) = chars.next() {
if !f(c) {
return (buf, Some(c));
return (buf, Some((pos, c)));
}
buf.push(c);

7
lalrpop/src/grammar/repr.rs
View File

@ -72,7 +72,8 @@ pub enum Symbol {
#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub enum ProductionAction {
Call(ActionFn)
// execute code provided by the user
Call(ActionFn),
}
#[derive(Clone, PartialEq, Eq)]
@ -133,6 +134,10 @@ impl Types {
&self.terminal_enum_type
}
pub fn opt_terminal_loc_type(&self) -> Option<&TypeRepr> {
self.terminal_loc_type.as_ref()
}
pub fn terminal_type(&self, id: TerminalString) -> &TypeRepr {
self.terminal_types.get(&id).unwrap_or(&self.default_terminal_type)
}

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

@ -104,15 +104,15 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
}
fn write_start_fn(&mut self) -> io::Result<()> {
let terminal_type = self.types.terminal_enum_type();
let item_type = self.iterator_item_type();
rust!(self.out, "#[allow(non_snake_case)]");
try!(self.out.write_pub_fn_header(
self.grammar,
format!("parse_{}", self.user_start_symbol),
vec![format!("{}TOKENS: IntoIterator<Item={}>", self.prefix, terminal_type)],
vec![format!("{}TOKENS: IntoIterator<Item={}>", self.prefix, item_type)],
vec![format!("{}tokens: {}TOKENS", self.prefix, self.prefix)],
format!("Result<(Option<{}>, {}), Option<{}>>",
terminal_type, self.types.nonterminal_type(self.start_symbol), terminal_type),
item_type, self.types.nonterminal_type(self.start_symbol), item_type),
vec![]));
rust!(self.out, "{{");
rust!(self.out, "let mut {}tokens = {}tokens.into_iter();", self.prefix, self.prefix);
@ -134,7 +134,7 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
fn write_state_fn(&mut self, this_index: StateIndex) -> io::Result<()> {
let this_state = &self.states[this_index.0];
let this_prefix = self.state_prefixes[this_index.0];
let terminal_type = self.types.terminal_enum_type();
let item_type = self.iterator_item_type();
// Leave a comment explaining what this state is.
rust!(self.out, "// State {}", this_index.0);
@ -154,7 +154,7 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
let mut fallthrough = false;
let base_args =
vec![format!("mut {}lookahead: Option<{}>", self.prefix, terminal_type),
vec![format!("mut {}lookahead: Option<{}>", self.prefix, item_type),
format!("{}tokens: &mut {}TOKENS", self.prefix, self.prefix)];
let sym_args: Vec<_> =
(0..this_prefix.len())
@ -165,17 +165,17 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
try!(self.out.write_pub_fn_header(
self.grammar,
format!("{}state{}", self.prefix, this_index.0),
vec![format!("{}TOKENS: Iterator<Item={}>", self.prefix, terminal_type)],
vec![format!("{}TOKENS: Iterator<Item={}>", self.prefix, item_type)],
base_args.into_iter().chain(sym_args).collect(),
format!("Result<(Option<{}>, {}Nonterminal<{}>), Option<{}>>",
terminal_type, self.prefix,
item_type, self.prefix,
self.grammar.user_type_parameter_refs(),
terminal_type),
item_type),
vec![]));
rust!(self.out, "{{");
rust!(self.out, "let mut {}result: (Option<{}>, {}Nonterminal<{}>);",
self.prefix, terminal_type, self.prefix, self.grammar.user_type_parameter_refs());
self.prefix, item_type, self.prefix, self.grammar.user_type_parameter_refs());
rust!(self.out, "match {}lookahead {{", self.prefix);
@ -343,7 +343,13 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
/// Emit a pattern that matches `id` but doesn't extract any data.
fn match_terminal(&mut self, id: TerminalString) -> io::Result<()> {
let pattern = self.grammar.pattern(id)
.map(&mut |_| "_");
.map(&mut |_| "_");
let mut pattern = format!("{}", pattern);
if self.types.opt_terminal_loc_type().is_some() {
pattern = format!("(_, {}, _)", pattern);
}
rust!(self.out, "Some({}) => {{", pattern);
Ok(())
}
@ -358,17 +364,38 @@ impl<'ascent,'grammar,W:Write> RecursiveAscent<'ascent,'grammar,W> {
pattern_names.last().cloned().unwrap()
});
let mut pattern = format!("{}", pattern);
if pattern_names.is_empty() {
rust!(self.out, "Some({}tok @ {}) => {{", self.prefix, pattern);
rust!(self.out, "let mut {} = &mut Some({}tok);",
let_name, self.prefix);
} else {
rust!(self.out, "Some({}) => {{", pattern);
rust!(self.out, "let mut {} = &mut Some(({}));",
let_name, pattern_names.connect(", "));
pattern_names.push(format!("{}tok", self.prefix));
pattern = format!("{}tok @ {}", self.prefix, pattern);
}
if self.types.opt_terminal_loc_type().is_some() {
pattern = format!("(_, {}, _)", pattern);
}
rust!(self.out, "Some({}) => {{", pattern);
rust!(self.out, "let mut {} = &mut Some(({}));",
let_name, pattern_names.connect(", "));
Ok(())
}
/// Returns the type of things we are iterating over. This will
/// depend on whether the user specified a location type `L`
/// or just an enum type `E`:
///
/// - `(L,E,L)` if a location type is specified,
/// - `E` otherwise.
fn iterator_item_type(&mut self) -> String {
let enum_type = self.types.terminal_enum_type();
match self.types.opt_terminal_loc_type() {
Some(loc_type) => {
format!("({},{},{})", loc_type, enum_type, loc_type)
}
None => {
format!("{}", enum_type)
}
}
}
}