add print statement

- remove opcode return's use as debug

src/chunk.zig

@@ -25,6 +25,8 @@ const AllOpcodes = struct {
     pub Equal: u8 = 12,
     pub Greater: u8 = 13,
     pub Less: u8 = 14,
+
+    pub Print: u8 = 15,
 };
 
 pub const OpCode = AllOpcodes{};
@@ -189,6 +191,8 @@ pub const Chunk = struct {
             return try simpleInstruction(stdout, "OP_GREATER", index);
         } else if (instruction == OpCode.Less) {
             return try simpleInstruction(stdout, "OP_LESS", index);
+        } else if (instruction == OpCode.Print) {
+            return try simpleInstruction(stdout, "OP_PRINT", index);
         } else {
             try stdout.print("Unknown opcode: {}\n", instruction);
             return index + 1;

src/compiler.zig

@@ -186,6 +186,17 @@ pub const Compiler = struct {
         self.errorCurrent(msg);
     }
 
+    fn check(self: *Compiler, ttype: TokenType) bool {
+        return self.parser.current.ttype == ttype;
+    }
+
+    fn match(self: *Compiler, ttype: TokenType) !bool {
+        if (!(self.check(ttype))) return false;
+
+        try self.advance();
+        return true;
+    }
+
     fn currentChunk(self: *Compiler) *chunks.Chunk {
         return self.chunk;
     }
@@ -314,14 +325,33 @@ pub const Compiler = struct {
         try self.parsePrecedence(.Assignment);
     }
 
+    fn printStmt(self: *Compiler) !void {
+        try self.expression();
+        try self.consume(.SEMICOLON, "Expect ';' after value.");
+        try self.emitByte(OpCode.Print);
+    }
+
+    fn declaration(self: *Compiler) !void {
+        try self.statement();
+    }
+
+    fn statement(self: *Compiler) !void {
+        if (try self.match(.PRINT)) {
+            try self.printStmt();
+        }
+    }
+
     /// Compile the source given when initializing the compiler
     /// into the given chunk.
     pub fn compile(self: *Compiler, chunk: *Chunk) !bool {
         self.scanr = try scanner.Scanner.init(self.allocator, self.src);
 
         try self.advance();
-        try self.expression();
-        try self.consume(.EOF, "Expect end of expression.");
+        while (!(try self.match(.EOF))) {
+            try self.declaration();
+        }
+        // try self.expression();
+        // try self.consume(.EOF, "Expect end of expression.");
         try self.end();
 
         return !self.parser.hadError;

src/vm.zig

@@ -240,9 +240,14 @@ pub const VM = struct {
                     break :blk;
                 },
 
-                chunk.OpCode.Return => blk: {
+                chunk.OpCode.Print => blk: {
                     try value.printValue(self.stdout, self.pop());
                     try self.stdout.print("\n");
+                    break :blk;
+                },
+
+                chunk.OpCode.Return => blk: {
+                    // Exit VM
                     return InterpretResult.Ok;
                 },