3 files changed, 58 insertions, 4 deletions

diff --git a/src/compiler.c b/src/compiler.c
index 51d7cd6..d16b335 100644
--- a/src/compiler.c
+++ b/src/compiler.c
@@ -104,6 +104,7 @@ typedef enum OpCode {
     OP_GEI,   // gek   rx, ra, cb
     OP_ANDI,  // andk   rx, ra, cb
     OP_ORI,   // ork    rx, ra, cb
+    OP_NOTI,  // noti  rx, ra
     OP_EQ,    // eq    rx, ra, rb
     OP_NEQ,   // neq    rx, ra, rb
     OP_LT,    // lt    rx, ra, rb
@@ -112,6 +113,7 @@ typedef enum OpCode {
     OP_GE,    // ge    rx, ra, rb
     OP_AND,   // and   rx, ra, rb
     OP_OR,    // or    rx, ra, rb
+    OP_NOT,   // not   rx, ra
 } OpCode;
 
 Str op_str[] = {
@@ -171,12 +173,18 @@ Str op_str[] = {
     [OP_GTI] = cstr("GTI     "),
     [OP_LEI] = cstr("LEI     "),
     [OP_GEI] = cstr("GEI     "),
+    [OP_ANDI] = cstr("ANDI    "),
+    [OP_ORI] = cstr("ORI     "),
+    [OP_NOTI] = cstr("NOTI    "),
     [OP_EQ] = cstr("EQ      "),
     [OP_NEQ] = cstr("NEQ     "),
     [OP_LT] = cstr("LT      "),
     [OP_GT] = cstr("GT      "),
     [OP_LE] = cstr("LE      "),
     [OP_GE] = cstr("GE      "),
+    [OP_AND] = cstr("AND     "),
+    [OP_OR] = cstr("OR      "),
+    [OP_NOT] = cstr("NOT     "),
 };
 
 typedef enum {
@@ -250,8 +258,8 @@ compile_binary(Chunk *chunk, Node *node) {
         case NODE_GT: op = OP_GT; break;
         case NODE_LE: op = OP_LE; break;
         case NODE_GE: op = OP_GE; break;
-        case NODE_AND: op = OP_EQ; break;
-        case NODE_OR: op = OP_NEQ; break;
+        case NODE_AND: op = OP_AND; break;
+        case NODE_OR: op = OP_OR; break;
         default: break;
     }
     CompResult comp_a = compile_expr(chunk, node->left);
@@ -289,11 +297,40 @@ compile_binary(Chunk *chunk, Node *node) {
 }
 
 CompResult
+compile_unary(Chunk *chunk, Node *node) {
+    OpCode op = OP_HALT;
+    OpCode ldop = OP_LD64K;
+    switch (node->kind) {
+        case NODE_NOT: {
+            op = OP_NOT;
+        } break;
+        default: break;
+    }
+    CompResult comp_a = compile_expr(chunk, node->left);
+    sz reg_a;
+    switch (comp_a.type) {
+        case COMP_CONST: {
+            reg_a = chunk->reg_idx++;
+            EMIT_OP(ldop, reg_a, comp_a.idx, 0, node, chunk);
+        } break;
+        case COMP_REG: {
+            reg_a = comp_a.idx;
+        } break;
+        default: {
+            return (CompResult){.type = COMP_ERR};
+        } break;
+    }
+    sz reg_dst = chunk->reg_idx++;
+    EMIT_OP(op, reg_dst, reg_a, 0, node, chunk);
+    return (CompResult){.type = COMP_REG, .idx = reg_dst};
+}
+
+CompResult
 compile_expr(Chunk *chunk, Node *node) {
     switch (node->kind) {
         // Logic.
-        // case NODE_NOT:
         // case NODE_XOR:
+        case NODE_NOT: return compile_unary(chunk, node); break;
         case NODE_AND:
         case NODE_OR:
         case NODE_EQ:
diff --git a/src/vm.c b/src/vm.c
index 08a9ec3..338c364 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -79,6 +79,14 @@ disassemble_instruction(Instruction instruction) {
             println("%s r%d, r%d, r%d", op_str[instruction.op], instruction.dst,
                     instruction.a, instruction.b);
             break;
+        case OP_NOTI:
+            println("%s r%d, c%d", op_str[instruction.op], instruction.dst,
+                    instruction.a, instruction.b);
+            break;
+        case OP_NOT:
+            println("%s r%d, r%d", op_str[instruction.op], instruction.dst,
+                    instruction.a, instruction.b);
+            break;
         case OP_HALT: println("%s", op_str[instruction.op]); break;
         default: println("Unknown opcode %d", instruction.op); break;
     }
@@ -130,6 +138,13 @@ vm_init(VM *vm, Chunk *chunk) {
         vm->regs[dst].TYPE = vm->regs[src_a].TYPE OP vm->regs[src_b].TYPE; \
     } while (0);
 
+#define OP_UNARY(OP, TYPE)                            \
+    do {                                              \
+        u8 dst = instruction.dst;                     \
+        u8 src_a = instruction.a;                     \
+        vm->regs[dst].TYPE = OP vm->regs[src_a].TYPE; \
+    } while (0);
+
 #define OP_BINARY_CONST(OP, TYPE)                                     \
     do {                                                              \
         u8 dst = instruction.dst;                                     \
@@ -160,6 +175,7 @@ vm_run(VM *vm) {
                 u8 src_a = instruction.a;
                 vm->regs[dst].i = vm->chunk->constants[src_a].i;
             } break;
+            case OP_NOT: OP_UNARY(!, i) break;
             case OP_EQ: OP_BINARY(==, i) break;
             case OP_NEQ: OP_BINARY(!=, i) break;
             case OP_LT: OP_BINARY(<, i) break;
diff --git a/tests/compilation.bad b/tests/compilation.bad
index da6a6e3..90ed1ca 100644
--- a/tests/compilation.bad
+++ b/tests/compilation.bad
@@ -1,6 +1,7 @@
 ; 1 < 2
+; !(1 == 0 || 1 <= 1)
 ; 1 == 1 && 1 <= 1
-1 * 3 >= 3 && 4 != 3 + 2
+!(1 * 3 >= 3 && 4 != 3 + 2)
 ; 1 + 2 * 3
 ; 1.0 + 2.0 * 3.0
 ; true