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

update tests to just write grammar; instead of grammar { },

Browse Source 
avoiding pointless rightward drift
This commit is contained in:
Niko Matsakis 2015-07-12 09:09:33 -04:00
parent 1102b26390
commit 4cf8bd92f2
6 changed files with 1376 additions and 1376 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,32 +1,32 @@
grammar {
use util::tok::Tok;
grammar;
extern token {
enum Tok {
"(" => Tok::LParen(..),
")" => Tok::RParen(..),
"-" => Tok::Minus(..),
"+" => Tok::Plus(..),
"*" => Tok::Times(..),
"/" => Tok::Div(..),
"Num" => Tok::Num(<i32>)
}
use util::tok::Tok;
extern token {
enum Tok {
"(" => Tok::LParen(..),
")" => Tok::RParen(..),
"-" => Tok::Minus(..),
"+" => Tok::Plus(..),
"*" => Tok::Times(..),
"/" => Tok::Div(..),
"Num" => Tok::Num(<i32>)
}
pub Expr = {
<l:Expr> "-" <r:Factor> => l - r;
<l:Expr> "+" <r:Factor> => l + r;
Factor;
};
Factor = {
<l:Factor> "*" <r:Term> => l * r;
<l:Factor> "/" <r:Term> => l / r;
Term;
};
Term = {
<"Num">;
"(" <Expr> ")";
};
}
pub Expr = {
<l:Expr> "-" <r:Factor> => l - r;
<l:Expr> "+" <r:Factor> => l + r;
Factor;
};
Factor = {
<l:Factor> "*" <r:Term> => l * r;
<l:Factor> "/" <r:Term> => l / r;
Term;
};
Term = {
<"Num">;
"(" <Expr> ")";
};

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

File diff suppressed because it is too large Load Diff

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

@ -1,25 +1,26 @@
grammar {
use util::tok::Tok;
grammar;
extern token {
enum Tok {
"(" => Tok::LParen(..),
")" => Tok::RParen(..),
"-" => Tok::Minus(..),
"Num" => Tok::Num(<i32>),
}
use util::tok::Tok;
extern token {
enum Tok {
"(" => Tok::LParen(..),
")" => Tok::RParen(..),
"-" => Tok::Minus(..),
"Num" => Tok::Num(<i32>),
}
pub S = E;
E = {
<l:E> "-" <r:T> => l-r;
T;
};
T = {
<"Num">;
"(" <E> ")";
};
}
pub S = E;
E = {
<l:E> "-" <r:T> => l-r;
T;
};
T = {
<"Num">;
"(" <E> ")";
};

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

@ -19,10 +19,10 @@ mod __parse__S {
use util::tok::Tok;
pub enum __Nonterminal {
__S(i32),
E(i32),
S(i32),
T(i32),
E(i32),
__S(i32),
}
// State 0
@ -37,27 +37,27 @@ mod __parse__S {
// T = (*) "Num" ["-"]
// __S = (*) S [EOF]
//
// "Num" -> Shift(S3)
// "(" -> Shift(S2)
// "(" -> Shift(S5)
// "Num" -> Shift(S4)
//
// E -> S2
// S -> S3
// T -> S1
// S -> S4
// E -> S5
pub fn __state0<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(Tok::Num(__tok0)) => {
let mut sym0 = &mut Some((__tok0));
let lookahead = tokens.next();
result = try!(__state3(lookahead, tokens, sym0));
}
Some(__tok @ Tok::LParen(..)) => {
let mut sym0 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state2(lookahead, tokens, sym0));
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));
}
_ => {
return Err(lookahead);
@ -66,17 +66,17 @@ mod __parse__S {
loop {
let (lookahead, nt) = result;
match nt {
__Nonterminal::T(nt) => {
__Nonterminal::E(nt) => {
let sym0 = &mut Some(nt);
result = try!(__state1(lookahead, tokens, sym0));
result = try!(__state2(lookahead, tokens, sym0));
}
__Nonterminal::S(nt) => {
let sym0 = &mut Some(nt);
result = try!(__state4(lookahead, tokens, sym0));
result = try!(__state3(lookahead, tokens, sym0));
}
__Nonterminal::E(nt) => {
__Nonterminal::T(nt) => {
let sym0 = &mut Some(nt);
result = try!(__state5(lookahead, tokens, sym0));
result = try!(__state1(lookahead, tokens, sym0));
}
_ => {
return Ok((lookahead, nt));
@ -89,8 +89,8 @@ mod __parse__S {
// E = T (*) [EOF]
// E = T (*) ["-"]
//
// EOF -> Reduce(E = T => ActionFn(3);)
// "-" -> Reduce(E = T => ActionFn(3);)
// EOF -> Reduce(E = T => ActionFn(3);)
//
pub fn __state1<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
@ -99,12 +99,12 @@ mod __parse__S {
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
None => {
Some(Tok::Minus(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action3(sym0);
return Ok((lookahead, __Nonterminal::E(nt)));
}
Some(Tok::Minus(..)) => {
None => {
let sym0 = sym0.take().unwrap();
let nt = super::__action3(sym0);
return Ok((lookahead, __Nonterminal::E(nt)));
@ -116,98 +116,43 @@ mod __parse__S {
}
// State 2
// E = (*) E "-" T [")"]
// E = (*) E "-" T ["-"]
// E = (*) T [")"]
// E = (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = "(" (*) E ")" [EOF]
// T = "(" (*) E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
// E = E (*) "-" T [EOF]
// E = E (*) "-" T ["-"]
// S = E (*) [EOF]
//
// "(" -> Shift(S7)
// "Num" -> Shift(S8)
// "-" -> Shift(S6)
// EOF -> Reduce(S = E => ActionFn(1);)
//
// E -> S6
// T -> S9
pub fn __state2<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!(__state7(lookahead, tokens, sym1));
}
Some(Tok::Num(__tok0)) => {
let mut sym1 = &mut Some((__tok0));
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!(__state6(lookahead, tokens, sym0, sym1));
}
__Nonterminal::T(nt) => {
let sym1 = &mut Some(nt);
result = try!(__state9(lookahead, tokens, sym1));
}
_ => {
return Ok((lookahead, nt));
}
}
}
return Ok(result);
}
// State 3
// T = "Num" (*) [EOF]
// T = "Num" (*) ["-"]
//
// "-" -> Reduce(T = "Num" => ActionFn(4);)
// EOF -> Reduce(T = "Num" => ActionFn(4);)
//
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::Minus(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
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::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
let nt = super::__action1(sym0);
return Ok((lookahead, __Nonterminal::S(nt)));
}
_ => {
return Err(lookahead);
}
}
return Ok(result);
}
// State 4
// State 3
// __S = S (*) [EOF]
//
// EOF -> Reduce(__S = S => ActionFn(0);)
//
pub fn __state4<TOKENS: Iterator<Item=Tok>>(
pub fn __state3<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
@ -225,69 +170,139 @@ mod __parse__S {
}
}
// State 5
// E = E (*) "-" T [EOF]
// E = E (*) "-" T ["-"]
// S = E (*) [EOF]
// State 4
// T = "Num" (*) [EOF]
// T = "Num" (*) ["-"]
//
// EOF -> Reduce(S = E => ActionFn(1);)
// "-" -> Shift(S10)
// EOF -> Reduce(T = "Num" => ActionFn(4);)
// "-" -> Reduce(T = "Num" => ActionFn(4);)
//
pub fn __state5<TOKENS: Iterator<Item=Tok>>(
pub fn __state4<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!(__state10(lookahead, tokens, sym0, sym1));
}
None => {
let sym0 = sym0.take().unwrap();
let nt = super::__action1(sym0);
return Ok((lookahead, __Nonterminal::S(nt)));
let nt = super::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
}
Some(Tok::Minus(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
}
_ => {
return Err(lookahead);
}
}
}
// State 5
// E = (*) E "-" T [")"]
// E = (*) E "-" T ["-"]
// E = (*) T [")"]
// E = (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = "(" (*) E ")" [EOF]
// T = "(" (*) E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S10)
// "(" -> Shift(S7)
//
// E -> S8
// T -> S9
pub fn __state5<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!(__state7(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!(__state8(lookahead, tokens, sym0, sym1));
}
__Nonterminal::T(nt) => {
let sym1 = &mut Some(nt);
result = try!(__state9(lookahead, tokens, sym1));
}
_ => {
return Ok((lookahead, nt));
}
}
}
return Ok(result);
}
// State 6
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [EOF]
// T = "(" E (*) ")" ["-"]
// E = E "-" (*) T [EOF]
// E = E "-" (*) T ["-"]
// T = (*) "(" E ")" [EOF]
// T = (*) "(" E ")" ["-"]
// T = (*) "Num" [EOF]
// T = (*) "Num" ["-"]
//
// "-" -> Shift(S11)
// ")" -> Shift(S12)
// "(" -> Shift(S5)
// "Num" -> Shift(S4)
//
// T -> S11
pub fn __state6<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::Minus(..)) => {
Some(__tok @ Tok::LParen(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state11(lookahead, tokens, sym1, sym2));
result = try!(__state5(lookahead, tokens, sym2));
}
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!(__state12(lookahead, tokens, sym0, sym1, sym2));
result = try!(__state4(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!(__state11(lookahead, tokens, sym0, sym1, sym2));
}
_ => {
return Ok((lookahead, nt));
}
}
}
return Ok(result);
}
@ -303,11 +318,11 @@ mod __parse__S {
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// "Num" -> Shift(S8)
// "(" -> Shift(S7)
// "Num" -> Shift(S10)
//
// E -> S13
// T -> S9
// E -> S12
pub fn __state7<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
@ -315,16 +330,16 @@ mod __parse__S {
) -> 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!(__state8(lookahead, tokens, sym1));
}
Some(__tok @ Tok::LParen(..)) => {
let mut sym1 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state7(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);
}
@ -332,14 +347,14 @@ mod __parse__S {
while sym0.is_some() {
let (lookahead, nt) = result;
match nt {
__Nonterminal::E(nt) => {
let sym1 = &mut Some(nt);
result = try!(__state13(lookahead, tokens, sym0, sym1));
}
__Nonterminal::T(nt) => {
let sym1 = &mut Some(nt);
result = try!(__state9(lookahead, tokens, sym1));
}
__Nonterminal::E(nt) => {
let sym1 = &mut Some(nt);
result = try!(__state12(lookahead, tokens, sym0, sym1));
}
_ => {
return Ok((lookahead, nt));
}
@ -349,33 +364,37 @@ mod __parse__S {
}
// State 8
// T = "Num" (*) [")"]
// T = "Num" (*) ["-"]
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [EOF]
// T = "(" E (*) ")" ["-"]
//
// ")" -> Reduce(T = "Num" => ActionFn(4);)
// "-" -> Reduce(T = "Num" => ActionFn(4);)
// "-" -> Shift(S13)
// ")" -> Shift(S14)
//
pub fn __state8<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
sym0: &mut Option<Tok>,
sym1: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
Some(Tok::RParen(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
Some(__tok @ Tok::Minus(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state13(lookahead, tokens, sym1, sym2));
}
Some(Tok::Minus(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
Some(__tok @ Tok::RParen(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state14(lookahead, tokens, sym0, sym1, sym2));
}
_ => {
return Err(lookahead);
}
}
return Ok(result);
}
// State 9
@ -409,116 +428,48 @@ mod __parse__S {
}
// State 10
// E = E "-" (*) T [EOF]
// E = E "-" (*) T ["-"]
// T = (*) "(" E ")" [EOF]
// T = (*) "(" E ")" ["-"]
// T = (*) "Num" [EOF]
// T = (*) "Num" ["-"]
// T = "Num" (*) [")"]
// T = "Num" (*) ["-"]
//
// "(" -> Shift(S2)
// "Num" -> Shift(S3)
// ")" -> Reduce(T = "Num" => ActionFn(4);)
// "-" -> Reduce(T = "Num" => ActionFn(4);)
//
// T -> S14
pub fn __state10<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 @ Tok::LParen(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state2(lookahead, tokens, sym2));
Some(Tok::RParen(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
}
Some(Tok::Num(__tok0)) => {
let mut sym2 = &mut Some((__tok0));
let lookahead = tokens.next();
result = try!(__state3(lookahead, tokens, sym2));
Some(Tok::Minus(..)) => {
let sym0 = sym0.take().unwrap();
let nt = super::__action4(sym0);
return Ok((lookahead, __Nonterminal::T(nt)));
}
_ => {
return Err(lookahead);
}
}
while sym1.is_some() {
let (lookahead, nt) = result;
match nt {
__Nonterminal::T(nt) => {
let sym2 = &mut Some(nt);
result = try!(__state14(lookahead, tokens, sym0, sym1, sym2));
}
_ => {
return Ok((lookahead, nt));
}
}
}
return Ok(result);
}
// State 11
// E = E "-" (*) T [")"]
// E = E "-" (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
// E = E "-" T (*) [EOF]
// E = E "-" T (*) ["-"]
//
// "(" -> Shift(S7)
// "Num" -> Shift(S8)
// "-" -> Reduce(E = E, "-", T => ActionFn(2);)
// EOF -> Reduce(E = E, "-", T => ActionFn(2);)
//
// T -> S15
pub fn __state11<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 @ Tok::LParen(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state7(lookahead, tokens, sym2));
}
Some(Tok::Num(__tok0)) => {
let mut sym2 = &mut Some((__tok0));
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!(__state15(lookahead, tokens, sym0, sym1, sym2));
}
_ => {
return Ok((lookahead, nt));
}
}
}
return Ok(result);
}
// State 12
// T = "(" E ")" (*) [EOF]
// T = "(" E ")" (*) ["-"]
//
// "-" -> Reduce(T = "(", E, ")" => ActionFn(5);)
// EOF -> Reduce(T = "(", E, ")" => ActionFn(5);)
//
pub fn __state12<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<Tok>,
sym1: &mut Option<i32>,
sym2: &mut Option<Tok>,
sym2: &mut Option<i32>,
) -> Result<(Option<Tok>, __Nonterminal), Option<Tok>> {
let mut result: (Option<Tok>, __Nonterminal);
match lookahead {
@ -526,15 +477,15 @@ mod __parse__S {
let sym0 = sym0.take().unwrap();
let sym1 = sym1.take().unwrap();
let sym2 = sym2.take().unwrap();
let nt = super::__action5(sym0, sym1, sym2);
return Ok((lookahead, __Nonterminal::T(nt)));
let nt = super::__action2(sym0, sym1, sym2);
return Ok((lookahead, __Nonterminal::E(nt)));
}
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((lookahead, __Nonterminal::T(nt)));
let nt = super::__action2(sym0, sym1, sym2);
return Ok((lookahead, __Nonterminal::E(nt)));
}
_ => {
return Err(lookahead);
@ -542,16 +493,16 @@ mod __parse__S {
}
}
// State 13
// State 12
// E = E (*) "-" T [")"]
// E = E (*) "-" T ["-"]
// T = "(" E (*) ")" [")"]
// T = "(" E (*) ")" ["-"]
//
// "-" -> Shift(S11)
// ")" -> Shift(S16)
// "-" -> Shift(S13)
// ")" -> Shift(S15)
//
pub fn __state13<TOKENS: Iterator<Item=Tok>>(
pub fn __state12<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<Tok>,
@ -562,12 +513,12 @@ mod __parse__S {
Some(__tok @ Tok::Minus(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state11(lookahead, tokens, sym1, sym2));
result = try!(__state13(lookahead, tokens, sym1, sym2));
}
Some(__tok @ Tok::RParen(..)) => {
let mut sym2 = &mut Some(__tok);
let lookahead = tokens.next();
result = try!(__state16(lookahead, tokens, sym0, sym1, sym2));
result = try!(__state15(lookahead, tokens, sym0, sym1, sym2));
}
_ => {
return Err(lookahead);
@ -576,19 +527,68 @@ mod __parse__S {
return Ok(result);
}
// State 14
// E = E "-" T (*) [EOF]
// E = E "-" T (*) ["-"]
// State 13
// E = E "-" (*) T [")"]
// E = E "-" (*) T ["-"]
// T = (*) "(" E ")" [")"]
// T = (*) "(" E ")" ["-"]
// T = (*) "Num" [")"]
// T = (*) "Num" ["-"]
//
// EOF -> Reduce(E = E, "-", T => ActionFn(2);)
// "-" -> Reduce(E = E, "-", T => ActionFn(2);)
// "Num" -> Shift(S10)
// "(" -> Shift(S7)
//
pub fn __state14<TOKENS: Iterator<Item=Tok>>(
// T -> S16
pub fn __state13<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
sym1: &mut Option<Tok>,
sym2: &mut Option<i32>,
) -> 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!(__state7(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 14
// T = "(" E ")" (*) [EOF]
// T = "(" E ")" (*) ["-"]
//
// EOF -> Reduce(T = "(", E, ")" => ActionFn(5);)
// "-" -> Reduce(T = "(", E, ")" => ActionFn(5);)
//
pub fn __state14<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 {
@ -596,15 +596,15 @@ mod __parse__S {
let sym0 = sym0.take().unwrap();
let sym1 = sym1.take().unwrap();
let sym2 = sym2.take().unwrap();
let nt = super::__action2(sym0, sym1, sym2);
return Ok((lookahead, __Nonterminal::E(nt)));
let nt = super::__action5(sym0, sym1, sym2);
return Ok((lookahead, __Nonterminal::T(nt)));
}
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((lookahead, __Nonterminal::E(nt)));
let nt = super::__action5(sym0, sym1, sym2);
return Ok((lookahead, __Nonterminal::T(nt)));
}
_ => {
return Err(lookahead);
@ -613,49 +613,13 @@ mod __parse__S {
}
// State 15
// E = E "-" T (*) [")"]
// E = E "-" T (*) ["-"]
//
// "-" -> Reduce(E = E, "-", T => ActionFn(2);)
// ")" -> Reduce(E = E, "-", T => ActionFn(2);)
//
pub fn __state15<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
sym1: &mut Option<Tok>,
sym2: &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 sym1 = sym1.take().unwrap();
let sym2 = sym2.take().unwrap();
let nt = super::__action2(sym0, sym1, sym2);
return Ok((lookahead, __Nonterminal::E(nt)));
}
Some(Tok::RParen(..)) => {
let sym0 = sym0.take().unwrap();
let sym1 = sym1.take().unwrap();
let sym2 = sym2.take().unwrap();
let nt = super::__action2(sym0, sym1, sym2);
return Ok((lookahead, __Nonterminal::E(nt)));
}
_ => {
return Err(lookahead);
}
}
}
// State 16
// T = "(" E ")" (*) [")"]
// T = "(" E ")" (*) ["-"]
//
// ")" -> Reduce(T = "(", E, ")" => ActionFn(5);)
// "-" -> Reduce(T = "(", E, ")" => ActionFn(5);)
//
pub fn __state16<TOKENS: Iterator<Item=Tok>>(
pub fn __state15<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<Tok>,
@ -683,6 +647,42 @@ mod __parse__S {
}
}
}
// State 16
// E = E "-" T (*) [")"]
// E = E "-" T (*) ["-"]
//
// ")" -> Reduce(E = E, "-", T => ActionFn(2);)
// "-" -> Reduce(E = E, "-", T => ActionFn(2);)
//
pub fn __state16<TOKENS: Iterator<Item=Tok>>(
mut lookahead: Option<Tok>,
tokens: &mut TOKENS,
sym0: &mut Option<i32>,
sym1: &mut Option<Tok>,
sym2: &mut Option<i32>,
) -> 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::__action2(sym0, sym1, sym2);
return Ok((lookahead, __Nonterminal::E(nt)));
}
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((lookahead, __Nonterminal::E(nt)));
}
_ => {
return Err(lookahead);
}
}
}
}
fn __action0(
__0: i32,

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

@ -23,7 +23,7 @@ rusty_peg! {
<tps:[GRAMMAR_TPS]>
<parameters:[GRAMMAR_PARAMS]>
<where_clauses:[WHERE_CLAUSES]>
"{" <i:{GRAMMAR_ITEM}> "}") => {
";" <i:{GRAMMAR_ITEM}>) => {
Grammar { span: Span(lo, hi),
type_parameters: tps.unwrap_or(vec![]),
parameters: parameters.unwrap_or(vec![]),

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

@ -21,29 +21,28 @@ fn type_ref_special_case_for_id() {
#[test]
fn empty_grammar() {
super::parse_grammar(r#"grammar { }"#).unwrap();
super::parse_grammar(r#"grammar;"#).unwrap();
}
#[test]
fn grammar_param1() {
super::parse_grammar(r#"grammar<T>(x: T) { }"#).unwrap();
super::parse_grammar(r#"grammar<T>(x: T);"#).unwrap();
}
#[test]
fn grammar_param2() {
super::parse_grammar(
r#"grammar<'a,T>(x: T, y: Vec<U>) where T: Copy, for<'a> &'a T: Baz { }"#
r#"grammar<'a,T>(x: T, y: Vec<U>) where T: Copy, for<'a> &'a T: Baz;"#
).unwrap();
}
#[test]
fn use_decls() {
super::parse_grammar("grammar {
super::parse_grammar("grammar;
use std::io;
use std::io::{self, a, b};
use std::baz::*;
use std::this as that;
}").unwrap();
use std::this as that;").unwrap();
}
#[test]
@ -58,50 +57,50 @@ fn symbol() {
#[test]
fn nonterminal0() {
super::parse_grammar(r#"grammar { Expr = Alt; }"#).unwrap();
super::parse_grammar(r#"grammar; Expr = Alt;"#).unwrap();
}
#[test]
fn paren() {
super::parse_grammar(r#"grammar { Expr = (Alt); }"#).unwrap();
super::parse_grammar(r#"grammar; Expr = (Alt);"#).unwrap();
}
#[test]
fn paren_with_plus() {
super::parse_grammar(r#"grammar { Expr = (Alt)+; }"#).unwrap();
super::parse_grammar(r#"grammar; Expr = (Alt)+;"#).unwrap();
}
#[test]
fn paren_with_plus_and_anon() {
super::parse_grammar(r#"grammar { Expr = (<Alt>)+; }"#).unwrap();
super::parse_grammar(r#"grammar; Expr = (<Alt>)+;"#).unwrap();
}
#[test]
fn named_choice() {
super::parse_grammar(r#"grammar { Expr = <n:Alt>; }"#).unwrap();
super::parse_grammar(r#"grammar; Expr = <n:Alt>;"#).unwrap();
}
#[test]
fn named_choice_plus() {
super::parse_grammar(r#"grammar { Expr = <Alt+>; }"#).unwrap();
super::parse_grammar(r#"grammar; Expr = <Alt+>;"#).unwrap();
}
#[test]
fn token_expr() {
super::parse_grammar(r#"grammar { extern token { enum Expr { "foo" => Bar } } }"#).unwrap();
super::parse_grammar(r#"grammar; extern token { enum Expr { "foo" => Bar } }"#).unwrap();
}
#[test]
fn map1() {
super::parse_grammar(
r#"grammar { Expr = <n:Alt+> => { { foo } }; }"#).unwrap();
r#"grammar; Expr = <n:Alt+> => { { foo } };"#).unwrap();
}
#[test]
#[allow(non_snake_case)]
fn mapN() {
super::parse_grammar(
r#"grammar { Expr = { Bar => { Baz }; X <n:Bar> => { Y }; }; }"#).unwrap();
r#"grammar; Expr = { Bar => { Baz }; X <n:Bar> => { Y }; };"#).unwrap();
}
#[test]