Finish FS_archive.c

6 files changed, 186 insertions, 13 deletions

diff --git a/arm9/lib/include/FS_archive.h b/arm9/lib/include/FS_archive.h
index baf11add..a86478e8 100644
--- a/arm9/lib/include/FS_archive.h
+++ b/arm9/lib/include/FS_archive.h
@@ -168,7 +168,19 @@ static inline BOOL FSi_IsArchiveUnloading(volatile const FSArchive * p_arc)
     return (p_arc->flag & FS_ARCHIVE_FLAG_UNLOADING) != 0;
 }
 
+static inline BOOL FSi_IsArchiveAsync(volatile const FSArchive * p_arc)
+{
+    return (p_arc->flag & FS_ARCHIVE_FLAG_IS_ASYNC) != 0;
+}
+
+static inline BOOL FS_IsArchiveTableLoaded(volatile const FSArchive * p_arc)
+{
+    return (p_arc->flag & FS_ARCHIVE_FLAG_TABLE_LOAD) ? TRUE : FALSE;
+}
+
 BOOL FSi_SendCommand(struct FSFile * file, FSCommandType command);
 BOOL FSi_ExecuteSyncCommand(struct FSFile * file);
+BOOL FS_SuspendArchive(FSArchive * p_arc);
+BOOL FS_ResumeArchive(FSArchive * p_arc);
 
 #endif //NITRO_FS_ARCHIVE_H_
diff --git a/arm9/lib/include/FS_file.h b/arm9/lib/include/FS_file.h
index 92e2149e..fdf6c4e2 100644
--- a/arm9/lib/include/FS_file.h
+++ b/arm9/lib/include/FS_file.h
@@ -179,6 +179,7 @@ BOOL FS_OpenFileDirect(FSFile * p_file, FSArchive * p_arc, u32 image_top, u32 im
 int FS_ReadFile(FSFile * p_file, void * dst, s32 len);
 int FS_ReadFileAsync(FSFile * p_file, void * dst, s32 len);
 BOOL FS_OpenFileFast(FSFile * p_file, FSFileID file_id);
+BOOL FS_CloseFile(FSFile * p_file);
 
 static inline u32 const FS_GetFileImageTop(volatile const FSFile * p_file) {
     return p_file->prop.file.top;
diff --git a/arm9/lib/include/FS_overlay.h b/arm9/lib/include/FS_overlay.h
index 1ef6469c..6025d04a 100644
--- a/arm9/lib/include/FS_overlay.h
+++ b/arm9/lib/include/FS_overlay.h
@@ -45,12 +45,11 @@ static inline u32 const FS_GetOverlayTotalSize(FSOverlayInfo * p_ovi)
     return p_ovi->header.ram_size + p_ovi->header.bss_size;
 }
 
-BOOL    FS_LoadOverlayInfo(FSOverlayInfo *p_ovi, MIProcessor target, FSOverlayID id);
-BOOL    FS_LoadOverlay(MIProcessor target, FSOverlayID id);
-BOOL    FS_UnloadOverlay(MIProcessor target, FSOverlayID id);
-BOOL    FS_LoadOverlayImage(FSOverlayInfo *p_ovi);
-void    FS_StartOverlay(FSOverlayInfo *p_ovi);
-BOOL    FS_LoadOverlayImageAsync(FSOverlayInfo *p_ovi, FSFile *p_file);
-void    FS_CloseFile(FSFile *p_file);
+BOOL FS_LoadOverlayInfo(FSOverlayInfo *p_ovi, MIProcessor target, FSOverlayID id);
+BOOL FS_LoadOverlay(MIProcessor target, FSOverlayID id);
+BOOL FS_UnloadOverlay(MIProcessor target, FSOverlayID id);
+BOOL FS_LoadOverlayImage(FSOverlayInfo *p_ovi);
+void FS_StartOverlay(FSOverlayInfo *p_ovi);
+BOOL FS_LoadOverlayImageAsync(FSOverlayInfo *p_ovi, FSFile *p_file);
 
 #endif //NITRO_FS_OVERLAY_H_
diff --git a/arm9/lib/include/FSi_util.h b/arm9/lib/include/FSi_util.h
index babb6d75..1012df13 100644
--- a/arm9/lib/include/FSi_util.h
+++ b/arm9/lib/include/FSi_util.h
@@ -1,6 +1,10 @@
 #ifndef NITRO_FSI_UTIL_H_
 #define NITRO_FSI_UTIL_H_
 
+#define ALIGN_MASK(a) ((u32)((a) - 1))
+
+#define ALIGN_BYTE(n, a) (((u32)(n) + ALIGN_MASK(a)) & ~ALIGN_MASK(a))
+
 static inline BOOL FSi_IsSlash(u32 c)
 {
     return (c == '/') || (c == '\\');
diff --git a/arm9/lib/include/OS_system.h b/arm9/lib/include/OS_system.h
index 1b263b19..88137c3b 100644
--- a/arm9/lib/include/OS_system.h
+++ b/arm9/lib/include/OS_system.h
@@ -37,9 +37,7 @@ OSProcMode OS_GetProcMode();
 void OS_SpinWait();
 void OS_WaitVBlankIntr();
 void OS_Terminate(void);
-static inline void OS_TPanic(const char * message)
-{
-    OS_Terminate();
-}
+#define OS_TPanic(...) OS_Terminate()
+#define OS_TWarning(...) ((void)0)
 
 #endif //POKEDIAMOND_OS_SYSTEM_H
diff --git a/arm9/lib/src/FS_archive.c b/arm9/lib/src/FS_archive.c
index c8404144..44a4e451 100644
--- a/arm9/lib/src/FS_archive.c
+++ b/arm9/lib/src/FS_archive.c
@@ -42,9 +42,9 @@ FSResult FSi_WriteMemCallback(struct FSArchive * p_arc, const void * src, u32 po
     return FS_RESULT_SUCCESS;
 }
 
-FSResult FSi_ReadMemoryCore(FSArchive * p_arc, u8 * dest, u32 offset, u32 size)
+FSResult FSi_ReadMemoryCore(FSArchive * p_arc, void * dest, u32 pos, u32 size)
 {
-    MI_CpuCopy8((const void *)offset, dest, size);
+    MI_CpuCopy8((const void *)pos, dest, size);
     return FS_RESULT_SUCCESS;
 }
 
@@ -283,3 +283,162 @@ BOOL FS_LoadArchive(FSArchive * p_arc, u32 base, u32 fat, u32 fat_size, u32 fnt,
     p_arc->flag |= FS_ARCHIVE_FLAG_LOADED;
     return TRUE;
 }
+
+BOOL FS_UnloadArchive(FSArchive * p_arc)
+{
+    OSIntrMode bak_psr = OS_DisableInterrupts();
+    if (FS_IsArchiveLoaded(p_arc))
+    {
+        if (FS_IsArchiveTableLoaded(p_arc))
+        {
+            OS_TWarning("memory may leak. preloaded-table of archive \"%s\" (0x%08X)", p_arc->name.ptr, p_arc->load_mem);
+        }
+        {
+            FSFile *p, *q;
+            BOOL bak_state = FS_SuspendArchive(p_arc);
+            p_arc->flag |= FS_ARCHIVE_FLAG_UNLOADING;
+            for (p = p_arc->list.next; p; p = q)
+            {
+                q = p->link.next;
+                FSi_ReleaseCommand(p, FS_RESULT_CANCELED);
+            }
+            p_arc->list.next = NULL;
+            if (bak_state)
+                FS_ResumeArchive(p_arc);
+        }
+        p_arc->base = 0;
+        p_arc->fat = 0;
+        p_arc->fat_size = 0;
+        p_arc->fnt = 0;
+        p_arc->fnt_size = 0;
+        p_arc->fat_bak = p_arc->fnt_bak = 0;
+        p_arc->flag &= ~(FS_ARCHIVE_FLAG_CANCELING | FS_ARCHIVE_FLAG_LOADED | FS_ARCHIVE_FLAG_UNLOADING);
+    }
+    OS_RestoreInterrupts(bak_psr);
+    return TRUE;
+}
+
+u32 FS_LoadArchiveTables(FSArchive *p_arc, void *p_mem, u32 max_size)
+{
+    u32 total_size = ALIGN_BYTE(p_arc->fat_size + p_arc->fnt_size + 32, 32);
+    if (total_size <= max_size)
+    {
+        u8     *p_cache = (u8 *)ALIGN_BYTE((u32)p_mem, 32);
+        FSFile  tmp;
+        FS_InitFile(&tmp);
+        if (FS_OpenFileDirect(&tmp, p_arc, p_arc->fat, p_arc->fat + p_arc->fat_size, (u32)~0))
+        {
+            if (FS_ReadFile(&tmp, p_cache, (s32)p_arc->fat_size) < 0)
+            {
+                MI_CpuFill8(p_cache, 0x00, p_arc->fat_size);
+            }
+            FS_CloseFile(&tmp);
+        }
+        p_arc->fat = (u32)p_cache;
+        p_cache += p_arc->fat_size;
+        if (FS_OpenFileDirect(&tmp, p_arc, p_arc->fnt, p_arc->fnt + p_arc->fnt_size, (u32)~0))
+        {
+            if (FS_ReadFile(&tmp, p_cache, (s32)p_arc->fnt_size) < 0)
+            {
+                MI_CpuFill8(p_cache, 0x00, p_arc->fnt_size);
+            }
+            FS_CloseFile(&tmp);
+        }
+        p_arc->fnt = (u32)p_cache;
+        p_arc->load_mem = p_mem;
+        p_arc->table_func = FSi_ReadMemoryCore;
+        p_arc->flag |= FS_ARCHIVE_FLAG_TABLE_LOAD;
+    }
+    return total_size;
+}
+
+void * FS_UnloadArchiveTables(FSArchive * p_arc)
+{
+    void *ret = NULL;
+    if (FS_IsArchiveLoaded(p_arc))
+    {
+        BOOL bak_stat = FS_SuspendArchive(p_arc);
+        if (FS_IsArchiveTableLoaded(p_arc))
+        {
+            p_arc->flag &= ~FS_ARCHIVE_FLAG_TABLE_LOAD;
+            ret = p_arc->load_mem;
+            p_arc->load_mem = NULL;
+            p_arc->fat = p_arc->fat_bak;
+            p_arc->fnt = p_arc->fnt_bak;
+            p_arc->table_func = p_arc->read_func;
+        }
+        if (bak_stat)
+            FS_ResumeArchive(p_arc);
+    }
+    return ret;
+}
+
+BOOL FS_SuspendArchive(FSArchive * p_arc)
+{
+    OSIntrMode bak_psr = OS_DisableInterrupts();
+    const BOOL bak_stat = !FS_IsArchiveSuspended(p_arc);
+    if (bak_stat)
+    {
+        if (FSi_IsArchiveRunning(p_arc))
+        {
+            p_arc->flag |= FS_ARCHIVE_FLAG_SUSPENDING;
+            do {
+                OS_SleepThread(&p_arc->stat_q);
+            } while (FSi_IsArchiveSuspending(p_arc));
+        }
+        else
+        {
+            p_arc->flag |= FS_ARCHIVE_FLAG_SUSPEND;
+        }
+    }
+    OS_RestoreInterrupts(bak_psr);
+    return bak_stat;
+}
+
+BOOL FS_ResumeArchive(FSArchive * p_arc)
+{
+    FSFile * p_target = NULL;
+    OSIntrMode bak_psr = OS_DisableInterrupts();
+    const BOOL bak_stat = !FS_IsArchiveSuspended(p_arc);
+    if (!bak_stat)
+    {
+        p_arc->flag &= ~FS_ARCHIVE_FLAG_SUSPEND;
+        p_target = FSi_NextCommand(p_arc);
+    }
+    OS_RestoreInterrupts(bak_psr);
+    if (p_target)
+        FSi_ExecuteAsyncCommand(p_target);
+    return bak_stat;
+}
+
+void FS_SetArchiveProc(struct FSArchive * p_arc, FS_ARCHIVE_PROC_FUNC proc, u32 flags)
+{
+    if (!flags)
+        proc = NULL;
+    else if (!proc)
+        flags = 0;
+    p_arc->proc = proc;
+    p_arc->proc_flag = flags;
+}
+
+void FS_NotifyArchiveAsyncEnd(FSArchive *p_arc, FSResult ret)
+{
+    if (FSi_IsArchiveAsync(p_arc))
+    {
+        FSFile *p_file = p_arc->list.next;
+        p_arc->flag &= ~FS_ARCHIVE_FLAG_IS_ASYNC;
+        FSi_ReleaseCommand(p_file, ret);
+        p_file = FSi_NextCommand(p_arc);
+        if (p_file)
+            FSi_ExecuteAsyncCommand(p_file);
+    }
+    else
+    {
+        FSFile *p_file = p_arc->list.next;
+        OSIntrMode bak_psr = OS_DisableInterrupts();
+        p_file->error = ret;
+        p_arc->flag &= ~FS_ARCHIVE_FLAG_IS_SYNC;
+        OS_WakeupThread(&p_arc->sync_q);
+        (void)OS_RestoreInterrupts(bak_psr);
+    }
+}