have memory malloced then converted to GC

src/arobject.h

@@ -35,13 +35,13 @@ typedef struct {
   void *data;
   size_t capacity;
   size_t size;
-  struct hashmap_GC *hashmap;
+  struct hashmap *hashmap;
 } ConstantArena;
 
 typedef struct {
   uint8_t registerCount;
   DArray *return_jumps;
-  darray_armem bytecode;
+  DArray bytecode;
   ConstantArena constants;
   char *path;
 } Translated;

src/main.c

@@ -4,7 +4,9 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
+#include "arobject.h"
 #include "dynamic_array/darray.h"
+#include "hashmap/hashmap.h"
 #include "lexer/lexer.h"
 #include "lexer/token.h"
 #include "memory.h"
@@ -256,7 +258,7 @@ int load_cache(Translated *translated_dest, char *joined_paths, uint64_t hash, c
     goto FAILED;
   }
 
-  darray_armem_resize(&translated_dest->bytecode, bytecodeSize);
+  darray_resize(&translated_dest->bytecode, bytecodeSize);
 
   if (fread(translated_dest->bytecode.data, 1, bytecodeSize, bytecode_file) !=
       bytecodeSize) {
@@ -413,11 +415,31 @@ Execution execute(char *path, Stack *stack) {
 
     fclose(file);
   }
+  hashmap_free(translated.constants.hashmap, NULL);
+  Translated gc_translated = {
+    translated.registerCount,
+    NULL,
+    {},
+    {},
+    translated.path
+  };
+  gc_translated.bytecode.data = ar_alloc(translated.bytecode.capacity);
+  memcpy(gc_translated.bytecode.data, translated.bytecode.data, translated.bytecode.capacity);
+  gc_translated.bytecode.element_size = translated.bytecode.element_size;
+  gc_translated.bytecode.size = translated.bytecode.size;
+  gc_translated.bytecode.resizable = false;
+  gc_translated.bytecode.capacity = translated.bytecode.size*translated.bytecode.element_size;
+  gc_translated.constants.data = ar_alloc(translated.constants.capacity);
+  memcpy(gc_translated.constants.data, translated.constants.data, translated.constants.capacity);
+  gc_translated.constants.size = translated.constants.size;
+  gc_translated.constants.capacity = translated.constants.capacity;
+  darray_free(&translated.bytecode, NULL);
+  free(translated.constants.data);
 
   start = clock();
-  RuntimeState state = init_runtime_state(translated, path);
+  RuntimeState state = init_runtime_state(gc_translated, path);
   Stack *main_scope = create_scope(stack);
-  ArErr err = runtime(translated, state, main_scope);
+  ArErr err = runtime(gc_translated, state, main_scope);
   free_runtime_state(state);
   end = clock();
   time_spent = (double)(end - start) / CLOCKS_PER_SEC;

src/runtime/call/call.c

@@ -72,12 +72,12 @@ double get_memory_usage_mb() {
 
 ArgonObject *argon_call(ArgonObject *original_object, size_t argc,
                         ArgonObject **argv, ArErr *err, RuntimeState *state) {
-  *err = run_call(original_object, argc, argv, state);
+  *err = run_call(original_object, argc, argv, state, true);
   return state->registers[0];
 }
 
 ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
-               RuntimeState *state) {
+               RuntimeState *state, bool CStackFrame) {
   ArgonObject *object = original_object;
   if (object->type != TYPE_FUNCTION && object->type != TYPE_NATIVE_FUNCTION &&
       object->type != TYPE_METHOD) {
@@ -151,6 +151,9 @@ ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
         scope,
         *state->currentStackFramePointer,
         (*state->currentStackFramePointer)->depth + 1};
+    if (CStackFrame) {
+      return runtime(new_stackFrame.translated, new_stackFrame.state, new_stackFrame.stack);
+    } else {
       if (((*state->currentStackFramePointer)->depth + 1) % STACKFRAME_CHUNKS ==
           0) {
         *state->currentStackFramePointer =
@@ -160,7 +163,8 @@ ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
       }
       **state->currentStackFramePointer = new_stackFrame;
       if ((*state->currentStackFramePointer)->depth >= 10000) {
-      double logval = log10((double)(*state->currentStackFramePointer)->depth);
+        double logval =
+            log10((double)(*state->currentStackFramePointer)->depth);
         if (floor(logval) == logval) {
           double memoryUsage = get_memory_usage_mb();
           fprintf(stderr,
@@ -177,6 +181,7 @@ ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
         }
       };
       return no_err;
+    }
   } else if (object->type == TYPE_NATIVE_FUNCTION) {
     ArErr err = no_err;
     state->registers[0] = object->value.native_fn(argc, argv, &err, state);

src/runtime/call/call.h

@@ -12,6 +12,6 @@ ArgonObject *argon_call(ArgonObject *original_object, size_t argc,
                         ArgonObject **argv, ArErr *err, RuntimeState *state);
 
 ArErr run_call(ArgonObject *original_object, size_t argc, ArgonObject **argv,
-               RuntimeState *state);
+               RuntimeState *state, bool CStackFrame);
 
 #endif // runtime_call_H

src/runtime/runtime.c

@@ -55,12 +55,13 @@ ArgonObject *ARGON_TYPE_TYPE___call__(size_t argc, ArgonObject **argv,
     return ARGON_NULL;
   }
 
-  ArgonObject *cls___new___args[] = {cls};
+  ArgonObject *new_object = argon_call(cls___new__, argc, argv, err, state);
-  ArgonObject *new_object = argon_call(cls___new__, sizeof(cls___new___args)/sizeof(ArgonObject *), cls___new___args, err, state);
   if (err->exists)
     return ARGON_NULL;
   ArgonObject *ARGON_TYPE_TYPE___call___args[] = {ARGON_TYPE_TYPE, new_object};
-  ArgonObject *new_object_class = ARGON_TYPE_TYPE___call__(sizeof(ARGON_TYPE_TYPE___call___args)/sizeof(ArgonObject *), ARGON_TYPE_TYPE___call___args, err, state);
+  ArgonObject *new_object_class = ARGON_TYPE_TYPE___call__(
+      sizeof(ARGON_TYPE_TYPE___call___args) / sizeof(ArgonObject *),
+      ARGON_TYPE_TYPE___call___args, err, state);
   if (new_object_class != ARGON_NULL && new_object_class == cls) {
     ArgonObject *cls___init__ =
         get_field_for_class(argv[0], "__init__", new_object);
@@ -83,9 +84,10 @@ ArgonObject *ARGON_TYPE_TYPE___call__(size_t argc, ArgonObject **argv,
 ArgonObject *BASE_CLASS___new__(size_t argc, ArgonObject **argv, ArErr *err,
                                 RuntimeState *state) {
   (void)state;
-  if (argc != 1) {
+  if (argc < 1) {
-    *err = create_err(0, 0, 0, "", "Runtime Error",
+    *err =
-                      "__new__ expects 1 argument, got %" PRIu64, argc);
+        create_err(0, 0, 0, "", "Runtime Error",
+                   "__new__ expects at least 1 argument, got %" PRIu64, argc);
     return ARGON_NULL;
   }
   ArgonObject *new_obj = new_object();
@@ -96,6 +98,7 @@ ArgonObject *BASE_CLASS___new__(size_t argc, ArgonObject **argv, ArErr *err,
 ArgonObject *BASE_CLASS___init__(size_t argc, ArgonObject **argv, ArErr *err,
                                  RuntimeState *state) {
   (void)state;
+  (void)argv;
   if (argc != 1) {
     *err = create_err(0, 0, 0, "", "Runtime Error",
                       "__init__ expects 1 argument, got %" PRIu64, argc);
@@ -123,16 +126,41 @@ ArgonObject *ARGON_STRING_TYPE___init__(size_t argc, ArgonObject **argv,
         argon_call(string_convert_method, 0, NULL, err, state);
     if (err->exists)
       return ARGON_NULL;
-    object->value.as_str.data = ar_alloc_atomic(string_object->value.as_str.length);
+    object->value.as_str.data =
-    memcpy(object->value.as_str.data, string_object->value.as_str.data, string_object->value.as_str.length);
+        ar_alloc_atomic(string_object->value.as_str.length);
+    memcpy(object->value.as_str.data, string_object->value.as_str.data,
+           string_object->value.as_str.length);
     object->value.as_str.length = string_object->value.as_str.length;
   }
   return ARGON_NULL;
 }
 
+ArgonObject *ARGON_BOOL_TYPE___new__(size_t argc, ArgonObject **argv,
+                                     ArErr *err, RuntimeState *state) {
+  if (argc != 2) {
+    *err = create_err(0, 0, 0, "", "Runtime Error",
+                      "__init__ expects 2 arguments, got %" PRIu64, argc);
+    return ARGON_NULL;
+  }
+  ArgonObject *self = argv[0];
+  ArgonObject *object = argv[1];
+
+  self->type = TYPE_STRING;
+  ArgonObject *boolean_convert_method = get_field_for_class(
+      get_field(object, "__class__", false, false), "__boolean__", object);
+  if (boolean_convert_method) {
+    ArgonObject *boolean_object =
+        argon_call(boolean_convert_method, 0, NULL, err, state);
+    if (err->exists)
+      return ARGON_NULL;
+    return boolean_object;
+  }
+  return ARGON_TRUE;
+}
 
 ArgonObject *ARGON_STRING_TYPE___string__(size_t argc, ArgonObject **argv,
                                           ArErr *err, RuntimeState *state) {
+  (void)state;
   if (argc != 1) {
     *err = create_err(0, 0, 0, "", "Runtime Error",
                       "__init__ expects 1 arguments, got %" PRIu64, argc);
@@ -190,10 +218,14 @@ void bootstrap_types() {
             create_argon_native_function("__init__", BASE_CLASS___new__));
   add_field(ARGON_TYPE_TYPE, "__call__",
             create_argon_native_function("__call__", ARGON_TYPE_TYPE___call__));
-  add_field(ARGON_STRING_TYPE, "__init__",
+  add_field(
+      ARGON_STRING_TYPE, "__init__",
       create_argon_native_function("__init__", ARGON_STRING_TYPE___init__));
-  add_field(ARGON_STRING_TYPE, "__string__",
+  add_field(
+      ARGON_STRING_TYPE, "__string__",
       create_argon_native_function("__string__", ARGON_STRING_TYPE___string__));
+  add_field(ARGON_BOOL_TYPE, "__new__",
+            create_argon_native_function("__new__", ARGON_BOOL_TYPE___new__));
 }
 
 void add_to_scope(Stack *stack, char *name, ArgonObject *value) {
@@ -207,6 +239,7 @@ void bootstrap_globals() {
   Global_Scope = create_scope(NULL);
   add_to_scope(Global_Scope, "string", ARGON_STRING_TYPE);
   add_to_scope(Global_Scope, "type", ARGON_TYPE_TYPE);
+  add_to_scope(Global_Scope, "boolean", ARGON_BOOL_TYPE);
 }
 
 int compare_by_order(const void *a, const void *b) {
@@ -216,7 +249,7 @@ int compare_by_order(const void *a, const void *b) {
 }
 
 uint8_t pop_byte(Translated *translated, RuntimeState *state) {
-  return *((uint8_t *)darray_armem_get(&translated->bytecode, state->head++));
+  return *((uint8_t *)darray_get(&translated->bytecode, state->head++));
 }
 
 uint64_t pop_bytecode(Translated *translated, RuntimeState *state) {
@@ -357,7 +390,7 @@ ArErr run_instruction(Translated *translated, RuntimeState *state,
   case OP_CALL:;
     ArErr err = run_call(state->call_instance->to_call,
                          state->call_instance->args_length,
-                         state->call_instance->args, state);
+                         state->call_instance->args, state, false);
     free(state->call_instance->args);
     call_instance = *state->call_instance;
     free(state->call_instance);

src/translator/function/function.c

@@ -13,9 +13,9 @@
 #include <string.h>
 size_t translate_parsed_function(Translated *translated,
                                  ParsedFunction *parsedFunction, ArErr *err) {
-  darray_armem main_bytecode = translated->bytecode;
+  DArray main_bytecode = translated->bytecode;
-  darray_armem _temp_bytecode;
+  DArray _temp_bytecode;
-  darray_armem_init(&_temp_bytecode, sizeof(uint8_t));
+  darray_init(&_temp_bytecode, sizeof(uint8_t));
   set_registers(translated, 1);
   translated->bytecode = _temp_bytecode;
   translate_parsed(translated, parsedFunction->body, err);
@@ -24,6 +24,7 @@ size_t translate_parsed_function(Translated *translated,
                  translated->bytecode.size*translated->bytecode.element_size);
   size_t function_bytecode_length = translated->bytecode.size;
   translated->bytecode = main_bytecode;
+  darray_free(&_temp_bytecode, NULL);
   size_t start = push_instruction_byte(translated, OP_LOAD_FUNCTION);
   size_t offset = arena_push(&translated->constants, parsedFunction->name,
                              strlen(parsedFunction->name));

src/translator/translator.c

@@ -28,10 +28,10 @@ void uint64_to_bytes(uint64_t value, uint8_t bytes[8]) {
 }
 
 void arena_init(ConstantArena *arena) {
-  arena->data = ar_alloc(CHUNK_SIZE);
+  arena->data = malloc(CHUNK_SIZE);
   arena->capacity = CHUNK_SIZE;
   arena->size = 0;
-  arena->hashmap = createHashmap_GC();
+  arena->hashmap = createHashmap();
 }
 
 void arena_resize(ConstantArena *arena, size_t new_size) {
@@ -55,7 +55,7 @@ size_t arena_push(ConstantArena *arena, const void *data, size_t length) {
   uint64_t hash = siphash64_bytes(data, length, siphash_key);
 
   // Look up offset in hashmap
-  void *val = hashmap_lookup_GC(arena->hashmap, hash);
+  void *val = hashmap_lookup(arena->hashmap, hash);
   if (val != NULL) {
     size_t offset =
         (size_t)(uintptr_t)val - 1; // stored as pointer but really offset
@@ -72,7 +72,7 @@ size_t arena_push(ConstantArena *arena, const void *data, size_t length) {
   arena->size += length;
 
   // Insert into hashmap: store offset as pointer-sized integer
-  hashmap_insert_GC(arena->hashmap, hash, (void *)data,
+  hashmap_insert(arena->hashmap, hash, (void *)data,
                  (void *)(uintptr_t)offset + 1, 0);
 
   return offset;
@@ -83,14 +83,14 @@ Translated init_translator(char* path) {
   translated.path = path;
   translated.registerCount = 1;
   translated.return_jumps=NULL;
-  darray_armem_init(&translated.bytecode, sizeof(uint8_t));
+  darray_init(&translated.bytecode, sizeof(uint8_t));
   arena_init(&translated.constants);
   return translated;
 }
 
 size_t push_instruction_byte(Translated *translator, uint8_t byte) {
   size_t offset = translator->bytecode.size;
-  darray_armem_push(&translator->bytecode, &byte);
+  darray_push(&translator->bytecode, &byte);
   return offset;
 }
 
@@ -103,7 +103,7 @@ size_t push_instruction_code(Translated *translator, uint64_t code) {
   uint8_t bytes[8];
   uint64_to_bytes(code, bytes);
   for (size_t i = 0; i < sizeof(bytes); i++) {
-    darray_armem_push(&translator->bytecode, &(bytes[i]));
+    darray_push(&translator->bytecode, &(bytes[i]));
   }
   return offset;
 }