Function region_realloc

TheForceEngine/TFE_Memory/memoryRegion.cpp:286–378

	}

	void* region_realloc(MemoryRegion* region, void* ptr, u64 size)
	{
		assert(region);
		if (!ptr) { return region_alloc(region, size); }
		if (size == 0) { return nullptr; }

		size = alloc_align(size + sizeof(RegionAllocHeader));
		if (size > region->blockSize) { return nullptr; }

		// If the current block is already large enough, skip looping over the memory blocks.
		RegionAllocHeader* header = (RegionAllocHeader*)((u8*)ptr - sizeof(RegionAllocHeader));
		if (header->size >= size)
		{
			return ptr;
		}

		// First try to reallocate in the same region.
		u32 prevSize = 0;
		for (s32 i = (s32)region->blockCount - 1; i >= 0; i--)
		{
			MemoryBlock* block = region->memBlocks[i];
			if (ptr >= block)
			{
				RegionAllocHeader* header = (RegionAllocHeader*)((u8*)ptr - sizeof(RegionAllocHeader));
				RegionAllocHeader* nextHeader = (RegionAllocHeader*)((u8*)header + header->size);
				assert(header->free == 0);

				if ((u8*)nextHeader >= (u8*)block + region->blockSize)
				{
					nextHeader = nullptr;
				}
				// If it is big enough, just stick to the same memory.
				if (header->size >= size)
				{
					return ptr;
				}
				// If the next block is free, merge the two blocks and then allocate from that.
				if (nextHeader && nextHeader->free && header->size + nextHeader->size >= size)
				{
					VERIFY_MEMORY();
					// Remove the nextHeader from the freelist.
					assert(nextHeader->free == 1);
					removeHeaderFromFreelist(block, nextHeader);

					// Merge blocks.
					block->sizeFree += header->size;
					header->size += nextHeader->size;
					block->count--;
									
					// Allocate from the new header.
					if (header->size - size >= MIN_SPLIT_SIZE)
					{
						// Split.
						u64 split0 = size;
						u64 split1 = header->size - split0;
						RegionAllocHeader* next = (RegionAllocHeader*)((u8*)header + split0);

						// Reset the header.