fix some memory leaks

.github/workflows/release.yml

@@ -12,6 +12,8 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v3
+        with:
+          submodules: recursive
 
       - name: Setup Python (needed for Conan)
         uses: actions/setup-python@v4

.gitignore

@@ -60,6 +60,4 @@ build
 *.yy.c
 *.yy.h
 
-out.arbin
-rand_test.ar
 __arcache__

.gitmodules

@@ -1,3 +1,9 @@
 [submodule "external/xxhash"]
 	path = external/xxhash
 	url = https://github.com/Cyan4973/xxHash.git
+[submodule "external/cwalk"]
+	path = external/cwalk
+	url = https://github.com/likle/cwalk.git
+[submodule "external/libdye"]
+	path = external/libdye
+	url = https://github.com/Ugric/libdye.git

CMakeLists.txt

@@ -30,7 +30,10 @@ add_custom_command(
 add_custom_target(GenerateLexer DEPENDS ${LEXER_C} ${LEXER_H})
 
 # Step 3: Add executable
-add_executable(argon ${CFILES} ${LEXER_C})
+add_executable(argon external/xxhash/xxhash.c external/cwalk/src/cwalk.c external/libdye/src/dye.c ${CFILES} ${LEXER_C})
+set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+target_include_directories(argon PRIVATE ${CMAKE_SOURCE_DIR}/external/cwalk/include)
+target_include_directories(argon PRIVATE ${CMAKE_SOURCE_DIR}/external/libdye/include)
 
 # Step 4: Build order
 add_dependencies(argon GenerateLexer)
@@ -56,3 +59,5 @@ target_link_libraries(argon PRIVATE
 target_include_directories(argon PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/src/lexer
 )
+
+add_custom_command(TARGET argon POST_BUILD COMMAND ${CMAKE_STRIP} $<TARGET_FILE:argon>)

Makefile

@@ -2,8 +2,8 @@ LEXER_SRC = src/lexer/lex.l
 LEXER_C = src/lexer/lex.yy.c
 LEXER_H = src/lexer/lex.yy.h
 
-CFILES = external/xxhash/xxhash.c $(shell find src -name '*.c')
-CFLAGS = $(ARCHFLAGS) -lm -lgc -lgmp -Wall -Wextra -Wno-unused-function
+CFILES = external/xxhash/xxhash.c external/cwalk/src/cwalk.c external/libdye/src/dye.c $(shell find src -name '*.c')
+CFLAGS = $(ARCHFLAGS) -lm -lgc -lgmp -Wall -Wextra -Wno-unused-function -Iexternal/cwalk/include -Iexternal/libdye/include
 BINARY = bin/argon
 
 all: $(BINARY)
@@ -15,6 +15,10 @@ $(BINARY): $(CFILES) $(LEXER_C) $(LEXER_H)
 	mkdir -p bin
 	gcc -O3 -o $(BINARY) $(CFILES) $(CFLAGS) -s
 
+native: $(CFILES) $(LEXER_C) $(LEXER_H)
+	mkdir -p bin
+	gcc -O3 -march=native -o $(BINARY) $(CFILES) $(CFLAGS)
+
 debug: $(CFILES) $(LEXER_C) $(LEXER_H)
 	mkdir -p bin
 	gcc -g -O0 -o $(BINARY) $(CFILES) $(CFLAGS)

gentest.py

@@ -1,7 +1,7 @@
 import random
-myfile = open("rand_test.ar","w")
+import sys
 
-for i in range(10000000):
-  myfile.write("\"")
-  myfile.write(str(random.random())[2::])
-  myfile.write("\"\n")
+for i in range(100000000):
+  sys.stdout.write("\"")
+  sys.stdout.write(str(random.random()))
+  sys.stdout.write("\"\n")

src/arobject.h

@@ -0,0 +1,52 @@
+#ifndef AROBJECT_H
+#define AROBJECT_H
+
+#include <gmp.h>
+#include "runtime/internals/dynamic_array_armem/darray_armem.h"
+
+typedef struct ArgonObject ArgonObject;  // forward declaration
+
+typedef enum ArgonType {
+  TYPE_NULL,
+  TYPE_BOOL,
+  TYPE_NUMBER,
+  TYPE_STRING,
+  TYPE_FUNCTION,
+  TYPE_NATIVE_FUNCTION,
+  TYPE_OBJECT,
+} ArgonType;
+
+struct string_struct {
+  char *data;
+  size_t length;
+};
+
+typedef struct Stack {
+  ArgonObject *scope;
+  struct Stack *prev;
+} Stack;
+
+struct argon_function_struct {
+  darray_armem bytecode;
+  Stack stack;
+  size_t number_of_parameters;
+  char **parameters;
+};
+
+// full definition of ArgonObject (no typedef again!)
+struct ArgonObject {
+  ArgonType type;
+  char *name;
+  ArgonObject *self;
+  ArgonObject *baseObject;
+  struct hashmap_GC *fields;
+  union {
+    mpq_t as_number;
+    bool as_bool;
+    struct string_struct as_str;
+    void *native_fn;
+    struct argon_function_struct argon_fn;
+  } value;
+};
+
+#endif // AROBJECT_H

src/err.c

@@ -0,0 +1,134 @@
+#include "err.h"
+#include "../external/libdye/include/dye.h"
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+const ArErr no_err = (ArErr){false};
+
+ArErr create_err(int64_t line, int64_t column, int length, char *path,
+                 const char *type, const char *fmt, ...) {
+  ArErr err;
+  err.exists = true;
+  err.path = path;
+  err.line = line;
+  err.column = column;
+  err.length = length;
+
+  // Copy error type safely
+  strncpy(err.type, type, sizeof(err.type) - 1);
+  err.type[sizeof(err.type) - 1] = '\0';
+
+  // Format error message
+  va_list args;
+  va_start(args, fmt);
+  vsnprintf(err.message, sizeof(err.message), fmt, args);
+  va_end(args);
+
+  return err;
+}
+
+void output_err(ArErr err) {
+  if (!err.exists)
+    return;
+  dye(stderr, DYE_WHITE, DYE_RED);
+  fprintf(stderr, "ERROR!");
+  dye(stderr, DYE_RESET, DYE_RESET);
+  fprintf(stderr, " ");
+  dyefg(stderr, DYE_RED);
+  dye_style(stderr, DYE_STYLE_BOLD);
+  fprintf(stderr, "%s", err.type);
+  dye_style(stderr, DYE_STYLE_RESET);
+  dyefg(stderr, DYE_RESET);
+  fprintf(stderr, ": ");
+  dyefg(stderr, DYE_RED);
+  fprintf(stderr, "%s", err.message);
+  dye_style(stderr, DYE_STYLE_RESET);
+  dyefg(stderr, DYE_RESET);
+  fprintf(stderr, "\n");
+
+  if (err.path && err.line) {
+    dyefg(stderr, DYE_GRAY);
+    fprintf(stderr, "  --> ");
+    dyefg(stderr, DYE_CYAN);
+    fprintf(stderr, "%s", err.path);
+    dyefg(stderr, DYE_GRAY);
+    fprintf(stderr, ":");
+    dyefg(stderr, DYE_YELLOW);
+    fprintf(stderr, "%zu", err.line);
+    dyefg(stderr, DYE_GRAY);
+    fprintf(stderr, ":");
+    dyefg(stderr, DYE_YELLOW);
+    fprintf(stderr, "%zu", err.column);
+    dye_style(stderr, DYE_STYLE_RESET);
+    dyefg(stderr, DYE_RESET);
+    fprintf(stderr, "\n");
+    FILE *file = fopen(err.path, "r");
+    if (file) {
+      dye_style(stderr, DYE_STYLE_RESET);
+      dyefg(stderr, DYE_RESET);
+      int line_number_width = snprintf(NULL, 0, "%zu", err.line);
+      char *buffer = NULL;
+      size_t size = 0;
+      int current_line = 1;
+      ssize_t len;
+
+      while ((len = getline(&buffer, &size, file)) != -1) {
+        if (current_line == err.line) {
+          break;
+        }
+        current_line++;
+      }
+      fprintf(stderr, "  ");
+      for (int i = 0; i < line_number_width; i++) {
+        fprintf(stderr, " ");
+      }
+      fprintf(stderr, "|\n");
+      getline(&buffer, &size, file);
+
+      char *line_starts = buffer;
+      while (*line_starts && isspace((unsigned char)*line_starts) && line_starts-buffer < err.column-1) {
+        line_starts++;
+        err.column--;
+      }
+      fprintf(stderr, " %zu | ", err.line);
+      if (err.length) {
+        fprintf(stderr, "%.*s", (int)err.column-1, line_starts);
+        dyefg(stderr, DYE_RED);
+        dye_style(stderr, DYE_STYLE_BOLD);
+        fprintf(stderr, "%.*s", err.length, line_starts + err.column - 1);
+        dye_style(stderr, DYE_STYLE_RESET);
+        dyefg(stderr, DYE_RESET);
+        fprintf(stderr, "%s", line_starts + (int)err.column + err.length - 1);
+        for (int64_t i = 0; i < err.column - 1; i++) {
+          fprintf(stderr, " ");
+        }
+      } else {
+        fprintf(stderr, "%s", line_starts);
+      }
+      free(buffer);
+      fprintf(stderr, "\n  ");
+      for (int i = 0; i < line_number_width; i++) {
+        fprintf(stderr, " ");
+      }
+      fprintf(stderr, "| ");
+
+      for (int i = 1; i < err.column; i++) {
+        fprintf(stderr, " ");
+      }
+      dyefg(stderr, DYE_RED);
+      dye_style(stderr, DYE_STYLE_BOLD);
+      for (int i = 0; i < err.length; i++) {
+        fprintf(stderr, "^");
+      }
+      dye_style(stderr, DYE_STYLE_RESET);
+      dyefg(stderr, DYE_RESET);
+      fprintf(stderr, "\n");
+    }
+  }
+}

src/err.h

@@ -0,0 +1,7 @@
+#include "returnTypes.h"
+
+extern const ArErr no_err;
+
+ArErr create_err(int64_t line, int64_t column, int length, char *path, const char *type,
+                 const char *fmt, ...);
+void output_err(ArErr err);

src/hashmap/hashmap.c

@@ -6,8 +6,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <stdlib.h>
-
 
 struct hashmap *createHashmap() {
   size_t size = 8;
@@ -20,7 +18,8 @@ struct hashmap *createHashmap() {
 }
 
 void hashmap_free(struct hashmap *t, free_val_func free_val) {
-    if (!t) return;
+  if (!t)
+    return;
 
   for (size_t i = 0; i < t->size; i++) {
     struct node *current = t->list[i];
@@ -56,13 +55,15 @@ void resize_hashmap(struct hashmap *t) {
     while (temp) {
       hashmap_insert(t, temp->hash, temp->key, temp->val,
                      temp->order); // Will increment count
+      struct node *temp_temp = temp;
       temp = temp->next;
+      free(temp_temp);
     }
   }
   free(old_list);
 }
 
-int hashCode(struct hashmap *t, uint64_t hash) { return hash % t->size; }
+int hashCode(struct hashmap *t, uint64_t hash) { return hash & (t->size - 1); }
 
 int hashmap_remove(struct hashmap *t, uint64_t hash) {
   int pos = hashCode(t, hash);
@@ -86,8 +87,8 @@ int hashmap_remove(struct hashmap *t, uint64_t hash) {
   return 0;
 }
 
-void hashmap_insert(struct hashmap *t, uint64_t hash, void *key,
-                    void *val, size_t order) {
+void hashmap_insert(struct hashmap *t, uint64_t hash, void *key, void *val,
+                    size_t order) {
   if (!order) {
     order = t->order++;
   }

src/hashmap/hashmap.h

@@ -3,8 +3,6 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-typedef struct ArgonObject ArgonObject;
-
 typedef void (*free_val_func)(void *val);
 
 struct node {

src/lexer/lex.l

@@ -108,8 +108,6 @@ int yywrap(void * unused_param) {
 #[^\n]*        { /* skip comment */ }
 
 .   {
-    GET_STATE
-    fprintf(stderr, "%s:%zu:%zu error: unexpected character '%s'\n", state->path, state->current_line+1, COLUMN_NO+1, yytext);
-    exit(1);
+    return TOKEN_INVALID;
 }
 %%

src/lexer/lexer.c

@@ -1,8 +1,8 @@
 #include "lexer.h"
-#include "lex.yy.h"
 #include "../string/string.h"
+#include "lex.yy.h"
 
-void lexer(LexerState state) {
+ArErr lexer(LexerState state) {
   size_t line = 1;
   size_t column = 1;
   int ch;
@@ -32,13 +32,16 @@ void lexer(LexerState state) {
 
   int token;
   while ((token = yylex(scanner)) != 0) {
-    Token token_struct = (Token){
-      token,
-      state.current_line+1,
-      state.current_column+1,
-      yyget_leng(scanner),
-      cloneString(yyget_text(scanner))
-    };
+    if (token == TOKEN_INVALID) {
+      ArErr err = create_err(state.current_line + 1, state.current_column + 1,
+                        yyget_leng(scanner), state.path, "Syntax Error",
+                        "Invalid Token '%s'", yyget_text(scanner));
+      yylex_destroy(scanner);
+      return err;
+    }
+    Token token_struct =
+        (Token){token, state.current_line + 1, state.current_column + 1,
+                yyget_leng(scanner), cloneString(yyget_text(scanner))};
     darray_push(state.tokens, &token_struct);
     if (token == TOKEN_NEW_LINE) {
       state.current_line += 1;
@@ -48,4 +51,5 @@ void lexer(LexerState state) {
     }
   }
   yylex_destroy(scanner);
+  return no_err;
 }

src/lexer/lexer.h

@@ -4,9 +4,10 @@
 #include "../dynamic_array/darray.h"
 #include "token.h"
 #include <stdio.h>
+#include "../err.h"
 
 typedef struct {
-  const char *path;
+  char *path;
   FILE *file;
   size_t current_line;
   size_t current_column;
@@ -14,6 +15,6 @@ typedef struct {
   // add more fields as needed
 } LexerState;
 
-void lexer(LexerState state);
+ArErr lexer(LexerState state);
 
 #endif // LEXER_H

src/lexer/token.h

@@ -72,6 +72,7 @@ typedef enum {
   TOKEN_COMMA,
   TOKEN_COLON,
   TOKEN_EXCLAMATION,
+  TOKEN_INVALID,
 } TokenType;
 
 typedef struct {

src/main.c

@@ -26,8 +26,45 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 #endif
+#include "../external/cwalk/include/cwalk.h"
 #include <string.h>
 
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <limits.h>
+#include <unistd.h>
+#endif
+#include "err.h"
+
+char *get_current_directory() {
+  char *buffer = NULL;
+
+#ifdef _WIN32
+  DWORD size = GetCurrentDirectoryA(0, NULL);
+  buffer = malloc(size);
+  if (buffer == NULL)
+    return NULL;
+  if (GetCurrentDirectoryA(size, buffer) == 0) {
+    free(buffer);
+    return NULL;
+  }
+#else
+  long size = pathconf(".", _PC_PATH_MAX);
+  if (size == -1)
+    size = 4096; // fallback
+  buffer = malloc(size);
+  if (buffer == NULL)
+    return NULL;
+  if (getcwd(buffer, size) == NULL) {
+    free(buffer);
+    return NULL;
+  }
+#endif
+
+  return buffer;
+}
+
 int ensure_dir_exists(const char *path) {
   struct stat st = {0};
 
@@ -41,126 +78,22 @@ int ensure_dir_exists(const char *path) {
   return 0;
 }
 
-char *normalize_path(char *path) {
-#ifdef _WIN32
-  for (char *p = path; *p; p++) {
-    if (*p == '/') {
-      *p = '\\';
-    }
-  }
-#endif
-  return path;
-}
-
-// Join two paths using '/' as separator, no platform checks here.
-int path_join(char *dest, size_t dest_size, const char *path1,
-              const char *path2) {
-  size_t len1 = strlen(path1);
-  size_t len2 = strlen(path2);
-
-  // Check if buffer is large enough (extra 2 for '/' and '\0')
-  if (len1 + len2 + 2 > dest_size)
-    return -1;
-
-  strcpy(dest, path1);
-
-  // Add '/' if needed
-  if (len1 > 0 && dest[len1 - 1] != '/') {
-    dest[len1] = '/';
-    dest[len1 + 1] = '\0';
-    len1++;
-  }
-
-  // Skip leading '/' in path2 to avoid double separator
-  if (len2 > 0 && path2[0] == '/') {
-    path2++;
-    len2--;
-  }
-
-  strcat(dest, path2);
-
-  return 0;
-}
-
 const char CACHE_FOLDER[] = "__arcache__";
 const char FILE_IDENTIFIER[5] = "ARBI";
 const char BYTECODE_EXTENTION[] = "arbin";
 const uint32_t version_number = 0;
 
-#ifdef _WIN32
-#define PATH_SEP '\\'
-#else
-#define PATH_SEP '/'
-#endif
-
-char *replace_extension(const char *path, const char *new_ext) {
-  // Defensive: if new_ext doesn't start with '.', add it
-  int need_dot = (new_ext[0] != '.');
-
-  // Find last path separator to avoid changing dots in folder names
-  const char *last_sep = strrchr(path, PATH_SEP);
-#ifdef _WIN32
-  // Windows can have '/' too as separator in practice, check it
-  const char *last_alt_sep = strrchr(path, '/');
-  if (last_alt_sep && (!last_sep || last_alt_sep > last_sep)) {
-    last_sep = last_alt_sep;
-  }
-#endif
-
-  // Find last '.' after last_sep (if any)
-  const char *last_dot = strrchr(path, '.');
-  if (last_dot && (!last_sep || last_dot > last_sep)) {
-    // Extension found: copy path up to last_dot, then append new_ext
-    size_t base_len = last_dot - path;
-    size_t ext_len = strlen(new_ext) + (need_dot ? 1 : 0);
-    size_t new_len = base_len + ext_len + 1;
-
-    char *result = malloc(new_len);
-    if (!result)
-      return NULL;
-
-    memcpy(result, path, base_len);
-
-    if (need_dot)
-      result[base_len] = '.';
-
-    strcpy(result + base_len + (need_dot ? 1 : 0), new_ext);
-
-    return result;
-  } else {
-    // No extension found: append '.' + new_ext (if needed)
-    size_t path_len = strlen(path);
-    size_t ext_len = strlen(new_ext) + (need_dot ? 1 : 0);
-    size_t new_len = path_len + ext_len + 1;
-
-    char *result = malloc(new_len);
-    if (!result)
-      return NULL;
-
-    strcpy(result, path);
-
-    if (need_dot)
-      strcat(result, ".");
-
-    strcat(result, new_ext);
-
-    return result;
-  }
-}
-
 int load_cache(Translated *translated_dest, char *joined_paths, uint64_t hash) {
   FILE *bytecode_file = fopen(joined_paths, "rb");
   if (!bytecode_file)
     return 1;
-  char file_identifier_from_cache[sizeof(FILE_IDENTIFIER)];
-  file_identifier_from_cache[strlen(FILE_IDENTIFIER)] = '\0';
+  char file_identifier_from_cache[sizeof(FILE_IDENTIFIER)] = {0};
   if (fread(&file_identifier_from_cache, 1,
             sizeof(file_identifier_from_cache) - 1,
             bytecode_file) != sizeof(file_identifier_from_cache) - 1 ||
       memcmp(file_identifier_from_cache, FILE_IDENTIFIER,
              sizeof(file_identifier_from_cache)) != 0) {
-    fclose(bytecode_file);
-    return 1;
+    goto FAILED;
   }
 
   uint32_t read_version;
@@ -228,19 +161,44 @@ FAILED:
   return 1;
 }
 
-int main(int argc, char *argv[]) {
-  generate_siphash_key(siphash_key);
+Execution execute(char *absolute_path) {
   clock_t start, end;
   double time_spent, total_time_spent = 0;
-  setlocale(LC_ALL, "");
-  if (argc <= 1)
-    return -1;
-  ar_memory_init();
-  char *path = argv[1];
 
-  FILE *file = fopen(path, "r");
+  const char *basename_ptr;
+  size_t basename_length;
+  cwk_path_get_basename(absolute_path, &basename_ptr, &basename_length);
+
+  if (!basename_ptr)
+    return (Execution){create_err(0, 0, 0, NULL, "Path Error",
+                                  "path has no basename '%s'", absolute_path),
+                       (Stack){NULL, NULL}};
+
+  char basename[FILENAME_MAX];
+  memcpy(basename, basename_ptr, basename_length);
+
+  size_t parent_directory_length;
+  cwk_path_get_dirname(absolute_path, &parent_directory_length);
+
+  char parent_directory[FILENAME_MAX];
+  memcpy(parent_directory, absolute_path, parent_directory_length);
+  parent_directory[parent_directory_length] = '\0';
+
+  char cache_folder_path[FILENAME_MAX];
+  cwk_path_join(parent_directory, CACHE_FOLDER, cache_folder_path,
+                sizeof(cache_folder_path));
+
+  char cache_file_path[FILENAME_MAX];
+  cwk_path_join(cache_folder_path, basename, cache_file_path,
+                sizeof(cache_file_path));
+  cwk_path_change_extension(cache_file_path, BYTECODE_EXTENTION,
+                            cache_file_path, sizeof(cache_file_path));
+
+  FILE *file = fopen(absolute_path, "r");
   if (!file) {
-    return -1;
+    return (Execution){create_err(0, 0, 0, NULL, "File Error",
+                                  "Unable to open file '%s'", absolute_path),
+                       (Stack){NULL, NULL}};
   }
 
   XXH3_state_t *hash_state = XXH3_createState();
@@ -255,30 +213,23 @@ int main(int argc, char *argv[]) {
   uint64_t hash = XXH3_64bits_digest(hash_state);
   XXH3_freeState(hash_state);
 
-  char *filename_without_extention =
-      replace_extension(path, BYTECODE_EXTENTION);
-
-  size_t joined_paths_length =
-      strlen(CACHE_FOLDER) + strlen(filename_without_extention) + 2;
-  char *joined_paths = checked_malloc(joined_paths_length);
-
-  path_join(joined_paths, joined_paths_length, CACHE_FOLDER,
-            filename_without_extention);
-  free(filename_without_extention);
-  filename_without_extention = NULL;
-
   Translated translated = init_translator();
 
-  if (load_cache(&translated, joined_paths, hash) != 0) {
+  if (load_cache(&translated, cache_file_path, hash) != 0) {
     free_translator(&translated);
     translated = init_translator();
 
     DArray tokens;
     darray_init(&tokens, sizeof(Token));
 
-    LexerState state = {path, file, 0, 0, &tokens};
+    LexerState state = {absolute_path, file, 0, 0, &tokens};
     start = clock();
-    lexer(state);
+    ArErr err = lexer(state);
+    if (err.exists) {
+      free_translator(&translated);
+      darray_free(&tokens, free_token);
+      return (Execution){err, (Stack){NULL, NULL}};
+    }
     end = clock();
     time_spent = (double)(end - start) / CLOCKS_PER_SEC;
     total_time_spent += time_spent;
@@ -290,7 +241,13 @@ int main(int argc, char *argv[]) {
     darray_init(&ast, sizeof(ParsedValue));
 
     start = clock();
-    parser(path, &ast, &tokens, false);
+    err = parser(absolute_path, &ast, &tokens, false);
+    if (err.exists) {
+      free_translator(&translated);
+      darray_free(&tokens, free_token);
+      darray_free(&ast, free_parsed);
+      return (Execution){err, (Stack){NULL, NULL}};
+    }
     end = clock();
     time_spent = (double)(end - start) / CLOCKS_PER_SEC;
     total_time_spent += time_spent;
@@ -305,9 +262,9 @@ int main(int argc, char *argv[]) {
     printf("Translation time taken: %f seconds\n", time_spent);
 
     darray_free(&ast, free_parsed);
-    ensure_dir_exists(CACHE_FOLDER);
+    ensure_dir_exists(cache_folder_path);
 
-    file = fopen(joined_paths, "wb");
+    file = fopen(cache_file_path, "wb");
 
     uint64_t constantsSize = (uint64_t)translated.constants.size;
     uint64_t bytecodeSize = (uint64_t)translated.bytecode.size;
@@ -330,11 +287,11 @@ int main(int argc, char *argv[]) {
     fclose(file);
   }
 
-  init_types();
-
   start = clock();
-  runtime(translated);
-
+  RuntimeState state = init_runtime_state(translated);
+  Stack main_scope = create_scope(NULL);
+  ArErr err = runtime(translated, state, main_scope);
+  free(state.registers);
   end = clock();
   time_spent = (double)(end - start) / CLOCKS_PER_SEC;
   total_time_spent += time_spent;
@@ -342,6 +299,25 @@ int main(int argc, char *argv[]) {
   printf("total time taken: %f seconds\n", total_time_spent);
 
   free_translator(&translated);
-  free(joined_paths);
+  return (Execution){err, main_scope};
+}
+
+int main(int argc, char *argv[]) {
+  setlocale(LC_ALL, "");
+  ar_memory_init();
+  generate_siphash_key(siphash_key);
+  init_types();
+  char *CWD = get_current_directory();
+  if (argc <= 1)
+    return -1;
+  char *path_non_absolute = argv[1];
+  char path[FILENAME_MAX];
+  cwk_path_get_absolute(CWD, path_non_absolute, path, sizeof(path));
+  free(CWD);
+  Execution resp = execute(path);
+  if (resp.err.exists) {
+    output_err(resp.err);
+    return -1;
+  }
   return 0;
 }

src/parser/assignable/access/access.c

@@ -1,51 +1,72 @@
 #include "access.h"
 #include "../../../lexer/token.h"
 #include "../../../memory.h"
-#include "../../string/string.h"
 #include "../../parser.h"
+#include "../../string/string.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-ParsedValue *parse_access(char *file, DArray *tokens, size_t *index,
+ParsedValueReturn parse_access(char *file, DArray *tokens, size_t *index,
                                ParsedValue *to_access) {
   Token *first_token = darray_get(tokens, *index);
   (*index)++;
   ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
   ParsedAccess *parsedAccess = checked_malloc(sizeof(ParsedAccess));
   parsedAccess->to_access = *to_access;
+  parsedValue->type = AST_ACCESS;
+  parsedValue->data = parsedAccess;
   free(to_access);
   darray_init(&parsedAccess->access, sizeof(ParsedValue));
   if (first_token->type == TOKEN_DOT) {
     error_if_finished(file, tokens, index);
     Token *token = darray_get(tokens, *index);
-    ParsedValue *parsedString = parse_string(token, false);
-    darray_push(&parsedAccess->access, parsedString);
-    free(parsedString);
+    ParsedValueReturn parsedString = parse_string(token, false);
+    if (parsedString.err.exists) {
+      free_parsed(parsedValue);
+      free(parsedValue);
+      return parsedString;
+    }
+    darray_push(&parsedAccess->access, parsedString.value);
+    free(parsedString.value);
+    parsedAccess->access_fields = true;
   } else {
+    parsedAccess->access_fields = false;
+    Token *token = first_token;
     while (true) {
       skip_newlines_and_indents(tokens, index);
       error_if_finished(file, tokens, index);
-      ParsedValue *parsedValue = parse_token(file, tokens, index, true);
+      ParsedValueReturn parsedAccessValue =
+          parse_token(file, tokens, index, true);
+      if (parsedAccessValue.err.exists) {
+        free_parsed(parsedValue);
+        free(parsedValue);
+        return parsedAccessValue;
+      } else if (!parsedAccessValue.value) {
+        free_parsed(parsedValue);
+        free(parsedValue);
+        return (ParsedValueReturn){
+            create_err(token->line, token->column, token->length, file,
+                       "Syntax Error", "expected value"),
+            NULL};
+      }
       darray_push(&parsedAccess->access, parsedValue);
       free(parsedValue);
       skip_newlines_and_indents(tokens, index);
       error_if_finished(file, tokens, index);
-      Token *token = darray_get(tokens, *index);
+      token = darray_get(tokens, *index);
       if (token->type == TOKEN_RBRACKET) {
         break;
       } else if (token->type != TOKEN_COLON) {
-        fprintf(stderr, "%s:%zu:%zu error: syntax error\n", file,
-                token->line, token->column);
+        fprintf(stderr, "%s:%zu:%zu error: syntax error\n", file, token->line,
+                token->column);
         exit(EXIT_FAILURE);
       }
       (*index)++;
     }
   }
-  parsedValue->type = AST_ACCESS;
-  parsedValue->data = parsedAccess;
   (*index)++;
-  return parsedValue;
+  return (ParsedValueReturn){no_err, parsedValue};
 }
 
 void free_parse_access(void *ptr) {

src/parser/assignable/access/access.h

@@ -5,11 +5,13 @@
 
 typedef struct {
   ParsedValue to_access;
+  bool access_fields;
   DArray access;
 } ParsedAccess;
 
 // Function declaration for parsing an identifier
-ParsedValue *parse_access(char*file,DArray *tokens, size_t * index, ParsedValue * to_access);
+ParsedValueReturn parse_access(char *file, DArray *tokens, size_t *index,
+                          ParsedValue *to_access);
 
 void free_parse_access(void *ptr);
 

src/parser/assignable/assign/assign.c

@@ -7,8 +7,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-ParsedValue *parse_assign(char *file, DArray *tokens, ParsedValue *assign_to,
-                          size_t *index) {
+ParsedValueReturn parse_assign(char *file, DArray *tokens,
+                               ParsedValue *assign_to, size_t *index) {
   Token *token = darray_get(tokens, *index);
   switch (assign_to->type) {
   case AST_IDENTIFIER:
@@ -18,36 +18,53 @@ ParsedValue *parse_assign(char *file, DArray *tokens, ParsedValue *assign_to,
     ParsedCall *call = assign_to->data;
     for (size_t i = 0; i < call->args.size; i++) {
       if (((ParsedValue *)darray_get(&call->args, i))->type != AST_IDENTIFIER) {
-        fprintf(stderr,
-                "%s:%zu:%zu error: parameter names need to start with a letter "
+        free_parsed(assign_to);
+        free(assign_to);
+        return (ParsedValueReturn){
+            create_err(
+                token->line, token->column, token->length, file, "Syntax Error",
+                "parameter names need to start with a letter "
                 "or _, "
-                "only use letters, digits, or _, and can't be keywords.\n",
-                file, token->line, token->column);
-        exit(EXIT_FAILURE);
+                "only use letters, digits, or _, and can't be keywords."),
+            NULL};
       }
     }
     break;
-  default:
-    fprintf(stderr, "%s:%zu:%zu error: can't assign to %s\n", file, token->line,
-            token->column, ValueTypeNames[assign_to->type]);
-    exit(EXIT_FAILURE);
+  default:;
+    ArErr err = create_err(token->line, token->column,
+                                          token->length, file, "Syntax Error",
+                                          "can't assign to %s",
+                                          ValueTypeNames[assign_to->type]);
+    free_parsed(assign_to);
+    free(assign_to);
+    return (ParsedValueReturn){err,
+                               NULL};
   }
   ParsedAssign *assign = checked_malloc(sizeof(ParsedAssign));
   assign->to = assign_to;
   assign->type = token->type;
-  (*index)++;
-  error_if_finished(file, tokens, index);
-  token = darray_get(tokens, *index);
-  assign->from = parse_token(file, tokens, index, true);
-  if (!assign->from) {
-    fprintf(stderr, "%s:%zu:%zu error: syntax error\n", file, token->line,
-            token->column);
-    exit(EXIT_FAILURE);
-  }
   ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
   parsedValue->type = AST_ASSIGN;
   parsedValue->data = assign;
-  return parsedValue;
+  (*index)++;
+  error_if_finished(file, tokens, index);
+  token = darray_get(tokens, *index);
+  ParsedValueReturn from = parse_token(file, tokens, index, true);
+  if (from.err.exists) {
+    free_parsed(parsedValue);
+    free(parsedValue);
+    return from;
+  }
+  assign->from = from.value;
+  if (!assign->from) {
+    free_parsed(parsedValue);
+    free(parsedValue);
+    return (ParsedValueReturn){create_err(token->line, token->column,
+                                          token->length, file, "Syntax Error",
+                                          "expected body"),
+                               NULL};
+  }
+  return (ParsedValueReturn){no_err, parsedValue};
 }
 
 void free_parse_assign(void *ptr) {
@@ -55,7 +72,9 @@ void free_parse_assign(void *ptr) {
   ParsedAssign *parsedAssign = parsedValue->data;
   free_parsed(parsedAssign->to);
   free(parsedAssign->to);
+  if (parsedAssign->from) {
     free_parsed(parsedAssign->from);
     free(parsedAssign->from);
+  }
   free(parsedAssign);
 }

src/parser/assignable/assign/assign.h

@@ -9,8 +9,8 @@ typedef struct {
   ParsedValue * from;
 } ParsedAssign;
 
-ParsedValue *parse_assign(char*file, DArray *tokens,
-                          ParsedValue *assign_to, size_t *index);
+ParsedValueReturn parse_assign(char *file, DArray *tokens, ParsedValue *assign_to,
+                          size_t *index);
 
 void free_parse_assign(void*ptr);
 

src/parser/assignable/call/call.c

@@ -6,7 +6,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-ParsedValue *parse_call(char *file, DArray *tokens, size_t *index,
+ParsedValueReturn parse_call(char *file, DArray *tokens, size_t *index,
                              ParsedValue *to_call) {
   ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
   ParsedCall *call = checked_malloc(sizeof(ParsedCall));
@@ -21,9 +21,26 @@ ParsedValue *parse_call(char *file, DArray *tokens, size_t *index,
     while ((*index) < tokens->size) {
       skip_newlines_and_indents(tokens, index);
       error_if_finished(file, tokens, index);
-      ParsedValue *parsedArg = parse_token(file, tokens, index, true);
-      darray_push(&call->args, parsedArg);
-      free(parsedArg);
+      ParsedValueReturn parsedArg = parse_token(file, tokens, index, true);
+      if (parsedArg.err.exists) {
+        free_parsed(to_call);
+        free(to_call);
+        free_parsed(parsedValue);
+        free(parsedValue);
+        return parsedArg;
+      } else if (!parsedArg.value) {
+        free_parsed(to_call);
+        free(to_call);
+        free_parsed(parsedValue);
+        free(parsedValue);
+
+        return (ParsedValueReturn){
+            create_err(token->line, token->column, token->length, file,
+                       "Syntax Error", "expected argument"),
+            NULL};
+      }
+      darray_push(&call->args, parsedArg.value);
+      free(parsedArg.value);
       error_if_finished(file, tokens, index);
       skip_newlines_and_indents(tokens, index);
       error_if_finished(file, tokens, index);
@@ -40,7 +57,7 @@ ParsedValue *parse_call(char *file, DArray *tokens, size_t *index,
     }
   }
   (*index)++;
-  return parsedValue;
+  return (ParsedValueReturn){no_err, parsedValue};
 }
 
 void free_parse_call(void *ptr) {

src/parser/assignable/call/call.h

@@ -9,7 +9,7 @@ typedef struct {
 } ParsedCall;
 
 // Function declaration for parsing an identifier
-ParsedValue *parse_call(char *file, DArray *tokens, size_t *index,
+ParsedValueReturn parse_call(char *file, DArray *tokens, size_t *index,
                         ParsedValue *to_call);
 void free_parse_call(void *ptr);
 

src/parser/assignable/identifier/identifier.c

@@ -4,9 +4,9 @@
 #include <string.h>
 #include "../../../memory.h"
 
-ParsedValue *parse_identifier(Token *token) {
+ParsedValueReturn parse_identifier(Token *token) {
   ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
   parsedValue->type = AST_IDENTIFIER;
   parsedValue->data = strcpy(checked_malloc(strlen(token->value) + 1), token->value);
-  return parsedValue;
+  return (ParsedValueReturn){no_err, parsedValue};
 }

src/parser/assignable/identifier/identifier.h

@@ -4,6 +4,6 @@
 #include "../../../lexer/token.h"  // for Token
 
 // Function declaration for parsing an identifier
-ParsedValue * parse_identifier(Token * token);
+ParsedValueReturn parse_identifier(Token *token);
 
 #endif // IDENTIFIER_H

src/parser/declaration/declaration.c

@@ -1,4 +1,6 @@
 #include "declaration.h"
+#include "../../hash_data/hash_data.h"
+#include "../../hashmap/hashmap.h"
 #include "../../lexer/token.h"
 #include "../../memory.h"
 #include "../function/function.h"
@@ -8,7 +10,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) {
+ParsedValueReturn parse_declaration(char *file, DArray *tokens, size_t *index) {
   (*index)++;
   error_if_finished(file, tokens, index);
   Token *token = darray_get(tokens, *index);
@@ -23,24 +25,28 @@ ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) {
     darray_push(declarations, &_declaration);
     ParsedSingleDeclaration *declaration =
         darray_get(declarations, declarations->size - 1);
-    bool isFunction=false;
+    bool isFunction = false;
     DArray parameters;
     declaration->from = parse_null();
 
     if (token->type != TOKEN_IDENTIFIER) {
-      fprintf(stderr, "%s:%zu:%zu error: declaration requires an identifier\n",
-              file, token->line, token->column);
-      exit(EXIT_FAILURE);
+      free_parsed(parsedValue);
+      free(parsedValue);
+      return (ParsedValueReturn){
+          create_err(token->line, token->column, token->length, file,
+                     "Syntax Error", "declaration requires an identifier"),
+          NULL};
     }
     declaration->name =
         strcpy(checked_malloc(strlen(token->value) + 1), token->value);
 
     (*index)++;
     if ((*index) >= tokens->size)
-      return parsedValue;
+      return (ParsedValueReturn){no_err, parsedValue};
     token = darray_get(tokens, *index);
     if (token->type == TOKEN_LPAREN) {
       isFunction = true;
+      struct hashmap *parameters_hashmap = createHashmap();
       darray_init(&parameters, sizeof(char *));
       (*index)++;
       error_if_finished(file, tokens, index);
@@ -48,7 +54,7 @@ ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) {
       if (token->type == TOKEN_RPAREN) {
         (*index)++;
         if ((*index) >= tokens->size)
-          return parsedValue;
+          return (ParsedValueReturn){no_err, parsedValue};
         token = darray_get(tokens, *index);
       } else {
         while ((*index) < tokens->size) {
@@ -56,15 +62,32 @@ ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) {
           error_if_finished(file, tokens, index);
           token = darray_get(tokens, *index);
           if (token->type != TOKEN_IDENTIFIER) {
-            fprintf(stderr,
-                    "%s:%zu:%zu error: parameter names need to start with a "
-                    "letter or _, only use letters, digits, or _, and can't be "
-                    "keywords.\n",
-                    file, token->line, token->column);
-            exit(EXIT_FAILURE);
+            free_parsed(parsedValue);
+            free(parsedValue);
+            return (ParsedValueReturn){
+                create_err(
+                    token->line, token->column, token->length, file,
+                    "Syntax Error",
+                    "parameter names need to start with a letter or _, only "
+                    "use letters, digits, or _, and can't be keywords."),
+                NULL};
           }
-          char *parameter_name = checked_malloc(strlen(token->value) + 1);
+          uint64_t hash =
+              siphash64_bytes(token->value, token->length, siphash_key);
+          if (hashmap_lookup(parameters_hashmap, hash) != NULL) {
+            free_parsed(parsedValue);
+            free(parsedValue);
+            return (ParsedValueReturn){
+                create_err(token->line, token->column, token->length, file,
+                           "Syntax Error",
+                           "duplicate argument in function "
+                           "definition"),
+                NULL};
+          }
+          char *parameter_name = checked_malloc(token->length + 1);
           strcpy(parameter_name, token->value);
+          hashmap_insert(parameters_hashmap, hash, parameter_name, (void *)1,
+                         0);
           darray_push(&parameters, &parameter_name);
           (*index)++;
           error_if_finished(file, tokens, index);
@@ -74,18 +97,22 @@ ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) {
           if (token->type == TOKEN_RPAREN) {
             (*index)++;
             if ((*index) >= tokens->size)
-              return parsedValue;
+              return (ParsedValueReturn){no_err, parsedValue};
             token = darray_get(tokens, *index);
             break;
           } else if (token->type != TOKEN_COMMA) {
-            fprintf(stderr, "%s:%zu:%zu error: expected comma\n", file,
-                    token->line, token->column);
-            exit(EXIT_FAILURE);
+            free_parsed(parsedValue);
+            free(parsedValue);
+            return (ParsedValueReturn){
+                create_err(token->line, token->column, token->length, file,
+                           "Syntax Error", "expected comma"),
+                NULL};
           }
           (*index)++;
           error_if_finished(file, tokens, index);
         }
       }
+      hashmap_free(parameters_hashmap, NULL);
     }
     if (token->type == TOKEN_ASSIGN) {
       (*index)++;
@@ -93,11 +120,20 @@ ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) {
 
       free(declaration->from);
 
-      declaration->from = parse_token(file, tokens, index, true);
+      ParsedValueReturn from = parse_token(file, tokens, index, true);
+      if (from.err.exists) {
+        free_parsed(parsedValue);
+        free(parsedValue);
+        return from;
+      }
+      declaration->from = from.value;
       if (!declaration->from) {
-        fprintf(stderr, "%s:%zu:%zu error: syntax error\n", file, token->line,
-                token->column);
-        exit(EXIT_FAILURE);
+        free_parsed(parsedValue);
+        free(parsedValue);
+        return (ParsedValueReturn){create_err(token->line, token->column,
+                                              token->length, file,
+                                              "Syntax Error", "expected body"),
+                                   NULL};
       }
     }
     if (isFunction) {
@@ -122,7 +158,7 @@ ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) {
     error_if_finished(file, tokens, index);
     token = darray_get(tokens, *index);
   }
-  return parsedValue;
+  return (ParsedValueReturn){no_err, parsedValue};
 }
 
 void free_string(void *ptr) {
@@ -133,9 +169,12 @@ void free_string(void *ptr) {
 
 void free_single_declaration(void *ptr) {
   ParsedSingleDeclaration *declaration = ptr;
+  if (declaration->name)
     free(declaration->name);
+  if (declaration->from) {
     free_parsed(declaration->from);
     free(declaration->from);
+  }
 }
 
 void free_declaration(void *ptr) {

src/parser/declaration/declaration.h

@@ -9,8 +9,7 @@ typedef struct {
 } ParsedSingleDeclaration;
 
 // Function declaration for parsing an identifier
-ParsedValue *parse_declaration(char *file, DArray *tokens,
-                              size_t *index);
+ParsedValueReturn parse_declaration(char *file, DArray *tokens, size_t *index);
 
 void free_declaration(void *ptr);
 

src/parser/dictionary/dictionary.c

@@ -7,7 +7,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-ParsedValue *parse_dictionary(char *file, DArray *tokens, size_t *index) {
+ParsedValueReturn parse_dictionary(char *file, DArray *tokens, size_t *index) {
   ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
   parsedValue->type = AST_DICTIONARY;
   DArray *dictionary = checked_malloc(sizeof(DArray));
@@ -23,17 +23,29 @@ ParsedValue *parse_dictionary(char *file, DArray *tokens, size_t *index) {
       error_if_finished(file, tokens, index);
       size_t keyIndex = *index;
       Token *keyToken = darray_get(tokens, *index);
-      ParsedValue *key;
+      ParsedValueReturn key;
       if (keyToken->type == TOKEN_IDENTIFIER) {
         (*index)++;
         key = parse_string(keyToken, false);
       } else {
         key = parse_token(file, tokens, index, true);
       }
+      if (key.err.exists) {
+        free_parsed(parsedValue);
+        free(parsedValue);
+        return key;
+      } else if (!key.value) {
+        free_parsed(parsedValue);
+        free(parsedValue);
+        return (ParsedValueReturn){create_err(token->line, token->column,
+                                              token->length, file,
+                                              "Syntax Error", "expected key"),
+                                   NULL};
+      }
       skip_newlines_and_indents(tokens, index);
       error_if_finished(file, tokens, index);
       token = darray_get(tokens, *index);
-      ParsedValue *value;
+      ParsedValueReturn value;
       bool tobreak = false;
       switch (token->type) {
       case TOKEN_COLON:
@@ -41,6 +53,22 @@ ParsedValue *parse_dictionary(char *file, DArray *tokens, size_t *index) {
         skip_newlines_and_indents(tokens, index);
         error_if_finished(file, tokens, index);
         value = parse_token(file, tokens, index, true);
+        if (value.err.exists) {
+          free_parsed(parsedValue);
+          free(parsedValue);
+          free_parsed(key.value);
+          free(key.value);
+          return value;
+        } else if (!value.value) {
+          free_parsed(parsedValue);
+          free(parsedValue);
+          free_parsed(key.value);
+          free(key.value);
+          return (ParsedValueReturn){
+              create_err(token->line, token->column, token->length, file,
+                         "Syntax Error", "expected value"),
+              NULL};
+        }
         skip_newlines_and_indents(tokens, index);
         error_if_finished(file, tokens, index);
         token = darray_get(tokens, *index);
@@ -63,7 +91,7 @@ ParsedValue *parse_dictionary(char *file, DArray *tokens, size_t *index) {
                 token->column);
         exit(EXIT_FAILURE);
       }
-      ParsedDictionaryEntry entry = {key, value};
+      ParsedDictionaryEntry entry = {key.value, value.value};
       darray_push(dictionary, &entry);
       if (tobreak) {
         break;
@@ -73,7 +101,7 @@ ParsedValue *parse_dictionary(char *file, DArray *tokens, size_t *index) {
     }
   }
   (*index)++;
-  return parsedValue;
+  return (ParsedValueReturn){no_err, parsedValue};
 }
 
 void free_dictionary_entry(void *ptr) {

src/parser/dictionary/dictionary.h

@@ -8,8 +8,7 @@ typedef struct {
   ParsedValue * value;
 } ParsedDictionaryEntry;
 
-ParsedValue *parse_dictionary(char *file, DArray *tokens,
-                      size_t *index);
+ParsedValueReturn parse_dictionary(char *file, DArray *tokens, size_t *index);
 
 void free_parsed_dictionary(void *ptr);
 

src/parser/dowrap/dowrap.c

@@ -24,7 +24,7 @@ void free_string_dowrap(void *ptr) {
   free(str);
 }
 
-ParsedValue *parse_dowrap(char *file, DArray *tokens, size_t *index) {
+ParsedValueReturn parse_dowrap(char *file, DArray *tokens, size_t *index) {
   ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
   parsedValue->type = AST_DOWRAP;
   DArray *dowrap_parsed = checked_malloc(sizeof(DArray));
@@ -32,9 +32,13 @@ ParsedValue *parse_dowrap(char *file, DArray *tokens, size_t *index) {
   parsedValue->data = dowrap_parsed;
   (*index)++;
   if ((*index) >= tokens->size)
-    return parsedValue;
+    return (ParsedValueReturn){no_err, parsedValue};
   Token *token = darray_get(tokens, *index);
   if (token->type != TOKEN_NEW_LINE) {
+    return (ParsedValueReturn){create_err(token->line, token->column,
+                                          token->length, file, "Syntax Error",
+                                          "expected body"),
+                               NULL};
     fprintf(stderr, "%s:%zu:%zu error: syntax error\n", file, token->line,
             token->column);
     exit(EXIT_FAILURE);
@@ -74,7 +78,7 @@ ParsedValue *parse_dowrap(char *file, DArray *tokens, size_t *index) {
         break;
       }
       if (temp_indent_depth > indent_depth) {
-        size_t indent_amount = temp_indent_depth-indent_depth;
+        size_t indent_amount = temp_indent_depth - indent_depth;
         Token indent_token;
         indent_token.line = token->line;
         indent_token.column = token->column;
@@ -85,21 +89,27 @@ ParsedValue *parse_dowrap(char *file, DArray *tokens, size_t *index) {
       }
       temp_indent_depth_toggle = false;
       temp_indent_depth = 0;
-      temp_index_count=0;
+      temp_index_count = 0;
       darray_push(&dowrap_tokens, token);
     }
   }
-  (*index)-=temp_index_count;
-  for (size_t i = 0; i<temp_index_count;i++) {
+  (*index) -= temp_index_count;
+  for (size_t i = 0; i < temp_index_count; i++) {
     darray_pop(&dowrap_tokens, NULL);
   }
-  parser(file, dowrap_parsed, &dowrap_tokens, false);
+  ArErr err = parser(file, dowrap_parsed, &dowrap_tokens, false);
 
   darray_free(&dowrap_tokens, NULL);
 
   darray_free(&to_free, free_string_dowrap);
 
-  return parsedValue;
+  if (err.exists) {
+    free_parsed(parsedValue);
+    free(parsedValue);
+    return (ParsedValueReturn){err, NULL};
+  }
+
+  return (ParsedValueReturn){no_err, parsedValue};
 }
 
 void free_dowrap(void *ptr) {

src/parser/dowrap/dowrap.h

@@ -4,8 +4,7 @@
 #include "../../lexer/token.h"  // for Token
 
 // Function declaration for parsing an identifier
-ParsedValue *parse_dowrap(char *file, DArray *tokens,
-                              size_t *index);
+ParsedValueReturn parse_dowrap(char *file, DArray *tokens, size_t *index);
 
 void free_dowrap(void *ptr);
 

src/parser/function/function.c

@@ -1,6 +1,5 @@
 #include "function.h"
 #include "../../memory.h"
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 

src/parser/if/if.c

@@ -6,7 +6,17 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-ParsedValue *parse_if(char *file, DArray *tokens, size_t *index) {
+void free_conditional(void *ptr) {
+  ParsedConditional *conditional = ptr;
+  if (conditional->condition) {
+    free_parsed(conditional->condition);
+    free(conditional->condition);
+  }
+  free_parsed(conditional->content);
+  free(conditional->content);
+}
+
+ParsedValueReturn parse_if(char *file, DArray *tokens, size_t *index) {
   (*index)++;
   error_if_finished(file, tokens, index);
 
@@ -35,28 +45,50 @@ ParsedValue *parse_if(char *file, DArray *tokens, size_t *index) {
       }
     }
 
-    ParsedValue *condition = NULL;
+    ParsedValueReturn condition = {no_err, NULL};
 
     if (token->type != TOKEN_ELSE) {
       // Parse ( condition )
       token = darray_get(tokens, *index);
       if (token->type != TOKEN_LPAREN) {
-        fprintf(stderr, "%s:%zu:%zu error: expected '(' after if\n", file,
-                token->line, token->column);
-        exit(EXIT_FAILURE);
+        darray_free(parsed_if, free_conditional);
+        free(parsed_if);
+        return (ParsedValueReturn){
+            create_err(token->line, token->column, token->length, file,
+                       "Syntax Error", "expected '(' after if"),
+            NULL};
       }
 
       (*index)++;
       error_if_finished(file, tokens, index);
       skip_newlines_and_indents(tokens, index);
       condition = parse_token(file, tokens, index, true);
+      if (condition.err.exists) {
+        darray_free(parsed_if, free_conditional);
+        free(parsed_if);
+        return condition;
+      } else if (!condition.value) {
+        darray_free(parsed_if, free_conditional);
+        free(parsed_if);
+        return (ParsedValueReturn){
+            create_err(token->line, token->column, token->length, file,
+                       "Syntax Error", "expected condition"),
+            NULL};
+      }
       skip_newlines_and_indents(tokens, index);
 
       token = darray_get(tokens, *index);
       if (token->type != TOKEN_RPAREN) {
-        fprintf(stderr, "%s:%zu:%zu error: missing closing ')' in condition\n",
-                file, token->line, token->column);
-        exit(EXIT_FAILURE);
+        if (condition.value) {
+          free_parsed(condition.value);
+          free(condition.value);
+        }
+        darray_free(parsed_if, free_conditional);
+        free(parsed_if);
+        return (ParsedValueReturn){
+            create_err(token->line, token->column, token->length, file,
+                       "Syntax Error", "missing closing ')' in condition"),
+            NULL};
       }
 
       (*index)++;
@@ -64,15 +96,32 @@ ParsedValue *parse_if(char *file, DArray *tokens, size_t *index) {
     }
 
     // Parse the body
-    ParsedValue *parsed_content = parse_token(file, tokens, index, false);
+    ParsedValueReturn parsed_content = parse_token(file, tokens, index, false);
 
-    if (!parsed_content) {
-      fprintf(stderr, "%s:%zu:%zu error: expected body after condition\n", file,
-              token->line, token->column);
-      exit(EXIT_FAILURE);
+    if (parsed_content.err.exists) {
+      if (condition.value) {
+        free_parsed(condition.value);
+        free(condition.value);
+      }
+      darray_free(parsed_if, free_conditional);
+      free(parsed_if);
+      return parsed_content;
     }
 
-    ParsedConditional conditional = {condition, parsed_content};
+    if (!parsed_content.value) {
+      if (condition.value) {
+        free_parsed(condition.value);
+        free(condition.value);
+      }
+      darray_free(parsed_if, free_conditional);
+      free(parsed_if);
+      return (ParsedValueReturn){create_err(token->line, token->column,
+                                            token->length, file, "Syntax Error",
+                                            "expected body"),
+                                 NULL};
+    }
+
+    ParsedConditional conditional = {condition.value, parsed_content.value};
     darray_push(parsed_if, &conditional);
 
     expect_conditional =
@@ -98,17 +147,7 @@ ParsedValue *parse_if(char *file, DArray *tokens, size_t *index) {
   //   printf("    - content value type: %d\n", cond->content->type);
   // }
 
-  return parsedValue;
-}
-
-void free_conditional(void *ptr) {
-  ParsedConditional *conditional = ptr;
-  if (conditional->condition) {
-    free_parsed(conditional->condition);
-    free(conditional->condition);
-  }
-  free_parsed(conditional->content);
-  free(conditional->content);
+  return (ParsedValueReturn){no_err, parsedValue};
 }
 
 void free_parsed_if(void *ptr) {

src/parser/if/if.h

@@ -8,8 +8,7 @@ typedef struct {
   ParsedValue *content;
 } ParsedConditional;
 
-ParsedValue *parse_if(char *file, DArray *tokens,
-                      size_t *index);
+ParsedValueReturn parse_if(char *file, DArray *tokens, size_t *index);
 
 void free_parsed_if(void *ptr);
 

src/parser/list/list.c

@@ -6,7 +6,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-ParsedValue *parse_list(char *file, DArray *tokens, size_t *index) {
+ParsedValueReturn parse_list(char *file, DArray *tokens, size_t *index) {
   ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
   parsedValue->type = AST_LIST;
   DArray *list = checked_malloc(sizeof(DArray));
@@ -19,9 +19,14 @@ ParsedValue *parse_list(char *file, DArray *tokens, size_t *index) {
   if (token->type != TOKEN_RBRACKET) {
     while (true) {
       skip_newlines_and_indents(tokens, index);
-      ParsedValue *parsedValue = parse_token(file, tokens, index, true);
-      darray_push(list, parsedValue);
+      ParsedValueReturn parsedItem = parse_token(file, tokens, index, true);
+      if (parsedItem.err.exists) {
+        free_parsed(parsedValue);
         free(parsedValue);
+        return parsedItem;
+      }
+      darray_push(list, parsedItem.value);
+      free(parsedItem.value);
       error_if_finished(file, tokens, index);
       skip_newlines_and_indents(tokens, index);
       error_if_finished(file, tokens, index);
@@ -38,7 +43,7 @@ ParsedValue *parse_list(char *file, DArray *tokens, size_t *index) {
     }
   }
   (*index)++;
-  return parsedValue;
+  return (ParsedValueReturn){no_err, parsedValue};
 }
 
 void free_parsed_list(void *ptr) {

src/parser/list/list.h

@@ -3,8 +3,7 @@
 #include "../../lexer/token.h" // for Token
 #include "../parser.h"
 
-ParsedValue *parse_list(char *file, DArray *tokens,
-                      size_t *index);
+ParsedValueReturn parse_list(char *file, DArray *tokens, size_t *index);
 
 void free_parsed_list(void *ptr);
 

src/parser/number/number.c

@@ -150,9 +150,9 @@
 //     return 0;
 // }
 
-ParsedValue *parse_number(Token *token) {
+ParsedValueReturn parse_number(Token *token) {
   ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
   parsedValue->type = AST_NUMBER;
   parsedValue->data = strdup(token->value);
-  return parsedValue;
+  return (ParsedValueReturn){no_err, parsedValue};
 }

src/parser/number/number.h

@@ -4,6 +4,6 @@
 #include "../../lexer/token.h"  // for Token
 
 // Function declaration for parsing an identifier
-ParsedValue * parse_number(Token * token);
+ParsedValueReturn parse_number(Token *token);
 
 #endif // NUMBER_H

src/parser/operations/operations.c

@@ -8,7 +8,7 @@
 
 ParsedValue convert_to_operation(DArray *to_operate_on, DArray *operations) {
   if (to_operate_on->size == 1) {
-    return *((ParsedValue*)darray_get(to_operate_on, 0));
+    return *((ParsedValue *)darray_get(to_operate_on, 0));
   }
   TokenType operation = 0;
   DArray positions;
@@ -37,23 +37,24 @@ ParsedValue convert_to_operation(DArray *to_operate_on, DArray *operations) {
         to_operate_on, to_operate_on_last_position, (*position) + 1);
     DArray operations_slice =
         darray_slice(operations, last_position, *position);
-    ParsedValue result =  convert_to_operation(&to_operate_on_slice, &operations_slice);
-    darray_push(&operationStruct->to_operate_on,
-                &result);
+    ParsedValue result =
+        convert_to_operation(&to_operate_on_slice, &operations_slice);
+    darray_push(&operationStruct->to_operate_on, &result);
     last_position = (*position);
     to_operate_on_last_position = (*position) + 1;
   }
-  DArray to_operate_on_slice =
-      darray_slice(to_operate_on, to_operate_on_last_position, to_operate_on->size);
-  DArray operations_slice = darray_slice(operations, last_position, operations->size);
-  ParsedValue result =convert_to_operation(&to_operate_on_slice, &operations_slice);
-  darray_push(&operationStruct->to_operate_on,
-              &result);
+  DArray to_operate_on_slice = darray_slice(
+      to_operate_on, to_operate_on_last_position, to_operate_on->size);
+  DArray operations_slice =
+      darray_slice(operations, last_position, operations->size);
+  ParsedValue result =
+      convert_to_operation(&to_operate_on_slice, &operations_slice);
+  darray_push(&operationStruct->to_operate_on, &result);
   darray_free(&positions, NULL);
   return parsedValue;
 }
 
-ParsedValue *parse_operations(char *file, DArray *tokens, size_t *index,
+ParsedValueReturn parse_operations(char *file, DArray *tokens, size_t *index,
                               ParsedValue *first_parsed_value) {
   DArray to_operate_on;
   darray_init(&to_operate_on, sizeof(ParsedValue));
@@ -77,17 +78,29 @@ ParsedValue *parse_operations(char *file, DArray *tokens, size_t *index,
     darray_push(&operations, &token->type);
     (*index)++;
     error_if_finished(file, tokens, index);
-    ParsedValue *parsedValue =
+    ParsedValueReturn parsedValue =
         parse_token_full(file, tokens, index, true, false);
-    darray_push(&to_operate_on, parsedValue);
-    free(parsedValue);
+    if (parsedValue.err.exists) {
+      darray_free(&to_operate_on, free_parsed);
+      darray_free(&operations, NULL);
+      return parsedValue;
+    } else if (!parsedValue.value) {
+      darray_free(&to_operate_on, free_parsed);
+      darray_free(&operations, NULL);
+      return (ParsedValueReturn){
+            create_err(token->line, token->column, token->length, file,
+                       "Syntax Error", "expected value"),
+            NULL};
+    }
+    darray_push(&to_operate_on, parsedValue.value);
+    free(parsedValue.value);
   }
   ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
   ParsedValue output = convert_to_operation(&to_operate_on, &operations);
-  memcpy(parsedValue, &output,sizeof(ParsedValue));
+  memcpy(parsedValue, &output, sizeof(ParsedValue));
   darray_free(&to_operate_on, NULL);
   darray_free(&operations, NULL);
-  return parsedValue;
+  return (ParsedValueReturn){no_err,parsedValue};
 }
 
 void free_operation(void *ptr) {

src/parser/operations/operations.h

@@ -8,7 +8,8 @@ typedef struct {
   DArray to_operate_on; // ParsedValue[]
 } ParsedOperation;
 
-ParsedValue *parse_operations(char*file,DArray *tokens, size_t * index, ParsedValue * first_parsed_value);
+ParsedValueReturn parse_operations(char *file, DArray *tokens, size_t *index,
+                              ParsedValue *first_parsed_value);
 
 void free_operation(void *ptr);
 

src/parser/parser.c

@@ -54,11 +54,11 @@ size_t skip_newlines_and_indents(DArray *tokens, size_t *index) {
   return count;
 }
 
-ParsedValue *parse_token_full(char *file, DArray *tokens, size_t *index,
+ParsedValueReturn parse_token_full(char *file, DArray *tokens, size_t *index,
                                    bool inline_flag, bool process_operations) {
   Token *token = darray_get(tokens, *index);
 
-  ParsedValue *output = NULL;
+  ParsedValueReturn output;
 
   if (!inline_flag) {
     switch (token->type) {
@@ -71,15 +71,15 @@ ParsedValue *parse_token_full(char *file, DArray *tokens, size_t *index,
   switch (token->type) {
   case TOKEN_TRUE:
     (*index)++;
-    output = parse_true();
+    output = (ParsedValueReturn){no_err, parse_true()};
     break;
   case TOKEN_FALSE:
     (*index)++;
-    output = parse_false();
+    output = (ParsedValueReturn){no_err, parse_false()};
     break;
   case TOKEN_NULL:
     (*index)++;
-    output = parse_null();
+    output = (ParsedValueReturn){no_err, parse_null()};
     break;
   case TOKEN_STRING:
     (*index)++;
@@ -87,18 +87,20 @@ ParsedValue *parse_token_full(char *file, DArray *tokens, size_t *index,
     break;
   case TOKEN_NEW_LINE:
     (*index)++;
-    return NULL;
-  case TOKEN_INDENT:
+    return (ParsedValueReturn){no_err, NULL};
+  case TOKEN_INDENT:;
+    Token *token_indent = token;
     if (strlen(token->value) > 0 && (*index + 1) < tokens->size) {
       token = darray_get(tokens, (*index) + 1);
       if (token->type != TOKEN_NEW_LINE) {
-        fprintf(stderr, "%s:%zu:%zu error: invalid indentation\n", file,
-                token->line, token->column);
-        exit(EXIT_FAILURE);
+        return (ParsedValueReturn){
+            create_err(token_indent->line, token_indent->column, token_indent->length, file,
+                       "Syntax Error", "unexpected indent"),
+            NULL};
       }
     }
     (*index)++;
-    return NULL;
+    return (ParsedValueReturn){no_err, NULL};
   case TOKEN_IDENTIFIER:
     (*index)++;
     output = parse_identifier(token);
@@ -128,6 +130,9 @@ ParsedValue *parse_token_full(char *file, DArray *tokens, size_t *index,
   // LHS required
   bool passed = false;
   while (!passed && (*index) < tokens->size) {
+    if (output.err.exists) {
+      return output;
+    }
     token = darray_get(tokens, *index);
     switch (token->type) {
     case TOKEN_ASSIGN:
@@ -138,18 +143,18 @@ ParsedValue *parse_token_full(char *file, DArray *tokens, size_t *index,
     case TOKEN_ASSIGN_PLUS:
     case TOKEN_ASSIGN_SLASH:
     case TOKEN_ASSIGN_STAR:
-      output = parse_assign(file, tokens, output, index);
+      output = parse_assign(file, tokens, output.value, index);
       break;
     case TOKEN_LPAREN:
-      output = parse_call(file, tokens, index, output);
+      output = parse_call(file, tokens, index, output.value);
       break;
     case TOKEN_DOT:
     case TOKEN_LBRACKET:
-      output = parse_access(file, tokens, index, output);
+      output = parse_access(file, tokens, index, output.value);
       break;
       SWITCH_OPERATIONS
       if (process_operations) {
-        output = parse_operations(file, tokens, index, output);
+        output = parse_operations(file, tokens, index, output.value);
         break;
       }
       /* fall through */
@@ -161,18 +166,21 @@ ParsedValue *parse_token_full(char *file, DArray *tokens, size_t *index,
   return output;
 }
 
-ParsedValue *parse_token(char *file, DArray *tokens, size_t *index,
+ParsedValueReturn parse_token(char *file, DArray *tokens, size_t *index,
                               bool inline_flag) {
   return parse_token_full(file, tokens, index, inline_flag, true);
 }
 
-void parser(char *file, DArray *parsed, DArray *tokens, bool inline_flag) {
+ArErr parser(char *file, DArray *parsed, DArray *tokens, bool inline_flag) {
   size_t index = 0;
   bool expecting_new_line = false;
   while (index < tokens->size) {
     size_t old_index = index;
-    ParsedValue *parsed_code = parse_token(file, tokens, &index, inline_flag);
-    if (parsed_code) {
+    ParsedValueReturn parsed_code =
+        parse_token(file, tokens, &index, inline_flag);
+    if (parsed_code.err.exists) {
+      return parsed_code.err;
+    } else if (parsed_code.value) {
       if (expecting_new_line) {
         Token *token = darray_get(tokens, old_index);
         fprintf(stderr, "%s:%zu:%zu error: expected a new line\n", file,
@@ -180,8 +188,8 @@ void parser(char *file, DArray *parsed, DArray *tokens, bool inline_flag) {
         exit(EXIT_FAILURE);
       }
       expecting_new_line = true;
-      darray_push(parsed, parsed_code);
-      free(parsed_code);
+      darray_push(parsed, parsed_code.value);
+      free(parsed_code.value);
     } else {
       expecting_new_line = false;
     }

src/parser/parser.h

@@ -2,26 +2,28 @@
 #define PARSER_H
 
 #include "../dynamic_array/darray.h"
+#include "../err.h"
 #include <stdbool.h>
 #include <stddef.h>
 
-#define SWITCH_OPERATIONS case TOKEN_AND:\
-case TOKEN_OR:\
-case TOKEN_NOT_IN:\
-case TOKEN_IN:\
-case TOKEN_LE:\
-case TOKEN_GE:\
-case TOKEN_LT:\
-case TOKEN_GT:\
-case TOKEN_NE:\
-case TOKEN_EQ:\
-case TOKEN_PLUS:\
-case TOKEN_MINUS:\
-case TOKEN_MODULO:\
-case TOKEN_STAR:\
-case TOKEN_FLOORDIV:\
-case TOKEN_SLASH:\
-case TOKEN_CARET:
+#define SWITCH_OPERATIONS                                                      \
+  case TOKEN_AND:                                                              \
+  case TOKEN_OR:                                                               \
+  case TOKEN_NOT_IN:                                                           \
+  case TOKEN_IN:                                                               \
+  case TOKEN_LE:                                                               \
+  case TOKEN_GE:                                                               \
+  case TOKEN_LT:                                                               \
+  case TOKEN_GT:                                                               \
+  case TOKEN_NE:                                                               \
+  case TOKEN_EQ:                                                               \
+  case TOKEN_PLUS:                                                             \
+  case TOKEN_MINUS:                                                            \
+  case TOKEN_MODULO:                                                           \
+  case TOKEN_STAR:                                                             \
+  case TOKEN_FLOORDIV:                                                         \
+  case TOKEN_SLASH:                                                            \
+  case TOKEN_CARET:
 
 typedef struct LinkedList LinkedList;
 
@@ -43,24 +45,29 @@ typedef enum {
   AST_FUNCTION
 } ValueType;
 
-extern const char* ValueTypeNames[];
+extern const char *ValueTypeNames[];
 
 typedef struct {
   ValueType type;
   void *data;
 } ParsedValue;
 
-void parser(char *file, DArray *parsed, DArray *tokens, bool inline_flag);
+typedef struct {
+  ArErr err;
+  ParsedValue *value;
+} ParsedValueReturn;
 
-ParsedValue *parse_token_full(char *file, DArray *tokens, size_t *index,
+ArErr parser(char *file, DArray *parsed, DArray *tokens, bool inline_flag);
+
+ParsedValueReturn parse_token_full(char *file, DArray *tokens, size_t *index,
                               bool inline_flag, bool process_operations);
 
-ParsedValue *parse_token(char *file, DArray *tokens, size_t *index,
+ParsedValueReturn parse_token(char *file, DArray *tokens, size_t *index,
                          bool inline_flag);
 
 void free_parsed(void *ptr);
 
-void error_if_finished(char *file,DArray *tokens, size_t *index);
+void error_if_finished(char *file, DArray *tokens, size_t *index);
 
 size_t skip_newlines_and_indents(DArray *tokens, size_t *index);
 

src/parser/string/string.c

@@ -245,7 +245,7 @@ char *unquote(char *str, size_t *decoded_len) {
   return unescaped;
 }
 
-ParsedValue *parse_string(Token* token, bool to_unquote) {
+ParsedValueReturn parse_string(Token* token, bool to_unquote) {
   ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue));
   parsedValue->type = AST_STRING;
   ParsedString *parsedString = checked_malloc(sizeof(ParsedString));
@@ -253,11 +253,19 @@ ParsedValue *parse_string(Token* token, bool to_unquote) {
   if (to_unquote) {
     parsedString->length = 0;
     parsedString->string = unquote(token->value, &parsedString->length);
+    if (!parsedString->string) {
+      free(parsedValue);
+      free(parsedString);
+      return (ParsedValueReturn){create_err(token->line, token->column,
+                                            token->length, NULL, "String Error",
+                                            "failed to unquote string %s", token->value),
+                                 NULL};
+    }
   } else {
     parsedString->string = strdup(token->value);
     parsedString->length = token->length;
   }
-  return parsedValue;
+  return (ParsedValueReturn){no_err,parsedValue};
 }
 
 void free_parsed_string(void *ptr) {

src/parser/string/string.h

@@ -15,7 +15,7 @@ char *swap_quotes(char *input, char quote);
 
 char *unquote(char *str, size_t *decoded_len);
 
-ParsedValue *parse_string(Token* token, bool to_unquote);
+ParsedValueReturn parse_string(Token* token, bool to_unquote);
 
 void free_parsed_string(void *ptr);
 

src/returnTypes.h

@@ -0,0 +1,22 @@
+#ifndef RETURN_TYPES_H
+#define RETURN_TYPES_H
+#include <stdint.h>
+#include "arobject.h"
+
+#define ERR_MSG_MAX_LEN 256
+
+typedef struct ArErr {
+  bool exists;
+  char *path;
+  int64_t line;
+  int64_t column;
+  int length;
+  char type[32];
+  char message[ERR_MSG_MAX_LEN];
+} ArErr;
+
+typedef struct Execution {
+  ArErr err;
+  Stack stack;
+} Execution;
+#endif // RETURN_TYPES_

src/runtime/internals/hashmap/hashmap.c

@@ -41,7 +41,7 @@ void resize_hashmap_GC(struct hashmap_GC *t) {
   }
 }
 
-int hashCode_GC(struct hashmap_GC *t, uint64_t hash) { return hash % t->size; }
+int hashCode_GC(struct hashmap_GC *t, uint64_t hash) { return hash & (t->size - 1); }
 
 int hashmap_remove_GC(struct hashmap_GC *t, uint64_t hash) {
   int pos = hashCode_GC(t, hash);

src/runtime/internals/hashmap/hashmap.h

@@ -3,8 +3,6 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-typedef struct ArgonObject ArgonObject;
-
 struct node_GC {
   uint64_t hash;
   void *key;

src/runtime/objects/object.h

@@ -1,53 +1,15 @@
 #ifndef OBJECT_H
 #define OBJECT_H
 #include "../internals/hashmap/hashmap.h"
-#include "../internals/dynamic_array_armem/darray_armem.h"
-#include <gmp.h>
-#include <stdbool.h>
 #include "../runtime.h"
+#include <stdbool.h>
 
 extern ArgonObject *BASE_CLASS;
 
-struct string_struct {
-  char *data;
-  size_t length;
-};
-struct argon_function_struct {
-  darray_armem bytecode;
-  struct Stack stack;
-  size_t number_of_parameters;
-  char** parameters;
-};
-
-typedef enum {
-  TYPE_NULL,
-  TYPE_BOOL,
-  TYPE_NUMBER,
-  TYPE_STRING,
-  TYPE_FUNCTION,
-  TYPE_NATIVE_FUNCTION,
-  TYPE_OBJECT, // generic user object
-} ArgonType;
-
-struct ArgonObject {
-  ArgonType type;
-  char* name;
-  ArgonObject *self;
-  ArgonObject *baseObject;
-  struct hashmap_GC *fields; // dynamic fields/methods
-  union {
-    mpq_t as_number;
-    bool as_bool;
-    struct string_struct as_str;
-    void *native_fn;
-    struct argon_function_struct argon_fn;
-    // others as needed
-  } value;
-};
 typedef struct ArgonObject ArgonObject;
 void init_base_field();
-ArgonObject* init_child_argon_object(ArgonObject *cls);
-ArgonObject* init_argon_class(char*name);
+ArgonObject *init_child_argon_object(ArgonObject *cls);
+ArgonObject *init_argon_class(char *name);
 
-void add_field(ArgonObject*target, char* name, ArgonObject *object);
+void add_field(ArgonObject *target, char *name, ArgonObject *object);
 #endif // OBJECT_H

src/runtime/runtime.c

@@ -1,4 +1,5 @@
 #include "runtime.h"
+#include "../err.h"
 #include "../translator/translator.h"
 #include "objects/functions/functions.h"
 #include "objects/null/null.h"
@@ -33,7 +34,6 @@ void init_types() {
   init_base_field();
 }
 
-
 uint8_t pop_byte(Translated *translated, RuntimeState *state) {
   return *((uint8_t *)darray_get(&translated->bytecode, state->head++));
 }
@@ -63,7 +63,7 @@ void load_const(Translated *translated, RuntimeState *state) {
   state->registers[to_register] = object;
 }
 
-void run_instruction(Translated *translated, RuntimeState *state,
+ArErr run_instruction(Translated *translated, RuntimeState *state,
                       struct Stack stack) {
   OperationType opcode = pop_byte(translated, state);
   switch (opcode) {
@@ -76,16 +76,27 @@ void run_instruction(Translated *translated, RuntimeState *state,
   case OP_LOAD_FUNCTION:
     load_argon_function(translated, state, stack);
     break;
+  default:
+    return create_err(0, 0, 0, NULL, "Runtime Error", "Invalid Opcode %#x", opcode);
   }
+  return no_err;
 }
 
-void runtime(Translated translated) {
-  RuntimeState state = {
+RuntimeState init_runtime_state(Translated translated) {
+  return (RuntimeState){
       checked_malloc(translated.registerCount * sizeof(ArgonObject *)), 0};
-  struct Stack stack = {};
+}
+
+Stack create_scope(Stack *prev) { return (Stack){NULL, prev}; }
+
+ArErr runtime(Translated translated, RuntimeState state, Stack stack) {
   state.head = 0;
   while (state.head < translated.bytecode.size) {
-    run_instruction(&translated, &state, stack);
+    ArErr err = run_instruction(&translated, &state, stack);
+    if (err.exists) {
+      return err;
+    }
   }
   free(state.registers);
+  return no_err;
 }

src/runtime/runtime.h

@@ -2,23 +2,24 @@
 #define RUNTIME_H
 #include "../translator/translator.h"
 #include "internals/hashmap/hashmap.h"
+#include "../returnTypes.h"
 
 typedef struct {
   ArgonObject **registers;
   size_t head;
 } RuntimeState;
 
-typedef struct Stack {
-    ArgonObject *scope;
-    struct Stack *prev;
-} Stack;
-
 void init_types();
 
 uint64_t pop_bytecode(Translated *translated, RuntimeState *state);
 
-void run_instruction(Translated *translated, RuntimeState *state, struct Stack stack);
+ArErr run_instruction(Translated *translated, RuntimeState *state,
+                      struct Stack stack);
 
-void runtime(Translated translated);
+RuntimeState init_runtime_state(Translated translated);
+
+Stack create_scope(Stack *prev);
+
+ArErr runtime(Translated translated, RuntimeState state, Stack stack);
 
 #endif // RUNTIME_H

src/translator/identifier/identifier.c

@@ -0,0 +1,15 @@
+#include "../translator.h"
+#include "identifier.h"
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+
+size_t translate_parsed_identifier(Translated *translated, char* identifier) {
+  size_t length = strlen(identifier);
+  size_t identifier_pos = arena_push(&translated->constants, identifier, length);
+  set_registers(translated, 1);
+  size_t start = push_instruction_byte(translated, OP_IDENTIFIER);
+  push_instruction_code(translated,length);
+  push_instruction_code(translated, identifier_pos);
+  return start;
+}

src/translator/identifier/identifier.h

@@ -0,0 +1,8 @@
+#ifndef BYTECODE_IDENTIFIER_H
+#define BYTECODE_IDENTIFIER_H
+#include "../translator.h"
+#include "../../parser/assignable/identifier/identifier.h"
+
+size_t translate_parsed_identifier(Translated *translated, char* identifier);
+
+#endif

src/translator/translator.c

@@ -3,6 +3,7 @@
 #include "../hashmap/hashmap.h"
 #include "declaration/declaration.h"
 #include "function/function.h"
+#include "identifier/identifier.h"
 #include "number/number.h"
 #include "string/string.h"
 #include <stddef.h>
@@ -122,6 +123,8 @@ size_t translate_parsed(Translated *translated, ParsedValue *parsedValue) {
   case AST_FUNCTION:
     return translate_parsed_function(translated,
                                      (ParsedFunction *)parsedValue->data);
+  case AST_IDENTIFIER:
+    return translate_parsed_identifier(translated, (char *)parsedValue->data);
   }
   return 0;
 }

src/translator/translator.h

@@ -8,7 +8,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
-typedef enum { OP_LOAD_CONST, OP_DECLARE, OP_LOAD_NULL, OP_LOAD_FUNCTION } OperationType;
+typedef enum { OP_LOAD_CONST, OP_DECLARE, OP_LOAD_NULL, OP_LOAD_FUNCTION, OP_IDENTIFIER } OperationType;
 typedef enum { TYPE_OP_STRING, TYPE_OP_NUMBER } types;
 
 typedef struct {

test.py

@@ -0,0 +1,35 @@
+import string
+from itertools import product
+import sys
+
+def generate_names(max_width, skip_keywords=None):
+    if skip_keywords is None:
+        skip_keywords = {"if", "else", "while", "forever", "for", "break", "continue",
+                         "return", "let", "import", "from", "do", "true", "false", "null",
+                         "delete", "not", "try", "catch", "in"}
+    else:
+        skip_keywords = set(skip_keywords)
+
+    chars = string.ascii_lowercase
+    first = True
+    write = sys.stdout.write
+
+    for length in range(1, max_width + 1):
+        print(length, file=sys.stderr)
+        i = 0
+        for p in product(chars, repeat=length):
+            name = ''.join(p)
+            if name in skip_keywords:
+                continue
+            if not first:
+                write('\n')
+            write(name)
+            first = False
+            if i>10000000:
+                break
+            i+=1
+
+# Example usage:
+max_width = 15
+# sys.stdout.write("let ")
+generate_names(max_width)

testing.ar

@@ -0,0 +1 @@
+let x = 10