From edcf43202de3cda14fa2992ea4d239be719a216f Mon Sep 17 00:00:00 2001
From: masterexplorer <master@explorer.hu>
Date: Tue, 27 Aug 2024 17:37:31 +0200
Subject: [PATCH] malloclike and freelike in C and C++ both working

---
 TurboList.hpp | 16 +++++++++-------
 main.cpp      |  1 +
 turbolist.h   | 24 ++++++++++++++++--------
 3 files changed, 26 insertions(+), 15 deletions(-)

diff --git a/TurboList.hpp b/TurboList.hpp
index 37430bb..323c547 100644
--- a/TurboList.hpp
+++ b/TurboList.hpp
@@ -1,6 +1,5 @@
 #ifndef TURBO_LIST_HPP
 #define TURBO_LIST_HPP
-// TODO: malloclike and freelike refactor
 
 #include<cstdint>
 #include<cstdlib>
@@ -17,7 +16,10 @@
 #define TL_UNLIKELY(x) __builtin_expect(!!(x), 0)
 #endif /* TL_UNLIKELY */
 
-template<typename T>
+typedef void*(MallocLike)(size_t);
+typedef void(FreeLike)(void*);
+
+template<typename T, MallocLike MALLOC = malloc, FreeLike FREE = free>
 class TurboList {
 	T *old;
 	T *nex;
@@ -29,11 +31,11 @@ class TurboList {
 
 	TL_NOINLINE void grow_and_insert(T elem) noexcept {
 			// assert(mid == 0);
-			if(old) free(old);
+			if(old) FREE(old);
 			old = nex;
 			mid = end;
 			capacity *= 2;
-			nex = (int *) malloc(this->capacity * sizeof(T));
+			nex = (int *) MALLOC(this->capacity * sizeof(T));
 
 			// Will go into the INSERT code path here
 			insert(elem);
@@ -46,12 +48,12 @@ public:
 			end(initial_size),
 			capacity(initial_cap) {
 
-		nex = (int *) malloc(this->capacity * sizeof(T));
+		nex = (int *) MALLOC(this->capacity * sizeof(T));
 	}
 
 	inline ~TurboList() noexcept {
-		if(nex) free(nex);
-		if(old) free(old);
+		if(nex) FREE(nex);
+		if(old) FREE(old);
 	}
 
 	inline T& operator[](uint32_t i) noexcept {
diff --git a/main.cpp b/main.cpp
index 291c26a..9aa1c5a 100644
--- a/main.cpp
+++ b/main.cpp
@@ -6,6 +6,7 @@
 #include<vector>
 #include"TurboList.hpp"
 #include"turbolist.h"
+#include<stdlib.h>
 
 // #define PRINT_DBG
 // #define N 65535
diff --git a/turbolist.h b/turbolist.h
index 88abc08..d4e7732 100644
--- a/turbolist.h
+++ b/turbolist.h
@@ -1,9 +1,7 @@
 #ifndef TURBO_LIST_H
 #define TURBO_LIST_H
-// TODO: malloclike and freelike refactor
 
 #include<stdint.h>
-#include<stdlib.h>
 #include<assert.h>
 
 #ifndef TL_NOINLINE
@@ -25,6 +23,8 @@ struct turbolist{
 	uint32_t end; // non-inclusive     e . . . .
 
 	uint32_t capacity;
+	void* (*malloc)(size_t size);
+	void (*free)(void*);
 };
 typedef struct turbolist turbolist;
 
@@ -32,17 +32,17 @@ static inline void turbolist_insert(turbolist *tl, int elem);
 
 static TL_NOINLINE void __turbolist_grow_and_insert(turbolist *tl, int elem) {
 		// assert(mid == 0);
-		if(tl->old) free(tl->old);
+		if(tl->old) tl->free(tl->old);
 		tl->old = tl->nex;
 		tl->mid = tl->end;
 		tl->capacity *= 2;
-		tl->nex = (int *) malloc(tl->capacity * sizeof(int));
+		tl->nex = (int *) tl->malloc(tl->capacity * sizeof(int));
 
 		// Will go into the INSERT code path here
 		turbolist_insert(tl, elem);
 }
 
-static inline turbolist turbolist_create(uint32_t initial_size = 0, uint32_t initial_cap = 16) {
+static inline turbolist turbolist_create_adv(void* (*malloc_like)(size_t size), void (*free_like)(void*), uint32_t initial_size = 0, uint32_t initial_cap = 16) {
 	assert(initial_size <= initial_cap);
 
 	turbolist tl;
@@ -50,13 +50,21 @@ static inline turbolist turbolist_create(uint32_t initial_size = 0, uint32_t ini
 	tl.mid = 0;
 	tl.end = initial_size;
 	tl.capacity = initial_cap;
-	tl.nex = (int *) malloc(tl.capacity * sizeof(int));
+	tl.malloc = malloc_like;
+	tl.free = free_like;
+	tl.nex = (int *) tl.malloc(tl.capacity * sizeof(int));
 	return tl;
 }
 
+#ifndef NO_CSTDLIB
+static inline turbolist turbolist_create(uint32_t initial_size = 0, uint32_t initial_cap = 16) {
+	return turbolist_create_adv(malloc, free, initial_size, initial_cap);
+}
+#endif /* NO_CSTDLIB */
+
 static inline void turbolist_delete(turbolist *tl) {
-	if(tl->nex) free(tl->nex);
-	if(tl->old) free(tl->old);
+	if(tl->nex) tl->free(tl->nex);
+	if(tl->old) tl->free(tl->old);
 }
 
 static inline int turbolist_get(turbolist *tl, uint32_t i) {