From c5d704a34ff6377dea5d651599864a9385d5c936 Mon Sep 17 00:00:00 2001
From: Luna <git@l4.pm>
Date: Sun, 2 Jun 2019 00:02:37 -0300
Subject: [PATCH] add not operator

---
 README.md        | 17 +++++++++++++++--
 src/chunk.zig    |  2 ++
 src/compiler.zig |  3 ++-
 src/vm.zig       |  7 +++++++
 4 files changed, 26 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 2168721..b8e6fc4 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,18 @@
 # jorts
 
-an interpreter for the lox language from https://craftinginterpreters.com
+a compiler for the lox language from https://craftinginterpreters.com
 
-this is a learning project.
+this is a learning project. the implemtation is based heavily off the C part
+of the book, but also the Java part for the scanner.
+
+## notes
+
+ - jorts' lox bytecode is not compatible with any implementation.
+
+## how do?
+
+```
+zig build run
+```
+
+and play around with it
diff --git a/src/chunk.zig b/src/chunk.zig
index c32345e..3f8b2f6 100644
--- a/src/chunk.zig
+++ b/src/chunk.zig
@@ -18,6 +18,8 @@ const AllOpcodes = struct {
     pub Nil: u8 = 8,
     pub True: u8 = 9,
     pub False: u8 = 10,
+
+    pub Not: u8 = 11,
 };
 
 pub const OpCode = AllOpcodes{};
diff --git a/src/compiler.zig b/src/compiler.zig
index 350e6ad..5928b95 100644
--- a/src/compiler.zig
+++ b/src/compiler.zig
@@ -75,7 +75,7 @@ var rules = []ParseRule{
     ParseRule{ .infix = Compiler.binary, .precedence = .Factor },
 
     // as the token enum says, those are 1/2 char tokens.
-    ParseRule{},
+    ParseRule{ .prefix = Compiler.unary },
     // this is specifically for the != operator
     ParseRule{ .precedence = .Equality },
     ParseRule{},
@@ -236,6 +236,7 @@ pub const Compiler = struct {
 
         switch (ttype) {
             .MINUS => try self.emitByte(OpCode.Negate),
+            .BANG => try self.emitByte(OpCode.Not),
             else => unreachable,
         }
     }
diff --git a/src/vm.zig b/src/vm.zig
index f1ce443..5b89051 100644
--- a/src/vm.zig
+++ b/src/vm.zig
@@ -16,6 +16,10 @@ pub const InterpretResult = error{
     RuntimeError,
 };
 
+fn isFalsey(val: value.Value) bool {
+    return val.vtype == .Nil or (val.vtype == .Bool and !val.as.Bool);
+}
+
 pub const VM = struct {
     chk: *Chunk = undefined,
     src: []const u8,
@@ -170,6 +174,9 @@ pub const VM = struct {
                 chunk.OpCode.Subtract => try self.doSub(),
                 chunk.OpCode.Multiply => try self.doMul(),
                 chunk.OpCode.Divide => try self.doDiv(),
+                chunk.OpCode.Not => blk: {
+                    try self.push(values.BoolVal(isFalsey(self.pop())));
+                },
                 chunk.OpCode.Negate => blk: {
                     var val = self.peek(0);
                     if (val.vtype != .Bool) {