Add bitwise operations

2 files changed, 74 insertions, 2 deletions

diff --git a/src/compiler.c b/src/compiler.c
index a251a90..e303cee 100644
--- a/src/compiler.c
+++ b/src/compiler.c
@@ -114,6 +114,17 @@ typedef enum OpCode {
     OP_AND,   // and   rx, ra, rb
     OP_OR,    // or    rx, ra, rb
     OP_NOT,   // not   rx, ra
+    // Bitwise operations.
+    OP_BITLSHIFTI,  // shli   rx, ra, cb
+    OP_BITRSHIFTI,  // shri   rx, ra, cb
+    OP_BITANDI,     // bandi  rx, ra, cb
+    OP_BITORI,      // bori   rx, ra, cb
+    OP_BITNOTI,     // bnoti  rx, ca
+    OP_BITLSHIFT,   // shl    rx, ra, rb
+    OP_BITRSHIFT,   // shr    rx, ra, rb
+    OP_BITAND,      // band   rx, ra, rb
+    OP_BITOR,       // bor    rx, ra, rb
+    OP_BITNOT,      // bnot   rx, ra
 } OpCode;
 
 Str op_str[] = {
@@ -185,6 +196,17 @@ Str op_str[] = {
     [OP_AND] = cstr("AND     "),
     [OP_OR] = cstr("OR      "),
     [OP_NOT] = cstr("NOT     "),
+    // Bitwise operations.
+    [OP_BITLSHIFTI] = cstr("LSHI    "),
+    [OP_BITRSHIFTI] = cstr("RSHI    "),
+    [OP_BITANDI] = cstr("BANDI   "),
+    [OP_BITORI] = cstr("BORI    "),
+    [OP_BITNOTI] = cstr("BNOTI   "),
+    [OP_BITLSHIFT] = cstr("LSH     "),
+    [OP_BITRSHIFT] = cstr("RSH     "),
+    [OP_BITAND] = cstr("BAND    "),
+    [OP_BITOR] = cstr("BOR     "),
+    [OP_BITNOT] = cstr("BNOT    "),
 };
 
 typedef enum {
@@ -218,6 +240,7 @@ compile_binary(Chunk *chunk, Node *node) {
     OpCode opi = OP_HALT;
     OpCode ldop = OP_LD64K;
     switch (node->kind) {
+        // Arithmetic.
         case NODE_ADD: {
             if (str_eq(node->type, cstr("int"))) {
                 op = OP_ADD;
@@ -263,6 +286,7 @@ compile_binary(Chunk *chunk, Node *node) {
                 opi = OP_MODFI;
             }
         } break;
+        // Logic.
         case NODE_EQ: {
             op = OP_EQ;
             opi = OP_EQI;
@@ -295,6 +319,23 @@ compile_binary(Chunk *chunk, Node *node) {
             op = OP_OR;
             opi = OP_ORI;
         } break;
+        // Bitwise.
+        case NODE_BITOR: {
+            op = OP_BITOR;
+            opi = OP_BITORI;
+        } break;
+        case NODE_BITAND: {
+            op = OP_BITAND;
+            opi = OP_BITANDI;
+        } break;
+        case NODE_BITLSHIFT: {
+            op = OP_BITLSHIFT;
+            opi = OP_BITLSHIFTI;
+        } break;
+        case NODE_BITRSHIFT: {
+            op = OP_BITRSHIFT;
+            opi = OP_BITRSHIFTI;
+        } break;
         default: break;
     }
     CompResult comp_a = compile_expr(chunk, node->left);
@@ -334,12 +375,15 @@ CompResult
 compile_unary(Chunk *chunk, Node *node) {
     OpCode op = OP_HALT;
     OpCode opi = OP_HALT;
-    OpCode ldop = OP_LD64K;
     switch (node->kind) {
         case NODE_NOT: {
             op = OP_NOT;
             opi = OP_NOTI;
         } break;
+        case NODE_BITNOT: {
+            op = OP_BITNOT;
+            opi = OP_BITNOTI;
+        } break;
         default: break;
     }
     CompResult comp_a = compile_expr(chunk, node->left);
@@ -366,6 +410,7 @@ compile_expr(Chunk *chunk, Node *node) {
     switch (node->kind) {
         // Logic.
         // case NODE_XOR:
+        case NODE_BITNOT:
         case NODE_NOT: return compile_unary(chunk, node); break;
         case NODE_AND:
         case NODE_OR:
@@ -374,6 +419,11 @@ compile_expr(Chunk *chunk, Node *node) {
         case NODE_LT:
         case NODE_GT:
         case NODE_LE:
+        // Bitwise ops.
+        case NODE_BITAND:
+        case NODE_BITOR:
+        case NODE_BITLSHIFT:
+        case NODE_BITRSHIFT:
         // Arithmetic.
         case NODE_GE:
         case NODE_ADD:
@@ -384,6 +434,7 @@ compile_expr(Chunk *chunk, Node *node) {
         case NODE_TRUE:
         case NODE_FALSE:
         case NODE_NUM_FLOAT:
+        case NODE_NUM_UINT:
         case NODE_NUM_INT: {
             sz value = node->value.i;
             // Make sure we don't have duplicated constants.
diff --git a/src/vm.c b/src/vm.c
index 644a682..2771d07 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -47,6 +47,10 @@ disassemble_instruction(Instruction instruction) {
         case OP_GEI:
         case OP_ANDI:
         case OP_ORI:
+        case OP_BITLSHIFTI:
+        case OP_BITRSHIFTI:
+        case OP_BITANDI:
+        case OP_BITORI:
             println("%s r%d, r%d, c%d", op_str[instruction.op], instruction.dst,
                     instruction.a, instruction.b);
             break;
@@ -76,13 +80,19 @@ disassemble_instruction(Instruction instruction) {
         case OP_GE:
         case OP_AND:
         case OP_OR:
+        case OP_BITLSHIFT:
+        case OP_BITRSHIFT:
+        case OP_BITAND:
+        case OP_BITOR:
             println("%s r%d, r%d, r%d", op_str[instruction.op], instruction.dst,
                     instruction.a, instruction.b);
             break;
+        case OP_BITNOTI:
         case OP_NOTI:
             println("%s r%d, c%d", op_str[instruction.op], instruction.dst,
                     instruction.a, instruction.b);
             break;
+        case OP_BITNOT:
         case OP_NOT:
             println("%s r%d, r%d", op_str[instruction.op], instruction.dst,
                     instruction.a, instruction.b);
@@ -183,6 +193,11 @@ vm_run(VM *vm) {
                 vm->regs[dst].i = vm->chunk->constants[src_a].i;
             } break;
             case OP_NOT: OP_UNARY(!, i) break;
+            case OP_BITNOT: OP_UNARY(~, i) break;
+            case OP_BITOR: OP_BINARY(|, i) break;
+            case OP_BITAND: OP_BINARY(&, i) break;
+            case OP_BITLSHIFT: OP_BINARY(<<, i) break;
+            case OP_BITRSHIFT: OP_BINARY(>>, i) break;
             case OP_EQ: OP_BINARY(==, i) break;
             case OP_NEQ: OP_BINARY(!=, i) break;
             case OP_LT: OP_BINARY(<, i) break;
@@ -208,6 +223,11 @@ vm_run(VM *vm) {
                     fmod(vm->regs[src_a].f, vm->chunk->constants[src_b].f);
             } break;
             case OP_NOTI: OP_UNARY_CONST(!, i) break;
+            case OP_BITNOTI: OP_UNARY_CONST(~, i) break;
+            case OP_BITORI: OP_BINARY_CONST(|, i) break;
+            case OP_BITANDI: OP_BINARY_CONST(&, i) break;
+            case OP_BITLSHIFTI: OP_BINARY_CONST(<<, i) break;
+            case OP_BITRSHIFTI: OP_BINARY_CONST(>>, i) break;
             case OP_EQI: OP_BINARY_CONST(==, i) break;
             case OP_NEQI: OP_BINARY_CONST(!=, i) break;
             case OP_LTI: OP_BINARY_CONST(<, i) break;
@@ -233,8 +253,9 @@ vm_run(VM *vm) {
                     fmod(vm->regs[src_a].f, vm->chunk->constants[src_b].f);
             } break;
             case OP_HALT: {
-                println("VM HALT (int) -> %d", vm->regs[instruction.dst]);
+                println("VM HALT (int)   -> %d", vm->regs[instruction.dst]);
                 println("VM HALT (float) -> %f", vm->regs[instruction.dst]);
+                println("VM HALT (hex)   -> %x", vm->regs[instruction.dst]);
                 return;
             }
             default: {