fixed up typedef for u32 and s32 from mistake long ago

.vscode/settings.json

@@ -26,6 +26,7 @@
         "type_traits": "cpp",
         "xtr1common": "cpp",
         "limits": "cpp",
-        "utility": "cpp"
+        "utility": "cpp",
+        "initializer_list": "cpp"
     }
 }

config/SOUE01/symbols.txt

@@ -280,16 +280,16 @@ getZoneFlagsMut__11FileManagerFv = .text:0x8000A630; // type:function size:0x24
 getZoneFlagsConst__11FileManagerFv = .text:0x8000A660; // type:function size:0x44
 getEnemyDefeatFlagsMut__11FileManagerFv = .text:0x8000A6B0; // type:function size:0x24
 getEnemyDefeatFlagsConst__11FileManagerFv = .text:0x8000A6E0; // type:function size:0x44
-setStoryFlags__11FileManagerFPUsUiUs = .text:0x8000A730; // type:function size:0x58
-setItemFlags__11FileManagerFPUsUiUs = .text:0x8000A790; // type:function size:0x58
-setDungeonFlags__11FileManagerFPUsUiUs = .text:0x8000A7F0; // type:function size:0x58
-setSceneFlags__11FileManagerFPUsUiUs = .text:0x8000A850; // type:function size:0x58
-setTBoxFlags__11FileManagerFPUsUiUs = .text:0x8000A8B0; // type:function size:0x58
-setTempFlags__11FileManagerFPUsUiUs = .text:0x8000A910; // type:function size:0x58
-setZoneFlags__11FileManagerFPUsUiUs = .text:0x8000A970; // type:function size:0x58
-setEnemyDefeatFlags__11FileManagerFPUsUiUs = .text:0x8000A9D0; // type:function size:0x58
+setStoryFlags__11FileManagerFPUsUlUs = .text:0x8000A730; // type:function size:0x58
+setItemFlags__11FileManagerFPUsUlUs = .text:0x8000A790; // type:function size:0x58
+setDungeonFlags__11FileManagerFPUsUlUs = .text:0x8000A7F0; // type:function size:0x58
+setSceneFlags__11FileManagerFPUsUlUs = .text:0x8000A850; // type:function size:0x58
+setTBoxFlags__11FileManagerFPUsUlUs = .text:0x8000A8B0; // type:function size:0x58
+setTempFlags__11FileManagerFPUsUlUs = .text:0x8000A910; // type:function size:0x58
+setZoneFlags__11FileManagerFPUsUlUs = .text:0x8000A970; // type:function size:0x58
+setEnemyDefeatFlags__11FileManagerFPUsUlUs = .text:0x8000A9D0; // type:function size:0x58
 getSkipFlags__11FileManagerFv = .text:0x8000AA30; // type:function size:0xC
-setSkipFlagsChecked__11FileManagerFPUsUiUs = .text:0x8000AA40; // type:function size:0x5C
+setSkipFlagsChecked__11FileManagerFPUsUlUs = .text:0x8000AA40; // type:function size:0x5C
 initFile__11FileManagerFi = .text:0x8000AAA0; // type:function size:0x124
 setCurrentHealthCapacity__11FileManagerFs = .text:0x8000ABD0; // type:function size:0x30
 getCurrentHealthCapacity__11FileManagerFv = .text:0x8000AC00; // type:function size:0x44
@@ -309,17 +309,17 @@ setAngleT2__11FileManagerFs = .text:0x8000AFD0; // type:function size:0x30
 getAngleT2__11FileManagerFv = .text:0x8000B000; // type:function size:0x44
 setAngleT3__11FileManagerFs = .text:0x8000B050; // type:function size:0x30
 getAngleT3__11FileManagerFv = .text:0x8000B080; // type:function size:0x44
-setPouchData__11FileManagerFiUi = .text:0x8000B0D0; // type:function size:0x54
+setPouchData__11FileManagerFiUl = .text:0x8000B0D0; // type:function size:0x54
 getPouchData__11FileManagerFi = .text:0x8000B130; // type:function size:0x74
 setPouchItem__11FileManagerFi7ITEM_ID = .text:0x8000B1B0; // type:function size:0x6C
 getPouchItem__11FileManagerFi = .text:0x8000B220; // type:function size:0x24
 setPouchUpperData__11FileManagerFii = .text:0x8000B250; // type:function size:0x6C
 getPouchUpperData__11FileManagerFi = .text:0x8000B2C0; // type:function size:0x24
-setItemCheckData__11FileManagerFUiUi = .text:0x8000B2F0; // type:function size:0x70
-getItemCheckData__11FileManagerFUi = .text:0x8000B360; // type:function size:0x88
-setItemCheckItem__11FileManagerFUi7ITEM_ID = .text:0x8000B3F0; // type:function size:0x84
-getItemCheckItem__11FileManagerFUi = .text:0x8000B480; // type:function size:0x24
-setItemCheckUpperData__11FileManagerFUiUi = .text:0x8000B4B0; // type:function size:0x84
+setItemCheckData__11FileManagerFUlUl = .text:0x8000B2F0; // type:function size:0x70
+getItemCheckData__11FileManagerFUl = .text:0x8000B360; // type:function size:0x88
+setItemCheckItem__11FileManagerFUl7ITEM_ID = .text:0x8000B3F0; // type:function size:0x84
+getItemCheckItem__11FileManagerFUl = .text:0x8000B480; // type:function size:0x24
+setItemCheckUpperData__11FileManagerFUlUl = .text:0x8000B4B0; // type:function size:0x84
 getItemCheckUpperData__11FileManagerFv = .text:0x8000B540; // type:function size:0x24
 setEquippedItem__11FileManagerFUc = .text:0x8000B570; // type:function size:0x30
 getEquippedItem__11FileManagerFv = .text:0x8000B5A0; // type:function size:0x44
@@ -341,12 +341,12 @@ setGuardianPotionPlusTimer__11FileManagerFs = .text:0x8000B970; // type:function
 getGuardianPotionPlusTimer__11FileManagerFv = .text:0x8000B9A0; // type:function size:0x44
 setDowsingSlotIdx__11FileManagerFUc = .text:0x8000B9F0; // type:function size:0x30
 getDowsingSlotIdx__11FileManagerFv = .text:0x8000BA20; // type:function size:0x44
-setBeaconPos__11FileManagerFUiUiP7mVec3_c = .text:0x8000BA70; // type:function size:0x104
-getBeaconPos__11FileManagerFUiUi = .text:0x8000BB80; // type:function size:0xEC
-setEnemyKillCount__11FileManagerFUiUs = .text:0x8000BC70; // type:function size:0x70
-getEnemyKillCount__11FileManagerFUi = .text:0x8000BCE0; // type:function size:0x80
-setHitCountFromEnemy__11FileManagerFUiUs = .text:0x8000BD60; // type:function size:0x70
-getHitCountFromEnemy__11FileManagerFUi = .text:0x8000BDD0; // type:function size:0x80
+setBeaconPos__11FileManagerFUlUlP7mVec3_c = .text:0x8000BA70; // type:function size:0x104
+getBeaconPos__11FileManagerFUlUl = .text:0x8000BB80; // type:function size:0xEC
+setEnemyKillCount__11FileManagerFUlUs = .text:0x8000BC70; // type:function size:0x70
+getEnemyKillCount__11FileManagerFUl = .text:0x8000BCE0; // type:function size:0x80
+setHitCountFromEnemy__11FileManagerFUlUs = .text:0x8000BD60; // type:function size:0x70
+getHitCountFromEnemy__11FileManagerFUl = .text:0x8000BDD0; // type:function size:0x80
 setLoadRoomT1_FileB__11FileManagerFs = .text:0x8000BE50; // type:function size:0x30
 getLoadRoomT1_FileB__11FileManagerFv = .text:0x8000BE80; // type:function size:0xC
 setEntranceT1_FileB__11FileManagerFUc = .text:0x8000BE90; // type:function size:0x30
@@ -388,16 +388,16 @@ setFileTimes__11FileManagerFv = .text:0x8000CC50; // type:function size:0x54
 setPlayTime__11FileManagerFx = .text:0x8000CCB0; // type:function size:0x40
 getSavedTime__11FileManagerFv = .text:0x8000CCF0; // type:function size:0x48
 setSavedTime__11FileManagerFx = .text:0x8000CD40; // type:function size:0x40
-setBeedleShopPathSegment__11FileManagerFUi = .text:0x8000CD80; // type:function size:0x30
+setBeedleShopPathSegment__11FileManagerFUl = .text:0x8000CD80; // type:function size:0x30
 getBeedleShopPathSegment__11FileManagerFv = .text:0x8000CDB0; // type:function size:0x44
 setBeedleShopPathSegFrac__11FileManagerFf = .text:0x8000CE00; // type:function size:0x30
 getBeedleShopPathSegFrac__11FileManagerFv = .text:0x8000CE30; // type:function size:0x44
 setBeedleShopRotation__11FileManagerFs = .text:0x8000CE80; // type:function size:0x30
 getBeedleShopRotation__11FileManagerFv = .text:0x8000CEB0; // type:function size:0x44
-fn_8000CF00__11FileManagerFUi = .text:0x8000CF00; // type:function size:0x70
-fn_8000CF70__11FileManagerFUi = .text:0x8000CF70; // type:function size:0x6C
-setSkykeepPuzzle__11FileManagerFUiUc = .text:0x8000CFE0; // type:function size:0x58
-getSkykeepPuzzleTile__11FileManagerFUi = .text:0x8000D040; // type:function size:0x6C
+fn_8000CF00__11FileManagerFUl = .text:0x8000CF00; // type:function size:0x70
+fn_8000CF70__11FileManagerFUl = .text:0x8000CF70; // type:function size:0x6C
+setSkykeepPuzzle__11FileManagerFUlUc = .text:0x8000CFE0; // type:function size:0x58
+getSkykeepPuzzleTile__11FileManagerFUl = .text:0x8000D040; // type:function size:0x6C
 checkFileStatus__11FileManagerFv = .text:0x8000D0B0; // type:function size:0x114
 checkSkipDataCRCs__11FileManagerFv = .text:0x8000D1D0; // type:function size:0x9C
 saveOrClearSelectedFileToFileA__11FileManagerFv = .text:0x8000D270; // type:function size:0xC
@@ -424,7 +424,7 @@ getCurrentFile__11FileManagerFv = .text:0x80011210; // type:function size:0x40
 getSkipFlags2__11FileManagerFv = .text:0x80011250; // type:function size:0xC
 getFileA__11FileManagerFv = .text:0x80011260; // type:function size:0x8
 getFileB__11FileManagerFv = .text:0x80011270; // type:function size:0x8
-calcFileCRC__11FileManagerFPCvUi = .text:0x80011280; // type:function size:0xC
+calcFileCRC__11FileManagerFPCvUl = .text:0x80011280; // type:function size:0xC
 updateEmptyFiles__11FileManagerFv = .text:0x80011290; // type:function size:0x34
 updateEmptyFileFlags__11FileManagerFv = .text:0x800112D0; // type:function size:0x9C
 isFileEmpty__11FileManagerFi = .text:0x80011370; // type:function size:0x20
@@ -498,7 +498,7 @@ fn_800146E0 = .text:0x800146E0; // type:function size:0x38
 fn_80014720 = .text:0x80014720; // type:function size:0x228
 fn_80014950 = .text:0x80014950; // type:function size:0x5C
 fn_800149B0 = .text:0x800149B0; // type:function size:0x478
-isTriggered__Q23EGG14CoreControllerFUi = .text:0x80014E30; // type:function size:0x18
+isTriggered__Q23EGG14CoreControllerFUl = .text:0x80014E30; // type:function size:0x18
 fn_80014E50 = .text:0x80014E50; // type:function size:0x54
 fn_80014EB0 = .text:0x80014EB0; // type:function size:0x3C4
 fn_80015280 = .text:0x80015280; // type:function size:0x1C
@@ -1030,7 +1030,7 @@ createHeap__9dAcBase_cFv = .text:0x8002C3A0; // type:function size:0x8
 __ct__9dAcBase_cFv = .text:0x8002C3B0; // type:function size:0x178
 __dt__7dBase_cFv = .text:0x8002C530; // type:function size:0x58
 __dt__9dAcBase_cFv = .text:0x8002C590; // type:function size:0xB4
-setTempCreateParams__9dAcBase_cFP7mVec3_cP7mAng3_cP7mVec3_ciUiP9dAcBase_cUcsUcP7ObjInfo = .text:0x8002C650; // type:function size:0x34
+setTempCreateParams__9dAcBase_cFP7mVec3_cP7mAng3_cP7mVec3_ciUlP9dAcBase_cUcsUcP7ObjInfo = .text:0x8002C650; // type:function size:0x34
 FUN_8002c690__9dAcBase_cFv = .text:0x8002C690; // type:function size:0x78
 initAllocatorWork1Heap__9dAcBase_cFiPci = .text:0x8002C710; // type:function size:0xC
 initAllocator__9dAcBase_cFiPcPQ23EGG4Heapi = .text:0x8002C720; // type:function size:0x8C
@@ -1052,10 +1052,10 @@ restorePosRotFromCopy__9dAcBase_cFv = .text:0x8002CEB0; // type:function size:0x
 itemDroppingAndGivingRelated__9dAcBase_cFP5Vec3fi = .text:0x8002CF10; // type:function size:0x80
 fillUpperParams2Byte__9dAcBase_cFv = .text:0x8002CF90; // type:function size:0x10
 getParams2_ignoreLower__9dAcBase_cFv = .text:0x8002CFA0; // type:function size:0xC
-setParams2Upper_ignoreLower__9dAcBase_cFUi = .text:0x8002CFB0; // type:function size:0xC
+setParams2Upper_ignoreLower__9dAcBase_cFUl = .text:0x8002CFB0; // type:function size:0xC
 getParams2UpperByte__9dAcBase_cFv = .text:0x8002CFC0; // type:function size:0xC
-setParams2UpperByte__9dAcBase_cFUi = .text:0x8002CFD0; // type:function size:0x14
-buildParams2__9dAcBase_cFUiUc = .text:0x8002CFF0; // type:function size:0x1C
+setParams2UpperByte__9dAcBase_cFUl = .text:0x8002CFD0; // type:function size:0x14
+buildParams2__9dAcBase_cFUlUc = .text:0x8002CFF0; // type:function size:0x1C
 getParams2Lower__9dAcBase_cFv = .text:0x8002D010; // type:function size:0xC
 findActor__9dAcBase_cFPcP9dAcBase_c = .text:0x8002D020; // type:function size:0x74
 searchActor__9dAcBase_cFR9dAcBase_c = .text:0x8002D0A0; // type:function size:0x88
@@ -1090,8 +1090,8 @@ setActorRef__9dAcBase_cFP7dBase_c = .text:0x8002D920; // type:function size:0x8
 setUnkFlag__9dAcBase_cFv = .text:0x8002D930; // type:function size:0x10
 FUN_8002d940__9dAcBase_cFv = .text:0x8002D940; // type:function size:0x14
 FUN_8002d960__9dAcBase_cFv = .text:0x8002D960; // type:function size:0x14
-createActor__9dAcBase_cFUsUiP5Vec3fP5Vec3sP5Vec3fUiiP7dBase_c = .text:0x8002D980; // type:function size:0xF4
-createActorUnkGroup3__9dAcBase_cFUsUiP5Vec3fP5Vec3sP5Vec3fUiiP7dBase_c = .text:0x8002DA80; // type:function size:0xF4
+createActor__9dAcBase_cFUsUlP5Vec3fP5Vec3sP5Vec3fUliP7dBase_c = .text:0x8002D980; // type:function size:0xF4
+createActorUnkGroup3__9dAcBase_cFUsUlP5Vec3fP5Vec3sP5Vec3fUliP7dBase_c = .text:0x8002DA80; // type:function size:0xF4
 getCurrentEventActor__9dAcBase_cFv = .text:0x8002DB80; // type:function size:0x4
 unkVirtFunc_0x6C__9dAcBase_cFv = .text:0x8002DB90; // type:function size:0x4
 doInteraction__9dAcBase_cFi = .text:0x8002DBA0; // type:function size:0x80
@@ -2370,7 +2370,7 @@ fn_800597A0 = .text:0x800597A0; // type:function size:0x18
 fn_800597C0 = .text:0x800597C0; // type:function size:0x18
 fn_800597E0 = .text:0x800597E0; // type:function size:0x18
 fn_80059800 = .text:0x80059800; // type:function size:0x18
-isPressed__Q23EGG14CoreControllerFUi = .text:0x80059820; // type:function size:0x18
+isPressed__Q23EGG14CoreControllerFUl = .text:0x80059820; // type:function size:0x18
 isAllPressed__Q23EGG14CoreControllerFv = .text:0x80059840; // type:function size:0x18
 fn_80059860 = .text:0x80059860; // type:function size:0x18
 fn_80059880 = .text:0x80059880; // type:function size:0x18
@@ -2388,7 +2388,7 @@ isReleased__Q23EGG14CoreControllerFv = .text:0x800599E0; // type:function size:0
 fn_80059A00 = .text:0x80059A00; // type:function size:0x18
 fn_80059A20 = .text:0x80059A20; // type:function size:0x18
 fn_80059A40 = .text:0x80059A40; // type:function size:0x18
-isAnyPressed__Q23EGG14CoreControllerFUi = .text:0x80059A60; // type:function size:0x1C
+isAnyPressed__Q23EGG14CoreControllerFUl = .text:0x80059A60; // type:function size:0x1C
 isNotPressed__Q23EGG14CoreControllerFv = .text:0x80059A80; // type:function size:0x14
 fn_80059AA0 = .text:0x80059AA0; // type:function size:0x18
 fn_80059AC0 = .text:0x80059AC0; // type:function size:0x8
@@ -4072,9 +4072,9 @@ doNothing__16SceneflagManagerFv = .text:0x800BD8C0; // type:function size:0x4
 setShouldCommit__16SceneflagManagerFUs = .text:0x800BD8D0; // type:function size:0xC
 __ct__16SceneflagManagerFv = .text:0x800BD8E0; // type:function size:0x64
 isNotTempOrZoneFlag__16SceneflagManagerFUs = .text:0x800BD950; // type:function size:0xC
-isZoneFlag__16SceneflagManagerFUi = .text:0x800BD960; // type:function size:0x20
+isZoneFlag__16SceneflagManagerFUl = .text:0x800BD960; // type:function size:0x20
 updateFlagindex__16SceneflagManagerFUs = .text:0x800BD980; // type:function size:0x70
-copyFromSave__16SceneflagManagerFUi = .text:0x800BD9F0; // type:function size:0x94
+copyFromSave__16SceneflagManagerFUl = .text:0x800BD9F0; // type:function size:0x94
 unsetAllTempflags__16SceneflagManagerFv = .text:0x800BDA90; // type:function size:0x40
 zoneflagsResetAll__16SceneflagManagerFv = .text:0x800BDAD0; // type:function size:0x40
 zoneflagsResetForRoom__16SceneflagManagerFUs = .text:0x800BDB10; // type:function size:0x4C
@@ -4129,13 +4129,13 @@ copyFromSaveFile2__9FlagSpaceFPUsUsUs = .text:0x800BEED0; // type:function size:
 copyFromSaveFile__9FlagSpaceFPUsUsUs = .text:0x800BEF50; // type:function size:0x20
 filemanagerCheck__9FlagSpaceFv = .text:0x800BEF70; // type:function size:0x20
 calculateMask__12UnkFlagStuffFi = .text:0x800BEF90; // type:function size:0x18
-doNothing__12UnkFlagStuffFUi = .text:0x800BEFB0; // type:function size:0x4
+doNothing__12UnkFlagStuffFUl = .text:0x800BEFB0; // type:function size:0x4
 __ct__12UnkFlagStuffFUsP17UnkFlagDefinition = .text:0x800BEFC0; // type:function size:0xC
-prepareIndexShiftMask__12UnkFlagStuffFUsUiPUsPUcPUs = .text:0x800BEFD0; // type:function size:0x80
+prepareIndexShiftMask__12UnkFlagStuffFUsUlPUsPUcPUs = .text:0x800BEFD0; // type:function size:0x80
 maskForIdx__12UnkFlagStuffFUs = .text:0x800BF050; // type:function size:0x50
-getCounterOrFlag__12UnkFlagStuffFUsPUsUi = .text:0x800BF0A0; // type:function size:0x68
-setCounterOrFlag__12UnkFlagStuffFUsPUsUiUi = .text:0x800BF110; // type:function size:0x9C
-checkFlagValid__12UnkFlagStuffFUsUi = .text:0x800BF1B0; // type:function size:0x50
+getCounterOrFlag__12UnkFlagStuffFUsPUsUl = .text:0x800BF0A0; // type:function size:0x68
+setCounterOrFlag__12UnkFlagStuffFUsPUsUlUl = .text:0x800BF110; // type:function size:0x9C
+checkFlagValid__12UnkFlagStuffFUsUl = .text:0x800BF1B0; // type:function size:0x50
 checkFlag__17BitwiseFlagHelperFUsUsPCUsUs = .text:0x800BF200; // type:function size:0x14
 setFlag__17BitwiseFlagHelperFUsUsPUsUs = .text:0x800BF220; // type:function size:0x20
 unsetFlag__17BitwiseFlagHelperFUsUsPUsUs = .text:0x800BF240; // type:function size:0x24
@@ -4176,7 +4176,7 @@ setCommitFlag__18DungeonflagManagerFUs = .text:0x800BF930; // type:function size
 __ct__18DungeonflagManagerFv = .text:0x800BF940; // type:function size:0x3C
 setupFlagStuff__18DungeonflagManagerFv = .text:0x800BF980; // type:function size:0x54
 copyFromSave__18DungeonflagManagerFs = .text:0x800BF9E0; // type:function size:0xC
-setToValue__18DungeonflagManagerFUsUi = .text:0x800BF9F0; // type:function size:0x6C
+setToValue__18DungeonflagManagerFUsUl = .text:0x800BF9F0; // type:function size:0x6C
 setFlag__18DungeonflagManagerFUs = .text:0x800BFA60; // type:function size:0x60
 getDungeonFlag__18DungeonflagManagerFUs = .text:0x800BFAC0; // type:function size:0x50
 doCommit__18DungeonflagManagerFv = .text:0x800BFB10; // type:function size:0x8C
@@ -9354,7 +9354,7 @@ fn_8016CB40 = .text:0x8016CB40; // type:function size:0x1C
 fn_8016CB60 = .text:0x8016CB60; // type:function size:0x78
 fn_8016CBE0 = .text:0x8016CBE0; // type:function size:0x3C
 fn_8016CC20 = .text:0x8016CC20; // type:function size:0x14
-checkedAdd__7CounterFi = .text:0x8016CC40; // type:function size:0xF0
+checkedAdd__7CounterFl = .text:0x8016CC40; // type:function size:0xF0
 getCommittedValue__7CounterFv = .text:0x8016CD30; // type:function size:0x20
 getUncommittedValue__7CounterFv = .text:0x8016CD50; // type:function size:0x20
 setValue__7CounterFUs = .text:0x8016CD70; // type:function size:0x24
@@ -17710,7 +17710,7 @@ fn_802EE4A0 = .text:0x802EE4A0; // type:function size:0x70
 fn_802EE510 = .text:0x802EE510; // type:function size:0x4C
 adjustFrmHeapRestoreCurrent__16mHeapAllocator_cFv = .text:0x802EE560; // type:function size:0x64
 fn_802EE5D0 = .text:0x802EE5D0; // type:function size:0x1C
-step__4mAngFsiss = .text:0x802EE5F0; // type:function size:0xA4
+step__4mAngFslss = .text:0x802EE5F0; // type:function size:0xA4
 __sinit_\m_angle_cpp = .text:0x802EE6A0; // type:function size:0x18 scope:local
 fn_802EE6C0 = .text:0x802EE6C0; // type:function size:0x114
 fn_802EE7E0 = .text:0x802EE7E0; // type:function size:0x44
@@ -17813,21 +17813,21 @@ fn_802F08E0 = .text:0x802F08E0; // type:function size:0x370
 fn_802F0C50 = .text:0x802F0C50; // type:function size:0x160
 fn_802F0DB0 = .text:0x802F0DB0; // type:function size:0x8
 fn_802F0DC0 = .text:0x802F0DC0; // type:function size:0x13C
-copyAttribute__5mHeapFUi = .text:0x802F0F00; // type:function size:0x34
+copyAttribute__5mHeapFUl = .text:0x802F0F00; // type:function size:0x34
 setCurrentHeap__5mHeapFPQ23EGG4Heap = .text:0x802F0F40; // type:function size:0x4
 createExpHeap__5mHeapFUlPQ23EGG4HeapPCcUlUl = .text:0x802F0F50; // type:function size:0x10C
 adjustExpHeap__5mHeapFPQ23EGG7ExpHeap = .text:0x802F1060; // type:function size:0x68
-expHeapCost__5mHeapFUli = .text:0x802F10D0; // type:function size:0x18
+expHeapCost__5mHeapFUlUl = .text:0x802F10D0; // type:function size:0x18
 createFrmHeap__5mHeapFUlPQ23EGG4HeapPCcUlUl = .text:0x802F10F0; // type:function size:0x10C
 destroyFrmHeap__5mHeapFPQ23EGG7FrmHeap = .text:0x802F1200; // type:function size:0x1C
 adjustFrmHeap__5mHeapFPQ23EGG7FrmHeap = .text:0x802F1220; // type:function size:0x68
-frmHeapCost__5mHeapFUli = .text:0x802F1290; // type:function size:0x18
-setTempHeap__5mHeapFPPQ23EGG4HeapPQ23EGG4Heap = .text:0x802F12B0; // type:function size:0x38
-restoreTempHeap__5mHeapFPPQ23EGG4Heapi = .text:0x802F12F0; // type:function size:0x58
+frmHeapCost__5mHeapFUlUl = .text:0x802F1290; // type:function size:0x18
+__ct__5mHeapFPQ23EGG4Heap = .text:0x802F12B0; // type:function size:0x38
+__dt__5mHeapFv = .text:0x802F12F0; // type:function size:0x58
 createHeap__5mHeapFUlPQ23EGG4HeapPCc = .text:0x802F1350; // type:function size:0x74
 saveCurrentHeap__5mHeapFv = .text:0x802F13D0; // type:function size:0xC
 restoreCurrentHeap__5mHeapFv = .text:0x802F13E0; // type:function size:0x2C
-makeFrmHeapAndUpdate__5mHeapFUlPQ23EGG4HeapPCciUi = .text:0x802F1410; // type:function size:0x40
+makeFrmHeapAndUpdate__5mHeapFUlPQ23EGG4HeapPCcUlUl = .text:0x802F1410; // type:function size:0x40
 getDefaultGameHeapId__5mHeapFv = .text:0x802F1450; // type:function size:0x8
 createGameHeap__5mHeapFiUlPQ23EGG4Heap = .text:0x802F1460; // type:function size:0xAC
 createGameHeap1__5mHeapFUlPQ23EGG4Heap = .text:0x802F1510; // type:function size:0x44
@@ -17835,7 +17835,7 @@ createArchiveHeap__5mHeapFUlPQ23EGG4Heap = .text:0x802F1560; // type:function si
 createCommandHeap__5mHeapFUlPQ23EGG4Heap = .text:0x802F1590; // type:function size:0x2C
 createDylinkHeap__5mHeapFUlPQ23EGG4Heap = .text:0x802F15C0; // type:function size:0x2C
 createAssertHeap__5mHeapFPQ23EGG4Heap = .text:0x802F15F0; // type:function size:0x50
-makeHeapOnCurrentGameHeap__5mHeapFUlPciUi = .text:0x802F1640; // type:function size:0x20
+makeHeapOnCurrentGameHeap__5mHeapFUlPCcUlUl = .text:0x802F1640; // type:function size:0x20
 fn_802F1660 = .text:0x802F1660; // type:function size:0x44
 fn_802F16B0 = .text:0x802F16B0; // type:function size:0xBC
 fn_802F1770 = .text:0x802F1770; // type:function size:0x4C
@@ -24182,7 +24182,7 @@ XStrToU32___Q24nw4r2dbFPCUc = .text:0x80436D20; // type:function size:0xCC
 CopySymbol___Q24nw4r2dbFPCUcPUcUlUc = .text:0x80436DF0; // type:function size:0x2DC
 QuerySymbolToMapFile___Q24nw4r2dbFPUcPC12OSModuleInfoUlPUcUl = .text:0x804370D0; // type:function size:0xD8
 QuerySymbolToSingleMapFile___Q24nw4r2dbFPQ34nw4r2db7MapFileUlPUcUl = .text:0x804371B0; // type:function size:0xF8
-MapFile_QuerySymbol__Q24nw4r2dbFPvPcUi = .text:0x804372B0; // type:function size:0x104
+MapFile_QuerySymbol__Q24nw4r2dbFPvPcUl = .text:0x804372B0; // type:function size:0x104
 Assertion_SetConsole__Q24nw4r2dbFPQ44nw4r2db6detail11ConsoleHead = .text:0x804373C0; // type:function size:0x10
 FExp__Q34nw4r4math6detailFf = .text:0x804373D0; // type:function size:0xAC
 FLog__Q34nw4r4math6detailFf = .text:0x80437480; // type:function size:0xA4
@@ -25367,9 +25367,9 @@ CallSeqUserprocCallback__Q44nw4r3snd6detail9SeqPlayerFUsPQ44nw4r3snd6detail8SeqT
 GetLocalVariable__Q44nw4r3snd6detail9SeqPlayerCFi = .text:0x80471B80; // type:function size:0x10
 SetLocalVariable__Q44nw4r3snd6detail9SeqPlayerFis = .text:0x80471B90; // type:function size:0x10
 SetGlobalVariable__Q44nw4r3snd6detail9SeqPlayerFis = .text:0x80471BA0; // type:function size:0x14
-SetTrackMute__Q44nw4r3snd6detail9SeqPlayerFUiQ34nw4r3snd7SeqMute = .text:0x80471BC0; // type:function size:0xBC
-SetTrackSilence__Q44nw4r3snd6detail9SeqPlayerFUibi = .text:0x80471C80; // type:function size:0xC4
-SetTrackVolume__Q44nw4r3snd6detail9SeqPlayerFUif = .text:0x80471D50; // type:function size:0xD4
+SetTrackMute__Q44nw4r3snd6detail9SeqPlayerFUlQ34nw4r3snd7SeqMute = .text:0x80471BC0; // type:function size:0xBC
+SetTrackSilence__Q44nw4r3snd6detail9SeqPlayerFUlbi = .text:0x80471C80; // type:function size:0xC4
+SetTrackVolume__Q44nw4r3snd6detail9SeqPlayerFUlf = .text:0x80471D50; // type:function size:0xD4
 InvalidateData__Q44nw4r3snd6detail9SeqPlayerFPCvPCv = .text:0x80471E30; // type:function size:0x1BC
 GetPlayerTrack__Q44nw4r3snd6detail9SeqPlayerFi = .text:0x80471FF0; // type:function size:0x20
 ParseNextTick__Q44nw4r3snd6detail9SeqPlayerFb = .text:0x80472010; // type:function size:0x12C
@@ -25395,9 +25395,9 @@ SetChannelPriority__Q44nw4r3snd6detail8SeqSoundFi = .text:0x80472D10; // type:fu
 SetReleasePriorityFix__Q44nw4r3snd6detail8SeqSoundFb = .text:0x80472D20; // type:function size:0x8
 SetSeqUserprocCallback__Q44nw4r3snd6detail8SeqSoundFPFUsPQ34nw4r3snd24SeqUserprocCallbackParamPv_vPv = .text:0x80472D30; // type:function size:0x8
 OnUpdatePlayerPriority__Q44nw4r3snd6detail8SeqSoundFv = .text:0x80472D40; // type:function size:0xE4
-SetTrackMute__Q44nw4r3snd6detail8SeqSoundFUiQ34nw4r3snd7SeqMute = .text:0x80472E30; // type:function size:0x8
-SetTrackSilence__Q44nw4r3snd6detail8SeqSoundFUibi = .text:0x80472E40; // type:function size:0x8
-SetTrackVolume__Q44nw4r3snd6detail8SeqSoundFUif = .text:0x80472E50; // type:function size:0x8
+SetTrackMute__Q44nw4r3snd6detail8SeqSoundFUlQ34nw4r3snd7SeqMute = .text:0x80472E30; // type:function size:0x8
+SetTrackSilence__Q44nw4r3snd6detail8SeqSoundFUlbi = .text:0x80472E40; // type:function size:0x8
+SetTrackVolume__Q44nw4r3snd6detail8SeqSoundFUlf = .text:0x80472E50; // type:function size:0x8
 ReadVariable__Q44nw4r3snd6detail8SeqSoundCFiPs = .text:0x80472E60; // type:function size:0x50
 WriteVariable__Q44nw4r3snd6detail8SeqSoundFis = .text:0x80472EB0; // type:function size:0x2C
 FUN_80472ee0 = .text:0x80472EE0; // type:function size:0x28
@@ -26184,12 +26184,12 @@ getUncompressedSize__Q23EGG14StreamDecompRLFPCv = .text:0x80495290; // type:func
 getHeaderSize__Q23EGG14StreamDecompRLFv = .text:0x804952A0; // type:function size:0x8
 getUncompressedSize__Q23EGG14StreamDecompLZFPCv = .text:0x804952B0; // type:function size:0x8
 getHeaderSize__Q23EGG14StreamDecompLZFv = .text:0x804952C0; // type:function size:0x8
-MEM_AllocFor_Heap__FP12MEMAllocatorUi = .text:0x804952D0; // type:function size:0x1C scope:local
+MEM_AllocFor_Heap__FP12MEMAllocatorUl = .text:0x804952D0; // type:function size:0x1C scope:local
 MEM_FreeFor_Heap__FP12MEMAllocatorPv = .text:0x804952F0; // type:function size:0x14 scope:local
-MEMInitAllocatorFor_Heap__FP12MEMAllocatoriPv = .text:0x80495310; // type:function size:0x1C
-__ct__Q23EGG9AllocatorFPQ23EGG4Heapi = .text:0x80495330; // type:function size:0x50
+MEMInitAllocatorFor_Heap__FP12MEMAllocatorlPv = .text:0x80495310; // type:function size:0x1C
+__ct__Q23EGG9AllocatorFPQ23EGG4Heapl = .text:0x80495330; // type:function size:0x50
 __dt__Q23EGG9AllocatorFv = .text:0x80495380; // type:function size:0x40
-alloc__Q23EGG9AllocatorFUi = .text:0x804953C0; // type:function size:0x14
+alloc__Q23EGG9AllocatorFUl = .text:0x804953C0; // type:function size:0x14
 free__Q23EGG9AllocatorFPv = .text:0x804953E0; // type:function size:0x10
 initialize__Q23EGG4HeapFv = .text:0x804953F0; // type:function size:0x40
 __ct__Q23EGG4HeapFP12MEMiHeapHead = .text:0x80495430; // type:function size:0x90
@@ -26204,7 +26204,7 @@ dump__Q23EGG4HeapFv = .text:0x804958A0; // type:function size:0x4
 dumpAll__Q23EGG4HeapFv = .text:0x804958B0; // type:function size:0xEC
 becomeCurrentHeap__Q23EGG4HeapFv = .text:0x804959A0; // type:function size:0x58
 _becomeCurrentHeapWithoutLock__Q23EGG4HeapFv = .text:0x80495A00; // type:function size:0x3C
-initAllocator__Q23EGG4HeapFPQ23EGG9Allocatori = .text:0x80495A40; // type:function size:0x14
+initAllocator__Q23EGG4HeapFPQ23EGG9Allocatorl = .text:0x80495A40; // type:function size:0x14
 __nw__FUlPv = .text:0x80495A60; // type:function size:0x8
 __nw__FUlPQ23EGG4Heapi = .text:0x80495A70; // type:function size:0x10
 __nw__FUlPQ23EGG9Allocator = .text:0x80495A80; // type:function size:0x10
@@ -26215,9 +26215,9 @@ __dt__Q23EGG7ExpHeapFv = .text:0x80495AF0; // type:function size:0x74
 create__Q23EGG7ExpHeapFPvUlUs = .text:0x80495B70; // type:function size:0xB8
 create__Q23EGG7ExpHeapFUlPQ23EGG4HeapUs = .text:0x80495C30; // type:function size:0xCC
 destroy__Q23EGG7ExpHeapFv = .text:0x80495D00; // type:function size:0x88
-alloc__Q23EGG7ExpHeapFUii = .text:0x80495D90; // type:function size:0xB8
+alloc__Q23EGG7ExpHeapFUll = .text:0x80495D90; // type:function size:0xB8
 free__Q23EGG7ExpHeapFPv = .text:0x80495E50; // type:function size:0x68
-resizeForMBlock__Q23EGG7ExpHeapFPvUi = .text:0x80495EC0; // type:function size:0x8
+resizeForMBlock__Q23EGG7ExpHeapFPvUl = .text:0x80495EC0; // type:function size:0x8
 getTotalFreeSize__Q23EGG7ExpHeapFv = .text:0x80495ED0; // type:function size:0x8
 getAllocatableSize__Q23EGG7ExpHeapFi = .text:0x80495EE0; // type:function size:0x8
 setGroupID__Q23EGG7ExpHeapFUs = .text:0x80495EF0; // type:function size:0x8
@@ -26253,7 +26253,7 @@ getSize__Q23EGG10AssertHeapFv = .text:0x80496810; // type:function size:0x8
 getHeapKind__Q23EGG10AssertHeapCFv = .text:0x80496820; // type:function size:0x8
 __ct__Q23EGG8DisposerFv = .text:0x80496830; // type:function size:0x54
 __dt__Q23EGG8DisposerFv = .text:0x80496890; // type:function size:0x74
-__ct__Q23EGG6ThreadFUiiiPQ23EGG4Heap = .text:0x80496910; // type:function size:0xD0
+__ct__Q23EGG6ThreadFUliiPQ23EGG4Heap = .text:0x80496910; // type:function size:0xD0
 __ct__Q23EGG6ThreadFP8OSThreadi = .text:0x804969E0; // type:function size:0x74
 __dt__Q23EGG6ThreadFv = .text:0x80496A60; // type:function size:0xBC
 findThread__Q23EGG6ThreadFP8OSThread = .text:0x80496B20; // type:function size:0x64
@@ -26299,7 +26299,7 @@ getTickPerFrame__Q23EGG12AsyncDisplayFv = .text:0x804982D0; // type:function siz
 clearEFB__Q23EGG12AsyncDisplayFUsUsUsUsUsUsQ34nw4r2ut5Color = .text:0x804982F0; // type:function size:0x398
 initialize__Q23EGG5VideoFP16_GXRenderModeObjPCQ33EGG5Video16RenderModeObjSet = .text:0x80498690; // type:function size:0x54
 configure__Q23EGG5VideoFP16_GXRenderModeObjPCQ33EGG5Video16RenderModeObjSet = .text:0x804986F0; // type:function size:0x104
-getTickPerVRetrace__Q23EGG5VideoFUi = .text:0x80498800; // type:function size:0x60
+getTickPerVRetrace__Q23EGG5VideoFUl = .text:0x80498800; // type:function size:0x60
 getTickPerVRetrace__Q23EGG5VideoFv = .text:0x80498860; // type:function size:0x24
 getStandardRenderModeObj__Q23EGG5VideoFPCQ33EGG5Video16RenderModeObjSet = .text:0x80498890; // type:function size:0x148
 init__Q23EGG3XfbFUsUsPQ23EGG4Heap = .text:0x804989E0; // type:function size:0x74
@@ -26309,9 +26309,9 @@ isRegisterd__Q23EGG10XfbManagerCFRQ23EGG3Xfb = .text:0x80498AF0; // type:functio
 attach__Q23EGG10XfbManagerFPQ23EGG3Xfb = .text:0x80498B30; // type:function size:0xE0
 copyEFB__Q23EGG10XfbManagerFb = .text:0x80498C10; // type:function size:0xE8
 setNextFrameBuffer__Q23EGG10XfbManagerFv = .text:0x80498D00; // type:function size:0x120
-create__Q23EGG12GraphicsFifoFUiPQ23EGG4Heap = .text:0x80498E20; // type:function size:0x68
+create__Q23EGG12GraphicsFifoFUlPQ23EGG4Heap = .text:0x80498E20; // type:function size:0x68
 __dt__Q23EGG12GraphicsFifoFv = .text:0x80498E90; // type:function size:0x98
-__ct__Q23EGG12GraphicsFifoFUiPQ23EGG4Heap = .text:0x80498F30; // type:function size:0x60
+__ct__Q23EGG12GraphicsFifoFUlPQ23EGG4Heap = .text:0x80498F30; // type:function size:0x60
 init__Q23EGG10CoreStatusFv = .text:0x80498F90; // type:function size:0xC
 getFSStickButton__Q23EGG10CoreStatusCFv = .text:0x80498FA0; // type:function size:0xAC
 __ct__Q23EGG14CoreControllerFv = .text:0x80499050; // type:function size:0x60
@@ -26378,7 +26378,7 @@ fromQuat__Q23EGG9Matrix34fFRCQ23EGG5Quatf = .text:0x8049AE90; // type:function s
 toQuat__Q23EGG9Matrix34fCFRQ23EGG5Quatf = .text:0x8049AF40; // type:function size:0x310
 slerpTo__Q23EGG9Matrix34fCFRCQ23EGG9Matrix34fRQ23EGG9Matrix34ff = .text:0x8049B250; // type:function size:0x78
 setAxisRotation__Q23EGG9Matrix34fFRCQ23EGG8Vector3ff = .text:0x8049B2D0; // type:function size:0x3C
-loadPosMtx__Q23EGG9Matrix34fFUi = .text:0x8049B310; // type:function size:0x4
+loadPosMtx__Q23EGG9Matrix34fFUl = .text:0x8049B310; // type:function size:0x4
 multiplyTo__Q23EGG9Matrix34fCFRCQ23EGG9Matrix34fRQ23EGG9Matrix34f = .text:0x8049B320; // type:function size:0x4
 __sinit_\eggMatrix_cpp = .text:0x8049B330; // type:function size:0x58 scope:local
 set__Q23EGG5QuatfFffff = .text:0x8049B390; // type:function size:0x14
@@ -26394,15 +26394,15 @@ normalise__Q23EGG8Vector3fFv = .text:0x8049BCC0; // type:function size:0x84
 setLength__Q23EGG8Vector3fFRCQ23EGG8Vector3ff = .text:0x8049BD50; // type:function size:0xB8
 setLength__Q23EGG8Vector3fFf = .text:0x8049BE10; // type:function size:0xA0
 __sinit_\eggVector_cpp = .text:0x8049BEB0; // type:function size:0xE0 scope:local
-wait__Q23EGG6AssertFUi = .text:0x8049BF90; // type:function size:0x78
+wait__Q23EGG6AssertFUl = .text:0x8049BF90; // type:function size:0x78
 system_vreport__Q23EGG6AssertFPCcP16__va_list_struct = .text:0x8049C010; // type:function size:0x4
 system_report__Q23EGG6AssertFPCce = .text:0x8049C020; // type:function size:0x80
 getPeriodPos__Q23EGG6AssertFPCc = .text:0x8049C0A0; // type:function size:0x54
 getMapSymbol__Q23EGG6AssertFPv = .text:0x8049C100; // type:function size:0x44
-isOutsideMEM1__Q23EGG6AssertFUi = .text:0x8049C150; // type:function size:0x2C
+isOutsideMEM1__Q23EGG6AssertFUl = .text:0x8049C150; // type:function size:0x2C
 setAssertCallback__Q23EGG6AssertFPFv_v = .text:0x8049C180; // type:function size:0x10
-system_halt__Q23EGG6AssertFPCcUiPCcP16__va_list_struct = .text:0x8049C190; // type:function size:0x398
-assert__Q23EGG6AssertFPCcUiPCce = .text:0x8049C530; // type:function size:0x8C
+system_halt__Q23EGG6AssertFPCcUlPCcP16__va_list_struct = .text:0x8049C190; // type:function size:0x398
+assert__Q23EGG6AssertFPCcUlPCce = .text:0x8049C530; // type:function size:0x8C
 FUN_8049c5c0 = .text:0x8049C5C0; // type:function size:0x10
 FUN_8049c5d0 = .text:0x8049C5D0; // type:function size:0x50
 FUN_8049c620 = .text:0x8049C620; // type:function size:0x44

include/common.h

@@ -54,12 +54,12 @@
 
 typedef signed char s8;
 typedef signed short s16;
-typedef signed int s32;
+typedef signed long s32;
 typedef signed long long s64;
 
 typedef unsigned char u8;
 typedef unsigned short u16;
-typedef unsigned int u32;
+typedef unsigned long u32;
 typedef unsigned long long u64;
 typedef float f32;
 typedef double f64;

include/d/d_base.h

@@ -22,8 +22,8 @@ public:
     /* 80050980 */ static void resetFlags();
     /* 800509a0 */ static bool isActorPlayer(dBase_c &);
     /* 800509e0 */ static void initLoader();
-    /* 80050a00 */ static dBase_c *createBase(ProfileName, dBase_c *, unsigned long, u8);
-    /* 80050a10 */ static dBase_c *createRoot(ProfileName, unsigned long, u8);
+    /* 80050a00 */ static dBase_c *createBase(ProfileName, dBase_c *, u32, u8);
+    /* 80050a10 */ static dBase_c *createRoot(ProfileName, u32, u8);
 
 private:
     /* 800509c0 */ static int loadAsyncCallback();

include/egg/core/eggAllocator.h

@@ -3,7 +3,7 @@
 #include "rvl/MEM.h"
 #include <common.h>
 
-/* 80495310 */ void MEMInitAllocatorFor_Heap(MEMAllocator* alloc, s32 align, void* heap);
+/* 80495310 */ void MEMInitAllocatorFor_Heap(MEMAllocator *alloc, s32 align, void *heap);
 
 namespace EGG {
 class Heap;

include/egg/core/eggArchive.h

@@ -46,9 +46,9 @@ public:
     /* 80493ac0 */ static Archive *loadFST(const char *fileName, Heap *heap, s32 align);
     /* 80493b80 */ void unmount();
     /* 80493c20 */ u32 getFile(const char *name, FileInfo *out);
-    /* 80493cf0 */ long convertPathToEntryID(const char *path);
-    /* 80493d00 */ void *getFileFast(long entryId, FileInfo *fileinfo);
-    /* 80493dc0 */ void *getFileFast(long entryId, Heap *heap, s32 align);
+    /* 80493cf0 */ s32 convertPathToEntryID(const char *path);
+    /* 80493d00 */ void *getFileFast(s32 entryId, FileInfo *fileinfo);
+    /* 80493dc0 */ void *getFileFast(s32 entryId, Heap *heap, s32 align);
     /* 80493f30 */ s32 countFile();
     /* 804940c0 */ void searchInside(FileCallbackFunc, void *);
     /* 80494140 */ static void *loadFromNAND(NANDFileInfo *fileInfo, Heap *heap, s32 align);

include/egg/core/eggHeap.h

@@ -18,10 +18,10 @@ class Allocator;
 
 struct HeapAllocArg {
     void *userArg; // 00
-    u32 size;    // 04
-    int align;   // 08
-    void *ptr;   // 0C the allocated ptr
-    Heap *heap;  // 10 heap to allocate in
+    u32 size;      // 04
+    int align;     // 08
+    void *ptr;     // 0C the allocated ptr
+    Heap *heap;    // 10 heap to allocate in
 
     inline HeapAllocArg() : userArg(0), size(0), align(0), heap(nullptr), ptr(nullptr) {}
 };

include/egg/math/eggMatrix.h

@@ -43,7 +43,7 @@ struct Matrix34f {
     /*          */ void makeT(const Vector3f &t);
     /* 8049ae90 */ void fromQuat(const Quatf &q);
     /* 8049af40 */ void toQuat(Quatf &q) const;
-    /* 8049b250 */ void slerpTo(const Matrix34f &, Matrix34f &, f32);
+    /* 8049b250 */ void slerpTo(const Matrix34f &, Matrix34f &, f32) const;
     /*          */ void copyTo16(f32 *pf) const;
     /* 8049b2d0 */ void setAxisRotation(const Vector3f &, f32);
     /*          */ Vector3f multVector(const Vector3f &vec) const;

include/f/f_base.h

@@ -126,13 +126,10 @@ public:
     /* 802e2510 */ bool checkChildProcessCreateState() const;
 
 public:
-    /* 802e2540 */ static void setTmpCtData(ProfileName profName, fTrNdBa_c *connectParent, unsigned long param,
-            u8 groupType);
-    /* 802e2560 */ static fBase_c *fBase_make(ProfileName profName, fTrNdBa_c *connectParent, unsigned long param,
-            u8 groupType);
-    /* 802e2640 */ static fBase_c *createRoot(ProfileName profName, unsigned long param, u8 groupType);
-    /* 802e2600 */ static fBase_c *createChild(ProfileName profName, fBase_c *parent, unsigned long param,
-            u8 groupType);
+    /* 802e2540 */ static void setTmpCtData(ProfileName profName, fTrNdBa_c *connectParent, u32 param, u8 groupType);
+    /* 802e2560 */ static fBase_c *fBase_make(ProfileName profName, fTrNdBa_c *connectParent, u32 param, u8 groupType);
+    /* 802e2640 */ static fBase_c *createRoot(ProfileName profName, u32 param, u8 groupType);
+    /* 802e2600 */ static fBase_c *createChild(ProfileName profName, fBase_c *parent, u32 param, u8 groupType);
 
 public:
     /* 80575ba8 */ static fLiMgBa_c m_forceExecuteList;

include/f/f_manager.h

@@ -32,7 +32,7 @@ public:
     /* 802e28c0 */ int getSearchTableNum();
     /* 802e28d0 */ static fBase_c *searchBaseByID(fBaseID_e id);
     /* 802e2920 */ static fBase_c *searchBaseByProfName(ProfileName profID, const fBase_c *parent);
-    /* 802e2980 */ static fBase_c *searchBaseByGroupType(unsigned char groupType, const fBase_c *parent);
+    /* 802e2980 */ static fBase_c *searchBaseByGroupType(u8 groupType, const fBase_c *parent);
     /* 802e29e0 */ static void mainLoop();
 
 private:

include/m/m_heap.h

@@ -14,37 +14,54 @@ class ExpHeap;
 class AssertHeap;
 } // namespace EGG
 // TODO: Doc symbols and func locations
-namespace mHeap {
-/* 802f0f00 */ u16 copyAttribute(u32);
-/* 802f0f40 */ EGG::Heap *setCurrentHeap(EGG::Heap *);
-/* 802f0f50 */ EGG::ExpHeap *createExpHeap(size_t size, EGG::Heap *parentHeap, char *name, s32 align, u32 unk);
-/* 802f1060 */ size_t adjustExpHeap(EGG::Heap *heap);
-/* 802f10d0 */ size_t expHeapCost(size_t start, s32 size);
-/* 802f10f0 */ EGG::FrmHeap *createFrmHeap(size_t size, EGG::Heap *parentHeap, char *name, size_t align, size_t attrs);
-/* 802f1200 */ void destroyFrmHeap(EGG::FrmHeap *heap);
-/* 802f1220 */ size_t adjustFrmHeap(EGG::FrmHeap *heap);
-/* 802f1290 */ size_t frmHeapCost(size_t start, s32 size);
-/* 802f12b0 */ EGG::Heap **setTempHeap(EGG::Heap **prevHeap, EGG::Heap *tempNewHeap);
-/* 802f12f0 */ EGG::Heap **restoreTempHeap(EGG::Heap **prevHeap, s32 size);
-/* 802f1350 */ EGG::ExpHeap *createHeap(size_t size, EGG::Heap *, char *name);
-/* 802f13d0 */ void saveCurrentHeap();
-/* 802f13e0 */ void restoreCurrentHeap();
-/* 802f1410 */ EGG::FrmHeap *makeFrmHeapAndUpdate(size_t size, EGG::Heap *parentHeap, const char *name, s32 align,
-        u32 unk);
-/* 802f1450 */ int getGameHeapNum();
-/* 802f1460 */ EGG::ExpHeap *createGameHeap(s32 heapNum, size_t size, EGG::Heap *parentHeap);
-/* 802f1510 */ EGG::ExpHeap *createGameHeap1(s32 size, EGG::Heap *parentHeap);
-/* 802f1560 */ EGG::ExpHeap *createArchiveHeap(size_t size, EGG::Heap *parentHeap);
-/* 802f1590 */ EGG::ExpHeap *createCommandHeap(size_t size, EGG::Heap *parentHeap);
-/* 802f15c0 */ EGG::ExpHeap *createDylinkHeap(size_t size, EGG::Heap *parentHeap);
-/* 802f15f0 */ EGG::AssertHeap *createAssertHeap(EGG::Heap *parentHeap);
-/* 802f1640 */ EGG::Heap *makeHeapOnCurrentGameHeap(size_t size, char *name, s32 align, u32 unk);
-extern EGG::ExpHeap *g_gameHeaps[4];
-extern EGG::ExpHeap *s_SavedCurrentHeap;
-extern EGG::ExpHeap *g_archiveHeap;
-extern EGG::ExpHeap *g_commandHeap;
-extern EGG::ExpHeap *g_dylinkHeap;
-extern EGG::AssertHeap *g_assertHeap;
+class mHeap {
+public:
+    /* 802f0f00 */ static u16 copyAttribute(u32);
+    /* 802f0f40 */ static EGG::Heap *setCurrentHeap(EGG::Heap *);
+    /* 802f0f50 */ static EGG::Heap *createExpHeap(size_t size, EGG::Heap *parentHeap, const char *name, u32 align,
+            u32 attrs);
+    /* 802f1060 */ static size_t adjustExpHeap(EGG::ExpHeap *heap);
+    /* 802f10d0 */ static size_t expHeapCost(size_t start, u32 size);
+    /* 802f10f0 */ static EGG::FrmHeap *createFrmHeap(size_t size, EGG::Heap *parentHeap, const char *name,
+            size_t align, size_t attrs);
+    /* 802f1200 */ static void destroyFrmHeap(EGG::FrmHeap *heap);
+    /* 802f1220 */ static size_t adjustFrmHeap(EGG::FrmHeap *heap);
+    /* 802f1290 */ static size_t frmHeapCost(size_t start, u32 size);
+    mHeap() {
+        heap = nullptr;
+    }
+    /* 802f12b0 */ mHeap(EGG::Heap *heap);
+    /* 802f12f0 */ ~mHeap();
+    /* 802f1350 */ static EGG::Heap *createHeap(size_t size, EGG::Heap *, const char *name);
+    /* 802f13d0 */ static void saveCurrentHeap();
+    /* 802f13e0 */ static void restoreCurrentHeap();
+    /* 802f1410 */ static EGG::FrmHeap *makeFrmHeapAndUpdate(size_t size, EGG::Heap *parentHeap, const char *name,
+            u32 align, u32 attrs);
+    /* 802f1450 */ static int getGameHeapNum();
+    /* 802f1460 */ static EGG::Heap *createGameHeap(int heapNum, size_t size, EGG::Heap *parentHeap);
+    /* 802f1510 */ static void createGameHeap1(size_t size, EGG::Heap *parentHeap);
+    /* 802f1560 */ static void createArchiveHeap(size_t size, EGG::Heap *parentHeap);
+    /* 802f1590 */ static void createCommandHeap(size_t size, EGG::Heap *parentHeap);
+    /* 802f15c0 */ static void createDylinkHeap(size_t size, EGG::Heap *parentHeap);
+    /* 802f15f0 */ static EGG::AssertHeap *createAssertHeap(EGG::Heap *parentHeap);
+    /* 802f1640 */ static EGG::Heap *makeHeapOnCurrentGameHeap(size_t size, const char *name, u32 align, u32 flags);
+
+    static int getDefaultGameHeapId();
+
+    static bool isValidHeapId(u32 id) {
+        return id >= 1 && id <= 2;
+    }
+
+    static EGG::Heap *g_gameHeaps[4];
+    static EGG::Heap *s_SavedCurrentHeap;
+    static EGG::Heap *g_archiveHeap;
+    static EGG::Heap *g_commandHeap;
+    static EGG::Heap *g_dylinkHeap;
+    static EGG::AssertHeap *g_assertHeap;
+    static u8 g_DefaultGameHeapId;
+    static const char *const s_GameHeapNames[4];
+
+    EGG::Heap *heap;
 }; // namespace mHeap
 
 #endif

include/nw4r/snd/snd_WaveSound.h

@@ -1,42 +1,39 @@
 #ifndef NW4R_SND_WAVESOUND_H
 #define NW4R_SND_WAVESOUND_H
-#include "types_nw4r.h"
 #include "snd_BasicSound.h"
 #include "snd_WsdPlayer.h"
+#include "types_nw4r.h"
 #include "ut_RuntimeTypeInfo.h"
 
-namespace nw4r
-{
-    namespace snd
-    {
-        namespace detail
-        {
-            struct WaveSound : BasicSound
-            {
-                WsdPlayer mPlayer; // at 0xD8
-                WaveSoundHandle *mTempSpecialHandle; // at 0x1B0
-                SoundInstanceManager<WaveSound> *mManager; // at 0x1B4
-                bool mIsPrepared; // at 0x1B8
 
-                WaveSound(SoundInstanceManager<WaveSound> *);
-                bool Prepare(const void *, long, WsdPlayer::StartOffsetType, s32, int, const WsdPlayer::WsdCallback *, u32);
-                void SetChannelPriority(int);
-                void SetReleasePriorityFix(bool);
+namespace nw4r {
+namespace snd {
+namespace detail {
+struct WaveSound : BasicSound {
+    WsdPlayer mPlayer;                         // at 0xD8
+    WaveSoundHandle *mTempSpecialHandle;       // at 0x1B0
+    SoundInstanceManager<WaveSound> *mManager; // at 0x1B4
+    bool mIsPrepared;                          // at 0x1B8
 
-                static ut::detail::RuntimeTypeInfo typeInfo;
-                
-                virtual const ut::detail::RuntimeTypeInfo * GetRuntimeTypeInfo() const; // at 0x8
-                virtual ~WaveSound(); // at 0xc
-                virtual UNKTYPE Shutdown(); // at 0x28
-                virtual bool IsPrepared() const; // at 0x2c
-                virtual void SetPlayerPriority(int); // at 0x4c
-                virtual bool IsAttachedTempSpecialHandle(); // at 0x5c
-                virtual UNKTYPE DetachTempSpecialHandle(); // at 0x60
-                virtual BasicPlayer * GetBasicPlayer(); // at 0x68
-                virtual const BasicPlayer * GetBasicPlayer() const; // at 0x6c
-            };
-        }
-    }
-}
+    WaveSound(SoundInstanceManager<WaveSound> *);
+    bool Prepare(const void *, s32, WsdPlayer::StartOffsetType, s32, int, const WsdPlayer::WsdCallback *, u32);
+    void SetChannelPriority(int);
+    void SetReleasePriorityFix(bool);
 
-#endif
+    static ut::detail::RuntimeTypeInfo typeInfo;
+
+    virtual const ut::detail::RuntimeTypeInfo *GetRuntimeTypeInfo() const; // at 0x8
+    virtual ~WaveSound();                                                  // at 0xc
+    virtual UNKTYPE Shutdown();                                            // at 0x28
+    virtual bool IsPrepared() const;                                       // at 0x2c
+    virtual void SetPlayerPriority(int);                                   // at 0x4c
+    virtual bool IsAttachedTempSpecialHandle();                            // at 0x5c
+    virtual UNKTYPE DetachTempSpecialHandle();                             // at 0x60
+    virtual BasicPlayer *GetBasicPlayer();                                 // at 0x68
+    virtual const BasicPlayer *GetBasicPlayer() const;                     // at 0x6c
+};
+} // namespace detail
+} // namespace snd
+} // namespace nw4r
+
+#endif

include/nw4r/ut/ut_DvdFileStream.h

@@ -24,7 +24,7 @@ public:
     };
 
 public:
-    DvdFileStream(long entrynum);
+    DvdFileStream(s32 entrynum);
     DvdFileStream(const DVDFileInfo *info, bool close);
     virtual ~DvdFileStream(); // at 0xC
 
@@ -67,15 +67,15 @@ public:
 
     virtual void Close(); // at 0x10
 
-    virtual long Read(void *dst, unsigned long size); // at 0x14
-    virtual bool ReadAsync(void *dst, unsigned long size, AsyncCallback callback,
+    virtual s32 Read(void *dst, u32 size); // at 0x14
+    virtual bool ReadAsync(void *dst, u32 size, AsyncCallback callback,
             void *arg); // at 0x18
 
-    virtual long Peek(void *dst, unsigned long size); // at 0x5C
-    virtual bool PeekAsync(void *dst, unsigned long size, AsyncCallback callback,
+    virtual s32 Peek(void *dst, u32 size); // at 0x5C
+    virtual bool PeekAsync(void *dst, u32 size, AsyncCallback callback,
             void *arg); // at 0x60
 
-    virtual void Seek(long offset, unsigned long origin); // at 0x44
+    virtual void Seek(s32 offset, u32 origin); // at 0x44
 
     virtual void Cancel();                                       // at 0x48
     virtual bool CancelAsync(AsyncCallback callback, void *arg); // at 0x4C
@@ -88,11 +88,11 @@ public:
     bool Open(const DVDFileInfo *info, bool close);
 
 private:
-    static void DvdAsyncCallback_(long result, DVDFileInfo *info);
-    static void DvdCBAsyncCallback_(long result, DVDCommandBlock *block);
+    static void DvdAsyncCallback_(s32 result, DVDFileInfo *info);
+    static void DvdCBAsyncCallback_(s32 result, DVDCommandBlock *block);
 
     void Initialize_();
-    unsigned long AdjustReadLength_(unsigned long len);
+    u32 AdjustReadLength_(u32 len);
 
 private:
     FilePosition mFilePosition;    // at 0x14

include/nw4r/ut/ut_DvdLockedFileStream.h

@@ -11,19 +11,19 @@ class DvdLockedFileStream : public DvdFileStream {
 public:
     NW4R_UT_RTTI_DECL(DvdLockedFileStream);
 
-    DvdLockedFileStream(long entrynum);
+    DvdLockedFileStream(s32 entrynum);
     DvdLockedFileStream(const DVDFileInfo *info, bool close);
     virtual ~DvdLockedFileStream(); // at 0xC
 
     virtual void Close(); // at 0x10
 
-    virtual long Read(void *dst, unsigned long size); // at 0x14
-    virtual bool ReadAsync(void *dst, unsigned long size, AsyncCallback callback, void *arg) {
+    virtual s32 Read(void *dst, u32 size); // at 0x14
+    virtual bool ReadAsync(void *dst, u32 size, AsyncCallback callback, void *arg) {
         return false;
     } // at 0x18
 
-    virtual long Peek(void *dst, unsigned long size); // at 0x5C
-    virtual bool PeekAsync(void *dst, unsigned long size, AsyncCallback callback, void *arg) {
+    virtual s32 Peek(void *dst, u32 size); // at 0x5C
+    virtual bool PeekAsync(void *dst, u32 size, AsyncCallback callback, void *arg) {
         return false;
     } // at 0x60
 

include/nw4r/ut/ut_FileStream.h

@@ -19,7 +19,7 @@ public:
         u32 GetFileSize() const {
             return mFileSize;
         }
-        void SetFileSize(unsigned long fileSize) {
+        void SetFileSize(u32 fileSize) {
             mFileSize = fileSize;
         }
 
@@ -27,9 +27,9 @@ public:
             return mFileOffset;
         }
 
-        u32 Skip(long offset);
-        u32 Append(long offset);
-        void Seek(long offset, unsigned long origin);
+        u32 Skip(s32 offset);
+        u32 Append(s32 offset);
+        void Seek(s32 offset, u32 origin);
 
     private:
         u32 mFileSize;   // at 0x0
@@ -41,7 +41,7 @@ public:
     virtual ~FileStream() {} // at 0xC
 
     virtual u32 GetSize() const = 0;                             // at 0x40
-    virtual void Seek(long offset, unsigned long origin);        // at 0x44
+    virtual void Seek(s32 offset, u32 origin);                   // at 0x44
     virtual void Cancel();                                       // at 0x48
     virtual bool CancelAsync(AsyncCallback callback, void *arg); // at 0x4C
     virtual bool CanSeek() const = 0;                            // at 0x50

include/nw4r/ut/ut_IOStream.h

@@ -10,17 +10,17 @@ class IOStream {
 public:
     NW4R_UT_RTTI_DECL(IOStream);
 
-    typedef void (*AsyncCallback)(long result, IOStream *stream, void *arg);
+    typedef void (*AsyncCallback)(s32 result, IOStream *stream, void *arg);
 
     IOStream() : mIsOpen(false), mCallback(NULL), mCallbackArg(NULL) {}
     virtual ~IOStream() {} // at 0xC
 
-    virtual void Close() = 0;                             // at 0x10
-    virtual long Read(void *dst, unsigned long size) = 0; // at 0x14
-    virtual bool ReadAsync(void *dst, unsigned long size, AsyncCallback callback,
-            void *arg);                                      // at 0x18
-    virtual long Write(const void *src, unsigned long size); // at 0x1C
-    virtual bool WriteAsync(const void *src, unsigned long size, AsyncCallback callback,
+    virtual void Close() = 0;                  // at 0x10
+    virtual s32 Read(void *dst, u32 size) = 0; // at 0x14
+    virtual bool ReadAsync(void *dst, u32 size, AsyncCallback callback,
+            void *arg);                           // at 0x18
+    virtual s32 Write(const void *src, u32 size); // at 0x1C
+    virtual bool WriteAsync(const void *src, u32 size, AsyncCallback callback,
             void *arg);                // at 0x20
     virtual bool IsBusy() const;       // at 0x24
     virtual bool CanAsync() const = 0; // at 0x28

include/nw4r/ut/ut_NandFileStream.h

@@ -25,8 +25,8 @@ public:
     };
 
 public:
-    NandFileStream(const char *path, unsigned long access);
-    NandFileStream(const NANDFileInfo *info, unsigned long access, bool close);
+    NandFileStream(const char *path, u32 access);
+    NandFileStream(const NANDFileInfo *info, u32 access, bool close);
     virtual ~NandFileStream(); // at 0xC
 
     virtual bool IsBusy() const {
@@ -68,21 +68,21 @@ public:
 
     virtual void Close(); // at 0x10
 
-    virtual long Read(void *dst, unsigned long size); // at 0x14
-    virtual bool ReadAsync(void *dst, unsigned long size, AsyncCallback callback,
+    virtual s32 Read(void *dst, u32 size); // at 0x14
+    virtual bool ReadAsync(void *dst, u32 size, AsyncCallback callback,
             void *arg); // at 0x18
 
-    virtual long Write(const void *src, unsigned long size); // at 0x1C
-    virtual bool WriteAsync(const void *src, unsigned long size, AsyncCallback callback,
+    virtual s32 Write(const void *src, u32 size); // at 0x1C
+    virtual bool WriteAsync(const void *src, u32 size, AsyncCallback callback,
             void *arg); // at 0x20
 
-    virtual void Seek(long offset, unsigned long origin); // at 0x44
+    virtual void Seek(s32 offset, u32 origin); // at 0x44
 
-    bool Open(const char *path, unsigned long access);
-    bool Open(const NANDFileInfo *info, unsigned long access, bool close) DECOMP_DONT_INLINE;
+    bool Open(const char *path, u32 access);
+    bool Open(const NANDFileInfo *info, u32 access, bool close) DECOMP_DONT_INLINE;
 
 private:
-    static void NandAsyncCallback_(long result, NANDCommandBlock *block);
+    static void NandAsyncCallback_(s32 result, NANDCommandBlock *block);
 
     void Initialize_();
 

include/nw4r/ut/ut_TextWriterBase.h

@@ -94,13 +94,13 @@ public:
     f32 VPrintfMutable(const T *format, va_list args);
     f32 PrintMutable(const T *str, int n);
 
-    // static int VSNPrintf(T *buffer, unsigned long count, const T *fmt, va_list args);
+    // static int VSNPrintf(T *buffer, u32 count, const T *fmt, va_list args);
 
-    static int VSNPrintf(char *buffer, unsigned long count, const char *fmt, va_list args) {
+    static int VSNPrintf(char *buffer, u32 count, const char *fmt, va_list args) {
         return vsnprintf(buffer, count, fmt, args);
     }
 
-    static int VSNPrintf(wchar_t *buffer, unsigned long count, const wchar_t *fmt, va_list args) {
+    static int VSNPrintf(wchar_t *buffer, u32 count, const wchar_t *fmt, va_list args) {
         return vswprintf(buffer, count, fmt, args);
     }
 
@@ -110,7 +110,7 @@ public:
     f32 PrintImpl(const T *str, int len, bool m);
     f32 AdjustCursor(f32 *x1, f32 *y1, const T *str, int len);
 
-    bool IsDrawFlagSet(unsigned long mask, unsigned long flag) const {
+    bool IsDrawFlagSet(u32 mask, u32 flag) const {
         return (mDrawFlag & mask) == flag;
     }
 
@@ -127,16 +127,6 @@ private:
     static TagProcessorBase<T> mDefaultTagProcessor;
 };
 
-// template <>
-// int TextWriterBase<char>::VSNPrintf(char *buffer, unsigned long count, const char *fmt, va_list args) {
-//     return vsnprintf(buffer, count, fmt, args);
-// }
-
-// template <>
-// int TextWriterBase<wchar_t>::VSNPrintf(wchar_t *buffer, unsigned long count, const wchar_t *fmt, va_list args) {
-//     return vswprintf(buffer, count, fmt, args);
-// }
-
 } // namespace ut
 } // namespace nw4r
 

include/nw4r/ut/ut_binaryFileFormat.h

@@ -19,7 +19,7 @@ struct BinaryFileHeader {
     u16 numBlocks;  // at 0xE
 };
 
-bool IsValidBinaryFile(const BinaryFileHeader *header, unsigned long magic, u16 version, u16 numBlocks);
+bool IsValidBinaryFile(const BinaryFileHeader *header, u32 magic, u16 version, u16 numBlocks);
 
 } // namespace ut
 } // namespace nw4r

include/rvl/DVD/dvd.h

@@ -45,8 +45,8 @@ typedef enum {
     DVD_COVER_CLOSED,
 } DVDCoverState;
 
-typedef void (*DVDAsyncCallback)(long result, struct DVDFileInfo *info);
-typedef void (*DVDCommandCallback)(long result, struct DVDCommandBlock *block);
+typedef void (*DVDAsyncCallback)(s32 result, struct DVDFileInfo *info);
+typedef void (*DVDCommandCallback)(s32 result, struct DVDCommandBlock *block);
 
 typedef struct DVDDiskID {
     char game[4];    // at 0x0

include/rvl/NAND/nand.h

@@ -66,7 +66,7 @@ typedef enum {
     NAND_PERM_RWALL = NAND_PERM_RALL | NAND_PERM_WALL
 } NANDPermission;
 
-typedef void (*NANDAsyncCallback)(long result, struct NANDCommandBlock *block);
+typedef void (*NANDAsyncCallback)(s32 result, struct NANDCommandBlock *block);
 
 typedef struct NANDStatus {
     u32 ownerId; // at 0x0
@@ -76,8 +76,8 @@ typedef struct NANDStatus {
 } NANDStatus;
 
 typedef struct NANDFileInfo {
-    long fd;                    // at 0x0
-    long tempFd;                // at 0x4
+    s32 fd;                     // at 0x0
+    s32 tempFd;                 // at 0x4
     char openPath[FS_MAX_PATH]; // at 0x8
     char tempPath[FS_MAX_PATH]; // at 0x48
     u8 access;                  // at 0x88
@@ -158,7 +158,7 @@ NANDResult NANDPrivateCreateDirAsync(const char *path, u8 perm, u8 attr, NANDAsy
 
 NANDResult NANDMove(const char *from, const char *to);
 
-NANDResult NANDGetLength(NANDFileInfo *info, unsigned long *length);
+NANDResult NANDGetLength(NANDFileInfo *info, u32 *length);
 NANDResult NANDGetLengthAsync(NANDFileInfo *info, u32 *lengthOut, NANDAsyncCallback callback, NANDCommandBlock *block);
 
 NANDResult NANDGetStatus(const char *path, NANDStatus *status);

src/d/d_base.cpp

@@ -11,7 +11,7 @@ dBase_c::dBase_c() : fBase_c() {
 
 void dBase_c::postDraw(fBase_c::MAIN_STATE_e status) {
     if (status != CANCELED) {
-        baseProperties |=  0x100;
+        baseProperties |= 0x100;
     } else {
         baseProperties &= ~0x100;
     }
@@ -30,7 +30,7 @@ int dBase_c::preExecute() {
 
 void dBase_c::postExecute(fBase_c::MAIN_STATE_e status) {
     if (status != CANCELED) {
-        baseProperties |=  0x4;
+        baseProperties |= 0x4;
     } else {
         baseProperties &= ~0x4;
     }
@@ -53,7 +53,7 @@ void dBase_c::resetFlags() {
     s_NextExecuteControlFlags = 0;
 }
 
-bool dBase_c::isActorPlayer(dBase_c& base) {
+bool dBase_c::isActorPlayer(dBase_c &base) {
     return base.profile_name == fProfile::PLAYER;
 }
 
@@ -70,12 +70,12 @@ void dBase_c::initLoader() {
     fBase_c::sUnloadCallback = unloadCallback;
 }
 
-dBase_c* dBase_c::createBase(ProfileName profName, dBase_c* parent, unsigned long param, u8 grouptype) {
-    return static_cast<dBase_c*>(fBase_c::createChild(profName, parent, param, grouptype));
+dBase_c *dBase_c::createBase(ProfileName profName, dBase_c *parent, u32 param, u8 grouptype) {
+    return static_cast<dBase_c *>(fBase_c::createChild(profName, parent, param, grouptype));
 }
 
-dBase_c* dBase_c::createRoot(ProfileName profName, unsigned long param, u8 groupType) {
-    return static_cast<dBase_c*>(fBase_c::createRoot(profName, param, groupType));
+dBase_c *dBase_c::createRoot(ProfileName profName, u32 param, u8 groupType) {
+    return static_cast<dBase_c *>(fBase_c::createRoot(profName, param, groupType));
 }
 
 // dBase_c::~dBase_c() {}

src/egg/core/eggController.cpp

@@ -1,10 +1,11 @@
 #include "egg/core/eggController.h"
+#include "MSL_C/string.h"
 #include "egg/core/eggAllocator.h"
 #include "egg/core/eggExpHeap.h"
 #include "egg/core/eggSystem.h"
-#include "MSL_C/string.h"
 #include "rvl/VI.h"
 
+
 EGG::NullController null_controller;
 namespace EGG {
 
@@ -192,7 +193,7 @@ extern "C" void fn_803DB1E0(s32 channel, bool arg);
     }
 }
 
-extern "C" long lbl_80574EE8;
+extern "C" s32 lbl_80574EE8;
 // TODO headers
 extern "C" void fn_803D9400(void *a, void *b);
 extern "C" void fn_803F2040(void *a, int b);

src/egg/core/eggHeap.cpp

@@ -38,13 +38,16 @@ namespace EGG {
     OSUnlockMutex(&sRootMutex);
 }
 
-/* 80495560 */ void *Heap::alloc(size_t size, s32 align, Heap *heap) {
+/* 80495560 */ void *Heap::alloc(size_t size, int align, Heap *heap) {
     Heap *currentHeap = sCurrentHeap;
     Thread *thread = Thread::findThread(OSGetCurrentThread());
     Heap *threadHeap = nullptr;
 
-    if (thread != nullptr && (threadHeap = thread->mAllocatableHeap, threadHeap != nullptr)) {
-        heap = threadHeap;
+    if (thread != nullptr) {
+        threadHeap = thread->mAllocatableHeap;
+        if (threadHeap != nullptr) {
+            heap = threadHeap;
+        }
     }
     if (sAllocatableHeap != nullptr) {
         if (heap == nullptr) {

src/egg/math/eggMatrix.cpp

@@ -332,7 +332,7 @@ void Matrix34f::toQuat(Quatf &q) const {
     q.multScalar(Math<f32>::inv(q.length()));
 }
 
-void Matrix34f::slerpTo(const Matrix34f &m2, Matrix34f &out, f32 t) {
+void Matrix34f::slerpTo(const Matrix34f &m2, Matrix34f &out, f32 t) const {
     Quatf q1, q2, q3;
     m2.toQuat(q1);
     toQuat(q2);

src/f/f_base.cpp

@@ -581,7 +581,7 @@ bool fBase_c::checkChildProcessCreateState() const {
 }
 
 /* 802e2540 */
-void fBase_c::setTmpCtData(ProfileName profile_name, fTrNdBa_c *connect_parent, unsigned long param, u8 group_type) {
+void fBase_c::setTmpCtData(ProfileName profile_name, fTrNdBa_c *connect_parent, u32 param, u8 group_type) {
     m_tmpCtData.prof_name = profile_name;
     m_tmpCtData.connect_parent = connect_parent;
     m_tmpCtData.params = param;
@@ -589,7 +589,7 @@ void fBase_c::setTmpCtData(ProfileName profile_name, fTrNdBa_c *connect_parent,
 }
 
 /* 802e2560 */
-fBase_c *fBase_c::fBase_make(ProfileName profile_name, fTrNdBa_c *connect_parent, unsigned long param, u8 group_type) {
+fBase_c *fBase_c::fBase_make(ProfileName profile_name, fTrNdBa_c *connect_parent, u32 param, u8 group_type) {
     if ((*fProfile::sProfileList)[profile_name] == nullptr) {
         return nullptr;
     }
@@ -608,7 +608,7 @@ fBase_c *fBase_c::fBase_make(ProfileName profile_name, fTrNdBa_c *connect_parent
 }
 
 /* 802e2600 */
-fBase_c *fBase_c::createChild(ProfileName profile_name, fBase_c *parent, unsigned long param, u8 group_type) {
+fBase_c *fBase_c::createChild(ProfileName profile_name, fBase_c *parent, u32 param, u8 group_type) {
     if (parent == nullptr) {
         return nullptr;
     }
@@ -621,6 +621,6 @@ fBase_c *fBase_c::createChild(ProfileName profile_name, fBase_c *parent, unsigne
 }
 
 /* 802e2640 */
-fBase_c *fBase_c::createRoot(ProfileName profile_name, unsigned long param, u8 group_type) {
+fBase_c *fBase_c::createRoot(ProfileName profile_name, u32 param, u8 group_type) {
     return fBase_make(profile_name, nullptr, param, group_type);
 }

src/m/m_heap.cpp

@@ -3,20 +3,24 @@
 #include <egg/core/eggFrmHeap.h>
 #include <m/m_heap.h>
 
-namespace mHeap {
-
-u8 g_DefaultGameHeapId = 1;
+u8 mHeap::g_DefaultGameHeapId = 1;
 
 #define MIN_ALIGN 0x20
 
-EGG::ExpHeap *g_gameHeaps[4];
-EGG::ExpHeap *s_SavedCurrentHeap;
-EGG::ExpHeap *g_archiveHeap;
-EGG::ExpHeap *g_commandHeap;
-EGG::ExpHeap *g_dylinkHeap;
-EGG::AssertHeap *g_assertHeap;
+EGG::Heap *mHeap::g_gameHeaps[4];
+EGG::Heap *mHeap::s_SavedCurrentHeap;
+EGG::Heap *mHeap::g_archiveHeap;
+EGG::Heap *mHeap::g_commandHeap;
+EGG::Heap *mHeap::g_dylinkHeap;
+EGG::AssertHeap *mHeap::g_assertHeap;
+const char *const mHeap::s_GameHeapNames[4] = {
+        0,
+        "ゲーム用汎用ヒープ1(mHeap::gameHeaps[1])",
+        "ゲーム用汎用ヒープ2(mHeap::gameHeaps[2])",
+        0,
+};
 
-u16 copyAttribute(u32 arg) {
+u16 mHeap::copyAttribute(u32 arg) {
     u16 result = 0;
 
     if ((arg & 1) != 0) {
@@ -31,13 +35,12 @@ u16 copyAttribute(u32 arg) {
     return result;
 }
 
-EGG::Heap *setCurrentHeap(EGG::Heap *heap) {
+EGG::Heap *mHeap::setCurrentHeap(EGG::Heap *heap) {
     return heap->becomeCurrentHeap();
 }
-EGG::ExpHeap *createExpHeap(size_t size, EGG::Heap *parent, const char *name, unsigned long align,
-        unsigned long attrs) {
-    if (parent == nullptr) {
-        parent = EGG::Heap::sCurrentHeap;
+EGG::Heap *mHeap::createExpHeap(size_t size, EGG::Heap *parentHeap, const char *name, u32 align, u32 attrs) {
+    if (parentHeap == nullptr) {
+        parentHeap = EGG::Heap::sCurrentHeap;
     }
 
     if (align < MIN_ALIGN) {
@@ -47,15 +50,15 @@ EGG::ExpHeap *createExpHeap(size_t size, EGG::Heap *parent, const char *name, un
     if (size != 0xFFFFFFFF) {
         size = expHeapCost(size, align);
     } else {
-        size = parent->getAllocatableSize(align);
+        size = parentHeap->getAllocatableSize(align);
     }
 
-    void *mem = parent->alloc(size, align);
+    void *mem = parentHeap->alloc(size, align);
     EGG::ExpHeap *heap = nullptr;
     if (mem != nullptr) {
         heap = EGG::ExpHeap::create(mem, size, copyAttribute(attrs));
         if (heap == nullptr) {
-            parent->free(mem);
+            parentHeap->free(mem);
         } else if (name != nullptr) {
             heap->mName = name;
         }
@@ -63,7 +66,7 @@ EGG::ExpHeap *createExpHeap(size_t size, EGG::Heap *parent, const char *name, un
     return heap;
 }
 
-size_t adjustExpHeap(EGG::ExpHeap *heap) {
+size_t mHeap::adjustExpHeap(EGG::ExpHeap *heap) {
     int ret = 0;
     if (heap != nullptr) {
         size_t ad = heap->adjust();
@@ -74,14 +77,14 @@ size_t adjustExpHeap(EGG::ExpHeap *heap) {
     }
     return ret;
 }
-size_t expHeapCost(size_t size, s32 align) {
+size_t mHeap::expHeapCost(size_t size, u32 align) {
     int a = align - 1;
-    long b = (0x84 + a);
-    
-    return size + (~(a) & b);
+    s32 b = (0x84 + a);
+
+    return size + (~(a)&b);
 }
 
-EGG::FrmHeap *createFrmHeap(size_t size, EGG::Heap *parent, const char *name, size_t align, size_t attrs) {
+EGG::FrmHeap *mHeap::createFrmHeap(size_t size, EGG::Heap *parent, const char *name, size_t align, size_t attrs) {
     if (parent == nullptr) {
         parent = EGG::Heap::sCurrentHeap;
     }
@@ -108,13 +111,13 @@ EGG::FrmHeap *createFrmHeap(size_t size, EGG::Heap *parent, const char *name, si
     }
     return heap;
 }
-void destroyFrmHeap(EGG::FrmHeap *heap) {
+void mHeap::destroyFrmHeap(EGG::FrmHeap *heap) {
     if (heap != nullptr) {
         heap->destroy();
     }
 }
 
-size_t adjustFrmHeap(EGG::FrmHeap *heap) {
+size_t mHeap::adjustFrmHeap(EGG::FrmHeap *heap) {
     int ret = 0;
     if (heap != nullptr) {
         size_t ad = heap->adjust();
@@ -126,28 +129,22 @@ size_t adjustFrmHeap(EGG::FrmHeap *heap) {
     return ret;
 }
 
-size_t frmHeapCost(size_t size, s32 align) {
+size_t mHeap::frmHeapCost(size_t size, u32 align) {
     int a = align - 1;
-    long b = (0x7C + a);
-    
-    return size + (~(a) & b);
+    s32 b = (0x7C + a);
+
+    return size + (~(a)&b);
 }
 
-EGG::Heap **setTempHeap(EGG::Heap **prevHeap, EGG::Heap *tempNewHeap) {
-    *prevHeap = tempNewHeap->becomeCurrentHeap();
-    return prevHeap;
-}
-EGG::Heap **restoreTempHeap(EGG::Heap **prevHeap, s32 size) {
-    if (prevHeap != nullptr) {
-        (*prevHeap)->becomeCurrentHeap();
-        if (size > 0) {
-            delete prevHeap;
-        }
-    }
-    return prevHeap;
+mHeap::mHeap(EGG::Heap *heap) {
+    this->heap = heap->becomeCurrentHeap();
 }
 
-EGG::ExpHeap *createHeap(size_t size, EGG::Heap *block, const char *name) {
+mHeap::~mHeap() {
+    heap->becomeCurrentHeap();
+}
+
+EGG::Heap *mHeap::createHeap(size_t size, EGG::Heap *block, const char *name) {
     EGG::ExpHeap *heap = EGG::ExpHeap::create(size, block, 4);
     if (heap != nullptr) {
         heap->setGroupID(0);
@@ -160,73 +157,56 @@ EGG::ExpHeap *createHeap(size_t size, EGG::Heap *block, const char *name) {
 
     return heap;
 }
-void saveCurrentHeap() {
-    s_SavedCurrentHeap = (EGG::ExpHeap *)EGG::Heap::sCurrentHeap;
+void mHeap::saveCurrentHeap() {
+    s_SavedCurrentHeap = EGG::Heap::sCurrentHeap;
 }
-void restoreCurrentHeap() {
+void mHeap::restoreCurrentHeap() {
     s_SavedCurrentHeap->becomeCurrentHeap();
     s_SavedCurrentHeap = nullptr;
 }
 
-EGG::FrmHeap *makeFrmHeapAndUpdate(size_t size, EGG::Heap *parentHeap, const char *name, s32 align, u32 unk) {
+EGG::FrmHeap *mHeap::makeFrmHeapAndUpdate(size_t size, EGG::Heap *parentHeap, const char *name, u32 align, u32 unk) {
     EGG::FrmHeap *heap = createFrmHeap(size, parentHeap, name, align, unk);
     if (heap != nullptr) {
-        EGG::Heap *heap2 = setCurrentHeap(heap);
-        s_SavedCurrentHeap = (EGG::ExpHeap *)heap2;
+        s_SavedCurrentHeap = setCurrentHeap(heap);
     }
     return heap;
 }
 
-int getDefaultGameHeapId() {
+int mHeap::getDefaultGameHeapId() {
     return g_DefaultGameHeapId;
 }
 
-inline bool isValidHeapId(u32 id) {
-    return id >= 1 && id <= 2;
-}
-
-const char *const s_GameHeapNames[4] = {
-        0,
-        "ゲーム用汎用ヒープ1(mHeap::gameHeaps[1])",
-        "ゲーム用汎用ヒープ2(mHeap::gameHeaps[2])",
-        0,
-};
-
-EGG::ExpHeap *createGameHeap(int heapId, size_t size, EGG::Heap *parent) {
+EGG::Heap *mHeap::createGameHeap(int heapId, size_t size, EGG::Heap *parent) {
     if (!isValidHeapId(heapId)) {
         return nullptr;
     }
 
-    g_gameHeaps[heapId] = createHeap(size, parent, s_GameHeapNames[heapId]);
+    g_gameHeaps[heapId] = mHeap::createHeap(size, parent, s_GameHeapNames[heapId]);
     if (heapId == g_DefaultGameHeapId) {
         g_gameHeaps[0] = g_gameHeaps[heapId];
     }
     return g_gameHeaps[heapId];
 }
-EGG::ExpHeap *createGameHeap1(size_t size, EGG::Heap *parent) {
-    return createGameHeap(getDefaultGameHeapId(), size, parent);
+void mHeap::createGameHeap1(size_t size, EGG::Heap *parentHeap) {
+    createGameHeap(getDefaultGameHeapId(), size, parentHeap);
 }
-EGG::ExpHeap *createArchiveHeap(size_t size, EGG::Heap *parent) {
+void mHeap::createArchiveHeap(size_t size, EGG::Heap *parent) {
     g_archiveHeap = createHeap(size, parent, "汎用ファイル読み込み用ヒープ(mHeap::archiveHeap)");
-    return g_archiveHeap;
 }
-EGG::ExpHeap *createCommandHeap(size_t size, EGG::Heap *parent) {
+void mHeap::createCommandHeap(size_t size, EGG::Heap *parent) {
     g_commandHeap = createHeap(size, parent, "DVD読み込みコマンド用ヒープ(mHeap::commandHeap)");
-    return g_commandHeap;
 }
-EGG::ExpHeap *createDylinkHeap(size_t size, EGG::Heap *parent) {
+void mHeap::createDylinkHeap(size_t size, EGG::Heap *parent) {
     g_dylinkHeap = createHeap(size, parent, "ダイナミックリンク用ヒープ(mHeap::dylinkHeap)");
-    return g_dylinkHeap;
 }
-EGG::AssertHeap *createAssertHeap(EGG::Heap *parent) {
+EGG::AssertHeap *mHeap::createAssertHeap(EGG::Heap *parent) {
     const char *name = "アサートヒープ(mHeap::assertHeap)";
     g_assertHeap = EGG::AssertHeap::create(EGG::AssertHeap::getSize(), parent);
     g_assertHeap->mName = name;
     return g_assertHeap;
 }
 
-EGG::Heap *makeHeapOnCurrentGameHeap(size_t size, char *name, s32 align, u32 flags) {
+EGG::Heap *mHeap::makeHeapOnCurrentGameHeap(size_t size, const char *name, u32 align, u32 flags) {
     return makeFrmHeapAndUpdate(size, g_gameHeaps[0], name, align, flags);
 }
-
-} // namespace mHeap

src/nw4r/ut/ut_DvdFileStream.cpp

@@ -7,7 +7,7 @@ namespace ut {
 
 NW4R_UT_RTTI_DEF_DERIVED(DvdFileStream, FileStream);
 
-void DvdFileStream::DvdAsyncCallback_(long result, DVDFileInfo *info) {
+void DvdFileStream::DvdAsyncCallback_(s32 result, DVDFileInfo *info) {
     DvdFileStream *self = reinterpret_cast<AsyncContext *>(info)->stream;
 
     self->mIsBusy = false;
@@ -18,7 +18,7 @@ void DvdFileStream::DvdAsyncCallback_(long result, DVDFileInfo *info) {
     }
 }
 
-void DvdFileStream::DvdCBAsyncCallback_(long result, DVDCommandBlock *block) {
+void DvdFileStream::DvdCBAsyncCallback_(s32 result, DVDCommandBlock *block) {
     DvdFileStream *self = reinterpret_cast<AsyncContext *>(block)->stream;
 
     self->mIsCancelling = false;
@@ -43,7 +43,7 @@ void DvdFileStream::Initialize_() {
     mAsyncContext.stream = this;
 }
 
-DvdFileStream::DvdFileStream(long entrynum) {
+DvdFileStream::DvdFileStream(s32 entrynum) {
     Initialize_();
     Open(entrynum);
 }
@@ -101,10 +101,10 @@ void DvdFileStream::Close() {
     }
 }
 
-long DvdFileStream::Read(void *dst, unsigned long size) {
+s32 DvdFileStream::Read(void *dst, u32 size) {
     size = AdjustReadLength_(size);
 
-    long result = DVDReadPrio(&mAsyncContext.info, dst, size, mFilePosition.Tell(), mPriority);
+    s32 result = DVDReadPrio(&mAsyncContext.info, dst, size, mFilePosition.Tell(), mPriority);
 
     if (result > 0) {
         mFilePosition.Skip(result);
@@ -113,7 +113,7 @@ long DvdFileStream::Read(void *dst, unsigned long size) {
     return result;
 }
 
-bool DvdFileStream::ReadAsync(void *dst, unsigned long size, AsyncCallback callback, void *arg) {
+bool DvdFileStream::ReadAsync(void *dst, u32 size, AsyncCallback callback, void *arg) {
     size = AdjustReadLength_(size);
 
     bool success = DvdFileStream::PeekAsync(dst, size, callback, arg);
@@ -127,13 +127,13 @@ bool DvdFileStream::ReadAsync(void *dst, unsigned long size, AsyncCallback callb
     return success;
 }
 
-long DvdFileStream::Peek(void *dst, unsigned long size) {
+s32 DvdFileStream::Peek(void *dst, u32 size) {
     size = AdjustReadLength_(size);
 
     return DVDReadPrio(&mAsyncContext.info, dst, size, mFilePosition.Tell(), mPriority);
 }
 
-bool DvdFileStream::PeekAsync(void *dst, unsigned long size, AsyncCallback callback, void *arg) {
+bool DvdFileStream::PeekAsync(void *dst, u32 size, AsyncCallback callback, void *arg) {
     mCallback = callback;
     mCallbackArg = arg;
     mIsBusy = true;
@@ -143,7 +143,7 @@ bool DvdFileStream::PeekAsync(void *dst, unsigned long size, AsyncCallback callb
     return DVDReadAsyncPrio(&mAsyncContext.info, dst, size, mFilePosition.Tell(), DvdAsyncCallback_, mPriority);
 }
 
-void DvdFileStream::Seek(long offset, unsigned long origin) {
+void DvdFileStream::Seek(s32 offset, u32 origin) {
     mFilePosition.Seek(offset, origin);
 }
 
@@ -164,7 +164,7 @@ bool DvdFileStream::CancelAsync(AsyncCallback callback, void *arg) {
     return success;
 }
 
-unsigned long DvdFileStream::AdjustReadLength_(unsigned long len) {
+u32 DvdFileStream::AdjustReadLength_(u32 len) {
     u32 fileOffset = mFilePosition.Tell();
     u32 fileSize = mFilePosition.GetFileSize();
 

src/nw4r/ut/ut_DvdLockedFileStream.cpp

@@ -24,7 +24,7 @@ void DvdLockedFileStream::InitMutex_() {
     OSRestoreInterrupts(enabled);
 }
 
-DvdLockedFileStream::DvdLockedFileStream(long entrynum) : DvdFileStream(entrynum) {
+DvdLockedFileStream::DvdLockedFileStream(s32 entrynum) : DvdFileStream(entrynum) {
     mCancelFlag = false;
     InitMutex_();
 }
@@ -41,20 +41,20 @@ void DvdLockedFileStream::Close() {
     mCancelFlag = false;
 }
 
-long DvdLockedFileStream::Read(void *dst, unsigned long size) {
+s32 DvdLockedFileStream::Read(void *dst, u32 size) {
     if (!LockMutex()) {
         return DVD_RESULT_CANCELED;
     }
-    long ret = DvdFileStream::Read(dst, size);
+    s32 ret = DvdFileStream::Read(dst, size);
     UnlockMutex();
     return ret;
 }
 
-long DvdLockedFileStream::Peek(void *dst, unsigned long size) {
+s32 DvdLockedFileStream::Peek(void *dst, u32 size) {
     if (!LockMutex()) {
         return DVD_RESULT_CANCELED;
     }
-    long ret = DvdFileStream::Peek(dst, size);
+    s32 ret = DvdFileStream::Peek(dst, size);
     UnlockMutex();
     return ret;
 }

src/nw4r/ut/ut_FileStream.cpp

@@ -15,7 +15,7 @@ bool FileStream::CancelAsync(AsyncCallback callback, void *arg) {
     return true;
 }
 
-u32 FileStream::FilePosition::Skip(long offset) {
+u32 FileStream::FilePosition::Skip(s32 offset) {
     if (offset != 0) {
         s64 newOffset = mFileOffset + offset;
         mFileOffset = Clamp<s64>(newOffset, 0, mFileSize);
@@ -24,7 +24,7 @@ u32 FileStream::FilePosition::Skip(long offset) {
     return mFileOffset;
 }
 
-u32 FileStream::FilePosition::Append(long offset) {
+u32 FileStream::FilePosition::Append(s32 offset) {
     s64 newOffset = mFileOffset + offset;
 
     if (newOffset < 0) {
@@ -37,7 +37,7 @@ u32 FileStream::FilePosition::Append(long offset) {
     return mFileOffset;
 }
 
-void FileStream::FilePosition::Seek(long offset, unsigned long origin) {
+void FileStream::FilePosition::Seek(s32 offset, u32 origin) {
     switch (origin) {
     case SEEK_BEG:
         mFileOffset = 0;

src/nw4r/ut/ut_IOStream.cpp

@@ -7,15 +7,15 @@ namespace ut {
 
 NW4R_UT_RTTI_DEF_BASE(IOStream);
 
-bool IOStream::ReadAsync(void *dst, unsigned long size, AsyncCallback callback, void *arg) {
+bool IOStream::ReadAsync(void *dst, u32 size, AsyncCallback callback, void *arg) {
     return false;
 }
 
-long IOStream::Write(const void *src, unsigned long size) {
+s32 IOStream::Write(const void *src, u32 size) {
     return false;
 }
 
-bool IOStream::WriteAsync(const void *src, unsigned long size, AsyncCallback callback, void *arg) {
+bool IOStream::WriteAsync(const void *src, u32 size, AsyncCallback callback, void *arg) {
     return false;
 }
 

src/nw4r/ut/ut_LockedCache.cpp

@@ -89,15 +89,15 @@ void Unlock() {
     sLCImpl.Unlock();
 }
 
-void LoadBlocks(void *dst, void *src, unsigned long size) {
+void LoadBlocks(void *dst, void *src, u32 size) {
     LCLoadBlocks(dst, src, size);
 }
 
-void StoreBlocks(void *dst, void *src, unsigned long size) {
+void StoreBlocks(void *dst, void *src, u32 size) {
     LCStoreBlocks(dst, src, size);
 }
 
-void StoreData(void *dst, void *src, unsigned long size) {
+void StoreData(void *dst, void *src, u32 size) {
     LCStoreData(dst, src, size);
 }
 

src/nw4r/ut/ut_NandFileStream.cpp

@@ -8,7 +8,7 @@ namespace ut {
 
 NW4R_UT_RTTI_DEF_DERIVED(NandFileStream, FileStream);
 
-void NandFileStream::NandAsyncCallback_(long result, NANDCommandBlock *block) {
+void NandFileStream::NandAsyncCallback_(s32 result, NANDCommandBlock *block) {
     NandFileStream *self = reinterpret_cast<AsyncContext *>(block)->stream;
 
     self->mIsBusy = false;
@@ -32,12 +32,12 @@ void NandFileStream::Initialize_() {
     mAsyncContext.stream = this;
 }
 
-NandFileStream::NandFileStream(const char *path, unsigned long access) {
+NandFileStream::NandFileStream(const char *path, u32 access) {
     Initialize_();
     Open(path, access);
 }
 
-NandFileStream::NandFileStream(const NANDFileInfo *info, unsigned long access, bool close) {
+NandFileStream::NandFileStream(const NANDFileInfo *info, u32 access, bool close) {
     Initialize_();
     Open(info, access, close);
 }
@@ -48,7 +48,7 @@ NandFileStream::~NandFileStream() {
     }
 }
 
-bool NandFileStream::Open(const char *path, unsigned long access) {
+bool NandFileStream::Open(const char *path, u32 access) {
     if (mCloseOnDestroy) {
         Close();
     }
@@ -61,7 +61,7 @@ bool NandFileStream::Open(const char *path, unsigned long access) {
     }
 
     if (mCanRead) {
-        unsigned long fileSize;
+        u32 fileSize;
 
         if (NANDGetLength(&mAsyncContext.info, &fileSize) != NAND_RESULT_OK) {
             NANDClose(&mAsyncContext.info);
@@ -80,7 +80,7 @@ bool NandFileStream::Open(const char *path, unsigned long access) {
     return true;
 }
 
-bool NandFileStream::Open(const NANDFileInfo *info, unsigned long access, bool close) {
+bool NandFileStream::Open(const NANDFileInfo *info, u32 access, bool close) {
     if (mCloseOnDestroy) {
         Close();
     }
@@ -90,7 +90,7 @@ bool NandFileStream::Open(const NANDFileInfo *info, unsigned long access, bool c
 
     mAsyncContext.info = *info;
 
-    unsigned long fileSize;
+    u32 fileSize;
     if (mCanRead) {
         if (NANDGetLength(&mAsyncContext.info, &fileSize) != NAND_RESULT_OK) {
             if (close) {
@@ -115,10 +115,10 @@ void NandFileStream::Close() {
     }
 }
 
-long NandFileStream::Read(void *dst, unsigned long size) {
+s32 NandFileStream::Read(void *dst, u32 size) {
     NANDSeek(&mAsyncContext.info, mFilePosition.Tell(), NAND_SEEK_BEG);
 
-    long result = NANDRead(&mAsyncContext.info, dst, size);
+    s32 result = NANDRead(&mAsyncContext.info, dst, size);
     if (result > 0) {
         mFilePosition.Skip(result);
     }
@@ -126,7 +126,7 @@ long NandFileStream::Read(void *dst, unsigned long size) {
     return result;
 }
 
-bool NandFileStream::ReadAsync(void *dst, unsigned long size, AsyncCallback callback, void *arg) {
+bool NandFileStream::ReadAsync(void *dst, u32 size, AsyncCallback callback, void *arg) {
     mCallback = callback;
     mCallbackArg = arg;
     mIsBusy = true;
@@ -145,23 +145,23 @@ bool NandFileStream::ReadAsync(void *dst, unsigned long size, AsyncCallback call
     return success;
 }
 
-long NandFileStream::Write(const void *src, unsigned long size) {
+s32 NandFileStream::Write(const void *src, u32 size) {
     NANDSeek(&mAsyncContext.info, mFilePosition.Tell(), NAND_SEEK_BEG);
-    long result = NANDWrite(&mAsyncContext.info, src, size);
+    s32 result = NANDWrite(&mAsyncContext.info, src, size);
     if (result > 0) {
         mFilePosition.Append(result);
     }
     return result;
 }
 
-bool NandFileStream::WriteAsync(const void *src, unsigned long size, AsyncCallback callback, void *arg) {
+bool NandFileStream::WriteAsync(const void *src, u32 size, AsyncCallback callback, void *arg) {
     mCallback = callback;
     mCallbackArg = arg;
     mIsBusy = true;
 
     NANDSeek(&mAsyncContext.info, mFilePosition.Tell(), NAND_SEEK_BEG);
 
-    long result = NANDWriteAsync(&mAsyncContext.info, src, size, NandAsyncCallback_, &mAsyncContext.block);
+    s32 result = NANDWriteAsync(&mAsyncContext.info, src, size, NandAsyncCallback_, &mAsyncContext.block);
 
     if (result == NAND_RESULT_OK) {
         mFilePosition.Append(size);
@@ -172,7 +172,7 @@ bool NandFileStream::WriteAsync(const void *src, unsigned long size, AsyncCallba
     return result == NAND_RESULT_OK;
 }
 
-void NandFileStream::Seek(long offset, unsigned long origin) {
+void NandFileStream::Seek(s32 offset, u32 origin) {
     mFilePosition.Seek(offset, origin);
 }
 

src/nw4r/ut/ut_binaryFileFormat.cpp

@@ -4,7 +4,7 @@ namespace nw4r {
 namespace ut {
 
 /* 8042a9e0 */
-bool IsValidBinaryFile(const BinaryFileHeader *header, unsigned long magic, u16 version, u16 numBlocks) {
+bool IsValidBinaryFile(const BinaryFileHeader *header, u32 magic, u16 version, u16 numBlocks) {
     if (header->magic != magic) {
         return false;
     }