Add grammar
This commit is contained in:
0x4261756D
parent
bee2fcb62b
commit
5a2171b023
474
src/grammar.rs
Normal file
474
src/grammar.rs
Normal file
@ -0,0 +1,474 @@
|
||||
use crate::tokenizer::Token;
|
||||
|
||||
pub enum Rule
|
||||
{
|
||||
Terminal(u8, Token),
|
||||
NonTerminal(u8, u8, u8)
|
||||
}
|
||||
|
||||
pub const NONTERMS: [&str; 115] =
|
||||
[
|
||||
"stat__15",
|
||||
"funcbody__50",
|
||||
"fieldlist",
|
||||
"fieldlist__1",
|
||||
"namelist",
|
||||
"parlist",
|
||||
">_non",
|
||||
"chunk",
|
||||
",_non",
|
||||
"field__29",
|
||||
"stat__11",
|
||||
"stat__45",
|
||||
"stat__33",
|
||||
"funcname",
|
||||
"prefixexp__25",
|
||||
";_?",
|
||||
"stat__5",
|
||||
"stat__38",
|
||||
"else_non",
|
||||
"stat__16",
|
||||
"<_non",
|
||||
"explist",
|
||||
"stat_*",
|
||||
"{_non",
|
||||
"funcnamedotexpansion_*",
|
||||
"stat__6",
|
||||
"funcnamedotexpansion",
|
||||
"moreattribs_*",
|
||||
"field__28",
|
||||
"retstat_?",
|
||||
"stat__9",
|
||||
"stat__37",
|
||||
"field",
|
||||
"local_non",
|
||||
")_non",
|
||||
"morevars_*",
|
||||
"moreattribs__19",
|
||||
"morevars",
|
||||
"forthirdarg_?",
|
||||
"::_non",
|
||||
"stat",
|
||||
"morefields_*",
|
||||
"]_non",
|
||||
"[_non",
|
||||
"assign",
|
||||
"field__31",
|
||||
"stat__4",
|
||||
"do_non",
|
||||
"unop",
|
||||
"elseifblocks__18",
|
||||
"elseblock_?",
|
||||
"label__21",
|
||||
"funcbody__51",
|
||||
"in_non",
|
||||
"stat__34",
|
||||
"exp",
|
||||
"funcnamecolonexpansion_?",
|
||||
"(_non",
|
||||
"if_non",
|
||||
"stat__7",
|
||||
"attrib__20",
|
||||
"elseifblocks__17",
|
||||
"fieldsep_?",
|
||||
"while_non",
|
||||
"elseifblocks_*",
|
||||
"binop",
|
||||
"..._non",
|
||||
"then_non",
|
||||
"return_non",
|
||||
"._non",
|
||||
"stat__35",
|
||||
"prefixexp",
|
||||
"attnamelist",
|
||||
"functioncall__26",
|
||||
"elseifblocks",
|
||||
"function_non",
|
||||
"}_non",
|
||||
"var__22",
|
||||
"tableconstructor__53",
|
||||
"varlist",
|
||||
"S_0",
|
||||
"Name_non",
|
||||
"goto_non",
|
||||
"parlistvarargs_?",
|
||||
"elseif_non",
|
||||
"for_non",
|
||||
"stat__8",
|
||||
"args",
|
||||
"stat__41",
|
||||
"stat__14",
|
||||
"until_non",
|
||||
"morenames_*",
|
||||
"stat__39",
|
||||
"stat__32",
|
||||
"end_non",
|
||||
"attnamelist__46",
|
||||
"moreexps_*",
|
||||
"stat__10",
|
||||
"=_non",
|
||||
":_non",
|
||||
"stat__36",
|
||||
"functioncall__27",
|
||||
"funcname__48",
|
||||
"attrib",
|
||||
"repeat_non",
|
||||
"args__49",
|
||||
"var",
|
||||
"var__23",
|
||||
"stat__40",
|
||||
"exp__0",
|
||||
"stat__42",
|
||||
"morefields",
|
||||
"moreattribs",
|
||||
"funcbody",
|
||||
"retstat__47",
|
||||
];
|
||||
|
||||
pub const GRAMMAR: [Rule; 344] =
|
||||
[
|
||||
Rule::Terminal(57, Token::RoundOpen),
|
||||
Rule::Terminal(34, Token::RoundClosed),
|
||||
Rule::Terminal(8, Token::Comma),
|
||||
Rule::Terminal(66, Token::DotDotDot),
|
||||
Rule::Terminal(69, Token::Dot),
|
||||
Rule::Terminal(39, Token::ColonColon),
|
||||
Rule::Terminal(99, Token::Colon),
|
||||
Rule::Terminal(15, Token::Semicolon),
|
||||
Rule::Terminal(20, Token::Lt),
|
||||
Rule::Terminal(98, Token::Equals),
|
||||
Rule::Terminal(6, Token::Gt),
|
||||
Rule::Terminal(81, Token::Name(String::new())),
|
||||
Rule::NonTerminal(80, 22, 29),
|
||||
Rule::NonTerminal(80, 68, 114),
|
||||
Rule::Terminal(80, Token::Return),
|
||||
Rule::NonTerminal(80, 40, 22),
|
||||
Rule::Terminal(80, Token::Semicolon),
|
||||
Rule::Terminal(80, Token::Break),
|
||||
Rule::NonTerminal(80, 82, 81),
|
||||
Rule::NonTerminal(80, 79, 44),
|
||||
Rule::NonTerminal(80, 47, 25),
|
||||
Rule::NonTerminal(80, 63, 46),
|
||||
Rule::NonTerminal(80, 104, 59),
|
||||
Rule::NonTerminal(80, 85, 30),
|
||||
Rule::NonTerminal(80, 75, 89),
|
||||
Rule::NonTerminal(80, 33, 0),
|
||||
Rule::NonTerminal(80, 58, 93),
|
||||
Rule::NonTerminal(80, 85, 31),
|
||||
Rule::NonTerminal(80, 33, 11),
|
||||
Rule::NonTerminal(80, 71, 87),
|
||||
Rule::NonTerminal(80, 71, 73),
|
||||
Rule::NonTerminal(80, 39, 51),
|
||||
Rule::Terminal(43, Token::SquareOpen),
|
||||
Rule::Terminal(42, Token::SquareClosed),
|
||||
Rule::Terminal(87, Token::StringLiteral(String::new())),
|
||||
Rule::NonTerminal(87, 57, 105),
|
||||
Rule::NonTerminal(87, 23, 78),
|
||||
Rule::NonTerminal(105, 21, 34),
|
||||
Rule::Terminal(105, Token::RoundClosed),
|
||||
Rule::NonTerminal(44, 98, 21),
|
||||
Rule::NonTerminal(72, 81, 95),
|
||||
Rule::Terminal(72, Token::Name(String::new())),
|
||||
Rule::NonTerminal(95, 103, 27),
|
||||
Rule::NonTerminal(95, 20, 60),
|
||||
Rule::NonTerminal(95, 112, 27),
|
||||
Rule::NonTerminal(95, 8, 36),
|
||||
Rule::NonTerminal(103, 20, 60),
|
||||
Rule::NonTerminal(60, 81, 6),
|
||||
Rule::Terminal(65, Token::Plus),
|
||||
Rule::Terminal(65, Token::Minus),
|
||||
Rule::Terminal(65, Token::Star),
|
||||
Rule::Terminal(65, Token::Slash),
|
||||
Rule::Terminal(65, Token::SlashSlash),
|
||||
Rule::Terminal(65, Token::Caret),
|
||||
Rule::Terminal(65, Token::Percent),
|
||||
Rule::Terminal(65, Token::Ampersand),
|
||||
Rule::Terminal(65, Token::Pipe),
|
||||
Rule::Terminal(65, Token::GtGt),
|
||||
Rule::Terminal(65, Token::LtLt),
|
||||
Rule::Terminal(65, Token::DotDot),
|
||||
Rule::Terminal(65, Token::Lt),
|
||||
Rule::Terminal(65, Token::LtEquals),
|
||||
Rule::Terminal(65, Token::Gt),
|
||||
Rule::Terminal(65, Token::GtEquals),
|
||||
Rule::Terminal(65, Token::EqualsEquals),
|
||||
Rule::Terminal(65, Token::TildeEquals),
|
||||
Rule::Terminal(65, Token::And),
|
||||
Rule::Terminal(65, Token::Or),
|
||||
Rule::NonTerminal(7, 22, 29),
|
||||
Rule::NonTerminal(7, 68, 114),
|
||||
Rule::Terminal(7, Token::Return),
|
||||
Rule::NonTerminal(7, 40, 22),
|
||||
Rule::Terminal(7, Token::Semicolon),
|
||||
Rule::Terminal(7, Token::Break),
|
||||
Rule::NonTerminal(7, 82, 81),
|
||||
Rule::NonTerminal(7, 79, 44),
|
||||
Rule::NonTerminal(7, 47, 25),
|
||||
Rule::NonTerminal(7, 63, 46),
|
||||
Rule::NonTerminal(7, 104, 59),
|
||||
Rule::NonTerminal(7, 85, 30),
|
||||
Rule::NonTerminal(7, 75, 89),
|
||||
Rule::NonTerminal(7, 33, 0),
|
||||
Rule::NonTerminal(7, 58, 93),
|
||||
Rule::NonTerminal(7, 85, 31),
|
||||
Rule::NonTerminal(7, 33, 11),
|
||||
Rule::NonTerminal(7, 71, 87),
|
||||
Rule::NonTerminal(7, 71, 73),
|
||||
Rule::NonTerminal(7, 39, 51),
|
||||
Rule::Terminal(47, Token::Do),
|
||||
Rule::Terminal(18, Token::Else),
|
||||
Rule::NonTerminal(50, 18, 7),
|
||||
Rule::Terminal(50, Token::Else),
|
||||
Rule::Terminal(84, Token::Elseif),
|
||||
Rule::NonTerminal(74, 84, 61),
|
||||
Rule::NonTerminal(64, 74, 64),
|
||||
Rule::NonTerminal(64, 84, 61),
|
||||
Rule::NonTerminal(61, 55, 49),
|
||||
Rule::NonTerminal(49, 67, 7),
|
||||
Rule::Terminal(49, Token::Then),
|
||||
Rule::Terminal(94, Token::End),
|
||||
Rule::Terminal(55, Token::Nil),
|
||||
Rule::Terminal(55, Token::False),
|
||||
Rule::Terminal(55, Token::True),
|
||||
Rule::Terminal(55, Token::Numeral(String::new())),
|
||||
Rule::Terminal(55, Token::StringLiteral(String::new())),
|
||||
Rule::Terminal(55, Token::DotDotDot),
|
||||
Rule::NonTerminal(55, 48, 55),
|
||||
Rule::NonTerminal(55, 55, 109),
|
||||
Rule::NonTerminal(55, 75, 113),
|
||||
Rule::NonTerminal(55, 23, 78),
|
||||
Rule::NonTerminal(55, 57, 14),
|
||||
Rule::Terminal(55, Token::Name(String::new())),
|
||||
Rule::NonTerminal(55, 71, 77),
|
||||
Rule::NonTerminal(55, 71, 26),
|
||||
Rule::NonTerminal(55, 71, 87),
|
||||
Rule::NonTerminal(55, 71, 73),
|
||||
Rule::NonTerminal(109, 65, 55),
|
||||
Rule::NonTerminal(21, 55, 96),
|
||||
Rule::Terminal(21, Token::Nil),
|
||||
Rule::Terminal(21, Token::False),
|
||||
Rule::Terminal(21, Token::True),
|
||||
Rule::Terminal(21, Token::Numeral(String::new())),
|
||||
Rule::Terminal(21, Token::StringLiteral(String::new())),
|
||||
Rule::Terminal(21, Token::DotDotDot),
|
||||
Rule::NonTerminal(21, 48, 55),
|
||||
Rule::NonTerminal(21, 55, 109),
|
||||
Rule::NonTerminal(21, 75, 113),
|
||||
Rule::NonTerminal(21, 23, 78),
|
||||
Rule::NonTerminal(21, 57, 14),
|
||||
Rule::Terminal(21, Token::Name(String::new())),
|
||||
Rule::NonTerminal(21, 71, 77),
|
||||
Rule::NonTerminal(21, 71, 26),
|
||||
Rule::NonTerminal(21, 71, 87),
|
||||
Rule::NonTerminal(21, 71, 73),
|
||||
Rule::NonTerminal(32, 43, 28),
|
||||
Rule::NonTerminal(32, 81, 45),
|
||||
Rule::Terminal(32, Token::Nil),
|
||||
Rule::Terminal(32, Token::False),
|
||||
Rule::Terminal(32, Token::True),
|
||||
Rule::Terminal(32, Token::Numeral(String::new())),
|
||||
Rule::Terminal(32, Token::StringLiteral(String::new())),
|
||||
Rule::Terminal(32, Token::DotDotDot),
|
||||
Rule::NonTerminal(32, 48, 55),
|
||||
Rule::NonTerminal(32, 55, 109),
|
||||
Rule::NonTerminal(32, 75, 113),
|
||||
Rule::NonTerminal(32, 23, 78),
|
||||
Rule::NonTerminal(32, 57, 14),
|
||||
Rule::Terminal(32, Token::Name(String::new())),
|
||||
Rule::NonTerminal(32, 71, 77),
|
||||
Rule::NonTerminal(32, 71, 26),
|
||||
Rule::NonTerminal(32, 71, 87),
|
||||
Rule::NonTerminal(32, 71, 73),
|
||||
Rule::NonTerminal(28, 55, 9),
|
||||
Rule::NonTerminal(9, 42, 45),
|
||||
Rule::NonTerminal(45, 98, 55),
|
||||
Rule::NonTerminal(2, 32, 3),
|
||||
Rule::NonTerminal(2, 43, 28),
|
||||
Rule::NonTerminal(2, 81, 45),
|
||||
Rule::Terminal(2, Token::Nil),
|
||||
Rule::Terminal(2, Token::False),
|
||||
Rule::Terminal(2, Token::True),
|
||||
Rule::Terminal(2, Token::Numeral(String::new())),
|
||||
Rule::Terminal(2, Token::StringLiteral(String::new())),
|
||||
Rule::Terminal(2, Token::DotDotDot),
|
||||
Rule::NonTerminal(2, 48, 55),
|
||||
Rule::NonTerminal(2, 55, 109),
|
||||
Rule::NonTerminal(2, 75, 113),
|
||||
Rule::NonTerminal(2, 23, 78),
|
||||
Rule::NonTerminal(2, 57, 14),
|
||||
Rule::Terminal(2, Token::Name(String::new())),
|
||||
Rule::NonTerminal(2, 71, 77),
|
||||
Rule::NonTerminal(2, 71, 26),
|
||||
Rule::NonTerminal(2, 71, 87),
|
||||
Rule::NonTerminal(2, 71, 73),
|
||||
Rule::NonTerminal(3, 41, 62),
|
||||
Rule::Terminal(3, Token::Comma),
|
||||
Rule::Terminal(3, Token::Semicolon),
|
||||
Rule::NonTerminal(3, 111, 41),
|
||||
Rule::NonTerminal(3, 62, 32),
|
||||
Rule::Terminal(62, Token::Comma),
|
||||
Rule::Terminal(62, Token::Semicolon),
|
||||
Rule::Terminal(85, Token::For),
|
||||
Rule::NonTerminal(38, 8, 55),
|
||||
Rule::NonTerminal(113, 57, 1),
|
||||
Rule::NonTerminal(1, 5, 52),
|
||||
Rule::NonTerminal(1, 34, 25),
|
||||
Rule::NonTerminal(52, 34, 25),
|
||||
Rule::NonTerminal(13, 81, 102),
|
||||
Rule::Terminal(13, Token::Name(String::new())),
|
||||
Rule::NonTerminal(102, 24, 56),
|
||||
Rule::NonTerminal(102, 26, 24),
|
||||
Rule::NonTerminal(102, 69, 81),
|
||||
Rule::NonTerminal(102, 99, 81),
|
||||
Rule::NonTerminal(56, 99, 81),
|
||||
Rule::NonTerminal(26, 69, 81),
|
||||
Rule::NonTerminal(24, 26, 24),
|
||||
Rule::NonTerminal(24, 69, 81),
|
||||
Rule::Terminal(75, Token::Function),
|
||||
Rule::NonTerminal(73, 99, 101),
|
||||
Rule::NonTerminal(101, 81, 87),
|
||||
Rule::Terminal(82, Token::Goto),
|
||||
Rule::Terminal(58, Token::If),
|
||||
Rule::Terminal(53, Token::In),
|
||||
Rule::NonTerminal(51, 81, 39),
|
||||
Rule::Terminal(33, Token::Local),
|
||||
Rule::NonTerminal(112, 8, 36),
|
||||
Rule::NonTerminal(27, 112, 27),
|
||||
Rule::NonTerminal(27, 8, 36),
|
||||
Rule::NonTerminal(36, 81, 103),
|
||||
Rule::Terminal(36, Token::Name(String::new())),
|
||||
Rule::NonTerminal(96, 38, 96),
|
||||
Rule::NonTerminal(96, 8, 55),
|
||||
Rule::NonTerminal(111, 62, 32),
|
||||
Rule::NonTerminal(41, 111, 41),
|
||||
Rule::NonTerminal(41, 62, 32),
|
||||
Rule::NonTerminal(91, 37, 91),
|
||||
Rule::NonTerminal(91, 8, 81),
|
||||
Rule::NonTerminal(37, 8, 81),
|
||||
Rule::NonTerminal(35, 37, 35),
|
||||
Rule::NonTerminal(35, 8, 81),
|
||||
Rule::NonTerminal(4, 81, 91),
|
||||
Rule::Terminal(4, Token::Name(String::new())),
|
||||
Rule::Terminal(5, Token::DotDotDot),
|
||||
Rule::NonTerminal(5, 4, 83),
|
||||
Rule::NonTerminal(5, 81, 91),
|
||||
Rule::Terminal(5, Token::Name(String::new())),
|
||||
Rule::NonTerminal(83, 8, 66),
|
||||
Rule::NonTerminal(71, 57, 14),
|
||||
Rule::Terminal(71, Token::Name(String::new())),
|
||||
Rule::NonTerminal(71, 71, 77),
|
||||
Rule::NonTerminal(71, 71, 26),
|
||||
Rule::NonTerminal(71, 71, 87),
|
||||
Rule::NonTerminal(71, 71, 73),
|
||||
Rule::NonTerminal(14, 55, 34),
|
||||
Rule::Terminal(104, Token::Repeat),
|
||||
Rule::NonTerminal(29, 68, 114),
|
||||
Rule::Terminal(29, Token::Return),
|
||||
Rule::NonTerminal(114, 21, 15),
|
||||
Rule::Terminal(114, Token::Semicolon),
|
||||
Rule::NonTerminal(114, 55, 96),
|
||||
Rule::Terminal(114, Token::Nil),
|
||||
Rule::Terminal(114, Token::False),
|
||||
Rule::Terminal(114, Token::True),
|
||||
Rule::Terminal(114, Token::Numeral(String::new())),
|
||||
Rule::Terminal(114, Token::StringLiteral(String::new())),
|
||||
Rule::Terminal(114, Token::DotDotDot),
|
||||
Rule::NonTerminal(114, 48, 55),
|
||||
Rule::NonTerminal(114, 55, 109),
|
||||
Rule::NonTerminal(114, 75, 113),
|
||||
Rule::NonTerminal(114, 23, 78),
|
||||
Rule::NonTerminal(114, 57, 14),
|
||||
Rule::Terminal(114, Token::Name(String::new())),
|
||||
Rule::NonTerminal(114, 71, 77),
|
||||
Rule::NonTerminal(114, 71, 26),
|
||||
Rule::NonTerminal(114, 71, 87),
|
||||
Rule::NonTerminal(114, 71, 73),
|
||||
Rule::Terminal(68, Token::Return),
|
||||
Rule::Terminal(40, Token::Semicolon),
|
||||
Rule::Terminal(40, Token::Break),
|
||||
Rule::NonTerminal(40, 82, 81),
|
||||
Rule::NonTerminal(40, 79, 44),
|
||||
Rule::NonTerminal(40, 47, 25),
|
||||
Rule::NonTerminal(40, 63, 46),
|
||||
Rule::NonTerminal(40, 104, 59),
|
||||
Rule::NonTerminal(40, 85, 30),
|
||||
Rule::NonTerminal(40, 75, 89),
|
||||
Rule::NonTerminal(40, 33, 0),
|
||||
Rule::NonTerminal(40, 58, 93),
|
||||
Rule::NonTerminal(40, 85, 31),
|
||||
Rule::NonTerminal(40, 33, 11),
|
||||
Rule::NonTerminal(40, 71, 87),
|
||||
Rule::NonTerminal(40, 71, 73),
|
||||
Rule::NonTerminal(40, 39, 51),
|
||||
Rule::NonTerminal(22, 40, 22),
|
||||
Rule::Terminal(22, Token::Semicolon),
|
||||
Rule::Terminal(22, Token::Break),
|
||||
Rule::NonTerminal(22, 82, 81),
|
||||
Rule::NonTerminal(22, 79, 44),
|
||||
Rule::NonTerminal(22, 47, 25),
|
||||
Rule::NonTerminal(22, 63, 46),
|
||||
Rule::NonTerminal(22, 104, 59),
|
||||
Rule::NonTerminal(22, 85, 30),
|
||||
Rule::NonTerminal(22, 75, 89),
|
||||
Rule::NonTerminal(22, 33, 0),
|
||||
Rule::NonTerminal(22, 58, 93),
|
||||
Rule::NonTerminal(22, 85, 31),
|
||||
Rule::NonTerminal(22, 33, 11),
|
||||
Rule::NonTerminal(22, 71, 87),
|
||||
Rule::NonTerminal(22, 71, 73),
|
||||
Rule::NonTerminal(22, 39, 51),
|
||||
Rule::NonTerminal(97, 53, 10),
|
||||
Rule::NonTerminal(10, 21, 16),
|
||||
Rule::NonTerminal(89, 13, 113),
|
||||
Rule::NonTerminal(0, 75, 19),
|
||||
Rule::NonTerminal(19, 81, 113),
|
||||
Rule::NonTerminal(93, 55, 12),
|
||||
Rule::NonTerminal(12, 67, 54),
|
||||
Rule::NonTerminal(54, 7, 70),
|
||||
Rule::NonTerminal(54, 64, 100),
|
||||
Rule::NonTerminal(54, 50, 94),
|
||||
Rule::Terminal(54, Token::End),
|
||||
Rule::NonTerminal(70, 64, 100),
|
||||
Rule::NonTerminal(70, 50, 94),
|
||||
Rule::Terminal(70, Token::End),
|
||||
Rule::NonTerminal(100, 50, 94),
|
||||
Rule::Terminal(100, Token::End),
|
||||
Rule::NonTerminal(31, 81, 17),
|
||||
Rule::NonTerminal(17, 98, 92),
|
||||
Rule::NonTerminal(92, 55, 108),
|
||||
Rule::NonTerminal(46, 55, 16),
|
||||
Rule::NonTerminal(108, 8, 88),
|
||||
Rule::NonTerminal(88, 55, 110),
|
||||
Rule::NonTerminal(110, 38, 16),
|
||||
Rule::NonTerminal(110, 47, 25),
|
||||
Rule::NonTerminal(11, 72, 44),
|
||||
Rule::NonTerminal(11, 81, 95),
|
||||
Rule::Terminal(11, Token::Name(String::new())),
|
||||
Rule::NonTerminal(16, 47, 25),
|
||||
Rule::NonTerminal(25, 7, 94),
|
||||
Rule::Terminal(25, Token::End),
|
||||
Rule::NonTerminal(59, 7, 86),
|
||||
Rule::NonTerminal(59, 90, 55),
|
||||
Rule::NonTerminal(86, 90, 55),
|
||||
Rule::NonTerminal(30, 4, 97),
|
||||
Rule::NonTerminal(78, 2, 76),
|
||||
Rule::Terminal(78, Token::CurlyClosed),
|
||||
Rule::Terminal(67, Token::Then),
|
||||
Rule::Terminal(48, Token::Minus),
|
||||
Rule::Terminal(48, Token::Not),
|
||||
Rule::Terminal(48, Token::Hash),
|
||||
Rule::Terminal(48, Token::Tilde),
|
||||
Rule::Terminal(90, Token::Until),
|
||||
Rule::Terminal(106, Token::Name(String::new())),
|
||||
Rule::NonTerminal(106, 71, 77),
|
||||
Rule::NonTerminal(106, 71, 26),
|
||||
Rule::NonTerminal(77, 43, 107),
|
||||
Rule::NonTerminal(107, 55, 42),
|
||||
Rule::NonTerminal(79, 106, 35),
|
||||
Rule::Terminal(79, Token::Name(String::new())),
|
||||
Rule::NonTerminal(79, 71, 77),
|
||||
Rule::NonTerminal(79, 71, 26),
|
||||
Rule::Terminal(63, Token::While),
|
||||
Rule::Terminal(23, Token::CurlyOpen),
|
||||
Rule::Terminal(76, Token::CurlyClosed),
|
||||
];
|
||||
290
src/parser.rs
Normal file
290
src/parser.rs
Normal file
@ -0,0 +1,290 @@
|
||||
use std::slice::Iter;
|
||||
|
||||
use crate::tokenizer::Token;
|
||||
#[derive(Debug)]
|
||||
pub struct BlockNode
|
||||
{
|
||||
stats: Vec<StatNode>,
|
||||
retstat: Option<RetstatNode>
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub enum StatNode
|
||||
{
|
||||
Semicolon,
|
||||
Assignment(AssignmentNode),
|
||||
FunctionCall(FunctionCallNode),
|
||||
Label(LabelNode),
|
||||
Break,
|
||||
Goto(GotoNode),
|
||||
Block(BlockNode),
|
||||
While(WhileNode),
|
||||
Repeat(RepeatNode),
|
||||
If(IfNode),
|
||||
For(ForNode),
|
||||
ForIn(ForInNode),
|
||||
Function(FunctionNode),
|
||||
LocalFunction(LocalFunctionNode),
|
||||
Local(LocalNode),
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct AssignmentNode
|
||||
{
|
||||
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct FunctionCallNode
|
||||
{
|
||||
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct RetstatNode
|
||||
{
|
||||
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct LabelNode
|
||||
{
|
||||
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct GotoNode
|
||||
{
|
||||
label: String
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct WhileNode
|
||||
{
|
||||
condition: ExpNode,
|
||||
block: BlockNode,
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct RepeatNode
|
||||
{
|
||||
condition: ExpNode,
|
||||
block: BlockNode,
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct IfNode
|
||||
{
|
||||
condition: ExpNode,
|
||||
then_block: BlockNode,
|
||||
elseifs: Option<Vec<ElseIfNode>>
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct ElseIfNode
|
||||
{
|
||||
condition: ExpNode,
|
||||
block: BlockNode,
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct ForNode
|
||||
{
|
||||
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct ForInNode
|
||||
{
|
||||
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct FunctionNode
|
||||
{
|
||||
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct LocalFunctionNode
|
||||
{
|
||||
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct LocalNode
|
||||
{
|
||||
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct ExpNode
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
pub fn parse(tokens: Vec<Token>) -> Result<BlockNode, &'static str>
|
||||
{
|
||||
let mut iter = tokens.iter();
|
||||
return parse_block(&mut iter);
|
||||
}
|
||||
|
||||
fn parse_block(tokens: &mut Iter<'_, Token>) -> Result<BlockNode, &'static str>
|
||||
{
|
||||
let mut block_node = BlockNode { retstat: None, stats: Vec::new() };
|
||||
while let Some(stat) = parse_stat(tokens)?
|
||||
{
|
||||
block_node.stats.push(stat);
|
||||
}
|
||||
block_node.retstat = parse_retstat(tokens)?;
|
||||
return Ok(block_node);
|
||||
}
|
||||
|
||||
fn parse_stat(tokens: &mut Iter<'_, Token>) -> Result<Option<StatNode>, &'static str>
|
||||
{
|
||||
match tokens.next()
|
||||
{
|
||||
Some(token) =>
|
||||
{
|
||||
match token
|
||||
{
|
||||
Token::Semicolon => return Ok(Some(StatNode::Semicolon)),
|
||||
Token::Break => return Ok(Some(StatNode::Break)),
|
||||
Token::Goto =>
|
||||
{
|
||||
match tokens.next()
|
||||
{
|
||||
Some(Token::Name(string)) => return Ok(Some(StatNode::Goto(GotoNode { label: string.clone() }))),
|
||||
_ => return Err("Failed to parse goto statement")
|
||||
}
|
||||
}
|
||||
Token::Do =>
|
||||
{
|
||||
let block = parse_block(tokens)?;
|
||||
match tokens.next()
|
||||
{
|
||||
Some(Token::End) => return Ok(Some(StatNode::Block(block))),
|
||||
_ => return Err("Failed to parse block statement")
|
||||
}
|
||||
}
|
||||
Token::While =>
|
||||
{
|
||||
if let Some(condition) = parse_exp(tokens)?
|
||||
{
|
||||
match tokens.next()
|
||||
{
|
||||
Some(Token::Do) =>
|
||||
{
|
||||
let block = parse_block(tokens)?;
|
||||
match tokens.next()
|
||||
{
|
||||
Some(Token::End) => return Ok(Some(StatNode::While(WhileNode { condition, block }))),
|
||||
_ => Err("No end after while block")
|
||||
}
|
||||
}
|
||||
_ => Err("No do after while condition"),
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
return Err("Failed to parse while condition");
|
||||
}
|
||||
}
|
||||
Token::Repeat =>
|
||||
{
|
||||
let block = parse_block(tokens)?;
|
||||
match tokens.next()
|
||||
{
|
||||
Some(Token::Until) =>
|
||||
{
|
||||
match parse_exp(tokens)?
|
||||
{
|
||||
Some(exp) => return Ok(Some(StatNode::Repeat(RepeatNode { condition: exp, block }))),
|
||||
None => Err("Failed to parse repeat condition")
|
||||
}
|
||||
}
|
||||
_ => Err("Missing until after repeat block")
|
||||
}
|
||||
}
|
||||
Token::If =>
|
||||
{
|
||||
if let Some(condition) = parse_exp(tokens)?
|
||||
{
|
||||
match tokens.next()
|
||||
{
|
||||
Some(Token::Then) =>
|
||||
{
|
||||
let block = parse_block(tokens)?;
|
||||
let mut elseifs: Vec<ElseIfNode> = Vec::new();
|
||||
loop
|
||||
{
|
||||
match tokens.next()
|
||||
{
|
||||
Some(Token::Elseif) =>
|
||||
{
|
||||
if let Some(elseif_condition) = parse_exp(tokens)?
|
||||
{
|
||||
match tokens.next()
|
||||
{
|
||||
Some(Token::Then) =>
|
||||
{
|
||||
elseifs.push(ElseIfNode { block: parse_block(tokens)?, condition: elseif_condition });
|
||||
}
|
||||
_ => return Err("Missing Then after elseif statement"),
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
return Err("Failed to parse elseif condition");
|
||||
}
|
||||
}
|
||||
Some(Token::Else) =>
|
||||
{
|
||||
match tokens.next()
|
||||
{
|
||||
Some(Token::End) => return Ok(Some(StatNode::If(IfNode { condition, then_block: block, elseifs: Some(elseifs) }))),
|
||||
_ => return Err("Missing end after else")
|
||||
}
|
||||
}
|
||||
Some(Token::End) =>
|
||||
{
|
||||
return Ok(Some(StatNode::If(IfNode { condition, then_block: block, elseifs: None })));
|
||||
}
|
||||
_ => return Err("Missing end after if block")
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => return Err("Missing then after if condition")
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
return Err("Failed to parse if condition");
|
||||
}
|
||||
}
|
||||
Token::For =>
|
||||
{
|
||||
match tokens.next()
|
||||
{
|
||||
Some(Token::Name(name)) =>
|
||||
{
|
||||
match tokens.next()
|
||||
{
|
||||
Some(Token::Equals) =>
|
||||
{
|
||||
todo!();
|
||||
}
|
||||
_ => todo!()
|
||||
}
|
||||
}
|
||||
_ => Err("Missing name after for"),
|
||||
}
|
||||
}
|
||||
_ => todo!()
|
||||
}
|
||||
}
|
||||
None => return Ok(None),
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_exp(tokens: &mut Iter<'_, Token>) -> Result<Option<ExpNode>, &'static str>
|
||||
{
|
||||
todo!();
|
||||
}
|
||||
|
||||
fn parse_retstat(tokens: &mut Iter<'_, Token>) -> Result<Option<RetstatNode>, &'static str>
|
||||
{
|
||||
match tokens.next()
|
||||
{
|
||||
Some(Token::Return) =>
|
||||
{
|
||||
todo!()
|
||||
}
|
||||
None => return Ok(None),
|
||||
_ => return Err("Found wrong token at the beginning of retstat")
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user