match up to func_801DB79C

1 files changed, 173 insertions, 5 deletions

diff --git a/src/code_801DB040.cpp b/src/code_801DB040.cpp
index 8d7a03a..17d2b56 100644
--- a/src/code_801DB040.cpp
+++ b/src/code_801DB040.cpp
@@ -1,5 +1,6 @@
 #include "types.h"

 #include "unkStruct.h"

+#include "Runtime/__mem.h"

 #include "code_801DAAE0.h"

 

 extern "C" {

@@ -7,6 +8,7 @@ extern "C" {
 typedef u32 (*FuncPtr)(void*, u32, u32);

 

 // TODO: func_801DBD00 might need this definition

+// TODO: doubly linked list

 struct unkClass

 {

     u8 unk0; // u8, u32, or union?

@@ -22,6 +24,7 @@ struct unkClass
     unkClass* unk20; //prev?

 };

 

+// TODO: free store for linked list nodes

 struct unkClass2

 {

     u8 pad[0x24];

@@ -54,11 +57,24 @@ extern unkClass2* lbl_8063F2EC; //TODO: rename/define/internalize
 

 

 

+// TODO: interface for this module

+

 //static

 unkClass* func_801DB040(u32 p1, u32 p2);

 unkClass* func_801DB07C(unkClass* p1, BOOL p2);

 void func_801DB15C(u32 p1);

-void* func_801DB184(MEMHeapHandle p1, u32 size, u32 p3, u32 p4, FuncPtr p5);

+void* func_801DB184(MEMHeapHandle heap, u32 size, u32 p3, u32 p4, FuncPtr p5);

+void* func_801DB270(MEMHeapHandle heap, u32 size, int align, u32 p4, u32 p5, FuncPtr p6);

+void* func_801DB360(u32 size, int align, u32 p3, u32 p4, FuncPtr p5);

+void func_801DB3BC(void* p1, u32 p2, u32 p3, FuncPtr p4);

+void* func_801DB4BC(u32 p1, u32 p2);

+u32 func_801DB4FC(u32 p1, u32 p2);

+u32 func_801DB548(u32 p1, u32 p2);

+u32 func_801DB5E4(u32 p1, u32 p2);

+void func_801DB644(u32 p1, u32 p2);

+void func_801DB674(u32 p1);

+BOOL func_801DB6D0(u32 p1, u32 p2, MEMHeapHandle p3, u32 p4, u32 p5, FuncPtr p6);

+

 

 

 //static

@@ -70,6 +86,8 @@ unkClass* func_801DB040(u32 p1, u32 p2)
     return NULL;

 }

 

+// free node's buffer, and optionally remove node from linked list,

+// returning new head?

 unkClass* func_801DB07C(unkClass* p1, BOOL p2)

 {

     unkClass* r31;

@@ -109,10 +127,11 @@ void func_801DB15C(u32 p1)
     lbl_8063F2EC = func_801DBD74(p1, 36);

 }

 

-// Add node to start of linked list

+// Add node to start of linked list, and return pointer to its data payload

 //static

-void* func_801DB184(MEMHeapHandle p1, u32 size, u32 p3, u32 p4, FuncPtr p5)

+void* func_801DB184(MEMHeapHandle heap, u32 size, u32 p3, u32 p4, FuncPtr p5)

 {

+    // check if node already exists?

     if (func_801DB040(p3, p4))

         return NULL;

     // allocate linked list node from free store?

@@ -121,7 +140,7 @@ void* func_801DB184(MEMHeapHandle p1, u32 size, u32 p3, u32 p4, FuncPtr p5)
         return NULL;

     // alloc

     // void* func_801DAC94(MEMHeapHandle heap, u32 size)

-    if ((r31->unkC = func_801DAC94(p1, size)) == NULL) {

+    if ((r31->unkC = func_801DAC94(heap, size)) == NULL) {

         // return node to free store?

         func_801DBD00(lbl_8063F2EC, r31);

         return NULL;

@@ -134,7 +153,7 @@ void* func_801DB184(MEMHeapHandle p1, u32 size, u32 p3, u32 p4, FuncPtr p5)
     lbl_8063F2E8 = r31;

     

     r31->unk0 = 1;

-    r31->unk8 = p1;

+    r31->unk8 = heap;

     r31->unk1 = 0;

     r31->unk10 = p3;

     r31->unk14 = p4;

@@ -143,14 +162,163 @@ void* func_801DB184(MEMHeapHandle p1, u32 size, u32 p3, u32 p4, FuncPtr p5)
     return r31->unkC;

 }

 

+// similar to func_801DB184, but use alignment allocator function

+// and do not clear unk4 of the unkClass structure

+void* func_801DB270(MEMHeapHandle heap, u32 size, int align, u32 p4, u32 p5, FuncPtr p6)

+{

+    if (func_801DB040(p4, p5))

+        return NULL;

+    unkClass* r31 = func_801DBC58(lbl_8063F2EC);

+    if (!r31)

+        return NULL;

+    // void* func_801DAD08(MEMHeapHandle heap, u32 size, int alignment);

+    if ((r31->unkC = func_801DAD08(heap, size, align)) == NULL) {

+        func_801DBD00(lbl_8063F2EC, r31);

+        return NULL;

+    }

+    if (lbl_8063F2E8)

+        lbl_8063F2E8->unk20 = r31;

+    

+    r31->unk1C = lbl_8063F2E8;

+    r31->unk20 = NULL;

+    lbl_8063F2E8 = r31;

+    

+    r31->unk0 = 1;

+    r31->unk8 = heap;

+    r31->unk1 = 0;

+    r31->unk10 = p4;

+    r31->unk14 = p5;

+    r31->unk18 = p6;

+    return r31->unkC;

+}

+

+void* func_801DB360(u32 size, int align, u32 p3, u32 p4, FuncPtr p5)

+{

+    return func_801DB270(func_801DAC0C(), size, align, p3, p4, p5);

+}

+

+// replace node in linked list?

+void func_801DB3BC(void* p1, u32 p2, u32 p3, FuncPtr p4)

+{

+    unkClass* r31 = func_801DB040(p2, p3);

+    if (!p1) {

+        if (r31)

+            func_801DB07C(r31, TRUE);

+        return;

+    }

+    

+    if (r31) {

+        if (!r31->unk0) {

+            if (r31->unkC != p1) {

+                if (r31->unk18)

+                    r31->unk18(r31->unkC, p2, p3);

+                r31->unkC = p1;

+            }

+            r31->unk18 = p4;

+        }

+    } else {

+        unkClass* r3 = func_801DBC58(lbl_8063F2EC);

+        if (r3) {

+            if (lbl_8063F2E8)

+                lbl_8063F2E8->unk20 = r3;

+            r3->unk1C = lbl_8063F2E8;

+            r3->unk20 = NULL;

+            lbl_8063F2E8 = r3;

+            r3->unk0 = 0;

+            r3->unk1 = 0;

+            r3->unkC = p1;

+            r3->unk10 = p2;

+            r3->unk14 = p3;

+            r3->unk18 = p4;

+        }

+    }

+}

 

+// get data payload from the specified node?

+void* func_801DB4BC(u32 p1, u32 p2)

+{

+    unkClass* r3 = func_801DB040(p1, p2);

+    if (!r3 || r3->unk1)

+        return NULL;

+    return r3->unkC;

+}

 

+// increment specified node's unk4 counter and return its new value

+u32 func_801DB4FC(u32 p1, u32 p2)

+{

+    unkClass* r3 = func_801DB040(p1, p2);

+    if (!r3 || r3->unk1)

+        return 0;

+    return ++r3->unk4;

+}

 

+// decrement specified node's unk4 counter and return its new value, and

+// free that node if its counter is already / will become 0

+u32 func_801DB548(u32 p1, u32 p2)

+{

+    unkClass* r31 = func_801DB040(p1, p2);

+    if (!r31 || r31->unk1)

+        return 0;

+    if (r31->unk4 == 0) {

+        func_801DB644(p1, p2);

+        return 0;

+    }

+    if (--r31->unk4 == 0)

+        func_801DB644(p1, p2);

+    return r31->unk4;

+}

 

+// get size of specified node's data payload

+u32 func_801DB5E4(u32 p1, u32 p2)

+{

+    unkClass* r3 = func_801DB040(p1, p2);

+    if (!r3)

+        return 0;

+    if (!r3->unkC)

+        return 0;

+    if (r3->unk0 == 0)

+        return 0;

+    return func_801DAEE0(r3->unkC);

+}

 

+// free specified node

+void func_801DB644(u32 p1, u32 p2)

+{

+    unkClass* r3 = func_801DB040(p1, p2);

+    if (r3)

+        func_801DB07C(r3, TRUE);

+}

 

+// search linked list for all nodes whose unk10 field matches p1, 

+// and remove those nodes from the list

+void func_801DB674(u32 p1)

+{

+    unkClass* p = lbl_8063F2E8;

+    while (p)

+        p = (p->unk10 == p1) ? func_801DB07C(p, TRUE) : p->unk1C;

+}

 

+// append a new node to the start of the linked list,

+// making its data payload a copy of the specified node's payload

+BOOL func_801DB6D0(u32 p1, u32 p2, MEMHeapHandle heap, u32 p4, u32 p5, FuncPtr p6)

+{

+    unkClass* r31 = func_801DB040(p1, p2);

+    if (!r31 || r31->unk1 || !r31->unkC || !r31->unk0)

+        return FALSE;

+    u32 blockSize = func_801DAEE0(r31->unkC);

+    if (blockSize == 0)

+        return FALSE;

+    void* data = func_801DB184(heap, blockSize, p4, p5, p6);

+    if (!data)

+        return FALSE;

+    memcpy(data, r31->unkC, blockSize);

+    return TRUE;

+}

 

+func_801DB79C()

+{

+    

+}