erlang.spawn/fallout2-ce: Classic Fallout for modern operating systems

src/memory_manager.cc
150 строк4 KB
Mike Klaas
Add original symbol beside all function and symbol offsets (#332)
12 май 2026, 05:49
12 май 2026, 05:497ae0452
#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 outputFunc_
static MemoryManagerPrintErrorProc* gMemoryManagerPrintErrorProc = memoryManagerDefaultPrintErrorImpl;

// 0x51958C mallocPtr
static MallocProc* gMemoryManagerMallocProc = memoryManagerDefaultMallocImpl;

// 0x519590 reallocPtr
static ReallocProc* gMemoryManagerReallocProc = memoryManagerDefaultReallocImpl;

// 0x519594 freePtr
static FreeProc* gMemoryManagerFreeProc = memoryManagerDefaultFreeImpl;

// 0x4845B0 defaultOutput
static void memoryManagerDefaultPrintErrorImpl(const char* string)
{
    printf("%s", string);
}

// 0x4845C8 debug_printf_0
static int memoryManagerPrintError(const char* format, ...)
{
    // 0x631F7C
    static char err[256];

    int length = 0;

    if (gMemoryManagerPrintErrorProc != nullptr) {
        va_list args;
        va_start(args, format);
        length = vsnprintf(err, sizeof(err), format, args);
        va_end(args);

        gMemoryManagerPrintErrorProc(err);
    }

    return length;
}

// 0x484610 error
[[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 defaultMalloc
static void* memoryManagerDefaultMallocImpl(size_t size)
{
    return malloc(size);
}

// 0x484634 defaultRealloc
static void* memoryManagerDefaultReallocImpl(void* ptr, size_t size)
{
    return realloc(ptr, size);
}

// 0x48463C defaultFree
static void memoryManagerDefaultFreeImpl(void* ptr)
{
    free(ptr);
}

// 0x484644 memoryRegisterAlloc
void memoryManagerSetProcs(MallocProc* mallocProc, ReallocProc* reallocProc, FreeProc* freeProc)
{
    gMemoryManagerMallocProc = mallocProc;
    gMemoryManagerReallocProc = reallocProc;
    gMemoryManagerFreeProc = freeProc;
}

// 0x484660 mymalloc
void* internal_malloc_safe(size_t size, const char* file, int line)
{
    void* ptr = gMemoryManagerMallocProc(size);
    if (ptr == nullptr) {
        memoryManagerFatalAllocationError("malloc", size, file, line);
    }

    return ptr;
}

// 0x4846B4 myrealloc
void* internal_realloc_safe(void* ptr, size_t size, const char* file, int line)
{
    ptr = gMemoryManagerReallocProc(ptr, size);
    if (ptr == nullptr) {
        memoryManagerFatalAllocationError("realloc", size, file, line);
    }

    return ptr;
}

// 0x484688 myfree
void internal_free_safe(void* ptr, const char* file, int line)
{
    if (ptr == nullptr) {
        memoryManagerPrintError("free: free of a null ptr, %s %d\n", file, line);
        exit(1);
    }

    gMemoryManagerFreeProc(ptr);
}

// 0x4846D8 mycalloc
void* internal_calloc_safe(int count, int size, const char* file, int line)
{
    void* ptr = gMemoryManagerMallocProc(count * size);
    if (ptr == nullptr) {
        memoryManagerFatalAllocationError("calloc", size, file, line);
    }

    memset(ptr, 0, count * size);

    return ptr;
}

// 0x484710 mystrdup
char* strdup_safe(const char* string, const char* file, int line)
{
    size_t size = strlen(string) + 1;
    char* copy = (char*)gMemoryManagerMallocProc(size);
    if (copy == nullptr) {
        memoryManagerFatalAllocationError("strdup", size, file, line);
    }

    strcpy(copy, string);

    return copy;
}

} // namespace fallout