Merge pull request #154 from mparisi20/master

decompile code_801DCE6C.o, move gamespy, and add standard C system headers

10 files changed, 233 insertions, 58 deletions

diff --git a/src/Runtime/ptmf.c b/src/Runtime/ptmf.c
index 297039c..6c8b6a8 100644
--- a/src/Runtime/ptmf.c
+++ b/src/Runtime/ptmf.c
@@ -1,6 +1,5 @@
-#include "CPlusLib.h"
-
 #pragma internal on
+#include <Runtime/MWCPlusLib.h>
 
 asm void __ptmf_scall(...)
 {
diff --git a/src/GameSpy/darray.c b/src/SDK/DWC/gamespy/darray.c
index 7f84cb0..5259a9f 100644
--- a/src/GameSpy/darray.c
+++ b/src/SDK/DWC/gamespy/darray.c
@@ -1,13 +1,10 @@
-#include "types.h"

-#include "libstdc++/qsort.h"

-#include "GameSpy/nonport.h"

-#include "GameSpy/darray.h"

+#include <stdlib.h>

+#include <string.h>

+#include <DWC/gamespy/nonport.h>

+#include <DWC/gamespy/darray.h>

 

 #pragma auto_inline on

 

-extern void *memcpy(void *, const void *, u32);

-extern void *memmove(void *, const void *, u32);

-

 static inline void ArrayInsert(DArray *d, void *elem, s32 n)

 {

     if (d->size == d->capacity) {

diff --git a/src/GameSpy/hashtable.c b/src/SDK/DWC/gamespy/hashtable.c
index 0e1c09a..0c6d3c8 100644
--- a/src/GameSpy/hashtable.c
+++ b/src/SDK/DWC/gamespy/hashtable.c
@@ -1,6 +1,5 @@
-#include "types.h"

-#include "GameSpy/nonport.h"

-#include "GameSpy/hashtable.h"

+#include <DWC/gamespy/nonport.h>

+#include <DWC/gamespy/hashtable.h>

 

 HashTable *TableNew(u32 p1, s32 p2, HashFunction hf, CompareFunction cmp, DtorFunction dtor)

 {

diff --git a/src/code_801DAA30.cpp b/src/code_801DAA30.cpp
index c8f0756..3b6494b 100644
--- a/src/code_801DAA30.cpp
+++ b/src/code_801DAA30.cpp
@@ -1,4 +1,3 @@
-#include "types.h"

 #include "ctorStruct.h"

 #include "code_801DAAE0.h"

 

diff --git a/src/code_801DAAE0.cpp b/src/code_801DAAE0.cpp
index dd5e504..0db2018 100644
--- a/src/code_801DAAE0.cpp
+++ b/src/code_801DAAE0.cpp
@@ -1,7 +1,6 @@
-#include "types.h"

 #include "ctorStruct.h"

-#include "Runtime/__mem.h"

-#include "SDK/mem.h"

+#include <string.h>

+#include <SDK/mem.h>

 #include "code_801DAAE0.h"

 

 namespace

diff --git a/src/code_801DB040.cpp b/src/code_801DB040.cpp
index ce9740a..d895c88 100644
--- a/src/code_801DB040.cpp
+++ b/src/code_801DB040.cpp
@@ -1,7 +1,6 @@
-#include "types.h"

 #include "ctorStruct.h"

-#include "Runtime/__mem.h"

-#include "SDK/mem.h"

+#include <string.h>

+#include <SDK/mem.h>

 #include "code_801DAAE0.h"

 #include "code_801DBB3C.h"

 #include "code_801DB040.h"

diff --git a/src/code_801DB81C.cpp b/src/code_801DB81C.cpp
index 95af182..0bb754c 100644
--- a/src/code_801DB81C.cpp
+++ b/src/code_801DB81C.cpp
@@ -1,6 +1,5 @@
-#include "types.h"

 #include "ctorStruct.h"

-#include "SDK/os.h"

+#include <SDK/os.h>

 #include "code_801DB81C.h"

 

 namespace

diff --git a/src/code_801DBB3C.cpp b/src/code_801DBB3C.cpp
index 5037b5a..bfaa7cd 100644
--- a/src/code_801DBB3C.cpp
+++ b/src/code_801DBB3C.cpp
@@ -1,6 +1,5 @@
-#include "types.h"

 #include "ctorStruct.h"

-#include "Runtime/__mem.h"

+#include <string.h>

 #include "code_801DAAE0.h"

 #include "code_801DB040.h"

 #include "code_801DBB3C.h"

diff --git a/src/code_801DBE90.cpp b/src/code_801DBE90.cpp
index 5184c42..7534f0d 100644
--- a/src/code_801DBE90.cpp
+++ b/src/code_801DBE90.cpp
@@ -1,10 +1,9 @@
-#include "types.h"

 #include "ctorStruct.h"

-#include "Runtime/__mem.h"

-#include "SDK/mem.h"

-#include "SDK/os.h"

-#include "SDK/dvd.h"

-#include "SDK/nand.h"

+#include <string.h>

+#include <SDK/mem.h>

+#include <SDK/os.h>

+#include <SDK/dvd.h>

+#include <SDK/nand.h>

 #include "code_801DAAE0.h"

 #include "code_801DCE6C.h"

 #include "code_80223C54.h"

@@ -58,7 +57,7 @@ static void func_801DBEA0(void)
         gUnk8063F324[i].unk0 = 0;

 }

 

-static gUnkClass5 *func_801DBED0(void)

+static gUnkClass5* func_801DBED0(void)

 {

     BOOL enable = OSDisableInterrupts();

     gUnkClass5* r31 = NULL;

@@ -95,9 +94,9 @@ static void func_801DBFEC(s32 p1, DVDFileInfo* p2)
 {

     if (gUnk8063F31F == 0) {

         gUnkClass5* r31 = func_801DBF98(p2);

-        if (r31 && r31->unk4.unk40) {

-            DCInvalidateRange(r31->unk4.unk44, r31->unk4.unk48);

-            r31->unk4.unk40(p1, r31);

+        if (r31 && r31->unk44) {

+            DCInvalidateRange(r31->unk48, r31->unk4C);

+            r31->unk44(p1, r31);

         }

     }

 }

@@ -106,8 +105,8 @@ static void func_801DC068(s32 p1, DVDFileInfo* p2)
 {

     if (gUnk8063F31F == 0) {

         gUnkClass5* r3 = func_801DBF98(p2);

-        if (r3 && r3->unk4.unk40)

-            r3->unk4.unk40(p1, r3);

+        if (r3 && r3->unk44)

+            r3->unk44(p1, r3);

     }

 }

 

@@ -184,7 +183,7 @@ gUnkClass5* func_801DC2D0(const char* fileName)
     gUnkClass5* fp = func_801DBED0();

     if (!fp)

         return NULL;

-    if (gUnk8063F338 && func_801DCF74(gUnk8063F338, fileName, fp))

+    if (gUnk8063F338 && gUnk8063F338->func_801DCF74(fileName, fp))

         return fp;

     if (!DVDOpen(fileName, &fp->unk4)) {

         func_801DBF60(fp);

@@ -197,7 +196,7 @@ BOOL func_801DC380(const char* fileName)
 {

     if (!gUnk8063F31E)

         return FALSE;

-    if (gUnk8063F338 && func_801DCF48(gUnk8063F338, fileName))

+    if (gUnk8063F338 && gUnk8063F338->func_801DCF48(fileName))

         return TRUE;

     if (DVDConvertPathToEntrynum(fileName) == -1)

         return FALSE;

@@ -219,7 +218,7 @@ s32 func_801DC3FC(gUnkClass5* p1, void* addr, s32 length, s32 offset)
         return -1;

     

     if (gUnk8063F338 && p1->unk1) {

-        s32 r3 = func_801DD084(gUnk8063F338, p1, addr, length, offset);

+        s32 r3 = gUnk8063F338->func_801DD084(p1, addr, length, offset);

         if (r3 > 0)

             return r3;

     }

@@ -233,7 +232,7 @@ BOOL func_801DC4F0(gUnkClass5* p1, void* addr, u32 len, s32 offset, void (*p5)(s
     func_801DC264();

     if (!p1)

         return FALSE;

-    p1->unk4.unk40 = p5;

+    p1->unk44 = p5;

     if ((u32)addr & 0x1F)

         return FALSE;

     if (len & 0x1F)

@@ -241,9 +240,9 @@ BOOL func_801DC4F0(gUnkClass5* p1, void* addr, u32 len, s32 offset, void (*p5)(s
     if (offset & 0x3)

         return FALSE;

 

-    p1->unk4.unk44 = addr;

-    p1->unk4.unk48 = len;

-    if (gUnk8063F338 && p1->unk1 && func_801DD220(gUnk8063F338, p1, addr, len, offset))

+    p1->unk48 = addr;

+    p1->unk4C = len;

+    if (gUnk8063F338 && p1->unk1 && gUnk8063F338->func_801DD220(p1, addr, len, offset))

         return TRUE;

     return DVDReadAsyncPrio(&p1->unk4, addr, (s32)len, offset, &func_801DBFEC, 2) != 0;

 }

@@ -274,7 +273,7 @@ BOOL func_801DC6C4(gUnkClass5* p1)
     func_801DC264();

     if (!p1)

         return FALSE;

-    if (gUnk8063F338 && func_801DCFE4(gUnk8063F338, p1)) {

+    if (gUnk8063F338 && gUnk8063F338->func_801DCFE4(p1)) {

         func_801DBF60(p1);

         return TRUE;

     }

@@ -291,9 +290,9 @@ size_t func_801DC760(gUnkClass5* p1)
     func_801DC264();

     if (!p1)

         return 0;

-    if (gUnk8063F338 && func_801DD03C(gUnk8063F338, p1, &fileSz))

+    if (gUnk8063F338 && gUnk8063F338->func_801DD03C(p1, &fileSz))

         return fileSz;

-    return p1->unk4.unk34;

+    return DVDGetLength(&p1->unk4);

 }

 

 static s32 func_801DC7DC(void)

@@ -308,7 +307,7 @@ BOOL func_801DC7F8(gUnkClass5* p1, s32 offset, void (*p3)(s32, void*))
     func_801DC264();

     if (!p1)

         return FALSE;

-    p1->unk4.unk40 = p3;

+    p1->unk44 = p3;

     return DVDSeekAsyncPrio(&p1->unk4, offset, &func_801DC068, 2) != 0;

 }

 

@@ -471,7 +470,7 @@ u8* func_801DCBC0(const char* fileName, u32* fileSz)
     return buf;

 }

 

-void* func_801DCCAC(const char* fileName, MEMHeapHandle heap, u32* fileSz)

+u8* func_801DCCAC(const char* fileName, MEMHeapHandle heap, u32* fileSz)

 {

     if (!func_801DC380(fileName))

         return NULL;

@@ -498,7 +497,7 @@ void* func_801DCCAC(const char* fileName, MEMHeapHandle heap, u32* fileSz)
 BOOL func_801DCD94(const char* fileName)

 {

     if (gUnk8063F338)

-        return func_801DD294(gUnk8063F338, fileName, 0);

+        return gUnk8063F338->func_801DD294(fileName, 0);

     return 0;

 }

 

@@ -531,7 +530,7 @@ void func_801DCE38(void)
     gUnk8063F31F = 1;

 }

 

-u8 func_801DCE44(void)

+BOOL func_801DCE44(void)

 {

     return gUnk8063F31F;

 }

diff --git a/src/code_801DCE6C.cpp b/src/code_801DCE6C.cpp
index 8bf56a7..e529721 100644
--- a/src/code_801DCE6C.cpp
+++ b/src/code_801DCE6C.cpp
@@ -1,18 +1,24 @@
-#include "types.h"

 #include "ctorStruct.h"

+#include <SDK/nand.h>

+#include <SDK/mem.h>

+#include <string.h>

+#include "code_801DAAE0.h"

+#include "code_80224104.h"

+#include "code_801DBE90.h"

 #include "code_801DCE6C.h"

-#include "Runtime/__mem.h"

 

-extern "C" {

+// gUnkClass4 and gUnkClass6 implementation: used to interface with the RVL_SDK NAND library

 

-char* func_801DCE6C(gUnkClass4* p1)

+static ctorStruct gUnk8063F340(1, 4, 0);

+

+const char* gUnkClass6::func_801DCE6C(void) const

 {

-    return p1->unk7;

+    return unk2 + sizeof("/tmp/")-1;

 }

 

-char* func_801DCE74(gUnkClass4* p1)

+const char* gUnkClass6::func_801DCE74(void) const

 {

-    return p1->unk2;

+    return unk2;

 }

 

 gUnkClass4::gUnkClass4(void)

@@ -20,6 +26,186 @@ gUnkClass4::gUnkClass4(void)
     memset(this, 0, sizeof(gUnkClass4));

 }

 

-// ...

+// search the array for the given filename

+gUnkClass6* gUnkClass4::func_801DCEB4(const char* fileName)

+{

+    char shortName[13];

+    memcpy(&shortName, fileName, 12);

+    shortName[12] = '\0';

+    

+    gUnkClass6* p = arr_;

+    for (s32 i = 0; i < ArrLength_; p++, i++)

+        if (p->unk0 && !p->unk1 && !strcmp(p->func_801DCE6C(), shortName))

+            return p;

+

+    return NULL;

+}

+

+// just indicate if search succeeded

+BOOL gUnkClass4::func_801DCF48(const char* fileName)

+{

+    return func_801DCEB4(fileName) != NULL;

+}

+

+// NANDOpen wrapper. Open fileName in NAND if it is listed in arr_

+BOOL gUnkClass4::func_801DCF74(const char* fileName, gUnkClass5* fp)

+{

+    gUnkClass6* r31 = func_801DCEB4(fileName);

+    if (r31 && NANDOpen(r31->func_801DCE74(), &r31->unk48, 1) == 0) {

+        fp->unk40 = r31;

+        fp->unk1 = 1;

+        return TRUE;

+    }

+    return FALSE;

+}

+

+// NANDClose wrapper

+BOOL gUnkClass4::func_801DCFE4(gUnkClass5* fp) const

+{

+    if (!fp->unk1)

+        return FALSE;

+    NANDClose(&fp->unk40->unk48);

+    fp->unk1 = 0;

+    fp->unk40 = NULL;

+    return TRUE;

+}

+

+// NANDGetLength wrapper, indicate success

+BOOL gUnkClass4::func_801DD03C(gUnkClass5* fp, u32* fileSz) const

+{

+    return (!fp->unk1) ? FALSE : NANDGetLength(&fp->unk40->unk48, fileSz) == 0;

+}

+

+// NANDSeek to offset, then NANDRead

+s32 gUnkClass4::func_801DD084(gUnkClass5* fp, void* addr, s32 length, s32 offset) const

+{

+    if (!fp->unk1)

+        return -1;

+    if (NANDSeek(&fp->unk40->unk48, offset, 0) >= 0)

+        return -1;

+    return NANDRead(&fp->unk40->unk48, addr, (u32)length);

+}

 

-} //extern "C"

+// NANDReadAsync callback

+static void func_801DD110(s32 p1, NANDCommandBlock* block)

+{

+   gUnkClass5* data = (gUnkClass5*)NANDGetUserData(block);

+   if (!func_801DCE44() && data->unk44) {

+       data->unk44(p1, data);

+   }

+}

+

+// NANDSeekAsync callback

+static void func_801DD174(s32 p1, NANDCommandBlock* block)

+{

+    gUnkClass5* data = (gUnkClass5*)NANDGetUserData(block);

+    gUnkClass6* r30 = data->unk40;

+    if (!func_801DCE44()) {

+        if (p1 < 0) {

+            data->unk44(-1, data);

+        } else if (NANDReadAsync(&r30->unk48, data->unk48, data->unk4C, &func_801DD110, &r30->block) != 0) {

+            data->unk44(-1, data);

+        }

+    }

+}

+

+// NANDReadAsync wrapper that first calls NANDSeekAsync

+BOOL gUnkClass4::func_801DD220(gUnkClass5* fp, void*, u32, s32 offset) const

+{

+    if (!fp->unk1)

+        return FALSE;

+    gUnkClass6* r31 = fp->unk40;

+    NANDSetUserData(&r31->block, fp);

+    return NANDSeekAsync(&r31->unk48, offset, 0, &func_801DD174, &r31->block) == 0;

+}

+

+// copy <fileName> from the DVD to /tmp/<fileName> in NAND

+BOOL gUnkClass4::func_801DD294(const char *fileName, s32)

+{

+    gUnkClass6 *r29; 

+    NANDFileInfo nandInfo;

+    gUnkClass5 *fp;

+    size_t i;

+    void *buffer;

+    BOOL flag;

+    s32 currOffset;

+    size_t maxLength;

+

+    if (func_801DCEB4(fileName))

+        return TRUE;

+

+    for (i = 0; i < ArrLength_; i++) {

+        r29 = arr_ + i;

+        if (!arr_[i].unk0) {

+            r29 = arr_ + i;

+            break;

+        }

+    }

+

+    if (!r29)

+        return FALSE;

+

+    // Ensure that fileName exists on the DVD, then open it

+    if (!func_801DC380(fileName))

+        return FALSE;    

+    fp = func_801DC2D0(fileName);

+    if (!fp)

+        return FALSE;

+

+    size_t fileSz = (func_801DC760(fp) + 0x1F) & (~0x1F);

+    if (0 == fileSz)

+        return FALSE;

+

+    buffer = func_801DAC94(lbl_8063E8EC, 0x200000);

+    if (!buffer)

+        return FALSE;

+

+    r29->unk0 = 1;

+    r29->unk1 = 1;

+    strcpy(r29->unk2, "/tmp/");

+    strncat(r29->unk2, fileName, 12);

+    flag = FALSE;

+    s32 createResult = NANDCreate(r29->unk2, 0x30, 0);

+    if (createResult == 0 || createResult == -6) {

+        if (NANDOpen(r29->unk2, &nandInfo, 3) == 0) {

+            currOffset = 0;

+            maxLength = 0x200000;

+            size_t length;

+            do {

+                length = (fileSz < maxLength) ? (fileSz) : (maxLength);

+                s32 readResult = func_801DC5FC(fp, buffer, (s32)length, currOffset, 2);

+                if (readResult < 0) {

+                    if (readResult == -1) {

+                        while (TRUE)

+                            func_80224588(lbl_8063F600);

+                    }

+                    func_801DAD48(lbl_8063E8EC, buffer);

+                    func_801DC6C4(fp);

+                    return FALSE;

+                }

+                s32 bytesWritten = NANDWrite(&nandInfo, buffer, length);

+                if (bytesWritten != ((s32) length)) {

+                    NANDClose(&nandInfo);

+                    break;

+                }

+                currOffset += length;

+            } while ((fileSz -= length) != 0);

+            if (NANDClose(&nandInfo) == 0) {

+                flag = TRUE;

+                r29->unk1 = 0;

+            }

+        }

+    }

+

+    if (buffer)

+        func_801DAD48(lbl_8063E8EC, buffer);

+

+    func_801DC6C4(fp);

+    if (flag) {

+        r29->unk1 = 0;

+        return TRUE;

+    } else {

+        r29->unk0 = 0;

+        return TRUE;

+    }

+}