libjsys/jsyswrapper: match all funcs, need unused for weak function emission?

include/JSystem/JFramework/JFWDisplay.h

@@ -98,12 +98,16 @@ class JFWDisplay {
         return sManager;
     }
 
+    const GXRenderModeObj* getRenderMode() const {
+        return mRMode;
+    }
+
     int getEfbHeight() const {
-        return JUTVideo::getManager()->getEfbHeight();
+        return getRenderMode() ->efbHeight;
     }
 
     int getEfbWidth() const {
-        return JUTVideo::getManager()->getFbWidth();
+        return getRenderMode() ->fbWidth;
     }
 
     JUTFader* getFader() const {
@@ -151,6 +155,15 @@ class JFWDisplay {
         return mEnableAlpha;
     }
 
+    void setGamma(u16 gamma) {
+        mGamma = gamma;
+    }
+
+    void setFrameRate(u16 framerate) {
+        mFrameRate = framerate;
+        mTickRate = 0;
+    }
+
     static JFWDisplay* sManager; // 0x80415718
 
   private:

include/JSystem/JFramework/JFWSystem.h

@@ -62,6 +62,18 @@ struct JFWSystem {
         JUT_ASSERT(sInitCalled == 0);
         CSetUpParam::renderMode = rmode;
     }
+    static JKRHeap* getSystemHeap() {
+        JUT_ASSERT(sInitCalled == 0);
+        return systemHeap;
+    }
+    static JKRHeap* getRootHeap() {
+        JUT_ASSERT(sInitCalled == 0);
+        return rootHeap;
+    }
+    static JUTConsole* getSystemConsole() {
+        JUT_ASSERT(sInitCalled == 0);
+        return systemConsole;
+    }
 };
 
 #endif

include/JSystem/JKernel/JKRHeap.h

@@ -120,7 +120,7 @@ class JKRHeap : public JKRDisposer {
     void freeAll();
     void freeTail();
     void fillFreeArea();
-    void resize(void*, u32);
+    s32 resize(void*, u32);
     static s32 getSize(void*, JKRHeap*);
 
     // ... more functions

include/JSystem/JSystem.h

@@ -2,7 +2,26 @@
 #define JSYSTEM_H
 
 #include "JSystem/JKernel/JKRAram.h"
+#include "JSystem/JKernel/JKRFileLoader.h"
+#include "JSystem/JKernel/JKRArchive.h"
 #include "JSystem/JMacro.h"
 #include "JSystem/JUtility/JUTException.h"
 
+// probably a better place to put these
+static inline void* JKRGetResource(const char* resourceName) {
+    return JKRFileLoader::getGlbResource(resourceName);
+}
+
+static inline void JKRRemoveResource(void* resource) {
+    JKRFileLoader::removeResource(resource, nullptr);
+}
+
+static inline BOOL JKRDetachResource(void* resource) {
+    return JKRFileLoader::detachResource(resource, nullptr);
+}
+
+static inline void* JKRGetResourceEntry_byName(u32 root_name, const char* res_name, JKRArchive* archive) {
+    return archive->findTypeResource(root_name, res_name);
+}
+
 #endif

include/JSystem/JUtility/JUTAssertion.h

@@ -13,6 +13,9 @@ void flushMessage();
 void flushMessage_dbPrint();
 u32 getSDevice(void);
 
+void changeDisplayTime(u32 time);
+void changeDevice(u32 device);
+
 void showAssert_f(u32 device, char const* file, int line, char const* errormsg, ...);
 inline void showAssert(u32 device, char const* file, int line, char const* errormsg) {
     showAssert_f(device, file, line, "%s", errormsg);

include/JSystem/JUtility/JUTException.h

@@ -105,11 +105,16 @@ struct JUTException : public JKRThread {
     void setTraceSuppress(u32 supress) {
         mTraceSuppress = supress;
     }
+
     void setGamePad(JUTGamePad* gamePad) {
         mGamePad = gamePad;
         mPadPort = JUTGamePad::Port_Invalid;
     }
 
+    void enterAllPad() {
+        setGamePad((JUTGamePad*)-1);
+    }
+
     static JUTException* getManager() {
         return sErrorManager;
     }

include/libjsys/jsyswrapper.h

@@ -21,39 +21,19 @@ typedef struct {
     void* mData;     // _10
 } CSDIFileEntry;
 
-extern void* JC_JFWSystem_getSystemConsole();
-extern void* JC_JFWSystem_getRootHeap();
-extern void* JC_JFWSystem_getSystemHeap();
-
 extern void* JC_JUTVideo_getManager();
-extern u16 JC_JUTVideo_getFbWidth(void* manager);
-extern u16 JC_JUTVideo_getEfbHeight(void* manager);
+extern u32 JC_JUTVideo_getFbWidth(void* manager);
+extern u32 JC_JUTVideo_getEfbHeight(void* manager);
 extern void JC_JUTVideo_setRenderMode(void* manager, GXRenderModeObj* renderMode);
 
-extern void* JC_JFWDisplay_getManager();
-extern void JC_JFWDisplay_startFadeOut(void* manager, int len);
-extern void JC_JFWDisplay_startFadeIn(void* manager, int len);
-extern void JC_JFWDisplay_setFrameRate(void* manager, u16 framerate);
-extern void JC_JFWDisplay_endFrame(void* manager);
-extern void JC_JFWDisplay_beginRender(void* manager);
-extern void JC_JFWDisplay_endRender(void* manager);
-extern void JC_JFWDisplay_setClearColor(void* manager, GXColor color);
-
 extern void JC_JKRAramHeap_dump(void* heap);
 extern void* JC_JKRAram_getAramHeap();
 
 extern u32 JC_JKRAramArchive_getAramAddress_byName(void* archive, u32 root_name, const char* res_name);
 extern CSDIFileEntry* JC__JKRGetResourceEntry_byName(u32 root_name, const char* res_name, void* archive);
 
-extern int JC_JKRHeap_dump(void* heap);
-extern s32 JC_JKRHeap_getTotalFreeSize(void* heap);
-
-extern void JC_JKRExpHeap_changeGroupID(void* expheap, u8 groupId);
-
-extern void JC_JUTGamePad_getPadStatus(PADStatus* status, int padId);
-
 extern void* JC__JKRDvdToMainRam_byName(const char* name, u8* buf, JKRExpandSwitch expandSwitch);
-extern BOOL JC__JKRDetachResource(void* ptr);
+extern void JC__JKRDetachResource(void* ptr);
 
 extern int JC_JUTConsole_isVisible(void* console);
 extern void JC_JUTConsole_setVisible(void* console, BOOL visible);
@@ -86,31 +66,48 @@ extern void JC_JUTProcBar_setVisibleHeapBar(void* procbar, BOOL visible);
 extern void* JC_JUTException_getManager();
 extern void* JC_JUTException_getConsole();
 extern BOOL JC_JUTException_isEnablePad(void* manager);
-extern void JC_JUTException_readPad(void* mgr, u32* trigger, u32* button);
+extern int JC_JUTException_readPad(void* mgr, u32* trigger, u32* button);
 extern void JC_JUTException_waitTime(u32 time);
 extern void JC_JUTException_enterAllPad(void* manager);
 extern void JC_JUTException_setMapFile(const char* path);
+extern void JC_JUTException_setPreUserCallback(void* callback);
+extern void JC_JUTException_setPostUserCallback(void* callback);
 
 extern void JC_JUTAssertion_changeDevice(int device);
 extern void JC_JUTAssertion_changeDisplayTime(int displayTime);
 
 extern void JC_JUTGamePad_read();
-extern void JC_JFWDisplay_startFadeOut(void* manager, int fadeout);
+extern PADStatus JC_JUTGamePad_getPadStatus(u32 port);
+extern u8 JC_JUTGamePad_recalibrate(u32 port);
+
+extern void* JC_JFWDisplay_getManager();
+extern int JC_JFWDisplay_startFadeIn(void* manager, int len);
+extern void JC_JFWDisplay_setFrameRate(void* manager, u16 framerate);
+extern void JC_JFWDisplay_endFrame(void* manager);
+extern void JC_JFWDisplay_beginRender(void* manager);
+extern void JC_JFWDisplay_endRender(void* manager);
+extern void JC_JFWDisplay_setClearColor(void* manager, GXColor color);
+extern int JC_JFWDisplay_startFadeOut(void* manager, int fadeout);
 extern void JC_JFWDisplay_clearEfb(void* manager, GXColor* color);
-extern GXRenderModeObj* JC_JFWDisplay_getRenderMode(void* manager);
-extern void* JC_JFWDisplay_changeToSingleXfb(void* manager, int param);
-extern u16 JC_JFWDisplay_getEfbWidth(void* manager);
-extern u16 JC_JFWDisplay_getEfbHeight(void* manager);
+extern const GXRenderModeObj* JC_JFWDisplay_getRenderMode(void* manager);
+extern void* JC_JFWDisplay_changeToSingleXfb(void* manager, int index);
+extern void* JC_JFWDisplay_changeToDoubleXfb(void* manager);
+extern int JC_JFWDisplay_getEfbWidth(void* manager);
+extern int JC_JFWDisplay_getEfbHeight(void* manager);
+extern void* JC_JFWDisplay_createManager_0(GXRenderModeObj* renderMode, void* heap, int exfbNumber, int enableAlpha);
+extern void JC_JFWDisplay_setFader(void* manager, void* fader);
+extern void JC_JFWDisplay_setGamma(void* manager, int gamma);
+extern void JC_JFWDisplay_destroyManager();
+
 extern void JC_JFWSystem_setMaxStdHeap(int max);
 extern void JC_JFWSystem_setSysHeapSize(u32 size);
 extern void JC_JFWSystem_setFifoBufSize(u32 size);
 extern void JC_JFWSystem_setAramAudioBufSize(u32 size);
 extern void JC_JFWSystem_setAramGraphBufSize(u32 size);
 extern void JC_JFWSystem_init();
-extern void* JC_JFWDisplay_createManager_0(GXRenderModeObj* renderMode, void* heap, int param0, int param1);
-extern void JC_JFWDisplay_setFader(void* manager, void* fader);
-extern void JC_JFWDisplay_setGamma(void* manager, int gamma);
-extern void JC_JFWDisplay_destroyManager();
+extern void* JC_JFWSystem_getSystemConsole();
+extern void* JC_JFWSystem_getRootHeap();
+extern void* JC_JFWSystem_getSystemHeap();
 
 extern void* JC_J2DOrthoGraph_new();
 extern void JC_J2DOrthoGraph_delete(void* orthograph);
@@ -118,23 +115,28 @@ extern void JC_J2DOrthoGraph_delete(void* orthograph);
 extern void* JC_JUTFader_new(int ul_x, int ul_y, int br_x, int br_y, u32* color);
 extern void JC_JUTFader_delete(void* fader);
 
-extern void JC_JFWDisplay_changeToDoubleXfb(void* manager);
 extern void* JC__JKRGetResource(const char* resourceName);
-extern u32 JC__JKRGetMemBlockSize(int, void*);
 
 extern void JC__JKRRemoveResource(void* res);
 
-extern void JC_J2DOrthoGraph_setOrtho(void* gport, u16 ul_x, u16 ul_y, u16 br_x, u16 br_y);
-extern void JC_J2DOrthoGraph_setPort(void* gport);
+extern void JC_J2DOrthoGraph_setOrtho(void* orthograph, int ul_x, int ul_y, int br_x, int br_y);
+extern void JC_J2DOrthoGraph_setPort(void* orthograph);
 
 extern void* JC_JKRAramArchive_new();
 extern BOOL JC__JKRMountFixedAramArchive(void* aram_archive, const char* file);
-extern BOOL JC__JKRUnmountFixedAramArchive(void* aram_archive);
+extern void JC__JKRUnmountFixedAramArchive(void* aram_archive);
 extern void JC_JKRAramArchive_delete(void* aram_archive);
 
 extern u32 JC_JKRHeap_getFreeSize(void* heap);
 extern void* JC_JKRHeap_alloc(void* heap, u32 size, int align);
 extern void JC_JKRHeap_free(void* heap, void* mem);
+extern size_t JC_JKRHeap_getSize(void* heap, void* mem);
+extern s32 JC_JKRHeap_resize(void* heap, void* ptr, s32 new_size);
+extern int JC_JKRHeap_dump(void* heap);
+extern s32 JC_JKRHeap_getTotalFreeSize(void* heap);
+extern u32 JC__JKRGetMemBlockSize(void* heap, void* ptr);
+
+extern u8 JC_JKRExpHeap_changeGroupID(void* expheap, u8 groupId);
 
 extern void* JC__JKRAllocFromAram(size_t size);
 extern u8* JC__JKRAramToMainRam_block(void* aramBlock, u8* ramDst, size_t size);
@@ -154,6 +156,11 @@ extern void* JC__JKRMountArchive(const char* path, int mount_mode, void* heap, i
 
 extern void* JC__JKRGetSystemHeap();
 
+extern void* JC_JUTXfb_getManager();
+extern void JC_JUTXfb_clearIndex(void* manager);
+
+extern u32 JC_JKRAramBlock_getAddress(void* aramBlock);
+
 #ifdef JSYSWRAPPER_DEBUG
 #define JSYSWRAPPER_PRINTF(console, fmt, ...) JC_JUTConsole_print_f(console, fmt, ...)
 #else

src/famicom_emu.c

@@ -120,7 +120,7 @@ extern void famicom_emu_init(GAME* game) {
     u8 player;
     int debug;
     void* manager;
-    GXRenderModeObj* render;
+    const GXRenderModeObj* render;
 
     famicom_done = 0;
     famicom_done_countdown = 0;

src/static/JSystem/JKernel/JKRHeap.cpp

@@ -134,9 +134,9 @@ void JKRHeap::freeTail() {
     do_freeTail();
 }
 
-void JKRHeap::resize(void* memoryBlock, u32 newSize) {
+s32 JKRHeap::resize(void* memoryBlock, u32 newSize) {
     JUT_WARNING_F(!mInitFlag, "resize block %x into %x in heap %x", memoryBlock, newSize, this);
-    do_resize(memoryBlock, newSize);
+    return do_resize(memoryBlock, newSize);
 }
 
 s32 JKRHeap::getSize(void* memoryBlock, JKRHeap* heap) {

src/static/jsyswrap.cpp

@@ -491,8 +491,8 @@ extern void JW_Init() {
     JC_JUTProcBar_setVisibleHeapBar(JC_JUTProcBar_getManager(), FALSE);
     jc_gport = JC_J2DOrthoGraph_new();
     u32 color = TCOLOR_BLACK;
-    jc_fader = JC_JUTFader_new(0, 0, JC_JUTVideo_getFbWidth(JC_JUTVideo_getManager()),
-                               JC_JUTVideo_getEfbHeight(JC_JUTVideo_getManager()), &color);
+    jc_fader = JC_JUTFader_new(0, 0, (u16)JC_JUTVideo_getFbWidth(JC_JUTVideo_getManager()),
+                               (u16)JC_JUTVideo_getEfbHeight(JC_JUTVideo_getManager()), &color);
     JC_JFWDisplay_setFader(display_manager, jc_fader);
     JC_JFWDisplay_setClearColor(display_manager, TCOLOR_BLACK);
     JC_JFWDisplay_setGamma(display_manager, 0);

src/static/libjsys/jsyswrapper.cpp

@@ -0,0 +1,17 @@
+#include "libjsys/jsyswrapper.h"
+
+#include "JSystem/JSystem.h"
+#include "JSystem/JKernel/JKRExpHeap.h"
+#include "JSystem/JUtility/JUTDbPrint.h"
+#include "JSystem/JUtility/JUTFader.h"
+#include "JSystem/J2D/J2DGrafContext.h"
+#include "JSystem/JFramework/JFWDisplay.h"
+#include "JSystem/JFramework/JFWSystem.h"
+#include "JSystem/JKernel/JKRDecomp.h"
+#include "JSystem/JKernel/JKRArchive.h"
+#include "JSystem/JKernel/JKRDvdRipper.h"
+
+#include "MSL_C/printf.h"
+
+#include "../src/static/libjsys/jsyswrapper_ext.cpp"
+#include "../src/static/libjsys/jsyswrapper_main.cpp"

src/static/libjsys/jsyswrapper_ext.cpp

@@ -0,0 +1,41 @@
+extern void JC_JUTConsole_print_f_va(void* console, const char* fmt, va_list arg) {
+    char buf[256];
+    
+    vsnprintf(buf, sizeof(buf), fmt, arg);
+    reinterpret_cast<JUTConsole*>(console)->print(buf);
+}
+
+extern void JW_JUTReport(int x, int y, int show_count, const char* fmt, ...) {
+    char buf[256];
+    va_list arg;
+    int len;
+    int shown_len;
+
+    va_start(arg, fmt);
+    len = (int)vsnprintf(buf, sizeof(buf), fmt, arg);
+    va_end(arg);
+
+    if (len >= 0) {
+        JUTDbPrint::sDebugPrint->enter(x, y, show_count, buf, len >= (int)sizeof(buf) ? sizeof(buf) - 1 : len);
+    }
+}
+
+extern void* JW_Alloc(size_t size, int align) {
+    return JC_JKRHeap_alloc(JC_JFWSystem_getSystemHeap(), size, align);
+}
+
+extern s32 JW_Resize(void* ptr, size_t new_size) {
+    return JC_JKRHeap_resize(JC_JFWSystem_getSystemHeap(), ptr, new_size);
+}
+
+extern void JW_Free(void* ptr) {
+    JC_JKRHeap_free(JC_JFWSystem_getSystemHeap(), ptr);
+}
+
+extern size_t JW_GetMemBlockSize(void* ptr) {
+    return JC_JKRHeap_getSize(JC_JFWSystem_getSystemHeap(), ptr);
+}
+
+extern void JW_JUTXfb_clearIndex(void) {
+    JC_JUTXfb_clearIndex(JC_JUTXfb_getManager());
+}

src/static/libjsys/jsyswrapper_main.cpp

@@ -0,0 +1,411 @@
+extern void JC_JUTFader_delete(void* fader) {
+    delete reinterpret_cast<JUTFader*>(fader);
+}
+
+extern void* JC_JUTFader_new(int ul_x, int ul_y, int br_x, int br_y, u32* color) {
+    return new JUTFader(ul_x, ul_y, br_x, br_y, JUtility::TColor(*(GXColor*)color));
+}
+
+extern void* JC_JUTDbPrint_getManager() {
+    return JUTDbPrint::getManager();
+}
+
+extern void JC_JUTDbPrint_setVisible(void* dbprint, BOOL visible) {
+    reinterpret_cast<JUTDbPrint*>(dbprint)->setVisible(visible);
+}
+
+extern void JC_J2DOrthoGraph_delete(void* orthograph) {
+    delete reinterpret_cast<J2DOrthoGraph*>(orthograph);
+}
+
+extern void* JC_J2DOrthoGraph_new() {
+    return new J2DOrthoGraph();
+}
+
+extern void JC_J2DOrthoGraph_setPort(void* orthograph) {
+    reinterpret_cast<J2DOrthoGraph*>(orthograph)->setPort();
+}
+
+extern void JC_J2DOrthoGraph_setOrtho(void* orthograph, int ul_x, int ul_y, int br_x, int br_y) {
+    reinterpret_cast<J2DOrthoGraph*>(orthograph)->setOrtho(JGeometry::TBox2f((f32)ul_x, (f32)ul_y, (f32)ul_x + (f32)br_x, (f32)ul_y + (f32)br_y), -1.0f, 1.0f);
+}
+
+extern void* JC_JUTVideo_getManager() {
+    return JUTVideo::getManager();
+}
+extern void JC_JUTVideo_setRenderMode(void* manager, GXRenderModeObj* renderMode) {
+    reinterpret_cast<JUTVideo*>(manager)->setRenderMode(renderMode);
+}
+
+extern u32 JC_JUTVideo_getFbWidth(void* manager) {
+    return reinterpret_cast<JUTVideo*>(manager)->getFbWidth();
+}
+
+extern u32 JC_JUTVideo_getEfbHeight(void* manager) {
+    return reinterpret_cast<JUTVideo*>(manager)->getEfbHeight();
+}
+
+extern void* JC_JKRHeap_alloc(void* heap, u32 size, int align) {
+    return reinterpret_cast<JKRHeap*>(heap)->alloc(size, align);
+}
+
+extern s32 JC_JKRHeap_resize(void* heap, void* ptr, s32 new_size) {
+    return reinterpret_cast<JKRHeap*>(heap)->resize(ptr, new_size);
+}
+
+extern void JC_JKRHeap_free(void* heap, void* mem) {
+    reinterpret_cast<JKRHeap*>(heap)->free(mem);
+}
+
+extern int JC_JKRHeap_dump(void* heap) {
+    return reinterpret_cast<JKRHeap*>(heap)->dump();
+}
+
+extern u32 JC_JKRHeap_getFreeSize(void* heap) {
+    return reinterpret_cast<JKRHeap*>(heap)->getFreeSize();
+}
+
+extern s32 JC_JKRHeap_getTotalFreeSize(void* heap) {
+    return reinterpret_cast<JKRHeap*>(heap)->getTotalFreeSize();
+}
+
+extern size_t JC_JKRHeap_getSize(void* heap, void* mem) {
+    return reinterpret_cast<JKRHeap*>(heap)->getSize(mem);
+}
+
+extern void* JC__JKRGetSystemHeap() {
+    return JKRHeap::getSystemHeap();
+}
+
+extern u32 JC__JKRGetMemBlockSize(void* heap, void* ptr) {
+    return JKRHeap::getSize(ptr, reinterpret_cast<JKRHeap*>(heap));
+}
+
+extern u8 JC_JKRExpHeap_changeGroupID(void* expheap, u8 groupId) {
+    return reinterpret_cast<JKRExpHeap*>(expheap)->changeGroupID((u8)groupId);
+}
+
+extern void JC_JUTGamePad_read() {
+    JUTGamePad::read();
+}
+
+extern PADStatus JC_JUTGamePad_getPadStatus(u32 port) {
+    return *JUTGamePad::getPadStatus(port);
+}
+
+extern u8 JC_JUTGamePad_recalibrate(u32 port) {
+    return JUTGamePad::recalibrate(port);
+}
+
+extern void JC_JUTConsole_setOutput(void* console, int output) {
+    reinterpret_cast<JUTConsole*>(console)->setOutput(output);
+}
+
+extern int JC_JUTConsole_getOutput(void* console) {
+    return reinterpret_cast<JUTConsole*>(console)->getOutput();
+}
+
+extern void JC_JUTConsole_setVisible(void* console, BOOL visible) {
+    reinterpret_cast<JUTConsole*>(console)->setVisible(visible);
+}
+
+extern int JC_JUTConsole_isVisible(void* console) {
+    return reinterpret_cast<JUTConsole*>(console)->isVisible();
+}
+
+extern u32 JC_JUTConsole_getHeight(void* console) {
+    return reinterpret_cast<JUTConsole*>(console)->getHeight();
+}
+
+extern void JC_JUTConsole_setPosition(void* console, int x, int y) {
+    reinterpret_cast<JUTConsole*>(console)->setPosition(x, y);
+}
+
+extern int JC_JUTConsole_getPositionX(void* console) {
+    return reinterpret_cast<JUTConsole*>(console)->getPositionX();
+}
+
+extern void JC_JUTConsole_clear(void* console) {
+    reinterpret_cast<JUTConsole*>(console)->clear();
+}
+
+extern void JC_JUTConsole_scroll(void* console, int scroll) {
+    reinterpret_cast<JUTConsole*>(console)->scroll(scroll);
+}
+
+extern void JC_JUTConsole_scrollToLastLine(void* console) {
+    reinterpret_cast<JUTConsole*>(console)->scrollToLastLine();
+}
+
+extern void JC_JUTConsole_scrollToFirstLine(void* console) {
+    reinterpret_cast<JUTConsole*>(console)->scrollToFirstLine();
+}
+
+extern u32 JC_JUTConsole_getUsedLine(void* console) {
+    return reinterpret_cast<JUTConsole*>(console)->getUsedLine();
+}
+
+extern int JC_JUTConsole_getLineOffset(void* console) {
+    return reinterpret_cast<JUTConsole*>(console)->getLineOffset();
+}
+
+extern void JC_JUTConsole_dumpToTerminal(void* console, int lines) {
+    reinterpret_cast<JUTConsole*>(console)->dumpToTerminal(lines);
+}
+
+extern void* JC_JUTConsoleManager_getManager() {
+    return JUTConsoleManager::getManager();
+}
+
+extern void JC_JUTConsoleManager_drawDirect(void* manager, int direct) {
+    reinterpret_cast<JUTConsoleManager*>(manager)->drawDirect(direct);
+}
+
+extern void* JC_JUTException_getManager() {
+    return JUTException::getManager();
+}
+
+extern void JC_JUTException_enterAllPad(void* manager) {
+    reinterpret_cast<JUTException*>(manager)->enterAllPad();
+}
+
+extern void JC_JUTException_setPreUserCallback(void* callback) {
+    JUTException::setPreUserCallback((JUTErrorHandler)callback);
+}
+
+extern void JC_JUTException_setPostUserCallback(void* callback) {
+    JUTException::setPostUserCallback((JUTErrorHandler)callback);
+}
+
+extern void JC_JUTException_setMapFile(const char* path) {
+    JUTException::appendMapFile(path);
+}
+
+extern void* JC_JUTException_getConsole() {
+    return JUTException::getConsole();
+}
+
+extern BOOL JC_JUTException_isEnablePad(void* manager) {
+    return reinterpret_cast<JUTException*>(manager)->isEnablePad();
+}
+
+extern int JC_JUTException_readPad(void* mgr, u32* trigger, u32* button) {
+    return reinterpret_cast<JUTException*>(mgr)->readPad(trigger, button);
+}
+
+extern void JC_JUTException_waitTime(u32 time) {
+    JUTException::waitTime(time);
+}
+
+extern void* JC_JFWDisplay_createManager_0(GXRenderModeObj* renderMode, void* heap, int exfbNumber, int enableAlpha) {
+    return JFWDisplay::createManager(renderMode, reinterpret_cast<JKRHeap*>(heap), (JUTXfb::EXfbNumber)exfbNumber, (bool)enableAlpha);
+}
+
+extern void JC_JFWDisplay_destroyManager() {
+    JFWDisplay::destroyManager();
+}
+
+extern void* JC_JFWDisplay_getManager() {
+    return JFWDisplay::getManager();
+}
+
+extern void JC_JFWDisplay_setGamma(void* manager, int gamma) {
+    reinterpret_cast<JFWDisplay*>(manager)->setGamma(gamma);
+}
+
+extern void JC_JFWDisplay_setFrameRate(void* manager, u16 framerate) {
+    reinterpret_cast<JFWDisplay*>(manager)->setFrameRate(framerate);
+}
+
+extern void JC_JFWDisplay_setFader(void* manager, void* fader) {
+    reinterpret_cast<JFWDisplay*>(manager)->setFader(reinterpret_cast<JUTFader*>(fader));
+}
+
+extern void JC_JFWDisplay_setClearColor(void* manager, GXColor color) {
+    reinterpret_cast<JFWDisplay*>(manager)->setClearColor(color);
+}
+
+extern void JC_JFWDisplay_beginRender(void* manager) {
+    reinterpret_cast<JFWDisplay*>(manager)->beginRender();
+}
+
+extern void JC_JFWDisplay_endRender(void* manager) {
+    reinterpret_cast<JFWDisplay*>(manager)->endRender();
+}
+
+extern void JC_JFWDisplay_endFrame(void* manager) {
+    reinterpret_cast<JFWDisplay*>(manager)->endFrame();
+}
+
+extern int JC_JFWDisplay_startFadeIn(void* manager, int len) {
+    return reinterpret_cast<JFWDisplay*>(manager)->startFadeIn(len);
+}
+
+extern int JC_JFWDisplay_startFadeOut(void* manager, int fadeout) {
+    return reinterpret_cast<JFWDisplay*>(manager)->startFadeOut(fadeout);
+}
+
+extern int JC_JFWDisplay_getEfbWidth(void* manager) {
+    return reinterpret_cast<JFWDisplay*>(manager)->getEfbWidth();
+}
+
+extern int JC_JFWDisplay_getEfbHeight(void* manager) {
+    return reinterpret_cast<JFWDisplay*>(manager)->getEfbHeight();
+}
+
+extern void* JC_JFWDisplay_changeToSingleXfb(void* manager, int index) {
+    return reinterpret_cast<JFWDisplay*>(manager)->changeToSingleXfb(index);
+}
+
+extern void* JC_JFWDisplay_changeToDoubleXfb(void* manager) {
+    return reinterpret_cast<JFWDisplay*>(manager)->changeToDoubleXfb();
+}
+
+extern void JC_JFWDisplay_clearEfb(void* manager, GXColor* color) {
+    reinterpret_cast<JFWDisplay*>(manager)->clearEfb(*color);
+}
+
+extern const GXRenderModeObj* JC_JFWDisplay_getRenderMode(void* manager) {
+    return reinterpret_cast<JFWDisplay*>(manager)->getRenderMode();
+}
+
+extern void JC_JFWSystem_setMaxStdHeap(int max) {
+    JFWSystem::setMaxStdHeap(max);
+}
+
+extern void JC_JFWSystem_setSysHeapSize(u32 size) {
+    JFWSystem::setSysHeapSize(size);
+}
+
+extern void JC_JFWSystem_setFifoBufSize(u32 size) {
+    JFWSystem::setFifoBufSize(size);
+}
+
+extern void JC_JFWSystem_setAramAudioBufSize(u32 size) {
+    JFWSystem::setAramAudioBufSize(size);
+}
+
+extern void JC_JFWSystem_setAramGraphBufSize(u32 size) {
+    JFWSystem::setAramGraphBufSize(size);
+}
+
+extern void JC_JFWSystem_init() {
+    JFWSystem::init();
+}
+
+extern void* JC_JFWSystem_getSystemHeap() {
+    return JFWSystem::getSystemHeap();
+}
+
+extern void* JC_JFWSystem_getRootHeap() {
+    return JFWSystem::getRootHeap();
+}
+
+extern void* JC_JFWSystem_getSystemConsole() {
+    return JFWSystem::getSystemConsole();
+}
+
+extern void* JC_JUTProcBar_getManager() {
+    return JUTProcBar::getManager();
+}
+
+extern void JC_JUTProcBar_setVisible(void* procbar, BOOL visible) {
+    reinterpret_cast<JUTProcBar*>(procbar)->setVisible(visible);
+}
+
+extern void JC_JUTProcBar_setVisibleHeapBar(void* procbar, BOOL visible) {
+    reinterpret_cast<JUTProcBar*>(procbar)->setHeapBarVisible(visible);
+}
+
+extern int JC_JKRDecomp_checkCompressed(u8* bufp) {
+    return JKRDecomp::checkCompressed(bufp);
+}
+
+extern void JC_JKRDecomp_decode(u8* comp_bufp, u8* decomp_bufp, u32 decomp_buf_size, u32 skipCount) {
+    JKRDecomp::decode(comp_bufp, decomp_bufp, decomp_buf_size, skipCount);
+}
+
+extern void* JC__JKRGetResource(const char* resourceName) {
+    return JKRGetResource(resourceName);
+
+}
+
+extern void JC__JKRRemoveResource(void* res) {
+    JKRRemoveResource(res);
+}
+
+extern void JC__JKRDetachResource(void* ptr) {
+    JKRDetachResource(ptr);
+}
+
+extern void* JC__JKRMountArchive(const char* path, int mount_mode, void* heap, int mount_direction) {
+    return JKRMountArchive(path, (JKRArchive::EMountMode)mount_mode, reinterpret_cast<JKRHeap*>(heap), (JKRArchive::EMountDirection)mount_direction);
+}
+
+extern CSDIFileEntry* JC__JKRGetResourceEntry_byName(u32 root_name, const char* res_name, void* archive) {
+    JKRGetResourceEntry_byName(root_name, res_name, reinterpret_cast<JKRArchive*>(archive));
+}
+
+extern void JC_JKRAramHeap_dump(void* heap) {
+    reinterpret_cast<JKRAramHeap*>(heap)->dump();
+}
+
+extern void* JC_JKRAram_getAramHeap() {
+    return JKRAram::getAramHeap();
+}
+
+extern void JC_JKRAramArchive_delete(void* aram_archive) {
+    delete reinterpret_cast<JKRAramArchive*>(aram_archive);
+}
+
+extern void* JC_JKRAramArchive_new() {
+    return new JKRAramArchive();
+}
+
+extern BOOL JC__JKRMountFixedAramArchive(void* aram_archive, const char* file) {
+    return reinterpret_cast<JKRAramArchive*>(aram_archive)->mountFixed(file, JKRArchive::MOUNT_DIRECTION_HEAD);
+}
+
+extern void JC__JKRUnmountFixedAramArchive(void* aram_archive) {
+    reinterpret_cast<JKRAramArchive*>(aram_archive)->unmountFixed();
+}
+
+extern u32 JC_JKRAramArchive_getAramAddress_byName(void* archive, u32 root_name, const char* res_name) {
+    return reinterpret_cast<JKRAramArchive*>(archive)->getAramAddress(root_name, res_name);
+}
+
+extern void* JC__JKRAllocFromAram(size_t size) {
+    return JKRAllocFromAram(size, JKRAramHeap::Head);
+}
+
+extern u32 JC_JKRAramBlock_getAddress(void* aramBlock) {
+    return reinterpret_cast<JKRAramBlock*>(aramBlock)->getAddress();
+}
+
+extern u8* JC__JKRAramToMainRam_block(void* aramBlock, u8* ramDst, size_t size) {
+    return JKRAram::aramToMainRam(reinterpret_cast<JKRAramBlock*>(aramBlock), ramDst, size, 0, EXPAND_SWITCH_DEFAULT, 0, nullptr, -1, nullptr);
+}
+
+extern void* JC__JKRMainRamToAram_block(u8* ramAddr, void* aramBlock, size_t size) {
+    return JKRAram::mainRamToAram(ramAddr, reinterpret_cast<JKRAramBlock*>(aramBlock), size, EXPAND_SWITCH_DEFAULT, 0, nullptr, -1);
+}
+
+extern void* JC__JKRDvdToMainRam_byName(const char* name, u8* buf, JKRExpandSwitch expandSwitch) {
+    return JKRDvdRipper::loadToMainRAM(name, buf, expandSwitch, 0, NULL, JKRDvdRipper::ALLOC_DIR_TOP, 0, NULL);
+}
+
+extern void JC_JUTAssertion_changeDevice(int device) {
+    JUTAssertion::changeDevice(device);
+}
+
+extern void JC_JUTAssertion_changeDisplayTime(int displayTime) {
+    JUTAssertion::changeDisplayTime(displayTime);
+}
+
+extern void* JC_JUTXfb_getManager() {
+    return JUTXfb::getManager();
+}
+
+extern void JC_JUTXfb_clearIndex(void* manager) {
+    reinterpret_cast<JUTXfb*>(manager)->clearIndex();
+}

src/static/libultra/controller.c

@@ -26,7 +26,7 @@ void __osContGetInitData(u8* p, OSContStatus* s){
     u8 success;
     
     for (i = 0, success = 0; i < __osMaxControllers; i++, s++){
-        JC_JUTGamePad_getPadStatus(&npad, i);
+        npad = JC_JUTGamePad_getPadStatus(i);
 
         if (npad.err == -3) {
             s->errno = 0;