1 files changed, 35 insertions, 12 deletions

diff --git a/src/vm.c b/src/vm.c
index 3400d7a..08a9ec3 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -39,6 +39,14 @@ disassemble_instruction(Instruction instruction) {
         case OP_MULFI:
         case OP_DIVFI:
         case OP_MODFI:
+        case OP_EQI:
+        case OP_NEQI:
+        case OP_LTI:
+        case OP_GTI:
+        case OP_LEI:
+        case OP_GEI:
+        case OP_ANDI:
+        case OP_ORI:
             println("%s r%d, r%d, c%d", op_str[instruction.op], instruction.dst,
                     instruction.a, instruction.b);
             break;
@@ -60,6 +68,14 @@ disassemble_instruction(Instruction instruction) {
         case OP_MULF:
         case OP_DIVF:
         case OP_MODF:
+        case OP_EQ:
+        case OP_NEQ:
+        case OP_LT:
+        case OP_GT:
+        case OP_LE:
+        case OP_GE:
+        case OP_AND:
+        case OP_OR:
             println("%s r%d, r%d, r%d", op_str[instruction.op], instruction.dst,
                     instruction.a, instruction.b);
             break;
@@ -106,7 +122,7 @@ vm_init(VM *vm, Chunk *chunk) {
     vm->ip = vm->chunk->code;
 }
 
-#define OP_ARITHMETIC(OP, TYPE)                                            \
+#define OP_BINARY(OP, TYPE)                                                \
     do {                                                                   \
         u8 dst = instruction.dst;                                          \
         u8 src_a = instruction.a;                                          \
@@ -114,7 +130,7 @@ 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_ARITHMETIC_CONST(OP, TYPE)                                 \
+#define OP_BINARY_CONST(OP, TYPE)                                     \
     do {                                                              \
         u8 dst = instruction.dst;                                     \
         u8 src_a = instruction.a;                                     \
@@ -144,15 +160,23 @@ vm_run(VM *vm) {
                 u8 src_a = instruction.a;
                 vm->regs[dst].i = vm->chunk->constants[src_a].i;
             } break;
-            case OP_ADD: OP_ARITHMETIC(+, i) break;
-            case OP_SUB: OP_ARITHMETIC(-, i) break;
-            case OP_MUL: OP_ARITHMETIC(*, i) break;
-            case OP_DIV: OP_ARITHMETIC(/, i) break;
-            case OP_MOD: OP_ARITHMETIC(%, i) break;
-            case OP_ADDF: OP_ARITHMETIC(+, f) break;
-            case OP_SUBF: OP_ARITHMETIC(-, f) break;
-            case OP_MULF: OP_ARITHMETIC(*, f) break;
-            case OP_DIVF: OP_ARITHMETIC(/, f) break;
+            case OP_EQ: OP_BINARY(==, i) break;
+            case OP_NEQ: OP_BINARY(!=, i) break;
+            case OP_LT: OP_BINARY(<, i) break;
+            case OP_GT: OP_BINARY(>, i) break;
+            case OP_LE: OP_BINARY(<=, i) break;
+            case OP_GE: OP_BINARY(>=, i) break;
+            case OP_AND: OP_BINARY(&&, i) break;
+            case OP_OR: OP_BINARY(||, i) break;
+            case OP_ADD: OP_BINARY(+, i) break;
+            case OP_SUB: OP_BINARY(-, i) break;
+            case OP_MUL: OP_BINARY(*, i) break;
+            case OP_DIV: OP_BINARY(/, i) break;
+            case OP_MOD: OP_BINARY(%, i) break;
+            case OP_ADDF: OP_BINARY(+, f) break;
+            case OP_SUBF: OP_BINARY(-, f) break;
+            case OP_MULF: OP_BINARY(*, f) break;
+            case OP_DIVF: OP_BINARY(/, f) break;
             case OP_MODF: {
                 u8 dst = instruction.dst;
                 u8 src_a = instruction.a;
@@ -165,7 +189,6 @@ vm_run(VM *vm) {
                 println("VM HALT (float) -> %f", vm->regs[instruction.dst]);
                 return;
             }
-
             default: {
                 eprintln("unimplemented OP code: %d", instruction.op);
                 return;