Refactor allocator to use offsets instead of absolute pointers

JLANG_malloc now returns size_t offsets relative to the heap buffer,
making all references stable across heap growth (realloc). Object API
updated accordingly: constructors return offsets, obj_print/obj_free
receive (allocator, offset). Added heap auto-grow when out of space.

src/memory/allocator.h

@@ -58,7 +58,7 @@ size_t JLANG_used(void *ptr) {
   // Iterate memory parsing only metadata
   JLANG_metadata *currentHeader = (JLANG_metadata *)allocPtr->memory;
   size_t used = 0;
-  while (currentHeader->in_use != 0 && used < allocPtr->size) {
+  while (currentHeader->size != 0 && used < allocPtr->size) {
     used += sizeof(JLANG_metadata) + currentHeader->size;
 
     // Current block is in_use, jump to next block
@@ -76,7 +76,7 @@ void *JLANG_last_free(void *ptr) {
   // Iterate memory parsing only metadata
   JLANG_metadata *currentHeader = (JLANG_metadata *)allocPtr->memory;
   size_t used = 0;
-  while (currentHeader->in_use != 0 && used < allocPtr->size) {
+  while (currentHeader->size != 0 && used < allocPtr->size) {
     used += sizeof(JLANG_metadata) + currentHeader->size;
 
     // Current block is in_use, jump to next block
@@ -88,7 +88,9 @@ void *JLANG_last_free(void *ptr) {
   return currentHeader;
 }
 
-void *JLANG_malloc(void *ptr, size_t size) {
+// JLANG_malloc devuelve un offset a la memoria del heap. No un absoluto a la
+// memoria del proceso
+size_t JLANG_malloc(void *ptr, size_t size) {
   JLANG_memory_allocator *allocPtr = (JLANG_memory_allocator *)ptr;
 
   // 1. Hay bloques disponibles??
@@ -101,16 +103,42 @@ void *JLANG_malloc(void *ptr, size_t size) {
     freeHeader->size = size;
     freeHeader->in_use = 1;
 
-    return (char *)freeHeader + sizeof(JLANG_metadata);
+    void *payloadPtr = (char *)freeHeader + sizeof(JLANG_metadata);
+
+    return (char *)payloadPtr - allocPtr->memory;
   }
 
-  return NULL; // TODO
+  /*
+    Se necesita más espacio..
+    De momento vamos a pedir otro array más grande y liberar el antiguo
+    Mantenemos toda la memoria contigua
+  */
+
+  int newSize = allocPtr->size + 1024;
+  char *newBuffer = (char *)malloc(newSize); // Otro 1KB
+  memset(newBuffer, 0, newSize);
+  memcpy(newBuffer, allocPtr->memory,
+         allocPtr->size); // Copiamos al nuevo buffer
+
+  allocPtr->size = newSize;
+
+  free(allocPtr->memory);       // Liberamos el buffer antiguo
+  allocPtr->memory = newBuffer; // Seteamos el nuevo buffer
+
+  JLANG_metadata *freeHeader = (JLANG_metadata *)JLANG_last_free(ptr);
+  freeHeader->size = size;
+  freeHeader->in_use = 1;
+
+  void *payloadPtr = (char *) freeHeader + sizeof(JLANG_metadata);
+  return (char *)payloadPtr - allocPtr->memory;
 }
 
-void JLANG_free(void *ptr, void *blockPtr) {
+void JLANG_free(void *ptr, size_t blockOffset) {
   JLANG_memory_allocator *allocPtr = (JLANG_memory_allocator *)ptr;
 
   // Get block header
+  void *blockPtr = allocPtr->memory + blockOffset;
+
   JLANG_metadata *blockHeader =
       (JLANG_metadata *)((char *)blockPtr - sizeof(JLANG_metadata));