1 files changed, 53 insertions, 2 deletions

diff --git a/src/compiler.c b/src/compiler.c
index bc875fd..51d7cd6 100644
--- a/src/compiler.c
+++ b/src/compiler.c
@@ -20,6 +20,7 @@ typedef union Constant {
 } Constant;
 
 typedef struct Chunk {
+    sz id;
     Instruction *code;
 
     // Constant values that fit in 64 bits.
@@ -94,6 +95,23 @@ typedef enum OpCode {
     OP_MOV16,  // mov16  rx, ra  -> rx = ra & 0xFFFF
     OP_MOV32,  // mov32  rx, ra  -> rx = ra & 0xFFFFFFFF
     OP_MOV64,  // mov64  rx, ra  -> rx = ra & 0xFFFFFFFFFFFFFFFF
+    // Logic operations (only 64 bits for now).
+    OP_EQI,   // eqk   rx, ra, cb
+    OP_NEQI,  // neqk   rx, ra, cb
+    OP_LTI,   // ltk   rx, ra, cb
+    OP_GTI,   // gtk   rx, ra, cb
+    OP_LEI,   // lek   rx, ra, cb
+    OP_GEI,   // gek   rx, ra, cb
+    OP_ANDI,  // andk   rx, ra, cb
+    OP_ORI,   // ork    rx, ra, cb
+    OP_EQ,    // eq    rx, ra, rb
+    OP_NEQ,   // neq    rx, ra, rb
+    OP_LT,    // lt    rx, ra, rb
+    OP_GT,    // gt    rx, ra, rb
+    OP_LE,    // le    rx, ra, rb
+    OP_GE,    // ge    rx, ra, rb
+    OP_AND,   // and   rx, ra, rb
+    OP_OR,    // or    rx, ra, rb
 } OpCode;
 
 Str op_str[] = {
@@ -146,6 +164,19 @@ Str op_str[] = {
     [OP_MOV16] = cstr("MOV16   "),
     [OP_MOV32] = cstr("MOV32   "),
     [OP_MOV64] = cstr("MOV64   "),
+    // Logic operations.
+    [OP_EQI] = cstr("EQI     "),
+    [OP_NEQI] = cstr("NEQI    "),
+    [OP_LTI] = cstr("LTI     "),
+    [OP_GTI] = cstr("GTI     "),
+    [OP_LEI] = cstr("LEI     "),
+    [OP_GEI] = cstr("GEI     "),
+    [OP_EQ] = cstr("EQ      "),
+    [OP_NEQ] = cstr("NEQ     "),
+    [OP_LT] = cstr("LT      "),
+    [OP_GT] = cstr("GT      "),
+    [OP_LE] = cstr("LE      "),
+    [OP_GE] = cstr("GE      "),
 };
 
 typedef enum {
@@ -213,6 +244,14 @@ compile_binary(Chunk *chunk, Node *node) {
                 op = OP_MODF;
             }
         } break;
+        case NODE_EQ: op = OP_EQ; break;
+        case NODE_NEQ: op = OP_NEQ; break;
+        case NODE_LT: op = OP_LT; break;
+        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;
         default: break;
     }
     CompResult comp_a = compile_expr(chunk, node->left);
@@ -243,8 +282,8 @@ compile_binary(Chunk *chunk, Node *node) {
             return (CompResult){.type = COMP_ERR};
         } break;
     }
-    sz reg_dst = comp_a.idx;  // Less registers
-    // sz reg_dst = chunk->reg_idx++; // Better for optimization
+    // sz reg_dst = comp_a.idx;  // Less registers
+    sz reg_dst = chunk->reg_idx++;  // Better for optimization
     EMIT_OP(op, reg_dst, reg_a, reg_b, node, chunk);
     return (CompResult){.type = COMP_REG, .idx = reg_dst};
 }
@@ -252,6 +291,18 @@ compile_binary(Chunk *chunk, Node *node) {
 CompResult
 compile_expr(Chunk *chunk, Node *node) {
     switch (node->kind) {
+        // Logic.
+        // case NODE_NOT:
+        // case NODE_XOR:
+        case NODE_AND:
+        case NODE_OR:
+        case NODE_EQ:
+        case NODE_NEQ:
+        case NODE_LT:
+        case NODE_GT:
+        case NODE_LE:
+        // Arithmetic.
+        case NODE_GE:
         case NODE_ADD:
         case NODE_SUB:
         case NODE_MUL: