JSUList.h templates and JKRHeap matches (#13)

* JSULink, JSUList, JSUTree and more matching in JKRHeap

* Added JSUListIterator and decompiled JKRHeap::dispose_subroutine

* more templates and JKRHeap functions

* JKRDisposer!

* only 4 functions not OK in JKRHeap

* fixed: *this->getObject()

Co-authored-by: Pheenoh <pheenoh@gmail.com>

7 files changed, 579 insertions, 200 deletions

diff --git a/include/JSystem/JKernel/JKRDisposer/JKRDisposer.h b/include/JSystem/JKernel/JKRDisposer/JKRDisposer.h
index 7d9576912f..4edb7116ed 100644
--- a/include/JSystem/JKernel/JKRDisposer/JKRDisposer.h
+++ b/include/JSystem/JKernel/JKRDisposer/JKRDisposer.h
@@ -9,12 +9,11 @@ class JKRDisposer {
   public:
     JKRDisposer();
     virtual ~JKRDisposer();
-
     virtual void callAllDisposer() = 0;
 
   public:
-    JKRHeap* heap;
-    JSUPtrLink ptr_link;
+    JKRHeap* mHeap;
+    JSULink<JKRDisposer> mLink;
 };
 
 #endif
diff --git a/include/JSystem/JKernel/JKRHeap/JKRHeap.h b/include/JSystem/JKernel/JKRHeap/JKRHeap.h
index 509bde938b..5df883da4d 100644
--- a/include/JSystem/JKernel/JKRHeap/JKRHeap.h
+++ b/include/JSystem/JKernel/JKRHeap/JKRHeap.h
@@ -4,7 +4,7 @@
 #include "dolphin/types.h"
 #include "JSystem/JKernel/JKRDisposer/JKRDisposer.h"
 
-typedef void (*JKRErrorHandler)(void*, unsigned long, int);
+typedef void (*JKRErrorHandler)(void*, u32, int);
 class JKRHeap : JKRDisposer {
   public:
     JKRHeap(void*, u32, JKRHeap*, bool);
@@ -31,7 +31,7 @@ class JKRHeap : JKRDisposer {
     s32 getSize(void* ptr);
 
     s32 getFreeSize();
-    s32 getMaxFreeBlock();
+    void* getMaxFreeBlock();
     s32 getTotalFreeSize();
     u8 changeGroupID(u8 param_1);
     s32 getMaxAllocatableSize(int alignment);
@@ -46,13 +46,41 @@ class JKRHeap : JKRDisposer {
     void dispose();
 
     static void copyMemory(void* dst, void* src, u32 size);
-    static void JKRDefaultMemoryErrorRoutine(JKRHeap* heap, u32 size, int alignment);
+    static void fillMemory(void* dst, u32 size, u8 value); // NOTE: never used
+    static bool checkMemoryFilled(void* src, u32 size, u8 value);
+
 
     bool setErrorFlag(bool param_1);
-    static JKRErrorHandler setErrorHandler(JKRErrorHandler param_1);
+    static void JKRDefaultMemoryErrorRoutine(JKRHeap* heap, u32 size, int alignment);
+    static JKRErrorHandler setErrorHandler(JKRErrorHandler error_handler);
+
 
     bool isSubHeap(JKRHeap* heap) const;
 
+    void* getBegin() const {
+        return (void*)mBegin;
+    }
+
+    void* getEnd() const {
+        return (void*)mEnd;
+    }
+
+    u32 getSize() const {
+        return mSize;
+    }
+
+    JSUTree<JKRHeap>& getHeapTree() {
+      return this->mChildTree;
+    }
+
+    void appendDisposer(JKRDisposer* disposer) {
+        mDisposerList.append(&disposer->mLink);
+    }
+
+    void removeDisposer(JKRDisposer* disposer) {
+        mDisposerList.remove(&disposer->mLink);
+    }
+
   protected:
     void callAllDisposer();
     virtual void vt_func4() = 0;
@@ -68,7 +96,7 @@ class JKRHeap : JKRDisposer {
     virtual s32 do_resize(void* ptr, u32 size)      = 0;
     virtual s32 do_getSize(void* ptr)               = 0;
     virtual s32 do_getFreeSize()                    = 0;
-    virtual s32 do_getMaxFreeBlock()                = 0;
+    virtual void* do_getMaxFreeBlock()                = 0;
     virtual s32 do_getTotalFreeSize()               = 0;
     virtual u8 do_changeGroupID(u8 param_1);
     virtual void do_getCurrent();
@@ -78,17 +106,16 @@ class JKRHeap : JKRDisposer {
 
   public:
     u8 mutex[24];
-    u32 begin;
-    u32 end;
-    u32 size;
+    u32 mBegin;
+    u32 mEnd;
+    u32 mSize;
     u8 field_0x3c;
     u8 field_0x3d;
     u8 field_0x3e;
     u8 field_0x3f;
-    JSUPtrList child_list;
-    JSUPtrLink heap_link;
-    JSUPtrList disposable_list;
-    bool error_flag;
+    JSUTree<JKRHeap> mChildTree;
+    JSUList<JKRDisposer> mDisposerList;
+    bool mErrorFlag;
     u8 field_0x69;
     u8 field_0x6a[2];
 };
diff --git a/include/JSystem/JSupport/JSUList/JSUList.h b/include/JSystem/JSupport/JSUList/JSUList.h
index eb57f70984..550243c688 100644
--- a/include/JSystem/JSupport/JSUList/JSUList.h
+++ b/include/JSystem/JSupport/JSUList/JSUList.h
@@ -3,22 +3,69 @@
 
 #include "dolphin/types.h"
 
+//
+// Link
+//
+
 class JSUPtrList;
 class JSUPtrLink {
   public:
-    JSUPtrLink(void* owner);
+    JSUPtrLink(void* object);
     ~JSUPtrLink();
 
+    void* getObjectPtr() const {
+        return mObject;
+    }
+
+    JSUPtrList* getList() const {
+        return mList;
+    }
+
+    JSUPtrLink* getNext() const {
+        return mNext;
+    }
+
+    JSUPtrLink* getPrev() const {
+        return mPrev;
+    }
+
   public:
-    void* owner;
-    JSUPtrList* list;
-    JSUPtrLink* prev;
-    JSUPtrLink* next;
+    void* mObject;
+    JSUPtrList* mList;
+    JSUPtrLink* mPrev;
+    JSUPtrLink* mNext;
 };
 
+template <typename T>
+class JSULink : public JSUPtrLink {
+  public:
+    JSULink(T* object) : JSUPtrLink((void*)object) {
+    }
+
+    T* getObject() const {
+        return (T*)getObjectPtr();
+    }
+
+    JSULink<T>* getNext() const {
+        return (JSULink<T>*)this->JSUPtrLink::getNext();
+    }
+
+    JSULink<T>* getPrev() const {
+        return (JSULink<T>*)this->JSUPtrLink::getPrev();
+    }
+};
+
+//
+// List
+//
+
 class JSUPtrList {
   public:
-    JSUPtrList(bool should_initiate);
+    JSUPtrList() {
+        this->initiate();
+    }
+
+    JSUPtrList(bool init);
     ~JSUPtrList();
 
     void initiate();
@@ -29,30 +76,245 @@ class JSUPtrList {
     bool remove(JSUPtrLink* ptr);
     JSUPtrLink* getNthLink(u32 i) const;
 
+    JSUPtrLink* getFirstLink() const {
+        return mHead;
+    }
+
+    JSUPtrLink* getLastLink() const {
+        return mTail;
+    }
+
+    u32 getNumLinks() const {
+        return mLength;
+    }
+
+  private:
+    JSUPtrLink* mHead;
+    JSUPtrLink* mTail;
+    u32 mLength;
+};
+
+template <typename T>
+class JSUList : protected JSUPtrList {
   public:
-    JSUPtrLink* head;
-    JSUPtrLink* tail;
-    u32 length;
+    JSUList() : JSUPtrList() {
+    }
+
+    JSUList(bool init) : JSUPtrList(init) {
+    }
+
+    bool append(JSULink<T>* link) {
+        return this->JSUPtrList::append((JSUPtrLink*)link);
+    }
+
+    bool prepend(JSULink<T>* link) {
+        return this->JSUPtrList::prepend((JSUPtrLink*)link);
+    }
+
+    bool insert(JSULink<T>* before, JSULink<T>* link) {
+        return this->JSUPtrList::insert((JSUPtrLink*)before, (JSUPtrLink*)link);
+    }
+
+    bool remove(JSULink<T>* link) {
+        return this->JSUPtrList::remove((JSUPtrLink*)link);
+    }
+
+    JSULink<T>* getFirst() const {
+        return (JSULink<T>*)getFirstLink();
+    }
+
+    JSULink<T>* getLast() const {
+        return (JSULink<T>*)getLastLink();
+    }
+
+    JSULink<T>* getEnd() const {
+        return NULL;
+    }
+
+    u32 getNumLinks() const {
+        return this->JSUPtrList::getNumLinks();
+    }
 };
 
 template <typename T>
-class JSUList : JSUPtrList {
+class JSUListIterator {
   public:
-    JSUList() : JSUPtrList(true) {
+    JSUListIterator() : mLink() {
+    }
+    JSUListIterator(JSULink<T>* link) : mLink(link) {
+    }
+    JSUListIterator(JSUList<T>* list) : JSUListIterator(list->getFirst()) {
+    }
+
+    JSUListIterator<T>& operator=(JSULink<T>* link) {
+        this->mLink = link;
+        return *this;
     }
-    ~JSUList(){};
 
-    void append(T* value) {
-        list.append(&value->ptr_link);
+    T* getObject() {
+        return this->mLink->getObject();
     }
 
-    void prepend(T* value) {
-        list.prepend(&value->ptr_link);
+    bool operator==(JSULink<T> const* other) const {
+        return this->mLink == other;
     }
 
-    void remove(T* value) {
-        list.remove(&value->ptr_link);
+    bool operator!=(JSULink<T> const* other) const {
+        return this->mLink != other;
     }
+
+    bool operator==(JSUListIterator<T> const& other) const {
+        return this->mLink == other.mLink;
+    }
+
+    bool operator!=(JSUListIterator<T> const& other) const {
+        return this->mLink != other.other;
+    }
+
+    JSUListIterator<T> operator++(int) {
+        JSUListIterator<T> prev = *this;
+        this->mLink             = this->mLink->getNext();
+        return prev;
+    }
+
+    JSUListIterator<T>& operator++() {
+        this->mLink = this->mLink->getNext();
+        return *this;
+    }
+
+    T& operator*() {
+        return *this->getObject();
+    }
+
+    T* operator->() {
+        return this->getObject();
+    }
+
+  private:
+    JSULink<T>* mLink;
+};
+
+//
+// Tree
+//
+
+#define JSU_TREE_FROM_LINK(T, LINK) (JSUTree<T>*)(((u8*)(LINK)) - 12)
+#define JSU_TREE_LINK_IF_NOT_NULL(TREE)                                                                                \
+    if (TREE) {                                                                                                        \
+        TREE = (JSUTree<T>*)(&(TREE)->mLink);                                                                          \
+    }
+
+#define _JSU_TREE_AS_LINK(TREE) ((JSULink<T>*)(TREE))
+
+template <typename T>
+class JSUTree {
+  public:
+    JSUTree(T* owner) : mList(), mLink(owner) {
+    }
+
+    bool appendChild(JSUTree<T>* child) {
+        JSU_TREE_LINK_IF_NOT_NULL(child);
+        return this->mList.append(_JSU_TREE_AS_LINK(child));
+    }
+
+    bool removeChild(JSUTree<T>* child) {
+        JSU_TREE_LINK_IF_NOT_NULL(child);
+        return this->mList.remove(_JSU_TREE_AS_LINK(child));
+    }
+
+    bool insertChild(JSUTree<T>* before, JSUTree<T>* child) {
+        JSU_TREE_LINK_IF_NOT_NULL(before);
+        JSU_TREE_LINK_IF_NOT_NULL(child);
+        return this->mList.insert(_JSU_TREE_AS_LINK(before), _JSU_TREE_AS_LINK(child));
+    }
+
+    JSUTree<T>* getEndChild() const {
+        return NULL;
+    }
+
+    JSUTree<T>* getFirstChild() const {
+        JSULink<T>* link = this->mList.getFirst();
+        return link ? JSU_TREE_FROM_LINK(T, link) : (JSUTree<T>*)link;
+    }
+
+    JSUTree<T>* getLastChild() const {
+        JSULink<T>* link = this->mList.getLast();
+        return link ? JSU_TREE_FROM_LINK(T, link) : (JSUTree<T>*)link;
+    }
+
+    JSUTree<T>* getNextChild() const {
+        JSULink<T>* link = this->mLink.getNext();
+        return link ? JSU_TREE_FROM_LINK(T, link) : (JSUTree<T>*)link;
+    }
+
+    JSUTree<T>* getPrevChild() const {
+        JSULink<T>* link = this->mLink.getPrev();
+        return link ? JSU_TREE_FROM_LINK(T, link) : (JSUTree<T>*)link;
+    }
+
+    u32 getNumChildren() const {
+        return this->mList.getNumLinks();
+    }
+
+    T* getObject() const {
+        return this->mLink.getObject();
+    }
+
+    JSUTree<T>* getParent() const {
+        return (JSUTree<T>*)this->mLink.getList();
+    }
+
+  private:
+    JSUList<T> mList;
+    JSULink<T> mLink;
+};
+
+template <typename T>
+class JSUTreeIterator {
+  public:
+    JSUTreeIterator() : mTree(NULL) {
+    }
+    JSUTreeIterator(JSUTree<T>* tree) : mTree(tree) {
+    }
+
+    JSUTreeIterator<T>& operator=(JSUTree<T>* tree) {
+        this->mTree = tree;
+        return *this;
+    }
+
+    T* getObject() {
+        return this->mTree->getObject();
+    }
+
+    bool operator==(JSUTree<T>* other) {
+        return this->mTree == other;
+    }
+
+    bool operator!=(JSUTree<T>* other) {
+        return this->mTree != other;
+    }
+
+    JSUTreeIterator<T> operator++(int) {
+        JSUTreeIterator<T> prev = *this;
+        this->mTree             = this->mTree->getNextChild();
+        return prev;
+    }
+
+    JSUTreeIterator<T>& operator++() {
+        this->mTree = this->mTree->getNextChild();
+        return *this;
+    }
+
+    T& operator*() {
+        return *this->getObject();
+    }
+
+    T* operator->() {
+        return this->getObject();
+    }
+
+  private:
+    JSUTree<T>* mTree;
 };
 
 #endif
diff --git a/include/functions.h b/include/functions.h
index 390d47fac9..0f963a2d57 100644
--- a/include/functions.h
+++ b/include/functions.h
@@ -111,7 +111,7 @@ extern "C" {
     void getTotalUsedSize__10JKRExpHeapCFv(void);
     void HeapCheck_NS_getUsedCount(void);
     void CheckHeap1__9HeapCheckFv(void);
-    void JUTException_NS_panic_f(void);
+    void JUTException_NS_panic_f(const char* filename, int line, const char* format, ...);
     void Debug_console__FUl(void);
     void debugDisplay__Fv(void);
     void CheckHeap__FUl(void);
diff --git a/libs/JSystem/JKernel/JKRDisposer.cpp b/libs/JSystem/JKernel/JKRDisposer.cpp
index 928784f65b..e26f0253e0 100644
--- a/libs/JSystem/JKernel/JKRDisposer.cpp
+++ b/libs/JSystem/JKernel/JKRDisposer.cpp
@@ -3,36 +3,17 @@
 #include "JSystem/JKernel/JKRHeap/JKRHeap.h"
 
 // #include "JSystem/JKernel/asm/func_802D147C.s"
-JKRDisposer::JKRDisposer() : ptr_link(this) {
-    this->heap = JKRHeap::findFromRoot(this);
-    if (this->heap != 0) {
-        this->heap->disposable_list.append(&this->ptr_link);
+JKRDisposer::JKRDisposer() : mLink(this) {
+    this->mHeap = JKRHeap::findFromRoot(this);
+    if (this->mHeap) {
+        this->mHeap->appendDisposer(this);
     }
 }
 
-/*
-Super close.
-
-This is what we expected: (from Ghidra)
-  if (this != (JKRDisposer *)&DAT_fffffff8) {
-      JSUPtrLink::~JSUPtrLink(&this->ptr_link,0);
-  }
-
-But the compiler generate code like this instead: (no if and -1 instead of 0)
-  JSUPtrLink::~JSUPtrLink(&this->ptr_link,-1);
-  
-Maybe we are using the wrong compiler?
-*/
-#ifdef NONMATCHING
+// #include "JSystem/JKernel/JKRDisposer/asm/func_802D14E4.s"
 JKRDisposer::~JKRDisposer() {
-  JKRHeap* heap = this->heap;
-  if (heap != 0) {
-    heap->disposable_list.remove(&this->ptr_link);
-  }
-}
-#else
-asm JKRDisposer::~JKRDisposer() {
-    nofralloc
-#include "JSystem/JKernel/JKRDisposer/asm/func_802D14E4.s"
+    JKRHeap* heap = this->mHeap;
+    if (heap) {
+        heap->removeDisposer(this);
+    }
 }
-#endif
diff --git a/libs/JSystem/JKernel/JKRHeap.cpp b/libs/JSystem/JKernel/JKRHeap.cpp
index e1ffcd5092..1b2c039494 100644
--- a/libs/JSystem/JKernel/JKRHeap.cpp
+++ b/libs/JSystem/JKernel/JKRHeap.cpp
@@ -1,36 +1,20 @@
 #include "JSystem/JKernel/JKRHeap/JKRHeap.h"
 #include "global.h"
 
-/*
-Very close! When initialzing child_list(true) it will use less register then the asm code. 
--  2cb0b0:      3b 5f 00 40     addi    r26,r31,64
--  2cb0b4:      7f 43 d3 78     mr      r3,r26
--  2cb0b8:      48 00 dd 9d     bl      0x2d8e54
--  2cb0bc:      38 7a 00 0c     addi    r3,r26,12
-
-+  2cb0b0:      38 7f 00 40     addi    r3,r31,64
-+  2cb0b4:      38 80 00 01     li      r4,1
-+  2cb0b8:      48 00 dd 01     bl      0x2d8db8
-+  2cb0bc:      38 7f 00 4c     addi    r3,r31,76
-*/
-#ifdef NONMATCHING
+// #include "JSystem/JKernel/JKRHeap/asm/func_802CE138.s"
 JKRHeap::JKRHeap(void* data, u32 size, JKRHeap* parent, bool error_flag)
-    : JKRDisposer(), child_list(true), heap_link(this), disposable_list(true) {
+    : JKRDisposer(), mChildTree(this), mDisposerList() {
     OSInitMutex(this->mutex);
-    this->size  = size;
-    this->begin = (u32)data;
-    this->end   = (u32)data + size;
+    this->mSize  = size;
+    this->mBegin = (u32)data;
+    this->mEnd   = (u32)data + size;
 
     if (parent == NULL) {
         this->becomeSystemHeap();
         this->becomeCurrentHeap();
     } else {
-        JSUPtrLink* ptr = (JSUPtrLink*)&this->child_list;
-        if (ptr != NULL) {
-            ptr = &this->heap_link;
-        }
+        parent->mChildTree.appendChild(&this->mChildTree);
 
-        parent->child_list.append(ptr);
         if (lbl_80451370 == lbl_80451378) {
             this->becomeSystemHeap();
         }
@@ -39,8 +23,8 @@ JKRHeap::JKRHeap(void* data, u32 size, JKRHeap* parent, bool error_flag)
         }
     }
 
-    this->error_flag = error_flag;
-    if ((this->error_flag == true) && (lbl_8045137C == NULL)) {
+    this->mErrorFlag = error_flag;
+    if ((this->mErrorFlag == true) && (lbl_8045137C == NULL)) {
         lbl_8045137C = JKRHeap::JKRDefaultMemoryErrorRoutine;
     }
 
@@ -48,17 +32,43 @@ JKRHeap::JKRHeap(void* data, u32 size, JKRHeap* parent, bool error_flag)
     this->field_0x3d = lbl_80451380[0];
     this->field_0x69 = 0;
 }
-#else
-asm JKRHeap::JKRHeap(void* data, u32 size, JKRHeap* parent, bool error_flag) {
-    nofralloc
-#include "JSystem/JKernel/JKRHeap/asm/func_802CE138.s"
-}
-#endif
 
+// using the wrong register for storing the results
+// lbl_80451370 = systemHeap;
+#ifdef NONMATCHING
+JKRHeap::~JKRHeap() {
+    JSUTree<JKRHeap>* parent = this->mChildTree.getParent();
+    parent->removeChild(&this->mChildTree);
+
+    JSUTree<JKRHeap>* nextRootHeap = lbl_80451378->mChildTree.getFirstChild();
+
+    JKRHeap* rootHeap = lbl_80451378;
+    JKRHeap* currentHeap = lbl_80451374;
+    if (currentHeap == this) {
+        if (!nextRootHeap) {
+            currentHeap = rootHeap;
+        } else {
+            currentHeap = nextRootHeap->getObject();
+        }
+    }
+    lbl_80451374 = currentHeap;
+
+    JKRHeap* systemHeap = lbl_80451370;
+    if (systemHeap == this) {
+        if (!nextRootHeap) {
+            systemHeap = rootHeap;
+        } else {
+            systemHeap = nextRootHeap->getObject();
+        }
+    }
+    lbl_80451370 = systemHeap;
+}
+#else
 asm JKRHeap::~JKRHeap() {
     nofralloc
 #include "JSystem/JKernel/JKRHeap/asm/func_802CE264.s"
 }
+#endif
 
 // #include "JSystem/JKernel/JKRHeap/asm/func_802CE378.s"
 bool JKRHeap::initArena(char** memory, u32* size, int param_3) {
@@ -188,7 +198,7 @@ s32 JKRHeap::getFreeSize() {
 }
 
 // #include "JSystem/JKernel/JKRHeap/asm/func_802CE758.s"
-s32 JKRHeap::getMaxFreeBlock() {
+void* JKRHeap::getMaxFreeBlock() {
     return this->do_getMaxFreeBlock();
 }
 
@@ -202,37 +212,105 @@ u8 JKRHeap::changeGroupID(u8 param_1) {
     return this->do_changeGroupID(param_1);
 }
 
-asm s32 JKRHeap::getMaxAllocatableSize(int alignment) {
+// "not/nor" instruction in the wrong place
+#ifdef NONMATCHING
+s32 JKRHeap::getMaxAllocatableSize(int alignment) {
+    u32 maxFreeBlock = (u32)this->getMaxFreeBlock();
+    s32 freeSize     = this->getFreeSize();
+
+    u32 mask        = alignment - 1U;
+    s32 ptrOffset   = mask & (alignment - (maxFreeBlock & 0xf));
+    s32 alignedSize = (freeSize - ptrOffset) & ~(alignment - 1U);
+    return alignedSize;
+}
+#else
+asm s32 JKRHeap::getMaxAllocatableSize(int alignment){
     nofralloc
-    #include "JSystem/JKernel/JKRHeap/asm/func_802CE7DC.s"
+#include "JSystem/JKernel/JKRHeap/asm/func_802CE7DC.s"
 }
+#endif
+
 
 // #include "JSystem/JKernel/JKRHeap/asm/func_802CE83C.s"
 JKRHeap* JKRHeap::findFromRoot(void* ptr) {
     if (lbl_80451378 == NULL) {
-        return (JKRHeap*)NULL;
+        return NULL;
     }
 
-    if (((void*)lbl_80451378->begin <= ptr) && (ptr < (void*)lbl_80451378->end)) {
+    if ((void*)lbl_80451378->mBegin <= ptr && ptr < (void*)lbl_80451378->mEnd) {
         return lbl_80451378->find(ptr);
     }
 
     return lbl_80451378->findAllHeap(ptr);
 }
 
-asm JKRHeap* JKRHeap::find(void* ptr) const {
-    nofralloc
-#include "JSystem/JKernel/JKRHeap/asm/func_802CE894.s"
+// #include "JSystem/JKernel/JKRHeap/asm/func_802CE894.s"
+JKRHeap* JKRHeap::find(void* ptr) const {
+    if ((void*)this->mBegin <= ptr && ptr < (void*)this->mEnd) {
+        const JSUTree<JKRHeap>& tree = this->mChildTree;
+        if (tree.getNumChildren() != 0) {
+            JSUTreeIterator<JKRHeap> iterator;
+            for (iterator = tree.getFirstChild(); iterator != tree.getEndChild(); iterator++) {
+                JKRHeap* child  = iterator.getObject();
+                JKRHeap* result = child->find(ptr);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+
+        return (JKRHeap*)this;
+    }
+
+    return NULL;
 }
 
-asm JKRHeap* JKRHeap::findAllHeap(void* ptr) const {
-    nofralloc
-#include "JSystem/JKernel/JKRHeap/asm/func_802CE93C.s"
+// #include "JSystem/JKernel/JKRHeap/asm/func_802CE93C.s"
+JKRHeap* JKRHeap::findAllHeap(void* ptr) const {
+    const JSUTree<JKRHeap>& tree = this->mChildTree;
+    if (tree.getNumChildren() != 0) {
+
+        JSUTreeIterator<JKRHeap> iterator;
+        for (iterator = tree.getFirstChild(); iterator != tree.getEndChild(); iterator++) {
+            JKRHeap* child  = iterator.getObject();
+            JKRHeap* result = child->findAllHeap(ptr);
+            if (result) {
+                return result;
+            }
+        }
+    }
+
+    if ((void*)this->mBegin <= ptr && ptr < (void*)this->mEnd) {
+        // Cast away const
+        return (JKRHeap*)this;
+    }
+
+    return NULL;
 }
 
-asm void JKRHeap::dispose_subroutine(u32 begin, u32 end) {
-    nofralloc
-#include "JSystem/JKernel/JKRHeap/asm/func_802CE9E4.s"
+// #include "JSystem/JKernel/JKRHeap/asm/func_802CE9E4.s"
+void JKRHeap::dispose_subroutine(u32 begin, u32 end) {
+    JSUListIterator<JKRDisposer> last_iterator;
+    JSUListIterator<JKRDisposer> next_iterator;
+    JSUListIterator<JKRDisposer> iterator;
+    for (iterator = this->mDisposerList.getFirst(); iterator != this->mDisposerList.getEnd();
+         iterator = next_iterator) {
+        JKRDisposer* disposer = iterator.getObject();
+
+        if ((void*)begin <= disposer && disposer < (void*)end) {
+            disposer->~JKRDisposer();
+            if (last_iterator == NULL) {
+                next_iterator = this->mDisposerList.getFirst();
+            } else {
+                next_iterator = last_iterator;
+                next_iterator++;
+            }
+        } else {
+            last_iterator = iterator;
+            next_iterator = iterator;
+            next_iterator++;
+        }
+    }
 }
 
 // #include "JSystem/JKernel/JKRHeap/asm/func_802CEA78.s"
@@ -248,13 +326,16 @@ void JKRHeap::dispose(void* begin, void* end) {
     this->dispose_subroutine((u32)begin, (u32)end);
 }
 
+// missing stack variable?
 #ifdef NONMATCHING
 void JKRHeap::dispose() {
-    JSUPtrLink* node;
-    JKRDisposer* disposable;
-    while (node = this->disposable_list.head, node != NULL) {
-        disposable = (JKRDisposer*)node->owner;
-        disposable->~JKRDisposer();
+    JKRDisposer* disposer;
+    JSUListIterator<JKRDisposer> iterator;
+
+    JSUList<JKRDisposer>* list = &this->mDisposerList;
+    while (iterator = list->getFirst(), iterator != list->getEnd()) {
+        disposer = iterator.getObject();
+        disposer->~JKRDisposer();
     }
 }
 #else
@@ -278,24 +359,54 @@ void JKRHeap::copyMemory(void* dst, void* src, u32 size) {
     }
 }
 
-asm void JKRHeap::JKRDefaultMemoryErrorRoutine(JKRHeap* heap, u32 size, int alignment) {
-    nofralloc
-#include "JSystem/JKernel/JKRHeap/asm/func_802CEB40.s"
+// #include "JSystem/JKernel/JKRHeap/asm/func_802CEB40.s"
+void JKRHeap::JKRDefaultMemoryErrorRoutine(JKRHeap* heap, u32 size, int alignment) {
+    const char* filename = lbl_8039CAD8;      // "JKRHeap.cpp"
+    const char* format   = lbl_8039CAD8 + 12; // "%s"
+    const char* arg1     = lbl_8039CAD8 + 15; // "abort\n"
+    JUTException_NS_panic_f(filename, 0x33f, format, arg1);
 }
 
-asm bool JKRHeap::setErrorFlag(bool param_1) {
-    nofralloc
-#include "JSystem/JKernel/JKRHeap/asm/func_802CEB78.s"
+// #include "JSystem/JKernel/JKRHeap/asm/func_802CEB78.s"
+bool JKRHeap::setErrorFlag(bool error_flag) {
+    bool prev        = this->mErrorFlag;
+    this->mErrorFlag = error_flag;
+    return prev;
 }
 
-asm JKRErrorHandler JKRHeap::setErrorHandler(JKRErrorHandler param_1) {
-    nofralloc
-#include "JSystem/JKernel/JKRHeap/asm/func_802CEB88.s"
+// #include "JSystem/JKernel/JKRHeap/asm/func_802CEB88.s"
+JKRErrorHandler JKRHeap::setErrorHandler(JKRErrorHandler error_handler) {
+    JKRErrorHandler prev = (JKRErrorHandler)lbl_8045137C;
+
+    if (!error_handler) {
+        error_handler = (JKRErrorHandler)JKRHeap::JKRDefaultMemoryErrorRoutine;
+    }
+
+    lbl_8045137C = error_handler;
+    return prev;
 }
 
-asm bool JKRHeap::isSubHeap(JKRHeap* heap) const {
-    nofralloc
-#include "JSystem/JKernel/JKRHeap/asm/func_802CEBA8.s"
+// #include "JSystem/JKernel/JKRHeap/asm/func_802CEBA8.s"
+bool JKRHeap::isSubHeap(JKRHeap* heap) const {
+    if (!heap) return false;
+
+    const JSUTree<JKRHeap>& tree = this->mChildTree;
+    if (tree.getNumChildren() != 0) {
+        JSUTreeIterator<JKRHeap> iterator;
+        for (iterator = tree.getFirstChild(); iterator != tree.getEndChild(); ++iterator) {
+            JKRHeap* child = iterator.getObject();
+            if (child == heap) {
+                return true;
+            }
+
+            bool is_sub_heap = child->isSubHeap(heap);
+            if (is_sub_heap) {
+                return true;
+            }
+        }
+    }
+
+    return false;
 }
 
 // #include "JSystem/JKernel/JKRHeap/asm/func_802CEC4C.s"
diff --git a/libs/JSystem/JSupport/JSUList.cpp b/libs/JSystem/JSupport/JSUList.cpp
index 508cc262b0..5aacdb34b7 100644
--- a/libs/JSystem/JSupport/JSUList.cpp
+++ b/libs/JSystem/JSupport/JSUList.cpp
@@ -2,17 +2,17 @@
 #include "global.h"
 
 // #include "JSupport/asm/func_802DBDFC.s"
-JSUPtrLink::JSUPtrLink(void* owner) {
-    this->list = NULL;
-    this->owner = owner;
-    this->prev = NULL;
-    this->next = NULL;
+JSUPtrLink::JSUPtrLink(void* object) {
+    this->mList   = NULL;
+    this->mObject = object;
+    this->mPrev   = NULL;
+    this->mNext   = NULL;
 }
 
 // #include "JSupport/asm/func_802DBE14.s"
 JSUPtrLink::~JSUPtrLink() {
-    if (this->list != NULL) {
-        this->list->remove(this);
+    if (this->mList != NULL) {
+        this->mList->remove(this);
     }
 }
 
@@ -21,59 +21,59 @@ JSUPtrLink::~JSUPtrLink() {
 //
 
 // #include "JSupport/asm/func_802DBE74.s"
-JSUPtrList::JSUPtrList(bool should_initiate) {
-    if (should_initiate != false) {
+JSUPtrList::JSUPtrList(bool init) {
+    if (init) {
         this->initiate();
     }
 }
 
 // #include "JSupport/asm/func_802DBEAC.s"
 JSUPtrList::~JSUPtrList() {
-    JSUPtrLink* node = this->head;
+    JSUPtrLink* node = this->mHead;
     s32 removed      = 0;
-    while (this->length > removed) {
-        node->list = NULL;
-        node       = node->next;
+    while (this->mLength > removed) {
+        node->mList = NULL;
+        node        = node->getNext();
         removed += 1;
     }
 }
 
 // #include "JSupport/asm/func_802DBF14.s"
 void JSUPtrList::initiate() {
-    this->head   = NULL;
-    this->tail   = NULL;
-    this->length = 0;
+    this->mHead   = NULL;
+    this->mTail   = NULL;
+    this->mLength = 0;
 }
 
 // #include "JSupport/asm/func_802DBF28.s"
 void JSUPtrList::setFirst(JSUPtrLink* first) {
-    first->list  = this;
-    first->prev  = NULL;
-    first->next  = NULL;
-    this->tail   = first;
-    this->head   = first;
-    this->length = 1;
+    first->mList  = this;
+    first->mPrev  = NULL;
+    first->mNext  = NULL;
+    this->mTail   = first;
+    this->mHead   = first;
+    this->mLength = 1;
 }
 
 // #include "JSupport/asm/func_802DBF4C.s"
 bool JSUPtrList::append(JSUPtrLink* ptr) {
-    JSUPtrList* list = ptr->list;
-    bool result = (NULL == list);
+    JSUPtrList* list = ptr->mList;
+    bool result      = (NULL == list);
     if (!result) {
         result = list->remove(ptr);
     }
 
-    if (result) { 
-        if (this->length == 0) {
+    if (result) {
+        if (this->mLength == 0) {
             this->setFirst(ptr);
         } else {
-            ptr->list        = this;
-            ptr->prev        = this->tail;
-            ptr->next        = NULL;
-            this->tail->next = ptr;
-            this->tail       = ptr;
-            this->length++;
-        } 
+            ptr->mList         = this;
+            ptr->mPrev         = this->mTail;
+            ptr->mNext         = NULL;
+            this->mTail->mNext = ptr;
+            this->mTail        = ptr;
+            this->mLength++;
+        }
     }
 
     return result;
@@ -81,23 +81,23 @@ bool JSUPtrList::append(JSUPtrLink* ptr) {
 
 // #include "JSupport/asm/func_802DBFF0.s"
 bool JSUPtrList::prepend(JSUPtrLink* ptr) {
-    JSUPtrList* list = ptr->list;
-    bool result = (NULL == list);
+    JSUPtrList* list = ptr->mList;
+    bool result      = (NULL == list);
     if (!result) {
         result = list->remove(ptr);
     }
 
-    if (result) { 
-        if (this->length == 0) {
+    if (result) {
+        if (this->mLength == 0) {
             this->setFirst(ptr);
         } else {
-            ptr->list = this;
-            ptr->prev = (JSUPtrLink*)NULL;
-            ptr->next = this->head;
-            this->head->prev = ptr;
-            this->head = ptr;
-            this->length++;
-        } 
+            ptr->mList         = this;
+            ptr->mPrev         = NULL;
+            ptr->mNext         = this->mHead;
+            this->mHead->mPrev = ptr;
+            this->mHead        = ptr;
+            this->mLength++;
+        }
     }
 
     return result;
@@ -105,29 +105,29 @@ bool JSUPtrList::prepend(JSUPtrLink* ptr) {
 
 // #include "JSupport/asm/func_802DC094.s"
 bool JSUPtrList::insert(JSUPtrLink* before, JSUPtrLink* ptr) {
-    if (before == this->head) {
-         return this->prepend(ptr);
+    if (before == this->mHead) {
+        return this->prepend(ptr);
     } else if (before == NULL) {
         return this->append(ptr);
     }
-    
-    if (before->list != this) {
+
+    if (before->mList != this) {
         return false;
     }
-    
-    bool result = (NULL == ptr->list);
+
+    bool result = (NULL == ptr->mList);
     if (!result) {
-        result = ptr->list->remove(ptr);
+        result = ptr->mList->remove(ptr);
     }
 
     if (result) {
-        JSUPtrLink* prev = before->prev;
-        ptr->list = this;
-        ptr->prev = prev;
-        ptr->next = before;
-        prev->next = ptr;
-        before->prev = ptr;
-        this->length++;
+        JSUPtrLink* prev = before->mPrev;
+        ptr->mList       = this;
+        ptr->mPrev       = prev;
+        ptr->mNext       = before;
+        prev->mNext      = ptr;
+        before->mPrev    = ptr;
+        this->mLength++;
     }
 
     return result;
@@ -135,24 +135,24 @@ bool JSUPtrList::insert(JSUPtrLink* before, JSUPtrLink* ptr) {
 
 // #include "JSupport/asm/func_802DC15C.s"
 bool JSUPtrList::remove(JSUPtrLink* ptr) {
-    bool is_parent = (ptr->list == this);
+    bool is_parent = (ptr->mList == this);
     if (is_parent) {
-        if (this->length == 1) {
-            this->head = NULL;
-            this->tail = NULL;
-        } else if (ptr == this->head) {
-            ptr->next->prev = NULL;
-            this->head      = ptr->next;
-        } else if (ptr == this->tail) {
-            ptr->prev->next = NULL;
-            this->tail      = ptr->prev;
+        if (this->mLength == 1) {
+            this->mHead = NULL;
+            this->mTail = NULL;
+        } else if (ptr == this->mHead) {
+            ptr->mNext->mPrev = NULL;
+            this->mHead       = ptr->mNext;
+        } else if (ptr == this->mTail) {
+            ptr->mPrev->mNext = NULL;
+            this->mTail       = ptr->mPrev;
         } else {
-            ptr->prev->next = ptr->next;
-            ptr->next->prev = ptr->prev;
+            ptr->mPrev->mNext = ptr->mNext;
+            ptr->mNext->mPrev = ptr->mPrev;
         }
 
-        ptr->list = NULL;
-        this->length--;
+        ptr->mList = NULL;
+        this->mLength--;
     }
 
     return is_parent;
@@ -160,15 +160,14 @@ bool JSUPtrList::remove(JSUPtrLink* ptr) {
 
 // #include "JSupport/asm/func_802DC20C.s"
 JSUPtrLink* JSUPtrList::getNthLink(u32 index) const {
-    if (index >= this->length) {
+    if (index >= this->mLength) {
         return NULL;
     }
 
-    JSUPtrLink* node = this->head;
-    for(u32 i = 0; i < index; i++) {
-        node = node->next;
+    JSUPtrLink* node = this->mHead;
+    for (u32 i = 0; i < index; i++) {
+        node = node->getNext();
     }
 
     return node;
 }
-