From 5dc0946a1964a68a290453b466766f3142af3ad2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jose=20Luis=20Monta=C3=B1es=20Ojados?= <joseluis@zubi.group>
Date: Sun, 15 Feb 2026 22:12:19 +0100
Subject: [PATCH] add JLANG_free and Object

---
 run.exe                | Bin 66102 -> 66815 bytes
 src/main.c             |  22 +++-
 src/memory/allocator.h | 290 ++++++++++++++++++++---------------------
 src/objects/object.h   | 101 ++++++++++++++
 4 files changed, 262 insertions(+), 151 deletions(-)
 create mode 100644 src/objects/object.h

diff --git a/run.exe b/run.exe
index 99be10faaace17b74b27fcd75af069a2b8b51f4d..cb1ae3770597c205238f0322e03e56b4676deb19 100644
GIT binary patch
delta 11966
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

delta 10957
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
H9UA{{C~2v3

diff --git a/src/main.c b/src/main.c
index 2512cdb..698031e 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1,4 +1,4 @@
-#include "memory/allocator.h"
+#include "objects/object.h"
 
 int main() {
   JLANG_memory_allocator *allocPtr = JLANG_CreateAllocator();
@@ -7,12 +7,24 @@ int main() {
   printf("memoryPtr=%p\n", allocPtr->memory);
   printf("size=%zu\n", allocPtr->size);
 
-  JLANG_visualize(allocPtr);
+  // Create object
+  Object *intVar1 = obj_new_int(allocPtr, 66);
+  obj_print(intVar1);
 
-  void *var1 = JLANG_malloc(allocPtr, 512);
-  printf("var1Ptr=%p\n", var1);
+  Object *stringVar1 = obj_new_string(allocPtr, "\nHello world!\n");
+  obj_print(stringVar1);
 
   JLANG_visualize(allocPtr);
-  
+
+  for (int i = 0; i < 10; i++) {
+    Object *intVar1 = obj_new_int(allocPtr, 66);
+    obj_print(intVar1);
+  }
+
+  obj_free(allocPtr, intVar1);
+  void* newPtr = JLANG_malloc(allocPtr, 8);
+
+  obj_print(stringVar1);
+  JLANG_visualize(allocPtr);
   return 0;
 }
\ No newline at end of file
diff --git a/src/memory/allocator.h b/src/memory/allocator.h
index e8c1ff1..b3d3cb5 100644
--- a/src/memory/allocator.h
+++ b/src/memory/allocator.h
@@ -1,11 +1,12 @@
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 /*
     Custom Memory Allocator
 
-    Implementacion custom de un memory allocator que opera sobre un array de bytes usandolo como "heap"
+    Implementacion custom de un memory allocator que opera sobre un array de
+   bytes usandolo como "heap"
 */
 
 #define JLANG_OK 0
@@ -15,99 +16,106 @@
 #define JLANG_PAYLOAD 2
 
 /*
-    La estructura de Metadata se encarga de almacenar el tamaño del bloque y si está en uso.
-    Se añadirá al principio de cada bloque
-    [BLOCK_METADATA] + [BLOCK_BYTES]
+    La estructura de Metadata se encarga de almacenar el tamaño del bloque y si
+   está en uso. Se añadirá al principio de cada bloque [BLOCK_METADATA] +
+   [BLOCK_BYTES]
 */
-typedef struct
-{
-    size_t size; // 8 bytes
-    int in_use;  // 4 bytes
-    // --- aquí el compilador mete 4 bytes invisibles ---
+typedef struct {
+  size_t size; // 8 bytes
+  int in_use;  // 4 bytes
+               // --- aquí el compilador mete 4 bytes invisibles ---
 } JLANG_metadata;
 
 /*
-    La estructura de Memory Allocator se encarga de almancenar el array de memoria y el tamaño de esta.
+    La estructura de Memory Allocator se encarga de almancenar el array de
+   memoria y el tamaño de esta.
 */
-typedef struct
-{
-    char *memory; // 8 bytes
-    size_t size;  // 8 bytes
+typedef struct {
+  char *memory; // 8 bytes
+  size_t size;  // 8 bytes
 } JLANG_memory_allocator;
 
-void *JLANG_CreateAllocator()
-{
-    // Allocate memory in heap for JLANG_memory_allocator
-    JLANG_memory_allocator *allocator = (JLANG_memory_allocator *)malloc(sizeof(JLANG_memory_allocator));
+void *JLANG_CreateAllocator() {
+  // Allocate memory in heap for JLANG_memory_allocator
+  JLANG_memory_allocator *allocator =
+      (JLANG_memory_allocator *)malloc(sizeof(JLANG_memory_allocator));
 
-    // Assign default free bytes
-    allocator->memory = (char *)malloc(1 * 1024);
-    allocator->size = 1 * 1024;
+  // Assign default free bytes
+  allocator->memory = (char *)malloc(1 * 1024);
+  allocator->size = 1 * 1024;
 
-    // ensure all memory is zero
-    for (int i = 0; i < 1 * 1024; i++)
-    {
-        allocator->memory[i] = 0;
-    }
+  // ensure all memory is zero
+  for (int i = 0; i < 1 * 1024; i++) {
+    allocator->memory[i] = 0;
+  }
 
-    return allocator;
+  return allocator;
 }
 
-size_t JLANG_used(void *ptr)
-{
-    JLANG_memory_allocator *allocPtr = (JLANG_memory_allocator *)ptr;
+size_t JLANG_used(void *ptr) {
+  JLANG_memory_allocator *allocPtr = (JLANG_memory_allocator *)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)
-    {
-        used += sizeof(JLANG_metadata) + currentHeader->size;
+  // Iterate memory parsing only metadata
+  JLANG_metadata *currentHeader = (JLANG_metadata *)allocPtr->memory;
+  size_t used = 0;
+  while (currentHeader->in_use != 0 && used < allocPtr->size) {
+    used += sizeof(JLANG_metadata) + currentHeader->size;
 
-        // Current block is in_use, jump to next block
-        currentHeader = (JLANG_metadata *)((char *)currentHeader + sizeof(JLANG_metadata) + currentHeader->size);
-    }
+    // Current block is in_use, jump to next block
+    currentHeader =
+        (JLANG_metadata *)((char *)currentHeader + sizeof(JLANG_metadata) +
+                           currentHeader->size);
+  }
 
-    return used;
+  return used;
 }
 
-void *JLANG_last_free(void *ptr)
-{
-    JLANG_memory_allocator *allocPtr = (JLANG_memory_allocator *)ptr;
+void *JLANG_last_free(void *ptr) {
+  JLANG_memory_allocator *allocPtr = (JLANG_memory_allocator *)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)
-    {
-        used += sizeof(JLANG_metadata) + currentHeader->size;
+  // Iterate memory parsing only metadata
+  JLANG_metadata *currentHeader = (JLANG_metadata *)allocPtr->memory;
+  size_t used = 0;
+  while (currentHeader->in_use != 0 && used < allocPtr->size) {
+    used += sizeof(JLANG_metadata) + currentHeader->size;
 
-        // Current block is in_use, jump to next block
-        currentHeader = (JLANG_metadata *)((char *)currentHeader + sizeof(JLANG_metadata) + currentHeader->size);
-    }
+    // Current block is in_use, jump to next block
+    currentHeader =
+        (JLANG_metadata *)((char *)currentHeader + sizeof(JLANG_metadata) +
+                           currentHeader->size);
+  }
 
-    return currentHeader;
+  return currentHeader;
 }
 
-void *JLANG_malloc(void *ptr, size_t size)
-{
-    JLANG_memory_allocator *allocPtr = (JLANG_memory_allocator *)ptr;
+void *JLANG_malloc(void *ptr, size_t size) {
+  JLANG_memory_allocator *allocPtr = (JLANG_memory_allocator *)ptr;
 
-    // 1. Hay bloques disponibles??
-    size_t used = JLANG_used(ptr);
-    size_t available = allocPtr->size - used;
+  // 1. Hay bloques disponibles??
+  size_t used = JLANG_used(ptr);
+  size_t available = allocPtr->size - used;
 
-    // chequear si hay suficiente espacio libre
-    if (available > size + sizeof(JLANG_metadata))
-    {
-        JLANG_metadata *freeHeader = (JLANG_metadata *)JLANG_last_free(ptr);
-        freeHeader->size = size;
-        freeHeader->in_use = 1;
+  // chequear si hay suficiente espacio libre
+  if (available > size + sizeof(JLANG_metadata)) {
+    JLANG_metadata *freeHeader = (JLANG_metadata *)JLANG_last_free(ptr);
+    freeHeader->size = size;
+    freeHeader->in_use = 1;
 
-        return (char *)freeHeader + sizeof(JLANG_metadata);
-    }
+    return (char *)freeHeader + sizeof(JLANG_metadata);
+  }
 
-    return NULL; // TODO
+  return NULL; // TODO
+}
+
+void JLANG_free(void *ptr, void *blockPtr) {
+  JLANG_memory_allocator *allocPtr = (JLANG_memory_allocator *)ptr;
+
+  // Get block header
+  JLANG_metadata *blockHeader =
+      (JLANG_metadata *)((char *)blockPtr - sizeof(JLANG_metadata));
+
+  // Set block as not_used
+  blockHeader->in_use = 0;
 }
 
 /*
@@ -116,101 +124,91 @@ void *JLANG_malloc(void *ptr, size_t size)
     [FF FF FF FF FF FF FF ]
 */
 
-int _ceil(float v)
-{
-    int n = (int)v;
-    float r = v - n;
+int _ceil(float v) {
+  int n = (int)v;
+  float r = v - n;
 
-    if (r > 0)
-    {
-        return n + 1;
-    }
-    return n;
+  if (r > 0) {
+    return n + 1;
+  }
+  return n;
 }
 
-void JLANG_visualize(void *ptr)
-{
-    JLANG_memory_allocator *allocPtr = (JLANG_memory_allocator *)ptr;
+void JLANG_visualize(void *ptr) {
+  JLANG_memory_allocator *allocPtr = (JLANG_memory_allocator *)ptr;
 
-    // Step 1. Get byte type
-    char *byteMapPtr = (char *)malloc(allocPtr->size);
-    memset(byteMapPtr, 0, allocPtr->size);
+  // Step 1. Get byte type
+  char *byteMapPtr = (char *)malloc(allocPtr->size);
+  memset(byteMapPtr, 0, allocPtr->size);
 
-    JLANG_metadata *currentHeader = (JLANG_metadata *)allocPtr->memory;
-    long used = 0;
-    while (used < allocPtr->size)
-    {
-        long blockIndex = (char *)currentHeader - (char *)allocPtr->memory;
-        printf("blockIndex=%u\n", blockIndex);
-        used += sizeof(JLANG_metadata) + currentHeader->size;
-        
-        /*
-            HEADER
-            blockIndex + sizeof(JLANG_metadata)
-        */
+  JLANG_metadata *currentHeader = (JLANG_metadata *)allocPtr->memory;
+  long used = 0;
+  while (used < allocPtr->size) {
+    long blockIndex = (char *)currentHeader - (char *)allocPtr->memory;
+    used += sizeof(JLANG_metadata) + currentHeader->size;
 
-        if (currentHeader->size > 0)
-        {
-            byteMapPtr[blockIndex] = JLANG_HEADER;
-            for (int i = 0; i < sizeof(JLANG_metadata); i++)
-            {
-                byteMapPtr[blockIndex + i] = JLANG_HEADER;
-            }
+    /*
+        HEADER
+        blockIndex + sizeof(JLANG_metadata)
+    */
 
-            /*
-                PAYLOAD
-            */
-            for (int i = 0; i < currentHeader->size; i++)
-            {
-                byteMapPtr[blockIndex + sizeof(JLANG_metadata) + i] = JLANG_PAYLOAD;
-            }
-        } else {
-            break;
-        }
+    if (currentHeader->size > 0) {
+      byteMapPtr[blockIndex] = JLANG_HEADER;
+      for (int i = 0; i < sizeof(JLANG_metadata); i++) {
+        byteMapPtr[blockIndex + i] = JLANG_HEADER;
+      }
 
-        // Jump to next block
-        currentHeader = (JLANG_metadata *)((char *)currentHeader + sizeof(JLANG_metadata) + currentHeader->size);
+      /*
+          PAYLOAD
+      */
+      for (int i = 0; i < currentHeader->size; i++) {
+        byteMapPtr[blockIndex + sizeof(JLANG_metadata) + i] = JLANG_PAYLOAD;
+      }
+    } else {
+      break;
     }
 
-    // Step 2. Draw
+    // Jump to next block
+    currentHeader =
+        (JLANG_metadata *)((char *)currentHeader + sizeof(JLANG_metadata) +
+                           currentHeader->size);
+  }
 
-    int bytePerRow = 40;
-    int totalRows = _ceil(allocPtr->size / bytePerRow);
-    printf("totalRows=%d\n", totalRows);
+  // Step 2. Draw
 
-    char *currentMemPtr = allocPtr->memory;
+  int bytePerRow = 40;
+  int totalRows = _ceil(allocPtr->size / bytePerRow);
+  printf("totalRows=%d\n", totalRows);
 
-    for (int i = 0; i < totalRows; i++)
-    {
-        printf("[");
-        for (int n = 0; n < bytePerRow; n++)
-        {
+  char *currentMemPtr = allocPtr->memory;
 
-            int index = n + i * bytePerRow;
+  for (int i = 0; i < totalRows; i++) {
+    printf("[");
+    for (int n = 0; n < bytePerRow; n++) {
 
-            switch (byteMapPtr[index])
-            {
-            case JLANG_HEADER:
-                printf("\033[46m");
-                break;
-            case JLANG_FREE:
-                printf("\033[32m");
-                break;
-            default:
-                printf("\033[41m");
-                break;
-            }
+      int index = n + i * bytePerRow;
 
-            printf("%.2x", (unsigned char) *(currentMemPtr + (n + i * bytePerRow)));
+      switch (byteMapPtr[index]) {
+      case JLANG_HEADER:
+        printf("\033[46m");
+        break;
+      case JLANG_FREE:
+        printf("\033[32m");
+        break;
+      default:
+        printf("\033[41m");
+        break;
+      }
 
-            if (n < bytePerRow - 1)
-            {
-                printf(" ");
-            }
+      printf("%.2x", (unsigned char)*(currentMemPtr + (n + i * bytePerRow)));
 
-            printf("\033[0m");
-        }
+      if (n < bytePerRow - 1) {
+        printf(" ");
+      }
 
-        printf("]\n");
+      printf("\033[0m");
     }
+
+    printf("]\n");
+  }
 }
diff --git a/src/objects/object.h b/src/objects/object.h
new file mode 100644
index 0000000..118666f
--- /dev/null
+++ b/src/objects/object.h
@@ -0,0 +1,101 @@
+#include "../memory/allocator.h"
+
+typedef enum
+{
+    OBJ_INT,
+    OBJ_FLOAT,
+    OBJ_STRING,
+    OBJ_LIST,
+    OBJ_NONE
+} ObjectType;
+
+typedef struct Object
+{
+    ObjectType type;
+    union
+    {
+        int int_val;
+        double float_val;
+        struct
+        {
+            char *chars;
+            int length;
+        } string_val;
+        struct
+        {
+            struct Object **items;
+            int count;
+            int capacity;
+        } list_val;
+    } data;
+} Object;
+
+Object *obj_new_int(void *allocator, int value)
+{
+    Object *objPtr = (Object *)JLANG_malloc(allocator, sizeof(Object));
+    objPtr->type = OBJ_INT;
+    objPtr->data.int_val = value;
+    return objPtr;
+}
+
+Object *obj_new_float(void *allocator, float value)
+{
+    Object *objPtr = (Object *)JLANG_malloc(allocator, sizeof(Object));
+    objPtr->type = OBJ_FLOAT;
+    objPtr->data.float_val = value;
+    return objPtr;
+}
+
+Object *obj_new_string(void *allocator, const char *str)
+{
+    Object *objPtr = (Object *)JLANG_malloc(allocator, sizeof(Object));
+    objPtr->type = OBJ_STRING;
+
+    int len = strlen(str);
+    char *buffer = (char *)JLANG_malloc(allocator, len + 1);
+    memcpy(buffer, str, len + 1);
+
+    objPtr->data.string_val.chars = buffer;
+    objPtr->data.string_val.length = len;
+
+    return objPtr;
+}
+
+Object *obj_new_list(void *allocator)
+{
+    Object *objPtr = (Object *)JLANG_malloc(allocator, sizeof(Object));
+    objPtr->type = OBJ_LIST;
+    return objPtr;
+}
+
+void obj_free(void *allocator, Object* obj) {
+    if (obj->type == OBJ_STRING) {
+        JLANG_free(allocator, obj->data.string_val.chars);
+    }
+
+    JLANG_free(allocator, obj);
+}
+
+void obj_print(Object *obj)
+{
+    switch (obj->type)
+    {
+    case OBJ_INT:
+        printf("%d", obj->data.int_val);
+        break;
+    case OBJ_FLOAT:
+        printf("%f", obj->data.float_val);
+        break;
+    case OBJ_LIST:
+        for (int i = 0; i < obj->data.list_val.count; i++)
+        {
+            obj_print(obj->data.list_val.items[i]);
+        }
+        break;
+    case OBJ_STRING:
+        printf("%s", obj->data.string_val.chars);
+        break;
+    default:
+        break;
+    }
+}