JKRFileLoader, JKRFileFinder, and JKRThread (#60)

* JKRFileLoader OK

* JKRFileFinder progress

* JKRFileFinder OK

* JKRFileCache fix virtual function signatures

* added OSThread and OSContext types

* JKRThread fixed nonmatching functions

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

include/JSystem/JKernel/JKRArchive/JKRArchive.h

@@ -8,7 +8,16 @@ class JKRHeap;
 class JKRDvdFile;
 class JKRArchive : public JKRFileLoader {
 public:
-    class SDirEntry {};
+    struct SDirEntry {
+        u8 type_flags;
+        u8 field_0x1;
+        u16 id;
+        char* name;
+        u16 field_0x8;
+        u16 num_entries;
+        s32 first_file_index;
+    };
+
     class SDIFileEntry {};
 
     enum EMountMode {
@@ -73,13 +82,13 @@ public:
 
 public:
     /* vt[04] */ virtual void becomeCurrent(char const*);                 /* override */
-    /* vt[05] */ virtual void getResource(char const*);                   /* override */
-    /* vt[06] */ virtual void getResource(u32, char const*);              /* override */
+    /* vt[05] */ virtual void* getResource(char const*);                  /* override */
+    /* vt[06] */ virtual void* getResource(u32, char const*);             /* override */
     /* vt[07] */ virtual void readResource(void*, u32, char const*);      /* override */
     /* vt[08] */ virtual void readResource(void*, u32, u32, char const*); /* override */
     /* vt[09] */ virtual void removeResourceAll(void);                    /* override */
-    /* vt[10] */ virtual void removeResource(void*);                      /* override */
-    /* vt[11] */ virtual void detachResource(void*);                      /* override */
+    /* vt[10] */ virtual bool removeResource(void*);                      /* override */
+    /* vt[11] */ virtual bool detachResource(void*);                      /* override */
     /* vt[12] */ virtual void getResSize(void const*) const;              /* override */
     /* vt[13] */ virtual void countFile(char const*) const;               /* override */
     /* vt[14] */ virtual void getFirstFile(char const*) const;            /* override */

include/JSystem/JKernel/JKRCompArchive/JKRCompArchive.h

@@ -12,7 +12,7 @@ public:
     void open(long);
 
     /* vt[09] */ void removeResourceAll(void); /* override */
-    /* vt[10] */ void removeResource(void*);   /* override */
+    /* vt[10] */ bool removeResource(void*);   /* override */
 
     /* vt[15] */ void getExpandedResSize(void const*) const;                      /* override */
     /* vt[16] */ void fetchResource(JKRArchive::SDIFileEntry*, u32*);             /* override */

include/JSystem/JKernel/JKRFileCache/JKRFileCache.h

@@ -31,13 +31,13 @@ protected:
 
 public:
     /* vt[04] */ virtual void becomeCurrent(char const*);                 /* override */
-    /* vt[05] */ virtual void getResource(char const*);                   /* override */
-    /* vt[06] */ virtual void getResource(u32, char const*);              /* override */
+    /* vt[05] */ virtual void* getResource(char const*);                  /* override */
+    /* vt[06] */ virtual void* getResource(u32, char const*);             /* override */
     /* vt[07] */ virtual void readResource(void*, u32, char const*);      /* override */
     /* vt[08] */ virtual void readResource(void*, u32, u32, char const*); /* override */
     /* vt[09] */ virtual void removeResourceAll(void);                    /* override */
-    /* vt[10] */ virtual void removeResource(void*);                      /* override */
-    /* vt[11] */ virtual void detachResource(void*);                      /* override */
+    /* vt[10] */ virtual bool removeResource(void*);                      /* override */
+    /* vt[11] */ virtual bool detachResource(void*);                      /* override */
     /* vt[12] */ virtual void getResSize(void const*) const;              /* override */
     /* vt[13] */ virtual void countFile(char const*) const;               /* override */
     /* vt[14] */ virtual void getFirstFile(char const*) const;            /* override */

include/JSystem/JKernel/JKRFileFinder/JKRFileFinder.h

@@ -2,28 +2,36 @@
 #define __JKRFILEFINDER_H__
 
 #include "dolphin/types.h"
+#include "dvd/dvd.h"
 
 struct JKRFileFinder_UnknownBase {
-    u32 field_0x0;
-    u32 field_0x4;
-    u16 field_0x8;
-    u16 field_0xa;
+    const char* mEntryName;
+    s32 mEntryFileIndex;
+    u16 mEntryId;
+    u16 mEntryTypeFlags;
 };
 
-class JKRFileFinder : JKRFileFinder_UnknownBase {
+class JKRFileFinder : public JKRFileFinder_UnknownBase {
 public:
-    JKRFileFinder();
+    JKRFileFinder() {
+        mIsAvailable = false;
+        mIsFileOrDirectory = false;
+    }
     virtual ~JKRFileFinder();
 
-    bool isAvailable() { return this->mIsAvailable; }
+    bool isAvailable() const { return mIsAvailable; }
+    bool isFile() const { return mIsFileOrDirectory; }
+    bool isDirectory() const { return mIsFileOrDirectory; }
 
 public:
     /* vt[3] */ virtual bool findNextFile(void) = 0;
 
-private:
-    bool mIsAvailable;
-    bool field_0x11;
-    u8 padding_0x12[2];
+protected:
+    /* 0x00 */  // JKRFileFinder_UnknownBase
+    /* 0x0C */  // vtable
+    /* 0x10 */ bool mIsAvailable;
+    /* 0x11 */ bool mIsFileOrDirectory;
+    /* 0x12 */ u8 field_0x12[2];
 };
 
 class JKRArchive;
@@ -36,24 +44,30 @@ public:
     /* vt[3] */ virtual bool findNextFile(void); /* override */
 
 private:
-    JKRArchive* mArchive;
-    u32 field_0x18;
-    u32 field_0x1c;
-    u32 field_0x20;
+    /* 0x00 */  // JKRFileFinder_UnknownBase
+    /* 0x0C */  // vtable
+    /* 0x10 */  // JKRFileFinder
+    /* 0x14 */ JKRArchive* mArchive;
+    /* 0x18 */ s32 mStartIndex;
+    /* 0x1C */ s32 mEndIndex;
+    /* 0x20 */ s32 mNextIndex;
 };
 
 class JKRDvdFinder : public JKRFileFinder {
 public:
-    JKRDvdFinder(char const*);
+    JKRDvdFinder(const char*);
     virtual ~JKRDvdFinder();
 
 public:
     /* vt[3] */ virtual bool findNextFile(void); /* override */
 
 private:
-    u8 mDvd[12];
-    bool mDvdIsOpen;
-    u8 padding_0x21[3];
+    /* 0x00 */  // JKRFileFinder_UnknownBase
+    /* 0x0C */  // vtable
+    /* 0x10 */  // JKRFileFinder
+    /* 0x14 */ DVDDirectory mDvdDirectory;
+    /* 0x20 */ bool mDvdIsOpen;
+    /* 0x21 */ u8 field_0x21[3];
 };
 
 #endif

include/JSystem/JKernel/JKRFileLoader/JKRFileLoader.h

@@ -9,31 +9,33 @@ public:
     JKRFileLoader(void);
     virtual ~JKRFileLoader();
 
-    bool isMounted() { return this->mIsMounted; }
+    bool isMounted() const { return this->mIsMounted; }
 
-    u32 getVolumeType() { return this->mVolumeType; }
+    u32 getVolumeType() const { return this->mVolumeType; }
 
 public:
     /* vt[03] */ virtual void unmount(void);
     /* vt[04] */ virtual void becomeCurrent(char const*) = 0;
-    /* vt[05] */ virtual void getResource(char const*) = 0;
-    /* vt[06] */ virtual void getResource(u32, char const*) = 0;
+    /* vt[05] */ virtual void* getResource(char const*) = 0;
+    /* vt[06] */ virtual void* getResource(u32, char const*) = 0;
     /* vt[07] */ virtual void readResource(void*, u32, char const*) = 0;
     /* vt[08] */ virtual void readResource(void*, u32, u32, char const*) = 0;
     /* vt[09] */ virtual void removeResourceAll(void) = 0;
-    /* vt[10] */ virtual void removeResource(void*) = 0;
-    /* vt[11] */ virtual void detachResource(void*) = 0;
+    /* vt[10] */ virtual bool removeResource(void*) = 0;
+    /* vt[11] */ virtual bool detachResource(void*) = 0;
     /* vt[12] */ virtual void getResSize(void const*) const = 0;
     /* vt[13] */ virtual void countFile(char const*) const = 0;
     /* vt[14] */ virtual void getFirstFile(char const*) const = 0;
 
 private:
-    JSULink<JKRFileLoader> mFileLoaderLink;
-    char* mVolumeName;
-    u32 mVolumeType;
-    bool mIsMounted;
-    u8 padding_0x31[3];
-    int mMountCount;
+    /* 0x00 */  // vtable
+    /* 0x04 */  // JKRDisposer
+    /* 0x18 */ JSULink<JKRFileLoader> mFileLoaderLink;
+    /* 0x28 */ char* mVolumeName;
+    /* 0x2C */ u32 mVolumeType;
+    /* 0x30 */ bool mIsMounted;
+    /* 0x31 */ u8 field_0x31[3];
+    /* 0x34 */ u32 mMountCount;
 
 public:
     static void* getGlbResource(char const*);
@@ -41,7 +43,7 @@ public:
     static bool removeResource(void*, JKRFileLoader*);
     static bool detachResource(void*, JKRFileLoader*);
     static JKRFileLoader* findVolume(char const**);
-    static char* fetchVolumeName(char*, long, char const*);
+    static const char* fetchVolumeName(char*, long, char const*);
 };
 
 #endif

include/JSystem/JKernel/JKRHeap/JKRHeap.h

@@ -156,4 +156,12 @@ inline void* JKRAllocFromHeap(JKRHeap* heap, u32 size, int alignment) {
     return JKRHeap::alloc(size, alignment, heap);
 }
 
+inline void JKRFreeToHeap(JKRHeap* heap, void* ptr) {
+    JKRHeap::free(ptr, heap);
+}
+
+inline void JKRFree(void* ptr) {
+    JKRHeap::free(ptr, NULL);
+}
+
 #endif

include/JSystem/JKernel/JKRMemArchive/JKRMemArchive.h

@@ -18,7 +18,7 @@ public:
     void open(void*, u32, JKRMemBreakFlag);
 
     /* vt[09] */ void removeResourceAll(void); /* override */
-    /* vt[10] */ void removeResource(void*);   /* override */
+    /* vt[10] */ bool removeResource(void*);   /* override */
 
     /* vt[15] */ void getExpandedResSize(void const*) const;                      /* override */
     /* vt[16] */ void fetchResource(JKRArchive::SDIFileEntry*, u32*);             /* override */

include/dvd/dvd.h

@@ -20,6 +20,18 @@ typedef enum DVDState {
 } DVDState;
 }
 
+struct DVDDirectory {
+    u32 entry_number;
+    u32 location;
+    u32 next;
+};
+
+struct DVDDirectoryEntry {
+    u32 entry_number;
+    BOOL is_directory;
+    char* name;
+};
+
 struct DVDDiskID {
     char game_name[4];
     char company[2];
@@ -70,9 +82,9 @@ DVDState DVDGetDriveStatus(void);
 s32 DVDCheckDisk(void);
 
 void DVDChangeDir(void);
-void DVDCloseDir(void);
-void DVDOpenDir(void);
-void DVDReadDir(void);
+BOOL DVDCloseDir(DVDDirectory*);
+BOOL DVDOpenDir(const char*, DVDDirectory*);
+BOOL DVDReadDir(DVDDirectory*, DVDDirectoryEntry*);
 }
 
 #endif

include/functions.h

@@ -30,7 +30,7 @@ void dComIfGp_setSelectItem(int);
 void getUsedCount__9HeapCheckCFv(void);
 void isEventBit__11dSv_event_cCFUs(void);
 char* strcpy(char*, const char*);
-int strcmp(char*, char*);
+int strcmp(const char*, const char*);
 void setBombNum__21dSv_player_item_max_cFUcUc(void);
 void func_803620AC(void);
 void func_803626BC(void);
@@ -241,7 +241,7 @@ void dComIfGs_setMixItemIndex(int, u8);
 void dComIfGs_setSelectItemIndex(int, u8);
 u8 dComIfGs_getMixItemIndex(int);
 char* strcpy(char*, const char*);
-int strcmp(char*, char*);
+int strcmp(const char*, const char*);
 void setBombNum__21dSv_player_item_max_cFUcUc(void);
 void func_803620AC(void);
 void func_803626BC(void);

include/os/OS.h

@@ -6,14 +6,12 @@
 
 #include "dolphin/types.h"
 
-#define OS_MESSAGE_NON_BLOCKING 0
-#define OS_MESSAGE_BLOCKING 1
-
 /* TODO: more structs, and get rid of the ones that are faked! */
 
 #define OS_MESSAGE_NON_BLOCKING 0
 #define OS_MESSAGE_BLOCKING 1
 
+struct OSThread;
 struct OSMutex {
     u8 unk[24];
 };
@@ -28,8 +26,22 @@ struct OSMutexQueue {
     struct OSMutex* next;
 };
 
-struct OSThread {
-    u8 unk[792];
+struct OSContext {
+    u32 gpr[32];
+    u32 cr;
+    u32 lr;
+    u32 ctr;
+    u32 xer;
+    double fpr[32];
+    u32 padding_1;
+    u32 fpscr;
+    u32 srr0;
+    u32 srr1;
+    u16 mode;
+    u16 state;
+    u32 gqr[8];
+    u32 padding_2;
+    double ps[32];
 };
 
 typedef void (*OSSwitchThreadCallback)(OSThread* from, OSThread* to);
@@ -85,6 +97,33 @@ typedef enum OSSoundMode {
     __SOUND_MODE_FORCE_ENUM_U32 = 0xffffffff,
 } OSSoundMode;
 
+typedef u16 OSThreadState;
+#define OS_THREAD_STATE_UNINITIALIZED 0
+#define OS_THREAD_STATE_READY 1
+#define OS_THREAD_STATE_RUNNING 2
+#define OS_THREAD_STATE_WAITING 4
+#define OS_THREAD_STATE_DEAD 8
+
+struct OSThread {
+    OSContext context;
+    OSThreadState state;
+    u16 attributes;
+    s32 suspend_count;
+    u32 effective_priority;
+    u32 base_priority;
+    void* exit_value;
+    OSThreadQueue* queue;
+    OSThreadLink link;
+    OSThreadQueue join_queue;
+    OSMutex* mutex;
+    OSMutexQueue owned_mutexes;
+    OSThreadLink active_threads_link;
+    u8* stack_base;
+    u8* stack_end;
+    u8* error_code;
+    void* data[2];
+};
+
 extern "C" {
 s32 OSEnableScheduler(void);
 s32 OSDisableScheduler(void);
@@ -101,7 +140,7 @@ void OSDetachThread(OSThread* thread);
 s32 OSResumeThread(OSThread* thread);
 void OSExitThread(void* exit_val);
 bool OSIsThreadSuspended(OSThread* thread);
-bool OSIsThreadTerminated(OSThread* thread);
+BOOL OSIsThreadTerminated(OSThread* thread);
 OSSwitchThreadCallback OSSetSwitchThreadCallback(OSSwitchThreadCallback* callback);
 
 void OSInitMessageQueue(OSMessageQueue* queue, OSMessage* messages, int message_count);

include/variables.h

@@ -220,11 +220,11 @@ extern JSUList<JKRFileLoader> lbl_80434354;  // JKRFileLoader::sVolumeList
 extern u8 lbl_803CC218;                      // JKRArcFinder::__vt
 extern u8 lbl_803CC228;                      // JKRFileFinder::__vt
 extern u8 lbl_803CC208;                      // JKRDvdFinder::__vt
-extern u8 lbl_8039D150;                      // "/"
+extern const char lbl_8039D150[16];          // "/"
 extern u8 lbl_803CC1C8;                      // JKRFileLoader::__vt
-extern u8 lbl_804508C0;                      // "/" JKernel::rootPath$2498
+extern const char lbl_804508C0[16];          // "/" JKernel::rootPath$2498
 extern u8 lbl_80434348;                      // JKernel::@2182 (global destructor chain)
-extern u8 lbl_803D2D18[256];                 // MSL_C.PPCEABI.bare.H::__lower_map
+extern const char lbl_803D2D18[256];         // MSL_C.PPCEABI.bare.H::__lower_map
 extern u8 lbl_803CC090;                      // JKRAssertHeap::__vt
 extern u8 lbl_80451398;                      // JKernel::DBfoundSize
 extern u8 lbl_8045139C;                      // JKernel::DBfoundOffset

libs/JSystem/JKernel/JKRArchivePub.cpp

@@ -38,12 +38,12 @@ asm void JKRArchive::getGlbResource(u32, char const*, JKRArchive*) {
 #include "JSystem/JKernel/JKRArchive/asm/func_802D5B38.s"
 }
 
-asm void JKRArchive::getResource(char const*) {
+asm void* JKRArchive::getResource(char const*) {
     nofralloc
 #include "JSystem/JKernel/JKRArchive/asm/func_802D5BE8.s"
 }
 
-asm void JKRArchive::getResource(u32, char const*) {
+asm void* JKRArchive::getResource(u32, char const*) {
     nofralloc
 #include "JSystem/JKernel/JKRArchive/asm/func_802D5C64.s"
 }
@@ -83,12 +83,12 @@ asm void JKRArchive::removeResourceAll(void) {
 #include "JSystem/JKernel/JKRArchive/asm/func_802D5FB4.s"
 }
 
-asm void JKRArchive::removeResource(void*) {
+asm bool JKRArchive::removeResource(void*) {
     nofralloc
 #include "JSystem/JKernel/JKRArchive/asm/func_802D603C.s"
 }
 
-asm void JKRArchive::detachResource(void*) {
+asm bool JKRArchive::detachResource(void*) {
     nofralloc
 #include "JSystem/JKernel/JKRArchive/asm/func_802D609C.s"
 }

libs/JSystem/JKernel/JKRCompArchive.cpp

@@ -31,7 +31,7 @@ asm void JKRCompArchive::removeResourceAll(void) {
 #include "JSystem/JKernel/JKRCompArchive/asm/func_802D9260.s"
 }
 
-asm void JKRCompArchive::removeResource(void*) {
+asm bool JKRCompArchive::removeResource(void*) {
     nofralloc
 #include "JSystem/JKernel/JKRCompArchive/asm/func_802D92F4.s"
 }

libs/JSystem/JKernel/JKRFileCache.cpp

@@ -22,12 +22,12 @@ asm void JKRFileCache::becomeCurrent(char const*) {
 #include "JSystem/JKernel/JKRFileCache/asm/func_802D4D44.s"
 }
 
-asm void JKRFileCache::getResource(char const*) {
+asm void* JKRFileCache::getResource(char const*) {
     nofralloc
 #include "JSystem/JKernel/JKRFileCache/asm/func_802D4DD8.s"
 }
 
-asm void JKRFileCache::getResource(unsigned long, char const*) {
+asm void* JKRFileCache::getResource(unsigned long, char const*) {
     nofralloc
 #include "JSystem/JKernel/JKRFileCache/asm/func_802D4EDC.s"
 }
@@ -47,12 +47,12 @@ asm void JKRFileCache::removeResourceAll(void) {
 #include "JSystem/JKernel/JKRFileCache/asm/func_802D50D4.s"
 }
 
-asm void JKRFileCache::removeResource(void*) {
+asm bool JKRFileCache::removeResource(void*) {
     nofralloc
 #include "JSystem/JKernel/JKRFileCache/asm/func_802D5164.s"
 }
 
-asm void JKRFileCache::detachResource(void*) {
+asm bool JKRFileCache::detachResource(void*) {
     nofralloc
 #include "JSystem/JKernel/JKRFileCache/asm/func_802D51F8.s"
 }

libs/JSystem/JKernel/JKRFileFinder.cpp

@@ -1,38 +1,96 @@
 #include "JSystem/JKernel/JKRFileFinder/JKRFileFinder.h"
+#include "JSystem/JKernel/JKRArchive/JKRArchive.h"
 #include "dvd/dvd.h"
 #include "global.h"
 
-asm JKRArcFinder::JKRArcFinder(JKRArchive*, long, long) {
-    nofralloc
-#include "JSystem/JKernel/JKRFileFinder/asm/func_802D4638.s"
+JKRArcFinder::JKRArcFinder(JKRArchive* archive, long startIndex, long numEntries)
+    : JKRFileFinder() {
+    mArchive = archive;
+    mIsAvailable = numEntries > 0;
+    mStartIndex = startIndex;
+    mEndIndex = startIndex + numEntries - 1;
+    mNextIndex = mStartIndex;
+    findNextFile();
 }
 
-asm bool JKRArcFinder::findNextFile(void) {
-    nofralloc
-#include "JSystem/JKernel/JKRFileFinder/asm/func_802D46C4.s"
+bool JKRArcFinder::findNextFile(void) {
+    JKRArchive::SDirEntry entry;
+
+    if (mIsAvailable) {
+        mIsAvailable = !(mNextIndex > mEndIndex);
+        if (mIsAvailable) {
+            mIsAvailable = mArchive->getDirEntry(&entry, mNextIndex);
+            mEntryName = entry.name;
+            mEntryFileIndex = mNextIndex;
+            mEntryId = entry.id;
+            mEntryTypeFlags = entry.type_flags;
+            mIsFileOrDirectory = (mEntryTypeFlags >> 1) & 1;
+            mNextIndex++;
+        }
+    }
+    return mIsAvailable;
 }
 
-asm JKRDvdFinder::JKRDvdFinder(char const*) {
-    nofralloc
-#include "JSystem/JKernel/JKRFileFinder/asm/func_802D4770.s"
+JKRDvdFinder::JKRDvdFinder(const char* directory) : JKRFileFinder() {
+    mDvdIsOpen = DVDOpenDir(directory, &mDvdDirectory);
+    mIsAvailable = mDvdIsOpen;
+    findNextFile();
 }
 
+// JKRFileFinder::~JKRFileFinder is not inlined
+#ifdef NONMATCHING
+JKRDvdFinder::~JKRDvdFinder() {
+    if (mDvdIsOpen) {
+        DVDCloseDir(&mDvdDirectory);
+    }
+}
+#else
 asm JKRDvdFinder::~JKRDvdFinder() {
     nofralloc
 #include "JSystem/JKernel/JKRFileFinder/asm/func_802D47F4.s"
 }
+#endif
 
+// everything matches except:
+//       u16 flags = 1;
+//       if(mIsFileOrDirectory) flags = 2;
+//       mEntryTypeFlags = flags;
+#ifdef NONMATCHING
+bool JKRDvdFinder::findNextFile(void) {
+    if (mIsAvailable) {
+        DVDDirectoryEntry directoryEntry;
+        mIsAvailable = DVDReadDir(&mDvdDirectory, &directoryEntry);
+
+        if (mIsAvailable) {
+            mIsFileOrDirectory = directoryEntry.is_directory != 0;
+            mEntryName = directoryEntry.name;
+            mEntryFileIndex = directoryEntry.entry_number;
+            mEntryId = 0;
+
+            u16 flags = 1;
+            if (mIsFileOrDirectory)
+                flags = 2;
+            mEntryTypeFlags = flags;
+        }
+    }
+
+    return mIsAvailable;
+}
+#else
 asm bool JKRDvdFinder::findNextFile(void) {
     nofralloc
 #include "JSystem/JKernel/JKRFileFinder/asm/func_802D4874.s"
 }
+#endif
 
-asm JKRFileFinder::~JKRFileFinder() {
-    nofralloc
-#include "JSystem/JKernel/JKRFileFinder/asm/func_802D4910.s"
-}
+JKRFileFinder::~JKRFileFinder() {}
 
+// JKRFileFinder::~JKRFileFinder is not inlined (same problem as with JKRDvdFinder::~JKRDvdFinder)
+#ifdef NONMATCHING
+JKRArcFinder::~JKRArcFinder() {}
+#else
 asm JKRArcFinder::~JKRArcFinder() {
     nofralloc
 #include "JSystem/JKernel/JKRFileFinder/asm/func_802D4958.s"
 }
+#endif

libs/JSystem/JKernel/JKRFileLoader.cpp

@@ -1,47 +1,157 @@
 #include "JSystem/JKernel/JKRFileLoader/JKRFileLoader.h"
 #include "global.h"
 
-asm JKRFileLoader::JKRFileLoader(void) {
-    nofralloc
-#include "JSystem/JKernel/JKRFileLoader/asm/func_802D40F0.s"
+JKRFileLoader::JKRFileLoader(void) : mFileLoaderLink(this) {
+    mVolumeName = NULL;
+    mVolumeType = 0;
+    mMountCount = 0;
 }
 
-asm JKRFileLoader::~JKRFileLoader() {
-    nofralloc
-#include "JSystem/JKernel/JKRFileLoader/asm/func_802D4148.s"
+JKRFileLoader::~JKRFileLoader() {
+    // lbl_80451418 = JKRFileLoader::sCurrentVolume
+    if (lbl_80451418 == this) {
+        lbl_80451418 = NULL;
+    }
 }
 
-asm void JKRFileLoader::unmount(void) {
-    nofralloc
-#include "JSystem/JKernel/JKRFileLoader/asm/func_802D41D4.s"
+void JKRFileLoader::unmount(void) {
+    s32 count = mMountCount;
+    if (mMountCount != 0) {
+        count--;
+        mMountCount = count;
+        if (count == 0) {
+            delete this;
+        }
+    }
 }
 
-asm void* JKRFileLoader::getGlbResource(char const*) {
-    nofralloc
-#include "JSystem/JKernel/JKRFileLoader/asm/func_802D4224.s"
+void* JKRFileLoader::getGlbResource(const char* name) {
+    const char* name_reference[1];
+    name_reference[0] = name;
+
+    JKRFileLoader* fileLoader = findVolume(name_reference);
+    void* resource;
+    if (fileLoader == NULL) {
+        resource = NULL;
+    } else {
+        resource = fileLoader->getResource(name_reference[0]);
+    }
+
+    return resource;
 }
 
-asm void* JKRFileLoader::getGlbResource(char const*, JKRFileLoader*) {
-    nofralloc
-#include "JSystem/JKernel/JKRFileLoader/asm/func_802D4270.s"
+void* JKRFileLoader::getGlbResource(const char* name, JKRFileLoader* fileLoader) {
+    // lbl_80434354 = JKRFileLoader::sVolumeList
+
+    void* resource = NULL;
+    if (fileLoader) {
+        return fileLoader->getResource(0, name);
+    }
+
+    JSUListIterator<JKRFileLoader> iterator;
+    for (iterator = lbl_80434354.getFirst(); iterator != lbl_80434354.getEnd(); ++iterator) {
+        resource = iterator->getResource(0, name);
+        if (resource)
+            break;
+    }
+    return resource;
 }
 
-asm bool JKRFileLoader::removeResource(void*, JKRFileLoader*) {
-    nofralloc
-#include "JSystem/JKernel/JKRFileLoader/asm/func_802D4308.s"
+bool JKRFileLoader::removeResource(void* resource, JKRFileLoader* fileLoader) {
+    // lbl_80434354 = JKRFileLoader::sVolumeList
+
+    if (fileLoader) {
+        return fileLoader->removeResource(resource);
+    }
+
+    JSUListIterator<JKRFileLoader> iterator;
+    for (iterator = lbl_80434354.getFirst(); iterator != lbl_80434354.getEnd(); ++iterator) {
+        if (iterator->removeResource(resource)) {
+            return true;
+        }
+    }
+
+    return false;
 }
 
-asm bool JKRFileLoader::detachResource(void*, JKRFileLoader*) {
-    nofralloc
-#include "JSystem/JKernel/JKRFileLoader/asm/func_802D43A0.s"
+bool JKRFileLoader::detachResource(void* resource, JKRFileLoader* fileLoader) {
+    // lbl_80434354 = JKRFileLoader::sVolumeList
+
+    if (fileLoader) {
+        return fileLoader->detachResource(resource);
+    }
+
+    JSUListIterator<JKRFileLoader> iterator;
+    for (iterator = lbl_80434354.getFirst(); iterator != lbl_80434354.getEnd(); ++iterator) {
+        if (iterator->detachResource(resource)) {
+            return true;
+        }
+    }
+
+    return false;
 }
 
-asm JKRFileLoader* JKRFileLoader::findVolume(char const**) {
-    nofralloc
-#include "JSystem/JKernel/JKRFileLoader/asm/func_802D4438.s"
+JKRFileLoader* JKRFileLoader::findVolume(const char** volumeName) {
+    // lbl_80451418 = JKRFileLoader::sCurrentVolume
+
+    if (*volumeName[0] != '/') {
+        return lbl_80451418;
+    }
+
+    char volumeNameBuffer[0x101];
+    *volumeName = fetchVolumeName(volumeNameBuffer, ARRAY_SIZE(volumeNameBuffer), *volumeName);
+
+    JSUListIterator<JKRFileLoader> iterator;
+    for (iterator = lbl_80434354.getFirst(); iterator != lbl_80434354.getEnd(); ++iterator) {
+        if (strcmp(volumeNameBuffer, iterator->mVolumeName) == 0) {
+            return iterator.getObject();
+        }
+    }
+
+    return NULL;
 }
 
-asm char* JKRFileLoader::fetchVolumeName(char*, long, char const*) {
+// matches, but lbl_804508C0 is accessed through r13
+#ifdef NONMATCHING
+const char* JKRFileLoader::fetchVolumeName(char* buffer, long bufferSize, const char* path) {
+    // lbl_803D2D18 = MSL_C.PPCEABI.bare.H::__lower_map
+    // lbl_8039D150 = JKernel::@stringBase0 "/"
+    // lbl_804508C0 = JKernel::rootPath$2498 "/"
+    // lbl_803D2D18 = MSL_C.PPCEABI.bare.H::__lower_map
+
+    if (strcmp(path, lbl_8039D150) == 0) {
+        strcpy(buffer, lbl_804508C0);
+        return lbl_804508C0;
+    }
+
+    path++;
+    while (*path != 0 && *path != '/') {
+        if (1 < bufferSize) {
+            u8 lower_char;
+            int ch = (int)*path;
+            if (ch == -1) {
+                lower_char = -1;
+            } else {
+                lower_char = lbl_803D2D18[ch & 0xFF];
+            }
+
+            *buffer = lower_char;
+            buffer++;
+            bufferSize--;
+        }
+        path++;
+    }
+
+    *buffer = '\0';
+    if (*path == '\0') {
+        path = lbl_804508C0;
+    }
+
+    return path;
+}
+#else
+asm const char* JKRFileLoader::fetchVolumeName(char* buffer, long bufferSize, const char* path) {
     nofralloc
 #include "JSystem/JKernel/JKRFileLoader/asm/func_802D44C4.s"
-}
+}
+#endif

libs/JSystem/JKernel/JKRMemArchive.cpp

@@ -41,7 +41,7 @@ asm void JKRMemArchive::removeResourceAll(void) {
 #include "JSystem/JKernel/JKRMemArchive/asm/func_802D6ED0.s"
 }
 
-asm void JKRMemArchive::removeResource(void*) {
+asm bool JKRMemArchive::removeResource(void*) {
     nofralloc
 #include "JSystem/JKernel/JKRMemArchive/asm/func_802D6F20.s"
 }

libs/JSystem/JKernel/JKRThread.cpp

@@ -34,14 +34,34 @@ JKRThread::JKRThread(JKRHeap* heap, u32 stack_size, int message_count, int param
     setCommon_mesgQueue(mHeap, message_count);
 }
 
-asm JKRThread::JKRThread(OSThread* thread, int message_count) {
-    nofralloc
-#include "JSystem/JKernel/JKRThread/asm/func_802D16B8.s"
+JKRThread::JKRThread(OSThread* thread, int message_count) : mThreadListLink(this) {
+    mSwitchCount = 0;
+    mCost = 0;
+    field_0x6c = 0;
+    field_0x60 = 0;
+    field_0x70 = 0;
+    mHeap = NULL;
+    mThreadRecord = thread;
+    mStackSize = (u32)thread->stack_end - (u32)thread->stack_base;
+    mStackMemory = thread->stack_base;
+
+    setCommon_mesgQueue(JKRHeap::getSystemHeap(), message_count);
 }
 
-asm JKRThread::~JKRThread() {
-    nofralloc
-#include "JSystem/JKernel/JKRThread/asm/func_802D1758.s"
+JKRThread::~JKRThread() {
+    // lbl_8043428C = JKRThread::sThreadList
+    lbl_8043428C.remove(&mThreadListLink);
+
+    if (mHeap) {
+        BOOL result = OSIsThreadTerminated(mThreadRecord);
+        if (result == FALSE) {
+            OSDetachThread(mThreadRecord);
+            OSCancelThread(mThreadRecord);
+        }
+        JKRFreeToHeap(mHeap, mStackMemory);
+        JKRFreeToHeap(mHeap, mThreadRecord);
+    }
+    JKRFree(mMessages);
 }
 
 void JKRThread::setCommon_mesgQueue(JKRHeap* heap, int message_count) {
@@ -70,25 +90,17 @@ void* JKRThread::start(void* param) {
     return thread->run();
 }
 
-#ifdef NONMATCHING
 JKRThread* JKRThread::searchThread(OSThread* thread) {
     JSUList<JKRThread>* threadList = JKRThread::getList();
     JSUListIterator<JKRThread> iterator;
-    for (iterator = threadList; iterator != threadList->getEnd(); iterator++) {
-        JKRThread* jkrThread = iterator.getObject();
-        if (jkrThread->mThreadRecord == thread) {
-            return jkrThread;
+    for (iterator = threadList; iterator != threadList->getEnd(); ++iterator) {
+        if (iterator->getThreadRecord() == thread) {
+            return iterator.getObject();
         }
     }
 
     return NULL;
 }
-#else
-asm JKRThread* JKRThread::searchThread(OSThread* thread) {
-    nofralloc
-#include "JSystem/JKernel/JKRThread/asm/func_802D1960.s"
-}
-#endif
 
 //
 //