fix memory leak in declaration and function

src/runtime/internals/dynamic_array_armem/darray_armem.c

@@ -0,0 +1,113 @@
+#include "darray_armem.h"
+#include "../../../memory.h"
+#include <gc/gc.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+void darray_armem_init(darray_armem *arr, size_t element_size) {
+  arr->element_size = element_size;
+  arr->size = 0;
+  arr->capacity = CHUNK_SIZE;
+  arr->data = ar_alloc(CHUNK_SIZE * element_size);
+  arr->resizable = true;
+  if (!arr->data) {
+    fprintf(stderr, "darray_armem_init: allocation failed\n");
+    exit(EXIT_FAILURE);
+  }
+}
+
+void darray_armem_resize(darray_armem *arr, size_t new_size) {
+  if (!arr->resizable) {
+    fprintf(stderr, "darray_armem_resize: unresizable darray_armem\n");
+    exit(EXIT_FAILURE);
+  }
+  size_t new_capacity = ((new_size + CHUNK_SIZE) / CHUNK_SIZE) * CHUNK_SIZE;
+  if (new_capacity != arr->capacity) {
+    void *new_data = ar_alloc(new_capacity * arr->element_size);
+    memccpy(new_data,arr->data, arr->element_size, arr->capacity);
+    if (!new_data) {
+      fprintf(stderr, "darray_armem_resize: reallocation failed\n");
+      exit(EXIT_FAILURE);
+    }
+    arr->data = new_data;
+    arr->capacity = new_capacity;
+  }
+
+  arr->size = new_size;
+}
+
+void darray_armem_push(darray_armem *arr, void *element) {
+  if (!arr->resizable) {
+    fprintf(stderr, "darray_armem_resize: unresizable darray_armem\n");
+    exit(EXIT_FAILURE);
+  }
+  if (arr->size >= arr->capacity) {
+    darray_armem_resize(arr, arr->size + 1);
+  } else {
+    arr->size++;
+  }
+
+  void *target = (char *)arr->data + (arr->size - 1) * arr->element_size;
+  memcpy(target, element, arr->element_size);
+}
+
+void darray_armem_pop(darray_armem *arr, void (*free_data)(void *)) {
+  if (!arr->resizable) {
+    fprintf(stderr, "darray_armem_resize: unresizable darray_armem\n");
+    exit(EXIT_FAILURE);
+  }
+  if (arr->size == 0)
+    return;
+
+  if (free_data) {
+    void *target = (char *)arr->data + (arr->size-1) * arr->element_size;
+    free_data(target);
+  }
+  
+  darray_armem_resize(arr, arr->size-1);
+}
+
+void *darray_armem_get(darray_armem *arr, size_t index) {
+  if (index >= arr->size) {
+    fprintf(stderr, "darray_armem_get: index out of bounds\n");
+    exit(EXIT_FAILURE);
+  }
+  return (char *)arr->data + index * arr->element_size;
+}
+
+darray_armem darray_armem_slice(darray_armem *arr, size_t start, size_t end) {
+  if (start > end || end > arr->size) {
+    fprintf(stderr, "darray_armem_slice: invalid slice range\n");
+    exit(EXIT_FAILURE);
+  }
+
+  darray_armem slice;
+
+  slice.data = (char *)arr->data + start * arr->element_size;
+  slice.size = (end - start);
+  slice.element_size = arr->element_size;
+  slice.capacity = ((slice.size + CHUNK_SIZE) / CHUNK_SIZE) * CHUNK_SIZE;
+  slice.resizable = false;
+
+  return slice;
+}
+
+void darray_armem_free(darray_armem *arr, void (*free_data)(void *)) {
+  if (!arr->resizable) {
+    // It's a view/slice — don't free
+    return;
+  }
+  if (free_data) {
+    for (size_t i = 0; i < arr->size; ++i) {
+      void *element = (char *)arr->data + i * arr->element_size;
+      free_data(element);
+    }
+  }
+  free(arr->data);
+  arr->data = NULL;
+  arr->size = 0;
+  arr->capacity = 0;
+  arr->element_size = 0;
+  arr->resizable = false;
+}

src/runtime/internals/dynamic_array_armem/darray_armem.h

@@ -0,0 +1,37 @@
+#ifndef darray_armem_H
+#define darray_armem_H
+
+#include <stdbool.h>
+#include <stddef.h> // for size_t
+
+#define CHUNK_SIZE 16
+
+typedef struct {
+  void *data;
+  size_t element_size;
+  size_t size;
+  size_t capacity;
+  bool resizable;
+} darray_armem;
+
+// Initializes the dynamic_array
+void darray_armem_init(darray_armem *arr, size_t element_size);
+
+// Pushes an element onto the array
+void darray_armem_push(darray_armem *arr, void *element);
+
+// Pops the last element, calling `free_data` if provided
+void darray_armem_pop(darray_armem *arr, void (*free_data)(void *));
+
+// Gets a pointer to an element at index
+void *darray_armem_get(darray_armem *arr, size_t index);
+
+// Frees the entire array and optionally each element
+void darray_armem_free(darray_armem *arr, void (*free_data)(void *));
+
+// Resizes the array to a new size (internal use, but exposed)
+void darray_armem_resize(darray_armem *arr, size_t new_size);
+
+darray_armem darray_armem_slice(darray_armem *arr, size_t start, size_t end);
+
+#endif // darray_armem_H

src/runtime/objects/functions/functions.c

@@ -23,24 +23,18 @@ void load_argon_function(Translated *translated, RuntimeState *state,
   object->value.argon_fn.number_of_parameters = pop_bytecode(translated, state);
   object->value.argon_fn.parameters =
       ar_alloc(object->value.argon_fn.number_of_parameters * sizeof(char *));
-  printf("%s(", object->name);
   for (size_t i = 0; i < object->value.argon_fn.number_of_parameters; i++) {
-    if(i!=0)printf(", ");
     offset = pop_bytecode(translated, state);
     length = pop_bytecode(translated, state);
     object->value.argon_fn.parameters[i] = ar_alloc_atomic(length + 1);
     memcpy(object->value.argon_fn.parameters[i], arena_get(&translated->constants, offset), length);
     object->value.argon_fn.parameters[i][length] = '\0';
-    printf("%s", object->value.argon_fn.parameters[i]);
   }
-  printf(") = ");
   offset = pop_bytecode(translated, state);
   length = pop_bytecode(translated, state);
-  darray_init(&object->value.argon_fn.bytecode, sizeof(uint64_t));
-  darray_resize(&object->value.argon_fn.bytecode, length/object->value.argon_fn.bytecode.element_size);
+  darray_armem_init(&object->value.argon_fn.bytecode, sizeof(uint64_t));
+  darray_armem_resize(&object->value.argon_fn.bytecode, length/object->value.argon_fn.bytecode.element_size);
   memcpy(object->value.argon_fn.bytecode.data, arena_get(&translated->constants, offset), length);
   object->value.argon_fn.stack = stack;
-  fwrite(object->value.argon_fn.bytecode.data, object->value.argon_fn.bytecode.element_size, object->value.argon_fn.bytecode.size, stdout);
-  printf("\n");
   state->registers[0]=object;
 }

src/runtime/objects/object.h

@@ -1,7 +1,7 @@
 #ifndef OBJECT_H
 #define OBJECT_H
 #include "../internals/hashmap/hashmap.h"
-#include "../../dynamic_array/darray.h"
+#include "../internals/dynamic_array_armem/darray_armem.h"
 #include <gmp.h>
 #include <stdbool.h>
 #include "../runtime.h"
@@ -13,7 +13,7 @@ struct string_struct {
   size_t length;
 };
 struct argon_function_struct {
-  DArray bytecode;
+  darray_armem bytecode;
   struct Stack stack;
   size_t number_of_parameters;
   char** parameters;

src/runtime/runtime.c

@@ -1,12 +1,13 @@
 #include "runtime.h"
 #include "../translator/translator.h"
 #include "internals/siphash/siphash.h"
+#include "objects/functions/functions.h"
 #include "objects/null/null.h"
 #include "objects/object.h"
 #include "objects/string/string.h"
 #include "objects/type/type.h"
-#include "objects/functions/functions.h"
 #include <fcntl.h>
+#include <gc/gc.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -35,25 +36,26 @@ void load_const(Translated *translated, RuntimeState *state) {
   size_t length = pop_bytecode(translated, state);
   uint64_t offset = pop_bytecode(translated, state);
 
-  void*data = ar_alloc_atomic(length);
-  memcpy(data, arena_get(&translated->constants,offset), length);
+  void *data = ar_alloc_atomic(length);
+  memcpy(data, arena_get(&translated->constants, offset), length);
   ArgonObject *object = ARGON_NULL;
   switch (type) {
-    case TYPE_OP_STRING:
-      object = init_string_object(data, length);
-      break;
+  case TYPE_OP_STRING:
+    object = init_string_object(data, length);
+    break;
   }
   state->registers[to_register] = object;
 }
 
-void run_instruction(Translated *translated, RuntimeState *state, struct Stack stack) {
+void run_instruction(Translated *translated, RuntimeState *state,
+                     struct Stack stack) {
   OperationType opcode = pop_bytecode(translated, state);
   switch (opcode) {
   case OP_LOAD_NULL:
     state->registers[pop_bytecode(translated, state)] = ARGON_NULL;
     break;
   case OP_LOAD_CONST:
-    load_const(translated,state);
+    load_const(translated, state);
     break;
   case OP_LOAD_FUNCTION:
     load_argon_function(translated, state, stack);
@@ -65,9 +67,10 @@ void runtime(Translated translated) {
   RuntimeState state = {
       checked_malloc(translated.registerCount * sizeof(ArgonObject *)), 0};
   struct Stack stack = {};
-
-  while (state.head < translated.bytecode.size)
-    run_instruction(&translated, &state,stack);
+  state.head = 0;
+  while (state.head < translated.bytecode.size) {
+    run_instruction(&translated, &state, stack);
+  }
   free(state.registers);
 }