Finish basic Virtual Machine

Author: heinthanth

.gitignore

@@ -1 +1,2 @@
-build/
+build/
+.vscode

includes/chunk.h

@@ -7,6 +7,11 @@
 typedef enum
 {
     OP_CONSTANT,
+    OP_ADD,
+    OP_SUBTRACT,
+    OP_MULTIPLY,
+    OP_DIVIDE,
+    OP_NEGATE,
     OP_RETURN
 } OpCode;
 

includes/common.h

@@ -5,4 +5,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#define DEBUG_TRACE_EXECUTION
+
 #endif

includes/vm.h

@@ -0,0 +1,31 @@
+#ifndef meon_vm_h
+#define meon_vm_h
+
+#include "chunk.h"
+#include "value.h"
+
+#define STACK_MAX 256
+
+typedef struct
+{
+    Chunk *chunk;
+    uint8_t *ip;
+    Value *stack;
+    int stackSize;
+    int stackMaxSize;
+} VM;
+
+typedef enum
+{
+    INTERPRET_OK,
+    INTERPRET_COMPILE_ERROR,
+    INTERPRET_RUNTIME_ERROR
+} InterpretResult;
+
+void initVM();
+void freeVM();
+InterpretResult interpret(Chunk *chunk);
+void push(Value value);
+Value pop();
+
+#endif

src/debug.c

@@ -29,7 +29,7 @@ static int simpleInstruction(const char *name, int offset)
 
 int disassembleInstruction(Chunk *chunk, int offset)
 {
-    printf("%04d ", offset);
+    printf("%04X ", offset);
     int line = getLine(chunk, offset);
     if (offset > 0 && line == getLine(chunk, offset - 1))
     {
@@ -43,10 +43,20 @@ int disassembleInstruction(Chunk *chunk, int offset)
     uint8_t instruction = chunk->code[offset];
     switch (instruction)
     {
-    case OP_RETURN:
-        return simpleInstruction("ret", offset);
     case OP_CONSTANT:
         return constantInstruction("const", chunk, offset);
+    case OP_ADD:
+        return simpleInstruction("add", offset);
+    case OP_SUBTRACT:
+        return simpleInstruction("sub", offset);
+    case OP_MULTIPLY:
+        return simpleInstruction("mul", offset);
+    case OP_DIVIDE:
+        return simpleInstruction("div", offset);
+    case OP_NEGATE:
+        return simpleInstruction("neg", offset);
+    case OP_RETURN:
+        return simpleInstruction("ret", offset);
     default:
         printf("Unknown OpCode %d\n", instruction);
         return offset + 1;

src/main.c

@@ -1,17 +1,34 @@
 #include "chunk.h"
 #include "debug.h"
+#include "vm.h"
 
 int main(int argc, char *argv[])
 {
+    initVM();
     Chunk chunk;
     initChunk(&chunk);
 
     int constant = addConstant(&chunk, 1.2);
     writeChunk(&chunk, OP_CONSTANT, 123);
     writeChunk(&chunk, constant, 123);
+
+    constant = addConstant(&chunk, 3.4);
+    writeChunk(&chunk, OP_CONSTANT, 123);
+    writeChunk(&chunk, constant, 123);
+
+    writeChunk(&chunk, OP_ADD, 123);
+
+    constant = addConstant(&chunk, 5.6);
+    writeChunk(&chunk, OP_CONSTANT, 123);
+    writeChunk(&chunk, constant, 123);
+
+    writeChunk(&chunk, OP_DIVIDE, 123);
+    writeChunk(&chunk, OP_NEGATE, 123);
     writeChunk(&chunk, OP_RETURN, 123);
 
     disassembleChunk(&chunk, "test chunk");
+    interpret(&chunk);
+    freeVM();
     freeChunk(&chunk);
     return 0;
-}
+}

src/vm.c

@@ -0,0 +1,110 @@
+#include <stdio.h>
+
+#include "common.h"
+#include "debug.h"
+#include "vm.h"
+#include "mem.h"
+
+VM vm;
+
+static void resetStack()
+{
+    vm.stackSize = 0;
+}
+
+void initVM()
+{
+    vm.stack = NULL;
+    vm.stackMaxSize = 0;
+    resetStack();
+}
+
+void freeVM() {}
+
+void push(Value value)
+{
+    if (vm.stackMaxSize < vm.stackSize + 1)
+    {
+        int old = vm.stackMaxSize;
+        vm.stackMaxSize = GROW_ARRAY_SIZE(old);
+        vm.stack = GROW_ARRAY(Value, vm.stack, old, vm.stackMaxSize);
+    }
+    vm.stack[vm.stackSize] = value;
+    vm.stackSize++;
+}
+
+Value pop()
+{
+    vm.stackSize--;
+    return vm.stack[vm.stackSize];
+}
+
+static InterpretResult run()
+{
+#define READ_BYTE() (*vm.ip++)
+#define READ_CONSTANT() (vm.chunk->constants.values[READ_BYTE()])
+
+#define BINARY_OP(op)     \
+    do                    \
+    {                     \
+        double b = pop(); \
+        double a = pop(); \
+        push(a op b);     \
+    } while (false)
+
+    for (;;)
+    {
+#ifdef DEBUG_TRACE_EXECUTION
+        printf("          ");
+        for (int i = 0; i < vm.stackSize; i++)
+        {
+            printf("[ ");
+            printValue(vm.stack[i]);
+            printf(" ]");
+        }
+        printf("\n");
+        disassembleInstruction(vm.chunk, (int)(vm.ip - vm.chunk->code));
+#endif
+
+        uint8_t instruction;
+        switch (instruction = READ_BYTE())
+        {
+        case OP_CONSTANT:
+        {
+            Value constant = READ_CONSTANT();
+            push(constant);
+            break;
+        }
+        case OP_ADD:
+            BINARY_OP(+);
+            break;
+        case OP_SUBTRACT:
+            BINARY_OP(-);
+            break;
+        case OP_MULTIPLY:
+            BINARY_OP(*);
+            break;
+        case OP_DIVIDE:
+            BINARY_OP(/);
+            break;
+        case OP_NEGATE:
+            push(-pop());
+            break;
+        case OP_RETURN:
+        {
+            printValue(pop());
+            printf("\n");
+            return INTERPRET_OK;
+        }
+        }
+    }
+#undef READ_BYTE
+#undef READ_CONSTANT
+}
+
+InterpretResult interpret(Chunk *chunk)
+{
+    vm.chunk = chunk;
+    vm.ip = vm.chunk->code;
+    return run();
+}