define HEAP_SIZE = 0x020;
global heap[HEAP_SIZE] = 0;

define PADDING_SIZE = 4;
define HEADER_SIZE = 5;

🗿HEADER REPRESENTATION
🗿+-------------+--------+--------+---------------------------+-------------------------------+---------+---------+---------+
🗿| initialised | used   | size   | pointer to the next block | pointer to the previous block | padding | data    | padding |
🗿| 1 case      | 1 case | 1 case | 1 case                    | 1 case                        | 4 cases | n cases | 4 cases | 
🗿+-------------+--------+--------+---------------------------+-------------------------------+---------+---------+---------+

🗿 INITIALISED
🗿 a boolean to state if the block is initialised

🗿 USED
🗿 a boolean to state if the block is used

🗿 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 = HEADER_SIZE + PADDING_SIZE;

setup_header(ptr, used, size, next_block, prev_block)
{
	local i;

	if (size + PADDING_SIZE * 2 + HEADER_SIZE > HEAP_SIZE)
		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
	{
		if (i == HEADER_SIZE + PADDING_SIZE)
			break;
		[ptr + i] = 0;							🗿 INITIALISE TOP PADDING
		[ptr + i + PADDING_SIZE + size] = 0;		🗿 INITIALISE BOT PADDING
		i++;
	}
}

find_next_space(size)
{
	local current;

	current = heap;
	loop
	{
		if ([current + LOCATION_USED] == 0
			& [current + LOCATION_SIZE] >= size)
			return (current);
		current = [current + LOCATION_NEXT];
		if ([current] == 0)
			return (0);
	}
}

print_heap()
{
	local i;

	i = 0;
	loop
	{
		if (i == HEAP_SIZE)
			return (0);
		dbg [heap + i];
		i++;
	}
}

split_block(ptr, size)
{
	local old_next;
	local next;
	local prev;
	local old_size;

	old_size = [ptr + LOCATION_SIZE];
	if (size + HEADER_SIZE >= [ptr + LOCATION_SIZE]) 🗿 if the block is to small to be split
		return (0);
	old_next = [ptr + LOCATION_NEXT];
	next = ptr + size + HEADER_SIZE + PADDING_SIZE * 2;
	prev = [ptr + LOCATION_PREV];
🗿	setup_header(ptr, used, size, next_block, prev_block);
	setup_header(ptr, 1, size, ptr + HEADER_SIZE + PADDING_SIZE * 2 + size, prev);
	setup_header(next, 0, old_size - size - HEADER_SIZE - PADDING_SIZE * 2, old_next, ptr);
	dbg 0x7777;
	dbg old_size - size - HEADER_SIZE - PADDING_SIZE * 2;
	return (0);
}

galloc(size)
{
	local ptr;

	if ([heap] == 0)																	🗿 if the heap is not initialised
		setup_header(heap, 0, HEAP_SIZE - HEADER_SIZE - PADDING_SIZE * 2, 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);
	}
	split_block(ptr, size);
	return (ptr + LOCATION_DATA);
}