m_Do debug (#3052)

* m_Do debug

* m_Do wii data

src/JSystem/J3DGraphAnimator/J3DModel.cpp

@@ -1,8 +1,9 @@
 #include "JSystem/JSystem.h" // IWYU pragma: keep
 
-#include "JSystem/J3DGraphAnimator/J3DShapeTable.h"
 #include "JSystem/J3DGraphAnimator/J3DModel.h"
+#include "JSystem/J3DGraphAnimator/J3DJoint.h"
 #include "JSystem/J3DGraphAnimator/J3DMaterialAnm.h"
+#include "JSystem/J3DGraphAnimator/J3DShapeTable.h"
 #include "JSystem/J3DGraphBase/J3DMaterial.h"
 #include "JSystem/J3DGraphBase/J3DShapeMtx.h"
 #include "JSystem/J3DGraphBase/J3DSys.h"

src/JSystem/J3DGraphAnimator/J3DModelData.cpp

@@ -5,9 +5,10 @@
 #include "JSystem/JSystem.h" // IWYU pragma: keep
 
 #include "JSystem/J3DGraphAnimator/J3DModelData.h"
+#include "JSystem/J3DGraphAnimator/J3DJoint.h"
 #include "JSystem/J3DGraphAnimator/J3DMaterialAnm.h"
-#include "JSystem/J3DGraphBase/J3DMaterial.h"
 #include "JSystem/J3DGraphAnimator/J3DModel.h"
+#include "JSystem/J3DGraphBase/J3DMaterial.h"
 
 void J3DModelData::clear() {
     mpRawData = 0;

src/Z2AudioLib/Z2SoundObjMgr.cpp

@@ -143,7 +143,7 @@ void Z2SoundObjMgr::searchEnemy() {
         Z2Calc::CURVE_POSITIVE);
     f32 veryFarDist = 5000.0f;
 
-    for (JSULink<Z2CreatureEnemy>* i = getFirst(); i != NULL; i = i->getNext()) {
+    for (JSULink<Z2CreatureEnemy>* i = field_0x0.getFirst(); i != NULL; i = i->getNext()) {
         Z2CreatureEnemy* enemy = i->getObject();
         if (enemy == NULL) {
             JUT_WARN_DEVICE(100, 1, "%s", "[Z2SoundObjMgr::searchEnemy] remain remove enemy\n");
@@ -349,7 +349,7 @@ u8 Z2SoundObjMgr::getEnemyID(const char* enemyName, JSULink<Z2CreatureEnemy>* en
     if (enemyName != NULL) {
         for (u8 i = 0; i < ARRAY_SIZEU(mEnemyInfo); i++) {
             if (strcmp(enemyName, mEnemyInfo[(u32)i].mName) == 0) {
-                append(enemyLink);
+                field_0x0.append(enemyLink);
                 return i;
             }
         }
@@ -379,7 +379,7 @@ void Z2SoundObjMgr::deleteEnemyAll() {
     JSULink<Z2CreatureEnemy>* i;
 
     // not moving the pointer forward looks like a bug, but deleteObject() actually unlinks the enemy from its owning list
-    while (i = getFirst(), i != NULL) {
+    while (i = field_0x0.getFirst(), i != NULL) {
         Z2CreatureEnemy* enemy = i->getObject();
         if (enemy == NULL) {
             JUT_WARN_DEVICE(367, 1, "%s", "[Z2SoundObjMgr::searchEnemy] remain remove enemy\n");
@@ -399,7 +399,7 @@ bool Z2SoundObjMgr::removeEnemy(JSULink<Z2CreatureEnemy>* enemyLink) {
         field_0x18--;
     }
 
-    bool result = remove(enemyLink);
+    bool result = field_0x0.remove(enemyLink);
     return result;
 }
 

src/m_Do/m_Do_DVDError.cpp

@@ -10,31 +10,38 @@
 #include "m_Do/m_Do_ext.h"
 #include "m_Do/m_Do_Reset.h"
 
+#if PLATFORM_GCN
+const int stack_size = 3072;
+#else
+const int stack_size = 8192;
+#endif
+
+
 bool mDoDvdErr_initialized;
 
 static OSThread DvdErr_thread;
 
 #pragma push
 #pragma force_active on
-static u8 DvdErr_stack[3072] ATTRIBUTE_ALIGN(16);
+static u8 DvdErr_stack[stack_size] ATTRIBUTE_ALIGN(16);
 #pragma pop
 
 static OSAlarm Alarm;
 
 void mDoDvdErr_ThdInit() {
-    if (!mDoDvdErr_initialized) {
-        OSTime time = OSGetTime();
-        OSThread* curThread = OSGetCurrentThread();
-        s32 priority = OSGetThreadPriority(curThread);
-
-        OSCreateThread(&DvdErr_thread, (void*(*)(void*))mDoDvdErr_Watch, NULL, DvdErr_stack + sizeof(DvdErr_stack),
-                       sizeof(DvdErr_stack), priority - 3, 1);
-        OSResumeThread(&DvdErr_thread);
-        OSCreateAlarm(&Alarm);
-        OSSetPeriodicAlarm(&Alarm, time, OS_BUS_CLOCK / 4, AlarmHandler);
-
-        mDoDvdErr_initialized = true;
+    if (mDoDvdErr_initialized) {
+        return;
     }
+
+    OSTime time = OSGetTime();
+
+    OSCreateThread(&DvdErr_thread, (void*(*)(void*))mDoDvdErr_Watch, NULL, DvdErr_stack + sizeof(DvdErr_stack),
+                    sizeof(DvdErr_stack), OSGetThreadPriority(OSGetCurrentThread()) - 3, 1);
+    OSResumeThread(&DvdErr_thread);
+    OSCreateAlarm(&Alarm);
+    OSSetPeriodicAlarm(&Alarm, time, OS_BUS_CLOCK / 4, AlarmHandler);
+
+    mDoDvdErr_initialized = true;
 }
 
 void mDoDvdErr_ThdCleanup() {
@@ -46,13 +53,17 @@ void mDoDvdErr_ThdCleanup() {
 }
 
 static void mDoDvdErr_Watch(void*) {
+#if PLATFORM_GCN
     OSDisableInterrupts();
-    { JKRThread thread(OSGetCurrentThread(), 0); }
+#endif
+    JKRThread(OSGetCurrentThread(), 0);
 
-    mDoExt_getAssertHeap()->becomeCurrentHeap();
+    JKRSetCurrentHeap(mDoExt_getAssertHeap());
 
+    s32 status;
     do {
-        if (DVDGetDriveStatus() == DVD_STATE_FATAL_ERROR) {
+        status = DVDGetDriveStatus();
+        if (status == DVD_STATE_FATAL_ERROR) {
             mDoDvdThd::suspend();
         }
         OSSuspendThread(&DvdErr_thread);

src/m_Do/m_Do_MemCard.cpp

@@ -857,7 +857,7 @@ s32 mDoMemCd_Ctrl_c::checkspaceNAND() {
 mDoMemCd_Ctrl_c g_mDoMemCd_control;
 
 static int mDoMemCd_main(void*) {
-    { JKRThread thread(OSGetCurrentThread(), 0); }
+    JKRThread(OSGetCurrentThread(), 0);
 
     JKRSetCurrentHeap(mDoExt_getAssertHeap());
 

src/m_Do/m_Do_MemCardRWmng.cpp

@@ -411,45 +411,42 @@ static BOOL mDoMemCdRWm_CheckCardStat(CARDFileInfo* file) {
 }
 
 static u32 mDoMemCdRWm_CalcCheckSum(void* data, u32 size) {
-    u16 high;
-    u16 low;
-
-    low = 0;
-    high = 0;
-    
-    u16* d = (u16*)data;
-    for (int i = 0; i < size / 2; i++) {    
+    int i;
+    u16 high, low;
+    high = low = 0;
+    u16* d;
+    for (i = 0, d = (u16*)data; i < size / 2; i++, d++) {
         high += *d;
         low += ~*d;
-        d++;
     }
 
     return high << 16 | low;
 }
 
 static u64 mDoMemCdRWm_CalcCheckSumGameData(void* data, u32 size) {
-    u32 high;
-    u32 low;
+    int i;
+    u32 high, low;
+    high = low = 0;
 
-    low = 0;
-    high = 0;
-
-    u8* d = (u8*)data;
-    for (int i = 0; i < size; i++) {
+    u8* d;
+    for (i = 0, d = (u8*)data; i < size; i++, d++) {
         high += *d;
         low += ~*d;
-        d++;
     }
 
-    return (u64)high << 32 | low;
+    u64 tmp = high;
+    return tmp << 32 | low;
 }
 
 BOOL mDoMemCdRWm_TestCheckSumGameData(void* data) {
-    u64 checksum = mDoMemCdRWm_CalcCheckSumGameData(data, (SAVEDATA_SIZE - sizeof(u64)));
-    return checksum == *(u64*)((u8*)data + (SAVEDATA_SIZE - sizeof(u64)));
+    u64 checksum;
+    u8* file_ptr = (u8*)data;
+    checksum = mDoMemCdRWm_CalcCheckSumGameData(data, (SAVEDATA_SIZE - sizeof(u64)));
+    return checksum == *(u64*)(file_ptr + (SAVEDATA_SIZE - sizeof(u64)));
 }
 
 void mDoMemCdRWm_SetCheckSumGameData(u8* data, u8 dataNum) {
     u8* file_ptr = data + (dataNum * SAVEDATA_SIZE);
-    *(u64*)(file_ptr + (SAVEDATA_SIZE - sizeof(u64))) = mDoMemCdRWm_CalcCheckSumGameData(file_ptr, (SAVEDATA_SIZE - sizeof(u64)));
+    u64 checksum = mDoMemCdRWm_CalcCheckSumGameData(file_ptr, (SAVEDATA_SIZE - sizeof(u64)));
+    *(u64*)(file_ptr + (SAVEDATA_SIZE - sizeof(u64))) = checksum;
 }

src/m_Do/m_Do_Reset.cpp

@@ -11,8 +11,13 @@
 #include "dolphin/gx.h"
 #include "m_Do/m_Do_audio.h"
 #include "m_Do/m_Do_DVDError.h"
+#include "m_Do/m_Do_ext.h"
 #include "m_Do/m_Do_MemCard.h"
 
+#if !PLATFORM_GCN
+#include "revolution/os.h"
+#endif
+
 static void my_OSCancelAlarmAll() {}
 
 static void destroyVideo() {
@@ -26,16 +31,15 @@ static void destroyVideo() {
 
 mDoRstData* mDoRst::mResetData;
 
-void mDoRst_reset(int param_0, u32 param_1, int param_2) {
+void mDoRst_reset(int reset, u32 resetCode, int forceMenu) {
+    JUT_ASSERT(83, mDoExt_GetCurrentRunningThread() != 0);
     JUTXfb::getManager()->clearIndex();
     mDoDvdErr_ThdCleanup();
     cAPICPad_recalibrate();
 
     if (mDoAud_zelAudio_c::isInitFlag()) {
-        bool audioReset;
         do {
-            audioReset = Z2AudioMgr::getInterface()->hasReset();
-        } while (!audioReset);
+        } while (!Z2AudioMgr::getInterface()->hasReset());
     }
 
     if (DVDGetDriveStatus() == DVD_STATE_BUSY) {
@@ -76,33 +80,68 @@ void mDoRst_reset(int param_0, u32 param_1, int param_2) {
 
     my_OSCancelAlarmAll();
     LCDisable();
+#if PLATFORM_GCN
     OSSetSaveRegion(mDoRst::mResetData, (u8*)&mDoRst::getResetData + 0x18);
-    OSResetSystem(param_0, param_1, param_2);
+    OSResetSystem(reset, resetCode, forceMenu);
+#else
+    if (reset == 2) {
+        OSShutdownSystem();
+    } else if (reset == 0) {
+        OSRestart(resetCode);
+    } else {
+        OSReturnToMenu();
+    }
+#endif
 
     do {
         VIWaitForRetrace();
     } while (true);
 }
 
-void mDoRst_resetCallBack(int port, void*) {
-    if (!mDoRst::isReset()) {
-        if (port == -1) {
-            cAPICPad_recalibrate();
-        } else {
-            if (mDoRst::is3ButtonReset()) {
-                JUTGamePad::C3ButtonReset::sResetOccurred = false;
-                JUTGamePad::C3ButtonReset::sCallback = mDoRst_resetCallBack;
-                JUTGamePad::C3ButtonReset::sCallbackArg = NULL;
-                return;
-            }
-            mDoRst::on3ButtonReset();
-            mDoRst::set3ButtonResetPort(port);
-            cAPICPad_recalibrate();
-        }
+void checkDiskCallback(s32 result, DVDCommandBlock* block) {
+    block->userData = (void*)result;
+}
 
-        if (DVDCheckDisk() == 0 && DVDGetDriveStatus() != DVD_STATE_FATAL_ERROR) {
+void mDoRst_resetCallBack(int port, void*) {
+    if (mDoRst::isReset()) {
+        return;
+    }
+    if (port == -1) {
+        cAPICPad_recalibrate();
+    } else {
+        if (mDoRst::is3ButtonReset()) {
+#if PLATFORM_GCN
+            JUTGamePad::C3ButtonReset::sResetOccurred = false;
+            JUTGamePad::C3ButtonReset::sCallback = mDoRst_resetCallBack;
+            JUTGamePad::C3ButtonReset::sCallbackArg = NULL;
+#endif
+            return;
+        }
+        mDoRst::on3ButtonReset();
+        mDoRst::set3ButtonResetPort(port);
+        cAPICPad_recalibrate();
+    }
+
+    int check;
+#if PLATFORM_GCN
+    check = DVDCheckDisk();
+#else
+    DVDCommandBlock block;
+    block.userData = (void*)-1;
+    while (DVDCheckDiskAsync(&block, checkDiskCallback));
+    do {
+        check = (int)block.userData;
+    } while (check == -1);
+#endif
+    if (check == 0) {
+        s32 status = DVDGetDriveStatus();
+        if (status != DVD_STATE_FATAL_ERROR) {
             mDoRst::onReturnToMenu();
         }
-        mDoRst::onReset();
     }
+    mDoRst::onReset();
+}
+
+void mDoRst_shutdownCallBack() {
+    mDoRst::onShutdown();
 }

src/m_Do/m_Do_audio.cpp

@@ -18,9 +18,9 @@
 #include <revolution/sc.h>
 #endif
 
-bool mDoAud_zelAudio_c::mInitFlag;
+u8 mDoAud_zelAudio_c::mInitFlag;
 
-bool mDoAud_zelAudio_c::mResetFlag;
+u8 mDoAud_zelAudio_c::mResetFlag;
 
 bool mDoAud_zelAudio_c::mBgmSet;
 

src/m_Do/m_Do_dvd_thread.cpp

@@ -5,17 +5,20 @@
 
 #include "m_Do/m_Do_dvd_thread.h"
 #include "JSystem/JAudio2/JASDvdThread.h"
+#include "JSystem/JKernel/JKRAramArchive.h"
 #include "JSystem/JKernel/JKRAssertHeap.h"
 #include "JSystem/JKernel/JKRDvdRipper.h"
 #include "JSystem/JKernel/JKRExpHeap.h"
 #include "JSystem/JKernel/JKRMemArchive.h"
 #include "m_Do/m_Do_Reset.h"
+#include "m_Do/m_Do_controller_pad.h"
 #include "m_Do/m_Do_ext.h"
 
 s32 mDoDvdThd::main(void* param_0) {
-    { JKRThread jkrThread(OSGetCurrentThread(), 0); }
-    mDoExt_getAssertHeap()->becomeCurrentHeap();
-    static_cast<mDoDvdThd_param_c*>(param_0)->mainLoop();
+    JKRThread(OSGetCurrentThread(), 0);
+    JKRSetCurrentHeap(mDoExt_getAssertHeap());
+    mDoDvdThd_param_c* param = static_cast<mDoDvdThd_param_c*>(param_0);
+    param->mainLoop();
     return 0;
 }
 
@@ -30,6 +33,11 @@ u8 mDoDvdThd::verbose;
 u8 mDoDvdThd::DVDLogoMode;
 bool mDoDvdThd::SyncWidthSound;
 u8 mDoDvdThd::Report_DVDRead;
+OSBootInfo* mDoDvdHack::BootInfo;
+mDoDvdHack::FSTEntry* mDoDvdHack::FstStart;
+const char* mDoDvdHack::FstStringStart;
+u32 mDoDvdHack::MaxEntryNum;
+mDoDvdHack::Manager mDoDvdHack::Manager::sManager;
 #else
 bool mDoDvdThd::SyncWidthSound;
 #endif
@@ -48,14 +56,61 @@ void mDoDvdThd::create(s32 param_0) {
 }
 
 void mDoDvdThd::suspend() {
+    OS_REPORT("DVD読み込みスレッドを停止しました\n");
     OSSuspendThread(&l_thread);
 }
 
-static s32 my_DVDConvertPathToEntrynum(char const* param_0) {
-    return DVDConvertPathToEntrynum(param_0);
+#if DEBUG
+void mDoDvdHack::__DVDFSInit() {
+    BootInfo = (OSBootInfo*)OSPhysicalToCached(0);
+    FstStart = (FSTEntry*)BootInfo->FSTLocation;
+    if (FstStart) {
+        MaxEntryNum = FstStart->nextEntryOrLength;
+        FstStringStart = (char*)FstStart + (MaxEntryNum* sizeof(FSTEntry));
+    }
 }
 
-mDoDvdThd_command_c::~mDoDvdThd_command_c() {}
+const char* mDoDvdHack::EntryToName(s32 entry) {
+    if (entry < 0) {
+        return "*ERROR*";
+    }
+    if (entry == 0) {
+        return "/";
+    }
+    return FstStringStart + (FstStart[entry].isDirAndStringOff & ~0xff000000);
+}
+
+const char* mDoDvdHack::ConvertEntrynumToName(s32 entry) {
+    __DVDFSInit();
+    return EntryToName(entry);
+}
+#endif
+
+static void dummy1() {
+    OS_REPORT(__FILE__);
+    OS_REPORT("DVDConvertEntrynumToPath: specified entrynum(%d) is out of range  ");
+    OS_REPORT("DVDConvertEntrynumToPath: maxlen should be more than 1 (%d is specified)");
+}
+
+
+static s32 my_DVDConvertPathToEntrynum(char const* path) {
+    s32 entrynum = DVDConvertPathToEntrynum(path);
+#if DEBUG
+    if (entrynum < 0) {
+        BOOL connected = mDoCPd_c::isConnect(2);
+        if (connected) {
+            JUT_WARN(437, "can\'t open:[%s]\n", path);
+        }
+    }
+#endif
+    return entrynum;
+}
+
+mDoDvdThd_command_c::~mDoDvdThd_command_c() {
+    if (!mIsDone) {
+        OS_REPORT_ERROR("mDoDvdThd_command_c::~mDoDvdThd_command_c() 完了していないコマンドがデストラクトされました\nきっとカタストロフィが発生することでしょう\n");
+    }
+}
 
 mDoDvdThd_param_c::mDoDvdThd_param_c() {
     OSInitMessageQueue(&mMessageQueue, &mMessageQueueMessages, 1);
@@ -90,16 +145,17 @@ void mDoDvdThd_param_c::cut(mDoDvdThd_command_c* param_0) {
 }
 
 static void cb(void* param_0) {
-    mDoDvdThd_command_c** pCmd = (mDoDvdThd_command_c**)param_0;
-    s32 result = (*pCmd)->execute();
+    mDoDvdThd_command_c* pCmd = *(mDoDvdThd_command_c**)param_0;
+    s32 result = pCmd->execute();
     if (result != 1) {
         OSReport_Error("mDoDvdThd_param_c::mainLoop() コマンドの実行が失敗しました。\n");
     }
 }
 
 void mDoDvdThd_param_c::mainLoop() {
+    mDoDvdThd_command_c* command;
     while (this->waitForKick() != 0) {
-        while (mDoDvdThd_command_c* command = this->getFirstCommand()) {
+        while (command = this->getFirstCommand()) {
             this->cut(command);
             if (mDoDvdThd::SyncWidthSound) {
                 JASDvd::getThreadPointer()->sendCmdMsg(cb, &command, 4);
@@ -128,6 +184,9 @@ mDoDvdThd_callback_c* mDoDvdThd_callback_c::create(mDoDvdThd_callback_func pFunc
         new (mDoExt_getCommandHeap(), -4) mDoDvdThd_callback_c(pFunc, pData);
     if (callCmd != NULL) {
         mDoDvdThd::l_param.addition(callCmd);
+        if (mDoDvdThd::DVDLogoMode) {
+            OS_REPORT("\x1b[34m<DVD> callback %08x %08x %08x\n\x1b[m", callCmd, pFunc, pData);
+        }
     }
     return callCmd;
 }
@@ -163,19 +222,28 @@ mDoDvdThd_mountArchive_c* mDoDvdThd_mountArchive_c::create(char const* pArchiveP
         } else {
             mountArcCmd->mHeap = pHeap;
             mDoDvdThd::l_param.addition(mountArcCmd);
+            if (mDoDvdThd::DVDLogoMode) {
+                OS_REPORT("\x1b[34m<DVD> mountArchive(%d:%s)\n\x1b[m", mountArcCmd->mEntryNumber, pArchivePath);
+            }
         }
     }
     return mountArcCmd;
 }
 
 s32 mDoDvdThd_mountArchive_c::execute() {
+#if PLATFORM_GCN
     bool isZeldaHeap = false;
     bool isGameHeap = false;
     bool isArcHeap = false;
     bool isJ2DHeap = false;
+#endif
     JKRHeap* heap = mHeap != NULL ? mHeap : mDoExt_getArchiveHeap();
-    JKRMemArchive* memArchive;
+    JKRMemArchive* memArchive = NULL;
+#if DEBUG
+    OSTime time1 = OSGetTime();
+#endif
     while (true) {
+#if PLATFORM_GCN
         if (heap == mDoExt_getArchiveHeapPtr()) {
             isArcHeap = true;
         } else if (heap == mDoExt_getZeldaHeap()) {
@@ -185,6 +253,7 @@ s32 mDoDvdThd_mountArchive_c::execute() {
         } else if (heap == mDoExt_getJ2dHeap()) {
             isJ2DHeap = true;
         }
+#endif
         if (mMountDirection == 0) {
             memArchive =
                 new (heap, 0) JKRMemArchive(mEntryNumber, JKRArchive::MOUNT_DIRECTION_HEAD);
@@ -194,12 +263,22 @@ s32 mDoDvdThd_mountArchive_c::execute() {
         }
         if (memArchive != NULL && memArchive->isMounted()) {
             mArchive = memArchive;
+#if DEBUG
+            OSTime time2 = OSGetTime();
+            u32 msec = OS_TICKS_TO_MSEC(time2 - time1);
+            if (mArchive && mDoDvdThd::verbose) {
+                OS_REPORT("mDoDvdThd_mountArchive_c::execute: mArchive=%08x mArcHeader=%08x mMountDirection=%d Time=%4dms %s\n", mArchive, mArchive->mArcHeader, mMountDirection, msec, mDoDvdHack::ConvertEntrynumToName(mEntryNumber));
+            }
+#endif
             break;
         }
         OSReport_Error("mDoDvdThd_mountArchive_c::execute マウント失敗\n");
+        OS_REPORT_ERROR("Name = %s\n", mDoDvdHack::ConvertEntrynumToName(mEntryNumber));
         if (memArchive) {
             delete memArchive;
         }
+        memArchive = NULL;
+#if PLATFORM_GCN
         if (!isZeldaHeap) {
             OSReport_Error("mDoDvdThd_mountArchive_c::execute ゼルダヒープで再チャレンジ！\n");
             heap = mDoExt_getZeldaHeap();
@@ -216,11 +295,60 @@ s32 mDoDvdThd_mountArchive_c::execute() {
             OSReport_FatalError("mDoDvdThd_mountArchive_c::execute ヒープが致命的に足りません！\n");
             break;
         }
+#else
+        if (heap != mDoExt_getZeldaHeap()) {
+            OSReport_Error("mDoDvdThd_mountArchive_c::execute システムヒープで再チャレンジ！\n");
+            heap = mDoExt_getZeldaHeap();
+        } else {
+            OSReport_FatalError("mDoDvdThd_mountArchive_c::execute ヒープが致命的に足りません！\n");
+            break;
+        }
+#endif
     }
     mIsDone = true;
     return mArchive != NULL;
 }
 
+mDoDvdThd_mountAramArchive_c::~mDoDvdThd_mountAramArchive_c() {}
+
+static void dummy_mDoDvdThd_mountAramArchive_c__create() {
+    OS_REPORT("<DVD> mountAramArchive(%d:%s)\n");
+}
+
+s32 mDoDvdThd_mountAramArchive_c::execute() {
+    JKRHeap* heap = mDoExt_getArchiveHeap();
+    BOOL result = FALSE;
+    if (!mArchive) {
+        if (mMountDirection == 0) {
+            mArchive = new (heap, 0x20) JKRAramArchive();
+        } else {
+            mArchive = new (heap, -0x20) JKRAramArchive();
+        }
+#if DEBUG
+        if (mDoDvdThd::verbose) {
+            OS_REPORT("mDoDvdThd_mountAramArchive_c::execute mArchive=%08x size=%08x\n", mArchive, JKRGetMemBlockSize(heap, mArchive));
+        }
+#endif
+        JUT_ASSERT(880, mArchive != NULL);
+    }
+    if (mArchive) {
+        JKRArchive::EMountDirection mountDirection = mMountDirection == 0 ? JKRArchive::MOUNT_DIRECTION_HEAD : JKRArchive::MOUNT_DIRECTION_TAIL;
+#if DEBUG
+        OSTime time1 = OSGetTime();
+#endif
+        result = mArchive->mountFixed(mEntryNum, mountDirection);
+#if DEBUG
+        OSTime time2 = OSGetTime();
+        u32 msec = OS_TICKS_TO_MSEC(time2 - time1);
+        if (mDoDvdThd::verbose) {
+            OS_REPORT("mDoDvdThd_mountAramArchive_c::execute: mArchive=%08x ->mAramCache=%08x ->mFileSystem=%08x %s\n", mArchive, mArchive->mBlock, mArchive->mDvdFile, mDoDvdHack::ConvertEntrynumToName(mEntryNum));
+        }
+#endif
+    }
+    mIsDone = true;
+    return result;
+}
+
 mDoDvdThd_mountXArchive_c::~mDoDvdThd_mountXArchive_c() {}
 
 mDoDvdThd_mountXArchive_c::mDoDvdThd_mountXArchive_c(u8 mountDirection, JKRArchive::EMountMode mountMode) {
@@ -249,21 +377,70 @@ mDoDvdThd_mountXArchive_c* mDoDvdThd_mountXArchive_c::create(char const* pArchiv
         } else {
             mountXArcCmd->mHeap = pHeap;
             mDoDvdThd::l_param.addition(mountXArcCmd);
+            if (mDoDvdThd::DVDLogoMode) {
+                OS_WARNING("<DVD> mountXArchive(%d:%s)\n", mountXArcCmd->mEntryNum, pArchivePath);
+            }
         }
     }
     return mountXArcCmd;
 }
 
 s32 mDoDvdThd_mountXArchive_c::execute() {
+#if DEBUG
+    OSTime time1 = OSGetTime();
+#endif
     JKRArchive::EMountDirection mountDirection =
         mMountDirection == 0 ? JKRArchive::MOUNT_DIRECTION_HEAD : JKRArchive::MOUNT_DIRECTION_TAIL;
     JKRHeap* heap = mHeap != NULL ? mHeap : mDoExt_getArchiveHeap();
+    s32 result = 0;
     mArchive = JKRArchive::mount(mEntryNum, mMountMode, heap, mountDirection);
-    s32 result = mArchive != NULL;
+    result = mArchive != NULL;
+#if DEBUG
+    if (result) {
+        OSTime time2 = OSGetTime();
+        u32 msec = OS_TICKS_TO_MSEC(time2 - time1);
+        if (mDoDvdThd::verbose) {
+            OS_REPORT("mDoDvdThd_mountXArchive_c::execute: mArchive=%08x %s\n", mArchive, mDoDvdHack::ConvertEntrynumToName(mEntryNum));
+        }
+    }
+#endif
     mIsDone = true;
     return result;
 }
 
+mDoDvdThd_getResource_c::~mDoDvdThd_getResource_c() {}
+
+static void dummy_mDoDvdThd_getResource_c__create() {
+    OS_REPORT("<DVD> getResource(%x,%d)\n");
+    OSReport("mDoDvdThd_getResource_c::create() クラス生成に失敗\n");
+    OSReport("mDoDvdThd_getResource_c::create() リソース取得に失敗\n");
+}
+
+s32 mDoDvdThd_getResource_c::execute() {
+#if DEBUG
+    OSTime time1 = OSGetTime();
+#endif
+    JUT_ASSERT(1080, mArchive);
+    mResource = mArchive->getResource(mResourceId);
+#if DEBUG
+    OSTime time2 = OSGetTime();
+    u32 msec = OS_TICKS_TO_MSEC(time2 - time1);
+    if (mArchive && mDoDvdThd::verbose) {
+        OS_REPORT("mDoDvdThd_getResource_c::execute: mResouce=%08x  Time=%4dms\n", mResource, msec);
+    }
+#endif
+    if (!mResource) {
+        OSReport_Error("mDoDvdThd_getResource_c::execute() リソース取得に失敗\n");
+    }
+    mIsDone = true;
+    return mResource != NULL;
+}
+
+static void dummy2() {
+    OS_REPORT("mEntryNum != -1");
+    OS_REPORT("mDoDvdThd_toMainRam_c(%d:%s)\n");
+}
+
 mDoDvdThd_toMainRam_c::mDoDvdThd_toMainRam_c(u8 param_0) {
     mMountDirection = param_0;
     if (param_0 == 0) {
@@ -284,6 +461,9 @@ mDoDvdThd_toMainRam_c* mDoDvdThd_toMainRam_c::create(char const* pArchivePath, u
         } else {
             toMainRAMCmd->mHeap = pHeap;
             mDoDvdThd::l_param.addition(toMainRAMCmd);
+            if (mDoDvdThd::DVDLogoMode) {
+                OS_WARNING("<DVD> toMainRam(%d:%s)\n", toMainRAMCmd->mEntryNum, pArchivePath);
+            }
         }
     }
     return toMainRAMCmd;
@@ -292,6 +472,9 @@ mDoDvdThd_toMainRam_c* mDoDvdThd_toMainRam_c::create(char const* pArchivePath, u
 mDoDvdThd_toMainRam_c::~mDoDvdThd_toMainRam_c() {}
 
 s32 mDoDvdThd_toMainRam_c::execute() {
+#if DEBUG
+    OSTime time1 = OSGetTime();
+#endif
     JKRHeap* heap;
     if (mHeap != NULL) {
         heap = mHeap;
@@ -301,17 +484,18 @@ s32 mDoDvdThd_toMainRam_c::execute() {
     JKRDvdRipper::EAllocDirection allocDir = mMountDirection == 0 ?
                                                  JKRDvdRipper::ALLOC_DIRECTION_FORWARD :
                                                  JKRDvdRipper::ALLOC_DIRECTION_BACKWARD;
-    mData = JKRDvdRipper::loadToMainRAM(mEntryNum, NULL, EXPAND_SWITCH_UNKNOWN1, 0, heap, allocDir,
+    mData = JKRDvdToMainRam(mEntryNum, NULL, EXPAND_SWITCH_UNKNOWN1, 0, heap, allocDir,
                                         0, NULL, NULL);
     if (mData != NULL) {
         mDataSize = heap->getSize(mData);
     }
+#if DEBUG
+    OSTime time2 = OSGetTime();
+    u32 msec = OS_TICKS_TO_MSEC(time2 - time1);
+    if (mDoDvdThd::verbose) {
+        OS_REPORT("mDoDvdThd_toMainRam_c::execute: mMemAddress=%08x mMemSize=%08x %s\n", mData, mDataSize, mDoDvdHack::ConvertEntrynumToName(mEntryNum));
+    }
+#endif
     mIsDone = true;
     return mData != NULL;
 }
-
-static void dummy() {
-    OSReport("mDoDvdThd_getResource_c::create() クラス生成に失敗\n");
-    OSReport("mDoDvdThd_getResource_c::create() リソース取得に失敗\n");
-    OSReport("mDoDvdThd_getResource_c::execute() リソース取得に失敗\n");
-}

src/m_Do/m_Do_ext.cpp

@@ -24,13 +24,9 @@
 #include "m_Do/m_Do_mtx.h"
 #include <cstdio>
 
-namespace m_Do_ext {
-u8 CurrentHeapAdjustVerbose;
-u8 HeapAdjustVerbose;
-u8 HeapAdjustQuiet;
-}
-
-static intptr_t safeGameHeapSize = -1;
+u8 mDoExt::CurrentHeapAdjustVerbose;
+u8 mDoExt::HeapAdjustVerbose;
+u8 mDoExt::HeapAdjustQuiet;
 
 static void mDoExt_setJ3DData(Mtx mtx, const J3DTransformInfo* transformInfo, u16 param_2) {
     bool local_28;
@@ -681,6 +677,7 @@ JKRExpHeap* mDoExt_getDbPrintHeap() {
 }
 
 JKRExpHeap* gameHeap;
+static intptr_t safeGameHeapSize = -1;
 
 JKRExpHeap* mDoExt_createGameHeap(u32 heapSize, JKRHeap* parentHeap) {
     JUT_ASSERT(1739, gameHeap == NULL || heapSize == 0);
@@ -2344,18 +2341,6 @@ static u8 l_matDL[132] ATTRIBUTE_ALIGN(32) = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-static u8 l_mat1DL[141] ATTRIBUTE_ALIGN(32) = {
-    0x10, 0x00, 0x00, 0x10, 0x40, 0xFF, 0xFF, 0x42, 0x80, 0x08, 0x30, 0x3C, 0xF3, 0xCF, 0x00, 0x10,
-    0x00, 0x00, 0x10, 0x18, 0x3C, 0xF3, 0xCF, 0x00, 0x10, 0x00, 0x00, 0x10, 0x0E, 0x00, 0x00, 0x7F,
-    0x32, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x10, 0x0C, 0xFF,
-    0xFF, 0xFF, 0xFF, 0x61, 0x28, 0x38, 0x00, 0x40, 0x61, 0xC0, 0x28, 0xFA, 0x8F, 0x61, 0xC1, 0x08,
-    0xFF, 0xF0, 0x61, 0x43, 0x00, 0x00, 0x41, 0x61, 0x40, 0x00, 0x00, 0x17, 0x61, 0x41, 0x00, 0x00,
-    0x0C, 0x61, 0xF3, 0x7F, 0x00, 0x00, 0x10, 0x00, 0x00, 0x10, 0x3F, 0x00, 0x00, 0x00, 0x01, 0x10,
-    0x00, 0x00, 0x10, 0x09, 0x00, 0x00, 0x00, 0x01, 0x61, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-};
-
 void mDoExt_3DlineMat0_c::setMaterial() {
     j3dSys.reinitGX();
     GXSetNumIndStages(0);
@@ -2659,6 +2644,18 @@ int mDoExt_3DlineMat1_c::init(u16 param_0, u16 param_1, ResTIMG* param_2, int pa
     return 1;
 }
 
+static u8 l_mat1DL[141] ATTRIBUTE_ALIGN(32) = {
+    0x10, 0x00, 0x00, 0x10, 0x40, 0xFF, 0xFF, 0x42, 0x80, 0x08, 0x30, 0x3C, 0xF3, 0xCF, 0x00, 0x10,
+    0x00, 0x00, 0x10, 0x18, 0x3C, 0xF3, 0xCF, 0x00, 0x10, 0x00, 0x00, 0x10, 0x0E, 0x00, 0x00, 0x7F,
+    0x32, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x10, 0x0C, 0xFF,
+    0xFF, 0xFF, 0xFF, 0x61, 0x28, 0x38, 0x00, 0x40, 0x61, 0xC0, 0x28, 0xFA, 0x8F, 0x61, 0xC1, 0x08,
+    0xFF, 0xF0, 0x61, 0x43, 0x00, 0x00, 0x41, 0x61, 0x40, 0x00, 0x00, 0x17, 0x61, 0x41, 0x00, 0x00,
+    0x0C, 0x61, 0xF3, 0x7F, 0x00, 0x00, 0x10, 0x00, 0x00, 0x10, 0x3F, 0x00, 0x00, 0x00, 0x01, 0x10,
+    0x00, 0x00, 0x10, 0x09, 0x00, 0x00, 0x00, 0x01, 0x61, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+
 void mDoExt_3DlineMat1_c::setMaterial() {
     j3dSys.reinitGX();
     GXSetNumIndStages(0);

src/m_Do/m_Do_ext2.cpp

@@ -0,0 +1,138 @@
+
+#include "d/dolzel.h" // IWYU pragma: keep
+
+#include "m_Do/m_Do_ext2.h"
+
+FixedMemoryCheck* FixedMemoryCheck::sFirst;
+
+FixedMemoryCheck::FixedMemoryCheck(u32* param_1, u32 size, JKRHeap* heap) {
+    mNowCode = param_1;
+    mSize = size;
+    mSaveCode = NULL;
+    mpHeap = heap;
+    field_0x10 = 0;
+    field_0x14 = false;
+    mNext = NULL;
+    if (sFirst) {
+        mNext = sFirst;
+    }
+    sFirst = this;
+}
+
+FixedMemoryCheck* FixedMemoryCheck::easyCreate(void* param_1, u32 size) {
+    JKRHeap* heap = JKRGetRootHeap2();
+    FixedMemoryCheck* memCheck = new (heap, 0) FixedMemoryCheck((u32*)param_1, size, heap);
+    if (!memCheck) {
+        memCheck = new (JKRGetSystemHeap(), 0) FixedMemoryCheck((u32*)param_1, size, NULL);
+    }
+    if (memCheck) {
+        memCheck->alloc();
+        memCheck->save();
+        memCheck->check();
+    }
+    return memCheck;
+}
+
+BOOL FixedMemoryCheck::checkAll() {
+    BOOL result = true;
+    for (FixedMemoryCheck* memCheck = sFirst; memCheck; memCheck = memCheck->mNext) {
+        if (!memCheck->check()) {
+            result = false;
+        }
+    }
+    return result;
+}
+
+BOOL FixedMemoryCheck::diffAll() {
+    BOOL result = true;
+    for (FixedMemoryCheck* memCheck = sFirst; memCheck; memCheck = memCheck->mNext) {
+        if (!memCheck->diff()) {
+            result = false;
+        }
+    }
+    return result;
+}
+
+BOOL FixedMemoryCheck::saveAll() {
+    BOOL result = true;
+    for (FixedMemoryCheck* memCheck = sFirst; memCheck; memCheck = memCheck->mNext) {
+        if (!memCheck->save()) {
+            result = false;
+        }
+    }
+    return result;
+}
+
+BOOL FixedMemoryCheck::alloc() {
+    if (!mpHeap) {
+        OSReport_Error("FixedMemoryCheck::alloc ヒープ未設定\n");
+        return false;
+    }
+
+    if (mSaveCode) {
+        OSReport_Error("FixedMemoryCheck::alloc セーブ確保済み\n");
+        return false;
+    }
+
+    mSaveCode = (u32*)JKRAllocFromHeap(mpHeap, mSize, 4);
+    OSReport("FixedMemoryCheck::alloc: %dKB確保\n", mSize >> 10);
+    return mSaveCode != NULL;
+}
+
+BOOL FixedMemoryCheck::save() {
+    if (!mNowCode) {
+        OSReport_Error("FixedMemoryCheck::save 設定ミス\n");
+        return false;
+    }
+    if (mSaveCode) {
+        memcpy(mSaveCode, mNowCode, mSize);
+    }
+    u32 r28 = 0;
+    for (int i = 0; i < mSize / 4; i++) {
+        r28 += mNowCode[i];
+    }
+    field_0x10 = r28;
+    OSReport("FixedMemoryCheck::save: チェックサム=%08x\n", field_0x10);
+    field_0x14 = false;
+    return true;
+}
+
+BOOL FixedMemoryCheck::check() {
+    BOOL result = true;
+    if (!mSaveCode || !mNowCode) {
+        OSReport_Error("FixedMemoryCheck::check 設定ミス\n");
+        return false;
+    }
+    u32 r29 = 0;
+    for (int i = 0; i < mSize / 4; i++) {
+        r29 += mNowCode[i];
+    }
+    if (r29 != field_0x10) {
+        OSReport_Error("FixedMemoryCheck::check: チェックサム不一致 %08x : %08x\n", field_0x10, r29);
+        result = false;
+    }
+    if (mSaveCode) {
+        int cmp = memcmp(mSaveCode, mNowCode, mSize);
+        if(cmp) {
+            OSReport_Error("FixedMemoryCheck::check メモリ破壊発見 %08x %08x\n", mNowCode, mSize);
+            result = false;
+            if (!field_0x14) {
+                diff();
+                field_0x14 = true;
+            }
+        }
+    }
+    return result;
+}
+
+BOOL FixedMemoryCheck::diff() {
+    BOOL result = true;
+    OSReport("Address  SaveCode NowCode\n");
+    for (int i = 0; i < mSize / 4; i++) {
+        if (mSaveCode[i] != mNowCode[i]) {
+            result = false;
+            OSReport("%08x %08x %08x\n", mNowCode + i, mSaveCode[i], mNowCode[i]);
+        }
+    }
+    return result;
+}

src/m_Do/m_Do_graphic.cpp

@@ -387,7 +387,7 @@ mDoGph_gInf_c::bloom_c mDoGph_gInf_c::m_bloom;
 
 Mtx mDoGph_gInf_c::mBlureMtx;
 
-#if DEBUG
+#if !PLATFORM_GCN
 cXyz mDoGph_gInf_c::csr_c::m_nowEffPos(0.0f, 0.0f, 0.0f);
 cXyz mDoGph_gInf_c::csr_c::m_oldEffPos(0.0f, 0.0f, 0.0f);
 cXyz mDoGph_gInf_c::csr_c::m_oldOldEffPos(0.0f, 0.0f, 0.0f);
@@ -2105,6 +2105,10 @@ int mDoGph_Painter() {
 mDoGph_HIO_c mDoGph_HIO;
 #endif
 
+static void dummy() {
+    OS_REPORT("mDoGph_Create():Initial of Graphic \n");
+}
+
 int mDoGph_Create() {
     JKRSolidHeap* heap = mDoExt_createSolidHeapToCurrent(0, NULL, 0);
     mDoGph_gInf_c::create();

src/m_Do/m_Do_lib.cpp

@@ -119,6 +119,7 @@ void mDoLib_pos2camera(Vec* src, Vec* dst) {
 }
 
 static void dummy() {
+    std::tan(0.0f);
     J3DAlphaComp* alphaComp = NULL;
     alphaComp->setAlphaCompInfo((J3DAlphaCompInfo){});
     J3DPEBlock* peBlock = NULL;

src/m_Do/m_Do_machine.cpp

@@ -491,7 +491,7 @@ void forever() {
 #if !PLATFORM_GCN
 void exceptionShutdown() {
     mDoRst_reset(2, 0, 0);
-    //OSShutdownSystem();
+    OSShutdownSystem();
     forever();
 }
 #endif
@@ -501,7 +501,7 @@ void exceptionRestart() {
 #if PLATFORM_GCN
     OSResetSystem(0, 0, 0);
 #else
-    //OSRestart(0);
+    OSRestart(0);
 #endif
     while (true) {}
 }

src/m_Do/m_Do_machine_exception.cpp

@@ -16,7 +16,7 @@ static JUTConsole* sConsole;
 void print_f(char const* fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    JUTConsole_print_f_va_(sConsole, fmt, args);
+    sConsole->print_f_va(fmt, args);
     va_end(args);
 }
 
@@ -44,8 +44,9 @@ void dispHeapInfo() {
     print_f("Archive %5d / %5d\n", archiveFree / 1024, archiveTotal / 1024);
     print("--------------------------------\n");
 
-    if (JKRAram::getAramHeap()) {
-        JKRAram::getAramHeap()->dump();
+    JKRAramHeap* aramHeap = JKRAram::getAramHeap();
+    if (aramHeap) {
+        aramHeap->dump();
     }
     DynamicModuleControlBase::dump();
     g_dComIfG_gameInfo.mResControl.dump();
@@ -62,8 +63,13 @@ void dispGameInfo() {
 
 void dispDateInfo() {
     print("------------- Date Infomation ---------\n");
+#if DEBUG
+    print(" DEBUG VERSION\n");
+    print("COMPILE USER: Authorized User\n");
+#else
     print(" FINAL VERSION\n");
     print("COMPILE USER: FINAL\n");
+#endif
     print_f("COPYDATE   : %17s\n", mDoMain::COPYDATE_STRING);
 
     OSCalendarTime time;
@@ -84,7 +90,8 @@ void dispDateInfo() {
 }
 
 void dispConsoleToTerminal() {
-    JFWSystem::getSystemConsole()->dumpToTerminal(0xFFFFFFFF);
+    JUTConsole* console = JFWSystem::getSystemConsole();
+    console->dumpToTerminal(0xFFFFFFFF);
 }
 
 void exception_addition(JUTConsole* pConsole) {

src/m_Do/m_Do_main.cpp

@@ -805,7 +805,7 @@ void parse_args(int argc, const char* argv[]) {
             dStage_roomControl_c::onNoArcBank();
             OS_REPORT("\x1b[33mアーカイブバンクを無効にしました\n\x1b[m");
         } else if (strcmp(argv[i], "--particle254") == 0) {
-            // data_8074c494 = 1;
+            fapGm_HIO_c::mParticle254Fix = 1;
             OSReport_Warning("パーティクル２５４固定にしました\n");
         } else if (strncmp(argv[i], "--menu=", sizeof("--menu=") - 1) == 0) {
             char* var_r27 = strchr(argv[i] + 7, ',');
@@ -822,15 +822,15 @@ void parse_args(int argc, const char* argv[]) {
                     if (spC != NULL) {
                         *spC = 0;
                         spC++;
-                        sscanf(spC, "%d", dScnMenu_c::cursolPoint);
+                        sscanf(spC, "%d", &dScnMenu_c::cursolPoint);
                         dScnMenu_c::m_error_flags |= (u8)8;
                     }
 
-                    sscanf(var_r26, "%d", dScnMenu_c::cursolLayer);
+                    sscanf(var_r26, "%d", &dScnMenu_c::cursolLayer);
                     dScnMenu_c::m_error_flags |= (u8)4;
                 }
 
-                sscanf(var_r27, "%d", dScnMenu_c::cursolRoomNo);
+                sscanf(var_r27, "%d", &dScnMenu_c::cursolRoomNo);
                 dScnMenu_c::m_error_flags |= (u8)2;
             }
 

src/m_Do/m_Do_printf.cpp

@@ -214,57 +214,63 @@ void OSReport_FatalError(const char* fmt, ...) {
 
 void OSReport_Error(const char* fmt, ...) {
     print_errors++;
-    if (!__OSReport_Error_disable) {
-        #if DEBUG
-        OSThread* thread = mDoExt_GetCurrentRunningThread();
-        if (thread != NULL) {
-            OSLockMutex(&print_mutex);
-        }
-        #endif
-
-        va_list args;
-        va_start(args, fmt);
-        OSReportForceEnableOn();
-        my_PutString("\x1B[41;37m[ERROR]");
-        OSVReport(fmt, args);
-        my_PutString("\x1B[m");
-        OSReportForceEnableOff();
-        fflush(stdout);
-        va_end(args);
-
-        #if DEBUG
-        if (thread != NULL) {
-            OSUnlockMutex(&print_mutex);
-        }
-        #endif
+    if (__OSReport_Error_disable) {
+        return;
     }
+
+    #if DEBUG
+    OSThread* thread = mDoExt_GetCurrentRunningThread();
+    if (thread != NULL) {
+        OSLockMutex(&print_mutex);
+    }
+    #endif
+
+    va_list args;
+    va_start(args, fmt);
+    OSReportForceEnableOn();
+    my_PutString("\x1B[41;37m[ERROR]");
+    OSVReport(fmt, args);
+    my_PutString("\x1B[m");
+    OSReportForceEnableOff();
+    fflush(stdout);
+    va_end(args);
+
+    #if DEBUG
+    if (thread != NULL) {
+        OSUnlockMutex(&print_mutex);
+    }
+    #endif
 }
 
 void OSReport_Warning(const char* fmt, ...) {
     print_warings++;
-    if (!__OSReport_Warning_disable) {
-        va_list args;
-        va_start(args, fmt);
-        OSReportForceEnableOn();
-        my_PutString("\x1B[43;30m[WARN]");
-        OSVAttention(fmt, args);
-        my_PutString("\x1B[m");
-        OSReportForceEnableOff();
-        fflush(stdout);
-        va_end(args);
+    if (__OSReport_Warning_disable) {
+        return;
     }
+
+    va_list args;
+    va_start(args, fmt);
+    OSReportForceEnableOn();
+    my_PutString("\x1B[43;30m[WARN]");
+    OSVAttention(fmt, args);
+    my_PutString("\x1B[m");
+    OSReportForceEnableOff();
+    fflush(stdout);
+    va_end(args);
 }
 
 void OSReport_System(const char* fmt, ...) {
     print_systems++;
-    if (!__OSReport_System_disable) {
-        va_list args;
-        va_start(args, fmt);
-        OSReportForceEnableOn();
-        OSVAttention(fmt, args);
-        OSReportForceEnableOff();
-        va_end(args);
+    if (__OSReport_System_disable) {
+        return;
     }
+
+    va_list args;
+    va_start(args, fmt);
+    OSReportForceEnableOn();
+    OSVAttention(fmt, args);
+    OSReportForceEnableOff();
+    va_end(args);
 }
 
 void OSPanic(const char* file, int line, const char* fmt, ...) {
@@ -286,6 +292,6 @@ void OSPanic(const char* file, int line, const char* fmt, ...) {
 
     // force a crash by writing to an invalid address
     tmp = (u32*)0x1234567;
-    *tmp = 0x1234567;
+    *tmp = (uintptr_t)tmp;
     PPCHalt();
 }

src/revolution/os/OSReset.c

@@ -175,7 +175,7 @@ static void KillThreads(void) {
     }
 }
 
-void OSShutdownSystem(BOOL reset, u32 resetCode, BOOL forceMenu) {
+void OSShutdownSystem() {
     SCIdleModeInfo idleModeInfo;
     OSIOSRev iosRev;
     OSStateFlags state;