add: test to galloc and advance on galloc

src/galloc.🗿

@@ -1,24 +1,49 @@
-define header_size = 3;
+define PADDING_SIZE = 4;
-define protection_size = 4;
+define HEADER_SIZE = PADDING_SIZE * 2 + 5;
-define heap_size = 65536
 
-global heap[header_size] = 0;
+define HEAP_SIZE = 65536;
+global heap[HEADER_SIZE] = 0;
 
 🗿HEADER REPRESENTATION
-🗿+-------------------------+-----------------------------+-----------------------------+---------+---------+---------+
+🗿+-------------+--------+--------+---------------------------+-------------------------------+---------+---------+---------+
-🗿| index of the next block | index of the previous block | used (if the block is used) | padding | data    | padding |
+🗿| initialised | used   | size   | pointer to the next block | pointer to the previous block | padding | data    | padding |
-🗿| 1 case                  | 1 case                      | 1 case                      | 4 cases | n cases | 4 cases | 
+🗿| 1 case      | 1 case | 1 case | 1 case                    | 1 case                        | 4 cases | n cases | 4 cases | 
-🗿+-------------------------+-----------------------------+-----------------------------+---------+---------+---------+
+🗿+-------------+--------+--------+---------------------------+-------------------------------+---------+---------+---------+
 
-🗿 padding is use to check invalid write
+🗿 INITIALISED
+🗿 a boolean to state if the block is initialised
 
+🗿 USED
+🗿 a boolean to state if the block is used
 
-setup_header(pos, size, preview_pos)
+🗿 SIZE
+🗿 The size of the data
+
+🗿 POINTER
+🗿 The address of block
+
+🗿 PADDING
+🗿 Is used to check invalid write
+🗿 If a case doesn't equal to 0 it is an invalid write
+
+define LOCATION_INITIALISED = 0;
+define LOCATION_USED = 1;
+define LOCATION_SIZE = 2;
+define LOCATION_NEXT = 3;
+define LOCATION_PREV = 4;
+define LOCATION_DATA = 9;
+
+setup_header(ptr, used, size, next_block, prev_block)
 {
 	local i;
 
-	[ptr] = pos;
+	if (size + PADDING_SIZE * 2 + HEADER_SIZE)
-	[ptr + 1] = 0;
+		return (1);
+	[ptr] = 1;					🗿 initialised
+	[ptr + 1] = used;			🗿 used
+	[ptr + 2] = size;			🗿 size
+	[ptr + 3] = next_block;		🗿 next block
+	[ptr + 4] = prev_block;		🗿 previous block
 
 	i = header_size;
 	loop {
@@ -28,27 +53,53 @@ setup_header(pos, size, preview_pos)
 		[ptr + i + size] = 0;
 		i++;
 	}
+	return (0);
 }
 
 find_next_space(size)
 {
 	local current;
-	local next;
 
-	current = 0;
+	current = heap;
 	loop
 	{
-		if (current > header_size)
+		if ([current + LOCATION_USED] == 0
+			& [current + LOCATION_SIZE] >= size)
+			return (current);
+		current = [current + LOCATION_NEXT];
+		if ([current] == 0)
 			return (0);
-		next_block = heap + current;
-		if ([next_block] == 0)				🗿check if the block is the last
-			| ([heap + current + 1] == 0)	🗿check if the block is not used
-			return (heap + current);
-		current = [heap + next_block];
 	}
 }
 
-salloc (size)
+divise_block(ptr, size)
 {
-	local p;
+	local old_next;
+	local next;
+
+	if (size + HEADER_SIZE >= [ptr + LOCATION_SIZE])
+		return (0);
+	old_next = [ptr + LOCATION_NEXT];
+	next = [ptr + size + HEADER_SIZE];
+	setup_header(next, 0, [ptr + LOCATION_SIZE] - HEADER_SIZE * 2, [ptr + LOCATION_SIZE] + HEADER_SIZE, old_next, ptr);
+	setup_header(ptr, 1, size, next, [ptr + LOCATION_PREV]);
+	return (0);
+}
+
+salloc(size)
+{
+	local ptr;
+
+	if ([heap] == 0)															🗿 if the heap is not initialised
+		setup_header(HEAP_SIZE - 2 * PADDING_SIZE - HEADER_SIZE, 0, 0, 0);		🗿 initialised all the heap
+	ptr = find_next_space(size);
+	if (ptr == 0)
+		return (0);
+	if ([ptr + LOCATION_SIZE] == size)
+	{
+		[ptr + LOCATION_USED] = 1;
+		return (ptr + LOCATION_DATA);
+	}
+	divise_block(ptr, size);
+	return (ptr);
 }

tests/galloc.🗿

@@ -0,0 +1,5 @@
+main()
+{
+	name = "galloc";
+	test(galloc(1), heap + LOCATION_DATA, "");
+}