Merge pull request #32 from robojumper/eggExpHeap

eggExpHeap matching

src/egg/core/eggExpHeap.cpp

@@ -0,0 +1,135 @@
+#include <egg/core/eggExpHeap.h>
+
+namespace EGG {
+
+/* 80495ab0 */ ExpHeap::ExpHeap(MEMiHeapHead *heapHandle) : Heap(heapHandle) {}
+
+/* 80495af0 */ ExpHeap::~ExpHeap() {
+    dispose();
+    MEMDestroyExpHeap(mHeapHandle);
+}
+
+/* 80495b70 */ ExpHeap *ExpHeap::create(void *heapStart, size_t size, u16 attr) {
+    ExpHeap *heap = nullptr;
+    void *startAddr = heapStart;
+    void *heapEnd = ROUND_DOWN_PTR((u8 *)heapStart + size, 0x04);
+    heapStart = ROUND_UP_PTR(heapStart, 0x04);
+
+    if (heapStart > heapEnd || ((u8 *)heapEnd - (u8 *)heapStart) < 0x38u) {
+        return nullptr;
+    }
+
+    MEMiHeapHead *head = MEMCreateExpHeapEx(((ExpHeap *)heapStart) + 1, ((u8 *)heapEnd - (u8 *)heapStart) - 0x34, attr);
+    if (head != nullptr) {
+        heap = new (heapStart) ExpHeap(head);
+        heap->mParentBlock = startAddr;
+        if (sCreateCallback != nullptr) {
+            (sCreateCallback)(heap);
+        }
+    }
+
+    return heap;
+}
+
+/* 80495c30 */ ExpHeap *ExpHeap::create(size_t size, Heap *heap, u16 attr) {
+    ExpHeap *newHeap = nullptr;
+    if (heap == nullptr) {
+        heap = sCurrentHeap;
+    }
+
+    if (size == -1) {
+        size = heap->getAllocatableSize(0x04);
+    }
+
+    void *block = heap->alloc(size, 0x04);
+    if (block != nullptr) {
+        newHeap = ExpHeap::create(block, size, attr);
+        if (newHeap == nullptr) {
+            heap->free(block);
+        }
+    }
+
+    return newHeap;
+}
+
+/* 80495d00 */ void ExpHeap::destroy() {
+    if (sDestroyCallback != nullptr) {
+        sDestroyCallback(this);
+    }
+
+    Heap *parentHeap = findParentHeap();
+    this->~ExpHeap();
+    if (parentHeap != nullptr) {
+        parentHeap->free(this);
+    }
+}
+
+/* 80495d90 */ void *ExpHeap::alloc(u32 size, s32 align) {
+    if (mFlag.onBit(0)) {
+#line 182
+        OSError("DAME DAME\n");
+    }
+
+    void *ptr = MEMAllocFromExpHeapEx(mHeapHandle, size, align);
+    if (sAllocCallback != nullptr) {
+        HeapAllocArg arg;
+        arg.userArg = sAllocCallbackArg;
+        arg.ptr = ptr;
+        arg.size = size;
+        arg.align = align;
+        arg.heap = this;
+        (sAllocCallback)(&arg);
+    }
+
+    return ptr;
+}
+
+/* 80495e50 */ void ExpHeap::free(void *ptr) {
+    if (sFreeCallback != nullptr) {
+        HeapFreeArg arg;
+        arg.userArg = sFreeCallbackArg;
+        arg.ptr = ptr;
+        arg.heap = this;
+        (sFreeCallback)(&arg);
+    }
+    MEMFreeToExpHeap(mHeapHandle, ptr);
+}
+
+/* 80495ec0 */ u32 ExpHeap::resizeForMBlock(void *block, u32 size) {
+    return MEMResizeForMBlockExpHeap(mHeapHandle, block, size);
+}
+
+/* 80495ed0 */ u32 ExpHeap::getTotalFreeSize() {
+    return MEMGetAllocatableSizeForExpHeap(mHeapHandle);
+}
+
+/* 80495ee0 */ u32 ExpHeap::getAllocatableSize(s32 align) {
+    return MEMGetAllocatableSizeForExpHeapEx(mHeapHandle, align);
+}
+
+/* 80495d00 */ void ExpHeap::setGroupID(u16 groupId) {
+    MEMSetGroupIdForExpHeap(mHeapHandle, groupId);
+}
+
+/* 80495f00 */ u32 ExpHeap::adjust() {
+    u32 adjustedSize = MEMAdjustExpHeap(mHeapHandle);
+    u32 totalSize = adjustedSize + 0x34;
+    if (totalSize > 0x34) {
+        Heap *parent = findParentHeap();
+        if (parent != nullptr) {
+            parent->resizeForMBlock(mParentBlock, totalSize);
+            return totalSize;
+        }
+    }
+    return 0;
+}
+
+/* 80495f80 */ u32 ExpHeap::getSizeForMBlock(const void *block) {
+    return MEMGetSizeForMBlockExpHeap(block);
+}
+
+/* 80495f90 */ Heap::eHeapKind ExpHeap::getHeapKind() const {
+    return HEAP_KIND_EXPANDED;
+}
+
+} // namespace EGG