rename to cute headers

cute_alloc.h

@@ -0,0 +1,321 @@
+/*
+	cute_alloc.h - v1.01
+
+	To create implementation (the function definitions)
+		#define CUTE_ALLOC_IMPLEMENTATION
+	in *one* C/CPP file (translation unit) that includes this file
+
+	SUMMARY:
+	This header contains a collection of allocators. None of the allocators are
+	very fancy, and all have particular limitations making them useful only in
+	specific scenarios. None of the allocators do any special alignment support.
+
+	There are a few kinds:
+
+		1. ca_stack_t          - stack based allocator
+		2. ca_frame_t          - frame based scratch allocator
+		3. CUTE_ALLOC_ALLOC/CUTE_ALLOC_FREE - malloc/free leak checker
+
+	And here are their descriptions:
+
+		1. Given an initial chunk of memory, implements a stack based allocator inside
+		the chunk. Each allocation is laid contiguously after the last. Deallocation must
+		occur in *reverse* order to allocation. Mostly useful for graph traversals.
+
+		2. Given an initial chunk of memory, acts like the stack allocator, but only
+		implements a single deallocation function. Upon deallocation, the entire stack is
+		cleared, typically by moving a single pointer. Mostly useful for loading level
+		assets, or for quick "temporary scratch-space" in the middle of an algorithm.
+
+		3. Thin wrapper around malloc/free for recording and reporting memory leaks. Call
+		CUTE_ALLOC_CHECK_FOR_LEAKS to find and printf any un-free'd memory. Define CUTE_ALLOC_LEAK_CHECK
+		to 0 in order to turn of leak checking and use raw malloc/free.
+
+	Revision history:
+		1.0  (11/01/2017) initial release
+		1.01 (11/11/2017) added leak checker for malloc/free
+*/
+
+#if !defined(CUTE_ALLOC_H)
+
+typedef struct ca_stack_t ca_stack_t;
+ca_stack_t* ca_stack_create(void* memory_chunk, size_t size);
+void* ca_stack_alloc(ca_stack_t* stack, size_t size);
+int ca_stack_free(ca_stack_t* stack, void* memory);
+size_t ca_stack_bytes_left(ca_stack_t* stack);
+
+typedef struct ca_frame_t ca_frame_t;
+ca_frame_t* ca_frame_create(void* memory_chunk, size_t size);
+void* ca_frame_alloc(ca_frame_t* frame, size_t size);
+void ca_frame_free(ca_frame_t* frame);
+
+// define these to your own user definition as necessary
+#if !defined(CUTE_ALLOC_ALLOC)
+	#define CUTE_ALLOC_ALLOC(size, ctx) ca_leak_check_alloc((size), (char*)__FILE__, __LINE__)
+#endif
+
+#if !defined(CUTE_ALLOC_FREE)
+	#define CUTE_ALLOC_FREE(mem, ctx) ca_leak_check_free(mem)
+#endif
+
+#if !defined(CUTE_ALLOC_CALLOC)
+	#define CUTE_ALLOC_CALLOC(count, element_size, ctx) ca_leak_check_calloc(count, element_size, (char*)__FILE__, __LINE__)
+#endif
+
+// 1 - use the leak checker
+// 0 - use plain malloc/free
+#define CUTE_ALLOC_LEAK_CHECK 1
+void* ca_leak_check_alloc(size_t size, char* file, int line);
+void* ca_leak_check_calloc(size_t count, size_t element_size, char* file, int line);
+void ca_leak_check_free(void* mem);
+int CUTE_ALLOC_CHECK_FOR_LEAKS();
+int CUTE_ALLOC_BYTES_IN_USE();
+
+// define these to your own user definition as necessary
+#if !defined(CUTE_ALLOC_MALLOC_FUNC)
+	#define CUTE_ALLOC_MALLOC_FUNC malloc
+#endif
+
+#if !defined(CUTE_ALLOC_FREE_FUNC)
+	#define CUTE_ALLOC_FREE_FUNC free
+#endif
+
+#if !defined(CUTE_ALLOC_CALLOC_FUNC)
+	#define CUTE_ALLOC_CALLOC_FUNC calloc
+#endif
+
+#define CUTE_ALLOC_H
+#endif
+
+#ifdef CUTE_ALLOC_IMPLEMENTATION
+#ifndef CUTE_ALLOC_IMPLEMENTATION_ONCE
+#define CUTE_ALLOC_IMPLEMENTATION_ONCE
+
+struct ca_stack_t
+{
+	void* memory;
+	size_t capacity;
+	size_t bytes_left;
+};
+
+#define CUTE_ALLOC_PTR_ADD(ptr, size) ((void*)(((char*)ptr) + (size)))
+#define CUTE_ALLOC_PTR_SUB(ptr, size) ((void*)(((char*)ptr) - (size)))
+
+ca_stack_t* ca_stack_create(void* memory_chunk, size_t size)
+{
+	ca_stack_t* stack = (ca_stack_t*)memory_chunk;
+	if (size < sizeof(ca_stack_t)) return 0;
+	*(size_t*)CUTE_ALLOC_PTR_ADD(memory_chunk, sizeof(ca_stack_t)) = 0;
+	stack->memory = CUTE_ALLOC_PTR_ADD(memory_chunk, sizeof(ca_stack_t) + sizeof(size_t));
+	stack->capacity = size - sizeof(ca_stack_t) - sizeof(size_t);
+	stack->bytes_left = stack->capacity;
+	return stack;
+}
+
+void* ca_stack_alloc(ca_stack_t* stack, size_t size)
+{
+	if (stack->bytes_left - sizeof(size_t) < size) return 0;
+	void* user_mem = stack->memory;
+	*(size_t*)CUTE_ALLOC_PTR_ADD(user_mem, size) = size;
+	stack->memory = CUTE_ALLOC_PTR_ADD(user_mem, size + sizeof(size_t));
+	stack->bytes_left -= sizeof(size_t) + size;
+	return user_mem;
+}
+
+int ca_stack_free(ca_stack_t* stack, void* memory)
+{
+	if (!memory) return 0;
+	size_t size = *(size_t*)CUTE_ALLOC_PTR_SUB(stack->memory, sizeof(size_t));
+	void* prev = CUTE_ALLOC_PTR_SUB(stack->memory, size + sizeof(size_t));
+	if (prev != memory) return 0;
+	stack->memory = prev;
+	stack->bytes_left += sizeof(size_t) + size;
+	return 1;
+}
+
+size_t ca_stack_bytes_left(ca_stack_t* stack)
+{
+	return stack->bytes_left;
+}
+
+struct ca_frame_t
+{
+	void* original;
+	void* ptr;
+	size_t capacity;
+	size_t bytes_left;
+};
+
+ca_frame_t* ca_frame_create(void* memory_chunk, size_t size)
+{
+	ca_frame_t* frame = (ca_frame_t*)memory_chunk;
+	frame->original = CUTE_ALLOC_PTR_ADD(memory_chunk, sizeof(ca_frame_t));
+	frame->ptr = frame->original;
+	frame->capacity = frame->bytes_left = size - sizeof(ca_frame_t);
+	return frame;
+}
+
+void* ca_frame_alloc(ca_frame_t* frame, size_t size)
+{
+	if (frame->bytes_left < size) return 0;
+	void* user_mem = frame->ptr;
+	frame->ptr = CUTE_ALLOC_PTR_ADD(frame->ptr, size);
+	frame->bytes_left -= size;
+	return user_mem;
+}
+
+void ca_frame_free(ca_frame_t* frame)
+{
+	frame->ptr = frame->original;
+	frame->bytes_left = frame->capacity;
+}
+
+#include <stdlib.h> // malloc, free
+
+#if CUTE_ALLOC_LEAK_CHECK
+#include <stdio.h>
+
+typedef struct ca_alloc_info_t ca_alloc_info_t;
+struct ca_alloc_info_t
+{
+	char* file;
+	size_t size;
+	int line;
+
+	struct ca_alloc_info_t* next;
+	struct ca_alloc_info_t* prev;
+};
+
+static ca_alloc_info_t* ca_alloc_head()
+{
+	static ca_alloc_info_t info;
+	static int init;
+
+	if (!init)
+	{
+		info.next = &info;
+		info.prev = &info;
+		init = 1;
+	}
+
+	return &info;
+}
+
+void* ca_leak_check_alloc(size_t size, char* file, int line)
+{
+	ca_alloc_info_t* mem = (ca_alloc_info_t*)CUTE_ALLOC_MALLOC_FUNC(sizeof(ca_alloc_info_t) + size);
+
+	if (!mem) return 0;
+
+	mem->file = file;
+	mem->line = line;
+	mem->size = size;
+	ca_alloc_info_t* head = ca_alloc_head();
+	mem->prev = head;
+	mem->next = head->next;
+	head->next->prev = mem;
+	head->next = mem;
+
+	return mem + 1;
+}
+
+#if !defined(CUTE_ALLOC_MEMSET)
+	#include <string.h> // memset
+	#define CUTE_ALLOC_MEMSET memset
+#endif
+
+void* ca_leak_check_calloc(size_t count, size_t element_size, char* file, int line)
+{
+	size_t size = count * element_size;
+	void* mem = ca_leak_check_alloc(size, file, line);
+	CUTE_ALLOC_MEMSET(mem, 0, size);
+	return mem;
+}
+
+void ca_leak_check_free(void* mem)
+{
+	if (!mem) return;
+
+	ca_alloc_info_t* info = (ca_alloc_info_t*)mem - 1;
+	info->prev->next = info->next;
+	info->next->prev = info->prev;
+
+	CUTE_ALLOC_FREE_FUNC(info);
+}
+
+int CUTE_ALLOC_CHECK_FOR_LEAKS()
+{
+	ca_alloc_info_t* head = ca_alloc_head();
+	ca_alloc_info_t* next = head->next;
+	int leaks = 0;
+
+	while (next != head)
+	{
+		printf("LEAKED %llu bytes from file \"%s\" at line %d from address %p.\n", next->size, next->file, next->line, next + 1);
+		next = next->next;
+		leaks = 1;
+	}
+
+	if (leaks) printf("WARNING: Memory leaks detected (see above).\n");
+	else printf("SUCCESS: No memory leaks detected.\n");
+	return leaks;
+}
+
+int CUTE_ALLOC_BYTES_IN_USE()
+{
+	ca_alloc_info_t* head = ca_alloc_head();
+	ca_alloc_info_t* next = head->next;
+	int bytes = 0;
+
+	while (next != head)
+	{
+		bytes += (int)next->size;
+		next = next->next;
+	}
+
+	return bytes;
+}
+#else
+#if !defined(CUTE_ALLOC_UNUSED)
+	#if defined(_MSC_VER)
+		#define CUTE_ALLOC_UNUSED(x) (void)x
+	#else
+		#define CUTE_ALLOC_UNUSED(x) (void)(sizeof(x))
+	#endif
+#endif
+
+inline void* ca_leak_check_alloc(size_t size, char* file, int line)
+{
+	CUTE_ALLOC_UNUSED(file);
+	CUTE_ALLOC_UNUSED(line);
+	return CUTE_ALLOC_MALLOC_FUNC(size);
+}
+
+void* ca_leak_check_calloc(size_t count, size_t element_size, char* file, int line)
+{
+	CUTE_ALLOC_UNUSED(file);
+	CUTE_ALLOC_UNUSED(line);
+	return CUTE_ALLOC_CALLOC_FUNC(count, size);
+}
+
+inline void ca_leak_check_free(void* mem)
+{
+	return CUTE_ALLOC_FREE_FUNC(mem);
+}
+
+inline int CUTE_ALLOC_CHECK_FOR_LEAKS() { return 0; }
+inline int CUTE_ALLOC_BYTES_IN_USE() { return 0; }
+#endif // CUTE_ALLOC_LEAK_CHECK
+
+#endif // CUTE_ALLOC_IMPLEMENTATION_ONCE
+#endif // CUTE_ALLOC_IMPLEMENTATION
+
+/*
+	This is free and unencumbered software released into the public domain.
+	Our intent is that anyone is free to copy and use this software,
+	for any purpose, in any form, and by any means.
+	The authors dedicate any and all copyright interest in the software
+	to the public domain, at their own expense for the betterment of mankind.
+	The software is provided "as is", without any kind of warranty, including
+	any implied warranty. If it breaks, you get to keep both pieces.
+*/