151 lines
3.6 KiB
C++
151 lines
3.6 KiB
C++
#include "memory_manager.h"
|
|
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
namespace fallout {
|
|
|
|
typedef void(MemoryManagerPrintErrorProc)(const char* string);
|
|
|
|
static void memoryManagerDefaultPrintErrorImpl(const char* string);
|
|
static int memoryManagerPrintError(const char* format, ...);
|
|
[[noreturn]] static void memoryManagerFatalAllocationError(const char* func, size_t size, const char* file, int line);
|
|
static void* memoryManagerDefaultMallocImpl(size_t size);
|
|
static void* memoryManagerDefaultReallocImpl(void* ptr, size_t size);
|
|
static void memoryManagerDefaultFreeImpl(void* ptr);
|
|
|
|
// 0x519588
|
|
static MemoryManagerPrintErrorProc* gMemoryManagerPrintErrorProc = memoryManagerDefaultPrintErrorImpl;
|
|
|
|
// 0x51958C
|
|
static MallocProc* gMemoryManagerMallocProc = memoryManagerDefaultMallocImpl;
|
|
|
|
// 0x519590
|
|
static ReallocProc* gMemoryManagerReallocProc = memoryManagerDefaultReallocImpl;
|
|
|
|
// 0x519594
|
|
static FreeProc* gMemoryManagerFreeProc = memoryManagerDefaultFreeImpl;
|
|
|
|
// 0x4845B0
|
|
static void memoryManagerDefaultPrintErrorImpl(const char* string)
|
|
{
|
|
printf("%s", string);
|
|
}
|
|
|
|
// 0x4845C8
|
|
static int memoryManagerPrintError(const char* format, ...)
|
|
{
|
|
// 0x631F7C
|
|
static char err[256];
|
|
|
|
int length = 0;
|
|
|
|
if (gMemoryManagerPrintErrorProc != NULL) {
|
|
va_list args;
|
|
va_start(args, format);
|
|
length = vsnprintf(err, sizeof(err), format, args);
|
|
va_end(args);
|
|
|
|
gMemoryManagerPrintErrorProc(err);
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
// 0x484610
|
|
[[noreturn]] static void memoryManagerFatalAllocationError(const char* func, size_t size, const char* file, int line)
|
|
{
|
|
memoryManagerPrintError("%s: Error allocating block of size %ld (%x), %s %d\n", func, size, size, file, line);
|
|
exit(1);
|
|
}
|
|
|
|
// 0x48462C
|
|
static void* memoryManagerDefaultMallocImpl(size_t size)
|
|
{
|
|
return malloc(size);
|
|
}
|
|
|
|
// 0x484634
|
|
static void* memoryManagerDefaultReallocImpl(void* ptr, size_t size)
|
|
{
|
|
return realloc(ptr, size);
|
|
}
|
|
|
|
// 0x48463C
|
|
static void memoryManagerDefaultFreeImpl(void* ptr)
|
|
{
|
|
free(ptr);
|
|
}
|
|
|
|
// 0x484644
|
|
void memoryManagerSetProcs(MallocProc* mallocProc, ReallocProc* reallocProc, FreeProc* freeProc)
|
|
{
|
|
gMemoryManagerMallocProc = mallocProc;
|
|
gMemoryManagerReallocProc = reallocProc;
|
|
gMemoryManagerFreeProc = freeProc;
|
|
}
|
|
|
|
// 0x484660
|
|
void* internal_malloc_safe(size_t size, const char* file, int line)
|
|
{
|
|
void* ptr = gMemoryManagerMallocProc(size);
|
|
if (ptr == NULL) {
|
|
memoryManagerFatalAllocationError("malloc", size, file, line);
|
|
}
|
|
|
|
return ptr;
|
|
}
|
|
|
|
// 0x4846B4
|
|
void* internal_realloc_safe(void* ptr, size_t size, const char* file, int line)
|
|
{
|
|
ptr = gMemoryManagerReallocProc(ptr, size);
|
|
if (ptr == NULL) {
|
|
memoryManagerFatalAllocationError("realloc", size, file, line);
|
|
}
|
|
|
|
return ptr;
|
|
}
|
|
|
|
// 0x484688
|
|
void internal_free_safe(void* ptr, const char* file, int line)
|
|
{
|
|
if (ptr == NULL) {
|
|
memoryManagerPrintError("free: free of a null ptr, %s %d\n", file, line);
|
|
exit(1);
|
|
}
|
|
|
|
gMemoryManagerFreeProc(ptr);
|
|
}
|
|
|
|
// 0x4846D8
|
|
void* internal_calloc_safe(int count, int size, const char* file, int line)
|
|
{
|
|
void* ptr = gMemoryManagerMallocProc(count * size);
|
|
if (ptr == NULL) {
|
|
memoryManagerFatalAllocationError("calloc", size, file, line);
|
|
}
|
|
|
|
memset(ptr, 0, count * size);
|
|
|
|
return ptr;
|
|
}
|
|
|
|
// 0x484710
|
|
char* strdup_safe(const char* string, const char* file, int line)
|
|
{
|
|
size_t size = strlen(string) + 1;
|
|
char* copy = (char*)gMemoryManagerMallocProc(size);
|
|
if (copy == NULL) {
|
|
memoryManagerFatalAllocationError("strdup", size, file, line);
|
|
}
|
|
|
|
strcpy(copy, string);
|
|
|
|
return copy;
|
|
}
|
|
|
|
} // namespace fallout
|