Compare commits

...

44 Commits

Author SHA1 Message Date
coah
18326569a4 cleanup(iplBoardObject): name StandData step and angle index
Rename StandData lerp counter and angle index used by stt_stand.
2026-10-01 19:07:05 -05:00
coah
30e1ef0938 cleanup(CXStreamingUncompression): name RL/LZ outData and outDataLen (#678)
Match Huffman context naming for the destination pointer and remaining
byte count on CXUncompContextRL/LZ.
2026-10-01 19:04:36 -05:00
coah
9ff511afd7 cleanup(RakuRakuThread): name BSS globals, alloc wrappers, syncProgress (#665)
- RakuRakuThread_810BDDD0 → sRakuAllocator
- RakuRakuThread_810BDDE0 → sRakuStatus
- RakuRakuThread_810BDED4 → sRakuMsgQueue
- RakuRakuThread_813FDEF0/FC → RakuSocketAlloc/Free
- RakuRakuThread_813FDF08/18 → RakuAtermAlloc/Free
- RakuRakuThread_813FDA04 → syncRakuProgress

DOL sha1 unchanged.
2026-10-01 19:00:34 -05:00
coah
2f206d7fe8 Add relocation-aware jump-table comparison and tests (#676) 2026-10-01 18:58:24 -05:00
coah
d6b044ff32 cleanup(BS2Mach): promote lbl_* aliases to real names (#675)
Replace address labels with the existing #define names (DvdReadPending,
TicketViews, CoverBlock, etc.) and drop the macros.

DOL sha1 unchanged.
2026-10-01 18:57:57 -05:00
coah
0e73a554de cleanup(AOSS): name protocol/state handlers (#671)
Rename remaining address-suffixed AOSS_* dispatch, reply, parse, and
send helpers. Pairs with crypto/connect helper rename PR.

DOL sha1 unchanged.
2026-10-01 18:57:52 -05:00
coah
d4cdae2177 cleanup(usb_kbd): name USBKBDCmdLED device and ledBits (#674)
Rename unk_0x00/unk_0x04 to match USBKBDSetLED parameters.
2026-10-01 18:55:13 -05:00
coah
4b831f9ec0 cleanup(ATERM): name protocol and crypto helpers (#673)
Rename remaining ATERM_814* address symbols to descriptive names for
network/stack, scan, association, AES key wrap, and MD5 helpers.

DOL sha1 unchanged.
2026-10-01 18:55:06 -05:00
coah
fbecedd948 cleanup(sdi_api): rename __sdCbArg.unk_0x0C to cmd (#672)
Field is assigned the SD command and switched on in __sdCb.
2026-10-01 18:52:58 -05:00
github-actions[bot]
f533c9f0f5 docs: update progress [skip ci] 2026-10-01 23:51:36 +00:00
github-actions[bot]
1366528dd6 docs: update progress [skip ci] 2026-10-01 23:50:59 +00:00
coah
bd27e72a48 match(tiPcKeyboard): LayoutByNW4R::updateInput (#670)
Force a u16 temporary for the Korean keymap table load so MWCC emits
clrlwi after lhz (instead of mr).
2026-10-01 18:50:45 -05:00
coah
08c53bbe23 cleanup(AOSS): name crypto and connect helpers (#669)
- AOSS_81401C9C → AOSSInitKeySchedule
- AOSS_81401DC0 → AOSSInitCrc32Table
- AOSS_81401E80 → AOSSXorBufferWithKey
- AOSS_81400830 → AOSSDecryptMessage
- AOSS_81401BBC → AOSSBuildInterfaceOption
- AOSS_814020CC → AOSSConnectAndAwaitHost

DOL sha1 unchanged.
2026-10-01 18:50:19 -05:00
coah
483005a940 link(d_nhttp_private): flip Matching after 100% objdiff (#668)
Unit is instruction-exact (7/7, 1320/1320) with clean C source.
Full 43U build keeps DOL SHA1 26116613f624061ba99c8d1a299aaa6efa85670d.

Co-authored-by: linker <linker@local>
2026-10-01 18:50:14 -05:00
coah
b18d01602a cleanup(CardSequence): name card-thread helpers (#667)
Rename address-suffixed CardSequence_* helpers to descriptive names
(send/poll/map/clear/refresh/thread/error/state/icon/move).

DOL sha1 unchanged.
2026-10-01 18:49:47 -05:00
coah
e38a4cebfe cleanup(MemoryCardManager): rename qsort comparator (#666)
iplMemoryCardManager_813CD034 → compareMemoryCardSortEntries

DOL sha1 unchanged.
2026-10-01 18:49:40 -05:00
coah
81dc9d2b3d cleanup(pf_code): rename pf_valid_fn_char_8162E6B0 to pf_valid_fn_char (#664)
Drop address suffix so source matches symbols.txt. Clear scope:local so
NonMatching pf_path splits resolve the same global.
2026-10-01 18:49:14 -05:00
coah
f645518810 cleanup(vi3in1): rename Vdac_Flag_Changed_816991E0 to Vdac_Flag_Changed (#663)
Drop address suffix so source matches symbols.txt. Clear scope:local so
NonMatching vi.c splits resolve the same global.
2026-10-01 18:48:47 -05:00
coah
51713e735e cleanup(AOSSLink): name sleep/IP helpers and NCD config BSS (#662)
- AOSS_813FD17C → AOSSi_SleepAlarmHandler
- AOSS_813FD18C → AOSSi_SleepMs
- AOSS_813FD25C → AOSSi_StoreIpv4Octets
- AOSS_810BD4A8 → AOSSi_NcdIfConfig
- AOSS_810BD608 → AOSSi_NcdIpConfig

DOL sha1 unchanged.
2026-10-01 18:48:41 -05:00
coah
ca998ad7cf cleanup(puh_msc): rename uhg_msc_memid_8169971C to uhg_msc_memid (#661)
Drop address suffix on the MSC memory-pool id so source matches
symbols.txt. Mark the symbol global so NonMatching puh_msc_blk
splits resolve the same name.
2026-10-01 18:46:27 -05:00
github-actions[bot]
486c20c623 docs: update progress [skip ci] 2026-10-01 23:46:01 +00:00
coah
6adb0dc52e cleanup(CHANSVm): rename FormatString and LookupScopedObject (#660)
- CHANSVm_8145049C → CHANSVmFormatString
- CHANSVm_81455654 → CHANSVmLookupScopedObject

Unit remains carefully Equivalent; DOL sha1 unchanged.
2026-10-01 18:45:59 -05:00
coah
c9f64372cf cleanup(CHANSVm): rename blob offset/size helpers and MakeU64 (#659)
- CHANSVm_81450D14 → CHANSVmBlobResolveOffset
- CHANSVm_81451314 → CHANSVmBlobGetCount
- CHANSVm_81451348 → CHANSVmBlobHasSpace
- CHANSVm_814540E0 → CHANSVmMakeU64

Unit still Matching; DOL sha1 unchanged.
2026-10-01 18:45:53 -05:00
coah
9f4a70db74 match(pf_fat): PFFAT_GetSectorSpecified (#658)
Rewrite the error cleanup as switch(error) so MWCC emits the
target beq/b/li epilogue instead of a collapsed bne/li.

Unit pf_fat: 30/35 -> 31/35 funcs; 9900 -> 9968 / 12572 code bytes.
DOL sha1: 26116613f624061ba99c8d1a299aaa6efa85670d
2026-10-01 18:45:26 -05:00
coah
e305e6047c cleanup(CHANSVm): name float/int/string convert helpers (#657)
- CHANSVm_8144B1D8 → CHANSVmFloatSign
- CHANSVm_8144B30C → CHANSVmConvertToIntFromFloat
- CHANSVm_8144B430 → CHANSVmConvertToFloatFromUndefined
- CHANSVm_8144B470 → CHANSVmConvertToFloatFromInt
- CHANSVm_8144B4D4 → CHANSVmConvertToFloatFromStr
- CHANSVm_8144B62C → CHANSVmFloatToWString
- CHANSVm_8144B734 → CHANSVmConvertToStrFromFloat

Verified ok + sha1 26116613f624061ba99c8d1a299aaa6efa85670d.
2026-10-01 18:45:19 -05:00
coah
df48bc9f76 Restore SD title switch block emission order (#656) 2026-10-01 18:43:05 -05:00
coah
3bd814f042 cleanup(SDMemory): rename iplSDMemory_813EE358 to containsTitleId (#655)
Helper scans a title-id list for a match; unused SDMemory* param kept.
Verified ok + sha1 26116613f624061ba99c8d1a299aaa6efa85670d.
2026-10-01 18:42:39 -05:00
coah
51b78ed7da cleanup(iplBalloon): name fade/align/margin fields (#654)
Rename TextBalloon unk_ members and ctor/setPos params.

Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 18:40:27 -05:00
coah
3eb5d8faee cleanup(iplAOSSThread): name stack sentinel like RakuStack (#653)
Replace *(u32*)(mpStackBuffer + 0x3FC0) with AOSSStack::sentinel.

Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 18:40:21 -05:00
coah
d99950fc88 cleanup(tiCandidateBox): drop unused sdata2 float decls (#652)
Removed seven bare extern lbl_81694D* decls that were never referenced.
Verified ok + sha1 26116613f624061ba99c8d1a299aaa6efa85670d.
2026-10-01 18:38:09 -05:00
coah
98d03059bd cleanup(iplBoardObject): rename Cos/Sin Ghidra locals (#651)
dVar2 → cosF, dVar3 → sinF in BoardObject::stt_stand.

Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 18:37:42 -05:00
coah
830e2f3920 cleanup(iplSound): name pitch/volume sdata2 float constants (#650)
lbl_816946A8 → scSoundTwoF (2.0f), lbl_816946AC → scSoundOneF (1.0f),
lbl_816946B0 → scSoundThirtyF (30.0f), lbl_816946B4 → scSoundSixtyF (60.0f).
2026-10-01 18:37:35 -05:00
coah
c1b00d8a14 cleanup(Date): drop unused lbl_816948F0 sdata2 decl (#649)
Bare extern was never referenced; scDateZeroF remains.
Verified ok + sha1 26116613f624061ba99c8d1a299aaa6efa85670d.
2026-10-01 18:37:29 -05:00
coah
9acdd7f8dc cleanup(WDScan): name OUI sdata/sdata2 padding bytes (#648)
Rename leftover lbl_* pad bytes that sit between the RSN/WPA OUI
triples (and after scWpaFindOui*) so force_active and locals match
the existing sc* naming.
2026-10-01 18:37:02 -05:00
coah
abf047831a cleanup(tiInputForm): rename scInputForm0_7111111F to DegToFIdx (#647)
0.7111111f is 256/360 (degrees → nw4r SinFIdx units). Drop the
digit-heavy name that looked like an address suffix.

Verified: ninja build/43U/ok; fuzzy unchanged; DOL sha1 unchanged.
2026-10-01 18:35:19 -05:00
coah
17be3b014b cleanup(ChannelSelect): name updateDiskState asm labels (#646)
Rename address-suffixed local labels and jumptable_8164DE80 inside the
carefully Equivalent updateDiskState asm to case*/done semantic names.
symbols.txt updated for the jumptable; codegen unchanged.

Verified: ninja build/43U/ok; ~96.37% code / ~99.76% fuzzy; DOL sha1 unchanged.
2026-10-01 18:35:13 -05:00
coah
0d9d3d1081 cleanup(runtime): prefix Matching asm L_* labels with function names (#645)
Rename 65 bare address labels in Runtime helpers (__div2u/__div2i/__mod*,
__cvt_*, __shr2i) to FunctionName_L_<addr> for readability; codegen unchanged.

Verified: ninja build/43U/ok; runtime 100%/100%; DOL sha1 unchanged.
2026-10-01 18:35:07 -05:00
coah
196b14aa58 cleanup(CDBDatabase): prefix Matching asm L_* labels with function names (#644)
Rename 169 bare address labels inside the seven Search* asm functions to
FunctionName_L_<addr>, matching the nand_drv style, so local branches are
readable without changing codegen.

Verified: ninja build/43U/ok; CDBDatabase 100%/100%; DOL sha1 unchanged.
2026-10-01 18:34:25 -05:00
coah
1dde229702 cleanup(sdChannelSelect): drop unused iplSDChannelSelect_813DD240 decl (#643)
The real path is collectTitlesFromNandUsage; this extern was never called.
Build still OK; DOL sha1 unchanged.
2026-10-01 18:33:58 -05:00
coah
94c03497ff cleanup(SDChannelObj): name address-suffixed C helpers (#636)
Rename iplSDChannelObj_813E* helpers to semantic names (setHeaps,
createBaseLayout, getLocalizedName, etc.) across the unit, callers,
header, and symbols.txt. Byte-identical: ok + sha1
26116613f624061ba99c8d1a299aaa6efa85670d; unit still ~90% code /
~99.99% fuzzy.
2026-10-01 18:33:42 -05:00
coah
e9dd012c09 cleanup(zmtkey): name Zi8MapKeyCode helper (#642)
Rename Zi8_81484484 (OEM/private-use wchar → key index) to
Zi8MapKeyCode. Byte-identical: ok + sha1
26116613f624061ba99c8d1a299aaa6efa85670d; unit still ~67.1% code /
~99.85% fuzzy.
2026-10-01 18:33:31 -05:00
coah
90e7b0ff2c iplSensitivity: suppress inline Rect dtor weak (#641)
Define IPL_CONTROLLER_TRIVIAL_RECT_DTOR so this TU no longer emits
~nw4r::ut::Rect. Compiled .text becomes byte-identical to the extract
(1112 bytes). Matching still blocked on .sdata2 layout (48 vs 56).

Co-authored-by: linker <linker@users.noreply.github.com>
2026-10-01 18:33:24 -05:00
coah
f7ec594202 cleanup(tiInputForm): name float/color sdata constants (#626)
* cleanup(tiInputForm): name float/color sdata constants

Prefix scInputForm* to avoid colliding with other units'
scHalfF/scTwoF globals. Leave unused N_KOR/N_CHN decls.

* cleanup(tiInputForm): keep ChanAppBox scHalfF/scTwoF

0x81694900/0x81694904 belong to iplChanAppBox; restore those symbol
names and leave only tiInputForm-owned scInputForm* at 0x81694D28+.
2026-10-01 18:25:29 -05:00
github-actions[bot]
ceefb50e42 docs: update progress [skip ci] 2026-10-01 23:25:22 +00:00
48 changed files with 1953 additions and 1632 deletions

View File

@@ -53,9 +53,9 @@ Progress
<!-- progress:start -->
| Decompiled | Matched | Linked | Data |
|:---:|:---:|:---:|:---:|
| 99.38% | 88.00% | 62.36% | 92.07% |
| 99.38% | 88.00% | 62.37% | 92.07% |
units 920/1027 complete, functions 12225/12563 matched.
units 920/1027 complete, functions 12226/12563 matched.
decompiled = code with a C/C++ implementation (objdiff fuzzy), matched = byte-exact code, linked = code actually linked into the DOL, data = byte-exact data
<!-- progress:end -->

View File

@@ -29,8 +29,8 @@ force_active:
- strspn
- strcspn
- padding__Q23ipl5scene
- lbl_81695063
- lbl_81695067
- scRsnOuiPad
- scWpaOuiPad
- __vt__Q49textinput6extend4memo19NigaoeEventObserver
# textinput::toolbar::csPaneToAnimation points one past the end of csAninationFile.

View File

@@ -27,7 +27,7 @@ BS2Allocator = .bss:0x8108B6E0; // type:object size:0x10 scope:global
BS2StateFlags = .bss:0x8108B6F0; // type:object size:0x20
Block = .bss:0x8108B720; // type:object size:0x30 align:32
PartitionInfoBuf = .bss:0x8108B760; // type:object size:0x800 align:32 data:4byte
lbl_8108BF60 = .bss:0x8108BF60; // type:object size:0x30 data:4byte
CoverBlock = .bss:0x8108BF60; // type:object size:0x30 data:4byte
BS2CacheFileInfo = .bss:0x8108BF90; // type:object size:0x8C
BS2NandBlock = .bss:0x8108C01C; // type:object size:0xBC
PartitionParams = .bss:0x8108C0E0; // type:object size:0x1DE00 scope:local align:32
@@ -37,7 +37,7 @@ GameTOCBuf = .bss:0x810A9F20; // type:object size:0x20 align:32
bi3 = .bss:0x810A9F40; // type:object size:0x2000 align:32 data:4byte
AppLoaderHdr = .bss:0x810ABF40; // type:object size:0x20 align:32 data:4byte
bi2 = .bss:0x810ABF60; // type:object size:0x2000 align:32 data:4byte
lbl_810ADF60 = .bss:0x810ADF60; // type:object size:0x20 align:32 data:4byte
UpdateDiskID = .bss:0x810ADF60; // type:object size:0x20 align:32 data:4byte
TicketViewsBuf = .bss:0x810ADF80; // type:object size:0x3600 scope:local align:32
Flags0 = .bss:0x810B1580; // type:object size:0x800 scope:local
Flags1 = .bss:0x810B1D80; // type:object size:0x800 scope:local
@@ -81,11 +81,11 @@ usbapStack = .bss:0x810BC460; // type:object size:0x1000
usbapMessageQ = .bss:0x810BD460; // type:object size:0x20
usbapNickname = .bss:0x810BD480; // type:object size:0x18
m_allocator__Q23ipl5scene = .bss:0x810BD498; // type:object size:0x10
AOSS_810BD4A8 = .bss:0x810BD4A8; // type:object size:0x160 data:byte
AOSS_810BD608 = .bss:0x810BD608; // type:object size:0x7C8 data:4byte
RakuRakuThread_810BDDD0 = .bss:0x810BDDD0; // type:object size:0x10
RakuRakuThread_810BDDE0 = .bss:0x810BDDE0; // type:object size:0xF4 data:4byte
RakuRakuThread_810BDED4 = .bss:0x810BDED4; // type:object size:0x24
AOSSi_NcdIfConfig = .bss:0x810BD4A8; // type:object size:0x160 data:byte
AOSSi_NcdIpConfig = .bss:0x810BD608; // type:object size:0x7C8 data:4byte
sRakuAllocator = .bss:0x810BDDD0; // type:object size:0x10
sRakuStatus = .bss:0x810BDDE0; // type:object size:0xF4 data:4byte
sRakuMsgQueue = .bss:0x810BDED4; // type:object size:0x24
AOSS_810BDEF8 = .bss:0x810BDEF8; // type:object size:0x20 data:4byte
AOSS_810BDF18 = .bss:0x810BDF18; // type:object size:0x6A0
AOSS_810BE5B8 = .bss:0x810BE5B8; // type:object size:0x280
@@ -4290,7 +4290,7 @@ __dt__Q43ipl5scene10MemoryBase9AnmButtonFv = .text:0x813CCF34; // type:function
__dt__Q43ipl5scene10MemoryBase6ButtonFv = .text:0x813CCF74; // type:function size:0x40
__dt__Q43ipl5scene10MemoryBase3AnmFv = .text:0x813CCFB4; // type:function size:0x40
__dt__Q33ipl5scene15MemoryBaseEventFv = .text:0x813CCFF4; // type:function size:0x40
iplMemoryCardManager_813CD034 = .text:0x813CD034; // type:function size:0x78
compareMemoryCardSortEntries = .text:0x813CD034; // type:function size:0x78
calc__Q33ipl5scene17MemoryCardManagerFv = .text:0x813CD0AC; // type:function size:0x4C
isSlotReady__Q33ipl5scene17MemoryCardManagerFUc = .text:0x813CD0F8; // type:function size:0x44
isSlotNoCard__Q33ipl5scene17MemoryCardManagerFUc = .text:0x813CD13C; // type:function size:0x40
@@ -4399,31 +4399,31 @@ getCardSlotState__Q23ipl10memorycardFv = .text:0x813D2024; // type:function size
getCardLastSrcSlot__Q23ipl10memorycardFv = .text:0x813D202C; // type:function size:0x10
getCardLastSendCmd__Q23ipl10memorycardFv = .text:0x813D203C; // type:function size:0x10
getCardLastCMDFCmdResult__Q23ipl10memorycardFv = .text:0x813D204C; // type:function size:0x10
CardSequence_813D205C = .text:0x813D205C; // type:function size:0x44
sendCardUnmountCmd = .text:0x813D205C; // type:function size:0x44
sendCardFormatCmd__Q23ipl10memorycardFUc = .text:0x813D20A0; // type:function size:0x50
sendCardCopyCmd__Q23ipl10memorycardFUcs = .text:0x813D20F0; // type:function size:0x54
sendCardMoveCmd__Q23ipl10memorycardFUcs = .text:0x813D2144; // type:function size:0x54
sendCardDeleteCmd__Q23ipl10memorycardFUcs = .text:0x813D2198; // type:function size:0x54
sendCardThreadStopCmd__Q23ipl10memorycardFv = .text:0x813D21EC; // type:function size:0x40
CardSequence_813D222C = .text:0x813D222C; // type:function size:0x110
CardSequence_813D233C = .text:0x813D233C; // type:function size:0x9C
pollCardSlot = .text:0x813D222C; // type:function size:0x110
mapCardErrorCode = .text:0x813D233C; // type:function size:0x9C
probeCard__Q23ipl10memorycardFv = .text:0x813D23D8; // type:function size:0x288
initCardThread__Q23ipl10memorycardFv = .text:0x813D2660; // type:function size:0x29C
shutdownCardThread__Q23ipl10memorycardFv = .text:0x813D28FC; // type:function size:0x148
getIconStateArray__Q23ipl10memorycardFv = .text:0x813D2A44; // type:function size:0x10
getIconComment__Q23ipl10memorycardFUcs = .text:0x813D2A54; // type:function size:0x20
CardSequence_813D2A74 = .text:0x813D2A74; // type:function size:0xCC
CardSequence_813D2B40 = .text:0x813D2B40; // type:function size:0x14C
CardSequence_813D2C8C = .text:0x813D2C8C; // type:function size:0x4B4
CardSequence_813D3140 = .text:0x813D3140; // type:function size:0xCC
CardSequence_813D320C = .text:0x813D320C; // type:function size:0x9C
CardSequence_813D32A8 = .text:0x813D32A8; // type:function size:0xD8
CardSequence_813D3380 = .text:0x813D3380; // type:function size:0x58
CardSequence_813D33D8 = .text:0x813D33D8; // type:function size:0x4C
CardSequence_813D3424 = .text:0x813D3424; // type:function size:0x800
CardSequence_813D3C24 = .text:0x813D3C24; // type:function size:0x14
CardSequence_813D3C38 = .text:0x813D3C38; // type:function size:0xDC
CardSequence_813D3D14 = .text:0x813D3D14; // type:function size:0x980
clearCardFileEntry = .text:0x813D2A74; // type:function size:0xCC
refreshCardSlotInfo = .text:0x813D2B40; // type:function size:0x14C
cardThreadMain = .text:0x813D2C8C; // type:function size:0x4B4
markAllCardFilesDirty = .text:0x813D3140; // type:function size:0xCC
handleCardMountResult = .text:0x813D320C; // type:function size:0x9C
reportCardThreadError = .text:0x813D32A8; // type:function size:0xD8
sendCardSlotState = .text:0x813D3380; // type:function size:0x58
clearAllCardFileEntries = .text:0x813D33D8; // type:function size:0x4C
loadCardFileIcons = .text:0x813D3424; // type:function size:0x800
clearCardWritePending = .text:0x813D3C24; // type:function size:0x14
checkCardFileDuplicate = .text:0x813D3C38; // type:function size:0xDC
runCardMoveOrCopy = .text:0x813D3D14; // type:function size:0x980
IPLContestInitialize = .text:0x813D4694; // type:function size:0xBC
IPLContestStart = .text:0x813D4750; // type:function size:0x14
IPLContestProcess = .text:0x813D4764; // type:function size:0x6E8
@@ -4685,42 +4685,42 @@ copyFrom__Q33ipl5scene22SDChannelSelectCommandFRCQ33ipl5scene22SDChannelSelectCo
@20@__dt__Q33ipl5scene15SDChannelSelectFv = .text:0x813E2F24; // type:function size:0x8
__ct__Q33ipl5scene12SDChannelObjFPQ23EGG4Heapii = .text:0x813E2F2C; // type:function size:0x130
__dt__Q33ipl5scene12SDChannelObjFv = .text:0x813E305C; // type:function size:0xA8
iplSDChannelObj_813E3104 = .text:0x813E3104; // type:function size:0x18
iplSDChannelObj_813E311C = .text:0x813E311C; // type:function size:0xC
iplSDChannelObj_813E3128 = .text:0x813E3128; // type:function size:0x50
iplSDChannelObj_813E3178 = .text:0x813E3178; // type:function size:0x8
iplSDChannelObj_813E3180 = .text:0x813E3180; // type:function size:0xAC
iplSDChannelObj_813E322C = .text:0x813E322C; // type:function size:0x9C
iplSDChannelObj_813E32C8 = .text:0x813E32C8; // type:function size:0x3C
iplSDChannelObj_813E3304 = .text:0x813E3304; // type:function size:0x8
iplSDChannelObj_813E330C = .text:0x813E330C; // type:function size:0x14
iplSDChannelObj_activateIfIdle = .text:0x813E3104; // type:function size:0x18
iplSDChannelObj_setHeaps = .text:0x813E311C; // type:function size:0xC
iplSDChannelObj_getOrAllocThumbnailData = .text:0x813E3128; // type:function size:0x50
iplSDChannelObj_setPane = .text:0x813E3178; // type:function size:0x8
iplSDChannelObj_setLayoutFile = .text:0x813E3180; // type:function size:0xAC
iplSDChannelObj_calc = .text:0x813E322C; // type:function size:0x9C
iplSDChannelObj_drawBase = .text:0x813E32C8; // type:function size:0x3C
iplSDChannelObj_drawPage = .text:0x813E3304; // type:function size:0x8
iplSDChannelObj_drawDialog = .text:0x813E330C; // type:function size:0x14
getTranslate__Q33ipl5scene12SDChannelObjCFv = .text:0x813E3320; // type:function size:0x10
iplSDChannelObj_813E3330 = .text:0x813E3330; // type:function size:0x24
iplSDChannelObj_813E3354 = .text:0x813E3354; // type:function size:0x98
iplSDChannelObj_813E33EC = .text:0x813E33EC; // type:function size:0x94
iplSDChannelObj_813E3480 = .text:0x813E3480; // type:function size:0x60
iplSDChannelObj_813E34E0 = .text:0x813E34E0; // type:function size:0x8
iplSDChannelObj_813E34E8 = .text:0x813E34E8; // type:function size:0x4C
iplSDChannelObj_813E3534 = .text:0x813E3534; // type:function size:0x4C
iplSDChannelObj_813E3580 = .text:0x813E3580; // type:function size:0x2D8
iplSDChannelObj_813E3858 = .text:0x813E3858; // type:function size:0xC8
iplSDChannelObj_813E3920 = .text:0x813E3920; // type:function size:0x164
iplSDChannelObj_813E3A84 = .text:0x813E3A84; // type:function size:0x98
iplSDChannelObj_813E3B1C = .text:0x813E3B1C; // type:function size:0x84
iplSDChannelObj_813E3BA0 = .text:0x813E3BA0; // type:function size:0xB8
iplSDChannelObj_813E3C58 = .text:0x813E3C58; // type:function size:0x44
iplSDChannelObj_813E3C9C = .text:0x813E3C9C; // type:function size:0x19C
iplSDChannelObj_813E3E38 = .text:0x813E3E38; // type:function size:0xF0
iplSDChannelObj_813E3F28 = .text:0x813E3F28; // type:function size:0x4C
iplSDChannelObj_813E3F74 = .text:0x813E3F74; // type:function size:0xEC
iplSDChannelObj_813E4060 = .text:0x813E4060; // type:function size:0xDC
iplSDChannelObj_813E413C = .text:0x813E413C; // type:function size:0x2D4
iplSDChannelObj_813E4410 = .text:0x813E4410; // type:function size:0x148
iplSDChannelObj_813E4558 = .text:0x813E4558; // type:function size:0x1AC
iplSDChannelObj_813E4704 = .text:0x813E4704; // type:function size:0x118
iplSDChannelObj_813E481C = .text:0x813E481C; // type:function size:0x18C
iplSDChannelObj_813E49A8 = .text:0x813E49A8; // type:function size:0xAC
iplSDChannelObj_813E4A54 = .text:0x813E4A54; // type:function size:0x168
iplSDChannelObj_hasAppMeta = .text:0x813E3330; // type:function size:0x24
iplSDChannelObj_startAppear = .text:0x813E3354; // type:function size:0x98
iplSDChannelObj_startDisappear = .text:0x813E33EC; // type:function size:0x94
iplSDChannelObj_setSelected = .text:0x813E3480; // type:function size:0x60
iplSDChannelObj_playPageHide = .text:0x813E34E0; // type:function size:0x8
iplSDChannelObj_resetPageAnim = .text:0x813E34E8; // type:function size:0x4C
iplSDChannelObj_resetDialogAnim = .text:0x813E3534; // type:function size:0x4C
iplSDChannelObj_applyLanguageGroups = .text:0x813E3580; // type:function size:0x2D8
iplSDChannelObj_createBaseLayout = .text:0x813E3858; // type:function size:0xC8
iplSDChannelObj_createIconLayout = .text:0x813E3920; // type:function size:0x164
iplSDChannelObj_createMenuLayout = .text:0x813E3A84; // type:function size:0x98
iplSDChannelObj_syncLayoutsToPane = .text:0x813E3B1C; // type:function size:0x84
iplSDChannelObj_createPageLayout = .text:0x813E3BA0; // type:function size:0xB8
iplSDChannelObj_setPageTranslate = .text:0x813E3C58; // type:function size:0x44
iplSDChannelObj_setPageAnim = .text:0x813E3C9C; // type:function size:0x19C
iplSDChannelObj_updatePageAnim = .text:0x813E3E38; // type:function size:0xF0
iplSDChannelObj_playPageAnimator = .text:0x813E3F28; // type:function size:0x4C
iplSDChannelObj_createDialogLayout = .text:0x813E3F74; // type:function size:0xEC
iplSDChannelObj_getLocalizedName = .text:0x813E4060; // type:function size:0xDC
iplSDChannelObj_setBalloonText = .text:0x813E413C; // type:function size:0x2D4
iplSDChannelObj_positionDialog = .text:0x813E4410; // type:function size:0x148
iplSDChannelObj_setDialogAnim = .text:0x813E4558; // type:function size:0x1AC
iplSDChannelObj_updateDialogAnim = .text:0x813E4704; // type:function size:0x118
iplSDChannelObj_findNewMessageGroup = .text:0x813E481C; // type:function size:0x18C
iplSDChannelObj_updateNewMessage = .text:0x813E49A8; // type:function size:0xAC
iplSDChannelObj_checkNewMessage = .text:0x813E4A54; // type:function size:0x168
__ct__Q33ipl5scene14SDChannelTitleFPQ23EGG4HeapPQ33ipl5scene15SDChannelSelect = .text:0x813E4BBC; // type:function size:0x1F4
__dt__Q33ipl5scene14SDChannelTitleFv = .text:0x813E4DB0; // type:function size:0x70
prepare__Q33ipl5scene14SDChannelTitleFv = .text:0x813E4E20; // type:function size:0x4C
@@ -4866,7 +4866,7 @@ onDialogState9__Q33ipl5scene8SDMemoryFv = .text:0x813EDF04; // type:function siz
onDialogState10__Q33ipl5scene8SDMemoryFv = .text:0x813EDFA8; // type:function size:0x130
onDialogState11__Q33ipl5scene8SDMemoryFv = .text:0x813EE0D8; // type:function size:0xE0
onDialogState12__Q33ipl5scene8SDMemoryFv = .text:0x813EE1B8; // type:function size:0x1A0
iplSDMemory_813EE358 = .text:0x813EE358; // type:function size:0x44
iplSDMemory_containsTitleId = .text:0x813EE358; // type:function size:0x44
onDialogState13__Q33ipl5scene8SDMemoryFv = .text:0x813EE39C; // type:function size:0xEC
onDialogState14__Q33ipl5scene8SDMemoryFv = .text:0x813EE488; // type:function size:0x1C4
onDialogState15__Q33ipl5scene8SDMemoryFv = .text:0x813EE64C; // type:function size:0x12C
@@ -5133,11 +5133,11 @@ cancel__Q33ipl5scene10AOSSThreadFv = .text:0x813FCE20; // type:function size:0x5
finish__Q33ipl5scene10AOSSThreadFP13NCDAossConfigPi = .text:0x813FCE70; // type:function size:0x2FC
printInfo__Q33ipl5scene10AOSSThreadFv = .text:0x813FD16C; // type:function size:0x4
AOSSi_Cancel = .text:0x813FD170; // type:function size:0xC
AOSS_813FD17C = .text:0x813FD17C; // type:function size:0x10
AOSS_813FD18C = .text:0x813FD18C; // type:function size:0x88
AOSSi_SleepAlarmHandler = .text:0x813FD17C; // type:function size:0x10
AOSSi_SleepMs = .text:0x813FD18C; // type:function size:0x88
AOSSi_Alloc = .text:0x813FD214; // type:function size:0x24
AOSSi_Free = .text:0x813FD238; // type:function size:0x24
AOSS_813FD25C = .text:0x813FD25C; // type:function size:0x2C
AOSSi_StoreIpv4Octets = .text:0x813FD25C; // type:function size:0x2C
AOSSi_SetNCDIPAddr = .text:0x813FD288; // type:function size:0x7C
AOSSi_InitLocal = .text:0x813FD304; // type:function size:0x68
AOSSi_EndLocal = .text:0x813FD36C; // type:function size:0x34
@@ -5146,62 +5146,62 @@ AOSSi_WLANConnect = .text:0x813FD72C; // type:function size:0x26C
AOSSi_Sleep = .text:0x813FD998; // type:function size:0x4
AOSSi_Status = .text:0x813FD99C; // type:function size:0x34
AOSS_SetCallback = .text:0x813FD9D0; // type:function size:0x34
RakuRakuThread_813FDA04__Q33ipl5scene14RakuRakuThreadFv = .text:0x813FDA04; // type:function size:0x6C scope:local
syncRakuProgress__Q33ipl5scene14RakuRakuThreadFv = .text:0x813FDA04; // type:function size:0x6C scope:local
__ct__Q33ipl5scene14RakuRakuThreadFPQ23EGG4Heap = .text:0x813FDA70; // type:function size:0xD8
__dt__Q33ipl5scene14RakuRakuThreadFv = .text:0x813FDB48; // type:function size:0xA4
destroy__Q33ipl5scene14RakuRakuThreadFv = .text:0x813FDBEC; // type:function size:0xD8
start__Q33ipl5scene14RakuRakuThreadFv = .text:0x813FDCC4; // type:function size:0x180
Run__Q33ipl5scene14RakuRakuThreadFv = .text:0x813FDE44; // type:function size:0xAC
RakuRakuThread_813FDEF0 = .text:0x813FDEF0; // type:function size:0xC scope:local
RakuRakuThread_813FDEFC = .text:0x813FDEFC; // type:function size:0xC scope:local
RakuRakuThread_813FDF08 = .text:0x813FDF08; // type:function size:0x10 scope:local
RakuRakuThread_813FDF18 = .text:0x813FDF18; // type:function size:0x10 scope:local
RakuSocketAlloc = .text:0x813FDEF0; // type:function size:0xC scope:local
RakuSocketFree = .text:0x813FDEFC; // type:function size:0xC scope:local
RakuAtermAlloc = .text:0x813FDF08; // type:function size:0x10 scope:local
RakuAtermFree = .text:0x813FDF18; // type:function size:0x10 scope:local
getState__Q33ipl5scene14RakuRakuThreadFv = .text:0x813FDF28; // type:function size:0x128
cancel__Q33ipl5scene14RakuRakuThreadFv = .text:0x813FE050; // type:function size:0x14
finish__Q33ipl5scene14RakuRakuThreadFP11NCDApConfigPi = .text:0x813FE064; // type:function size:0x214
printInfo__Q33ipl5scene14RakuRakuThreadFv = .text:0x813FE278; // type:function size:0x4
AOSSi_Init = .text:0x813FE27C; // type:function size:0x22C
AOSS_Init_old = .text:0x813FE4A8; // type:function size:0x18C0
AOSS_813FFD68 = .text:0x813FFD68; // type:function size:0x36C
AOSSValidateInitConfig = .text:0x813FFD68; // type:function size:0x36C
AOSS_CheckAP = .text:0x814000D4; // type:function size:0xE0
AOSS_814001B4 = .text:0x814001B4; // type:function size:0x13C
AOSS_814002F0 = .text:0x814002F0; // type:function size:0x1E0
AOSS_814004D0 = .text:0x814004D0; // type:function size:0x1D4
AOSS_814006A4 = .text:0x814006A4; // type:function size:0x18C
AOSS_81400830 = .text:0x81400830; // type:function size:0x504
AOSS_81400D34 = .text:0x81400D34; // type:function size:0xD8
AOSS_81400E0C = .text:0x81400E0C; // type:function size:0x2F8
AOSS_81401104 = .text:0x81401104; // type:function size:0x180
AOSS_81401284 = .text:0x81401284; // type:function size:0x128
AOSS_814013AC = .text:0x814013AC; // type:function size:0x1C8
AOSS_81401574 = .text:0x81401574; // type:function size:0x204
AOSS_81401778 = .text:0x81401778; // type:function size:0x444
AOSS_81401BBC = .text:0x81401BBC; // type:function size:0xE0
AOSS_81401C9C = .text:0x81401C9C; // type:function size:0x124
AOSS_81401DC0 = .text:0x81401DC0; // type:function size:0xC0
AOSS_81401E80 = .text:0x81401E80; // type:function size:0x24C
AOSS_814020CC = .text:0x814020CC; // type:function size:0xF0
ATERM_814021BC = .text:0x814021BC; // type:function size:0x268
ATERM_81402424 = .text:0x81402424; // type:function size:0x348
ATERM_8140276C = .text:0x8140276C; // type:function size:0x2B8
ATERM_81402A24 = .text:0x81402A24; // type:function size:0x41C
ATERM_81402E40 = .text:0x81402E40; // type:function size:0x180
ATERM_81402FC0 = .text:0x81402FC0; // type:function size:0x21C
ATERM_814031DC = .text:0x814031DC; // type:function size:0x214
ATERM_814033F0 = .text:0x814033F0; // type:function size:0x224
ATERM_81403614 = .text:0x81403614; // type:function size:0xC4
ATERM_814036D8 = .text:0x814036D8; // type:function size:0x1F0
ATERM_814038C8 = .text:0x814038C8; // type:function size:0xEDC
AOSSDispatchReceiveState = .text:0x814001B4; // type:function size:0x13C
AOSSHandleDiscoverReply = .text:0x814002F0; // type:function size:0x1E0
AOSSHandleAuthReply = .text:0x814004D0; // type:function size:0x1D4
AOSSHandleFinalReply = .text:0x814006A4; // type:function size:0x18C
AOSSDecryptMessage = .text:0x81400830; // type:function size:0x504
AOSSCheckAccessPointName = .text:0x81400D34; // type:function size:0xD8
AOSSParseNetworkSettings = .text:0x81400E0C; // type:function size:0x2F8
AOSSParseWepConfig = .text:0x81401104; // type:function size:0x180
AOSSParsePskConfig = .text:0x81401284; // type:function size:0x128
AOSSApplyAuthOptions = .text:0x814013AC; // type:function size:0x1C8
AOSSSendDiscoveryRequest = .text:0x81401574; // type:function size:0x204
AOSSSendHelloRequest = .text:0x81401778; // type:function size:0x444
AOSSBuildInterfaceOption = .text:0x81401BBC; // type:function size:0xE0
AOSSInitKeySchedule = .text:0x81401C9C; // type:function size:0x124
AOSSInitCrc32Table = .text:0x81401DC0; // type:function size:0xC0
AOSSXorBufferWithKey = .text:0x81401E80; // type:function size:0x24C
AOSSConnectAndAwaitHost = .text:0x814020CC; // type:function size:0xF0
ATERMStartNetworkStack = .text:0x814021BC; // type:function size:0x268
ATERMScanAccessPoints = .text:0x81402424; // type:function size:0x348
ATERMFindChangedApRecord = .text:0x8140276C; // type:function size:0x2B8
ATERMDiscoverAccessPoints = .text:0x81402A24; // type:function size:0x41C
ATERMBuildEncryptedMessage = .text:0x81402E40; // type:function size:0x180
ATERMParsePacket = .text:0x81402FC0; // type:function size:0x21C
ATERMBuildAssociationRequest = .text:0x814031DC; // type:function size:0x214
ATERMParseAssociationResponse = .text:0x814033F0; // type:function size:0x224
ATERMParseHexBytes = .text:0x81403614; // type:function size:0xC4
ATERMApplyScanSecuritySettings = .text:0x814036D8; // type:function size:0x1F0
ATERMRunConfigProtocol = .text:0x814038C8; // type:function size:0xEDC
ATERMi_AutoConfigThread = .text:0x814047A4; // type:function size:0xA0
ATERM_81404844 = .text:0x81404844; // type:function size:0x1D4
ATERM_81404A18 = .text:0x81404A18; // type:function size:0x1E4
ATERM_81404BFC = .text:0x81404BFC; // type:function size:0x430
ATERM_8140502C = .text:0x8140502C; // type:function size:0x228
ATERM_81405254 = .text:0x81405254; // type:function size:0x43C
ATERM_81405690 = .text:0x81405690; // type:function size:0x43C
ATERM_81405ACC = .text:0x81405ACC; // type:function size:0x240
ATERM_81405D0C = .text:0x81405D0C; // type:function size:0xB40
ATERM_8140684C = .text:0x8140684C; // type:function size:0x10
ATERMAesKeyWrap = .text:0x81404844; // type:function size:0x1D4
ATERMAesKeyUnwrap = .text:0x81404A18; // type:function size:0x1E4
ATERMAesExpandEncryptKey = .text:0x81404BFC; // type:function size:0x430
ATERMAesExpandDecryptKey = .text:0x8140502C; // type:function size:0x228
ATERMAesEncryptBlock = .text:0x81405254; // type:function size:0x43C
ATERMAesDecryptBlock = .text:0x81405690; // type:function size:0x43C
ATERMMd5Update = .text:0x81405ACC; // type:function size:0x240
ATERMMd5Transform = .text:0x81405D0C; // type:function size:0xB40
ATERMAlarmWakeQueue = .text:0x8140684C; // type:function size:0x10
ATERMi_ApConfigStart = .text:0x8140685C; // type:function size:0x19C
ATERMi_ApConfigEnd = .text:0x814069F8; // type:function size:0x204
ATERMi_ApConfigGetState = .text:0x81406BFC; // type:function size:0x8C
@@ -6670,19 +6670,19 @@ CHANSVmStrCpyToU16FromU8 = .text:0x8144B058; // type:function size:0x34
CHANSVmStrCpyToU8FromU16 = .text:0x8144B08C; // type:function size:0x44
CHANSVmStrCpyToU8FromStringObject = .text:0x8144B0D0; // type:function size:0xB4
VmIsNan = .text:0x8144B184; // type:function size:0x54 scope:local
CHANSVm_8144B1D8 = .text:0x8144B1D8; // type:function size:0x20 scope:local
CHANSVmFloatSign = .text:0x8144B1D8; // type:function size:0x20 scope:local
VmIntToFloat = .text:0x8144B1F8; // type:function size:0x50 scope:local
CHANSVmParseInt = .text:0x8144B248; // type:function size:0xC4 scope:local
CHANSVm_8144B30C = .text:0x8144B30C; // type:function size:0xAC scope:local
CHANSVmConvertToIntFromFloat = .text:0x8144B30C; // type:function size:0xAC scope:local
CHANSVmConvertToIntFromStr = .text:0x8144B3B8; // type:function size:0x70
CHANSVmConvertToIntFromArray = .text:0x8144B428; // type:function size:0x8
CHANSVm_8144B430 = .text:0x8144B430; // type:function size:0x40
CHANSVm_8144B470 = .text:0x8144B470; // type:function size:0x64
CHANSVm_8144B4D4 = .text:0x8144B4D4; // type:function size:0x14C
CHANSVmConvertToFloatFromUndefined = .text:0x8144B430; // type:function size:0x40
CHANSVmConvertToFloatFromInt = .text:0x8144B470; // type:function size:0x64
CHANSVmConvertToFloatFromStr = .text:0x8144B4D4; // type:function size:0x14C
CHANSVmConvertToStrFromUndefined = .text:0x8144B620; // type:function size:0xC
CHANSVm_8144B62C = .text:0x8144B62C; // type:function size:0x58 scope:local
CHANSVmFloatToWString = .text:0x8144B62C; // type:function size:0x58 scope:local
CHANSVmConvertToStrFromInt = .text:0x8144B684; // type:function size:0xB0
CHANSVm_8144B734 = .text:0x8144B734; // type:function size:0xDC
CHANSVmConvertToStrFromFloat = .text:0x8144B734; // type:function size:0xDC
CHANSVmConvertToStrFromArray = .text:0x8144B810; // type:function size:0x10
CHANSVmConvertObjectTypeError = .text:0x8144B820; // type:function size:0x50
CHANSVmGetEnumedType = .text:0x8144B870; // type:function size:0x6C scope:local
@@ -6804,14 +6804,14 @@ VmStringSplice = .text:0x8144FDD8; // type:function size:0x1E4
VmStringSplit = .text:0x8144FFBC; // type:function size:0x378
VmStringToLowerCase = .text:0x81450334; // type:function size:0xB4
VmStringToUpperCase = .text:0x814503E8; // type:function size:0xB4
CHANSVm_8145049C = .text:0x8145049C; // type:function size:0x6BC
CHANSVmFormatString = .text:0x8145049C; // type:function size:0x6BC
VmStringFormat = .text:0x81450B58; // type:function size:0x4C
VmGetStrFromObjHdr = .text:0x81450BA4; // type:function size:0x24
VmGetIntFromObjHdr = .text:0x81450BC8; // type:function size:0x24
VmBlobInitValue = .text:0x81450BEC; // type:function size:0x20 scope:local
VmBlobCreateDirect = .text:0x81450C0C; // type:function size:0xAC scope:local
VmBlobGetDataBufferDirect = .text:0x81450CB8; // type:function size:0x5C scope:local
CHANSVm_81450D14 = .text:0x81450D14; // type:function size:0xB8
CHANSVmBlobResolveOffset = .text:0x81450D14; // type:function size:0xB8
VmBlobCtor = .text:0x81450DCC; // type:function size:0xA8 scope:local
VmBlobDtor = .text:0x81450E74; // type:function size:0x28 scope:local
VmBlobGetOffset = .text:0x81450E9C; // type:function size:0x68
@@ -6820,8 +6820,8 @@ VmBlobSkip = .text:0x81450FC8; // type:function size:0xF0
VmBlobGetLength = .text:0x814510B8; // type:function size:0x68
VmBlobSetLength = .text:0x81451120; // type:function size:0xF8
VmBlobFill = .text:0x81451218; // type:function size:0xFC
CHANSVm_81451314 = .text:0x81451314; // type:function size:0x34
CHANSVm_81451348 = .text:0x81451348; // type:function size:0x50
CHANSVmBlobGetCount = .text:0x81451314; // type:function size:0x34
CHANSVmBlobHasSpace = .text:0x81451348; // type:function size:0x50
VmBlobGetString = .text:0x81451398; // type:function size:0xC8
VmBlobSetString = .text:0x81451460; // type:function size:0x12C
VmBlobGetWString = .text:0x8145158C; // type:function size:0xE0
@@ -6857,7 +6857,7 @@ VmBlobSetS32 = .text:0x814532E4; // type:function size:0xD8
VmBlobSetS64 = .text:0x814533BC; // type:function size:0xE4
vmBlobParsePackFormatString = .text:0x814534A0; // type:function size:0x1D0
VmBlobPackCommon = .text:0x81453670; // type:function size:0xA70 scope:local
CHANSVm_814540E0 = .text:0x814540E0; // type:function size:0x6C
CHANSVmMakeU64 = .text:0x814540E0; // type:function size:0x6C
VmBlobCreate = .text:0x8145414C; // type:function size:0x8
VmBlobPack = .text:0x81454154; // type:function size:0x8
VmBlobUnpack = .text:0x8145415C; // type:function size:0x814
@@ -6875,7 +6875,7 @@ CHANSVmGetFreeExeSize = .text:0x81455198; // type:function size:0x28
CHANSVmAddExe = .text:0x814551C0; // type:function size:0x3F8
VmOffsU32ToPtr = .text:0x814555B8; // type:function size:0x18 scope:local
CHANSConvertModuleOfsToPtr = .text:0x814555D0; // type:function size:0x84
CHANSVm_81455654 = .text:0x81455654; // type:function size:0x8C
CHANSVmLookupScopedObject = .text:0x81455654; // type:function size:0x8C
VmPushFuncReturnInfo = .text:0x814556E0; // type:function size:0x1AC scope:local
VmReturnWithValue = .text:0x8145588C; // type:function size:0x1D4 scope:local
CHANSVmLinkModules = .text:0x81455A60; // type:function size:0x2F4
@@ -7284,7 +7284,7 @@ Zi8_814834AC = .text:0x814834AC; // type:function size:0x55C
Zi8GetKOcandidates = .text:0x81483A08; // type:function size:0xA74
Zi8LogError = .text:0x8148447C; // type:function size:0x4
Zi8ReplaceLastError = .text:0x81484480; // type:function size:0x4
Zi8_81484484 = .text:0x81484484; // type:function size:0x80
Zi8MapKeyCode = .text:0x81484484; // type:function size:0x80
ziNumKeysWithChars = .text:0x81484504; // type:function size:0xC4 scope:local
Zi8getKeyLayout = .text:0x814845C8; // type:function size:0x2D8
Zi8ChangeCharCase = .text:0x814848A0; // type:function size:0x48C
@@ -14198,7 +14198,7 @@ ca_ppki = .rodata:0x8162DBB8; // type:object size:0x400 noreloc
ms_dpki = .rodata:0x8162DFB8; // type:object size:0x240 noreloc
ms_ppki = .rodata:0x8162E1F8; // type:object size:0x240 noreloc
@1272 = .rodata:0x8162E438; // type:object size:0x278 scope:local data:4byte
pf_valid_fn_char = .rodata:0x8162E6B0; // type:object size:0x60 scope:local noreloc
pf_valid_fn_char = .rodata:0x8162E6B0; // type:object size:0x60 noreloc
fat_special_values = .rodata:0x8162E710; // type:object size:0x3C
cp932_to_unicode = .rodata:0x8162E750; // type:object size:0x4272 data:2byte
fa_nand_func = .rodata:0x816329C8; // type:object size:0x20
@@ -15942,7 +15942,7 @@ lbl_8164DD80 = .data:0x8164DD80; // type:object size:0x37
lbl_8164DDB7 = .data:0x8164DDB7; // type:object size:0xAD
scPaneName_N_GCIcon = .data:0x8164DE64; // type:object size:0x9 data:string
scPaneName_N_DiscUpdateIcon = .data:0x8164DE6D; // type:object size:0x11 data:string
jumptable_8164DE80 = .data:0x8164DE80; // type:object size:0x1C scope:local
updateDiskState_jumptable = .data:0x8164DE80; // type:object size:0x1C scope:local
scSE_WSD_SELECT = .data:0x8164DE9C; // type:object size:0xB data:string
lbl_8164DEA7 = .data:0x8164DEA7; // type:object size:0x10 data:string
lbl_8164DEB7 = .data:0x8164DEB7; // type:object size:0x114
@@ -20244,10 +20244,10 @@ lbl_81694654 = .sdata2:0x81694654; // type:object size:0x4 align:4 data:float
@10044 = .sdata2:0x8169469C; // type:object size:0x4 scope:local align:4 data:float
lbl_816946A0 = .sdata2:0x816946A0; // type:object size:0x4 align:4 data:float
scSoundZeroF = .sdata2:0x816946A4; // type:object size:0x4 align:4 data:float
lbl_816946A8 = .sdata2:0x816946A8; // type:object size:0x4 align:4 data:float
lbl_816946AC = .sdata2:0x816946AC; // type:object size:0x4 align:4 data:float
lbl_816946B0 = .sdata2:0x816946B0; // type:object size:0x4 align:4 data:float
lbl_816946B4 = .sdata2:0x816946B4; // type:object size:0x4 align:4 data:float
scSoundTwoF = .sdata2:0x816946A8; // type:object size:0x4 align:4 data:float
scSoundOneF = .sdata2:0x816946AC; // type:object size:0x4 align:4 data:float
scSoundThirtyF = .sdata2:0x816946B0; // type:object size:0x4 align:4 data:float
scSoundSixtyF = .sdata2:0x816946B4; // type:object size:0x4 align:4 data:float
lbl_816946B8 = .sdata2:0x816946B8; // type:object size:0x8 align:8 data:double
lbl_816946C0 = .sdata2:0x816946C0; // type:object size:0x8 align:8 data:double
lbl_816946C8 = .sdata2:0x816946C8; // type:object size:0x8 align:8 data:double
@@ -20617,31 +20617,31 @@ lbl_81694D18 = .sdata2:0x81694D18; // type:object size:0x4 data:4byte
lbl_81694D1C = .sdata2:0x81694D1C; // type:object size:0x4 data:4byte
lbl_81694D20 = .sdata2:0x81694D20; // type:object size:0x1 data:byte
lbl_81694D24 = .sdata2:0x81694D24; // type:object size:0x1 data:byte
lbl_81694D28 = .sdata2:0x81694D28; // type:object size:0x4 align:4 data:float
lbl_81694D2C = .sdata2:0x81694D2C; // type:object size:0x4 align:4 data:float
lbl_81694D30 = .sdata2:0x81694D30; // type:object size:0x8 align:8 data:double
lbl_81694D38 = .sdata2:0x81694D38; // type:object size:0x4 align:4 data:float
lbl_81694D3C = .sdata2:0x81694D3C; // type:object size:0x4 align:4 data:float
lbl_81694D40 = .sdata2:0x81694D40; // type:object size:0x4 align:4 data:float
lbl_81694D44 = .sdata2:0x81694D44; // type:object size:0x4 align:4 data:float
lbl_81694D48 = .sdata2:0x81694D48; // type:object size:0x4 align:4 data:float
lbl_81694D4C = .sdata2:0x81694D4C; // type:object size:0x4 align:4 data:float
lbl_81694D50 = .sdata2:0x81694D50; // type:object size:0x4 align:4 data:float
lbl_81694D54 = .sdata2:0x81694D54; // type:object size:0x4 align:4 data:float
lbl_81694D58 = .sdata2:0x81694D58; // type:object size:0x4 align:4 data:float
lbl_81694D5C = .sdata2:0x81694D5C; // type:object size:0x4 align:4 data:float
lbl_81694D60 = .sdata2:0x81694D60; // type:object size:0x4 align:4 data:float
lbl_81694D64 = .sdata2:0x81694D64; // type:object size:0x4 align:4 data:float
lbl_81694D68 = .sdata2:0x81694D68; // type:object size:0x4 align:4 data:float
lbl_81694D6C = .sdata2:0x81694D6C; // type:object size:0x1 data:byte
lbl_81694D6D = .sdata2:0x81694D6D; // type:object size:0x1 data:byte
lbl_81694D6E = .sdata2:0x81694D6E; // type:object size:0x1 data:byte
lbl_81694D6F = .sdata2:0x81694D6F; // type:object size:0x1 data:byte
lbl_81694D70 = .sdata2:0x81694D70; // type:object size:0x4 align:4 data:float
lbl_81694D74 = .sdata2:0x81694D74; // type:object size:0x4 align:4 data:float
lbl_81694D78 = .sdata2:0x81694D78; // type:object size:0x4 align:4 data:float
lbl_81694D80 = .sdata2:0x81694D80; // type:object size:0x8 align:8 data:double
lbl_81694D88 = .sdata2:0x81694D88; // type:object size:0x4 align:4 data:float
scInputFormZeroF = .sdata2:0x81694D28; // type:object size:0x4 align:4 data:float
scInputForm640F = .sdata2:0x81694D2C; // type:object size:0x4 align:4 data:float
scInputFormF32ConvertMagic = .sdata2:0x81694D30; // type:object size:0x8 align:8 data:double
scInputFormOneF = .sdata2:0x81694D38; // type:object size:0x4 align:4 data:float
scInputFormHalfF = .sdata2:0x81694D3C; // type:object size:0x4 align:4 data:float
scInputFormDegToFIdxF = .sdata2:0x81694D40; // type:object size:0x4 align:4 data:float
scInputForm150F = .sdata2:0x81694D44; // type:object size:0x4 align:4 data:float
scInputForm30F = .sdata2:0x81694D48; // type:object size:0x4 align:4 data:float
scInputForm50F = .sdata2:0x81694D4C; // type:object size:0x4 align:4 data:float
scInputForm10F = .sdata2:0x81694D50; // type:object size:0x4 align:4 data:float
scInputForm52F = .sdata2:0x81694D54; // type:object size:0x4 align:4 data:float
scInputFormTwoF = .sdata2:0x81694D58; // type:object size:0x4 align:4 data:float
scInputForm140F = .sdata2:0x81694D5C; // type:object size:0x4 align:4 data:float
scInputForm90F = .sdata2:0x81694D60; // type:object size:0x4 align:4 data:float
scInputForm253F = .sdata2:0x81694D64; // type:object size:0x4 align:4 data:float
scInputForm20F = .sdata2:0x81694D68; // type:object size:0x4 align:4 data:float
scInputFormColorRU8 = .sdata2:0x81694D6C; // type:object size:0x1 data:byte
scInputFormColorGU8 = .sdata2:0x81694D6D; // type:object size:0x1 data:byte
scInputFormColorBU8 = .sdata2:0x81694D6E; // type:object size:0x1 data:byte
scInputFormColorAU8 = .sdata2:0x81694D6F; // type:object size:0x1 data:byte
scInputForm255F = .sdata2:0x81694D70; // type:object size:0x4 align:4 data:float
scInputForm127F = .sdata2:0x81694D74; // type:object size:0x4 align:4 data:float
scInputForm14592F = .sdata2:0x81694D78; // type:object size:0x4 align:4 data:float
scInputFormF64ConvertMagic = .sdata2:0x81694D80; // type:object size:0x8 align:8 data:double
scInputForm15F = .sdata2:0x81694D88; // type:object size:0x4 align:4 data:float
lbl_81694D90 = .sdata2:0x81694D90; // type:object size:0x4 align:4 data:float
lbl_81694D94 = .sdata2:0x81694D94; // type:object size:0x4 align:4 data:float
lbl_81694D98 = .sdata2:0x81694D98; // type:object size:0x4 align:4 data:float
@@ -21694,7 +21694,7 @@ Tick = .sdata:0x81696520; // type:object size:0x4 scope:local data:4byte
@2844 = .sdata:0x81696562; // type:object size:0x5 scope:local data:string
@2845 = .sdata:0x81696567; // type:object size:0x8 scope:local data:string
@3032 = .sdata:0x8169656F; // type:object size:0x8 scope:local data:string
lbl_81696578 = .sdata:0x81696578; // type:object size:0x4 data:4byte
TicketViews = .sdata:0x81696578; // type:object size:0x4 data:4byte
lbl_8169657C = .sdata:0x8169657C; // type:object size:0x8 data:string
lbl_81696584 = .sdata:0x81696584; // type:object size:0x7
lbl_8169658B = .sdata:0x8169658B; // type:object size:0x5 data:string
@@ -23349,60 +23349,60 @@ BS2BootType = .sbss:0x816989FC; // type:object size:0x4 scope:global data:4byte
BS2VideoMode = .sbss:0x81698A00; // type:object size:0x4 data:4byte
InvalidSram = .sbss:0x81698A04; // type:object size:0x4 data:4byte
State = .sbss:0x81698A08; // type:object size:0x4 scope:local data:4byte
lbl_81698A0C = .sbss:0x81698A0C; // type:object size:0x4 scope:local data:4byte
lbl_81698A10 = .sbss:0x81698A10; // type:object size:0x4 scope:local data:4byte
lbl_81698A14 = .sbss:0x81698A14; // type:object size:0x4 scope:local data:4byte
lbl_81698A18 = .sbss:0x81698A18; // type:object size:0x4 scope:local data:4byte
lbl_81698A1C = .sbss:0x81698A1C; // type:object size:0x4 scope:local data:4byte
DvdReadPending = .sbss:0x81698A0C; // type:object size:0x4 scope:local data:4byte
BannerAllocation = .sbss:0x81698A10; // type:object size:0x4 scope:local data:4byte
BannerBuffer = .sbss:0x81698A14; // type:object size:0x4 scope:local data:4byte
BannerAvailable = .sbss:0x81698A18; // type:object size:0x4 scope:local data:4byte
Allocator = .sbss:0x81698A1C; // type:object size:0x4 scope:local data:4byte
StartingGame = .sbss:0x81698A20; // type:object size:0x4 data:4byte
lbl_81698A24 = .sbss:0x81698A24; // type:object size:0x4 scope:local data:4byte
lbl_81698A28 = .sbss:0x81698A28; // type:object size:0x4 scope:local data:4byte
lbl_81698A2C = .sbss:0x81698A2C; // type:object size:0x4 scope:local data:4byte
lbl_81698A30 = .sbss:0x81698A30; // type:object size:0x4 scope:local data:4byte
RestartRequested = .sbss:0x81698A24; // type:object size:0x4 scope:local data:4byte
PartitionOpen = .sbss:0x81698A28; // type:object size:0x4 scope:local data:4byte
CacheSeekComplete = .sbss:0x81698A2C; // type:object size:0x4 scope:local data:4byte
LoadingTitle = .sbss:0x81698A30; // type:object size:0x4 scope:local data:4byte
FatalErrorFlag = .sbss:0x81698A34; // type:object size:0x4 data:4byte
RetryErrorFlag = .sbss:0x81698A38; // type:object size:0x4 data:4byte
UpdateErrorFlag = .sbss:0x81698A3C; // type:object size:0x4 data:4byte
AbortFlag = .sbss:0x81698A40; // type:object size:0x4 data:4byte
lbl_81698A44 = .sbss:0x81698A44; // type:object size:0x4 data:4byte
lbl_81698A48 = .sbss:0x81698A48; // type:object size:0x4 data:4byte
lbl_81698A4C = .sbss:0x81698A4C; // type:object size:0x4 scope:local data:4byte
lbl_81698A50 = .sbss:0x81698A50; // type:object size:0x4 scope:local data:4byte
lbl_81698A54 = .sbss:0x81698A54; // type:object size:0x4 scope:local data:4byte
lbl_81698A58 = .sbss:0x81698A58; // type:object size:0x4 scope:local data:4byte
lbl_81698A5C = .sbss:0x81698A5C; // type:object size:0x4 scope:local data:4byte
lbl_81698A60 = .sbss:0x81698A60; // type:object size:0x8 scope:local data:4byte
lbl_81698A68 = .sbss:0x81698A68; // type:object size:0x8 scope:local data:4byte
lbl_81698A70 = .sbss:0x81698A70; // type:object size:0x8 data:4byte
lbl_81698A78 = .sbss:0x81698A78; // type:object size:0x4 data:4byte
lbl_81698A7C = .sbss:0x81698A7C; // type:object size:0x4 scope:local data:4byte
lbl_81698A80 = .sbss:0x81698A80; // type:object size:0x4 scope:local data:4byte
lbl_81698A84 = .sbss:0x81698A84; // type:object size:0x4 data:4byte
lbl_81698A88 = .sbss:0x81698A88; // type:object size:0x4 data:4byte
lbl_81698A8C = .sbss:0x81698A8C; // type:object size:0x4 data:4byte
lbl_81698A90 = .sbss:0x81698A90; // type:object size:0x4 data:4byte
lbl_81698A94 = .sbss:0x81698A94; // type:object size:0x4 data:4byte
lbl_81698A98 = .sbss:0x81698A98; // type:object size:0x4 data:4byte
lbl_81698A9C = .sbss:0x81698A9C; // type:object size:0x4 data:4byte
lbl_81698AA0 = .sbss:0x81698AA0; // type:object size:0x8 data:4byte
lbl_81698AA8 = .sbss:0x81698AA8; // type:object size:0x4 data:4byte
lbl_81698AAC = .sbss:0x81698AAC; // type:object size:0x4 data:4byte
lbl_81698AB0 = .sbss:0x81698AB0; // type:object size:0x4 data:4byte
lbl_81698AB4 = .sbss:0x81698AB4; // type:object size:0x4 data:4byte
lbl_81698AB8 = .sbss:0x81698AB8; // type:object size:0x4 data:4byte
lbl_81698ABC = .sbss:0x81698ABC; // type:object size:0x4 data:4byte
lbl_81698AC0 = .sbss:0x81698AC0; // type:object size:0x4 data:4byte
lbl_81698AC4 = .sbss:0x81698AC4; // type:object size:0x4 data:4byte
lbl_81698AC8 = .sbss:0x81698AC8; // type:object size:0x4 data:4byte
lbl_81698ACC = .sbss:0x81698ACC; // type:object size:0x4 data:4byte
lbl_81698AD0 = .sbss:0x81698AD0; // type:object size:0x4 data:4byte
lbl_81698AD4 = .sbss:0x81698AD4; // type:object size:0x4 data:4byte
lbl_81698AD8 = .sbss:0x81698AD8; // type:object size:0x4 scope:local data:4byte
lbl_81698ADC = .sbss:0x81698ADC; // type:object size:0x4 scope:local data:4byte
lbl_81698AE0 = .sbss:0x81698AE0; // type:object size:0x4 scope:local data:4byte
lbl_81698AE4 = .sbss:0x81698AE4; // type:object size:0x4 scope:local data:4byte
lbl_81698AE8 = .sbss:0x81698AE8; // type:object size:0x4 scope:local data:4byte
lbl_81698AEC = .sbss:0x81698AEC; // type:object size:0x4 scope:local data:4byte
lbl_81698AF0 = .sbss:0x81698AF0; // type:object size:0x4 scope:local data:4byte
CacheFailed = .sbss:0x81698A44; // type:object size:0x4 data:4byte
RegionValid = .sbss:0x81698A48; // type:object size:0x4 data:4byte
NandPending = .sbss:0x81698A4C; // type:object size:0x4 scope:local data:4byte
CancelNand = .sbss:0x81698A50; // type:object size:0x4 scope:local data:4byte
LowReadResult = .sbss:0x81698A54; // type:object size:0x4 scope:local data:4byte
CacheCommandComplete = .sbss:0x81698A58; // type:object size:0x4 scope:local data:4byte
AudioBufferUnconfigured = .sbss:0x81698A5C; // type:object size:0x4 scope:local data:4byte
ResetTime = .sbss:0x81698A60; // type:object size:0x8 scope:local data:4byte
SpinupDeadline = .sbss:0x81698A68; // type:object size:0x8 scope:local data:4byte
CoverPollTime = .sbss:0x81698A70; // type:object size:0x8 data:4byte
DriveWasReset = .sbss:0x81698A78; // type:object size:0x4 data:4byte
TitleTicketView = .sbss:0x81698A7C; // type:object size:0x4 scope:local data:4byte
CurrentTmd = .sbss:0x81698A80; // type:object size:0x4 scope:local data:4byte
TitleCode = .sbss:0x81698A84; // type:object size:0x4 data:4byte
RequiredIosHigh = .sbss:0x81698A88; // type:object size:0x4 data:4byte
RequiredIosLow = .sbss:0x81698A8C; // type:object size:0x4 data:4byte
GamePartition = .sbss:0x81698A90; // type:object size:0x4 data:4byte
UpdatePartition = .sbss:0x81698A94; // type:object size:0x4 data:4byte
PartitionCursor = .sbss:0x81698A98; // type:object size:0x4 data:4byte
DataToc = .sbss:0x81698A9C; // type:object size:0x4 data:4byte
GameToc = .sbss:0x81698AA0; // type:object size:0x8 data:4byte
CoverOpenTimeHigh = .sbss:0x81698AA8; // type:object size:0x4 data:4byte
CoverOpenTimeLow = .sbss:0x81698AAC; // type:object size:0x4 data:4byte
NandTransferred = .sbss:0x81698AB0; // type:object size:0x4 data:4byte
NandLength = .sbss:0x81698AB4; // type:object size:0x4 data:4byte
NandBuffer = .sbss:0x81698AB8; // type:object size:0x4 data:4byte
NandFile = .sbss:0x81698ABC; // type:object size:0x4 data:4byte
NandOperation = .sbss:0x81698AC0; // type:object size:0x4 data:4byte
NandCompletion = .sbss:0x81698AC4; // type:object size:0x4 data:4byte
LoaderOffset = .sbss:0x81698AC8; // type:object size:0x4 data:4byte
LoaderLength = .sbss:0x81698ACC; // type:object size:0x4 data:4byte
LoaderAddress = .sbss:0x81698AD0; // type:object size:0x4 data:4byte
CacheLength = .sbss:0x81698AD4; // type:object size:0x4 data:4byte
BannerLength = .sbss:0x81698AD8; // type:object size:0x4 scope:local data:4byte
DvdTransferLength = .sbss:0x81698ADC; // type:object size:0x4 scope:local data:4byte
DvdTransferred = .sbss:0x81698AE0; // type:object size:0x4 scope:local data:4byte
DvdProgress = .sbss:0x81698AE4; // type:object size:0x4 scope:local data:4byte
LoaderClose = .sbss:0x81698AE8; // type:object size:0x4 scope:local data:4byte
LoaderMain = .sbss:0x81698AEC; // type:object size:0x4 scope:local data:4byte
LoaderInit = .sbss:0x81698AF0; // type:object size:0x4 scope:local data:4byte
pEntries = .sbss:0x81698AF8; // type:object size:0x4 scope:local data:4byte
EntriesCount = .sbss:0x81698AFC; // type:object size:0x4 scope:local data:4byte
pFlags = .sbss:0x81698B00; // type:object size:0x4 scope:local data:4byte
@@ -23750,7 +23750,7 @@ flushFlag3in1 = .sbss:0x816991CC; // type:object size:0x4 scope:local data:4byte
flushFlag = .sbss:0x816991D0; // type:object size:0x4 scope:local data:4byte
retraceCount = .sbss:0x816991D4; // type:object size:0x4 scope:local data:4byte
__i2c_ident_first = .sbss:0x816991D8; // type:object size:0x4 scope:local data:4byte
Vdac_Flag_Changed = .sbss:0x816991E0; // type:object size:0x4 scope:local data:4byte
Vdac_Flag_Changed = .sbss:0x816991E0; // type:object size:0x4 data:4byte
__level = .sbss:0x816991E4; // type:object size:0x4 scope:local data:4byte
__gamma = .sbss:0x816991E8; // type:object size:0x4 scope:local data:4byte
__type = .sbss:0x816991EC; // type:object size:0x4 scope:local data:4byte
@@ -24048,7 +24048,7 @@ g_detach_func = .sbss:0x8169970C; // type:object size:0x4 scope:local data:4byte
st_uhs_msc_status = .sbss:0x81699710; // type:object size:0x4 scope:local data:4byte
st_uhs_msc_msgid = .sbss:0x81699714; // type:object size:0x4 scope:local data:4byte
st_uhs_msc_tskid = .sbss:0x81699718; // type:object size:0x4 scope:local data:4byte
uhg_msc_memid = .sbss:0x8169971C; // type:object size:0x4 scope:local data:4byte
uhg_msc_memid = .sbss:0x8169971C; // type:object size:0x4 data:4byte
st_uhs_msc_blk_buf = .sbss:0x81699720; // type:object size:0x4 scope:local data:4byte
__sdCardStatus = .sbss:0x81699728; // type:object size:0x4 scope:local data:4byte
__sdReq = .sbss:0x8169972C; // type:object size:0x4 scope:local data:4byte

View File

@@ -1063,7 +1063,7 @@ config.libs = [
Object(NonMatching, "nhttp/NHTTP_socket_RVL.c"),
Object(NonMatching, "nhttp/NHTTP_stdlib_RVL.c"),
Object(NonMatching, "nhttp/NHTTP_thread.c"),
Object(NonMatching, "nhttp/d_nhttp_private.c"),
Object(Matching, "nhttp/d_nhttp_private.c"),
Object(Matching, "nhttp/d_nhttp.c"),
Object(Matching, "nhttp/d_nhttp_common.c"),
]

View File

@@ -162,14 +162,14 @@ namespace ipl {
class {
public:
void init() {
unk_0x0C = -1;
mAngleIdx = -1;
pos.x = 0.0f;
pos.y = 0.0f;
}
math::VEC2 pos; // pos
int unk_0x08;
int unk_0x0C;
int mStep;
int mAngleIdx;
} mStandData; // 0xE4
picture mPicture; // 0xF4

View File

@@ -81,22 +81,22 @@ namespace ipl {
void* mpThumbnailData;
NandSDWorker::SDAppMetaEntry mAppMeta;
};
extern "C" void iplSDChannelObj_813E3104(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E311C(SDChannelObj* channel, EGG::ExpHeap* firstHeap,
extern "C" void iplSDChannelObj_activateIfIdle(SDChannelObj* channel);
extern "C" void iplSDChannelObj_setHeaps(SDChannelObj* channel, EGG::ExpHeap* firstHeap,
EGG::ExpHeap* secondHeap);
extern "C" void iplSDChannelObj_813E322C(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E32C8(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E34E0(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E3178(SDChannelObj* channel, nw4r::lyt::Pane* pane);
extern "C" void iplSDChannelObj_813E3180(SDChannelObj* channel, nand::LayoutFile* layoutFile);
extern "C" void iplSDChannelObj_813E3304(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E330C(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E3354(SDChannelObj* channel, int state);
extern "C" void iplSDChannelObj_813E33EC(SDChannelObj* channel, int state);
extern "C" void iplSDChannelObj_813E3480(SDChannelObj* channel, bool selected);
extern "C" void iplSDChannelObj_813E34E8(SDChannelObj* channel, int enabled);
extern "C" void* iplSDChannelObj_813E3128(SDChannelObj* channel);
extern "C" bool iplSDChannelObj_813E3330(SDChannelObj* channel);
extern "C" void iplSDChannelObj_calc(SDChannelObj* channel);
extern "C" void iplSDChannelObj_drawBase(SDChannelObj* channel);
extern "C" void iplSDChannelObj_playPageHide(SDChannelObj* channel);
extern "C" void iplSDChannelObj_setPane(SDChannelObj* channel, nw4r::lyt::Pane* pane);
extern "C" void iplSDChannelObj_setLayoutFile(SDChannelObj* channel, nand::LayoutFile* layoutFile);
extern "C" void iplSDChannelObj_drawPage(SDChannelObj* channel);
extern "C" void iplSDChannelObj_drawDialog(SDChannelObj* channel);
extern "C" void iplSDChannelObj_startAppear(SDChannelObj* channel, int state);
extern "C" void iplSDChannelObj_startDisappear(SDChannelObj* channel, int state);
extern "C" void iplSDChannelObj_setSelected(SDChannelObj* channel, bool selected);
extern "C" void iplSDChannelObj_resetPageAnim(SDChannelObj* channel, int enabled);
extern "C" void* iplSDChannelObj_getOrAllocThumbnailData(SDChannelObj* channel);
extern "C" bool iplSDChannelObj_hasAppMeta(SDChannelObj* channel);
union SDChannelSelectCommandArguments {
u32 values[3];

View File

@@ -14,8 +14,8 @@ namespace ipl {
WAIT_UNTIL_FADE_IN = 15
};
TextBalloon(EGG::Heap* heap, nand::LayoutFile* layoutFile, const char* directory, const char* fileName, const ipl::math::VEC3& unk2,
f32 unk3 = 120.0f, f32 unk4 = 30.0f);
TextBalloon(EGG::Heap* heap, nand::LayoutFile* layoutFile, const char* directory, const char* fileName, const ipl::math::VEC3& initialPos,
f32 margin16x9 = 120.0f, f32 margin4x3 = 30.0f);
~TextBalloon();
void calc();
@@ -31,7 +31,7 @@ namespace ipl {
void fadeout();
void fadeoutForce();
void setPos(const math::VEC3& pos, bool unk0, int unk1);
void setPos(const math::VEC3& pos, bool use16x9X, int hAlign);
void updatePos(const math::VEC3& pos);
void set_translate(const math::VEC3& trans);
@@ -50,7 +50,7 @@ namespace ipl {
undefined4 unk_0x00;
undefined4 unk_0x04;
BOOL unk_0x08;
BOOL mbWaitingFadeIn; // 0x08
layout::Object* mpLayout; // 0x0C
@@ -60,10 +60,10 @@ namespace ipl {
u32 mTextLen; // 0x18
math::VEC3 mBalloonPos; // 0x1C
undefined4 unk_0x28;
undefined unk_0x2C;
f32 unk_0x30;
f32 unk_0x34;
undefined4 mHAlign; // 0x28
undefined mbUse16x9X; // 0x2C
f32 mMargin16x9; // 0x30
f32 mMargin4x3; // 0x34
int mWaitUntilFadeIn; // 0x38

View File

@@ -8,7 +8,7 @@ ziU16 Zi8GetTableCount(ziU8 language, ziU8 tableIndex, ziPtr __zi8_work_data);
ziU32 Zi8GetTableAddress(ziU8 language, ziU8 tableIndex, ziPtr __zi8_work_data);
ziU8 Zi8getKeyLayout(ziU8 language, ziWChar key, ziWChar* chars, ziU8 mode, ziPtr __zi8_work_data);
ziBool Zi8_81484484(ziWChar character, ziWChar* output, ziPtr __zi8_work_data) {
ziBool Zi8MapKeyCode(ziWChar character, ziWChar* output, ziPtr __zi8_work_data) {
if (character == 0xeffa) {
*output = 0;
} else if ((character >= 0xeff1) && (character <= 0xeff9)) {
@@ -58,7 +58,7 @@ ziBool Zi8getKeyLayout(ziU8 language, ziWChar key, ziWChar* chars, ziU8 mode, zi
*chars = 0;
if (ZI_WORK->userKeys[language] != 0) {
customTable = ZI_WORK->userKeys[language];
if (!Zi8_81484484(key, &key, __zi8_work_data)) {
if (!Zi8MapKeyCode(key, &key, __zi8_work_data)) {
return 0;
}
keyChars = customTable->lower[key];
@@ -87,7 +87,7 @@ tables_ready:
Zi8ReplaceLastError(0x962, __zi8_work_data);
return 0;
}
if (!Zi8_81484484(key, &key, __zi8_work_data) || (key >= numKeys)) {
if (!Zi8MapKeyCode(key, &key, __zi8_work_data) || (key >= numKeys)) {
Zi8ReplaceLastError(300, __zi8_work_data);
return 0;
}

View File

@@ -42,7 +42,7 @@ typedef struct UHF_MSC_MESSAGE {
} UHF_MSC_MESSAGE;
extern UHF_MSC_DEVICE uhg_msc_blk_device_tbl[8];
extern s32 uhg_msc_memid_8169971C;
extern s32 uhg_msc_memid;
s32 uhf_ker_set_priority(s32 task_id, s32 priority);
void* uhf_ker_get_memory_block(s32 pool, u32 size, u32 alignment);
s32 uhf_ker_release_memory_block(s32 pool, void* block);

View File

@@ -16,8 +16,8 @@ typedef s32 CXStreamingResult;
#define CX_STREAMING_ERR_BAD_FILE_TABLE -5
typedef struct CXUncompContextRL {
u8* unk_0x00; // 0x00
int unk_0x04; // 0x04
u8* outData; // 0x00
int outDataLen; // 0x04
u32 size; // 0x08
u16 unk_0x0C; // 0x0C
u8 unk_0x0e; // 0x0E
@@ -25,8 +25,8 @@ typedef struct CXUncompContextRL {
} CXUncompContextRL;
typedef struct CXUncompContextLZ {
u8* unk_0x00; // 0x00
int unk_0x04; // 0x04
u8* outData; // 0x00
int outDataLen; // 0x04
u32 size; // 0x08
int unk_0x0C; // 0x0C
u8 unk_0x10; // 0x10

View File

@@ -20,8 +20,8 @@ typedef void (*USBKBDEventCallback)(void*, char*);
typedef void (*USBKBDCmdLEDCallback)(BOOL success, void* cbarg);
typedef struct USBKBDCmdLED {
vu32 unk_0x00;
vu8 unk_0x04;
vu32 device; // 0x00
vu8 ledBits; // 0x04
} USBKBDCmdLED;
typedef struct USBKBDCmdLEDAsync {

View File

@@ -5,8 +5,8 @@ static inline int CXiReadHeader(u8*, int*, const u8*, int, int);
static inline CXHuffmanDecodeTableEntry* GetNextNode(CXHuffmanDecodeTableEntry*, int);
void CXInitUncompContextRL(CXUncompContextRL* context, u8* data) {
context->unk_0x00 = data;
context->unk_0x04 = 0;
context->outData = data;
context->outDataLen = 0;
context->unk_0x0e = 0;
context->unk_0x0C = 0;
context->unk_0x0f = 8;
@@ -14,8 +14,8 @@ void CXInitUncompContextRL(CXUncompContextRL* context, u8* data) {
}
void CXInitUncompContextLZ(CXUncompContextLZ* context, u8* data) {
context->unk_0x00 = data;
context->unk_0x04 = 0;
context->outData = data;
context->outDataLen = 0;
context->unk_0x11 = 0;
context->unk_0x12 = 0;
context->unk_0x0C = 0;
@@ -54,27 +54,27 @@ CXStreamingResult CXReadUncompRL(CXUncompContextRL* context, const void* src, u3
}
}
a = CXiReadHeader(&context->unk_0x0f, &context->unk_0x04, pSrc, size, context->size);
a = CXiReadHeader(&context->unk_0x0f, &context->outDataLen, pSrc, size, context->size);
pSrc += a;
size -= a;
if (!size) {
return !context->unk_0x0f ? context->unk_0x04 : CX_STREAMING_ERR_BAD_FILE_TYPE;
return !context->unk_0x0f ? context->outDataLen : CX_STREAMING_ERR_BAD_FILE_TYPE;
}
}
while (context->unk_0x04 > 0) {
while (context->outDataLen > 0) {
if (!(context->unk_0x0e & 0x80)) {
while (context->unk_0x0C) {
*context->unk_0x00++ = *pSrc++;
*context->outData++ = *pSrc++;
context->unk_0x0C--;
context->unk_0x04--;
context->outDataLen--;
size--;
if (!size) {
return context->unk_0x04;
return context->outDataLen;
}
}
} else if (context->unk_0x0C) {
@@ -82,14 +82,14 @@ CXStreamingResult CXReadUncompRL(CXUncompContextRL* context, const void* src, u3
size--;
while (context->unk_0x0C) {
*context->unk_0x00++ = b;
*context->outData++ = b;
context->unk_0x0C--;
context->unk_0x04--;
context->outDataLen--;
}
if (!size) {
return context->unk_0x04;
return context->outDataLen;
}
}
@@ -103,19 +103,19 @@ CXStreamingResult CXReadUncompRL(CXUncompContextRL* context, const void* src, u3
context->unk_0x0C += 1;
}
if (context->unk_0x0C > context->unk_0x04) {
if (context->unk_0x0C > context->outDataLen) {
if (!context->size) {
return CX_STREAMING_ERR_BAD_FILE_SIZE;
}
context->unk_0x0C = context->unk_0x04;
context->unk_0x0C = context->outDataLen;
}
if (size) {
continue;
}
return context->unk_0x04;
return context->outDataLen;
}
if (!context->size && size > 32) {
@@ -174,27 +174,27 @@ CXStreamingResult CXReadUncompLZ(CXUncompContextLZ* context, const void* src, u3
}
}
a = CXiReadHeader(&context->unk_0x13, &context->unk_0x04, pSrc, size, context->size);
a = CXiReadHeader(&context->unk_0x13, &context->outDataLen, pSrc, size, context->size);
pSrc += a;
size -= a;
if (!size) {
return !context->unk_0x13 ? context->unk_0x04 : CX_STREAMING_ERR_BAD_FILE_TYPE;
return !context->unk_0x13 ? context->outDataLen : CX_STREAMING_ERR_BAD_FILE_TYPE;
}
}
while (context->unk_0x04 > 0) {
while (context->outDataLen > 0) {
while (context->unk_0x12) {
s32 a;
if (!size) {
return context->unk_0x04;
return context->outDataLen;
}
if (!(context->unk_0x11 & 0x80)) {
*context->unk_0x00++ = *pSrc++;
context->unk_0x04--;
*context->outData++ = *pSrc++;
context->outDataLen--;
size--;
@@ -240,7 +240,7 @@ CXStreamingResult CXReadUncompLZ(CXUncompContextLZ* context, const void* src, u3
size--;
if (!size) {
return context->unk_0x04;
return context->outDataLen;
}
}
@@ -251,23 +251,23 @@ CXStreamingResult CXReadUncompLZ(CXUncompContextLZ* context, const void* src, u3
size--;
context->unk_0x10 = 3;
if (context->unk_0x0C > context->unk_0x04) {
if (context->unk_0x0C > context->outDataLen) {
if (!context->size) {
return CX_STREAMING_ERR_BAD_FILE_SIZE;
}
context->unk_0x0C = context->unk_0x04;
context->unk_0x0C = context->outDataLen;
}
while (context->unk_0x0C > 0) {
*context->unk_0x00 = context->unk_0x00[-a];
context->unk_0x00++;
context->unk_0x04--;
*context->outData = context->outData[-a];
context->outData++;
context->outDataLen--;
context->unk_0x0C--;
}
there:
if (!context->unk_0x04) {
if (!context->outDataLen) {
goto out;
}
@@ -276,7 +276,7 @@ CXStreamingResult CXReadUncompLZ(CXUncompContextLZ* context, const void* src, u3
}
if (!size) {
return context->unk_0x04;
return context->outDataLen;
}
context->unk_0x11 = *pSrc++;

View File

@@ -1,6 +1,6 @@
#include <private/fa/puh_msc.h>
s32 uhg_msc_memid_8169971C;
s32 uhg_msc_memid;
static s32 st_uhs_msc_tskid;
static s32 st_uhs_msc_msgid;
static s32 st_uhs_msc_status;
@@ -47,13 +47,13 @@ static s32 _uhf_msc_api_send_message(UHF_MSC_PARAMETERS* parameters, u32 command
s32 result = 0;
s32 semaphore;
UHF_MSC_MESSAGE* message;
message = uhf_ker_get_memory_block(uhg_msc_memid_8169971C, sizeof(UHF_MSC_MESSAGE), 4);
message = uhf_ker_get_memory_block(uhg_msc_memid, sizeof(UHF_MSC_MESSAGE), 4);
if (message == NULL) {
return -12;
}
semaphore = uhf_ker_create_sem(0, 0);
if (semaphore <= 0) {
uhf_ker_release_memory_block(uhg_msc_memid_8169971C, message);
uhf_ker_release_memory_block(uhg_msc_memid, message);
return -12;
}
message->command = command;
@@ -61,7 +61,7 @@ static s32 _uhf_msc_api_send_message(UHF_MSC_PARAMETERS* parameters, u32 command
message->result = &result;
message->parameters = *parameters;
if (uhf_ker_send_message(st_uhs_msc_msgid, message, 0) != 0) {
uhf_ker_release_memory_block(uhg_msc_memid_8169971C, message);
uhf_ker_release_memory_block(uhg_msc_memid, message);
uhf_ker_delete_sem(semaphore);
return -12;
}

View File

@@ -287,13 +287,13 @@ s32 _uhf_msc_blk_send_message(UHF_MSC_PARAMETERS* parameters, u32 command) {
s32 semaphore;
UHF_MSC_MESSAGE* message;
s32 mailbox = uhf_msc_get_message_id();
message = uhf_ker_get_memory_block(uhg_msc_memid_8169971C, sizeof(UHF_MSC_MESSAGE), 4);
message = uhf_ker_get_memory_block(uhg_msc_memid, sizeof(UHF_MSC_MESSAGE), 4);
if (message == NULL) {
return -1;
}
semaphore = uhf_ker_create_sem(0, 0);
if (semaphore <= 0) {
uhf_ker_release_memory_block(uhg_msc_memid_8169971C, message);
uhf_ker_release_memory_block(uhg_msc_memid, message);
return -1;
}
message->command = command;
@@ -301,7 +301,7 @@ s32 _uhf_msc_blk_send_message(UHF_MSC_PARAMETERS* parameters, u32 command) {
message->result = &result;
message->parameters = *parameters;
if (uhf_ker_send_message(mailbox, message, 0) != 0) {
uhf_ker_release_memory_block(uhg_msc_memid_8169971C, message);
uhf_ker_release_memory_block(uhg_msc_memid, message);
uhf_ker_delete_sem(semaphore);
return -1;
}

View File

@@ -1,7 +1,7 @@
#include <private/vf/PrFILE2/pf_types.h>
// clang-format off
const pf_u8 pf_valid_fn_char_8162E6B0[96] = {
const pf_u8 pf_valid_fn_char[96] = {
1, 3, 0, 3, 3, 3, 3, 3, 3, 3, 0, 1, 1, 3, 3, 0,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 1, 0, 1, 0, 0,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

View File

@@ -1282,11 +1282,13 @@ s32 PFFAT_GetSectorSpecified(PFFAT_FFD* file, u32 fileSectorIndex,
error = PFFAT_GetSector(file, fileSectorIndex, clusterIndex != 0, 0,
sector);
if (error != 0) {
goto done;
switch (error) {
case 0:
error = 0;
break;
default:
break;
}
error = 0;
done:
return error;
}

View File

@@ -56,7 +56,7 @@ typedef struct PF_PATH_VOLUME_SET {
} PF_PATH_VOLUME_SET;
extern PF_PATH_VOLUME_SET pf_vol_set;
extern const pf_u8 pf_valid_fn_char_8162E6B0[96];
extern const pf_u8 pf_valid_fn_char[96];
extern void PFSTR_SetCodeMode(PF_STR*, pf_u32);
extern pf_u32 PFSTR_GetCodeMode(PF_STR*);
extern pf_s8* PFSTR_GetStrPos(PF_STR*, pf_u32);
@@ -75,9 +75,9 @@ extern pf_u32 PFPATH_CheckExtShortNameSignature(PF_STR*);
extern pf_u32 PFPATH_CheckExtShortName(PF_STR*, pf_u32, pf_bool);
extern void PFCODE_Divide_Width(pf_s32, pf_s16*, pf_s16*);
#define VALID_PATH_CHAR(x, b) ((pf_u8)(x) >= 0x80 || ((pf_u8)(x) >= ' ' && (pf_valid_fn_char_8162E6B0[(pf_u8)(x) - ' '] & b)))
#define VALID_PATH_CHAR(x, b) ((pf_u8)(x) >= 0x80 || ((pf_u8)(x) >= ' ' && (pf_valid_fn_char[(pf_u8)(x) - ' '] & b)))
#define VALID_PATH_WCHAR(x, b) \
((x) >= 0x80 || (pf_u8)(x) >= ' ' && ((pf_u8)(x) & 0xFF00) == 0 && (pf_valid_fn_char_8162E6B0[(pf_u8)((x & 0x00FF) - ' ')] & b))
((x) >= 0x80 || (pf_u8)(x) >= ' ' && ((pf_u8)(x) & 0xFF00) == 0 && (pf_valid_fn_char[(pf_u8)((x & 0x00FF) - ' ')] & b))
pf_s32 PFPATH_DoSplitPath(PF_STR* p_path, PF_STR* p_dir_path, PF_STR* p_filename, pf_u32 wildcard) {
pf_s8* p;

View File

@@ -43,7 +43,7 @@ typedef struct __sdCbArg {
SDCallbackFunc cb; // 0x00
void* cbArg; // 0x04
SDDev* dev; // 0x08
u32 unk_0x0C;
u32 cmd; // 0x0C
u32 SDDevRca;
u32* resp; // 0x14
u8* SDSectorSize;
@@ -70,7 +70,7 @@ ISD_Error ISD_GetCardSize(SDDev* dev, u32* outSize, u32* outSize2, u32* outSecto
IOSError __sdCb(s32 result, void* arg) {
__sdCbArg* data = (__sdCbArg*)arg;
switch (data->unk_0x0C) {
switch (data->cmd) {
case 4: {
if (result != 0) {
OSReport(__sdPathData, result);
@@ -196,7 +196,7 @@ static IOSError sduCommandv(s32 fd, u32 cmd, u32 cmdType, u32 respType, u32 arg,
data->cb = cb;
data->cbArg = cbArg;
data->resp = resp;
data->unk_0x0C = cmd;
data->cmd = cmd;
data->SDSectorSize = (u8*)sdCmd;
ret = IOS_IoctlvAsync(fd, 7, readCount, writeCount, __sdVect, __sdCb, data);
@@ -243,7 +243,7 @@ static ISD_Error sduCommand(s32 fd, u32 cmd, u32 cmdType, u32 respType, u32 arg,
data->cb = cb;
data->cbArg = cbArg;
data->resp = resp;
data->unk_0x0C = cmd;
data->cmd = cmd;
data->SDDevRca = 1;
data->SDSectorSize = (u8*)sdCmd;

View File

@@ -101,8 +101,8 @@ USBKBDErr USBKBDSetLED(u32 device, u8 ledBits, USBKBDCmdLED* cmd) {
return USB_KBD_ERR_NOT_INIT;
}
cmd->unk_0x04 = ledBits;
cmd->unk_0x00 = device;
cmd->ledBits = ledBits;
cmd->device = device;
return IOS_Write(usbKbdFd, cmd, sizeof(USBKBDCmdLED)) != IPC_RESULT_OK ? USB_KBD_ERR_FATAL : USB_KBD_ERR_OK;
}
@@ -118,8 +118,8 @@ USBKBDErr USBKBDSetLEDAsync(u32 device, u8 ledBits, USBKBDCmdLEDAsync* cmd, USBK
if (usbKbdFd < 0) {
return USB_KBD_ERR_NOT_INIT;
}
cmd->base.unk_0x00 = device;
cmd->base.unk_0x04 = ledBits;
cmd->base.device = device;
cmd->base.ledBits = ledBits;
cmd->cb = cb;
cmd->cbArg = cbArg;

View File

@@ -12,7 +12,7 @@
extern void SIRefreshSamplingRate(void);
extern void VISetRGBModeImm(void);
extern void __VISetRevolutionModeSimple(void);
extern volatile u32 Vdac_Flag_Changed_816991E0;
extern volatile u32 Vdac_Flag_Changed;
extern void __VISetYUVSEL(u32 enable);
extern void __VISetFilter4EURGB60(u32 enable);
extern void __VISetCGMS(void);
@@ -324,8 +324,8 @@ position_interrupt:
}
old_tvtype = currentTvType;
if (flushFlag3in1 != 0) {
while (Vdac_Flag_Changed_816991E0 != 0) {
changeBit = 1U << (31 - __cntlzw(Vdac_Flag_Changed_816991E0));
while (Vdac_Flag_Changed != 0) {
changeBit = 1U << (31 - __cntlzw(Vdac_Flag_Changed));
switch (changeBit) {
case 1:
__VISetCGMS();
@@ -352,7 +352,7 @@ position_interrupt:
__VISetRGBModeImm();
break;
}
Vdac_Flag_Changed_816991E0 &= ~changeBit;
Vdac_Flag_Changed &= ~changeBit;
}
flushFlag3in1 = 0;
}

View File

@@ -138,7 +138,7 @@ static s32 Vdac_Flag_Region;
static s32 __type;
static s32 __gamma;
static s32 __level;
volatile u32 Vdac_Flag_Changed_816991E0;
volatile u32 Vdac_Flag_Changed;
static void __VISetCCSEL(u8 flag) {
u8 data[2];
@@ -339,7 +339,7 @@ void VISetCGMS(u8 wd0, u8 wd1, u8 wd2) {
__wd0 = wd0;
__wd1 = wd1;
__wd2 = wd2;
Vdac_Flag_Changed_816991E0 |= 1;
Vdac_Flag_Changed |= 1;
}
}
@@ -382,7 +382,7 @@ void VISetMacrovision(s32 type) {
if ((__type != type) || (__tvType != tvFormat)) {
__type = type;
__tvType = tvFormat;
Vdac_Flag_Changed_816991E0 |= 8;
Vdac_Flag_Changed |= 8;
}
}
@@ -448,7 +448,7 @@ void VISetTrapFilter(BOOL filter) {
return;
}
__filter = filter;
Vdac_Flag_Changed_816991E0 |= 0x20;
Vdac_Flag_Changed |= 0x20;
}
void __VISetRGBOverDrive(void) {
@@ -468,7 +468,7 @@ void __VISetRGBOverDrive(void) {
}
void VISetRGBModeImm(void) {
Vdac_Flag_Changed_816991E0 |= 0x80;
Vdac_Flag_Changed |= 0x80;
}
void __VISetRGBModeImm(void) {
@@ -520,34 +520,34 @@ void __VISetRevolutionMode(void) {
__wd0 = 0;
__wd1 = 0;
__wd2 = 0;
Vdac_Flag_Changed_816991E0 |= 1;
Vdac_Flag_Changed |= 1;
}
if ((__gp1 != 0) || (__gp2 != 0) || (__gp3 != 0) || (__gp4 != 0)) {
__gp1 = 0;
__gp2 = 0;
__gp3 = 0;
__gp4 = 0;
Vdac_Flag_Changed_816991E0 |= 2;
Vdac_Flag_Changed |= 2;
}
if ((__cc1 != 0) || (__cc2 != 0) || (__cc3 != 0) || (__cc4 != 0)) {
__cc1 = 0;
__cc2 = 0;
__cc3 = 0;
__cc4 = 0;
Vdac_Flag_Changed_816991E0 |= 4;
Vdac_Flag_Changed |= 4;
}
VISetMacrovision(1);
if (__filter != 0) {
__filter = 0;
Vdac_Flag_Changed_816991E0 |= 0x20;
Vdac_Flag_Changed |= 0x20;
}
if (__level != 0) {
__level = 0;
Vdac_Flag_Changed_816991E0 |= 0x40;
Vdac_Flag_Changed |= 0x40;
}
if (__gamma != 10) {
__gamma = 10;
Vdac_Flag_Changed_816991E0 |= 0x10;
Vdac_Flag_Changed |= 0x10;
}
VIFlush();
VIWaitForRetrace();
@@ -588,7 +588,7 @@ void VISetWSS(u8 gp1, u8 gp2, u8 gp3, u8 gp4) {
__gp2 = gp2;
__gp3 = gp3;
__gp4 = gp4;
Vdac_Flag_Changed_816991E0 |= 2;
Vdac_Flag_Changed |= 2;
}
}
@@ -598,14 +598,14 @@ void VISetClosedCaption(u8 cc1, u8 cc2, u8 cc3, u8 cc4) {
__cc2 = cc2;
__cc3 = cc3;
__cc4 = cc4;
Vdac_Flag_Changed_816991E0 |= 4;
Vdac_Flag_Changed |= 4;
}
}
void VISetRGBOverDrive(s32 level) {
if (__level != level) {
__level = level;
Vdac_Flag_Changed_816991E0 |= 0x40;
Vdac_Flag_Changed |= 0x40;
}
}

File diff suppressed because it is too large Load Diff

View File

@@ -13,22 +13,22 @@
const u8 scRsnOui0 = 0;
const u8 scRsnOui1 = 0x0F;
const u8 scRsnOui2 = 0xAC;
const u8 lbl_81695063 = 0;
const u8 scRsnOuiPad = 0;
const u8 scWpaOui0 = 0;
const u8 scWpaOui1 = 0x50;
const u8 scWpaOui2 = 0xF2;
const u8 lbl_81695067 = 0;
const u8 scWpaOuiPad = 0;
#pragma pop
#pragma push
#pragma section sconst_type ".sdata"
const u8 scWpaFindOui0 = 0;
const u8 scWpaFindOui1 = 0x50;
const u8 scWpaFindOui2 = 0xF2;
const u8 lbl_81697D73 = 0;
const u8 lbl_81697D74 = 0;
const u8 lbl_81697D75 = 0;
const u8 lbl_81697D76 = 0;
const u8 lbl_81697D77 = 0;
const u8 scWpaFindOuiPad0 = 0;
const u8 scWpaFindOuiPad1 = 0;
const u8 scWpaFindOuiPad2 = 0;
const u8 scWpaFindOuiPad3 = 0;
const u8 scWpaFindOuiPad4 = 0;
#pragma pop
#define scRsnOui0 (*((volatile const u8*)&scRsnOui0))

View File

@@ -313,18 +313,18 @@ asm void __div2u() {
cmpwi r3, 0x0
cntlzw r0, r3
cntlzw r9, r4
bne L_815F9538
bne __div2u_L_815F9538
addi r0, r9, 0x20
L_815F9538:
__div2u_L_815F9538:
cmpwi r5, 0x0
cntlzw r9, r5
cntlzw r10, r6
bne L_815F954C
bne __div2u_L_815F954C
addi r9, r10, 0x20
L_815F954C:
__div2u_L_815F954C:
cmpw r0, r9
subfic r10, r0, 0x40
bgt L_815F9604
bgt __div2u_L_815F9604
addi r9, r9, 0x1
subfic r9, r9, 0x40
add r0, r0, r9
@@ -332,49 +332,49 @@ L_815F954C:
mtctr r9
cmpwi r9, 0x20
subi r7, r9, 0x20
blt L_815F9584
blt __div2u_L_815F9584
srw r8, r3, r7
li r7, 0x0
b L_815F9598
L_815F9584:
b __div2u_L_815F9598
__div2u_L_815F9584:
srw r8, r4, r9
subfic r7, r9, 0x20
slw r7, r3, r7
or r8, r8, r7
srw r7, r3, r9
L_815F9598:
__div2u_L_815F9598:
cmpwi r0, 0x20
subic r9, r0, 0x20
blt L_815F95B0
blt __div2u_L_815F95B0
slw r3, r4, r9
li r4, 0x0
b L_815F95C4
L_815F95B0:
b __div2u_L_815F95C4
__div2u_L_815F95B0:
slw r3, r3, r0
subfic r9, r0, 0x20
srw r9, r4, r9
or r3, r3, r9
slw r4, r4, r0
L_815F95C4:
__div2u_L_815F95C4:
li r10, -0x1
addic r7, r7, 0x0
L_815F95CC:
__div2u_L_815F95CC:
adde r4, r4, r4
adde r3, r3, r3
adde r8, r8, r8
adde r7, r7, r7
subfc r0, r6, r8
subfe. r9, r5, r7
blt L_815F95F4
blt __div2u_L_815F95F4
mr r8, r0
mr r7, r9
addic r0, r10, 0x1
L_815F95F4:
bdnz L_815F95CC
__div2u_L_815F95F4:
bdnz __div2u_L_815F95CC
adde r4, r4, r4
adde r3, r3, r3
blr
L_815F9604:
__div2u_L_815F9604:
li r4, 0x0
li r3, 0x0
blr
@@ -385,32 +385,32 @@ asm void __div2i() {
#ifdef __MWERKS__
stwu r1, -0x10(r1)
clrrwi. r9, r3, 31
beq L_815F9624
beq __div2i_L_815F9624
subfic r4, r4, 0x0
subfze r3, r3
L_815F9624:
__div2i_L_815F9624:
stw r9, 0x8(r1)
clrrwi. r10, r5, 31
beq L_815F9638
beq __div2i_L_815F9638
subfic r6, r6, 0x0
subfze r5, r5
L_815F9638:
__div2i_L_815F9638:
stw r10, 0xc(r1)
cmpwi r3, 0x0
cntlzw r0, r3
cntlzw r9, r4
bne L_815F9650
bne __div2i_L_815F9650
addi r0, r9, 0x20
L_815F9650:
__div2i_L_815F9650:
cmpwi r5, 0x0
cntlzw r9, r5
cntlzw r10, r6
bne L_815F9664
bne __div2i_L_815F9664
addi r9, r10, 0x20
L_815F9664:
__div2i_L_815F9664:
cmpw r0, r9
subfic r10, r0, 0x40
bgt L_815F9738
bgt __div2i_L_815F9738
addi r9, r9, 0x1
subfic r9, r9, 0x40
add r0, r0, r9
@@ -418,60 +418,60 @@ L_815F9664:
mtctr r9
cmpwi r9, 0x20
subi r7, r9, 0x20
blt L_815F969C
blt __div2i_L_815F969C
srw r8, r3, r7
li r7, 0x0
b L_815F96B0
L_815F969C:
b __div2i_L_815F96B0
__div2i_L_815F969C:
srw r8, r4, r9
subfic r7, r9, 0x20
slw r7, r3, r7
or r8, r8, r7
srw r7, r3, r9
L_815F96B0:
__div2i_L_815F96B0:
cmpwi r0, 0x20
subic r9, r0, 0x20
blt L_815F96C8
blt __div2i_L_815F96C8
slw r3, r4, r9
li r4, 0x0
b L_815F96DC
L_815F96C8:
b __div2i_L_815F96DC
__div2i_L_815F96C8:
slw r3, r3, r0
subfic r9, r0, 0x20
srw r9, r4, r9
or r3, r3, r9
slw r4, r4, r0
L_815F96DC:
__div2i_L_815F96DC:
li r10, -0x1
addic r7, r7, 0x0
L_815F96E4:
__div2i_L_815F96E4:
adde r4, r4, r4
adde r3, r3, r3
adde r8, r8, r8
adde r7, r7, r7
subfc r0, r6, r8
subfe. r9, r5, r7
blt L_815F970C
blt __div2i_L_815F970C
mr r8, r0
mr r7, r9
addic r0, r10, 0x1
L_815F970C:
bdnz L_815F96E4
__div2i_L_815F970C:
bdnz __div2i_L_815F96E4
adde r4, r4, r4
adde r3, r3, r3
lwz r9, 0x8(r1)
lwz r10, 0xc(r1)
xor. r7, r9, r10
beq L_815F9734
beq __div2i_L_815F9734
cmpwi r9, 0x0
subfic r4, r4, 0x0
subfze r3, r3
L_815F9734:
b L_815F9740
L_815F9738:
__div2i_L_815F9734:
b __div2i_L_815F9740
__div2i_L_815F9738:
li r4, 0x0
li r3, 0x0
L_815F9740:
__div2i_L_815F9740:
addi r1, r1, 0x10
blr
#endif
@@ -482,18 +482,18 @@ asm void __mod2u() {
cmpwi r3, 0x0
cntlzw r0, r3
cntlzw r9, r4
bne L_815F975C
bne __mod2u_L_815F975C
addi r0, r9, 0x20
L_815F975C:
__mod2u_L_815F975C:
cmpwi r5, 0x0
cntlzw r9, r5
cntlzw r10, r6
bne L_815F9770
bne __mod2u_L_815F9770
addi r9, r10, 0x20
L_815F9770:
__mod2u_L_815F9770:
cmpw r0, r9
subfic r10, r0, 0x40
bgt L_815F9828
bgt __mod2u_L_815F9828
addi r9, r9, 0x1
subfic r9, r9, 0x40
add r0, r0, r9
@@ -501,49 +501,49 @@ L_815F9770:
mtctr r9
cmpwi r9, 0x20
subi r7, r9, 0x20
blt L_815F97A8
blt __mod2u_L_815F97A8
srw r8, r3, r7
li r7, 0x0
b L_815F97BC
L_815F97A8:
b __mod2u_L_815F97BC
__mod2u_L_815F97A8:
srw r8, r4, r9
subfic r7, r9, 0x20
slw r7, r3, r7
or r8, r8, r7
srw r7, r3, r9
L_815F97BC:
__mod2u_L_815F97BC:
cmpwi r0, 0x20
subic r9, r0, 0x20
blt L_815F97D4
blt __mod2u_L_815F97D4
slw r3, r4, r9
li r4, 0x0
b L_815F97E8
L_815F97D4:
b __mod2u_L_815F97E8
__mod2u_L_815F97D4:
slw r3, r3, r0
subfic r9, r0, 0x20
srw r9, r4, r9
or r3, r3, r9
slw r4, r4, r0
L_815F97E8:
__mod2u_L_815F97E8:
li r10, -0x1
addic r7, r7, 0x0
L_815F97F0:
__mod2u_L_815F97F0:
adde r4, r4, r4
adde r3, r3, r3
adde r8, r8, r8
adde r7, r7, r7
subfc r0, r6, r8
subfe. r9, r5, r7
blt L_815F9818
blt __mod2u_L_815F9818
mr r8, r0
mr r7, r9
addic r0, r10, 0x1
L_815F9818:
bdnz L_815F97F0
__mod2u_L_815F9818:
bdnz __mod2u_L_815F97F0
mr r4, r8
mr r3, r7
blr
L_815F9828:
__mod2u_L_815F9828:
blr
#endif
}
@@ -551,30 +551,30 @@ L_815F9828:
asm void __mod2i() {
#ifdef __MWERKS__
cmpwi cr7, r3, 0x0
bge cr7, L_815F983C
bge cr7, __mod2i_L_815F983C
subfic r4, r4, 0x0
subfze r3, r3
L_815F983C:
__mod2i_L_815F983C:
cmpwi r5, 0x0
bge L_815F984C
bge __mod2i_L_815F984C
subfic r6, r6, 0x0
subfze r5, r5
L_815F984C:
__mod2i_L_815F984C:
cmpwi r3, 0x0
cntlzw r0, r3
cntlzw r9, r4
bne L_815F9860
bne __mod2i_L_815F9860
addi r0, r9, 0x20
L_815F9860:
__mod2i_L_815F9860:
cmpwi r5, 0x0
cntlzw r9, r5
cntlzw r10, r6
bne L_815F9874
bne __mod2i_L_815F9874
addi r9, r10, 0x20
L_815F9874:
__mod2i_L_815F9874:
cmpw r0, r9
subfic r10, r0, 0x40
bgt L_815F9928
bgt __mod2i_L_815F9928
addi r9, r9, 0x1
subfic r9, r9, 0x40
add r0, r0, r9
@@ -582,52 +582,52 @@ L_815F9874:
mtctr r9
cmpwi r9, 0x20
subi r7, r9, 0x20
blt L_815F98AC
blt __mod2i_L_815F98AC
srw r8, r3, r7
li r7, 0x0
b L_815F98C0
L_815F98AC:
b __mod2i_L_815F98C0
__mod2i_L_815F98AC:
srw r8, r4, r9
subfic r7, r9, 0x20
slw r7, r3, r7
or r8, r8, r7
srw r7, r3, r9
L_815F98C0:
__mod2i_L_815F98C0:
cmpwi r0, 0x20
subic r9, r0, 0x20
blt L_815F98D8
blt __mod2i_L_815F98D8
slw r3, r4, r9
li r4, 0x0
b L_815F98EC
L_815F98D8:
b __mod2i_L_815F98EC
__mod2i_L_815F98D8:
slw r3, r3, r0
subfic r9, r0, 0x20
srw r9, r4, r9
or r3, r3, r9
slw r4, r4, r0
L_815F98EC:
__mod2i_L_815F98EC:
li r10, -0x1
addic r7, r7, 0x0
L_815F98F4:
__mod2i_L_815F98F4:
adde r4, r4, r4
adde r3, r3, r3
adde r8, r8, r8
adde r7, r7, r7
subfc r0, r6, r8
subfe. r9, r5, r7
blt L_815F991C
blt __mod2i_L_815F991C
mr r8, r0
mr r7, r9
addic r0, r10, 0x1
L_815F991C:
bdnz L_815F98F4
__mod2i_L_815F991C:
bdnz __mod2i_L_815F98F4
mr r4, r8
mr r3, r7
L_815F9928:
bge cr7, L_815F9934
__mod2i_L_815F9928:
bge cr7, __mod2i_L_815F9934
subfic r4, r4, 0x0
subfze r3, r3
L_815F9934:
__mod2i_L_815F9934:
blr
#endif
}
@@ -668,9 +668,9 @@ asm void __shr2i() {
slw r10, r3, r8
or r4, r4, r10
sraw r10, r3, r9
ble L_815F99A0
ble __shr2i_L_815F99A0
or r4, r4, r10
L_815F99A0:
__shr2i_L_815F99A0:
sraw r3, r3, r5
blr
#endif
@@ -680,13 +680,13 @@ asm void __cvt_sll_dbl() {
#ifdef __MWERKS__
stwu r1, -0x10(r1)
clrrwi. r5, r3, 31
beq L_815F99BC
beq __cvt_sll_dbl_L_815F99BC
subfic r4, r4, 0x0
subfze r3, r3
L_815F99BC:
__cvt_sll_dbl_L_815F99BC:
or. r7, r3, r4
li r6, 0x0
beq L_815F9A44
beq __cvt_sll_dbl_L_815F9A44
cntlzw r7, r3
cntlzw r8, r4
extlwi r9, r7, 5, 26
@@ -705,22 +705,22 @@ L_815F99BC:
clrlwi r7, r4, 21
cmpwi r7, 0x400
addi r6, r6, 0x43e
blt L_815F9A2C
bgt L_815F9A20
blt __cvt_sll_dbl_L_815F9A2C
bgt __cvt_sll_dbl_L_815F9A20
rlwinm. r7, r4, 0, 20, 20
beq L_815F9A2C
L_815F9A20:
beq __cvt_sll_dbl_L_815F9A2C
__cvt_sll_dbl_L_815F9A20:
addic r4, r4, 0x800
addze r3, r3
addze r6, r6
L_815F9A2C:
__cvt_sll_dbl_L_815F9A2C:
rotrwi r4, r4, 11
rlwimi r4, r3, 21, 0, 10
extrwi r3, r3, 20, 1
slwi r6, r6, 20
or r3, r6, r3
or r3, r5, r3
L_815F9A44:
__cvt_sll_dbl_L_815F9A44:
stw r3, 0x8(r1)
stw r4, 0xc(r1)
lfd f1, 0x8(r1)
@@ -734,7 +734,7 @@ asm void __cvt_ull_dbl() {
stwu r1, -0x10(r1)
or. r7, r3, r4
li r6, 0x0
beq L_815F9AE0
beq __cvt_ull_dbl_L_815F9AE0
cntlzw r7, r3
cntlzw r8, r4
extlwi r9, r7, 5, 26
@@ -753,21 +753,21 @@ asm void __cvt_ull_dbl() {
clrlwi r7, r4, 21
cmpwi r7, 0x400
addi r6, r6, 0x43e
blt L_815F9ACC
bgt L_815F9AC0
blt __cvt_ull_dbl_L_815F9ACC
bgt __cvt_ull_dbl_L_815F9AC0
rlwinm. r7, r4, 0, 20, 20
beq L_815F9ACC
L_815F9AC0:
beq __cvt_ull_dbl_L_815F9ACC
__cvt_ull_dbl_L_815F9AC0:
addic r4, r4, 0x800
addze r3, r3
addze r6, r6
L_815F9ACC:
__cvt_ull_dbl_L_815F9ACC:
rotrwi r4, r4, 11
rlwimi r4, r3, 21, 0, 10
extrwi r3, r3, 20, 1
slwi r6, r6, 20
or r3, r6, r3
L_815F9AE0:
__cvt_ull_dbl_L_815F9AE0:
stw r3, 0x8(r1)
stw r4, 0xc(r1)
lfd f1, 0x8(r1)
@@ -781,7 +781,7 @@ asm void __cvt_ull_flt() {
stwu r1, -0x10(r1)
or. r7, r3, r4
li r6, 0x0
beq L_815F9B7C
beq __cvt_ull_flt_L_815F9B7C
cntlzw r7, r3
cntlzw r8, r4
extlwi r9, r7, 5, 26
@@ -800,21 +800,21 @@ asm void __cvt_ull_flt() {
clrlwi r7, r4, 21
cmpwi r7, 0x400
addi r6, r6, 0x43e
blt L_815F9B68
bgt L_815F9B5C
blt __cvt_ull_flt_L_815F9B68
bgt __cvt_ull_flt_L_815F9B5C
rlwinm. r7, r4, 0, 20, 20
beq L_815F9B68
L_815F9B5C:
beq __cvt_ull_flt_L_815F9B68
__cvt_ull_flt_L_815F9B5C:
addic r4, r4, 0x800
addze r3, r3
addze r6, r6
L_815F9B68:
__cvt_ull_flt_L_815F9B68:
rotrwi r4, r4, 11
rlwimi r4, r3, 21, 0, 10
extrwi r3, r3, 20, 1
slwi r6, r6, 20
or r3, r6, r3
L_815F9B7C:
__cvt_ull_flt_L_815F9B7C:
stw r3, 0x8(r1)
stw r4, 0xc(r1)
lfd f1, 0x8(r1)
@@ -832,17 +832,17 @@ asm void __cvt_dbl_usll() {
lwz r4, 0xc(r1)
extrwi r5, r3, 11, 1
cmplwi r5, 0x3ff
bge L_815F9BBC
bge __cvt_dbl_usll_L_815F9BBC
li r3, 0x0
li r4, 0x0
b L_815F9C58
L_815F9BBC:
b __cvt_dbl_usll_L_815F9C58
__cvt_dbl_usll_L_815F9BBC:
mr r6, r3
clrlwi r3, r3, 12
oris r3, r3, 0x10
subi r5, r5, 0x433
cmpwi r5, 0x0
bge L_815F9BFC
bge __cvt_dbl_usll_L_815F9BFC
neg r5, r5
subfic r8, r5, 0x20
subic r9, r5, 0x20
@@ -852,21 +852,21 @@ L_815F9BBC:
srw r10, r3, r9
or r4, r4, r10
srw r3, r3, r5
b L_815F9C48
L_815F9BFC:
b __cvt_dbl_usll_L_815F9C48
__cvt_dbl_usll_L_815F9BFC:
cmpwi r5, 0xa
ble+ L_815F9C28
ble+ __cvt_dbl_usll_L_815F9C28
clrrwi. r6, r6, 31
beq L_815F9C18
beq __cvt_dbl_usll_L_815F9C18
lis r3, 0x8000
li r4, 0x0
b L_815F9C58
L_815F9C18:
b __cvt_dbl_usll_L_815F9C58
__cvt_dbl_usll_L_815F9C18:
lis r3, 0x7fff
ori r3, r3, 0xffff
li r4, -0x1
b L_815F9C58
L_815F9C28:
b __cvt_dbl_usll_L_815F9C58
__cvt_dbl_usll_L_815F9C28:
subfic r8, r5, 0x20
subic r9, r5, 0x20
slw r3, r3, r5
@@ -875,12 +875,12 @@ L_815F9C28:
slw r10, r4, r9
or r3, r3, r10
slw r4, r4, r5
L_815F9C48:
__cvt_dbl_usll_L_815F9C48:
clrrwi. r6, r6, 31
beq L_815F9C58
beq __cvt_dbl_usll_L_815F9C58
subfic r4, r4, 0x0
subfze r3, r3
L_815F9C58:
__cvt_dbl_usll_L_815F9C58:
addi r1, r1, 0x10
blr
#endif
@@ -894,19 +894,19 @@ asm void __cvt_dbl_ull() {
lwz r4, 0xc(r1)
extrwi r5, r3, 11, 1
cmplwi r5, 0x3ff
bge L_815F9C88
L_815F9C7C:
bge __cvt_dbl_ull_L_815F9C88
__cvt_dbl_ull_L_815F9C7C:
li r3, 0x0
li r4, 0x0
b L_815F9D00
L_815F9C88:
b __cvt_dbl_ull_L_815F9D00
__cvt_dbl_ull_L_815F9C88:
clrrwi. r6, r3, 31
bne L_815F9C7C
bne __cvt_dbl_ull_L_815F9C7C
clrlwi r3, r3, 12
oris r3, r3, 0x10
subi r5, r5, 0x433
cmpwi r5, 0x0
bge L_815F9CCC
bge __cvt_dbl_ull_L_815F9CCC
neg r5, r5
subfic r8, r5, 0x20
subic r9, r5, 0x20
@@ -916,14 +916,14 @@ L_815F9C88:
srw r10, r3, r9
or r4, r4, r10
srw r3, r3, r5
b L_815F9D00
L_815F9CCC:
b __cvt_dbl_ull_L_815F9D00
__cvt_dbl_ull_L_815F9CCC:
cmpwi r5, 0xb
ble+ L_815F9CE0
ble+ __cvt_dbl_ull_L_815F9CE0
li r3, -0x1
li r4, -0x1
b L_815F9D00
L_815F9CE0:
b __cvt_dbl_ull_L_815F9D00
__cvt_dbl_ull_L_815F9CE0:
subfic r8, r5, 0x20
subic r9, r5, 0x20
slw r3, r3, r5
@@ -932,7 +932,7 @@ L_815F9CE0:
slw r10, r4, r9
or r3, r3, r10
slw r4, r4, r5
L_815F9D00:
__cvt_dbl_ull_L_815F9D00:
addi r1, r1, 0x10
blr
#endif

View File

@@ -30,8 +30,8 @@ typedef struct AppLoaderHeader {
} AppLoaderHeader;
u8 TicketViewsBuf[OSRoundUp32B(sizeof(ESTicketView) * 64)] ALIGN32;
ESTicketView *lbl_81696578 = (ESTicketView *)TicketViewsBuf;
DVDDiskID lbl_810ADF60 ALIGN32;
ESTicketView *TicketViews = (ESTicketView *)TicketViewsBuf;
DVDDiskID UpdateDiskID ALIGN32;
OSBootInfo2 bi2 ALIGN32;
AppLoaderHeader AppLoaderHdr ALIGN32;
OSBootInfo3 bi3 ALIGN32;
@@ -41,118 +41,66 @@ DVDDiskID DiskID ALIGN32;
DVDPartitionParams PartitionParams ALIGN32;
NANDCommandBlock BS2NandBlock;
NANDFileInfo BS2CacheFileInfo;
DVDCommandBlock lbl_8108BF60;
DVDCommandBlock CoverBlock;
u8 PartitionInfoBuf[OSRoundUp32B(sizeof(DVDPartitionInfo) * 256)] ALIGN32;
DVDCommandBlock Block;
BS2State State = BS2_STT_BEGIN;
vu32 lbl_81698A0C = 0;
u32 lbl_81698A10 = 0;
u32 lbl_81698A14 = 0;
u32 lbl_81698A18 = 0;
u32 lbl_81698A1C = 0;
vu32 DvdReadPending = 0;
u32 BannerAllocation = 0;
u32 BannerBuffer = 0;
u32 BannerAvailable = 0;
u32 Allocator = 0;
BOOL StartingGame = FALSE;
u32 lbl_81698A24 = 0;
u32 lbl_81698A28 = 0;
u32 lbl_81698A2C = 0;
u32 lbl_81698A30 = 0;
u32 RestartRequested = 0;
u32 PartitionOpen = 0;
u32 CacheSeekComplete = 0;
u32 LoadingTitle = 0;
BOOL FatalErrorFlag = FALSE;
BOOL RetryErrorFlag = FALSE;
BOOL UpdateErrorFlag = FALSE;
BOOL AbortFlag = FALSE;
volatile int lbl_81698A44 = 0;
volatile int lbl_81698A48 = 0;
volatile int lbl_81698A4C = 0;
vu32 lbl_81698A50 = 0;
u32 lbl_81698A54 = 0;
u32 lbl_81698A58 = 0;
u32 lbl_81698A5C = 0;
u64 lbl_81698A60 = 0;
u64 lbl_81698A68 = 0;
u64 lbl_81698A70 = 0;
u32 lbl_81698A78 = 0;
u32 lbl_81698A7C = 0;
u32 lbl_81698A80 = 0;
u32 lbl_81698A84 = 0;
u32 lbl_81698A88 = 0;
u32 lbl_81698A8C = 0;
u32 lbl_81698A90 = 0;
u32 lbl_81698A94 = 0;
u32 lbl_81698A98 = 0;
u32 lbl_81698A9C = 0;
u64 lbl_81698AA0 = 0;
u32 lbl_81698AA8 = 0;
u32 lbl_81698AAC = 0;
vu32 lbl_81698AB0 = 0;
vu32 lbl_81698AB4 = 0;
u8 *lbl_81698AB8 = NULL;
NANDFileInfo *lbl_81698ABC = NULL;
vu32 lbl_81698AC0 = 0;
volatile NANDCallback lbl_81698AC4 = NULL;
u32 lbl_81698AC8 = 0;
vu32 lbl_81698ACC = 0;
u32 lbl_81698AD0 = 0;
vu32 lbl_81698AD4 = 0;
vu32 lbl_81698AD8 = 0;
vu32 lbl_81698ADC = 0;
vu32 lbl_81698AE0 = 0;
u32 *lbl_81698AE4 = 0;
u32 lbl_81698AE8 = 0;
u32 lbl_81698AEC = 0;
u32 lbl_81698AF0 = 0;
volatile int CacheFailed = 0;
volatile int RegionValid = 0;
volatile int NandPending = 0;
vu32 CancelNand = 0;
u32 LowReadResult = 0;
u32 CacheCommandComplete = 0;
u32 AudioBufferUnconfigured = 0;
u64 ResetTime = 0;
u64 SpinupDeadline = 0;
u64 CoverPollTime = 0;
u32 DriveWasReset = 0;
u32 TitleTicketView = 0;
u32 CurrentTmd = 0;
u32 TitleCode = 0;
u32 RequiredIosHigh = 0;
u32 RequiredIosLow = 0;
u32 GamePartition = 0;
u32 UpdatePartition = 0;
u32 PartitionCursor = 0;
u32 DataToc = 0;
u64 GameToc = 0;
u32 CoverOpenTimeHigh = 0;
u32 CoverOpenTimeLow = 0;
vu32 NandTransferred = 0;
vu32 NandLength = 0;
u8 *NandBuffer = NULL;
NANDFileInfo *NandFile = NULL;
vu32 NandOperation = 0;
volatile NANDCallback NandCompletion = NULL;
u32 LoaderOffset = 0;
vu32 LoaderLength = 0;
u32 LoaderAddress = 0;
vu32 CacheLength = 0;
vu32 BannerLength = 0;
vu32 DvdTransferLength = 0;
vu32 DvdTransferred = 0;
u32 *DvdProgress = 0;
u32 LoaderClose = 0;
u32 LoaderMain = 0;
u32 LoaderInit = 0;
#define DvdReadPending lbl_81698A0C
#define BannerAllocation lbl_81698A10
#define BannerBuffer lbl_81698A14
#define BannerAvailable lbl_81698A18
#define Allocator lbl_81698A1C
#define RestartRequested lbl_81698A24
#define PartitionOpen lbl_81698A28
#define CacheSeekComplete lbl_81698A2C
#define LoadingTitle lbl_81698A30
#define CacheFailed lbl_81698A44
#define RegionValid lbl_81698A48
#define NandPending lbl_81698A4C
#define CancelNand lbl_81698A50
#define LowReadResult lbl_81698A54
#define CacheCommandComplete lbl_81698A58
#define AudioBufferUnconfigured lbl_81698A5C
#define ResetTime lbl_81698A60
#define SpinupDeadline lbl_81698A68
#define CoverPollTime lbl_81698A70
#define DriveWasReset lbl_81698A78
#define TitleTicketView lbl_81698A7C
#define CurrentTmd lbl_81698A80
#define TitleCode lbl_81698A84
#define RequiredIosHigh lbl_81698A88
#define RequiredIosLow lbl_81698A8C
#define GamePartition lbl_81698A90
#define UpdatePartition lbl_81698A94
#define PartitionCursor lbl_81698A98
#define DataToc lbl_81698A9C
#define GameToc lbl_81698AA0
#define CoverOpenTimeHigh lbl_81698AA8
#define CoverOpenTimeLow lbl_81698AAC
#define NandTransferred lbl_81698AB0
#define NandLength lbl_81698AB4
#define NandBuffer lbl_81698AB8
#define NandFile lbl_81698ABC
#define NandOperation lbl_81698AC0
#define NandCompletion lbl_81698AC4
#define LoaderOffset lbl_81698AC8
#define LoaderLength lbl_81698ACC
#define LoaderAddress lbl_81698AD0
#define CacheLength lbl_81698AD4
#define BannerLength lbl_81698AD8
#define DvdTransferLength lbl_81698ADC
#define DvdTransferred lbl_81698AE0
#define DvdProgress lbl_81698AE4
#define LoaderClose lbl_81698AE8
#define LoaderMain lbl_81698AEC
#define LoaderInit lbl_81698AF0
#define CoverBlock lbl_8108BF60
#define UpdateDiskID lbl_810ADF60
#define TicketViews lbl_81696578
void BS2Report(const char *msg, ...) {
#ifdef ENABLE_BS2_REPORT

View File

@@ -604,7 +604,7 @@ vmBoolInt VmIsNan(vmFloat value) {
return isnan(value) || value == VM_NAN;
}
double CHANSVm_8144B1D8(double value) {
double CHANSVmFloatSign(double value) {
// Clamp to -1.0~1.0
return value < 0.0 ? -1.0 : value > 0.0 ? 1.0 : value;
}
@@ -650,14 +650,14 @@ static s32 CHANSVmParseInt(CHANSVmObjHdr* obj, s32 base, u64* out) {
return 0;
}
CHANSVmObjHdr* CHANSVm_8144B30C(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* object) {
CHANSVmObjHdr* CHANSVmConvertToIntFromFloat(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* object) {
// Convert to int from float
CHANSVmObjHdr* newObj = CHANSVmNewObject(vm, vmFalse, vmNull, CHANS_VM_OBJ_TYPE_INTEGER, 0);
if (newObj != vmNull) {
if (VmIsNan(object->value.float_v)) {
newObj->value.int_v = 0;
} else {
newObj->value.int_v = (u64)(CHANSVm_8144B1D8(object->value.float_v) * floor(fabs(object->value.float_v)));
newObj->value.int_v = (u64)(CHANSVmFloatSign(object->value.float_v) * floor(fabs(object->value.float_v)));
}
}
return newObj;
@@ -675,7 +675,7 @@ CHANSVmObjHdr* CHANSVmConvertToIntFromArray(CHANSVm* vm, CHANSVmObjType type, CH
return vmNull;
}
CHANSVmObjHdr* CHANSVm_8144B430(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* object) {
CHANSVmObjHdr* CHANSVmConvertToFloatFromUndefined(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* object) {
CHANSVmObjHdr* result = CHANSVmNewObject(vm, vmFalse, vmNull, CHANS_VM_OBJ_TYPE_FLOAT, 0);
if (result != vmNull) {
result->value.float_v = VM_NAN;
@@ -683,7 +683,7 @@ CHANSVmObjHdr* CHANSVm_8144B430(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr*
return result;
}
CHANSVmObjHdr* CHANSVm_8144B470(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* intObj) {
CHANSVmObjHdr* CHANSVmConvertToFloatFromInt(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* intObj) {
CHANSVmObjHdr* result = CHANSVmNewObject(vm, vmFalse, vmNull, CHANS_VM_OBJ_TYPE_FLOAT, 0);
if (result != vmNull) {
result->value.float_v = VmIntToFloat(intObj->value.int_v);
@@ -771,7 +771,7 @@ static inline s32 CHANSVmParseFloat(CHANSVmObjHdr* obj, f64* out) {
return 0;
}
CHANSVmObjHdr* CHANSVm_8144B4D4(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* object) {
CHANSVmObjHdr* CHANSVmConvertToFloatFromStr(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* object) {
// Convert string keyword into float value
CHANSVmObjHdr* newObj = CHANSVmNewObject(vm, vmFalse, vmNull, CHANS_VM_OBJ_TYPE_FLOAT, 0);
@@ -785,7 +785,7 @@ CHANSVmObjHdr* CHANSVmConvertToStrFromUndefined(CHANSVm* vm, CHANSVmObjType type
return (CHANSVmObjHdr*)CHANSVmConstStringObjectUndefined_;
}
s32 CHANSVm_8144B62C(vmWString buf, u32 len, vmFloat val) NO_INLINE {
s32 CHANSVmFloatToWString(vmWString buf, u32 len, vmFloat val) NO_INLINE {
s32 result = snprintf((char*)buf, len / 2, scFloatPrintfFmt, val);
CHANSVmStrCpyToU16FromU8(buf, (vmString)buf, result);
return VM_STR_LENGTH(result);
@@ -815,7 +815,7 @@ error:
return vmNull;
}
CHANSVmObjHdr* CHANSVm_8144B734(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* value) {
CHANSVmObjHdr* CHANSVmConvertToStrFromFloat(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* value) {
const CHANSVmObjHdr* base;
CHANSVmObjHdr* newObj;
s32 result;
@@ -835,7 +835,7 @@ CHANSVmObjHdr* CHANSVm_8144B734(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr*
newObj = CHANSVmNewObject(vm, vmFalse, vmNull, CHANS_VM_OBJ_TYPE_STRING, VM_STRING_SIZE);
if (newObj != vmNull) {
result = CHANSVm_8144B62C(newObj->value.wstring_v->spData, VM_STRING_SIZE, value->value.float_v);
result = CHANSVmFloatToWString(newObj->value.wstring_v->spData, VM_STRING_SIZE, value->value.float_v);
newObj->value.wstring_v->len = result;
if (newObj->value.wstring_v->len == 0) {
goto error;
@@ -904,9 +904,9 @@ char scVmGetResultType[] = "VmGetResultType";
// clang-format off
const VmConvertEntry VmTypeConvertFuncTbl[] = {
{vmNull, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError},
{CHANSVmConvertObjectTypeError, vmNull, CHANSVm_8144B30C, CHANSVmConvertToIntFromStr, CHANSVmConvertToIntFromArray, CHANSVmConvertObjectTypeError},
{CHANSVm_8144B430, CHANSVm_8144B470, vmNull, CHANSVm_8144B4D4, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError},
{CHANSVmConvertToStrFromUndefined, CHANSVmConvertToStrFromInt, CHANSVm_8144B734, vmNull, CHANSVmConvertToStrFromArray, CHANSVmConvertObjectTypeError},
{CHANSVmConvertObjectTypeError, vmNull, CHANSVmConvertToIntFromFloat, CHANSVmConvertToIntFromStr, CHANSVmConvertToIntFromArray, CHANSVmConvertObjectTypeError},
{CHANSVmConvertToFloatFromUndefined, CHANSVmConvertToFloatFromInt, vmNull, CHANSVmConvertToFloatFromStr, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError},
{CHANSVmConvertToStrFromUndefined, CHANSVmConvertToStrFromInt, CHANSVmConvertToStrFromFloat, vmNull, CHANSVmConvertToStrFromArray, CHANSVmConvertObjectTypeError},
{CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, vmNull, CHANSVmConvertObjectTypeError},
{CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, vmNull},
};
@@ -2183,7 +2183,7 @@ static u32 VmArrayJoinSub(CHANSVmObjHdr* obj, CHANSVmObjHdr* array, wchar_t* sep
if (offset + 0x80 > bufSize) {
goto error;
}
elemLen = CHANSVm_8144B62C((vmWString)((u8*)(*obj->value.ptr_v) + offset), 0x80, chunk->elements[countInChunk].value.float_v);
elemLen = CHANSVmFloatToWString((vmWString)((u8*)(*obj->value.ptr_v) + offset), 0x80, chunk->elements[countInChunk].value.float_v);
break;
}
case CHANS_VM_TYPE_ARRAY: {
@@ -3400,7 +3400,7 @@ VmMethodDefine(String, ToUpperCase) {
return vmFalse;
}
CHANSVmObjHdr* CHANSVm_8145049C(CHANSVm* vm, CHANSVmObjHdr* obj, u32 arg) {
CHANSVmObjHdr* CHANSVmFormatString(CHANSVm* vm, CHANSVmObjHdr* obj, u32 arg) {
u8 pad0[8];
u8 tempBuf[16];
u8 fmtBufData[32];
@@ -3745,7 +3745,7 @@ null_return:
VmMethodDefine(String, Format) {
u32 result;
if (VmParentObj != vmNull && VmParentObj->type == CHANS_VM_TYPE_CLASS_REF) {
result = (u32)CHANSVm_8145049C(VmInst, VmReturnObj, 0);
result = (u32)CHANSVmFormatString(VmInst, VmReturnObj, 0);
return result != 0;
}
return 0;
@@ -3775,10 +3775,10 @@ int VmGetIntFromObjHdr(CHANSVmObjHdr* object) {
return 0;
}
u32 CHANSVm_81451314(BlobHeader* blob, CHANSVmObjHdr* ptr, u32 limit);
BOOL CHANSVm_81451348(BlobHeader* blob, s64 size);
u32 CHANSVmBlobGetCount(BlobHeader* blob, CHANSVmObjHdr* ptr, u32 limit);
BOOL CHANSVmBlobHasSpace(BlobHeader* blob, s64 size);
CHANSVmObjHdr* CHANSVmNewBlobObject(CHANSVm* VmInst, CHANSVmObjHdr* obj, u32 size, void* src, u32 count);
static u64 CHANSVm_814540E0(u32 upper, u32 lower);
static u64 CHANSVmMakeU64(u32 upper, u32 lower);
static void VmBlobInitValue(BlobHeader* blob, u32 size) {
if (blob != vmNull) {
@@ -3834,7 +3834,7 @@ static u8* VmBlobGetDataBufferDirect(CHANSVmObjHdr* obj) {
return vmNull;
}
BOOL CHANSVm_81450D14(BlobHeader* blob, s64 val, u32* out) {
BOOL CHANSVmBlobResolveOffset(BlobHeader* blob, s64 val, u32* out) {
s64 pos;
if (blob == vmNull) {
@@ -3901,7 +3901,7 @@ VmMethodDefine(Blob, Seek) {
return 0;
}
if (CHANSVm_81450D14(blob, val->value.int_v, &tmp)) {
if (CHANSVmBlobResolveOffset(blob, val->value.int_v, &tmp)) {
blob->offset = tmp;
} else {
return 0;
@@ -3988,9 +3988,9 @@ VmMethodDefine(Blob, Fill) {
return 0;
}
count = blob != vmNull ? CHANSVm_81451314(blob, fill, blob->offset) : 0;
count = blob != vmNull ? CHANSVmBlobGetCount(blob, fill, blob->offset) : 0;
if (CHANSVm_81451348(blob, count)) {
if (CHANSVmBlobHasSpace(blob, count)) {
memset(blob->pData + blob->offset, (u8)val->value.int_v, count);
blob->offset += count;
return 1;
@@ -3999,7 +3999,7 @@ VmMethodDefine(Blob, Fill) {
return 0;
}
u32 CHANSVm_81451314(BlobHeader* blob, CHANSVmObjHdr* ptr, u32 limit) {
u32 CHANSVmBlobGetCount(BlobHeader* blob, CHANSVmObjHdr* ptr, u32 limit) {
if (ptr != vmNull) {
return *(u32*)((u8*)ptr + 4);
}
@@ -4013,7 +4013,7 @@ u32 CHANSVm_81451314(BlobHeader* blob, CHANSVmObjHdr* ptr, u32 limit) {
return 0;
}
BOOL CHANSVm_81451348(BlobHeader* blob, s64 size) {
BOOL CHANSVmBlobHasSpace(BlobHeader* blob, s64 size) {
u32 curOff = blob->offset;
return size >= 0 && (s64)(blob->size - curOff) >= size;
}
@@ -4028,7 +4028,7 @@ VmMethodDefine(Blob, GetString) {
}
size = (u32)arg->value.int_v;
if (CHANSVm_81451348(blob, size)) {
if (CHANSVmBlobHasSpace(blob, size)) {
CHANSVmErr err = CHANSVmSetU16StringFromU8(VmInst, VmReturnObj, (char*)(blob->pData + blob->offset), size);
blob->offset += size;
return err == CHANS_VM_OK;
@@ -4058,7 +4058,7 @@ VmMethodDefine(Blob, SetString) {
}
}
if (CHANSVm_81451348(blob, size)) {
if (CHANSVmBlobHasSpace(blob, size)) {
memset(blob->pData + blob->offset, 0, size);
CHANSVmStrCpyToU8FromU16(blob->pData + blob->offset, strData, charCount);
blob->offset += size;
@@ -4076,7 +4076,7 @@ VmMethodDefine(Blob, GetWString) {
return 0;
}
if (CHANSVm_81451348(blob, VM_STR_LENGTH(arg->value.int_v))) {
if (CHANSVmBlobHasSpace(blob, VM_STR_LENGTH(arg->value.int_v))) {
CHANSVmErr err = CHANSVmSetU16String(VmInst, VmReturnObj, (wchar_t*)(blob->pData + blob->offset), (u32)arg->value.int_v << 1);
u32 oldOffset = blob->offset;
u64 length = VM_STR_LENGTH(arg->value.int_v);
@@ -4113,7 +4113,7 @@ VmMethodDefine(Blob, SetWString) {
}
}
if (CHANSVm_81451348(blob, size)) {
if (CHANSVmBlobHasSpace(blob, size)) {
memcpy(blob->pData + blob->offset, strData, strLen);
if (strLen < size) {
memset(blob->pData + blob->offset + strLen, 0, size - strLen);
@@ -4184,8 +4184,8 @@ VmMethodDefine(Blob, CopyRangeFrom) {
srcOff = 0;
destOff = 0;
if (CHANSVm_81450D14(destBlob, destOffObj->value.int_v, &destOff) != 0 && CHANSVm_81450D14(srcBlob, srcOffObj->value.int_v, &srcOff) != 0) {
count = CHANSVm_81451314(srcBlob, countObj, srcOff);
if (CHANSVmBlobResolveOffset(destBlob, destOffObj->value.int_v, &destOff) != 0 && CHANSVmBlobResolveOffset(srcBlob, srcOffObj->value.int_v, &srcOff) != 0) {
count = CHANSVmBlobGetCount(srcBlob, countObj, srcOff);
{
u32 destinationOffset = destOff;
okFlag = (s64)count >= 0 && (s64)(destBlob->size - destinationOffset) >= (s64)count;
@@ -4213,9 +4213,9 @@ VmMethodDefine(Blob, GetBlob) {
if (blob == vmNull)
return 0;
count = blob != vmNull ? CHANSVm_81451314(blob, arg, blob->offset) : 0;
count = blob != vmNull ? CHANSVmBlobGetCount(blob, arg, blob->offset) : 0;
if (CHANSVm_81451348(blob, count)) {
if (CHANSVmBlobHasSpace(blob, count)) {
if (CHANSVmNewBlobObject(VmInst, VmReturnObj, count, blob->offset + blob->pData, count) != vmNull) {
blob->offset += count;
return 1;
@@ -4262,7 +4262,7 @@ VmMethodDefine(Blob, SetBlob) {
}
}
if (CHANSVm_81451348(destBlob, logicalSize)) {
if (CHANSVmBlobHasSpace(destBlob, logicalSize)) {
memmove(destBlob->pData + *(u32*)&destBlob->offset, srcBlob->pData + srcBlob->offset, copySize);
if (copySize < logicalSize) {
memset(destBlob->offset + destBlob->pData + copySize, 0, logicalSize - copySize);
@@ -4284,9 +4284,9 @@ VmMethodDefine(Blob, GetHexString) {
return vmFalse;
}
count = blob != vmNull ? CHANSVm_81451314(blob, arg, blob->offset) : 0;
count = blob != vmNull ? CHANSVmBlobGetCount(blob, arg, blob->offset) : 0;
if (CHANSVm_81451348(blob, count) && CHANSVmNewObject(VmInst, vmFalse, VmReturnObj, CHANS_VM_OBJ_TYPE_STRING, count * 4) != vmNull) {
if (CHANSVmBlobHasSpace(blob, count) && CHANSVmNewObject(VmInst, vmFalse, VmReturnObj, CHANS_VM_OBJ_TYPE_STRING, count * 4) != vmNull) {
wchar_t* dest = (wchar_t*)VmGetStrFromObjHdr(VmReturnObj);
u8* src = blob->pData;
u32 offset = blob->offset;
@@ -4352,8 +4352,8 @@ VmMethodDefine(Blob, CalcRangeSHA1Digest) {
return 0;
}
if (CHANSVm_81450D14(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVm_81451314(blob, arg1, offset);
if (CHANSVmBlobResolveOffset(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVmBlobGetCount(blob, arg1, offset);
{
u32 off = offset;
@@ -4417,8 +4417,8 @@ VmMethodDefine(Blob, CalcRangeMD5Digest) {
return 0;
}
if (CHANSVm_81450D14(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVm_81451314(blob, arg1, offset);
if (CHANSVmBlobResolveOffset(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVmBlobGetCount(blob, arg1, offset);
{
u32 off = offset;
@@ -4464,8 +4464,8 @@ VmMethodDefine(Blob, CalcRangeCRC16) {
return 0;
}
if (CHANSVm_81450D14(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVm_81451314(blob, arg1, offset);
if (CHANSVmBlobResolveOffset(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVmBlobGetCount(blob, arg1, offset);
{
u32 off = offset;
if (((s64)size >= 0LL && (s64)(blob->size - off) >= (s64)size) != vmFalse) {
@@ -4500,8 +4500,8 @@ VmMethodDefine(Blob, CalcRangeCRC32) {
return 0;
}
if (CHANSVm_81450D14(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVm_81451314(blob, arg1, offset);
if (CHANSVmBlobResolveOffset(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVmBlobGetCount(blob, arg1, offset);
{
u32 off = offset;
@@ -4573,8 +4573,8 @@ VmMethodDefine(Blob, CalcRangeHMAC) {
return 0;
}
if (CHANSVm_81450D14(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVm_81451314(blob, arg1, offset);
if (CHANSVmBlobResolveOffset(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVmBlobGetCount(blob, arg1, offset);
off = offset;
if (((s64)size >= 0LL && (s64)(blob->size - off) >= (s64)size) != vmFalse) {
NETHMACContext ctx;
@@ -5202,7 +5202,7 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
copySize = paramValue;
}
if (copySize < 0 || !CHANSVm_81451348(parentBlob, copySize)) {
if (copySize < 0 || !CHANSVmBlobHasSpace(parentBlob, copySize)) {
goto error;
}
@@ -5220,7 +5220,7 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
break;
}
case 5: {
if (paramValue < 0 || !CHANSVm_81451348(parentBlob, paramValue)) {
if (paramValue < 0 || !CHANSVmBlobHasSpace(parentBlob, paramValue)) {
goto error;
}
if (paramValue > 0) {
@@ -5247,7 +5247,7 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
goto error;
}
if (!CHANSVm_81451348(parentBlob, elemSize * count)) {
if (!CHANSVmBlobHasSpace(parentBlob, elemSize * count)) {
goto error;
}
@@ -5342,7 +5342,7 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
break;
}
case 8: {
*(u64*)packBuf = CHANSVm_814540E0(packBuf[0], packBuf[1]);
*(u64*)packBuf = CHANSVmMakeU64(packBuf[0], packBuf[1]);
break;
}
}
@@ -5379,7 +5379,7 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
goto error;
}
if (!CHANSVm_81451348(parentBlob, elemSize * count)) {
if (!CHANSVmBlobHasSpace(parentBlob, elemSize * count)) {
goto error;
}
@@ -5424,7 +5424,7 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
}
bufSize = (count + 1) / 2;
if (!CHANSVm_81451348(parentBlob, bufSize)) {
if (!CHANSVmBlobHasSpace(parentBlob, bufSize)) {
goto error;
}
@@ -5472,7 +5472,7 @@ error:
return vmFalse;
}
static u64 CHANSVm_814540E0(u32 upper, u32 lower) {
static u64 CHANSVmMakeU64(u32 upper, u32 lower) {
// Read U64 and byte-swap
u64 x = (u64)upper << 32 | lower;
return x >> 56 & 0x00000000000000ffULL | x >> 40 & 0x000000000000ff00ULL | x >> 24 & 0x0000000000ff0000ULL | x >> 8 & 0x00000000ff000000ULL |
@@ -5648,7 +5648,7 @@ VmMethodDefine(Blob, Unpack) {
} else {
count = outVal;
}
if (count < 0 || !CHANSVm_81451348(srcBlob, count)) {
if (count < 0 || !CHANSVmBlobHasSpace(srcBlob, count)) {
goto error;
}
@@ -5663,7 +5663,7 @@ VmMethodDefine(Blob, Unpack) {
break;
}
case 5: {
if (outVal < 0 || !CHANSVm_81451348(srcBlob, outVal)) {
if (outVal < 0 || !CHANSVmBlobHasSpace(srcBlob, outVal)) {
goto error;
}
@@ -5682,7 +5682,7 @@ VmMethodDefine(Blob, Unpack) {
} else {
count = outVal;
}
if (count < 0 || !CHANSVm_81451348(srcBlob, outSize * count)) {
if (count < 0 || !CHANSVmBlobHasSpace(srcBlob, outSize * count)) {
goto error;
}
@@ -5710,7 +5710,7 @@ VmMethodDefine(Blob, Unpack) {
break;
}
case 8: {
unpackBuf.value = CHANSVm_814540E0(unpackBuf.words[0], unpackBuf.words[1]);
unpackBuf.value = CHANSVmMakeU64(unpackBuf.words[0], unpackBuf.words[1]);
break;
}
}
@@ -5794,7 +5794,7 @@ VmMethodDefine(Blob, Unpack) {
}
count = (srcBlob->size - srcBlob->offset) / outSize;
}
if ((s32)count < 0 || !CHANSVm_81451348(srcBlob, outSize * count)) {
if ((s32)count < 0 || !CHANSVmBlobHasSpace(srcBlob, outSize * count)) {
goto error;
}
@@ -5845,7 +5845,7 @@ VmMethodDefine(Blob, Unpack) {
}
bufSize = (s32)(count + 1) / 2;
if (!CHANSVm_81451348(srcBlob, bufSize)) {
if (!CHANSVmBlobHasSpace(srcBlob, bufSize)) {
goto error;
}
@@ -6466,7 +6466,7 @@ void CHANSConvertModuleOfsToPtr(CHANSVmModule* ptr) {
VmOffsU32ToPtr((void**)&ptr->pLineTbl, ptr);
}
static CHANSVmObjHdr* CHANSVm_81455654(CHANSVm* vm, s32 id) {
static CHANSVmObjHdr* CHANSVmLookupScopedObject(CHANSVm* vm, s32 id) {
CHANSVmObjHdr* data = vmNull;
CHANSVmPrivate* pVm = (CHANSVmPrivate*)vm;
CHANSVmExecutionCtx* ctx = pVm->pActiveCtx;
@@ -6755,7 +6755,7 @@ static CHANSVmErr VmReturnWithValue(CHANSVm* vm, u32 val) {
}
} else {
for (i = 0; i < pVm->pActiveCtx->pDbg->moduleCount; i++) {
if (CHANSVmDeleteObject(vm, CHANSVm_81455654(vm, i)) != CHANS_VM_OK) {
if (CHANSVmDeleteObject(vm, CHANSVmLookupScopedObject(vm, i)) != CHANS_VM_OK) {
return CHANS_VM_ERR_RETURN;
}
}
@@ -6873,7 +6873,7 @@ CHANSVmErr CHANSVmLinkModules(CHANSVm* vm, vmS32 unk0) {
CHANSVmObjHdr* obj;
if (idx >= module->moduleCount) {
goto pass3_idx_err;
} else if (obj = CHANSVm_81455654(vm, idx), obj == vmNull) {
} else if (obj = CHANSVmLookupScopedObject(vm, idx), obj == vmNull) {
goto pass3_obj_err;
} else if (obj->type == CHANS_VM_OBJ_TYPE_BLANK) {
goto pass3_success;
@@ -7602,7 +7602,7 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
break;
}
case CHANS_VM_OBJ_TYPE_FLOAT: {
invertedVal = (s64)(CHANSVm_8144B1D8(pAcc->value.float_v) * floor(fabs(pAcc->value.float_v)));
invertedVal = (s64)(CHANSVmFloatSign(pAcc->value.float_v) * floor(fabs(pAcc->value.float_v)));
break;
}
case CHANS_VM_OBJ_TYPE_STRING: {
@@ -7818,7 +7818,7 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
result = CHANS_VM_ERR_GET_PROPERTY_NAME;
arrayIdx = 0;
imm16Val = VM_READ_BE_U16(operandBuf, 0);
foundObj = CHANSVm_81455654(vm, imm16Val);
foundObj = CHANSVmLookupScopedObject(vm, imm16Val);
accumulator = &pVm->accumulator;
if (foundObj != vmNull && accumulator->type == CHANS_VM_OBJ_TYPE_INTEGER &&
(computedAddr = accumulator->value.data.len, (u64)accumulator->value.int_v <= ~1U)) {
@@ -7954,7 +7954,7 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
if (operandBuf == vmNull) {
return CHANS_VM_ERR_CODE_RANGE;
}
foundObj = CHANSVm_81455654(vm, (VM_READ_BE_U16(operandBuf, 0)) & 0x1FFF);
foundObj = CHANSVmLookupScopedObject(vm, (VM_READ_BE_U16(operandBuf, 0)) & 0x1FFF);
result = VmDeleteCommon(vm, foundObj);
break;
}
@@ -7982,12 +7982,12 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
imm16Val = (opcodeVal << 8 | operandBuf[1]) & 0x1FFF;
switch (opcodeVal & CHANS_VM_OP_SYMBOL_STORE) {
case 0: {
foundObj = CHANSVm_81455654(vm, imm16Val);
foundObj = CHANSVmLookupScopedObject(vm, imm16Val);
result = VmStore(vm, &pVm->accumulator, foundObj);
break;
}
case CHANS_VM_OP_SYMBOL_STORE: {
foundObj = CHANSVm_81455654(vm, imm16Val);
foundObj = CHANSVmLookupScopedObject(vm, imm16Val);
result = VmStore(vm, foundObj, &pVm->accumulator);
break;
}

View File

@@ -5,13 +5,6 @@
#include <new>
extern "C" const f32 lbl_81694D90;
extern "C" const f32 lbl_81694DA8;
extern "C" const f32 lbl_81694DAC;
extern "C" const f32 lbl_81694DB0;
extern "C" const f32 lbl_81694DB4;
extern "C" const f32 lbl_81694DBC;
extern "C" const double lbl_81694DC8;
extern "C" void _savegpr_24();
extern "C" void _restgpr_24();
extern "C" void GetFont__Q34nw4r3lyt8TextBoxCFv();

View File

@@ -154,7 +154,7 @@ extern "C" const char scT_title_textCHN[];
extern "C" const char lbl_816973A4[];
extern "C" const char lbl_816973AC[];
#pragma pop
extern "C" const f32 lbl_81694D28;
extern "C" const f32 scInputFormZeroF;
extern "C" void _savegpr_20();
extern "C" void _restgpr_20();
extern "C" void _savegpr_27();
@@ -386,31 +386,31 @@ extern "C" const wchar_t pppURLCheck[2][10] = {L"http://", L"https://"};
#pragma pop
extern "C" const f32 lbl_81694D28 = 0.0f;
extern "C" const f32 lbl_81694D2C = 640.0f;
extern "C" const f64 lbl_81694D30 = 4503601774854144.0;
extern "C" const f32 lbl_81694D38 = 1.0f;
extern "C" const f32 lbl_81694D3C = 0.5f;
extern "C" const f32 lbl_81694D40 = 0.7111111f;
extern "C" const f32 lbl_81694D44 = 150.0f;
extern "C" const f32 lbl_81694D48 = 30.0f;
extern "C" const f32 lbl_81694D4C = 50.0f;
extern "C" const f32 lbl_81694D50 = 10.0f;
extern "C" const f32 lbl_81694D54 = 52.0f;
extern "C" const f32 lbl_81694D58 = 2.0f;
extern "C" const f32 lbl_81694D5C = 140.0f;
extern "C" const f32 lbl_81694D60 = 90.0f;
extern "C" const f32 lbl_81694D64 = 253.0f;
extern "C" const f32 lbl_81694D68 = 20.0f;
extern "C" const u8 lbl_81694D6C = 0xff;
extern "C" const u8 lbl_81694D6D = 0x32;
extern "C" const u8 lbl_81694D6E = 0x32;
extern "C" const u8 lbl_81694D6F = 0;
extern "C" const f32 lbl_81694D70 = 255.0f;
extern "C" const f32 lbl_81694D74 = 127.0f;
extern "C" const f32 lbl_81694D78 = 14592.0f;
extern "C" const f64 lbl_81694D80 = 4503599627370496.0;
extern "C" const f32 lbl_81694D88 = 15.0f;
extern "C" const f32 scInputFormZeroF = 0.0f;
extern "C" const f32 scInputForm640F = 640.0f;
extern "C" const f64 scInputFormF32ConvertMagic = 4503601774854144.0;
extern "C" const f32 scInputFormOneF = 1.0f;
extern "C" const f32 scInputFormHalfF = 0.5f;
extern "C" const f32 scInputFormDegToFIdxF = 0.7111111f;
extern "C" const f32 scInputForm150F = 150.0f;
extern "C" const f32 scInputForm30F = 30.0f;
extern "C" const f32 scInputForm50F = 50.0f;
extern "C" const f32 scInputForm10F = 10.0f;
extern "C" const f32 scInputForm52F = 52.0f;
extern "C" const f32 scInputFormTwoF = 2.0f;
extern "C" const f32 scInputForm140F = 140.0f;
extern "C" const f32 scInputForm90F = 90.0f;
extern "C" const f32 scInputForm253F = 253.0f;
extern "C" const f32 scInputForm20F = 20.0f;
extern "C" const u8 scInputFormColorRU8 = 0xff;
extern "C" const u8 scInputFormColorGU8 = 0x32;
extern "C" const u8 scInputFormColorBU8 = 0x32;
extern "C" const u8 scInputFormColorAU8 = 0;
extern "C" const f32 scInputForm255F = 255.0f;
extern "C" const f32 scInputForm127F = 127.0f;
extern "C" const f32 scInputForm14592F = 14592.0f;
extern "C" const f64 scInputFormF64ConvertMagic = 4503599627370496.0;
extern "C" const f32 scInputForm15F = 15.0f;
f32 sfColorPhase;
bool mbHyphen = true;
@@ -3386,7 +3386,7 @@ void Base::drawCursor(f32 x, f32 y) {
f32 opacity = static_cast<u32>(muGlobalAlpha) / 255.0f;
mfCursorX = x;
mfCursorY = y;
GXColor color = {lbl_81694D6C, lbl_81694D6D, lbl_81694D6E, lbl_81694D6F};
GXColor color = {scInputFormColorRU8, scInputFormColorGU8, scInputFormColorBU8, scInputFormColorAU8};
f32 pulse = nw4r::math::SinFIdx(0.7111111f * muCursorTimer);
color.a = static_cast<s32>(opacity * (127.0f + 127.0f * pulse));
f32 width = mfViewWidth - mfViewX;

View File

@@ -2539,11 +2539,14 @@ namespace textinput {
u32 koreanCode = code;
if (caps)
koreanCode = util::reverseLetterCaseW(koreanCode);
u16 mapped;
if (koreanCode >= L'a' && koreanCode <= L'z')
koreanCode = KOREAN_LOWER[static_cast<u16>(koreanCode) - L'a'];
mapped = KOREAN_LOWER[static_cast<u16>(koreanCode) - L'a'];
else if (koreanCode >= L'A' && koreanCode <= L'Z')
koreanCode = KOREAN_UPPER[static_cast<u16>(koreanCode) - L'A'];
code = koreanCode;
mapped = KOREAN_UPPER[static_cast<u16>(koreanCode) - L'A'];
else
mapped = koreanCode;
code = mapped;
}
}
animation = searchAnmPane(code);

View File

@@ -485,16 +485,16 @@ namespace ipl {
}
void BoardObject::stt_stand() {
f32 degrees = mStandData.unk_0x0C * 30.0f + 30.0f;
f32 dVar2 = nw4r::math::CosFIdx(degrees * 0.7111111f);
degrees = mStandData.unk_0x0C * 30.0f + 30.0f;
f32 dVar3 = nw4r::math::SinFIdx(degrees * 0.7111111f);
f32 degrees = mStandData.mAngleIdx * 30.0f + 30.0f;
f32 cosF = nw4r::math::CosFIdx(degrees * 0.7111111f);
degrees = mStandData.mAngleIdx * 30.0f + 30.0f;
f32 sinF = nw4r::math::SinFIdx(degrees * 0.7111111f);
math::VEC2 standPos;
__ct__Q33ipl4math4VEC2Fff(&standPos, dVar3 * 160.0f, dVar2 * 160.0f);
mBoardPos = (((mStandData.pos * (f32)(10 - mStandData.unk_0x08)) + (standPos * mStandData.unk_0x08)) / 10.0f);
__ct__Q33ipl4math4VEC2Fff(&standPos, sinF * 160.0f, cosF * 160.0f);
mBoardPos = (((mStandData.pos * (f32)(10 - mStandData.mStep)) + (standPos * mStandData.mStep)) / 10.0f);
if ((mStandData.unk_0x08 += 1) > 10) {
if ((mStandData.mStep += 1) > 10) {
mStandData.init();
mState = STATE_NORMAL;
}

View File

@@ -313,7 +313,6 @@ namespace ipl {
#pragma push
#pragma section sconst_type ".sdata2"
extern "C" const f32 scDateZeroF = 0.0f;
extern "C" const f32 lbl_816948F0;
#pragma pop
} // namespace scene
} // namespace ipl

View File

@@ -45,7 +45,7 @@ struct CardThreadState {
MEMAllocator sAllocator_;
static CardThreadState* sThread;
extern "C" void* CardSequence_813D2C8C();
extern "C" void* cardThreadMain();
static char sCardSlotName[3] = "AB";
FileInfo* getCardDirState() {
@@ -68,7 +68,7 @@ long getCardLastCMDFCmdResult() {
return sThread->completionResult;
}
extern "C" s32 CardSequence_813D205C(u8 slot) {
extern "C" s32 sendCardUnmountCmd(u8 slot) {
sThread->sourceSlot = slot;
sThread->lastCommand = 9;
sThread->lastResult = -21;
@@ -114,12 +114,12 @@ void sendCardDeleteCmd(u8 slot, s16 fileNo) {
}
void sendCardThreadStopCmd() NO_INLINE {
CardSequence_813D205C(0);
CardSequence_813D205C(1);
sendCardUnmountCmd(0);
sendCardUnmountCmd(1);
OSSendMessage(&sThread->requests, (OSMessage)0xB, 0);
}
extern "C" void CardSequence_813D222C(u8 slot) {
extern "C" void pollCardSlot(u8 slot) {
s32 result;
if (sThread->valid == 1) {
@@ -139,7 +139,7 @@ extern "C" void CardSequence_813D222C(u8 slot) {
}
}
if (result == 0) {
if (sThread->slots[slot].state > 2 && CardSequence_813D205C(slot)) {
if (sThread->slots[slot].state > 2 && sendCardUnmountCmd(slot)) {
sThread->slots[slot].changed = 0;
}
}
@@ -148,7 +148,7 @@ done:
return;
}
extern "C" s32 CardSequence_813D233C(s32 result) {
extern "C" s32 mapCardErrorCode(s32 result) {
switch (result) {
case 0:
return 0;
@@ -186,8 +186,8 @@ extern "C" s32 CardSequence_813D233C(s32 result) {
void probeCard() {
OSMessage message;
CardSequence_813D222C(0);
CardSequence_813D222C(1);
pollCardSlot(0);
pollCardSlot(1);
while (OSReceiveMessage(&sThread->responses, &message, 0)) {
s16 slot = (s16)(((u32)message >> 16) & 1);
s8 command = (u8)(u32)message;
@@ -251,9 +251,9 @@ checkCommand:
break;
}
sThread->lastResult = CardSequence_813D233C((s8)(((u32)message << 16) >> 24));
sThread->lastResult = mapCardErrorCode((s8)(((u32)message << 16) >> 24));
if ((s8)(u8)(u32)message != 0 && (s8)(u8)(u32)message != 9) {
sThread->completionResult = CardSequence_813D233C((s8)(((u32)message << 16) >> 24));
sThread->completionResult = mapCardErrorCode((s8)(((u32)message << 16) >> 24));
if (sThread->sourceSlot != (s16)(((u32)message >> 16) & 1)) {
sThread->destinationFileNo = (u32)message >> 24;
}
@@ -302,7 +302,7 @@ void initCardThread() {
OSInitMessageQueue(&sThread->responses, sThread->responseMessages, 0x10);
OSInitMessageQueue(&sThread->requests, sThread->requestMessages, 0x10);
OSCreateThread(&sThread->thread, (void* (*)(void*))CardSequence_813D2C8C, 0,
OSCreateThread(&sThread->thread, (void* (*)(void*))cardThreadMain, 0,
sThread->stack + sizeof(sThread->stack), 0x8000, 0x11, 0);
OSResumeThread(&sThread->thread);
OSSendMessage(&sThread->requests, (OSMessage)10, 0);
@@ -348,7 +348,7 @@ const char* getIconComment(u8 slot, s16 index) {
return sThread->comments[slot][index];
}
extern "C" void CardSequence_813D2A74(s32 slot, s32 index) {
extern "C" void clearCardFileEntry(s32 slot, s32 index) {
BOOL interrupts = OSDisableInterrupts();
sThread->files[slot][index].fileNo = 0;
sThread->files[slot][index].size = 0;
@@ -360,7 +360,7 @@ extern "C" void CardSequence_813D2A74(s32 slot, s32 index) {
OSRestoreInterrupts(interrupts);
}
extern "C" void CardSequence_813D2B40(s32 slot) {
extern "C" void refreshCardSlotInfo(s32 slot) {
u16 memSize;
u32 sectorSize;
s32 freeBytes;
@@ -391,12 +391,12 @@ extern "C" void CardSequence_813D2B40(s32 slot) {
}
}
extern "C" s32 CardSequence_813D320C(s32 slot, s32 result);
extern "C" s32 CardSequence_813D32A8(s32 slot, s32 state, s32 result);
extern "C" void CardSequence_813D3380(s32 slot, s32 state, s32 fileNo);
extern "C" void CardSequence_813D33D8(s32 slot);
extern "C" s32 CardSequence_813D3424(s32 slot, s32 fileNo, CARDDir* dir);
extern "C" void CardSequence_813D3D14(s32 slot, s16 fileNo, s32 command);
extern "C" s32 handleCardMountResult(s32 slot, s32 result);
extern "C" s32 reportCardThreadError(s32 slot, s32 state, s32 result);
extern "C" void sendCardSlotState(s32 slot, s32 state, s32 fileNo);
extern "C" void clearAllCardFileEntries(s32 slot);
extern "C" s32 loadCardFileIcons(s32 slot, s32 fileNo, CARDDir* dir);
extern "C" void runCardMoveOrCopy(s32 slot, s16 fileNo, s32 command);
static inline void sendValidityResponse(u32 command, u32 valid) {
union {
@@ -408,7 +408,7 @@ static inline void sendValidityResponse(u32 command, u32 valid) {
OSSendMessage(&sThread->responses, (OSMessage)reply.value, 1);
}
extern "C" void* CardSequence_813D2C8C() {
extern "C" void* cardThreadMain() {
struct CardThreadLocals {
u8 compareName[6];
u32 message;
@@ -455,7 +455,7 @@ loopStart:
command = (local.message >> 14) & 4;
result = CARDMount(slot, sThread->mountBuffers[command / 4], 0);
if (result < 0) {
result = CardSequence_813D320C(slot, result);
result = handleCardMountResult(slot, result);
if (result != 0) {
goto mountContinue;
}
@@ -467,11 +467,11 @@ loopStart:
}
mountContinue:
CardSequence_813D33D8(slot);
clearAllCardFileEntries(slot);
for (file = 0; file < 0x7F; ++file) {
result = __CARDGetStatusEx(slot, (s16)file, &local.mountDir);
if (result < 0) {
result = CardSequence_813D320C(slot, result);
result = handleCardMountResult(slot, result);
if (result != 0) {
continue;
}
@@ -496,16 +496,16 @@ loopStart:
goto mountError;
}
} else {
result = CardSequence_813D3424(slot, (s16)file, &local.mountDir);
result = loadCardFileIcons(slot, (s16)file, &local.mountDir);
if (result < 0) {
goto mountError;
}
}
}
}
CardSequence_813D2B40(slot);
refreshCardSlotInfo(slot);
sThread->mounted[command / 4] = 1;
CardSequence_813D3380(slot, 0, 0);
sendCardSlotState(slot, 0, 0);
OSReport("Slot %c\n", sCardSlotName[slot]);
for (listingFile = 0; listingFile < 0x7F; ++listingFile) {
if (__CARDGetStatusEx(slot, (u16)listingFile, &local.listingDir) == 0) {
@@ -519,30 +519,30 @@ loopStart:
mountError:
OSReport("MountError\n");
CardSequence_813D32A8(slot, 0, result);
reportCardThreadError(slot, 0, result);
break;
}
case 9:
CardSequence_813D32A8((local.message >> 16) & 1, 9, -3);
reportCardThreadError((local.message >> 16) & 1, 9, -3);
break;
case 1: {
slot = (local.message >> 16) & 1;
result = CARDFormat(slot);
if (result < 0) {
CardSequence_813D32A8(slot, 1, result);
reportCardThreadError(slot, 1, result);
} else {
sThread->mounted[slot] = 1;
CardSequence_813D2B40(slot);
CardSequence_813D3380(slot, 1, 0);
refreshCardSlotInfo(slot);
sendCardSlotState(slot, 1, 0);
}
break;
}
case 2:
CardSequence_813D3D14((local.message >> 16) & 1,
runCardMoveOrCopy((local.message >> 16) & 1,
(s16)(u8)(local.message >> 24), (s8)command);
break;
case 3:
CardSequence_813D3D14((local.message >> 16) & 1,
runCardMoveOrCopy((local.message >> 16) & 1,
(s16)(u8)(local.message >> 24), (s8)command);
break;
case 4: {
@@ -550,11 +550,11 @@ loopStart:
fileNo = (s16)(local.message >> 24);
result = CARDFastDelete(slot, fileNo);
if (result < 0) {
CardSequence_813D32A8(slot, 4, result);
reportCardThreadError(slot, 4, result);
} else {
CardSequence_813D2A74(slot, fileNo);
CardSequence_813D2B40(slot);
CardSequence_813D3380(slot, 4, (u8)fileNo);
clearCardFileEntry(slot, fileNo);
refreshCardSlotInfo(slot);
sendCardSlotState(slot, 4, (u8)fileNo);
}
break;
}
@@ -581,7 +581,7 @@ loopStart:
++outerSlot;
} while (outerSlot < 2);
CardSequence_813D3380(0, 0xC, 0);
sendCardSlotState(0, 0xC, 0);
break;
default:
break;
@@ -593,9 +593,9 @@ loopCheck:
return 0;
}
extern "C" s32 CardSequence_813D3C38(s32 slot, s16 fileNo);
extern "C" s32 checkCardFileDuplicate(s32 slot, s16 fileNo);
extern "C" void CardSequence_813D3140() {
extern "C" void markAllCardFilesDirty() {
u32 slot = 0;
s32 fileNo;
@@ -607,7 +607,7 @@ extern "C" void CardSequence_813D3140() {
sThread->files[slot][fileNo].unk_0x06 = 0;
if (sThread->mounted[slot] != 0 &&
sThread->mounted[slot ^ 1] != 0 &&
CardSequence_813D3C38((u8)slot, (s16)fileNo) < 0) {
checkCardFileDuplicate((u8)slot, (s16)fileNo) < 0) {
sThread->files[slot][fileNo].unk_0x06 = flagValue;
}
++fileNo;
@@ -618,7 +618,7 @@ extern "C" void CardSequence_813D3140() {
} while ((s32)slot < 2);
}
extern "C" s32 CardSequence_813D320C(s32 slot, s32 result) {
extern "C" s32 handleCardMountResult(s32 slot, s32 result) {
if (result == -5) {
goto reportError;
}
@@ -640,32 +640,32 @@ repairedCard:
{
result = CARDCheck(slot);
if (result < 0) {
return CardSequence_813D32A8(slot, 0, result);
return reportCardThreadError(slot, 0, result);
}
OSReport("CardThread:Broken Card Repaired\n");
return 1;
}
reportError:
return CardSequence_813D32A8(slot, 0, result);
return reportCardThreadError(slot, 0, result);
}
extern "C" s32 CardSequence_813D32A8(s32 slot, s32 state, s32 result) {
extern "C" s32 reportCardThreadError(s32 slot, s32 state, s32 result) {
if (result != -7 && result != -27 && result != -8 && result != -9 &&
(CardSequence_813D33D8(slot), result != -6) && result != -13) {
(clearAllCardFileEntries(slot), result != -6) && result != -13) {
OSReport("DEBUG: UnmountCard %d \n", slot);
CARDUnmount(slot);
sThread->mounted[slot & 0xFF] = 0;
}
OSReport("DEBUG: CardThread error %d %d\n", state, result);
CardSequence_813D3140();
markAllCardFilesDirty();
OSSendMessage(&sThread->responses,
(OSMessage)(((slot & 1) << 16) | ((result & 0xFF) << 8) | (state & 0xFF)), 1);
return 0;
}
extern "C" void CardSequence_813D3380(s32 slot, s32 state, s32 fileNo) {
CardSequence_813D3140();
extern "C" void sendCardSlotState(s32 slot, s32 state, s32 fileNo) {
markAllCardFilesDirty();
OSMessageQueue* queue = &sThread->responses;
union CardThreadMessage {
u32 value;
@@ -683,15 +683,15 @@ extern "C" void CardSequence_813D3380(s32 slot, s32 state, s32 fileNo) {
OSSendMessage(queue, (OSMessage)message.value, 1);
}
extern "C" void CardSequence_813D33D8(s32 slot) {
extern "C" void clearAllCardFileEntries(s32 slot) {
s32 file = 0;
do {
CardSequence_813D2A74(slot, (s16)file);
clearCardFileEntry(slot, (s16)file);
file = file + 1;
} while (file < 0x7F);
}
extern "C" s32 CardSequence_813D3424(s32 slot, s32 fileNo, CARDDir* dir) {
extern "C" s32 loadCardFileIcons(s32 slot, s32 fileNo, CARDDir* dir) {
struct CardSequenceFileData {
s32 commentSectorSize;
s32 sectorSize;
@@ -922,11 +922,11 @@ closeFileSuccess:
return 0;
}
extern "C" void CardSequence_813D3C24(s32, s32) {
extern "C" void clearCardWritePending(s32, s32) {
sThread->writePending = 0;
}
extern "C" s32 CardSequence_813D3C38(s32 slot, s16 fileNo) {
extern "C" s32 checkCardFileDuplicate(s32 slot, s16 fileNo) {
CARDDir sourceDir;
CARDDir otherDir;
s32 result = __CARDGetStatusEx(slot, fileNo, &sourceDir);
@@ -950,7 +950,7 @@ extern "C" s32 CardSequence_813D3C38(s32 slot, s16 fileNo) {
return 0;
}
extern "C" void CardSequence_813D3D14(s32 slot, s16 fileNo, s32 command) {
extern "C" void runCardMoveOrCopy(s32 slot, s16 fileNo, s32 command) {
CARDDir createStatus;
CARDDir checkedStatus;
CARDDir ioStatus;
@@ -970,10 +970,10 @@ extern "C" void CardSequence_813D3D14(s32 slot, s16 fileNo, s32 command) {
s32 statusResult;
s32 stage;
result = CardSequence_813D3C38(slot, fileNo);
result = checkCardFileDuplicate(slot, fileNo);
if (result < 0) {
CardSequence_813D32A8(slot, command, result);
reportCardThreadError(slot, command, result);
goto finish;
}
@@ -999,7 +999,7 @@ sectorSizeCheck:
goto sectorSizeDone;
}
sectorSizeError:
CardSequence_813D32A8(slot, command, sectorError);
reportCardThreadError(slot, command, sectorError);
goto finish;
sectorSizeDone:
;
@@ -1023,7 +1023,7 @@ sectorSizeDone:
result = CARDGetResultCode(slot);
}
if (result < 0) {
CardSequence_813D32A8(slot, command, result);
reportCardThreadError(slot, command, result);
goto finish;
}
@@ -1056,7 +1056,7 @@ createDone:
;
}
if (destinationFileNo < 0) {
CardSequence_813D32A8(destinationSlot, command, destinationFileNo);
reportCardThreadError(destinationSlot, command, destinationFileNo);
goto finish;
}
@@ -1099,7 +1099,7 @@ createDone:
sThread->writePending = 1;
ioResult = CARDWriteAsync(&sThread->destinationFile,
sThread->transferBuffer, size, offset,
CardSequence_813D3C24);
clearCardWritePending);
if (ioResult < 0) {
goto copyIoFailure;
}
@@ -1176,7 +1176,7 @@ copyIoDone:
}
} else {
metadataCopied = TRUE;
result = CardSequence_813D3424(destinationSlot, destinationFileNo,
result = loadCardFileIcons(destinationSlot, destinationFileNo,
&sourceStatus);
if (result < 0) {
OSReport("Can't read icon for move dstfile\n");
@@ -1214,7 +1214,7 @@ copyIoDone:
s32 setResult = result;
if (result == -3) {
CARDFastDelete(slot, fileNo);
CardSequence_813D2A74(slot, fileNo);
clearCardFileEntry(slot, fileNo);
} else {
s32 restoreResult = __CARDSetStatusEx(slot, fileNo, &moveStatus);
if (restoreResult < 0) {
@@ -1227,13 +1227,13 @@ copyIoDone:
stage = 3;
result = CARDFastDelete(slot, fileNo);
if (result >= 0) {
CardSequence_813D2A74(slot, fileNo);
clearCardFileEntry(slot, fileNo);
stage = 4;
result = __CARDGetStatusEx(destinationSlot,
destinationFileNo, &moveStatus);
if (result >= 0) {
stage = 5;
if ((result = CardSequence_813D3424(
if ((result = loadCardFileIcons(
destinationSlot, destinationFileNo, &moveStatus)) < 0) {
goto moveStatusError;
}
@@ -1270,10 +1270,10 @@ moveStatusDone:
}
if (result >= 0) {
CardSequence_813D2B40(slot);
CardSequence_813D2B40(destinationSlot);
CardSequence_813D3380(slot, 0, fileNo & 0xFF);
CardSequence_813D3380(destinationSlot, command, destinationFileNo & 0xFF);
refreshCardSlotInfo(slot);
refreshCardSlotInfo(destinationSlot);
sendCardSlotState(slot, 0, fileNo & 0xFF);
sendCardSlotState(destinationSlot, command, destinationFileNo & 0xFF);
goto finish;
}
@@ -1281,7 +1281,7 @@ cleanup:
destinationSlot = slot ^ 1;
result = CARDGetResultCode(destinationSlot);
if (result < 0) {
CardSequence_813D32A8(destinationSlot, command, result);
reportCardThreadError(destinationSlot, command, result);
} else {
if (temporaryCreated && !metadataCopied) {
CARDFastDelete(destinationSlot, destinationFileNo);
@@ -1289,18 +1289,18 @@ cleanup:
if (metadataCopied) {
if (__CARDGetStatusEx(destinationSlot, destinationFileNo,
&createStatus) == 0) {
CardSequence_813D3424(destinationSlot, destinationFileNo, &createStatus);
loadCardFileIcons(destinationSlot, destinationFileNo, &createStatus);
}
}
CardSequence_813D2B40(destinationSlot);
CardSequence_813D3380(destinationSlot, 0, fileNo & 0xFF);
refreshCardSlotInfo(destinationSlot);
sendCardSlotState(destinationSlot, 0, fileNo & 0xFF);
}
result = CARDGetResultCode(slot);
if (result < 0) {
CardSequence_813D32A8(slot, command, result);
reportCardThreadError(slot, command, result);
} else {
CardSequence_813D2B40(slot);
CardSequence_813D3380(slot, 0, fileNo & 0xFF);
refreshCardSlotInfo(slot);
sendCardSlotState(slot, 0, fileNo & 0xFF);
}
finish:

View File

@@ -92,7 +92,7 @@ namespace ipl {
extern "C" void List_GetNth__Q24nw4r2utFPCQ34nw4r2ut4ListUs();
extern "C" void getChannelBasePane__Q33ipl5scene13ChannelSelectFi();
extern "C" void initPane__Q33ipl3gui11PaneManagerFPQ34nw4r3lyt4Pane();
extern "C" void* jumptable_8164DE80[];
extern "C" void* updateDiskState_jumptable[];
extern "C" void getCurrentChannel__Q33ipl7channel7ManagerFPiPi();
extern "C" void calcNormalRestart__Q33ipl5scene13ChannelSelectFv();
extern "C" void _savegpr_28();
@@ -857,7 +857,7 @@ namespace ipl {
extern "C" char scPaneName_N_GCIcon[] = "N_GCIcon";
extern "C" char scPaneName_N_DiscUpdateIcon[] = "N_DiscUpdateIcon";
extern "C" void* jumptable_8164DE80[7] = {
extern "C" void* updateDiskState_jumptable[7] = {
(void*)((const char*)updateDiskState__Q33ipl5scene13ChannelSelectFv + 0x4C),
(void*)((const char*)updateDiskState__Q33ipl5scene13ChannelSelectFv + 0x21C),
(void*)((const char*)updateDiskState__Q33ipl5scene13ChannelSelectFv + 0x284),
@@ -1346,18 +1346,18 @@ namespace ipl {
lwz r4, 0xa8(r28)
cmplwi r0, 0x6
lwz r27, 0x4(r4)
bgt updateDiskState_813AD2C8
lis r4, jumptable_8164DE80@ha
bgt updateDiskState_done
lis r4, updateDiskState_jumptable@ha
slwi r0, r0, 2
addi r4, r4, jumptable_8164DE80@l
addi r4, r4, updateDiskState_jumptable@l
lwzx r4, r4, r0
mtctr r4
bctr
updateDiskState_813ACF94:
updateDiskState_case0:
lwz r4, 0xa4(r3)
lwz r0, 0x14(r4)
cmpwi r0, 0x1
beq updateDiskState_813AD2C8
beq updateDiskState_done
lwz r3, 0x94(r3)
lis r29, scPaneName_N_GCIcon@ha
addi r4, r29, scPaneName_N_GCIcon@l
@@ -1381,7 +1381,7 @@ namespace ipl {
li r4, 0x0
bl SetVisible__Q34nw4r3lyt4PaneFb
cmpwi r27, 0x5
bne updateDiskState_813AD078
bne updateDiskState_case0_diskState3
lwz r4, 0xc0(r31)
lwz r3, 0x84(r28)
subi r4, r4, 0xf
@@ -1391,32 +1391,32 @@ namespace ipl {
lwz r0, 0xc0(r31)
mr r27, r3
cmpwi r0, 0xf
bne updateDiskState_813AD03C
bne updateDiskState_case0_afterThumb
lwz r3, 0xa8(r28)
addi r4, r31, 0xf8
addi r5, r31, 0xfc
bl getDiskInfo__Q33ipl3bs27ManagerFPPcPPc
updateDiskState_813AD03C:
updateDiskState_case0_afterThumb:
cmpwi r27, 0x0
beq updateDiskState_813AD050
beq updateDiskState_case0_afterLayout
lwz r3, 0x90(r31)
mr r4, r27
bl createDiskLayout__Q33ipl5scene10ChannelObjFPv
updateDiskState_813AD050:
updateDiskState_case0_afterLayout:
lbz r0, 0xf4(r31)
cmpwi r0, 0x0
bne updateDiskState_813AD064
bne updateDiskState_case0_afterDiskIn
mr r3, r31
bl startDiskInEvent__Q33ipl5scene13ChannelSelectFv
updateDiskState_813AD064:
updateDiskState_case0_afterDiskIn:
li r3, 0x0
li r0, 0x1
stb r3, 0xf4(r31)
stw r0, 0xf0(r31)
b updateDiskState_813AD2C8
updateDiskState_813AD078:
b updateDiskState_done
updateDiskState_case0_diskState3:
cmpwi r27, 0x3
bne updateDiskState_813AD134
bne updateDiskState_case0_diskState6
lwz r3, 0x84(r28)
li r0, 0x0
addi r4, r29, scPaneName_N_GCIcon@l
@@ -1444,7 +1444,7 @@ namespace ipl {
bl setLangPane__Q33ipl5scene10ChannelObjFPCQ33ipl6layout6Object
lwz r3, 0x98(r31)
cmpwi r3, 0x0
beq updateDiskState_813AD10C
beq updateDiskState_case0_state3_afterAnim
li r0, 0x2
stw r0, 0x18(r3)
lwz r28, 0x98(r31)
@@ -1452,45 +1452,45 @@ namespace ipl {
bl initFrame__Q33ipl7utility15FrameControllerFv
li r0, 0x1
stw r0, 0x14(r28)
updateDiskState_813AD10C:
updateDiskState_case0_state3_afterAnim:
lbz r0, 0xf4(r31)
cmpwi r0, 0x0
bne updateDiskState_813AD120
bne updateDiskState_case0_state3_afterDiskIn
mr r3, r31
bl startDiskInEvent__Q33ipl5scene13ChannelSelectFv
updateDiskState_813AD120:
updateDiskState_case0_state3_afterDiskIn:
li r3, 0x0
li r0, 0x1
stb r3, 0xf4(r31)
stw r0, 0xf0(r31)
b updateDiskState_813AD2C8
updateDiskState_813AD134:
b updateDiskState_done
updateDiskState_case0_diskState6:
cmpwi r27, 0x6
bne updateDiskState_813AD2C8
bne updateDiskState_done
lbz r0, 0xf4(r31)
cmpwi r0, 0x0
bne updateDiskState_813AD150
bne updateDiskState_case0_state6_afterDiskIn
mr r3, r31
bl startDiskInEvent__Q33ipl5scene13ChannelSelectFv
updateDiskState_813AD150:
updateDiskState_case0_state6_afterDiskIn:
li r3, 0x0
li r0, 0x4
stb r3, 0xf4(r31)
stw r0, 0xf0(r31)
b updateDiskState_813AD2C8
updateDiskState_813AD164:
b updateDiskState_done
updateDiskState_case1:
lwz r4, 0x8c(r3)
lwz r0, 0x14(r4)
cmpwi r0, 0x1
beq updateDiskState_813AD2C8
beq updateDiskState_done
lwz r3, 0x90(r3)
bl resetDiskTitleName__Q33ipl5scene10ChannelObjFv
cmpwi r27, 0x5
bne updateDiskState_813AD1C0
bne updateDiskState_case1_setState3
lwz r3, 0x90(r31)
lwz r3, 0x34(r3)
cmpwi r3, 0x0
beq updateDiskState_813AD1B4
beq updateDiskState_case1_setState2
li r0, 0x2
stw r0, 0x18(r3)
lwz r3, 0x90(r31)
@@ -1499,85 +1499,85 @@ namespace ipl {
bl initFrame__Q33ipl7utility15FrameControllerFv
li r0, 0x1
stw r0, 0x14(r27)
updateDiskState_813AD1B4:
updateDiskState_case1_setState2:
li r0, 0x2
stw r0, 0xf0(r31)
b updateDiskState_813AD2C8
updateDiskState_813AD1C0:
b updateDiskState_done
updateDiskState_case1_setState3:
li r0, 0x3
stw r0, 0xf0(r31)
b updateDiskState_813AD2C8
updateDiskState_813AD1CC:
b updateDiskState_done
updateDiskState_case2:
cmpwi r27, 0x5
bne updateDiskState_813AD1E4
bne updateDiskState_case2_doOut
lwz r4, 0x84(r28)
lbz r0, 0x1b81(r4)
cmpwi r0, 0x0
beq updateDiskState_813AD2C8
updateDiskState_813AD1E4:
beq updateDiskState_done
updateDiskState_case2_doOut:
lwz r3, 0xa0(r3)
lwz r0, 0x14(r3)
cmpwi r0, 0x1
beq updateDiskState_813AD2C8
beq updateDiskState_done
mr r3, r31
bl startDiskOutEvent__Q33ipl5scene13ChannelSelectFv
lwz r3, 0x90(r31)
bl changeDisk__Q33ipl5scene10ChannelObjFv
li r0, 0x6
stw r0, 0xf0(r31)
b updateDiskState_813AD2C8
updateDiskState_813AD210:
b updateDiskState_done
updateDiskState_case3:
cmpwi r27, 0x3
bne updateDiskState_813AD228
bne updateDiskState_case3_doOut
lwz r4, 0x84(r28)
lbz r0, 0x1b81(r4)
cmpwi r0, 0x0
beq updateDiskState_813AD2C8
updateDiskState_813AD228:
beq updateDiskState_done
updateDiskState_case3_doOut:
lwz r3, 0xa0(r3)
lwz r0, 0x14(r3)
cmpwi r0, 0x1
beq updateDiskState_813AD2C8
beq updateDiskState_done
mr r3, r31
bl startDiskOutEvent__Q33ipl5scene13ChannelSelectFv
lwz r3, 0x90(r31)
bl changeDisk__Q33ipl5scene10ChannelObjFv
li r0, 0x6
stw r0, 0xf0(r31)
b updateDiskState_813AD2C8
updateDiskState_813AD254:
b updateDiskState_done
updateDiskState_case4:
lwz r4, 0x8c(r3)
lwz r0, 0x14(r4)
cmpwi r0, 0x1
beq updateDiskState_813AD2C8
beq updateDiskState_done
li r0, 0x5
stw r0, 0xf0(r3)
b updateDiskState_813AD2C8
updateDiskState_813AD270:
b updateDiskState_done
updateDiskState_case5:
cmpwi r27, 0x6
beq updateDiskState_813AD2C8
beq updateDiskState_done
lwz r4, 0xa0(r3)
lwz r0, 0x14(r4)
cmpwi r0, 0x1
beq updateDiskState_813AD2C8
beq updateDiskState_done
bl startDiskOutEvent__Q33ipl5scene13ChannelSelectFv
lwz r3, 0x90(r31)
bl changeDisk__Q33ipl5scene10ChannelObjFv
li r0, 0x6
stw r0, 0xf0(r31)
b updateDiskState_813AD2C8
updateDiskState_813AD2A0:
b updateDiskState_done
updateDiskState_case6:
lwz r4, 0x8c(r3)
lwz r0, 0x14(r4)
cmpwi r0, 0x1
beq updateDiskState_813AD2C8
beq updateDiskState_done
lwz r3, 0x90(r3)
bl destroyDiskLayout__Q33ipl5scene10ChannelObjFv
lwz r3, 0x90(r31)
bl resetDiskTitleName__Q33ipl5scene10ChannelObjFv
li r0, 0x0
stw r0, 0xf0(r31)
updateDiskState_813AD2C8:
updateDiskState_done:
addi r11, r1, 0x20
bl _restgpr_27
lwz r0, 0x24(r1)

View File

@@ -11,7 +11,7 @@ struct MemoryCardSortEntry {
s64 key;
};
extern "C" int iplMemoryCardManager_813CD034(const void* first, const void* second) {
extern "C" int compareMemoryCardSortEntries(const void* first, const void* second) {
const MemoryCardSortEntry* a = static_cast<const MemoryCardSortEntry*>(first);
const MemoryCardSortEntry* b = static_cast<const MemoryCardSortEntry*>(second);
s64 bKey = b->key;
@@ -92,7 +92,7 @@ void MemoryCardManager::sort_file_array(u8 slot) {
mFile[slot][file].unk_0x08 = 0;
}
}
qsort(mFile[slot], 0x7f, sizeof(MCFile), iplMemoryCardManager_813CD034);
qsort(mFile[slot], 0x7f, sizeof(MCFile), compareMemoryCardSortEntries);
}
void MemoryCardManager::sendCardCmdMove(u8 slot, s16 index) {

View File

@@ -934,7 +934,7 @@ namespace ipl {
}
}
extern "C" bool iplSDMemory_813EE358(const SDMemory* memory,
extern "C" bool iplSDMemory_containsTitleId(const SDMemory* memory,
ESTitleId titleId,
const ESTitleId* titleIds, u32 titleCount) {
for (u32 i = 0; i < titleCount; i++) {
@@ -951,7 +951,7 @@ namespace ipl {
s32 result = mpSDChannelSelect->getWorker()->get_async_result();
if (result == 0) {
ESTitleId titleId = mTitleIds[mCurrentTitle];
if (iplSDMemory_813EE358(this, titleId,
if (iplSDMemory_containsTitleId(this, titleId,
mNandTitleIds, mNandTitleCount)) {
mDialogState = 17;
} else {
@@ -984,8 +984,8 @@ namespace ipl {
swprintf(mCurrentTitleName, 0x107f, L"%ls\n%ls", titleName, message);
System::getDialog()->setTitleForSDMemory(mCurrentTitleName);
if (iplSDMemory_813EE358(this, mTitleIds[mCurrentTitle], mSDTitleIds, mTitleNameCount) ||
iplSDMemory_813EE358(this, mTitleIds[mCurrentTitle], mNandTitleIds, mNandTitleCount)) {
if (iplSDMemory_containsTitleId(this, mTitleIds[mCurrentTitle], mSDTitleIds, mTitleNameCount) ||
iplSDMemory_containsTitleId(this, mTitleIds[mCurrentTitle], mNandTitleIds, mNandTitleCount)) {
ESTitleId titleId = mTitleIds[mCurrentTitle];
if (iplSDChannelSelect_813DB478(mpSDChannelSelect, titleId)) {
mDialogState = 14;
@@ -1064,7 +1064,7 @@ namespace ipl {
mCurrentTitle++;
if (mTitleCount > mCurrentTitle) {
ESTitleId nextTitleId = mTitleIds[mCurrentTitle];
if (iplSDMemory_813EE358(this, nextTitleId,
if (iplSDMemory_containsTitleId(this, nextTitleId,
mNandTitleIds, mNandTitleCount)) {
mDialogState = 17;
} else {

View File

@@ -49,42 +49,42 @@ namespace ipl {
};
static const f32 scThumbnailOffsets[][2] = {{64.0f, 48.0f}, {85.0f, 48.0f}};
extern "C" void iplSDChannelObj_813E3104(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_813E311C(SDChannelObj* channel, EGG::ExpHeap* firstHeap,
extern "C" void iplSDChannelObj_activateIfIdle(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_setHeaps(SDChannelObj* channel, EGG::ExpHeap* firstHeap,
EGG::ExpHeap* secondHeap) NO_INLINE;
extern "C" void* iplSDChannelObj_813E3128(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_813E3178(SDChannelObj* channel, nw4r::lyt::Pane* pane) NO_INLINE;
extern "C" void iplSDChannelObj_813E3180(SDChannelObj* channel, nand::LayoutFile* layoutFile) NO_INLINE;
extern "C" void iplSDChannelObj_813E322C(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_813E32C8(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_813E3304(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_813E330C(SDChannelObj* channel) NO_INLINE;
extern "C" bool iplSDChannelObj_813E3330(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_813E3354(SDChannelObj* channel, int request) NO_INLINE;
extern "C" void iplSDChannelObj_813E33EC(SDChannelObj* channel, int request) NO_INLINE;
extern "C" void iplSDChannelObj_813E3480(SDChannelObj* channel, bool request) NO_INLINE;
extern "C" void iplSDChannelObj_813E34E0(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_813E34E8(SDChannelObj* channel, int request) NO_INLINE;
extern "C" void iplSDChannelObj_813E3534(SDChannelObj* channel, bool request) NO_INLINE;
extern "C" void iplSDChannelObj_813E3580(const layout::Object* layout) NO_INLINE;
extern "C" void iplSDChannelObj_813E3858(SDChannelObj* channel) NO_INLINE;
extern "C" f32 iplSDChannelObj_813E3920(SDChannelObj* channel) NO_INLINE;
extern "C" f32 iplSDChannelObj_813E3A84(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_813E3B1C(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_813E3BA0(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_813E3C58(SDChannelObj* channel, const nw4r::math::VEC3& vec) NO_INLINE;
extern "C" void iplSDChannelObj_813E3C9C(SDChannelObj* channel, int request) NO_INLINE;
extern "C" void iplSDChannelObj_813E3E38(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_813E3F28(SDChannelObj* channel, int request) NO_INLINE;
extern "C" void iplSDChannelObj_813E3F74(SDChannelObj* channel) NO_INLINE;
extern "C" const wchar_t* iplSDChannelObj_813E4060(SDChannelObj* channel, int index) NO_INLINE;
extern "C" void iplSDChannelObj_813E413C(SDChannelObj* channel, const wchar_t* text) NO_INLINE;
extern "C" void iplSDChannelObj_813E4410(SDChannelObj* channel, const nw4r::math::VEC3& vec) NO_INLINE;
extern "C" void iplSDChannelObj_813E4558(SDChannelObj* channel, int request) NO_INLINE;
extern "C" void iplSDChannelObj_813E4704(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_813E481C(SDChannelObj* channel, layout::Object* layout) NO_INLINE;
extern "C" void iplSDChannelObj_813E49A8(SDChannelObj* channel) NO_INLINE;
extern "C" BOOL iplSDChannelObj_813E4A54(SDChannelObj* channel) NO_INLINE;
extern "C" void* iplSDChannelObj_getOrAllocThumbnailData(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_setPane(SDChannelObj* channel, nw4r::lyt::Pane* pane) NO_INLINE;
extern "C" void iplSDChannelObj_setLayoutFile(SDChannelObj* channel, nand::LayoutFile* layoutFile) NO_INLINE;
extern "C" void iplSDChannelObj_calc(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_drawBase(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_drawPage(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_drawDialog(SDChannelObj* channel) NO_INLINE;
extern "C" bool iplSDChannelObj_hasAppMeta(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_startAppear(SDChannelObj* channel, int request) NO_INLINE;
extern "C" void iplSDChannelObj_startDisappear(SDChannelObj* channel, int request) NO_INLINE;
extern "C" void iplSDChannelObj_setSelected(SDChannelObj* channel, bool request) NO_INLINE;
extern "C" void iplSDChannelObj_playPageHide(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_resetPageAnim(SDChannelObj* channel, int request) NO_INLINE;
extern "C" void iplSDChannelObj_resetDialogAnim(SDChannelObj* channel, bool request) NO_INLINE;
extern "C" void iplSDChannelObj_applyLanguageGroups(const layout::Object* layout) NO_INLINE;
extern "C" void iplSDChannelObj_createBaseLayout(SDChannelObj* channel) NO_INLINE;
extern "C" f32 iplSDChannelObj_createIconLayout(SDChannelObj* channel) NO_INLINE;
extern "C" f32 iplSDChannelObj_createMenuLayout(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_syncLayoutsToPane(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_createPageLayout(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_setPageTranslate(SDChannelObj* channel, const nw4r::math::VEC3& vec) NO_INLINE;
extern "C" void iplSDChannelObj_setPageAnim(SDChannelObj* channel, int request) NO_INLINE;
extern "C" void iplSDChannelObj_updatePageAnim(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_playPageAnimator(SDChannelObj* channel, int request) NO_INLINE;
extern "C" void iplSDChannelObj_createDialogLayout(SDChannelObj* channel) NO_INLINE;
extern "C" const wchar_t* iplSDChannelObj_getLocalizedName(SDChannelObj* channel, int index) NO_INLINE;
extern "C" void iplSDChannelObj_setBalloonText(SDChannelObj* channel, const wchar_t* text) NO_INLINE;
extern "C" void iplSDChannelObj_positionDialog(SDChannelObj* channel, const nw4r::math::VEC3& vec) NO_INLINE;
extern "C" void iplSDChannelObj_setDialogAnim(SDChannelObj* channel, int request) NO_INLINE;
extern "C" void iplSDChannelObj_updateDialogAnim(SDChannelObj* channel) NO_INLINE;
extern "C" void iplSDChannelObj_findNewMessageGroup(SDChannelObj* channel, layout::Object* layout) NO_INLINE;
extern "C" void iplSDChannelObj_updateNewMessage(SDChannelObj* channel) NO_INLINE;
extern "C" BOOL iplSDChannelObj_checkNewMessage(SDChannelObj* channel) NO_INLINE;
SDChannelObj::SDChannelObj(EGG::Heap* heap, int page, int index)
: mpHeap(heap), mpDialogHeap(NULL), mpChannelHeap(NULL), mState(0), mPage(page), mIndex(index),
@@ -112,42 +112,42 @@ namespace ipl {
if (mpDialogLayout != NULL)
delete mpDialogLayout;
}
extern "C" void iplSDChannelObj_813E3104(SDChannelObj* channel) {
extern "C" void iplSDChannelObj_activateIfIdle(SDChannelObj* channel) {
if (channel->mState == 0)
channel->mState = 2;
}
extern "C" void iplSDChannelObj_813E311C(SDChannelObj* channel, EGG::ExpHeap* firstHeap,
extern "C" void iplSDChannelObj_setHeaps(SDChannelObj* channel, EGG::ExpHeap* firstHeap,
EGG::ExpHeap* secondHeap) {
channel->mpDialogHeap = firstHeap;
channel->mpChannelHeap = secondHeap;
}
extern "C" void* iplSDChannelObj_813E3128(SDChannelObj* channel) {
extern "C" void* iplSDChannelObj_getOrAllocThumbnailData(SDChannelObj* channel) {
if (channel->mpThumbnailData == NULL)
channel->mpThumbnailData = new (channel->mpHeap, 32) u8[0x19000];
return channel->mpThumbnailData;
}
extern "C" void iplSDChannelObj_813E3178(SDChannelObj* channel, nw4r::lyt::Pane* pane) {
extern "C" void iplSDChannelObj_setPane(SDChannelObj* channel, nw4r::lyt::Pane* pane) {
channel->mpPane = pane;
}
extern "C" void iplSDChannelObj_813E3180(SDChannelObj* channel, nand::LayoutFile* layoutFile) {
extern "C" void iplSDChannelObj_setLayoutFile(SDChannelObj* channel, nand::LayoutFile* layoutFile) {
if (!SDChannelSelect::isChannelReady(channel)) {
channel->mpLayoutFile = layoutFile;
if (channel->mpPageLayout == NULL)
iplSDChannelObj_813E3BA0(channel);
iplSDChannelObj_createPageLayout(channel);
if (channel->mpDialogLayout == NULL)
iplSDChannelObj_813E3F74(channel);
iplSDChannelObj_createDialogLayout(channel);
if (channel->mState == 2 || channel->mState == 1 && channel->mpPaneAnimator->isFinished()) {
iplSDChannelObj_813E3858(channel);
iplSDChannelObj_createBaseLayout(channel);
channel->mState = 3;
}
}
}
extern "C" void iplSDChannelObj_813E322C(SDChannelObj* channel) {
extern "C" void iplSDChannelObj_calc(SDChannelObj* channel) {
switch (channel->mState) {
case 0:
channel->mState = 2;
@@ -157,25 +157,25 @@ namespace ipl {
break;
channel->mState = 2;
case 2:
iplSDChannelObj_813E3858(channel);
iplSDChannelObj_createBaseLayout(channel);
channel->mState = 3;
break;
case 3:
iplSDChannelObj_813E3B1C(channel);
iplSDChannelObj_syncLayoutsToPane(channel);
break;
}
}
extern "C" void iplSDChannelObj_813E32C8(SDChannelObj* channel) {
extern "C" void iplSDChannelObj_drawBase(SDChannelObj* channel) {
if (SDChannelSelect::isChannelReady(channel))
channel->mpBaseLayout->draw();
}
extern "C" void iplSDChannelObj_813E3304(SDChannelObj* channel) {
extern "C" void iplSDChannelObj_drawPage(SDChannelObj* channel) {
channel->mpPageLayout->draw();
}
extern "C" void iplSDChannelObj_813E330C(SDChannelObj* channel) {
extern "C" void iplSDChannelObj_drawDialog(SDChannelObj* channel) {
if (channel->mpDialogLayout != NULL)
channel->mpDialogLayout->draw();
}
@@ -184,14 +184,14 @@ namespace ipl {
return (nw4r::math::VEC3&)mpBaseLayout->GetRootPane()->GetTranslate();
}
extern "C" bool iplSDChannelObj_813E3330(SDChannelObj* channel) {
extern "C" bool iplSDChannelObj_hasAppMeta(SDChannelObj* channel) {
if (channel->mStateFlags == 0 || channel->mStateFlags == 3)
return true;
else
return false;
}
extern "C" void iplSDChannelObj_813E3354(SDChannelObj* channel, int request) {
extern "C" void iplSDChannelObj_startAppear(SDChannelObj* channel, int request) {
if (request & 0x10000U) {
channel->mAnimationState = 0;
} else if (request & 0x20000U) {
@@ -201,14 +201,14 @@ namespace ipl {
}
if (!(request & 1)) {
iplSDChannelObj_813E3C9C(channel, 1);
iplSDChannelObj_setPageAnim(channel, 1);
}
if (!(request & 2)) {
iplSDChannelObj_813E4558(channel, 1);
iplSDChannelObj_setDialogAnim(channel, 1);
}
}
extern "C" void iplSDChannelObj_813E33EC(SDChannelObj* channel, int request) {
extern "C" void iplSDChannelObj_startDisappear(SDChannelObj* channel, int request) {
if (request & 0x10000U) {
channel->mAnimationState = 0;
} else if (request & 0x20000U) {
@@ -218,44 +218,44 @@ namespace ipl {
}
if (!(request & 1)) {
iplSDChannelObj_813E3C9C(channel, 3);
iplSDChannelObj_setPageAnim(channel, 3);
}
if (!(request & 2)) {
iplSDChannelObj_813E4558(channel, 4);
iplSDChannelObj_setDialogAnim(channel, 4);
}
}
extern "C" void iplSDChannelObj_813E3480(SDChannelObj* channel, bool request) {
extern "C" void iplSDChannelObj_setSelected(SDChannelObj* channel, bool request) {
if (request) {
iplSDChannelObj_813E3C9C(channel, 1);
iplSDChannelObj_setPageAnim(channel, 1);
channel->mAnimationState = 1;
} else {
iplSDChannelObj_813E3C9C(channel, 0);
iplSDChannelObj_setPageAnim(channel, 0);
channel->mAnimationState = 0;
}
iplSDChannelObj_813E4558(channel, 0);
iplSDChannelObj_setDialogAnim(channel, 0);
}
extern "C" void iplSDChannelObj_813E34E0(SDChannelObj* channel) {
iplSDChannelObj_813E3C9C(channel, 4);
extern "C" void iplSDChannelObj_playPageHide(SDChannelObj* channel) {
iplSDChannelObj_setPageAnim(channel, 4);
}
extern "C" void iplSDChannelObj_813E34E8(SDChannelObj* channel, int request) {
iplSDChannelObj_813E3C9C(channel, 0);
extern "C" void iplSDChannelObj_resetPageAnim(SDChannelObj* channel, int request) {
iplSDChannelObj_setPageAnim(channel, 0);
if (request) {
channel->mAnimationState = 0;
}
}
extern "C" void iplSDChannelObj_813E3534(SDChannelObj* channel, bool request) {
iplSDChannelObj_813E4558(channel, 0);
extern "C" void iplSDChannelObj_resetDialogAnim(SDChannelObj* channel, bool request) {
iplSDChannelObj_setDialogAnim(channel, 0);
if (request) {
channel->mAnimationState = 0;
}
}
extern "C" void iplSDChannelObj_813E3580(const layout::Object* layout) {
extern "C" void iplSDChannelObj_applyLanguageGroups(const layout::Object* layout) {
int lang = System::getLanguage();
const char* langGroup = scLangGroups[lang];
char availableLanguages[10][4] = {};
@@ -319,18 +319,18 @@ namespace ipl {
}
}
extern "C" void iplSDChannelObj_813E3858(SDChannelObj* channel) {
extern "C" void iplSDChannelObj_createBaseLayout(SDChannelObj* channel) {
bool adjust = false;
if (channel->mpDialogLayout == NULL)
iplSDChannelObj_813E3F74(channel);
iplSDChannelObj_createDialogLayout(channel);
f32 frame;
if (iplSDChannelObj_813E3330(channel))
frame = iplSDChannelObj_813E3920(channel);
if (iplSDChannelObj_hasAppMeta(channel))
frame = iplSDChannelObj_createIconLayout(channel);
else {
frame = iplSDChannelObj_813E3A84(channel);
frame = iplSDChannelObj_createMenuLayout(channel);
adjust = true;
}
iplSDChannelObj_813E3B1C(channel);
iplSDChannelObj_syncLayoutsToPane(channel);
if (channel->mpBaseAnimator != NULL)
channel->mpBaseAnimator->play();
channel->mpBaseLayout->finishBinding();
@@ -340,11 +340,11 @@ namespace ipl {
channel->mpBaseLayout->adjustHeap();
}
extern "C" f32 iplSDChannelObj_813E3920(SDChannelObj* channel) {
extern "C" f32 iplSDChannelObj_createIconLayout(SDChannelObj* channel) {
f32 frame = 0.0f;
channel->mpBaseLayout =
layout::Object::create(channel->mpHeap, 0x8000, channel->mpThumbnailData, "arc", "icon.brlyt");
iplSDChannelObj_813E3580(channel->mpBaseLayout);
iplSDChannelObj_applyLanguageGroups(channel->mpBaseLayout);
if (channel->mpBaseLayout->searchFile("icon.brlan"))
channel->mpBaseAnimator = channel->mpBaseLayout->bind("icon.brlan");
else if (channel->mpBaseLayout->searchFile("icon_Whole.brlan"))
@@ -357,30 +357,30 @@ namespace ipl {
frame = minimum + (System::getRndm()->get_u16() % (u16)(maximum - minimum));
}
if (channel->mStateFlags == 0) {
iplSDChannelObj_813E481C(channel, channel->mpBaseLayout);
iplSDChannelObj_findNewMessageGroup(channel, channel->mpBaseLayout);
channel->mNewMessageState = 1;
}
return frame;
}
extern "C" f32 iplSDChannelObj_813E3A84(SDChannelObj* channel) {
extern "C" f32 iplSDChannelObj_createMenuLayout(SDChannelObj* channel) {
channel->mpBaseLayout =
layout::Object::create(channel->mpHeap, 0x8000, channel->mpLayoutFile, "arc", "mn_SdcardMenu_d.brlyt");
channel->mpBaseAnimator = channel->mpBaseLayout->bind("mn_SdcardMenu_d.brlan");
return System::getRndm()->get_u16() % 2000;
}
extern "C" void iplSDChannelObj_813E3B1C(SDChannelObj* channel) {
iplSDChannelObj_813E49A8(channel);
extern "C" void iplSDChannelObj_syncLayoutsToPane(SDChannelObj* channel) {
iplSDChannelObj_updateNewMessage(channel);
nw4r::math::VEC3 position(0, 0, 0);
MTXMultVec(channel->mpPane->GetGlobalMtx(), position, position);
channel->mpBaseLayout->GetRootPane()->SetTranslate(position);
channel->mpBaseLayout->calc();
iplSDChannelObj_813E3C58(channel, position);
iplSDChannelObj_813E4410(channel, position);
iplSDChannelObj_setPageTranslate(channel, position);
iplSDChannelObj_positionDialog(channel, position);
}
extern "C" void iplSDChannelObj_813E3BA0(SDChannelObj* channel) {
extern "C" void iplSDChannelObj_createPageLayout(SDChannelObj* channel) {
channel->mpPageLayout = new (channel->mpDialogHeap, 4)
layout::Object(channel->mpDialogHeap, channel->mpLayoutFile, "arc", "my_IplTop_d.brlyt");
@@ -388,17 +388,17 @@ namespace ipl {
channel->mpPageAnimators[i] = channel->mpPageLayout->bind(scCursorAnims[i], scCursur, false);
}
iplSDChannelObj_813E3C9C(channel, 0);
iplSDChannelObj_setPageAnim(channel, 0);
channel->mpPageLayout->finishBinding();
}
extern "C" void iplSDChannelObj_813E3C58(SDChannelObj* channel, const nw4r::math::VEC3& vec) {
extern "C" void iplSDChannelObj_setPageTranslate(SDChannelObj* channel, const nw4r::math::VEC3& vec) {
channel->mpPageLayout->GetRootPane()->SetTranslate(vec);
iplSDChannelObj_813E3E38(channel);
iplSDChannelObj_updatePageAnim(channel);
channel->mpPageLayout->calc();
}
extern "C" void iplSDChannelObj_813E3C9C(SDChannelObj* channel, int request) {
extern "C" void iplSDChannelObj_setPageAnim(SDChannelObj* channel, int request) {
if (request == 0) {
channel->mPageAnimation = 0;
channel->mPageAnimationFrame = 0;
@@ -413,14 +413,14 @@ namespace ipl {
channel->mPageAnimation = 4;
channel->mPageAnimationFrame = 0;
channel->mpPageLayout->GetRootPane()->SetVisible(true);
iplSDChannelObj_813E3F28(channel, 2);
iplSDChannelObj_playPageAnimator(channel, 2);
} else {
switch (channel->mPageAnimation) {
case 0: {
if (request == 1) {
channel->mPageAnimation = 1;
channel->mpPageLayout->GetRootPane()->SetVisible(true);
iplSDChannelObj_813E3F28(channel, 1);
iplSDChannelObj_playPageAnimator(channel, 1);
}
break;
}
@@ -437,7 +437,7 @@ namespace ipl {
case 2: {
if (request == 3) {
channel->mPageAnimation = 3;
iplSDChannelObj_813E3F28(channel, 0);
iplSDChannelObj_playPageAnimator(channel, 0);
}
break;
}
@@ -453,7 +453,7 @@ namespace ipl {
}
}
extern "C" void iplSDChannelObj_813E3E38(SDChannelObj* channel) {
extern "C" void iplSDChannelObj_updatePageAnim(SDChannelObj* channel) {
switch (channel->mPageAnimation) {
case 1: {
if (!channel->mpPageAnimators[1]->isPlaying()) {
@@ -472,7 +472,7 @@ namespace ipl {
break;
}
if (prev == 3) {
iplSDChannelObj_813E3C9C(channel, 3);
iplSDChannelObj_setPageAnim(channel, 3);
channel->mPageAnimationFrame = 0;
}
}
@@ -481,46 +481,46 @@ namespace ipl {
case 3: {
if (!channel->mpPageAnimators[0]->isPlaying()) {
int prev = channel->mPageAnimationFrame;
iplSDChannelObj_813E3C9C(channel, 0);
iplSDChannelObj_setPageAnim(channel, 0);
if (prev == 1) {
iplSDChannelObj_813E3C9C(channel, 1);
iplSDChannelObj_setPageAnim(channel, 1);
}
}
break;
}
case 4: {
if (!channel->mpPageAnimators[2]->isPlaying()) {
iplSDChannelObj_813E3C9C(channel, 0);
iplSDChannelObj_setPageAnim(channel, 0);
}
break;
}
}
}
extern "C" void iplSDChannelObj_813E3F28(SDChannelObj* channel, int request) {
extern "C" void iplSDChannelObj_playPageAnimator(SDChannelObj* channel, int request) {
channel->mpPageAnimators[request]->setAnmType(ANIM_TYPE_FORWARD);
channel->mpPageAnimators[request]->play();
}
extern "C" void iplSDChannelObj_813E3F74(SDChannelObj* channel) {
if (!iplSDChannelObj_813E3330(channel)) {
extern "C" void iplSDChannelObj_createDialogLayout(SDChannelObj* channel) {
if (!iplSDChannelObj_hasAppMeta(channel)) {
channel->mpDialogLayout = NULL;
return;
}
channel->mpDialogLayout = new (channel->mpChannelHeap, 4)
layout::Object(channel->mpChannelHeap, channel->mpLayoutFile, "arc", "my_IplTopBalloon_a.brlyt");
if (channel->mStateFlags == 0)
iplSDChannelObj_813E413C(channel, iplSDChannelObj_813E4060(channel, 0));
iplSDChannelObj_setBalloonText(channel, iplSDChannelObj_getLocalizedName(channel, 0));
else if (channel->mStateFlags == 3)
iplSDChannelObj_813E413C(channel, scUnknownName);
iplSDChannelObj_setBalloonText(channel, scUnknownName);
else
iplSDChannelObj_813E413C(channel, L"");
iplSDChannelObj_setBalloonText(channel, L"");
channel->mpDialogAnimator = channel->mpDialogLayout->bind("my_IplTopBalloon_a_BalloonInOut.brlan");
iplSDChannelObj_813E4558(channel, 0);
iplSDChannelObj_setDialogAnim(channel, 0);
channel->mpDialogLayout->finishBinding();
}
extern "C" const wchar_t* iplSDChannelObj_813E4060(SDChannelObj* channel, int index) {
extern "C" const wchar_t* iplSDChannelObj_getLocalizedName(SDChannelObj* channel, int index) {
if (channel->mAppMeta.metaHdr.names[System::getLanguage()][index][0] != 0)
return channel->mAppMeta.metaHdr.names[System::getLanguage()][index];
const u32* languages = scLangLookup[System::getRegion()];
@@ -533,7 +533,7 @@ namespace ipl {
return channel->mAppMeta.metaHdr.names[languages[0]][index];
}
extern "C" void iplSDChannelObj_813E413C(SDChannelObj* channel, const wchar_t* text) {
extern "C" void iplSDChannelObj_setBalloonText(SDChannelObj* channel, const wchar_t* text) {
nw4r::lyt::TextBox* textPane =
nw4r::ut::DynamicCast<nw4r::lyt::TextBox*>(channel->mpDialogLayout->FindPaneByName(scBalloon));
@@ -585,7 +585,7 @@ namespace ipl {
channel->mpDialogLayout->FindPaneByName(scBase)->SetSize(newSize);
}
extern "C" void iplSDChannelObj_813E4410(SDChannelObj* channel, const nw4r::math::VEC3& vec) {
extern "C" void iplSDChannelObj_positionDialog(SDChannelObj* channel, const nw4r::math::VEC3& vec) {
if (channel->mpDialogLayout != NULL) {
nw4r::lyt::Size size;
@@ -611,12 +611,12 @@ namespace ipl {
const nw4r::math::VEC3 pos(vec.x + horizontalOffset, vec.y + verticalOffset, 0.0f);
channel->mpDialogLayout->GetRootPane()->SetTranslate(pos);
iplSDChannelObj_813E4704(channel);
iplSDChannelObj_updateDialogAnim(channel);
channel->mpDialogLayout->calc();
}
}
extern "C" void iplSDChannelObj_813E4558(SDChannelObj* channel, int request) {
extern "C" void iplSDChannelObj_setDialogAnim(SDChannelObj* channel, int request) {
if (channel->mpDialogLayout != NULL) {
if (request == 0) {
channel->mDialogState = 0;
@@ -676,11 +676,11 @@ namespace ipl {
}
}
extern "C" void iplSDChannelObj_813E4704(SDChannelObj* channel) {
extern "C" void iplSDChannelObj_updateDialogAnim(SDChannelObj* channel) {
switch (channel->mDialogState) {
case 1: {
if ((reinterpret_cast<u32&>(channel->mDialogTimer) += 1) >= 20.0f) {
iplSDChannelObj_813E4558(channel, 2);
iplSDChannelObj_setDialogAnim(channel, 2);
break;
}
}
@@ -690,9 +690,9 @@ namespace ipl {
case 2: {
if (!channel->mpDialogLayout->isPlaying(0)) {
int prev = channel->mDialogFrame;
iplSDChannelObj_813E4558(channel, 3);
iplSDChannelObj_setDialogAnim(channel, 3);
if (prev == 4) {
iplSDChannelObj_813E4558(channel, 4);
iplSDChannelObj_setDialogAnim(channel, 4);
channel->mDialogFrame = 0;
}
}
@@ -701,9 +701,9 @@ namespace ipl {
case 4: {
if (!channel->mpDialogLayout->isPlaying(0)) {
int prev = channel->mDialogFrame;
iplSDChannelObj_813E4558(channel, 0);
iplSDChannelObj_setDialogAnim(channel, 0);
if (prev == 1) {
iplSDChannelObj_813E4558(channel, 1);
iplSDChannelObj_setDialogAnim(channel, 1);
}
}
break;
@@ -711,7 +711,7 @@ namespace ipl {
}
}
extern "C" void iplSDChannelObj_813E481C(SDChannelObj* channel, layout::Object* layout) {
extern "C" void iplSDChannelObj_findNewMessageGroup(SDChannelObj* channel, layout::Object* layout) {
char groupName[20];
char** lookup;
nw4r::lyt::Group* group;
@@ -752,11 +752,11 @@ namespace ipl {
}
}
extern "C" void iplSDChannelObj_813E49A8(SDChannelObj* channel) {
extern "C" void iplSDChannelObj_updateNewMessage(SDChannelObj* channel) {
if (System::getNwc24Manager() != NULL) {
switch (channel->mNewMessageState) {
case 1: {
if (iplSDChannelObj_813E4A54(channel)) {
if (iplSDChannelObj_checkNewMessage(channel)) {
channel->mNewMessageState = 2;
channel->mNewMessageFrame = 0;
}
@@ -772,7 +772,7 @@ namespace ipl {
}
}
extern "C" BOOL iplSDChannelObj_813E4A54(SDChannelObj* channel) {
extern "C" BOOL iplSDChannelObj_checkNewMessage(SDChannelObj* channel) {
if (System::getNwc24Manager() == NULL || !System::getNwc24Manager()->getNewTitleTbl(NULL)) {
return FALSE;
}

View File

@@ -107,13 +107,8 @@ namespace ipl {
extern "C" bool iplSDChannelSelect_813DD240(
SDChannelSelect* scene, const s32* requiredBytes, const s32* requiredBlocks,
ESTitleId* titleIds, char* titleNames, u32* titleCount);
extern "C" void iplSDChannelObj_813E3534(SDChannelObj* channel, int enabled);
extern "C" void iplSDChannelObj_resetDialogAnim(SDChannelObj* channel, int enabled);
SDChannelSelect::SDChannelSelect(EGG::Heap* heap)
: FaderSceneBase(heap),
@@ -213,7 +208,7 @@ namespace ipl {
SDChannelObj* channel = NULL;
while (channel = static_cast<SDChannelObj*>(nw4r::ut::List_GetNext(&mChannelObjects, channel)),
channel != NULL) {
iplSDChannelObj_813E3104(channel);
iplSDChannelObj_activateIfIdle(channel);
}
}
@@ -602,7 +597,7 @@ namespace ipl {
mpCurrentLoadedChannel = loadedChannel;
mpSDWorker->get_sd_app_meta_async(
static_cast<ESTitleId32>(notice.titleId),
static_cast<u8*>(iplSDChannelObj_813E3128(loadedChannel)),
static_cast<u8*>(iplSDChannelObj_getOrAllocThumbnailData(loadedChannel)),
&loadedChannel->mAppMeta);
mWorkerCommand = 3;
}
@@ -845,9 +840,9 @@ namespace ipl {
SDChannelObj* completed = mpCurrentLoadedChannel;
completed->mStateFlags = 0;
completed->mState = 2;
DCFlushRange(iplSDChannelObj_813E3128(mpCurrentLoadedChannel), 0x19000);
DCFlushRange(iplSDChannelObj_getOrAllocThumbnailData(mpCurrentLoadedChannel), 0x19000);
} else {
memcpy(iplSDChannelObj_813E3128(mpCurrentLoadedChannel),
memcpy(iplSDChannelObj_getOrAllocThumbnailData(mpCurrentLoadedChannel),
mpCorruptIconFile->getBuffer(), mpCorruptIconFile->getLength());
memset(&mpCurrentLoadedChannel->mAppMeta, 0, sizeof(mpCurrentLoadedChannel->mAppMeta));
SDChannelObj* completed = mpCurrentLoadedChannel;
@@ -1835,9 +1830,9 @@ namespace ipl {
int channelIndex = channel->getIndex();
if (channelPage == mCurrentPage) {
if (mState != 5 || channelIndex != mCurrentChannelIndex) {
iplSDChannelObj_813E34E8(channel, 1);
iplSDChannelObj_resetPageAnim(channel, 1);
}
iplSDChannelObj_813E3534(channel, 1);
iplSDChannelObj_resetDialogAnim(channel, 1);
}
}
@@ -2059,19 +2054,19 @@ namespace ipl {
}
void SDChannelSelect::updateChannelObject(SDChannelObj* channel) {
iplSDChannelObj_813E3104(channel);
iplSDChannelObj_813E311C(channel, mpDialogHeap, mpChannelHeap);
iplSDChannelObj_813E3178(channel,
iplSDChannelObj_activateIfIdle(channel);
iplSDChannelObj_setHeaps(channel, mpDialogHeap, mpChannelHeap);
iplSDChannelObj_setPane(channel,
getChannelBasePane(channel->getPage(), channel->getIndex(),
mCurrentPage));
iplSDChannelObj_813E3180(channel, mpLayoutFile);
iplSDChannelObj_setLayoutFile(channel, mpLayoutFile);
}
void SDChannelSelect::calcChannelObjects() {
SDChannelObj* channel = NULL;
while (channel = static_cast<SDChannelObj*>(nw4r::ut::List_GetNext(&mChannelObjects, channel)),
channel != NULL) {
iplSDChannelObj_813E322C(channel);
iplSDChannelObj_calc(channel);
}
}
@@ -2086,9 +2081,9 @@ namespace ipl {
}
setChannelScissor(channel);
iplSDChannelObj_813E32C8(channel);
iplSDChannelObj_drawBase(channel);
if (iplSDChannelObj_813E3330(channel)) {
if (iplSDChannelObj_hasAppMeta(channel)) {
switch (mState) {
case 15:
case 16:
@@ -2154,7 +2149,7 @@ namespace ipl {
while (channel = static_cast<SDChannelObj*>(nw4r::ut::List_GetNext(&mChannelObjects, channel)),
channel != NULL) {
if (hasChannelObject(channel->getPage(), channel->getIndex())) {
iplSDChannelObj_813E3304(channel);
iplSDChannelObj_drawPage(channel);
}
}
@@ -2162,7 +2157,7 @@ namespace ipl {
while (channel = static_cast<SDChannelObj*>(nw4r::ut::List_GetNext(&mChannelObjects, channel)),
channel != NULL) {
if (hasChannelObject(channel->getPage(), channel->getIndex())) {
iplSDChannelObj_813E330C(channel);
iplSDChannelObj_drawDialog(channel);
}
}
}
@@ -2296,7 +2291,7 @@ namespace ipl {
nw4r::ut::List_GetNext(&mChannelObjects, channel)),
channel != NULL) {
int titleIndex = channel->getPage() * MAX_CHANNEL_INDEX + channel->getIndex();
if (!iplSDChannelObj_813E3330(channel) && mpChannelTitleIds[titleIndex] != 0 &&
if (!iplSDChannelObj_hasAppMeta(channel) && mpChannelTitleIds[titleIndex] != 0 &&
mbNeedsRefresh) {
channel->mStateFlags = 2;
}
@@ -2391,7 +2386,7 @@ namespace ipl {
while (channel = static_cast<SDChannelObj*>(
nw4r::ut::List_GetNext(&mChannelObjects, channel)),
channel != NULL) {
if (iplSDChannelObj_813E3330(channel)) {
if (iplSDChannelObj_hasAppMeta(channel)) {
SDChannelObj* previous = static_cast<SDChannelObj*>(
nw4r::ut::List_GetPrev(&mChannelObjects, channel));
nw4r::ut::List_Remove(&mChannelObjects, channel);
@@ -2418,7 +2413,7 @@ namespace ipl {
nw4r::ut::List_GetNext(&mChannelObjects, channel)),
channel != NULL) {
int channelIndex = channel->mPage * 12 + channel->mIndex;
if (!iplSDChannelObj_813E3330(channel) &&
if (!iplSDChannelObj_hasAppMeta(channel) &&
mpChannelTitleIds[channelIndex] != 0) {
channel->mStateFlags = 2;
}
@@ -2634,7 +2629,7 @@ namespace ipl {
initPageAnimations(
math::VEC3((nw4r::math::VEC3&)channel->mpBaseLayout->GetRootPane()->GetTranslate()),
0);
iplSDChannelObj_813E34E0(channel);
iplSDChannelObj_playPageHide(channel);
SDButton* button = static_cast<SDButton*>(System::getSceneManager()->getScene(0x24));
if (mbLeftArrowVisible) {
@@ -2982,7 +2977,7 @@ namespace ipl {
while (channel = static_cast<SDChannelObj*>(
nw4r::ut::List_GetNext(&mChannelObjects, channel)),
channel != NULL) {
iplSDChannelObj_813E34E8(channel, 1);
iplSDChannelObj_resetPageAnim(channel, 1);
}
for (int index = 0; index < MAX_CHANNEL_INDEX; ++index) {
@@ -3004,7 +2999,7 @@ namespace ipl {
while (channel = static_cast<SDChannelObj*>(
nw4r::ut::List_GetNext(&mChannelObjects, channel)),
channel != NULL) {
iplSDChannelObj_813E34E8(channel, 1);
iplSDChannelObj_resetPageAnim(channel, 1);
}
for (int index = 0; index < MAX_CHANNEL_INDEX; ++index) {
@@ -3066,10 +3061,10 @@ namespace ipl {
} else {
SDChannelObj* destination = findChannelObject(mDestinationPage, mDestinationIndex);
iplSDChannelObj_813E3178(
iplSDChannelObj_setPane(
static_cast<SDChannelObj*>(mpCurrentChannel),
getChannelBasePane(mDestinationPage, mDestinationIndex, mCurrentPage));
iplSDChannelObj_813E3178(
iplSDChannelObj_setPane(
destination, getChannelBasePane(mSourcePage, mSourceIndex, mCurrentPage));
SDChannelObj* current;
@@ -3083,8 +3078,8 @@ namespace ipl {
destination->mPage = sourcePage;
destination->mIndex = sourceIndex;
iplSDChannelObj_813E322C(static_cast<SDChannelObj*>(mpCurrentChannel));
iplSDChannelObj_813E322C(destination);
iplSDChannelObj_calc(static_cast<SDChannelObj*>(mpCurrentChannel));
iplSDChannelObj_calc(destination);
mpCurrentChannel = transitionAnimator;
destination->mpBaseAnimator->setCurrentFrame(mpHelpLayout->getCurrentFrame());
@@ -3208,7 +3203,7 @@ namespace ipl {
if (isChannelMoveTarget(mCurrentPage, index) ||
(mCurrentPage == mSourcePage && index == mSourceIndex)) {
SDChannelObj* channel = findChannelObject(mCurrentPage, index);
iplSDChannelObj_813E3354(channel, 2);
iplSDChannelObj_startAppear(channel, 2);
snd::getSystem()->startSE("WIPL_SE_CH_TARGETTING");
controller->rumble(1);
}
@@ -3217,7 +3212,7 @@ namespace ipl {
if (isChannelMoveTarget(mCurrentPage, index) ||
(mCurrentPage == mSourcePage && index == mSourceIndex)) {
SDChannelObj* channel = findChannelObject(mCurrentPage, index);
iplSDChannelObj_813E33EC(channel, 2);
iplSDChannelObj_startDisappear(channel, 2);
}
break;
default:
@@ -3297,7 +3292,7 @@ namespace ipl {
int channelPage = channel->getPage();
int channelIndex = channel->getIndex();
bool selected = channelPage == page && channelIndex == index;
iplSDChannelObj_813E3480(channel, selected);
iplSDChannelObj_setSelected(channel, selected);
}
snd::getSystem()->startSEwithPos("WIPL_SE_CH_HOLD", mPointerPosition.x);
@@ -3333,7 +3328,7 @@ namespace ipl {
SDChannelObj* channel = NULL;
while (channel = static_cast<SDChannelObj*>(nw4r::ut::List_GetNext(&mChannelObjects, channel)),
channel != NULL) {
iplSDChannelObj_813E34E8(channel, 1);
iplSDChannelObj_resetPageAnim(channel, 1);
}
for (int index = 0; index < MAX_CHANNEL_INDEX; ++index) {
@@ -3432,14 +3427,14 @@ namespace ipl {
break;
case ::gui::EventHandler::ON_POINT:
if (mpScene->mState == 1 && SDChannelSelect::isChannelReady(channel)) {
iplSDChannelObj_813E3354(channel, 0);
iplSDChannelObj_startAppear(channel, 0);
snd::getSystem()->startSE("WIPL_SE_CH_TARGETTING");
controller->rumble(1);
}
break;
case ::gui::EventHandler::ON_LEFT:
if (mpScene->mState == 1 && SDChannelSelect::isChannelReady(channel)) {
iplSDChannelObj_813E33EC(channel, 0);
iplSDChannelObj_startDisappear(channel, 0);
}
break;
}

View File

@@ -134,8 +134,8 @@ public:
SDChannelTitle* mpScene;
};
extern "C" void iplSDChannelObj_813E3580(layout::Object* layout);
extern "C" const wchar_t* iplSDChannelObj_813E4060(SDChannelObj* channel, int nameIndex);
extern "C" void iplSDChannelObj_applyLanguageGroups(layout::Object* layout);
extern "C" const wchar_t* iplSDChannelObj_getLocalizedName(SDChannelObj* channel, int nameIndex);
extern "C" bool iplSDChannelTitle_startZoomFade(SDChannelTitle* scene);
extern "C" void iplSDChannelTitle_rebuildBannerLayout(SDChannelTitle* scene);
extern "C" void iplSDChannelTitle_setPaneMessage(SDChannelTitle* scene, nw4r::lyt::Pane* pane, u32 message, bool allocate);
@@ -311,9 +311,9 @@ FaderSceneCommand SDChannelTitle::calcNormal() {
case 18: if (SCCheckStatus() != 1) { mState = 21; } break;
case 19: iplSDChannelTitle_startCopyProgress(this); break;
case 20: iplSDChannelTitle_updateCopyPrepare(this); break;
case 23: iplSDChannelTitle_updateMemoryCalc(this); break;
case 21: iplSDChannelTitle_updateEnqueueNotice(this); break;
case 22: iplSDChannelTitle_updateCopyProgress(this); break;
case 23: iplSDChannelTitle_updateMemoryCalc(this); break;
case 24: iplSDChannelTitle_loadTitleBanner(this); break;
case 25: iplSDChannelTitle_updateBannerLoad(this); break;
case 26: iplSDChannelTitle_showCopyError(this); break;
@@ -401,8 +401,8 @@ FaderSceneCommand SDChannelTitle::calcFadeout() {
} title;
title.id = channel->mAppMeta.titleId;
wchar_t names[2][21];
memcpy(names[0], iplSDChannelObj_813E4060(channel, 0), sizeof(names[0]));
memcpy(names[1], iplSDChannelObj_813E4060(channel, 1), sizeof(names[1]));
memcpy(names[0], iplSDChannelObj_getLocalizedName(channel, 0), sizeof(names[0]));
memcpy(names[1], iplSDChannelObj_getLocalizedName(channel, 1), sizeof(names[1]));
union MakerCode {
u16 code;
char bytes[2];
@@ -537,7 +537,7 @@ extern "C" void iplSDChannelTitle_createBannerLayout(SDChannelTitle* scene) {
if (scene->mpBannerFiles[scene->mLoadedIndex] && scene->mpBannerFiles[scene->mLoadedIndex]->checkData() == 1) {
scene->mpBannerLayout = layout::Object::create(scene->mpBannerHeap, 0x40000,
scene->mpBannerFiles[scene->mLoadedIndex], "arc", "banner.brlyt");
iplSDChannelObj_813E3580(scene->mpBannerLayout);
iplSDChannelObj_applyLanguageGroups(scene->mpBannerLayout);
iplSDChannelTitle_bindBannerAnimations(scene);
} else {
scene->mpBannerLayout = NULL;
@@ -552,15 +552,15 @@ extern "C" void iplSDChannelTitle_createIconLayout(SDChannelTitle* scene) {
SDChannelObj* channel = scene->mpChannelSelect->findChannelObject(scene->mPage, scene->mIndex);
if (channel) {
scene->mpIconLayout = layout::Object::create(scene->mpIconHeap, 0x8000,
iplSDChannelObj_813E3128(channel), "arc", "icon.brlyt");
iplSDChannelObj_813E3580(scene->mpIconLayout);
iplSDChannelObj_getOrAllocThumbnailData(channel), "arc", "icon.brlyt");
iplSDChannelObj_applyLanguageGroups(scene->mpIconLayout);
if (scene->mpIconLayout->searchFile("icon.brlan")) {
scene->mpIconLayout->bind("icon.brlan")->play();
} else if (scene->mpIconLayout->searchFile("icon_Whole.brlan")) {
scene->mpIconLayout->bind("icon_Whole.brlan")->play();
}
if (channel->mStateFlags == 0) {
static_cast<nw4r::lyt::TextBox*>(scene->mpProgressLayout->FindPaneByName("T_title"))->SetString(iplSDChannelObj_813E4060(channel, 0));
static_cast<nw4r::lyt::TextBox*>(scene->mpProgressLayout->FindPaneByName("T_title"))->SetString(iplSDChannelObj_getLocalizedName(channel, 0));
} else {
static_cast<nw4r::lyt::TextBox*>(scene->mpProgressLayout->FindPaneByName("T_title"))->SetString(sMissingTitle);
}
@@ -611,7 +611,7 @@ extern "C" void iplSDChannelTitle_updateChangeState(SDChannelTitle* scene) {
++scene->mChangeFrame;
if ((!scene->mpBannerFiles[1 - scene->mLoadedIndex] || scene->mpBannerFiles[1 - scene->mLoadedIndex]->isFinished()) &&
(!scene->mpSoundFiles[1 - scene->mLoadedIndex] || scene->mpSoundFiles[1 - scene->mLoadedIndex]->isFinished()) &&
iplSDChannelObj_813E3330(channel) && scene->mChangeFrame > 10 &&
iplSDChannelObj_hasAppMeta(channel) && scene->mChangeFrame > 10 &&
(!scene->mScriptEnabled || scene->mScriptState == 4)) {
if (scene->mpBannerFiles[scene->mLoadedIndex]) {
delete scene->mpBannerFiles[scene->mLoadedIndex];
@@ -972,7 +972,7 @@ extern "C" void iplSDChannelTitle_tryLaunchSelected(SDChannelTitle* scene) {
scene->mState = 1;
} else {
SDChannelObj* channel = scene->mpChannelSelect->findChannelObject(scene->mPage, scene->mIndex);
if (iplSDChannelObj_813E3330(channel)) {
if (iplSDChannelObj_hasAppMeta(channel)) {
iplSDChannelTitle_beginLaunch(scene, channel);
}
}
@@ -1264,7 +1264,7 @@ extern "C" void iplSDChannelTitle_setPageAndIndex(SDChannelTitle* scene, int pag
SDChannelObj* channel = scene->mpChannelSelect->findChannelObject(scene->mPage, scene->mIndex);
scene->mPosition.x = SDChannelSelect::getChannelPanePosition(scene->mpChannelSelect, scene->mIndex).x;
scene->mPosition.y = SDChannelSelect::getChannelPanePosition(scene->mpChannelSelect, scene->mIndex).y;
if (iplSDChannelObj_813E3330(channel)) {
if (iplSDChannelObj_hasAppMeta(channel)) {
iplSDChannelTitle_beginLaunch(scene, channel);
} else {
scene->mState = 28;

View File

@@ -290,25 +290,25 @@ extern int SORecvFrom(int socket, void* buffer, int length, int flags, void* add
extern int SOSendTo(int socket, const void* buffer, int length, int flags, const void* address);
extern int SOBind(int socket, const void* address);
int AOSS_813FFD68(AOSSInitInput* input);
int AOSSValidateInitConfig(AOSSInitInput* input);
int AOSS_CheckAP(AOSSAccessPointRecord* list);
int AOSS_814001B4(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request, int socket);
int AOSS_814002F0(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request);
int AOSS_814004D0(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request);
int AOSS_814006A4(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request);
int AOSS_81400830(AOSSDecryptionMessage* message);
int AOSS_81400D34(u16 command, const u8* manufacturerAddress);
int AOSS_81401104(const AOSSOptionRecord* packet, AOSSStoredConfig* config);
int AOSS_81401284(const AOSSOptionRecord* packet, AOSSStoredConfig* config);
void AOSS_81401C9C(AOSSKeySchedule* schedule, const u8* key, u32 keyLength, u32 stateLength);
void AOSS_81401DC0(u32 seed, u32* table);
s16 AOSS_81401BBC(void* buffer);
int AOSS_81401574(void* packet, AOSSRequestRecords* request, int socket);
int AOSS_81401778(void* packet, void* request, int socket);
int AOSS_81401E80(void* packet, s32 length, char* key, int keyLength);
int AOSS_814020CC(void* settings, void* config);
int AOSS_81400E0C(const AOSSOptionRecord* packet, u8* settings);
int AOSS_814013AC(int state, const AOSSReplyOption* response, int responseLength, void* config, void* networkData);
int AOSSDispatchReceiveState(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request, int socket);
int AOSSHandleDiscoverReply(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request);
int AOSSHandleAuthReply(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request);
int AOSSHandleFinalReply(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request);
int AOSSDecryptMessage(AOSSDecryptionMessage* message);
int AOSSCheckAccessPointName(u16 command, const u8* manufacturerAddress);
int AOSSParseWepConfig(const AOSSOptionRecord* packet, AOSSStoredConfig* config);
int AOSSParsePskConfig(const AOSSOptionRecord* packet, AOSSStoredConfig* config);
void AOSSInitKeySchedule(AOSSKeySchedule* schedule, const u8* key, u32 keyLength, u32 stateLength);
void AOSSInitCrc32Table(u32 seed, u32* table);
s16 AOSSBuildInterfaceOption(void* buffer);
int AOSSSendDiscoveryRequest(void* packet, AOSSRequestRecords* request, int socket);
int AOSSSendHelloRequest(void* packet, void* request, int socket);
int AOSSXorBufferWithKey(void* packet, s32 length, char* key, int keyLength);
int AOSSConnectAndAwaitHost(void* settings, void* config);
int AOSSParseNetworkSettings(const AOSSOptionRecord* packet, u8* settings);
int AOSSApplyAuthOptions(int state, const AOSSReplyOption* response, int responseLength, void* config, void* networkData);
int AOSSi_Init(AOSSInitInput* input) {
int result;
@@ -652,7 +652,7 @@ int AOSS_Init_old(AOSSInitInput* input)
}
goto finish_initialization;
wait_for_initial_link:
state = AOSS_814020CC(&settings,s_accessPointConfig);
state = AOSSConnectAndAwaitHost(&settings,s_accessPointConfig);
if (state == -1) {
input->status = 0xf;
if (s_accessPointConfig) {
@@ -860,7 +860,7 @@ request_socket_cleanup_complete:
memset(s_accessPointConfig,0,0x58);
initialWait = waitIntervals.limits.connection;
for (waitAttempt = 0; waitAttempt < (short)initialWait; waitAttempt++) {
requestResult = AOSS_814020CC(&settings,s_accessPointConfig);
requestResult = AOSSConnectAndAwaitHost(&settings,s_accessPointConfig);
if (requestResult == -1) {
input->status = 0xf;
if (s_accessPointConfig) {
@@ -950,14 +950,14 @@ request_socket_cleanup_complete:
s_operationState = 2;
AOSSi_Status(2);
}
requestResult = AOSS_81401574(networkAddresses,&requestRecords,requestResult);
requestResult = AOSSSendDiscoveryRequest(networkAddresses,&requestRecords,requestResult);
break;
case 1:
if (s_operationState != 3) {
s_operationState = 3;
AOSSi_Status(3);
}
requestResult = AOSS_81401778(networkAddresses,&requestRecords,requestResult);
requestResult = AOSSSendHelloRequest(networkAddresses,&requestRecords,requestResult);
break;
case 2:
@@ -969,7 +969,7 @@ request_socket_cleanup_complete:
memset(s_responseBuffer,0,0x5dc);
memcpy(messageIdentity,&requestRecords.records[2],8);
manufacturerLength = strlen(s_manufacturer);
AOSS_81401E80(messageIdentity,8,s_manufacturer,manufacturerLength);
AOSSXorBufferWithKey(messageIdentity,8,s_manufacturer,manufacturerLength);
receivedLength = SOHtoNs(1);
packetWords->initialLength = receivedLength;
packetWords->initialType = 0;
@@ -1089,7 +1089,7 @@ process_received_packet:
packetBuffer->socket = s_socket;
retryWait = SONtoHs(receivedLength);
packetBuffer->length = retryWait & 0xffff;
requestResult = AOSS_814001B4(protocolState,packetBuffer,&receivedPackets,&requestRecords,s_socket);
requestResult = AOSSDispatchReceiveState(protocolState,packetBuffer,&receivedPackets,&requestRecords,s_socket);
if (requestResult == 100) {
protocolResult = 0;
}
@@ -1206,7 +1206,7 @@ wait_for_packet:
memset(s_accessPointConfig,0,0x58);
initialWait = waitIntervals.limits.connection;
for (waitAttempt = 0; waitAttempt < (short)initialWait; waitAttempt++) {
state = AOSS_814020CC(&settings,s_accessPointConfig);
state = AOSSConnectAndAwaitHost(&settings,s_accessPointConfig);
if (state == -1) {
input->status = 0xf;
if (s_accessPointConfig) {
@@ -1391,7 +1391,7 @@ protocol_socket_cleanup_complete:
resultCode = 0xffffffff;
goto finish_initialization;
} else {
protocolResult = AOSS_813FFD68(input);
protocolResult = AOSSValidateInitConfig(input);
if (protocolResult == 0) goto configuration_success;
{
input->status = 6;
@@ -1414,7 +1414,7 @@ finish_initialization:
return (int)resultCode;
}
int AOSS_813FFD68(AOSSInitInput* input) {
int AOSSValidateInitConfig(AOSSInitInput* input) {
AOSSConfigRecord* config;
u8* output;
u8* cursor;
@@ -1599,7 +1599,7 @@ int AOSS_CheckAP(AOSSAccessPointRecord* list) {
return result;
}
int AOSS_814001B4(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request, int socket) {
int AOSSDispatchReceiveState(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request, int socket) {
u16 messageLength = SONtoHs(packet->message.messageLength);
u16 opcode;
@@ -1611,26 +1611,26 @@ int AOSS_814001B4(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestR
(*count)++;
return state;
}
if (AOSS_81400830((AOSSDecryptionMessage*)&packet->message) > 0) {
if (AOSSDecryptMessage((AOSSDecryptionMessage*)&packet->message) > 0) {
(*count)++;
return state;
}
opcode = SONtoHs(packet->message.opcode);
switch (opcode) {
case 0x1010:
state = AOSS_814002F0(state, packet, count, request);
state = AOSSHandleDiscoverReply(state, packet, count, request);
break;
case 0x2010:
state = AOSS_814004D0(state, packet, count, request);
state = AOSSHandleAuthReply(state, packet, count, request);
break;
case 0x3010:
state = AOSS_814006A4(state, packet, count, request);
state = AOSSHandleFinalReply(state, packet, count, request);
break;
}
return state;
}
int AOSS_814002F0(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request) {
int AOSSHandleDiscoverReply(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request) {
AOSSReplyPayload* reply;
AOSSRequestRecord* requestRecord;
size_t manufacturerLength;
@@ -1652,7 +1652,7 @@ int AOSS_814002F0(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestR
manufacturerLength = strlen(s_manufacturer);
reply = &packet->message.payload.reply;
requestRecord = &request->records[0];
AOSS_81401E80(&packet->message.payload.manufacturerAddress, 8, s_manufacturer, manufacturerLength);
AOSSXorBufferWithKey(&packet->message.payload.manufacturerAddress, 8, s_manufacturer, manufacturerLength);
compareResult = memcmp(requestRecord->address, packet->message.payload.manufacturerAddress, 6);
if (compareResult != 0) {
validationResult = -1;
@@ -1686,7 +1686,7 @@ int AOSS_814002F0(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestR
(*count)++;
return state;
}
parserResult = AOSS_81400E0C(&reply->data.optionRecord, s_networkBuffer);
parserResult = AOSSParseNetworkSettings(&reply->data.optionRecord, s_networkBuffer);
if (parserResult < 0) {
if (parserResult == -2) {
s_errorCode = 0x16;
@@ -1705,7 +1705,7 @@ int AOSS_814002F0(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestR
return 1;
}
int AOSS_814004D0(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request) {
int AOSSHandleAuthReply(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request) {
size_t manufacturerLength;
int compareResult;
u16 packetSequence;
@@ -1724,7 +1724,7 @@ int AOSS_814004D0(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestR
operationResult = 0;
reply = &packet->message.payload.reply;
manufacturerLength = strlen(s_manufacturer);
AOSS_81401E80(&packet->message.payload.manufacturerAddress, 8, s_manufacturer, manufacturerLength);
AOSSXorBufferWithKey(&packet->message.payload.manufacturerAddress, 8, s_manufacturer, manufacturerLength);
compareResult = memcmp(request->records[1].address,
packet->message.payload.manufacturerAddress, 6);
if (compareResult != 0) {
@@ -1756,7 +1756,7 @@ int AOSS_814004D0(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestR
} else {
memset(&s_configData, 0, sizeof(s_configData));
authType = SONtoHs(packet->message.authType);
operationResult = AOSS_814013AC(0, (const AOSSReplyOption*)reply, authType, &s_configData,
operationResult = AOSSApplyAuthOptions(0, (const AOSSReplyOption*)reply, authType, &s_configData,
s_networkBuffer);
if (operationResult < 0) {
*count = *count + 1;
@@ -1772,7 +1772,7 @@ int AOSS_814004D0(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestR
return state;
}
int AOSS_814006A4(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request) {
int AOSSHandleFinalReply(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestRecords* request) {
int result = state;
size_t manufacturerLength;
int compareResult;
@@ -1788,7 +1788,7 @@ int AOSS_814006A4(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestR
errorCode = 0;
manufacturerLength = strlen(s_manufacturer);
AOSS_81401E80(&packet->message.payload.manufacturerAddress, 8, s_manufacturer, manufacturerLength);
AOSSXorBufferWithKey(&packet->message.payload.manufacturerAddress, 8, s_manufacturer, manufacturerLength);
compareResult = memcmp(request->records[2].address,
packet->message.payload.manufacturerAddress, 6);
if (compareResult != 0) {
@@ -1828,7 +1828,7 @@ int AOSS_814006A4(int state, AOSSReceiveBuffer* packet, int* count, AOSSRequestR
return result;
}
int AOSS_81400830(AOSSDecryptionMessage* message) {
int AOSSDecryptMessage(AOSSDecryptionMessage* message) {
u32 checksum;
u8 manufacturerAddress[8];
AOSSKeySchedule schedule;
@@ -1850,14 +1850,14 @@ int AOSS_81400830(AOSSDecryptionMessage* message) {
int result;
memcpy(manufacturerAddress, message->manufacturerAddress, sizeof(manufacturerAddress));
result = AOSS_81401E80(manufacturerAddress, sizeof(manufacturerAddress), s_manufacturer,
result = AOSSXorBufferWithKey(manufacturerAddress, sizeof(manufacturerAddress), s_manufacturer,
strlen(s_manufacturer));
if (result == -1) {
s_errorCode = 2;
return -100;
}
result = AOSS_81400D34(SONtoHs(message->command), manufacturerAddress);
result = AOSSCheckAccessPointName(SONtoHs(message->command), manufacturerAddress);
if (result != 0) {
return result;
}
@@ -1886,7 +1886,7 @@ int AOSS_81400830(AOSSDecryptionMessage* message) {
} else {
memcpy(s_packetState.keyNonce, &encrypted->keyNonce, sizeof(encrypted->keyNonce));
memcpy(s_packetState.keyAddress, s_accessPointName, sizeof(s_accessPointName));
AOSS_81401C9C(&schedule, s_packetState.keyNonce,
AOSSInitKeySchedule(&schedule, s_packetState.keyNonce,
sizeof(s_packetState.keyNonce) + sizeof(s_packetState.keyAddress), dataLength);
outputCursor = decryptedData;
@@ -1906,7 +1906,7 @@ int AOSS_81400830(AOSSDecryptionMessage* message) {
}
crc = 0xffffffff;
AOSS_81401DC0(0, s_crcTable);
AOSSInitCrc32Table(0, s_crcTable);
for (crcIndex = 0; crcIndex < (s32)dataLength; crcIndex++) {
crc = (crc >> 8) ^ s_crcTable[(crc ^ decryptedData[crcIndex]) & 0xff];
}
@@ -1931,7 +1931,7 @@ int AOSS_81400830(AOSSDecryptionMessage* message) {
return 0;
}
int AOSS_81400D34(u16 command, const u8* manufacturerAddress) {
int AOSSCheckAccessPointName(u16 command, const u8* manufacturerAddress) {
u8* storedAddress = s_accessPointName;
int result = 0;
int hasAddress = 0;
@@ -1961,7 +1961,7 @@ int AOSS_81400D34(u16 command, const u8* manufacturerAddress) {
return result;
}
int AOSS_81400E0C(const AOSSOptionRecord* packet, u8* settings) {
int AOSSParseNetworkSettings(const AOSSOptionRecord* packet, u8* settings) {
const u8* packetBytes = (const u8*)packet;
const AOSSOptionRecord* record;
s32 length;
@@ -2027,7 +2027,7 @@ int AOSS_81400E0C(const AOSSOptionRecord* packet, u8* settings) {
return 0;
}
int AOSS_81401104(const AOSSOptionRecord* packet, AOSSStoredConfig* config) {
int AOSSParseWepConfig(const AOSSOptionRecord* packet, AOSSStoredConfig* config) {
const u8* packetBytes = (const u8*)packet;
const AOSSOptionRecord* record = (const AOSSOptionRecord*)(packetBytes + 6);
u32 length;
@@ -2099,7 +2099,7 @@ int AOSS_81401104(const AOSSOptionRecord* packet, AOSSStoredConfig* config) {
return 0;
}
int AOSS_81401284(const AOSSOptionRecord* packet, AOSSStoredConfig* config) {
int AOSSParsePskConfig(const AOSSOptionRecord* packet, AOSSStoredConfig* config) {
const u8* packetBytes = (const u8*)packet;
const AOSSOptionRecord* record = (const AOSSOptionRecord*)(packetBytes + 6);
u32 length;
@@ -2146,7 +2146,7 @@ int AOSS_81401284(const AOSSOptionRecord* packet, AOSSStoredConfig* config) {
return 0;
}
int AOSS_814013AC(int state, const AOSSReplyOption* response, int responseLength, void* config, void* networkData) {
int AOSSApplyAuthOptions(int state, const AOSSReplyOption* response, int responseLength, void* config, void* networkData) {
u32 flags = 0;
const AOSSReplyOption* responseRecord;
AOSSConfigRecord* configRecord;
@@ -2190,19 +2190,19 @@ int AOSS_814013AC(int state, const AOSSReplyOption* response, int responseLength
do {
switch (option->fields.type) {
case 3:
result = AOSS_81401104((const AOSSOptionRecord*)option, wep40Config);
result = AOSSParseWepConfig((const AOSSOptionRecord*)option, wep40Config);
flags |= 1;
break;
case 4:
result = AOSS_81401104((const AOSSOptionRecord*)option, wep104Config);
result = AOSSParseWepConfig((const AOSSOptionRecord*)option, wep104Config);
flags |= 2;
break;
case 5:
result = AOSS_81401284((const AOSSOptionRecord*)option, tkipConfig);
result = AOSSParsePskConfig((const AOSSOptionRecord*)option, tkipConfig);
flags |= 4;
break;
case 6:
result = AOSS_81401284((const AOSSOptionRecord*)option, aesConfig);
result = AOSSParsePskConfig((const AOSSOptionRecord*)option, aesConfig);
flags |= 8;
break;
case 10:
@@ -2234,7 +2234,7 @@ int AOSS_814013AC(int state, const AOSSReplyOption* response, int responseLength
return 0;
}
int AOSS_81401574(void* packet, AOSSRequestRecords* request, int socket) {
int AOSSSendDiscoveryRequest(void* packet, AOSSRequestRecords* request, int socket) {
u8* responsePayload;
u8 accessPointName[8];
AOSSSocketAddress destination;
@@ -2257,7 +2257,7 @@ int AOSS_81401574(void* packet, AOSSRequestRecords* request, int socket) {
responsePayload = response->payload;
memcpy(s_accessPointName, &request->records[0], 8);
memcpy(accessPointName, s_accessPointName, 8);
recordLength = AOSS_81401BBC(&requestRecord->record);
recordLength = AOSSBuildInterfaceOption(&requestRecord->record);
if (recordLength < 0) {
s_errorCode = 3;
if (requestRecord != 0) {
@@ -2269,7 +2269,7 @@ int AOSS_81401574(void* packet, AOSSRequestRecords* request, int socket) {
requestRecord->length = SOHtoNs(recordLength);
requestLength = recordLength + 4;
memcpy(responsePayload, requestRecord, requestLength);
encryptionResult = AOSS_81401E80(accessPointName, 8, s_manufacturer, 6);
encryptionResult = AOSSXorBufferWithKey(accessPointName, 8, s_manufacturer, 6);
if (encryptionResult != 0) {
s_errorCode = 2;
if (requestRecord != 0) {
@@ -2302,7 +2302,7 @@ int AOSS_81401574(void* packet, AOSSRequestRecords* request, int socket) {
return result;
}
int AOSS_81401778(void* packet, void* request, int socket) {
int AOSSSendHelloRequest(void* packet, void* request, int socket) {
AOSSHelloPacket* response = (AOSSHelloPacket*)s_responseBuffer;
AOSSHelloPayload* payload;
AOSSRequestRecords* requestRecords = (AOSSRequestRecords*)request;
@@ -2343,7 +2343,7 @@ int AOSS_81401778(void* packet, void* request, int socket) {
const u32* crcTable;
sequence = 1;
checksum = 0xffffffff;
AOSS_81401DC0(0, s_crcTable);
AOSSInitCrc32Table(0, s_crcTable);
crcTable = s_crcTable;
{
u32 part;
@@ -2361,7 +2361,7 @@ int AOSS_81401778(void* packet, void* request, int socket) {
memcpy(&payload->encrypted.key.nonce, &nonce, 2);
memcpy(s_packetState.keyNonce, payload->encrypted.key.nonceBytes, 2);
memcpy(s_packetState.keyAddress, s_accessPointName, 8);
AOSS_81401C9C(&construction.schedule, s_packetState.keyNonce,
AOSSInitKeySchedule(&construction.schedule, s_packetState.keyNonce,
sizeof(s_packetState.keyNonce) + sizeof(s_packetState.keyAddress), 8);
for (index = 0; index < 8; index++) {
state = construction.schedule.bytes;
@@ -2386,7 +2386,7 @@ int AOSS_81401778(void* packet, void* request, int socket) {
}
memcpy(construction.accessPointName, &requestRecords->records[1], 8);
encryptionResult = AOSS_81401E80(construction.accessPointName, 8, s_manufacturer, 6);
encryptionResult = AOSSXorBufferWithKey(construction.accessPointName, 8, s_manufacturer, 6);
if (encryptionResult != 0) {
s_errorCode = 2;
return -1;
@@ -2415,7 +2415,7 @@ int AOSS_81401778(void* packet, void* request, int socket) {
return 0;
}
s16 AOSS_81401BBC(void* buffer) {
s16 AOSSBuildInterfaceOption(void* buffer) {
AOSSOptionRecord* record = (AOSSOptionRecord*)buffer;
u32 optionValue;
s16 dataLength;
@@ -2439,7 +2439,7 @@ s16 AOSS_81401BBC(void* buffer) {
return (s16)(dataLength + 10);
}
void AOSS_81401C9C(AOSSKeySchedule* schedule, const u8* key, u32 keyLength, u32 stateLength) {
void AOSSInitKeySchedule(AOSSKeySchedule* schedule, const u8* key, u32 keyLength, u32 stateLength) {
u32 index = 0;
u32 keyIndex;
u32 swapIndex;
@@ -2471,7 +2471,7 @@ void AOSS_81401C9C(AOSSKeySchedule* schedule, const u8* key, u32 keyLength, u32
}
}
void AOSS_81401DC0(u32 seed, u32* table) {
void AOSSInitCrc32Table(u32 seed, u32* table) {
u32 index;
u32 value;
@@ -2488,7 +2488,7 @@ void AOSS_81401DC0(u32 seed, u32* table) {
}
}
int AOSS_81401E80(void* packet, s32 length, char* key, int keyLength) {
int AOSSXorBufferWithKey(void* packet, s32 length, char* key, int keyLength) {
u8* temporaryHalf;
s32 halfLength = length / 2;
u8* packetHalf;
@@ -2542,7 +2542,7 @@ int AOSS_81401E80(void* packet, s32 length, char* key, int keyLength) {
return result;
}
int AOSS_814020CC(void* settings, void* config) {
int AOSSConnectAndAwaitHost(void* settings, void* config) {
s32 connectionAttempts = 0;
u32 ticksPerMillisecond;

View File

@@ -12,8 +12,8 @@ static u8 secondaryDns[4];
static void* (*allocateMemory)(u32, s32);
static void (*releaseMemory)(u32, void*, s32);
static void (*statusCallback)(void);
static NCDIfConfig AOSS_810BD4A8;
static NCDIpConfig AOSS_810BD608;
static NCDIfConfig AOSSi_NcdIfConfig;
static NCDIpConfig AOSSi_NcdIpConfig;
struct AOSSRate {
u16 mask;
@@ -60,11 +60,11 @@ void AOSSi_Cancel(void) {
AOSSi_cancel_flag = 1;
}
void AOSS_813FD17C(OSAlarm* alarm, OSContext* context) {
void AOSSi_SleepAlarmHandler(OSAlarm* alarm, OSContext* context) {
OSSendMessage((OSMessageQueue*)alarm->tag, NULL, 0);
}
void AOSS_813FD18C(u32 milliseconds) {
void AOSSi_SleepMs(u32 milliseconds) {
OSMessage storage;
OSMessage message;
OSMessageQueue queue;
@@ -72,7 +72,7 @@ void AOSS_813FD18C(u32 milliseconds) {
OSInitMessageQueue(&queue, &storage, 1);
OSCreateAlarm(&alarm);
OSSetAlarmTag(&alarm, (u32)&queue);
OSSetAlarm(&alarm, (u32)(milliseconds * (OS_TIMER_CLOCK / 1000)), AOSS_813FD17C);
OSSetAlarm(&alarm, (u32)(milliseconds * (OS_TIMER_CLOCK / 1000)), AOSSi_SleepAlarmHandler);
OSReceiveMessage(&queue, &message, 1);
}
@@ -89,7 +89,7 @@ void AOSSi_Free(void* block) {
}
}
void AOSS_813FD25C(u8* destination, u32 address) {
void AOSSi_StoreIpv4Octets(u8* destination, u32 address) {
int index;
for (index = 0; index < 4; ++index) {
*destination++ = address >> ((3 - index) * 8);
@@ -97,11 +97,11 @@ void AOSS_813FD25C(u8* destination, u32 address) {
}
int AOSSi_SetNCDIPAddr(u32 address, u32 netmask, u32 gateway, u32 dns1, u32 dns2) {
AOSS_813FD25C(ipAddress, address);
AOSS_813FD25C(ipNetmask, netmask);
AOSS_813FD25C(ipGateway, gateway);
AOSS_813FD25C(primaryDns, dns1);
AOSS_813FD25C(secondaryDns, dns2);
AOSSi_StoreIpv4Octets(ipAddress, address);
AOSSi_StoreIpv4Octets(ipNetmask, netmask);
AOSSi_StoreIpv4Octets(ipGateway, gateway);
AOSSi_StoreIpv4Octets(primaryDns, dns1);
AOSSi_StoreIpv4Octets(secondaryDns, dns2);
return 0;
}
@@ -150,7 +150,7 @@ startup:
goto unlock;
}
++startupRetries;
AOSS_813FD18C(10);
AOSSi_SleepMs(10);
goto startup;
}
if (WD_GetInfo(&info) == 0) {
@@ -231,7 +231,7 @@ startup:
*output = list;
break;
}
AOSS_813FD18C(100);
AOSSi_SleepMs(100);
}
AOSSi_Free(buffer);
}
@@ -242,7 +242,7 @@ cleanup:
goto unlock;
}
++cleanupRetries;
AOSS_813FD18C(10);
AOSSi_SleepMs(10);
goto cleanup;
}
unlock:
@@ -252,7 +252,7 @@ unlock:
return -1;
}
++unlockRetries;
AOSS_813FD18C(10);
AOSSi_SleepMs(10);
goto unlock;
}
return result;
@@ -262,7 +262,7 @@ int AOSSi_WLANConnect(struct AOSSConnection* connection, struct AOSSConnectionSt
int retries = 0;
int result = 0;
WD_Info info ATTRIBUTE_ALIGN(32);
NCDIfConfig* interfaceConfig = &AOSS_810BD4A8;
NCDIfConfig* interfaceConfig = &AOSSi_NcdIfConfig;
NCDIpConfig* ipConfig;
memset(interfaceConfig, 0, sizeof(*interfaceConfig));
interfaceConfig->selectedMedia = 1;
@@ -288,7 +288,7 @@ int AOSSi_WLANConnect(struct AOSSConnection* connection, struct AOSSConnectionSt
}
interfaceConfig->netif.wireless.config.manual.ssidLength = (u8)connection->ssidLength;
memcpy(interfaceConfig->netif.wireless.config.manual.ssid, connection->ssid, connection->ssidLength);
ipConfig = &AOSS_810BD608;
ipConfig = &AOSSi_NcdIpConfig;
memset(ipConfig, 0, sizeof(*ipConfig));
ipConfig->adjust.maxTransferUnit = 1300;
ipConfig->adjust.tcpRetransTimeout = 100;
@@ -303,7 +303,7 @@ int AOSSi_WLANConnect(struct AOSSConnection* connection, struct AOSSConnectionSt
if (NCDSetIpConfig(ipConfig) != 0) {
result = -1;
}
if (result == 0 && NCDSetIfConfig(&AOSS_810BD4A8) != 0) {
if (result == 0 && NCDSetIfConfig(&AOSSi_NcdIfConfig) != 0) {
result = -1;
}
if (result == 0) {
@@ -317,7 +317,7 @@ int AOSSi_WLANConnect(struct AOSSConnection* connection, struct AOSSConnectionSt
break;
}
++retries;
AOSS_813FD18C(10);
AOSSi_SleepMs(10);
}
}
if (result == 0) {
@@ -335,7 +335,7 @@ int AOSSi_WLANConnect(struct AOSSConnection* connection, struct AOSSConnectionSt
}
void AOSSi_Sleep(u32 milliseconds) {
AOSS_813FD18C(milliseconds);
AOSSi_SleepMs(milliseconds);
}
int AOSSi_Status(void) {

View File

@@ -540,20 +540,20 @@ AtermProgressCallback gAtermProgressCallback;
u32 gAtermResult;
s32 gAtermState;
void ATERM_8140684C(OSAlarm* alarm, OSContext* context);
s32 ATERM_814038C8(void);
void ATERM_81405ACC(AtermMd5Context* context, void* input, u32 length);
void ATERMAlarmWakeQueue(OSAlarm* alarm, OSContext* context);
s32 ATERMRunConfigProtocol(void);
void ATERMMd5Update(AtermMd5Context* context, void* input, u32 length);
extern u8 gAtermDigestFill[64];
extern u8* gAtermRequestOptions;
int ATERM_81404844(u16* destination, u16* source, u32 length, void* key, u32 keyLength);
int ATERM_81404A18(u16* destination, u16* source, u32 length, void* key, u32 keyLength);
int ATERM_81404BFC(u32* expandedKey, const void* key, u32 keyBits);
int ATERM_8140502C(u32* expandedKey, const void* key, u32 keyBits);
void ATERM_81405254(const u32* expandedKey, u32 rounds, const u8* input, u8* output);
void ATERM_81405690(const u32* expandedKey, u32 rounds, const u8* input, u8* output);
int ATERM_814033F0(u16* response);
int ATERMAesKeyWrap(u16* destination, u16* source, u32 length, void* key, u32 keyLength);
int ATERMAesKeyUnwrap(u16* destination, u16* source, u32 length, void* key, u32 keyLength);
int ATERMAesExpandEncryptKey(u32* expandedKey, const void* key, u32 keyBits);
int ATERMAesExpandDecryptKey(u32* expandedKey, const void* key, u32 keyBits);
void ATERMAesEncryptBlock(const u32* expandedKey, u32 rounds, const u8* input, u8* output);
void ATERMAesDecryptBlock(const u32* expandedKey, u32 rounds, const u8* input, u8* output);
int ATERMParseAssociationResponse(u16* response);
int ATERM_814021BC(void) {
int ATERMStartNetworkStack(void) {
int status;
int waitCount = 0;
u32 convertedHost;
@@ -605,7 +605,7 @@ int ATERM_814021BC(void) {
OSCreateAlarm(&interfaceAlarm);
OSSetAlarmTag(&interfaceAlarm, (u32)&interfaceQueue);
timeoutTicks = (__mulhwu(0x10624DD3, *(u32*)0x800000F8 >> 2) >> 6) * 10;
OSSetAlarm(&interfaceAlarm, timeoutTicks, ATERM_8140684C);
OSSetAlarm(&interfaceAlarm, timeoutTicks, ATERMAlarmWakeQueue);
OSReceiveMessage(&interfaceQueue, &interfaceMessage, 1);
}
@@ -621,7 +621,7 @@ int ATERM_814021BC(void) {
OSCreateAlarm(&hostAlarm);
OSSetAlarmTag(&hostAlarm, (u32)&hostQueue);
timeoutTicks = (__mulhwu(0x10624DD3, *(u32*)0x800000F8 >> 2) >> 6) * 10;
OSSetAlarm(&hostAlarm, timeoutTicks, ATERM_8140684C);
OSSetAlarm(&hostAlarm, timeoutTicks, ATERMAlarmWakeQueue);
OSReceiveMessage(&hostQueue, &hostMessage, 1);
}
} else {
@@ -631,7 +631,7 @@ int ATERM_814021BC(void) {
return waitCount;
}
int ATERM_81402424(u16* resultBuffer, u32 resultBufferLength) {
int ATERMScanAccessPoints(u16* resultBuffer, u32 resultBufferLength) {
int lockId;
int result = -2;
u16* scanBuffer = resultBuffer;
@@ -678,7 +678,7 @@ int ATERM_81402424(u16* resultBuffer, u32 resultBufferLength) {
OSCreateAlarm(&startupAlarm);
OSSetAlarmTag(&startupAlarm, (u32)&startupQueue);
OSSetAlarm(&startupAlarm, (__mulhwu(0x10624DD3, *(u32*)0x800000F8 >> 2) >> 6) * 10,
ATERM_8140684C);
ATERMAlarmWakeQueue);
OSReceiveMessage(&startupQueue, &startupMessage, 1);
} while (1);
@@ -719,7 +719,7 @@ int ATERM_81402424(u16* resultBuffer, u32 resultBufferLength) {
OSCreateAlarm(&scanAlarm);
OSSetAlarmTag(&scanAlarm, (u32)&scanQueue);
OSSetAlarm(&scanAlarm, (__mulhwu(0x10624DD3, *(u32*)0x800000F8 >> 2) >> 6) * 10,
ATERM_8140684C);
ATERMAlarmWakeQueue);
OSReceiveMessage(&scanQueue, &scanMessage, 1);
}
@@ -737,7 +737,7 @@ cleanup_driver:
OSCreateAlarm(&cleanupAlarm);
OSSetAlarmTag(&cleanupAlarm, (u32)&cleanupQueue);
OSSetAlarm(&cleanupAlarm, (__mulhwu(0x10624DD3, *(u32*)0x800000F8 >> 2) >> 6) * 10,
ATERM_8140684C);
ATERMAlarmWakeQueue);
OSReceiveMessage(&cleanupQueue, &cleanupMessage, 1);
}
@@ -752,7 +752,7 @@ unlock_driver:
OSCreateAlarm(&unlockAlarm);
OSSetAlarmTag(&unlockAlarm, (u32)&unlockQueue);
OSSetAlarm(&unlockAlarm, (__mulhwu(0x10624DD3, *(u32*)0x800000F8 >> 2) >> 6) * 10,
ATERM_8140684C);
ATERMAlarmWakeQueue);
OSReceiveMessage(&unlockQueue, &unlockMessage, 1);
}
}
@@ -760,7 +760,7 @@ unlock_driver:
return result;
}
int ATERM_8140276C(AtermApRecordSet* currentRecords, AtermApRecordSet* previousRecords,
int ATERMFindChangedApRecord(AtermApRecordSet* currentRecords, AtermApRecordSet* previousRecords,
u32* changedIndex) {
u32 previousIndex;
u32 currentIndex = 0;
@@ -869,7 +869,7 @@ int ATERM_8140276C(AtermApRecordSet* currentRecords, AtermApRecordSet* previousR
return result;
}
int ATERM_81402A24(void) {
int ATERMDiscoverAccessPoints(void) {
s32 result = -1;
u32 scanBufferBytes;
u32 recordIndex;
@@ -912,7 +912,7 @@ int ATERM_81402A24(void) {
break;
}
result = ATERM_81402424((u16*)scanBuffer, scanBufferBytes);
result = ATERMScanAccessPoints((u16*)scanBuffer, scanBufferBytes);
if (result < 0) {
goto cleanup;
}
@@ -954,7 +954,7 @@ int ATERM_81402A24(void) {
currentRecords->count = result;
if (gAtermState != 1 &&
ATERM_8140276C(currentRecords, previousRecords, (u32*)&progressInfo[0])) {
ATERMFindChangedApRecord(currentRecords, previousRecords, (u32*)&progressInfo[0])) {
AtermApRecord* selectedRecord;
gAtermSelectedRecordIndex = progressInfo[0];
selectedRecord = &currentRecords->entries[progressInfo[0]];
@@ -1036,7 +1036,7 @@ cleanup:
return result;
}
int ATERM_81402E40(u16* messageBuffer, u32 sequence, u16* payload, size_t payloadLength,
int ATERMBuildEncryptedMessage(u16* messageBuffer, u32 sequence, u16* payload, size_t payloadLength,
void* encryptionKey) {
u8* end;
u8* cursor;
@@ -1045,7 +1045,7 @@ int ATERM_81402E40(u16* messageBuffer, u32 sequence, u16* payload, size_t payloa
memset(payload, 0, 8);
payload[0] = SOHtoNs((payloadLength - 8) & 0xFFFF);
if (encryptionKey != NULL) {
ATERM_81404844(messageBuffer + 3, payload, payloadLength, encryptionKey, 0x10);
ATERMAesKeyWrap(messageBuffer + 3, payload, payloadLength, encryptionKey, 0x10);
payloadLength += 8;
} else {
memcpy(messageBuffer + 3, payload, payloadLength);
@@ -1064,7 +1064,7 @@ int ATERM_81402E40(u16* messageBuffer, u32 sequence, u16* payload, size_t payloa
return (int)(end + sizeof(u16) - (u8*)messageBuffer);
}
int ATERM_81402FC0(AtermPacket* packet, u32* setupType) {
int ATERMParsePacket(AtermPacket* packet, u32* setupType) {
u8* cursor;
u8* end;
u8* payload;
@@ -1142,7 +1142,7 @@ int ATERM_81402FC0(AtermPacket* packet, u32* setupType) {
return 0;
}
int ATERM_814031DC(AtermAssociationRequest* request) {
int ATERMBuildAssociationRequest(AtermAssociationRequest* request) {
u8 scanAddress[8];
u8 interfaceMacAddress[8];
char interfaceMacText[32];
@@ -1227,7 +1227,7 @@ int ATERM_814031DC(AtermAssociationRequest* request) {
return 1;
}
int ATERM_814033F0(u16* response) {
int ATERMParseAssociationResponse(u16* response) {
u16* optionCursor = response + 4;
u8* optionValue;
u16* responseEnd;
@@ -1317,7 +1317,7 @@ int ATERM_814033F0(u16* response) {
return result;
}
int ATERM_81403614(u8* destination, const char* source, s32 length) {
int ATERMParseHexBytes(u8* destination, const char* source, s32 length) {
s32 value = 0;
s32 characterIndex = 0;
@@ -1349,7 +1349,7 @@ int ATERM_81403614(u8* destination, const char* source, s32 length) {
return 1;
}
int ATERM_814036D8(void) {
int ATERMApplyScanSecuritySettings(void) {
s32 result = 1;
char* sourceKey;
char* outputKey;
@@ -1389,7 +1389,7 @@ int ATERM_814036D8(void) {
break;
case 10:
gAtermConfigurationResult.setupMode = 1;
ATERM_81403614((u8*)outputKey, keyString, 10);
ATERMParseHexBytes((u8*)outputKey, keyString, 10);
break;
case 13:
gAtermConfigurationResult.setupMode = 2;
@@ -1397,7 +1397,7 @@ int ATERM_814036D8(void) {
break;
case 26:
gAtermConfigurationResult.setupMode = 2;
ATERM_81403614((u8*)outputKey, keyString, 0x1A);
ATERMParseHexBytes((u8*)outputKey, keyString, 0x1A);
break;
case 16:
gAtermConfigurationResult.setupMode = 3;
@@ -1405,7 +1405,7 @@ int ATERM_814036D8(void) {
break;
case 32:
gAtermConfigurationResult.setupMode = 3;
ATERM_81403614((u8*)outputKey, keyString, 0x20);
ATERMParseHexBytes((u8*)outputKey, keyString, 0x20);
break;
default:
result = -7;
@@ -1432,7 +1432,7 @@ int ATERM_814036D8(void) {
return result;
}
s32 ATERM_814038C8(void) {
s32 ATERMRunConfigProtocol(void) {
OSMessageQueue waitQueue;
OSMessage waitBuffer[1];
OSMessage waitMessage;
@@ -1459,7 +1459,7 @@ s32 ATERM_814038C8(void) {
OSSetAlarmTag(&waitAlarm, (u32)&waitQueue);
OSSetAlarm(&waitAlarm,
(__mulhwu(reciprocal, OS_BUS_CLOCK >> 2) >> 6) * 500,
ATERM_8140684C);
ATERMAlarmWakeQueue);
OSReceiveMessage(&waitQueue, &waitMessage, 1);
switch (gAtermProtocolState) {
case 0:
@@ -1467,7 +1467,7 @@ s32 ATERM_814038C8(void) {
case 1:
{
AtermProgress progress;
result = ATERM_81402A24();
result = ATERMDiscoverAccessPoints();
if (result != 1) {
failed = 1;
break;
@@ -1485,7 +1485,7 @@ s32 ATERM_814038C8(void) {
break;
}
case 2:
result = ATERM_814021BC();
result = ATERMStartNetworkStack();
if (result != 1) {
failed = 1;
break;
@@ -1525,11 +1525,11 @@ s32 ATERM_814038C8(void) {
break;
}
peerAddress.length = 8;
ATERM_814031DC((AtermAssociationRequest*)gAtermConfigurationResult.connectionPrefix);
ATERMBuildAssociationRequest((AtermAssociationRequest*)gAtermConfigurationResult.connectionPrefix);
receivedLength = SORecvFrom(socket, gAtermConfigurationResult.packetBuffer,
sizeof(gAtermConfigurationResult.packetBuffer), 4, &peerAddress);
if (receivedLength > 0 &&
ATERM_81402FC0((AtermPacket*)gAtermConfigurationResult.packetBuffer, &gAtermResponseMode)) {
ATERMParsePacket((AtermPacket*)gAtermConfigurationResult.packetBuffer, &gAtermResponseMode)) {
AtermProgress progress;
gAtermDeadline = (u32)(OSGetTime() / (__mulhwu(reciprocal, OS_BUS_CLOCK >> 2) >> 6)) + 30000;
gAtermProtocolState = 5;
@@ -1588,7 +1588,7 @@ s32 ATERM_814038C8(void) {
longOption++;
}
optionEnd = (u8*)longOption;
gAtermMessageLength = ATERM_81402E40((u16*)gAtermConfigurationResult.packetBuffer, 2,
gAtermMessageLength = ATERMBuildEncryptedMessage((u16*)gAtermConfigurationResult.packetBuffer, 2,
(u16*)response->data, optionEnd - gAtermRequestOptions + 8, NULL);
sendAddress.length = 8;
sendAddress.family = 2;
@@ -1628,7 +1628,7 @@ s32 ATERM_814038C8(void) {
} else if (sequence != 3) {
payloadLength = 0;
} else if (gAtermConfigurationResult.connectionPrefix != NULL) {
ATERM_81404A18((u16*)response->authentication.payload, (u16*)payload,
ATERMAesKeyUnwrap((u16*)response->authentication.payload, (u16*)payload,
payloadLength, gAtermConfigurationResult.connectionPrefix, 16);
payloadLength -= 8;
} else {
@@ -1660,7 +1660,7 @@ s32 ATERM_814038C8(void) {
digestContext.state[1] = 0xEFCDAB89;
digestContext.state[2] = 0x98BADCFE;
digestContext.state[3] = 0x10325476;
ATERM_81405ACC(&digestContext, &authenticationTime, sizeof(authenticationTime));
ATERMMd5Update(&digestContext, &authenticationTime, sizeof(authenticationTime));
digestLength[0] = digestContext.bitCountLow;
digestLength[1] = digestContext.bitCountLow >> 8;
digestLength[2] = digestContext.bitCountLow >> 16;
@@ -1670,9 +1670,9 @@ s32 ATERM_814038C8(void) {
digestLength[6] = digestContext.bitCountHigh >> 16;
digestLength[7] = digestContext.bitCountHigh >> 24;
digestBytes = (digestContext.bitCountLow >> 3) & 0x3F;
ATERM_81405ACC(&digestContext, gAtermDigestFill,
ATERMMd5Update(&digestContext, gAtermDigestFill,
digestBytes < 56 ? 56 - digestBytes : 120 - digestBytes);
ATERM_81405ACC(&digestContext, digestLength, sizeof(digestLength));
ATERMMd5Update(&digestContext, digestLength, sizeof(digestLength));
response->authentication.digest[0] = digestContext.state[0];
response->authentication.digest[1] = digestContext.state[0] >> 8;
response->authentication.digest[2] = digestContext.state[0] >> 16;
@@ -1724,7 +1724,7 @@ s32 ATERM_814038C8(void) {
memcpy(option->value, response->authentication.digest, 8);
gAtermReplyLength = (u8*)(option + 1) - response->data;
response->authentication.decoded.length = gAtermReplyLength - 8;
gAtermMessageLength = ATERM_81402E40((u16*)gAtermConfigurationResult.packetBuffer, 4,
gAtermMessageLength = ATERMBuildEncryptedMessage((u16*)gAtermConfigurationResult.packetBuffer, 4,
(u16*)response->data, gAtermReplyLength, gAtermConfigurationResult.connectionPrefix);
sendAddress.length = 8;
sendAddress.family = 2;
@@ -1758,14 +1758,14 @@ s32 ATERM_814038C8(void) {
} else if (sequence != 5) {
payloadLength = 0;
} else if (sessionKey != NULL) {
ATERM_81404A18((u16*)response->authentication.payload, (u16*)payload,
ATERMAesKeyUnwrap((u16*)response->authentication.payload, (u16*)payload,
payloadLength, sessionKey, 16);
payloadLength -= 8;
} else {
memcpy(response->authentication.payload, payload, payloadLength);
}
gAtermReplyLength = payloadLength;
if (payloadLength != 0 && ATERM_814033F0((u16*)response->data)) {
if (payloadLength != 0 && ATERMParseAssociationResponse((u16*)response->data)) {
gAtermProtocolState = 9;
retries = 0;
gAtermMode = gScanSettings.ssid[0] != 0;
@@ -1795,7 +1795,7 @@ s32 ATERM_814038C8(void) {
memcpy(option->value, &gAtermMode, 1);
gAtermReplyLength = (u8*)(option + 1) - response->data;
response->authentication.decoded.length = gAtermReplyLength - 8;
gAtermMessageLength = ATERM_81402E40((u16*)gAtermConfigurationResult.packetBuffer, 6,
gAtermMessageLength = ATERMBuildEncryptedMessage((u16*)gAtermConfigurationResult.packetBuffer, 6,
(u16*)response->data, gAtermReplyLength, sessionKey);
if (NCDGetLinkStatus() != 5) {
lastSendTime = (u32)(OSGetTime() / (__mulhwu(reciprocal, OS_BUS_CLOCK >> 2) >> 6)) + 1000;
@@ -1817,7 +1817,7 @@ s32 ATERM_814038C8(void) {
if (now >= lastSendTime + 1000) {
if (++retries >= 10) {
failed = 1;
result = ATERM_814036D8();
result = ATERMApplyScanSecuritySettings();
} else {
gAtermProtocolState = 9;
}
@@ -1840,7 +1840,7 @@ s32 ATERM_814038C8(void) {
u8 gAtermDigestFill[64] = { 0x80 };
s32 ATERMi_AutoConfigThread(void) {
s32 result = ATERM_814038C8();
s32 result = ATERMRunConfigProtocol();
AtermProgress progress;
u32 equalityMask;
s32 completedState;
@@ -1864,7 +1864,7 @@ s32 ATERMi_AutoConfigThread(void) {
return 0;
}
int ATERM_81404844(u16* destination, u16* source, u32 length, void* key, u32 keyLength) {
int ATERMAesKeyWrap(u16* destination, u16* source, u32 length, void* key, u32 keyLength) {
u32 expandedKey[80];
union { u32 words[4]; u8 bytes[16]; } block;
union { u64 value; u8 bytes[8]; } counter;
@@ -1889,7 +1889,7 @@ int ATERM_81404844(u16* destination, u16* source, u32 length, void* key, u32 key
return 0;
}
rounds = ATERM_81404BFC(expandedKey, key, keyLength << 3);
rounds = ATERMAesExpandEncryptKey(expandedKey, key, keyLength << 3);
destinationBytes = (u8*)destination;
sourceBytes = (const u8*)source;
memcpy(destinationBytes + 8, sourceBytes, length);
@@ -1901,7 +1901,7 @@ int ATERM_81404844(u16* destination, u16* source, u32 length, void* key, u32 key
outputBlock = destinationBytes + blockOffset;
memcpy(stateBytes + 8, outputBlock, 8);
ATERM_81405254(expandedKey, rounds, stateBytes, stateBytes);
ATERMAesEncryptBlock(expandedKey, rounds, stateBytes, stateBytes);
counter.value = (u64)(s64)blockIndex + passBase;
stateBytes[0] ^= counter.bytes[0];
stateBytes[1] ^= counter.bytes[1];
@@ -1918,7 +1918,7 @@ int ATERM_81404844(u16* destination, u16* source, u32 length, void* key, u32 key
return 1;
}
int ATERM_81404A18(u16* destination, u16* source, u32 length, void* key, u32 keyLength) {
int ATERMAesKeyUnwrap(u16* destination, u16* source, u32 length, void* key, u32 keyLength) {
u32 expandedKey[80];
union { u32 words[4]; u8 bytes[16]; } block;
union { u64 value; u8 bytes[8]; } counter;
@@ -1942,7 +1942,7 @@ int ATERM_81404A18(u16* destination, u16* source, u32 length, void* key, u32 key
return 0;
}
rounds = ATERM_8140502C(expandedKey, key, keyLength << 3);
rounds = ATERMAesExpandDecryptKey(expandedKey, key, keyLength << 3);
destinationBytes = (u8*)destination;
sourceBytes = (const u8*)source;
memcpy(block.words, sourceBytes, 8);
@@ -1963,7 +1963,7 @@ int ATERM_81404A18(u16* destination, u16* source, u32 length, void* key, u32 key
stateBytes[6] ^= counter.bytes[6];
stateBytes[7] ^= counter.bytes[7];
memcpy(stateBytes + 8, outputBlock, 8);
ATERM_81405690(expandedKey, rounds, stateBytes, stateBytes);
ATERMAesDecryptBlock(expandedKey, rounds, stateBytes, stateBytes);
memcpy(outputBlock, stateBytes + 8, 8);
}
}
@@ -1986,7 +1986,7 @@ int ATERM_81404A18(u16* destination, u16* source, u32 length, void* key, u32 key
((u32)keyBytes[(index) * 4 + 2] << 8) ^ \
keyBytes[(index) * 4 + 3])
int ATERM_81404BFC(u32* expandedKey, const void* key, u32 keyBits) {
int ATERMAesExpandEncryptKey(u32* expandedKey, const void* key, u32 keyBits) {
const u8* keyBytes = (const u8*)key;
u32* roundKey = expandedKey;
@@ -2096,8 +2096,8 @@ int ATERM_81404BFC(u32* expandedKey, const void* key, u32 keyBits) {
(inverseTable0[byte0] ^ inverseTable1[byte1]); \
}
int ATERM_8140502C(u32* expandedKey, const void* key, u32 keyBits) {
int rounds = ATERM_81404BFC(expandedKey, key, keyBits);
int ATERMAesExpandDecryptKey(u32* expandedKey, const void* key, u32 keyBits) {
int rounds = ATERMAesExpandEncryptKey(expandedKey, key, keyBits);
u32* roundKey;
s32 roundCount;
s32 firstIndex;
@@ -2145,7 +2145,7 @@ int ATERM_8140502C(u32* expandedKey, const void* key, u32 keyBits) {
#undef ATERM_AES_TRANSFORM_KEY
void ATERM_81405254(const u32* expandedKey, u32 rounds, const u8* input, u8* output) {
void ATERMAesEncryptBlock(const u32* expandedKey, u32 rounds, const u8* input, u8* output) {
u32 state0, state1, state2, state3;
u32 next0, next1, next2, next3;
s32 roundPairs;
@@ -2232,7 +2232,7 @@ void ATERM_81405254(const u32* expandedKey, u32 rounds, const u8* input, u8* out
output[15] = state3;
}
void ATERM_81405690(const u32* expandedKey, u32 rounds, const u8* input, u8* output) {
void ATERMAesDecryptBlock(const u32* expandedKey, u32 rounds, const u8* input, u8* output) {
u32 state0, state1, state2, state3;
u32 next0, next1, next2, next3;
s32 roundPairs;
@@ -2319,9 +2319,9 @@ void ATERM_81405690(const u32* expandedKey, u32 rounds, const u8* input, u8* out
output[15] = state3;
}
void ATERM_81405D0C(u32 state[4], const u8 block[64]);
void ATERMMd5Transform(u32 state[4], const u8 block[64]);
void ATERM_81405ACC(AtermMd5Context* context, void* input, u32 length) {
void ATERMMd5Update(AtermMd5Context* context, void* input, u32 length) {
u8* data = (u8*)input;
u32 bufferIndex = (context->bitCountLow >> 3) & 0x3F;
u32 bytesToFill;
@@ -2338,9 +2338,9 @@ void ATERM_81405ACC(AtermMd5Context* context, void* input, u32 length) {
for (copiedBytes = 0; copiedBytes < bytesToFill; copiedBytes++) {
context->buffer8[bufferIndex + copiedBytes] = data[copiedBytes];
}
ATERM_81405D0C(context->state, context->buffer8);
ATERMMd5Transform(context->state, context->buffer8);
for (copiedBytes = bytesToFill; copiedBytes + 63 < length; copiedBytes += 64) {
ATERM_81405D0C(context->state, data + copiedBytes);
ATERMMd5Transform(context->state, data + copiedBytes);
}
bufferIndex = 0;
} else {
@@ -2358,7 +2358,7 @@ void ATERM_81405ACC(AtermMd5Context* context, void* input, u32 length) {
(A) += (B); \
} while (0)
void ATERM_81405D0C(u32 state[4], const u8 block[64]) {
void ATERMMd5Transform(u32 state[4], const u8 block[64]) {
u32 byteIndex;
u32 index;
const u8* inputWord;
@@ -2452,7 +2452,7 @@ void ATERM_81405D0C(u32 state[4], const u8 block[64]) {
}
#undef ATERM_MD5_STEP
void ATERM_8140684C(OSAlarm* alarm, OSContext* context) {
void ATERMAlarmWakeQueue(OSAlarm* alarm, OSContext* context) {
OSMessageQueue* queue = (OSMessageQueue*)alarm->tag;
OSSendMessage(queue, NULL, 0);
}
@@ -2525,7 +2525,7 @@ int ATERMi_ApConfigEnd(void) {
OSSetAlarmTag(&cancelAlarm, (u32)&cancelQueue);
OSSetAlarm(&cancelAlarm,
OSMillisecondsToTicks(100),
ATERM_8140684C);
ATERMAlarmWakeQueue);
OSReceiveMessage(&cancelQueue, &cancelMessage, 1);
}
@@ -2534,7 +2534,7 @@ int ATERMi_ApConfigEnd(void) {
OSSetAlarmTag(&joinAlarm, (u32)&joinQueue);
OSSetAlarm(&joinAlarm,
OSMillisecondsToTicks(500),
ATERM_8140684C);
ATERMAlarmWakeQueue);
OSReceiveMessage(&joinQueue, &joinMessage, 1);
while (OSIsThreadTerminated(&sAtermThread) == 0) {
OSJoinThread(&sAtermThread, NULL);

View File

@@ -64,6 +64,11 @@ namespace ipl {
static s32 sAOSSState;
static s32 sAOSSUnk;
struct AOSSStack {
u32 storage[4080];
u32 sentinel;
};
class AOSSThread : public utility::ut_thread {
public:
AOSSThread(EGG::Heap* heap);
@@ -84,7 +89,7 @@ namespace ipl {
private:
s32 mState; // 0x32C
s32 mThreadPriority; // 0x330
u8* mpStackBuffer; // 0x334
AOSSStack* mpStack; // 0x334
u8* mpHeapBuffer; // 0x338
MEMHeapHandle mpExpHeap; // 0x33C
AOSSConfig mAoss; // 0x340
@@ -94,7 +99,7 @@ namespace ipl {
mpExpHeap = NULL;
sAOSSState = 0;
mpHeapBuffer = (u8*)heap->alloc(0x40000, 0x20);
mpStackBuffer = (u8*)heap->alloc(0x1000, 0x20);
mpStack = (AOSSStack*)heap->alloc(0x1000, 0x20);
}
void AOSSThread::destroy(int flag) {
@@ -137,8 +142,8 @@ namespace ipl {
mThreadPriority = OSGetThreadPriority(OSGetCurrentThread()) - 2;
sAOSSState = 1;
SOInit(&config);
memset(mpStackBuffer, 0, 4);
Create(mpStackBuffer, 0x1000, mThreadPriority, TRUE);
memset(mpStack, 0, 4);
Create(mpStack, 0x1000, mThreadPriority, TRUE);
OSRestoreInterrupts(level);
return 1;
@@ -178,7 +183,7 @@ namespace ipl {
mAoss.unk_0x04 = 4;
NETGetWirelessMacAddress(mAoss.mac);
*(u32*)(mpStackBuffer + 0x3FC0) = 0x97654321;
mpStack->sentinel = 0x97654321;
mState = AOSSi_Init(&mAoss);
AOSSi_EndLocal();

View File

@@ -28,26 +28,26 @@ int ATERMi_ApConfigEnd();
namespace ipl {
namespace scene {
extern "C" MEMAllocator RakuRakuThread_810BDDD0;
MEMAllocator RakuRakuThread_810BDDD0;
extern "C" MEMAllocator sRakuAllocator;
MEMAllocator sRakuAllocator;
struct RakuStatus {
RakuProgress progress;
RakuConfiguration configuration;
};
extern "C" RakuStatus RakuRakuThread_810BDDE0;
RakuStatus RakuRakuThread_810BDDE0;
extern "C" OSMessageQueue RakuRakuThread_810BDED4;
OSMessageQueue RakuRakuThread_810BDED4;
extern "C" RakuStatus sRakuStatus;
RakuStatus sRakuStatus;
extern "C" OSMessageQueue sRakuMsgQueue;
OSMessageQueue sRakuMsgQueue;
static OSTime startTime;
static bool active;
static OSMessage messageSlot;
static int displayState = 1;
extern "C" {
static void* RakuRakuThread_813FDEF0(u32, s32 size);
static void RakuRakuThread_813FDEFC(u32, void* block, s32);
static void* RakuRakuThread_813FDF08(u32 size);
static void RakuRakuThread_813FDF18(void* block);
static void* RakuSocketAlloc(u32, s32 size);
static void RakuSocketFree(u32, void* block, s32);
static void* RakuAtermAlloc(u32 size);
static void RakuAtermFree(void* block);
}
struct RakuStack {
@@ -60,7 +60,7 @@ public:
virtual ~RakuRakuThread();
virtual void* Run();
virtual void unk_0x2C() = 0;
void RakuRakuThread_813FDA04();
void syncRakuProgress();
static void progressCallback(RakuProgress* progress);
void destroy();
int start();
@@ -78,15 +78,15 @@ private:
MEMHeapHandle mHeap;
};
void RakuRakuThread::RakuRakuThread_813FDA04() {
void RakuRakuThread::syncRakuProgress() {
BOOL interrupts = OSDisableInterrupts();
RakuRakuThread_810BDDE0.progress = *(RakuProgress*)this;
sRakuStatus.progress = *(RakuProgress*)this;
startTime = OSGetTime();
OSRestoreInterrupts(interrupts);
}
void RakuRakuThread::progressCallback(RakuProgress* progress) {
((RakuRakuThread*)progress)->RakuRakuThread_813FDA04();
((RakuRakuThread*)progress)->syncRakuProgress();
}
RakuRakuThread::RakuRakuThread(EGG::Heap* heap) : utility::ut_thread() {
@@ -101,12 +101,12 @@ RakuRakuThread::RakuRakuThread(EGG::Heap* heap) : utility::ut_thread() {
active = false;
mFinished = 0;
mRunning = 0;
OSInitMessageQueue(&RakuRakuThread_810BDED4, &messageSlot, 1);
OSInitMessageQueue(&sRakuMsgQueue, &messageSlot, 1);
}
RakuRakuThread::~RakuRakuThread() {
if (mRunning) {
OSJamMessage(&RakuRakuThread_810BDED4, (OSMessage)2, 1);
OSJamMessage(&sRakuMsgQueue, (OSMessage)2, 1);
WaitForThreadExit();
}
destroy();
@@ -114,7 +114,7 @@ RakuRakuThread::~RakuRakuThread() {
void RakuRakuThread::destroy() {
if (active) {
OSSendMessage(&RakuRakuThread_810BDED4, (OSMessage)1, 0);
OSSendMessage(&sRakuMsgQueue, (OSMessage)1, 0);
u32 start = OSGetTick();
while ((u32)(OSGetTick() - start) / (OS_TIMER_CLOCK / 1000) < 2000) {
RakuProgress progress;
@@ -127,7 +127,7 @@ void RakuRakuThread::destroy() {
}
if (mHeap != NULL) {
MEMDestroyExpHeap(mHeap);
memset(&RakuRakuThread_810BDDD0, 0, sizeof(MEMAllocator));
memset(&sRakuAllocator, 0, sizeof(MEMAllocator));
mHeap = NULL;
}
}
@@ -139,19 +139,19 @@ int RakuRakuThread::start() {
BOOL interrupts = OSDisableInterrupts();
startTime = OSGetTime();
mHeap = MEMCreateExpHeapEx(mHeapBuffer, 0x40000, 2);
MEMInitAllocatorForExpHeap(&RakuRakuThread_810BDDD0, mHeap, 32);
MEMInitAllocatorForExpHeap(&sRakuAllocator, mHeap, 32);
mPriority = OSGetThreadPriority(OSGetCurrentThread()) - 1;
active = true;
mFinished = 0;
memset(&RakuRakuThread_810BDDE0.configuration, 0, sizeof(RakuConfiguration));
memset(&RakuRakuThread_810BDDE0.progress, 0, sizeof(RakuProgress));
memset(&sRakuStatus.configuration, 0, sizeof(RakuConfiguration));
memset(&sRakuStatus.progress, 0, sizeof(RakuProgress));
SOLibraryConfig socketConfig;
socketConfig.alloc = RakuRakuThread_813FDEF0;
socketConfig.free = RakuRakuThread_813FDEFC;
socketConfig.alloc = RakuSocketAlloc;
socketConfig.free = RakuSocketFree;
SOInit(&socketConfig);
ATERMi_ApConfigStart(mPriority, 200,
progressCallback,
RakuRakuThread_813FDF08, RakuRakuThread_813FDF18, 4096);
RakuAtermAlloc, RakuAtermFree, 4096);
if (!mRunning) {
mRunning = 1;
memset(mStack, 0, 4);
@@ -165,12 +165,12 @@ int RakuRakuThread::start() {
void* RakuRakuThread::Run() {
OSMessage message;
while (true) {
while (OSReceiveMessage(&RakuRakuThread_810BDED4, &message, 0)) {
while (OSReceiveMessage(&sRakuMsgQueue, &message, 0)) {
if ((s32)message == 2) {
return this;
}
}
OSReceiveMessage(&RakuRakuThread_810BDED4, &message, 1);
OSReceiveMessage(&sRakuMsgQueue, &message, 1);
if ((s32)message == 2) {
break;
}
@@ -184,17 +184,17 @@ void* RakuRakuThread::Run() {
return this;
}
static void* RakuRakuThread_813FDEF0(u32, s32 size) {
return MEMAllocFromAllocator(&RakuRakuThread_810BDDD0, size);
static void* RakuSocketAlloc(u32, s32 size) {
return MEMAllocFromAllocator(&sRakuAllocator, size);
}
static void RakuRakuThread_813FDEFC(u32, void* block, s32) {
MEMFreeToAllocator(&RakuRakuThread_810BDDD0, block);
static void RakuSocketFree(u32, void* block, s32) {
MEMFreeToAllocator(&sRakuAllocator, block);
}
static void* RakuRakuThread_813FDF08(u32 size) {
return MEMAllocFromAllocator(&RakuRakuThread_810BDDD0, size);
static void* RakuAtermAlloc(u32 size) {
return MEMAllocFromAllocator(&sRakuAllocator, size);
}
static void RakuRakuThread_813FDF18(void* block) {
MEMFreeToAllocator(&RakuRakuThread_810BDDD0, block);
static void RakuAtermFree(void* block) {
MEMFreeToAllocator(&sRakuAllocator, block);
}
int RakuRakuThread::getState() {
@@ -202,7 +202,7 @@ int RakuRakuThread::getState() {
return 0;
}
BOOL interrupts = OSDisableInterrupts();
switch (RakuRakuThread_810BDDE0.progress.state) {
switch (sRakuStatus.progress.state) {
case 1: displayState = 1; break;
case 2: displayState = 2; break;
case 3: displayState = 2; break;
@@ -214,14 +214,14 @@ int RakuRakuThread::getState() {
}
if (displayState != 6 && displayState != 7 &&
((u32)OSGetTime() - (u32)startTime) / (OS_TIMER_CLOCK / 1000) >= 90000) {
OSSendMessage(&RakuRakuThread_810BDED4, (OSMessage)1, 0);
OSSendMessage(&sRakuMsgQueue, (OSMessage)1, 0);
}
OSRestoreInterrupts(interrupts);
return displayState;
}
int RakuRakuThread::cancel() {
return OSSendMessage(&RakuRakuThread_810BDED4, (OSMessage)1, 0);
return OSSendMessage(&sRakuMsgQueue, (OSMessage)1, 0);
}
int RakuRakuThread::finish(NCDApConfig* config, int* result) {
@@ -231,23 +231,23 @@ int RakuRakuThread::finish(NCDApConfig* config, int* result) {
}
return 1;
}
s32 state = RakuRakuThread_810BDDE0.progress.state;
s32 state = sRakuStatus.progress.state;
if ((u32)(state - 6) > 1) {
return 0;
}
if (!mFinished) {
if (state == 6) {
ATERMi_ApConfigGetResult(&RakuRakuThread_810BDDE0.configuration);
ATERMi_ApConfigGetResult(&sRakuStatus.configuration);
printInfo();
}
OSSendMessage(&RakuRakuThread_810BDED4, (OSMessage)1, 0);
OSSendMessage(&sRakuMsgQueue, (OSMessage)1, 0);
return 0;
}
SOFinish();
active = false;
destroy();
if (config != NULL) {
RakuConfiguration* settings = &RakuRakuThread_810BDDE0.configuration;
RakuConfiguration* settings = &sRakuStatus.configuration;
memcpy(config->ssid, settings->ssid, 32);
config->ssidLength = strlen(settings->ssid);
if (settings->security == 1) {
@@ -273,7 +273,7 @@ int RakuRakuThread::finish(NCDApConfig* config, int* result) {
}
}
if (result != NULL) {
*result = RakuRakuThread_810BDDE0.progress.result;
*result = sRakuStatus.progress.result;
}
return 1;
}

View File

@@ -1,3 +1,7 @@
#define IPL_CONTROLLER_TRIVIAL_RECT_DTOR
#include <nw4r/ut/Rect.h>
#undef IPL_CONTROLLER_TRIVIAL_RECT_DTOR
#include "system/iplSystem.h"
#include "system/iplNand.h"
#include "utility/iplGraphics.h"

View File

@@ -10,9 +10,9 @@
namespace ipl {
namespace scene {
TextBalloon::TextBalloon(EGG::Heap* heap, nand::LayoutFile* layoutFile, const char* directory, const char* fileName, const math::VEC3& unk2,
f32 unk3, f32 unk4)
: unk_0x08(FALSE), mpText(NULL), mTextLen(0), mBalloonPos(unk2), unk_0x28(0), unk_0x2C(1), unk_0x30(unk3), unk_0x34(unk4),
TextBalloon::TextBalloon(EGG::Heap* heap, nand::LayoutFile* layoutFile, const char* directory, const char* fileName, const math::VEC3& initialPos,
f32 margin16x9, f32 margin4x3)
: mbWaitingFadeIn(FALSE), mpText(NULL), mTextLen(0), mBalloonPos(initialPos), mHAlign(0), mbUse16x9X(1), mMargin16x9(margin16x9), mMargin4x3(margin4x3),
mWaitUntilFadeIn(0) {
mpLayout = new (heap, 4) layout::Object(heap, layoutFile, directory, fileName);
mpLayout->bind("my_IplTopBalloon_a_BalloonInOut.brlan");
@@ -31,7 +31,7 @@ namespace ipl {
void TextBalloon::calc() {
mpLayout->calc();
switch (unk_0x08) {
switch (mbWaitingFadeIn) {
case TRUE: {
break;
}
@@ -73,7 +73,7 @@ namespace ipl {
balloonPane->SetVisible(false);
unk_0x08 = FALSE;
mbWaitingFadeIn = FALSE;
}
void TextBalloon::fadein() {
@@ -81,7 +81,7 @@ namespace ipl {
mpLayout->FindPaneByName("N_Balloon")->SetVisible(false);
mWaitUntilFadeIn = 0;
unk_0x08 = TRUE;
mbWaitingFadeIn = TRUE;
set_textbox(mpText);
set_translate(mBalloonPos);
@@ -91,17 +91,17 @@ namespace ipl {
void TextBalloon::fadeinNoSetTextbox() {
if (mpText != NULL) {
mWaitUntilFadeIn = 0;
unk_0x08 = TRUE;
mbWaitingFadeIn = TRUE;
set_translate(mBalloonPos);
}
}
void TextBalloon::setPos(const math::VEC3& pos, bool unk0, int unk1) {
void TextBalloon::setPos(const math::VEC3& pos, bool use16x9X, int hAlign) {
mBalloonPos = pos;
unk_0x28 = unk1;
unk_0x2C = unk0;
mHAlign = hAlign;
mbUse16x9X = use16x9X;
nw4r::ut::Rect proj16x9;
nw4r::ut::Rect proj4x3;
@@ -109,7 +109,7 @@ namespace ipl {
System::getProjectionRect(&proj16x9);
System::getProjectionRect4x3(&proj4x3);
if (unk_0x2C == 0) {
if (mbUse16x9X == 0) {
mBalloonPos.x *= proj4x3.GetWidth() / proj16x9.GetWidth();
}
}
@@ -122,7 +122,7 @@ namespace ipl {
System::getProjectionRect(&proj16x9);
System::getProjectionRect4x3(&proj4x3);
if (unk_0x2C == 0) {
if (mbUse16x9X == 0) {
mBalloonPos.x *= proj4x3.GetWidth() / proj16x9.GetWidth();
}
@@ -133,27 +133,27 @@ namespace ipl {
if (mWaitUntilFadeIn++ > WAIT_UNTIL_FADE_IN) {
anm_fadein();
snd::getSystem()->startSE("WIPL_SE_BALLOON");
unk_0x08 = FALSE;
mbWaitingFadeIn = FALSE;
}
}
void TextBalloon::fadeout() {
if (!unk_0x08) {
if (!mbWaitingFadeIn) {
mpLayout->setAnmType(ANIM_TYPE_BACKWARD);
mpLayout->start();
}
unk_0x08 = FALSE;
mbWaitingFadeIn = FALSE;
}
void TextBalloon::fadeoutForce() {
if (!unk_0x08) {
if (!mbWaitingFadeIn) {
if (mpLayout->getAnim()->getAnmType() == ANIM_TYPE_FORWARD) {
mpLayout->getAnim()->setAnmType(ANIM_TYPE_BACKWARD);
mpLayout->getAnim()->restart();
}
} else if (unk_0x08 == TRUE) {
} else if (mbWaitingFadeIn == TRUE) {
mWaitUntilFadeIn = 0;
unk_0x08 = FALSE;
mbWaitingFadeIn = FALSE;
}
}
@@ -167,9 +167,9 @@ namespace ipl {
f32 temp0;
if (SCGetAspectRatio() == SC_ASPECT_RATIO_16x9) {
temp0 = unk_0x30;
temp0 = mMargin16x9;
} else {
temp0 = unk_0x34;
temp0 = mMargin4x3;
}
nw4r::lyt::Pane* balloonPane = mpLayout->FindPaneByName("N_Balloon");
@@ -181,7 +181,7 @@ namespace ipl {
System::getProjectionRect(&proj16x9);
System::getProjectionRect4x3(&proj4x3);
switch (unk_0x28) {
switch (mHAlign) {
case 1: {
temp1 = get_size("W_Base")->width / 2;
break;
@@ -192,7 +192,7 @@ namespace ipl {
}
}
if (unk_0x2C == 0) {
if (mbUse16x9X == 0) {
temp1 *= proj4x3.GetWidth() / proj16x9.GetWidth();
}

View File

@@ -20,10 +20,10 @@ extern "C" {
extern "C" void _seBlk__Q23ipl3snd();
extern "C" nw4r::snd::SoundHandle* _mainBGMHandle__Q23ipl3snd;
extern "C" const f32 scSoundZeroF;
extern "C" const f32 lbl_816946AC;
extern "C" const f32 lbl_816946A8;
extern "C" const f32 lbl_816946B0;
extern "C" const f32 lbl_816946B4;
extern "C" const f32 scSoundOneF;
extern "C" const f32 scSoundTwoF;
extern "C" const f32 scSoundThirtyF;
extern "C" const f32 scSoundSixtyF;
extern "C" {
void _savegpr_29();
void pauseOffSE__Q33ipl3snd6SystemFv();
@@ -500,21 +500,21 @@ namespace snd {
if (block->handle.detail_GetAttachedSound() != NULL) {
block->handle.detail_GetAttachedSound()->SetPan(pan);
}
f32 pitch = lbl_816946A8 * y / rect.right;
if (lbl_816946AC < pitch) {
pitch = lbl_816946AC;
f32 pitch = scSoundTwoF * y / rect.right;
if (scSoundOneF < pitch) {
pitch = scSoundOneF;
}
if (block->handle.detail_GetAttachedSound() != NULL) {
block->handle.detail_GetAttachedSound()->SetVolume(pitch, 0);
}
if (lbl_816946B0 < y) {
f32 pitch2 = y / lbl_816946B0;
if (scSoundThirtyF < y) {
f32 pitch2 = y / scSoundThirtyF;
if (block->handle.detail_GetAttachedSound() != NULL) {
block->handle.detail_GetAttachedSound()->SetPitch(pitch2);
}
} else if (lbl_816946B4 < y) {
} else if (scSoundSixtyF < y) {
if (block->handle.detail_GetAttachedSound() != NULL) {
block->handle.detail_GetAttachedSound()->SetPitch(lbl_816946A8);
block->handle.detail_GetAttachedSound()->SetPitch(scSoundTwoF);
}
}
return (int)block;

View File

@@ -0,0 +1,213 @@
"""Compare relocated switch destinations after checking instructions with ctxdiff.
Usage: python jump_table_diff.py <unit> <function> [--table <reference-symbol>]
Paths follow ctxdiff.py: build/43U/{src,obj}/<unit>.o. Requires pyelftools.
Exit 0: all selected tables match (or no tables); 1: mismatch; 2: invalid or
ambiguous input. This checks relative destinations, not behavioral equivalence.
Automatic selection covers local jumptable_* symbols whose R_PPC_ADDR32 entries
all target the selected function. External callback tables/vtables are not
covered. Source locations are inferred from corresponding function relocations,
never from an assumption that both data sections have the same layout.
"""
import argparse
from dataclasses import dataclass
from pathlib import Path
import sys
from elftools.common.exceptions import ELFError
from elftools.elf.elffile import ELFFile
@dataclass(frozen=True)
class Symbol:
name: str
section: object
value: int
size: int
kind: str = "STT_OBJECT"
@dataclass(frozen=True)
class Relocation:
offset: int
kind: int
symbol: int
addend: int
@dataclass
class ObjectInfo:
sections: dict
symbols: list
relocations: dict
def symbol(self, name):
found = [s for s in self.symbols if s.name == name
and isinstance(s.section, int) and s.size]
if len(found) != 1:
raise ValueError("expected one defined symbol: " + name)
symbol = found[0]
if (symbol.section not in self.sections or symbol.value < 0
or symbol.size <= 0
or symbol.value + symbol.size > self.sections[symbol.section][1]):
raise ValueError("symbol is outside its section: " + name)
return symbol
def location(self, relocation):
if not 0 <= relocation.symbol < len(self.symbols):
raise ValueError("relocation symbol index is out of range")
symbol = self.symbols[relocation.symbol]
if not isinstance(symbol.section, int):
return None
if symbol.section not in self.sections:
raise ValueError("relocation symbol has an invalid section")
return symbol.section, symbol.value + relocation.addend
def relocs(self, section):
return self.relocations.get(section, {})
def read_object(path):
with open(path, "rb") as stream:
elf = ELFFile(stream)
if (elf.elfclass != 32 or elf.little_endian
or elf["e_machine"] != "EM_PPC" or elf["e_type"] != "ET_REL"):
raise ValueError("expected a relocatable big-endian ELF32 PowerPC object")
symtab = elf.get_section_by_name(".symtab")
if symtab is None:
raise ValueError("object has no .symtab")
symbols = [Symbol(s.name, s["st_shndx"], s["st_value"], s["st_size"],
s["st_info"]["type"]) for s in symtab.iter_symbols()]
sections = {}
relocations = {}
for index, section in enumerate(elf.iter_sections()):
sections[index] = (section.name, section["sh_size"])
if section["sh_type"] == "SHT_REL":
raise ValueError("REL relocations are unsupported; expected RELA")
if section["sh_type"] != "SHT_RELA":
continue
if elf.get_section(section["sh_link"]).name != ".symtab":
raise ValueError("relocation uses a different symbol table")
entries = relocations.setdefault(section["sh_info"], {})
for r in section.iter_relocations():
if r["r_offset"] in entries:
raise ValueError("multiple relocations at the same offset")
entries[r["r_offset"]] = Relocation(
r["r_offset"], r["r_info_type"], r["r_info_sym"], r["r_addend"])
return ObjectInfo(sections, symbols, relocations)
def jump_target(obj, relocation, function):
if relocation is None or relocation.kind != 1: # R_PPC_ADDR32
return None
location = obj.location(relocation)
if location is None or location[0] != function.section:
return None
offset = location[1] - function.value
if offset < 0 or offset >= function.size or offset % 4:
return None
return offset
def reference_tables(obj, function, name=None):
candidates = [obj.symbol(name)] if name else [
s for s in obj.symbols if s.name.startswith("jumptable_") and s.size]
result = []
for table in candidates:
if not isinstance(table.section, int) or table.size % 4:
if name:
raise ValueError("invalid reference table extent")
continue
section_size = obj.sections[table.section][1]
if table.value < 0 or table.value + table.size > section_size:
raise ValueError("reference table is outside its section")
targets = [jump_target(obj, obj.relocs(table.section).get(offset), function)
for offset in range(table.value, table.value + table.size, 4)]
if targets and all(target is not None for target in targets):
result.append((table, targets))
elif name:
raise ValueError("reference table does not target the selected function")
return result
def source_table_location(source, reference, source_fn, reference_fn, table):
if source_fn.size != reference_fn.size:
raise ValueError("function sizes differ; check ctxdiff before table matching")
locations = set()
for relocation in reference.relocs(reference_fn.section).values():
if not reference_fn.value <= relocation.offset < reference_fn.value + reference_fn.size:
continue
if reference.location(relocation) != (table.section, table.value):
continue
offset = source_fn.value + relocation.offset - reference_fn.value
other = source.relocs(source_fn.section).get(offset)
if other is None or other.kind != relocation.kind:
raise ValueError("table-reference relocations differ; check ctxdiff")
location = source.location(other)
if location is None:
raise ValueError("source table reference is undefined")
if source.sections[location[0]][0] != reference.sections[table.section][0]:
raise ValueError("source table resolves to a different section")
locations.add(location)
if len(locations) != 1:
raise ValueError("cannot infer one source table from function relocations")
section, offset = next(iter(locations))
sizes = {s.size for s in source.symbols if s.section == section
and s.value == offset and s.size and s.kind != "STT_SECTION"}
if len(sizes) != 1:
raise ValueError("source table extent is missing or ambiguous")
size = next(iter(sizes))
if size % 4 or offset < 0 or offset + size > source.sections[section][1]:
raise ValueError("invalid source table extent")
return section, offset, size
def compare_table(source, reference, source_fn, reference_fn, table, expected):
section, offset, size = source_table_location(
source, reference, source_fn, reference_fn, table)
actual = [jump_target(source, source.relocs(section).get(i), source_fn)
for i in range(offset, offset + size, 4)]
differences = []
for i in range(max(len(actual), len(expected))):
src = actual[i] if i < len(actual) else None
ref = expected[i] if i < len(expected) else None
if i >= min(len(actual), len(expected)) or src != ref:
differences.append((i, src, ref))
return actual, differences
def main(argv=None):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("unit", help="e.g. src/scene/sdChannelSelect/iplSDChannelSelect")
parser.add_argument("function", help="exact function symbol used by ctxdiff")
parser.add_argument("--table", help="optional exact reference jump-table symbol")
args = parser.parse_args(argv)
try:
source = read_object(Path("build/43U/src") / (args.unit + ".o"))
reference = read_object(Path("build/43U/obj") / (args.unit + ".o"))
source_fn = source.symbol(args.function)
reference_fn = reference.symbol(args.function)
tables = reference_tables(reference, reference_fn, args.table)
mismatch = False
for table, expected in tables:
actual, differences = compare_table(
source, reference, source_fn, reference_fn, table, expected)
matched = sum(a == b for a, b in zip(actual, expected))
print("%s: %d/%d entries match (source=%d reference=%d)" %
(table.name, matched, len(expected), len(actual), len(expected)))
for index, src, ref in differences:
src_text = "unresolved/missing" if src is None else "+0x%X" % src
ref_text = "missing" if ref is None else "+0x%X" % ref
print(" [%d] source %s; reference %s" % (index, src_text, ref_text))
mismatch |= bool(differences)
print("Compared %d jump table(s); instruction correctness requires ctxdiff." % len(tables))
return 1 if mismatch else 0
except (OSError, ValueError, ELFError) as error:
print("ERROR: %s" % error, file=sys.stderr)
return 2
if __name__ == "__main__":
sys.exit(main())

View File

@@ -0,0 +1,159 @@
import contextlib
from dataclasses import replace
import io
import unittest
from unittest.mock import patch
import jump_table_diff as tool
def fixture(entries=(0x10, 0x20, 0x30), function_offset=0x100,
table_offset=0x40, source=False, section_ids=(1, 2)):
text, data = section_ids
symbols = [
tool.Symbol("dispatch", text, function_offset, 0x80, "STT_FUNC"),
tool.Symbol("@123" if source else "jumptable_test", data,
table_offset, len(entries) * 4),
]
references = {
text: {
function_offset + 2: tool.Relocation(function_offset + 2, 6, 1, 0),
function_offset + 6: tool.Relocation(function_offset + 6, 4, 1, 0),
},
data: {table_offset + i * 4: tool.Relocation(table_offset + i * 4, 1, 0, value)
for i, value in enumerate(entries)},
}
return tool.ObjectInfo({text: (".text", 0x1000), data: (".data", 0x1000)},
symbols, references)
def compare(source, reference=None):
reference = reference or fixture()
src_fn = source.symbol("dispatch")
ref_fn = reference.symbol("dispatch")
table, expected = tool.reference_tables(reference, ref_fn, "jumptable_test")[0]
return tool.compare_table(source, reference, src_fn, ref_fn, table, expected)
class JumpTableTests(unittest.TestCase):
def test_infers_shifted_source_table_and_function(self):
source = fixture(source=True, function_offset=0x200, table_offset=0x90,
section_ids=(3, 4))
self.assertEqual(compare(source), ([0x10, 0x20, 0x30], []))
def test_detects_swapped_destinations_despite_same_function_size(self):
actual, differences = compare(fixture((0x20, 0x10, 0x30), source=True))
self.assertEqual(actual, [0x20, 0x10, 0x30])
self.assertEqual(differences, [(0, 0x20, 0x10), (1, 0x10, 0x20)])
def test_section_relative_code_reference(self):
source = fixture(source=True, table_offset=0x90)
source.symbols.append(tool.Symbol("", 2, 0, 0, "STT_SECTION"))
for offset, relocation in list(source.relocations[1].items()):
source.relocations[1][offset] = replace(relocation, symbol=2, addend=0x90)
self.assertEqual(compare(source)[1], [])
def test_section_relative_table_entries(self):
source = fixture(source=True)
source.symbols.append(tool.Symbol("", 1, 0, 0, "STT_SECTION"))
for offset, relocation in list(source.relocations[2].items()):
source.relocations[2][offset] = replace(
relocation, symbol=2, addend=0x100 + relocation.addend)
self.assertEqual(compare(source)[1], [])
def test_missing_entry_is_mismatch(self):
source = fixture(source=True)
del source.relocations[2][0x44]
self.assertEqual(compare(source)[1], [(1, None, 0x20)])
def test_wrong_relocation_kind_is_mismatch(self):
source = fixture(source=True)
source.relocations[2][0x44] = replace(source.relocations[2][0x44], kind=10)
self.assertEqual(compare(source)[1], [(1, None, 0x20)])
def test_out_of_function_destination_is_mismatch(self):
source = fixture(source=True)
source.relocations[2][0x44] = replace(source.relocations[2][0x44], addend=0x80)
self.assertEqual(compare(source)[1], [(1, None, 0x20)])
def test_extra_source_entry_is_not_a_pass(self):
self.assertEqual(compare(fixture((0x10, 0x20, 0x30, 0x40), source=True))[1],
[(3, 0x40, None)])
def test_short_source_table_is_not_a_pass(self):
self.assertEqual(compare(fixture((0x10, 0x20), source=True))[1],
[(2, None, 0x30)])
def test_different_function_sizes_reject_inference(self):
source = fixture(source=True)
source.symbols[0] = replace(source.symbols[0], size=0x84)
with self.assertRaisesRegex(ValueError, "function sizes differ"):
compare(source)
def test_disagreeing_code_references_reject_inference(self):
source = fixture(source=True)
source.relocations[1][0x106] = replace(source.relocations[1][0x106], addend=4)
with self.assertRaisesRegex(ValueError, "infer one source table"):
compare(source)
def test_missing_code_reference_rejects_inference(self):
source = fixture(source=True)
del source.relocations[1][0x106]
with self.assertRaisesRegex(ValueError, "table-reference relocations differ"):
compare(source)
def test_ambiguous_source_extent_rejects_inference(self):
source = fixture(source=True)
source.symbols.append(tool.Symbol("alias", 2, 0x40, 16))
with self.assertRaisesRegex(ValueError, "extent is missing or ambiguous"):
compare(source)
def test_different_source_section_rejects_inference(self):
source = fixture(source=True)
source.sections[2] = (".rodata", 0x1000)
with self.assertRaisesRegex(ValueError, "different section"):
compare(source)
def test_undefined_source_reference_rejects_inference(self):
source = fixture(source=True)
source.symbols[1] = replace(source.symbols[1], section="SHN_UNDEF")
with self.assertRaisesRegex(ValueError, "reference is undefined"):
compare(source)
def test_invalid_relocation_symbol_rejected(self):
source = fixture(source=True)
source.relocations[2][0x44] = replace(source.relocations[2][0x44], symbol=999)
with self.assertRaisesRegex(ValueError, "symbol index is out of range"):
compare(source)
def test_duplicate_function_rejected(self):
source = fixture(source=True)
source.symbols.append(source.symbols[0])
with self.assertRaisesRegex(ValueError, "one defined symbol"):
compare(source)
def test_out_of_section_symbol_rejected(self):
source = fixture(source=True)
source.symbols[0] = replace(source.symbols[0], size=0x2000)
with self.assertRaisesRegex(ValueError, "outside its section"):
compare(source)
def test_unrelated_reference_table_is_not_selected(self):
reference = fixture((0x80, 0x84, 0x88))
self.assertEqual(tool.reference_tables(reference, reference.symbol("dispatch")), [])
with self.assertRaisesRegex(ValueError, "does not target"):
tool.reference_tables(reference, reference.symbol("dispatch"), "jumptable_test")
def test_cli_exit_codes(self):
for source, expected_status in [(fixture(source=True), 0),
(fixture((0x20, 0x10, 0x30), source=True), 1)]:
with patch.object(tool, "read_object", side_effect=[source, fixture()]):
with contextlib.redirect_stdout(io.StringIO()):
self.assertEqual(tool.main(["unused", "dispatch"]), expected_status)
with patch.object(tool, "read_object", side_effect=ValueError("bad object")):
with contextlib.redirect_stderr(io.StringIO()):
self.assertEqual(tool.main(["unused", "dispatch"]), 2)
if __name__ == "__main__":
unittest.main()