1 files changed, 41 insertions, 15 deletions

diff --git a/src/compiler.rs b/src/compiler.rs
index c542412..4bb2469 100644
--- a/src/compiler.rs
+++ b/src/compiler.rs
@@ -338,6 +338,7 @@ impl Compiler {
 
         while !matches!(self.peek(), Token::RightBrace | Token::EOF) {
             self.statement(block);
+            expect!(self, Token::Newline, "Expect newline after expression.");
         }
 
         self.level -= 1;
@@ -380,12 +381,10 @@ impl Compiler {
         block.add(Op::Pop, self.line());
     }
 
-    fn for(&mut self, block: &mut Block) {
+    fn for_loop(&mut self, block: &mut Block) {
         expect!(self, Token::For, "Expected 'for' at start of for-loop.");
 
-        self.level += 1;
-        let h = self.stack.len();
-
+        // Definition
         match self.peek_four() {
             (Token::Identifier(name), Token::Identifier(typ), Token::ColonEqual, _) => {
                 self.eat();
@@ -403,21 +402,47 @@ impl Compiler {
                 self.eat();
                 self.define_variable(&name, Type::UnkownType, block);
             }
+
+            _ => { error!(self, "Expected definition at start of for-loop."); }
         }
 
+        expect!(self, Token::Comma, "Expect ',' between initalizer and loop expression.");
+
+        let cond = block.curr();
+        self.expression(block);
+        let cond_out = block.add(Op::Illegal, self.line());
+        let cond_cont = block.add(Op::Illegal, self.line());
+        expect!(self, Token::Comma, "Expect ',' between initalizer and loop expression.");
+
+        let inc = block.curr();
+        self.statement(block);
+        block.add(Op::Jmp(cond), self.line());
+
+        // patch_jmp!(Op::Jmp, cond_cont => block.curr());
+        block.patch(Op::Jmp(block.curr()), cond_cont);
+        self.scope(block);
+        block.add(Op::Jmp(inc), self.line());
+
+        block.patch(Op::JmpFalse(block.curr()), cond_out);
     }
 
     fn statement(&mut self, block: &mut Block) {
         self.clear_panic();
 
+        macro_rules! tokens {
+            ($( $token:pat ),*) => {
+                ($( $token , )* ..)
+            };
+        }
+
         match self.peek_four() {
-            (Token::Print, _, _, _) => {
+            tokens!(Token::Print) => {
                 self.eat();
                 self.expression(block);
                 block.add(Op::Print, self.line());
             },
 
-            (Token::Identifier(name), Token::Identifier(typ), Token::ColonEqual, _) => {
+            tokens!(Token::Identifier(name), Token::Identifier(typ), Token::ColonEqual) => {
                 self.eat();
                 self.eat();
                 self.eat();
@@ -428,43 +453,43 @@ impl Compiler {
                 }
             }
 
-            (Token::Identifier(name), Token::ColonEqual, _, _) => {
+            tokens!(Token::Identifier(name), Token::ColonEqual) => {
                 self.eat();
                 self.eat();
                 self.define_variable(&name, Type::UnkownType, block);
             }
 
-            (Token::Identifier(name), Token::Equal, _, _) => {
+            tokens!(Token::Identifier(name), Token::Equal) => {
                 self.eat();
                 self.eat();
                 self.assign(&name, block);
             }
 
-            (Token::If, _, _, _) => {
+            tokens!(Token::If) => {
                 self.if_statment(block);
             }
 
-            (Token::For, _, _, _) => {
-                self.for(block);
+            tokens!(Token::For) => {
+                self.for_loop(block);
             }
 
-            (Token::Unreachable, _, _, _) => {
+            tokens!(Token::Unreachable) => {
                 self.eat();
                 block.add(Op::Unreachable, self.line());
             }
 
-            (Token::LeftBrace, _, _, _) => {
+            tokens!(Token::LeftBrace) => {
                 self.scope(block);
             }
 
-            (Token::Newline, _, _, _) => {}
+            tokens!(Token::Newline) => {}
 
             _ => {
                 self.expression(block);
                 block.add(Op::Pop, self.line());
             }
         }
-        expect!(self, Token::Newline, "Expect newline after expression.");
+
     }
 
     pub fn compile(&mut self, name: &str, file: &Path) -> Result<Block, Vec<Error>> {
@@ -472,6 +497,7 @@ impl Compiler {
 
         while self.peek() != Token::EOF {
             self.statement(&mut block);
+            expect!(self, Token::Newline, "Expect newline after expression.");
         }
         block.add(Op::Return, self.line());