Compare commits

...

177 Commits

Author SHA1 Message Date
coah
429f44ce37 cleanup(CXStreamingUncompression): name remaining RL/LZ/Huffman fields
Follows #678 (outData/outDataLen). Renames length/flags/hdrLen and
Huffman wordBuffer/wordBits.
2026-10-02 00:44:32 +00: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
coah
5c20a11fa8 Restore truncated PC-keyboard event thunk name (#519) 2026-10-01 17:15:31 -05:00
coah
f85a98a6e3 cleanup(iplSettingSelect): name exit-sequence helpers (#516)
Rename Matching-only fn_* exit/reboot helpers to descriptive
snake_case names; update mangled symbols.txt entries.
2026-10-01 17:15:19 -05:00
coah
137ee3242a cleanup(iplCSPane): name fatal OSFatal color/msg and zero float (#511)
lbl_81697844..47 → scCsFatalColorR/G/B/A, lbl_8166A6E3 → scCsFatalMsg,
lbl_81694FC0 → scCsZeroF.
2026-10-01 17:15:08 -05:00
coah
2368a9a774 cleanup(tiHwKeyboard): name EU/non-EU country map tables (#515)
Rename Matching-only setLanguage country lookup tables and
symbols.txt entries.
2026-10-01 17:13:57 -05:00
coah
90399bb6cf cleanup(iplDate): name calendar date pane/string labels (#518)
Matching-only renames in scene/calendar/iplDate (+ symbols.txt).
2026-10-01 17:13:54 -05:00
coah
fc831357ea CDBDatabase: convert Close and FindByKey to matching C (#491)
* CDBDatabase: convert Close and FindByKey to matching C

Replace asm bodies for CDBDatabaseClose and CDBDatabaseFindByKey with
equivalent C that matches instruction-exact (ctxdiff diffs 0). Unit stays
33/33 matched with 100% code and data.

* CDBDatabase: reuse labeled error strings for Close/FindByKey

Point CDBReportError at the existing lbl_ string pool entries so the
linked DOL matches baserom SHA1 26116613f624061ba99c8d1a299aaa6efa85670d.
2026-10-01 17:13:50 -05:00
coah
e2191ae933 cleanup(TVRC): name timing constants and file header (#509)
lbl_816945C8/D0/D8/E0 → scTvrcMsPerSec/NsecPerSec/One/FloatMagic;
lbl_81696230 → scTvrcFileHeader ("TVR0").
2026-10-01 17:11:51 -05:00
coah
7d77c095c0 cleanup(iplSystem): name ortho viewport float constants (#508)
lbl_81694424..38 → scOrthoLeft/Right/Bottom/Top and scWideOrthoLeft/Right.
2026-10-01 17:10:58 -05:00
coah
db8ff7e141 cleanup(www_window): name debug/error format strings (#507)
lbl_816962F8 → scWwwErrorQ, lbl_81643B40 → scWwwTexBufFmt,
lbl_81643B5E → scWwwNoBrowserWin.
2026-10-01 17:10:19 -05:00
github-actions[bot]
2cb6c2dfae docs: update progress [skip ci] 2026-10-01 22:09:43 +00:00
coah
6f96235605 cleanup(tiGUIManager): name sdata2 zero/half/line-color constants (#506)
lbl_81694EE8 → scGuiZeroF, lbl_81694EF0 → scGuiHalfF,
lbl_81694EEC..F → scGuiLineColorR/G/B/A.
2026-10-01 17:09:30 -05:00
coah
367b042e63 Restore memo input vtable declarations and emission order (#505) 2026-10-01 17:08:19 -05:00
148 changed files with 5654 additions and 4648 deletions

View File

@@ -53,9 +53,9 @@ Progress
<!-- progress:start -->
| Decompiled | Matched | Linked | Data |
|:---:|:---:|:---:|:---:|
| 99.37% | 87.69% | 61.93% | 91.28% |
| 99.38% | 88.09% | 62.52% | 92.12% |
units 917/1027 complete, functions 12211/12563 matched.
units 921/1027 complete, functions 12232/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
@@ -1054,7 +1054,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 +3551,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

@@ -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),
@@ -934,7 +934,7 @@ config.libs = [
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/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"),
]

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

@@ -149,6 +149,7 @@ namespace textinput {
void Update();
u32 GetModifierState() const;
void SetCountry(u8 country);
void SetModifierState(u32, u32);
#if defined(TI_CELLPHONE_HKB_KEYSET)

View File

@@ -20,7 +20,7 @@ namespace textinput {
#else
~HWKeyboard();
#endif
#ifdef TIMANAGER_IMPLEMENTATION
#if defined(TIMANAGER_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION)
void setLanguage(Destination destination, Language language);
#endif

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:
@@ -145,7 +149,7 @@ namespace textinput {
#ifdef TISIGNWINDOW_IMPLEMENTATION
bool isAtokActive() const;
#endif
#ifdef MYTILETTERFORM_IMPLEMENTATION
#if defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
virtual void create(MEMAllocator* allocator);
virtual void init();
virtual void onCommand(INPUT_COMMAND command, void* data);
@@ -384,7 +388,7 @@ namespace textinput {
virtual void setRootPaneScaleFor16x9();
virtual void setRootPaneScaleFor4x3();
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION)
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
virtual void onSE(sound::SE seId);
#endif

View File

@@ -135,8 +135,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 +149,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

@@ -6,7 +6,7 @@
#include <nw4r/ut/CharWriter.h>
#include <nw4r/ut/Rect.h>
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION)
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
#include <string.h>
#endif
@@ -34,7 +34,7 @@ namespace textinput {
} CursorPos;
typedef struct DrawInfo {
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION)
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
nw4r::ut::Rect rect;
wchar_t character;
#else
@@ -94,7 +94,7 @@ namespace textinput {
virtual u32 getEndPos() const;
// todo
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION)
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
virtual void setDrawModifyScopeLine(s32 startLine, s32 endLine);
virtual void setDrawCacheScopeLine(s32 startLine, s32 endLine);
virtual void modifyCursorCache(s32 line, u32 position, f32 x, f32 y, f32 width, f32 height);
@@ -103,12 +103,12 @@ namespace textinput {
virtual void setDrawCacheScopeLine();
virtual void modifyCursorCache();
#endif
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION)
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
virtual bool isEnableCursorCache() const;
#else
virtual void isEnableCursorCache();
#endif
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION)
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(TITEXTDRAWER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
virtual u32 getDrawModifyStartLine() const;
virtual u32 getDrawModifyEndLine() const;
#else

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

@@ -167,12 +167,12 @@ namespace ipl {
bool is_stopped_all_anm() const;
void fn_81409864();
void calc_exit_sequence();
void fn_814098F4();
void fn_unk_inline();
void fn_81409988();
void fn_814099EC();
void prepare_exit_abort();
void wait_decide_se();
void start_exit_fade();
void finish_exit_reboot();
int mState; // 0x60
int mPrevState; // 0x64

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

@@ -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

@@ -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;

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

@@ -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

@@ -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

@@ -1180,20 +1180,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);
@@ -1278,11 +1282,13 @@ s32 PFFAT_GetSectorSpecified(PFFAT_FFD* file, u32 fileSectorIndex,
error = PFFAT_GetSector(file, fileSectorIndex, clusterIndex != 0, 0,
sector);
if (error != 0) {
goto done;
switch (error) {
case 0:
error = 0;
break;
default:
break;
}
error = 0;
done:
return error;
}

View File

@@ -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;

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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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) {

View File

@@ -18,10 +18,8 @@ enum {
#define FRIEND_LIST_MAGIC 'WcFl'
#define FRIEND_LIST_VERSION 2
const char lbl_8166E160[26] __attribute__((section(".data"), aligned(8))) = "/shared2/wc24/nwc24fl.bin";
void* const lbl_8166E160_pad __attribute__((section(".data"))) = (void*)0;
static const char* FLFilePath = lbl_8166E160;
const u32 FLFilePath_pad __attribute__((section(".sdata"), aligned(1))) = 0;
char scNwc24FlPath[] = "/shared2/wc24/nwc24fl.bin";
static const char* FLFilePath = scNwc24FlPath;
const char g_SpecialsChars[16] = { '(', ')', '<', '>', '[', ']', ':', ';', '\\', ',', '"' };

View File

@@ -783,7 +783,7 @@ static NWC24Err DuplicationCheck(MBCHeader* header, const NWC24MsgObjPrivate* ms
continue;
}
if (msg->unk_0x1C != 0 && entry->crc == msg->unk_0x1C && entry->type == msg->type && entry->length == msg->length &&
entry->flags == msg->unk_0x10 && (s32)entry->date == (s32)msg->unk_0x28) {
entry->flags == msg->unk_0x10 && (s32)entry->date == (s32)msg->date) {
duplicateId = entry->msgId;
duplicateOffset = offset;
continue;
@@ -962,8 +962,8 @@ static NWC24Err CopyMsgObjToMBCFmt(const NWC24MsgObjPrivate* msg, MBCEntry* entr
entry->crc = msg->unk_0x1C;
entry->fromIdHigh = msg->fromIdHigh;
entry->fromIdLow = msg->fromIdLow;
entry->date = msg->unk_0x28;
entry->receivedDate = msg->unk_0x2C;
entry->date = msg->date;
entry->receivedDate = msg->receivedDate;
entry->numTo = msg->numTo;
entry->numAttached = msg->numAttached;
entry->groupId = msg->groupId;
@@ -1009,8 +1009,8 @@ static NWC24Err CopyMsgObjToPrvFmt(const MBCEntry* entry, NWC24MsgObjPrivate* ms
msg->unk_0x1C = entry->crc;
msg->fromIdHigh = entry->fromIdHigh;
msg->fromIdLow = entry->fromIdLow;
msg->unk_0x28 = entry->date;
msg->unk_0x2C = entry->receivedDate;
msg->date = entry->date;
msg->receivedDate = entry->receivedDate;
msg->numTo = entry->numTo;
msg->numAttached = entry->numAttached;
msg->groupId = entry->groupId;

View File

@@ -158,7 +158,7 @@ static inline NWC24Err WriteMessageIdField(NWC24MsgObjPrivate* msg) {
Mail_memset(buffer, 0, 1024);
Mail_strcpy(buffer, "Message-Id: <");
Mail_memset(idText, 0, 32);
Mail_sprintf(idText, "%05X%08X%08X%08X", msg->msgId, (u32)(myId >> 32), (u32)myId, msg->unk_0x28);
Mail_sprintf(idText, "%05X%08X%08X%08X", msg->msgId, (u32)(myId >> 32), (u32)myId, msg->date);
Mail_strcat(buffer, idText);
Mail_strcat(buffer, domain);
Mail_strcat(buffer, ">\r\n");
@@ -312,7 +312,7 @@ static NWC24Err NWC24CommitMsgInternal(NWC24MsgObjPrivate* msg, NWC24MBoxType ty
}
CHECK_WRITE(WriteExtraFields(msg));
Mail_memset(MultiPartDivider, 0, 40);
Mail_sprintf(MultiPartDivider, "Boundary-NWC24-%08X%05X", msg->unk_0x28, msg->msgId);
Mail_sprintf(MultiPartDivider, "Boundary-NWC24-%08X%05X", msg->date, msg->msgId);
buffer = NWC24WorkP->stringWork;
Mail_memset(buffer, 0, 1024);
Mail_strcpy(buffer, "MIME-Version: 1.0\r\n");
@@ -654,9 +654,9 @@ static NWC24Err WriteDateField(NWC24MsgObjPrivate* msg) {
date.sec = calendar.sec;
if (date.month > 12)
return NWC24_ERR_FORMAT;
NWC24iDateToMinutes(&msg->unk_0x28, &date);
NWC24iDateToMinutes(&msg->date, &date);
if (msg->type & 0x1000000)
NWC24iMinutesToDate(&date, msg->unk_0x2C);
NWC24iMinutesToDate(&date, msg->receivedDate);
buffer = NWC24WorkP->stringWork;
Mail_memset(buffer, 0, 1024);
Mail_sprintf(buffer, "Date: %02d %s %d %02d:%02d:%02d -0000\r\n", date.day, months[date.month - 1], date.year, date.hour, date.min, date.sec);

View File

@@ -46,9 +46,9 @@ NWC24Err NWC24InitMsgObj(NWC24MsgObj* msg, NWC24MsgType type) {
return NWC24_ERR_INVALID_VALUE;
}
msgObj->unk_0x28 = 0;
msgObj->date = 0;
msgObj->type |= 0x200000;
msgObj->unk_0x2C = 0;
msgObj->receivedDate = 0;
NWC24GetMyUserId(&msgObj->fromId);
msgObj->numTo = 0;
@@ -477,7 +477,7 @@ NWC24Err NWC24GetMsgFromId(const NWC24MsgObj* msg, NWC24UserId* fromId) {
NWC24Err NWC24GetMsgDate(const NWC24MsgObj* msg, OSCalendarTime* msgDate) {
const NWC24MsgObjPrivate* msgObj = (const NWC24MsgObjPrivate*)msg;
NWC24iMinutesToOSCalendarTime(msgDate, msgObj->unk_0x28);
NWC24iMinutesToOSCalendarTime(msgDate, msgObj->date);
return NWC24_OK;
}

View File

@@ -198,8 +198,10 @@ int SOShutdown(int socket, int how) {
}
int SOPoll(SOPollFD* fds, unsigned int count, s64 timeout) {
s32 size;
s32 bytes;
s32 result;
s32 rm;
s32 result,bytes,size;
PollRequest* request;
SOPollFD* reply;
if((result=SOiPrepare(NULL,&rm))==0) {
@@ -256,11 +258,17 @@ char* SOInetNtoA(SOInAddr address) {
int SOInetPtoN(int family, const char* text, void* address) {
s32 rm;
int temporary,result,size,bytes;
int temporary;
int size;
int result;
int bytes;
InetRequest* request;
if((result=SOiPrepareTempRm(NULL,&rm,&temporary))==0) {
bytes=0;
if(family==2) bytes=4;
switch (family) {
case 2: bytes=4; break;
default: break;
}
if(!bytes) result=-5;
else if(!text) result=-28;
else {

View File

@@ -10,36 +10,36 @@
#pragma push
#pragma section sconst_type ".sdata2"
const u8 lbl_81695060 = 0;
const u8 lbl_81695061 = 0x0F;
const u8 lbl_81695062 = 0xAC;
const u8 lbl_81695063 = 0;
const u8 lbl_81695064 = 0;
const u8 lbl_81695065 = 0x50;
const u8 lbl_81695066 = 0xF2;
const u8 lbl_81695067 = 0;
const u8 scRsnOui0 = 0;
const u8 scRsnOui1 = 0x0F;
const u8 scRsnOui2 = 0xAC;
const u8 scRsnOuiPad = 0;
const u8 scWpaOui0 = 0;
const u8 scWpaOui1 = 0x50;
const u8 scWpaOui2 = 0xF2;
const u8 scWpaOuiPad = 0;
#pragma pop
#pragma push
#pragma section sconst_type ".sdata"
const u8 lbl_81697D70 = 0;
const u8 lbl_81697D71 = 0x50;
const u8 lbl_81697D72 = 0xF2;
const u8 lbl_81697D73 = 0;
const u8 lbl_81697D74 = 0;
const u8 lbl_81697D75 = 0;
const u8 lbl_81697D76 = 0;
const u8 lbl_81697D77 = 0;
const u8 scWpaFindOui0 = 0;
const u8 scWpaFindOui1 = 0x50;
const u8 scWpaFindOui2 = 0xF2;
const u8 scWpaFindOuiPad0 = 0;
const u8 scWpaFindOuiPad1 = 0;
const u8 scWpaFindOuiPad2 = 0;
const u8 scWpaFindOuiPad3 = 0;
const u8 scWpaFindOuiPad4 = 0;
#pragma pop
#define lbl_81695060 (*((volatile const u8*)&lbl_81695060))
#define lbl_81695061 (*((volatile const u8*)&lbl_81695061))
#define lbl_81695062 (*((volatile const u8*)&lbl_81695062))
#define lbl_81695064 (*((volatile const u8*)&lbl_81695064))
#define lbl_81695065 (*((volatile const u8*)&lbl_81695065))
#define lbl_81695066 (*((volatile const u8*)&lbl_81695066))
#define lbl_81697D70 (*((volatile const u8*)&lbl_81697D70))
#define lbl_81697D71 (*((volatile const u8*)&lbl_81697D71))
#define lbl_81697D72 (*((volatile const u8*)&lbl_81697D72))
#define scRsnOui0 (*((volatile const u8*)&scRsnOui0))
#define scRsnOui1 (*((volatile const u8*)&scRsnOui1))
#define scRsnOui2 (*((volatile const u8*)&scRsnOui2))
#define scWpaOui0 (*((volatile const u8*)&scWpaOui0))
#define scWpaOui1 (*((volatile const u8*)&scWpaOui1))
#define scWpaOui2 (*((volatile const u8*)&scWpaOui2))
#define scWpaFindOui0 (*((volatile const u8*)&scWpaFindOui0))
#define scWpaFindOui1 (*((volatile const u8*)&scWpaFindOui1))
#define scWpaFindOui2 (*((volatile const u8*)&scWpaFindOui2))
extern void _savegpr_21();
extern void _restgpr_21();
@@ -175,9 +175,9 @@ s32 WDGetPrivacyMode(WDBssDesc* bssDesc) {
if (WDFindInformationElement((WDInfoElement**)&ieData, &ieLength, bssDesc, 0x30)) {
u8 data[WD_VENDOR_LENGTH];
data[0] = lbl_81695060;
data[1] = lbl_81695061;
data[2] = lbl_81695062;
data[0] = scRsnOui0;
data[1] = scRsnOui1;
data[2] = scRsnOui2;
memcpy(readIE, ieData, sizeof(WDVendorInfoElement) + 2);
if (memcmp(&readIE[2], data, WD_VENDOR_LENGTH) == 0) {
if ((s32)readIE[5] == 3) {
@@ -218,15 +218,15 @@ privacy_second: {
u8 data[WD_VENDOR_LENGTH];
u8 findData[WD_VENDOR_LENGTH];
findData[0] = lbl_81697D70;
findData[1] = lbl_81697D71;
findData[2] = lbl_81697D72;
findData[0] = scWpaFindOui0;
findData[1] = scWpaFindOui1;
findData[2] = scWpaFindOui2;
if (!WDiFindVendorSpecificIE(&ieData, &ieLength, bssDesc, 0xDD, findData, 1)) {
goto privacy_fallback;
}
data[0] = lbl_81695064;
data[1] = lbl_81695065;
data[2] = lbl_81695066;
data[0] = scWpaOui0;
data[1] = scWpaOui1;
data[2] = scWpaOui2;
{
memcpy(readIE, ieData, sizeof(WDVendorInfoElement));

View File

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

View File

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

View File

@@ -20,14 +20,14 @@ void VoiceCallback(void* _voice) {
}
inline u8* getCurrAddr(VoiceInfo* voice) {
AXPB* iVar4 = &voice->getAXVPB()->pb;
AXPB* pb = &voice->getAXVPB()->pb;
nw4r::ut::AutoInterruptLock lock;
if (iVar4 == NULL) {
if (pb == NULL) {
return 0;
}
u16 addrHi = iVar4->addr.currentAddressHi;
u16 addrLo = iVar4->addr.currentAddressLo;
u16 addrHi = pb->addr.currentAddressHi;
u16 addrLo = pb->addr.currentAddressLo;
return (u8*)((addrHi << 16) + addrLo);
}

View File

@@ -604,7 +604,7 @@ vmBoolInt VmIsNan(vmFloat value) {
return isnan(value) || value == VM_NAN;
}
double CHANSVm_8144B1D8(double value) {
double CHANSVmFloatSign(double value) {
// Clamp to -1.0~1.0
return value < 0.0 ? -1.0 : value > 0.0 ? 1.0 : value;
}
@@ -650,14 +650,14 @@ static s32 CHANSVmParseInt(CHANSVmObjHdr* obj, s32 base, u64* out) {
return 0;
}
CHANSVmObjHdr* CHANSVm_8144B30C(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* object) {
CHANSVmObjHdr* CHANSVmConvertToIntFromFloat(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* object) {
// Convert to int from float
CHANSVmObjHdr* newObj = CHANSVmNewObject(vm, vmFalse, vmNull, CHANS_VM_OBJ_TYPE_INTEGER, 0);
if (newObj != vmNull) {
if (VmIsNan(object->value.float_v)) {
newObj->value.int_v = 0;
} else {
newObj->value.int_v = (u64)(CHANSVm_8144B1D8(object->value.float_v) * floor(fabs(object->value.float_v)));
newObj->value.int_v = (u64)(CHANSVmFloatSign(object->value.float_v) * floor(fabs(object->value.float_v)));
}
}
return newObj;
@@ -675,7 +675,7 @@ CHANSVmObjHdr* CHANSVmConvertToIntFromArray(CHANSVm* vm, CHANSVmObjType type, CH
return vmNull;
}
CHANSVmObjHdr* CHANSVm_8144B430(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* object) {
CHANSVmObjHdr* CHANSVmConvertToFloatFromUndefined(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* object) {
CHANSVmObjHdr* result = CHANSVmNewObject(vm, vmFalse, vmNull, CHANS_VM_OBJ_TYPE_FLOAT, 0);
if (result != vmNull) {
result->value.float_v = VM_NAN;
@@ -683,7 +683,7 @@ CHANSVmObjHdr* CHANSVm_8144B430(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr*
return result;
}
CHANSVmObjHdr* CHANSVm_8144B470(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* intObj) {
CHANSVmObjHdr* CHANSVmConvertToFloatFromInt(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* intObj) {
CHANSVmObjHdr* result = CHANSVmNewObject(vm, vmFalse, vmNull, CHANS_VM_OBJ_TYPE_FLOAT, 0);
if (result != vmNull) {
result->value.float_v = VmIntToFloat(intObj->value.int_v);
@@ -692,31 +692,31 @@ CHANSVmObjHdr* CHANSVm_8144B470(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr*
}
// The 16-bit strings use a single null byte for termination for some reason. Because of that, L"..." cannot be used.
u8 lbl_81669070[19] = {0x00, 'u', 0x00, 'n', 0x00, 'd', 0x00, 'e', 0x00, 'f', 0x00, 'i', 0x00, 'n', 0x00, 'e', 0x00, 'd', 0x00};
u8 lbl_81669083[17] = {0x00, 'I', 0x00, 'n', 0x00, 'f', 0x00, 'i', 0x00, 'n', 0x00, 'i', 0x00, 't', 0x00, 'y', 0x00};
u8 lbl_81669094[19] = {0x00, '-', 0x00, 'I', 0x00, 'n', 0x00, 'f', 0x00, 'i', 0x00, 'n', 0x00, 'i', 0x00, 't', 0x00, 'y', 0x00};
u8 scUndefinedUtf16[19] = {0x00, 'u', 0x00, 'n', 0x00, 'd', 0x00, 'e', 0x00, 'f', 0x00, 'i', 0x00, 'n', 0x00, 'e', 0x00, 'd', 0x00};
u8 scInfinityUtf16[17] = {0x00, 'I', 0x00, 'n', 0x00, 'f', 0x00, 'i', 0x00, 'n', 0x00, 'i', 0x00, 't', 0x00, 'y', 0x00};
u8 scMinusInfinityUtf16[19] = {0x00, '-', 0x00, 'I', 0x00, 'n', 0x00, 'f', 0x00, 'i', 0x00, 'n', 0x00, 'i', 0x00, 't', 0x00, 'y', 0x00};
// clang-format off
const CHANSVmObjHdr CHANSVmConstStringObjectUndefined = {{(wchar_t*)lbl_81669070, 18}, {0}, vmNull};
const CHANSVmObjHdr lbl_81616C88 = {{(wchar_t*)"\0N\0a\0N", 6}, {0}, vmNull};
const CHANSVmObjHdr lbl_81616C98 = {{(wchar_t*)lbl_81669083, 16}, {0}, vmNull};
const CHANSVmObjHdr lbl_81616CA8 = {{(wchar_t*)lbl_81669094, 18}, {0}, vmNull};
const CHANSVmObjHdr lbl_81616CB8 = {{(wchar_t*)"\0,", 2}, {0}, vmNull};
const CHANSVmObjHdr CHANSVmConstStringObjectUndefined = {{(wchar_t*)scUndefinedUtf16, 18}, {0}, vmNull};
const CHANSVmObjHdr CHANSVmConstStringObjectNaN = {{(wchar_t*)"\0N\0a\0N", 6}, {0}, vmNull};
const CHANSVmObjHdr CHANSVmConstStringObjectInfinity = {{(wchar_t*)scInfinityUtf16, 16}, {0}, vmNull};
const CHANSVmObjHdr CHANSVmConstStringObjectMinusInfinity = {{(wchar_t*)scMinusInfinityUtf16, 18}, {0}, vmNull};
const CHANSVmObjHdr CHANSVmConstStringObjectComma = {{(wchar_t*)"\0,", 2}, {0}, vmNull};
const CHANSVmObjHdr CHANSVmConstStringDataEmpty = {{(wchar_t*)"", 0}, {0}, vmNull};
const CHANSVmObjHdr CHANSVmConstStringObjectUndefined_[] = {{{(void*)&CHANSVmConstStringObjectUndefined, 0}, 0x03800100, vmNull},
{{(void*)&lbl_81616C88, 0}, 0x03800100, vmNull},
{{(void*)&lbl_81616C98, 0}, 0x03800100, vmNull},
{{(void*)&lbl_81616CA8, 0}, 0x03800100, vmNull},
{{(void*)&CHANSVmConstStringObjectNaN, 0}, 0x03800100, vmNull},
{{(void*)&CHANSVmConstStringObjectInfinity, 0}, 0x03800100, vmNull},
{{(void*)&CHANSVmConstStringObjectMinusInfinity, 0}, 0x03800100, vmNull},
{{vmNull, 0}, 0x00800000, vmNull}};
char VmReportFormat[] = "%s";
const CHANSVmFloatConstantList lbl_81616D28[] = {
const CHANSVmFloatConstantList scFloatConstantList[] = {
{ "Infinity", (double*)&VmInf },
{ "+Infinity", (double*)&VmInf },
{ "-Infinity", (double*)&VmMinusInf },
{ "NaN", (double*)&VmNaN }
};
char lbl_8169758A[] = "%.16lg";
char scFloatPrintfFmt[] = "%.16lg";
// clang-format on
static inline s32 CHANSVmParseFloat(CHANSVmObjHdr* obj, f64* out) {
@@ -741,8 +741,8 @@ static inline s32 CHANSVmParseFloat(CHANSVmObjHdr* obj, f64* out) {
*bufEnd = '\0';
for (i = 0; i < 4; i++) {
if (strcmp(buf, lbl_81616D28[i].spName) == 0) {
number = *lbl_81616D28[i].pValue;
if (strcmp(buf, scFloatConstantList[i].spName) == 0) {
number = *scFloatConstantList[i].pValue;
goto store;
}
}
@@ -771,7 +771,7 @@ static inline s32 CHANSVmParseFloat(CHANSVmObjHdr* obj, f64* out) {
return 0;
}
CHANSVmObjHdr* CHANSVm_8144B4D4(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* object) {
CHANSVmObjHdr* CHANSVmConvertToFloatFromStr(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* object) {
// Convert string keyword into float value
CHANSVmObjHdr* newObj = CHANSVmNewObject(vm, vmFalse, vmNull, CHANS_VM_OBJ_TYPE_FLOAT, 0);
@@ -785,8 +785,8 @@ CHANSVmObjHdr* CHANSVmConvertToStrFromUndefined(CHANSVm* vm, CHANSVmObjType type
return (CHANSVmObjHdr*)CHANSVmConstStringObjectUndefined_;
}
s32 CHANSVm_8144B62C(vmWString buf, u32 len, vmFloat val) NO_INLINE {
s32 result = snprintf((char*)buf, len / 2, lbl_8169758A, val);
s32 CHANSVmFloatToWString(vmWString buf, u32 len, vmFloat val) NO_INLINE {
s32 result = snprintf((char*)buf, len / 2, scFloatPrintfFmt, val);
CHANSVmStrCpyToU16FromU8(buf, (vmString)buf, result);
return VM_STR_LENGTH(result);
}
@@ -815,7 +815,7 @@ error:
return vmNull;
}
CHANSVmObjHdr* CHANSVm_8144B734(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* value) {
CHANSVmObjHdr* CHANSVmConvertToStrFromFloat(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* value) {
const CHANSVmObjHdr* base;
CHANSVmObjHdr* newObj;
s32 result;
@@ -835,7 +835,7 @@ CHANSVmObjHdr* CHANSVm_8144B734(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr*
newObj = CHANSVmNewObject(vm, vmFalse, vmNull, CHANS_VM_OBJ_TYPE_STRING, VM_STRING_SIZE);
if (newObj != vmNull) {
result = CHANSVm_8144B62C(newObj->value.wstring_v->spData, VM_STRING_SIZE, value->value.float_v);
result = CHANSVmFloatToWString(newObj->value.wstring_v->spData, VM_STRING_SIZE, value->value.float_v);
newObj->value.wstring_v->len = result;
if (newObj->value.wstring_v->len == 0) {
goto error;
@@ -899,14 +899,14 @@ vmBoolInt CHANSVmGetEnumedType(CHANSVmObjType* eType, vmU32 iType) NO_INLINE {
}
// TODO: Here was a function defined that was inlined into VmStep.
char lbl_81669128[] = "VmGetResultType";
char scVmGetResultType[] = "VmGetResultType";
// clang-format off
const VmConvertEntry VmTypeConvertFuncTbl[] = {
{vmNull, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError},
{CHANSVmConvertObjectTypeError, vmNull, CHANSVm_8144B30C, CHANSVmConvertToIntFromStr, CHANSVmConvertToIntFromArray, CHANSVmConvertObjectTypeError},
{CHANSVm_8144B430, CHANSVm_8144B470, vmNull, CHANSVm_8144B4D4, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError},
{CHANSVmConvertToStrFromUndefined, CHANSVmConvertToStrFromInt, CHANSVm_8144B734, vmNull, CHANSVmConvertToStrFromArray, CHANSVmConvertObjectTypeError},
{CHANSVmConvertObjectTypeError, vmNull, CHANSVmConvertToIntFromFloat, CHANSVmConvertToIntFromStr, CHANSVmConvertToIntFromArray, CHANSVmConvertObjectTypeError},
{CHANSVmConvertToFloatFromUndefined, CHANSVmConvertToFloatFromInt, vmNull, CHANSVmConvertToFloatFromStr, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError},
{CHANSVmConvertToStrFromUndefined, CHANSVmConvertToStrFromInt, CHANSVmConvertToStrFromFloat, vmNull, CHANSVmConvertToStrFromArray, CHANSVmConvertObjectTypeError},
{CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, vmNull, CHANSVmConvertObjectTypeError},
{CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, CHANSVmConvertObjectTypeError, vmNull},
};
@@ -1254,7 +1254,7 @@ CHANSVmErr VmBitXor(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* ret, CHANSV
}
CHANSVmErr VmCmpEq(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* ret, CHANSVmObjHdr* left, CHANSVmObjHdr* right) {
vmBoolInt bVar1;
vmBoolInt stringsMatch;
vmBoolInt isEqual;
CHANSVmErr err;
@@ -1287,11 +1287,11 @@ CHANSVmErr VmCmpEq(CHANSVm* vm, CHANSVmObjType type, CHANSVmObjHdr* ret, CHANSVm
case CHANS_VM_OBJ_TYPE_STRING: {
isEqual = vmFalse;
if (left->value.string_v->len == right->value.string_v->len) {
bVar1 = vmFalse;
stringsMatch = vmFalse;
if (left->value.string_v->len == 0 || memcmp(*left->value.ptr_v, *right->value.ptr_v, left->value.string_v->len) == 0) {
bVar1 = vmTrue;
stringsMatch = vmTrue;
}
if (bVar1) {
if (stringsMatch) {
isEqual = vmTrue;
}
}
@@ -2183,7 +2183,7 @@ static u32 VmArrayJoinSub(CHANSVmObjHdr* obj, CHANSVmObjHdr* array, wchar_t* sep
if (offset + 0x80 > bufSize) {
goto error;
}
elemLen = CHANSVm_8144B62C((vmWString)((u8*)(*obj->value.ptr_v) + offset), 0x80, chunk->elements[countInChunk].value.float_v);
elemLen = CHANSVmFloatToWString((vmWString)((u8*)(*obj->value.ptr_v) + offset), 0x80, chunk->elements[countInChunk].value.float_v);
break;
}
case CHANS_VM_TYPE_ARRAY: {
@@ -2225,7 +2225,7 @@ CHANSVmObjHdr* VmArrayJoinCommon(CHANSVm* vm, u32 retObjAddr, CHANSVmObjHdr* obj
u32 actualLen;
if (separatorAddr == 0) {
separatorAddr = *(u32*)&lbl_81616CB8;
separatorAddr = *(u32*)&CHANSVmConstStringObjectComma;
separatorLen = 2;
}
@@ -3400,7 +3400,7 @@ VmMethodDefine(String, ToUpperCase) {
return vmFalse;
}
CHANSVmObjHdr* CHANSVm_8145049C(CHANSVm* vm, CHANSVmObjHdr* obj, u32 arg) {
CHANSVmObjHdr* CHANSVmFormatString(CHANSVm* vm, CHANSVmObjHdr* obj, u32 arg) {
u8 pad0[8];
u8 tempBuf[16];
u8 fmtBufData[32];
@@ -3745,7 +3745,7 @@ null_return:
VmMethodDefine(String, Format) {
u32 result;
if (VmParentObj != vmNull && VmParentObj->type == CHANS_VM_TYPE_CLASS_REF) {
result = (u32)CHANSVm_8145049C(VmInst, VmReturnObj, 0);
result = (u32)CHANSVmFormatString(VmInst, VmReturnObj, 0);
return result != 0;
}
return 0;
@@ -3775,10 +3775,10 @@ int VmGetIntFromObjHdr(CHANSVmObjHdr* object) {
return 0;
}
u32 CHANSVm_81451314(BlobHeader* blob, CHANSVmObjHdr* ptr, u32 limit);
BOOL CHANSVm_81451348(BlobHeader* blob, s64 size);
u32 CHANSVmBlobGetCount(BlobHeader* blob, CHANSVmObjHdr* ptr, u32 limit);
BOOL CHANSVmBlobHasSpace(BlobHeader* blob, s64 size);
CHANSVmObjHdr* CHANSVmNewBlobObject(CHANSVm* VmInst, CHANSVmObjHdr* obj, u32 size, void* src, u32 count);
static u64 CHANSVm_814540E0(u32 upper, u32 lower);
static u64 CHANSVmMakeU64(u32 upper, u32 lower);
static void VmBlobInitValue(BlobHeader* blob, u32 size) {
if (blob != vmNull) {
@@ -3790,9 +3790,9 @@ static void VmBlobInitValue(BlobHeader* blob, u32 size) {
static const char VmBlobClassName[] = "Blob";
char lbl_81669DF5[] = "0123456789abcdef";
char* lbl_816976E4 = lbl_81669DF5;
char* lbl_816976E8 = lbl_81669DF5;
char scHexDigits[] = "0123456789abcdef";
char* scHexDigitsPtr = scHexDigits;
char* scHexDigitsPtr2 = scHexDigits;
static CHANSVmObjHdr* VmBlobCreateDirect(CHANSVm* vm, CHANSVmObjHdr* obj, u32 size) NO_INLINE {
CHANSVmNativeClass* cls;
@@ -3834,7 +3834,7 @@ static u8* VmBlobGetDataBufferDirect(CHANSVmObjHdr* obj) {
return vmNull;
}
BOOL CHANSVm_81450D14(BlobHeader* blob, s64 val, u32* out) {
BOOL CHANSVmBlobResolveOffset(BlobHeader* blob, s64 val, u32* out) {
s64 pos;
if (blob == vmNull) {
@@ -3901,7 +3901,7 @@ VmMethodDefine(Blob, Seek) {
return 0;
}
if (CHANSVm_81450D14(blob, val->value.int_v, &tmp)) {
if (CHANSVmBlobResolveOffset(blob, val->value.int_v, &tmp)) {
blob->offset = tmp;
} else {
return 0;
@@ -3988,9 +3988,9 @@ VmMethodDefine(Blob, Fill) {
return 0;
}
count = blob != vmNull ? CHANSVm_81451314(blob, fill, blob->offset) : 0;
count = blob != vmNull ? CHANSVmBlobGetCount(blob, fill, blob->offset) : 0;
if (CHANSVm_81451348(blob, count)) {
if (CHANSVmBlobHasSpace(blob, count)) {
memset(blob->pData + blob->offset, (u8)val->value.int_v, count);
blob->offset += count;
return 1;
@@ -3999,7 +3999,7 @@ VmMethodDefine(Blob, Fill) {
return 0;
}
u32 CHANSVm_81451314(BlobHeader* blob, CHANSVmObjHdr* ptr, u32 limit) {
u32 CHANSVmBlobGetCount(BlobHeader* blob, CHANSVmObjHdr* ptr, u32 limit) {
if (ptr != vmNull) {
return *(u32*)((u8*)ptr + 4);
}
@@ -4013,7 +4013,7 @@ u32 CHANSVm_81451314(BlobHeader* blob, CHANSVmObjHdr* ptr, u32 limit) {
return 0;
}
BOOL CHANSVm_81451348(BlobHeader* blob, s64 size) {
BOOL CHANSVmBlobHasSpace(BlobHeader* blob, s64 size) {
u32 curOff = blob->offset;
return size >= 0 && (s64)(blob->size - curOff) >= size;
}
@@ -4028,7 +4028,7 @@ VmMethodDefine(Blob, GetString) {
}
size = (u32)arg->value.int_v;
if (CHANSVm_81451348(blob, size)) {
if (CHANSVmBlobHasSpace(blob, size)) {
CHANSVmErr err = CHANSVmSetU16StringFromU8(VmInst, VmReturnObj, (char*)(blob->pData + blob->offset), size);
blob->offset += size;
return err == CHANS_VM_OK;
@@ -4058,7 +4058,7 @@ VmMethodDefine(Blob, SetString) {
}
}
if (CHANSVm_81451348(blob, size)) {
if (CHANSVmBlobHasSpace(blob, size)) {
memset(blob->pData + blob->offset, 0, size);
CHANSVmStrCpyToU8FromU16(blob->pData + blob->offset, strData, charCount);
blob->offset += size;
@@ -4076,7 +4076,7 @@ VmMethodDefine(Blob, GetWString) {
return 0;
}
if (CHANSVm_81451348(blob, VM_STR_LENGTH(arg->value.int_v))) {
if (CHANSVmBlobHasSpace(blob, VM_STR_LENGTH(arg->value.int_v))) {
CHANSVmErr err = CHANSVmSetU16String(VmInst, VmReturnObj, (wchar_t*)(blob->pData + blob->offset), (u32)arg->value.int_v << 1);
u32 oldOffset = blob->offset;
u64 length = VM_STR_LENGTH(arg->value.int_v);
@@ -4113,7 +4113,7 @@ VmMethodDefine(Blob, SetWString) {
}
}
if (CHANSVm_81451348(blob, size)) {
if (CHANSVmBlobHasSpace(blob, size)) {
memcpy(blob->pData + blob->offset, strData, strLen);
if (strLen < size) {
memset(blob->pData + blob->offset + strLen, 0, size - strLen);
@@ -4184,8 +4184,8 @@ VmMethodDefine(Blob, CopyRangeFrom) {
srcOff = 0;
destOff = 0;
if (CHANSVm_81450D14(destBlob, destOffObj->value.int_v, &destOff) != 0 && CHANSVm_81450D14(srcBlob, srcOffObj->value.int_v, &srcOff) != 0) {
count = CHANSVm_81451314(srcBlob, countObj, srcOff);
if (CHANSVmBlobResolveOffset(destBlob, destOffObj->value.int_v, &destOff) != 0 && CHANSVmBlobResolveOffset(srcBlob, srcOffObj->value.int_v, &srcOff) != 0) {
count = CHANSVmBlobGetCount(srcBlob, countObj, srcOff);
{
u32 destinationOffset = destOff;
okFlag = (s64)count >= 0 && (s64)(destBlob->size - destinationOffset) >= (s64)count;
@@ -4213,9 +4213,9 @@ VmMethodDefine(Blob, GetBlob) {
if (blob == vmNull)
return 0;
count = blob != vmNull ? CHANSVm_81451314(blob, arg, blob->offset) : 0;
count = blob != vmNull ? CHANSVmBlobGetCount(blob, arg, blob->offset) : 0;
if (CHANSVm_81451348(blob, count)) {
if (CHANSVmBlobHasSpace(blob, count)) {
if (CHANSVmNewBlobObject(VmInst, VmReturnObj, count, blob->offset + blob->pData, count) != vmNull) {
blob->offset += count;
return 1;
@@ -4262,7 +4262,7 @@ VmMethodDefine(Blob, SetBlob) {
}
}
if (CHANSVm_81451348(destBlob, logicalSize)) {
if (CHANSVmBlobHasSpace(destBlob, logicalSize)) {
memmove(destBlob->pData + *(u32*)&destBlob->offset, srcBlob->pData + srcBlob->offset, copySize);
if (copySize < logicalSize) {
memset(destBlob->offset + destBlob->pData + copySize, 0, logicalSize - copySize);
@@ -4284,15 +4284,15 @@ VmMethodDefine(Blob, GetHexString) {
return vmFalse;
}
count = blob != vmNull ? CHANSVm_81451314(blob, arg, blob->offset) : 0;
count = blob != vmNull ? CHANSVmBlobGetCount(blob, arg, blob->offset) : 0;
if (CHANSVm_81451348(blob, count) && CHANSVmNewObject(VmInst, vmFalse, VmReturnObj, CHANS_VM_OBJ_TYPE_STRING, count * 4) != vmNull) {
if (CHANSVmBlobHasSpace(blob, count) && CHANSVmNewObject(VmInst, vmFalse, VmReturnObj, CHANS_VM_OBJ_TYPE_STRING, count * 4) != vmNull) {
wchar_t* dest = (wchar_t*)VmGetStrFromObjHdr(VmReturnObj);
u8* src = blob->pData;
u32 offset = blob->offset;
u32 destOff = 0;
u32 i = 0;
char* hexTbl = lbl_816976E4;
char* hexTbl = scHexDigitsPtr;
u32 loop_i;
src += offset;
@@ -4352,8 +4352,8 @@ VmMethodDefine(Blob, CalcRangeSHA1Digest) {
return 0;
}
if (CHANSVm_81450D14(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVm_81451314(blob, arg1, offset);
if (CHANSVmBlobResolveOffset(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVmBlobGetCount(blob, arg1, offset);
{
u32 off = offset;
@@ -4417,8 +4417,8 @@ VmMethodDefine(Blob, CalcRangeMD5Digest) {
return 0;
}
if (CHANSVm_81450D14(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVm_81451314(blob, arg1, offset);
if (CHANSVmBlobResolveOffset(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVmBlobGetCount(blob, arg1, offset);
{
u32 off = offset;
@@ -4464,8 +4464,8 @@ VmMethodDefine(Blob, CalcRangeCRC16) {
return 0;
}
if (CHANSVm_81450D14(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVm_81451314(blob, arg1, offset);
if (CHANSVmBlobResolveOffset(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVmBlobGetCount(blob, arg1, offset);
{
u32 off = offset;
if (((s64)size >= 0LL && (s64)(blob->size - off) >= (s64)size) != vmFalse) {
@@ -4500,8 +4500,8 @@ VmMethodDefine(Blob, CalcRangeCRC32) {
return 0;
}
if (CHANSVm_81450D14(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVm_81451314(blob, arg1, offset);
if (CHANSVmBlobResolveOffset(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVmBlobGetCount(blob, arg1, offset);
{
u32 off = offset;
@@ -4573,8 +4573,8 @@ VmMethodDefine(Blob, CalcRangeHMAC) {
return 0;
}
if (CHANSVm_81450D14(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVm_81451314(blob, arg1, offset);
if (CHANSVmBlobResolveOffset(blob, arg0->value.int_v, &offset) != 0) {
size = CHANSVmBlobGetCount(blob, arg1, offset);
off = offset;
if (((s64)size >= 0LL && (s64)(blob->size - off) >= (s64)size) != vmFalse) {
NETHMACContext ctx;
@@ -5202,7 +5202,7 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
copySize = paramValue;
}
if (copySize < 0 || !CHANSVm_81451348(parentBlob, copySize)) {
if (copySize < 0 || !CHANSVmBlobHasSpace(parentBlob, copySize)) {
goto error;
}
@@ -5220,7 +5220,7 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
break;
}
case 5: {
if (paramValue < 0 || !CHANSVm_81451348(parentBlob, paramValue)) {
if (paramValue < 0 || !CHANSVmBlobHasSpace(parentBlob, paramValue)) {
goto error;
}
if (paramValue > 0) {
@@ -5247,7 +5247,7 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
goto error;
}
if (!CHANSVm_81451348(parentBlob, elemSize * count)) {
if (!CHANSVmBlobHasSpace(parentBlob, elemSize * count)) {
goto error;
}
@@ -5342,7 +5342,7 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
break;
}
case 8: {
*(u64*)packBuf = CHANSVm_814540E0(packBuf[0], packBuf[1]);
*(u64*)packBuf = CHANSVmMakeU64(packBuf[0], packBuf[1]);
break;
}
}
@@ -5379,7 +5379,7 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
goto error;
}
if (!CHANSVm_81451348(parentBlob, elemSize * count)) {
if (!CHANSVmBlobHasSpace(parentBlob, elemSize * count)) {
goto error;
}
@@ -5424,7 +5424,7 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
}
bufSize = (count + 1) / 2;
if (!CHANSVm_81451348(parentBlob, bufSize)) {
if (!CHANSVmBlobHasSpace(parentBlob, bufSize)) {
goto error;
}
@@ -5472,7 +5472,7 @@ error:
return vmFalse;
}
static u64 CHANSVm_814540E0(u32 upper, u32 lower) {
static u64 CHANSVmMakeU64(u32 upper, u32 lower) {
// Read U64 and byte-swap
u64 x = (u64)upper << 32 | lower;
return x >> 56 & 0x00000000000000ffULL | x >> 40 & 0x000000000000ff00ULL | x >> 24 & 0x0000000000ff0000ULL | x >> 8 & 0x00000000ff000000ULL |
@@ -5648,7 +5648,7 @@ VmMethodDefine(Blob, Unpack) {
} else {
count = outVal;
}
if (count < 0 || !CHANSVm_81451348(srcBlob, count)) {
if (count < 0 || !CHANSVmBlobHasSpace(srcBlob, count)) {
goto error;
}
@@ -5663,7 +5663,7 @@ VmMethodDefine(Blob, Unpack) {
break;
}
case 5: {
if (outVal < 0 || !CHANSVm_81451348(srcBlob, outVal)) {
if (outVal < 0 || !CHANSVmBlobHasSpace(srcBlob, outVal)) {
goto error;
}
@@ -5682,7 +5682,7 @@ VmMethodDefine(Blob, Unpack) {
} else {
count = outVal;
}
if (count < 0 || !CHANSVm_81451348(srcBlob, outSize * count)) {
if (count < 0 || !CHANSVmBlobHasSpace(srcBlob, outSize * count)) {
goto error;
}
@@ -5710,7 +5710,7 @@ VmMethodDefine(Blob, Unpack) {
break;
}
case 8: {
unpackBuf.value = CHANSVm_814540E0(unpackBuf.words[0], unpackBuf.words[1]);
unpackBuf.value = CHANSVmMakeU64(unpackBuf.words[0], unpackBuf.words[1]);
break;
}
}
@@ -5794,7 +5794,7 @@ VmMethodDefine(Blob, Unpack) {
}
count = (srcBlob->size - srcBlob->offset) / outSize;
}
if ((s32)count < 0 || !CHANSVm_81451348(srcBlob, outSize * count)) {
if ((s32)count < 0 || !CHANSVmBlobHasSpace(srcBlob, outSize * count)) {
goto error;
}
@@ -5845,7 +5845,7 @@ VmMethodDefine(Blob, Unpack) {
}
bufSize = (s32)(count + 1) / 2;
if (!CHANSVm_81451348(srcBlob, bufSize)) {
if (!CHANSVmBlobHasSpace(srcBlob, bufSize)) {
goto error;
}
@@ -5864,7 +5864,7 @@ VmMethodDefine(Blob, Unpack) {
u8* hexTable;
u8 byte;
u8 nibble;
hexTable = (u8*)lbl_816976E8;
hexTable = (u8*)scHexDigitsPtr2;
srcPos = srcData;
destPos = destStr;
@@ -5992,7 +5992,7 @@ void CHANSVmImageRegisterAllocator(CHANSVmImageAllocatorCallback allocCb, CHANSV
VmImageCtorCallback = ctorCb;
}
char lbl_8169778C[] = "Image";
char scImageClassName[] = "Image";
CHANSVmObjHdr* CHANSVmNewImageObject(CHANSVm* vm, CHANSVmObjHdr* object, vmPtr srcData, vmU16 width, vmU16 height, s32 format) {
u32 bpp;
@@ -6030,7 +6030,7 @@ CHANSVmObjHdr* CHANSVmNewImageObject(CHANSVm* vm, CHANSVmObjHdr* object, vmPtr s
if (object == vmNull) {
goto ret;
}
if (CHANSVmSetObjectAsNativeInstance(vm, object, vmNull, lbl_8169778C) != CHANS_VM_OK) {
if (CHANSVmSetObjectAsNativeInstance(vm, object, vmNull, scImageClassName) != CHANS_VM_OK) {
goto error;
}
image = (CHANSVmImage*)((u32*)object->value.ptr_v)[0];
@@ -6120,10 +6120,10 @@ static vmBoolInt VmWinEmuWrite(CHANSVm* vm, CHANSVmObjHdr* parent, CHANSVmObjHdr
const CHANSVmMethodList VmWinEmuMethodTbl[] = {"write", VmWinEmuWrite};
char lbl_816977AC[] = "Date";
char lbl_816977B1[] = "@Math";
char lbl_816977B7[] = "Math";
char lbl_816977BC[] = "@WinEmu";
char scDateClassName[] = "Date";
char scMathInternalName[] = "@Math";
char scMathClassName[] = "Math";
char scWinEmuInternalName[] = "@WinEmu";
static CHANSVmErr VmPushFuncReturnInfo(CHANSVm* vm, u32 argCount, u32 totalSlots, u32 headerCount);
@@ -6186,7 +6186,7 @@ CHANSVmErr CHANSVmInit(CHANSVm* vm, vmPtr work, vmU32 size) {
goto class_fail;
/* Date class */
cls = CHANSVmAddNativeClass2(vm, lbl_816977AC, VmDateCtor, 0, VmDateDtor);
cls = CHANSVmAddNativeClass2(vm, scDateClassName, VmDateCtor, 0, VmDateDtor);
if (cls == vmNull) {
ok = vmFalse;
} else {
@@ -6196,7 +6196,7 @@ CHANSVmErr CHANSVmInit(CHANSVm* vm, vmPtr work, vmU32 size) {
goto class_fail;
/* Math class */
if (CHANSVmNewBuiltinObject(vm, lbl_816977B1, vmNull, vmNull, vmNull, lbl_816977B7, vmNull, VmMathPropertyTbl, CHANSVmPropertyCount(VmMathPropertyTbl),
if (CHANSVmNewBuiltinObject(vm, scMathInternalName, vmNull, vmNull, vmNull, scMathClassName, vmNull, VmMathPropertyTbl, CHANSVmPropertyCount(VmMathPropertyTbl),
VmMathMethodTbl, CHANSVmMethodCount(VmMathMethodTbl)) == 0) {
goto class_fail;
}
@@ -6235,13 +6235,13 @@ CHANSVmErr CHANSVmInit(CHANSVm* vm, vmPtr work, vmU32 size) {
/* Image class */
VmImageAllocCallback = vmNull;
VmImageCtorCallback = vmNull;
if (CHANSVmNewBuiltinObject(vm, lbl_8169778C, vmNull, VmImageCtor, vmNull, vmNull, vmNull, VmImagePropertyTbl, CHANSVmPropertyCount(VmImagePropertyTbl),
if (CHANSVmNewBuiltinObject(vm, scImageClassName, vmNull, VmImageCtor, vmNull, vmNull, vmNull, VmImagePropertyTbl, CHANSVmPropertyCount(VmImagePropertyTbl),
vmNull, 0) == 0) {
goto class_fail;
}
/* Screen (@WinEmu) class */
if (CHANSVmNewBuiltinObject(vm, lbl_816977BC, vmNull, vmNull, vmNull, "document", vmNull, vmNull, 0, (CHANSVmMethodList*)&VmWinEmuMethodTbl,
if (CHANSVmNewBuiltinObject(vm, scWinEmuInternalName, vmNull, vmNull, vmNull, "document", vmNull, vmNull, 0, (CHANSVmMethodList*)&VmWinEmuMethodTbl,
CHANSVmMethodCount(VmWinEmuMethodTbl)) == 0) {
class_fail:
result = CHANS_VM_ERR_NATIVE_METHOD_INIT;
@@ -6466,7 +6466,7 @@ void CHANSConvertModuleOfsToPtr(CHANSVmModule* ptr) {
VmOffsU32ToPtr((void**)&ptr->pLineTbl, ptr);
}
static CHANSVmObjHdr* CHANSVm_81455654(CHANSVm* vm, s32 id) {
static CHANSVmObjHdr* CHANSVmLookupScopedObject(CHANSVm* vm, s32 id) {
CHANSVmObjHdr* data = vmNull;
CHANSVmPrivate* pVm = (CHANSVmPrivate*)vm;
CHANSVmExecutionCtx* ctx = pVm->pActiveCtx;
@@ -6755,7 +6755,7 @@ static CHANSVmErr VmReturnWithValue(CHANSVm* vm, u32 val) {
}
} else {
for (i = 0; i < pVm->pActiveCtx->pDbg->moduleCount; i++) {
if (CHANSVmDeleteObject(vm, CHANSVm_81455654(vm, i)) != CHANS_VM_OK) {
if (CHANSVmDeleteObject(vm, CHANSVmLookupScopedObject(vm, i)) != CHANS_VM_OK) {
return CHANS_VM_ERR_RETURN;
}
}
@@ -6873,7 +6873,7 @@ CHANSVmErr CHANSVmLinkModules(CHANSVm* vm, vmS32 unk0) {
CHANSVmObjHdr* obj;
if (idx >= module->moduleCount) {
goto pass3_idx_err;
} else if (obj = CHANSVm_81455654(vm, idx), obj == vmNull) {
} else if (obj = CHANSVmLookupScopedObject(vm, idx), obj == vmNull) {
goto pass3_obj_err;
} else if (obj->type == CHANS_VM_OBJ_TYPE_BLANK) {
goto pass3_success;
@@ -7417,7 +7417,7 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
}
default: {
// TODO: This is an inlined function called "VmGetResultType"
CHANS_VM_PRINTF_CUSTOM("%s: no table for op '%c'\n", lbl_81669128, opKind);
CHANS_VM_PRINTF_CUSTOM("%s: no table for op '%c'\n", scVmGetResultType, opKind);
goto error_setter;
}
}
@@ -7602,7 +7602,7 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
break;
}
case CHANS_VM_OBJ_TYPE_FLOAT: {
invertedVal = (s64)(CHANSVm_8144B1D8(pAcc->value.float_v) * floor(fabs(pAcc->value.float_v)));
invertedVal = (s64)(CHANSVmFloatSign(pAcc->value.float_v) * floor(fabs(pAcc->value.float_v)));
break;
}
case CHANS_VM_OBJ_TYPE_STRING: {
@@ -7818,7 +7818,7 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
result = CHANS_VM_ERR_GET_PROPERTY_NAME;
arrayIdx = 0;
imm16Val = VM_READ_BE_U16(operandBuf, 0);
foundObj = CHANSVm_81455654(vm, imm16Val);
foundObj = CHANSVmLookupScopedObject(vm, imm16Val);
accumulator = &pVm->accumulator;
if (foundObj != vmNull && accumulator->type == CHANS_VM_OBJ_TYPE_INTEGER &&
(computedAddr = accumulator->value.data.len, (u64)accumulator->value.int_v <= ~1U)) {
@@ -7954,7 +7954,7 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
if (operandBuf == vmNull) {
return CHANS_VM_ERR_CODE_RANGE;
}
foundObj = CHANSVm_81455654(vm, (VM_READ_BE_U16(operandBuf, 0)) & 0x1FFF);
foundObj = CHANSVmLookupScopedObject(vm, (VM_READ_BE_U16(operandBuf, 0)) & 0x1FFF);
result = VmDeleteCommon(vm, foundObj);
break;
}
@@ -7982,12 +7982,12 @@ CHANSVmErr CHANSVmStep(CHANSVm* vm, int stepCount) {
imm16Val = (opcodeVal << 8 | operandBuf[1]) & 0x1FFF;
switch (opcodeVal & CHANS_VM_OP_SYMBOL_STORE) {
case 0: {
foundObj = CHANSVm_81455654(vm, imm16Val);
foundObj = CHANSVmLookupScopedObject(vm, imm16Val);
result = VmStore(vm, &pVm->accumulator, foundObj);
break;
}
case CHANS_VM_OP_SYMBOL_STORE: {
foundObj = CHANSVm_81455654(vm, imm16Val);
foundObj = CHANSVmLookupScopedObject(vm, imm16Val);
result = VmStore(vm, foundObj, &pVm->accumulator);
break;
}

View File

@@ -1,19 +1,19 @@
#include <revolution/gx/GXStruct.h>
#include <revolution/os/OSError.h>
extern "C" const char lbl_8166A6E3[];
extern "C" const u8 lbl_81697844;
extern "C" const u8 lbl_81697845;
extern "C" const u8 lbl_81697846;
extern "C" const u8 lbl_81697847;
extern "C" const char scCsFatalMsg[];
extern "C" const u8 scCsFatalColorR;
extern "C" const u8 scCsFatalColorG;
extern "C" const u8 scCsFatalColorB;
extern "C" const u8 scCsFatalColorA;
#define NW4R_DB_ASSERT_H
#define NW4R_ASSERT(x) \
{ \
if (!(x)) { \
GXColor front = {lbl_81697844, lbl_81697845, lbl_81697846, lbl_81697847}; \
GXColor front = {scCsFatalColorR, scCsFatalColorG, scCsFatalColorB, scCsFatalColorA}; \
GXColor back = {0, 0, 0, 0}; \
OSFatal((GXColor)front, (GXColor)back, lbl_8166A6E3); \
OSFatal((GXColor)front, (GXColor)back, scCsFatalMsg); \
} \
}
@@ -29,7 +29,7 @@ extern "C" const u8 lbl_81697847;
#include "math/iplMathTypes.h"
extern "C" const f32 lbl_81694FC0 = 0.0f;
extern "C" const f32 scCsZeroF = 0.0f;
extern "C" nw4r::ut::Color GetTextColor__Q34nw4r3lyt7TextBoxCFUl(const nw4r::lyt::TextBox*, u32);
@@ -130,7 +130,7 @@ namespace ipl {
nw4r::math::VEC2 scale;
scale.x = pane->GetScale().x;
scale.y = pane->GetScale().y;
result = vec3::_ctor(VmInst, VmReturnObj, scale.x, scale.y, lbl_81694FC0) == TRUE;
result = vec3::_ctor(VmInst, VmReturnObj, scale.x, scale.y, scCsZeroF) == TRUE;
}
}
return result;
@@ -514,7 +514,7 @@ namespace ipl {
nw4r::math::VEC3 get_vec_(CHANSVm* vm) {
u32 argc = CHANSVmGetArgc(vm);
CHANSVmObjHdr* arg = CHANSVmGetArg(vm, 0);
nw4r::math::VEC3 out(lbl_81694FC0, lbl_81694FC0, lbl_81694FC0);
nw4r::math::VEC3 out(scCsZeroF, scCsZeroF, scCsZeroF);
if (argc == 1 && util::is_valid_class(arg, "VEC3")) {
f32* src = static_cast<f32*>(*arg->value.ptr_v);
out.x = src[0];
@@ -540,7 +540,7 @@ namespace ipl {
nw4r::lyt::Size get_size_(CHANSVm* vm) {
u32 argc = CHANSVmGetArgc(vm);
CHANSVmObjHdr* arg = CHANSVmGetArg(vm, 0);
nw4r::lyt::Size out(lbl_81694FC0, lbl_81694FC0);
nw4r::lyt::Size out(scCsZeroF, scCsZeroF);
if (argc == 1 && util::is_valid_class(arg, "Size")) {
f32* src = static_cast<f32*>(*arg->value.ptr_v);
out.width = src[0];
@@ -622,15 +622,15 @@ namespace ipl {
namespace pane {
#pragma push
#pragma section const_type ".data"
extern "C" const char lbl_8166A6E3[] = "Error#004\nAn error has occurred.\nThe system files are corrupted.";
extern "C" const char scCsFatalMsg[] = "Error#004\nAn error has occurred.\nThe system files are corrupted.";
#pragma pop
#pragma push
#pragma section data_type ".sdata"
extern "C" __declspec(section ".sdata") const u8 lbl_81697844 = 0xff;
extern "C" __declspec(section ".sdata") const u8 lbl_81697845 = 0xff;
extern "C" __declspec(section ".sdata") const u8 lbl_81697846 = 0xff;
extern "C" __declspec(section ".sdata") const u8 lbl_81697847 = 0;
extern "C" __declspec(section ".sdata") const u8 scCsFatalColorR = 0xff;
extern "C" __declspec(section ".sdata") const u8 scCsFatalColorG = 0xff;
extern "C" __declspec(section ".sdata") const u8 scCsFatalColorB = 0xff;
extern "C" __declspec(section ".sdata") const u8 scCsFatalColorA = 0;
#pragma pop
}
}

View File

@@ -12,11 +12,11 @@ namespace ext_ead {
}
}
extern "C" char lbl_816962F8[] = "ERROR?\n";
extern "C" char lbl_81643B40[] = " TextureBuffer_ %d:%d ptr:%p\n";
extern "C" char lbl_81643B5E[] = "INFO: cannot create browser window\n";
extern "C" char scWwwErrorQ[] = "ERROR?\n";
extern "C" char scWwwTexBufFmt[] = " TextureBuffer_ %d:%d ptr:%p\n";
extern "C" char scWwwNoBrowserWin[] = "INFO: cannot create browser window\n";
#define OSReport(...) OSReport(lbl_816962F8)
#define OSReport(...) OSReport(scWwwErrorQ)
#include "iplwww/www_window.h"
#undef OSReport
@@ -76,12 +76,12 @@ namespace ext_ead {
memset(mTexBufArr[i][j], 0, texBufSize);
DCStoreRange(mTexBufArr[i][j], texBufSize);
print::IPLWWWReport(print::WWW_DEBUG, lbl_81643B40, j, i, mTexBufArr[i][j]);
print::IPLWWWReport(print::WWW_DEBUG, scWwwTexBufFmt, j, i, mTexBufArr[i][j]);
}
}
if (WWWCreateBrowserWindow(mpBrowserThread->GetHandle(), &mpWwwWindow, 0)) {
print::IPLWWWReport(print::WWW_WARNING, lbl_81643B5E);
print::IPLWWWReport(print::WWW_WARNING, scWwwNoBrowserWin);
return NULL;
} else {
WWWRect rect = {0, 0, 0, 0};

View File

@@ -20,6 +20,16 @@ protected:
namespace extend {
namespace memo {
class EventHandler : public inputform::EventHandler {
public:
EventHandler(InputForm* form) : inputform::EventHandler(form), mpMemoForm(form) {}
virtual ~EventHandler() {}
virtual void onTiEvent(gui::PaneComponent*, u32, Input*);
private:
InputForm* mpMemoForm;
};
class AnmPane : public nw4rmanager::AnmPane {
protected:
AnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer)
@@ -28,8 +38,8 @@ public:
virtual ~AnmPane();
virtual void init();
virtual void changeAnimation(u32 id);
virtual u32 getState();
virtual u32 getKeyType() const;
virtual u32 getState();
protected:
u32 meState;
u32 meKeyType;
@@ -49,13 +59,6 @@ public:
virtual void onAnmEvent(AnmPaneEvent event);
};
class SimpleAnmPane : public nw4rmanager::AnmPane {
public:
SimpleAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : nw4rmanager::AnmPane(pane, observer) {}
virtual ~SimpleAnmPane() {}
virtual void init();
virtual void changeAnimation(u32 id);
};
class ScrollButton {
public:
@@ -74,15 +77,16 @@ private:
bool mbRightPressed;
};
class EventHandler : public inputform::EventHandler {
class SimpleAnmPane : public nw4rmanager::AnmPane {
public:
EventHandler(InputForm* form) : inputform::EventHandler(form), mpMemoForm(form) {}
virtual ~EventHandler() {}
virtual void onTiEvent(gui::PaneComponent*, u32, Input*);
private:
InputForm* mpMemoForm;
SimpleAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : nw4rmanager::AnmPane(pane, observer) {}
virtual ~SimpleAnmPane() {}
virtual void init();
virtual void changeAnimation(u32 id);
};
static const char* scPaneName[] = {
"N_Header", "N_Body", "B_Body", "N_Footer", "Nigaoe",
"T_Nigaoe", "B_Nigaoe", "T_Letter", "T_TouchLetter"

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