Compare commits

...

263 Commits

Author SHA1 Message Date
Devin AI
c56cd025f6 misc1 attempts: UpdateThread lwzx reload analysis + wpformatter def-order variant
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 13:17:26 +00:00
Devin AI
f7e2e49fee iplESMisc: DUD titleId inline-deref + single-local reload decode (exact 449 insns, 89.53)
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 12:52:44 +00:00
Devin AI
154fb5b299 misc1.attempts: Getter_ web-binding analysis — 14 word diffs, scope experiments exhausted
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 12:06:53 +00:00
Devin AI
ebc8205b9d BS2Update: volatile State/EntriesCount decls — UpdateThread 92->94.3
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 11:59:43 +00:00
Devin AI
d20a1e062c BS2Mach: volatile decls for callback-touched flags (AbortFlag/RestartRequested/FatalErrorFlag/PartitionOpen/LoadingTitle) + vu16 hwreg stores — BS2Tick 1123->1117
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 11:52:38 +00:00
Devin AI
8b678466e3 misc1.attempts: BS2Tick decode batch + Getter_ exhaustion evidence
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 11:42:15 +00:00
Devin AI
c734c88148 BS2Tick: bootArea strncmp web + case-0x25 break/partition hoist + banner align + streaming local
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 11:32:40 +00:00
Devin AI
ab2ef1d510 BS2Mach .data: align carved literal names to MWCC emission (all 95 objects pair)
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 10:25:50 +00:00
Devin AI
9266adbb1a odh: s32 width web-class fix + mullw operand order; BS2UpdateInit arg4 analysis
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 10:05:23 +00:00
Devin AI
fb57813580 misc1.attempts: BS2Mach residuals — head weave, diAddr rotation, BS2Tick callee window
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 09:21:07 +00:00
Devin AI
d567b1017b BS2Mach: DivideCallback 100%, CheckBS2 99.51, .data inner-literal carving
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 09:17:41 +00:00
Devin AI
9958ebf072 www_wiisetting: data 100% (Getter_ strBuf removal aligns jumptable relocs; 121+2 symbols.txt literal renames). Getter_ 99.86: 2 web-rotation pairs
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 08:52:25 +00:00
Devin AI
7f29fb70a3 misc1: odh setQuantizationTable 100% + symbols.txt literal pairing
result-through-temp web split flips cdj_c_setQuantizationTable to 100%
(23/28 fns, matched_code 8320). Renamed orig lbl_ sdata2 literals to
emitted @NNNN names — pairs the LineConv11 float pool symbols.

Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 08:43:02 +00:00
Devin AI
035fe767c8 misc1: BS2UpdateInit 79.88 -> 94.0 via early &Flags0 def
pFlags = Flags0 materializes the bss base web in the prologue; MWCC
then anchors a callee reg (r30) and folds Flags1/Thread/stack addresses
as offsets, reproducing orig's fold codegen and savegpr_29 frame.
Residual: pFlags store (+2 insns), stack-top two-step (fold tie).

Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 08:37:01 +00:00
Devin AI
98f91a2475 misc1: AxAdpcmPlayer 100% — flip to Matching
In-loop pAxvpbBuf assignment births the &axVoiceBuf web after
coeffsBufB's (use order), reproducing orig's materialization order;
all in-loop uses routed through the alias so it stays a single
callee-pinned web (r17). 0 instruction diffs, matched_code 3088/3088,
matched_data 6476/6476, DOL sha1 verified.

Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 08:05:20 +00:00
Devin AI
7a9f07fc77 BS2Update: -sdata 8 extra_cflags for ...data.0 literal pool + sdata smalls
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 07:22:07 +00:00
Devin AI
0b1c20ee0f BS2Update volatile rc decode + BS2Mach stmt-order web fix
- static volatile s32 rc (orig reloads per-access; UpdateThread 92.3->93.35)
- UpdateThread sdata string pairs via symbols.txt @-renames
- BS2NANDDivideCallback stmt-order swap resolves r5/r6 web pairing
- iplSound.h: drop IPL_SOUND_MATCHING resetAllSound guard (upstream now Matching)

Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 06:00:32 +00:00
Devin AI
35f2cae118 misc1: wprintf __wpformatter 99.27->99.38 (signed /2 diff + buff+512 call arg decodes)
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 05:46:22 +00:00
Devin AI
1ef24d1600 misc1: AxAdpcm start decode (member-load + direct-array webs) 14->1 diffs; symbols.txt literal renames
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 05:46:22 +00:00
Devin AI
8e30630b02 misc1: decode DUD s32 return (ret callee-pinned); AxAdpcm coeffs local
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 05:46:22 +00:00
Devin AI
436146576e misc1: pair wiisetting strProps via symbols.txt; document w1004 walls
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 05:46:22 +00:00
Devin AI
f9b48c3b4f misc1: attempts — symbols.txt lever verified, AxAdpcm start parked
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 05:46:22 +00:00
Devin AI
6b14d400eb symbols.txt: name anon .sdata/.sbss objects (iplESMisc data 100%, www_wiisetting MSG_* pair)
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 05:46:22 +00:00
Devin AI
8d17448cc3 BS2Update .sbss 100%: semantic symbols.txt names for 4 anon objects (splitter propagates to orig .o)
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 05:46:22 +00:00
Devin AI
3fe3424570 misc1: attempts notes
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 05:46:22 +00:00
Devin AI
4beff22472 odh: remove ODHEncodeRGBA8/Y8U8V8 + ODHDecodeY8U8V8 (absent from orig .o)
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 05:46:22 +00:00
Devin AI
eb59607940 BS2Update: decode .bss as 5 separate GLOBAL objects + pFlags=Flags0 init
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 05:46:20 +00:00
Devin AI
7b83d86bb4 wprintf: named buff_end web, wpformatter residual regname ties
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 05:46:16 +00:00
Devin AI
ff2db54d42 www_wiisetting: strBuf init-at-decl, Getter_ 9 regname diffs left
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 05:46:16 +00:00
Devin AI
a715aa6bb0 iplSound: decode .bss globals — u32 unk[3] + UnkCls wrapper (0xd8), sSystem 0x63c; data 100%
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 05:46:15 +00:00
Devin AI
1847720857 BS2Mach: semantic STB_GLOBAL decode, data sections 100%
- rename lbl_XXX decls to orig symtab semantic names (static for LOCAL-bound)
- u32 nandLen hoist in NANDDivide Async fns
- CacheCommandComplete = NandPending shared-const form at 2 sites
- iplSound/BS2Update/iplESMisc decode progress

Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 05:46:07 +00:00
coah
775167f4a5 Link the verified native NUP HTTP unit (#740) 2026-10-02 00:45:17 -05:00
github-actions[bot]
547637bf79 docs: update progress [skip ci] 2026-10-02 05:43:38 +00:00
coah
2b1e29a746 data(iplKeyboard data 1176/1184) (data-d1b) (worker 9e9e6cc1) (#739) 2026-10-02 00:42:44 -05:00
github-actions[bot]
394f6c2444 docs: update progress [skip ci] 2026-10-02 05:41:38 +00:00
coah
35e7147b97 data(iplUSBAP, AOSS data 100%, iplSetting +640, ATERM sbss) (data-d3) (worker ef0da9b3) (#738) 2026-10-02 00:40:50 -05:00
github-actions[bot]
ed3fad1bff docs: update progress [skip ci] 2026-10-02 05:38:15 +00:00
coah
f72e4281a8 match(AXFXChorusExp 7/7) (near7f) (worker f241c3a9) (#737) 2026-10-02 00:37:19 -05:00
github-actions[bot]
f6fd278076 docs: update progress [skip ci] 2026-10-02 05:34:04 +00:00
coah
4b25950eeb data(iplGCWindow, iplSDMemory data 100%) (data-d5) (worker a506aca5) (#736) 2026-10-02 00:32:51 -05:00
coah
dc5d3cf81b Use the implicit HKBManager destructor and link native C++ (#734) 2026-10-02 00:32:38 -05:00
github-actions[bot]
d54e4ba47a docs: update progress [skip ci] 2026-10-02 05:31:35 +00:00
coah
3f330a39ea data(sd_drv data 408->1016) (data-d6) (worker 7268acb9) (#735) 2026-10-02 00:30:26 -05:00
github-actions[bot]
85701c828f docs: update progress [skip ci] 2026-10-02 05:27:56 +00:00
coah
f37268de4f data(BS2Update, iplSound, AOSSLink, iplRakuRakuThread data 100%) (data-d2) (worker 1146ea35) (#733) 2026-10-02 00:26:43 -05:00
github-actions[bot]
26afef0d00 docs: update progress [skip ci] 2026-10-02 05:25:02 +00:00
coah
ecd5e498b5 match(iplMemoryCardManager 17/26) (near9d) (worker ef0188be) (#732) 2026-10-02 00:24:04 -05:00
coah
68e1ee3a35 Restore two original CDB record diagnostic messages (#731) 2026-10-02 00:22:41 -05:00
github-actions[bot]
bcb2ac0e37 docs: update progress [skip ci] 2026-10-02 05:21:18 +00:00
coah
00ff6ea6a0 data(OSUtf 48704/48704 data, iplKeyboard 31/32) (data-d1) (worker c9656d2b) (#730) 2026-10-02 00:20:11 -05:00
github-actions[bot]
eadb516be8 docs: update progress [skip ci] 2026-10-02 05:18:56 +00:00
coah
e3be21cd6c match(nup_nhttp 9/9) (near8e) (worker 6e28d64b) (#729) 2026-10-02 00:18:07 -05:00
coah
9eb08c48a7 Restore the original decide sound in address-book click handling (#727) 2026-10-02 00:16:06 -05:00
github-actions[bot]
456e9dbd2e docs: update progress [skip ci] 2026-10-02 05:15:36 +00:00
coah
4d08c3005b match(tiHKBManager 29/29) (near6i) (worker ba6dfd2a) (#728) 2026-10-02 00:14:31 -05:00
coah
a16c5191f0 Fix the waiting pane references in settings visibility calls (#726) 2026-10-02 00:13:43 -05:00
coah
eecf16f01e Extend memo Manager vtable through its proven final virtual slot (#725) 2026-10-02 00:02:01 -05:00
github-actions[bot]
73f5b332e2 docs: update progress [skip ci] 2026-10-02 04:55:57 +00:00
coah
3d97a4040f Prevent false pointer relocation in the SDK CP932 scalar table (#724) 2026-10-01 23:55:19 -05:00
coah
0b623f581b Restore memo destructor definitions; defer unresolved data linking (#714) 2026-10-01 23:47:34 -05:00
github-actions[bot]
f4e539191d docs: update progress [skip ci] 2026-10-02 04:46:16 +00:00
coah
cb0716f7a5 match(pf_path 26/27) (near6g) (worker 8270df04) (#723) 2026-10-01 23:45:27 -05:00
github-actions[bot]
d47d308721 docs: update progress [skip ci] 2026-10-02 04:45:10 +00:00
coah
1bf9ae4569 match(tiPcKeyboard 140/141, AXFXChorusExp 6/7, aes 7/9) (near7d) (worker 348bb89e) (#722) 2026-10-01 23:44:15 -05:00
github-actions[bot]
bab82c12dd docs: update progress [skip ci] 2026-10-02 04:40:19 +00:00
coah
ccca706770 Match and link USBAP registration; correct thread sbss ownership (#721) 2026-10-01 23:39:26 -05:00
github-actions[bot]
a9833b51a2 docs: update progress [skip ci] 2026-10-02 04:26:00 +00:00
coah
76d8500dcf Repair two reconstructed function symbol names (#720) 2026-10-01 23:25:16 -05:00
github-actions[bot]
184bee0173 docs: update progress [skip ci] 2026-10-02 03:54:08 +00:00
coah
368a86cc6c match(nup_nhttp): 6 -> 8 exact (near8c) (worker 9dbfc514) (#719) 2026-10-01 22:53:23 -05:00
github-actions[bot]
9a7da62d3a docs: update progress [skip ci] 2026-10-02 03:47:25 +00:00
coah
b3c1300392 match(iplSDChannelTitle 64/69, NHTTP_recvbuf 6/7) (worker c82a056b) (#718) 2026-10-01 22:46:49 -05:00
coah
bd762fd162 docs(agents): add orchestrator handoff section (tools, state, pickup steps) (#717) 2026-10-01 22:44:50 -05:00
github-actions[bot]
f18d945894 docs: update progress [skip ci] 2026-10-02 03:02:34 +00:00
coah
bc505c3b8a Restore sensitivity projection constant pool and link source (#716) 2026-10-01 21:49:43 -05:00
coah
a5f79b81fa Correct memo Manager title setter vtable target (#715) 2026-10-01 21:35:19 -05:00
github-actions[bot]
137edaff42 docs: update progress [skip ci] 2026-10-02 01:58:17 +00:00
coah
4a7353ec73 Restore sound globals and link iplSound (#713) 2026-10-01 20:57:25 -05:00
coah
618e713b53 docs(agents): describe the Claude orchestrator / Codex worker loop (#711)
Effort scale, silent mode for workers, gate and landing rules, the PR
review daemon and auto-merge conditions, single-orchestrator rule, and
the policy additions (no retail .s linking, definition-level volatile).
2026-10-01 20:56:59 -05:00
github-actions[bot]
3dcd723459 docs: update progress [skip ci] 2026-10-02 01:55:54 +00:00
coah
4ed63ff786 match(tiHKBManager): key validity (worker 4e3e9738) (#712) 2026-10-01 20:54:55 -05:00
coah
eb8b9b978d Discover compiler-named and custom jump tables (#710) 2026-10-01 20:29:36 -05:00
github-actions[bot]
10e3f47e64 docs: update progress [skip ci] 2026-10-02 01:19:23 +00:00
coah
006457008c match(pf_fat): fsinfo byte order and sector rounding, 34/35 (worker 4129772d) (#709) 2026-10-01 20:18:35 -05:00
github-actions[bot]
75677c746b docs: update progress [skip ci] 2026-10-02 01:16:28 +00:00
coah
ccbc04a997 match(NHTTP_stdlib_RVL): hex/decimal parsing, 10/14 (worker 8531a6bf) (#708) 2026-10-01 20:15:19 -05:00
coah
da35a476bf Decompile sound effect stopping with a void return (#707) 2026-10-01 20:12:48 -05:00
coah
589bee2b0d Decompile system sound initialization (#706) 2026-10-01 20:07:38 -05:00
github-actions[bot]
f36411d483 docs: update progress [skip ci] 2026-10-02 01:03:37 +00:00
coah
9a897b043b match(pdm_partition): partition sector conversion, 18/20 (worker a5353c91) (#705) 2026-10-01 20:02:35 -05:00
coah
4d828ed557 Generate hardware keyboard vtable from C++ declarations (#704) 2026-10-01 19:59:33 -05:00
coah
f479546211 Decompile hardware keyboard character conversion (#703) 2026-10-01 19:54:11 -05:00
github-actions[bot]
a6c7690eb0 docs: update progress [skip ci] 2026-10-02 00:52:09 +00:00
coah
54b82eb747 Decompile hardware keyboard input dispatch (#701) 2026-10-01 19:51:53 -05:00
coah
326273b619 match(NHTTP_recvbuf): NHTTPi_RecvBufN (#559)
* match(NHTTP_recvbuf): NHTTPi_RecvBufN

Declare available before response and reload recvBufLen via
volatile so MWCC places response in r10 and reloads length
before the offset subtract.

* match(NHTTP_recvbuf): declare recvBufLen volatile instead of a use-site cast

The target re-reads recvBufLen back to back with no intervening store,
so the field itself is volatile. Field-level volatile leaves every other
function in the six NHTTP units that touch it unchanged.
2026-10-01 19:51:25 -05:00
github-actions[bot]
31d0f12981 docs: update progress [skip ci] 2026-10-02 00:50:35 +00:00
coah
01fb2284c6 match(tiHKBManager 26/29, pf_fat 32/35, SOBasic 21/22) (worker 536586f5) (#702) 2026-10-01 19:49:48 -05:00
coah
426555a34f match(SaveDataManager): decompile isEqualChannel (#677)
* match(SaveDataManager): decompile isEqualChannel

* cleanup(SaveDataManager): drop register keyword from isEqualChannel
2026-10-01 19:47:51 -05:00
coah
9acff80781 cleanup(CXStreamingUncompression): name remaining RL/LZ/Huffman fields (#680)
Follows #678 (outData/outDataLen). Renames length/flags/hdrLen and
Huffman wordBuffer/wordBits.
2026-10-01 19:45:41 -05:00
coah
3c9af06f34 Decompile hardware keyboard language selection (#700) 2026-10-01 19:43:23 -05:00
github-actions[bot]
824fe9fc0a docs: update progress [skip ci] 2026-10-02 00:38:30 +00:00
coah
34d6a62df3 match(tiPcKeyboard 138/141, AXFXChorusExp 5/7) (worker 1aeb77af) (#699) 2026-10-01 19:37:15 -05:00
github-actions[bot]
f97f091472 docs: update progress [skip ci] 2026-10-02 00:36:30 +00:00
coah
6c042d2a06 Correct memory-card conversion constant ownership (#697) 2026-10-01 19:35:48 -05:00
coah
53f70c85ce Correct L2CAP diagnostic string ownership (#696) 2026-10-01 19:35:42 -05:00
github-actions[bot]
7a24a5c17e docs: update progress [skip ci] 2026-10-02 00:30:05 +00:00
coah
37c7c21953 Restore hardware-keyboard function order and link unit (#698) 2026-10-01 19:29:25 -05:00
github-actions[bot]
a81b7c36fe docs: update progress [skip ci] 2026-10-02 00:16:19 +00:00
coah
d17ab22bf0 match(SOBasic): SOInetPtoN address family selection, 19/22 (worker 1e3ff7dd) (#695) 2026-10-01 19:15:29 -05:00
coah
17407ed1cb cleanup(iplButton): name anim-wait and new-mail anm flags (#694)
Rename Button calc busy flag and new-mail animation controls; update
ChannelTitle setter call sites.
2026-10-01 19:14:24 -05:00
coah
199883f758 cleanup(eZiText): rename work unk_0x16 to cangjieEnabled (#693)
Same Zi8GetFormatVersion(... ) & 2 pattern as ZiInfoWork.cangjieEnabled.
2026-10-01 19:14:18 -05:00
coah
edfb253724 cleanup(eZiText): rename work unk_0x538 to language (#692)
Assigned from parameters->language in zi8getc2; Matching zi8initd clears it.
2026-10-01 19:13:52 -05:00
coah
c8bb9f44da cleanup(iplDate): name focus state, pending cmd, point count (#691)
Rename Date focus SM fields used by onCmdRecv / pointer enter-leave.
2026-10-01 19:13:46 -05:00
coah
0d75b24a96 cleanup(CXStreamingUncompression): rename unk_0x0C to length (#690)
RL/LZ run and match length field (countdown while writing).
2026-10-01 19:11:21 -05:00
coah
262996a0de cleanup(NWC24MsgObj): rename unk_0x28/2C to date/receivedDate (#688)
Evidence from NWC24MBoxCtrl entry->date / entry->receivedDate copies.
2026-10-01 19:10:55 -05:00
coah
f095c9ea12 cleanup(iplCalendar): name draw list and search-task flag (#687)
Rename the secondary date list used for draw order and the vBOOL that
tracks the jam search task.
2026-10-01 19:10:27 -05:00
coah
f410332140 cleanup(iplNandSDWorker): rename unk_0x04 to mbCancel (#686)
requestCancel() sets this flag; work loops check it to abort.
2026-10-01 19:10:21 -05:00
coah
fed31b69b6 cleanup(iplBoardObject): name StandData step and angle index (#685)
Rename StandData lerp counter and angle index used by stt_stand.
2026-10-01 19:09:54 -05:00
coah
5ac1f65c4a cleanup(tiInputForm): name unused N_KOR/N_CHN sdata strings (#684)
lbl_816973A4 → scN_KOR, lbl_816973AC → scN_CHN.
2026-10-01 19:09:49 -05:00
coah
d9fbf88fb8 cleanup(eZiText): rename work unk_0x18 to subLanguage (#683)
Assigned from parameters->subLanguage in zi8getc2; Matching users
zi8is/zi8misc/zaddress updated.
2026-10-01 19:09:22 -05:00
github-actions[bot]
a77ce293ce docs: update progress [skip ci] 2026-10-02 00:09:13 +00:00
coah
e5f4e0e1f4 match(pf_cluster): InsertCluster and capacity check, 7/8 (worker a218bc12) (#689) 2026-10-01 19:08:17 -05:00
coah
c1cccf1c2c cleanup(iplTextWriter): rename unk_0x7D to mbResetAcceptable (#682)
Field is exactly what isResetAcceptable() returns; also update LetterWriter
uses of the inherited member.
2026-10-01 19:07:17 -05:00
coah
ded159048f cleanup(CDBAttr): name dirty / wiiIdDirty / wiiIdValid flags (#681)
Runtime flags after the attr buffer: lead dirty, wiiId-region dirty
(full write), and wiiId/attr loaded-valid.
2026-10-01 19:07:12 -05:00
coah
0ec86e7985 cleanup(jdec): name frame remX/remY remainder fields (#679)
Width/height leftover pixels after MCU tiling, set from remX/remY locals.
2026-10-01 19:06:45 -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
coah
5d1a8bd697 Revert "Link iqdec_b65_frv32 via retail .s (#615)" (#640)
This reverts commit 40653c3c02.
2026-10-01 18:24:26 -05:00
coah
c42fb1fe71 cleanup(SDChannelTitle): name address-suffixed C helpers (#639)
Rename iplSDChannelTitle_813E* helpers to semantic names across the
unit and symbols.txt. Byte-identical: ok + sha1
26116613f624061ba99c8d1a299aaa6efa85670d; unit still ~80.9% code /
~99.76% fuzzy.
2026-10-01 18:23:38 -05:00
coah
8e96e8a722 match(SaveDataManager): decompile getNumValidChannel (#622)
Exact match (23/23, diffs 0). DOL SHA1 26116613f624061ba99c8d1a299aaa6efa85670d.

Adds ChannelSlot/ChannelPage overlays (slots at +0x30, page stride 0xC0)
so the loop uses typed .valid/.titleId instead of raw byte loads.
2026-10-01 18:22:58 -05:00
coah
854cc579df Fix keyboard prediction and animation jump tables (#638) 2026-10-01 18:22:03 -05:00
coah
26a36e2964 Restore SD memory dialog-state dispatch mapping (#637) 2026-10-01 18:21:37 -05:00
coah
8729671a43 Match GC card-removal no-op jump target (#635) 2026-10-01 18:21:10 -05:00
coah
08f5f08a13 match(CDBDatabase): decompile CDBDatabaseCreateRecordAtOnce (#558)
Exact match (37/37, diffs 0). DOL SHA1 26116613f624061ba99c8d1a299aaa6efa85670d.
Rebased onto latest main.
2026-10-01 18:20:54 -05:00
coah
893afc25b4 cleanup(tiHwKeyboard): name convertWCCode jumptable (#634)
Rename jumptable_81668EF8 to scHwKeyboardConvertWCCodeJumpTable.
2026-10-01 18:20:44 -05:00
coah
dee9f9d8ea cleanup(zikorean): name Korean lookup/match helpers (#633)
Rename Zi8_814813FC/81481E6C to Zi8LookupKoreanChar and
Zi8MatchKoreanSequence.
2026-10-01 18:20:39 -05:00
coah
728bfa984b cleanup(TMCJPEG): name decode-buffer refill helpers (#632)
Rename TMCJPEG_814EAF50/814EB108 to refillJpegBufferAfterFF
and refillJpegBuffer.
2026-10-01 18:15:59 -05:00
coah
921234fdac cleanup(rvl_dec): name literal-copy goto label (#631)
Rename LAB_813325b8 to copy_lit_tail.
2026-10-01 18:15:23 -05:00
coah
9d6f9dce74 cleanup(Contest): name NAT detection callback (#629)
Rename iplContest_813D54F8 to onNatDetectionDone.
2026-10-01 18:15:18 -05:00
coah
f1bcb9d78c cleanup(ChannelTitle): name disk TMD/tmp-title task callbacks (#628)
Rename address-suffixed static tasks to markTmdReadyTask and
deleteTmpTitleContentTask.
2026-10-01 18:14:53 -05:00
coah
efda1f0093 Restore SD state-machine switch case mappings (#623) 2026-10-01 18:14:28 -05:00
github-actions[bot]
115bc95101 docs: update progress [skip ci] 2026-10-01 23:12:57 +00:00
coah
cbac1eda5a match(KPAD): sensor interval constant pool data (worker 93817b04) (#630) 2026-10-01 18:12:12 -05:00
github-actions[bot]
f0de86aa16 docs: update progress [skip ci] 2026-10-01 23:11:14 +00:00
github-actions[bot]
215f40f835 docs: update progress [skip ci] 2026-10-01 23:10:30 +00:00
coah
5b364355cd match(NWC24Download 25/30, nup 19/23) (worker da66e510) (#627) 2026-10-01 18:10:29 -05:00
coah
ea8e69528f match(wad): _WADHash, 35/40 (worker ae91d0cb) (#625) 2026-10-01 18:09:19 -05:00
coah
2a5fbdb4b9 cleanup(tiInputForm): name pane/string labels (#620)
Rename known layout pane name placeholders; leave float
constants and unused N_KOR/N_CHN sdata decls for follow-ups.
2026-10-01 18:08:19 -05:00
coah
dd3cd80d9b match(CDBDatabase): decompile CDBDatabasePrivateCreateRecordAtOnceEx_ (#619)
Exact match (73/73, diffs 0). DOL SHA1 26116613f624061ba99c8d1a299aaa6efa85670d.

Co-authored-by: asm2c <asm2c@local>
2026-10-01 18:08:05 -05:00
github-actions[bot]
3cbe527d23 docs: update progress [skip ci] 2026-10-01 23:07:39 +00:00
coah
3ab6d87c3d cleanup(CHANSVm): name string labels and VmCmpEq bVar (#618)
Rename UTF-16 / class-name / printf / hex placeholders and
CHANSVmConstStringObject* companions; bVar1 → stringsMatch.
2026-10-01 18:07:38 -05:00
coah
40653c3c02 Link iqdec_b65_frv32 via retail .s (#615)
NonMatching/Equivalent source does not keep DOL SHA1. Assemble extracted unit and mark Matching.

Also fix --defsym VERSION_* for gas (needs =1).

Linked code: 62.047% -> 62.084% / 919 units
DOL SHA1: 26116613f624061ba99c8d1a299aaa6efa85670d

Co-authored-by: linker <linker@local>
2026-10-01 18:06:29 -05:00
github-actions[bot]
f0829ff810 docs: update progress [skip ci] 2026-10-01 23:06:06 +00:00
coah
ffdd7b58e0 cleanup(tiCandidateBox): name pane/string labels (#608)
Rename address placeholders for known pane names and related
sdata aliases; leave float constants for a follow-up.
2026-10-01 18:05:58 -05:00
coah
1a0f83a156 match(CDBDatabase): decompile CDBDatabaseCreateRecordAtOnceEx (#607)
Exact match (51/51, diffs 0). DOL SHA1 26116613f624061ba99c8d1a299aaa6efa85670d.

Co-authored-by: asm2c <asm2c@local>
2026-10-01 18:05:17 -05:00
coah
a3d088e4d3 match(d_nhttp_private): NHTTPDeleteConnection (#606)
Rewrite ConnectionStarted's null check as if/else so the inlined
WaitConnection path matches beq/bne block order (null → -1 first).

Before: 6/7 funcs, 908/1320 code bytes
After:  7/7 funcs, 1320/1320 code bytes
DOL sha1: 26116613f624061ba99c8d1a299aaa6efa85670d
2026-10-01 18:04:32 -05:00
coah
3b90bd66c6 cleanup(iplSound): name zero float constant (#599)
Rename lbl_816946A4 → scSoundZeroF (defined 0.0f). Leave other pitch
floats alone until they have Matching definitions.
2026-10-01 18:04:18 -05:00
coah
b395269be6 cleanup(iplChannelObj): rename leftover bVar locals (#605)
- bVar4 → foundLangGroup
- bVar3 → isNonRsoGroup
- bVar1 → shouldAdjustHeap
2026-10-01 18:04:05 -05:00
github-actions[bot]
60bc67e097 docs: update progress [skip ci] 2026-10-01 23:04:00 +00:00
coah
4e8223f3d4 cleanup(wad): sync WAD*Ex header params with .c (#592)
Match wad.h to wad.c (flags/offset/fileListOut/processCallback).
2026-10-01 18:03:49 -05:00
github-actions[bot]
3f36d5f4cc docs: update progress [skip ci] 2026-10-01 23:03:03 +00:00
coah
1f0dc64062 cleanup(kpad): sync KPADGetProjectionPos param names (#589)
Match the header to the .c (param_3/param_4 → rect/scale).
2026-10-01 18:02:56 -05:00
coah
5db0cd6086 cleanup(CDBDatabase): name error message string labels (#581)
Rename Matching lbl_* CDBReportError messages to scCdbMsg_*.
2026-10-01 18:02:31 -05:00
coah
54b44a3534 Restore keyboard unit filename and getter emission order, then link (#572) 2026-10-01 18:02:26 -05:00
coah
1493baaba0 match(pf_fat12): PFFAT12_WriteFATEntryWithBuf (#573)
Reorder locals and rewrite cross-byte stores as p_buf[offset+1].

Co-authored-by: matcher <matcher@local>
2026-10-01 18:02:05 -05:00
coah
22dd088277 match(SOBasic): SOPoll (#571)
Reorder locals (size, bytes, result, rm) for register allocation.

Co-authored-by: matcher <matcher@local>
2026-10-01 18:00:59 -05:00
coah
1bbc40cb3b cleanup(iplChannelObj): name layout/export/SE string labels (#556)
Replace Equivalent-unit lbl_* placeholders with scPaneName_/scBrlyt_/
scBrlan_/scExport_/scSE_ names; rename local_50 to langCodeBuf.
Update symbols.txt. Byte-identical; DOL sha1 unchanged.
2026-10-01 17:59:14 -05:00
coah
e6bf9cc669 cleanup(NWC24FriendList): rename friend-list path string (#533)
Rename lbl_8166E160 to scNwc24FlPath using a plain non-const char[]
declaration (no section attributes or pad objects).
2026-10-01 17:58:48 -05:00
coah
ffd9cc4a69 cleanup(iplDate): name zero float constant (#514)
String pane/brlan/SE labels already landed via #518. Rename the remaining
Matching .sdata2 zero float lbl_816948EC -> scDateZeroF.
2026-10-01 17:58:21 -05:00
coah
eb8f78788d cleanup(RsoSystem): name fatal OSFatal color/msg and zero float (#510)
lbl_8169622C..F → scRsoFatalColorR/G/B/A, lbl_81639230 → scRsoFatalMsg,
lbl_81694598 → scRsoZeroF.
2026-10-01 17:57:55 -05:00
github-actions[bot]
889823ed67 docs: update progress [skip ci] 2026-10-01 22:57:28 +00:00
coah
7dea4122fc match(tiInputForm): 217/221, replace two asm bodies with C++ (worker ec292914) (#621) 2026-10-01 17:56:40 -05:00
github-actions[bot]
1802d45758 docs: update progress [skip ci] 2026-10-01 22:48:56 +00:00
coah
130cc9e88e match(pf_fat): PFFAT_GetClusterAllocated (#570)
Reorder locals so p_start_cluster lands in r7 and p_vol in r8.

Co-authored-by: matcher <matcher@local>
2026-10-01 17:47:34 -05:00
coah
a801d1c5d6 cleanup(CXStreamingUncompression): rename Huffman init dest param (#568)
Match the Huffman prototype to the .c and the RL/LZ decls (param_2 → data).
2026-10-01 17:47:08 -05:00
coah
8ab07fbb20 Restore SD title button-string ownership (#567) 2026-10-01 17:46:43 -05:00
coah
f68fcc0f9b cleanup(lyt_window): name OSFatal color/msg constants (#566)
Rename assert-path sdata2 color bytes and Error#004 string labels.
2026-10-01 17:46:18 -05:00
coah
5ad481ae40 match(iplSaveDataManager): convert getAvailableInList to C (#563)
Exact match (28/28, diffs 0). Finds first zero titleId whose
chanInfo primaryType is not 1, using dens=12 for page/slot.
2026-10-01 17:45:53 -05:00
coah
713951c551 cleanup(ChannelTitle): rename play-limit hour/minute locals (#562)
Rename Ghidra local_38/local_58 to hourStr/minuteStr in the play-time
limit formatting path.
2026-10-01 17:45:28 -05:00
coah
b47507aa3f cleanup(sdi_api): rename leftover Ghidra param_* names (#560)
Rename ISD_GetHCRegister/GetDeviceStatus/GetCardSize and
sduCommand(v)/MultiBlockAsync parameters to descriptive names.
2026-10-01 17:44:43 -05:00
coah
01a73b600f cleanup(ChannelSelect): rename pane/SE string labels (#557)
Rename lbl_* pane and sound-effect string symbols to scPaneName_/scSE_
names; add missing WSD_SELECT definition. Build stays byte-identical.
2026-10-01 17:43:38 -05:00
coah
83b577cf62 match(CDBDatabase): convert CreateRecordImAtOnce_ to C (#555)
Exact match (84/84, diffs 0). Closed/readonly checks via instance flags,
OSTime to CDBDate via OS_BUS_CLOCK/4, then CDBRecordCreateAtOnce.
2026-10-01 17:42:32 -05:00
coah
f67990d237 cleanup(bta_dm_act): name compress check/callback params (#553)
Rename unused id on check_compress; align L2CAP compress callback
formals with pe_type/mem_level/wbits/direction/config/enable.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:41:10 -05:00
coah
ad85ad1537 cleanup(l2c_api): name compression API params (#552)
Rename SetCompression param_6 to config; RegisterCompression to p_callback/unused.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:41:02 -05:00
coah
f32665703f cleanup(AxAdpcmPlayer): rename iVar4 to pb (#551)
Rename Ghidra iVar4 to pb in getCurrAddr.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:40:35 -05:00
coah
e062e1c669 cleanup(uusb_ppc): name UUSB_Read/Write params (#550)
Rename pipe/buf/len on Read; pipe/unused on Write; fix debug print to use len.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:40:09 -05:00
coah
76a60f8c1a CDBDatabase: convert Search_ to matching C (#548)
Exact match (53/53, diffs 0). Builds CDBSearchConditions and calls
SearchYearLayer. DOL SHA1 unchanged.

Co-authored-by: asm2c <asm2c@local>
2026-10-01 17:40:03 -05:00
github-actions[bot]
63579601e2 docs: update progress [skip ci] 2026-10-01 22:39:45 +00:00
coah
e46bac9a1b cleanup(hcisu_h2): name USB callback, receive, and init params (#549)
Rename Ghidra param_* on Matching hcisu_h2 helpers:
usb_cback event/status, receive_msg pipe, init taskId/mbox/bufSize.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:39:42 -05:00
coah
1f224c53c1 cleanup(usbkbd): name SetLED device and ledBits params (#547)
Rename USBKBDSetLED/Async param_1/param_2 to device/ledBits.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:38:34 -05:00
coah
30e2147479 match(sd_drv): pfd_st_removal_callback (#546)
Force store-before-load of media_inserted by reading it back
in the device check so MWCC emits li r0 / stw / lwz order.
2026-10-01 17:38:28 -05:00
coah
6ffcbf8f46 cleanup(bte_main): name usb close status param (#545)
Rename bta_usb_close_evt param_1 to status.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:38:01 -05:00
coah
47add32987 cleanup(bte_hcisu): name unused task param (#544)
Rename bte_hcisu_task param_1 to unused (never read).
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:37:34 -05:00
coah
e0ea552982 data(tiHwKeyboard): fix .rodata order for country maps (#543)
Move scCountryMap_* and controlKeys after the HWKeyboard methods that
emit the KeyInputData aggregate constant, so .rodata matches original
order (@6525, EU, NonEU, controlKeys). Leaves .sdata2 symbol-size /
.sdata section pad below 100%.

objdiff: .rodata 90.9% -> 100%; matched_data ~40% -> ~93.7%.
DOL sha1 unchanged (26116613f624061ba99c8d1a299aaa6efa85670d).

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 17:37:04 -05:00
coah
c7949ac4f0 cleanup(puh_ker_sem): name create_sem params (#542)
Rename uhf_ker_create_sem param_1/param_2 to initCount/flags.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:36:35 -05:00
coah
e697514b7b cleanup(CXSecureUncompression): name Huffman table verify params (#541)
Rename CXiVerifyHuffmanTable_ param_1/param_2 to table/bitSize.
Byte-identical; DOL sha1 unchanged.
2026-10-01 17:36:08 -05:00
coah
32c3f7f2cd cleanup(CXStreamingUncompression): name init/header params (#540)
Align RL/LZ init dest param with Huffman (data) and name
CXiReadHeader maxOutLen.
2026-10-01 17:36:01 -05:00
coah
1618565c1d Update SD title-check caller after NandSDWorker rename (#539) 2026-10-01 17:35:35 -05:00
coah
6040414eec cleanup(jdec_main): name JPEG AAN scale table (#538)
Rename lbl_8161E080 to scJpegAanScale for the 64-word IDCT scale
rodata copied into decode work.
2026-10-01 17:35:07 -05:00
coah
08acc800f1 cleanup(cntcache): name version and path string data (#537)
Rename packed string blob, title/data path format, and \" \\n\" sdata.
2026-10-01 17:34:41 -05:00
coah
0703b62968 cleanup(WPAD): name version and manage string data (#536)
Rename SDK version banner and WPADiManageHandler message blob.
2026-10-01 17:34:14 -05:00
github-actions[bot]
86c3cacc2d docs: update progress [skip ci] 2026-10-01 22:34:09 +00:00
coah
f7e6fc5387 cleanup(db_exception): name FPCSR flag local (#535)
Replace Ghidra uVar1 with fpcsr in ShowMainInfo_ FPE reporting.
2026-10-01 17:33:47 -05:00
coah
dfbb774ce4 Link fully matched tiTextDrawer (#532)
Promote keyboard/tiTextDrawer.cpp from NonMatching to Matching. All 24
functions are exact (3,476/3,476 code bytes) and the linked DOL stays
byte-identical, SHA-1 26116613f624061ba99c8d1a299aaa6efa85670d.

The unit's .sdata2 reports 44/48 bytes only because dtk folded the
section's 4-byte alignment pad into the last float symbol; the linker
restores the same pad, so no padding array or metadata change is needed.

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 17:33:23 -05:00
coah
9b69048f06 cleanup(WDScan): name RSN/WPA OUI byte constants (#531)
Rename privacy-mode OUI sdata/sdata2 bytes used by WDGetPrivacyMode.
Leave unused pad bytes as address labels so section layout stays fixed.
2026-10-01 17:32:44 -05:00
coah
602b10ed43 data(CDBFileSystemUtils): match .sdata path separator (#530)
Replace lbl_816979E8 + .sdata section pragma with a plain
char CDBFSPathSeparator = '/' so the .sdata symbol size matches
the original (1 byte). Rename the symbol in symbols.txt to match.

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 17:32:14 -05:00
github-actions[bot]
f0a91338f4 docs: update progress [skip ci] 2026-10-01 22:31:51 +00:00
coah
ff568a273c cleanup(rvl_dec): name Rvl_decode_ash C locals (#528)
Replace Ghidra locals in the non-asm ASH decoder path with
bitstream/huffman-oriented names.
2026-10-01 17:31:22 -05:00
coah
9f6ef656fd cleanup(rvl_dec): name Rvl_decode_szs C locals (#526)
Replace Ghidra locals in the non-asm SZS decoder path with
readable names (decodedSize, bitMask, copyLen, etc.).
2026-10-01 17:31:13 -05:00
coah
9d2f607b3f data(NHTTP_request): match multipart boundary .rodata size (#529)
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 17:31:00 -05:00
coah
c836ab8bae cleanup(iplChannelManager): name title lookup and meta helpers (#520)
Rename Matching-only fn_8133A* APIs and update SD call sites plus
mangled symbols.txt entries.
2026-10-01 17:30:44 -05:00
coah
b889c52efc CDBDatabase: convert CleanUpEmptyDirectories to matching C (#527)
Exact match (133/133, diffs 0). Uses labeled error strings so the
DOL string pool stays identical to baserom.

Co-authored-by: asm2c <asm2c@local>
2026-10-01 17:30:33 -05:00
coah
282c29b2c7 data(pf_entry): match default volume label size (#525)
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 17:30:07 -05:00
coah
27e37fd7ee cleanup(sdi_api): rename path/format string blob (#524)
lbl_81691748 -> __sdPathData (packed SD reset OSReport format +
slot0/slot1/slotw path strings used by ISD_InitCard).
2026-10-01 17:29:41 -05:00
coah
00051c32c6 cleanup(iplChannelTitle): name group/pane/brlan string labels (#522)
Replace Matching-only lbl_* layout string placeholders and pointer
arrays with scGroup_/scPaneName_/scBrlan_ names; update symbols.txt.
2026-10-01 17:29:16 -05:00
coah
80fecf3aa3 cleanup(iplChanAppBox): name brlan/pane strings and sdata2 constants (#521)
Replace Matching-only lbl_* animation, pane, group, and float
placeholders; update symbols.txt.
2026-10-01 17:29:11 -05:00
github-actions[bot]
37724c57d6 docs: update progress [skip ci] 2026-10-01 22:27:32 +00:00
coah
1a32db7bdc fix: update iplSDChannelSelect caller missed by #496 rename (#554) 2026-10-01 17:26:54 -05:00
coah
2aab31c1f9 match(NHTTP_thread): NHTTPi_RecvProxyConnectHeader init order (#513)
Set cursor/index before ended so MWCC emits li r4 then li r5.
2026-10-01 17:18:22 -05:00
coah
24c84f5bfc cleanup: rename NandSDWorker SD app title check helpers (#496)
Rename iplNandSD_81348EA8/do_unk_8134C838 to
check_sd_app_titles_async/do_check_sd_app_titles. DOL sha1 unchanged.
2026-10-01 17:17:04 -05:00
coah
73de5786da cleanup(www_surface): rename CreateManager params to match cpp (#512)
param_10 → arcPath; rectW0/H0/W1/H1 → surfaceW/H, browserW/H.
Header-only rename aligned with www_surface.cpp.
2026-10-01 17:16:25 -05:00
coah
3abcd34252 cleanup(iplCalendar): name month/pos pane arrays and day-grid locals (#517)
Replace Matching-only lbl_* pane name tables and Ghidra locals in
the day layout path; update symbols.txt for the arrays.
2026-10-01 17:16:04 -05:00
188 changed files with 10767 additions and 5829 deletions

164
AGENTS.md
View File

@@ -164,9 +164,8 @@ This repository targets only Wii Menu 4.3U. Do not configure or build 43E,
43J, or 43K while doing matching work.
Most workers should pursue exact matching or safe linking; assign the remainder
to decompilation. Keep up to 75 live workers when the runtime allows it, while
reserving capacity for fixer and validation workers. Fill completed slots with
disjoint tasks. Never duplicate a source file or function
to decompilation. Keep every worker slot busy (currently four Codex slots; see
"Orchestrator loop" below). Fill completed slots with disjoint tasks. Never duplicate a source file or function
range. Workers return changed paths, exact objdiff measurements, and validation
results. Fuzzy-only results are not accepted.
@@ -246,6 +245,12 @@ and merge the PR, fast-forward `origin/main`, and publish progress. If a
candidate fails validation, return it to its worker; do not fix the candidate
inline in the orchestrator.
Two exceptions, both set by the human: once a leaf has failed at `max` effort
(see the effort scale below) the orchestrator itself takes a crack at it, and
the orchestrator may finish PRs whose authors are gone (rebase, drop a
forbidden pattern, close with evidence). Record every such attempt in the
policy log, including the ones that fail.
A new thread must begin by reading this file, checking the live 43U report and
remote branch, and dispatching the worker pool. The parent must not claim a
match without fresh independent verification.
@@ -320,6 +325,159 @@ Linked: <percent> | Fuzzy: <percent> | Data: <percent>
Do not report stale values, unmerged PR results, or add other text to that
update. Continue all required verification and coordination silently.
## Orchestrator loop (Claude orchestrator, Codex workers)
This is the loop currently in use. One Claude session is the orchestrator.
It does not spawn Claude subagents. All decompilation work goes to Codex CLI
workers running `gpt-6.1-sol`. The orchestrator assigns leaves, verifies,
lands, reviews outside PRs, and only decompiles by hand in the cases listed
under the ownership boundary above.
Only one orchestrator session may run at a time. If a second session resumes
the same thread (for example, the same session opened in two windows), close
one of them. Two orchestrators double-merge PRs and fight over the shared
build tree.
### Worker slots and the effort scale
Run four worker slots, each in its own worktree on a fresh branch from
`origin/main`. Every slot gets a disjoint set of three or four leaves (units),
closest-to-matching first. A slot starts at `medium` (or `low`) reasoning
effort and escalates only when a round produces no new exact function:
```
low/medium -> high -> xhigh -> max -> orchestrator attempt -> parked
```
A round that gains at least one exact function is landed, and the remaining
functions go out again at the same effort or one step up. A set that fails at
`max` goes to the orchestrator. If the orchestrator also fails, the function
is parked as a compiler tie-break with its evidence. Fill freed slots from the
live checklist right away; never leave a slot idle.
Before starting a function, a worker fetches `origin/main` and checks it is
not already matched. Outside contributors land work in parallel, and
duplicated matches waste a round.
### Silent mode for workers
Workers run unattended and must not talk. Every turn is tool calls only: no
plans, no progress notes, no summaries. Progress goes into an attempts log
file in `tools/decomp-assist/`. The only text message in a run is the final
report, at most 8-15 short lines:
- exact functions per unit, before and after;
- the final `GATE` line;
- commit hashes;
- a link to the attempts log.
Runs are audited for text messages, and any chatter is a contract
violation. Workers also must not push, open PRs, merge, rebase, touch other
worktrees, or spawn subagents.
Each worker prompt has this layout:
1. the `<task>` block (leaves, current exact counts, method, report format);
2. the shared `common.md` block with `<silent_mode>`, `<forbidden>`,
`<method>` and `<definition_of_done>`.
Resume a stalled worker on the same session with the failure evidence. Don't
replace it with a fresh one.
### Gate, landing and review
- `gate.py <unit...>` is the acceptance check for workers and for outside
PRs. It covers:
- a full 4.3U build and the DOL SHA1;
- per-unit objdiff and instruction-exact counts;
- regressions against a baseline report of `origin/main`;
- a net forbidden-pattern scan and a readability scan (auto-named
identifiers, raw `*(T*)(p + N)` offset casts).
- A function that disappears because it was renamed is not a regression,
unless the unit's exact count, code or data also drops.
- Landing a worker result builds a branch from `origin/main` with the
worker's diff, gates it, pushes it, then opens and squash-merges a PR on
the fork. After that it regenerates the checklist.
- Never run two full builds in the same build tree at once.
- Never land while the review queue is building. Both use the same
verification worktree.
Outside PRs are reviewed by a daemon. It re-runs the gate on any open PR
whose head commit changed since its last review. A PR is merged
automatically only when all of these hold:
- the PR rebases cleanly;
- the full build passes;
- the DOL hash matches;
- the gate passes, or its only failures are renamed-away functions;
- the diff adds no forbidden pattern and no `.s` file.
Everything else is reviewed by hand:
- **Conflicts:** comment asking for a rebase.
- **Forbidden patterns:** request changes with a concrete honest
alternative.
- **"Linking" by swapping in retail assembly or pinned labels:** close and
explain.
- **Proven split/ownership corrections** (relocation evidence, total data
unchanged): merge even if one unit's numbers move to its neighbour.
Policy additions learned in this loop:
- Linking a unit by building the retail `.s` instead of its C/C++ is
forbidden. "Linked" means the C/C++ itself compiles to the exact bytes.
- Definition-level `volatile` (on the field or object declaration) is allowed
when the target proves it, e.g. back-to-back reloads with no store in
between. Check that it changes no other function in the units that use it.
Use-site volatile casts and the `register` keyword stay forbidden.
### Handoff: where the loop lives
The loop's tools and state live outside the repository, in the author's
workers directory `/mnt/drive2/projects/wii-ipl-workers` (`$W` below). A new
orchestrator thread picks up from there.
Tools in `$W/_restore0928-tools/`:
| File | Purpose |
|------|---------|
| `gate.py <unit...> [--base origin/main] [--quick]` | the acceptance gate; `--quick` only skips the clean `rm -rf build/43U` |
| `land.sh <name> <worktree> merge-base <unit...> <title>` | gate a worker's diff on a fresh branch, push, open and squash-merge the PR |
| `luna.sh <worktree> <name> <prompt> <effort> [session]` | start (or resume) one Codex worker; run with `MODEL=gpt-6.1-sol CODEX_BIN=$W/_codex159/bin/codex` |
| `reviewd.sh` | review daemon: queues every open PR whose head changed |
| `revq.sh`, `automerge.py` | the daemon's gate runner and merge decision |
| `checklist.py` | regenerates `$W/CHECKLIST.md` from a report |
| `chatter.py <run-prefix>` | counts worker text messages for the silent-mode audit |
| `baseline-<sha8>.json` | objdiff reports of past `origin/main` commits, used for regressions |
State:
- `$W/_luna-runs/prompts/`: worker prompts. `common.md` is shared; each
task is `<name>.task.md`, and the launched prompt is `<name>.md` = task +
common.
- `$W/_luna-runs/<name>.<time>.jsonl` and `.last.md`: worker transcript and
final report.
- `$W/_luna-runs/effort-policy.txt`: the policy log. Records escalations,
parked functions, and every orchestrator attempt with what was tried.
- `$W/CHECKLIST.md`: units with non-exact code, worst first.
- Worktrees: `verify-fix` is the only verification and landing tree;
`sol-low`, `sol-med`, `sol-high` and `w0929-fix-board` are the four worker
slots; `orch` is orchestrator scratch.
- Logs: `/tmp/reviewd.log`, `/tmp/vfq.log` (current review batch) and
`/tmp/automerge.log` (merge decisions). These are lost on reboot, which
only means open PRs get reviewed again.
- `/tmp/wii-git.lock`: every `git fetch` or checkout in a shared worktree
runs under `flock` on this file, because worktrees share refs.
To pick up the loop:
1. Make sure no other orchestrator session is running.
2. Check `pgrep -af "reviewd.sh|luna.sh|land.sh"` and restart the review
daemon if it isn't running.
3. Read the newest `.last.md` for each slot. Land gains, then relaunch the
slot per the effort scale.
4. Handle every `NEEDS REVIEW` line in `/tmp/automerge.log`.
## Goal completion contract
The decompilation loop does not stop after a successful wave, a convenient

View File

@@ -53,9 +53,9 @@ Progress
<!-- progress:start -->
| Decompiled | Matched | Linked | Data |
|:---:|:---:|:---:|:---:|
| 99.37% | 87.69% | 61.93% | 91.37% |
| 99.46% | 88.57% | 62.98% | 97.20% |
units 917/1027 complete, functions 12211/12563 matched.
units 925/1027 complete, functions 12264/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

@@ -688,13 +688,13 @@ src/scene/memoryCard/iplMemoryCard.cpp:
.text start:0x813C9DCC end:0x813CC1FC
.rodata start:0x81610368 end:0x81610480
.data start:0x81651D30 end:0x81652640
.sdata2 start:0x81694A68 end:0x81694A80
.sdata2 start:0x81694A68 end:0x81694A78
.sdata start:0x81696C78 end:0x81696CA0
src/scene/memoryCard/iplMemoryCardBase.cpp:
.text start:0x813CC1FC end:0x813CD034
.data start:0x81652640 end:0x816526D0
.sdata2 start:0x81694A80 end:0x81694A88
.sdata2 start:0x81694A78 end:0x81694A88
src/scene/memoryCard/iplMemoryCardManager.cpp:
.text start:0x813CD034 end:0x813CE548
@@ -804,14 +804,14 @@ src/scene/sdChannelSelect/iplSDChannelObj.cpp:
.rodata start:0x81610608 end:0x81610918
.data start:0x81654B38 end:0x81654F98
.sdata2 start:0x81694B18 end:0x81694B60
.sdata start:0x81696DD0 end:0x81696E40
.sdata start:0x81696DD0 end:0x81696E30
src/scene/sdChannelTitle/iplSDChannelTitle.cpp:
.text start:0x813E4BBC end:0x813E947C
.rodata start:0x81610918 end:0x81610948
.data start:0x81654F98 end:0x81655638
.sdata2 start:0x81694B60 end:0x81694B88
.sdata start:0x81696E40 end:0x81696EF0
.sdata start:0x81696E30 end:0x81696EF0
src/scene/sdButton/iplSDButton.cpp:
.text start:0x813E947C end:0x813EA88C
@@ -869,11 +869,12 @@ src/scene/setting/iplUSBAP.cpp:
.bss start:0x810BC148 end:0x810BD498
.text start:0x813FC520 end:0x813FC8FC
.data start:0x81657B08 end:0x81657B18
.sbss start:0x81698C08 end:0x81698C28
.sbss start:0x81698C08 end:0x81698C20
src/scene/setting/iplUSBAPThread.cpp:
.text start:0x813FC8FC end:0x813FCA0C
.data start:0x81657B18 end:0x81657B60
.sbss start:0x81698C20 end:0x81698C28
src/scene/setting/iplAOSSThread.cpp:
.bss start:0x810BD498 end:0x810BD4A8
@@ -1054,7 +1055,7 @@ src/keyboard/tiNw4rManager.cpp:
.data start:0x8165F818 end:0x8165F8F0
.sdata2 start:0x81694E10 end:0x81694E28
src/keyboard/tiManager.cpp:
src/keyboard/tiKeyboard.cpp:
.text start:0x81437558 end:0x81439608
.ctors start:0x8160D208 end:0x8160D20C
.data start:0x8165F8F0 end:0x81660378
@@ -3551,12 +3552,12 @@ libs/RVL_SDK/src/bte/l2c_csm.c:
libs/RVL_SDK/src/bte/l2c_link.c:
.text start:0x815AC630 end:0x815AD7BC
.data start:0x8168E930 end:0x8168EB68
.data start:0x8168E930 end:0x8168EBA0
libs/RVL_SDK/src/bte/l2c_main.c:
.bss start:0x811725E0 end:0x81172DC8
.text start:0x815AD7BC end:0x815AE7EC
.data start:0x8168EB68 end:0x8168EEA0
.data start:0x8168EBA0 end:0x8168EEA0
libs/RVL_SDK/src/bte/l2c_utils.c:
.text start:0x815AE7EC end:0x815B06B0

File diff suppressed because it is too large Load Diff

View File

@@ -689,7 +689,7 @@ config.libs = [
]
),
IPLSection("sound", [
Object(NonMatching, "sound/iplSound.cpp"),
Object(Matching, "sound/iplSound.cpp"),
]
),
IPLSection("iplwww", [
@@ -719,7 +719,7 @@ config.libs = [
Object(Matching, "BS2/BS2.c"),
Object(Matching, "BS2/BS2Init.c"),
Object(NonMatching, "BS2/BS2Mach.c"),
Object(NonMatching, "BS2/BS2Update.c"),
Object(NonMatching, "BS2/BS2Update.c", extra_cflags=["-sdata 8"]),
Object(Matching, "BS2/BS2ParentalControl.c"),
Object(Matching, "BS2/BS2BringUp.c"),
Object(Matching, "BS2/BS2Reset.c"),
@@ -869,11 +869,11 @@ config.libs = [
),
IPLSection("setting", [
Object(NonMatching, "scene/setting/iplSetting.cpp"),
Object(NonMatching, "scene/setting/iplSensitivity.cpp"),
Object(Matching, "scene/setting/iplSensitivity.cpp"),
Object(Matching, "scene/setting/iplNCDSetting.cpp"),
Object(Matching, "scene/setting/iplParental.cpp"),
Object(Matching, "scene/setting/iplAPScanThread.cpp"),
Object(NonMatching, "scene/setting/iplUSBAP.cpp"),
Object(Matching, "scene/setting/iplUSBAP.cpp"),
Object(NonMatching, "scene/setting/iplUSBAPThread.cpp"),
Object(Matching, "scene/setting/iplAOSSThread.cpp"),
Object(NonMatching, "scene/setting/AOSSLink.c"),
@@ -901,7 +901,7 @@ config.libs = [
),
IPLSection("bannerSound", [
Object(Matching, "bannerSound/AudioWavePlayer.cpp"),
Object(Equivalent, "bannerSound/AxAdpcmPlayer.cpp"),
Object(Matching, "bannerSound/AxAdpcmPlayer.cpp"),
Object(Matching, "bannerSound/BannerSoundPlayer.cpp"),
Object(Matching, "bannerSound/AudioWaveUtility.cpp"),
]
@@ -918,9 +918,9 @@ config.libs = [
Object(NonMatching, "keyboard/tiString.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiAtokString.cpp", extra_cflags=["-O4,p"]), # for 4.3J
Object(NonMatching, "keyboard/tiZiString.cpp", extra_cflags=["-O4,p"]), # for 4.3U and 4.3E
Object(NonMatching, "keyboard/tiTextDrawer.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiTextDrawer.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiNw4rManager.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiManager.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiUtil.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiCpData.cpp", extra_cflags=["-O4,p"], shift_jis=False),
Object(Matching, "keyboard/tiSwData.cpp", extra_cflags=["-O4,p"], shift_jis=False),
@@ -933,8 +933,8 @@ config.libs = [
Object(Matching, "keyboard/MyTiBg.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiDebug.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiGUIManager.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiHKBManager.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiHwKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiHKBManager.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiHwKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiLayout.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiLayoutGather.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiKoreanInput.cpp", extra_cflags=["-O4,p"]), # for 4.3K
@@ -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"),
]
@@ -1869,7 +1869,7 @@ config.libs = [
),
RVLSDKLib("nup", [
Object(NonMatching, "nup/nup.cpp"),
Object(NonMatching, "nup/nup_nhttp.cpp"),
Object(Matching, "nup/nup_nhttp.cpp"),
Object(Matching, "nup/nup_mem.cpp"),
]
),

View File

@@ -38,7 +38,11 @@ namespace ipl {
u8 unk_0x07; // 0x07
u8 iconFmt[8]; // 0x08
u16 anmFrameBits; // 0x10
#ifdef IPL_MEMORY_CARD_MANAGER_CPP
volatile s16 anmMax;
#else
s16 anmMax; // 0x12
#endif
u32 bannerOffset; // 0x14
u32 bannerTlutOffset; // 0x18
u32 iconOffset[8]; // 0x1C

View File

@@ -35,8 +35,8 @@ namespace ext_ead {
class SurfaceManager {
public:
static void CreateManager(int rectW0, int rectH0, int rectW1, int rectH1, void* mem1Buf, u32 mem1BufSize, void* mem2Buf, u32 mem2BufSize,
void* libBuf, const char* param_10);
static void CreateManager(int surfaceW, int surfaceH, int browserW, int browserH, void* mem1Buf, u32 mem1BufSize, void* mem2Buf, u32 mem2BufSize,
void* libBuf, const char* arcPath);
static void DisposeManager();
static void RegisterArcFile(void* fileBuf);

View File

@@ -92,7 +92,11 @@ namespace textinput {
virtual void setSaveData(savedata::MemoSetting memoSetting) {
mMemoSetting = memoSetting;
}
#ifdef IPL_KEYBOARD_MEMO_GET_SAVE_DATA
virtual savedata::MemoSetting getSaveData();
#else
virtual savedata::MemoSetting getSaveData() { return mMemoSetting; }
#endif
virtual void changeState(StateTimeLine stateTimeLine);
virtual State* getState() { return mpCurrentState; }

View File

@@ -20,6 +20,8 @@ namespace textinput {
public:
void NotifyEvent(u8 down, u8 code);
void Update();
bool HasCurrentKey(u32 slot) const { return (current & (1 << slot)) != 0; }
bool HadPreviousKey(u32 slot) const { return (previous & (1 << slot)) != 0; }
void UpdateModState_();
void Clear() {
held = 0;
@@ -107,10 +109,23 @@ namespace textinput {
HKBManager* manager;
};
HKBManager() __attribute__((never_inline));
~HKBManager();
static HKBManager& getInstance() { return sInstance; }
void Initialize();
void ClearState();
u32 FilterCharacter(u32 code) const {
if (allowedCharacters == 0) return code;
u32 count = allowedCharacterCount;
if (count == 0) return code;
for (u32 index = 0; index < count; index++) {
if (static_cast<u16>(code) == allowedCharacters[index]) return code;
}
return 0;
}
void DetachDevice(KBDDevEvent* event) {
u8 device = event->device;
attached[device] = 0;
states[device].Clear();
}
u32 GetModifierState() const;
void SetCountry(u8 country);
void SetModifierState(u32 state, u32 mask);
@@ -149,6 +164,7 @@ namespace textinput {
void Update();
u32 GetModifierState() const;
void SetCountry(u8 country);
void SetModifierState(u32, u32);
#if defined(TI_CELLPHONE_HKB_KEYSET)

View File

@@ -15,12 +15,12 @@ namespace textinput {
#endif
public:
HWKeyboard(Manager *);
#ifdef TIMANAGER_IMPLEMENTATION
#if defined(TIMANAGER_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION)
inline ~HWKeyboard();
#else
~HWKeyboard();
#endif
#ifdef TIMANAGER_IMPLEMENTATION
#if defined(TIMANAGER_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION)
void setLanguage(Destination destination, Language language);
#endif
@@ -29,7 +29,7 @@ namespace textinput {
wchar_t convertWCCode(wchar_t code) const;
#endif
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION)
void updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data);
#else
virtual void updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data);
@@ -46,9 +46,10 @@ namespace textinput {
bool updateTappingShift_(input::HKBManager&);
#endif
void updateShift(input::HKBManager& hkbManager);
void controlKeyTriggeredHandler(input::HKBManager);
bool controlKeyTriggeredHandler(input::HKBManager&);
Manager *mgr() { return mpManager; }
const Manager *mgr() const { return mpManager; }
Manager* mpManager; // 0x10
u8 field_0x14; // 0x14

View File

@@ -133,7 +133,11 @@ namespace textinput {
friend class Base;
public:
RowInfoManager(u16 maxLength) : mpInfo(NULL), mMaxLength(maxLength), mpAllocator(NULL) {}
#ifdef TIINPUTFORM_IMPLEMENTATION
void init() __attribute__((never_inline));
#else
void init();
#endif
~RowInfoManager();
#endif
private:

View File

@@ -113,6 +113,8 @@ namespace textinput {
#ifdef TIMANAGER_IMPLEMENTATION
virtual void setTitleText(wchar_t* titleText);
void initAspect();
#elif defined(MYTIMANAGER_IMPLEMENTATION)
virtual void setTitleText(wchar_t* titleText);
#else
virtual void setTitleText(const wchar_t* titleText);
#endif
@@ -135,8 +137,13 @@ namespace textinput {
virtual keyboard::cellphonetype::LayoutByNW4R* getCellPhoneKeyboard() { return mpCellPhoneKeyboard; }
virtual const keyboard::cellphonetype::LayoutByNW4R* getCellPhoneKeyboard() const { return mpCellPhoneKeyboard; }
#ifdef TIMANAGER_IMPLEMENTATION
virtual void* getSignKeyboard();
virtual const void* getSignKeyboard() const;
#else
virtual void* getSignKeyboard() { return mpSignWindow; }
virtual const void* getSignKeyboard() const { return mpSignWindow; }
#endif
virtual candidatebox::LayoutByNW4R* getCandidateBox() { return mpCandidateBox; }
virtual const candidatebox::LayoutByNW4R* getCandidateBox() const { return mpCandidateBox; }
@@ -144,8 +151,13 @@ namespace textinput {
virtual toolbar::LayoutByNW4R* getToolBar() { return mpToolBar; }
virtual const toolbar::LayoutByNW4R* getToolBar() const { return mpToolBar; }
#ifdef TIMANAGER_IMPLEMENTATION
virtual void* getPredictLanguageSelectDialog();
virtual const void* getPredictLanguageSelectDialog() const;
#else
virtual void* getPredictLanguageSelectDialog() { return mpPredictLanguageDialog; }
virtual const void* getPredictLanguageSelectDialog() const { return mpPredictLanguageDialog; }
#endif
virtual inputform::EditBuffer* createEditBuffer();
virtual keyboard::hwkey::HWKeyboard* createHWKeyboard();

View File

@@ -7,6 +7,10 @@
#include "utility/iplFrameController.h"
#ifdef IPL_GC_WINDOW_CPP
#include "math/iplMathTypes.h"
#endif
#ifdef IPL_GCW_INTP_CTOR_OUT_OF_LINE
#include "global/decomp/utils.h"
#endif
@@ -38,6 +42,33 @@ namespace ipl {
T mEnd;
};
#ifdef IPL_GC_WINDOW_CPP
template <>
class Interporation<VEC3> : public utility::FrameController {
public:
virtual ~Interporation();
void init(int playback, f32 maxFrame, f32 minFrame, const VEC3& start,
const VEC3& end, f32 speed = 1.0f) {
mStart = start;
mEnd = end;
utility::FrameController::init(playback, maxFrame, minFrame, speed);
}
const VEC3& getStart() { return mStart; }
const VEC3& getEnd() { return mEnd; }
void playBackwards() {
mAnmType = ANIM_TYPE_BACKWARD;
mState = ANIM_STATE_PLAY;
}
protected:
VEC3 mStart;
VEC3 mEnd;
};
#endif
template <typename T>
class LinearIntp : public Interporation<T> {
public:
@@ -61,6 +92,16 @@ namespace ipl {
T get2() const { return (((mStart * (mMaxFrame - mFrame)) + (mEnd * mFrame)) / mMaxFrame); }
};
#ifdef IPL_GC_WINDOW_CPP
template <>
class LinearIntp<VEC3> : public Interporation<VEC3> {
public:
LinearIntp() {}
virtual ~LinearIntp();
VEC3 get() const;
};
#endif
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
template <typename T>

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

@@ -309,8 +309,8 @@ namespace ipl {
return mbArrowVisible[i];
}
void setUnk_0x105(bool flag) {
unk_0x105 = flag;
void setSuppressNewMailAnm(bool flag) {
mbSuppressNewMailAnm = flag;
}
protected:
@@ -354,7 +354,7 @@ namespace ipl {
ANIM_MAX,
};
int unk_0x54;
int mAnimWait;
layout::Object* mpLayout; // 0x58
nand::LayoutFile* mpLayoutFile; // 0x5C
@@ -373,8 +373,8 @@ namespace ipl {
BOOL mbHovered[BTN_MAX]; // 0xD8
bool unk_0x104;
bool unk_0x105;
bool mbNewMailAnm;
bool mbSuppressNewMailAnm;
utility::timer mTimer; // 0x108
bool mbEnabled; // 0x110

View File

@@ -95,9 +95,9 @@ namespace ipl {
public:
nw4r::ut::List mDateList; // 0x84
nw4r::ut::List unk_0x90;
nw4r::ut::List mDrawList;
bool mbScrolling; // 0x9C
vBOOL unk_0xA0;
vBOOL mbSearchTaskRunning;
BOOL mbTaskCanceled; // 0xA4
vBOOL mbBackToBoardAlt; // 0xA8
bool mbAsian; // 0xAC

View File

@@ -68,8 +68,8 @@ namespace ipl {
vBOOL mbAppearMsg; // 0x0C
private:
u32 unk_0x10;
int unk_0x14;
u32 mFocusState;
int mPendingFocusCmd;
layout::Object* mpLayout; // 0x18
gui::PaneManager* mpGui; // 0x1C
layout::PaneAnimator* mpCurrentPaneAnim; // 0x20
@@ -77,7 +77,7 @@ namespace ipl {
public:
utility::Date* mpDate; // 0x38
u32 unk_0x3C;
u32 mPointCount;
static const char* mscAnimPanes[ANIM_PANE_MAX];

View File

@@ -293,8 +293,8 @@ namespace ipl {
LOCKED_DIALOG_ANIM_MAX,
};
static void iplChannelTitle_813BA684(void* work);
static void iplChannelTitle_813BA784(void* work);
static void markTmdReadyTask(void* work);
static void deleteTmpTitleContentTask(void* work);
static void getTmdTask(void* work);
static void getTicketLimitTask(void* work);
static BOOL isTimeLimitedTicket(ESTicketView * ticket, u32* remainTime = NULL);

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

@@ -42,7 +42,7 @@ namespace ipl {
};
virtual BOOL isResetAcceptable() const {
return unk_0x7D;
return mbResetAcceptable;
}
virtual void prepare();
@@ -108,7 +108,7 @@ namespace ipl {
static const int mToFace_Duration = 20;
bool mbClosing; // 0x7C
bool unk_0x7D;
bool mbResetAcceptable;
wchar_t* mWCString; // 0x80

View File

@@ -44,7 +44,7 @@ namespace ipl {
int stopBGM(int unk = 0);
#endif
int stopBGM(nw4r::snd::SoundHandle* handle, int unk = 0);
int stopSE(nw4r::snd::SoundHandle* handle, int unk = 0);
void stopSE(nw4r::snd::SoundHandle* handle, int unk = 0);
void stopAllSound(int unk = 0);
int resetAllSound();
@@ -99,7 +99,7 @@ namespace ipl {
long clipGELT_S32(long value, long lo, long hi);
private:
u32 unk_0x620[0x18];
u32 unk_0x620[3];
};
// use getSystem() and getBannerPlayer() instead

View File

@@ -336,19 +336,19 @@ namespace ipl {
BOOL nand_error_handling(int code);
SEntry* fn_8133A4E0(ESTitleId titleId);
u32 fn_8133A57C(ESTitleId titleId);
u32 fn_8133A5B8(ESTitleId titleId);
BOOL fn_8133A5F0(ESTitleId titleId);
BOOL fn_8133A634(ESTitleId titleId);
BOOL fn_8133A678(ESTitleId titleId);
BOOL fn_8133A6B8(ESTitleId titleId);
BOOL fn_8133A73C(ESTitleId titleId);
nand::MetaFile* fn_8133A7A4(EGG::Heap* heap, ESTitleId titleId);
nand::MetaFile* fn_8133A85C(EGG::Heap* heap, ESTitleId titleId);
nand::SharedFile* fn_8133A924(EGG::Heap* heap, ESTitleId titleId);
void fn_8133A9F0();
void fn_8133AA50(ESTitleId titleId);
SEntry* findEntryByTitleId(ESTitleId titleId);
u32 getBannerCSIdx(ESTitleId titleId);
u32 getSoundSize(ESTitleId titleId);
BOOL needsNetSetting(ESTitleId titleId);
BOOL usesAltSound(ESTitleId titleId);
BOOL isMissingTicket(ESTitleId titleId);
BOOL isNewsChannelV6Plus(ESTitleId titleId);
BOOL isOperaChannel(ESTitleId titleId);
nand::MetaFile* readBannerMetaAsync(EGG::Heap* heap, ESTitleId titleId);
nand::MetaFile* readSoundMetaAsync(EGG::Heap* heap, ESTitleId titleId);
nand::SharedFile* readBannerCSAsync(EGG::Heap* heap, ESTitleId titleId);
void clearTmpChannel();
void unloadBanner(ESTitleId titleId);
BOOL isReady() { return mState == FINISH; }

View File

@@ -92,7 +92,7 @@ namespace ipl {
void read_sd_app_location_async(ESTitleId32* titleIds);
void check_for_sd_app_to_nand_async(ESTitleId titleId, AppBlocksInfo* usedBlocks, AppBlocksInfo* freeBlocks);
void check_backup_fits_async(TitleIdList* newTitles, TitleIdList* replacingTitles);
void iplNandSD_81348EA8(void* ptrA, void* ptrB, void* ptrC);
void check_sd_app_titles_async(void* ptrA, void* ptrB, void* ptrC);
void list_nand_apps_usage_async(void* ptrA, void* ptr);
@@ -152,7 +152,7 @@ namespace ipl {
BOOL is_working();
#ifdef IPL_SD_CHANNEL_SELECT_CPP
void requestCancel() { unk_0x04 = true; }
void requestCancel() { mbCancel = true; }
#endif
WIISaveBannerFile* get_cached_nand_save_banner(ESTitleId titleId);
@@ -514,7 +514,7 @@ namespace ipl {
void do_check_for_sd_app_to_nand();
void check_backup_fits();
void do_list_nand_apps_usage();
void do_unk_8134C838();
void do_check_sd_app_titles();
void do_move_nand_app_to_sd();
void do_move_sd_app_to_nand();
@@ -531,7 +531,7 @@ namespace ipl {
static void wad_backup_progress_callback(u32 completed, u32 total, BOOL done);
Work* myWork; // 0x00
bool unk_0x04; // 0x04
bool mbCancel; // 0x04
static const char* c_banner_file_name;
static const char* c_nocopy_folder_name;

View File

@@ -26,6 +26,18 @@ namespace ipl {
namespace savedata {
extern "C" BOOL isTitleCached(void* manager, ESTitleId titleId);
struct ChannelSlot {
u8 valid; // 0x00 (primaryType)
u8 pad[3]; // 0x01
s32 titleId; // 0x04 (sceneID)
u8 rest[8]; // 0x08
};
struct ChannelPage {
u8 pad[0x30];
ChannelSlot slots[MAX_CHANNEL_INDEX]; // 0x30
};
class Manager {
public:
Manager(EGG::Heap* heap);

View File

@@ -50,7 +50,7 @@ namespace ipl {
static BOOL IsLastTicketExpired(ESTitleId* titleId);
static void DeleteExpiredFlagFile();
static void DeleteUnauthorizedData(EGG::Heap* heap);
static s32 DeleteUnauthorizedData(EGG::Heap* heap);
static u32 CheckTmdCountryCode(ESTmdView* tmdView);
static u32 CheckTmdParentalControl(ESTmdView* tmdView);

View File

@@ -977,6 +977,7 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
long double long_double_num;
wchar_t buff[512];
wchar_t* buff_ptr;
wchar_t* buff_end = buff + 511;
const wchar_t* string_end;
wchar_t fill_char = ' ';
@@ -1038,7 +1039,7 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
}
}
num_chars = buff + 512 - 1 - buff_ptr;
num_chars = ((long)buff_end - (long)buff_ptr) / 2;
break;
case 'o':
@@ -1080,7 +1081,7 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
}
}
num_chars = buff + 512 - 1 - buff_ptr;
num_chars = ((long)buff_end - (long)buff_ptr) / 2;
break;
case 'f':
@@ -1099,7 +1100,7 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
goto conversion_error;
}
num_chars = buff + 512 - 1 - buff_ptr;
num_chars = ((long)buff_end - (long)buff_ptr) / 2;
break;
case 'a':
@@ -1114,7 +1115,7 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
goto conversion_error;
}
num_chars = buff + 512 - 1 - buff_ptr;
num_chars = ((long)buff_end - (long)buff_ptr) / 2;
break;
case 's':

View File

@@ -301,9 +301,9 @@ namespace nw4r {
}
if (error == OS_EXCEPTION_FLOATING_POINT_EXCEPTION) {
u32 uVar1 = sException.FPCSR_COPY;
uVar1 &= (((uVar1 & 0xf8) << 0x16) | 0x01f80700);
if ((uVar1 & 0x20000000) != 0) {
u32 fpcsr = sException.FPCSR_COPY;
fpcsr &= (((fpcsr & 0xf8) << 0x16) | 0x01f80700);
if ((fpcsr & 0x20000000) != 0) {
Exception_Printf_(" FPE: Invalid operation\n");
if ((sException.FPCSR_COPY & 0x1000000) != 0) {
Exception_Printf_(" SNaN\n");
@@ -333,16 +333,16 @@ namespace nw4r {
Exception_Printf_(" Invalid integer convert\n");
}
}
if ((uVar1 & 0x10000000) != 0) {
if ((fpcsr & 0x10000000) != 0) {
Exception_Printf_(" FPE: Overflow\n");
}
if ((uVar1 & 0x8000000) != 0) {
if ((fpcsr & 0x8000000) != 0) {
Exception_Printf_(" FPE: Underflow\n");
}
if ((uVar1 & 0x4000000) != 0) {
if ((fpcsr & 0x4000000) != 0) {
Exception_Printf_(" FPE: Zero division\n");
}
if ((uVar1 & 0x2000000) != 0) {
if ((fpcsr & 0x2000000) != 0) {
Exception_Printf_(" FPE: Inexact result\n");
}
}

View File

@@ -1,19 +1,19 @@
#include <nw4r/db/assert.h>
extern "C" const u8 lbl_81695550 = 255;
extern "C" const u8 lbl_81695551 = 255;
extern "C" const u8 lbl_81695552 = 255;
extern "C" const u8 lbl_81695553 = 0;
extern "C" char lbl_816719DC[] = "Error#004\nAn error has occurred.\nThe system files are corrupted.";
extern "C" const u8 scLytFatalColorR = 255;
extern "C" const u8 scLytFatalColorG = 255;
extern "C" const u8 scLytFatalColorB = 255;
extern "C" const u8 scLytFatalColorA = 0;
extern "C" char scLytFatalMsg[] = "Error#004\nAn error has occurred.\nThe system files are corrupted.";
#undef NW4R_ASSERT
#define NW4R_ASSERT(x) \
{ \
if (!(x)) { \
GXColor front = {*((volatile const u8*)&::lbl_81695550), *((volatile const u8*)&::lbl_81695551), \
*((volatile const u8*)&::lbl_81695552), *((volatile const u8*)&::lbl_81695553)}; \
GXColor front = {*((volatile const u8*)&::scLytFatalColorR), *((volatile const u8*)&::scLytFatalColorG), \
*((volatile const u8*)&::scLytFatalColorB), *((volatile const u8*)&::scLytFatalColorA)}; \
GXColor back = {0, 0, 0, 0}; \
OSFatal((GXColor)front, (GXColor)back, ::lbl_816719DC); \
OSFatal((GXColor)front, (GXColor)back, ::scLytFatalMsg); \
} \
}

View File

@@ -64,8 +64,8 @@ typedef struct {
u16 mcuYCount; // 0x10
u16 mcuXCount2; // 0x12
u32 unk_0x14;
u8 unk_0x18;
u8 unk_0x19;
u8 remX; // 0x18
u8 remY; // 0x19
u8 compCount; // 0x1A
u8 scanCompCount; // 0x1B
u8 blockCount[4]; // 0x1C
@@ -143,8 +143,8 @@ struct TMCCJPEGDecWork_t {
u16 mcuYCount; // 0x1800
u16 mcuXCount2; // 0x1802
u32 unk_0x1804;
u8 unk_0x1808;
u8 unk_0x1809;
u8 remX; // 0x1808
u8 remY; // 0x1809
u8 compCount; // 0x180A
u8 scanCompCount; // 0x180B
u8 blockCount[4]; // 0x180C

View File

@@ -1,7 +1,7 @@
#include <tmc_jpeg_internal.h>
static s32 TMCJPEG_814EAF50(TMCCJPEGDecWork* work);
static s32 TMCJPEG_814EB108(TMCCJPEGDecWork* work);
static s32 refillJpegBufferAfterFF(TMCCJPEGDecWork* work);
static s32 refillJpegBuffer(TMCCJPEGDecWork* work);
s32 TMCJPEGDEC_init_ptr_buff(TMCCJPEGDecWork* work, void* param) {
u32 readSize;
@@ -52,7 +52,7 @@ s32 TMCJPEGDEC_get_byte(u8* dst, TMCCJPEGDecWork* work) {
if (work->pBufCur >= work->pBufEnd) {
if (work->remaining != 0) {
s32 r = TMCJPEG_814EB108(work);
s32 r = refillJpegBuffer(work);
if (r < 0) {
return r;
}
@@ -69,7 +69,7 @@ s32 TMCJPEGDEC_get_byte(u8* dst, TMCCJPEGDecWork* work) {
if (cur >= work->pBufEnd) {
if (work->remaining != 0) {
s32 r = TMCJPEG_814EB108(work);
s32 r = refillJpegBuffer(work);
if (r < 0) {
return r;
}
@@ -92,7 +92,7 @@ s32 TMCJPEGDEC_get_wbyte(u16* dst, TMCCJPEGDecWork* work) {
if (work->pBufCur >= work->pBufEnd) {
if (work->remaining != 0) {
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r < 0) {
goto br;
} else {
@@ -119,7 +119,7 @@ s32 TMCJPEGDEC_get_wbyte(u16* dst, TMCCJPEGDecWork* work) {
}
if (work->remaining != 0) {
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r >= 0) {
goto o1;
}
@@ -144,7 +144,7 @@ p2:
goto r2;
}
if (work->remaining != 0) {
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r < 0)
goto ez;
else {
@@ -166,7 +166,7 @@ r2:
}
if (work->remaining != 0) {
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r < 0)
goto ez;
else {
@@ -193,7 +193,7 @@ s32 TMCJPEGDEC_get_sbyte(u8* dst, u32 count, TMCCJPEGDecWork* work) {
for (i = 0; i < count; i++) {
if (work->pBufCur >= work->pBufEnd) {
if (work->remaining != 0) {
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r < 0) {
goto copy_byte;
} else {
@@ -214,7 +214,7 @@ s32 TMCJPEGDEC_get_sbyte(u8* dst, u32 count, TMCCJPEGDecWork* work) {
goto r0;
}
if (work->remaining != 0) {
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r >= 0) {
goto r0;
}
@@ -251,7 +251,7 @@ lp:
if (work->remaining == 0) {
goto er1;
}
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r >= 0) {
goto lc;
}
@@ -271,7 +271,7 @@ lc:
if (work->remaining == 0) {
goto er2;
}
r = TMCJPEG_814EB108(work);
r = refillJpegBuffer(work);
if (r >= 0) {
goto ret0;
}
@@ -320,7 +320,7 @@ s32 TMCJPEGDEC_load_buff(TMCCJPEGDecWork* work) {
if (work->remaining == 0) {
break;
}
r = TMCJPEG_814EAF50(work);
r = refillJpegBufferAfterFF(work);
if (r < 0) {
return r;
}
@@ -345,7 +345,7 @@ s32 TMCJPEGDEC_load_buff(TMCCJPEGDecWork* work) {
if (work->remaining == 0) {
break;
}
r = TMCJPEG_814EAF50(work);
r = refillJpegBufferAfterFF(work);
if (r < 0) {
return r;
}
@@ -364,7 +364,7 @@ s32 TMCJPEGDEC_chk_possible_size(TMCCJPEGDecWork* work) {
return work->pBufEnd - work->pBufCur;
}
static s32 TMCJPEG_814EAF50(TMCCJPEGDecWork* work) {
static s32 refillJpegBufferAfterFF(TMCCJPEGDecWork* work) {
u8 marker;
u32 readSize;
u8* dest;
@@ -410,7 +410,7 @@ static s32 TMCJPEG_814EAF50(TMCCJPEGDecWork* work) {
return 0;
}
static s32 TMCJPEG_814EB108(TMCCJPEGDecWork* work) {
static s32 refillJpegBuffer(TMCCJPEGDecWork* work) {
u8* end;
u32 i, j;
s32 readSize;

View File

@@ -59,8 +59,8 @@ s32 TMCJPEGDEC_Setsize(TMCCJPEGDecWork* work) {
state->stepY = (state->scaleFactor + work->mcuXRem - 1) / state->scaleFactor;
state->jpegWidth = ((s32)(work->frameWidth + state->scaleFactor) - 1) / state->scaleFactor;
state->jpegHeight = (state->scaleFactor + work->frameHeight - 1) / state->scaleFactor;
state->stepXExt = (state->scaleFactor + work->unk_0x1808 - 1) / state->scaleFactor;
state->stepYExt = (state->scaleFactor + work->unk_0x1809 - 1) / state->scaleFactor;
state->stepXExt = (state->scaleFactor + work->remX - 1) / state->scaleFactor;
state->stepYExt = (state->scaleFactor + work->remY - 1) / state->scaleFactor;
state->dataSizeX = (state->stepXExt != 0) ? (state->maxX - 1) * state->stepX : (state->maxX + 1) * state->stepX;
state->dataSizeY = (state->stepYExt != 0) ? (state->maxY - 1) * state->stepY : (state->maxY + 1) * state->stepY;

View File

@@ -2,7 +2,7 @@
extern void* memset(void* dest, s32 val, u32 count);
extern const u32 lbl_8161E080[64] = {
extern const u32 scJpegAanScale[64] = {
0x00000100, 0x000000B9, 0x000000C4, 0x000000DA, 0x00000100, 0x00000146, 0x000001D9, 0x000003A0, 0x000000B9, 0x00000085, 0x0000008D,
0x0000009D, 0x000000B9, 0x000000EB, 0x00000155, 0x0000029D, 0x000000C4, 0x0000008D, 0x00000096, 0x000000A7, 0x000000C4, 0x000000F9,
0x0000016A, 0x000002C6, 0x000000DA, 0x0000009D, 0x000000A7, 0x000000B9, 0x000000DA, 0x00000115, 0x00000192, 0x00000315, 0x00000100,
@@ -562,8 +562,8 @@ s32 TMCJPEGDEC_scan_varinit(TMCCJPEGDecWork* work) {
remX = p->frameWidth % p->mcuXCount;
remY = p->frameHeight % p->mcuXRem;
p->unk_0x18 = remX;
p->unk_0x19 = remY;
p->remX = remX;
p->remY = remY;
p->mcuYCount = p->mcuYCount + ((u8)remX != 0 ? 1 : 0);
p->mcuXCount2 = p->mcuXCount2 + ((u8)remY != 0 ? 1 : 0);
@@ -1424,7 +1424,7 @@ static s32 TMCJPEGDEC_parse_dqt(TMCCJPEGDecWork* work) {
s32 r;
d = tblCopy;
*(CopyBlock64*)d = *(CopyBlock64*)lbl_8161E080;
*(CopyBlock64*)d = *(CopyBlock64*)scJpegAanScale;
scaleInfo = (QuantizationTables*)&work->scaleFlag;
@@ -1919,8 +1919,8 @@ static s32 TMCJPEGDEC_parse_sof(TMCCJPEGDecWork* work) {
remX = fw - mcuCountX * mcuX;
remY = fh - mcuCountY * mcuY;
work->unk_0x1808 = remX;
work->unk_0x1809 = remY;
work->remX = remX;
work->remY = remY;
{
u16 xr = (remX != 0) ? 1 : 0;

View File

@@ -215,9 +215,9 @@ struct __zi8_work_data_s {
ziU32 unk_0x0C;
ziU32 unk_0x10;
ziU16 unk_0x14;
ziU8 unk_0x16;
ziU8 cangjieEnabled; // 0x16
ziU8 unk_0x17;
ziU8 unk_0x18;
ziU8 subLanguage; // 0x18
ziU8 unk_0x19;
ziU16 unk_0x1A;
ziU8 unk_0x1C[3];
@@ -258,7 +258,7 @@ struct __zi8_work_data_s {
ziU8 unk_0x330[8];
ziU32 unk_0x338;
ziU8 unk_0x33C[0x1FC];
ziU8 unk_0x538;
ziU8 language; // 0x538
ziU8 unk_0x539;
ziU8 unk_0x53A[0x40];
ziWChar unk_0x57A[0x641];

View File

@@ -55,7 +55,7 @@ ziU32 Zi8GetTableData(ziU8 lang, ziU8 tableIdx, ziU8 memberId ZI_NEED_WORK) {
if (langIdx-- != 0) {
tableData = ZI_WORK->langEntries[langIdx].tableData;
if ((lang == ZI8_LANG_ZH) && (tableData[3] >= 4) &&
((ZI_WORK->unk_0x18 == 1) || (ZI_WORK->unk_0x18 == 0x80) || (ZI_WORK->unk_0x18 == 0x40))) {
((ZI_WORK->subLanguage == 1) || (ZI_WORK->subLanguage == 0x80) || (ZI_WORK->subLanguage == 0x40))) {
offset = ((tableData[0x8B] << 0x10) + (tableData[0x8C] << 8) + tableData[0x8D]);
if (offset != 0) {
tableData += offset;

View File

@@ -430,7 +430,7 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
if (getMode != 7 && getMode != 10 && getMode != 8 && getMode != 9) {
Zi8PrepareMatch(request, &match, 0, work);
} else {
if (!((struct __zi8_work_data_s*)work)->unk_0x16 || request->elementCount > 6) {
if (!((struct __zi8_work_data_s*)work)->cangjieEnabled || request->elementCount > 6) {
resultFallback = 0;
goto engine_finish;
}
@@ -1151,7 +1151,7 @@ context_word_lookup:
if (ordinalIndex == 0xFFFF) goto context_results_done;
record = records + ordinalIndex * 12;
phoneticGroups = phraseTable + ((record[9] & 15) << 16 | (record[11] | record[10] << 8));
if (((struct __zi8_work_data_s*)work)->unk_0x16) {
if (((struct __zi8_work_data_s*)work)->cangjieEnabled) {
switch (phoneticGroups[0] & 7) {
case 2: phoneticGroups += 2; break;
case 3: case 4: phoneticGroups += 3; break;
@@ -1965,7 +1965,7 @@ component_retry:
((ZiChineseWork*)work)->duplicateOrdinals[((ZiChineseWork*)work)->duplicateIndex] = ordinalIndex;
relatedRecord = records + ordinalIndex * 12;
phoneticGroups = phraseTable + ((relatedRecord[9] & 15) << 16 | (relatedRecord[11] | relatedRecord[10] << 8));
if (((struct __zi8_work_data_s*)work)->unk_0x16) {
if (((struct __zi8_work_data_s*)work)->cangjieEnabled) {
switch (phoneticGroups[0] & 7) {
case 2: phoneticGroups += 2; break;
case 3: case 4: phoneticGroups += 3; break;

View File

@@ -164,7 +164,7 @@ static ziBool Zi8AlphaSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED
if (parameters->maxCandidates < length) length = parameters->maxCandidates;
parameters->letters = length;
if ((parameters->getOptions & 0x80) == 0) {
ZI_WORK->unk_0x538 = parameters->language;
ZI_WORK->language = parameters->language;
parameters->candidates[0] = 0xfff0;
output = (ziWChar*)&ZI_WORK->unk_0x338;
}
@@ -490,8 +490,8 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
ZI_WORK->unk_0x00 = '\0';
}
}
ZI_WORK->unk_0x18 = parameters->subLanguage;
ZI_WORK->unk_0x16 = Zi8GetFormatVersion(1,ZI_WORK) & 2;
ZI_WORK->subLanguage = parameters->subLanguage;
ZI_WORK->cangjieEnabled = Zi8GetFormatVersion(1,ZI_WORK) & 2;
options->maxCount = ZI_WORK->unk_0x10;
options->maxWordLength = ZI_WORK->unk_0x0A;
ZI_WORK->unk_0x0A = -1;
@@ -558,7 +558,7 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
}
else if ((parameters->language == 1) &&
((((parameters->getMode == 7 || (parameters->getMode == 8)) || (parameters->getMode == 10)) || (parameters->getMode == 9)))) {
if (ZI_WORK->unk_0x16 != '\0') {
if (ZI_WORK->cangjieEnabled != '\0') {
candidateCount = Zi8GetChineseCandidates(parameters,options,ZI_WORK);
} else {
error = 0x708;
@@ -582,7 +582,7 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
}
}
else {
ZI_WORK->unk_0x538 = parameters->language;
ZI_WORK->language = parameters->language;
if ((parameters->getOptions & 0x80) == 0) {
saved.restoreCandidates = 1;
saved.savedOptions = parameters->getOptions;

View File

@@ -42,13 +42,13 @@ ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
return 0;
}
ZI_WORK->unk_0x1874 = 0x2D;
ZI_WORK->unk_0x538 = 0;
ZI_WORK->language = 0;
ZI_WORK->unk_0x1C[3] = 0;
ZI_WORK->unk_0x141A = 0x100;
Zi8SetLatinSearchOrder(0, 0, ZI_WORK);
ZADP_Zi8SetPDremoveOpt(1, ZI_WORK);
ZI_WORK->unk_0x17 = 5;
ZI_WORK->unk_0x16 = Zi8GetFormatVersion(1, ZI_WORK) & 2;
ZI_WORK->cangjieEnabled = Zi8GetFormatVersion(1, ZI_WORK) & 2;
ZI_WORK->unk_0x1B28.bits.msb = 1;
ZI_WORK->unk_0x1B2C.bits.msb = 1;
zyFuzzy = ZI_WORK->unk_0x1B2C.word;

View File

@@ -24,17 +24,17 @@ ziU8 Zi8GetZHCharSet(ziPtr workData) {
return 0;
}
if (Zi8GetTableCount(1, 10, workData) != 0) {
bak = ((struct __zi8_work_data_s*)workData)->unk_0x18;
((struct __zi8_work_data_s*)workData)->unk_0x18 = 1;
bak = ((struct __zi8_work_data_s*)workData)->subLanguage;
((struct __zi8_work_data_s*)workData)->subLanguage = 1;
addr = Zi8GetTableAddress(1, 10, workData);
p = (ziU8*)addr;
v0 = (ziU16)((ziU16)p[0] | ((ziU16)p[1] << 8));
((struct __zi8_work_data_s*)workData)->unk_0x18 = 0;
((struct __zi8_work_data_s*)workData)->subLanguage = 0;
addr = Zi8GetTableAddress(1, 10, workData);
p = (ziU8*)addr;
v1 = (ziU16)((ziU16)p[2] | ((ziU16)p[3] << 8));
v2 = (ziU16)((ziU16)p[4] | ((ziU16)p[5] << 8));
((struct __zi8_work_data_s*)workData)->unk_0x18 = bak;
((struct __zi8_work_data_s*)workData)->subLanguage = bak;
if (v0 != 0) {
if (v0 > 0x4E20) {
charSet |= 8;

View File

@@ -139,7 +139,7 @@ ziU32 Zi8SecMatchChar(ziPtr nodeAddress, ziU8* dictionaryAddress, ziMatchParam*
data = (ziU8*)Zi8GetTableAddress(1, 1, ZI_WORK);
data += ((ziU8*)nodeAddress)[0xB] + (((ziU8*)nodeAddress)[0xA] << 8) + ((((ziU8*)nodeAddress)[9] & 0xF) << 16);
if (ZI_WORK->unk_0x16 != 0) {
if (ZI_WORK->cangjieEnabled != 0) {
switch (data[0] & 7) {
case 2:
data += 2;
@@ -346,7 +346,7 @@ match_code:
traversal.soundIndex = initialCode;
}
sound = (ziU8*)(tableAddress + ((node[9] & 0xF) * 0x10000 + (node[0xB] + node[0xA] * 0x100)));
if (ZI_WORK->unk_0x16 != 0) {
if (ZI_WORK->cangjieEnabled != 0) {
switch (sound[0] & 7) {
case 2:
sound += 2;

View File

@@ -37,7 +37,7 @@ ziU16 Zi8Uni2Ptr(ziU16 ch, ziE12* buf ZI_NEED_WORK) {
p = (ziU8*)(table2 +
(((e[9] & 0xF) << 16) |
(e[0xB] | (e[0xA] << 8))));
if (WORKP->unk_0x16 != 0) {
if (WORKP->cangjieEnabled != 0) {
switch (p[0] & 7) {
case 2:
p += 2;
@@ -65,7 +65,7 @@ ziU16 Zi8Uni2Ptr(ziU16 ch, ziE12* buf ZI_NEED_WORK) {
}
}
e = (ziU8*)table;
if (WORKP->unk_0x1B18 != ZI8_NULL && WORKP->unk_0x1B24 == WORKP->unk_0x18) {
if (WORKP->unk_0x1B18 != ZI8_NULL && WORKP->unk_0x1B24 == WORKP->subLanguage) {
if ((ziU16)ch >= WORKP->unk_0x1B1C && (ziU16)ch <= WORKP->unk_0x1B1E) {
i = (ziU16)(ch - WORKP->unk_0x1B1C);
goto map;

View File

@@ -4,7 +4,7 @@
ziU32 Zi8GetTableAddress(ziU8 lang, ziU8 tableIdx, ziPtr workData);
ziU16 Zi8GetTableCount(ziU8 lang, ziU8 tableIdx, ziPtr workData);
ziU8 Zi8_814813FC(ziWChar character, ziU8* result, ziU16* index, ziPtr workData) {
ziU8 Zi8LookupKoreanChar(ziWChar character, ziU8* result, ziU16* index, ziPtr workData) {
ziU16 i;
ziU8* table;
@@ -23,7 +23,7 @@ ziU8 Zi8_814813FC(ziWChar character, ziU8* result, ziU16* index, ziPtr workData)
return 0;
}
ziU8 Zi8_81481E6C(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 count, ziPtr workData);
ziU8 Zi8MatchKoreanSequence(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 count, ziPtr workData);
ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
ziPtr workData) {
@@ -97,9 +97,9 @@ ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
result = 0;
for (currentCharacter = 0; currentCharacter < state.elementIndex; currentCharacter++) {
if (Zi8_814813FC(buffer[currentCharacter], &state.characterIndex,
if (Zi8LookupKoreanChar(buffer[currentCharacter], &state.characterIndex,
&state.inputIndex, workData) != 0) {
state.matched = Zi8_81481E6C(&state.nextIndex,
state.matched = Zi8MatchKoreanSequence(&state.nextIndex,
buffer + currentCharacter + 1,
state.characterIndex,
(state.elementIndex - currentCharacter) - 1,
@@ -235,7 +235,7 @@ ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
return result;
}
ziU8 Zi8_81481E6C(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 count, ziPtr workData) {
ziU8 Zi8MatchKoreanSequence(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 count, ziPtr workData) {
ziU16 nestedScratch;
ziU16 nestedIndexStorage;
ziU16 index1;
@@ -375,8 +375,8 @@ ziU8 Zi8_81481E6C(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 count, ziPt
}
if ((index3 >= tableCount) || (firstCharacter != (table + index3 * 4)[2]) ||
(input[1] != (table + index3 * 4)[1]) || (input[0] != table[index3 * 4])) {
if ((Zi8_814813FC(input[1], &mappedCharacter, &nestedScratch, workData) != 0) &&
(Zi8_81481E6C(&nestedIndexStorage, input + 2, mappedCharacter, 1, workData) != 0)) {
if ((Zi8LookupKoreanChar(input[1], &mappedCharacter, &nestedScratch, workData) != 0) &&
(Zi8MatchKoreanSequence(&nestedIndexStorage, input + 2, mappedCharacter, 1, workData) != 0)) {
*resultIndex = index1;
return 1;
}
@@ -397,8 +397,8 @@ ziU8 Zi8_81481E6C(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 count, ziPt
if ((index4 >= tableCount) || (firstCharacter != (table + index4 * 4)[3]) ||
(input[2] != (table + index4 * 4)[2]) || (input[1] != (table + index4 * 4)[1]) ||
(input[0] != table[index4 * 4])) {
if ((Zi8_814813FC(input[2], &mappedCharacter, &nestedScratch, workData) != 0) &&
(Zi8_81481E6C(&nestedIndexStorage, input + 3, mappedCharacter, 1, workData) != 0)) {
if ((Zi8LookupKoreanChar(input[2], &mappedCharacter, &nestedScratch, workData) != 0) &&
(Zi8MatchKoreanSequence(&nestedIndexStorage, input + 3, mappedCharacter, 1, workData) != 0)) {
*resultIndex = index2;
return 2;
}
@@ -409,8 +409,8 @@ ziU8 Zi8_81481E6C(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 count, ziPt
*resultIndex = index4;
return 4;
}
if ((Zi8_814813FC(input[3], &mappedCharacter, &nestedScratch, workData) != 0) &&
(Zi8_81481E6C(&nestedIndexStorage, input + 4, mappedCharacter, 1, workData) != 0)) {
if ((Zi8LookupKoreanChar(input[3], &mappedCharacter, &nestedScratch, workData) != 0) &&
(Zi8MatchKoreanSequence(&nestedIndexStorage, input + 4, mappedCharacter, 1, workData) != 0)) {
*resultIndex = index3;
return 3;
}

View File

@@ -103,10 +103,10 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
if (length == 1) return 1;
count = --length;
ordinals[count] |= 0x8000;
ZI_WORK->unk_0x16 = Zi8GetFormatVersion(1, __zi8_work_data) & 2;
ZI_WORK->cangjieEnabled = Zi8GetFormatVersion(1, __zi8_work_data) & 2;
entry = (ziChineseEntry*)Zi8GetTableAddress(1, 0, __zi8_work_data) + ordinals[0];
data = (ziU8*)Zi8GetTableAddress(1, 1, __zi8_work_data) + ((entry->offsetHigh & 15) << 16 | ((entry->offsetLow[0] << 8) | entry->offsetLow[1]));
if (ZI_WORK->unk_0x16 != 0) {
if (ZI_WORK->cangjieEnabled != 0) {
switch (*data & 7) {
case 2:
offset = 2;

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

@@ -457,7 +457,7 @@ void bta_dm_signal_strength(tBTA_DM_MSG *p_data);
void bta_dm_acl_change(tBTA_DM_MSG *p_data);
BOOLEAN bta_sys_check_compress(int, UINT8 app_id, BD_ADDR peer_addr);
BOOLEAN bta_sys_check_compress(int id, UINT8 app_id, BD_ADDR peer_addr);
void bta_dm_keep_acl(tBTA_DM_MSG *p_data);
void bta_dm_immediate_disable(void);

View File

@@ -151,7 +151,7 @@ UINT8 L2CA_SetTraceLevel(UINT8 new_level);
UINT8 L2CA_SetDesireRole(UINT8 new_role);
BOOLEAN L2CA_SetAclPriority(BD_ADDR bd_addr, UINT8 priority);
void L2CA_SetCompression(UINT16 local_cid, UINT8 pe_type, UINT8 mem_level,
UINT8 wbits, UINT8 direction, UINT8 param_6,
UINT8 wbits, UINT8 direction, UINT8 config,
UINT8 enable);
void L2CA_RegisterCompression(tL2CA_COMPRESS_CB *, signed);
UINT8 L2CA_Flush(UINT16 cid);

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

@@ -3,7 +3,7 @@
#include <revolution/types.h>
s32 uhf_ker_create_sem(u32 param_1, int param_2);
s32 uhf_ker_create_sem(u32 initCount, int flags);
s32 uhf_ker_delete_sem(int sem);
s32 uhf_ker_get_sem(int sem);

View File

@@ -16,24 +16,24 @@ 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
u8 unk_0x0f; // 0x0F
u16 length; // 0x0C
u8 flags; // 0x0E
u8 hdrLen; // 0x0F
} 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
u8 unk_0x11; // 0x11
u8 unk_0x12; // 0x12
u8 unk_0x13; // 0x13
u8 unk_0x14; // 0x14
int length; // 0x0C
u8 lengthBytesLeft; // 0x10
u8 flags; // 0x11
u8 flagsLeft; // 0x12
u8 hdrLen; // 0x13
u8 lzType; // 0x14
u8 padding[3];
} CXUncompContextLZ;
@@ -52,19 +52,19 @@ typedef struct CXUncompContextHuffman {
u32 size; // 0x08
CXHuffmanDecodeTableEntry* decodeTable; // 0x0C
u32 bits; // 0x10
u32 unk_0x14; // 0x14
u32 wordBuffer; // 0x14
s16 decodeTableSize; // 0x18
u8 bitsLeft; // 0x1A
u8 unk_0x1b; // 0x1B
u8 wordBits; // 0x1B
u8 depth; // 0x1C
u8 hdrLen; // 0x1D
u8 padding[2]; // 0x1E
CXHuffmanDecodeTableEntry decodeTableData[0x200]; // 0x20
} CXUncompContextHuffman;
void CXInitUncompContextRL(CXUncompContextRL* context, u8* param_2);
void CXInitUncompContextLZ(CXUncompContextLZ* context, u8* param_2);
void CXInitUncompContextHuffman(CXUncompContextHuffman* context, u8* param_2);
void CXInitUncompContextRL(CXUncompContextRL* context, u8* data);
void CXInitUncompContextLZ(CXUncompContextLZ* context, u8* data);
void CXInitUncompContextHuffman(CXUncompContextHuffman* context, u8* data);
CXStreamingResult CXReadUncompRL(CXUncompContextRL* context, const void* src, u32 size);
CXStreamingResult CXReadUncompLZ(CXUncompContextLZ* context, const void* src, u32 size);

View File

@@ -68,7 +68,7 @@ void KPADInit();
s32 KPADRead(s32 chan, KPADStatus* status, u32 length);
void KPADSetSensorHeight(s32 chan, f32 sensorHeight);
void KPADGetProjectionPos(Vec2* dest, Vec2* src, const Rect* param_3, f32 param_4);
void KPADGetProjectionPos(Vec2* dest, Vec2* src, const Rect* rect, f32 scale);
void KPADSetPosParam(s32 chan, f32 x, f32 y);
void KPADSetBtnRepeat(s32 chan, f32, f32);

View File

@@ -40,7 +40,7 @@ ISD_Error ISD_ProbeCard(u32 slot);
ISD_Error ISD_MountCard(u32 slot, SDDev** dev);
ISD_Error ISD_UnmountCard(SDDev* dev);
ISD_Error ISD_GetHCRegister(SDDev* dev, u32 param_2, u32* param_3, u32 param_4) NO_INLINE;
ISD_Error ISD_GetHCRegister(SDDev* dev, u32 reg, u32* outValue, u32 size) NO_INLINE;
ISD_Error ISD_ReadBlock(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRespSize);
ISD_Error ISD_WriteBlock(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRespSize);

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 {
@@ -33,8 +33,8 @@ typedef struct USBKBDCmdLEDAsync {
USBKBDErr USBKBDInitialize(USBKBDAttachCallback attachCb, USBKBDDetachCallback detachCb);
USBKBDErr USBKBDSetLED(u32, u8, USBKBDCmdLED* cmd);
USBKBDErr USBKBDSetLEDAsync(u32, u8, USBKBDCmdLEDAsync* cmd, USBKBDCmdLEDCallback cb, void* cbArg);
USBKBDErr USBKBDSetLED(u32 device, u8 ledBits, USBKBDCmdLED* cmd);
USBKBDErr USBKBDSetLEDAsync(u32 device, u8 ledBits, USBKBDCmdLEDAsync* cmd, USBKBDCmdLEDCallback cb, void* cbArg);
USBKBDErr USBKBDRegisterEventCallback(USBKBDEventCallback cb);

View File

@@ -80,11 +80,11 @@ typedef struct {
typedef void (*WADProcessCallback)(u32 completed, u32 total, BOOL done);
s32 WADGetTitleVersionEx(char* path, ESTitleId* titleId, u16* titleVersion, WADLocation location, u32 offset);
s32 WADBackupEx(u64 titleId, u32 param_2, MEMAllocator* allocator, char* path, u32* sizeOut, WADLocation location, u32 param_7,
WADProcessCallback processCB);
s32 WADBackupEx(u64 titleId, u32 flags, MEMAllocator* allocator, char* path, u32* sizeOut, WADLocation location, u32 offset,
WADProcessCallback processCallback);
s32 WADImportGetBlocks(char* path, MEMAllocator* allocator, WADLocation location, u32 offset, u32 param_5, WADBlocks* blocks, u32* param_7);
s32 WADImportEx(char* path, MEMAllocator* allocator, WADLocation location, u32 param_4, u32 param_5, WADProcessCallback processCB);
s32 WADImportGetBlocks(char* path, MEMAllocator* allocator, WADLocation location, u32 offset, u32 flags, WADBlocks* blocks, u32* fileListOut);
s32 WADImportEx(char* path, MEMAllocator* allocator, WADLocation location, u32 offset, u32 flags, WADProcessCallback processCallback);
s32 WADGetInstalledVersion(ESTitleId titleID, u16* version);

View File

@@ -67,14 +67,17 @@ BOOL AXFXChorusExpSettings(AXFX_CHORUS_EXP* fx) {
OSRestoreInterrupts(enabled);
return result;
}
void AXFXChorusExpShutdown(AXFX_CHORUS_EXP* fx) {
BOOL enabled = OSDisableInterrupts();
static void __FreeDelayLine(AXFX_CHORUS_EXP* fx) {
u32 channel;
fx->active |= 1;
for (channel = 0; channel < 3; channel++) {
if (fx->delay.line[channel] != NULL) __AXFXFree(fx->delay.line[channel]);
fx->delay.line[channel] = NULL;
}
}
void AXFXChorusExpShutdown(AXFX_CHORUS_EXP* fx) {
BOOL enabled = OSDisableInterrupts();
fx->active |= 1;
__FreeDelayLine(fx);
OSRestoreInterrupts(enabled);
}
void AXFXChorusExpCallback(AXFX_BUFFERUPDATE* update, AXFX_CHORUS_EXP* fx) {
@@ -118,10 +121,11 @@ void AXFXChorusExpCallback(AXFX_BUFFERUPDATE* update, AXFX_CHORUS_EXP* fx) {
fx->history[0][history] = fx->delay.line[0][source];
fx->history[1][history] = fx->delay.line[1][source];
fx->history[2][history] = fx->delay.line[2][source];
history = (history + 1) & 3;
history++;
history &= 3;
source++;
if (source >= fx->delay.size) source = 0;
whole--;
if (source >= fx->delay.size) source = 0;
}
fx->delay.lastPos = position & 0xFFFF0000;
coefficients = __AXFXGetSrcCoef((fraction >> 9) & 0x7F);
@@ -129,14 +133,18 @@ void AXFXChorusExpCallback(AXFX_BUFFERUPDATE* update, AXFX_CHORUS_EXP* fx) {
f32 filtered = 0.0f;
f32 dry;
filtered += coefficients[0] * fx->history[channel][history];
history = (history + 1) & 3;
history++;
history &= 3;
filtered += coefficients[1] * fx->history[channel][history];
history = (history + 1) & 3;
history++;
history &= 3;
filtered += coefficients[2] * fx->history[channel][history];
history = (history + 1) & 3;
history++;
history &= 3;
filtered += coefficients[3] * fx->history[channel][history];
history = (history + 1) & 3;
if (fx->busIn != NULL) dry = *input[channel]++ + *output[channel];
history++;
history &= 3;
if (fx->busIn != NULL) dry = *output[channel] + *input[channel]++;
else dry = *output[channel];
fx->delay.line[channel][fx->delay.inPos] = dry + filtered * fx->feedback;
*output[channel]++ = filtered * fx->outGain;
@@ -149,8 +157,20 @@ void AXFXChorusExpCallback(AXFX_BUFFERUPDATE* update, AXFX_CHORUS_EXP* fx) {
if (fx->delay.outPos >= fx->delay.sizeFP) fx->delay.outPos = 0;
}
}
static inline void chorus_gradient(AXFX_CHORUS_EXP_LFO* lfo, f32 depth, f32 step) {
depth /= step;
lfo->gradFactor = 65536.0f * depth;
}
static BOOL __InitParams(AXFX_CHORUS_EXP* fx) {
f32 delay, depth, step;
f32 delay;
f32 depth;
f32 step;
u32 channel;
u32 sample;
s32 stepSamp;
s32 phaseAdd;
s32 depthSamp;
if (fx->delayTime < 0.1f || fx->delayTime > 50.0f) return FALSE;
if (fx->depth < 0.0f || fx->depth > 1.0f) return FALSE;
if (fx->rate < 0.1f || fx->rate > 2.0f) return FALSE;
@@ -160,61 +180,60 @@ static BOOL __InitParams(AXFX_CHORUS_EXP* fx) {
fx->lfo.table = __AXFXGetLfoSinTable();
delay = 32.0f * fx->delayTime;
depth = delay * fx->depth;
if (delay <= depth) {
if (depth >= delay) {
depth -= 1.0f;
if (depth < 0.0f) depth = 0.0f;
}
fx->lfo.depthSamp = 65536.0f * depth;
fx->lfo.phaseAdd = 65536.0f * (256.0f * fx->rate / 32000.0f);
step = (32000.0f / fx->rate) * (1.0f / 256.0f);
fx->lfo.stepSamp = 65536.0f * step;
fx->lfo.gradFactor = 65536.0f * (depth / step);
fx->lfo.lastNum = -1;
fx->lfo.phase = 0;
fx->lfo.sign = 0;
fx->lfo.lastValue = 0;
fx->lfo.grad = 0;
fx->history[0][0] = 0.0f;
fx->history[0][1] = 0.0f;
fx->history[0][2] = 0.0f;
fx->history[0][3] = 0.0f;
fx->history[1][0] = 0.0f;
fx->history[1][1] = 0.0f;
fx->history[1][2] = 0.0f;
fx->history[1][3] = 0.0f;
fx->history[2][0] = 0.0f;
fx->history[2][1] = 0.0f;
fx->history[2][2] = 0.0f;
fx->history[2][3] = 0.0f;
depthSamp = 65536.0f * depth;
phaseAdd = 65536.0f * (256.0f * fx->rate / 32000.0f);
step = (32000.0f / fx->rate) / 256.0f;
stepSamp = 65536.0f * step;
fx->lfo.depthSamp = depthSamp;
fx->lfo.phaseAdd = phaseAdd;
fx->lfo.stepSamp = stepSamp;
chorus_gradient(&fx->lfo, depth, step);
for (channel = 0; channel < 3; channel++) {
for (sample = 0; sample < 4; sample++) {
fx->history[channel][sample] = 0.0f;
}
}
fx->histIndex = 0;
return TRUE;
}
static void __CalcLFO(s32* output, AXFX_CHORUS_EXP_LFO* lfo) {
u32 remaining = 96;
do {
s32 value;
u32 phase = lfo->phase & 0xFFFF0000;
s32 start;
s64 value;
s32 difference;
s64 gradient;
u32 phase;
u32 sample;
for (sample = 0; sample < 96; sample++) {
phase = lfo->phase & 0xFFFF0000;
if (phase != lfo->lastNum) {
s32 start, difference;
s64 product;
lfo->lastNum = phase;
phase >>= 16;
start = lfo->table[phase];
difference = lfo->table[(phase + 1) & 0x7F] - start;
product = (s64)start * lfo->depthSamp;
value = ((u32)(product >> 32) << 8) | ((u32)product >> 24);
product = (s64)difference * lfo->gradFactor;
lfo->grad = ((u32)(product >> 32) << 8) | ((u32)product >> 24);
gradient = difference;
gradient *= lfo->gradFactor;
lfo->grad = gradient >> 24;
value = (s64)start * lfo->depthSamp;
value >>= 24;
} else {
value = lfo->lastValue + lfo->grad;
}
else value = lfo->lastValue + lfo->grad;
lfo->lastValue = value;
if (lfo->sign != 0) value = -value;
if (lfo->sign >= 1) value = -value;
lfo->phase += lfo->phaseAdd;
if (lfo->phase & 0xFF800000) {
lfo->phase &= 0x7FFFFF;
lfo->sign ^= 1;
}
*output++ = value;
remaining--;
} while (remaining != 0);
}
}

View File

@@ -1376,7 +1376,7 @@ static void bta_dm_link_quality_cback(tBTM_LINK_QUALITY_RESULTS *p_result)
}
}
BOOLEAN bta_sys_check_compress(int param_1, UINT8 app_id, BD_ADDR peer_addr)
BOOLEAN bta_sys_check_compress(int id, UINT8 app_id, BD_ADDR peer_addr)
{
BOOLEAN status = FALSE;
int i;
@@ -1399,8 +1399,8 @@ BOOLEAN bta_sys_check_compress(int param_1, UINT8 app_id, BD_ADDR peer_addr)
}
static BOOLEAN bta_dm_l2cap_server_compress_cback(
BD_ADDR peer_addr, int param_2, int param_3, int param_4,
int param_5, int param_6, int param_7, UINT8 **p_mem_pool,
BD_ADDR peer_addr, int pe_type, int mem_level, int wbits,
int direction, int config, int enable, UINT8 **p_mem_pool,
UINT32 *mem_pool_size)
{
BOOLEAN status = FALSE;

View File

@@ -22,7 +22,7 @@ void bte_hcisu_send(HC_BT_HDR *p_msg, UINT16 event)
GKI_freebuf(p_msg);
}
void bte_hcisu_task(int param_1)
void bte_hcisu_task(int unused)
{
if (p_hcisu_if)
{

View File

@@ -152,11 +152,11 @@ void BTA_CleanUp(tBTA_APP_INFO_CBACK *p_cb)
GKI_shutdown();
}
void bta_usb_close_evt(INT8 param_1)
void bta_usb_close_evt(INT8 status)
{
if (_bte_app_info)
{
if (param_1 >= 0)
if (status >= 0)
(*_bte_app_info)(0);
else
(*_bte_app_info)(1);

View File

@@ -113,20 +113,20 @@ static UINT16 const hcisu_msg_evt_table[] =
MSG_HC_TO_STACK_HCI_EVT,
};
void hcisu_h2_usb_cback(UINT8 param_1, INT8 param_2)
void hcisu_h2_usb_cback(UINT8 event, INT8 status)
{
switch (param_1)
switch (event)
{
case 0:
break;
case 4:
bta_usb_close_evt(param_2);
bta_usb_close_evt(status);
break;
}
}
UINT16 hcisu_h2_receive_msg(UINT16 param_1, tHCISU_H2_CB *p_cb)
UINT16 hcisu_h2_receive_msg(UINT16 pipe, tHCISU_H2_CB *p_cb)
{
UINT16 bytes_read = 0;
UINT8 byte;
@@ -138,7 +138,7 @@ UINT16 hcisu_h2_receive_msg(UINT16 param_1, tHCISU_H2_CB *p_cb)
if (p_cb->at_0x1e != 2)
return 0;
r27 = param_1 + 1;
r27 = pipe + 1;
while (TRUE)
{
@@ -148,36 +148,36 @@ UINT16 hcisu_h2_receive_msg(UINT16 param_1, tHCISU_H2_CB *p_cb)
++bytes_read;
msg_received = FALSE;
switch (p_cb->at_0x1a[param_1])
switch (p_cb->at_0x1a[pipe])
{
case 0:
if (r27 == 1)
{
p_cb->at_0x00[param_1] = GKI_getpoolbuf(GKI_POOL_ID_2);
p_cb->at_0x14[param_1] = 4;
p_cb->at_0x00[pipe] = GKI_getpoolbuf(GKI_POOL_ID_2);
p_cb->at_0x14[pipe] = 4;
}
else if (r27 == 2)
{
p_cb->at_0x00[param_1] = GKI_getpoolbuf(GKI_POOL_ID_3);
p_cb->at_0x14[param_1] = 2;
p_cb->at_0x00[pipe] = GKI_getpoolbuf(GKI_POOL_ID_3);
p_cb->at_0x14[pipe] = 2;
}
else if (r27 == 3)
{
p_cb->at_0x00[param_1] = GKI_getpoolbuf(GKI_POOL_ID_1);
p_cb->at_0x14[param_1] = 3;
p_cb->at_0x00[pipe] = GKI_getpoolbuf(GKI_POOL_ID_1);
p_cb->at_0x14[pipe] = 3;
}
else
{
break;
}
if (p_cb->at_0x00[param_1])
if (p_cb->at_0x00[pipe])
{
p_cb->at_0x00[param_1]->len = 0;
p_cb->at_0x00[param_1]->event =
hcisu_msg_evt_table[p_cb->at_0x14[param_1] - 1];
p_cb->at_0x00[param_1]->offset = 0;
p_cb->at_0x1a[param_1] = 1;
p_cb->at_0x00[pipe]->len = 0;
p_cb->at_0x00[pipe]->event =
hcisu_msg_evt_table[p_cb->at_0x14[pipe] - 1];
p_cb->at_0x00[pipe]->offset = 0;
p_cb->at_0x1a[pipe] = 1;
}
else
{
@@ -185,54 +185,54 @@ UINT16 hcisu_h2_receive_msg(UINT16 param_1, tHCISU_H2_CB *p_cb)
"HCIS: Unable to allocate buffer for incoming HCI "
"message.");
p_cb->at_0x1a[param_1] = 2;
p_cb->at_0x1a[pipe] = 2;
}
p_cb->at_0x0c[param_1] =
hcisu_preamble_table[p_cb->at_0x14[param_1] - 1];
p_cb->at_0x0c[pipe] =
hcisu_preamble_table[p_cb->at_0x14[pipe] - 1];
/* fallthrough */
case 1:
*((UINT8 *)(p_cb->at_0x00[param_1] + 1)
+ p_cb->at_0x00[param_1]->len++) = byte;
*((UINT8 *)(p_cb->at_0x00[pipe] + 1)
+ p_cb->at_0x00[pipe]->len++) = byte;
--p_cb->at_0x0c[param_1];
--p_cb->at_0x0c[pipe];
if (p_cb->at_0x0c[param_1] == 0)
if (p_cb->at_0x0c[pipe] == 0)
{
msg_len = byte;
if (p_cb->at_0x14[param_1] == 2)
if (p_cb->at_0x14[pipe] == 2)
{
msg_len = (msg_len << 8) + p_cb->at_0x17[param_1];
msg_len = (msg_len << 8) + p_cb->at_0x17[pipe];
if ((p_cb->at_0x00[param_1] =
if ((p_cb->at_0x00[pipe] =
(HC_BT_HDR *)l2cap_link_chk_pkt_start(
(BT_HDR *)p_cb->at_0x00[param_1]))
(BT_HDR *)p_cb->at_0x00[pipe]))
== 0)
{
p_cb->at_0x0c[param_1] = msg_len;
p_cb->at_0x0c[pipe] = msg_len;
if (msg_len == 0)
p_cb->at_0x1a[param_1] = 0;
p_cb->at_0x1a[pipe] = 0;
else
p_cb->at_0x1a[param_1] = 4;
p_cb->at_0x1a[pipe] = 4;
break;
}
}
p_cb->at_0x0c[param_1] = msg_len;
p_cb->at_0x0c[pipe] = msg_len;
if (sizeof(HC_BT_HDR)
+ hcisu_preamble_table[p_cb->at_0x14[param_1] - 1]
+ hcisu_preamble_table[p_cb->at_0x14[pipe] - 1]
+ msg_len
> GKI_get_buf_size(p_cb->at_0x00[param_1]))
> GKI_get_buf_size(p_cb->at_0x00[pipe]))
{
GKI_freebuf(p_cb->at_0x00[param_1]);
p_cb->at_0x00[param_1] = NULL;
p_cb->at_0x1a[param_1] = 4;
GKI_freebuf(p_cb->at_0x00[pipe]);
p_cb->at_0x00[pipe] = NULL;
p_cb->at_0x1a[pipe] = 4;
BT_TRACE(HCI, ERROR,
"HCIS: Invalid length for incoming HCI message.");
@@ -242,85 +242,85 @@ UINT16 hcisu_h2_receive_msg(UINT16 param_1, tHCISU_H2_CB *p_cb)
if (msg_len != 0)
{
p_cb->at_0x1a[param_1] = 3;
p_cb->at_0x1a[pipe] = 3;
}
else
{
msg_received = TRUE;
p_cb->at_0x1a[param_1] = 0;
p_cb->at_0x1a[pipe] = 0;
}
}
else
{
p_cb->at_0x17[param_1] = byte;
p_cb->at_0x17[pipe] = byte;
}
break;
case 2:
--p_cb->at_0x0c[param_1];
--p_cb->at_0x0c[pipe];
if (p_cb->at_0x0c[param_1] == 0)
if (p_cb->at_0x0c[pipe] == 0)
{
msg_len = byte;
if (p_cb->at_0x14[param_1] == 2)
msg_len = (msg_len << 8) + p_cb->at_0x17[param_1];
if (p_cb->at_0x14[pipe] == 2)
msg_len = (msg_len << 8) + p_cb->at_0x17[pipe];
p_cb->at_0x0c[param_1] = msg_len;
p_cb->at_0x1a[param_1] = 4;
p_cb->at_0x0c[pipe] = msg_len;
p_cb->at_0x1a[pipe] = 4;
}
else
{
p_cb->at_0x17[param_1] = byte;
p_cb->at_0x17[pipe] = byte;
}
break;
case 3:
*((UINT8 *)(p_cb->at_0x00[param_1] + 1)
+ p_cb->at_0x00[param_1]->len++) = byte;
*((UINT8 *)(p_cb->at_0x00[pipe] + 1)
+ p_cb->at_0x00[pipe]->len++) = byte;
--p_cb->at_0x0c[param_1];
--p_cb->at_0x0c[pipe];
len = UUSB_Read(param_1 + 1,
(UINT8 *)(p_cb->at_0x00[param_1] + 1)
+ p_cb->at_0x00[param_1]->len,
p_cb->at_0x0c[param_1]);
len = UUSB_Read(pipe + 1,
(UINT8 *)(p_cb->at_0x00[pipe] + 1)
+ p_cb->at_0x00[pipe]->len,
p_cb->at_0x0c[pipe]);
p_cb->at_0x00[param_1]->len += len;
p_cb->at_0x0c[param_1] -= len;
p_cb->at_0x00[pipe]->len += len;
p_cb->at_0x0c[pipe] -= len;
bytes_read += len;
if (p_cb->at_0x0c[param_1] == 0)
if (p_cb->at_0x0c[pipe] == 0)
{
if (p_cb->at_0x14[param_1] == 2
if (p_cb->at_0x14[pipe] == 2
&& l2cap_link_chk_pkt_end() == 0)
{
p_cb->at_0x1a[param_1] = 0;
p_cb->at_0x1a[pipe] = 0;
}
else
{
msg_received = TRUE;
p_cb->at_0x1a[param_1] = 0;
p_cb->at_0x1a[pipe] = 0;
}
}
break;
case 4:
--p_cb->at_0x0c[param_1];
--p_cb->at_0x0c[pipe];
if (p_cb->at_0x0c[param_1] == 0)
p_cb->at_0x1a[param_1] = 0;
if (p_cb->at_0x0c[pipe] == 0)
p_cb->at_0x1a[pipe] = 0;
break;
}
if (msg_received)
{
GKI_send_msg(hcisu_h2_cb.at_0x1f, 0, p_cb->at_0x00[param_1]);
p_cb->at_0x00[param_1] = NULL;
GKI_send_msg(hcisu_h2_cb.at_0x1f, 0, p_cb->at_0x00[pipe]);
p_cb->at_0x00[pipe] = NULL;
}
}
@@ -403,7 +403,7 @@ void hcisu_h2_send_msg(tHCISU_H2_CB *p_cb, HC_BT_HDR *p_msg)
hcisu_h2_send_msg_now(p_cb, p_msg);
}
void hcisu_h2_init(UINT8 param_1, UINT8 param_2, UINT16 param_3)
void hcisu_h2_init(UINT8 taskId, UINT8 mbox, UINT16 bufSize)
{
hcisu_h2_cb.at_0x1e = 0;
@@ -411,9 +411,9 @@ void hcisu_h2_init(UINT8 param_1, UINT8 param_2, UINT16 param_3)
hcisu_h2_cb.at_0x1a[1] = 0;
hcisu_h2_cb.at_0x1a[2] = 0;
hcisu_h2_cb.at_0x1f = param_1;
hcisu_h2_cb.at_0x20 = param_2;
hcisu_h2_cb.at_0x12 = param_3;
hcisu_h2_cb.at_0x1f = taskId;
hcisu_h2_cb.at_0x20 = mbox;
hcisu_h2_cb.at_0x12 = bufSize;
}
BOOLEAN hcisu_h2_open(tHCI_CFG *_p_cfg)

View File

@@ -478,7 +478,7 @@ BOOLEAN L2CA_SetAclPriority(BD_ADDR bd_addr, UINT8 priority)
}
void L2CA_SetCompression(UINT16 local_cid, UINT8 pe_type, UINT8 mem_level,
UINT8 wbits, UINT8 direction, UINT8 param_6,
UINT8 wbits, UINT8 direction, UINT8 config,
UINT8 enable)
{
tL2C_LCB *p_lcb;
@@ -506,7 +506,7 @@ void L2CA_SetCompression(UINT16 local_cid, UINT8 pe_type, UINT8 mem_level,
}
}
void L2CA_RegisterCompression(tL2CA_COMPRESS_CB *param_1, int param_2)
void L2CA_RegisterCompression(tL2CA_COMPRESS_CB *p_callback, int unused)
{
#if 0
/* ... */

View File

@@ -565,7 +565,7 @@ void UUSB_Open(tUUSB *uusb, tUUSB_CBACK *cback)
(void)uusb;
}
UINT16 UUSB_Read(UINT8 param_1, void *param_2, UINT16 param_3)
UINT16 UUSB_Read(UINT8 pipe, void *buf, UINT16 len)
{
return 0;
}
@@ -580,7 +580,7 @@ int UUSB_WriteBuf(/* ... */)
return 0;
}
UINT16 UUSB_Write(UINT8 param_1, void *p_data, UINT16 len, void *param_4)
UINT16 UUSB_Write(UINT8 pipe, void *p_data, UINT16 len, void *unused)
{
short sp18 = 0;
IOSError ret = 0;
@@ -591,7 +591,7 @@ UINT16 UUSB_Write(UINT8 param_1, void *p_data, UINT16 len, void *param_4)
if (usb.state != 2)
return 0;
switch (param_1)
switch (pipe)
{
case 0:
p_buf = GKI_getpoolbuf(usb.cmd_buffer_pool);
@@ -656,7 +656,7 @@ UINT16 UUSB_Write(UINT8 param_1, void *p_data, UINT16 len, void *param_4)
memcpy(p_buffer, p_data, len);
if (len > 190)
UUSBDBG(" woah ! thats pretty Big ! :%d", param_3);
UUSBDBG(" woah ! thats pretty Big ! :%d", len);
if (usb.at_0x38 < 5 && usb.bulk_buffer_q.count == 0)
{
@@ -696,7 +696,7 @@ UINT16 UUSB_Write(UINT8 param_1, void *p_data, UINT16 len, void *param_4)
break;
}
(void)param_4;
(void)unused;
return ret;
}

View File

@@ -7,7 +7,7 @@
#include <stdlib.h>
#include <string.h>
char lbl_81693350[0xd0] = {
char scCntCacheStrs[0xd0] = {
0x3c, 0x3c, 0x20, 0x52, 0x56, 0x4c, 0x5f, 0x53, 0x44, 0x4b, 0x20, 0x2d, 0x20, 0x43, 0x4e, 0x54,
0x43, 0x41, 0x43, 0x48, 0x45, 0x20, 0x09, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x62,
0x75, 0x69, 0x6c, 0x64, 0x3a, 0x20, 0x41, 0x70, 0x72, 0x20, 0x32, 0x30, 0x20, 0x32, 0x30, 0x31,
@@ -22,12 +22,12 @@ char lbl_81693350[0xd0] = {
0x74, 0x20, 0x00, 0x00, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x69, 0x74, 0x6c, 0x65, 0x00,
0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x00, 0x00, 0x00
};
char lbl_81693420[0x16] = {
char scCntCacheTitleDataFmt[0x16] = {
0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x2f, 0x25, 0x30, 0x38, 0x78, 0x2f, 0x25, 0x30, 0x38, 0x78,
0x2f, 0x64, 0x61, 0x74, 0x61, 0x00,
};
const char* __CNTCACHEVersion = lbl_81693350;
char lbl_816985DC[3] = {0x20, 0x0a, 0x00};
const char* __CNTCACHEVersion = scCntCacheStrs;
char scCntCacheSpaceNl[3] = {0x20, 0x0a, 0x00};
extern void _savegpr_23();
extern void _restgpr_23();
@@ -72,9 +72,9 @@ asm void CNTCACHEClear() {
mr r11, r12
stw r0, 4(r12)
bl _savegpr_23
lis r30, lbl_81693350@ha
lis r30, scCntCacheStrs@ha
lis r3, _CNTCACHEMutex@ha
addi r30, r30, lbl_81693350@l
addi r30, r30, scCntCacheStrs@l
li r29, 0
addi r3, r3, _CNTCACHEMutex@l
bl OSLockMutex
@@ -146,7 +146,7 @@ L_184:
stb r31, 0(r4)
subf r23, r24, r4
mr r3, r24
la r4, lbl_816985DC
la r4, scCntCacheSpaceNl
bl strtok
cmpwi r3, 0
mr r29, r3
@@ -246,7 +246,7 @@ asm void _CNTCACHEDeleteTitle() {
stwu r1, -0x20(r1)
mflr r0
li r3, 0
la r4, lbl_816985DC
la r4, scCntCacheSpaceNl
stw r0, 0x24(r1)
stw r31, 0x1c(r1)
stw r30, 0x18(r1)
@@ -284,7 +284,7 @@ L_350:
bl ES_DeleteTitleContent
L_364:
li r3, 0
la r4, lbl_816985DC
la r4, scCntCacheSpaceNl
bl strtok
L_370:
cmpwi r3, 0
@@ -305,10 +305,10 @@ asm int _CNTCACHEIsTitleRemovable(ESTitleId titleId) {
subfic r11, r11, -0x2100
stwux r1, r1, r11
mflr r0
lis r5, lbl_81693420@ha
lis r5, scCntCacheTitleDataFmt@ha
stw r0, 4(r12)
li r0, 1
addi r5, r5, lbl_81693420@l
addi r5, r5, scCntCacheTitleDataFmt@l
stw r31, -4(r12)
stw r30, -8(r12)
mr r30, r3
@@ -403,7 +403,7 @@ asm void _CNTCACHEDeleteContent() {
stw r0, 4(r12)
bl _savegpr_26
li r3, 0
la r4, lbl_816985DC
la r4, scCntCacheSpaceNl
bl strtok
li r31, 0
li r4, 0
@@ -441,10 +441,10 @@ asm void _CNTCACHEDeleteContent() {
rlwinm. r0, r3, 0, 0x1b, 0x1b
beq L_6f0
li r3, 0
la r4, lbl_816985DC
la r4, scCntCacheSpaceNl
bl strtok
li r26, 1
lis r27, lbl_81693420@ha
lis r27, scCntCacheTitleDataFmt@ha
b L_6e8
L_5b0:
stw r31, errno(r0)
@@ -488,7 +488,7 @@ L_5e8:
li r0, -1
stw r26, 0x20(r1)
addi r3, r1, 0x40
addi r5, r27, lbl_81693420@l
addi r5, r27, scCntCacheTitleDataFmt@l
stw r26, 0x24(r1)
and r6, r30, r0
and r7, r29, r0
@@ -529,7 +529,7 @@ L_6d4:
bdnz L_5e8
L_6dc:
li r3, 0
la r4, lbl_816985DC
la r4, scCntCacheSpaceNl
bl strtok
L_6e8:
cmpwi r3, 0

View File

@@ -221,11 +221,11 @@ CXSecureResult CXSecureUncompressLZ(const void* src, u32 length, void* dst) {
return CX_SECURE_ERR_OK;
}
BOOL CXiVerifyHuffmanTable_(const void* param_1, u8 param_2) {
const u8* a = param_1;
BOOL CXiVerifyHuffmanTable_(const void* table, u8 bitSize) {
const u8* a = table;
const u8* b = a + 1;
u32 c = *a;
const u8* d = (u8*)param_1 + ((c + 1) << 1);
const u8* d = (u8*)table + ((c + 1) << 1);
u8 e[sizeof(u8) * 0x40];
u32 i;
@@ -233,7 +233,7 @@ BOOL CXiVerifyHuffmanTable_(const void* param_1, u8 param_2) {
e[i] = 0;
}
if (param_2 == 4 && c >= 16) {
if (bitSize == 4 && c >= 16) {
return FALSE;
}

View File

@@ -4,24 +4,24 @@
static inline int CXiReadHeader(u8*, int*, const u8*, int, int);
static inline CXHuffmanDecodeTableEntry* GetNextNode(CXHuffmanDecodeTableEntry*, int);
void CXInitUncompContextRL(CXUncompContextRL* context, u8* param_2) {
context->unk_0x00 = param_2;
context->unk_0x04 = 0;
context->unk_0x0e = 0;
context->unk_0x0C = 0;
context->unk_0x0f = 8;
void CXInitUncompContextRL(CXUncompContextRL* context, u8* data) {
context->outData = data;
context->outDataLen = 0;
context->flags = 0;
context->length = 0;
context->hdrLen = 8;
context->size = 0;
}
void CXInitUncompContextLZ(CXUncompContextLZ* context, u8* param_2) {
context->unk_0x00 = param_2;
context->unk_0x04 = 0;
context->unk_0x11 = 0;
context->unk_0x12 = 0;
context->unk_0x0C = 0;
context->unk_0x10 = 3;
context->unk_0x13 = 8;
context->unk_0x14 = 0;
void CXInitUncompContextLZ(CXUncompContextLZ* context, u8* data) {
context->outData = data;
context->outDataLen = 0;
context->flags = 0;
context->flagsLeft = 0;
context->length = 0;
context->lengthBytesLeft = 3;
context->hdrLen = 8;
context->lzType = 0;
context->size = 0;
}
@@ -31,8 +31,8 @@ void CXInitUncompContextHuffman(CXUncompContextHuffman* context, u8* data) {
context->depth = 0;
context->decodeTableSize = -1;
context->decodeTable = context->decodeTableData;
context->unk_0x14 = 0;
context->unk_0x1b = 0;
context->wordBuffer = 0;
context->wordBits = 0;
context->bits = 0;
context->bitsLeft = 0;
context->hdrLen = 8;
@@ -42,9 +42,9 @@ void CXInitUncompContextHuffman(CXUncompContextHuffman* context, u8* data) {
CXStreamingResult CXReadUncompRL(CXUncompContextRL* context, const void* src, u32 size) {
const u8* pSrc = src;
if (context->unk_0x0f) {
if (context->hdrLen) {
int a;
if (context->unk_0x0f == 8) {
if (context->hdrLen == 8) {
if ((*pSrc & CX_COMPRESSION_TYPE_MASK) != CX_COMPRESSION_TYPE_RUN_LENGTH) {
return CX_STREAMING_ERR_BAD_FILE_TYPE;
}
@@ -54,68 +54,68 @@ CXStreamingResult CXReadUncompRL(CXUncompContextRL* context, const void* src, u3
}
}
a = CXiReadHeader(&context->unk_0x0f, &context->unk_0x04, pSrc, size, context->size);
a = CXiReadHeader(&context->hdrLen, &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->hdrLen ? context->outDataLen : CX_STREAMING_ERR_BAD_FILE_TYPE;
}
}
while (context->unk_0x04 > 0) {
if (!(context->unk_0x0e & 0x80)) {
while (context->unk_0x0C) {
*context->unk_0x00++ = *pSrc++;
while (context->outDataLen > 0) {
if (!(context->flags & 0x80)) {
while (context->length) {
*context->outData++ = *pSrc++;
context->unk_0x0C--;
context->unk_0x04--;
context->length--;
context->outDataLen--;
size--;
if (!size) {
return context->unk_0x04;
return context->outDataLen;
}
}
} else if (context->unk_0x0C) {
} else if (context->length) {
u8 b = *pSrc++;
size--;
while (context->unk_0x0C) {
*context->unk_0x00++ = b;
while (context->length) {
*context->outData++ = b;
context->unk_0x0C--;
context->unk_0x04--;
context->length--;
context->outDataLen--;
}
if (!size) {
return context->unk_0x04;
return context->outDataLen;
}
}
context->unk_0x0e = *pSrc++;
context->flags = *pSrc++;
size--;
context->unk_0x0C = context->unk_0x0e & 0x7f;
context->length = context->flags & 0x7f;
if (context->unk_0x0e & 0x80) {
context->unk_0x0C += 3;
if (context->flags & 0x80) {
context->length += 3;
} else {
context->unk_0x0C += 1;
context->length += 1;
}
if (context->unk_0x0C > context->unk_0x04) {
if (context->length > context->outDataLen) {
if (!context->size) {
return CX_STREAMING_ERR_BAD_FILE_SIZE;
}
context->unk_0x0C = context->unk_0x04;
context->length = context->outDataLen;
}
if (size) {
continue;
}
return context->unk_0x04;
return context->outDataLen;
}
if (!context->size && size > 32) {
@@ -125,7 +125,7 @@ CXStreamingResult CXReadUncompRL(CXUncompContextRL* context, const void* src, u3
return CX_STREAMING_ERR_OK;
}
static int CXiReadHeader(u8* pHdrLen, int* pOutLen, const u8* pSrc, int srcSize, int param_5) {
static int CXiReadHeader(u8* pHdrLen, int* pOutLen, const u8* pSrc, int srcSize, int maxOutLen) {
int bytesParsed = 0;
while (*pHdrLen) {
@@ -150,8 +150,8 @@ static int CXiReadHeader(u8* pHdrLen, int* pOutLen, const u8* pSrc, int srcSize,
}
}
if (param_5 > 0 && param_5 < *pOutLen) {
*pOutLen = param_5;
if (maxOutLen > 0 && maxOutLen < *pOutLen) {
*pOutLen = maxOutLen;
}
return bytesParsed;
@@ -160,79 +160,79 @@ static int CXiReadHeader(u8* pHdrLen, int* pOutLen, const u8* pSrc, int srcSize,
CXStreamingResult CXReadUncompLZ(CXUncompContextLZ* context, const void* src, u32 size) {
const u8* pSrc = src;
if (context->unk_0x13) {
if (context->hdrLen) {
int a;
if (context->unk_0x13 == 8) {
if (context->hdrLen == 8) {
if ((*pSrc & CX_COMPRESSION_TYPE_MASK) != CX_COMPRESSION_TYPE_LZ) {
return CX_STREAMING_ERR_BAD_FILE_TYPE;
}
context->unk_0x14 = *pSrc & 0x0F;
context->lzType = *pSrc & 0x0F;
if (context->unk_0x14 != 0 && context->unk_0x14 != 1) {
if (context->lzType != 0 && context->lzType != 1) {
return CX_STREAMING_ERR_BAD_FILE_TYPE;
}
}
a = CXiReadHeader(&context->unk_0x13, &context->unk_0x04, pSrc, size, context->size);
a = CXiReadHeader(&context->hdrLen, &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->hdrLen ? context->outDataLen : CX_STREAMING_ERR_BAD_FILE_TYPE;
}
}
while (context->unk_0x04 > 0) {
while (context->unk_0x12) {
while (context->outDataLen > 0) {
while (context->flagsLeft) {
s32 a;
if (!size) {
return context->unk_0x04;
return context->outDataLen;
}
if (!(context->unk_0x11 & 0x80)) {
*context->unk_0x00++ = *pSrc++;
context->unk_0x04--;
if (!(context->flags & 0x80)) {
*context->outData++ = *pSrc++;
context->outDataLen--;
size--;
goto there;
}
while (context->unk_0x10) {
context->unk_0x10--;
while (context->lengthBytesLeft) {
context->lengthBytesLeft--;
if (!context->unk_0x14) {
context->unk_0x0C = *pSrc++;
context->unk_0x0C += 0x30;
context->unk_0x10 = 0;
if (!context->lzType) {
context->length = *pSrc++;
context->length += 0x30;
context->lengthBytesLeft = 0;
} else {
switch (context->unk_0x10) {
switch (context->lengthBytesLeft) {
case 2: {
context->unk_0x0C = *pSrc++;
context->length = *pSrc++;
if (context->unk_0x0C >> 4 == 1) {
context->unk_0x0C = (context->unk_0x0C & 0x0F) << 16;
context->unk_0x0C += 0x1110;
} else if (context->unk_0x0C >> 4 == 0) {
context->unk_0x0C = (context->unk_0x0C & 0x0F) << 8;
context->unk_0x0C += 0x110;
context->unk_0x10 = 1;
if (context->length >> 4 == 1) {
context->length = (context->length & 0x0F) << 16;
context->length += 0x1110;
} else if (context->length >> 4 == 0) {
context->length = (context->length & 0x0F) << 8;
context->length += 0x110;
context->lengthBytesLeft = 1;
} else {
context->unk_0x0C += 0x10;
context->unk_0x10 = 0;
context->length += 0x10;
context->lengthBytesLeft = 0;
}
break;
}
case 1: {
context->unk_0x0C += *pSrc++ << 8;
context->length += *pSrc++ << 8;
break;
}
case 0: {
context->unk_0x0C += *pSrc++;
context->length += *pSrc++;
break;
}
}
@@ -240,47 +240,47 @@ CXStreamingResult CXReadUncompLZ(CXUncompContextLZ* context, const void* src, u3
size--;
if (!size) {
return context->unk_0x04;
return context->outDataLen;
}
}
a = (context->unk_0x0C & 0x0F) << 8;
context->unk_0x0C >>= 4;
a = (context->length & 0x0F) << 8;
context->length >>= 4;
a = (a | *pSrc++) + 1;
size--;
context->unk_0x10 = 3;
context->lengthBytesLeft = 3;
if (context->unk_0x0C > context->unk_0x04) {
if (context->length > context->outDataLen) {
if (!context->size) {
return CX_STREAMING_ERR_BAD_FILE_SIZE;
}
context->unk_0x0C = context->unk_0x04;
context->length = context->outDataLen;
}
while (context->unk_0x0C > 0) {
*context->unk_0x00 = context->unk_0x00[-a];
context->unk_0x00++;
context->unk_0x04--;
context->unk_0x0C--;
while (context->length > 0) {
*context->outData = context->outData[-a];
context->outData++;
context->outDataLen--;
context->length--;
}
there:
if (!context->unk_0x04) {
if (!context->outDataLen) {
goto out;
}
context->unk_0x11 <<= 1;
context->unk_0x12--;
context->flags <<= 1;
context->flagsLeft--;
}
if (!size) {
return context->unk_0x04;
return context->outDataLen;
}
context->unk_0x11 = *pSrc++;
context->unk_0x12 = 8;
context->flags = *pSrc++;
context->flagsLeft = 8;
size--;
}
@@ -369,16 +369,16 @@ CXStreamingResult CXReadUncompHuffman(CXUncompContextHuffman* context, const voi
continue;
}
context->unk_0x14 >>= context->depth;
context->unk_0x14 |= context->decodeTable->raw << (32 - context->depth);
context->wordBuffer >>= context->depth;
context->wordBuffer |= context->decodeTable->raw << (32 - context->depth);
context->decodeTable = context->decodeTableData + 1;
context->unk_0x1b += context->depth;
context->wordBits += context->depth;
if (context->unk_0x1b == 32) {
*context->outData = CXiConvertEndian32_(context->unk_0x14);
if (context->wordBits == 32) {
*context->outData = CXiConvertEndian32_(context->wordBuffer);
context->outData++;
context->outDataLen -= 4;
context->unk_0x1b = 0;
context->wordBits = 0;
if (context->outDataLen <= 0) {
goto out;

View File

@@ -11,7 +11,7 @@ typedef struct PFD_SDDRV_INFO {
u32 media_inserted;
u32 media_ejected;
s8 drive;
} PFD_SDDRV_INFO;
} ATTRIBUTE_ALIGN(8) PFD_SDDRV_INFO;
typedef union PFD_SDDEV_STORAGE {
SDDev device;
@@ -291,7 +291,7 @@ s32 pfd_st_removal_callback(s32 status, void* data) {
return 0;
}
g_pfd_sddrv_info.media_inserted = 0;
if (pfd_sddrv_device(&g_pfd_sddrv_info) != 0) {
if (g_pfd_sddrv_info.media_inserted == 0 && pfd_sddrv_device(&g_pfd_sddrv_info) != 0) {
g_event = 1;
result = ISD_RegisterDeviceIntrHandler(g_pfd_sddrv_info.device, (SDDevIntrCallback)pfd_st_inter_callback, &g_event);
if (result != 0) {

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

@@ -141,7 +141,7 @@ pf_s32 pdm_part_get_start_sector(PDM_PARTITION* p_part) {
}
return 0;
}
pf_u32 pdm_part_chg_ltop(PDM_PARTITION* p_part, pf_u32 sector, pf_u32 bps) {
static inline pf_u32 partition_physical_sector(PDM_PARTITION* p_part, pf_u32 sector, pf_u32 bps) {
pf_u16 media_bps;
pf_u32 ratio;
pf_u32 start;
@@ -158,6 +158,9 @@ pf_u32 pdm_part_chg_ltop(PDM_PARTITION* p_part, pf_u32 sector, pf_u32 bps) {
else if (ratio == 8) { start >>= 3; }
return sector + start;
}
pf_u32 pdm_part_chg_ltop(PDM_PARTITION* p_part, pf_u32 sector, pf_u32 bps) NO_INLINE {
return partition_physical_sector(p_part, sector, bps);
}
pf_s32 pdm_part_get_partition(PDM_DISK* p_disk, pf_u32 id, PDM_PARTITION** pp_part) {
pf_s32 err;
pf_u16 index;

View File

@@ -322,6 +322,8 @@ pf_s32 PFCLUSTER_CombineFiles(PFCLUSTER_ENT_ITER* p_first_iter, PFCLUSTER_ENT_IT
pf_u32 first_spare_clusters;
pf_u32 second_spare_clusters;
pf_u32 excess_clusters;
pf_s32 second_allocated_clusters;
pf_u32 capacity_clusters;
pf_u32 first_end_cluster;
pf_u32 first_spare_cluster;
pf_u32 second_spare_cluster;
@@ -370,8 +372,10 @@ pf_s32 PFCLUSTER_CombineFiles(PFCLUSTER_ENT_ITER* p_first_iter, PFCLUSTER_ENT_IT
if (*p_second_iter->ffd.p_start_cluster != 0) {
second_spare_clusters = p_second_iter->ffd.last_cluster.max_chain_index + 1 - second_used_clusters;
}
if (-1U / cluster_size + 1 < (second_used_clusters + second_spare_clusters) + first_used_clusters) {
excess_clusters = (second_used_clusters + second_spare_clusters) + first_used_clusters - (-1U / cluster_size + 1);
second_allocated_clusters = second_used_clusters + second_spare_clusters;
capacity_clusters = -1U / cluster_size + 1;
if (capacity_clusters < first_used_clusters + second_allocated_clusters) {
excess_clusters = first_used_clusters + second_allocated_clusters - capacity_clusters;
err = PFFAT_TraceClustersChain(&p_second_iter->ffd, second_spare_cluster,
cluster_size * ((p_second_iter->ffd.last_cluster.max_chain_index + 1 - excess_clusters) - second_used_clusters),
&end_cluster, &spare_cluster);
@@ -534,7 +538,7 @@ pf_s32 PFCLUSTER_DivideFile(PFCLUSTER_ENT_ITER* p_source_iter, PFCLUSTER_ENT_ITE
pf_s32 PFCLUSTER_InsertCluster(PFCLUSTER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent,
pf_u32 cluster_index, pf_u32 num_clusters, pf_u32* p_inserted_clusters) {
pf_s32 err;
pf_u32 requested_size;
pf_u32 previous_cluster;
pf_u32 next_cluster;
pf_u32 success_size;
@@ -544,7 +548,7 @@ pf_s32 PFCLUSTER_InsertCluster(PFCLUSTER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent,
pf_u32 allocated_size;
pf_u32 first_cluster;
pf_u32 last_cluster;
pf_u32 requested_size;
pf_s32 err;
pf_u32 file_clusters;
pf_u32 remainder;
pf_u32 extra_size;

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

@@ -654,7 +654,7 @@ pf_s32 PFENT_MakeRootDir(PF_VOLUME* p_vol) {
return 7;
}
{
static pf_u8 default_volume_label[16] = "NO NAME ";
static pf_u8 default_volume_label[12] = "NO NAME ";
PFDRV_LoadVolumeLabelFromBuf(p_vol, default_volume_label);
}
return 0;

View File

@@ -784,6 +784,21 @@ s32 PFFAT_WriteClusterWithBuf(PFFAT_FFD* file, u32 cluster, u32 chainIndex,
return 0;
}
static s32 PFFAT_WriteFATCopies(PF_VOLUME* volume, PF_CACHE_PAGE* page) {
u16 fatIndex;
u32 sector;
s32 firstError;
sector = page->sector;
firstError = 0;
for (fatIndex = 0; fatIndex < volume->bpb.num_active_FATs; fatIndex++) {
s32 error = PFSEC_WriteFAT(volume, page->p_buf, sector, 0, volume->bpb.bytes_per_sector);
if (error != 0 && firstError == 0) firstError = error;
sector += volume->bpb.sectors_per_FAT;
}
return firstError;
}
s32 PFFAT_DoAllocateChain(PFFAT_FFD* file, u32 chainLength, u32 chainIndex,
u32* firstAllocatedCluster,
u32* lastAllocatedCluster, s32 resetClusters)
@@ -793,13 +808,10 @@ s32 PFFAT_DoAllocateChain(PFFAT_FFD* file, u32 chainLength, u32 chainIndex,
u32 firstFreeCluster;
u32 lastFreeCluster;
u32 cluster;
u32 currentSector;
PF_CACHE_PAGE* flushPage;
u32 firstFlushError;
s32 alreadyAllocated;
s32 error;
PF_CACHE_PAGE* page;
u16 completedFATs;
volume = file->p_vol;
eoc2 = fat_special_values[volume->bpb.fat_type].eoc2;
@@ -873,18 +885,7 @@ s32 PFFAT_DoAllocateChain(PFFAT_FFD* file, u32 chainLength, u32 chainIndex,
file->last_cluster.max_chain_index = chainIndex;
*lastAllocatedCluster = lastFreeCluster;
firstFlushError = 0;
currentSector = page->sector;
flushPage = page;
for (completedFATs = 0; completedFATs < volume->bpb.num_active_FATs;
completedFATs++) {
error = PFSEC_WriteFAT(volume, flushPage->p_buf, currentSector, 0,
volume->bpb.bytes_per_sector);
if (error != 0 && firstFlushError == 0) {
firstFlushError = error;
}
currentSector += volume->bpb.sectors_per_FAT;
}
firstFlushError = PFFAT_WriteFATCopies(volume, page);
if (firstFlushError != 0) {
PFCACHE_FreeDataPage(volume, page);
return firstFlushError;
@@ -1180,20 +1181,24 @@ s32 PFFAT_GetClusterSpecified(PFFAT_FFD* file, u32 chainIndex,
s32 PFFAT_GetClusterAllocated(PFFAT_FFD* file, u32 chainIndex,
u32 numClusters, u32* cluster)
{
u32* start;
PF_VOLUME* vol;
PFFAT_HINT* hint;
u32 fatType;
u32 locateStart;
u32 locateEnd;
s32 error;
fatType = file->p_vol->bpb.fat_type;
start = file->p_start_cluster;
vol = file->p_vol;
fatType = vol->bpb.fat_type;
hint = file->p_hint;
if (*file->p_start_cluster == 1) {
if (*start == 1) {
if (fatType <= FAT_16) {
*cluster = -1;
return 0;
}
*file->p_start_cluster = file->p_vol->bpb.root_dir_cluster;
*start = vol->bpb.root_dir_cluster;
}
*cluster = -1;
error = find_cluster_in_chain(file, chainIndex, 2, numClusters, 1, cluster);
@@ -1227,8 +1232,6 @@ s32 PFFAT_GetSector(PFFAT_FFD* file, u32 fileSectorIndex, u32 mode,
u32 fatType;
u32 chainIndex;
u32 cluster;
u32 numRemainder;
u32 numDivide;
u32 numClusters;
u32 numSectors;
s32 error;
@@ -1244,12 +1247,10 @@ s32 PFFAT_GetSector(PFFAT_FFD* file, u32 fileSectorIndex, u32 mode,
}
chainIndex = fileSectorIndex >> volume->bpb.log2_sectors_per_cluster;
if (mode == 2) {
numSectors = (size / volume->bpb.bytes_per_sector) +
((size % volume->bpb.bytes_per_sector) != 0);
numDivide = numSectors / volume->bpb.sectors_per_cluster;
numRemainder =
(numSectors % volume->bpb.sectors_per_cluster) != 0;
numClusters = numRemainder + numDivide;
numClusters = size / volume->bpb.bytes_per_sector;
numSectors = numClusters + (size % volume->bpb.bytes_per_sector != 0);
numClusters = numSectors / volume->bpb.sectors_per_cluster;
numClusters = numClusters + (numSectors % volume->bpb.sectors_per_cluster != 0);
error = PFFAT_GetClusterAllocated(file, chainIndex, numClusters,
&cluster);
if (error != 0) {
@@ -1278,11 +1279,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;
}
@@ -1869,11 +1872,12 @@ s32 PFFAT_RefreshFSINFO(PF_VOLUME* volume)
error = 17;
}
if (error == 0) {
if (((u32)&((PFFAT_FSINFO*)page->p_buf)
->num_free_clusters.word &
3) != 0) {
((PFFAT_FSINFO*)page->p_buf)->num_free_clusters.bytes[0] =
(u8)volume->num_free_clusters;
PFFAT_FSINFO* info;
u8* freeClusterBytes;
info = (PFFAT_FSINFO*)page->p_buf;
freeClusterBytes = info->num_free_clusters.bytes;
if (((u32)freeClusterBytes & 3) != 0) {
freeClusterBytes[0] = (u8)volume->num_free_clusters;
((PFFAT_FSINFO*)page->p_buf)->num_free_clusters.bytes[1] =
(u8)(volume->num_free_clusters >> 8);
((PFFAT_FSINFO*)page->p_buf)->num_free_clusters.bytes[2] =
@@ -1882,11 +1886,9 @@ s32 PFFAT_RefreshFSINFO(PF_VOLUME* volume)
(u8)(volume->num_free_clusters >> 24);
} else {
u32 freeClusters = volume->num_free_clusters;
((PFFAT_FSINFO*)page->p_buf)->num_free_clusters.word =
(freeClusters << 24) |
((freeClusters & 0xFF00) << 8) |
((freeClusters >> 8) & 0xFF00) | (freeClusters >> 24);
u32 upperBytes = (freeClusters << 24) | ((freeClusters << 8) & 0x00FF0000);
u32 lowerBytes = (freeClusters >> 24) | ((freeClusters >> 8) & 0xFF00);
info->num_free_clusters.word = upperBytes | lowerBytes;
}
error = PFSEC_WriteData(
volume, page->p_buf, volume->bpb.fs_info_sector, 0,

View File

@@ -120,13 +120,13 @@ pf_s32 VFiPFFAT12_WriteFATEntry(PF_VOLUME* p_vol, pf_u16 cluster, pf_u16 value)
}
pf_s32 PFFAT12_WriteFATEntryWithBuf(PF_VOLUME* p_vol, pf_s16 cluster, pf_u16 value, PF_CACHE_PAGE* p_page) {
pf_s32 err;
pf_u32 next_sector;
pf_u32 offset_in_sector;
pf_u16 current_fat;
pf_s32 fat_offset;
pf_u32 fat_sector;
pf_s32 result;
pf_u32 next_sector;
pf_s32 err;
fat_offset = (pf_u16)(cluster + (cluster >> 1));
fat_sector = (pf_u16)(p_vol->bpb.active_FAT_sector + (fat_offset >> p_vol->bpb.log2_bytes_per_sector));
offset_in_sector = fat_offset & (p_vol->bpb.bytes_per_sector - 1);
@@ -153,7 +153,7 @@ pf_s32 PFFAT12_WriteFATEntryWithBuf(PF_VOLUME* p_vol, pf_s16 cluster, pf_u16 val
p_page->sector = next_sector;
p_page->p_buf[0] = value >> 4;
} else {
((pf_u16)offset_in_sector + p_page->p_buf)[1] = value >> 4;
*(p_page->p_buf + ((pf_u16)offset_in_sector + 1)) = value >> 4;
}
} else {
p_page->p_buf[(pf_u16)offset_in_sector] = value;
@@ -165,7 +165,7 @@ pf_s32 PFFAT12_WriteFATEntryWithBuf(PF_VOLUME* p_vol, pf_s16 cluster, pf_u16 val
p_page->sector = next_sector;
p_page->p_buf[0] = (p_page->p_buf[0] & 0xF0) | ((pf_u8)(value >> 8));
} else {
((pf_u16)offset_in_sector + p_page->p_buf)[1] = (((pf_u16)offset_in_sector + p_page->p_buf)[1] & 0xF0) | ((pf_u8)(value >> 8));
*(p_page->p_buf + ((pf_u16)offset_in_sector + 1)) = (*(p_page->p_buf + ((pf_u16)offset_in_sector + 1)) & 0xF0) | ((pf_u8)(value >> 8));
}
}
if (err != 0) { result = err; }

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;
@@ -360,17 +360,16 @@ pf_bool PFPATH_MatchFileNameWithPattern(const pf_s8* file_name, PF_STR* p_patter
pf_s32 PFPATH_cmpNameImpl(const pf_s8* name, const pf_s8* pattern, pf_u32* matched_end) {
pf_u32 read_char;
pf_s32 recursive_error;
pf_u16 name_char;
pf_s32 name_width;
pf_u16 pattern_char;
pf_u16 converted_pattern;
pf_u16 converted_name;
pf_s32 name_width;
pf_u16 name_char;
pf_s32 pattern_width;
PF_PATH_VOLUME_SET* volume = &pf_vol_set;
while (*pattern != 0) {
pattern_width = volume->codeset.oem_char_width(pattern);
name_width = volume->codeset.oem_char_width(name);
pattern_width = pf_vol_set.codeset.oem_char_width(pattern);
name_width = pf_vol_set.codeset.oem_char_width(name);
if (pattern_width == 1) {
read_char = pf_toupper(*pattern);
} else {
@@ -399,18 +398,18 @@ pf_s32 PFPATH_cmpNameImpl(const pf_s8* name, const pf_s8* pattern, pf_u32* match
}
case '*': {
do {
pattern_width = volume->codeset.oem_char_width(pattern);
if (pattern_width != 1) {
read_char = (pf_u16)PF_GET_LE_U16((const pf_u8*)pattern);
} else {
pattern_width = pf_vol_set.codeset.oem_char_width(pattern);
if (pattern_width == 1) {
read_char = pf_toupper(*pattern);
} else {
read_char = (pf_u16)PF_GET_LE_U16((const pf_u8*)pattern);
}
pattern_char = (pf_u16)read_char;
pattern += pattern_width;
if (pattern_char == '?') {
if (name_char == 0) { return 1; }
name += name_width;
name_width = volume->codeset.oem_char_width(name);
name_width = pf_vol_set.codeset.oem_char_width(name);
if (name_width == 1) { read_char = pf_toupper(*name); }
else { read_char = (pf_u16)PF_GET_LE_U16((const pf_u8*)name); }
name_char = (pf_u16)read_char;
@@ -428,7 +427,7 @@ pf_s32 PFPATH_cmpNameImpl(const pf_s8* name, const pf_s8* pattern, pf_u32* match
}
if (*matched_end != 0) { return recursive_error; }
}
name_width = volume->codeset.oem_char_width(name);
name_width = pf_vol_set.codeset.oem_char_width(name);
if (name_width == 1) {
read_char = pf_toupper(*name);
} else {

View File

@@ -267,6 +267,14 @@ void KPADSetPosParam(s32 chan, f32 x, f32 y) {
kpad->posParamY = y;
}
extern const f32 sensorIntervalConversion;
static inline f32 object_interval_distance(f32 interval) {
return interval / sensorIntervalConversion;
}
const f32 sensorIntervalConversion = 0.383864f;
static void reset_kpad(KPADInside* kpad) {
f32 upperY;
f32 distanceValue;
@@ -1570,7 +1578,7 @@ void KPADInit(void) {
objectInterval = kp_obj_interval;
enabled = OSDisableInterrupts();
kp_obj_interval = objectInterval;
distanceValue = objectInterval / 0.383864f;
distanceValue = object_interval_distance(objectInterval);
kp_err_dist_min = distanceValue;
kp_dist_vv1 = distanceValue;
OSRestoreInterrupts(enabled);

View File

@@ -1174,8 +1174,8 @@ static inline s32 __nupGetBoot2Version(u16* version) {
s32 result = ES_GetBoot2Version(&bootVersion);
if (result == 0) {
u16 checkedVersion = bootVersion;
*version = checkedVersion;
if (checkedVersion != bootVersion) { result = -0x1389; }
if (checkedVersion == bootVersion) { *version = checkedVersion; }
}
return result;
}
@@ -1229,7 +1229,7 @@ extern "C" void* __nupOp(void* argument) {
u32 needsAudit;
char* auditData = 0;
s32 result;
u16 serverBootVersion = 0;
u16 serverBootVersion;
u16 bootTitleVersion;
u16 systemMenuVersion;
ESTitleId currentTitleId;
@@ -1350,12 +1350,11 @@ extern "C" void* __nupOp(void* argument) {
OSUnlockMutex(&context->mutex);
for (i = 0; i < context->titleCount; i++) {
NUPTitleInfo* title = &context->titles[i];
ESTitleId titleId = title->titleId;
if (titleId == 0x0000000100000001ULL) {
if (context->titles[i].titleId == 0x0000000100000001ULL) {
bootTitle = title;
} else if (titleId == 0x0000000100000002ULL) {
} else if (context->titles[i].titleId == 0x0000000100000002ULL) {
menuTitle = title;
} else if (titleId == currentTitleId) {
} else if (context->titles[i].titleId == currentTitleId) {
systemTitle = title;
}
if (bootTitle != 0 && menuTitle != 0 && systemTitle != 0) {

View File

@@ -50,12 +50,16 @@ int NHTTPGetHeaderAll(void*, char**);
void NHTTPCancelRequestAsync(int);
void NHTTPDestroyResponse(void*);
static inline unsigned long NhttpBufferSize(unsigned long requested) {
if (requested != 0 && requested < 0x8000) return requested;
return 0x8000;
}
static u8* __nupNhttpBufFull(u8** buffer, unsigned long* length, unsigned long requested, void*, void*, HttpState* state) {
u8* next = NULL;
if (state->progress != NULL && *length != 0) {
state->progress(state->progressContext, *length);
}
if ((state->received + *length) < state->received) {
if ((u32)(state->received + *length) < (u32)state->received) {
if (state->error == 0) state->error = -5012;
}
state->received += *length;
@@ -69,22 +73,26 @@ static u8* __nupNhttpBufFull(u8** buffer, unsigned long* length, unsigned long r
if (state->error != 0) goto done;
}
next = *buffer;
if (next == NULL) {
if (requested != 0 && requested < 0x8000) {} else requested = 0x8000;
switch ((u32)next) {
case 0: {
requested = NhttpBufferSize(requested);
next = (u8*)nup::__nupMalloc(requested);
if (next == NULL) {
state->error = -5000;
goto done;
}
*length = requested;
break;
}
default: break;
}
if (*length != 0) state->lastActivity = OSGetTime();
}
}
done:
if (state->error != 0) {
next = NULL;
*length = 0;
next = NULL;
}
return next;
}
@@ -101,12 +109,17 @@ static void __nupNhttpReqDone(int result, void* response, HttpState* state) {
}
static int __nupNhttpOp(char* url, NHTTPReqMethod method, char* headers, u8* body, unsigned long bodyLength, unsigned long limit, ProgressCallback progress, void* progressContext, FlushCallback flush, void* flushContext) {
unsigned long transferred, expected;
int length;
char* responseHeaders = NULL;
u8* responseBody = NULL;
HttpState state;
int result = 0;
char* headerCopy = NULL;
void* request;
int requestId;
int status;
u8* responseBody = NULL;
char* responseHeaders = NULL;
int length;
unsigned long expected;
unsigned long transferred;
HttpState state;
state.error = 0;
state.limit = limit;
state.received = 0;
@@ -118,10 +131,7 @@ static int __nupNhttpOp(char* url, NHTTPReqMethod method, char* headers, u8* bod
state.done = 0;
state.result = 0;
state.lastActivity = 0;
int result = 0;
int requestId = 0;
char* headerCopy = NULL;
void* request = NHTTPCreateRequestEx(url, method, NULL, 0, __nupNhttpReqDone, &state, __nupNhttpBufFull, __nupNhttpBufFree);
request = NHTTPCreateRequestEx(url, method, NULL, 0, __nupNhttpReqDone, &state, __nupNhttpBufFull, __nupNhttpBufFree);
if (request == NULL) { result = -7000 - NHTTPGetError(); goto cleanup; }
if (NHTTPSetSocketBufferSize(request, 0x8000) != 0) { result = -7000 - NHTTPGetError(); goto cleanup; }
if (headers != NULL) {
@@ -130,16 +140,15 @@ static int __nupNhttpOp(char* url, NHTTPReqMethod method, char* headers, u8* bod
if (headerCopy == NULL) { result = -5000; goto cleanup; }
memcpy(headerCopy, headers, size);
char* field = headerCopy;
while (*field != 0) {
char* colon = strchr(field, ':');
if (colon == NULL) break;
char* end = strstr(colon, "\r\n");
if (end == NULL) break;
char* colon;
char* end;
while (*field != 0 && (colon = strchr(field, ':')) != NULL && (end = strstr(colon, "\r\n")) != NULL) {
*colon = 0;
*end = 0;
while (*field && isspace(*field)) field++;
do { colon++; } while (*colon && isspace(*colon));
if (NHTTPAddHeaderField(request, field, colon) != 0) { result = -7000 - NHTTPGetError(); goto cleanup; }
char* value = colon + 1;
while (*value && isspace(*value)) ++value;
if (NHTTPAddHeaderField(request, field, value) != 0) { result = -7000 - NHTTPGetError(); goto cleanup; }
field = end + 2;
}
}
@@ -153,40 +162,39 @@ static int __nupNhttpOp(char* url, NHTTPReqMethod method, char* headers, u8* bod
if (method == NHTTP_POST && body != NULL && bodyLength != 0 && NHTTPAddPostDataRaw(request, body, bodyLength) != 0) { result = -7000 - NHTTPGetError(); goto cleanup; }
requestId = NHTTPSendRequestAsync(request);
if (requestId < 0) {
int error = NHTTPGetError();
result = -7000 - NHTTPGetError();
NHTTPDeleteRequest(request);
result = -7000 - error;
goto cleanup;
}
state.lastActivity = OSGetTime();
for (;;) {
if (NHTTPGetProgress(&expected, &transferred) != 0 && state.done != 0) {
if (state.result != 0) { result = -7000 - state.result; goto cleanup; }
if (state.response != NULL) {
length = NHTTPGetBodyAll(state.response, &responseBody);
if (length < 0) { result = -5007; goto cleanup; }
__nupNhttpBufFull(&responseBody, (unsigned long*)&length, 0, NULL, NULL, &state);
while (NHTTPGetProgress(&expected, &transferred) == 0 || state.done == 0) {
if (OSGetTime() - state.lastActivity >= OSMillisecondsToTicks((OSTime)90000)) {
if (requestId >= 0) {
NHTTPCancelRequestAsync(requestId);
NCDSleep(OSMillisecondsToTicks(100));
}
result = state.error;
if (result != 0 || state.response == NULL) goto cleanup;
length = NHTTPGetHeaderAll(state.response, &responseHeaders);
if (length < 0) { result = -5007; goto cleanup; }
char* protocol = strstr(responseHeaders, "HTTP/");
if (protocol != NULL && sscanf(protocol, "HTTP/%*d.%*d %d", &status) == 1) {
if (status != 200 && status != 202) result = -5000 - status;
goto cleanup;
}
result = -5007;
result = -5009;
goto cleanup;
}
if (OSGetTime() - state.lastActivity >= OSMillisecondsToTicks(90000)) break;
NCDSleep(OSMillisecondsToTicks(100));
}
if (requestId >= 0) {
NHTTPCancelRequestAsync(requestId);
NCDSleep(OSMillisecondsToTicks(100));
if (state.result != 0) { result = -7000 - state.result; goto cleanup; }
if (state.response != NULL) {
length = NHTTPGetBodyAll(state.response, &responseBody);
if (length < 0) { result = -5007; goto cleanup; }
__nupNhttpBufFull(&responseBody, (unsigned long*)&length, 0, NULL, NULL, &state);
}
result = -5009;
if (state.error != 0) { result = state.error; goto cleanup; }
if (state.response == NULL) goto cleanup;
length = NHTTPGetHeaderAll(state.response, &responseHeaders);
if (length < 0) { result = -5007; goto cleanup; }
char* protocol = strstr(responseHeaders, "HTTP/");
if (protocol == NULL || sscanf(protocol, "HTTP/%*d.%*d %d", &status) != 1) {
result = -5007;
goto cleanup;
}
if (status != 200 && status != 202) result = -5000 - status;
goto cleanup;
cleanup:
if (state.response != NULL || result == -5009) NHTTPDestroyResponse(state.response);
if (headerCopy != NULL) nup::__nupFree(headerCopy);
@@ -194,18 +202,21 @@ cleanup:
}
extern "C" {
static long __nupHttpStringFlush(u8* data, unsigned long length, unsigned long requested, void* context) {
HttpString* text = (HttpString*)context;
static inline unsigned long HttpStringGrowthSize(HttpString* text, unsigned long total, unsigned long requested) {
if (requested >= total) return requested;
requested = text->growth + total;
text->growth <<= 1;
if (text->growth >= text->maximumGrowth) text->growth = text->maximumGrowth;
return requested;
}
static inline long AppendHttpString(unsigned long length, u8* data, unsigned long requested, HttpString* text) {
u8* next;
unsigned long total;
total = length + text->length;
total = text->length + length;
long result = 0;
if (total > text->capacity) {
if (requested >= total) {} else {
requested = text->growth + total;
text->growth <<= 1;
if (text->growth < text->maximumGrowth) {} else text->growth = text->maximumGrowth;
}
u8* next = (u8*)nup::__nupMalloc(requested);
requested = HttpStringGrowthSize(text, total, requested);
next = (u8*)nup::__nupMalloc(requested);
if (next == NULL) { result = -5000; goto done; }
if (text->buffer != NULL) {
memcpy(next, text->buffer, text->length);
@@ -218,6 +229,9 @@ static long __nupHttpStringFlush(u8* data, unsigned long length, unsigned long r
done:
return result;
}
static long __nupHttpStringFlush(u8* data, unsigned long length, unsigned long requested, void* context) {
return AppendHttpString(length, data, requested, (HttpString*)context);
}
}
static int __nupNhttpOpString(u8** output, unsigned long* outputLength, char* url, NHTTPReqMethod method, char* headers, u8* body, unsigned long bodyLength, unsigned long limit, ProgressCallback progress, void* context) NO_INLINE;
static int __nupNhttpOpString(u8** output, unsigned long* outputLength, char* url, NHTTPReqMethod method, char* headers, u8* body, unsigned long bodyLength, unsigned long limit, ProgressCallback progress, void* context) {

View File

@@ -15,7 +15,7 @@
#define SD_SLOT_PATH_LENGTH 32
char lbl_81691748[] = " +++ SD RESET Failed: %d +++\n\0"
char __sdPathData[] = " +++ SD RESET Failed: %d +++\n\0"
"/dev/sdio/slot0\0/dev/sdio/slot1\0/dev/sdio/slotw";
typedef void (*SDCallbackFunc)(s32, void*);
@@ -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;
@@ -55,25 +55,25 @@ enum {
static IOSFd sduOpenFD(u32 slot);
static IOSError sduCommandv(s32 fd, u32 cmd, u32 cmdType, u32 respType, u32 arg, u32 buffer, u32 blockCount, u32 sectorSize, u32 param_9, u32* resp,
static IOSError sduCommandv(s32 fd, u32 cmd, u32 cmdType, u32 respType, u32 arg, u32 buffer, u32 blockCount, u32 sectorSize, u32 dma, u32* resp,
void* cb, void* cbArg);
static ISD_Error sduCommand(s32 fd, u32 cmd, u32 cmdType, u32 respType, u32 arg, u32 buffer, u32 blockCount, u32 sectorSize, u32 param_9, u32* resp,
static ISD_Error sduCommand(s32 fd, u32 cmd, u32 cmdType, u32 respType, u32 arg, u32 buffer, u32 blockCount, u32 sectorSize, u32 dma, u32* resp,
void* cb, void* cbArg);
static ISD_Error sduDatabuswidth(SDDev* dev, u32 buswidth);
static ISD_Error sduGetSCR(SDDev* dev, u32* data) NO_INLINE;
static ISD_Error sduGetOCR(SDDev* dev, u32* data);
extern ISD_Error ISD_ReadMultiBlockAsync(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRespSize, u32 param_5, u32 param_6);
extern ISD_Error ISD_WriteMultiBlockAsync(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRespSize, u32 param_5, u32 param_6);
ISD_Error ISD_GetCardSize(SDDev* dev, u32* param_2, u32* param_3, u32* param_4);
extern ISD_Error ISD_ReadMultiBlockAsync(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRespSize, u32 callback, u32 callbackArg);
extern ISD_Error ISD_WriteMultiBlockAsync(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRespSize, u32 callback, u32 callbackArg);
ISD_Error ISD_GetCardSize(SDDev* dev, u32* outSize, u32* outSize2, u32* outSectorSize);
IOSError __sdCb(s32 result, void* arg) {
__sdCbArg* data = (__sdCbArg*)arg;
switch (data->unk_0x0C) {
switch (data->cmd) {
case 4: {
if (result != 0) {
OSReport(lbl_81691748, result);
OSReport(__sdPathData, result);
data->dev->SDDevRca = 0;
} else {
if (data->dev != NULL) {
@@ -106,33 +106,33 @@ IOSError __sdCb(s32 result, void* arg) {
return result;
}
ISD_Error ISD_GetHCRegister(SDDev* dev, u32 param_2, u32* param_3, u32 param_4) {
ISD_Error ISD_GetHCRegister(SDDev* dev, u32 reg, u32* outValue, u32 size) {
IOSError ret;
if (__sdHeapId[0] < 0) {
return SD_ERROR_FATAL;
}
__sdReg[0] = param_2;
__sdReg[3] = param_4;
__sdReg[0] = reg;
__sdReg[3] = size;
__sdReg[4] = 0;
if (param_3 != NULL) {
if (outValue != NULL) {
ret = IOS_Ioctl(dev->SDDevFd, SD_IOCTL_2, __sdReg, 0x18, __sdCmdBuffer, 4);
if (ret != IPC_RESULT_OK) {
return SD_ERROR_FATAL;
}
*param_3 = *__sdCmdBuffer;
*outValue = *__sdCmdBuffer;
return ret;
}
return SD_ERROR_FATAL;
}
ISD_Error ISD_GetDeviceStatus(SDDev* dev, u32* param_2) {
ISD_Error ISD_GetDeviceStatus(SDDev* dev, u32* status) {
IOSError ret = SD_ERROR_FATAL;
if (__sdHeapId[0] >= 0 && param_2 != NULL) {
if (__sdHeapId[0] >= 0 && status != NULL) {
OSLockMutex(&__reqMutex);
if (__sdReq != 0) {
@@ -145,7 +145,7 @@ ISD_Error ISD_GetDeviceStatus(SDDev* dev, u32* param_2) {
if (ret != IPC_RESULT_OK) {
__sdReq = 0;
} else {
*param_2 = *__sdCmdBuffer;
*status = *__sdCmdBuffer;
__sdReq = 0;
}
}
@@ -154,13 +154,13 @@ ISD_Error ISD_GetDeviceStatus(SDDev* dev, u32* param_2) {
return ret;
}
static IOSError sduCommandv(s32 fd, u32 cmd, u32 cmdType, u32 respType, u32 arg, u32 buffer, u32 blockCount, u32 sectorSize, u32 param_9, u32* resp,
static IOSError sduCommandv(s32 fd, u32 cmd, u32 cmdType, u32 respType, u32 arg, u32 buffer, u32 blockCount, u32 sectorSize, u32 dma, u32* resp,
void* cb, void* cbArg) {
IOSError ret;
u32 readCount, writeCount;
u32* sdCmd;
if (param_9 != 0) {
if (dma != 0) {
readCount = 2;
writeCount = 1;
} else {
@@ -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);
@@ -216,7 +216,7 @@ static IOSError sduCommandv(s32 fd, u32 cmd, u32 cmdType, u32 respType, u32 arg,
return ret;
}
static ISD_Error sduCommand(s32 fd, u32 cmd, u32 cmdType, u32 respType, u32 arg, u32 buffer, u32 blockCount, u32 sectorSize, u32 param_9, u32* resp,
static ISD_Error sduCommand(s32 fd, u32 cmd, u32 cmdType, u32 respType, u32 arg, u32 buffer, u32 blockCount, u32 sectorSize, u32 dma, u32* resp,
void* cb, void* cbArg) {
ISD_Error ret;
u32* sdCmd;
@@ -232,7 +232,7 @@ static ISD_Error sduCommand(s32 fd, u32 cmd, u32 cmdType, u32 respType, u32 arg,
sdCmd[6] = buffer;
sdCmd[4] = blockCount;
sdCmd[5] = sectorSize;
sdCmd[7] = param_9;
sdCmd[7] = dma;
if (resp != NULL) {
if (cb != NULL) {
@@ -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;
@@ -365,7 +365,7 @@ ISD_Error ISD_WriteMultiBlock(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRespSi
return ISD_WriteMultiBlockAsync(dev, offset, cmdResp, cmdRespSize, 0, 0);
}
ISD_Error ISD_ReadMultiBlockAsync(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRespSize, u32 param_5, u32 param_6) {
ISD_Error ISD_ReadMultiBlockAsync(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRespSize, u32 callback, u32 callbackArg) {
ISD_Error ret;
u32 status;
@@ -435,12 +435,12 @@ ISD_Error ISD_ReadMultiBlockAsync(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRe
DCInvalidateRange(cmdResp, cmdRespSize << 9);
ret = sduCommandv(dev->SDDevFd, 0x12, 3, 1, offset, (u32)cmdResp, cmdRespSize, 0x200, 1, __sdResp2, (void*)param_5, (void*)param_6);
ret = sduCommandv(dev->SDDevFd, 0x12, 3, 1, offset, (u32)cmdResp, cmdRespSize, 0x200, 1, __sdResp2, (void*)callback, (void*)callbackArg);
if (ret != IPC_RESULT_OK) {
__sdReq = 0;
}
if (param_5 == 0) {
if (callback == 0) {
__sdReq = 0;
}
}
@@ -449,7 +449,7 @@ out:
return ret;
}
ISD_Error ISD_WriteMultiBlockAsync(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRespSize, u32 param_5, u32 param_6) {
ISD_Error ISD_WriteMultiBlockAsync(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRespSize, u32 callback, u32 callbackArg) {
ISD_Error ret;
u32 status;
@@ -519,12 +519,12 @@ ISD_Error ISD_WriteMultiBlockAsync(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdR
DCFlushRange(cmdResp, cmdRespSize << 9);
ret = sduCommand(dev->SDDevFd, 0x19, 3, 1, offset, (u32)cmdResp, cmdRespSize, 0x200, 1, __sdResp2, (void*)param_5, (void*)param_6);
ret = sduCommand(dev->SDDevFd, 0x19, 3, 1, offset, (u32)cmdResp, cmdRespSize, 0x200, 1, __sdResp2, (void*)callback, (void*)callbackArg);
if (ret != IPC_RESULT_OK) {
__sdReq = 0;
}
if (param_5 == 0) {
if (callback == 0) {
__sdReq = 0;
}
}
@@ -570,7 +570,7 @@ ISD_Error ISD_UnmountCard(SDDev* dev) {
ISD_Error ISD_InitCard() {
static u8* lo;
char* paths = lbl_81691748;
char* paths = __sdPathData;
ISD_Error ret = SD_ERROR_SUCCESS;
BOOL enabled;
@@ -782,7 +782,7 @@ static ISD_Error sduGetOCR(SDDev* dev, u32* data) {
}
#ifdef __MWERKS__
asm ISD_Error ISD_GetCardSize(register SDDev* dev, register u32* param_2, register u32* param_3, register u32* param_4) {
asm ISD_Error ISD_GetCardSize(register SDDev* dev, register u32* outSize, register u32* outSize2, register u32* outSectorSize) {
nofralloc
stwu r1, -0x30(r1)
@@ -859,13 +859,13 @@ ISD_GetCardSize_store:
stw r5, 0x18(r28)
stw r0, 0x1c(r28)
stw r3, 0x20(r28)
beq ISD_GetCardSize_no_param2
beq ISD_GetCardSize_no_outSize
stw r3, 0(r29)
ISD_GetCardSize_no_param2:
ISD_GetCardSize_no_outSize:
cmpwi r30, 0
beq ISD_GetCardSize_no_param3
beq ISD_GetCardSize_no_outSize2
stw r3, 0(r30)
ISD_GetCardSize_no_param3:
ISD_GetCardSize_no_outSize2:
cmpwi r31, 0
beq ISD_GetCardSize_success_return
li r0, 0x200
@@ -884,7 +884,7 @@ ISD_GetCardSize_return:
blr
}
#else
ISD_Error ISD_GetCardSize(SDDev* dev, u32* param_2, u32* param_3, u32* param_4) {
ISD_Error ISD_GetCardSize(SDDev* dev, u32* outSize, u32* outSize2, u32* outSectorSize) {
ISD_Error ret;
u32 out0;
u32 out1;
@@ -915,14 +915,14 @@ ISD_Error ISD_GetCardSize(SDDev* dev, u32* param_2, u32* param_3, u32* param_4)
dev->SDSectorNum = out1;
dev->SDDevSize = out2;
if (param_2 != NULL) {
*param_2 = out2;
if (outSize != NULL) {
*outSize = out2;
}
if (param_3 != NULL) {
*param_3 = out2;
if (outSize2 != NULL) {
*outSize2 = out2;
}
if (param_4 != NULL) {
*param_4 = 512;
if (outSectorSize != NULL) {
*outSectorSize = 512;
}
return SD_ERROR_SUCCESS;

View File

@@ -34,13 +34,13 @@ static void uhf_ker_sem_inline_1() {
}
}
s32 uhf_ker_create_sem(u32 param_1, int param_2) {
s32 uhf_ker_create_sem(u32 initCount, int flags) {
int i, k;
if (param_1 != 0 && param_1 != 1) {
if (initCount != 0 && initCount != 1) {
return -5;
}
if (param_2 != 0) {
if (flags != 0) {
return -5;
}
@@ -60,13 +60,13 @@ s32 uhf_ker_create_sem(u32 param_1, int param_2) {
OSInitSemaphore(&st_uhf_ker_sem[i], 1);
sem = &st_uhf_ker_sem[i];
for (k = (int)(1 - param_1); k > 0; k--) {
for (k = (int)(1 - initCount); k > 0; k--) {
OSWaitSemaphore((OSSemaphore*)sem);
}
st_uhs_ker_sem_mng.entries[i].sem = sem;
st_uhs_ker_sem_mng.entries[i].unk_0x04 = param_1;
st_uhs_ker_sem_mng.entries[i].unk_0x08 = param_2;
st_uhs_ker_sem_mng.entries[i].unk_0x04 = initCount;
st_uhs_ker_sem_mng.entries[i].unk_0x08 = flags;
st_uhs_ker_sem_mng.unk_0x90++;
uhf_ker_sem_inline_1();

View File

@@ -96,13 +96,13 @@ USBKBDErr USBKBDInitialize(USBKBDAttachCallback attachCb, USBKBDDetachCallback d
return USB_KBD_ERR_OK;
}
USBKBDErr USBKBDSetLED(u32 param_1, u8 param_2, USBKBDCmdLED* cmd) {
USBKBDErr USBKBDSetLED(u32 device, u8 ledBits, USBKBDCmdLED* cmd) {
if (usbKbdFd < 0) {
return USB_KBD_ERR_NOT_INIT;
}
cmd->unk_0x04 = param_2;
cmd->unk_0x00 = param_1;
cmd->ledBits = ledBits;
cmd->device = device;
return IOS_Write(usbKbdFd, cmd, sizeof(USBKBDCmdLED)) != IPC_RESULT_OK ? USB_KBD_ERR_FATAL : USB_KBD_ERR_OK;
}
@@ -114,12 +114,12 @@ static IOSError usbKbdSetLEDHandler(IOSError error, void* arg) {
return IPC_RESULT_OK;
}
USBKBDErr USBKBDSetLEDAsync(u32 param_1, u8 param_2, USBKBDCmdLEDAsync* cmd, USBKBDCmdLEDCallback cb, void* cbArg) {
USBKBDErr USBKBDSetLEDAsync(u32 device, u8 ledBits, USBKBDCmdLEDAsync* cmd, USBKBDCmdLEDCallback cb, void* cbArg) {
if (usbKbdFd < 0) {
return USB_KBD_ERR_NOT_INIT;
}
cmd->base.unk_0x00 = param_1;
cmd->base.unk_0x04 = param_2;
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;
}
}

View File

@@ -2947,6 +2947,7 @@ static s32 WAD_815C43E0(WADHashThreadArgs* args) {
static s32 _WADHash(WADStream* stream, u32 offset, u32 size, void* context, void* buffer,
u32 chunkSize, void* secondBuffer, void* threadStack, u32 threadStackSize) {
OSMutex* mutex;
s32 result;
u32 completed = 0;
void* readBuffer;
@@ -3005,7 +3006,6 @@ static s32 _WADHash(WADStream* stream, u32 offset, u32 size, void* context, void
OSResumeThread(&thread);
bufferIndex = 0;
while (size != 0 && transfer.error == 0) {
OSMutex* mutex;
readSize = size > chunkSize ? chunkSize : size;
mutex = &transfer.mutex[bufferIndex];
OSLockMutex(mutex);
@@ -3019,11 +3019,10 @@ static s32 _WADHash(WADStream* stream, u32 offset, u32 size, void* context, void
readBuffer = transfer.buffers[bufferIndex];
result = WADReadStream(stream, &readBuffer, readSize, offset + completed);
if ((u32)result != readSize) {
OSMutex* otherMutex = &transfer.mutex[bufferIndex ^ 1];
OSLockMutex(otherMutex);
OSLockMutex(&transfer.mutex[bufferIndex ^ 1]);
OSCancelThread(&thread);
OSJoinThread(&thread, 0);
OSUnlockMutex(otherMutex);
OSUnlockMutex(&transfer.mutex[bufferIndex ^ 1]);
OSUnlockMutex(mutex);
result = -3005;
goto done;

View File

@@ -28,8 +28,8 @@
#define DPD_CONFIG2_SIZE 2
#define SPK_CONFIG_SIZE 7
char lbl_81687720[] = "<< RVL_SDK - WPAD \trelease build: Apr 20 2010 11:20:55 (0x4199_60831) >>";
const char* __WPADVersion = lbl_81687720;
char scWpadVersionStr[] = "<< RVL_SDK - WPAD \trelease build: Apr 20 2010 11:20:55 (0x4199_60831) >>";
const char* __WPADVersion = scWpadVersionStr;
WPADStorage _wpd;
WPADCB* _wpdcb[WPAD_MAX_CONTROLLERS];
@@ -617,7 +617,7 @@ static void __reconnect(BOOL exec) {
WUDShutdown(exec);
}
#ifdef __MWERKS__
char lbl_81687810[0x58] = "Reconnect Start!!\n\0\0\0\0\0\0"
char scWpadManageStrs[0x58] = "Reconnect Start!!\n\0\0\0\0\0\0"
"Check the update of WiFi using channel\n\0"
"WiFi uses channel = %d\n";
extern void _savegpr_19();
@@ -629,8 +629,8 @@ static asm void WPADiManageHandler(OSAlarm* pAlarm, OSContext* pContext) {
stw r0, 0x164(r1)
addi r11, r1, 0x160
bl _savegpr_19
lis r28, lbl_81687720@ha
addi r28, r28, lbl_81687720@l
lis r28, scWpadVersionStr@ha
addi r28, r28, scWpadVersionStr@l
bl WUDGetStatus
cmpwi r3, 0x3
beq WPADiManageHandler_8AC8

View File

@@ -54,9 +54,9 @@ typedef struct _CDBAttrBuf {
typedef struct _CDBAttr {
CDBAttrBuf buf; // 0x00
BOOL unk_0x400; // 0x400
BOOL unk_0x404; // 0x404
BOOL unk_0x408; // 0x408
BOOL dirty; // 0x400
BOOL wiiIdDirty; // 0x404
BOOL wiiIdValid; // 0x408
} CDBAttr;
#pragma pack(pop)

View File

@@ -97,7 +97,7 @@ typedef struct NHTTPResponseInfo
s32 isSuccess;
s32 isHeaderParse;
s32 httpStatus;
u32 recvBufLen;
volatile u32 recvBufLen;
char* allHeader_p;
char* foundHeader_p;
char* recvBuf_p;

View File

@@ -44,8 +44,8 @@ typedef struct NWC24MsgObjPrivate {
#else
NWC24UserId fromId; // 0x20
#endif
u32 unk_0x28;
u32 unk_0x2C;
u32 date; // 0x28
u32 receivedDate; // 0x2C
NWC24Data unk_0x30;
NWC24Data unk_0x38;
NWC24Data subject; // 0x40

View File

@@ -87,6 +87,10 @@ typedef struct WD_Info_ {
u8 unk_0x60[0x30]; // 0x60 (is it padding???)
} PACKED WD_Info;
#ifdef __cplusplus
extern "C" {
#endif
s32 WDCheckEnableChannel(u16* enableChannel);
s32 WDScanOnce(u8* scanBuffer, u32 scanBufferLen, WDScanParam* param);
s32 WDGetPrivacyMode(WDBssDesc* bssDesc);
@@ -94,4 +98,8 @@ s32 WDGetPrivacyMode(WDBssDesc* bssDesc);
BOOL WDFindInformationElement(WDInfoElement** outIE, u32* outIELength, WDBssDesc* bssDesc, int id);
BOOL WDiFindVendorSpecificIE(WDVendorInfoElement** outIE, u32* outIELength, WDBssDesc* bssDesc, int id, u8* data, u8 mode);
#ifdef __cplusplus
}
#endif
#endif // REVOLUTION_WD_H

View File

@@ -55,9 +55,9 @@ CDBErr CDBAttrCheckAttrBuf(CDBAttr* attr) {
void CDBAttrInit(CDBAttr* attr) {
memset(&attr->buf, 0, sizeof(CDBAttrBuf));
attr->unk_0x408 = FALSE;
attr->unk_0x400 = FALSE;
attr->unk_0x404 = FALSE;
attr->wiiIdValid = FALSE;
attr->dirty = FALSE;
attr->wiiIdDirty = FALSE;
}
CDBErr CDBAttrCreateOnNAND(CDBAttr* attr, const char* desc, u32 lastModifiedDate) {
@@ -89,7 +89,7 @@ CDBErr CDBAttrCreateOnNAND(CDBAttr* attr, const char* desc, u32 lastModifiedDate
err = CDB_ERROR_OK;
attr->unk_0x400 = TRUE;
attr->dirty = TRUE;
}
if (err != CDB_ERROR_OK) {
@@ -98,11 +98,11 @@ CDBErr CDBAttrCreateOnNAND(CDBAttr* attr, const char* desc, u32 lastModifiedDate
attrLastModifiedDate = lastModifiedDate;
memcpy(&attr->buf.lastModifiedDate, &attrLastModifiedDate, sizeof(u32));
attr->unk_0x400 = TRUE;
attr->dirty = TRUE;
attrModifiedCount = 0;
memcpy(&attr->buf.cdbID.modifiedCount, &attrModifiedCount, sizeof(u32));
attr->unk_0x400 = TRUE;
attr->dirty = TRUE;
GenCDBIdNumber(&cdbNum);
attrCdbIDNum = cdbNum;
@@ -110,12 +110,12 @@ CDBErr CDBAttrCreateOnNAND(CDBAttr* attr, const char* desc, u32 lastModifiedDate
attrWiiID = CDBGetWiiId();
memcpy(&attr->buf.wiiId, &attrWiiID, sizeof(u64));
attr->unk_0x408 = TRUE;
attr->wiiIdValid = TRUE;
err = CDB_ERROR_OK;
attr->unk_0x400 = TRUE;
attr->unk_0x404 = TRUE;
attr->dirty = TRUE;
attr->wiiIdDirty = TRUE;
return err;
}
@@ -123,7 +123,7 @@ CDBErr CDBAttrCreateOnNAND(CDBAttr* attr, const char* desc, u32 lastModifiedDate
CDBErr CDBAttrSetModifiedDate(CDBAttr* attr, u32 modifiedDate) {
u32 value = modifiedDate;
memcpy(&attr->buf.lastModifiedDate, &value, sizeof(u32));
attr->unk_0x400 = TRUE;
attr->dirty = TRUE;
return CDB_ERROR_OK;
}
@@ -131,7 +131,7 @@ CDBErr CDBAttrSetModifiedDate(CDBAttr* attr, u32 modifiedDate) {
CDBErr CDBAttrSetModifiedCount(CDBAttr* attr, u32 modifiedCount) {
u32 value = modifiedCount;
memcpy(&attr->buf.cdbID.modifiedCount, &value, sizeof(u32));
attr->unk_0x400 = TRUE;
attr->dirty = TRUE;
return CDB_ERROR_OK;
}
@@ -151,7 +151,7 @@ CDBErr CDBAttrGetIDNumber(CDBAttr* attr, CDBId* cdbID) {
CDBErr CDBAttrSetWiiId(CDBAttr* attr, u64 wiiId) {
u64 value = wiiId;
memcpy(&attr->buf.wiiId, &value, sizeof(u64));
attr->unk_0x404 = TRUE;
attr->wiiIdDirty = TRUE;
return CDB_ERROR_OK;
}

File diff suppressed because it is too large Load Diff

View File

@@ -6,13 +6,10 @@
#include <stdlib.h>
#include <string.h>
#pragma push
#pragma section sconst_type ".sdata"
extern const char lbl_816979E8[8] = "/\0\0\0\0\0\0\0";
#pragma pop
char CDBFSPathSeparator = '/';
void CDBFSConcatenatePath(char* path, const char* concatPath) {
strcat(path, lbl_816979E8);
strcat(path, &CDBFSPathSeparator);
strcat(path, concatPath);
}

View File

@@ -455,7 +455,7 @@ CDBErr CDBRecordGetId(CDBRecord* record, CDBId* id) {
} else {
CDBLock();
if (record->file == NULL) {
CDBReportError("can't get CDBId of the record ; the record is closed\n");
CDBReportError("can't get maker code of the record ; the record is closed\n");
err = CDB_ERROR_27;
} else {
CDBLock();
@@ -933,7 +933,7 @@ CDBErr CDBRecordDecrypt(CDBRecord* record, void* buffer, u32 size, u32* dataSize
if (CDBRecordKeyCompareByDate(&comparisonKey, &record->key) != 0) {
if (CDBIsPrintDebugMessage(3)) {
CDBReport_(3);
OSReport("CDBRecordPrivateChangeOwner\n");
OSReport("ファイル名の改竄を検出\n");
}
return CDB_ERROR_32;
}

View File

@@ -21,7 +21,7 @@ CDBErr CDBRecordFileReadAttrBuf(CDBRecord* record) {
return err;
}
recordFile->attr.unk_0x408 = TRUE;
recordFile->attr.wiiIdValid = TRUE;
return CDB_ERROR_OK;
}
@@ -34,12 +34,12 @@ CDBErr CDBRecordFileWriteAttrBuf(CDBRecord* record) {
return CDB_ERROR_27;
}
if (recordFile->attr.unk_0x400 && !recordFile->attr.unk_0x404) {
if (recordFile->attr.dirty && !recordFile->attr.wiiIdDirty) {
err = CDBFWriteAttrOnlyLeadChunk(&recordFile->bridgeFile, &recordFile->attr, record->key.location);
if (err != CDB_ERROR_OK) {
return err;
}
} else if (recordFile->attr.unk_0x400 || recordFile->attr.unk_0x404) {
} else if (recordFile->attr.dirty || recordFile->attr.wiiIdDirty) {
err = CDBFWriteAttr(&recordFile->bridgeFile, &recordFile->attr, record->key.location);
if (err != CDB_ERROR_OK) {
return err;

View File

@@ -234,30 +234,39 @@ void AESiDecryptBlock(AESContext* context, u32* output, const u32* input) {
}
BOOL NETAESCreateEx(AESContext* context, const void* key, u32 keyLength, const void* iv, const AESBlockMode* mode) {
BOOL result=FALSE;
u32 words,index,value;
u32* schedule;
u32 words;
u32 index;
u32 value;
BOOL result = FALSE;
if (keyLength != 16 && keyLength != 24 && keyLength != 32) {
OSReport("NETAESCreateEx() failed! (key-length is allowed only 16, 20, 24 BYTEs)");
} else {
context->rounds=keyLength/4+6;
context->needsTransform=1;
context->mode=mode;
context->needsTransform = 1;
context->rounds = (keyLength * 8) / 32 + 6;
context->mode = mode;
memcpy(context->chain, iv, 16);
schedule=context->keys;
words=keyLength/4;
memcpy(schedule,key,keyLength);
value=schedule[words-1];
for(index=words; index<(context->rounds+1)*4; ++index) {
if (index%words == 0) {
value=SUBSTITUTE_XOR(AESiSubShiftTable,value<<8,value<<8,value<<8,value>>24) ^ ((u32)AESiRoundKeyRcon0[index/words-1]<<24);
} else if(words>6 && index%words==4) {
value=SUBSTITUTE_XOR(AESiSubShiftTable,value,value,value,value);
schedule = context->keys;
words = keyLength / 4;
memcpy(schedule, key, keyLength);
value = schedule[words - 1];
for (index = words; index < (context->rounds + 1) * 4; ++index) {
if (index % words == 0) {
u32 high = (u32)AESiSubShiftTable[(value >> 16) & 255] << 24;
u32 low = AESiSubShiftTable[value >> 24];
u32 lower = (u32)AESiSubShiftTable[value & 255] << 8;
u32 upper = (u32)AESiSubShiftTable[(value >> 8) & 255] << 16;
value = (low ^ high) ^ (lower ^ upper);
value ^= (u32)AESiRoundKeyRcon0[index / words - 1] << 24;
} else if (words > 6 && index % words == 4) {
value = ((u32)AESiSubShiftTable[value >> 24] << 24) ^
(((u32)AESiSubShiftTable[(value >> 16) & 255] << 16) ^
(AESiSubShiftTable[value & 255] ^ ((u32)AESiSubShiftTable[(value >> 8) & 255] << 8)));
}
value ^= schedule[index-words];
schedule[index]=value;
value ^= schedule[index - words];
schedule[index] = value;
}
result=TRUE;
result = TRUE;
}
return result;
}

View File

@@ -13,7 +13,7 @@ static void FindHeaderBlock(const NHTTPResponseInfo* response, s32 position, NHT
}
}
static s8 ReadHeaderChar(const NHTTPResponseInfo* response, NHTTPi_HDRBUFLIST** block, s32* offset) {
static int ReadHeaderChar(const NHTTPResponseInfo* response, NHTTPi_HDRBUFLIST** block, s32* offset) {
if(!*block) {
if(*offset<1024) return (s8)response->hdrBufFirst[(*offset)++];
*block=response->hdrBufBlock_p;
@@ -30,30 +30,31 @@ static int LowerCase(int character) {
s32 NHTTPi_findNextLineHdrRecvBuf(const NHTTPResponseInfo* response, s32 position, s32 limit, s32* colon, s32* newlineLength) {
NHTTPi_HDRBUFLIST* block;
s32 offset;
s32 next=-1;
BOOL carriage=FALSE;
if(colon) *colon=-1;
if(position>=limit) return -1;
FindHeaderBlock(response,position,&block,&offset);
for(; position<limit; ++position) {
s8 character=ReadHeaderChar(response,&block,&offset);
if(character==':' && colon && *colon<0) *colon=position;
if(carriage) {
if(character=='\n') {
next=position==limit-1 ? 0 : position+1;
if(newlineLength) *newlineLength=2;
if (position < limit) {
s32 next=-1;
BOOL carriage=FALSE;
FindHeaderBlock(response,position,&block,&offset);
for(; position<limit; ++position) {
int character=ReadHeaderChar(response,&block,&offset);
if((s8)character==':' && colon && *colon<0) *colon=position;
if(carriage) {
if((s8)character=='\n') {
next=position==limit-1 ? 0 : position+1;
if(newlineLength) *newlineLength=2;
}
return next;
}
if((s8)character=='\r') {
next=position==limit-1 ? 0 : position+1;
carriage=TRUE;
if(newlineLength) *newlineLength=1;
}
if((s8)character=='\n') {
next=position==limit-1 ? 0 : position+1;
if(newlineLength) *newlineLength=1;
return next;
}
return next;
}
if(character=='\r') {
next=position==limit-1 ? 0 : position+1;
carriage=TRUE;
if(newlineLength) *newlineLength=1;
}
if(character=='\n') {
next=position==limit-1 ? 0 : position+1;
if(newlineLength) *newlineLength=1;
return next;
}
}
return -1;
@@ -62,11 +63,12 @@ s32 NHTTPi_findNextLineHdrRecvBuf(const NHTTPResponseInfo* response, s32 positio
s32 NHTTPi_skipSpaceHdrRecvBuf(const NHTTPResponseInfo* response, s32 position, s32 limit) {
NHTTPi_HDRBUFLIST* block;
s32 offset;
if(position>=limit) return -1;
FindHeaderBlock(response,position,&block,&offset);
for(; position<limit; ++position) {
s8 character=ReadHeaderChar(response,&block,&offset);
if(character!=' ') return position;
if (position < limit) {
FindHeaderBlock(response,position,&block,&offset);
for(; position<limit; ++position) {
s8 character=ReadHeaderChar(response,&block,&offset);
if(character!=' ') return position;
}
}
return -1;
}
@@ -91,32 +93,35 @@ s32 NHTTPi_loadFromHdrRecvBuf(NHTTPResponseInfo* response, char* destination, s3
s32 amount;
NHTTPi_HDRBUFLIST* block;
if(position+length>response->headerLen) return FALSE;
if(length) {
if(position<1024) {
amount=length;
if(length>1024-position) amount=1024-position;
NHTTPi_memcpy(destination,response->hdrBufFirst+position,amount);
position+=amount; length-=amount; destination+=amount;
}
if (position + length <= response->headerLen) {
if(length) {
s32 blocks;
position-=1024;
block=response->hdrBufBlock_p;
blocks=position>>9;
position&=511;
while(blocks--) block=block->next_p;
while(length) {
if(position<1024) {
amount=length;
if(length>512-position) amount=512-position;
NHTTPi_memcpy(destination,block->block+position,amount);
position=(position+amount)&511;
block=block->next_p;
length-=amount; destination+=amount;
if(length>1024-position) amount=1024-position;
NHTTPi_memcpy(destination,response->hdrBufFirst+position,amount);
position+=amount; length-=amount; destination+=amount;
}
if(length) {
s32 blocks;
position-=1024;
block=response->hdrBufBlock_p;
blocks=position>>9;
position&=511;
while(blocks--) block=block->next_p;
while(length) {
amount=length;
if(length>512-position) amount=512-position;
NHTTPi_memcpy(destination,block->block+position,amount);
position+=amount;
position&=511;
block=block->next_p;
length-=amount; destination+=amount;
}
}
}
return TRUE;
}
return TRUE;
return FALSE;
}
BOOL NHTTPi_isRecvBufFull(NHTTPResponseInfo* response, u32 length) { return length>=response->recvBufLen; }
@@ -127,10 +132,14 @@ s32 NHTTPi_RecvBuf(void* mutex, NHTTPRequestInfo* request, s32 socket, u32 offse
}
s32 NHTTPi_RecvBufN(void* mutex, NHTTPRequestInfo* request, s32 socket, u32 offset, s32 length, s32 flags) {
NHTTPResponseInfo* response=request->response;
s32 available;
NHTTPResponseInfo* response=request->response;
void* buf;
if(response->recvBufLen<=offset) return -1003;
available=response->recvBufLen-offset;
available=response->recvBufLen;
buf=response->recvBuf_p;
available=available-offset;
buf=(u8*)buf+offset;
if(length>available) length=available;
return NHTTPi_SocRecv(mutex,request,socket,response->recvBuf_p+offset,length,flags);
return NHTTPi_SocRecv(mutex,request,socket,buf,length,flags);
}

View File

@@ -1,6 +1,6 @@
#include <private/nhttp.h>
const char NHTTPi_strMultipartBound[] = STR_POSTBOUND;
const char NHTTPi_strMultipartBound[24] = STR_POSTBOUND;
void* NHTTPi_alloc(u32 size, int align);
void NHTTPi_free(void* ptr);

View File

@@ -67,10 +67,11 @@ s32 NHTTPi_strToHex(const char* string, s32 length) {
s32 value;
BOOL started;
if(length>8) return -1;
if((length==8) & (*string>='7')) return -1;
if((length==8) & (*string>'7')) return -1;
value=0; started=FALSE;
for(; length>0; --length,++string) {
s8 character=LowerCase(*string);
u8 rawCharacter = *(const u8*)string;
s8 character = LowerCase((s8)rawCharacter);
if(character>='0' && character<='9') { value=(value<<4)+character-'0'; started=TRUE; }
else if(character>='a' && character<='f') { value=(value<<4)+character-'a'+10; started=TRUE; }
else {
@@ -103,9 +104,9 @@ s32 NHTTPi_strToInt(const char* string, s32 length) {
s32 NHTTPi_intToStr(char* destination, u32 value) {
u32 scales[9]={1000000000,100000000,10000000,1000000,100000,10000,1000,100,10};
BOOL started;
int digit;
char* output;
int digit;
BOOL started;
s32 length;
output = destination;
length = 0;
@@ -135,18 +136,22 @@ s32 NHTTPi_compareToken(const char* left, const char* right) {
}
s32 NHTTPi_strtonum(const char* string, u32 length) {
int digits=0;
s32 value=0;
while(length--) {
int character=*string++;
if(character==' ') continue;
if((character>='0') & (character<='9')) {
value=value*10+character-'0';
int character;
s32 value;
int digits;
digits = 0;
value = 0;
for (; length != 0; --length, ++string) {
u8 rawCharacter = *(const u8*)string;
character = (s8)rawCharacter;
if (character == ' ') continue;
if ((character >= '0') & (character <= '9')) {
value = value * 10 + character - '0';
++digits;
if(digits>9) return -1;
if (digits > 9) return -1;
}
}
if(digits==0) return -1;
if (digits == 0) return -1;
return value;
}

View File

@@ -371,9 +371,9 @@ static BOOL NHTTPi_RecvProxyConnectHeader(NHTTPThreadContext* context)
response->httpStatus = NHTTPi_strToInt(header + 9, 3);
if (NHTTPi_strnicmp(header, "HTTP/", 5) == 0 && header[8] == ' '
&& response->httpStatus == 200) accepted = TRUE;
ended = FALSE;
cursor = header;
index = 0;
ended = FALSE;
while (index < used)
{
if (index > 1 && cursor[-1] == '\r' && *cursor == '\r') ended = TRUE;

View File

@@ -55,7 +55,13 @@ static s32 ConnectionStarted(NHTTPConnectionInfo* handle) {
void* system=NHTTPi_GetSystemInfoP();
void* mutex=NHTTPi_GetMutexInfoP(system);
NHTTPConnectionInfo* connection=NHTTPi_GetConnection(mutex,handle);
return connection ? connection->started : -1;
s32 started;
if (connection == NULL) {
started = -1;
} else {
started = connection->started;
}
return started;
}
static s32 ConnectionState(NHTTPConnectionInfo* handle) {

View File

@@ -873,40 +873,48 @@ NWC24Err NWC24GetDlTask(NWC24DlTask* dlTask, NWC24DlId dlId) {
return operationResult;
}
static inline NWC24Err InitDlIteration(DlTaskIterationState* state, u32 sortMode) {
memset(state, 0, sizeof(*state));
state->comparisonValue = 0x7fffffff;
state->selectedValue = (s32)0x80000001;
state->sortMode = sortMode;
state->comparisonId = 0xffffffff;
state->initialized = 1;
state->valid = 1;
return NWC24_OK;
}
NWC24Err NWC24PurgeOldestDlTask() {
DlTaskIterationState state;
NWC24File file;
NWC24DlTask task;
DlTaskListHeader* header;
NWC24DlId taskId;
NWC24DlTask* taskPointer;
NWC24DlId selectedId;
NWC24DlTask* taskPointer;
NWC24Err result;
NWC24Err closeResult;
memset(&state, 0, sizeof(state));
state.sortMode = 0;
state.comparisonValue = 0x7fffffff;
state.selectedValue = (s32)0x80000001;
state.comparisonId = 0xffffffff;
state.initialized = 1;
state.valid = 1;
result = InitDlIteration(&state, 0);
if (result < NWC24_OK) { return NWC24_OK; }
while ((result = NWC24IterateDlTaskEx((NWC24DlIterateWork*)&state, &taskId)) == NWC24_OK) {
header = GetCachedDlHeader();
if (taskId >= header->taskCount) { break; }
}
if (result < NWC24_OK) {
if (result == NWC24_ERR_DONE) { result = NWC24_ERR_FAILED; }
return result;
if (result >= NWC24_OK) {
taskPointer = &task;
selectedId = taskId;
result = ReadDlTaskInline(taskPointer, selectedId);
if (result < NWC24_OK) { return result; }
taskPointer = &task;
result = RemoveDlTask(taskPointer);
if (result < NWC24_OK) { return result; }
} else if (result == NWC24_ERR_DONE) {
result = NWC24_ERR_FAILED;
}
taskPointer = &task;
selectedId = taskId;
result = ReadDlTaskInline(taskPointer, selectedId);
if (result < NWC24_OK) { return result; }
return RemoveDlTask(taskPointer);
return result;
}
NWC24Err NWC24ManageDlTaskListForMenu() {
NWC24DlTask task;
@@ -921,7 +929,9 @@ NWC24Err NWC24ManageDlTaskListForMenu() {
result = ReadDlTaskInline(taskPointer, 2);
if (result == NWC24_ERR_NOT_FOUND) { return NWC24_OK; }
if (result < NWC24_OK) { return result; }
return RemoveDlTask(&task);
taskPointer = &task;
result = RemoveDlTask(taskPointer);
return result;
}
NWC24Err NWC24GetDlOptOutFlags(NWC24DlTask* dlTask, u8* dlOptOutFlags) {

Some files were not shown because too many files have changed in this diff Show More