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>

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

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];
 };

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;
 
-  public:
-    JSUPtrLink* head;
-    JSUPtrLink* tail;
-    u32 length;
+    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 : JSUPtrList {
+class JSUList : protected JSUPtrList {
   public:
-    JSUList() : JSUPtrList(true) {
-    }
-    ~JSUList(){};
-
-    void append(T* value) {
-        list.append(&value->ptr_link);
+    JSUList() : JSUPtrList() {
     }
 
-    void prepend(T* value) {
-        list.prepend(&value->ptr_link);
+    JSUList(bool init) : JSUPtrList(init) {
     }
 
-    void remove(T* value) {
-        list.remove(&value->ptr_link);
+    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 JSUListIterator {
+  public:
+    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;
+    }
+
+    T* getObject() {
+        return this->mLink->getObject();
+    }
+
+    bool operator==(JSULink<T> const* other) const {
+        return this->mLink == other;
+    }
+
+    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

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);