dont accidentally use these until they are done

arch/linux/tui/main.c

@@ -4,7 +4,7 @@
 #define CODE_SIZE 8192
 #define MEMORY_SIZE 65536
 u8 lmem[MEMORY_SIZE] = {0};
-u32 lcode[CODE_SIZE] = {0};
+u8 lcode[CODE_SIZE] = {0};
 
 bool init_vm() {
   mem = lmem;
@@ -50,76 +50,22 @@ u32 syscall(u32 id, u32 size, u32 mem_ptr) {
 }
 
 void test_add_two_num() {
-  i32 main_local_count = 5; 
+  code[cp++] = OP_GET;
-  mp += (4 * main_local_count);
+  code[cp++] = OP_GET;
-  code[cp++] = ENCODE_B(OP_LOAD_IMM, 0, 1);
+  code[cp++] = OP_GET;
-  code[cp++] = ENCODE_B(OP_PUSH, 0, 0);
+  code[cp++] = OP_CALL;
-  code[cp++] = ENCODE_B(OP_LOAD_IMM, 1, 1);
+  code[cp++] = OP_INT_TO_STR;
-  code[cp++] = ENCODE_B(OP_PUSH, 1, 0);
+  code[cp++] = OP_SYSCALL;
-  i32 add = cp + 5;
+  code[cp++] = OP_HALT;
-  code[cp++] = ENCODE_B(OP_LOAD_IMM, 2, add);
-
-  code[cp++] = ENCODE_A(OP_CALL, 2, 3, 0);
-  code[cp++] = ENCODE_A(OP_INT_TO_STR, 4, 3, 0);
-  code[cp++] = ENCODE_A(OP_SYSCALL, SYSCALL_CONSOLE_WRITE, 1, 4);
-  code[cp++] = ENCODE_A(OP_HALT, 0, 0, 0);
-
   /* add */
-  code[cp++] = ENCODE_A(OP_ADD_INT, 2, 1, 0);
+  code[cp++] = OP_ADD_INT;
-  code[cp++] = ENCODE_B(OP_RETURN, 2, 0);
+  code[cp++] = OP_RETURN;
-}
-
-void test_fibonacci() {
-  i32 fib = 7;
-  i32 base_case = 21;
-  /* function main() */
-  i32 main_local_count = 4; 
-  mp += (4 * main_local_count);
-  /* fib(35) */
-  code[cp++] = ENCODE_B(OP_LOAD_IMM, 0, 35);
-  code[cp++] = ENCODE_B(OP_PUSH, 0, 0);
-  code[cp++] = ENCODE_B(OP_LOAD_IMM, 1, fib);
-  code[cp++] = ENCODE_A(OP_CALL, 1, 9, 2);
-  /* print */
-  code[cp++] = ENCODE_A(OP_INT_TO_STR, 3, 2, 0);
-  code[cp++] = ENCODE_A(OP_SYSCALL, SYSCALL_CONSOLE_WRITE, 1, 3);
-  code[cp++] = ENCODE_A(OP_HALT, 0, 0, 0);
-  /* function fib (int n) int */
-  code[cp++] = ENCODE_B(OP_LOAD_IMM, 8, fib);
-  code[cp++] = ENCODE_B(OP_LOAD_IMM, 1, 2);
-  code[cp++] = ENCODE_B(OP_LOAD_IMM, 2, base_case);
-  code[cp++] = ENCODE_A(OP_JLT_INT, 2, 0, 1);
-  code[cp++] = ENCODE_B(OP_LOAD_IMM, 3, 2);
-  code[cp++] = ENCODE_A(OP_SUB_INT, 4, 0, 3);
-  code[cp++] = ENCODE_B(OP_PUSH, 4, 0);
-  code[cp++] = ENCODE_A(OP_CALL, 8, 9, 5);
-  code[cp++] = ENCODE_B(OP_LOAD_IMM, 3, 1);
-  code[cp++] = ENCODE_A(OP_SUB_INT, 4, 0, 3);
-  code[cp++] = ENCODE_B(OP_PUSH, 4, 0);
-  code[cp++] = ENCODE_A(OP_CALL, 8, 9, 6);
-  code[cp++] = ENCODE_A(OP_ADD_INT, 7, 6, 5);
-  code[cp++] = ENCODE_B(OP_RETURN, 7, 0);
-  code[cp++] = ENCODE_B(OP_RETURN, 0, 0);
-}
-
-void test_hello() {
-  u32 hello =str_alloc("nuqneH 'u'?", 12);
-  u32 new_line = str_alloc("\n", 1);
-  fp = mp;
-  /* function main() */
-  i32 main_local_count = 3; 
-  mp += (4 * main_local_count);
-  code[cp++] = ENCODE_B(OP_LOAD_IMM, 0, hello);
-  code[cp++] = ENCODE_A(OP_SYSCALL, SYSCALL_CONSOLE_WRITE, 0, 0);
-  code[cp++] = ENCODE_B(OP_LOAD_IMM, 0, new_line);
-  code[cp++] = ENCODE_A(OP_SYSCALL, SYSCALL_CONSOLE_WRITE, 0, 0);
-  code[cp++] = ENCODE_A(OP_HALT, 0, 0, 0);
 }
 
 i32 main() {
   init_vm();
 
-  test_hello();
+  test_add_two_num();
 
   while(step_vm()) {
     // do stuff

build

@@ -69,7 +69,7 @@ case $MODE in
 	BUILD_FLAGS="-g -Wall -Wextra -Werror -pedantic"
     ;;
     "release")
-	BUILD_FLAGS="-Ofast -Wall -Wextra -Werror -pedantic"
+	BUILD_FLAGS="-O2 -Wall -Wextra -Werror -pedantic"
     ;;
 esac
 

test/add.ul

@@ -1,29 +0,0 @@
-/**
- * Plexes
- */
-plex Terminal {
-  nat handle;
-}
-
-/**
- * Main function
- */
-function main() {
-    pln(add(1, 1) as str);
-}
-
-/**
- * Add two numbers together
- */
-function add(int a, int b) int {
-    return a + b;
-}
-
-/**
- * Print with a newline
- */
-function pln(str message) {
-    Terminal term = open("/dev/term/0", 0);
-    term.write(message);
-    term.write("\n");
-}

test/fib.ul

@@ -1,30 +0,0 @@
-/**
- * Plexes
- */
-plex Terminal {
-  nat handle;
-}
-
-/**
- * Main function
- */
-function main() {
-    pln(fib(35) as str);
-}
-
-/**
- * Recursively calculate fibonacci
- */
-function fib(int n) int {
-  if (n < 2) return n;
-  return fib(n - 2) + fib(n - 1);
-}
-
-/**
- * Print with a newline
- */
-function pln(str message) {
-    Terminal term = open("/dev/term/0", 0);
-    term.write(message);
-    term.write("\n");
-}

test/hello.ul

@@ -1,22 +0,0 @@
-/**
- * Plexes
- */
-plex Terminal {
-  nat handle;
-}
-
-/**
- * Main function
- */
-function main() {
-    pln("nuqneH 'u'?");
-}
-
-/**
- * Print with a newline
- */
-function pln(str message) {
-    Terminal term = open("/dev/term/0", 0);
-    term.write(message);
-    term.write("\n");
-}

test/malloc.ul

@@ -1,26 +0,0 @@
-/**
- * Plexes
- */
-plex Terminal {
-  nat handle;
-}
-
-
-/**
- * Main function
- */
-function main() {
-    Terminal term = open("/dev/term/0", 0);
-    pln("Enter a string: ");
-    pln(term.read(32) as str);
-    return 0;
-}
-
-/**
- * Print with a newline
- */
-function pln(str message) {
-    Terminal term = open("/dev/term/0", 0);
-    term.write(message);
-    term.write("\n");
-}

test/paint.ul

@@ -1,108 +0,0 @@
-/**
- * Constants
- */
-const byte BLACK = 0;
-const byte WHITE = 255;
-const byte DARK_GRAY = 73;
-const byte GRAY = 146;
-const byte LIGHT_GRAY = 182;
-
-byte selected_color = 255;
-
-trait Device {
-  nat handle;
-}
-
-plex Screen implements Device {
-  nat handle;
-  nat width;
-  nat height;
-  byte[] buffer;
-
-  draw() {
-    this.write(this.buffer);
-  }
-}
-
-plex Mouse implements Device {
-  nat handle;
-  nat x;
-  nat y;
-  bool left;
-  bool right;
-  bool middle;
-  bool btn4;
-}
-
-/**
- * Main function
- */
-function main() {
-    Screen screen = open("/dev/screen/0", 0);
-    Mouse mouse = open("/dev/mouse/0", 0);
-
-    outline_swatch(screen, BLACK, 1, 1);
-    outline_swatch(screen, WHITE, 21, 1);
-    screen.draw();
-
-    loop {
-      if (!mouse.left) continue; 
-      
-      int box_size = 20;
-      int x = 1;
-      int y = 1;
-      byte color = BLACK;
-      outlined_swatch(screen, color, x, y);
-      set_color(box_size, x, y, mouse.x, mouse.y, color);
-      
-      color = WHITE;
-      x = 21;
-      outlined_swatch(screen, color, x, y);
-      set_color(box_size, x, y, mouse.x, mouse.y, color);
-      screen.draw();
-      
-      rectangle(screen, selected_color, x, y, 5, 5);
-    }
-    exit(0);
-}
-
-/**
- * Checks if the click is within the bound and update the selected color if so.
- */
-function set_color(int box_size, int bx, int by, int mx, int my, byte color) {
-    int right = bx + box_size;
-    int bottom = by + box_size;
-
-    if (mx < bx) return;
-    if (mx > right) return;
-    if (my < by) return;
-    if (my > bottom) return;
-
-    selected_color = color;
-}
-
-/**
- * Draw a color box with a grey outline, if selected use a darker color
- */
-function outline_swatch(Device screen, byte color, int x, int y) {
-    byte bg_color = GRAY;
-    if (selected_color == color) {
-	    bg_color = DARK_GRAY;
-    }
-
-    rectangle(screen, bg_color, x, y, 20, 20);
-    rectangle(screen, color, x + 2, y + 2, 17, 17);
-}
-
-/**
- * Draw a rectangle
- */ 
-function rectangle(Device screen, byte color, int x, int y, int width, int height) {
-  int base = y * screen.width + x + screen.buffer.ptr + 4;
-
-  do (int i = height; i > 0; i--) {
-    int row = base + width;
-    memset(screen.buffer, row, color, width);
-    base += screen.width;
-  }
-}

test/simple.ul

@@ -1,25 +0,0 @@
-/**
- * Constants
- */
-const str nl = "\n";
-
-plex Terminal {
-  nat handle;
-}
-
-/**
- * Main function
- */
-function main() {
-  pln((1.0 + 1.0) as str);
-  exit(0);
-}
-
-/**
- * Print with a newline
- */
-function pln(str message) {
-    Terminal term = open("/dev/term/0", 0);
-    write(term, message, message.length);
-    write(term, nl, nl.length);
-}

test/window.ul

@@ -1,72 +0,0 @@
-/**
- * Constants
- */
-const str screen_namespace = "/dev/screen/0"
-const str mouse_namespace = "/dev/mouse/0"
-const str terminal_namespace = "/dev/term/0"
-const str new_line = "\n"
-const byte WHITE = 255
-
-/**
- * Devices
- */
-plex Terminal {
-  nat handle;
-}
-
-plex Screen {
-  nat handle;
-  nat width;
-  nat height;
-  byte[] buffer;
-
-  draw() {
-    write(this, this.buffer, this.buffer_size);
-  }
-}
-
-plex Mouse {
-  nat handle;
-  nat x;
-  nat y;
-  bool left;
-  bool right;
-  bool middle;
-  bool btn4;
-  nat size;
-}
-
-/**
- * Main function
- */
-function main() {
-    Screen screen = open(screen_namespace, 0);
-    pln(screen.handle as str);
-    pln(screen.width as str);
-    pln(screen.size as str);
-    unsafe {
-      pln(screen.screen_buffer.ptr as str);
-    }
-
-    Mouse mouse = open(mouse_namespace, 0);
-    screen.draw();
-
-    loop {
-        if (mouse.left) {
-            unsafe {
-              screen.buffer[mouse.y * width + mouse.x +
-                                  screen.buffer.ptr + 4] = WHITE;
-              screen.draw();
-            }
-        }
-    }
-}
-
-/**
- * Print with a newline
- */
-function pln(str message) {
-    Terminal term = open(terminal_namespace, 0);
-    write(term, message, message.length);
-    write(term, nl, nl.length);
-}

tools/assembler/assembler.c

@@ -0,0 +1,7 @@
+#include "assembler.h"
+/**
+ * Emit bytecode to the VM from the source string.
+ */
+void assemble(char *source, ScopeTable *st) {
+
+}

tools/assembler/assembler.h

@@ -0,0 +1,55 @@
+#ifndef UNDAR_IR_ASSEMBLER_H
+#define UNDAR_IR_ASSEMBLER_H
+
+#include "../../vm/libc.h"
+#include "lexer.h"
+
+typedef enum { GLOBAL, LOCAL, VAR } ScopeType;
+typedef enum {
+  VOID,
+  BOOL,
+  I8,
+  I16,
+  I32,
+  U8,
+  U16,
+  U32,
+  F8,
+  F16,
+  F32,
+  STR,
+  PLEX,
+  ARRAY,
+  FUNCTION
+} SymbolType;
+
+typedef struct symbol_s Symbol;
+typedef struct symbol_tab_s SymbolTable;
+typedef struct scope_tab_s ScopeTable;
+
+#define MAX_SYMBOL_NAME_LENGTH 64
+struct symbol_s {
+  char name[MAX_SYMBOL_NAME_LENGTH];
+  u8 name_length;
+  SymbolType type;
+  ScopeType scope;
+  u32 ref;  // vm->mp if global, vm->pc local, register if var 
+  u32 size; // size of symbol
+};
+
+struct symbol_tab_s {
+  Symbol symbols[256];
+  u8 count;
+  i32 parent;
+};
+
+struct scope_tab_s {
+  SymbolTable *scopes;
+  u32 count;
+  u32 capacity;
+  i32 scope_ref;
+};
+
+void assemble(char *source, ScopeTable *st);
+
+#endif

tools/assembler/lexer.c

@@ -0,0 +1,401 @@
+#include <string.h>
+
+#include "../../vm/libc.h"
+#include "lexer.h"
+
+typedef struct {
+  const char *start;
+  const char *current;
+  i32 line;
+} Lexer;
+
+Lexer lexer;
+
+void init_lexer(const char *source) {
+  lexer.start = source;
+  lexer.current = source;
+  lexer.line = 1;
+}
+
+static bool is_alpha(char c) {
+  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
+}
+
+static bool is_digit(char c) { return c >= '0' && c <= '9'; }
+
+static bool is_at_end() { return *lexer.current == '\0'; }
+
+static char advance() {
+  lexer.current++;
+  return lexer.current[-1];
+}
+
+static char peek() { return *lexer.current; }
+
+static char peek_next() {
+  if (is_at_end())
+    return '\0';
+  return lexer.current[1];
+}
+
+static bool match(char expected) {
+  if (is_at_end())
+    return false;
+  if (*lexer.current != expected)
+    return false;
+  lexer.current++;
+  return true;
+}
+
+static Token make_token(TokenType type) {
+  Token token;
+  token.type = type;
+  token.start = lexer.start;
+  token.length = (i32)(lexer.current - lexer.start);
+  token.line = lexer.line;
+  return token;
+}
+
+static Token error_token(const char *message) {
+  Token token;
+  token.type = TOKEN_ERROR;
+  token.start = message;
+  token.length = (i32)strlen(message);
+  token.line = lexer.line;
+  return token;
+}
+
+static void skip_whitespace() {
+  for (;;) {
+    char c = peek();
+    switch (c) {
+    case ' ':
+    case '\r':
+    case '\t':
+      advance();
+      break;
+    case '\n':
+      lexer.line++;
+      advance();
+      break;
+    case '/':
+      if (peek_next() == '/') {
+        // Single-line comment: skip until newline or end of file
+        advance();
+        while (peek() != '\n' && !is_at_end())
+          advance();
+      } else if (peek_next() == '*') {
+        // Multi-line comment: skip until '*/' or end of file
+        advance();
+        advance();
+        while (!is_at_end()) {
+          if (peek() == '\n')
+            lexer.line++;
+          if (peek() == '*' && peek_next() == '/') {
+            advance();
+            advance();
+            break; // Exit loop, comment ended
+          }
+          advance();
+        }
+      } else {
+        return; // Not a comment, let tokenization handle it
+      }
+      break;
+    default:
+      return;
+    }
+  }
+}
+
+static TokenType check_keyword(i32 start, i32 length, const char *rest,
+                              TokenType type) {
+  if (lexer.current - lexer.start == start + length &&
+      memcmp(lexer.start + start, rest, length) == 0) {
+    return type;
+  }
+
+  return TOKEN_IDENTIFIER;
+}
+
+static TokenType identifierType() {
+  switch (lexer.start[0]) {
+  case 'a':
+    if (lexer.current - lexer.start > 1) {
+      switch (lexer.start[1]) {
+      case 'n':
+        return check_keyword(2, 1, "d", TOKEN_OPERATOR_AND);
+      case 's':
+        return check_keyword(2, 0, "", TOKEN_KEYWORD_AS);
+      }
+    }
+    break;
+  case 'c':
+    if (lexer.current - lexer.start > 1) {
+      switch (lexer.start[1]) {
+      case 'l':
+        return check_keyword(2, 3, "ose", TOKEN_KEYWORD_CLOSE);
+      case 'o':
+        return check_keyword(2, 3, "nst", TOKEN_KEYWORD_CONST);
+      }
+    }
+    break;
+  case 'e':
+    return check_keyword(1, 3, "lse", TOKEN_KEYWORD_ELSE);
+  case 'f':
+    if (lexer.current - lexer.start > 1) {
+      switch (lexer.start[1]) {
+      case 'a':
+        return check_keyword(2, 3, "lse", TOKEN_KEYWORD_FALSE);
+      case 'o':
+        return check_keyword(2, 1, "r", TOKEN_KEYWORD_FOR);
+      case '3':
+        return check_keyword(1, 1, "2", TOKEN_TYPE_REAL);
+      }
+      return check_keyword(1, 7, "unction", TOKEN_KEYWORD_FN);
+    }
+    break;
+  case 'i':
+    if (lexer.current - lexer.start > 1) {
+      switch (lexer.start[1]) {
+      case 'f':
+        return check_keyword(2, 0, "", TOKEN_KEYWORD_IF);
+      case 's':
+        return check_keyword(2, 0, "", TOKEN_KEYWORD_IS);
+      case '8':
+        return check_keyword(2, 0, "", TOKEN_TYPE_I8);
+      case '1':
+        return check_keyword(2, 1, "6", TOKEN_TYPE_I16);
+      case '3':
+        return check_keyword(2, 1, "2", TOKEN_TYPE_INT);        
+      case 'n':
+        if (lexer.current - lexer.start > 2) {
+          switch (lexer.start[2]) {
+          case 'i':
+            return check_keyword(3, 2, "t", TOKEN_KEYWORD_INIT);
+          case 't':
+            return check_keyword(3, 0, "", TOKEN_TYPE_INT);
+          }
+        }
+        break;
+      }
+    }
+    break;
+  case 'n':
+    if (lexer.current - lexer.start > 1) {
+      switch (lexer.start[1]) {
+      case 'a':
+        return check_keyword(2, 1, "t", TOKEN_TYPE_NAT);
+      case 'i':
+        return check_keyword(2, 1, "l", TOKEN_KEYWORD_NIL);
+      }
+    }
+    break;
+  case 'o':
+    if (lexer.current - lexer.start > 1) {
+      switch (lexer.start[1]) {
+      case 'p':
+        return check_keyword(2, 2, "en", TOKEN_KEYWORD_OPEN);
+      case 'r':
+        return check_keyword(2, 0, "", TOKEN_OPERATOR_OR);
+      }
+    }
+    break;
+  case 'p':
+    if (lexer.current - lexer.start > 1) {
+      switch (lexer.start[1]) {
+      case 'l':
+        return check_keyword(2, 2, "ex", TOKEN_KEYWORD_PLEX);
+      }
+    }
+    break;
+  case 'r':
+    if (lexer.current - lexer.start > 1) {
+      switch (lexer.start[1]) {
+      case 'e':
+        if (lexer.current - lexer.start > 2) {
+          switch (lexer.start[2]) {
+          case 'f':
+            return check_keyword(3, 4, "resh", TOKEN_KEYWORD_REFRESH);
+          case 't':
+            return check_keyword(3, 3, "urn", TOKEN_KEYWORD_RETURN);
+          case 'a':  
+            if (lexer.current - lexer.start > 3) {
+              switch(lexer.start[3]) {
+                case 'd':
+                  return check_keyword(4, 0, "", TOKEN_KEYWORD_READ);
+                case 'l':
+                  return check_keyword(4, 0, "", TOKEN_TYPE_REAL);
+              }
+            }
+          }
+        }
+        break;
+      }
+    }
+    break;
+  case 's':
+    if (lexer.current - lexer.start > 1) {
+      switch (lexer.start[1]) {
+      case 't':
+        return check_keyword(2, 1, "r", TOKEN_TYPE_STR);
+      }
+    }
+    break;
+  case 't':
+    if (lexer.current - lexer.start > 1) {
+      switch (lexer.start[1]) {
+      case 'h':
+        return check_keyword(2, 2, "is", TOKEN_KEYWORD_THIS);
+      case 'r':
+        return check_keyword(2, 2, "ue", TOKEN_KEYWORD_TRUE);
+      }
+    }
+    break;
+  case 'u':
+    if (lexer.current - lexer.start > 1) {
+      switch (lexer.start[1]) {
+      case 's':
+        return check_keyword(2, 1, "e", TOKEN_KEYWORD_USE);
+      case '8':
+        return check_keyword(2, 0, "", TOKEN_TYPE_U8);
+      case '1':
+        return check_keyword(2, 1, "6", TOKEN_TYPE_U16);
+      case '3':
+        return check_keyword(2, 1, "2", TOKEN_TYPE_NAT);        
+      }
+    }
+    break;
+  case 'w':
+    if (lexer.current - lexer.start > 1) {
+      switch (lexer.start[1]) {
+      case 'h':
+        return check_keyword(2, 3, "ile", TOKEN_KEYWORD_WHILE);
+      case 'r':
+        return check_keyword(2, 3, "ite", TOKEN_KEYWORD_WRITE);
+      }
+    }
+    break;
+  case 'b':
+    if (lexer.current - lexer.start > 1) {
+      switch (lexer.start[1]) {
+      case 'y':
+        return check_keyword(2, 2, "te", TOKEN_TYPE_U8);
+      case 'o':
+        return check_keyword(2, 2, "ol", TOKEN_TYPE_U8);
+      }
+    }    
+    break;
+  case 'g':
+    return check_keyword(1, 5, "lobal", TOKEN_KEYWORD_GLOBAL);
+  case 'l':
+    return check_keyword(1, 3, "oop", TOKEN_KEYWORD_LOOP);
+  case 'd':
+    return check_keyword(1, 1, "o", TOKEN_KEYWORD_DO);  
+  case 'v':
+    return check_keyword(1, 3, "oid", TOKEN_TYPE_VOID);        
+  }
+
+  return TOKEN_IDENTIFIER;
+}
+
+static Token identifier() {
+  while (is_alpha(peek()) || is_digit(peek()))
+    advance();
+  return make_token(identifierType());
+}
+
+static Token number() {
+  while (is_digit(peek()))
+    advance();
+
+  /*  Look for a fractional part. */
+  if (peek() == '.' && is_digit(peek_next())) {
+    /*  Consume the ".". */
+    advance();
+
+    while (is_digit(peek()))
+      advance();
+
+    return make_token(TOKEN_LITERAL_REAL);
+  }
+
+  return make_token(TOKEN_LITERAL_INT);
+}
+
+static Token string() {
+  while (peek() != '"' && !is_at_end()) {
+    if (peek() == '\n')
+      lexer.line++;
+    advance();
+  }
+
+  if (is_at_end())
+    return error_token("Unterminated string.");
+
+  /*  The closing quote. */
+  advance();
+  return make_token(TOKEN_LITERAL_STR);
+}
+
+Token next_token() {
+  skip_whitespace();
+  lexer.start = lexer.current;
+
+  if (is_at_end())
+    return make_token(TOKEN_EOF);
+
+  char c = advance();
+  if (is_alpha(c))
+    return identifier();
+  char next = peek();
+  if ((c == '-' && is_digit(next)) || is_digit(c))
+    return number();
+
+  switch (c) {
+  case '(':
+    return make_token(TOKEN_LPAREN);
+  case ')':
+    return make_token(TOKEN_RPAREN);
+  case '{':
+    return make_token(TOKEN_LBRACE);
+  case '}':
+    return make_token(TOKEN_RBRACE);
+  case '[':
+    return make_token(TOKEN_LBRACKET);
+  case ']':
+    return make_token(TOKEN_RBRACKET);
+  case ';':
+    return make_token(TOKEN_SEMICOLON);
+  case ',':
+    return make_token(TOKEN_COMMA);
+  case '.':
+    return make_token(TOKEN_DOT);
+  case '-':
+    return make_token(match('>') ? TOKEN_ARROW_RIGHT : TOKEN_MINUS);
+  case '+':
+    return make_token(TOKEN_PLUS);
+  case '/':
+    return make_token(TOKEN_SLASH);
+  case '&':
+    return make_token(match('&') ? TOKEN_AND_AND : TOKEN_AND);
+  case '#':
+    return make_token(TOKEN_MESH);
+  case '$':
+    return make_token(TOKEN_BIG_MONEY);
+  case '*':
+    return make_token(TOKEN_STAR);
+  case '!':
+    return make_token(match('=') ? TOKEN_BANG_EQ : TOKEN_BANG);
+  case '=':
+    return make_token(match('=') ? TOKEN_EQ_EQ : TOKEN_EQ);
+  case '<':
+    return make_token(match('=') ? TOKEN_LTE : TOKEN_LT);
+  case '>':
+    return make_token(match('=') ? TOKEN_GTE : TOKEN_GT);
+  case '"':
+    return string();
+  }
+
+  return error_token("Unexpected character.");
+}

tools/assembler/lexer.h

@@ -1,8 +1,6 @@
 #ifndef UNDAR_LEXER_H
 #define UNDAR_LEXER_H
 
-#include "../vm/libc.h"
-
 typedef enum {
   TOKEN_EOF,
   TOKEN_IDENTIFIER,
@@ -84,8 +82,7 @@ typedef struct {
   int line;
 } Token;
 
-void initLexer(const char *source);
+void init_lexer(const char *source);
 Token next_token();
-const char* token_type_to_string(TokenType type);
 
 #endif

tools/compiler.c

@@ -1,152 +0,0 @@
-#include "parser.h"
-#include "compiler.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-
-Symbol *symbol_table_lookup(ScopeTable *table, const char *name, u32 length,
-                            i32 scope_ref) {
-  SymbolTable st = table->scopes[scope_ref];
-  for (u32 i = 0; i < st.count; i++) {
-    if (st.symbols[i].name_length == length) {
-      if (sleq(st.symbols[i].name, name, length)) {
-        return &table->scopes[scope_ref].symbols[i];
-      }
-    }
-  }
-  if (st.parent < 0)
-    return nil;
-  return symbol_table_lookup(table, name, length, st.parent);
-}
-
-u8 symbol_table_add(ScopeTable *table, Symbol s) {
-  Symbol *sym =
-      symbol_table_lookup(table, s.name, s.name_length, table->scope_ref);
-  if (sym != nil) {
-    fprintf(stderr,
-            "Error: Symbol '%.*s' already defined, in this scope"
-            " please pick a different variable name or create a new scope.\n",
-            s.name_length, s.name);
-    exit(1);
-  }
-
-  if (table->scopes[table->scope_ref].count + 1 > 255) {
-    fprintf(stderr, "Error: Only 255 symbols are allowed per scope"
-                    " first off: impressive; secondly:"
-                    " just create a new scope and keep going.\n");
-    exit(1);
-  }
-
-  if (!table_realloc(table)) {
-    fprintf(stderr,
-            "Error: Symbol table is out of memory! This is likely because you "
-            " built the assembler in static mode, increase the static size."
-            " if you built using malloc, that means your computer is out of"
-            " memory. Close a few tabs in your web browser and try again."
-            " Count was %d, while capacity was %d\n",
-            table->count, table->capacity);
-    exit(1);
-  }
-
-  table->scopes[table->scope_ref].symbols[table->scopes[table->scope_ref].count] = s;
-  u8 index = table->scopes[table->scope_ref].count;
-  table->scopes[table->scope_ref].count++;
-  return index;
-}
-
-u32 get_ref(ScopeTable *st, const char *name, u32 length) {
-  Symbol *sym = symbol_table_lookup(st, name, length, st->scope_ref);
-  if (!sym) {
-    fprintf(stderr, "Error: Assembler has no idea what Symbol '%.*s' means.\n",
-            length, name);
-    exit(1);
-    return 0;
-  }
-  return sym->ref;
-}
-
-u32 get_ptr(Token token, ScopeTable *st) {
-  if (token.type == TOKEN_IDENTIFIER) {
-    return get_ref(st, token.start, token.length);
-  }
-
-  if (token.type == TOKEN_LITERAL_INT) {
-    return atoi(token.start);
-  }
-
-  if (token.type == TOKEN_LITERAL_NAT) {
-    char *endptr;
-    u32 out = (u32)strtoul(token.start, &endptr, 10);
-    if (endptr == token.start || *endptr != '\0') {
-      fprintf(stderr, "Invalid decimal literal at line %d: %.*s\n", token.line,
-              token.length, token.start);
-      exit(1);
-    }
-    return out;
-  }
-
-  fprintf(stderr, "Error: Not a pointer or symbol at line %d: %.*s\n",
-          token.line, token.length, token.start);
-  exit(1);
-}
-
-u32 get_reg(Token token, ScopeTable *st) {
-  if (token.type == TOKEN_IDENTIFIER) {
-    return get_ref(st, token.start, token.length);
-  }
-
-  if (token.type == TOKEN_BIG_MONEY) {
-    token = next_token();
-    return atoi(token.start);
-  }
-
-  fprintf(stderr, "Error: Not a register or symbol at line %d: %.*s\n",
-          token.line, token.length, token.start);
-  exit(1);
-}
-
-Token next_id_or_reg() {
-  Token token = next_token();
-  if (token.type == TOKEN_IDENTIFIER) {
-    return token;
-  }
-
-  if (token.type == TOKEN_BIG_MONEY) {
-    token = next_token();
-    return token;
-  }
-
-  printf("Not an ID or register at line %d: %.*s\n", token.line, token.length,
-         token.start);
-  exit(1);
-
-  return token;
-}
-
-Token next_id_or_ptr() {
-  Token token = next_token();
-
-  if (token.type != TOKEN_IDENTIFIER && token.type != TOKEN_LITERAL_NAT &&
-      token.type != TOKEN_LITERAL_INT && token.type != TOKEN_LITERAL_REAL) {
-    printf("Not an ID or register at line %d: %.*s\n", token.line, token.length,
-           token.start);
-    exit(1);
-  }
-  return token;
-}
-
-Token next_token_is(TokenType type) {
-  Token token = next_token();
-  if (token.type != type) {
-    printf("ERROR at line %d: %.*s\n", token.line, token.length, token.start);
-    exit(1);
-  }
-  return token;
-}
-
-/**
- * Compile.
- */
-bool compile(ScopeTable *st, char *source) {
-  return false;
-}

tools/compiler.h

@@ -1,88 +0,0 @@
-#ifndef UNDAR_COMPILER_H
-#define UNDAR_COMPILER_H
-
-#include "../vm/libc.h"
-#include "../vm/vm.h"
-
-typedef enum { GLOBAL, LOCAL, VAR } ScopeType;
-typedef enum {
-  VOID,
-  BOOL,
-  I8,
-  I16,
-  I32,
-  U8,
-  U16,
-  U32,
-  F8,
-  F16,
-  F32,
-  STR,
-  PLEX,
-  ARRAY,
-  FUNCTION
-} SymbolType;
-
-typedef struct symbol_s Symbol;
-typedef struct symbol_tab_s SymbolTable;
-typedef struct value_type_s ValueType;
-typedef struct plex_fields_tab_s PlexFieldsTable;
-typedef struct plex_def_s PlexDef;
-typedef struct plex_tab_s PlexTable;
-typedef struct scope_s Scope;
-typedef struct scope_tab_s ScopeTable;
-
-struct value_type_s {
-  SymbolType type;
-  u32 name;
-  u32 size;
-  u32 table_ref; // if it is a heap object
-};
-
-struct plex_def_s {
-  u32 name;
-  u32 size;
-  u32 field_ref_start;
-  u32 field_count;
-};
-
-struct plex_fields_tab_s {
-  u32 *plex_refs;
-  ValueType *fields;
-  u32 count;
-  u32 capacity;
-};
-
-struct plex_tab_s {
-  PlexDef *symbols;
-  u32 count;
-  u32 capacity;
-};
-
-#define MAX_SYMBOL_NAME_LENGTH 64
-struct symbol_s {
-  char name[MAX_SYMBOL_NAME_LENGTH];
-  u8 name_length;
-  SymbolType type;
-  ScopeType scope;
-  u32 ref;  // vm->mp if global, vm->pc local, register if var 
-  u32 size; // size of symbol
-};
-
-struct symbol_tab_s {
-  Symbol symbols[256];
-  u8 count;
-  i32 parent;
-};
-
-struct scope_tab_s {
-  SymbolTable *scopes;
-  u32 count;
-  u32 capacity;
-  i32 scope_ref;
-};
-
-bool compile(ScopeTable *st, char *source);
-extern bool table_realloc(ScopeTable *table);/* implement this in arch/ not here */
-
-#endif

tools/parser.c

@@ -1,507 +0,0 @@
-#include "parser.h"
-
-typedef struct {
-  const char *start;
-  const char *current;
-  int line;
-} Lexer;
-
-Lexer lexer;
-
-void initLexer(const char *source) {
-  lexer.start = source;
-  lexer.current = source;
-  lexer.line = 1;
-}
-
-static bool isAlpha(char c) {
-  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
-}
-
-static bool isDigit(char c) { return c >= '0' && c <= '9'; }
-
-static bool isAtEnd() { return *lexer.current == '\0'; }
-
-static char advance() {
-  lexer.current++;
-  return lexer.current[-1];
-}
-
-static char peek() { return *lexer.current; }
-
-static char peekNext() {
-  if (isAtEnd())
-    return '\0';
-  return lexer.current[1];
-}
-
-static bool match(char expected) {
-  if (isAtEnd())
-    return false;
-  if (*lexer.current != expected)
-    return false;
-  lexer.current++;
-  return true;
-}
-
-static Token makeToken(TokenType type) {
-  Token token;
-  token.type = type;
-  token.start = lexer.start;
-  token.length = (int)(lexer.current - lexer.start);
-  token.line = lexer.line;
-  return token;
-}
-
-static Token errorToken(const char *message) {
-  Token token;
-  token.type = TOKEN_ERROR;
-  token.start = message;
-  token.length = (int)slen(message);
-  token.line = lexer.line;
-  return token;
-}
-
-static void skipWhitespace() {
-  for (;;) {
-    char c = peek();
-    switch (c) {
-    case ' ':
-    case '\r':
-    case '\t':
-      advance();
-      break;
-    case '\n':
-      lexer.line++;
-      advance();
-      break;
-    case '/':
-      if (peekNext() == '/') {
-        // Single-line comment: skip until newline or end of file
-        advance();
-        while (peek() != '\n' && !isAtEnd())
-          advance();
-      } else if (peekNext() == '*') {
-        // Multi-line comment: skip until '*/' or end of file
-        advance();
-        advance();
-        while (!isAtEnd()) {
-          if (peek() == '\n')
-            lexer.line++;
-          if (peek() == '*' && peekNext() == '/') {
-            advance();
-            advance();
-            break; // Exit loop, comment ended
-          }
-          advance();
-        }
-      } else {
-        return; // Not a comment, let tokenization handle it
-      }
-      break;
-    default:
-      return;
-    }
-  }
-}
-
-static TokenType checkKeyword(int start, int length, const char *rest,
-                              TokenType type) {
-  if (lexer.current - lexer.start == start + length &&
-      sleq(lexer.start + start, rest, length)) {
-    return type;
-  }
-
-  return TOKEN_IDENTIFIER;
-}
-
-static TokenType identifierType() {
-  switch (lexer.start[0]) {
-  case 'a':
-    if (lexer.current - lexer.start > 1) {
-      switch (lexer.start[1]) {
-      case 'n':
-        return checkKeyword(2, 1, "d", TOKEN_OPERATOR_AND);
-      case 's':
-        return checkKeyword(2, 0, "", TOKEN_KEYWORD_AS);
-      }
-    }
-    break;
-  case 'c':
-    if (lexer.current - lexer.start > 1) {
-      switch (lexer.start[1]) {
-      case 'l':
-        return checkKeyword(2, 3, "ose", TOKEN_KEYWORD_CLOSE);
-      case 'o':
-        return checkKeyword(2, 3, "nst", TOKEN_KEYWORD_CONST);
-      }
-    }
-    break;
-  case 'e':
-    return checkKeyword(1, 3, "lse", TOKEN_KEYWORD_ELSE);
-  case 'f':
-    if (lexer.current - lexer.start > 1) {
-      switch (lexer.start[1]) {
-      case 'a':
-        return checkKeyword(2, 3, "lse", TOKEN_KEYWORD_FALSE);
-      case 'o':
-        return checkKeyword(2, 1, "r", TOKEN_KEYWORD_FOR);
-      case '3':
-        return checkKeyword(2, 1, "2", TOKEN_TYPE_REAL);
-      }
-      return checkKeyword(1, 7, "unction", TOKEN_KEYWORD_FN);
-    }
-    break;
-  case 'i':
-    if (lexer.current - lexer.start > 1) {
-      switch (lexer.start[1]) {
-      case 'f':
-        return checkKeyword(2, 0, "", TOKEN_KEYWORD_IF);
-      case 's':
-        return checkKeyword(2, 0, "", TOKEN_KEYWORD_IS);
-      case '8':
-        return checkKeyword(2, 0, "", TOKEN_TYPE_I8);
-      case '1':
-        return checkKeyword(2, 1, "6", TOKEN_TYPE_I16);
-      case '3':
-        return checkKeyword(2, 1, "2", TOKEN_TYPE_INT);
-      case 'n':
-        if (lexer.current - lexer.start > 2) {
-          switch (lexer.start[2]) {
-          case 'i':
-            return checkKeyword(3, 2, "t", TOKEN_KEYWORD_INIT);
-          case 't':
-            return checkKeyword(3, 0, "", TOKEN_TYPE_INT);
-          }
-        }
-        break;
-      }
-    }
-    break;
-  case 'n':
-    if (lexer.current - lexer.start > 1) {
-      switch (lexer.start[1]) {
-      case 'a':
-        return checkKeyword(2, 1, "t", TOKEN_TYPE_NAT);
-      case 'i':
-        return checkKeyword(2, 1, "l", TOKEN_KEYWORD_NIL);
-      }
-    }
-    break;
-  case 'o':
-    if (lexer.current - lexer.start > 1) {
-      switch (lexer.start[1]) {
-      case 'p':
-        return checkKeyword(2, 2, "en", TOKEN_KEYWORD_OPEN);
-      case 'r':
-        return checkKeyword(2, 0, "", TOKEN_OPERATOR_OR);
-      }
-    }
-    break;
-  case 'p':
-    if (lexer.current - lexer.start > 1) {
-      switch (lexer.start[1]) {
-      case 'l':
-        return checkKeyword(2, 2, "ex", TOKEN_KEYWORD_PLEX);
-      }
-    }
-    break;
-  case 'r':
-    if (lexer.current - lexer.start > 1) {
-      switch (lexer.start[1]) {
-      case 'e':
-        if (lexer.current - lexer.start > 2) {
-          switch (lexer.start[2]) {
-          case 'a':
-            return checkKeyword(3, 1, "d", TOKEN_KEYWORD_READ);
-          case 'f':
-            return checkKeyword(3, 4, "resh", TOKEN_KEYWORD_REFRESH);
-          case 't':
-            return checkKeyword(3, 3, "urn", TOKEN_KEYWORD_RETURN);
-          }
-        }
-        break;
-      }
-    }
-    break;
-  case 's':
-    if (lexer.current - lexer.start > 1) {
-      switch (lexer.start[1]) {
-      case 't':
-        return checkKeyword(2, 1, "r", TOKEN_TYPE_STR);
-      }
-    }
-    break;
-  case 't':
-    if (lexer.current - lexer.start > 1) {
-      switch (lexer.start[1]) {
-      case 'h':
-        return checkKeyword(2, 2, "is", TOKEN_KEYWORD_THIS);
-      case 'r':
-        return checkKeyword(2, 2, "ue", TOKEN_KEYWORD_TRUE);
-      }
-    }
-    break;
-  case 'u':
-    if (lexer.current - lexer.start > 1) {
-      switch (lexer.start[1]) {
-      case 's':
-        return checkKeyword(2, 1, "e", TOKEN_KEYWORD_USE);
-      case '8':
-        return checkKeyword(2, 0, "", TOKEN_TYPE_U8);
-      case '1':
-        return checkKeyword(2, 1, "6", TOKEN_TYPE_U16);
-      case '3':
-        return checkKeyword(2, 1, "2", TOKEN_TYPE_NAT);
-      }
-    }
-    break;
-  case 'w':
-    if (lexer.current - lexer.start > 1) {
-      switch (lexer.start[1]) {
-      case 'h':
-        return checkKeyword(2, 3, "ile", TOKEN_KEYWORD_WHILE);
-      case 'r':
-        return checkKeyword(2, 3, "ite", TOKEN_KEYWORD_WRITE);
-      }
-    }
-    break;
-  case 'g':
-    return checkKeyword(1, 5, "lobal", TOKEN_KEYWORD_GLOBAL);
-  }
-
-  return TOKEN_IDENTIFIER;
-}
-
-static Token identifier() {
-  while (isAlpha(peek()) || isDigit(peek()))
-    advance();
-  return makeToken(identifierType());
-}
-
-static Token number() {
-  while (isDigit(peek()))
-    advance();
-
-  /*  Look for a fractional part. */
-  if (peek() == '.' && isDigit(peekNext())) {
-    /*  Consume the ".". */
-    advance();
-
-    while (isDigit(peek()))
-      advance();
-
-    return makeToken(TOKEN_LITERAL_REAL);
-  }
-
-  return makeToken(TOKEN_LITERAL_INT);
-}
-
-static Token string() {
-  while (peek() != '"' && !isAtEnd()) {
-    if (peek() == '\n')
-      lexer.line++;
-    advance();
-  }
-
-  if (isAtEnd())
-    return errorToken("Unterminated string.");
-
-  /*  The closing quote. */
-  advance();
-  return makeToken(TOKEN_LITERAL_STR);
-}
-
-Token next_token() {
-  skipWhitespace();
-  lexer.start = lexer.current;
-
-  if (isAtEnd())
-    return makeToken(TOKEN_EOF);
-
-  char c = advance();
-  if (isAlpha(c))
-    return identifier();
-  if (isDigit(c))
-    return number();
-
-  switch (c) {
-  case '(':
-    return makeToken(TOKEN_LPAREN);
-  case ')':
-    return makeToken(TOKEN_RPAREN);
-  case '{':
-    return makeToken(TOKEN_LBRACE);
-  case '}':
-    return makeToken(TOKEN_RBRACE);
-  case '[':
-    return makeToken(TOKEN_LBRACKET);
-  case ']':
-    return makeToken(TOKEN_RBRACKET);
-  case ';':
-    return makeToken(TOKEN_SEMICOLON);
-  case ',':
-    return makeToken(TOKEN_COMMA);
-  case '.':
-    return makeToken(TOKEN_DOT);
-  case '-':
-    return makeToken(match('>') ? TOKEN_ARROW_RIGHT : TOKEN_MINUS);
-  case '+':
-    return makeToken(TOKEN_PLUS);
-  case '/':
-    return makeToken(TOKEN_SLASH);
-  case '&':
-    return makeToken(match('&') ? TOKEN_AND_AND : TOKEN_AND);
-  case '#':
-    return makeToken(TOKEN_MESH);
-  case '$':
-    return makeToken(TOKEN_BIG_MONEY);
-  case '*':
-    return makeToken(TOKEN_STAR);
-  case '!':
-    return makeToken(match('=') ? TOKEN_BANG_EQ : TOKEN_BANG);
-  case '=':
-    return makeToken(match('=') ? TOKEN_EQ_EQ : TOKEN_EQ);
-  case '<':
-    return makeToken(match('=') ? TOKEN_LTE : TOKEN_LT);
-  case '>':
-    return makeToken(match('=') ? TOKEN_GTE : TOKEN_GT);
-  case '"':
-    return string();
-  }
-
-  return errorToken("Unexpected character.");
-}
-
-const char *token_type_to_string(TokenType type) {
-  switch (type) {
-  case TOKEN_EOF:
-    return "EOF";
-  case TOKEN_IDENTIFIER:
-    return "IDENTIFIER";
-  case TOKEN_LITERAL_INT:
-    return "LITERAL_INT";
-  case TOKEN_LITERAL_NAT:
-    return "LITERAL_NAT";
-  case TOKEN_LITERAL_REAL:
-    return "LITERAL_REAL";
-  case TOKEN_LITERAL_STR:
-    return "LITERAL_STR";
-  case TOKEN_TYPE_INT:
-    return "TYPE_INT";
-  case TOKEN_TYPE_NAT:
-    return "TYPE_NAT";
-  case TOKEN_TYPE_REAL:
-    return "TYPE_REAL";
-  case TOKEN_TYPE_STR:
-    return "TYPE_STR";
-  case TOKEN_KEYWORD_PLEX:
-    return "KEYWORD_PLEX";
-  case TOKEN_KEYWORD_FN:
-    return "KEYWORD_FN";
-  case TOKEN_KEYWORD_CONST:
-    return "KEYWORD_CONST";
-  case TOKEN_KEYWORD_IF:
-    return "KEYWORD_IF";
-  case TOKEN_KEYWORD_IS:
-    return "IS";
-  case TOKEN_KEYWORD_AS:
-    return "AS";
-  case TOKEN_KEYWORD_ELSE:
-    return "KEYWORD_ELSE";
-  case TOKEN_KEYWORD_WHILE:
-    return "KEYWORD_WHILE";
-  case TOKEN_KEYWORD_FOR:
-    return "KEYWORD_FOR";
-  case TOKEN_KEYWORD_RETURN:
-    return "KEYWORD_RETURN";
-  case TOKEN_KEYWORD_USE:
-    return "KEYWORD_USE";
-  case TOKEN_KEYWORD_INIT:
-    return "KEYWORD_INIT";
-  case TOKEN_KEYWORD_THIS:
-    return "KEYWORD_THIS";
-  case TOKEN_KEYWORD_OPEN:
-    return "TOKEN_KEYWORD_OPEN";
-  case TOKEN_KEYWORD_READ:
-    return "TOKEN_KEYWORD_READ";
-  case TOKEN_KEYWORD_WRITE:
-    return "TOKEN_KEYWORD_WRITE";
-  case TOKEN_KEYWORD_REFRESH:
-    return "TOKEN_KEYWORD_REFRESH";
-  case TOKEN_KEYWORD_CLOSE:
-    return "TOKEN_KEYWORD_CLOSE";
-  case TOKEN_KEYWORD_NIL:
-    return "KEYWORD_NIL";
-  case TOKEN_KEYWORD_TRUE:
-    return "KEYWORD_TRUE";
-  case TOKEN_KEYWORD_FALSE:
-    return "KEYWORD_FALSE";
-  case TOKEN_KEYWORD_GLOBAL:
-    return "KEYWORD_GLOBAL";
-  case TOKEN_OPERATOR_NOT:
-    return "OPERATOR_NOT";
-  case TOKEN_OPERATOR_AND:
-    return "OPERATOR_AND";
-  case TOKEN_OPERATOR_OR:
-    return "OPERATOR_OR";
-  case TOKEN_BANG:
-    return "BANG";
-  case TOKEN_BANG_EQ:
-    return "BANG_EQ";
-  case TOKEN_EQ:
-    return "EQ";
-  case TOKEN_EQ_EQ:
-    return "EQ_EQ";
-  case TOKEN_GT:
-    return "GT";
-  case TOKEN_LT:
-    return "LT";
-  case TOKEN_GTE:
-    return "GTE";
-  case TOKEN_LTE:
-    return "LTE";
-  case TOKEN_DOT:
-    return "DOT";
-  case TOKEN_COMMA:
-    return "COMMA";
-  case TOKEN_COLON:
-    return "COLON";
-  case TOKEN_SEMICOLON:
-    return "SEMICOLON";
-  case TOKEN_PLUS:
-    return "PLUS";
-  case TOKEN_MINUS:
-    return "MINUS";
-  case TOKEN_STAR:
-    return "STAR";
-  case TOKEN_SLASH:
-    return "SLASH";
-  case TOKEN_LPAREN:
-    return "LPAREN";
-  case TOKEN_RPAREN:
-    return "RPAREN";
-  case TOKEN_LBRACE:
-    return "LBRACE";
-  case TOKEN_RBRACE:
-    return "RBRACE";
-  case TOKEN_LBRACKET:
-    return "LBRACKET";
-  case TOKEN_RBRACKET:
-    return "RBRACKET";
-  case TOKEN_ARROW_RIGHT:
-    return "ARROW_RIGHT";
-  case TOKEN_MESH:
-    return "MESH";
-  case TOKEN_BIG_MONEY:
-    return "BIG_MONEY";
-  case TOKEN_AND:
-    return "AND";
-  case TOKEN_AND_AND:
-    return "AND_AND";
-  case TOKEN_ERROR:
-    return "ERROR";
-  default:
-    return "UNKNOWN_TOKEN";
-  }
-}

vm/vm.c

@@ -1,15 +1,16 @@
 #include "vm.h"
 #define FRAME_HEADER_SIZE 12
 
-u32 pc;       /* program counter */
+u32 pc;        /* program counter */
-u32 cp;       /* code pointer */
+u32 cp;        /* code pointer */
-u32 mp;       /* memory pointer */
+u32 mp;        /* memory pointer */
-u32 fp;       /* frame pointer */
+u32 fp;        /* frame pointer */
-u8  lc;       /* child local count */
+u32 sp;        /* frame pointer */
-u8  status;   /* status flag */
+u8  status;    /* status flag */
-u8 interrupt; /* device interrupt */
+u8  interrupt; /* device interrupt */
-u32 *code;    /* code */
+u32 *stack;    /* stack */
-u8 *mem;      /* memory */
+u8  *code;     /* code */
+u8  *mem;      /* memory */
 
 #define MAX_LEN_INT32 11
 #define MAX_INT32 2147483647
@@ -28,8 +29,8 @@ u32 str_alloc(char *str, u32 length) {
 }
 
 bool step_vm() {
-  u32 instruction = code[pc++];
+
-  u8 opcode = DECODE_OP(instruction);
+  u8 opcode = code[pc++];
   u32 *locals = (u32*)(&mem[fp]);
   u32 *globals = (u32*)(mem);
 
@@ -39,35 +40,30 @@ bool step_vm() {
     return false;
   }
   case OP_CALL: {
-    DECODE_A(instruction)
+    /* TODO: Fix this one so it makes sense with a stack based system */
     /* function to jump to */
-    u32 fn_ptr = locals[dest]; 
+    u32 fn_ptr = stack[--sp]; 
     /* get mp in 'global indexing mode' */
     u32 *header = &globals[mp / 4];
     /* reset child locals counter */
     lc = 0;
     /* push parents frame value to reset the heap to */
     (*header++) = fp;
-    /* push return address to child frame */
-    (*header++) = pc;
-    /* push local address to return the value to */
-    (*header++) = fp + (src2 * 4);
     /* increase the mp to new size */
     mp += FRAME_HEADER_SIZE;
     /* now set the frame pointer, where the locals start */
     fp = mp;    
     /* move mp forward by count many locals */
-    mp += (src1 * 4);
+    mp += stack[--sp];
     /* jump to dest_ptr */
     pc = fn_ptr;
-    return true;
+    return false;
   }
   case OP_RETURN: {
-    DECODE_B(instruction)
+    /* TODO: Fix this one so it makes sense with a stack based system */
-    u32 size = 0;
+    u32 i, size = 0;
-    u32 return_value = locals[dest];
+    u32 return_value = stack[--sp];
-    bool is_ptr = (((u32)(1)) << 15) & imm;
+    bool is_ptr = (((u32)(1)) << 15) & return_value;
-    bool replaces_value = (((u32)(1)) << 14) & imm;
 
     /* reset mp to saved mp, use header size to get "real" start of frame */
     u32 *frame_start = &globals[(fp / 4) - 3];
@@ -75,7 +71,6 @@ bool step_vm() {
     u32 return_address = *frame_start++;
     u32 parent_local_return_address = *frame_start++;
 
-    USED(replaces_value);
     /* reset memory to parents end of memory */
     mp = fp - FRAME_HEADER_SIZE;
     /* reset the frame pointer */
@@ -91,248 +86,181 @@ bool step_vm() {
       mp += size;
     } else {
     /* otherwise just write the return value to its location */
-      globals[(parent_local_return_address / 4)] = return_value;
+      mcpy(&mem[parent_local_return_address], &return_value, sizeof(u32));
     }
 
     /* jump to parent frame */
     pc = return_address;
-    return true;
+    return false;
   }
   case OP_SYSCALL: {
-    DECODE_A(instruction)
+    u32 id = stack[--sp];   /* syscall id */
-    u32 id = dest;   /* syscall id */
+    u32 size = stack[--sp]; /* size of heap at that pointer */
-    u32 size = src1; /* size of heap at that pointer */
+    u32 rd = stack[--sp]; /* the pointer */
-    u32 rd = locals[src2]; /* the pointer */
     status = syscall(id, size, rd);
     return true;
   }
   case OP_PUSH: {
-    DECODE_B(instruction)
+    return false;
-    USED(imm); 
-    globals[(mp / 4) + lc + 3] = locals[dest];
-    lc++;
-    return true;
   }
   case OP_POP: {
-    DECODE_B(instruction)
+    --sp;
-    USED(dest);
-    USED(imm); 
-    mp -= 4;
-    lc--;
     return true;
   }
-  case OP_LOAD_IMM: {
+  case OP_SET: {
-    DECODE_B(instruction)
+    return false;
-    locals[dest] = imm;
-    return true;
-  }
-  case OP_LOAD_UPPER_IMM: {
-    DECODE_B(instruction)
-    u32 value = locals[dest];
-    locals[dest] = (value | (((u32)(imm)) << 16));
-    return true;
-  }
-  case OP_LOAD_IND_8: {
-    DECODE_A(instruction)
-    USED(src2);
-    locals[dest] = READ_U8(locals[src1]);
-    return true;
-  }
-  case OP_LOAD_IND_16: {
-    DECODE_A(instruction)
-    USED(src2);
-    locals[dest] = READ_U16(locals[src1]);
-    return true;
-  }
-  case OP_LOAD_IND_32: {
-    DECODE_A(instruction)
-    USED(src2);
-    locals[dest] = READ_U32(locals[src1]);
-    return true;
-  }
-  case OP_LOAD_OFF_8: {
-    DECODE_A(instruction)
-    locals[dest] = READ_U8((locals[src1] + locals[src2]));
-    return true;
-  }
-  case OP_LOAD_OFF_16: {
-    DECODE_A(instruction)
-    locals[dest] = READ_U16((locals[src1] + locals[src2]));
-    return true;
-  }
-  case OP_LOAD_OFF_32: {
-    DECODE_A(instruction)
-    locals[dest] = READ_U32((locals[src1] + locals[src2]));
-    return true;
-  }
-  case OP_STORE_IND_8: {
-    DECODE_A(instruction)
-    USED(src2);
-    WRITE_U8(locals[dest], locals[src1]);
-    return true;
-  }
-  case OP_STORE_IND_16: {
-    DECODE_A(instruction)
-    USED(src2);
-    WRITE_U16(locals[dest], locals[src1]);
-    return true;
-  }
-  case OP_STORE_IND_32: {
-    DECODE_A(instruction)
-    USED(src2);
-    WRITE_U32(locals[dest], locals[src1]);
-    return true;
-  }
-  case OP_STORE_OFF_8: {
-    DECODE_A(instruction)
-    WRITE_U8((locals[dest] + locals[src2]), locals[src1]);
-    return true;
-  }
-  case OP_STORE_OFF_16: {
-    DECODE_A(instruction)
-    WRITE_U16((locals[dest] + locals[src2]), locals[src1]);
-    return true;
-  }
-  case OP_STORE_OFF_32: {
-    DECODE_A(instruction)
-    WRITE_U32((locals[dest] + locals[src2]), locals[src1]);
-    return true;
   }
   case OP_MEM_ALLOC: {
-    DECODE_A(instruction)
+    u32 size = stack[--sp];
-    u32 size = locals[src1];
+    stack[sp++] = mp;
-    locals[dest] = mp;
     WRITE_U32(mp, size);
-    USED(src2);
     mp += (size + 4);
     return true;
   }
   case OP_MEM_CPY_8: {
-    DECODE_A(instruction)
+    u32 i = 0;
-
+    u32 count = stack[--sp];
-    u8 *ptr_src;
+    u32 msrc = stack[--sp];
-    u8 *ptr_dest;
+    u32 mdest = stack[--sp];
-    u32 mdest = locals[dest];
-    u32 msrc = locals[src1];
-    u32 count = locals[src2];
 
     if (mdest + count >= mp) {
       status = 1;
       return true;
     }
 
-    ptr_dest = &mem[mdest];
+    for (i = 0; i < count; i++) {
-    ptr_src = &mem[msrc];
+      mem[msrc + i] = mem[mdest + i];
-    mcpy(ptr_dest, ptr_src, count*sizeof(u8));
+    }
 
     status = 0;
     return true;
   }
   case OP_MEM_CPY_16: {
-    DECODE_A(instruction)
+    u32 i = 0;
-
+    u32 count = stack[--sp];
-    u8 *ptr_src;
+    u32 msrc = stack[--sp];
-    u8 *ptr_dest;
+    u32 mdest = stack[--sp];
-    u32 mdest = locals[dest];
-    u32 msrc = locals[src1];
-    u32 count = locals[src2];
 
     if (mdest + count >= mp) {
       status = 1;
       return true;
     }
 
-    ptr_dest = &mem[mdest];
+    for (i = 0; i < count; i++) {
-    ptr_src = &mem[msrc];
+      u16 value = READ_U16(mdest + i);
-    mcpy(ptr_dest, ptr_src, count*sizeof(u16));
+      WRITE_U16(msrc + i, value);
+    }
 
     status = 0;
     return true;
   }
   case OP_MEM_CPY_32: {
-    DECODE_A(instruction)
+    u32 i = 0;
-
+    u32 count = stack[--sp];
-    u8 *ptr_src;
+    u32 msrc = stack[--sp];
-    u8 *ptr_dest;
+    u32 mdest = stack[--sp];
-    u32 mdest = locals[dest];
-    u32 msrc = locals[src1];
-    u32 count = locals[src2];
 
     if (mdest + count >= mp) {
       status = 1;
       return true;
     }
 
-    ptr_dest = &mem[mdest];
+    for (i = 0; i < count; i++) {
-    ptr_src = &mem[msrc];
+      globals[msrc + i] = globals[mdest + i];
-    mcpy(ptr_dest, ptr_src, count*sizeof(u32));
+    }
 
     status = 0;
     return true;
   }
   case OP_MEM_SET_8: {
-    DECODE_A(instruction)
+    u32 i, start, end;
+    u8 value = (u8)stack[--sp];
+    u32 count = stack[--sp];
+    start = stack[--sp];
+    end = start + count;
 
-    u8 *ptr_dest;
+    if (start >= mp || end > mp) {
-    u8 value = (u8)locals[src1];
-    u32 count = locals[src2];
-    u32 mdest = locals[dest];
-
-    if (mdest + count >= mp) {
       status = 1;
       return true;
     }
 
-    ptr_dest = &mem[mdest];
+    for (i = start; i < end; i++) {
-    mcpy(ptr_dest, &value, count*sizeof(u8));
+      mem[i] = value;
+    }
 
     status = 0;
     return true;
   }
   case OP_MEM_SET_16: {
-    DECODE_A(instruction)
+    u32 i, start, end;
+    u8 value = (u8)stack[--sp];
+    u32 count = stack[--sp];
+    start = stack[--sp];
+    end = start + count;
 
-    u8 *ptr_dest;
+    if (start >= mp || end > mp) {
-    u16 value = (u16)locals[src1];
-    u32 count = locals[src2];
-    u32 mdest = locals[dest];
-
-    if (mdest + count >= mp) {
       status = 1;
       return true;
     }
 
-    ptr_dest = &mem[mdest];
+    for (i = start; i < end; i += 2) {
-    mcpy(ptr_dest, &value, count*sizeof(u16));
+      WRITE_U16(i, value);
+    }
 
     status = 0;
     return true;
   }
   case OP_MEM_SET_32: {
-    DECODE_A(instruction)
+    u32 i, start, end;
+    u8 value = (u8)stack[--sp];
+    u32 count = stack[--sp];
+    start = stack[--sp];
+    end = start + count;
 
-    u8 *ptr_dest;
+    if (start >= mp || end > mp) {
-    u32 value = locals[src1];
-    u32 count = locals[src2];
-    u32 mdest = locals[dest];
-
-    if (mdest + count >= mp) {
       status = 1;
       return true;
     }
 
-    ptr_dest = &mem[mdest];
+    for (i = start; i < end; i += 4) {
-    mcpy(ptr_dest, &value, count*sizeof(u32));
+      WRITE_U32(i, value);
+    }
 
     status = 0;
     return true;
   }
-  case OP_MOV: {
+  case OP_DUP: {
-    DECODE_A(instruction)
+    u32 a = stack[--sp];
-    USED(src2);
+    stack[sp++] = a;
-    locals[dest] = locals[src1];
+    stack[sp++] = a;
     return true;
   }
+  case OP_EXCH: {
+    u32 a = stack[--sp];
+    u32 b = stack[--sp];
+    stack[sp++] = b;
+    stack[sp++] = a;
+    return true;
+  }
+  case OP_OVER: {
+    u32 a = stack[sp - 1];
+    stack[sp++] = a;
+    return true;
+  }
+  case OP_PICK: {
+    u32 n = stack[--sp];
+    u32 b = stack[sp - n];
+    stack[sp++] = b;
+    return true;
+  }
+  case OP_ROT: {
+    return false;
+  }
+  case OP_DEPTH: {
+    u32 a = sp;
+    stack[sp++] = a; 
+    return true;
+  }  
   case OP_ADD_INT: {
     MATH_OP(i32, +);
   }
@@ -364,27 +292,27 @@ bool step_vm() {
     MATH_OP(i32, -);
   }
   case OP_MUL_REAL: {
-    DECODE_A(instruction)
+    i32 src1 = (i32)stack[--sp];
+    i32 src2 = (i32)stack[--sp];
 
-    i32 src1_whole = (i32)locals[src1] >> 16;
+    i32 src1_whole = src1 >> 16;
-    i32 src2_whole = (i32)locals[src2] >> 16;
+    i32 src2_whole = src2 >> 16;
 
-    i32 src1_decimal = (i32)locals[src1] & 16;
+    i32 src1_decimal = src1 & 16;
-    i32 src2_decimal = (i32)locals[src2] & 16;
+    i32 src2_decimal = src2 & 16;
 
     i32 result = 0;
     result += (src1_whole * src2_whole) << 16;
     result += (src1_whole * src2_decimal);
     result += (src1_decimal * src2_whole);
     result += ((src1_decimal * src2_decimal) >> 16) & 16;
-    locals[dest] = result;
+    stack[sp++] = result;
     return true;
   }
   case OP_DIV_REAL: {
-    DECODE_A(instruction)
     i32 result;
-    i32 src1_val = (i32)locals[src1];
+    i32 src1_val = (i32)stack[--sp];
-    i32 src2_val = (i32)locals[src2];
+    i32 src2_val = (i32)stack[--sp];
 
     u32 src2_reciprocal = 1;
     src2_reciprocal <<= 31;
@@ -393,49 +321,37 @@ bool step_vm() {
     result = src1_val * src2_reciprocal;
     result <<= 1;
 
-    locals[dest] = result;
+    stack[sp++] = result;
     return true;
   }
   case OP_INT_TO_REAL: {
-    DECODE_A(instruction)
+    i32 result = (i32)stack[--sp] << 16;
-    i32 result = (i32)locals[src1] << 16;
+    stack[sp++] = result;
-    USED(src2);
-    locals[dest] = result;
     return true;
   }
   case OP_INT_TO_NAT: {
-    DECODE_A(instruction)
+    u32 result = (u32)stack[--sp];
-    u32 result = (u32)locals[src1];
+    stack[sp++] = result;
-    USED(src2);
-    locals[dest] = result;
     return true;
   }
   case OP_NAT_TO_REAL: {
-    DECODE_A(instruction)
+    i32 result = (i32)stack[--sp] << 16;
-    i32 result = (i32)locals[src1] << 16;
+    stack[sp++] = result;
-    USED(src2);
-    locals[dest] = result;
     return true;
   }
   case OP_NAT_TO_INT: {
-    DECODE_A(instruction)
+    i32 result = (i32)stack[--sp];
-    i32 result = (i32)locals[src1];
+    stack[sp++] = result;
-    USED(src2);
-    locals[dest] = result;
     return true;
   }
   case OP_REAL_TO_INT: {
-    DECODE_A(instruction)
+    i32 result = (i32)stack[--sp] >> 16;
-    i32 result = (i32)locals[src1] >> 16;
+    stack[sp++] = result;
-    USED(src2);
-    locals[dest] = result;
     return true;
   }
   case OP_REAL_TO_NAT: {
-    DECODE_A(instruction)
+    u32 result = (u32)stack[--sp] >> 16;
-    u32 result = (u32)locals[src1] >> 16;
+    stack[sp++] = result;
-    USED(src2);
-    locals[dest] = result;
     return true;
   }
   case OP_BIT_SHIFT_LEFT: {
@@ -456,46 +372,23 @@ bool step_vm() {
   case OP_BIT_XOR: {
     MATH_OP_NO_CAST(^);
   }
-  case OP_JMP_IMM: {
+  case OP_JMP: {
-    DECODE_C(instruction)
+    u32 jmp_dest = stack[--sp];
-    pc = imm;
-    return true;
-  }
-  case OP_JMP_ABS: {
-    DECODE_A(instruction)
-    u32 jmp_dest = locals[dest];
     if (jmp_dest > cp) {
       status = 1;
       return true;
     }
-    USED(src1);
-    USED(src2);
-
-    pc = jmp_dest;
-    return true;
-  }
-  case OP_JMP_OFF: {
-    DECODE_A(instruction)
-    u32 jmp_dest = locals[dest] + locals[src1];
-    if (jmp_dest > cp) {
-      status = 1;
-      return true;
-    }
-    USED(src2);
 
     pc = jmp_dest;
     return true;
   }
   case OP_JMP_FLAG: {
-    DECODE_A(instruction)
     u32 mask;
-    u32 jmp_dest = locals[dest];
+    u32 jmp_dest = stack[--sp];
     if (jmp_dest > cp) {
       status = 1;
       return true;
     }
-    USED(src1);
-    USED(src2);
 
     mask = -(u32)(status == 0);
     pc = (jmp_dest & mask) | (pc & ~mask);
@@ -556,15 +449,12 @@ bool step_vm() {
     COMPARE_AND_JUMP(i32, <=);
   }
   case OP_INT_TO_STR: {
-    DECODE_A(instruction)
-    
     u32 i = MAX_LEN_INT32;
-    i32 v = (i32)locals[src1];
+    i32 v = (i32)stack[--sp];
     char buffer[MAX_LEN_INT32];
     i32 n = v;
     bool neg = n < 0;
-    USED(src2);
+    
-
     if (neg)
       n = -n;
 
@@ -579,18 +469,16 @@ bool step_vm() {
       buffer[--i] = '0';
 
     /* Copy from buffer[i] to buffer + MAX_LEN_INT32 */
-    locals[dest] = str_alloc(buffer + i, MAX_LEN_INT32 - i);
+    stack[sp++] = str_alloc(buffer + i, MAX_LEN_INT32 - i);
 
     return pc;
   }
   case OP_NAT_TO_STR: {
-    DECODE_A(instruction)
+    u32 v = (i32)stack[--sp];
-    
-    u32 v = (i32)locals[src1];
     char buffer[MAX_LEN_INT32];
     u32 n = v;
     u32 i = MAX_LEN_INT32;
-    USED(src2);
+
     do {
       buffer[--i] = radix_set[n % 10];
       n /= 10;
@@ -599,15 +487,13 @@ bool step_vm() {
     if (v == 0)
       buffer[--i] = '0';
     /* Copy from buffer[i] to buffer + MAX_LEN_INT32 */
-    locals[dest] = str_alloc(buffer + i, MAX_LEN_INT32 - i);
+    stack[sp++] = str_alloc(buffer + i, MAX_LEN_INT32 - i);
 
     return pc;
   }
   case OP_REAL_TO_STR: {
-    DECODE_A(instruction)
-    
     u32 i = 0, j = 0;
-    i32 q = (i32)locals[src1];
+    i32 q = (i32)stack[--sp];
     char buffer[MAX_LEN_INT32];
     u32 int_part, frac_part;
 
@@ -618,7 +504,6 @@ bool step_vm() {
 
     int_part = q >> 16;
     frac_part = q & 0xFFFF;
-    USED(src2);
 
     if (int_part == 0) {
       buffer[i++] = radix_set[0];
@@ -641,7 +526,7 @@ bool step_vm() {
       frac_part &= 0xFFFF;           
     }
 
-    locals[dest] = str_alloc(buffer + i, MAX_LEN_INT32 - i);
+    stack[sp++] = str_alloc(buffer + i, MAX_LEN_INT32 - i);
     
     return pc;
   }

vm/vm.h

@@ -3,115 +3,84 @@
 
 #include "libc.h"
 
-/**
- * Instruction Types
- *
- * A : [8:opcode][8:dest][8:src1][8:src2]
- * B : [8:opcode][8:dest][16:immediate]
- * C : [8:opcode][24:immediate]
- */
-#define DECODE_OP(instruction)      ((((u32)(instruction)) >> 24) & 0xFF)
-
-#define ENCODE_A(opcode, dest, src1, src2) ((((u32)(opcode) & 0xFF) << 24) | \
-					    (((u32)(dest) & 0xFF) << 16) | \
-					    (((u32)(src1) & 0xFF) << 8) | \
-					    (((u32)(src2) & 0xFF)))
-
-#define DECODE_A(instruction) \
-  u8 dest = (((u32)(instruction)) >> 16) & 0xFF; \
-  u8 src1 = (((u32)(instruction)) >> 8) & 0xFF; \
-  u8 src2 = ((u32)(instruction)) & 0xFF;
-
-#define ENCODE_B(opcode, dest, imm) ((((u32)(opcode) & 0xFF) << 24) | \
-				     (((u32)(dest) & 0xFF) << 16) | \
-				     (((u32)(imm)) & 0xFFFF))
-#define DECODE_B(instruction) \
-  u8 dest = (((u32)(instruction)) >> 16) & 0xFF;	\
-  u16 imm = ((u32)(instruction)) & 0xFFFF;
-
-#define ENCODE_C(opcode, imm)       ((((u32)(opcode) & 0xFF) << 24) | \
-				     (((u32)(imm)) & 0xFFFFFF))
-#define DECODE_C(instruction) \
-  u32 imm = ((u32)(instruction)) & 0xFFFFFF;
-
 typedef enum {
-  OP_HALT,           /* halt                 : A : all zeros        : halt execution */
+  OP_HALT,           /* - `halt`                            | halt execution */
-  OP_CALL,           /* call                 : A : dest args return : creates a new frame */  
+  OP_CALL,           /* ptr `call`                          | creates a new frame */  
-  OP_RETURN,         /* return               : B : dest return_flags: returns from a frame to the parent frame */
+  OP_RETURN,         /* - `return`                          | returns from a frame to the parent frame */
-  OP_SYSCALL,        /* syscall              : A : id args mem_ptr  : does a system call based on id with args  */
+  OP_SYSCALL,        /* id args mem_ptr `syscall` -         | id args mem_ptr  : does a system call based on id with args  */
-  OP_LOAD_IMM,       /* load_immediate       : B : locals[dest] = const as u16 */
+  OP_LOAD_8,         /* &dest `load-8` u8                   | push memory[obj1] onto stack as u8 */
-  OP_LOAD_UPPER_IMM, /* load_upper_immediate : B : locals[dest] = const as u32 << 16 | u16 */
+  OP_LOAD_16,        /* &dest `load-16` u16                 | push memory[obj1] onto stack as u16 */
-  OP_LOAD_IND_8,     /* load_indirect_8      : A : locals[dest] = memory[locals[src1]] as u8  */
+  OP_LOAD_32,        /* &dest `load` u32                    | push memory[obj1] onto stack as u32 */
-  OP_LOAD_IND_16,    /* load_indirect_16     : A : locals[dest] = memory[locals[src1]] as u16 */
+  OP_STORE_8,        /* &dest obj1 `store-8` -              | memory[dest] = obj1 << 8 */
-  OP_LOAD_IND_32,    /* load_indirect_32     : A : locals[dest] = memory[locals[src1]] as u32 */
+  OP_STORE_16,       /* &dest obj1 `store-16`-              | memory[dest] = obj1 << 16 */
-  OP_LOAD_OFF_8,     /* load_offset_8        : A : locals[dest] = memory[locals[src1] + locals[src2]] as u8 */
+  OP_STORE_32,       /* &dest obj1 `store`   -              | memory[dest] = obj1 */
-  OP_LOAD_OFF_16,    /* load_offset_16       : A : locals[dest] = memory[locals[src1] + locals[src2]] as u16 */
+  OP_MALLOC,         /* size `malloc` ptr                   | allocate 'size + 4' of memory and push ptr to memory on stack */
-  OP_LOAD_OFF_32,    /* load_offset_32       : A : locals[dest] = memory[locals[src1] + locals[src2]] as u32 */
+  OP_PUSH,           /* &local `get` obj1                   | get the value from the local slot */
-  OP_STORE_IND_8,    /* store_indirect_8     : A : memory[locals[dest]] = locals[src1] && 0xFF */
+  OP_POP,            /* - `pop` -                           | removes top item from the stack */
-  OP_STORE_IND_16,   /* store_indirect_16    : A : memory[locals[dest]] = locals[src1] && 0xFFFF*/
+  OP_SET,            /* obj1 &local `set` -                 | set the value of the local slot   */
-  OP_STORE_IND_32,   /* store_indirect_32    : A : memory[locals[dest]] = locals[src1] */
+  OP_DUP,            /* obj1 `dup` obj1 obj1                | duplicates the top of the stack */
-  OP_STORE_OFF_8,    /* store_offset_8       : A : memory[locals[dest] + locals[src2]] = locals[src1] && 0xFF */
+  OP_EXCH,           /* obj2 obj1 `exch` obj1 obj2          | swaps the top two values on the stack */
-  OP_STORE_OFF_16,   /* store_offset_16      : A : memory[locals[dest] + locals[src2]] = locals[src1] && 0xFFFF */
+  OP_OVER,           /* obj2 obj1 `over` obj2               | copys the 2nd to the top element and pushes to the stack */
-  OP_STORE_OFF_32,   /* store_offset_32      : A : memory[locals[dest] + locals[src2]] = locals[src1] */  
+  OP_PICK,           /* N `pick` objN                       | gets the nth element on the stack and pushes it on top */
-  OP_MEM_ALLOC,      /* alloc                : A : memory[dest] = [locals[src1] as size + 4] */
+  OP_ROT,            /* obj3 obj2 obj1 `rot` obj2 obj1 obj3 | takes the 3rd element and moves it to the top of the stack */
-  OP_MEM_CPY_8,      /* memcpy_8             : A : memory[src1..src1+src2] = memory[dest..dest+src2] */
+  OP_DEPTH,          /* - `depth` heap_count                | pushes the number of elements on the stack to the stack*/
-  OP_MEM_CPY_16,     /* memcpy_16            : A : memory[src1..src1+src2] = memory[dest..dest+src2] */
+  OP_MEM_ALLOC,      /* size `alloc` ptr                    | allocate 'size + 4' of memory and push ptr to memory on stack */
-  OP_MEM_CPY_32,     /* memcpy_32            : A : memory[src1..src1+src2] = memory[dest..dest+src2] */
+  OP_MEM_CPY_8,      /* size src dest `memcpy_8`  -         | memory[src..src+size] = memory[dest..dest+size] */
-  OP_MEM_SET_8,      /* memset_8             : A : memory[dest..dest+src2] = local[src1] as u8 */
+  OP_MEM_CPY_16,     /* size src dest `memcpy_16` -         | memory[src..src+size] = memory[dest..dest+size] */
-  OP_MEM_SET_16,     /* memset_16            : A : memory[dest..dest+src2] = local[src1] as u16 */
+  OP_MEM_CPY_32,     /* size src dest `memcpy_32` -         | memory[src..src+size] = memory[dest..dest+size] */
-  OP_MEM_SET_32,     /* memset_32            : A : memory[dest..dest+src2] = local[src1] as u32 */
+  OP_MEM_SET_8,      /* size src dest `memset_8`  -         | memory[dest..dest+size] = local[src] as u8 */
-  OP_MOV,            /* mov                  : A : locals[dest] = locals[src1] */
+  OP_MEM_SET_16,     /* size src dest `memset_16` -         | memory[dest..dest+size] = local[src] as u16 */
-  OP_PUSH,           /* push                 : B : push u32 value onto the childs locals */
+  OP_MEM_SET_32,     /* size src dest `memset_32` -         | memory[dest..dest+size] = local[src] as u32 */
-  OP_POP,            /* pop                  : C : pop u32 value off the stack (move MP back) */
+  OP_ADD_INT,        /* obj2 obj1 `add_int`  obj            | obj1 + obj2 then push result on stack */
-  OP_ADD_INT,        /* add_int              : A : locals[dest] = locals[src1] + locals[src2]  */
+  OP_SUB_INT,        /* obj2 obj1 `sub_int`  obj            | obj1 - obj2 then push result on stack */
-  OP_SUB_INT,        /* sub_int              : A : locals[dest] = locals[src1] - locals[src2]  */
+  OP_MUL_INT,        /* obj2 obj1 `mul_int`  obj            | obj1 * obj2 then push result on stack */
-  OP_MUL_INT,        /* mul_int              : A : locals[dest] = locals[src1] * locals[src2]  */
+  OP_DIV_INT,        /* obj2 obj1 `div_int`  obj            | obj1 / obj2 then push result on stack */
-  OP_DIV_INT,        /* div_int              : A : locals[dest] = locals[src1] / locals[src2]  */
+  OP_ADD_NAT,        /* obj2 obj1 `add_nat`  obj            | obj1 + obj2 then push result on stack */
-  OP_ADD_NAT,        /* add_nat              : A : locals[dest] = locals[src1] + locals[src2]  */
+  OP_SUB_NAT,        /* obj2 obj1 `sub_nat`  obj            | obj1 - obj2 then push result on stack */
-  OP_SUB_NAT,        /* sub_nat              : A : locals[dest] = locals[src1] - locals[src2]  */
+  OP_MUL_NAT,        /* obj2 obj1 `mul_nat`  obj            | obj1 * obj2 then push result on stack */
-  OP_MUL_NAT,        /* mul_nat              : A : locals[dest] = locals[src1] * locals[src2]  */
+  OP_DIV_NAT,        /* obj2 obj1 `div_nat`  obj            | obj1 / obj2 then push result on stack */
-  OP_DIV_NAT,        /* div_nat              : A : locals[dest] = locals[src1] / locals[src2]  */
+  OP_ADD_REAL,       /* obj2 obj1 `add_real` obj            | obj1 + obj2 then push result on stack */
-  OP_ADD_REAL,       /* add_real             : A : locals[dest] = locals[src1] + locals[src2]  */
+  OP_SUB_REAL,       /* obj2 obj1 `sub_real` obj            | obj1 - obj2 then push result on stack */
-  OP_SUB_REAL,       /* sub_real             : A : locals[dest] = locals[src1] - locals[src2]  */
+  OP_MUL_REAL,       /* obj2 obj1 `mul_real` obj            | obj1 * obj2 then push result on stack */
-  OP_MUL_REAL,       /* mul_real             : A : locals[dest] = locals[src1] * locals[src2]  */
+  OP_DIV_REAL,       /* obj2 obj1 `div_real` obj            | obj1 / obj2 then push result on stack */
-  OP_DIV_REAL,       /* div_real             : A : locals[dest] = locals[src1] / locals[src2]  */
+  OP_INT_TO_REAL,    /* obj1 `int_to_real` obj1 as real     | casts an int to a fixed number */
-  OP_INT_TO_REAL,    /* int_to_real          : A : locals[dest] = locals[src1] as real */
+  OP_INT_TO_NAT,     /* obj1 `int_to_nat`  obj1 as nat      | casts an int to a unsigned int */
-  OP_INT_TO_NAT,     /* int_to_nat           : A : locals[dest] = locals[src1] as nat */
+  OP_NAT_TO_REAL,    /* obj1 `nat_to_real` obj1 as real     | casts a unsigned int to a fixed number */
-  OP_NAT_TO_REAL,    /* nat_to_real          : A : locals[dest] = locals[src1] as real */
+  OP_NAT_TO_INT,     /* obj1 `nat_to_int`  obj1 as int      | casts a unsigned int to an int */
-  OP_NAT_TO_INT,     /* nat_to_int           : A : locals[dest] = locals[src1] as int */
+  OP_REAL_TO_INT,    /* obj1 `real_to_int` obj1 as int      | casts a fixed number to an int */
-  OP_REAL_TO_INT,    /* real_to_int          : A : locals[dest] = locals[src1] as int  */
+  OP_REAL_TO_NAT,    /* obj1 `real_to_nat` obj1 as nat      | casts a fixed number to an unsigned int */
-  OP_REAL_TO_NAT,    /* real_to_nat          : A : locals[dest] = locals[src1] as nat */
+  OP_BIT_SHIFT_LEFT, /* obj2 obj1 `bit_shift_left`  obj     | src1] << locals[src2] */
-  OP_BIT_SHIFT_LEFT, /* bit_shift_left       : A : locals[dest] = locals[src1] << locals[src2] */
+  OP_BIT_SHIFT_RIGHT,/* obj2 obj1 `bit_shift_right` obj     | src1] >> locals[src2] */
-  OP_BIT_SHIFT_RIGHT,/* bit_shift_right      : A : locals[dest] = locals[src1] >> locals[src2] */
+  OP_BIT_SHIFT_R_EXT,/* obj2 obj1 `bit_shift_r_ext` obj     | src1 >> src2 then cast result as i32 */
-  OP_BIT_SHIFT_R_EXT,/* bit_shift_r_ext      : A : locals[dest] as i32 = locals[src1] >> locals[src2] */
+  OP_BIT_AND,        /* obj2 obj1 `bit_and` obj             | obj1 & obj2 */
-  OP_BIT_AND,        /* bit_and              : A : locals[dest] = locals[src1] & locals[src2] */
+  OP_BIT_OR,         /* obj2 obj1 `bit_or`  obj             | obj1 | obj2 */
-  OP_BIT_OR,         /* bit_or               : A : locals[dest] = locals[src1] | locals[src2] */
+  OP_BIT_XOR,        /* obj2 obj1 `bit_xor` obj             | obj1 ^ obj2 */
-  OP_BIT_XOR,        /* bit_xor              : A : locals[dest] = locals[src1] ^ locals[src2] */
+  OP_JMP,            /* pc `jump`                           | jump unconditionally */
-  OP_JMP_IMM,        /* jump_immediate       : E : jump to imm unconditionally */
+  OP_JMP_FLAG,       /* pc `jump_if_flag`                   | jump to pc if flag > 0 */  
-  OP_JMP_ABS,        /* jump_absolute        : A : jump to locals[dest] unconditionally */
+  OP_JEQ_INT,        /* obj2 obj1 pc `jump_eq_int`          | jump to pc if obj1 as int == obj2 as int */
-  OP_JMP_OFF,        /* jump_offset          : A : jump to locals[dest] + locals[src1] unconditionally */
+  OP_JNE_INT,        /* obj2 obj1 pc `jump_neq_int`         | jump to pc if obj1 as int != obj2 as int */
-  OP_JMP_FLAG,       /* jump_if_flag         : A : jump to locals[dest] if flag > 0 */  
+  OP_JGT_INT,        /* obj2 obj1 pc `jump_gt_int`          | jump to pc if obj1 as int >  obj2 as int */
-  OP_JEQ_INT,        /* jump_eq_int          : A : jump to locals[dest] if locals[src1] as int == locals[src2] as int */
+  OP_JLT_INT,        /* obj2 obj1 pc `jump_lt_int`          | jump to pc if obj1 as int <  obj2 as int */
-  OP_JNE_INT,        /* jump_neq_int         : A : jump to locals[dest] if locals[src1] as int != locals[src2] as int */
+  OP_JLE_INT,        /* obj2 obj1 pc `jump_le_int`          | jump to pc if obj1 as int <= obj2 as int */
-  OP_JGT_INT,        /* jump_gt_int          : A : jump to locals[dest] if locals[src1] as int >  locals[src2] as int */
+  OP_JGE_INT,        /* obj2 obj1 pc `jump_ge_int`          | jump to pc if obj1 as int >= obj2 as int */
-  OP_JLT_INT,        /* jump_lt_int          : A : jump to locals[dest] if locals[src1] as int <  locals[src2] as int */
+  OP_JEQ_NAT,        /* obj2 obj1 pc `jump_eq_nat`          | jump to pc if obj1 as nat == obj2 as nat */
-  OP_JLE_INT,        /* jump_le_int          : A : jump to locals[dest] if locals[src1] as int <= locals[src2] as int */
+  OP_JNE_NAT,        /* obj2 obj1 pc `jump_neq_nat`         | jump to pc if obj1 as nat != obj2 as nat */
-  OP_JGE_INT,        /* jump_ge_int          : A : jump to locals[dest] if locals[src1] as int >= locals[src2] as int */
+  OP_JGT_NAT,        /* obj2 obj1 pc `jump_gt_nat`          | jump to pc if obj1 as nat >  obj2 as nat */
-  OP_JEQ_NAT,        /* jump_eq_nat          : A : jump to locals[dest] if locals[src1] as nat == locals[src2] as nat */
+  OP_JLT_NAT,        /* obj2 obj1 pc `jump_lt_nat`          | jump to pc if obj1 as nat <  obj2 as nat */
-  OP_JNE_NAT,        /* jump_neq_nat         : A : jump to locals[dest] if locals[src1] as nat != locals[src2] as nat */
+  OP_JLE_NAT,        /* obj2 obj1 pc `jump_le_nat`          | jump to pc if obj1 as nat <= obj2 as nat */
-  OP_JGT_NAT,        /* jump_gt_nat          : A : jump to locals[dest] if locals[src1] as nat >  locals[src2] as nat */
+  OP_JGE_NAT,        /* obj2 obj1 pc `jump_ge_nat`          | jump to pc if obj1 as nat >= obj2 as nat */
-  OP_JLT_NAT,        /* jump_lt_nat          : A : jump to locals[dest] if locals[src1] as nat <  locals[src2] as nat */
+  OP_JEQ_REAL,       /* obj2 obj1 pc `jump_eq_real`         | jump to pc if obj1 as real == obj2 as real */
-  OP_JLE_NAT,        /* jump_le_nat          : A : jump to locals[dest] if locals[src1] as nat <= locals[src2] as nat */
+  OP_JNE_REAL,       /* obj2 obj1 pc `jump_neq_real`        | jump to pc if obj1 as real != obj2 as real */
-  OP_JGE_NAT,        /* jump_ge_nat          : A : jump to locals[dest] if locals[src1] as nat >= locals[src2] as nat */
+  OP_JGE_REAL,       /* obj2 obj1 pc `jump_ge_real`         | jump to pc if obj1 as real >= obj2 as real */
-  OP_JEQ_REAL,       /* jump_eq_real         : A : jump to locals[dest] if locals[src1] as real == locals[src2] as real */
+  OP_JGT_REAL,       /* obj2 obj1 pc `jump_gt_real`         | jump to pc if obj1 as real >  obj2 as real */
-  OP_JNE_REAL,       /* jump_neq_real        : A : jump to locals[dest] if locals[src1] as real != locals[src2] as real */
+  OP_JLT_REAL,       /* obj2 obj1 pc `jump_lt_real`         | jump to pc if obj1 as real <  obj2 as real */
-  OP_JGE_REAL,       /* jump_ge_real         : A : jump to locals[dest] if locals[src1] as real >= locals[src2] as real */
+  OP_JLE_REAL,       /* obj2 obj1 pc `jump_le_real`         | jump to pc if obj1 as real <= obj2 as real */
-  OP_JGT_REAL,       /* jump_gt_real         : A : jump to locals[dest] if locals[src1] as real >  locals[src2] as real */
+  OP_INT_TO_STR,     /* obj1 `int-to-string`  str_ptr       | convert obj1 to str */
-  OP_JLT_REAL,       /* jump_lt_real         : A : jump to locals[dest] if locals[src1] as real <  locals[src2] as real */
+  OP_NAT_TO_STR,     /* obj1 `nat-to-string`  str_ptr       | convert obj1 to str */
-  OP_JLE_REAL,       /* jump_le_real         : A : jump to locals[dest] if locals[src1] as real <= locals[src2] as real */
+  OP_REAL_TO_STR,    /* obj1 `real-to-string` str_ptr       | convert obj1 to str */
-  OP_INT_TO_STR,     /* int_to_str           : A : locals[dest] = &mem[mp..] locals[src1] as str */
+  OP_STR_TO_INT,     /* str_ptr `string-to-int`  obj        | convert obj1 to int */
-  OP_NAT_TO_STR,     /* nat_to_str           : A : locals[dest] = &mem[mp..] locals[src1] as str */
+  OP_STR_TO_NAT,     /* str_ptr `string-to-nat`  obj        | convert obj1 to nat */
-  OP_REAL_TO_STR,    /* real_to_str          : A : locals[dest] = &mem[mp..] locals[src1] as str */
+  OP_STR_TO_REAL,    /* str_ptr `string-to-real` obj        | convert obj1 to real */
   OP_MAX_OPCODE      /* not an opcode count of instructions */
 } Opcode;
 
@@ -125,10 +94,12 @@ extern u32 pc;           /* program counter */
 extern u32 cp;           /* code pointer */
 extern u32 mp;           /* memory pointer */
 extern u32 fp;           /* frame pointer */
+extern u32 sp;           /* stack pointer */
 extern u8  lc;           /* child local count */
 extern u8 status;        /* status flag */
 extern u8 interrupt;     /* device interrupt */
-extern u32 *code;        /* code */
+extern u32 *stack;       /* stack */
+extern u8 *code;         /* code */
 extern u8 *mem;          /* memory */
 
 #define READ_U8(addr) (mem[addr])
@@ -160,31 +131,34 @@ extern u8 *mem;          /* memory */
       mem[addr + 3] = ((value) >> 24) & 0xFF;                       \
   } while (0)
 
+#define COMPARE_AND_JUMP(type, op)                                             \
+  do {                                                                         \
+    i32 cond;                                                                  \
+    u32 mask, target;                                                          \
+    type value;                                                                \
+    type value2;                                                               \
+    value2 = (type)stack[--sp];                                                \
+    value = (type)stack[--sp];                                                 \
+    target = stack[--sp];                                                      \
+    cond = !!(value op value2);                                                \
+    mask = -(u32)cond;                                                         \
+    pc = (target & mask) | (pc & ~mask);                                       \
+    return true;                                                               \
+  } while (0)
+
 #define MATH_OP(type, op)                                                      \
   do {                                                                         \
-    DECODE_A(instruction)                                                      \
+    type b = (type)stack[--sp];                                                \
-    locals[dest] = ((type)locals[src1] op (type)locals[src2]);			           \
+    type a = (type)stack[--sp];                                                \
+    stack[sp++] = (type)(a op b);                                              \
     return true;                                                               \
   } while (0)
 
 #define MATH_OP_NO_CAST(op)                                                    \
   do {                                                                         \
-    DECODE_A(instruction)                                                      \
+    u32 b = stack[--sp];                                                       \
-    locals[dest] = (locals[src1] op locals[src2]);			                       \
+    u32 a = stack[--sp];                                                       \
-    return true;                                                               \
+    stack[sp++] = a op b;                                                      \
-  } while (0)
-
-#define COMPARE_AND_JUMP(type, op)                                             \
-  do {                                                                         \
-    DECODE_A(instruction)                                                      \
-    i32 cond;                                                                  \
-    u32 mask;                                                                  \
-    u32 target = locals[dest];                                                 \
-    type value = (type)locals[src1];                                           \
-    type value2 = (type)locals[src2];                                          \
-    cond = !!(value op value2);                                                \
-    mask = -(u32)cond;                                                         \
-    pc = (target & mask) | (pc & ~mask);                                       \
     return true;                                                               \
   } while (0)