diff --git a/src/grammar.rs b/src/grammar.rs
new file mode 100644
index 0000000..d6a48eb
--- /dev/null
+++ b/src/grammar.rs
@@ -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),
+];
diff --git a/src/parser.rs b/src/parser.rs
new file mode 100644
index 0000000..73ddf39
--- /dev/null
+++ b/src/parser.rs
@@ -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")
+	}
+}
\ No newline at end of file