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

define PADDING_SIZE = 4;
define HEADER_SIZE = 5;

🗿HEADER REPRESENTATION
🗿+-------------+--------+--------+-------------------------------+---------------------------+---------+---------+---------+
🗿| initialised | used   | size   | pointer to the previous block | pointer to the next 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_PREV = 3;
define LOCATION_NEXT = 4;
define LOCATION_DATA = HEADER_SIZE + PADDING_SIZE;

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

	[ptr + LOCATION_INITIALISED] = 1;
	[ptr + LOCATION_USED] = used;
	[ptr + LOCATION_SIZE] = size;
	[ptr + LOCATION_PREV] = prev_block;
	[ptr + LOCATION_NEXT] = next_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++;
	}
}

galloc_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);
	}
}

galloc_print_heap()
{
	local i;

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

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

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

galloc(size)
{
	local ptr;

	if ([heap] == 0)																	🗿 if the heap is not initialised
		galloc_setup_header(heap, 0, HEAP_SIZE - HEADER_SIZE - PADDING_SIZE * 2, 0, 0);		🗿 initialised all the heap
	ptr = galloc_find_next_space(size);
	if (ptr == 0)
		return (0);
	if ([ptr + LOCATION_SIZE] == size)
	{
		[ptr + LOCATION_USED] = 1;
		return (ptr + LOCATION_DATA);
	}
	galloc_split_block(ptr, size);
	return (ptr + LOCATION_DATA);
}

galloc_merge_blocks(first_block, last_block)
{
	local size;

	if (last_block == first_block)
	{
		galloc_setup_header(first_block, 0, [first_block + LOCATION_SIZE], [first_block + LOCATION_NEXT], [first_block + LOCATION_PREV]);
	}
	size = last_block - first_block + [last_block + LOCATION_SIZE];
	galloc_setup_header(first_block, 0, size, [last_block + LOCATION_NEXT], [first_block + LOCATION_PREV]);
}

free(ptr)
{
	local block;
	local prev_block;
	local next_block;
	local first_block;
	local last_block;

	if (ptr > heap + HEAP_SIZE | heap > ptr)
	{
		putstr("Error: free: invalid ptr\n");
		return;
	}
	block = ptr - LOCATION_DATA;
	prev_block = [block + LOCATION_PREV];
	if (prev_block == 0 | [prev_block + LOCATION_USED])
		first_block = block;
	else
		first_block = prev_block;
	next_block = [block + LOCATION_NEXT];
	if (next_block == 0 | [next_block + LOCATION_USED])
		last_block = block;
	else
		last_block = next_block;
	galloc_merge_blocks(first_block, last_block);
}

leaks()
{
	return ([heap + LOCATION_NEXT] != 0);
}