Revert "Replace {Alloc,FreeAll}Temporary() with mimalloc"

This reverts commit c4ca4be.

Removing the `mimalloc` dependency will make it easier to build
Windows XP (maybe even 2000) compatible versions of SolveSpace.

Author: ruevs

src/platform/platformbase.cpp

@@ -1,8 +1,12 @@
 #include "solvespace.h"
-#include <mimalloc.h>
 
 #if defined(WIN32)
 #   include <Windows.h>
+#   include <shellapi.h>
+#else
+#   include <unistd.h>
+#   include <sys/stat.h>
+#   include <mutex>
 #endif // defined(WIN32)
 
 namespace SolveSpace {
@@ -63,34 +67,64 @@ void DebugPrint(const char *fmt, ...) {
 #endif
 
 //-----------------------------------------------------------------------------
-// Temporary arena.
+// Temporary arena, on Windows.
 //-----------------------------------------------------------------------------
 
-struct MimallocHeap {
-    mi_heap_t *heap = NULL;
-
-    ~MimallocHeap() {
-        if(heap != NULL)
-            mi_heap_destroy(heap);
-    }
-};
+#if defined(WIN32)
 
-static thread_local MimallocHeap TempArena;
+static HANDLE TempArena = NULL;
 
-void *AllocTemporary(size_t size) {
-    if(TempArena.heap == NULL) {
-        TempArena.heap = mi_heap_new();
-        ssassert(TempArena.heap != NULL, "out of memory");
-    }
-    void *ptr = mi_heap_zalloc(TempArena.heap, size);
+void *AllocTemporary(size_t size)
+{
+    if(!TempArena)
+        TempArena = HeapCreate(0, 0, 0);
+    void *ptr = HeapAlloc(TempArena, HEAP_ZERO_MEMORY, size);
     ssassert(ptr != NULL, "out of memory");
     return ptr;
 }
 
-void FreeAllTemporary() {
-    MimallocHeap temp;
-    std::swap(TempArena.heap, temp.heap);
+void FreeAllTemporary()
+{
+    HeapDestroy(TempArena);
+    TempArena = NULL;
+}
+
+#endif
+
+//-----------------------------------------------------------------------------
+// Temporary arena, on Linux.
+//-----------------------------------------------------------------------------
+
+#if !defined(WIN32)
+
+struct ArenaChunk {
+    ArenaChunk *next;
+};
+
+static std::mutex TempArenaMutex;
+static ArenaChunk *TempArena = NULL;
+
+void *AllocTemporary(size_t size)
+{
+    ArenaChunk *chunk = (ArenaChunk *)calloc(1, sizeof(ArenaChunk) + size);
+    ssassert(chunk != NULL, "out of memory");
+    std::lock_guard<std::mutex> guard(TempArenaMutex);
+    chunk->next = TempArena;
+    TempArena = chunk;
+    return (void *)(chunk + 1);
+}
+
+void FreeAllTemporary()
+{
+    std::lock_guard<std::mutex> guard(TempArenaMutex);
+    while(TempArena) {
+        ArenaChunk *chunk = TempArena;
+        TempArena = TempArena->next;
+        free(chunk);
+    }
 }
 
+#endif
+
 }
 }