fix memory leak in declaration and function

src/dynamic_array/darray.h

@@ -4,7 +4,7 @@
 #include <stdbool.h>
 #include <stddef.h> // for size_t
 
-#define CHUNK_SIZE 1024
+#define CHUNK_SIZE 16
 
 typedef struct {
   void *data;

src/main.c

@@ -3,16 +3,16 @@
 #include "lexer/token.h"
 #include "memory.h"
 #include "parser/parser.h"
-#include "translator/translator.h"
 #include "runtime/runtime.h"
+#include "translator/translator.h"
 
 #include <endian.h>
-#include <string.h>
 #include <locale.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
+#include <string.h>
 #include <unistd.h>
 
 const char FILE_IDENTIFIER[] = "ARBI";
@@ -62,7 +62,7 @@ int main(int argc, char *argv[]) {
   regCount = htole64(regCount);
   constantsSize = htole64(constantsSize);
   bytecodeSize = htole64(bytecodeSize);
-  
+
   fwrite(&FILE_IDENTIFIER, sizeof(char), strlen(FILE_IDENTIFIER), file);
   fwrite(&version_number_htole64ed, sizeof(uint64_t), 1, file);
   fwrite(&regCount, sizeof(uint64_t), 1, file);
@@ -77,7 +77,6 @@ int main(int argc, char *argv[]) {
   generate_siphash_key();
 
   init_types();
-
   runtime(translated);
 
   free_translator(&translated);

src/parser/assignable/call/call.c

@@ -49,5 +49,6 @@ void free_parse_call(void *ptr) {
 
   darray_free(&parsedCall->args, free_parsed);
   free_parsed(parsedCall->to_call);
+  free(parsedCall->to_call);
   free(parsedCall);
 }

src/parser/declaration/declaration.c

@@ -1,9 +1,9 @@
 #include "declaration.h"
 #include "../../lexer/token.h"
 #include "../../memory.h"
+#include "../function/function.h"
 #include "../literals/literals.h"
 #include "../parser.h"
-#include "../function/function.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -23,7 +23,6 @@ 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;
     DArray parameters;
     declaration->from = parse_null();
 
@@ -40,7 +39,6 @@ ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) {
       return parsedValue;
     token = darray_get(tokens, *index);
     if (token->type == TOKEN_LPAREN) {
-      isFunction = true;
       darray_init(&parameters, sizeof(char *));
       (*index)++;
       error_if_finished(file, tokens, index);
@@ -63,8 +61,8 @@ ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) {
                     file, token->line, token->column);
             exit(EXIT_FAILURE);
           }
-          char *parameter_name =
-              strcpy(checked_malloc(strlen(token->value) + 1), token->value);
+          char *parameter_name = checked_malloc(strlen(token->value) + 1);
+          strcpy(parameter_name, token->value);
           darray_push(&parameters, &parameter_name);
           (*index)++;
           error_if_finished(file, tokens, index);
@@ -99,13 +97,15 @@ ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) {
                 token->column);
         exit(EXIT_FAILURE);
       }
-      if (isFunction) {
-        declaration->from = create_parsed_function(declaration->name, parameters, declaration->from);
-      }
-      if ((*index) >= tokens->size)
-        break;
-      token = darray_get(tokens, *index);
     }
+    if (parameters.resizable) {
+      declaration->from = create_parsed_function(declaration->name, parameters,
+                                                 declaration->from);
+    }
+    if ((*index) >= tokens->size)
+      break;
+    token = darray_get(tokens, *index);
+
     size_t count = skip_newlines_and_indents(tokens, index);
     if ((*index) >= tokens->size)
       break;

src/parser/function/function.c

@@ -1,5 +1,6 @@
 #include "function.h"
 #include "../../memory.h"
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -15,11 +16,17 @@ ParsedValue *create_parsed_function(char *name, DArray parameters,
   return parsedValue;
 }
 
+void free_parameter(void *ptr) {
+  char** data = ptr;
+  free(*data);
+}
+
 void free_function(void *ptr) {
   ParsedValue *parsedValue = ptr;
   ParsedFunction *parsed = parsedValue->data;
   free_parsed(parsed->body);
+  free(parsed->body);
   free(parsed->name);
-  darray_free(&parsed->parameters, NULL);
+  darray_free(&parsed->parameters, free_parameter);
   free(parsed);
 }

src/parser/parser.c

@@ -23,8 +23,8 @@
 #include <string.h>
 
 const char *ValueTypeNames[] = {
-    "string",  "assign",     "identifier",  "number",    "if statement",
-    "access",  "call",       "declaration", "null",      "boolean",
+    "string",  "assign",     "identifier",  "number",     "if statement",
+    "access",  "call",       "declaration", "null",       "boolean",
     "do wrap", "operations", "list",        "dictionary", "function"};
 
 void error_if_finished(char *file, DArray *tokens, size_t *index) {
@@ -157,7 +157,7 @@ ParsedValue *parse_token_full(char *file, DArray *tokens, size_t *index,
       passed = true;
     }
   }
-  
+
   return output;
 }
 

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