Generalize binary compilation expression

3 files changed, 67 insertions, 25 deletions

diff --git a/src/compiler.c b/src/compiler.c
index d1e8a74..bc875fd 100644
--- a/src/compiler.c
+++ b/src/compiler.c
@@ -45,7 +45,7 @@ typedef enum OpCode {
     //            OP    DST   A   B
     // ---------------------------------------------------------------
     // VM/high level instructions.
-    OP_HALT,   // halt
+    OP_HALT,  // halt
     // Load/Store instructions.
     OP_LD8K,   // ld8k   rx, ca      -> u8  rx = ca
     OP_LD16K,  // ld16k  rx, ca      -> u16 rx = ca
@@ -68,16 +68,16 @@ typedef enum OpCode {
     OP_ST32,   // st32   rx, ra, rb  -> u32 *p; p[ra + rb] = rx
     OP_ST64,   // st64   rx, ra, rb  -> u64 *p; p[ra + rb] = rx
     // Integer arithmetic (only int/s64 for now).
-    OP_ADDI,   // addk   rx, ra, cb
-    OP_SUBI,   // subk   rx, ra, cb
-    OP_MULI,   // mulk   rx, ra, cb
-    OP_DIVI,   // divk   rx, ra, cb
-    OP_MODI,   // modk   rx, ra, cb
-    OP_ADD,    // add    rx, ra, rb
-    OP_SUB,    // sub    rx, ra, rb
-    OP_MUL,    // mul    rx, ra, rb
-    OP_DIV,    // div    rx, ra, rb
-    OP_MOD,    // mod    rx, ra, rb
+    OP_ADDI,  // addk   rx, ra, cb
+    OP_SUBI,  // subk   rx, ra, cb
+    OP_MULI,  // mulk   rx, ra, cb
+    OP_DIVI,  // divk   rx, ra, cb
+    OP_MODI,  // modk   rx, ra, cb
+    OP_ADD,   // add    rx, ra, rb
+    OP_SUB,   // sub    rx, ra, rb
+    OP_MUL,   // mul    rx, ra, rb
+    OP_DIV,   // div    rx, ra, rb
+    OP_MOD,   // mod    rx, ra, rb
     // Floating point arithmetic (only f64 for now).
     OP_ADDFI,  // addfk  rx, ra, cb
     OP_SUBFI,  // subfk  rx, ra, cb
@@ -174,7 +174,47 @@ CompResult compile_expr(Chunk *chunk, Node *node);
     } while (0)
 
 CompResult
-compile_binary(OpCode op, Chunk *chunk, Node *node) {
+compile_binary(Chunk *chunk, Node *node) {
+    OpCode op = OP_HALT;
+    OpCode ldop = OP_LD64K;
+    switch (node->kind) {
+        case NODE_ADD: {
+            if (str_eq(node->type, cstr("int"))) {
+                op = OP_ADD;
+            } else if (str_eq(node->type, cstr("f64"))) {
+                op = OP_ADDF;
+            }
+        } break;
+        case NODE_SUB: {
+            if (str_eq(node->type, cstr("int"))) {
+                op = OP_SUB;
+            } else if (str_eq(node->type, cstr("f64"))) {
+                op = OP_SUBF;
+            }
+        } break;
+        case NODE_MUL: {
+            if (str_eq(node->type, cstr("int"))) {
+                op = OP_MUL;
+            } else if (str_eq(node->type, cstr("f64"))) {
+                op = OP_MULF;
+            }
+        } break;
+        case NODE_DIV: {
+            if (str_eq(node->type, cstr("int"))) {
+                op = OP_DIV;
+            } else if (str_eq(node->type, cstr("f64"))) {
+                op = OP_DIVF;
+            }
+        } break;
+        case NODE_MOD: {
+            if (str_eq(node->type, cstr("int"))) {
+                op = OP_MOD;
+            } else if (str_eq(node->type, cstr("f64"))) {
+                op = OP_MODF;
+            }
+        } break;
+        default: break;
+    }
     CompResult comp_a = compile_expr(chunk, node->left);
     CompResult comp_b = compile_expr(chunk, node->right);
     sz reg_a;
@@ -182,7 +222,7 @@ compile_binary(OpCode op, Chunk *chunk, Node *node) {
     switch (comp_a.type) {
         case COMP_CONST: {
             reg_a = chunk->reg_idx++;
-            EMIT_OP(OP_LD64K, reg_a, comp_a.idx, 0, node, chunk);
+            EMIT_OP(ldop, reg_a, comp_a.idx, 0, node, chunk);
         } break;
         case COMP_REG: {
             reg_a = comp_a.idx;
@@ -194,7 +234,7 @@ compile_binary(OpCode op, Chunk *chunk, Node *node) {
     switch (comp_b.type) {
         case COMP_CONST: {
             reg_b = chunk->reg_idx++;
-            EMIT_OP(OP_LD64K, reg_b, comp_b.idx, 0, node, chunk);
+            EMIT_OP(ldop, reg_b, comp_b.idx, 0, node, chunk);
         } break;
         case COMP_REG: {
             reg_b = comp_b.idx;
@@ -212,11 +252,11 @@ compile_binary(OpCode op, Chunk *chunk, Node *node) {
 CompResult
 compile_expr(Chunk *chunk, Node *node) {
     switch (node->kind) {
-        case NODE_ADD: return compile_binary(OP_ADD, chunk, node); break;
-        case NODE_SUB: return compile_binary(OP_SUB, chunk, node); break;
-        case NODE_MUL: return compile_binary(OP_MUL, chunk, node); break;
-        case NODE_DIV: return compile_binary(OP_DIV, chunk, node); break;
-        case NODE_MOD: return compile_binary(OP_MOD, chunk, node); break;
+        case NODE_ADD:
+        case NODE_SUB:
+        case NODE_MUL:
+        case NODE_DIV:
+        case NODE_MOD: return compile_binary(chunk, node); break;
         case NODE_TRUE:
         case NODE_FALSE:
         case NODE_NUM_FLOAT:
diff --git a/src/vm.c b/src/vm.c
index 8d4e67e..3400d7a 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -161,7 +161,8 @@ vm_run(VM *vm) {
                     fmod(vm->regs[src_a].f, vm->chunk->constants[src_b].f);
             } break;
             case OP_HALT: {
-                println("VM HALT -> %d", vm->regs[instruction.dst]);
+                println("VM HALT (int) -> %d", vm->regs[instruction.dst]);
+                println("VM HALT (float) -> %f", vm->regs[instruction.dst]);
                 return;
             }
 
diff --git a/tests/compilation.bad b/tests/compilation.bad
index 782e75f..6fc5662 100644
--- a/tests/compilation.bad
+++ b/tests/compilation.bad
@@ -1,9 +1,10 @@
 1 + 2 * 3
-true
-false
-0 1
-"hello"
-"world"
+1.0 + 2.0 * 3.0
+; true
+; false
+; 0 1
+; "hello"
+; "world"
 ; fun foo(): int {
 ;     32
 ; }