Merge remote-tracking branch 'upstream/main'

1 files changed, 297 insertions, 44 deletions

diff --git a/src/JSystem/JKernel/JKRArchivePub.cpp b/src/JSystem/JKernel/JKRArchivePub.cpp
index edcaf067..f080e84a 100644
--- a/src/JSystem/JKernel/JKRArchivePub.cpp
+++ b/src/JSystem/JKernel/JKRArchivePub.cpp
@@ -3,115 +3,368 @@
 // Translation Unit: JKRArchivePub.cpp
 //
 
-#include "JSystem/JKernel/JKRArchivePub.h"
-#include "dolphin/types.h"
+#include "JSystem/JKernel/JKRArchive.h"
+#include "JSystem/JKernel/JKRAramArchive.h"
+#include "JSystem/JKernel/JKRCompArchive.h"
+#include "JSystem/JKernel/JKRDvdArchive.h"
+#include "JSystem/JKernel/JKRFileFinder.h"
+#include "JSystem/JKernel/JKRHeap.h"
+#include "JSystem/JKernel/JKRMemArchive.h"
+#include "JSystem/JUtility/JUTAssert.h"
+#include "dolphin/dvd/dvd.h"
 
 /* 802B7FB4-802B8008       .text check_mount_already__10JKRArchiveFl */
-void JKRArchive::check_mount_already(long) {
-    /* Nonmatching */
+JKRArchive* JKRArchive::check_mount_already(s32 entryNum) {
+    JSUList<JKRFileLoader>& volumeList = getVolumeList();
+    JSUListIterator<JKRFileLoader> iterator;
+    for (iterator = volumeList.getFirst(); iterator != volumeList.getEnd(); ++iterator) {
+        if (iterator->getVolumeType() == 'RARC') {
+            JKRArchive* archive = (JKRArchive*)iterator.getObject();
+            if (archive->mEntryNum == entryNum) {
+                archive->mMountCount++;
+                return archive;
+            }
+        }
+    }
+
+    return NULL;
 }
 
 /* 802B8008-802B8064       .text mount__10JKRArchiveFPCcQ210JKRArchive10EMountModeP7JKRHeapQ210JKRArchive15EMountDirection */
-void JKRArchive::mount(const char*, JKRArchive::EMountMode, JKRHeap*, JKRArchive::EMountDirection) {
-    /* Nonmatching */
+JKRArchive* JKRArchive::mount(const char* path, JKRArchive::EMountMode mountMode, JKRHeap* heap, JKRArchive::EMountDirection mountDirection) {
+    s32 entryNum = DVDConvertPathToEntrynum(path);
+    if (entryNum < 0)
+        return NULL;
+
+    return mount(entryNum, mountMode, heap, mountDirection);
 }
 
 /* 802B8064-802B81D0       .text mount__10JKRArchiveFlQ210JKRArchive10EMountModeP7JKRHeapQ210JKRArchive15EMountDirection */
-void JKRArchive::mount(long, JKRArchive::EMountMode, JKRHeap*, JKRArchive::EMountDirection) {
-    /* Nonmatching */
+JKRArchive* JKRArchive::mount(s32 entryNum, JKRArchive::EMountMode mountMode, JKRHeap* heap, JKRArchive::EMountDirection mountDirection) {
+    JKRArchive* archive = check_mount_already(entryNum);
+    if (archive != NULL) {
+        return archive;
+    } else {
+        int alignment;
+        if (mountDirection == JKRArchive::MOUNT_DIRECTION_HEAD) {
+            alignment = 4;
+        } else {
+            alignment = -4;
+        }
+
+        JKRArchive* archive;
+        switch (mountMode) {
+        case JKRArchive::MOUNT_MEM:
+            archive = new (heap, alignment) JKRMemArchive(entryNum, mountDirection);
+            break;
+        case JKRArchive::MOUNT_ARAM:
+            archive = new (heap, alignment) JKRAramArchive(entryNum, mountDirection);
+            break;
+        case JKRArchive::MOUNT_DVD:
+            archive = new (heap, alignment) JKRDvdArchive(entryNum, mountDirection);
+            break;
+        case JKRArchive::MOUNT_COMP:
+            archive = new (heap, alignment) JKRCompArchive(entryNum, mountDirection);
+            break;
+        }
+
+        if (archive && archive->getMountMode() == JKRArchive::UNKNOWN_MOUNT_MODE) {
+            delete archive;
+            archive = NULL;
+        }
+
+        return archive;
+    }
 }
 
 /* 802B81D0-802B8258       .text becomeCurrent__10JKRArchiveFPCc */
-void JKRArchive::becomeCurrent(const char*) {
-    /* Nonmatching */
+bool JKRArchive::becomeCurrent(const char* path) {
+    SDIDirEntry* dirEntry;
+    if (*path == '/') {
+        path++;
+
+        if (*path == '\0')
+            path = NULL;
+        dirEntry = findDirectory(path, 0);
+    } else {
+        dirEntry = findDirectory(path, getCurrentDirID());
+    }
+
+    bool found = dirEntry != NULL;
+    if (found) {
+        setCurrentVolume(this);
+        setCurrentDirID(dirEntry - mNodes);
+    }
+
+    return found;
 }
 
 /* 802B8258-802B82D0       .text getDirEntry__10JKRArchiveCFPQ210JKRArchive9SDirEntryUl */
-void JKRArchive::getDirEntry(JKRArchive::SDirEntry*, unsigned long) const {
-    /* Nonmatching */
+bool JKRArchive::getDirEntry(SDirEntry* dirEntry, u32 index) const {
+    SDIFileEntry* fileEntry = findIdxResource(index);
+    if (!fileEntry) {
+        return false;
+    }
+
+    dirEntry->flags = fileEntry->getFlags();
+    dirEntry->id = fileEntry->getFileID();
+    dirEntry->name = mStringTable + fileEntry->getNameOffset();
+    return true;
 }
 
 /* 802B82D0-802B8380       .text getGlbResource__10JKRArchiveFUlPCcP10JKRArchive */
-void JKRArchive::getGlbResource(unsigned long, const char*, JKRArchive*) {
-    /* Nonmatching */
+void* JKRArchive::getGlbResource(u32 param_0, const char* path, JKRArchive* archive) {
+    void* resource = NULL;
+    if (archive) {
+        return archive->getResource(param_0, path);
+    }
+
+    JSUList<JKRFileLoader>& volumeList = getVolumeList();
+    JSUListIterator<JKRFileLoader> iterator;
+    for (iterator = volumeList.getFirst(); iterator != volumeList.getEnd(); ++iterator) {
+        if (iterator->getVolumeType() == 'RARC') {
+            resource = iterator->getResource(param_0, path);
+            if (resource)
+                break;
+        }
+    }
+
+    return resource;
 }
 
 /* 802B8380-802B8450       .text getResource__10JKRArchiveFPCc */
-void JKRArchive::getResource(const char*) {
-    /* Nonmatching */
+void* JKRArchive::getResource(const char* path) {
+    JUT_ASSERT(285, isMounted());
+    SDIFileEntry* fileEntry;
+    if (*path == '/') {
+        fileEntry = findFsResource(path + 1, 0);
+    } else {
+        fileEntry = findFsResource(path, getCurrentDirID());
+    }
+
+    if (fileEntry) {
+        return fetchResource(fileEntry, NULL);
+    }
+
+    return NULL;
 }
 
 /* 802B8450-802B8528       .text getResource__10JKRArchiveFUlPCc */
-void JKRArchive::getResource(unsigned long, const char*) {
-    /* Nonmatching */
+void* JKRArchive::getResource(u32 type, const char* path) {
+    JUT_ASSERT(332, isMounted());
+    SDIFileEntry* fileEntry;
+    if (type == 0 || type == '????') {
+        fileEntry = findNameResource(path);
+    } else {
+        fileEntry = findTypeResource(type, path);
+    }
+
+    if (fileEntry) {
+        return fetchResource(fileEntry, NULL);
+    }
+
+    return NULL;
 }
 
 /* 802B8528-802B85F0       .text readTypeResource__10JKRArchiveFPvUlUlPCcP10JKRArchive */
-void JKRArchive::readTypeResource(void*, unsigned long, unsigned long, const char*, JKRArchive*) {
+// missing instructions
+void JKRArchive::readTypeResource(void* buffer, u32 bufferSize, u32 type, const char* path, JKRArchive* archive) {
     /* Nonmatching */
+    if (archive) {
+        archive->readResource(buffer, bufferSize, type, path);
+        return;
+    }
+    JSUListIterator<JKRFileLoader> iterator;
+    for (iterator = sVolumeList.getFirst(); iterator != sVolumeList.getEnd(); iterator++) {
+        if (iterator->getVolumeType() == 'RARC') {
+            u32 result = iterator->readResource(buffer, bufferSize, type, path);
+            if (result != 0) {
+                return;
+            }
+        }
+    }
 }
 
 /* 802B85F0-802B86DC       .text readResource__10JKRArchiveFPvUlUlPCc */
-void JKRArchive::readResource(void*, unsigned long, unsigned long, const char*) {
-    /* Nonmatching */
+u32 JKRArchive::readResource(void* buffer, u32 bufferSize, u32 type, const char* path) {
+    JUT_ASSERT(491, isMounted());
+    SDIFileEntry* fileEntry;
+    if (type == 0 || type == '????') {
+        fileEntry = findNameResource(path);
+    } else {
+        fileEntry = findTypeResource(type, path);
+    }
+
+    if (fileEntry) {
+        u32 resourceSize;
+        fetchResource(buffer, bufferSize, fileEntry, &resourceSize);
+        return resourceSize;
+    }
+
+    return 0;
 }
 
 /* 802B86DC-802B87C0       .text readResource__10JKRArchiveFPvUlPCc */
-void JKRArchive::readResource(void*, unsigned long, const char*) {
-    /* Nonmatching */
+u32 JKRArchive::readResource(void* buffer, u32 bufferSize, const char* path) {
+    JUT_ASSERT(537, isMounted());
+    SDIFileEntry* fileEntry;
+    if (*path == '/') {
+        fileEntry = findFsResource(path + 1, 0);
+    } else {
+        fileEntry = findFsResource(path, getCurrentDirID());
+    }
+
+    if (fileEntry) {
+        u32 resourceSize;
+        fetchResource(buffer, bufferSize, fileEntry, &resourceSize);
+        return resourceSize;
+    }
+
+    return 0;
 }
 
 /* 802B87C0-802B8878       .text readIdxResource__10JKRArchiveFPvUlUl */
-void JKRArchive::readIdxResource(void*, unsigned long, unsigned long) {
-    /* Nonmatching */
+u32 JKRArchive::readIdxResource(void* buffer, u32 bufferSize, u32 index) {
+    JUT_ASSERT(593, isMounted());
+    SDIFileEntry* fileEntry = findIdxResource(index);
+    if (fileEntry) {
+        u32 resourceSize;
+        fetchResource(buffer, bufferSize, fileEntry, &resourceSize);
+        return resourceSize;
+    }
+
+    return 0;
 }
 
 /* 802B8878-802B8930       .text readResource__10JKRArchiveFPvUlUs */
-void JKRArchive::readResource(void*, unsigned long, unsigned short) {
-    /* Nonmatching */
+u32 JKRArchive::readResource(void* buffer, u32 bufferSize, u16 id) {
+    JUT_ASSERT(627, isMounted());
+    SDIFileEntry* fileEntry = findIdResource(id);
+    if (fileEntry) {
+        u32 resourceSize;
+        fetchResource(buffer, bufferSize, fileEntry, &resourceSize);
+        return resourceSize;
+    }
+
+    return 0;
 }
 
 /* 802B8930-802B89B8       .text removeResourceAll__10JKRArchiveFv */
 void JKRArchive::removeResourceAll() {
-    /* Nonmatching */
+    if (mArcInfoBlock && mMountMode != MOUNT_MEM) {
+        SDIFileEntry* fileEntry = mFiles;
+        for (int i = 0; i < mArcInfoBlock->num_file_entries; fileEntry++, i++) {
+            if (fileEntry->data) {
+                JKRFreeToHeap(mHeap, fileEntry->data);
+                fileEntry->data = NULL;
+            }
+        }
+    }
 }
 
 /* 802B89B8-802B8A54       .text removeResource__10JKRArchiveFPv */
-void JKRArchive::removeResource(void*) {
-    /* Nonmatching */
+bool JKRArchive::removeResource(void* resource) {
+    JUT_ASSERT(687, resource != 0);
+    SDIFileEntry* fileEntry = findPtrResource(resource);
+    if (fileEntry == NULL)
+        return false;
+
+    fileEntry->data = NULL;
+    JKRFreeToHeap(mHeap, resource);
+    return true;
 }
 
 /* 802B8A54-802B8AE4       .text detachResource__10JKRArchiveFPv */
-void JKRArchive::detachResource(void*) {
-    /* Nonmatching */
+bool JKRArchive::detachResource(void* resource) {
+    JUT_ASSERT(719, resource != 0);
+    SDIFileEntry* fileEntry = findPtrResource(resource);
+    if (fileEntry == NULL)
+        return false;
+
+    fileEntry->data = NULL;
+    return true;
 }
 
 /* 802B8AE4-802B8B6C       .text getResSize__10JKRArchiveCFPCv */
-void JKRArchive::getResSize(const void*) const {
-    /* Nonmatching */
+u32 JKRArchive::getResSize(const void* resource) const {
+    JUT_ASSERT(746, resource != 0);
+    SDIFileEntry* fileEntry = findPtrResource(resource);
+    if (fileEntry == NULL)
+        return -1;
+
+    return fileEntry->data_size;
 }
 
 /* 802B8B6C-802B8BF0       .text countResource__10JKRArchiveCFUl */
-void JKRArchive::countResource(unsigned long) const {
-    /* Nonmatching */
+u32 JKRArchive::countResource(u32 type) const {
+    SDIDirEntry* dirEntry = findResType(type);
+    if (dirEntry) {
+        int count = 0;
+        for (int i = dirEntry->first_file_index; i < dirEntry->first_file_index + dirEntry->num_entries; i++) {
+            if (mFiles[i].isUnknownFlag1()) {
+                count++;
+            }
+        }
+        return count;
+    }
+    return 0;
 }
 
 /* 802B8BF0-802B8C50       .text countFile__10JKRArchiveCFPCc */
-void JKRArchive::countFile(const char*) const {
-    /* Nonmatching */
+u32 JKRArchive::countFile(const char* path) const {
+    SDIDirEntry* dirEntry;
+    if (*path == '/') {
+        path++;
+
+        if (*path == '\0')
+            path = NULL;
+        dirEntry = findDirectory(path, 0);
+    } else {
+        dirEntry = findDirectory(path, sCurrentDirID);
+    }
+
+    if (dirEntry) {
+        return dirEntry->num_entries;
+    }
+
+    return 0;
 }
 
 /* 802B8C50-802B8CFC       .text getFirstFile__10JKRArchiveCFPCc */
-void JKRArchive::getFirstFile(const char*) const {
-    /* Nonmatching */
+JKRFileFinder* JKRArchive::getFirstFile(const char* path) const {
+    SDIDirEntry* dirEntry;
+    if (*path == '/') {
+        path++;
+
+        if (*path == '\0')
+            path = NULL;
+        dirEntry = findDirectory(path, 0);
+    } else {
+        dirEntry = findDirectory(path, sCurrentDirID);
+    }
+
+    if (dirEntry) {
+        return new (JKRHeap::sSystemHeap, 0) JKRArcFinder((JKRArchive*)this, dirEntry->first_file_index, dirEntry->num_entries);
+    }
+
+    return NULL;
 }
 
 /* 802B8CFC-802B8DC4       .text getFirstResource__10JKRArchiveCFUl */
-void JKRArchive::getFirstResource(unsigned long) const {
-    /* Nonmatching */
+JKRArcFinder* JKRArchive::getFirstResource(u32 type) const {
+    SDIDirEntry* dirEntry = findResType(type);
+    if (dirEntry && (getFileAttribute(dirEntry->first_file_index) & 1)) {
+        return new (JKRHeap::sSystemHeap, 0) JKRArcFinder((JKRArchive*)this, dirEntry->first_file_index, countResource(type));
+    }
+    return new (JKRHeap::sSystemHeap, 0) JKRArcFinder((JKRArchive*)this, 0, 0);
 }
 
 /* 802B8DC4-802B8DFC       .text getFileAttribute__10JKRArchiveCFUl */
-void JKRArchive::getFileAttribute(unsigned long) const {
-    /* Nonmatching */
+u32 JKRArchive::getFileAttribute(u32 index) const {
+    SDIFileEntry* fileEntry = findIdxResource(index);
+    if (fileEntry) {
+        return fileEntry->getFlags();
+    }
+
+    return 0;
 }