basic VM working

builder.c

@@ -8,12 +8,12 @@ int main(int argc, char **argv){
 
   nb_append(&cmd, "gcc");
   nb_append(&cmd, "-Wall -Wextra");
-  nb_append(&cmd, "lexer.c");
-  nb_append(&cmd, "-o lex");
+  nb_append(&cmd, "vm.c");
+  nb_append(&cmd, "-o vm");
   nb_cmd(&cmd); 
 
 
-  nb_append(&cmd, "./lex");
+  nb_append(&cmd, "./vm");
   for (int i=1; i<argc; ++i){
     nb_append(&cmd, argv[i]);
   }

lexer.h

@@ -22,7 +22,11 @@ typedef enum {
   TOKEN_NEWLINE,
   TOKEN_LPAREN,
   TOKEN_RPAREN,
-  TOKEN_COMMA
+  TOKEN_COMMA,
+  TOKEN_LCURLY,
+  TOKEN_RCURLY,
+  TOKEN_COLON,
+  TOKEN_SEMI
 } symbols;
 
 typedef enum {
@@ -52,6 +56,10 @@ char *token_type_to_string(symbols type) {
     case TOKEN_EOF: return "TOKEN_EOF";
     case TOKEN_NEWLINE: return "TOKEN_NEWLINE";
     case TOKEN_IDENTIFIER: return "TOKEN_IDENTIFIER";
+    case TOKEN_LCURLY: return "TOKEN_LCURLY";
+    case TOKEN_RCURLY: return "TOKEN_RCURLY";
+    case TOKEN_SEMI: return "TOKEN_SEMI";
+    case TOKEN_COLON: return "TOKEN_COLON";
     case TOKEN_UNKNOWN: return "TOKEN_UNKNOWN";
     // default: return "UNKNOWN_SYMBOL";
   }
@@ -141,61 +149,90 @@ int str_to_int(char *strint) { return atoi(strint); }
 float str_to_float(char *strif) { return strtof(strif, NULL); }
 
 
+
 size_t read_from_tok(Token *tok, const char *input, size_t cursor) {
   char buf[64];
   size_t start = cursor;
   size_t i = 0;
 
-  if (isdigit(input[cursor])) {
+  if (isdigit((unsigned char)input[cursor])) {
     int dots_seen = 0;
-    // dont allow for 3.3.3 (example)
-    while (isdigit(input[cursor]) || input[cursor] == '.') {
+    while (isdigit((unsigned char)input[cursor]) || input[cursor] == '.') {
       if (input[cursor] == '.') dots_seen++;
       buf[i++] = input[cursor++];
+      if (i >= sizeof(buf) - 1) break;
     }
     buf[i] = '\0';
-    if (dots_seen == 0) {
-      token_push(tok, TOKEN_INTEGER, buf, BHV_NUMBER, cursor - start);
-    } else {
-      token_push(tok, TOKEN_FLOAT, buf, BHV_FLOAT, cursor - start);
+    token_push(tok, dots_seen == 0 ? TOKEN_INTEGER : TOKEN_FLOAT,
+               buf, dots_seen == 0 ? BHV_NUMBER : BHV_FLOAT,
+               cursor - start);
+    return cursor - start; // all digits handled
   }
-  }  else if (input[cursor] == '"'){
-      cursor++;
+
+  else if (input[cursor] == '"') {
+    cursor++; // skip opening quote
     while (input[cursor] != '"' && input[cursor] != '\0') {
       buf[i++] = input[cursor++];
       if (i >= sizeof(buf) - 1) break;
     }
     buf[i] = '\0';
-    if (input[cursor] == '"') cursor ++;
+    if (input[cursor] == '"') cursor++; // skip closing quote
     token_push(tok, TOKEN_STRING, buf, BHV_STRING, cursor - start);
-  } else if (isalpha(input[cursor])) { // should be after checking for strlit
-    while (isalpha(input[cursor])) {
+    return cursor - start;
+  }
+
+  else if (isalpha((unsigned char)input[cursor])) {
+    while (isalpha((unsigned char)input[cursor])) {
       buf[i++] = input[cursor++];
+      if (i >= sizeof(buf) - 1) break;
     }
     buf[i] = '\0';
     token_push(tok, TOKEN_IDENTIFIER, buf, BHV_IDENT, cursor - start);
-    //refactor into separate function to use in parsing functions and definitions  
-  } else {
-      buf[0] = input[cursor];
-      buf[1] = '\0';
+    return cursor - start;
+  }
+
+  // Single-character tokens and symbols
   switch (input[cursor]) {
     case '+': token_push(tok, TOKEN_PLUS, "+", BHV_STACK, 1); break;
     case '-': token_push(tok, TOKEN_MINUS, "-", BHV_STACK, 1); break;
     case '*': token_push(tok, TOKEN_MUL, "*", BHV_STACK, 1); break;
     case '/': token_push(tok, TOKEN_DIV, "/", BHV_STACK, 1); break;
-        case ' ': token_push(tok, TOKEN_SPACE, " ", BHV_UNDEFINED, 1); break;
-        case '\n': token_push(tok, TOKEN_NEWLINE, "\\n", BHV_UNDEFINED, 1); break;
-        case '(': token_push(tok, TOKEN_LPAREN, "(", BHV_STACK, 1); break;
-        case ')': token_push(tok, TOKEN_RPAREN, ")", BHV_STACK, 1); break;
-        case ',': token_push(tok, TOKEN_COMMA, ",", BHV_STACK, 1); break;
-        default: token_push(tok, TOKEN_UNKNOWN, buf, BHV_UNDEFINED, 1); break;
+    case '{': token_push(tok, TOKEN_LCURLY, "{", BHV_STACK, 1); break;
+    case '}': token_push(tok, TOKEN_RCURLY, "}", BHV_STACK, 1); break;
+    case ';': token_push(tok, TOKEN_SEMI, ";", BHV_STACK, 1); break;
+    case ':': token_push(tok, TOKEN_COLON, ":", BHV_STACK, 1); break;
+
+    case '(':
+      token_push(tok, TOKEN_LPAREN, "(", BHV_STACK, 1);
+      break;
+    case ')':
+      token_push(tok, TOKEN_RPAREN, ")", BHV_STACK, 1);
+      break;
+    case ',':
+      token_push(tok, TOKEN_COMMA, ",", BHV_STACK, 1);
+      break;
+    case ' ':
+      // you can skip space tokens if you don't need them
+      token_push(tok, TOKEN_SPACE, " ", BHV_UNDEFINED, 1);
+      break;
+    case '\n':
+      token_push(tok, TOKEN_NEWLINE, "\\n", BHV_UNDEFINED, 1);
+      break;
+    case '\0':
+      return 0; // end of input
+    default: {
+      buf[0] = input[cursor];
+      buf[1] = '\0';
+      token_push(tok, TOKEN_UNKNOWN, buf, BHV_UNDEFINED, 1);
+      break;
     }
-    cursor++;
   }
 
+  cursor++; // move forward exactly one char for symbol cases
   return cursor - start;
 }
 
+
 Token tokenize_all(const char *input) {
   Token tok;
   token_init(&tok, 8);

parser.h

@@ -0,0 +1,219 @@
+#include "./lexer.h"
+#define NB_IMPLEMENTATION
+#include "./nb.h"
+
+int get_prec(symbols op){
+  switch (op) {
+    case TOKEN_MUL:
+    case TOKEN_DIV:
+       return 2; break;
+    case TOKEN_PLUS:
+    case TOKEN_MINUS:
+      return 1; break;
+    default: return 0;
+  }
+}
+// parse
+
+bool is_left_asc(symbols op){
+  switch (op) {
+    case TOKEN_MUL:
+    case TOKEN_DIV:
+    case TOKEN_PLUS:
+    case TOKEN_MINUS:
+      return true; break;
+    default: return false;
+  }
+}
+
+Token *global_tok = NULL;
+
+typedef enum {
+  SYM_VAR,
+  SYM_FUNC,
+} SymbolKind;
+
+typedef struct {
+  const char* name;
+  size_t ret_count;
+  size_t arg_count;
+  symbols arg_types[16];
+  symbols ret_type;
+  SymbolKind symbol_kind;
+  bool builtin;
+} Symbol;
+
+
+static Symbol builtins[] = {
+    { "print", 1, 1, { TOKEN_UNKNOWN }, TOKEN_EOF, SYM_FUNC, true },
+};
+
+
+typedef struct {
+  Symbol *symbols;
+  size_t size;
+  size_t capacity;
+} SymbolTable; 
+
+
+static int builtin_num = sizeof(builtins)/sizeof(builtins[0]);
+
+static SymbolTable global_env = {
+  .size = sizeof(builtins)/sizeof(builtins[0]),
+  .capacity = sizeof(builtins)/sizeof(builtins[0]),
+  .symbols = builtins};
+
+
+Symbol *symbol_lookup(SymbolTable *table, const char *n){
+  for (size_t i=0; i<table->size; ++i){
+    if(strcmp(n, table->symbols[i].name) == 0){
+      return &table->symbols[i];
+    }
+  }
+  return NULL;
+}
+
+// fn add(x: int, y: int) int {
+//   return x+y;
+// }
+
+
+void symbol_table_init(SymbolTable *table, size_t initial_capacity) {
+    table->symbols = malloc(sizeof(Symbol) * initial_capacity);
+    if (!table->symbols) {
+        fprintf(stderr, "symbol_table_init: malloc failed\n");
+        exit(1);
+    }
+    table->size = 0;
+    table->capacity = initial_capacity;
+}
+
+void symbol_table_add(SymbolTable *table, Symbol sym) {
+    if (table->size >= table->capacity) {
+        table->capacity = (table->capacity == 0) ? 8 : table->capacity * 2;
+        table->symbols = realloc(table->symbols, sizeof(Symbol) * table->capacity);
+        if (!table->symbols) {
+            fprintf(stderr, "symbol_table_add: realloc failed\n");
+            exit(1);
+        }
+    }
+    table->symbols[table->size++] = sym;
+}
+
+
+void symbol_table_free(SymbolTable *table) {
+    free(table->symbols);
+    table->symbols = NULL;
+    table->size = 0;
+    table->capacity = 0;
+}
+
+
+Token build_rpn(Token *inp, SymbolTable *symtab) {
+    Token output;
+    Token stack;
+
+    token_init(&output, 16);
+    token_init(&stack, 16);
+
+    for (size_t i = 0; i < inp->size; ++i) {
+        symbols type = inp->type[i];
+        const char *text = inp->text[i];
+
+        if (type == TOKEN_IDENTIFIER && i + 1 < inp->size && inp->type[i + 1] == TOKEN_LPAREN) {
+            Symbol *found = symbol_lookup(symtab, text);
+            if (!found) {
+                Symbol sym = {
+                    .name = strdup(text),
+                    .arg_count = 0,
+                    .ret_type = TOKEN_EOF,
+                    .symbol_kind = SYM_FUNC,
+                    .builtin = false
+                };
+                symbol_table_add(symtab, sym);
+            }
+            token_push(&stack, type, text, inp->behaviour[i], 0);
+        } else if (type == TOKEN_IDENTIFIER) {
+            Symbol *found = symbol_lookup(symtab, text);
+            if (!found) {
+                Symbol sym = {
+                    .name = strdup(text),
+                    .arg_count = 0,
+                    .ret_type = TOKEN_UNKNOWN,
+                    .symbol_kind = SYM_VAR,
+                    .builtin = false
+                };
+                symbol_table_add(symtab, sym);
+            }
+            token_push(&output, type, text, inp->behaviour[i], 0);
+        } else if (type == TOKEN_LPAREN) {
+            token_push(&stack, type, text, inp->behaviour[i], 0);
+        } else if (type == TOKEN_RPAREN) {
+            while (stack.size > 0 && stack.type[stack.size - 1] != TOKEN_LPAREN) {
+                token_push(&output, stack.type[stack.size - 1],
+                           stack.text[stack.size - 1],
+                           stack.behaviour[stack.size - 1], 0);
+                stack.size--;
+            }
+            if (stack.size > 0 && stack.type[stack.size - 1] == TOKEN_LPAREN)
+                stack.size--;
+            if (stack.size > 0 && stack.type[stack.size - 1] == TOKEN_IDENTIFIER) {
+                token_push(&output, stack.type[stack.size - 1],
+                           stack.text[stack.size - 1],
+                           stack.behaviour[stack.size - 1], 0);
+                stack.size--;
+            }
+        } else if (type == TOKEN_INTEGER || type == TOKEN_FLOAT || type == TOKEN_STRING) {
+            token_push(&output, type, text, inp->behaviour[i], 0);
+        } else if (is_left_asc(type)) {
+            while (stack.size > 0 && stack.type[stack.size - 1] != TOKEN_LPAREN &&
+                   (get_prec(stack.type[stack.size - 1]) > get_prec(type) ||
+                    get_prec(stack.type[stack.size - 1]) == get_prec(type)) &&
+                   is_left_asc(type)) {
+                token_push(&output, stack.type[stack.size - 1],
+                           stack.text[stack.size - 1],
+                           stack.behaviour[stack.size - 1], 0);
+                stack.size--;
+            }
+            token_push(&stack, type, text, inp->behaviour[i], 0);
+        }
+    }
+
+    while (stack.size > 0) {
+        token_push(&output, stack.type[stack.size - 1],
+                   stack.text[stack.size - 1],
+                   stack.behaviour[stack.size - 1], 0);
+        stack.size--;
+    }
+
+    token_push(&output, TOKEN_EOF, "EOF", BHV_UNDEFINED, 0);
+    return output;
+}
+
+void print_token(Token *tk){
+  for (size_t i=0; i<tk->size; ++i){
+    printf("TokenNum: %zu Type: %s Value: %s\n", i, tk->tktype[i], tk->text[i]);
+  }
+}
+
+
+
+
+// int main(int argc, char **argv){
+//   if (argc < 2) return -1;
+//   const char ts[] = "\"hello\" hi + 2 2.312"; 
+//   const char math[] = "print(((1+2)*6)/18)"; // = 1
+//   const char print[] = "print(\"hello\")";
+//   const char simple[] = "1 + (  3 + 3  )/4+4*3";
+  
+
+//   char* read = nb_read_file(argv[1]);
+//   Token tk = tokenize_all(read);
+//   printf("INPUT: %s\n", read);
+//   SymbolTable table = {0};
+//   symbol_table_init(&table, 32);
+
+
+//   Token rpn = build_rpn(&tk, &table);
+//   print_token(&rpn); 
+// }

parser3.c

@@ -1,4 +1,6 @@
 #include "./lexer.h"
+#define NB_IMPLEMENTATION
+#include "./nb.h"
 
 int get_prec(symbols op){
   switch (op) {
@@ -24,18 +26,194 @@ bool is_left_asc(symbols op){
   }
 }
 
-void build_rpn();
+Token *global_tok = NULL;
+
+typedef enum {
+  SYM_VAR,
+  SYM_FUNC,
+} SymbolKind;
+
+typedef struct {
+  const char* name;
+  size_t ret_count;
+  size_t arg_count;
+  symbols arg_types[16];
+  symbols ret_type;
+  SymbolKind symbol_kind;
+  bool builtin;
+} Symbol;
 
 
+static Symbol builtins[] = {
+    { "print", 1, 1, { TOKEN_UNKNOWN }, TOKEN_EOF, SYM_FUNC, true },
+};
 
 
+typedef struct {
+  Symbol *symbols;
+  size_t size;
+  size_t capacity;
+} SymbolTable; 
 
-int main(void){
-  const char ts[] = "\"hello\" hi + 2"; 
-  const char math[] = "((1+2)*6)/18"; // = 1
-  Token tk = tokenize_all(math);
-  for (size_t i=0; i<tk.size; ++i){
-    printf("TokenNum: %zu Type: %s Value: %s\n", i, tk.tktype[i], tk.text[i]);
+
+static int builtin_num = sizeof(builtins)/sizeof(builtins[0]);
+
+static SymbolTable global_env = {
+  .size = sizeof(builtins)/sizeof(builtins[0]),
+  .capacity = sizeof(builtins)/sizeof(builtins[0]),
+  .symbols = builtins};
+
+
+Symbol *symbol_lookup(SymbolTable *table, const char *n){
+  for (size_t i=0; i<table->size; ++i){
+    if(strcmp(n, table->symbols[i].name) == 0){
+      return &table->symbols[i];
     }
-  // printf("token count: %zu\n", tk.size);
+  }
+  return NULL;
+}
+
+// fn add(x: int, y: int) int {
+//   return x+y;
+// }
+
+
+void symbol_table_init(SymbolTable *table, size_t initial_capacity) {
+    table->symbols = malloc(sizeof(Symbol) * initial_capacity);
+    if (!table->symbols) {
+        fprintf(stderr, "symbol_table_init: malloc failed\n");
+        exit(1);
+    }
+    table->size = 0;
+    table->capacity = initial_capacity;
+}
+
+void symbol_table_add(SymbolTable *table, Symbol sym) {
+    if (table->size >= table->capacity) {
+        table->capacity = (table->capacity == 0) ? 8 : table->capacity * 2;
+        table->symbols = realloc(table->symbols, sizeof(Symbol) * table->capacity);
+        if (!table->symbols) {
+            fprintf(stderr, "symbol_table_add: realloc failed\n");
+            exit(1);
+        }
+    }
+    table->symbols[table->size++] = sym;
+}
+
+
+void symbol_table_free(SymbolTable *table) {
+    free(table->symbols);
+    table->symbols = NULL;
+    table->size = 0;
+    table->capacity = 0;
+}
+
+
+Token build_rpn(Token *inp, SymbolTable *symtab) {
+    Token output;
+    Token stack;
+
+    token_init(&output, 16);
+    token_init(&stack, 16);
+
+    for (size_t i = 0; i < inp->size; ++i) {
+        symbols type = inp->type[i];
+        const char *text = inp->text[i];
+
+        if (type == TOKEN_IDENTIFIER && i + 1 < inp->size && inp->type[i + 1] == TOKEN_LPAREN) {
+            Symbol *found = symbol_lookup(symtab, text);
+            if (!found) {
+                Symbol sym = {
+                    .name = strdup(text),
+                    .arg_count = 0,
+                    .ret_type = TOKEN_EOF,
+                    .symbol_kind = SYM_FUNC,
+                    .builtin = false
+                };
+                symbol_table_add(symtab, sym);
+            }
+            token_push(&stack, type, text, inp->behaviour[i], 0);
+        } else if (type == TOKEN_IDENTIFIER) {
+            Symbol *found = symbol_lookup(symtab, text);
+            if (!found) {
+                Symbol sym = {
+                    .name = strdup(text),
+                    .arg_count = 0,
+                    .ret_type = TOKEN_UNKNOWN,
+                    .symbol_kind = SYM_VAR,
+                    .builtin = false
+                };
+                symbol_table_add(symtab, sym);
+            }
+            token_push(&output, type, text, inp->behaviour[i], 0);
+        } else if (type == TOKEN_LPAREN) {
+            token_push(&stack, type, text, inp->behaviour[i], 0);
+        } else if (type == TOKEN_RPAREN) {
+            while (stack.size > 0 && stack.type[stack.size - 1] != TOKEN_LPAREN) {
+                token_push(&output, stack.type[stack.size - 1],
+                           stack.text[stack.size - 1],
+                           stack.behaviour[stack.size - 1], 0);
+                stack.size--;
+            }
+            if (stack.size > 0 && stack.type[stack.size - 1] == TOKEN_LPAREN)
+                stack.size--;
+            if (stack.size > 0 && stack.type[stack.size - 1] == TOKEN_IDENTIFIER) {
+                token_push(&output, stack.type[stack.size - 1],
+                           stack.text[stack.size - 1],
+                           stack.behaviour[stack.size - 1], 0);
+                stack.size--;
+            }
+        } else if (type == TOKEN_INTEGER || type == TOKEN_FLOAT || type == TOKEN_STRING) {
+            token_push(&output, type, text, inp->behaviour[i], 0);
+        } else if (is_left_asc(type)) {
+            while (stack.size > 0 && stack.type[stack.size - 1] != TOKEN_LPAREN &&
+                   (get_prec(stack.type[stack.size - 1]) > get_prec(type) ||
+                    get_prec(stack.type[stack.size - 1]) == get_prec(type)) &&
+                   is_left_asc(type)) {
+                token_push(&output, stack.type[stack.size - 1],
+                           stack.text[stack.size - 1],
+                           stack.behaviour[stack.size - 1], 0);
+                stack.size--;
+            }
+            token_push(&stack, type, text, inp->behaviour[i], 0);
+        }
+    }
+
+    while (stack.size > 0) {
+        token_push(&output, stack.type[stack.size - 1],
+                   stack.text[stack.size - 1],
+                   stack.behaviour[stack.size - 1], 0);
+        stack.size--;
+    }
+
+    token_push(&output, TOKEN_EOF, "EOF", BHV_UNDEFINED, 0);
+    return output;
+}
+
+void print_token(Token *tk){
+  for (size_t i=0; i<tk->size; ++i){
+    printf("TokenNum: %zu Type: %s Value: %s\n", i, tk->tktype[i], tk->text[i]);
+  }
+}
+
+
+
+
+int main(int argc, char **argv){
+  if (argc < 2) return -1;
+  const char ts[] = "\"hello\" hi + 2 2.312"; 
+  const char math[] = "print(((1+2)*6)/18)"; // = 1
+  const char print[] = "print(\"hello\")";
+  const char simple[] = "1 + (  3 + 3  )/4+4*3";
+  
+
+  char* read = nb_read_file(argv[1]);
+  Token tk = tokenize_all(read);
+  printf("INPUT: %s\n", read);
+  SymbolTable table = {0};
+  symbol_table_init(&table, 32);
+
+
+  Token rpn = build_rpn(&tk, &table);
+  print_token(&rpn); 
 }

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;
+}