added a basic heap inspection utility to the debugger and modified the impl of the buffer object

src/objects/heap.c

@@ -20,6 +20,7 @@ typedef struct {
 } PendingDestruct;
 
 struct xHeap {
+	int objcount;
 	int   size;
 	int   used;
 	int   total;
@@ -30,7 +31,7 @@ struct xHeap {
 
 	_Bool collecting;
 	_Bool collection_failed;
-	int moved_with_destructors;
+	int movedcount;
 	void *old_body;
 	int   old_used;
 	int   old_total;
@@ -48,6 +49,7 @@ Heap *Heap_New(int size)
 	if(heap == NULL)
 		return NULL;
 
+	heap->objcount = 0;
 	heap->total = 0;
 	heap->size = size;
 	heap->used = 0;
@@ -105,6 +107,21 @@ void Heap_Free(Heap *heap)
 	free(heap);
 }
 
+void *Heap_GetPointer(Heap *heap)
+{
+	return heap->body;
+}
+
+unsigned int Heap_GetSize(Heap *heap)
+{
+	return heap->size;
+}
+
+unsigned int Heap_GetObjectCount(Heap *heap)
+{
+	return heap->objcount;
+}
+
 float Heap_GetUsagePercentage(Heap *heap)
 {
 	return 100.0 * heap->total / heap->size;
@@ -176,6 +193,8 @@ void *Heap_Malloc(Heap *heap, TypeObject *type, Error *err)
 	if(requires_destruct)
 		heap->pend[heap->pend_used++] = (PendingDestruct) { .object = obj, .destructor = obj->type->free };
 
+	heap->objcount += 1;
+
 	return (Object*) addr;
 }
 
@@ -246,7 +265,7 @@ _Bool Heap_StartCollection(Heap *heap, Error *error)
 	heap->oflow = NULL;
 	heap->collecting = 1;
 	heap->collection_failed = 0;
-	heap->moved_with_destructors = 0;
+	heap->movedcount = 0;
 	heap->error = error;
 	return 1;
 }
@@ -311,6 +330,7 @@ _Bool Heap_StopCollection(Heap *heap)
 	free(heap->old_body);
 
 	heap->collecting = 0;
+	heap->objcount = heap->movedcount;
 	return 1;
 }
 
@@ -397,8 +417,7 @@ void Heap_CollectReference(Object **referer, void *userp)
 						((MovedObject*) old_location)->new_location = new_location;
 					}
 
-					if(type->free != NULL)
-						heap->moved_with_destructors += 1;
+					heap->movedcount += 1;
 				}
 
 			// Collect the reference to the type.

src/objects/o_buffer.c

@@ -1,35 +1,57 @@
+#include <stdlib.h>
 #include <assert.h>
 #include <string.h>
 #include "../utils/defs.h"
 #include "objects.h"
 
 typedef struct {
-	int           size,
-	              refs;
-	unsigned char data[];
-} BufferBody;
-
-typedef struct {
-	Object      base;
-	BufferBody *body;
-	int offset, length;
+	Object         base;
+	int            size;
+	unsigned char *body;
 } BufferObject;
 
-static Object *select(Object *self, Object *key, Heap *heap, Error *err);
-static _Bool   insert(Object *self, Object *key, Object *val, Heap *heap, Error *err);
-static int     count(Object *self);
-static void	   print(Object *obj, FILE *fp);
+typedef struct {
+	Object        base;
+	BufferObject *sliced;
+	int           offset, 
+	              length;
+} BufferSliceObject;
+
+static Object *buffer_select(Object *self, Object *key, Heap *heap, Error *err);
+static _Bool   buffer_insert(Object *self, Object *key, Object *val, Heap *heap, Error *err);
+static int     buffer_count(Object *self);
+static void	   buffer_print(Object *obj, FILE *fp);
+static _Bool   buffer_free(Object *self, Error *error);
+
+static Object *slice_select(Object *self, Object *key, Heap *heap, Error *err);
+static _Bool   slice_insert(Object *self, Object *key, Object *val, Heap *heap, Error *err);
+static int     slice_count(Object *self);
+static void	   slice_print(Object *obj, FILE *fp);
+
 
 static TypeObject t_buffer = {
 	.base = (Object) { .type = &t_type, .flags = Object_STATIC },
 	.name = "buffer",
 	.size = sizeof (BufferObject),
-	.select = select,
-	.insert = insert,
-	.count = count,
-	.print = print,
+	.select = buffer_select,
+	.insert = buffer_insert,
+	.count = buffer_count,
+	.print = buffer_print,
+	.free  = buffer_free,
 };
 
+static TypeObject t_buffer_slice = {
+	.base = (Object) { .type = &t_type, .flags = Object_STATIC },
+	.name = "buffer slice",
+	.size = sizeof (BufferSliceObject),
+	.select = slice_select,
+	.insert = slice_insert,
+	.count = slice_count,
+	.print = slice_print,
+};
+
+#define THRESHOLD 128
+
 Object *Object_NewBuffer(int size, Heap *heap, Error *error)
 {
 	assert(size >= 0);
@@ -42,73 +64,147 @@ Object *Object_NewBuffer(int size, Heap *heap, Error *error)
 		if(obj == NULL)
 			return NULL;
 
-		obj->offset = 0;
-		obj->length = size;
-		obj->body = Heap_RawMalloc(heap, sizeof(BufferBody) + sizeof(unsigned char) * size, error);
+		unsigned char *body;
 
-		if(obj->body == NULL)
-			return NULL;
+		if(size > THRESHOLD)
+			{
+				body = malloc(sizeof(unsigned char) * size);
 
-		obj->body->size = size;
-		obj->body->refs = 1;
-		memset(obj->body->data, 0, size);
+				if(body == NULL)
+					{
+						Error_Report(error, 1, "No memory");
+						return NULL;
+					}
+			}
+		else
+			{
+				body = Heap_RawMalloc(heap, sizeof(unsigned char) * size, error);
+				
+				if(body == NULL)
+					return NULL;
+			}
+
+		obj->size = size;
+		obj->body = body;
+		memset(obj->body, 0, size);
 	}
 
 	return (Object*) obj;
 }
 
+static _Bool buffer_free(Object *self, Error *error)
+{
+	(void) error;
+
+	BufferObject *buffer = (BufferObject*) self;
+	
+	if(buffer->size > THRESHOLD)
+		free(buffer->body);
+	return 1;
+}
+
 Object *Object_SliceBuffer(Object *buffer, int offset, int length, Heap *heap, Error *error)
 {
-	if(buffer->type != &t_buffer)
+	if(buffer->type != &t_buffer && buffer->type != &t_buffer_slice)
 		{
-			Error_Report(error, 0, "Not a buffer");
+			Error_Report(error, 0, "Not a buffer or a buffer slice");
 			return NULL;
 		}
 
-	BufferObject *original = (BufferObject*) buffer;
-	BufferObject *slice = (BufferObject*) Heap_Malloc(heap, &t_buffer, error);
+	BufferSliceObject *slice = (BufferSliceObject*) Heap_Malloc(heap, &t_buffer_slice, error);
 
-	if(offset < 0 || offset >= original->length)
+	if(slice == NULL)
+		return NULL;
+
+	if(buffer->type == &t_buffer)
 		{
-			Error_Report(error, 0, "offset out of range");
-			return NULL;
+			BufferObject *original = (BufferObject*) buffer;
+
+			if(offset < 0 || offset >= original->size)
+				{
+					Error_Report(error, 0, "offset out of range");
+					return NULL;
+				}
+
+			if(length < 0 || length >= original->size)
+				{
+					Error_Report(error, 0, "length out of range");
+					return NULL;
+				}
+
+			if(offset + length > original->size)
+				{
+					Error_Report(error, 0, "slice out of range");
+					return NULL;
+				}
+
+			slice->sliced = original;
+			slice->offset = offset;
+			slice->length = length;
+		}
+	else
+		{
+			assert(buffer->type == &t_buffer_slice);
+
+			BufferSliceObject *original = (BufferSliceObject*) buffer;
+
+			if(offset < 0 || offset >= original->length)
+				{
+					Error_Report(error, 0, "offset out of range");
+					return NULL;
+				}
+
+			if(length < 0 || length >= original->length)
+				{
+					Error_Report(error, 0, "length out of range");
+					return NULL;
+				}
+
+			if(offset + length > original->length)
+				{
+					Error_Report(error, 0, "slice out of range");
+					return NULL;
+				}
+
+			slice->sliced = original->sliced;
+			slice->offset = original->offset + offset;
+			slice->length = length;
 		}
 
-	if(length < 0 || length >= original->length)
-		{
-			Error_Report(error, 0, "length out of range");
-			return NULL;
-		}
-
-	if(offset + length > original->length)
-		{
-			Error_Report(error, 0, "slice out of range");
-			return NULL;
-		}
-
-	slice->offset = original->offset + offset;
-	slice->length = length;
-	slice->body = original->body;
-	slice->body->refs += 1;
 	return (Object*) slice;
 }
 
 void *Object_GetBufferAddrAndSize(Object *obj, int *size, Error *error)
 {
-	if(obj->type != &t_buffer)
+	if(obj->type != &t_buffer && obj->type != &t_buffer_slice)
 		{
-			Error_Report(error, 0, "Not a buffer");
+			Error_Report(error, 0, "Not a buffer or a buffer slice");
 			return NULL;
 		}
 
-	BufferObject *buf = (BufferObject*) obj;
+	if(obj->type == &t_buffer)
+		{
+			BufferObject *buffer = (BufferObject*) obj;
+		
+			if(size)
+				*size = buffer->size;
 
-	if(size)
-		*size = buf->length;
-	return buf->body->data + buf->offset;
+			return buffer->body;
+		}
+	else
+		{
+			assert(obj->type == &t_buffer_slice);
+
+			BufferSliceObject *slice = (BufferSliceObject*) obj;
+
+			if(size)
+				*size = slice->length;
+
+			return slice->sliced->body + slice->offset;
+		}
 }
 
-static Object *select(Object *self, Object *key, Heap *heap, Error *error)
+static Object *buffer_select(Object *self, Object *key, Heap *heap, Error *error)
 {
 	assert(self != NULL);
 	assert(self->type == &t_buffer);
@@ -127,18 +223,48 @@ static Object *select(Object *self, Object *key, Heap *heap, Error *error)
 
 	BufferObject *buffer = (BufferObject*) self;
 
-	if(idx < 0 || idx >= buffer->length)
+	if(idx < 0 || idx >= buffer->size)
 		{
 			Error_Report(error, 0, "Out of range index");
 			return NULL;
 		}
 
-	unsigned char byte = buffer->body->data[buffer->offset + idx];
+	unsigned char byte = buffer->body[idx];
 
 	return Object_FromInt(byte, heap, error);
 }
 
-static _Bool insert(Object *self, Object *key, Object *val, Heap *heap, Error *error)
+static Object *slice_select(Object *self, Object *key, Heap *heap, Error *error)
+{
+	assert(self != NULL);
+	assert(self->type == &t_buffer_slice);
+	assert(key != NULL);
+	assert(heap != NULL);
+	assert(error != NULL);
+
+	if(!Object_IsInt(key))
+		{
+			Error_Report(error, 0, "Non integer key");
+			return NULL;
+		}
+
+	int idx = Object_ToInt(key, error);
+	assert(error->occurred == 0);
+
+	BufferSliceObject *slice = (BufferSliceObject*) self;
+
+	if(idx < 0 || idx >= slice->length)
+		{
+			Error_Report(error, 0, "Out of range index");
+			return NULL;
+		}
+
+	unsigned char byte = slice->sliced->body[slice->offset + idx];
+
+	return Object_FromInt(byte, heap, error);
+}
+
+static _Bool buffer_insert(Object *self, Object *key, Object *val, Heap *heap, Error *error)
 {
 	assert(error != NULL);
 	assert(key != NULL);
@@ -158,39 +284,95 @@ static _Bool insert(Object *self, Object *key, Object *val, Heap *heap, Error *e
 	int idx = Object_ToInt(key, error);
 	assert(error->occurred == 0);
 
-	if(idx < 0 || idx >= buffer->length)
+	if(idx < 0 || idx >= buffer->size)
 		{
 			Error_Report(error, 0, "Out of range index");
 			return NULL;
 		}
 
-	unsigned char byte = Object_ToInt(val, error);
+	long long int qword = Object_ToInt(val, error);
+
+	if(qword > 255 || qword < 0)
+		{
+			Error_Report(error, 0, "Not in range [0, 255]");
+			return NULL;
+		}
+
+	unsigned char byte = qword & 0xff;
 
 	if(error->occurred == 1)
 		return 0;
 
-	buffer->body->data[buffer->offset + idx] = byte;
+	buffer->body[idx] = byte;
 	return 1;
 }
 
-static int count(Object *self)
+static _Bool slice_insert(Object *self, Object *key, Object *val, Heap *heap, Error *error)
 {
-	BufferObject *buffer = (BufferObject*) self;
+	assert(error != NULL);
+	assert(key != NULL);
+	assert(val != NULL);
+	assert(heap != NULL);
+	assert(self != NULL);
+	assert(self->type == &t_buffer_slice);
 
-	return buffer->length;
+	BufferSliceObject *slice = (BufferSliceObject*) self;
+
+	if(!Object_IsInt(key))
+		{
+			Error_Report(error, 0, "Non integer key");
+			return NULL;
+		}
+
+	int idx = Object_ToInt(key, error);
+	assert(error->occurred == 0);
+
+	if(idx < 0 || idx >= slice->length)
+		{
+			Error_Report(error, 0, "Out of range index");
+			return NULL;
+		}
+
+	long long int qword = Object_ToInt(val, error);
+
+	if(qword > 255 || qword < 0)
+		{
+			Error_Report(error, 0, "Not in range [0, 255]");
+			return NULL;
+		}
+
+	unsigned char byte = qword & 0xff;
+
+	if(error->occurred == 1)
+		return 0;
+
+	slice->sliced->body[slice->offset + idx] = byte;
+	return 1;
 }
 
-static void print(Object *self, FILE *fp)
+static int buffer_count(Object *self)
 {
 	BufferObject *buffer = (BufferObject*) self;
 
+	return buffer->size;
+}
+
+static int slice_count(Object *self)
+{
+	BufferSliceObject *slice = (BufferSliceObject*) self;
+
+	return slice->length;
+}
+
+static void print_bytes(FILE *fp, unsigned char *addr, int size)
+{
 	fprintf(fp, "[");
 
-	for(int i = 0; i < buffer->length; i += 1)
+	for(int i = 0; i < size; i += 1)
 		{
 			unsigned char byte, low, high;
 
-			byte = buffer->body->data[buffer->offset + i];
+			byte = addr[i];
 			low  = byte & 0xf;
 			high = byte >> 4;
 
@@ -204,8 +386,20 @@ static void print(Object *self, FILE *fp)
 
 			fprintf(fp, "%c%c", c1, c2);
 
-			if(i+1 < buffer->length)
+			if(i+1 < size)
 				fprintf(fp, ", ");
 		}
 	fprintf(fp, "]");
+}
+
+static void buffer_print(Object *self, FILE *fp)
+{
+	BufferObject *buffer = (BufferObject*) self;
+	print_bytes(fp, buffer->body, buffer->size);
+}
+
+static void slice_print(Object *self, FILE *fp)
+{
+	BufferSliceObject *slice = (BufferSliceObject*) self;
+	print_bytes(fp, slice->sliced->body + slice->offset, slice->length);
 }

src/objects/objects.c

@@ -364,12 +364,14 @@ _Bool Object_Compare(Object *obj1, Object *obj2, Error *error)
 
 void Object_WalkReferences(Object *parent, void (*callback)(Object **referer, void *userp), void *userp)
 {
+	assert(parent != NULL);
 	if(parent->type->walk != NULL)
 		parent->type->walk(parent, callback, userp);
 }
 
 void Object_WalkExtensions(Object *parent, void (*callback)(void **referer, unsigned int size, void *userp), void *userp)
 {
+	assert(parent != NULL);
 	if(parent->type->walkexts != NULL)
 		parent->type->walkexts(parent, callback, userp);
 }

src/objects/objects.h

@@ -81,6 +81,9 @@ _Bool 	 	 Heap_StartCollection(Heap *heap, Error *error);
 _Bool 	  	 Heap_StopCollection(Heap *heap);
 void  	 	 Heap_CollectReference(Object **referer, void *heap);
 float 		 Heap_GetUsagePercentage(Heap *heap);
+unsigned int Heap_GetObjectCount(Heap *heap);
+void        *Heap_GetPointer(Heap *heap);
+unsigned int Heap_GetSize(Heap *heap);
 
 const TypeObject* Object_GetType(const Object *obj);
 const char*	 Object_GetName(const Object *obj);