basic VM working

vm.c

@@ -0,0 +1,204 @@
+#include "parser.h"
+#include <string.h>
+
+typedef enum {
+  OP_PUSH_INT,
+  OP_PUSH_FLOAT,
+  OP_PUSH_STRING,
+  OP_ADD,
+  OP_SUB,
+  OP_MUL,
+  OP_DIV,
+  OP_PRINT,
+  OP_HALT
+} OPcode;
+
+typedef struct {
+  OPcode op;
+  double num;
+  char *strlit;
+} instruct;
+
+typedef enum {
+    VAL_INT,
+    VAL_FLOAT,
+    VAL_STRING,
+} ValueType;
+
+typedef struct {
+    ValueType type;
+    union {
+        long i;
+        double f;
+        char *s;
+    };
+} Value;
+
+typedef struct {
+  instruct *program;
+  size_t inst_p;
+  size_t program_size;
+  Value stack[256];
+  size_t st_p;
+  bool running;
+} VM;
+
+instruct *rpn_to_bytecode(Token *rpn, size_t *out){
+  size_t cap = 64;
+  size_t size = 0;
+
+  instruct *prog = malloc(sizeof(instruct) * cap);
+
+  for (size_t i=0; i<rpn->size; ++i){
+    symbols t = rpn->type[i];
+    const char *text = rpn->text[i];
+
+    instruct ins = {0};
+
+    switch (t){
+      case TOKEN_INTEGER: ins.op = OP_PUSH_INT; ins.num = atof(text); break;
+      case TOKEN_FLOAT: ins.op = OP_PUSH_FLOAT; ins.num = atof(text); break;
+      case TOKEN_STRING: ins.op = OP_PUSH_STRING; ins.strlit = strdup(text); break;
+      case TOKEN_PLUS: ins.op = OP_ADD; break;
+      case TOKEN_MINUS: ins.op = OP_SUB; break;
+      case TOKEN_MUL: ins.op = OP_MUL; break;
+      case TOKEN_DIV: ins.op = OP_DIV; break;
+
+      case TOKEN_IDENTIFIER:
+        if (strcmp(text, "print") == 0) {
+            ins.op = OP_PRINT;
+        } else {
+            printf("[WARNING] Uknown Identifier '%s'\n", text);
+        }
+        break; //TODO: unhardcode this
+      case TOKEN_EOF: ins.op = OP_HALT; break;
+      default: continue;
+    }
+    if (size >= cap){
+      cap*=2;
+      prog = realloc(prog, sizeof(instruct)*cap);
+    }
+    prog[size++] = ins;
+  }
+  *out = size;
+  return prog;
+}
+
+void vm_run(VM *vm) {
+    vm->running = true;
+    vm->inst_p = 0;
+    vm->st_p = 0;
+
+    while (vm->running && vm->inst_p < vm->program_size) {
+        instruct ins = vm->program[vm->inst_p++];
+
+        switch (ins.op) {
+        case OP_PUSH_INT: {
+            Value v = { .type = VAL_INT, .i = ins.num };
+            vm->stack[vm->st_p++] = v;
+        } break;
+
+        case OP_PUSH_FLOAT: {
+            Value v = { .type = VAL_FLOAT, .f = ins.num };
+            vm->stack[vm->st_p++] = v;
+        } break;
+
+        case OP_PUSH_STRING: {
+            Value v = { .type = VAL_STRING, .s = strdup(ins.strlit) };
+            vm->stack[vm->st_p++] = v;
+        } break;
+
+        case OP_ADD:
+        case OP_SUB:
+        case OP_MUL:
+        case OP_DIV: {
+            if (vm->st_p < 2) {
+                fprintf(stderr, "not enough values on stack.\n");
+                vm->running = false;
+                break;
+            }
+
+            Value b = vm->stack[--vm->st_p];
+            Value a = vm->stack[--vm->st_p];
+
+            double av = (a.type == VAL_INT) ? a.i : a.f;
+            double bv = (b.type == VAL_INT) ? b.i : b.f;
+            double result = 0;
+
+            switch (ins.op) {
+            case OP_ADD: result = av + bv; break;
+            case OP_SUB: result = av - bv; break;
+            case OP_MUL: result = av * bv; break;
+            case OP_DIV:
+                if (bv == 0) {
+                    fprintf(stderr, "division by zero.\n");
+                    vm->running = false;
+                } else result = av / bv;
+                break;
+            default: break;
+            }
+
+            Value v = { .type = VAL_FLOAT, .f = result };
+            vm->stack[vm->st_p++] = v;
+        } break;
+
+        case OP_PRINT: {
+            if (vm->st_p == 0) {
+                fprintf(stderr, "cant print an empty stack\n");
+                vm->running = false;
+                break;
+            }
+
+            Value v = vm->stack[--vm->st_p];
+            switch (v.type) {
+            case VAL_INT:   printf("%ld\n", v.i); break;
+            case VAL_FLOAT: printf("%g\n", v.f); break;
+            case VAL_STRING:
+                printf("%s\n", v.s);
+                free(v.s);
+                break;
+            }
+        } break;
+
+        case OP_HALT:
+            vm->running = false;
+            break;
+
+        default:
+            fprintf(stderr, "unknown opcode %d\n", ins.op);
+            vm->running = false;
+            break;
+        }
+    }
+}
+
+int main(int argc, char **argv) {
+    if (argc < 2) {
+        fprintf(stderr, "Usage: %s <source file>\n", argv[0]);
+        return 1;
+    }
+
+    char* read = nb_read_file(argv[1]);
+    //printf("INPUT: %s\n", read);
+
+    Token tk = tokenize_all(read);
+    SymbolTable table = {0};
+    symbol_table_init(&table, 32);
+
+    Token rpn = build_rpn(&tk, &table);
+    //print_token(&rpn);
+
+    size_t prog_size = 0;
+    instruct *prog = rpn_to_bytecode(&rpn, &prog_size);
+    VM vm = {
+        .program = prog,
+        .program_size = prog_size,
+        .inst_p = 0,
+        .st_p = 0,
+        .running = true,
+    };
+
+    vm_run(&vm);
+
+    return 0;
+}