Compare commits

...

359 Commits

Author SHA1 Message Date
coah
095d1d857b cleanup(iplUtility): rename BScroller/Scroller unk fields
BScroller: unk_0x08/0x10 → mCurPos/mStartPos
Scroller: unk_0x3C/44/48/4C → mVelocity/mAnimFrom/mFriction/mAccel

Verified: iplUtility 100%/100%, DOL sha1 26116613f624061ba99c8d1a299aaa6efa85670d
2026-10-02 14:56:48 -05:00
coah
8864436cde match(iplChannelObj 56/56) (near1c) (worker f210b2fc) (#946) 2026-10-02 14:56:25 -05:00
coah
a9a3f36cf0 usbkbd: rename USBKBDCmdLEDAsync unused gap to pad_0x08 (#945)
Padding between USBKBDCmdLED base and the async callback fields;
never accessed by name in Matching usb_kbd.
2026-10-02 14:51:48 -05:00
coah
ffeed96e49 cleanup(iplCSSavedata): rename sMountPath (#943)
unk_0x00 → sMountPath: optional NAND archive path used to VF-mount @CS.
Empty → load from NAND via sPath; set (two-arg ctor) → load_vf_ mounts
that path and opens sPath inside the volume.
2026-10-02 14:49:08 -05:00
coah
1216db0acb sc: rename SC_BT_DEV_INFO unused gaps to pad_* (#942)
unk_0x14 / unk_0x15 / unk_0x30 sit between devName and linkKey
(and after linkKey) with no named field readers in Matching units;
mark them as pads.
2026-10-02 14:48:42 -05:00
coah
85b993f48c cleanup(eZiText): rename work unk_0x1F to ignoreCase (#938)
When set, PUD/UWD/OEM matching tries Zi8ChangeCharCase and UWD
stores the folded form in the alt prefix buffer.
2026-10-02 14:47:52 -05:00
coah
a2a0460567 cleanup(AudioWavePlayer): rename mbFillInCallback (#937)
unk_0xB5 → mbFillInCallback: when true MakeWave runs in the wave-packet
callback; when false it runs from update(). Ctor defaults true.
2026-10-02 14:47:25 -05:00
coah
df0fa22203 cleanup(eZiText): rename zi8DawgCtx unk_0x338 to endNode (#936)
Walk stops when the current node equals endNode; cleared on reset.
2026-10-02 14:47:19 -05:00
coah
11c75ddb62 cleanup(eZiText): rename work unk_0x17 to zhPudMinPrefix (#935)
Init to 5; Chinese PUD entries whose first payload byte is below this
are skipped.
2026-10-02 14:45:11 -05:00
coah
15b9f71a6e cleanup(eZiText): rename work unk_0x0C to targetCount (#933)
Init to 0xFFFF; Zi8Punctuation count-mode stops when count >= targetCount.
2026-10-02 14:45:06 -05:00
coah
0a7baea67a cleanup(eZiText): align ziSwParam with ZiCandidateOptions (#932)
zi8getSW receives ZiCandidateOptions* as ziPtr; rename the local
view fields to match (keep ziS32 maxCount for signed compares).
2026-10-02 14:44:40 -05:00
coah
6f6f63cb81 cleanup(puh_ker_tsk): rename unused manager tail fields to pads (#931)
The four u32s after entries[] are never read or written.
2026-10-02 14:44:14 -05:00
coah
4a046a17ab cleanup(AxAdpcmPlayer): rename VoiceInfo update sync flag (#930)
unk_0x0C / getUnk_0x0C / setUnk_0x0C → mUpdateFlag / getUpdateFlag / setUpdateFlag

Cross-thread voice sync: main sets 1, calc() promotes to 2, audio callback clears to 0.
2026-10-02 14:43:48 -05:00
coah
842c850c10 cleanup(eZiText): rename dawg flags forceAltGraph/advanceGroup (#928)
unk_0x141C gates FI+group 0xC alternate graphTableId; unk_0x141D
controls whether NextDawgGroup skips the first group.
2026-10-02 14:42:42 -05:00
coah
6b95233f01 cleanup(uusb_ppc): name outstanding counters and intrEndpoint2 (#927)
at_0x38/48 track in-flight bulk/intr USB reads (cap 5); at_0x13 sits
with the other endpoint bytes and is only cleared.
2026-10-02 14:42:16 -05:00
coah
2dba9bd13b cleanup(hcisu_h2): name tHCISU_H2_CB receive/open fields (#926)
From init/receive_msg: p_rx_msg, bytes_left, buf_size, pkt_type,
len_hi, rx_state, open_state, task_id, mbox.
2026-10-02 14:41:49 -05:00
coah
fd775c34dc link(iplChannelSelect: native weak vtable / Hermite emission) (link1) (worker bf02f407) (#934) 2026-10-02 14:39:44 -05:00
coah
a8ab2099cd cleanup(puh_ker_msg): name messages companion and unused pad (#924)
Entry +4 is the OSMessage* array slot beside queue (OSInitMessageQueue
layout); manager +0x14 is never referenced.
2026-10-02 14:37:35 -05:00
coah
96db1eac04 match(iplSetting 109/112) (#923)
* match(iplSetting 107/112): initKeyboard + data symbol pairing

initKeyboard: drop zero-inits on rowLimit/stringLimit, decl order for
callee-saved regs, KeyboardSetting field store order (IPL_SETTING layout),
Zi dictionary temps evaluated system-then-oem for arg regs.

symbols.txt: shrink scAnmTable to 0xE8 and name absorbed rodata literals;
add missing .data @string literals in unlabeled gaps; rename .sdata lbl_*
to matching @ names so .data relocs pair (.data fuzzy 71%→97%).

* match(iplSetting 108/112): createBrowser

Separate case 7 from default in the direct-page switch so MWCC
emits the target cmpwi/8 shape; default leaves the path unset.
createBrowser 98.85 → 100. DOL SHA1 unchanged.

* match(iplSetting 109/112): calcKeyboard

Drop formText=NULL inits (target has no early zeros) and split
asterisks[index++]=* into store then index++ for loop shape.
calcKeyboard 98.0 → 100. createBrowser still 100. DOL unchanged.
2026-10-02 14:37:30 -05:00
coah
5a332eceba cleanup(iplChannelSelect): rename ortho translate/scale fields (#922)
unk_0xD8 -> mOrthoTrans; unk_0xE4 -> mOrthoScale (setOrthoTransAndScale).
Byte-identical.
2026-10-02 14:37:03 -05:00
coah
ed2d5b30b4 cleanup(eZiText): align ziGetParam count/completion with EZTX (#921)
Rename unk_0x20 → count and count → completion so ziGetParam matches
EZTXGetParam under TIZISTRING_IMPLEMENTATION (same offsets; cast in eztx.c).
2026-10-02 14:36:35 -05:00
coah
02dbcc53bd cleanup(usb): name USBCommandBlock isoArg and pads (#920)
unkIsoArg is the second arg to USBIsoCallback; unk_0x10/0x38 are
unused gaps before clean[] and the path/msg union.
2026-10-02 14:36:28 -05:00
coah
2da1c58f2c cleanup(NWC24MsgObj): rename trailing unk_0xF4/F8/FC to pad (#919)
Never read or written; sit after iconNew at end of NWC24MsgObjPrivate.
2026-10-02 14:36:01 -05:00
coah
1c8ada226a cleanup(NWC24FriendList): rename FLHeader unk_0x20 to pad_0x20 (#918)
Unused 7×u32 gap between confirmedBits and listFlags; never read or
written by name (only whole-header memset/IO). Matching unit stays OK.
2026-10-02 14:35:34 -05:00
coah
f05f7bbcf7 cleanup(eZiText): rename work unk_0x12E to uwdPrioritySort (#917)
When set, UWD insert stops at first lower-priority candidate.
2026-10-02 14:35:08 -05:00
coah
f508371ca0 cleanup(eZiText): rename work unk_0x00 to getcPhase (#916)
Multi-pass getc state (0..9 / tab) shared by Zi8punct and zi8getc2.
2026-10-02 14:34:22 -05:00
coah
7216fd527f cleanup(eZiText): rename work unk_0x130/138 to uwdDicts/uwdDictCount (#914)
User-word dictionary ptr stack + depth (mirrors pudTable/pudCount).
2026-10-02 14:33:56 -05:00
coah
26e90aa988 cleanup(eZiText): rename work unk_0x1B30 to koAltTables (#913)
Korean path selects alternate hangul tables when non-zero.
2026-10-02 14:33:31 -05:00
coah
e059ea0632 cleanup(puh_ker_tsk): rename entry unk_0x00/04 to thread/stack (#912)
OSThread* used with OSSetThreadPriority; following buffer is task stack.
2026-10-02 14:33:04 -05:00
coah
e6f54e254d cleanup(usb_kbd): rename async mem unk_0x09 to reserved (#911)
HID boot-keyboard reserved byte between modifiers and keycodes.
2026-10-02 14:32:37 -05:00
coah
299a6ca724 cleanup(puh_ker_sem): name semaphore manager fields (#910)
initCount/flags from create args; usedCount active slots; lockSem manager lock.
2026-10-02 14:30:27 -05:00
coah
77439a3268 cleanup(iplChannelManager): name mbDiskChannelReady (#908)
unk_0x1B81 -> mbDiskChannelReady
isUnk_0x1B81 -> isDiskChannelReady
setUnk_0x1B81 -> setDiskChannelReady

Set when BS2 enters RVL_GAME and disk banner info is applied; cleared when
disk banner data is consumed or channel UI dismisses it.

Touched channelSelect / channelTitle callers.

Matching 100% before/after; DOL sha1 unchanged.
2026-10-02 14:29:40 -05:00
coah
f65fac3351 cleanup(WPAD): rename CB unk_0x910 to suppressDisconnect (#907)
When set, comm-timeout path skips WPADiDisconnect and reports TRANSFER.
2026-10-02 14:29:12 -05:00
coah
c7ceb3efe0 cleanup(WPAD): name FS/CL stick min/max calib fields (#903)
DEBUGPrint labels X/Y max/min beside stick centers in calibration.
2026-10-02 14:27:25 -05:00
coah
401d0c88e7 cleanup(eZiText): rename work unk_0x12C to uwdPtrCount (#901)
Count of ZH user-word ptr stack entries (distinct from uwdCount @ 0x1C7).
2026-10-02 14:26:58 -05:00
coah
6cb5ac9ded cleanup(eZiText): name unicode map range fields in work (#900)
Zi8Uni2Ptr OEM remap table + two char ranges + subLanguage gate.
2026-10-02 14:26:31 -05:00
coah
8870c4aa75 cleanup(NWC24FriendList): rename FLHeader unk_0x3C to listFlags (#898)
Written by SetListFlag (OR of flag bits on add).
2026-10-02 14:25:44 -05:00
coah
402687106b cleanup(NWC24FriendList): rename Get/SetUnkFlag helpers (#897)
GetUnkFlag/SetUnkFlag → GetConfirmedBit/SetConfirmedBit;
SetUnkFlag2 → SetListFlag (writes FLHeader unk_0x3C).
2026-10-02 14:25:17 -05:00
coah
2080aeb0cf cleanup(NWC24FriendList): rename FLHeader unk_0x10 to confirmedBits (#896)
Per-friend bitfield; GetUnkFlag==1 sets NWC24_FRIENDSTATUS_CONFIRMED.
2026-10-02 14:24:50 -05:00
coah
1f3d89772e cleanup(iplChannelScriptManager): name CSData mbHasNewMessage (#895)
unk_0x1A -> mbHasNewMessage

Set true when starting channel script, cleared when the title has no new
NWC24 message (isNewMessageThere).

Touched channelSelect / channelTitle / sdChannelTitle writers.

Matching 100% before/after; DOL sha1 unchanged.
2026-10-02 14:24:22 -05:00
coah
f429cd07cc cleanup(CDBRecord): rename unk_0x00 to database (#894)
Held as CDBDatabase*; copied to recordFile->database.
2026-10-02 14:23:55 -05:00
coah
f7b1b9b09b cleanup(eZiText): rename work unk_0x1B28 to pyFuzzy (#892)
Union holding Pinyin fuzzy pairs; initd copies .word into pyFuzzy.
2026-10-02 14:21:24 -05:00
coah
fcbc0c56b7 cleanup(WPAD): rename CB unk_0x38 to gameInfoStatus (#891)
Stores WPAD_ERR_* from getGameInfo checksum validation.
2026-10-02 14:20:58 -05:00
coah
ab8bece04e cleanup(iplController): name decide/pinch/kpad/classic fields (#889)
unk_0x08 -> mDecideHoldCount
unk_0x1C -> mbForceInvalid
unk_0x1D -> mbPinching
unk_0x1E -> mbWasPinching
unk_0x20 -> mpKpadStatus
unk_0x24 -> mClassicCursorPos
unk_0x2C -> mClassicCursorTimer

Also update iplControllerManager ctor inits for Base fields.

Matching 100% before/after; DOL sha1 unchanged.
2026-10-02 14:20:10 -05:00
coah
0059de422f cleanup(iplSettingSelect): rename pending scene and exit sequence fields (#888)
unk_0x90 -> mPendingSceneId (SCENE_* values); unk_0x94 -> mExitSeqStep.
Also use SCENE_* constants instead of magic numbers. Byte-identical.
2026-10-02 14:19:44 -05:00
coah
413c779180 cleanup(eZiText): rename work unk_0x0A to maxWordLength (#886)
Copied to/from options->maxWordLength; assigned from length.
2026-10-02 14:18:33 -05:00
coah
f9ecefa6a2 cleanup(NWC24Work): rename MBox header/entry work buffers (#883)
sendMbcHeader/recvMbcHeader/mbcEntry for cached MBC structures.
2026-10-02 14:17:06 -05:00
coah
320700d49b cleanup(eZiText): rename work unk_0x141E to graphTableId (#882)
Passed to Zi8GetTableAddress / Zi8GetTableSize (often 0x10).
2026-10-02 14:16:39 -05:00
coah
c52153e9f7 cleanup(eZiText): rename work unk_0x141A to capacity (#880)
Copied into options.capacity in zi8getc2; init to 0x100.
2026-10-02 14:15:52 -05:00
coah
899438ff02 cleanup(NWC24MsgObj): rename unk_0xD0 to extraData (#879)
Written by WriteExtraFields during commit.
2026-10-02 14:15:25 -05:00
coah
8476c93f00 cleanup(eZiText): rename work unk_0x17EA to matchOffset (#878)
Offset into match elements / result buffer during Zi8MatchROMdata1.
2026-10-02 14:14:57 -05:00
coah
9b375e1e50 cleanup(eZiText): rename work unk_0x1764 to groupPtr (#876)
Cursor into DAWG group table (from group / Zi8GetTableAddress).
2026-10-02 14:14:04 -05:00
coah
73795cb3fb cleanup(ErrorHandler): name set() arg storage fields (#875)
Rename unused debug-ish stash fields to match ErrorHandler::set params:
- unk_0x14 → mArg1 (char[4] from arg1)
- unk_0x0C → mArg2
- unk_0x10 → mArg3

Verified: ErrorHandler 100%/100%, build/43U/ok, DOL sha1
26116613f624061ba99c8d1a299aaa6efa85670d
2026-10-02 14:11:44 -05:00
coah
0c780f6d1f cleanup(eZiText): rename work unk_0x1418 to formatCount (#874)
Count of entries filled into formats[]; saved as savedCount.
2026-10-02 14:11:17 -05:00
coah
63f4c7aeab cleanup(NWC24MsgObj): rename flags to headerSize (#873)
Same 0x10 slot as MsgRead headerSize; Commit stamps body offset.
2026-10-02 14:10:50 -05:00
coah
282ddd99b7 cleanup(iplSettingButton): rename Unk ring-buffer placeholders (#872)
Unk -> CmdEntry; unk_0x64 -> mCmdQueue; capacity/count/read/write
indices. Byte-identical (DOL sha1 unchanged).
2026-10-02 14:10:24 -05:00
coah
c7d0f8f01b cleanup(CDBRecordFile): rename unk_0x1C to allocFlag (#871)
Stores CDB_RECORD_ALLOC_* from CDBRecordInstanceInit type arg.
2026-10-02 14:09:58 -05:00
coah
414b553743 cleanup(iplNwc24Manager): name receiving / title-table flags (#870)
unk_0xA31 -> mbReceiving
unk_0xA33 -> mbNewTitleTblReady
isUnk0xA31 -> isReceivingIdle (same == false semantics)

Touched channelTitle / sdChannelTitle / iplResetHandler callers for the getter rename.

Matching units 100% before/after; DOL sha1 unchanged.
2026-10-02 14:09:31 -05:00
coah
da96c27969 cleanup(NWC24MsgObj): rename unk_0x30/38 to fromData/toData (#868)
MIME From/To address spans used by WriteFromField/WriteToField and ReadMsgFromAddr.
2026-10-02 14:08:59 -05:00
coah
0a925c7053 cleanup(iplUrlProcessor): rename collision and processor placeholders (#865)
line_collision: unk_0x00/04/08 -> mLeft/mRight/mY
url_collision: unk_0x00/04/08 -> mTagNo/mpStart/mpEnd
UrlProcessor: unk_0x40..53 -> mHitYOffset/mMemoTranslateY/mCurTagNo/
mSelectedTagNo/mbColorPass/mbInTag/mbHoverOffset/mbFocusEnabled
Rename setUnk/getUnk accessors; update FocusObject call sites.
Byte-identical (DOL sha1 unchanged). Unit objdiff 100%.
2026-10-02 14:07:51 -05:00
coah
c0126c37d4 cleanup(WPADMem): rename WPADMemBlock.unk_0x10 to callback (#864)
Typed as WPADCallback and invoked on disconnect; leave other
_wmb fields that are only zeroed unnamed for now.

Verified: WPAD/WPADMem 100%/100%, build/43U/ok, DOL sha1
26116613f624061ba99c8d1a299aaa6efa85670d
2026-10-02 14:07:46 -05:00
coah
fc2d150c6d cleanup(WPAD): rename unk_0x98D/98E to encStatus/continuous (#863)
encStatus drives extension decode; continuous selects report mode.
2026-10-02 14:07:19 -05:00
coah
7851b2b29f cleanup(NWC24MsgObj): rename unk_0x10 to flags (#862)
Copied to/from mailbox entry->flags in NWC24MBoxCtrl.
2026-10-02 14:05:10 -05:00
coah
263411ccac cleanup(iplContest): name session NAT/HTTP unk fields (#861)
Rename clear Contest session placeholders from usage:
- unk_0x030 → natState (GameSpy/NAT detect state machine)
- unk_0x034 → gsAvailable
- unk_0x038 → natTimedOut
- unk_0x03c → natFailed
- unk_0x7f0 → httpBuf (NHTTP response buffer)

Verified: iplContest 100%/100%, build/43U/ok, DOL sha1 26116613f624061ba99c8d1a299aaa6efa85670d
2026-10-02 14:04:43 -05:00
coah
09de907f0b cleanup(eZiText): rename work unk_0x141F to maxCnt (#860)
Tracks max context->cnt during DAWG match in Matching zi8dawg.
2026-10-02 14:04:17 -05:00
coah
4e3ab6eae5 cleanup(jdec): rename MCU product fields to mcuTotal (#859)
Frame unk_0x14 and work unk_0x1804 are mcuX*mcuY totals.
2026-10-02 14:04:10 -05:00
coah
99d6fe20a2 cleanup(eZiText): rename work unk_0x1410 to formats (#858)
Saved/restored as savedFormats; assigned from formats arrays.
2026-10-02 14:03:44 -05:00
coah
00013016df cleanup(iplBS2Manager): name tick/update/abort/restart flags (#857)
unk_0x0C -> mbTickEnabled
unk_0x0D -> mbUpdateRequested
unk_0x0E -> mbAbortRequested
unk_0x0F -> mbRestartRequested

Matching 100% before/after; DOL sha1 unchanged.
2026-10-02 14:03:18 -05:00
coah
3e279ef189 cleanup(eZiText): rename work unk_0x17F0 to dawgGroup (#856)
Holds NextDawgGroup() cursor in Matching zi8dawg.
2026-10-02 14:02:52 -05:00
coah
32417fe8a2 cleanup(eZiText): rename work unk_0x01 to countOnly (#855)
Assigned/compared with options->countOnly in zi8getc2.
2026-10-02 14:02:44 -05:00
coah
2d9e3ee14a cleanup(eZiText): rename work unk_0x1A to separator (#854)
Init to space (0x20); Matching zi8space emits it; zi8cgetc saves as separator.
2026-10-02 14:00:30 -05:00
coah
23db5e05e1 cleanup(CDBCryptBuf): rename unk_0x3EC00/04 to size/offset (#853)
Decrypt fills size; Matching CDBRecordFile uses offset for seek/tell/read.
2026-10-02 14:00:24 -05:00
coah
741c9263e3 cleanup(iplSDButton): rename unk_0x54 to mAnimWait (#852)
Same pattern as Button: wait flag while help-button click anim plays.
2026-10-02 14:00:18 -05:00
coah
29fe1efaf2 Use the original Raku progress callback directly and link its thread (#851) 2026-10-02 13:32:07 -05:00
devin-ai-integration[bot]
45aaeb16b2 Link iplChannelTitle: emit gates + name 5 real .data objects (#834)
iplNand.h: IPL_CHANNEL_TITLE_NOVTABLE makes LangFile/LayoutFile virtuals
inline-only for this TU (orig emits their vtables elsewhere), while the
GUIManager.h/iplGuiManager.h gates no longer suppress ~Interface/
EventHandler/~PaneManager emission here - those vtables emit weakly as in
orig. config/43U/symbols.txt: name the 5 real emitted objects at
0x8164EFE4-0x8164F0B8 (dedup'd PaneManager/EventHandler/Interface/
LayoutFile/LangFile vtable emits) so objdiff's byte-diff range covers the
full .data extent; without names the compare stopped at 0x87c and the
extra emit range scored as inserts.

DOL sha1 identical, .data bytes + .rela.data set identical to orig, unit
all sections 100.

Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: coah80 <usernamecole7@gmail.com>
2026-10-02 13:26:47 -05:00
coah
e9114959c9 Retain original socket-option APIs and link matched routines (#848) 2026-10-02 13:20:27 -05:00
coah
1f0eb50f01 match(iplChannelSelect 102/102) (rt7b) (worker e0f02483) (#850) 2026-10-02 13:17:47 -05:00
coah
d93fb2d5f8 match(iplRakuRakuThread 14/14) (rt8b) (worker 8e747652) (#849) 2026-10-02 13:14:53 -05:00
coah
27abfe81d9 Link matched FAT allocation-chain routines (#847) 2026-10-02 13:10:48 -05:00
coah
bf6bc87fbd match(nup 20/23) (fz15h) (worker d8281f4c) (#846) 2026-10-02 13:01:18 -05:00
coah
786a2dd3e8 match(ATERM 17/26, zi8alpha 11/12) (fz20e) (worker 8133f528) (#845) 2026-10-02 12:55:03 -05:00
coah
bdd15186a7 match(pf_fat 35/35) (fz21e) (worker 4f270f72) (#844) 2026-10-02 12:48:07 -05:00
coah
40a2ea7e91 match(SOOption 4/4) (fz3k) (worker 6d7c19b7) (#843) 2026-10-02 12:45:44 -05:00
coah
0b10215388 match(iplSDChannelSelect 122/129) (fz16f) (worker abd61c86) (#842) 2026-10-02 12:42:39 -05:00
coah
4e293a4223 match(odh 24/28) (fz10h) (worker afc4f94d) (#841) 2026-10-02 12:41:08 -05:00
coah
d94df60412 Link matched eZiText wide-word routines (#840) 2026-10-02 12:36:59 -05:00
coah
daf04f1f26 Link matched NWC24 mailbox and message-commit routines (#839) 2026-10-02 12:36:52 -05:00
coah
1994d24f06 match(ZiDAWGGetSibling, Zi8IsWordW: 16-bit byte widening) (orchestrator + data-d11j) (worker 993402bc) (#838) 2026-10-02 12:28:01 -05:00
coah
0d9b038782 match(NWC24MsgCommit 18/18, Texture_MCUtoY8U8V8 12/13) (fz15g) (worker fed147c9) (#837) 2026-10-02 12:25:41 -05:00
coah
ff90063ef9 match(NWC24MBoxCtrl 25/25) (fz21d) (worker 710e3312) (#836) 2026-10-02 12:19:14 -05:00
devin-ai-integration[bot]
c1183780c2 eggAudioExpMgr: emit-gate headers for orig symbol set (stays Equivalent) (#835)
Split 2 of 2 from #815. Removes the invented 'Sample' class. The
EGG_AUDIO_EXPMGR_NO_INLINE_VIRTUALS gates (ArcPlayerMgr 9 virtuals,
SoundHeapMgr loadState/getCurrentLevel, nw4r AutoLock ct/dt) reproduce
orig's .o emit set exactly: same 8 .text symbols at the same offsets plus
__vt__ at .data+0/0x78.

Stays Equivalent: orig orders the secondary-vtable thunks
[@52@dt][@52@calc] while MWCC emits [@52@calc][@52@dt] here, and orig
emits them GLOBAL while ours are WEAK. Verified across 6 other orig
units that thunk order follows most-derived declared-virtual order; the
only lever found that flips it is a second ODR-used derived class's
vtable build - invented code, rejected. See
tools/decomp-assist/linkgap-audio.attempts.md.

Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: coah80 <usernamecole7@gmail.com>
2026-10-02 12:07:38 -05:00
coah
2050ad7616 match(odh 23/28, iplAddress 96/101) (fz10g) (worker 5f8a5379) (#833) 2026-10-02 11:52:47 -05:00
coah
9077ef8c7a data(SOBasic data 100%) (fz3j) (worker 2898f5a5) (#832) 2026-10-02 11:50:33 -05:00
coah
bc303bc36e match(NWC24MsgCommit 17/18) (fz15f) (worker a92a10dd) (#831) 2026-10-02 11:44:54 -05:00
coah
5518cb16fd match(NWC24MsgSubject 9/12, NWC24DateParser 6/8) (fz7h) (worker 5c09b5ac) (#830) 2026-10-02 11:21:02 -05:00
coah
0c06b01c8d Restore memo manager animation vtable and destructor emission for linking (#829) 2026-10-02 11:19:48 -05:00
coah
adc15fdf6f Link matched FAT directory-entry iterator (#828) 2026-10-02 11:17:41 -05:00
coah
dea64a8c9c data(tiPcKeyboard data 100%) (fz21b) (worker c70a72a8) (#827) 2026-10-02 11:10:50 -05:00
coah
3cde45682d match(pf_entry_iterator 16/16) (fz3i) (worker 03d4f3a7) (#826) 2026-10-02 11:04:54 -05:00
coah
ae7cf34cab match(iplSDChannelSelect 121/129) (fz16d) (worker df276bb6) (#825) 2026-10-02 11:03:03 -05:00
coah
91cc177cb7 ci: stop the separate README progress commit (#824)
Landings now write the README progress table inside their own commit,
so the progress job only rebuilds and publishes the numbers to the job
summary instead of pushing a second docs commit to main.
2026-10-02 10:51:22 -05:00
github-actions[bot]
ecee6f01e4 docs: update progress [skip ci] 2026-10-02 15:50:37 +00:00
coah
28d3333887 Link matched JPEG resolution-change routines (#823) 2026-10-02 10:49:57 -05:00
github-actions[bot]
2119935c1d docs: update progress [skip ci] 2026-10-02 15:48:02 +00:00
coah
c7896c3802 match(ATERM 15/26) (fz20) (worker 4adbcdd4) (#822) 2026-10-02 10:46:43 -05:00
github-actions[bot]
68c4c9aeac docs: update progress [skip ci] 2026-10-02 15:45:30 +00:00
coah
1b942565f7 match(Texture_MCUtoY8U8V8 11/13) (fz15e) (worker 2e0b96a1) (#821) 2026-10-02 10:44:28 -05:00
github-actions[bot]
a9705fa1a3 docs: update progress [skip ci] 2026-10-02 15:43:50 +00:00
coah
e1f0ef93a5 match(BS2Update 9/10) (fz1f) (worker 8d7decce) (#820) 2026-10-02 10:42:48 -05:00
github-actions[bot]
adcd8ca586 docs: update progress [skip ci] 2026-10-02 15:40:05 +00:00
coah
76d72f06ce match(idct_resolution_change_var 6/6) (fz3h) (worker ac1e42c9) (#819) 2026-10-02 10:39:11 -05:00
github-actions[bot]
b0474b6eac docs: update progress [skip ci] 2026-10-02 15:38:42 +00:00
coah
9ce28d272f match(KPAD 21/29) (fz16c) (worker a1ca8f8d) (#818) 2026-10-02 10:37:46 -05:00
github-actions[bot]
771208ab77 docs: update progress [skip ci] 2026-10-02 15:10:45 +00:00
coah
cee13c5a0b Correct SD notice APIs to accept aligned 64-bit title IDs (#817) 2026-10-02 10:10:09 -05:00
github-actions[bot]
1c974dbd49 docs: update progress [skip ci] 2026-10-02 14:53:28 +00:00
devin-ai-integration[bot]
bac1e5427a Decode iplSDChannelTitle + ut_ArchiveFontBase (source-only, stays NonMatching) (#816)
- SDButton::setEventHandler was genuinely 1-arg in retail (dead second
  param): corrected decl/def/call sites + symbols.txt mangle. Fixes 5
  fns to instruction-identical and lifts iplSDChannelTitle data to
  .data/.rodata/.sdata/.sdata2 100% (was 12.1%).
- ut_ArchiveFontBase: reordered sheetOffsetsScratch decl/assign to
  match orig materialization.

Both units remain NonMatching — flip attempts verified to break the
linked DOL: iplSDChannelTitle's object emits 51 net-extra anonymous
literal objects (pool merge/order differs, fuzzy 99.94) plus two fns
+4B each (updateCopyStart, startCopyProgress); ut_ArchiveFontBase has
a ~0x380B content region differing (fuzzy 98.47). DOL sha1 stays
26116613f624061ba99c8d1a299aaa6efa85670d with them unlinked.

Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: coah80 <usernamecole7@gmail.com>
2026-10-02 09:52:51 -05:00
github-actions[bot]
b6687e9ff9 docs: update progress [skip ci] 2026-10-02 11:41:42 +00:00
coah
ff52d5235d Restore focus-object emission order and shared pane string for native linking (#814) 2026-10-02 06:40:57 -05:00
github-actions[bot]
7be7f1594e docs: update progress [skip ci] 2026-10-02 11:34:52 +00:00
coah
51b483cbb7 Restore FAT directory definition order and link directory/volume routines (#812) 2026-10-02 06:34:15 -05:00
github-actions[bot]
1bb1fb08be docs: update progress [skip ci] 2026-10-02 11:33:16 +00:00
coah
2f759f35f1 match(iplAddress 95/101) (fz10e) (worker 3c5ccd78) (#813) 2026-10-02 06:32:21 -05:00
github-actions[bot]
ed5c96bd85 docs: update progress [skip ci] 2026-10-02 11:24:46 +00:00
coah
3816427a3e match(iplAddressEdit 90/94) (fz16b) (worker 95d2a3ab) (#811) 2026-10-02 06:23:21 -05:00
github-actions[bot]
2d0a4faa6f docs: update progress [skip ci] 2026-10-02 11:22:42 +00:00
coah
a61a7cf140 match(pf_volume 37/37, idct_resolution_change_var 5/6) (fz3g) (worker fa51267c) (#810) 2026-10-02 06:21:42 -05:00
github-actions[bot]
dce9e0732d docs: update progress [skip ci] 2026-10-02 11:20:10 +00:00
coah
8121c71188 match(Texture_MCUtoY8U8V8 6/13, NWC24MsgCommit 16/18) (fz15c) (worker c264f4a8) (#809) 2026-10-02 06:18:58 -05:00
github-actions[bot]
d6997b0cb9 docs: update progress [skip ci] 2026-10-02 11:15:33 +00:00
github-actions[bot]
6b80fd87f5 docs: update progress [skip ci] 2026-10-02 11:13:58 +00:00
coah
8f920a08c2 match(pf_dir 38/38, iplFocusObject 89/89) (fz1e) (worker db809c39) (#808) 2026-10-02 06:13:48 -05:00
coah
9c81288c55 Link matched eZiText DAWG routines (#807) 2026-10-02 06:12:34 -05:00
github-actions[bot]
abb652bb85 docs: update progress [skip ci] 2026-10-02 11:09:26 +00:00
coah
b578087994 match(Zi8MatchUWDdata; zi8uwd 3/4) (data-d11g) (worker bd9a219c) (#806) 2026-10-02 06:07:57 -05:00
github-actions[bot]
d542ace0ed docs: update progress [skip ci] 2026-10-02 11:02:05 +00:00
coah
d195c16c86 match(zi8dawg 6/6) (fz10d) (worker 64753ac9) (#805) 2026-10-02 06:00:09 -05:00
github-actions[bot]
2daa6aedf6 docs: update progress [skip ci] 2026-10-02 10:55:47 +00:00
coah
9432f36a57 Link matched NWC24 message-reading routines (#804) 2026-10-02 05:54:37 -05:00
github-actions[bot]
4f77bbd2ae docs: update progress [skip ci] 2026-10-02 10:49:20 +00:00
coah
9c6416820d match(NWC24MsgRead 16/16) (fz7e) (worker 784d9f03) (#803) 2026-10-02 05:47:59 -05:00
github-actions[bot]
4bfa1b6c4c docs: update progress [skip ci] 2026-10-02 10:40:05 +00:00
coah
cbed5f6d77 Link matched USB mass-storage block routines (#801) 2026-10-02 05:38:55 -05:00
github-actions[bot]
f8da383802 docs: update progress [skip ci] 2026-10-02 10:38:03 +00:00
coah
18786d6b7d match(ZiDAWGGetChild; zidawg1 3/6) (data-d11f) (worker 07efcb48) (#802) 2026-10-02 05:36:59 -05:00
github-actions[bot]
e7e35742dd docs: update progress [skip ci] 2026-10-02 10:33:16 +00:00
coah
73a89b06e5 match(iplAddressEdit 88/94) (fz16) (worker 41ea7122) (#800) 2026-10-02 05:32:10 -05:00
github-actions[bot]
f0d938021e docs: update progress [skip ci] 2026-10-02 10:26:08 +00:00
coah
e9545f74d5 match(NWC24MsgSubject 8/12) (fz7d) (worker 8ef4fd28) (#799) 2026-10-02 05:25:05 -05:00
github-actions[bot]
d0a9514c9b docs: update progress [skip ci] 2026-10-02 10:22:53 +00:00
github-actions[bot]
c653415d77 docs: update progress [skip ci] 2026-10-02 10:22:05 +00:00
coah
f98ffd0da3 Link matched SD channel object natively (#797) 2026-10-02 05:21:44 -05:00
coah
c31af38e0e Link matched HTTP worker and FAT cluster routines (#796) 2026-10-02 05:21:17 -05:00
github-actions[bot]
9aef037505 docs: update progress [skip ci] 2026-10-02 10:20:51 +00:00
coah
72cf3991b2 match(pf_volume 35/37, pf_entry_iterator 15/16, puh_msc_blk 11/11) (fz3f) (worker 6b7deeb0) (#798) 2026-10-02 05:19:45 -05:00
github-actions[bot]
d8937f9e82 docs: update progress [skip ci] 2026-10-02 10:12:22 +00:00
coah
36d651fe72 match(NWC24iMBoxCheck: volatile oldest-id local proven by store/reload) (orchestrator) (worker 2dcffb88) (#795) 2026-10-02 05:11:13 -05:00
github-actions[bot]
e133119aa5 docs: update progress [skip ci] 2026-10-02 10:09:35 +00:00
coah
fa50eeea1a Link matched NWC24 MIME parser natively (#794) 2026-10-02 05:08:40 -05:00
coah
ae5f904c0b Match CHANS integer parser with a read-only input object (#793) 2026-10-02 05:08:34 -05:00
github-actions[bot]
11f4b29c64 docs: update progress [skip ci] 2026-10-02 10:04:23 +00:00
coah
c7344eccc8 match(NHTTP_thread 26/26, pf_cluster 8/8) (fz8c) (worker 0b57076a) (#792) 2026-10-02 05:03:18 -05:00
github-actions[bot]
86cda2adbe docs: update progress [skip ci] 2026-10-02 10:01:15 +00:00
coah
0d1fa438ba Match HTTP socket send with a const request view and link (#790) 2026-10-02 05:00:25 -05:00
github-actions[bot]
343fa90f9b docs: update progress [skip ci] 2026-10-02 09:59:04 +00:00
coah
ed52b1987e data(ziswordw, zi8uwd data 100%) (data-d11e) (worker d8fd359e) (#791) 2026-10-02 04:57:57 -05:00
github-actions[bot]
00f44a924b docs: update progress [skip ci] 2026-10-02 09:53:45 +00:00
coah
d494f44516 match(NWC24Mime 16/16) (fz7c) (worker 112576fc) (#789) 2026-10-02 04:52:29 -05:00
github-actions[bot]
5439b99f38 docs: update progress [skip ci] 2026-10-02 09:49:58 +00:00
coah
4ccc441d7e data(iplSDChannelTitle, tiCandidateBox data 100%) (data-d15b) (worker 1e30e292) (#788) 2026-10-02 04:48:32 -05:00
github-actions[bot]
4264e5ff51 docs: update progress [skip ci] 2026-10-02 09:44:23 +00:00
coah
f182215e66 match(NHTTP_socket_RVL 9/10, lyt_window data) (fz2e) (worker 3f0262d6) (#787) 2026-10-02 04:42:46 -05:00
github-actions[bot]
fe6a45c09a docs: update progress [skip ci] 2026-10-02 09:21:35 +00:00
coah
f07dd4a6ca match(NWC24Mime 15/16) (fz7b) (worker b676b7bc) (#786) 2026-10-02 04:20:07 -05:00
github-actions[bot]
65cd387bcb docs: update progress [skip ci] 2026-10-02 09:07:11 +00:00
coah
d0c3d43000 match(vi 29/30) (fz10) (worker 2323903b) (#785) 2026-10-02 04:05:45 -05:00
github-actions[bot]
a2abf24854 docs: update progress [skip ci] 2026-10-02 09:01:43 +00:00
coah
1ce1b0458a Link matched USB access-point thread natively (#784) 2026-10-02 04:00:56 -05:00
github-actions[bot]
0e37502750 docs: update progress [skip ci] 2026-10-02 09:00:50 +00:00
coah
78d6827757 Link matched board scene natively (#783) 2026-10-02 03:58:42 -05:00
coah
b0fbec3f25 Link matched HMAC and socket-information units (#782) 2026-10-02 03:58:34 -05:00
coah
d34e09d5dc match(iplUSBAPThread 7/7, iplSDChannelObj 37/38) (fz1d) (worker bb4dde27) (#781) 2026-10-02 03:54:27 -05:00
github-actions[bot]
7cce8859c3 docs: update progress [skip ci] 2026-10-02 08:51:16 +00:00
coah
711ee737f9 match(zi8pud2 6/8; zidawg1 data 100%, structure) (data-d11d) (worker 41cd3236) (#780) 2026-10-02 03:49:46 -05:00
github-actions[bot]
82def66db6 docs: update progress [skip ci] 2026-10-02 08:49:06 +00:00
coah
2039813ccf match(iplBoard 94/94) (fz2d) (worker 0e765719) (#779) 2026-10-02 03:47:50 -05:00
github-actions[bot]
eabfb0cde9 docs: update progress [skip ci] 2026-10-02 08:47:14 +00:00
coah
2cc9824045 match(hmac 3/3, SOInformation 4/4) (fz8) (worker 4ecc5f21) (#778) 2026-10-02 03:46:04 -05:00
github-actions[bot]
6f90840464 docs: update progress [skip ci] 2026-10-02 08:45:35 +00:00
coah
0978b074b8 data(tiInputForm, tiKeyboard data 100%) (data-d4c) (worker a49df763) (#777) 2026-10-02 03:44:38 -05:00
github-actions[bot]
252e40e22f docs: update progress [skip ci] 2026-10-02 08:44:10 +00:00
coah
2230741db8 match(NWC24Mime 13/16) (fz7) (worker 3a4b90c9) (#776) 2026-10-02 03:43:07 -05:00
github-actions[bot]
f3adacfe3d docs: update progress [skip ci] 2026-10-02 08:39:36 +00:00
coah
1cd71c6903 Describe existing MetroTRK trap entries as sized functions (#775) 2026-10-02 03:38:51 -05:00
github-actions[bot]
7b64914abb docs: update progress [skip ci] 2026-10-02 08:23:28 +00:00
devin-ai-integration[bot]
199de6f6c0 Link bannerSound/AxAdpcmPlayer (clean subset) (#774)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: coah80 <usernamecole7@gmail.com>
2026-10-02 03:22:37 -05:00
github-actions[bot]
513c2a869e docs: update progress [skip ci] 2026-10-02 08:07:20 +00:00
coah
24b6645572 match(SOOption 3/4, pf_volume 34/37) (fz3c) (worker f024666b) (#773) 2026-10-02 03:06:10 -05:00
github-actions[bot]
9536177edd docs: update progress [skip ci] 2026-10-02 08:01:44 +00:00
coah
81325e667c Restore SDK path function emission order and native linking (#772) 2026-10-02 03:00:54 -05:00
coah
51d5dc519b Refresh completion code total after removing overlapping extent (#771) 2026-10-02 02:57:20 -05:00
github-actions[bot]
b84b3c0d57 docs: update progress [skip ci] 2026-10-02 07:45:02 +00:00
coah
950bb0dda6 match(NHTTP_socket_RVL 8/10) (fz2c) (worker d651d6ad) (#770) 2026-10-02 02:43:25 -05:00
github-actions[bot]
de05797e19 docs: update progress [skip ci] 2026-10-02 07:43:17 +00:00
coah
c70816c7e1 match(PFPATH_MatchFileNameWithPattern: fix overlapping symbol extent) (orchestrator) (worker 5f027758) (#769) 2026-10-02 02:40:46 -05:00
github-actions[bot]
1d290fa12a docs: update progress [skip ci] 2026-10-02 07:33:40 +00:00
coah
6547b1fa10 Link memo input form natively after exact data restoration (#768) 2026-10-02 02:32:54 -05:00
github-actions[bot]
3bdb663f09 docs: update progress [skip ci] 2026-10-02 07:28:48 +00:00
coah
8120309670 Link matched SDK FAT12 and file units natively (#767) 2026-10-02 02:27:48 -05:00
github-actions[bot]
a4c84cbf53 docs: update progress [skip ci] 2026-10-02 07:25:52 +00:00
coah
6ebe56bc04 Emit GCWindow interpolation constructor in native order and link (#765) 2026-10-02 02:24:55 -05:00
github-actions[bot]
69c235ffc2 docs: update progress [skip ci] 2026-10-02 07:23:27 +00:00
coah
767f393bf9 data(iplESMisc data 100%), match(NHTTP_stdlib_RVL 11/14, data 100%) (near8g) (worker 2fc43755) (#766) 2026-10-02 02:22:15 -05:00
github-actions[bot]
6368cc44e9 docs: update progress [skip ci] 2026-10-02 07:20:46 +00:00
coah
7deffd048c data(MyTiInputForm data 100%, tiInputForm/MyTiManager data up) (data-d4b) (worker 4e1959af) (#764) 2026-10-02 02:19:33 -05:00
github-actions[bot]
4aaa362c5e docs: update progress [skip ci] 2026-10-02 07:14:34 +00:00
coah
5fe0a61af7 Initialize KPR callbacks explicitly and enable native linking (#762) 2026-10-02 02:13:46 -05:00
github-actions[bot]
dbf6a1256e docs: update progress [skip ci] 2026-10-02 07:13:27 +00:00
coah
c6c0b145f8 match(pf_fat12 4/4) (fz3b) (worker 18afdc56) (#763) 2026-10-02 02:12:31 -05:00
github-actions[bot]
b38c5653df docs: update progress [skip ci] 2026-10-02 07:11:00 +00:00
coah
d9cf3598fc match(iplMemoryCardManager 18/26) (near9f) (worker 05f3938f) (#761) 2026-10-02 02:09:55 -05:00
coah
c44fbd7209 match(pf_file 45/45) (fz2b) (worker 26c4b368) (#760) 2026-10-02 02:07:43 -05:00
coah
f78a686e32 Correct AOSS allocation callback symbol signatures (#759) 2026-10-02 02:05:41 -05:00
coah
c9fb0697ca tools: audit literal values at corresponding PPC calls (#758) 2026-10-02 01:59:04 -05:00
github-actions[bot]
11df09974b docs: update progress [skip ci] 2026-10-02 06:57:45 +00:00
coah
a3b27c9ed0 match(puh_msc_blk 10/11; pf_fat12, iqdec fuzzy up) (fz3) (worker 6651d7cf) (#757) 2026-10-02 01:56:45 -05:00
github-actions[bot]
91fd1dcb69 docs: update progress [skip ci] 2026-10-02 06:55:24 +00:00
coah
b02273897c fuzzy(zidawg1, zi8pud2, ziswordw structure; ziswordw data) (data-d11b) (worker 9a700863) (#756) 2026-10-02 01:54:31 -05:00
github-actions[bot]
249c129e67 docs: update progress [skip ci] 2026-10-02 06:53:24 +00:00
coah
9ef60d674d match(iplGCWindow 48/48, NWC24MBoxCtrl data 100%) (fz4) (worker 715d7be2) (#755) 2026-10-02 01:52:29 -05:00
github-actions[bot]
aa677ad520 docs: update progress [skip ci] 2026-10-02 06:47:56 +00:00
coah
cbf6363d0f match(kpr_lib 9/9, zconvert 3/4) (fz2) (worker 7208e236) (#754) 2026-10-02 01:46:58 -05:00
github-actions[bot]
c4857800df docs: update progress [skip ci] 2026-10-02 06:33:14 +00:00
coah
0dd0a6941a data(iplSDChannelSelect, iplChannelSelect, wad, NHTTP_thread data 100%) (data-d5c) (worker a2bc7e81) (#753) 2026-10-02 01:32:21 -05:00
github-actions[bot]
422a344b28 docs: update progress [skip ci] 2026-10-02 06:29:37 +00:00
coah
5543b7b720 data(tiTextDrawer data 100%) (data-d14) (worker 6757043c) (#752) 2026-10-02 01:28:42 -05:00
github-actions[bot]
5d63d15248 docs: update progress [skip ci] 2026-10-02 06:27:05 +00:00
coah
2f0f5a44c7 data(zi8alpha data 180->516) (data-d13) (worker 5c2aec13) (#751) 2026-10-02 01:26:05 -05:00
github-actions[bot]
08923eda6c docs: update progress [skip ci] 2026-10-02 06:17:06 +00:00
coah
0c94076d99 data(NHTTP_thread data 88->304) (data-d5b) (worker b909c94b) (#750) 2026-10-02 01:16:02 -05:00
github-actions[bot]
0695760312 docs: update progress [skip ci] 2026-10-02 06:15:45 +00:00
coah
b3c23834a7 data(iplAddressEdit, iplAddress, WPADHIDParser, iplBoardObject data 100%) (data-d7b) (worker 364037a2) (#749) 2026-10-02 01:14:46 -05:00
coah
b145a74db1 data(tiHwKeyboard, sha1, nettime data 100%) (data-d12) (worker b6f9650f) (#748) 2026-10-02 01:13:29 -05:00
github-actions[bot]
b941fc6268 docs: update progress [skip ci] 2026-10-02 06:11:34 +00:00
coah
d5cd4ca777 data(RFL MiddleDatabase/MakeTex/DataUtility/NWC24 data 100%) (data-d10b) (worker 65d1c6de) (#747) 2026-10-02 01:10:19 -05:00
github-actions[bot]
5b7fb6f968 docs: update progress [skip ci] 2026-10-02 06:07:04 +00:00
coah
6fa90e5574 Link the verified native AXFXChorusExp unit (#746) 2026-10-02 01:06:03 -05:00
github-actions[bot]
9702056bda docs: update progress [skip ci] 2026-10-02 06:04:52 +00:00
coah
dc40dd44bb data(RFL Database/HiddenDatabase/NANDLoader/Model data 100%) (data-d9) (worker ba614360) (#745) 2026-10-02 01:03:37 -05:00
github-actions[bot]
32f358cd65 docs: update progress [skip ci] 2026-10-02 06:01:45 +00:00
coah
0cc4c57ecd data(NHTTP_os_RVL, iplDate data 100%, ATERM +80) (data-d3b) (worker 385ef001) (#744) 2026-10-02 01:00:51 -05:00
coah
a1d6b7d930 Correct fixed-width candidate pane-name record boundaries (#742) 2026-10-02 00:57:56 -05:00
github-actions[bot]
18e8dd2d07 docs: update progress [skip ci] 2026-10-02 05:56:49 +00:00
coah
09d3f9beef data(iplController, d_nhttp, iplKeyboard data 100%) (data-d1c) (worker 154fb6cd) (#743) 2026-10-02 00:55:55 -05:00
github-actions[bot]
41adc87d89 docs: update progress [skip ci] 2026-10-02 05:54:16 +00:00
coah
d2ef39c441 data(sd_drv, www_surface, iplFocusObject data 100%) (data-d6b) (worker 85303ada) (#741) 2026-10-02 00:52:57 -05:00
github-actions[bot]
1296031075 docs: update progress [skip ci] 2026-10-02 05:46:15 +00:00
coah
775167f4a5 Link the verified native NUP HTTP unit (#740) 2026-10-02 00:45:17 -05:00
github-actions[bot]
547637bf79 docs: update progress [skip ci] 2026-10-02 05:43:38 +00:00
coah
2b1e29a746 data(iplKeyboard data 1176/1184) (data-d1b) (worker 9e9e6cc1) (#739) 2026-10-02 00:42:44 -05:00
github-actions[bot]
394f6c2444 docs: update progress [skip ci] 2026-10-02 05:41:38 +00:00
coah
35e7147b97 data(iplUSBAP, AOSS data 100%, iplSetting +640, ATERM sbss) (data-d3) (worker ef0da9b3) (#738) 2026-10-02 00:40:50 -05:00
github-actions[bot]
ed3fad1bff docs: update progress [skip ci] 2026-10-02 05:38:15 +00:00
coah
f72e4281a8 match(AXFXChorusExp 7/7) (near7f) (worker f241c3a9) (#737) 2026-10-02 00:37:19 -05:00
github-actions[bot]
f6fd278076 docs: update progress [skip ci] 2026-10-02 05:34:04 +00:00
coah
4b25950eeb data(iplGCWindow, iplSDMemory data 100%) (data-d5) (worker a506aca5) (#736) 2026-10-02 00:32:51 -05:00
coah
dc5d3cf81b Use the implicit HKBManager destructor and link native C++ (#734) 2026-10-02 00:32:38 -05:00
github-actions[bot]
d54e4ba47a docs: update progress [skip ci] 2026-10-02 05:31:35 +00:00
coah
3f330a39ea data(sd_drv data 408->1016) (data-d6) (worker 7268acb9) (#735) 2026-10-02 00:30:26 -05:00
github-actions[bot]
85701c828f docs: update progress [skip ci] 2026-10-02 05:27:56 +00:00
coah
f37268de4f data(BS2Update, iplSound, AOSSLink, iplRakuRakuThread data 100%) (data-d2) (worker 1146ea35) (#733) 2026-10-02 00:26:43 -05:00
github-actions[bot]
26afef0d00 docs: update progress [skip ci] 2026-10-02 05:25:02 +00:00
coah
ecd5e498b5 match(iplMemoryCardManager 17/26) (near9d) (worker ef0188be) (#732) 2026-10-02 00:24:04 -05:00
coah
68e1ee3a35 Restore two original CDB record diagnostic messages (#731) 2026-10-02 00:22:41 -05:00
github-actions[bot]
bcb2ac0e37 docs: update progress [skip ci] 2026-10-02 05:21:18 +00:00
coah
00ff6ea6a0 data(OSUtf 48704/48704 data, iplKeyboard 31/32) (data-d1) (worker c9656d2b) (#730) 2026-10-02 00:20:11 -05:00
github-actions[bot]
eadb516be8 docs: update progress [skip ci] 2026-10-02 05:18:56 +00:00
coah
e3be21cd6c match(nup_nhttp 9/9) (near8e) (worker 6e28d64b) (#729) 2026-10-02 00:18:07 -05:00
coah
9eb08c48a7 Restore the original decide sound in address-book click handling (#727) 2026-10-02 00:16:06 -05:00
github-actions[bot]
456e9dbd2e docs: update progress [skip ci] 2026-10-02 05:15:36 +00:00
coah
4d08c3005b match(tiHKBManager 29/29) (near6i) (worker ba6dfd2a) (#728) 2026-10-02 00:14:31 -05:00
coah
a16c5191f0 Fix the waiting pane references in settings visibility calls (#726) 2026-10-02 00:13:43 -05:00
coah
eecf16f01e Extend memo Manager vtable through its proven final virtual slot (#725) 2026-10-02 00:02:01 -05:00
github-actions[bot]
73f5b332e2 docs: update progress [skip ci] 2026-10-02 04:55:57 +00:00
coah
3d97a4040f Prevent false pointer relocation in the SDK CP932 scalar table (#724) 2026-10-01 23:55:19 -05:00
coah
0b623f581b Restore memo destructor definitions; defer unresolved data linking (#714) 2026-10-01 23:47:34 -05:00
github-actions[bot]
f4e539191d docs: update progress [skip ci] 2026-10-02 04:46:16 +00:00
coah
cb0716f7a5 match(pf_path 26/27) (near6g) (worker 8270df04) (#723) 2026-10-01 23:45:27 -05:00
github-actions[bot]
d47d308721 docs: update progress [skip ci] 2026-10-02 04:45:10 +00:00
coah
1bf9ae4569 match(tiPcKeyboard 140/141, AXFXChorusExp 6/7, aes 7/9) (near7d) (worker 348bb89e) (#722) 2026-10-01 23:44:15 -05:00
github-actions[bot]
bab82c12dd docs: update progress [skip ci] 2026-10-02 04:40:19 +00:00
coah
ccca706770 Match and link USBAP registration; correct thread sbss ownership (#721) 2026-10-01 23:39:26 -05:00
github-actions[bot]
a9833b51a2 docs: update progress [skip ci] 2026-10-02 04:26:00 +00:00
coah
76d8500dcf Repair two reconstructed function symbol names (#720) 2026-10-01 23:25:16 -05:00
github-actions[bot]
184bee0173 docs: update progress [skip ci] 2026-10-02 03:54:08 +00:00
coah
368a86cc6c match(nup_nhttp): 6 -> 8 exact (near8c) (worker 9dbfc514) (#719) 2026-10-01 22:53:23 -05:00
github-actions[bot]
9a7da62d3a docs: update progress [skip ci] 2026-10-02 03:47:25 +00:00
coah
b3c1300392 match(iplSDChannelTitle 64/69, NHTTP_recvbuf 6/7) (worker c82a056b) (#718) 2026-10-01 22:46:49 -05:00
coah
bd762fd162 docs(agents): add orchestrator handoff section (tools, state, pickup steps) (#717) 2026-10-01 22:44:50 -05:00
github-actions[bot]
f18d945894 docs: update progress [skip ci] 2026-10-02 03:02:34 +00:00
coah
bc505c3b8a Restore sensitivity projection constant pool and link source (#716) 2026-10-01 21:49:43 -05:00
coah
a5f79b81fa Correct memo Manager title setter vtable target (#715) 2026-10-01 21:35:19 -05:00
github-actions[bot]
137edaff42 docs: update progress [skip ci] 2026-10-02 01:58:17 +00:00
coah
4a7353ec73 Restore sound globals and link iplSound (#713) 2026-10-01 20:57:25 -05:00
coah
618e713b53 docs(agents): describe the Claude orchestrator / Codex worker loop (#711)
Effort scale, silent mode for workers, gate and landing rules, the PR
review daemon and auto-merge conditions, single-orchestrator rule, and
the policy additions (no retail .s linking, definition-level volatile).
2026-10-01 20:56:59 -05:00
github-actions[bot]
3dcd723459 docs: update progress [skip ci] 2026-10-02 01:55:54 +00:00
coah
4ed63ff786 match(tiHKBManager): key validity (worker 4e3e9738) (#712) 2026-10-01 20:54:55 -05:00
coah
eb8b9b978d Discover compiler-named and custom jump tables (#710) 2026-10-01 20:29:36 -05:00
github-actions[bot]
10e3f47e64 docs: update progress [skip ci] 2026-10-02 01:19:23 +00:00
coah
006457008c match(pf_fat): fsinfo byte order and sector rounding, 34/35 (worker 4129772d) (#709) 2026-10-01 20:18:35 -05:00
github-actions[bot]
75677c746b docs: update progress [skip ci] 2026-10-02 01:16:28 +00:00
coah
ccbc04a997 match(NHTTP_stdlib_RVL): hex/decimal parsing, 10/14 (worker 8531a6bf) (#708) 2026-10-01 20:15:19 -05:00
coah
da35a476bf Decompile sound effect stopping with a void return (#707) 2026-10-01 20:12:48 -05:00
coah
589bee2b0d Decompile system sound initialization (#706) 2026-10-01 20:07:38 -05:00
github-actions[bot]
f36411d483 docs: update progress [skip ci] 2026-10-02 01:03:37 +00:00
coah
9a897b043b match(pdm_partition): partition sector conversion, 18/20 (worker a5353c91) (#705) 2026-10-01 20:02:35 -05:00
coah
4d828ed557 Generate hardware keyboard vtable from C++ declarations (#704) 2026-10-01 19:59:33 -05:00
coah
f479546211 Decompile hardware keyboard character conversion (#703) 2026-10-01 19:54:11 -05:00
github-actions[bot]
a6c7690eb0 docs: update progress [skip ci] 2026-10-02 00:52:09 +00:00
coah
54b82eb747 Decompile hardware keyboard input dispatch (#701) 2026-10-01 19:51:53 -05:00
coah
326273b619 match(NHTTP_recvbuf): NHTTPi_RecvBufN (#559)
* match(NHTTP_recvbuf): NHTTPi_RecvBufN

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

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

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

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

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

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

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

DOL sha1 unchanged.
2026-10-01 18:55:06 -05:00
coah
fbecedd948 cleanup(sdi_api): rename __sdCbArg.unk_0x0C to cmd (#672)
Field is assigned the SD command and switched on in __sdCb.
2026-10-01 18:52:58 -05:00
288 changed files with 76456 additions and 5215 deletions

View File

@@ -2,6 +2,8 @@ name: README progress
# runs on the self-hosted runner on cole's server so it doesn't use hosted minutes.
# only push/schedule/manual triggers, never pull_request, so fork PRs can't reach this machine.
# README progress is written inside each landing commit by the orchestrator, so this job never commits;
# it only rebuilds and publishes the current numbers to the job summary.
on:
push:
branches: [main]
@@ -15,7 +17,7 @@ concurrency:
cancel-in-progress: true
permissions:
contents: write
contents: read
jobs:
progress:
@@ -48,15 +50,8 @@ jobs:
- name: Report
run: build/tools/objdiff-cli report generate -p . -o build/43U/report.json -f json
- name: Update README
run: python3 tools/update_readme_progress.py build/43U/report.json README.md "$GITHUB_SHA"
- name: Commit
- name: Summary
run: |
if git diff --quiet README.md; then exit 0; fi
git config user.name "github-actions[bot]"
git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
git add README.md
git commit -m "docs: update progress [skip ci]"
git pull --rebase origin main || { git rebase --abort; echo "main moved, next run will update"; exit 0; }
git push origin HEAD:main
python3 tools/update_readme_progress.py build/43U/report.json README.md "$GITHUB_SHA"
sed -n '/progress:start/,/progress:end/p' README.md >> "$GITHUB_STEP_SUMMARY"
git checkout -- README.md

170
AGENTS.md
View File

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

View File

@@ -53,9 +53,9 @@ Progress
<!-- progress:start -->
| Decompiled | Matched | Linked | Data |
|:---:|:---:|:---:|:---:|
| 99.38% | 88.00% | 62.37% | 92.07% |
| 99.59% | 90.94% | 73.37% | 99.37% |
units 920/1027 complete, functions 12226/12563 matched.
units 960/1027 complete, functions 12369/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

@@ -11,6 +11,8 @@ splits: 'config/43U/splits.txt'
ldscript_template: 'config/ldscript_ipl2.lcf'
force_active:
- SOGetSockOpt
- SOSetInterfaceOpt
- fprintf
- leap_days
- __msl_time2tm

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
@@ -869,11 +869,12 @@ src/scene/setting/iplUSBAP.cpp:
.bss start:0x810BC148 end:0x810BD498
.text start:0x813FC520 end:0x813FC8FC
.data start:0x81657B08 end:0x81657B18
.sbss start:0x81698C08 end:0x81698C28
.sbss start:0x81698C08 end:0x81698C20
src/scene/setting/iplUSBAPThread.cpp:
.text start:0x813FC8FC end:0x813FCA0C
.data start:0x81657B18 end:0x81657B60
.sbss start:0x81698C20 end:0x81698C28
src/scene/setting/iplAOSSThread.cpp:
.bss start:0x810BD498 end:0x810BD4A8
@@ -3551,12 +3552,12 @@ libs/RVL_SDK/src/bte/l2c_csm.c:
libs/RVL_SDK/src/bte/l2c_link.c:
.text start:0x815AC630 end:0x815AD7BC
.data start:0x8168E930 end:0x8168EB68
.data start:0x8168E930 end:0x8168EBA0
libs/RVL_SDK/src/bte/l2c_main.c:
.bss start:0x811725E0 end:0x81172DC8
.text start:0x815AD7BC end:0x815AE7EC
.data start:0x8168EB68 end:0x8168EEA0
.data start:0x8168EBA0 end:0x8168EEA0
libs/RVL_SDK/src/bte/l2c_utils.c:
.text start:0x815AE7EC end:0x815B06B0

File diff suppressed because it is too large Load Diff

View File

@@ -689,7 +689,7 @@ config.libs = [
]
),
IPLSection("sound", [
Object(NonMatching, "sound/iplSound.cpp"),
Object(Matching, "sound/iplSound.cpp"),
]
),
IPLSection("iplwww", [
@@ -738,11 +738,11 @@ config.libs = [
]
),
IPLSection("board", [
Object(Equivalent, "scene/board/iplBoard.cpp"),
Object(Matching, "scene/board/iplBoard.cpp"),
Object(Matching, "scene/board/iplBoardObject.cpp"),
Object(Matching, "scene/board/iplBoardSD.cpp"),
Object(Matching, "scene/board/iplUrlProcessor.cpp"),
Object(Equivalent, "scene/board/iplFocusObject.cpp"),
Object(Matching, "scene/board/iplFocusObject.cpp"),
]
),
IPLSection("button", [
@@ -766,13 +766,13 @@ config.libs = [
]
),
IPLSection("channelSelect", [
Object(Equivalent, "scene/channelSelect/iplChannelSelect.cpp"),
Object(Matching, "scene/channelSelect/iplChannelSelect.cpp"),
Object(Matching, "scene/channelSelect/iplClock.cpp"),
Object(Equivalent, "scene/channelSelect/iplChannelObj.cpp"),
]
),
IPLSection("channelTitle", [
Object(Equivalent, "scene/channelTitle/iplChannelTitle.cpp"),
Object(Matching, "scene/channelTitle/iplChannelTitle.cpp"),
]
),
IPLSection("faceSelect", [
@@ -816,7 +816,7 @@ config.libs = [
Object(Matching, "scene/memoryCard/iplMemoryCardBase.cpp"),
Object(NonMatching, "scene/memoryCard/iplMemoryCardManager.cpp"),
Object(Matching, "scene/memoryCard/iplGCSaveData.cpp"),
Object(NonMatching, "scene/memoryCard/iplGCWindow.cpp"),
Object(Matching, "scene/memoryCard/iplGCWindow.cpp"),
]
),
IPLSection("textBalloon", [
@@ -850,7 +850,7 @@ config.libs = [
),
IPLSection("sdChannelSelect", [
Object(NonMatching, "scene/sdChannelSelect/iplSDChannelSelect.cpp"),
Object(NonMatching, "scene/sdChannelSelect/iplSDChannelObj.cpp"),
Object(Matching, "scene/sdChannelSelect/iplSDChannelObj.cpp"),
]
),
IPLSection("sdChannelTitle", [
@@ -869,15 +869,15 @@ config.libs = [
),
IPLSection("setting", [
Object(NonMatching, "scene/setting/iplSetting.cpp"),
Object(NonMatching, "scene/setting/iplSensitivity.cpp"),
Object(Matching, "scene/setting/iplSensitivity.cpp"),
Object(Matching, "scene/setting/iplNCDSetting.cpp"),
Object(Matching, "scene/setting/iplParental.cpp"),
Object(Matching, "scene/setting/iplAPScanThread.cpp"),
Object(NonMatching, "scene/setting/iplUSBAP.cpp"),
Object(NonMatching, "scene/setting/iplUSBAPThread.cpp"),
Object(Matching, "scene/setting/iplUSBAP.cpp"),
Object(Matching, "scene/setting/iplUSBAPThread.cpp"),
Object(Matching, "scene/setting/iplAOSSThread.cpp"),
Object(NonMatching, "scene/setting/AOSSLink.c"),
Object(NonMatching, "scene/setting/iplRakuRakuThread.cpp"),
Object(Matching, "scene/setting/iplRakuRakuThread.cpp"),
Object(NonMatching, "scene/setting/AOSS.c", extra_cflags=["-O4,p", "-inline off"]),
Object(NonMatching, "scene/setting/ATERM.c", extra_cflags=["-O4,p", "-inline off"]),
]
@@ -901,7 +901,7 @@ config.libs = [
),
IPLSection("bannerSound", [
Object(Matching, "bannerSound/AudioWavePlayer.cpp"),
Object(Equivalent, "bannerSound/AxAdpcmPlayer.cpp"),
Object(Matching, "bannerSound/AxAdpcmPlayer.cpp"),
Object(Matching, "bannerSound/BannerSoundPlayer.cpp"),
Object(Matching, "bannerSound/AudioWaveUtility.cpp"),
]
@@ -927,14 +927,14 @@ config.libs = [
Object(Matching, "keyboard/tiPkData.cpp", extra_cflags=["-O4,p"], shift_jis=False),
Object(Matching, "keyboard/tiLanguageIndependentData.cpp", extra_cflags=["-O4,p"], shift_jis=False),
Object(Matching, "keyboard/tiTextInputBase.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/MyTiManager.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/MyTiInputForm.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/MyTiManager.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/MyTiInputForm.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/MyTiLetterForm.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/MyTiBg.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiDebug.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiGUIManager.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiHKBManager.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiHwKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiHKBManager.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiHwKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiLayout.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiLayoutGather.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiKoreanInput.cpp", extra_cflags=["-O4,p"]), # for 4.3K
@@ -989,7 +989,7 @@ config.libs = [
Object(NonMatching, "clib/zi8cgetc.c"),
Object(Matching, "clib/zi8cinfo.c"),
Object(Matching, "clib/zi8copy.c"),
Object(NonMatching, "clib/zi8dawg.c"),
Object(Matching, "clib/zi8dawg.c"),
Object(Matching, "clib/zi8getc.c"),
Object(NonMatching, "clib/zi8getc2.c"),
Object(Matching, "clib/zi8getSW.c"),
@@ -1005,7 +1005,7 @@ config.libs = [
Object(Matching, "clib/zi8ZHuwd.c"),
Object(NonMatching, "clib/zidawg1.c"),
Object(Matching, "clib/zikorean.c"),
Object(NonMatching, "clib/ziswordw.c"),
Object(Matching, "clib/ziswordw.c"),
Object(NonMatching, "clib/zkokeyp.c"),
Object(Matching, "clib/zierror.c"),
Object(NonMatching, "clib/zmtkey.c"),
@@ -1045,7 +1045,7 @@ config.libs = [
Object(Matching, "net/crc.c"),
Object(NonMatching, "net/md5.c"),
Object(Matching, "net/sha1.c"),
Object(NonMatching, "net/hmac.c"),
Object(Matching, "net/hmac.c"),
Object(Matching, "net/neterrorcode.c"),
Object(Matching, "net/NETVersion.c"),
Object(NonMatching, "net/aes.c"),
@@ -1060,9 +1060,9 @@ config.libs = [
Object(NonMatching, "nhttp/NHTTP_recvbuf.c"),
Object(Matching, "nhttp/NHTTP_request.c"),
Object(Matching, "nhttp/NHTTP_response.c"),
Object(NonMatching, "nhttp/NHTTP_socket_RVL.c"),
Object(Matching, "nhttp/NHTTP_socket_RVL.c"),
Object(NonMatching, "nhttp/NHTTP_stdlib_RVL.c"),
Object(NonMatching, "nhttp/NHTTP_thread.c"),
Object(Matching, "nhttp/NHTTP_thread.c"),
Object(Matching, "nhttp/d_nhttp_private.c"),
Object(Matching, "nhttp/d_nhttp.c"),
Object(Matching, "nhttp/d_nhttp_common.c"),
@@ -1075,12 +1075,12 @@ config.libs = [
Object(Matching, "nwc24/NWC24Utils.c"),
Object(Matching, "nwc24/NWC24Manage.c"),
Object(Matching, "nwc24/NWC24MsgObj.c"),
Object(NonMatching, "nwc24/NWC24MBoxCtrl.c"),
Object(NonMatching, "nwc24/NWC24Mime.c"),
Object(Matching, "nwc24/NWC24MBoxCtrl.c"),
Object(Matching, "nwc24/NWC24Mime.c"),
Object(Matching, "nwc24/NWC24Stream.c"),
Object(Matching, "nwc24/NWC24Parser.c"),
Object(NonMatching, "nwc24/NWC24MsgCommit.c"),
Object(NonMatching, "nwc24/NWC24MsgRead.c"),
Object(Matching, "nwc24/NWC24MsgCommit.c"),
Object(Matching, "nwc24/NWC24MsgRead.c"),
Object(NonMatching, "nwc24/NWC24MsgSubject.c"),
Object(Matching, "nwc24/NWC24Schedule.c"),
Object(NonMatching, "nwc24/NWC24DateParser.c"),
@@ -1097,8 +1097,8 @@ config.libs = [
RevoEXLib("so", [
Object(Matching, "so/SOCommon.c"),
Object(NonMatching, "so/SOBasic.c"),
Object(NonMatching, "so/SOInformation.c"),
Object(NonMatching, "so/SOOption.c"),
Object(Matching, "so/SOInformation.c"),
Object(Matching, "so/SOOption.c"),
]
),
RevoEXLib("ssl", [
@@ -1212,7 +1212,7 @@ config.libs = [
Object(NonMatching, "exif/exif_parse.c"),
Object(Matching, "reschange/iqdec_resolution_change_a3.c"),
Object(NonMatching, "reschange/idct_resolution_change_var.c"),
Object(Matching, "reschange/idct_resolution_change_var.c"),
Object(NonMatching, "texturecvtr/Texture_MCUtoY8U8V8.c"),
Object(NonMatching, "texturecvtr/Texture_MCUtoRGB565.c"),
@@ -1453,7 +1453,7 @@ config.libs = [
Object(Matching, "axfx/AXFXReverbStd.c"),
Object(Matching, "axfx/AXFXReverbStdExp.c"),
Object(Matching, "axfx/AXFXChorus.c"),
Object(NonMatching, "axfx/AXFXChorusExp.c"),
Object(Matching, "axfx/AXFXChorusExp.c"),
Object(Matching, "axfx/AXFXLfoTable.c"),
Object(Matching, "axfx/AXFXSrcCoef.c"),
Object(Matching, "axfx/AXFXHooks.c"),
@@ -1692,19 +1692,19 @@ config.libs = [
Object(Matching, "fa/pdm_disk.c"),
Object(NonMatching, "fa/pdm_partition.c"),
Object(NonMatching, "fa/pf_cache.c"),
Object(NonMatching, "fa/pf_cluster.c"),
Object(NonMatching, "fa/pf_dir.c"),
Object(Matching, "fa/pf_cluster.c"),
Object(Matching, "fa/pf_dir.c"),
Object(Matching, "fa/pf_entry.c"),
Object(NonMatching, "fa/pf_entry_iterator.c"),
Object(NonMatching, "fa/pf_fat.c"),
Object(NonMatching, "fa/pf_fat12.c"),
Object(Matching, "fa/pf_entry_iterator.c"),
Object(Matching, "fa/pf_fat.c"),
Object(Matching, "fa/pf_fat12.c"),
Object(Matching, "fa/pf_fat16.c"),
Object(Matching, "fa/pf_fat32.c"),
Object(Matching, "fa/pf_fatfs.c"),
Object(NonMatching, "fa/pf_file.c"),
Object(NonMatching, "fa/pf_path.c"),
Object(Matching, "fa/pf_file.c"),
Object(Matching, "fa/pf_path.c"),
Object(Matching, "fa/pf_sector.c"),
Object(NonMatching, "fa/pf_volume.c"),
Object(Matching, "fa/pf_volume.c"),
Object(Matching, "fa/pf_volume_apiadd.c"),
Object(Matching, "fa/pf_cp932.c"),
Object(Matching, "fa/pf_api_util.c"),
@@ -1860,7 +1860,7 @@ config.libs = [
Object(Matching, "fa/msc/puh_msc.c"),
Object(Matching, "fa/msc/puh_msc_cmd.c"),
Object(NonMatching, "fa/msc/puh_msc_blk.c"),
Object(Matching, "fa/msc/puh_msc_blk.c"),
]
),
RVLSDKLib("sdi", [
@@ -1869,7 +1869,7 @@ config.libs = [
),
RVLSDKLib("nup", [
Object(NonMatching, "nup/nup.cpp"),
Object(NonMatching, "nup/nup_nhttp.cpp"),
Object(Matching, "nup/nup_nhttp.cpp"),
Object(Matching, "nup/nup_mem.cpp"),
]
),
@@ -1892,7 +1892,7 @@ config.libs = [
]
),
RVLSDKLib("kpr", [
Object(NonMatching, "kpr/kpr_lib.c"),
Object(Matching, "kpr/kpr_lib.c"),
]
),
RVLSDKLib("usbkbd", [

View File

@@ -43,7 +43,7 @@ private:
bool mIsPlaying; // 0xB2
bool mIsSetBuf; // 0xB3
bool mThreadRunning; // 0xB4
bool unk_0xB5; // 0xB5
bool mbFillInCallback; // 0xB5
WaveFileAiff mAiff; // 0xB8
WaveFileWav mWav; // 0xE8

View File

@@ -16,12 +16,12 @@ public:
AXVPB* getAXVPB() { return mpVPB; }
u32 getState() { return mState; }
u32 getUnk_0x08() { return unk_0x08; }
int getUnk_0x0C() { return unk_0x0C; }
int getUpdateFlag() { return mUpdateFlag; }
void setAXVPB(AXVPB* newVal) { mpVPB = newVal; }
void setState(u32 newVal) { mState = newVal; }
void setUnk_0x08(u32 newVal) { unk_0x08 = newVal; }
void setUnk_0x0C(u32 newVal) { unk_0x0C = newVal; }
void setUpdateFlag(u32 newVal) { mUpdateFlag = newVal; }
AXPBMIX* getMix() { return &mMix; }
@@ -31,7 +31,7 @@ private:
AXVPB* mpVPB; // 0x00
u32 mState; // 0x04
u32 unk_0x08; // 0x08
int unk_0x0C; // 0x0c
int mUpdateFlag; // 0x0c
AXPBMIX mMix; // 0x10
};

View File

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

View File

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

View File

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

View File

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

View File

@@ -113,6 +113,8 @@ namespace textinput {
#ifdef TIMANAGER_IMPLEMENTATION
virtual void setTitleText(wchar_t* titleText);
void initAspect();
#elif defined(MYTIMANAGER_IMPLEMENTATION)
virtual void setTitleText(wchar_t* titleText);
#else
virtual void setTitleText(const wchar_t* titleText);
#endif

View File

@@ -197,6 +197,7 @@ namespace textinput {
bool mbMaintainCursorCache;
#elif defined(MYTIINPUTFORM_IMPLEMENTATION)
protected:
void setDrawScrollY(const f32& scroll) { mfDrawScrollY = scroll; }
u8 mDrawState[0x27];
f32 mfDrawScrollY;
u8 mDrawCacheState[0x14];

View File

@@ -55,7 +55,7 @@ namespace textinput {
public:
Animation() : mfAnimationTime(0.0f), mbInAnimation(false), mbSE(false), mpAnimObserver(NULL) {}
#ifdef TIINPUTFORM_IMPLEMENTATION
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(MYTIMANAGER_IMPLEMENTATION)
virtual void startAnm(f32 start, f32 end, f32 duration, AnimObserver* observer, void* data);
#else
virtual void startAnm(AnimObserver*, f32, f32, f32, void*);

View File

@@ -34,14 +34,14 @@ namespace gui {
virtual void draw(Mtx& mtx) {} // 0x14 (0x05)
virtual void draw() {} // 0x18 (0x06)
#if defined(IPL_CHANNEL_TITLE_NOVTABLE) || defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
#if defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
virtual ~Interface(); // 0x1C (0x07)
#else
virtual ~Interface() {} // 0x1C (0x07)
#endif
};
#if defined(IPL_CHANNEL_TITLE_NOVTABLE) || defined(IPL_GC_WINDOW_NOVTABLE) || defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
#if defined(IPL_GC_WINDOW_NOVTABLE) || defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
class __declspec(novtable) EventHandler {
#else
class EventHandler {

View File

@@ -24,7 +24,7 @@ namespace ipl {
mbDisableCon(bDisableCon) {}
#endif
#if defined(IPL_CHANNEL_TITLE_NOVTABLE) || defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
#if defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
virtual ~PaneManager();
#else
virtual ~PaneManager() {}

View File

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

View File

@@ -143,7 +143,11 @@ namespace ipl {
#else
VEC3 operator-(const VEC3& rhs) const { return VEC3(x - rhs.x, y - rhs.y, z - rhs.z); }
#endif
#ifdef IPL_FOCUS_OBJECT_CPP
VEC3 operator*(f32 val) const;
#else
VEC3 operator*(f32 val) const { return VEC3(x * val, y * val, z * val); }
#endif
VEC3 operator*(f64 val) const {
nw4r::math::VEC3 vecOut;
VEC3Scale(&vecOut, this, (f32)val);

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

@@ -53,24 +53,7 @@ namespace ipl {
mBScroller.init();
}
BOOL calc(bool canScroll) __attribute__((never_inline)) /*for now*/ {
BOOL result = FALSE;
if (canScroll) {
if (mBScroller.calc()) {
result = TRUE;
}
}
mScroller.calc();
f32 movable = mScroller.movable_pos(mBScroller.getSpeed());
mScroller.addScroll(movable);
mBScroller.addSoundFreq(movable);
return result;
}
BOOL calc(bool canScroll);
BOOL is_busy() const {
BOOL result = TRUE;

View File

@@ -18,11 +18,11 @@ namespace ipl {
class line_collision {
public:
line_collision() : unk_0x00(0.0f), unk_0x04(0.0f), unk_0x08(0.0f) {}
line_collision() : mLeft(0.0f), mRight(0.0f), mY(0.0f) {}
f32 unk_0x00;
f32 unk_0x04;
f32 unk_0x08;
f32 mLeft;
f32 mRight;
f32 mY;
nw4r::ut::Link mLinkList; // 0x0C
};
@@ -31,9 +31,9 @@ namespace ipl {
url_collision();
~url_collision();
int unk_0x00;
wchar_t* unk_0x04;
wchar_t* unk_0x08;
int mTagNo;
wchar_t* mpStart;
wchar_t* mpEnd;
nw4r::ut::Link mLinkList; // 0x0C
nw4r::ut::List mLineCollisions; // 0x14
};
@@ -53,19 +53,19 @@ namespace ipl {
void parse(nw4r::ut::PrintContext<wchar_t>* context);
BOOL is_focused() const;
void select(int unk);
void select(int tagNo);
int get_focused_tagno(int chan) const;
url_collision* get_selected_col();
void get_url(char* urlOut, u32 urlLen);
void setUnk_0x40(f32 val) { unk_0x40 = val; }
void setUnk_0x44(f32 val) { unk_0x44 = val; }
void setUnk_0x53(bool val) { unk_0x53 = val; }
void setHitYOffset(f32 val) { mHitYOffset = val; }
void setMemoTranslateY(f32 val) { mMemoTranslateY = val; }
void setFocusEnabled(bool val) { mbFocusEnabled = val; }
u8 getUnk_0x50() const { return unk_0x50; }
void setUnk_0x50(u8 val) { unk_0x50 = val; }
u8 getColorPass() const { return mbColorPass; }
void setColorPass(u8 val) { mbColorPass = val; }
private:
typedef struct {
@@ -75,14 +75,14 @@ namespace ipl {
con_data mConData[WPAD_MAX_CONTROLLERS]; // 0x00
nw4r::ut::List mUrlCollisions; // 0x34
f32 unk_0x40;
f32 unk_0x44;
int unk_0x48;
int unk_0x4C;
u8 unk_0x50;
u8 unk_0x51;
u8 unk_0x52;
u8 unk_0x53;
f32 mHitYOffset;
f32 mMemoTranslateY;
int mCurTagNo;
int mSelectedTagNo;
u8 mbColorPass;
u8 mbInTag;
u8 mbHoverOffset;
u8 mbFocusEnabled;
};
} // namespace scene
} // namespace ipl

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

@@ -259,8 +259,8 @@ namespace ipl {
f32 mChanThumbOff_X; // 0xD0
f32 mChanThumbOff_Y; // 0xD4
math::VEC3 unk_0xD8;
math::VEC2 unk_0xE4;
math::VEC3 mOrthoTrans;
math::VEC2 mOrthoScale;
f32 mScaleAdjust; // 0xEC
int mDiskState; // 0xF0

View File

@@ -65,7 +65,11 @@ namespace ipl {
virtual BOOL isReady() const { return FALSE; }
/** @brief If the user can power off/reset the system */
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual BOOL isResetAcceptable() { return TRUE; }
#else
virtual BOOL isResetAcceptable() const { return TRUE; }
#endif
/** @brief The scene running code when powering off/resetting the system */
virtual void startResetting() {}
/** @brief If the scene has finished its powering off/resetting task */

View File

@@ -102,12 +102,7 @@ namespace ipl {
static const char* getButtonName(int button) { return smButtonName[button]; }
#endif
#ifdef IPL_SD_CHANNEL_SELECT_CPP
void setEventHandler(::gui::EventHandler * event,
::gui::EventHandler * optOutEvent = NULL);
#else
void setEventHandler(::gui::EventHandler * event, ::gui::EventHandler * optOutEvent);
#endif
void setEventHandler(::gui::EventHandler * event);
void setText(const char* paneName, u32 msgId);
void setText(const char* paneName, const wchar_t* text);
@@ -150,7 +145,7 @@ namespace ipl {
ANIM_MAX,
};
int unk_0x54;
int mAnimWait;
layout::Object* mpLayout; // 0x58
nand::LayoutFile* mpLayoutFile; // 0x5C

View File

@@ -203,9 +203,9 @@ namespace ipl {
bool enqueueLoadNotice();
bool enqueuePageNotice();
bool enqueueResultNotice(u32 result);
bool enqueueChannelNotice(u32 controller, u32 page, u32 index, u32 value);
bool enqueueChannelNotice(u64 titleId, u32 value);
bool enqueueMoveNotice(u32 controller, u32 page, u32 index);
bool enqueueStateNotice(u32 controller, u32 page, u32 index, u32 state);
bool enqueueStateNotice(u64 titleId, u32 state);
bool enqueueErrorNotice(u32 page, u32 index);
bool enqueueCommandNotice(u32 page, u32 index, u32 command);
bool enqueueDeleteNotice(u32 controller, u32 page, u32 index);

View File

@@ -62,17 +62,17 @@ namespace ipl {
void start_left_event(const char* paneName);
void start_trig_event(const char* paneName);
typedef struct Unk {
typedef struct CmdEntry {
int command; // 0x00
u32 msgID; // 0x04
} Unk;
} CmdEntry;
Unk unk_0x64[64];
CmdEntry mCmdQueue[64];
int unk_0x264;
int unk_0x268;
int unk_0x26C;
int unk_0x270;
int mQueueCapacity;
int mQueueCount;
int mQueueRead;
int mQueueWrite;
int mSettingArg; // 0x274

View File

@@ -185,8 +185,8 @@ namespace ipl {
gui::PaneManager* mpGui; // 0x74
BOOL mbHovered[BTN_MAX]; // 0x78
u32 unk_0x90;
u32 unk_0x94;
u32 mPendingSceneId;
u32 mExitSeqStep;
static const char* smButtonName[BTN_MAX];
};

View File

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

View File

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

View File

@@ -89,10 +89,10 @@ namespace ipl {
int mIPLState; // 0x04
volatile BS2State mState; // 0x08
bool unk_0x0C;
bool unk_0x0D;
bool unk_0x0E;
bool unk_0x0F;
bool mbTickEnabled; // 0x0C
bool mbUpdateRequested; // 0x0D
bool mbAbortRequested; // 0x0E
bool mbRestartRequested; // 0x0F
bool mbIsDiagDisc; // 0x10
bool mbIncludesSeatTitles; // 0x11
u8* mpBannerBuffer; // 0x14

View File

@@ -365,8 +365,8 @@ namespace ipl {
int getChJumpChanPage() { return mChJumpPage; }
int getChJumpChanIndex() { return mChJumpIndex; }
void setUnk_0x1B81(bool flag) { unk_0x1B81 = flag; }
bool isUnk_0x1B81() { return unk_0x1B81; }
void setDiskChannelReady(bool flag) { mbDiskChannelReady = flag; }
bool isDiskChannelReady() { return mbDiskChannelReady; }
void resetChJumpLoad() { mbLoadedChJump = false; }
bool hasLoadedChJump() { return mbLoadedChJump; }
@@ -399,7 +399,7 @@ namespace ipl {
int mBS2State; // 0x1B7C
bool mbCanRefresh; // 0x1B80
bool unk_0x1B81;
bool mbDiskChannelReady;
u8* mpDiskIconBuf; // 0x1B84
u8* mpDiskBannerBuf; // 0x1B88

View File

@@ -33,7 +33,7 @@ namespace ipl {
u64 titleId; // 0x10
bool threadTerminated; // 0x18
bool unk_0x19;
bool unk_0x1A;
bool mbHasNewMessage; // 0x1A
EGG::ExpHeap* getHeap() { return heap; }
} CSData;

View File

@@ -118,26 +118,26 @@ namespace ipl {
public:
Base(int chan, KPADStatus& status) {
mButton = 0;
unk_0x08 = 0;
mDecideHoldCount = 0;
mLastRumbleTime = 0;
mRumbleType = -1;
mChan = chan;
mType = 2;
unk_0x1C = 0;
mbForceInvalid = 0;
KPADEnableDPD(chan);
unk_0x1D = 0;
unk_0x1E = 0;
unk_0x20 = &status;
mbPinching = 0;
mbWasPinching = 0;
mpKpadStatus = &status;
}
Base(int chan, int type, KPADStatus& status) {
mButton = 0;
unk_0x08 = 0;
mDecideHoldCount = 0;
mLastRumbleTime = 0;
mRumbleType = -1;
mChan = chan;
mType = type;
unk_0x1C = 0;
mbForceInvalid = 0;
KPADEnableDPD(chan);
}
@@ -152,15 +152,15 @@ namespace ipl {
protected:
u8 mButton;
u32 unk_0x08;
u32 mDecideHoldCount;
OSTick mLastRumbleTime;
s32 mRumbleType;
u32 mChan;
u32 mType;
u8 unk_0x1C;
u8 unk_0x1D;
u8 unk_0x1E;
KPADStatus* unk_0x20;
u8 mbForceInvalid;
u8 mbPinching;
u8 mbWasPinching;
KPADStatus* mpKpadStatus;
};
class Revolution : public Base {
@@ -206,8 +206,8 @@ namespace ipl {
virtual BOOL isValidDpdClassic() const;
private:
math::VEC2 unk_0x24;
int unk_0x2C;
math::VEC2 mClassicCursorPos;
int mClassicCursorTimer;
};
class Master : public Interface {
@@ -264,18 +264,18 @@ namespace ipl {
public:
Base(int chan, KPADStatus& arg1) {
mButton = 0;
unk_0x08 = 0;
mDecideHoldCount = 0;
mLastRumbleTime = 0;
mRumbleType = -1;
mChan = chan;
mType = 2;
unk_0x1C = 0;
mbForceInvalid = 0;
KPADEnableDPD(chan);
unk_0x1D = 0;
unk_0x1E = 0;
unk_0x20 = &arg1;
mbPinching = 0;
mbWasPinching = 0;
mpKpadStatus = &arg1;
}
virtual ~Base(); // 0x08
@@ -326,15 +326,15 @@ namespace ipl {
// protected:
u8 mButton; // 0x4
u32 unk_0x08; // 0x8
u32 mDecideHoldCount; // 0x8
OSTick mLastRumbleTime; // 0xC
s32 mRumbleType; // 0x10
u32 mChan; // 0x14
u32 mType; // 0x18
u8 unk_0x1C;
u8 unk_0x1D; // 0x1D
u8 unk_0x1E; // 0x1E
KPADStatus* unk_0x20; // 0x20
u8 mbForceInvalid;
u8 mbPinching; // 0x1D
u8 mbWasPinching; // 0x1E
KPADStatus* mpKpadStatus; // 0x20
};
class Interface : public Base {
@@ -446,8 +446,8 @@ namespace ipl {
virtual BOOL isValidDpdClassic() const; // 0x8C
private:
math::VEC2 unk_0x24;
int unk_0x2C;
math::VEC2 mClassicCursorPos;
int mClassicCursorTimer;
};
class Manager {

View File

@@ -60,9 +60,9 @@ namespace ipl {
int mMessageID; // 0x08
int unk_0x0C;
int unk_0x10;
char unk_0x14[4];
int mArg2;
int mArg3;
char mArg1[4];
u8* mpArcData; // 0x18
u32 mArcSize; // 0x1C

View File

@@ -145,6 +145,13 @@ namespace ipl {
mpCommonFile = commonFile;
mpLangFile = langFile;
}
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
virtual ~LangFile() {}
virtual void read() {}
virtual bool isFinished() { return false; }
virtual int checkData() { return 0; }
virtual bool isFatalError() { return false; }
#else
virtual ~LangFile(); // 0x08
virtual void read(); // 0x0C
@@ -152,6 +159,7 @@ namespace ipl {
virtual bool isFinished(); // 0x14
virtual int checkData(); // 0x18
virtual bool isFatalError(); // 0x1C
#endif
File* getCmnFile() const { return mpCommonFile; }
File* getLangFile() const { return mpLangFile; }
@@ -165,7 +173,11 @@ namespace ipl {
public:
LayoutFile(EGG::Heap* heap, const char* dirName, const char* fileName, ARCHandle* arc, bool bIsNandFile);
LayoutFile(File* commonFile, File* langFile = NULL) : LangFile(commonFile, langFile) {}
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
virtual ~LayoutFile() {} // 0x08
#else
virtual ~LayoutFile(); // 0x08
#endif
};
} // namespace nand
} // namespace ipl

View File

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

@@ -139,7 +139,7 @@ namespace ipl {
bool received() { return mbReviecedMsg; }
void prepNextReceive() { mbReviecedMsg = false; }
volatile bool isUnk0xA31() { return unk_0xA31 == false; }
volatile bool isReceivingIdle() { return mbReceiving == false; }
BOOL isAppDlEnableLock(u32 appId) {
utility::autoMutexLock lock(mAutoLock);
@@ -175,9 +175,9 @@ namespace ipl {
OSMutex mAutoLock; // 0xA18
bool mbReviecedMsg;
bool unk_0xA31;
bool mbReceiving;
bool mbReceivePaused; // 0xA32
bool unk_0xA33;
bool mbNewTitleTblReady;
static Arg smArg;

View File

@@ -27,7 +27,11 @@ namespace ipl {
void init(int type, f32 maxFrame, f32 minFrame, f32 speed = 1.0f);
void initFrame();
#ifdef IPL_CHANNEL_SELECT_CPP
virtual inline void calc();
#else
virtual void calc(); // 0x0C
#endif
void setMaxFrame(f32 value) { mMaxFrame = value; }
f32 getMaxFrame() const { return mMaxFrame; }

View File

@@ -32,8 +32,8 @@ namespace ipl {
void set_arw_param();
int mState; // 0x04
math::VEC2 unk_0x08;
math::VEC2 unk_0x10;
math::VEC2 mCurPos;
math::VEC2 mStartPos;
f32 mSpeed; // 0x18
f32 mSoundFreq; // 0x1C
};
@@ -55,7 +55,7 @@ namespace ipl {
void init() {
mState = 0;
mScroll = 0.0f;
unk_0x3C = 0.0f;
mVelocity = 0.0f;
mUpLimit = 0.0f;
mDownLimit = 0.0f;
}
@@ -92,11 +92,11 @@ namespace ipl {
int mState; // 0x30
f32 mDownLimit; // 0x34
f32 mUpLimit; // 0x38
f32 unk_0x3C;
f32 mVelocity;
f32 mScroll; // 0x40
f32 unk_0x44;
f32 unk_0x48;
f32 unk_0x4C;
f32 mAnimFrom;
f32 mFriction;
f32 mAccel;
};
} // namespace utility
} // namespace ipl

View File

@@ -38,6 +38,19 @@ namespace EGG {
virtual void calc(); // 0x30
#ifdef EGG_AUDIO_EXPMGR_NO_INLINE_VIRTUALS
virtual bool startSound(nw4r::snd::SoundHandle* pHandle, u32 id); // 0x34
virtual bool startSound(nw4r::snd::SoundHandle* pHandle, unsigned int id); // 0x38
virtual bool startSound(nw4r::snd::SoundHandle* pHandle, const char* pName); // 0x3C
virtual bool prepareSound(nw4r::snd::SoundHandle* pHandle, u32 id); // 0x44
virtual bool prepareSound(nw4r::snd::SoundHandle* pHandle, unsigned int id); // 0x44
virtual bool prepareSound(nw4r::snd::SoundHandle* pHandle, const char* pName); // 0x48
virtual bool holdSound(nw4r::snd::SoundHandle* pHandle, u32 id); // 0x50
virtual bool holdSound(nw4r::snd::SoundHandle* pHandle, unsigned int id); // 0x50
virtual bool holdSound(nw4r::snd::SoundHandle* pHandle, const char* pName); // 0x58
#else
virtual bool startSound(nw4r::snd::SoundHandle* pHandle, u32 id) { return mSoundArchivePlayer.StartSound(pHandle, id); } // 0x34
virtual bool startSound(nw4r::snd::SoundHandle* pHandle, unsigned int id) { return mSoundArchivePlayer.StartSound(pHandle, id); } // 0x38
virtual bool startSound(nw4r::snd::SoundHandle* pHandle, const char* pName) NO_INLINE {
@@ -66,6 +79,7 @@ namespace EGG {
u32 id = changeNameToId(pName);
return mSoundArchivePlayer.HoldSound(pHandle, id);
} // 0x58
#endif
u32 changeNameToId(const char* pName) { return mpArchive->ConvertLabelStringToSoundId(pName); }
const char* changeIdToName(u32 id) { return mpArchive->GetSoundLabelString(id); }

View File

@@ -19,6 +19,10 @@ namespace EGG {
~SoundHeapMgr() { destroySoundHeap(); }
#ifdef EGG_AUDIO_EXPMGR_NO_INLINE_VIRTUALS
virtual bool loadState(s32 id); // 0x08
virtual s32 getCurrentLevel(); // 0x0C
#else
virtual bool loadState(s32 id) {
#ifdef IPL_SOUND_MATCHING
if (id > 0 && mHeap.GetCurrentLevel() >= id) {
@@ -35,6 +39,7 @@ namespace EGG {
} // 0x08
virtual s32 getCurrentLevel() { return mHeap.GetCurrentLevel(); } // 0x0C
#endif
s32 saveState() { return mHeap.SaveState(); }

View File

@@ -1,3 +1,5 @@
#define EGG_AUDIO_EXPMGR_NO_INLINE_VIRTUALS
#include <egg/core.h>
namespace EGG {

View File

@@ -1120,6 +1120,7 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
case 's':
if (format.argument_options == wchar_argument) {
wchar_t* wcs_ptr = va_arg(args, wchar_t*);
int wideLength;
if (wcs_ptr == NULL) {
wcs_ptr = L"";
@@ -1127,22 +1128,24 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
if (format.alternate_form) {
wchar_t first = *wcs_ptr++;
num_chars = (unsigned char)first;
wideLength = (unsigned char)first;
if (format.precision_specified && num_chars > format.precision) {
num_chars = format.precision;
if (format.precision_specified && wideLength > format.precision) {
wideLength = format.precision;
}
} else if (format.precision_specified) {
num_chars = format.precision;
wideLength = format.precision;
if ((string_end = wmemchr((wchar_t*)wcs_ptr, 0, num_chars)) != 0) {
num_chars = string_end - wcs_ptr;
if ((string_end = wmemchr((wchar_t*)wcs_ptr, 0, wideLength)) != 0) {
wideLength = string_end - wcs_ptr;
}
} else {
num_chars = wcslen(wcs_ptr);
wideLength = wcslen(wcs_ptr);
}
num_chars = wideLength;
buff_ptr = wcs_ptr;
break;
} else {

View File

@@ -1,32 +1,45 @@
// Yes, versions other than 4.3U align by 8.
#if defined(VERSION_43U)
#pragma function_align 32
#else
#pragma function_align 8
#endif // VERSION_43U
#endif
#include <TRK_Hollywood_Revolution.h>
#pragma force_active on
// Encapsulating function to get the file to align properly
asm void __targsupp() {
// clang-format off
#ifdef __MWERKS__
// clang-format off
asm DSIOResult TRKAccessFile(MessageCommandID cmd, unsigned int handle, int* count, unsigned char* buffer) {
#ifdef __MWERKS__
nofralloc
entry TRKAccessFile
twi 31, r0, 0
blr
entry TRKOpenFile
twi 31, r0, 0
blr
entry TRKCloseFile
twi 31, r0, 0
blr
entry TRKPositionFile
twi 31, r0, 0
blr
#endif // __MWERKS__
// clang-format on
twi 31, r0, 0
blr
#endif
}
#pragma function_align 8
asm DSIOResult TRKOpenFile() {
#ifdef __MWERKS__
nofralloc
twi 31, r0, 0
blr
#endif
}
asm DSIOResult TRKCloseFile() {
#ifdef __MWERKS__
nofralloc
twi 31, r0, 0
blr
#endif
}
asm DSIOResult TRKPositionFile() {
#ifdef __MWERKS__
nofralloc
twi 31, r0, 0
blr
#endif
}
// clang-format on

View File

@@ -19,8 +19,13 @@ namespace nw4r {
template <typename T>
class AutoLock : private NonCopyable {
public:
#ifdef EGG_AUDIO_EXPMGR_NO_INLINE_VIRTUALS
explicit AutoLock(T& rLockObj);
~AutoLock();
#else
explicit AutoLock(T& rLockObj) : mLockObj(rLockObj) { Lock(rLockObj); }
~AutoLock() { Unlock(mLockObj); }
#endif
private:
T& mLockObj; // 0x00

View File

@@ -1,13 +1,13 @@
#include <nw4r/db/assert.h>
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" const u8 scLytFatalColorR;
extern "C" const u8 scLytFatalColorG;
extern "C" const u8 scLytFatalColorB;
extern "C" const u8 scLytFatalColorA;
extern "C" char scLytFatalMsg[] = "Error#004\nAn error has occurred.\nThe system files are corrupted.";
#undef NW4R_ASSERT
#define NW4R_ASSERT(x) \
#define NW4R_GLOBAL_ASSERT(x) \
{ \
if (!(x)) { \
GXColor front = {*((volatile const u8*)&::scLytFatalColorR), *((volatile const u8*)&::scLytFatalColorG), \
@@ -17,6 +17,15 @@ extern "C" char scLytFatalMsg[] = "Error#004\nAn error has occurred.\nThe system
} \
}
#define NW4R_ASSERT(x) \
{ \
if (!(x)) { \
GXColor front = {255, 255, 255, 0}; \
GXColor back = {0, 0, 0, 0}; \
OSFatal((GXColor)front, (GXColor)back, ::scLytFatalMsg); \
} \
}
#include <nw4r/lyt/window.h>
#include <nw4r/lyt/common.h>
@@ -488,7 +497,7 @@ namespace nw4r {
}
Material* Window::GetFrameMaterial(u32 frameIdx) const {
NW4R_ASSERT(frameIdx < WINDOWFRAME_MAX);
NW4R_GLOBAL_ASSERT(frameIdx < WINDOWFRAME_MAX);
if (frameIdx >= mFrameNum) {
return NULL;
}
@@ -501,3 +510,8 @@ namespace nw4r {
}
} // namespace lyt
} // namespace nw4r
extern "C" const u8 scLytFatalColorR = 255;
extern "C" const u8 scLytFatalColorG = 255;
extern "C" const u8 scLytFatalColorB = 255;
extern "C" const u8 scLytFatalColorA = 0;

View File

@@ -314,7 +314,7 @@ namespace nw4r {
ArchiveFontBase::ConstructState ArchiveFontBase::ConstructOpAnalyzeGLGR(ConstructContext* ctx, CachedStreamReader* reader) {
u32 glgrInnerLen;
HeaderedGlyphGroups* pGlgr;
ArchiveFontBinaryLayout* font;
const ArchiveFontBinaryLayout* font;
u8* glgrEnd;
u32 expectedMaxSize;
@@ -337,7 +337,7 @@ namespace nw4r {
// Copy the glgr to work
{
pGlgr = &font->glgr;
pGlgr = (HeaderedGlyphGroups*)&font->glgr;
glgrEnd = (u8*)pGlgr + (u32)ctx->mNextBlockHdr.size;
memcpy(pGlgr, &ctx->mNextBlockHdr, sizeof(BinaryBlockHeader));
@@ -368,21 +368,21 @@ namespace nw4r {
u32 sheetOffsetsScratchSize;
dataBlockCount = font->hdr.dataBlocks; // 0x0E
sheetGlyphCount = font->glgr.inner.sheetGlyphCount; // 0x1C
dataBlockCount = font->hdr.dataBlocks; // 0x0E
// countName = font->glgr.inner.nameCount;
countSheet = font->glgr.inner.sheetCount;
// count0A = font->glgr.inner.smthCount_0x0a;
// count0C = font->glgr.inner.smthCount_0x0c;
sheetOffsetsSize = ROUNDUP(countSheet * sizeof(u16), 4);
sheetOffsetsScratch = (u16*)ROUNDDOWN((u32)((u8*)font + ctx->remWorkSpace()) - sheetOffsetsSize, 2);
stepSheetFlags = detail::CalcSizeFlagSet(countSheet);
flagsSheetsOff = detail::CalcOffsetSheetFlags(font->glgr.inner.nameCount, countSheet, font->glgr.inner.smthCount_0x0a,
font->glgr.inner.smthCount_0x0c);
flagsSheets = (const u32*)font + (flagsSheetsOff >> 2);
pGlgr = &font->glgr;
sheetOffsetsSize = ROUNDUP(countSheet * sizeof(u16), 4);
sheetOffsetsScratch = (u16*)ROUNDDOWN((u32)((u8*)font + ctx->remWorkSpace()) - sheetOffsetsSize, 2);
pGlgr = (HeaderedGlyphGroups*)&font->glgr;
ENSURE_WORK_HAS_SIZE(ctx, glgrEnd - (u8*)font + sheetOffsetsSize);
// if (ctx->pWorkEnd - workCurr < fontSizeToEndOfGlgr + sheetOffsetsSize) {
// return CONSTRUCT_STATE_FATAL_ERR;

View File

@@ -63,9 +63,9 @@ typedef struct {
u8 mcuYRem; // 0x0F
u16 mcuYCount; // 0x10
u16 mcuXCount2; // 0x12
u32 unk_0x14;
u8 unk_0x18;
u8 unk_0x19;
u32 mcuTotal; // 0x14
u8 remX; // 0x18
u8 remY; // 0x19
u8 compCount; // 0x1A
u8 scanCompCount; // 0x1B
u8 blockCount[4]; // 0x1C
@@ -142,9 +142,9 @@ struct TMCCJPEGDecWork_t {
u8 mcuYRem; // 0x17FF
u16 mcuYCount; // 0x1800
u16 mcuXCount2; // 0x1802
u32 unk_0x1804;
u8 unk_0x1808;
u8 unk_0x1809;
u32 mcuTotal; // 0x1804
u8 remX; // 0x1808
u8 remY; // 0x1809
u8 compCount; // 0x180A
u8 scanCompCount; // 0x180B
u8 blockCount[4]; // 0x180C

View File

@@ -10,14 +10,12 @@ static TMCHuffmanEntry readHuffmanEntry(const TMCHuffmanEntry* entries, u32 inde
return entries[index];
}
static TMCHuffmanEntry readHuffmanLimit(const TMCHuffmanEntry* entries) {
TMCHuffmanEntry limit;
limit.bitLength = entries->bitLength;
limit.symbol = entries->symbol;
return limit;
static void readHuffmanLimit(const TMCHuffmanEntry* entries, TMCHuffmanEntry* limit) {
limit->bitLength = entries->bitLength;
limit->symbol = entries->symbol;
}
static inline s32 decodeLongHuffman(s32 bitCount, const TMCHuffmanEntry* table, const u8* symbols, TMCCJPEGDecWork* work) {
static inline s32 decodeLongHuffman(s32 bitCount, const TMCHuffmanEntry* table, const u8* symbols, TMCCJPEGDecWork* work, TMCHuffmanEntry* limit, TMCHuffmanEntry* decoded) {
u32 bitData;
u32 code;
u32 length;
@@ -51,17 +49,21 @@ static inline s32 decodeLongHuffman(s32 bitCount, const TMCHuffmanEntry* table,
code |= (bitData >> bitCount) & 1;
read_entry:
{
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
if (code > (u32)decoded.bitLength) {
readHuffmanLimit(entry, limit);
*decoded = *limit;
if (code > (u32)decoded->bitLength) {
continue;
}
code = code - entry->bitLength + entry->symbol;
return symbols[code & 0xFF];
{
u32 relativeCode = code - entry->bitLength;
u32 symbolIndex = relativeCode + entry->symbol;
return symbols[symbolIndex & 0xFF];
}
}
}
}
static inline s32 decodeACHuffman(s32 bitCount, const TMCHuffmanEntry* entry, const u8* symbols, TMCCJPEGDecWork* work) {
static inline s32 decodeACHuffman(s32 bitCount, const TMCHuffmanEntry* entry, const u8* symbols, TMCCJPEGDecWork* work, TMCHuffmanEntry* limit, TMCHuffmanEntry* decoded) {
u32 bitData;
u32 code;
u32 length;
@@ -94,33 +96,41 @@ static inline s32 decodeACHuffman(s32 bitCount, const TMCHuffmanEntry* entry, co
code |= (bitData >> bitCount) & 1;
read_entry:
{
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
if (code > (u32)decoded.bitLength) {
readHuffmanLimit(entry, limit);
*decoded = *limit;
if (code > (u32)decoded->bitLength) {
continue;
}
code = code - entry->bitLength + entry->symbol;
return symbols[code & 0xFF];
{
u32 relativeCode = code - entry->bitLength;
u32 symbolIndex = relativeCode + entry->symbol;
return symbols[symbolIndex & 0xFF];
}
}
}
}
s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_ptr, TMCCJPEGDecWork* work) {
TMCHuffmanEntry dcEntry;
TMCHuffmanEntry acEntry;
const TMCHuffmanEntry* ac_fast;
TMCHuffmanEntry dcDecoded;
TMCHuffmanEntry dcLimit;
TMCHuffmanEntry acDecoded;
TMCHuffmanEntry acLimit;
u8* huff_sym;
const TMCHuffmanEntry* ac_fast;
s32 idx;
u32* huff_tbl;
s32 bit_pos;
u32 bit_data;
const TMCHuffmanEntry* dc_fast;
u32 tmp;
s32 r;
s32 blk0;
s32 idx;
TMCHuffmanEntry acEntry;
s32 extra;
s32 t;
s32 zz;
s32 q;
u32 tmp;
const TMCHuffmanEntry* dc_fast;
const u8* zztbl;
bit_pos = work->bitCount;
@@ -135,22 +145,19 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
bit_pos = work->bitCount;
bit_data = work->bitBuf;
tmp = bit_pos - 8;
tmp = ((bit_data >> tmp) & 0xFF) << 2;
{
dcEntry = readHuffmanEntry(dc_fast, tmp >> 2);
dcEntry = readHuffmanEntry(dc_fast, (bit_data >> (bit_pos - 8)) & 0xFF);
r = dcEntry.bitLength;
extra = dcEntry.symbol;
}
if (r != 0) {
bit_pos -= r;
work->bitCount = bit_pos;
work->bitCount = bit_pos - r;
r = extra;
} else {
huff_sym = work->pDCHuffSym;
huff_tbl = work->pDCHuffTbl;
r = decodeLongHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work);
r = decodeLongHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work, &dcLimit, &dcDecoded);
if (r < 0) {
return r;
}
@@ -210,7 +217,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
r = acEntry.symbol;
} else {
bit_pos = work->bitCount;
r = decodeACHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work);
r = decodeACHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work, &acLimit, &acDecoded);
if (r < 0) {
return r;
}

View File

@@ -16,7 +16,7 @@ static u16 readU16(const u8* p, u16 byteOrder) {
}
static u16 readExifU16(const u8* data, u16 byteOrder) {
u32 value = data[0] | data[1] << 8;
u16 value = data[0] | data[1] << 8;
if (byteOrder == 0x4949) {
return (u16)value;
}
@@ -246,9 +246,9 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
u32 ifdOffset;
const u8* entries;
u16 remaining;
u16 count;
s32 entriesSize;
u16 index;
s32 entriesSize;
u16 count;
pInfo->thumbnailData = (u8*)data;
pInfo->dataEnd = (u8*)data + size;
pInfo->nextIfdOffset = 0;
@@ -339,7 +339,7 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
}
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, const u8* entry) {
u16 tag;
s32 tag;
u16 type;
tag = readU16(entry, byteOrder);

View File

@@ -51,7 +51,7 @@ s32 TMCJPEGDEC_Setsize(TMCCJPEGDecWork* work) {
}
state->componentCount = work->componentCount;
state->result = work->unk_0x1804;
state->result = work->mcuTotal;
state->maxX = work->mcuYCount;
state->maxY = work->mcuXCount2;
@@ -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

@@ -562,12 +562,12 @@ 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);
p->unk_0x14 = (u32)p->mcuYCount * (u32)p->mcuXCount2;
p->mcuTotal = (u32)p->mcuYCount * (u32)p->mcuXCount2;
for (idx = 0; idx < (s32)p->scanCompCount; idx++) {
u8 compId;
@@ -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;
@@ -1929,7 +1929,7 @@ static s32 TMCJPEGDEC_parse_sof(TMCCJPEGDecWork* work) {
mcuCountY += yr;
frameInfo->mcuYCount = mcuCountX;
frameInfo->mcuXCount2 = mcuCountY;
work->unk_0x1804 = (u32)mcuCountX * (u32)mcuCountY;
work->mcuTotal = (u32)mcuCountX * (u32)mcuCountY;
}
compCount2 = frameInfo->compCount;

View File

@@ -15,9 +15,13 @@ static s8 clampS8(s32 v) {
void TMCJPEGDEC_IdctBlock4x4(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigzag) {
s32 bd;
s32 d;
s32 c;
s32 a;
s32 cd;
s32 oddrot;
s32 evsum;
s32 rot;
s32 d;
s32 b;
s32* sp;
@@ -26,57 +30,41 @@ void TMCJPEGDEC_IdctBlock4x4(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigzag
s32 tmp[64];
s32 i;
s32 evsum, rot, oddrot, cd;
sp = block + 24;
dp = tmp + 24;
for (i = 0; i < 2; i++) {
a = sp[0]; // 0x0
b = sp[1]; // 0x4
c = sp[2]; // 0x8
d = sp[3]; // 0xc
for (i = 0; i < 4; i++) {
s32 a, b, c, d;
s32 odddiff, bd, evsum, cd, rot, oddrot;
a = sp[0];
b = sp[1];
c = sp[2];
d = sp[3];
odddiff = b - d;
bd = b + d;
evsum = a + c;
oddrot = (0xB5 * (sp[1] - sp[3]) >> 8) + bd;
rot = (0xB5 * (sp[1] - sp[3])) >> 8;
dp[1] = (a - c) + rot;
dp[2] = (a - c) - rot;
dp[3] = evsum - oddrot;
dp[0] = evsum + oddrot;
b = sp[-7]; // -0x1c
d = sp[-5]; // -0x14
bd = b + d;
rot = ((b - d) * 0xB5) >> 8;
cd = a - c;
rot = (odddiff * 0xB5) >> 8;
oddrot = rot + bd;
a = sp[-8]; // -0x20
c = sp[-6]; // -0x18
dp[-8] = (a + c) + oddrot;
dp[-7] = (a - c) + rot;
dp[-6] = (a - c) - rot;
dp[-5] = (a + c) - oddrot;
sp -= 16;
dp -= 16;
dp[0] = evsum + oddrot;
dp[1] = cd + rot;
dp[2] = cd - rot;
dp[3] = evsum - oddrot;
sp -= 8;
dp -= 8;
}
{
u32 idx = 3;
sp = tmp + 3;
for (i = 0; i < 4; i++) {
u8* bp = conv_row_ptr + idx;
a = sp[0] + 0x40000;
b = sp[8];
d = sp[24];
c = sp[16];
a = tmp[idx] + 0x40000;
b = tmp[idx + 8];
d = tmp[idx + 24];
c = tmp[idx + 16];
evsum = a + c;
cd = a - c;
@@ -90,7 +78,6 @@ void TMCJPEGDEC_IdctBlock4x4(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigzag
bp[pitch * 2] = clampU8((cd - rot) >> 11);
bp[pitch * 4 - pitch] = clampU8((evsum - oddrot) >> 11);
sp--;
idx -= 1;
}
}
@@ -131,38 +118,37 @@ void TMCJPEGDEC_IdctBlock4x4_Col(s32* sp, u8* conv_row_ptr, u16 pitch, s32 zigza
s32 a, b, c, d;
s32 evsum, evdiff, oddsum, odddiff, rot, oddrot;
for (i = 0; i < 2; i++) {
s32 a0 = src[0], b0 = src[1], c0 = src[2], d0 = src[3];
s32 a1 = src[-8], b1 = src[-7], c1 = src[-6], d1 = src[-5];
s32 odddiff0 = b0 - d0;
s32 oddsum0 = b0 + d0;
s32 evsum0 = a0 + c0;
s32 evdiff0 = a0 - c0;
s32 rot0 = (odddiff0 * 0xB5) >> 8;
s32 odddiff1 = b1 - d1;
s32 oddsum1 = b1 + d1;
s32 evsum1 = a1 + c1;
s32 evdiff1 = a1 - c1;
s32 rot1 = (odddiff1 * 0xB5) >> 8;
dst[0] = evsum0 + (oddsum0 + rot0);
dst[1] = evdiff0 + rot0;
dst[2] = evdiff0 - rot0;
dst[3] = evsum0 - (oddsum0 + rot0);
dst[-8] = evsum1 + (oddsum1 + rot1);
dst[-7] = evdiff1 + rot1;
dst[-6] = evdiff1 - rot1;
dst[-5] = evsum1 - (oddsum1 + rot1);
src -= 16;
dst -= 16;
for (i = 0; i < 4; i++) {
a = src[0];
b = src[1];
c = src[2];
d = src[3];
odddiff = b - d;
oddsum = b + d;
evsum = a + c;
evdiff = a - c;
rot = (odddiff * 0xB5) >> 8;
oddrot = rot + oddsum;
dst[0] = evsum + oddrot;
dst[1] = evdiff + rot;
dst[2] = evdiff - rot;
dst[3] = evsum - oddrot;
src -= 8;
dst -= 8;
}
src = tmp + 3;
for (i = 3; i >= 0; i--) {
s32 evdiff;
s32 a;
s32 c;
s32 b;
s32 evsum;
s32 d;
s32 oddsum;
s32 odddiff;
s32 rot;
s32 oddrot;
u8* out = conv_row_ptr + i;
a = src[0];
b = src[8];
@@ -170,7 +156,7 @@ void TMCJPEGDEC_IdctBlock4x4_Col(s32* sp, u8* conv_row_ptr, u16 pitch, s32 zigza
d = src[24];
odddiff = b - d;
oddsum = b + d;
oddsum = d + b;
evsum = a + c;
evdiff = a - c;
rot = odddiff * 0xB5 >> 8;

View File

@@ -166,23 +166,23 @@ s32 TMCJPEGDEC_set_converterRGBA8(TMCCJPEGDecWork* work) {
}
static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
s8 crValue;
s32 red;
u8* luminance;
u8* cb;
u8* cr;
TMCCJPEGDecState* state;
u8* texture;
s32 height;
s32 yEnd;
s32 column;
s32 xEnd;
s32 green;
s32 column;
s32 yEnd;
s32 tileWidth;
s32 blueOffset;
u16* output;
s32 tileRow;
s32 lumaSkip;
s32 red;
s8 crValue;
s32 chromaSkip;
s32 width;
s32 cbValue;
@@ -216,7 +216,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
redOffset = (crValue * 359) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
greenOffset = -(crValue * 183 + cbValue * 88) >> 8;
blueOffset = (cbValue * 454) >> 8;
}
{
@@ -224,7 +224,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((blue | green | red) >> 8) {
if ((red | green | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -238,7 +238,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((blue | green | red) >> 8) {
if ((red | green | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -252,7 +252,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((blue | green | red) >> 8) {
if ((red | green | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -266,7 +266,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((blue | green | red) >> 8) {
if ((red | green | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -285,20 +285,20 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
}
static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 column;
u8* luminance;
u8* cb;
u8* cr;
TMCCJPEGDecState* state;
s32 tileWidth;
u8* texture;
s32 width;
s32 height;
s32 xEnd;
s32 yEnd;
s32 lumaSkip;
s32 chromaSkip;
s32 tileRow;
s32 xEnd;
u8* texture;
TMCCJPEGDecState* state;
u8* luminance;
u8* cb;
s32 width;
s32 height;
u8* cr;
s32 column;
s32 lumaSkip;
s32 yEnd;
s32 tileWidth;
u16* output;
s32 cbValue;
s8 crValue;
@@ -345,7 +345,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
red = blue + redOffset;
green = blue + greenOffset;
blue = blue + blueOffset;
if ((blue | red | green) >> 8) {
if ((green | red | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -366,11 +366,11 @@ static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 chromaSkip;
s32 blue;
s32 lumaSkip;
s32 cbValue;
s32 tileWidth;
TMCCJPEGDecState* state;
s32 xEnd;
u16* output;
u8* texture;
s32 width;
s32 height;
@@ -379,7 +379,7 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
s32 red;
u8* cr;
s32 column;
u16* output;
s32 xEnd;
s32 yEnd;
s32 redOffset;
s32 tileRow;
@@ -387,7 +387,7 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
s32 blueOffset;
s32 value;
s32 green;
s32 lumaSkip;
s32 blue;
s32 crValue;
luminance = work->convBuf + 4;
@@ -415,7 +415,7 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((blue | red | green) >> 8) {
if ((red | green | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -426,7 +426,7 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((blue | red | green) >> 8) {
if ((red | green | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -441,21 +441,21 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
}
static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 column;
u8* luminance;
u8* cb;
s32 blue;
u16* output;
s32 xEnd;
u8* cr;
TMCCJPEGDecState* state;
s32 tileWidth;
u8* texture;
u8* luminance;
s32 width;
s32 height;
s32 xEnd;
s32 yEnd;
s32 lumaSkip;
u8* cb;
u8* texture;
s32 column;
s32 chromaSkip;
s32 yEnd;
s32 tileRow;
u16* output;
s32 cbValue;
s32 crValue;
s32 redOffset;
@@ -463,7 +463,7 @@ static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
s32 blueOffset;
s32 value;
s32 red;
s32 blue;
s32 lumaSkip;
s32 green;
luminance = work->convBuf + 4;
@@ -502,7 +502,7 @@ static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
red = value + redOffset;
blue = value + blueOffset;
green = value + greenOffset;
if ((blue | red | green) >> 8) {
if ((red | green | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -517,19 +517,19 @@ static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
}
static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 blue;
s32 tileRow;
s8 crValue;
s32 chromaSkip;
u8* luminance;
TMCCJPEGDecState* state;
s32 xEnd;
u8* texture;
s32 width;
s32 height;
s32 blueOffset;
u8* texture;
s32 green;
s32 blue;
s32 lumaSkip;
s32 yEnd;
s32 tileRow;
s32 xEnd;
s32 value;
s32 column;
u8* cr;
@@ -538,7 +538,7 @@ static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
s32 redOffset;
u8* cb;
u16* output;
s32 green;
s32 blueOffset;
s32 red;
s32 cbValue;
@@ -578,7 +578,7 @@ static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
if ((blue | green | red) >> 8) {
if ((red | green | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -593,7 +593,7 @@ static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((blue | green | red) >> 8) {
if ((red | green | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -620,11 +620,11 @@ static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
u8* luminance = work->convBuf + 4;
u8* cb = work->convBuf + 260;
u8* cr = work->convBuf + 324;
s32 width;
TMCCJPEGDecState* state = work->pState;
s32 tileWidth = (state->convWidth >> 2) << 1;
u8* texture = state->pTexBuffer;
s32 width;
u8* cr = work->convBuf + 324;
s32 height;
if (state->dataSizeX == (u32)x) {
width = state->stepXExt;
@@ -660,7 +660,7 @@ static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
s32 green = value + greenOffset;
s32 red = value + redOffset;
s32 blue = value + blueOffset;
if ((blue | red | green) >> 8) {
if ((green | red | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -686,7 +686,7 @@ static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
u16* output;
s32 column;
s32 tileRow;
s32 redOffset;
TMCCJPEGDecState* state;
s32 lumaSkip;
@@ -695,7 +695,7 @@ static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
u8* cb;
u8* cr;
s32 height;
s32 tileRow;
s32 column;
s32 chromaSkip;
s32 width;
s32 xEnd;
@@ -742,7 +742,7 @@ static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((blue | red | green) >> 8) {
if ((red | green | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -770,7 +770,7 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
u16* output;
s32 lumaSkip;
s32 blue;
s32 tileRow;
u8* texture;
u8* luminance;
u8* cb;
u8* cr;
@@ -783,7 +783,7 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
s32 greenOffset;
s32 yEnd;
s32 cbValue;
u8* texture;
s32 tileRow;
s32 blueOffset;
s32 red;
s8 crValue;
@@ -831,7 +831,7 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((blue | red | green) >> 8) {
if ((red | green | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -856,20 +856,20 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
static void TMCJPEGDEC_converterYUV444toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
u16* output;
s32 tileWidth;
s32 tileRow;
s32 xEnd;
s32 rowSkip;
u8* texture;
u8* luminance;
u8* cb;
u8* cr;
TMCCJPEGDecState* state;
s8 crValue;
s32 crValue;
s32 height;
s32 width;
s32 column;
s32 rowSkip;
s32 xEnd;
s32 yEnd;
u8* texture;
s32 tileWidth;
s32 row;
s32 red;
s32 cbValue;
@@ -899,7 +899,7 @@ static void TMCJPEGDEC_converterYUV444toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + (-(cbValue * 88 + crValue * 183) >> 8);
red = value + ((crValue * 359) >> 8);
blue = value + ((cbValue * 454) >> 8);
if ((blue | red | green) >> 8) {
if ((red | green | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;

View File

@@ -171,9 +171,7 @@ s32 TMCJPEGDEC_set_converterY8U8V8(TMCCJPEGDecWork* work) {
static void TMCJPEG_814EFEAC(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 rowSkip;
u8* output;
s32 chromaXEnd;
u32 tileRow;
u32 chromaTileWidth;
s32 chromaYEnd;
u8* lumaTexture;
TMCCJPEGDecState* state;
@@ -216,17 +214,17 @@ static void TMCJPEG_814EFEAC(TMCCJPEGDecWork* work, s32 x, s32 y) {
}
luminance += rowSkip;
}
chromaTileWidth = state->chromaWidth >> 3;
tileWidth = state->chromaWidth >> 3;
x = (u32)x >> 2;
width = 8 / state->scaleFactor;
height = 8 / state->scaleFactor;
chromaXEnd = x + width;
xEnd = x + width;
chromaYEnd = y + height;
for (; y < chromaYEnd; y++) {
for (column = x; column < chromaXEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
for (column = x; column < xEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cb + 128;
cb++;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cr + 128;
cr++;
}
cb += 8 - width;
@@ -235,7 +233,6 @@ static void TMCJPEG_814EFEAC(TMCCJPEGDecWork* work, s32 x, s32 y) {
}
static void TMCJPEG_814F043C(TMCCJPEGDecWork* work, s32 x, s32 y) {
u32 chromaTileWidth;
TMCCJPEGDecState* state;
u8* lumaTexture;
u8* luminance;
@@ -250,9 +247,9 @@ static void TMCJPEG_814F043C(TMCCJPEGDecWork* work, s32 x, s32 y) {
u8* output;
u8* cb;
u8* cr;
s32 xEnd;
s32 tileOffset;
s32 width;
s32 tileOffset;
s32 xEnd;
u32 tileWidth;
luminance = work->convBuf + 4;
@@ -287,13 +284,13 @@ static void TMCJPEG_814F043C(TMCCJPEGDecWork* work, s32 x, s32 y) {
x = (u32)x >> 2;
width = (width + 3) >> 2;
xEnd = x + width;
chromaTileWidth = state->chromaWidth >> 3;
tileWidth = state->chromaWidth >> 3;
chromaEnd = y + height;
for (; y < chromaEnd; y++) {
for (column = x; column < xEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cb + 128;
cb++;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cr + 128;
cr++;
}
cb += 8 - width;
@@ -306,9 +303,7 @@ static void TMCJPEG_814F0A58(TMCCJPEGDecWork* work, s32 x, s32 y) {
u8* lumaTexture;
u8* luminance;
s32 column;
s32 chromaXEnd;
s32 row;
u32 chromaTileWidth;
TMCCJPEGDecState* state;
s32 width;
s32 height;
@@ -319,7 +314,6 @@ static void TMCJPEG_814F0A58(TMCCJPEGDecWork* work, s32 x, s32 y) {
u8* cb;
u32 tileWidth;
u8* cr;
s32 chromaRowSkip;
row = y;
luminance = work->convBuf + 4;
@@ -344,24 +338,22 @@ static void TMCJPEG_814F0A58(TMCCJPEGDecWork* work, s32 x, s32 y) {
x = (u32)x >> 1;
width = 8 / state->scaleFactor;
height = 8 / state->scaleFactor;
chromaXEnd = x + width;
xEnd = x + width;
chromaYEnd = y + height;
chromaTileWidth = state->chromaWidth >> 3;
chromaRowSkip = 8 - width;
for (; y < chromaYEnd; y++) {
for (column = x; column < chromaXEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
tileWidth = state->chromaWidth >> 3;
for (row = y; row < chromaYEnd; row++) {
for (column = x; column < xEnd; column += 1) {
(cbTexture + ((row & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (row >> 2) * tileWidth) << 5)] = *cb + 128;
cb++;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
(crTexture + ((row & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (row >> 2) * tileWidth) << 5)] = *cr + 128;
cr++;
}
cb += chromaRowSkip;
cb += 8 - width;
cr += 8 - width;
}
}
static void TMCJPEG_814F11C4(TMCCJPEGDecWork* work, s32 x, s32 y) {
u32 chromaTileWidth;
TMCCJPEGDecState* state;
u8* lumaTexture;
u8* luminance;
@@ -376,9 +368,9 @@ static void TMCJPEG_814F11C4(TMCCJPEGDecWork* work, s32 x, s32 y) {
u8* output;
u8* cb;
u8* cr;
s32 xEnd;
s32 tileOffset;
s32 width;
s32 tileOffset;
s32 xEnd;
u32 tileWidth;
luminance = work->convBuf + 4;
@@ -413,13 +405,13 @@ static void TMCJPEG_814F11C4(TMCCJPEGDecWork* work, s32 x, s32 y) {
x = (u32)x >> 1;
width = (width + 1) >> 1;
xEnd = x + width;
chromaTileWidth = state->chromaWidth >> 3;
tileWidth = state->chromaWidth >> 3;
chromaEnd = y + height;
for (; y < chromaEnd; y++) {
for (column = x; column < xEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cb + 128;
cb++;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cr + 128;
cr++;
}
cb += 8 - width;
@@ -428,23 +420,21 @@ static void TMCJPEG_814F11C4(TMCCJPEGDecWork* work, s32 x, s32 y) {
}
static void TMCJPEG_814F17E0(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 height;
s32 chromaYEnd;
s32 column;
u8* lumaTexture;
s32 chromaXEnd;
s32 height;
u8* luminance;
u32 chromaTileWidth;
s32 column;
u8* cbTexture;
s32 width;
s32 row;
u8* crTexture;
u32 tileWidth;
s32 xEnd;
u8* cb;
TMCCJPEGDecState* state;
s32 yEnd;
s32 xEnd;
s32 width;
u8* cr;
s32 row;
u32 tileWidth;
row = y;
luminance = work->convBuf + 4;
@@ -470,14 +460,14 @@ static void TMCJPEG_814F17E0(TMCCJPEGDecWork* work, s32 x, s32 y) {
y = (u32)y >> 1;
width = 8 / state->scaleFactor;
height = 8 / state->scaleFactor;
chromaXEnd = x + width;
xEnd = x + width;
chromaYEnd = y + height;
chromaTileWidth = state->chromaWidth >> 3;
tileWidth = state->chromaWidth >> 3;
for (; y < chromaYEnd; y++) {
for (column = x; column < chromaXEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
for (column = x; column < xEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cb + 128;
cb++;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cr + 128;
cr++;
}
cb += 8 - width;
@@ -486,7 +476,6 @@ static void TMCJPEG_814F17E0(TMCCJPEGDecWork* work, s32 x, s32 y) {
}
static void TMCJPEG_814F1F48(TMCCJPEGDecWork* work, s32 x, s32 y) {
u32 chromaTileWidth;
TMCCJPEGDecState* state;
u8* lumaTexture;
u8* luminance;
@@ -497,13 +486,13 @@ static void TMCJPEG_814F1F48(TMCCJPEGDecWork* work, s32 x, s32 y) {
u8* crTexture;
u32 tileRow;
s32 height;
s32 yEnd;
s32 width;
u8* output;
u8* cb;
u8* cr;
s32 xEnd;
s32 tileOffset;
s32 width;
s32 yEnd;
u32 tileWidth;
luminance = work->convBuf + 4;
@@ -539,13 +528,13 @@ static void TMCJPEG_814F1F48(TMCCJPEGDecWork* work, s32 x, s32 y) {
x = (u32)x >> 1;
width = (width + 1) >> 1;
xEnd = x + width;
chromaTileWidth = state->chromaWidth >> 3;
tileWidth = state->chromaWidth >> 3;
chromaEnd = y + ((height + 1) >> 1);
for (; y < chromaEnd; y++) {
for (column = x; column < xEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cb + 128;
cb++;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cr + 128;
cr++;
}
cb += 8 - width;
@@ -554,9 +543,8 @@ static void TMCJPEG_814F1F48(TMCCJPEGDecWork* work, s32 x, s32 y) {
}
static void TMCJPEG_814F2570(TMCCJPEGDecWork* work, s32 x, s32 y) {
u32 chromaTileWidth;
TMCCJPEGDecState* state;
u8* lumaTexture;
TMCCJPEGDecState* state;
u8* luminance;
s32 column;
s32 row;
@@ -596,13 +584,13 @@ static void TMCJPEG_814F2570(TMCCJPEGDecWork* work, s32 x, s32 y) {
luminance += 8 - width;
}
y = (u32)y >> 1;
chromaTileWidth = state->chromaWidth >> 3;
tileWidth = state->chromaWidth >> 3;
chromaEnd = y + 8 / state->scaleFactor;
for (; y < chromaEnd; y++) {
for (column = x; column < xEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cb + 128;
cb++;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * tileWidth) << 5)] = *cr + 128;
cr++;
}
cb += 8 - width;

View File

@@ -163,12 +163,12 @@ typedef struct _ziGetParam {
ziWChar* candidates; // 0x18
ziU8 maxCandidates; // 0x1C
ziWChar firstCandidate; // 0x1E
ziU8 unk_0x20; // 0x20
ziU8 count; // 0x20 (EZTXGetParam.count)
ziU8 letters; // 0x21
ziU8 count; // 0x22
ziU8* scratch; // 0x24
ziU32 unk_0x28; // 0x28
ziU8 letters; // 0x21
ziU8 completion; // 0x22 (EZTXGetParam.completion)
ziU8* scratch; // 0x24
ziU32 unk_0x28; // 0x28
} ziGetParam;
typedef struct _ziLanguageEntry {
@@ -195,7 +195,7 @@ typedef struct _zi8DawgCtx {
ziU8* table; // 0x10
ziU8* p14; // 0x14
zi8DawgRec recs[0x32]; // 0x18
ziU32 unk_0x338; // 0x338
ziU32 endNode; // 0x338
} zi8DawgCtx;
typedef struct _ziUwdNode {
@@ -204,34 +204,34 @@ typedef struct _ziUwdNode {
} ziUwdNode;
struct __zi8_work_data_s {
ziU8 unk_0x00;
ziU8 unk_0x01;
ziU8 getcPhase; // 0x00
ziU8 countOnly; // 0x01
ziU8 unk_0x02[2];
ziLanguageEntry* langEntries; // 0x04
ziU8 unk_0x08;
ziU8 unk_0x09;
ziU8 unk_0x0A;
ziU8 maxWordLength;
ziU8 unk_0x0B;
ziU32 unk_0x0C;
ziU32 targetCount; // 0x0C
ziU32 unk_0x10;
ziU16 unk_0x14;
ziU8 unk_0x16;
ziU8 unk_0x17;
ziU8 unk_0x18;
ziU8 cangjieEnabled; // 0x16
ziU8 zhPudMinPrefix;
ziU8 subLanguage; // 0x18
ziU8 unk_0x19;
ziU16 unk_0x1A;
ziU16 separator; // 0x1A
ziU8 unk_0x1C[3];
ziU8 unk_0x1F;
ziU8 ignoreCase;
ziU16 unk_0x20[0x40];
ziU16 unk_0xA0[0x42];
ziU16* unk_0x124[1];
ziU8* unk_0x128;
ziU8 unk_0x12C;
ziU8 uwdPtrCount; // 0x12C
ziU8 unk_0x12D;
ziU8 unk_0x12E;
ziU8 uwdPrioritySort; // 0x12E
ziU8 unk_0x12F;
ziPtr unk_0x130[2];
ziU8 unk_0x138;
ziPtr uwdDicts[2]; // 0x130
ziU8 uwdDictCount; // 0x138
ziU8 unk_0x139[3];
ziU32 unk_0x13C;
ziU8 unk_0x140;
@@ -258,32 +258,32 @@ 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];
ziPtr unk_0x11FC;
ziPtr userKeys[0x83]; // 0x1200
ziU8 unk_0x140C[4];
ziU32 unk_0x1410;
ziU32 formats; // 0x1410
ziU8 unk_0x1414[4];
ziU8 unk_0x1418;
ziU8 formatCount;
ziU8 unk_0x1419;
ziU16 unk_0x141A;
ziU8 unk_0x141C;
ziU8 unk_0x141D;
ziU8 unk_0x141E;
ziU8 unk_0x141F;
ziU16 capacity; // 0x141A
ziU8 forceAltGraph; // 0x141C (lang FI + group 0xC -> graphTableId 0x10)
ziU8 advanceGroup; // 0x141D (nonzero: skip first dawg group)
ziU8 graphTableId; // 0x141E
ziU8 maxCnt; // 0x141F
ziU8 unk_0x1420[4];
zi8DawgCtx dawgCtx; // 0x1424
ziU8 unk_0x1760[4]; // 0x1760
ziU8* unk_0x1764; // 0x1764
ziU8* groupPtr; // 0x1764
ziU8 unk_0x1768;
ziU8 unk_0x1769[0x81];
ziU16 unk_0x17EA;
ziU16 matchOffset; // 0x17EA
ziU8 unk_0x17EC;
ziU8 unk_0x17ED[3];
ziU8* unk_0x17F0;
ziU8* dawgGroup; // 0x17F0
ziWChar unk_0x17F4[0x40]; // 0x17F4..0x1874
ziU16 unk_0x1874;
ziU8 unk_0x1876;
@@ -309,26 +309,26 @@ struct __zi8_work_data_s {
ziWChar unk_0x1A92[0x41];
ziU8 unk_0x1B14;
ziU8 unk_0x1B15[3];
ziU16* unk_0x1B18;
ziU16 unk_0x1B1C;
ziU16 unk_0x1B1E;
ziU16 unk_0x1B20;
ziU16 unk_0x1B22;
ziU8 unk_0x1B24;
ziU16* unicodeMap; // 0x1B18
ziU16 unicodeRange1Min; // 0x1B1C
ziU16 unicodeRange1Max; // 0x1B1E
ziU16 unicodeRange2Min; // 0x1B20
ziU16 unicodeRange2Max; // 0x1B22
ziU8 unicodeMapSubLang; // 0x1B24
ziU8 unk_0x1B25[3];
union {
ziU32 word;
struct {
ziU32 msb : 1;
} bits;
} unk_0x1B28;
} pyFuzzy; // 0x1B28
union {
ziU32 word;
struct {
ziU32 msb : 1;
} bits;
} unk_0x1B2C;
ziU8 unk_0x1B30;
ziU8 koAltTables; // 0x1B30
ziU8 unk_0x1B31;
ziU16 unk_0x1B32;
ziU16 unk_0x1B34;

View File

@@ -21,7 +21,7 @@ ziS32 Zi8Punctuation(ziGetParam* param ZI_NEED_WORK) {
}
if (fc == 0) {
count++;
if (ZI_WORK->unk_0x00 == 0) {
if (ZI_WORK->getcPhase == 0) {
param->candidates[i++] = Zi8PunctTable[j];
if ((param->context & 0x10) != 0) {
param->candidates[i++] = 0x20;
@@ -33,7 +33,7 @@ ziS32 Zi8Punctuation(ziGetParam* param ZI_NEED_WORK) {
break;
}
} else {
if (count >= (ziS32)ZI_WORK->unk_0x0C) {
if (count >= (ziS32)ZI_WORK->targetCount) {
return count;
}
}
@@ -42,7 +42,7 @@ ziS32 Zi8Punctuation(ziGetParam* param ZI_NEED_WORK) {
}
j++;
}
if (ZI_WORK->unk_0x00 == 0) {
if (ZI_WORK->getcPhase == 0) {
param->letters = count;
}
return count;

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

@@ -27,11 +27,11 @@ ziPtr Zi8GetTableAddress(ziU8, ziU8 ZI_NEED_WORK);
ziWChar Zi8ConvertUC2UserKey(ziChar, ziU8 ZI_NEED_WORK);
ziWChar Zi8ConvertUC2WC(ziChar character, ziU8 language ZI_NEED_WORK) {
ziU8* table;
const ziConversionTables* defaults;
ziWChar* mapped;
ziU8* cursor;
ziU16 first, last;
const ziConversionTables* defaults;
ziU8* table;
if (character == 0) {
Zi8LogError(0x133, __zi8_work_data);
return 0;

View File

@@ -796,11 +796,11 @@ Zi8UInt Zi8Get1KeyPressSpelling(Zi8OneKeyParam *params,Zi8OneKeyOptions *options
if (remaining != 0) {
remaining--;
} else {
totalCandidates++;
totalCandidates = totalCandidates + 1;
if (options->countOnly == '\0') {
*output++ = spellingBuffer[spellingIndex];
*output++ = 0;
candidateCount++;
candidateCount = candidateCount + 1;
}
else if ((int)totalCandidates >= options->maxCount) goto finishSpelling;
if (candidateCount >= params->maxCandidates) goto finishSpelling;
@@ -940,8 +940,7 @@ Zi8UInt Zi8Get1KeyPressSpelling(Zi8OneKeyParam *params,Zi8OneKeyOptions *options
for (tableIndex = 0; tableIndex < params->count;) {
while (*output != 0) {
if (*output != 0x27) {
*output |= 0xf300;
output++;
*output++ |= 0xf300;
} else {
*output++ = 0xf360;
}
@@ -1001,10 +1000,10 @@ Zi8UInt Zi8Get1KeyPressSpelling(Zi8OneKeyParam *params,Zi8OneKeyOptions *options
}
if (Zi8IsDupWordW(output,(ziU8)phoneticIndex,work) == 0) {
if (remaining == 0) {
totalCandidates++;
totalCandidates = totalCandidates + 1;
if (options->countOnly == 0) {
output += phoneticIndex + 1;
candidateCount++;
++candidateCount;
} else if ((int)totalCandidates >= options->maxCount) goto finishSpelling;
if (candidateCount >= params->maxCandidates) goto finishSpelling;
} else {

View File

@@ -2,14 +2,14 @@
#include <zi8clib/zitypes.h>
ziU32 Zi8GetZHuwdPtr(ziU32* arg0, ziU16* arg1 ZI_NEED_WORK) {
if (ZI_WORK->unk_0x12C == 0) {
if (ZI_WORK->uwdPtrCount == 0) {
*arg0 = 0;
*arg1 = 0;
Zi8LogError(0x1A5, ZI_WORK);
return 0;
} else {
*arg1 = ZI_WORK->unk_0x124[ZI_WORK->unk_0x12C - 1][1] / 3;
*arg0 = (ziU32)ZI_WORK->unk_0x124[ZI_WORK->unk_0x12C - 1];
*arg1 = ZI_WORK->unk_0x124[ZI_WORK->uwdPtrCount - 1][1] / 3;
*arg0 = (ziU32)ZI_WORK->unk_0x124[ZI_WORK->uwdPtrCount - 1];
*arg0 += 8;
Zi8LogError(0x64, ZI_WORK);
return 1;

View File

@@ -285,9 +285,9 @@ static ziBool ZiIsLetterHyphen(ziWChar character ZI_NEED_WORK) {
else return ZI8_FALSE;
}
void Zi8ChangeWordCase(ziWChar* word, ziU8 language, ziPtr work) {
void Zi8ChangeWordCase(ziWChar* word, ziU8 language, ZiAlphaWork* work) {
enum { LOWER_CASE, UPPER_CASE } upper = LOWER_CASE;
if (((ZiAlphaWork*)work)->caseMode == 3) {
if (work->caseMode == 3) {
Zi8ChangeCharCase(1, word++, language, work);
} else if (((ZiAlphaWork*)work)->caseMode == 1) {
upper = UPPER_CASE;

View File

@@ -18,7 +18,7 @@ static Zi8UInt Zi8SetFindCand(ziU8* foundCandidates, Zi8UInt ordinal, ziPtr work
}
ziWChar* ZiGetNextPhonetic(ziWChar* spelling, ziWChar* end ZI_NEED_WORK) {
while (*spelling && *spelling != ZI_WORK->unk_0x1A && *spelling != 0xF360 && spelling < end) {
while (*spelling && *spelling != ZI_WORK->separator && *spelling != 0xF360 && spelling < end) {
++spelling;
}
if (!*spelling || spelling == end) {
@@ -37,8 +37,8 @@ int ZiPartialMatch(ziWChar* spelling, ziWChar* spellingEnd,
if (spelling == spellingEnd || candidate == candidateEnd || !*spelling || !*candidate) {
return 1;
}
while (*spelling != ZI_WORK->unk_0x1A && *spelling != 0xF360) {
if (*candidate == ZI_WORK->unk_0x1A || *candidate == 0xF360) {
while (*spelling != ZI_WORK->separator && *spelling != 0xF360) {
if (*candidate == ZI_WORK->separator || *candidate == 0xF360) {
break;
}
if (*spelling != *candidate) {
@@ -425,12 +425,12 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
charset <<= 4;
skipCount = request->firstCandidate;
request->letters = 0;
request->completion = 0;
request->count = 0;
request->unk_0x20 = 0;
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;
}
@@ -577,27 +577,27 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
if (getMode == 1) {
switch ((int)match.phon2[index] >> 9) {
case 24: case 25:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->cANDch) ordinalIndex = 0xFDFF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->cANDch) ordinalIndex = 0xFDFF;
break;
case 26: case 27:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->sANDsh) ordinalIndex = 0xFDFF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->sANDsh) ordinalIndex = 0xFDFF;
break;
case 28: case 29:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->zANDzh) ordinalIndex = 0xFDFF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->zANDzh) ordinalIndex = 0xFDFF;
break;
case 56: case 59:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->fANDh) ordinalIndex = 0xF9FF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->fANDh) ordinalIndex = 0xF9FF;
break;
case 38:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->nANDl) ordinalIndex = 0xE5FF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->nANDl) ordinalIndex = 0xE5FF;
break;
case 43:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->nANDl && ((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->lANDr) ordinalIndex = 0xE1FF;
else if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->lANDr) ordinalIndex = 0xF1FF;
else if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->nANDl) ordinalIndex = 0xE5FF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->nANDl && ((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->lANDr) ordinalIndex = 0xE1FF;
else if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->lANDr) ordinalIndex = 0xF1FF;
else if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->nANDl) ordinalIndex = 0xE5FF;
break;
case 44:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->lANDr) ordinalIndex = 0xF1FF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->lANDr) ordinalIndex = 0xF1FF;
break;
}
} else {
@@ -650,13 +650,13 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
if (getMode == 1) {
switch (match.phon2[index] & 0x1F0) {
case 0x10: case 0x80: case 0x100:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->anANDang) ordinalIndex = 0xFFF7;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->anANDang) ordinalIndex = 0xFFF7;
break;
case 0x180:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->enANDeng) ordinalIndex = 0xFFF7;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->enANDeng) ordinalIndex = 0xFFF7;
break;
case 0x60:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->inANDing) ordinalIndex = 0xFFF7;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->inANDing) ordinalIndex = 0xFFF7;
break;
}
} else {
@@ -720,7 +720,7 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
return 0;
}
emitWords = 1;
if (request->count) request->count = request->elementCount;
if (request->completion) request->completion = request->elementCount;
}
if (!options->candidateMode) Zi8InitDupWordBuf(work);
records = (ziU8*)Zi8GetTableAddress(1, 0, work);
@@ -753,8 +753,7 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
if (!componentTable) {
componentCount = Zi8GetTableCount(1, 7, work);
componentOrdinals = (ziU8*)Zi8GetTableAddress(1, 7, work);
componentCursor = (ziU8*)Zi8GetTableAddress(1, 2, work);
componentTable = componentCursor;
componentTable = componentCursor = (ziU8*)Zi8GetTableAddress(1, 2, work);
componentCursor += 8;
--componentCount;
componentIndex = componentCount;
@@ -931,13 +930,13 @@ engine_search:
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) {
request->letters = emittedCount;
request->unk_0x20 = emittedCount;
request->count = emittedCount;
goto engine_finish;
}
} else output[emittedCount++] = character;
if (emittedCount >= request->maxCandidates) {
request->letters = emittedCount;
request->unk_0x20 = emittedCount;
request->count = emittedCount;
goto engine_finish;
}
}
@@ -982,7 +981,7 @@ pud_candidate:
++rangeIndex;
}
if (rangeIndex == request->elementCount) {
if (!(request->context & 0x10)) request->count = request->elementCount;
if (!(request->context & 0x10)) request->completion = request->elementCount;
candidateStatus = 1;
character = currentSpelling[wordLength];
candidateOrdinal = 0xFFFF;
@@ -1109,13 +1108,13 @@ pud_charset:
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) {
request->letters = emittedCount;
request->unk_0x20 = emittedCount;
request->count = emittedCount;
goto engine_finish;
}
} else output[emittedCount++] = character;
if (emittedCount >= request->maxCandidates) {
request->letters = emittedCount;
request->unk_0x20 = emittedCount;
request->count = emittedCount;
goto engine_finish;
}
}
@@ -1151,7 +1150,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;
@@ -1303,13 +1302,13 @@ context_word_lookup:
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) {
request->letters = emittedCount;
request->unk_0x20 = emittedCount;
request->count = emittedCount;
goto engine_finish;
}
} else output[emittedCount++] = previousOrdinal;
if (emittedCount >= request->maxCandidates) {
request->letters = emittedCount;
request->unk_0x20 = emittedCount;
request->count = emittedCount;
goto engine_finish;
}
}
@@ -1322,7 +1321,7 @@ context_phrase_next:
}
}
context_results_done:
if (request->wordCharCount) request->unk_0x20 = emittedCount;
if (request->wordCharCount) request->count = emittedCount;
if (getOptions == 5) goto engine_finish;
if ((wordLength && (getMode == 1 || getMode == 2) && match.nCand > 1) ||
(wordLength && getMode == 0 && match.nSeg > 1)) {
@@ -1753,7 +1752,7 @@ tone_candidates:
}
}
user_character_search:
if (((struct __zi8_work_data_s*)work)->unk_0x12C && (getMode != 0 || !firstPhoneticPass) &&
if (((struct __zi8_work_data_s*)work)->uwdPtrCount && (getMode != 0 || !firstPhoneticPass) &&
!options->countOnly && (match.nCand <= 1 || (getMode != 1 && getMode != 2)) &&
Zi8GetZHuwdPtr(&userEntries, &userCount, work) && (getMode != 0 || match.nSeg <= 1)) {
userIndex = 0;
@@ -1965,7 +1964,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;
@@ -2573,7 +2572,7 @@ filtered_accept:
if (totalResults >= options->maxResults) goto engine_finish;
} else if (!options->countOnly) {
if (++((ZiChineseWork*)work)->duplicateIndex >= 64) ((ZiChineseWork*)work)->duplicateIndex = 0;
if (filteringMode == 4) request->unk_0x20 = emittedCount + 1;
if (filteringMode == 4) request->count = emittedCount + 1;
if (emitWords) {
++emittedCount;
outputIndex += rangeCount;
@@ -2869,7 +2868,7 @@ ziU8 Zi8GetElementCount(ziWChar* elements, ziU8 elementCount, ziU8 charCount ZI_
ziU8 count;
ziWChar spacedElements[256];
struct { ziWChar separator; } savedState;
savedState.separator = ZI_WORK->unk_0x1A;
savedState.separator = ZI_WORK->separator;
if (elementCount <= 1 || !charCount) {
return elementCount;
}
@@ -2882,9 +2881,9 @@ ziU8 Zi8GetElementCount(ziWChar* elements, ziU8 elementCount, ziU8 charCount ZI_
if (spacedIndex == elementCount) {
return elementCount;
}
ZI_WORK->unk_0x1A = 0xF360;
ZI_WORK->separator = 0xF360;
Zi8ZHaddSpace(elements, elementCount, spacedElements, 256, __zi8_work_data);
ZI_WORK->unk_0x1A = savedState.separator;
ZI_WORK->separator = savedState.separator;
spacedIndex = elementIndex = count = 0;
while (charCount && elementIndex < elementCount) {
if (spacedElements[spacedIndex] == 0xF360) {

View File

@@ -32,17 +32,17 @@ ziU32 Zi8MatchROMdata0(ziWChar* elements, ziU8 count, ziU8 language,
if (language != context->lang || graphTable != context->key) records[0].key = 0;
if (count == 1 && mode != 0 && graphTable == 0xe) goto finish_graph;
if (status != 0) {
if (records[context->cnt - 1].node == (ziU8*)context->unk_0x338) goto finish_graph;
if (records[context->cnt - 1].node == (ziU8*)context->endNode) goto finish_graph;
for (index = 0; index < count; index++) {
if (records[index].key != elements[index] &&
(ziU16)records[index].attr != elements[index]) goto finish_graph;
}
if (mode == 1) acceptPrefix = 0;
} else {
if (ZI_WORK->unk_0x141E != 0 && graphTable == 0xc &&
Zi8GetTableSize(language, ZI_WORK->unk_0x141E, ZI_WORK) != 0) {
graphData = (ziU8*)Zi8GetTableAddress(language, ZI_WORK->unk_0x141E, ZI_WORK);
keyTable = ZI_WORK->unk_0x141E + 1;
if (ZI_WORK->graphTableId != 0 && graphTable == 0xc &&
Zi8GetTableSize(language, ZI_WORK->graphTableId, ZI_WORK) != 0) {
graphData = (ziU8*)Zi8GetTableAddress(language, ZI_WORK->graphTableId, ZI_WORK);
keyTable = ZI_WORK->graphTableId + 1;
} else {
if (Zi8GetTableSize(language, graphTable, ZI_WORK) == 0) {
Zi8LogError(0x961, ZI_WORK);
@@ -82,7 +82,7 @@ check_keys:
records[0].node = ZiDAWGGetGraphInfo(context, keyData, (ziS16*)keys);
} else {
records[0].node = ZiDAWGGetGraph(context);
context->unk_0x338 = 0;
context->endNode = 0;
context->p14 = 0;
}
records[0].key = 0;
@@ -98,7 +98,7 @@ check_keys:
}
searching = 1;
current = &records[context->cnt - 1];
while (searching && context->cnt != 0 && current->node != (ziU8*)context->unk_0x338) {
while (searching && context->cnt != 0 && current->node != (ziU8*)context->endNode) {
if (capacity < context->cnt) goto finish_graph;
current->attr = ZiDAWGgetCHARattribute(context, current->node, ZI_WORK);
if (context->cnt <= count) {
@@ -136,7 +136,7 @@ descend:
records[context->cnt].node = ZiDAWGGetChild(records[context->cnt - 1].node);
if (records[context->cnt].node == (ziU8*)0) goto next_sibling;
context->cnt++;
if (ZI_WORK->unk_0x141F < context->cnt) ZI_WORK->unk_0x141F = context->cnt;
if (ZI_WORK->maxCnt < context->cnt) ZI_WORK->maxCnt = context->cnt;
goto update_current;
next_sibling:
while (context->cnt != 0) {
@@ -159,7 +159,7 @@ ziU8* NextDawgGroup(ziU8* group, ziU8 language, ziPtr __zi8_work_data)
Zi8LogError(0x962,ZI_WORK);
return 0;
}
if (ZI_WORK->unk_0x141D == 0) {
if (ZI_WORK->advanceGroup == 0) {
return group;
}
}
@@ -184,37 +184,36 @@ unsigned int Zi8MatchROMdata1(ziWChar *elements, ziU8 count, ziU8 language, ziWC
result = 0;
if (status == 0) {
ZI_WORK->unk_0x1764 = (ziU8*)group;
if (ZI_WORK->unk_0x1764 == 0) {
ZI_WORK->groupPtr = (ziU8*)group;
if (ZI_WORK->groupPtr == 0) {
if (Zi8GetTableSize(language & 0xff,0xb,ZI_WORK) != 0) {
tableAddress = Zi8GetTableAddress(language & 0xff,0xb,ZI_WORK);
ZI_WORK->unk_0x1764 = (ziU8*)tableAddress;
ZI_WORK->groupPtr = (ziU8*)(tableAddress = Zi8GetTableAddress(language & 0xff,0xb,ZI_WORK));
}
}
if (ZI_WORK->unk_0x1764 != 0) {
for (; (*ZI_WORK->unk_0x1764 != 0xff && ((groupIndex & 0xff) != 0));
if (ZI_WORK->groupPtr != 0) {
for (; (*ZI_WORK->groupPtr != 0xff && ((groupIndex & 0xff) != 0));
groupIndex = groupIndex - 1) {
while (*ZI_WORK->unk_0x1764 != 0xff) {
ZI_WORK->unk_0x1764 += 2;
while (*ZI_WORK->groupPtr != 0xff) {
ZI_WORK->groupPtr += 2;
}
ZI_WORK->unk_0x1764++;
ZI_WORK->groupPtr++;
}
}
}
if (ZI_WORK->unk_0x1764 == 0) {
if (ZI_WORK->groupPtr == 0) {
result = Zi8MatchROMdata0(elements,count,language & 0xff,output,capacity & 0xffff,
mode & 0xff,status & 0xff,0,1,acceptPrefix,0,&ZI_WORK->dawgCtx,
ZI_WORK->unk_0x1760,ZI_WORK);
}
else {
while (*ZI_WORK->unk_0x1764 != 0xff) {
while (*ZI_WORK->groupPtr != 0xff) {
result = Zi8MatchROMdata0(elements,count,language & 0xff,output,
capacity & 0xffff,mode & 0xff,status & 0xff,
*ZI_WORK->unk_0x1764,
ZI_WORK->unk_0x1764[1],acceptPrefix,0,
*ZI_WORK->groupPtr,
ZI_WORK->groupPtr[1],acceptPrefix,0,
&ZI_WORK->dawgCtx,ZI_WORK->unk_0x1760,ZI_WORK);
if ((result & 0xff) != 0) break;
ZI_WORK->unk_0x1764 += 2;
ZI_WORK->groupPtr += 2;
status = 0;
}
}
@@ -231,31 +230,31 @@ unsigned int Zi8MatchROMdata2(ziWChar* elements, ziU8 count, ziU8 language,
if (reservedMode != 0) return 0;
if (status == 0) {
ZI_WORK->unk_0x1768 = 0;
ZI_WORK->unk_0x17EA = 0;
if (group != 0 && *group == 0xc && language == 10 && ZI_WORK->unk_0x141C != 0) {
ZI_WORK->unk_0x141E = 0x10;
ZI_WORK->matchOffset = 0;
if (group != 0 && *group == 0xc && language == 10 && ZI_WORK->forceAltGraph != 0) {
ZI_WORK->graphTableId = 0x10;
} else {
ZI_WORK->unk_0x141E = 0;
ZI_WORK->graphTableId = 0;
}
}
search_segment:
ZI_WORK->unk_0x141F = 1;
result = Zi8MatchROMdata1(elements + ZI_WORK->unk_0x17EA,
count - ZI_WORK->unk_0x17EA, language,
&ZI_WORK->unk_0x17F4[ZI_WORK->unk_0x17EA], capacity,
ZI_WORK->maxCnt = 1;
result = Zi8MatchROMdata1(elements + ZI_WORK->matchOffset,
count - ZI_WORK->matchOffset, language,
&ZI_WORK->unk_0x17F4[ZI_WORK->matchOffset], capacity,
mode, status, ZI_WORK->unk_0x1768, (char*)group,
acceptPrefix, ZI_WORK);
if ((ziU8)result != 0) {
for (index = (ziU8)(ZI_WORK->unk_0x17EA + result); index != 0; index--) {
for (index = (ziU8)(ZI_WORK->matchOffset + result); index != 0; index--) {
output[index - 1] = ZI_WORK->unk_0x17F4[index - 1];
}
result = (ziU8)(result + ZI_WORK->unk_0x17EA);
result = (ziU8)(result + ZI_WORK->matchOffset);
} else {
if (status != 0 || count == 1) goto finish_segments;
if (mode == 1 && ZI_WORK->unk_0x1768 == 0 &&
(ziU8)Zi8MatchROMdata1(elements + ZI_WORK->unk_0x17EA,
count - ZI_WORK->unk_0x17EA, language,
&ZI_WORK->unk_0x17F4[ZI_WORK->unk_0x17EA], capacity,
(ziU8)Zi8MatchROMdata1(elements + ZI_WORK->matchOffset,
count - ZI_WORK->matchOffset, language,
&ZI_WORK->unk_0x17F4[ZI_WORK->matchOffset], capacity,
0, status, ZI_WORK->unk_0x1768, (char*)group,
acceptPrefix, ZI_WORK) != 0) goto finish_segments;
if ((Zi8GetTableCount(language, 0x1f, ZI_WORK) & 4) == 0) {
@@ -263,25 +262,25 @@ search_segment:
if (elements[index] == 0xeff1) goto finish_segments;
}
}
if (ZI_WORK->unk_0x141F > capacity) goto finish_segments;
for (index = ZI_WORK->unk_0x141F; index != 0; index--) {
result = Zi8MatchROMdata1(elements + ZI_WORK->unk_0x17EA, index, language,
&ZI_WORK->unk_0x17F4[ZI_WORK->unk_0x17EA], capacity,
if (ZI_WORK->maxCnt > capacity) goto finish_segments;
for (index = ZI_WORK->maxCnt; index != 0; index--) {
result = Zi8MatchROMdata1(elements + ZI_WORK->matchOffset, index, language,
&ZI_WORK->unk_0x17F4[ZI_WORK->matchOffset], capacity,
1, 0, ZI_WORK->unk_0x1768, (char*)group,
acceptPrefix, ZI_WORK);
if ((ziU8)result != 0) {
ZI_WORK->unk_0x17EA += (ziU8)result;
if (ZI_WORK->unk_0x17EA == count) return 0;
ZI_WORK->matchOffset += (ziU8)result;
if (ZI_WORK->matchOffset == count) return 0;
ZI_WORK->unk_0x1768++;
status = 0;
ZI_WORK->unk_0x141E = 0;
ZI_WORK->graphTableId = 0;
if (ZI_WORK->dawgCtx.key == 0 && language == 10) {
for (index = 0; index < ZI_WORK->unk_0x17EA; index++) {
for (index = 0; index < ZI_WORK->matchOffset; index++) {
switch (ZI_WORK->unk_0x17F4[index]) {
case 0x61:
case 0x6f:
case 0x75:
ZI_WORK->unk_0x141E = 0x10;
ZI_WORK->graphTableId = 0x10;
goto search_segment;
}
}
@@ -307,7 +306,7 @@ ziU32 Zi8MatchROMdata(ziWChar* elements, ziU8 count, ziU8 language,
} else {
if (status == 0) {
ZI_WORK->unk_0x17EC = 0;
ZI_WORK->unk_0x17F0 = NextDawgGroup(0, language, ZI_WORK);
ZI_WORK->dawgGroup = NextDawgGroup(0, language, ZI_WORK);
} else if (ZI_WORK->unk_0x17EC != 0) {
Zi8LogError(100, ZI_WORK);
goto finish_match;
@@ -317,30 +316,30 @@ ziU32 Zi8MatchROMdata(ziWChar* elements, ziU8 count, ziU8 language,
result = Zi8MatchROMdata2(elements, count, language, output, capacity,
mode, status, reservedMode, 0, acceptPrefix, ZI_WORK);
} else {
while (ZI_WORK->unk_0x17F0 != 0) {
while (ZI_WORK->dawgGroup != 0) {
result = Zi8MatchROMdata2(elements, count, language, output, capacity,
mode, status, reservedMode, ZI_WORK->unk_0x17F0,
mode, status, reservedMode, ZI_WORK->dawgGroup,
acceptPrefix, ZI_WORK);
if ((ziU8)result != 0) break;
status = 0;
if (count <= 1 && language == 0x36) break;
ZI_WORK->unk_0x17F0 = NextDawgGroup(ZI_WORK->unk_0x17F0, language, ZI_WORK);
ZI_WORK->dawgGroup = NextDawgGroup(ZI_WORK->dawgGroup, language, ZI_WORK);
}
}
if ((ziU8)result == 0 && status == 0 && mode == 1 && count == 1 && capacity >= 1) {
mode = 0;
ZI_WORK->unk_0x17EC = 1;
if (tableSize != 0) {
ZI_WORK->unk_0x17F0 = NextDawgGroup(0, language, ZI_WORK);
while (ZI_WORK->unk_0x17F0 != 0) {
ZI_WORK->dawgGroup = NextDawgGroup(0, language, ZI_WORK);
while (ZI_WORK->dawgGroup != 0) {
if ((ziU8)Zi8MatchROMdata2(elements, count, language, output, capacity,
mode, status, reservedMode, ZI_WORK->unk_0x17F0,
mode, status, reservedMode, ZI_WORK->dawgGroup,
acceptPrefix, ZI_WORK) != 0) {
*output = *elements;
result = 1;
break;
}
ZI_WORK->unk_0x17F0 = NextDawgGroup(ZI_WORK->unk_0x17F0, language, ZI_WORK);
ZI_WORK->dawgGroup = NextDawgGroup(ZI_WORK->dawgGroup, language, ZI_WORK);
}
} else {
if ((ziU8)Zi8MatchROMdata2(elements, count, language, output, capacity,

View File

@@ -8,11 +8,15 @@ extern ziU8 Zi8SyllablesROMdata(ziWChar* keys, ziU8 count, ziU8 lang, ziWChar* o
ziU16 a, ziU8 b, ziU8* cntOut, ziU8 c ZI_NEED_WORK);
typedef struct _ziSwParam {
ziU8 flag;
ziU8 unk_0x01[0xB];
ziS32 count;
ziU16 cap;
ziU8 unk_0x12[2];
ziU8 countOnly; // 0x00 - same layout as ZiCandidateOptions
ziU8 maxWordLength; // 0x01
ziU8 lookupMode; // 0x02
ziU8 suffixOnly; // 0x03
ziU8 controls[8]; // 0x04
ziS32 maxCount; // 0x0C - signed view of ZiCandidateOptions.maxCount
ziU16 capacity; // 0x10
ziU8 minWordLength; // 0x12
ziU8 flags; // 0x13
} ziSwParam;
ziU32 Zi8GetSyllablesCandidates(ziGetParam* param, ziSwParam* sw ZI_NEED_WORK) {
@@ -54,16 +58,16 @@ ziU32 Zi8GetSyllablesCandidates(ziGetParam* param, ziSwParam* sw ZI_NEED_WORK) {
goto end;
}
if (sw->flag != 0 || (param->getOptions & 0xFD) != 0x81) {
if (sw->countOnly != 0 || (param->getOptions & 0xFD) != 0x81) {
out = buf;
rem = 0x40;
} else {
out = (ziWChar*)param->candidates;
rem = sw->cap - 1;
rem = sw->capacity - 1;
}
if ((param->getOptions & 0xFD) == 0x80) {
u28 = (ziU8*)param->candidates;
rem = sw->cap - 1;
rem = sw->capacity - 1;
}
if (rem <= param->elementCount) {
@@ -94,8 +98,8 @@ ziU32 Zi8GetSyllablesCandidates(ziGetParam* param, ziSwParam* sw ZI_NEED_WORK) {
firstCand--;
goto L5dc;
}
if (sw->flag != 0) {
if (++count >= sw->count) goto end;
if (sw->countOnly != 0) {
if (++count >= sw->maxCount) goto end;
goto L5dc;
}
@@ -147,8 +151,8 @@ L464b:
firstCand--;
goto L560;
}
if (sw->flag != 0) {
if (++count >= sw->count) goto end;
if (sw->countOnly != 0) {
if (++count >= sw->maxCount) goto end;
goto L560;
}
if (u28 != 0) {
@@ -202,7 +206,7 @@ dec:
goto L560;
end:
if (sw->flag != 0) {
if (sw->countOnly != 0) {
param->letters = 0;
} else {
param->letters = (ziU8)count;

View File

@@ -32,9 +32,9 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
ziBool Zi8ZHsetPYfuzzyPairs(ziFuzzyPYPairs pairs ZI_NEED_WORK) {
if (pairs.ziDefault) {
ZI_WORK->unk_0x1B28.word = *(const ziU32*)&Zi8PYdefaultFuzzyPairs;
ZI_WORK->pyFuzzy.word = *(const ziU32*)&Zi8PYdefaultFuzzyPairs;
} else {
ZI_WORK->unk_0x1B28.word = *(ziU32*)&pairs;
ZI_WORK->pyFuzzy.word = *(ziU32*)&pairs;
}
return 1;
}
@@ -50,11 +50,11 @@ ziBool Zi8ZHsetZYfuzzyPairs(ziFuzzyZYPairs pairs ZI_NEED_WORK) {
ziBool Zi8SetLatinSearchOrder(ziU8* searchArray, ziU8 searchSize ZI_NEED_WORK) {
if (searchArray == 0 || *searchArray == 0) {
ZI_WORK->unk_0x1410 = (ziU32)Zi8SOdefaultArray;
ZI_WORK->unk_0x1418 = 9;
ZI_WORK->formats = (ziU32)Zi8SOdefaultArray;
ZI_WORK->formatCount = 9;
} else {
ZI_WORK->unk_0x1410 = (ziU32)searchArray;
ZI_WORK->unk_0x1418 = searchSize;
ZI_WORK->formats = (ziU32)searchArray;
ZI_WORK->formatCount = searchSize;
}
return 1;
}
@@ -158,13 +158,13 @@ static ziBool Zi8AlphaSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED
length = length - parameters->firstCandidate;
if (countOnly != 0) {
parameters->letters = length;
ZI_WORK->unk_0x0A = 0xff;
ZI_WORK->maxWordLength = 0xff;
return 1;
}
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;
}
@@ -175,7 +175,7 @@ static ziBool Zi8AlphaSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED
current = signatures.first;
length = signatures.length;
}
if (length > ZI_WORK->unk_0x0A) length = ZI_WORK->unk_0x0A;
if (length > ZI_WORK->maxWordLength) length = ZI_WORK->maxWordLength;
if ((parameters->elementCount < ZI_WORK->unk_0x140C[0] ||
(parameters->getOptions & 0x7e) == 2) && length > parameters->elementCount) {
length = parameters->elementCount;
@@ -185,7 +185,7 @@ static ziBool Zi8AlphaSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED
if (parameters->letters == 2) {
current = signatures.second;
length = secondLength;
if (length > ZI_WORK->unk_0x0A) length = ZI_WORK->unk_0x0A;
if (length > ZI_WORK->maxWordLength) length = ZI_WORK->maxWordLength;
if ((parameters->elementCount < ZI_WORK->unk_0x140C[0] ||
(parameters->getOptions & 0x7e) == 2) && length > parameters->elementCount) {
length = parameters->elementCount;
@@ -194,7 +194,7 @@ static ziBool Zi8AlphaSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED
*output++ = 0;
}
*output++ = 0;
ZI_WORK->unk_0x0A = 0xff;
ZI_WORK->maxWordLength = 0xff;
return 1;
}
@@ -226,7 +226,7 @@ static ziBool Zi8ZhSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED_WO
length = length - parameters->firstCandidate;
if (countOnly != 0) {
parameters->letters = length;
ZI_WORK->unk_0x0A = 0xff;
ZI_WORK->maxWordLength = 0xff;
return 1;
}
if (parameters->maxCandidates < length) length = parameters->maxCandidates;
@@ -279,13 +279,13 @@ static ziBool Zi8ZhSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED_WO
ziU8 _Zi8GetCandidates(ziGetParam* parameters ZI_NEED_WORK) {
ZiCandidateOptions options = {0};
options.capacity = ZI_WORK->unk_0x141A;
options.capacity = ZI_WORK->capacity;
return Zi8GetCandidatesOrCount(parameters, &options, ZI_WORK);
}
ziU8 _Zi8CheckCandidates(ziGetParam* parameters ZI_NEED_WORK) {
ZiCandidateOptions options = {0};
options.capacity = ZI_WORK->unk_0x141A;
options.capacity = ZI_WORK->capacity;
options.flags = 1;
return Zi8GetCandidatesOrCount(parameters, &options, ZI_WORK);
}
@@ -324,7 +324,7 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
saved.savedCandidates = 0;
saved.restoreCandidates = 0;
if (options->lookupMode == '\0') {
if (((ZI_WORK->unk_0x00 == '\t') && (parameters->elementCount != 0)) &&
if (((ZI_WORK->getcPhase == '\t') && (parameters->elementCount != 0)) &&
(((parameters->elements[parameters->elementCount - 1] == 0xEFF8 &&
((ziU8)Zi8AlphaSignature(parameters,options->countOnly,ZI_WORK) != 0)) ||
((parameters->elements[parameters->elementCount - 1] == 0xEF04 &&
@@ -339,22 +339,22 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
if ((parameters->elementCount == 1) && (parameters->firstCandidate == 0)) {
switch (parameters->language) {
case 1:
if ((ZI_WORK->unk_0x00 == '\0') || (ZI_WORK->unk_0x01 == options->countOnly)) {
switch(ZI_WORK->unk_0x00) {
if ((ZI_WORK->getcPhase == '\0') || (ZI_WORK->countOnly == options->countOnly)) {
switch(ZI_WORK->getcPhase) {
case '\0':
if (parameters->elements[0] == 0xEF04) {
ZI_WORK->unk_0x01 = options->countOnly;
ZI_WORK->unk_0x00 = '\x01';
ZI_WORK->countOnly = options->countOnly;
ZI_WORK->getcPhase = '\x01';
}
break;
case '\x02':
case '\x04':
case '\x06':
if (parameters->elements[0] == 0xEF04) {
++ZI_WORK->unk_0x00;
++ZI_WORK->getcPhase;
}
else {
ZI_WORK->unk_0x00 = '\0';
ZI_WORK->getcPhase = '\0';
}
break;
case '\x01':
@@ -362,17 +362,17 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
case '\x05':
case '\a':
if (parameters->elements[0] == 0xEF01) {
++ZI_WORK->unk_0x00;
++ZI_WORK->getcPhase;
}
else {
ZI_WORK->unk_0x00 = '\0';
ZI_WORK->getcPhase = '\0';
}
break;
case '\b':
case '\t':
if ((parameters->elements[0] == 0xEF04) &&
((ziU8)Zi8ZhSignature(parameters,options->countOnly,ZI_WORK) != 0)) {
ZI_WORK->unk_0x00 = '\t';
ZI_WORK->getcPhase = '\t';
candidateCount = (unsigned int)parameters->letters;
if (options->countOnly != '\0') {
parameters->letters = 0;
@@ -381,10 +381,10 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
return candidateCount;
}
default:
ZI_WORK->unk_0x00 = '\0';
ZI_WORK->getcPhase = '\0';
}
if ((ZI_WORK->unk_0x00 == '\0') && (parameters->elements[0] == 0xEF04)) {
ZI_WORK->unk_0x00 = '\x01';
if ((ZI_WORK->getcPhase == '\0') && (parameters->elements[0] == 0xEF04)) {
ZI_WORK->getcPhase = '\x01';
}
}
break;
@@ -400,75 +400,75 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
break;
case 0x11:
default:
if ((ZI_WORK->unk_0x00 == '\0') || (ZI_WORK->unk_0x01 == options->countOnly)) {
switch(ZI_WORK->unk_0x00) {
if ((ZI_WORK->getcPhase == '\0') || (ZI_WORK->countOnly == options->countOnly)) {
switch(ZI_WORK->getcPhase) {
case '\0':
if (parameters->elements[0] == 0xEFF2) {
ZI_WORK->unk_0x01 = options->countOnly;
ZI_WORK->unk_0x00 = '\x01';
ZI_WORK->countOnly = options->countOnly;
ZI_WORK->getcPhase = '\x01';
}
break;
case '\x01':
if (parameters->elements[0] == 0xEFF3) {
ZI_WORK->unk_0x00 = '\x02';
ZI_WORK->getcPhase = '\x02';
}
else {
ZI_WORK->unk_0x00 = '\0';
ZI_WORK->getcPhase = '\0';
}
break;
case '\x02':
if (parameters->elements[0] == 0xEFF5) {
ZI_WORK->unk_0x00 = '\x03';
ZI_WORK->getcPhase = '\x03';
}
else {
ZI_WORK->unk_0x00 = '\0';
ZI_WORK->getcPhase = '\0';
}
break;
case '\x03':
if (parameters->elements[0] == 0xEFF7) {
ZI_WORK->unk_0x00 = '\x04';
ZI_WORK->getcPhase = '\x04';
}
else {
ZI_WORK->unk_0x00 = '\0';
ZI_WORK->getcPhase = '\0';
}
break;
case '\x04':
if (parameters->elements[0] == 0xEFF8) {
ZI_WORK->unk_0x00 = '\x05';
ZI_WORK->getcPhase = '\x05';
}
else {
ZI_WORK->unk_0x00 = '\0';
ZI_WORK->getcPhase = '\0';
}
break;
case '\x05':
if (parameters->elements[0] == 0xEFF9) {
ZI_WORK->unk_0x00 = '\x06';
ZI_WORK->getcPhase = '\x06';
}
else {
ZI_WORK->unk_0x00 = '\0';
ZI_WORK->getcPhase = '\0';
}
break;
case '\x06':
if (parameters->elements[0] == 0xEFF2) {
ZI_WORK->unk_0x00 = '\a';
ZI_WORK->getcPhase = '\a';
}
else {
ZI_WORK->unk_0x00 = '\0';
ZI_WORK->getcPhase = '\0';
}
break;
case '\a':
if (parameters->elements[0] == 0xEFF5) {
ZI_WORK->unk_0x00 = '\b';
ZI_WORK->getcPhase = '\b';
}
else {
ZI_WORK->unk_0x00 = '\0';
ZI_WORK->getcPhase = '\0';
}
break;
case '\b':
case '\t':
if ((parameters->elements[0] == 0xEFF8) &&
((ziU8)Zi8AlphaSignature(parameters,options->countOnly,ZI_WORK) != 0)) {
ZI_WORK->unk_0x00 = '\t';
ZI_WORK->getcPhase = '\t';
candidateCount = (unsigned int)parameters->letters;
if (options->countOnly != '\0') {
parameters->letters = 0;
@@ -477,24 +477,24 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
return candidateCount;
}
default:
ZI_WORK->unk_0x00 = '\0';
ZI_WORK->getcPhase = '\0';
}
if ((ZI_WORK->unk_0x00 == '\0') && (parameters->elements[0] == 0xEFF2)) {
ZI_WORK->unk_0x00 = '\x01';
if ((ZI_WORK->getcPhase == '\0') && (parameters->elements[0] == 0xEFF2)) {
ZI_WORK->getcPhase = '\x01';
}
}
break;
}
}
else if (1 < parameters->elementCount) {
ZI_WORK->unk_0x00 = '\0';
ZI_WORK->getcPhase = '\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;
options->maxWordLength = ZI_WORK->maxWordLength;
ZI_WORK->maxWordLength = -1;
if ((ziU8)Zi8LangSupported(parameters->language,ZI_WORK) == 0) {
Zi8LogError(0x163,ZI_WORK);
return 0;
@@ -521,7 +521,7 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
((ziU8)Zi8IsCharacter(parameters->elements[0],ZI_WORK) != 0)))) {
saved.convertedElementCount = Zi8GetCharInfo(parameters->elements[0],characterInfo,0x10,1,ZI_WORK);
if (saved.convertedElementCount == 0) {
parameters->letters = parameters->count = parameters->unk_0x20 = 0;
parameters->letters = parameters->completion = parameters->count = 0;
candidateCount = 0;
error = 900;
}
@@ -540,7 +540,7 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
parameters->elements = saved.savedElements;
parameters->elementCount = saved.savedElementCount;
parameters->getMode = saved.savedGetMode;
parameters->count = 1;
parameters->completion = 1;
}
}
else if ((parameters->language == 1) && (parameters->getMode == 0xf)) {
@@ -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;
@@ -711,6 +711,6 @@ void Zi8Memcpy(ziU8* destination, ziU8* source, ziS32 count) {
}
ziBool Zi8SetMaxWordLength(ziU8 length ZI_NEED_WORK) {
ZI_WORK->unk_0x0A = length;
ZI_WORK->maxWordLength = length;
return 1;
}

View File

@@ -18,12 +18,12 @@ ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
Zi8Memset(__zi8_work_data, 0, 0x1B44);
ZI_WORK->unk_0x08 = 1;
ZI_WORK->unk_0x09 = 1;
ZI_WORK->unk_0x0A = 0xFF;
ZI_WORK->maxWordLength = 0xFF;
ZI_WORK->unk_0x10 = 0x64;
*(ziU16*)&ZI_WORK->unk_0x0C = 0xFFFF;
ZI_WORK->unk_0x1A = 0x20;
*(ziU16*)&ZI_WORK->targetCount = 0xFFFF;
ZI_WORK->separator = 0x20;
ZI_WORK->unk_0x1C[2] = 0;
ZI_WORK->unk_0x1B30 = 0;
ZI_WORK->koAltTables = 0;
ZI_WORK->unk_0x1B3A = 0;
ZI_WORK->unk_0x1B36 = 0;
ZI_WORK->unk_0x1B32 = 0;
@@ -42,19 +42,19 @@ 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;
ZI_WORK->capacity = 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->unk_0x1B28.bits.msb = 1;
ZI_WORK->zhPudMinPrefix = 5;
ZI_WORK->cangjieEnabled = Zi8GetFormatVersion(1, ZI_WORK) & 2;
ZI_WORK->pyFuzzy.bits.msb = 1;
ZI_WORK->unk_0x1B2C.bits.msb = 1;
zyFuzzy = ZI_WORK->unk_0x1B2C.word;
pzyFuzzy = &zyFuzzy;
Zi8ZHsetZYfuzzyPairs(pzyFuzzy, ZI_WORK);
pyFuzzy = ZI_WORK->unk_0x1B28.word;
pyFuzzy = ZI_WORK->pyFuzzy.word;
ppyFuzzy = &pyFuzzy;
Zi8ZHsetPYfuzzyPairs(ppyFuzzy, ZI_WORK);
Zi8SetParentalControls(2, ZI_WORK);

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,19 +65,19 @@ 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 ((ziU16)ch >= WORKP->unk_0x1B1C && (ziU16)ch <= WORKP->unk_0x1B1E) {
i = (ziU16)(ch - WORKP->unk_0x1B1C);
if (WORKP->unicodeMap != ZI8_NULL && WORKP->unicodeMapSubLang == WORKP->subLanguage) {
if ((ziU16)ch >= WORKP->unicodeRange1Min && (ziU16)ch <= WORKP->unicodeRange1Max) {
i = (ziU16)(ch - WORKP->unicodeRange1Min);
goto map;
}
if ((ziU16)ch >= WORKP->unk_0x1B20 && (ziU16)ch <= WORKP->unk_0x1B22) {
i = (ziU16)(WORKP->unk_0x1B1E + (ch - WORKP->unk_0x1B20) -
WORKP->unk_0x1B1C + 1);
if ((ziU16)ch >= WORKP->unicodeRange2Min && (ziU16)ch <= WORKP->unicodeRange2Max) {
i = (ziU16)(WORKP->unicodeRange1Max + (ch - WORKP->unicodeRange2Min) -
WORKP->unicodeRange1Min + 1);
goto map;
}
return 0xFFFF;
map:
i = WORKP->unk_0x1B18[i];
i = WORKP->unicodeMap[i];
if (i != 0xFFFF) {
e = (ziU8*)table + i * 0xC;
if (hi == e[6] && lo == e[7]) {

View File

@@ -49,39 +49,42 @@ void Zi8CopyZHSpelling(ziU8* source, ziWChar* output, ziU16 capacity, int size,
}
}
}
ziU8 ZADP_Zi8SetPDremoveOpt(ziU8 option ZI_NEED_WORK) {
ziU8 ZADP_Zi8SetPDremoveOpt(ziU8 option, struct __zi8_work_data_s* __zi8_work_data) {
ziU8 previous;
previous = ZI_WORK->pdRemoveOpt;
ZI_WORK->pdRemoveOpt = option;
previous = __zi8_work_data->pdRemoveOpt;
__zi8_work_data->pdRemoveOpt = option;
Zi8LogError(100, __zi8_work_data);
return previous;
}
ziU32 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziWChar* spelling, ziU16 spellingCapacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
int fallback = 0;
ziU8* bytePattern;
ziWChar folded;
ziU32 entrySize, wordSize, copied;
ziU8* entry;
ziPudSection* section;
int wordSize;
int copied;
ziU8* word;
int index;
int fallback = 0;
ziU32 entrySize;
ziPudHeader* table;
ziPudSection* section;
ziU8* byteOutput;
if (!(ZI_WORK->pudCount <= 16 && ZI_WORK->pudCount != 0 && ZI_WORK->pudTable[ZI_WORK->pudCount - 1] != 0)) {
Zi8LogError(0x4B0, __zi8_work_data);
return 0;
}
if (language == 1) {
length &= 0x7F;
length *= 2;
}
if (continuation == 0) {
table = (ziPudHeader*)ZI_WORK->pudTable[ZI_WORK->pudCount - 1];
index = 0;
section = table->sections;
while (index < table->languageCount && section->language != language) {
index++;
index = 0;
while (index < table->languageCount) {
if (section->language == language) break;
section++;
index++;
}
if (table->languageCount <= index) {
if (index >= table->languageCount) {
Zi8LogError(0x4F6, __zi8_work_data);
return 0;
}
@@ -90,90 +93,97 @@ ziU32 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar*
ZI_WORK->unk_0x318 = 0;
}
for (;;) {
entry = (ziU8*)ZI_WORK->unk_0x310;
if (entry == 0) {
word = (ziU8*)ZI_WORK->unk_0x310;
if (word == 0) {
Zi8LogError(0x4B3, __zi8_work_data);
return 0;
}
while ((ziS32)ZI_WORK->unk_0x318 < (ziS32)ZI_WORK->unk_0x314) {
word = entry + 1;
wordSize = *entry;
wordSize = *word++;
entrySize = wordSize;
if (language == 1) {
if (*word < ZI_WORK->unk_0x17) goto next;
entrySize = wordSize - 1;
word = entry + 2;
if (ZI_WORK->zhPudMinPrefix > *word) goto next;
wordSize--;
entrySize--;
word++;
wordSize = ZiGetZHWordSize((ziWChar*)word, entrySize);
} else if (ZI_WORK->unk_0x31E != 0 && complete != 0 && wordSize > length && word[length] == 0x20) goto matchText;
if ((ziS32)length > (ziS32)wordSize || (complete != 0 && wordSize != length) || (complete == 0 && wordSize == length)) goto next;
if (language == 1) {
for (index = 0; index < length; index++) {
if (word[index] != ((ziU8*)pattern)[index]) goto next;
}
goto matched;
}
matchText:
for (index = 0; index < length; index++) {
if (pattern[index] < 0xEFF1 || pattern[index] > 0xF37F) {
folded = Zi8ConvertUC2WC(word[index], language, __zi8_work_data);
if (folded != pattern[index] && (!ZI_WORK->unk_0x1F || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[index])) goto next;
} else if (pattern[index] != Zi8ConvertUC2Key(word[index], language, __zi8_work_data)) goto next;
}
matched:
if (fallback) {
ZI_WORK->unk_0x310 = 0;
ZI_WORK->unk_0x318 = 0;
ZI_WORK->unk_0x314 = 0;
if (*pattern < 0xEFF1) *output = Zi8ConvertWC2Key(*pattern, language, __zi8_work_data);
else *output = *pattern;
return 1;
}
if (language == 1) {
index = 0;
for (copied = 0; index < (ziS32)wordSize && copied < capacity; copied++) {
((ziU8*)output)[index] = word[index];
((ziU8*)output)[index + 1] = word[index + 1];
index += 2;
}
Zi8CopyZHSpelling(word, spelling, spellingCapacity, entrySize, wordSize);
} else if (ZI_WORK->unk_0x31E != 0 && complete != 0 && length < wordSize && word[length] == 0x20) goto matchText;
if ((ziS32)length > (ziS32)wordSize || (complete != 0 && wordSize != length) || (complete == 0 && wordSize == length)) {
next:
ZI_WORK->unk_0x318++;
word += entrySize;
} else {
for (copied = 0; copied < wordSize && copied < capacity; copied++) {
output[copied] = Zi8ConvertUC2WC(word[copied], language, __zi8_work_data);
if (ZI_WORK->unk_0x31E != 0 && copied >= length && output[copied] == 0x20) {
if (complete != 0 || copied >= length) break;
goto next;
if (language == 1) {
bytePattern = (ziU8*)pattern;
for (index = 0; index < length; index++) {
if (word[index] != bytePattern[index]) goto next;
}
goto matched;
}
matchText:
for (index = 0; index < length; index++) {
if (pattern[index] >= 0xEFF1 && pattern[index] <= 0xF37F) {
if (pattern[index] != Zi8ConvertUC2Key(word[index], language, __zi8_work_data)) goto next;
} else {
folded = Zi8ConvertUC2WC(word[index], language, __zi8_work_data);
if (folded != pattern[index] && (!ZI_WORK->ignoreCase || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[index])) goto next;
}
}
matched:
if (fallback) {
ZI_WORK->unk_0x310 = 0;
ZI_WORK->unk_0x318 = 0;
ZI_WORK->unk_0x314 = 0;
if (*pattern >= 0xEFF1) *output = *pattern;
else *output = Zi8ConvertWC2Key(*pattern, language, __zi8_work_data);
return 1;
}
if (language == 1) {
byteOutput = (ziU8*)output;
for (index = copied = 0; index < (ziS32)wordSize && copied < capacity; copied++) {
byteOutput[index] = word[index];
index++;
byteOutput[index] = word[index];
index++;
}
Zi8CopyZHSpelling(word, spelling, spellingCapacity, entrySize, wordSize);
} else {
for (copied = 0; copied < wordSize && copied < capacity; copied++) {
output[copied] = Zi8ConvertUC2WC(word[copied], language, __zi8_work_data);
if (ZI_WORK->unk_0x31E != 0 && copied >= length && output[copied] == 0x20) {
if (complete != 0 || copied >= length) break;
goto next;
}
}
}
ZI_WORK->unk_0x318++;
ZI_WORK->unk_0x310 = (ziU32)(word + entrySize);
Zi8LogError(100, __zi8_work_data);
return (ziU8)copied;
}
ZI_WORK->unk_0x318++;
ZI_WORK->unk_0x310 = (ziU32)(word + entrySize);
Zi8LogError(100, __zi8_work_data);
return (ziU8)copied;
next:
ZI_WORK->unk_0x318++;
entry = word + entrySize;
}
if (length != 1 || complete == 0 || continuation != 0) {
if (length == 1 && complete != 0 && continuation == 0) {
complete = 0;
fallback = 1;
ZI_WORK->unk_0x318 = 0;
} else {
ZI_WORK->unk_0x310 = 0;
ZI_WORK->unk_0x318 = 0;
ZI_WORK->unk_0x314 = 0;
return 0;
}
complete = 0;
fallback = 1;
ZI_WORK->unk_0x318 = 0;
}
}
ziU32 Zi8MatchPUDdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
ziU32 Zi8MatchPUDdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation, struct __zi8_work_data_s* __zi8_work_data) {
ziU32 result;
if (continuation == 0) ZI_WORK->pudCount = 1;
if (continuation == 0) __zi8_work_data->pudCount = 1;
for (;;) {
result = Zi8_8147FD7C(pattern, length, language, output, capacity, complete, continuation, __zi8_work_data);
if ((ziU8)result != 0) break;
if (++ZI_WORK->pudCount <= 16) {
if (++__zi8_work_data->pudCount <= 16) {
continuation = 0;
} else {
ZI_WORK->pudCount = 1;
__zi8_work_data->pudCount = 1;
break;
}
}

View File

@@ -68,7 +68,7 @@ ziU8 Zi8ZHaddSpace(ziWChar* src, ziU8 count, ziWChar* dst,
}
if (pdst[k - 1] != 0xF360 &&
(pdst[k - 1] < 0xF331 || pdst[k - 1] > 0xF335)) {
pdst[k++] = ZI_WORK->unk_0x1A;
pdst[k++] = ZI_WORK->separator;
}
psrc += i;
n -= i;

View File

@@ -15,11 +15,11 @@ void Zi8Memset(ziPtr, ziU32, ziU32);
ziBool Zi8_81480224(ziUserWord* word ZI_NEED_WORK) {
ziU8 length;
ziU8 position;
ziUwdNode* previous;
ziUwdNode* current;
ziUwdNode* added;
ziUserWord* candidate;
ziU8 position;
if (ZI_WORK->uwdCount >= 32) {
Zi8LogError(0x19D, __zi8_work_data);
return 0;
@@ -41,7 +41,7 @@ ziBool Zi8_81480224(ziUserWord* word ZI_NEED_WORK) {
current = ZI_WORK->uwdList;
while (current != 0) {
candidate = (ziUserWord*)current->word;
if (ZI_WORK->unk_0x12E == 1 && word->priority > candidate->priority) break;
if (ZI_WORK->uwdPrioritySort == 1 && candidate->priority < word->priority) break;
if (candidate->length == length) {
position = 0;
while (position < length) {
@@ -56,8 +56,7 @@ ziBool Zi8_81480224(ziUserWord* word ZI_NEED_WORK) {
previous = current;
current = current->next;
}
length = ZI_WORK->uwdCount++;
added = &ZI_WORK->uwdNodes[length];
added = &ZI_WORK->uwdNodes[ZI_WORK->uwdCount++];
if (previous == 0) {
ZI_WORK->uwdList = added;
added->next = current;
@@ -87,40 +86,42 @@ void Zi8_8148047C(ziPtr __zi8_work_data) {
ZI_WORK->uwdList = 0;
}
ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16 currentLength, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
ziWChar folded;
int fallback = 0;
int visited = 0;
int prefixLength;
int position, previousOffset;
ziU32 size;
ziU8 entryLanguage;
ziU32 entryLength;
ziUserDictionary* dictionary;
ziU8* cursor;
ziU8* begin;
ziU8* boundary;
ziU8* end;
ziUserWord* candidate;
ziUserWord* previous;
ziUserWord* result;
ziUserDictionary* dictionary;
int firstSegment;
ziU32 size;
int headerSize;
int entryLanguage;
volatile int entryLength;
int previousOffset;
int visited = 0;
int fallback = 0;
ziWChar folded;
ziU8* text;
int position;
int prefixLength;
Zi8LogError(100, __zi8_work_data);
if (!(ZI_WORK->unk_0x138 <= 2 && ZI_WORK->unk_0x138 != 0 && ZI_WORK->unk_0x130[ZI_WORK->unk_0x138 - 1] != 0)) {
if (!(ZI_WORK->uwdDictCount <= 2 && ZI_WORK->uwdDictCount != 0 && ZI_WORK->uwdDicts[ZI_WORK->uwdDictCount - 1] != 0)) {
Zi8ReplaceLastError(0x19C, __zi8_work_data);
return 0;
}
dictionary = ZI_WORK->unk_0x130[ZI_WORK->unk_0x138 - 1];
dictionary = ZI_WORK->uwdDicts[ZI_WORK->uwdDictCount - 1];
if (continuation != 0) {
result = Zi8_814803F4(__zi8_work_data);
text = (ziU8*)Zi8_814803F4(__zi8_work_data);
entryLength = 0;
if (result != 0) {
entryLanguage = result->language;
entryLength = result->length;
if (text != 0) {
language = ((ziUserWord*)text)->language;
entryLength = ((ziUserWord*)text)->length;
if (entryLength >= capacity) {
Zi8_8148047C(__zi8_work_data);
return 0;
}
for (position = 0; position < (ziS32)entryLength; position++) output[position] = Zi8ConvertUC2WC(result->text[position], entryLanguage, __zi8_work_data);
text = ((ziUserWord*)text)->text;
for (position = 0; position < (ziS32)entryLength; position++) output[position] = Zi8ConvertUC2WC(text[position], language, __zi8_work_data);
}
return entryLength;
}
@@ -130,21 +131,24 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
if (currentWord == 0 || currentLength == 0 || currentWord[currentLength - 1] != 0x20) ZI_WORK->unk_0x140 = 0;
else {
prefixLength = 0;
for (position = currentLength - 2; currentWord[position] != 0x20 && position >= 0; position--) prefixLength++;
for (position = currentLength - 2; position >= 0;) {
if (currentWord[position] == 0x20) break;
position--;
prefixLength++;
}
position++;
if (prefixLength == 0 || prefixLength > 63) ZI_WORK->unk_0x140 = 0;
else {
ZI_WORK->unk_0x140 = 1;
ZI_WORK->unk_0x141[0] = prefixLength + 5;
ZI_WORK->unk_0x141[prefixLength + 4] = prefixLength + 5;
ZI_WORK->unk_0x141[prefixLength + 4] = ZI_WORK->unk_0x141[0] = prefixLength + 5;
ZI_WORK->unk_0x141[1] = language;
ZI_WORK->unk_0x141[2] = prefixLength;
previousOffset = 4;
for (; prefixLength > 0; prefixLength--, position++) {
while (prefixLength > 0) {
folded = currentWord[position];
ZI_WORK->unk_0x141[previousOffset] = Zi8ConvertWC2UC(folded, language, __zi8_work_data);
ZI_WORK->unk_0x184[previousOffset] = 0;
if (ZI_WORK->unk_0x1F != 0) {
if (ZI_WORK->ignoreCase != 0) {
if (!Zi8ChangeCharCase(1, &folded, language, __zi8_work_data)) Zi8ChangeCharCase(0, &folded, language, __zi8_work_data);
ZI_WORK->unk_0x184[previousOffset] = Zi8ConvertWC2UC(folded, language, __zi8_work_data);
}
@@ -152,48 +156,56 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
ZI_WORK->unk_0x140 = 0;
break;
}
prefixLength--;
position++;
}
}
}
if (ZI_WORK->unk_0x140 == 0 && length == 0) return 0;
rescan:
begin = dictionary->entries + dictionary->current;
cursor = begin = dictionary->entries + dictionary->current;
boundary = (ziU8*)dictionary + dictionary->boundary + 7;
end = (ziU8*)dictionary + dictionary->end + 7;
cursor = begin;
if (begin < boundary) firstSegment = 1;
else firstSegment = 0;
while (firstSegment ? cursor < boundary : cursor < end) {
while ((cursor < boundary && firstSegment) || (cursor < end && !firstSegment)) {
size = *cursor;
candidate = (ziUserWord*)cursor;
position = visited++;
if ((ziS32)ZI_WORK->unk_0x13C <= position && (size & 0xC0) == 0) {
if ((ziS32)ZI_WORK->unk_0x13C > visited++ || (((ziUserWord*)cursor)->size & 0xC0) != 0) {
next:
if ((cursor += size) > end) {
if (firstSegment) break;
firstSegment = 1;
size = cursor - end - 1;
cursor = dictionary->entries + size;
}
} else {
previous = (ziUserWord*)(cursor + size);
if ((ziU8*)previous > end) previous = (ziUserWord*)(cursor + ((ziU8*)dictionary - end) + 7);
entryLanguage = candidate->language;
entryLength = candidate->length;
if (entryLanguage == language && length <= entryLength && entryLength < capacity && (complete == 0 || entryLength == length) && (complete != 0 || entryLength != length)) {
if ((ziU8*)previous > end) previous = (ziUserWord*)(dictionary->entries + (cursor - end - 1));
text = cursor;
headerSize = *text++;
entryLanguage = *text++;
entryLength = *text++;
text++;
if (entryLanguage == language && entryLength >= length && entryLength < capacity && (complete == 0 || entryLength == length) && (complete != 0 || entryLength != length)) {
for (position = 0; position < length; position++) {
if (pattern[position] < 0xEFF1 || pattern[position] > 0xF010) {
folded = Zi8ConvertUC2WC(candidate->text[position], language, __zi8_work_data);
if (folded != pattern[position] && (!ZI_WORK->unk_0x1F || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[position])) goto next;
} else if (pattern[position] != Zi8ConvertUC2Key(candidate->text[position], language, __zi8_work_data)) goto next;
if (pattern[position] >= 0xEFF1 && pattern[position] <= 0xF010) {
if (pattern[position] != Zi8ConvertUC2Key(text[position], language, __zi8_work_data)) goto next;
} else {
folded = Zi8ConvertUC2WC(text[position], language, __zi8_work_data);
if (folded != pattern[position] && (!ZI_WORK->ignoreCase || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[position])) goto next;
}
}
if (ZI_WORK->unk_0x140 != 0) {
if (ZI_WORK->unk_0x141[0] != previous->size || ZI_WORK->unk_0x141[1] != previous->language || ZI_WORK->unk_0x141[2] != previous->length) goto next;
for (position = 4; position < ZI_WORK->unk_0x141[2] + 4; position++) {
if (ZI_WORK->unk_0x141[position] != ((ziU8*)previous)[position] && ZI_WORK->unk_0x184[position] != ((ziU8*)previous)[position]) goto next;
prefixLength = 4;
position = ZI_WORK->unk_0x141[2] + 4;
for (; prefixLength < position; prefixLength++) {
if (ZI_WORK->unk_0x141[prefixLength] != ((ziU8*)previous)[prefixLength] && ZI_WORK->unk_0x184[prefixLength] != ((ziU8*)previous)[prefixLength]) goto next;
}
}
Zi8_81480224(candidate, __zi8_work_data);
Zi8_81480224((ziUserWord*)cursor, __zi8_work_data);
}
}
next:
cursor += size;
if (end < cursor) {
if (firstSegment) break;
firstSegment = 1;
cursor = dictionary->entries + (cursor - end - 1);
goto next;
}
}
if (ZI_WORK->unk_0x140 != 0 && length != 0) {
@@ -201,23 +213,24 @@ next:
visited = 0;
goto rescan;
}
if (complete == 1 && length != 0 && continuation == 0) {
if (length == 1 && complete != 0 && continuation == 0) {
complete = 0;
fallback = 1;
visited = 0;
goto rescan;
}
}
result = Zi8_814803F4(__zi8_work_data);
entryLength = 0;
if (result != 0) {
entryLanguage = result->language;
entryLength = result->length;
text = (ziU8*)Zi8_814803F4(__zi8_work_data);
if (text != 0) {
language = ((ziUserWord*)text)->language;
entryLength = ((ziUserWord*)text)->length;
if (entryLength >= capacity) {
Zi8_8148047C(__zi8_work_data);
return 0;
}
for (position = 0; position < (ziS32)entryLength; position++) output[position] = Zi8ConvertUC2WC(result->text[position], entryLanguage, __zi8_work_data);
text = ((ziUserWord*)text)->text;
for (position = 0; position < (ziS32)entryLength; position++) output[position] = Zi8ConvertUC2WC(text[position], language, __zi8_work_data);
return entryLength;
}
return entryLength;
return 0;
}

View File

@@ -1,7 +1,7 @@
#include <zi8clib/zierror.h>
#include <zi8clib/zitypes.h>
extern ziU16 nodeHeaderTable[16];
extern const ziU16 nodeHeaderTable[16];
ziU32 ZiDAWGGetChild(ziU32 node) {
ziU32 base;
@@ -22,11 +22,10 @@ ziU32 ZiDAWGGetChild(ziU32 node) {
node += offset;
if (((ziU32)header & 2) != 0) {
if ((*(ziU8*)node & 0x80) != 0) {
offset = (*(ziU8*)node & 0x7f) * 0x10000 + ((ziU32)*((ziU8*)node + 1) & 0xffff) * 0x100 + 0x8000;
offset += *((ziU8*)node + 2);
offset = ((*(ziU8*)node & 0x7f) << 16) +
((((ziU32)*((ziU8*)node + 1) & 0xffff) << 8) + *((ziU8*)node + 2)) + 0x8000;
} else {
offset = ((ziU32)*(ziU8*)node & 0xffff) * 0x100;
offset += (ziU32)*((ziU8*)node + 1);
offset = (((ziU32)*(ziU8*)node & 0xffff) << 8) + (ziU32)*((ziU8*)node + 1);
}
} else if (((ziU32)header & 8) != 0) {
if ((*(ziU8*)node & 0x80) != 0) {
@@ -42,41 +41,50 @@ ziU32 ZiDAWGGetChild(ziU32 node) {
return node;
}
ziU8* ZiDAWGGetSibling(ziU8* node) {
ziU16 header;
ziU8* cursor = node;
typedef struct ziDawgLongOffset {
ziU8 flags;
ziU8 middle;
ziU8 low;
} ziDawgLongOffset;
typedef char ziDawgLongOffsetSizeCheck[(sizeof(ziDawgLongOffset) == 3) ? 1 : -1];
ziU8* ZiDAWGGetSibling(ziU8* cursor) {
ziS32 depth;
ziU8* node;
ziU16 header;
ziS32 offset;
depth = 0;
node = cursor;
offset = 0;
header = nodeHeaderTable[node[0] >> 4];
header = nodeHeaderTable[cursor[0] >> 4];
if ((header & 4) == 0) {
node = 0;
return 0;
} else {
if ((header & 8) != 0) {
if ((node[0] & 0xf) == 0xf) {
node += 2;
if ((cursor[0] & 0xf) == 0xf) {
cursor += 2;
} else {
node += 1;
cursor += 1;
}
if ((header & 2) != 0) {
if ((*node & 0x80) == 0) {
node += 2;
if ((*cursor & 0x80) != 0) {
cursor += 3;
} else {
node += 3;
cursor += 2;
}
}
if ((*node & 0x80) != 0) {
node += (*node & 0x7f) * 0x10000 + (ziU32)node[1] * 0x100 +
(ziU32)node[2] + 0x8000;
if ((*cursor & 0x80) != 0) {
node += (((const ziDawgLongOffset*)cursor)->flags & 0x7f) * 0x10000 +
(((ziU32)(ziU16)cursor[1] << 8) +
((const ziDawgLongOffset*)cursor)->low) + 0x8000;
} else {
node += (ziU16)*node * 0x100 + (ziU32)node[1];
node = cursor[1] + (node + (ziU16)*cursor * 0x100);
}
return node;
} else {
cursor = node;
do {
header = nodeHeaderTable[cursor[0] >> 4];
if ((cursor[0] & 0xf) == 0xf) {
@@ -88,14 +96,16 @@ ziU8* ZiDAWGGetSibling(ziU8* node) {
}
if ((header & 1) != 0) {
if ((header & 2) == 0) {
depth++;
} else if ((*cursor & 0x80) != 0) {
cursor += 3;
offset += 3;
if ((header & 2) != 0) {
if ((*cursor & 0x80) != 0) {
cursor += 3;
offset += 3;
} else {
cursor += 2;
offset += 2;
}
} else {
cursor += 2;
offset += 2;
depth++;
}
}
@@ -113,18 +123,17 @@ ziU8* ZiDAWGGetSibling(ziU8* node) {
}
} while (0 < depth);
node += offset;
return node + offset;
}
}
return node;
}
ziU8 ZiDAWGgetEOWattribute(ziU32 node) {
return (nodeHeaderTable[*(ziU8*)node >> 4] & 0x10) > 0;
}
ziU32 ZiDAWGgetCHARattribute(ziPtr context, ziU32 node, ziPtr __zi8_work_data) {
ziU32 ZiDAWGgetCHARattribute(zi8DawgCtx* context, ziU32 node, ziPtr __zi8_work_data) {
ziU8 key;
ziU32 attribute;
@@ -134,15 +143,15 @@ ziU32 ZiDAWGgetCHARattribute(ziPtr context, ziU32 node, ziPtr __zi8_work_data) {
key = (ziU32)*(ziU8*)node & 0xf;
}
if (key > ((zi8DawgCtx*)context)->cap) {
if (key > context->cap) {
Zi8LogError(0x138b, __zi8_work_data);
return 0;
}
attribute = key << 24;
attribute |= ((ziU8*)((zi8DawgCtx*)context)->p0C)[key] << 16;
attribute += ((ziU32)((ziU8*)((zi8DawgCtx*)context)->p08)[key * 2] & 0xFFFF) << 8;
attribute += ((ziU8*)((zi8DawgCtx*)context)->p08)[key * 2 + 1];
attribute |= ((ziU8*)context->p0C)[key] << 16;
attribute |= (((ziU32)((ziU8*)context->p08)[key * 2] & 0xFFFF) << 8) +
((ziU8*)context->p08 + key * 2)[1];
Zi8LogError(0x64, __zi8_work_data);
return attribute;
}
@@ -155,60 +164,55 @@ ziU32 ZiDAWGGetGraph(ziPtr context) {
ziU32 ZiDAWGGetGraphInfo(zi8DawgCtx* context, ziU8* entry, ziU16* keys) {
ziU32 graph;
ziS32 result;
ziU32 end;
ziU8 depth;
ziU32 pair;
ziU32 end;
ziS32 result;
graph = ZiDAWGGetGraph(context);
result = 0;
pair = (((ziU16)entry[0] << 8) + entry[1]);
if (pair != 0) {
if ((((ziU16)entry[0] << 8) + entry[1]) != 0 || (((ziU16)entry[2] << 8) + entry[3]) != 0) {
return 0;
}
pair = (((ziU16)entry[2] << 8) + entry[3]);
if (pair == 0) {
end = (ziU32)(entry + (((ziU16)entry[4] << 8) + entry[5] + 1) * 10);
entry += 10;
depth = 0;
while ((depth < 2) && (*keys != 0)) {
if ((*keys < 0xeff1) || (0xf010 < *keys)) {
break;
}
end = (ziU32)(entry + (((ziU16)entry[4] << 8) + entry[5] + 1) * 10);
entry += 10;
depth = 0;
while ((depth < 2) && (*keys != 0)) {
if (*keys >= 0xeff1 && *keys <= 0xf010) {
goto checkEntry;
while (1) {
if (*keys == (ziS32)(entry[3] + ((ziU16)entry[2] << 8))) {
if (*keys == (ziS32)(((ziU16)entry[2] << 8) + entry[3])) {
break;
}
entry += (entry[1] + ((ziU16)entry[0] << 8)) * 10 + 10;
entry += (((ziU16)entry[0] << 8) + entry[1]) * 10 + 10;
checkEntry:
if (((ziU32)entry >= end) ||
(*keys == (ziS32)(entry[3] + ((ziU16)entry[2] << 8)))) {
(*keys == (ziS32)(((ziU16)entry[2] << 8) + entry[3]))) {
break;
}
}
if ((ziU32)entry >= end) {
return 0;
}
result = graph + (ziU32)entry[4] * 0x10000 + ((ziU16)entry[5] << 8) +
entry[6];
((zi8DawgCtx*)context)->unk_0x338 =
graph + (ziU32)entry[7] * 0x10000 + ((ziU16)entry[8] << 8) +
entry[9];
if (((zi8DawgCtx*)context)->unk_0x338 == graph) {
((zi8DawgCtx*)context)->unk_0x338 = 0;
}
if ((entry[1] + ((ziU16)entry[0] << 8)) == 0) {
break;
}
end = (ziU32)(entry + (entry[1] + ((ziU16)entry[0] << 8)) * 10 + 10);
entry += 10;
depth++;
keys++;
} else {
return 0;
}
if ((ziU32)entry >= end) {
return 0;
}
result = graph + (ziU32)entry[4] * 0x10000 + (((ziU16)entry[5] << 8) + entry[6]);
((zi8DawgCtx*)context)->endNode =
graph + (ziU32)entry[7] * 0x10000 + (((ziU16)entry[8] << 8) + entry[9]);
if (((zi8DawgCtx*)context)->endNode == graph) {
((zi8DawgCtx*)context)->endNode = 0;
}
if ((((ziU16)entry[0] << 8) + entry[1]) == 0) {
break;
}
end = (((ziU16)entry[0] << 8) + entry[1]) * 10 + ((ziU32)entry + 10);
entry += 10;
depth++;
keys++;
}
return result;

View File

@@ -52,7 +52,7 @@ ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
result = 0;
state.characterIndex = 0xFF;
state.currentCandidate = params->firstCandidate;
params->letters = params->count = params->unk_0x20 = 0;
params->letters = params->completion = params->count = 0;
if ((argument != 0) && (*argument != 0)) {
Zi8LogError(0x7D0, workData);
return 0;
@@ -104,7 +104,7 @@ ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
state.characterIndex,
(state.elementIndex - currentCharacter) - 1,
workData);
if ((((struct __zi8_work_data_s*)workData)->unk_0x1B30 == 1)) {
if ((((struct __zi8_work_data_s*)workData)->koAltTables == 1)) {
switch (state.characterIndex) {
case 1:
selectedTable = (ziU8*)Zi8GetTableAddress(ZI8_LANG_KO, 0x1E, workData);
@@ -179,13 +179,13 @@ ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
} else {
params->candidates[(ziU8)result] =
((ziU16)selectedTable[state.nextIndex * 2] << 8) | (selectedTable + state.nextIndex * 2)[1];
if ((state.tableCount6 != 0) && (((struct __zi8_work_data_s*)workData)->unk_0x1B30 == 0)) {
if ((state.tableCount6 != 0) && (((struct __zi8_work_data_s*)workData)->koAltTables == 0)) {
params->candidates[(ziU8)result] += state.inputIndex * state.tableCount3;
}
result++;
}
if (currentCharacter == 0) {
params->count = state.matched + 1;
params->completion = state.matched + 1;
}
currentCharacter += state.matched;
} else {
@@ -199,14 +199,14 @@ ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
state.currentCandidate--;
}
if (currentCharacter == 0) {
params->count = 1;
params->completion = 1;
}
} else {
for (state.index = 0; state.index < state.tableCount31; state.index++) {
if ((state.table31[(state.index * 3)] == buffer[currentCharacter]) &&
((state.table31 + state.index * 3)[1] == buffer[currentCharacter + 1])) {
if (currentCharacter == 0) {
params->count = 1;
params->completion = 1;
}
params->candidates[(ziU8)result] =
state.tableCount0 + (state.table31 + state.index * 3)[2];
@@ -218,7 +218,7 @@ ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
if (state.index == state.tableCount31) {
if ((params->candidates[(ziU8)result] = buffer[currentCharacter]) < 0xFF) {
if (currentCharacter == 0) {
params->count = 1;
params->completion = 1;
}
params->candidates[(ziU8)result] += state.tableCount0;
result++;
@@ -249,7 +249,7 @@ ziU8 Zi8MatchKoreanSequence(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 c
firstCharacter = input[0];
mappedCharacter = 0xFF;
if (((struct __zi8_work_data_s*)workData)->unk_0x1B30 == 0) {
if (((struct __zi8_work_data_s*)workData)->koAltTables == 0) {
table = (ziU8*)Zi8GetTableAddress(ZI8_LANG_KO, 3, workData);
tableCount = Zi8GetTableCount(ZI8_LANG_KO, 3, workData);
} else {

View File

@@ -20,127 +20,134 @@ typedef struct ziChineseEntry {
ziU8 offsetLow[2];
} ziChineseEntry;
ziU8 Zi8GetCandidatesOrCount(ziGetParam*, ziSearchState* ZI_NEED_WORK);
ziU32 Zi8GetCandidatesOrCount(ziGetParam*, ziSearchState* ZI_NEED_WORK);
ziU8 Zi8GetFormatVersion(ziU8 ZI_NEED_WORK);
ziPtr Zi8GetTableAddress(ziU8, ziU8 ZI_NEED_WORK);
ziU16 Zi8Uni2Ord(ziWChar ZI_NEED_WORK);
typedef struct ziEncodedOrdinal {
ziU8 low;
ziU8 high;
} ziEncodedOrdinal;
typedef char ziEncodedOrdinalSizeCheck[(sizeof(ziEncodedOrdinal) == 2) ? 1 : -1];
ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
int count;
int offset;
ziU8 group;
ziU8 remaining;
ziU16 value;
ziWChar* cursor;
ziSearchState search;
ziChineseEntry* table = 0;
ziU8* baseData = 0;
ziU8 group = 0;
ziU8 remaining = 0;
ziU16 value = 0;
ziGetParam request;
ziWChar ordinals[65];
int length;
int unmatched;
int count;
int countLeft;
ziChineseEntry* entry;
ziWChar* cursor;
ziU8* data;
ziU8 formats[8] = {1, 5, 0, 0, 0, 0, 0, 0};
ziU32 savedFormats = ZI_WORK->unk_0x1410;
ziU8 savedCount = ZI_WORK->unk_0x1418;
search.flags = 0;
search.word = 0;
search.length = 0;
search.position = 0;
search.capacity = 0;
search.options = 0;
ziU32 savedFormats = ZI_WORK->formats;
ziU8 savedCount = ZI_WORK->formatCount;
ziSearchState search = {0};
Zi8LogError(100, __zi8_work_data);
if (word == 0 || *word == 0) {
Zi8ReplaceLastError(300, __zi8_work_data);
return 0;
}
if (language != 1) {
for (length = 0; word[length] != 0; length++) {
if (word[length] >= 0xEFF1 || length == 64) return 0;
for (count = 0; word[count] != 0; count++) {
if (word[count] >= 0xEFF1 || count == 64) return 0;
}
((ziU8*)&search.length)[0] = length;
((ziU8*)&search.length)[0] = count;
((ziU8*)&search.flags)[2] = 1;
((ziU16*)&search.capacity)[0] = 64;
search.word = word;
((ziU16*)&search.capacity)[0] = 64;
request.language = language;
request.getMode = 0;
request.subLanguage = 7;
request.context = 1;
request.getOptions = 0x81;
request.elements = word;
request.elementCount = length;
request.elementCount = count;
request.currentWord = 0;
request.wordCharCount = 0;
request.candidates = ordinals;
request.maxCandidates = 1;
request.firstCandidate = 0;
ZI_WORK->unk_0x1410 = (ziU32)formats;
ZI_WORK->formats = (ziU32)formats;
if (ZI_WORK->unk_0x1C[0] == 2) {
ZI_WORK->unk_0x1418 = 0;
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->unk_0x1418++] = 1;
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->unk_0x1418++] = 2;
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->unk_0x1418++] = 3;
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->unk_0x1418++] = 4;
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->unk_0x1418++] = 5;
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->unk_0x1418++] = 6;
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->unk_0x1418++] = 7;
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->unk_0x1418++] = 8;
} else if (ZI_WORK->unk_0x1C[0] == 0) ZI_WORK->unk_0x1418 = 1;
else ZI_WORK->unk_0x1418 = 2;
ZI_WORK->formatCount = 0;
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->formatCount++] = 1;
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->formatCount++] = 2;
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->formatCount++] = 3;
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->formatCount++] = 4;
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->formatCount++] = 5;
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->formatCount++] = 6;
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->formatCount++] = 7;
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->formatCount++] = 8;
} else if (ZI_WORK->unk_0x1C[0] != 0) ZI_WORK->formatCount = 2;
else ZI_WORK->formatCount = 1;
count = Zi8GetCandidatesOrCount(&request, &search, __zi8_work_data);
ZI_WORK->unk_0x1410 = savedFormats;
ZI_WORK->unk_0x1418 = savedCount;
ZI_WORK->formats = savedFormats;
ZI_WORK->formatCount = savedCount;
if (count != 0) return 1;
}
if (language == 1) {
length = 0;
do {
ordinals[length] = Zi8Uni2Ord(word[length], __zi8_work_data);
if (ordinals[length] == 0xFFFF) return 0;
length++;
if (length == 64) return 0;
} while (word[length] != 0);
if (language != 1) {
Zi8ReplaceLastError(0x26C, __zi8_work_data);
return 0;
}
{
count = 0;
while (word[count] != 0) {
ordinals[count] = Zi8Uni2Ord(word[count], __zi8_work_data);
if (ordinals[count] == 0xFFFF) return 0;
count++;
if (count == 64) return 0;
}
{
if (length == 1) return 1;
count = --length;
if (count-- == 1) return 1;
ordinals[count] |= 0x8000;
ZI_WORK->unk_0x16 = 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) {
ZI_WORK->cangjieEnabled = Zi8GetFormatVersion(1, __zi8_work_data) & 2;
table = (ziChineseEntry*)Zi8GetTableAddress(1, 0, __zi8_work_data);
entry = table + ordinals[0];
baseData = (ziU8*)Zi8GetTableAddress(1, 1, __zi8_work_data);
baseData += ((entry->offsetHigh & 15) << 16 | (entry->offsetLow[1] | (entry->offsetLow[0] << 8)));
data = baseData;
if (ZI_WORK->cangjieEnabled != 0) {
switch (*data & 7) {
case 2:
offset = 2;
countLeft = 2;
break;
case 3:
case 4:
offset = 3;
countLeft = 3;
break;
case 5:
offset = 4;
countLeft = 4;
break;
default:
offset = 1;
countLeft = 1;
break;
}
data += offset;
data += countLeft;
}
if ((*data & 0x80) == 0) return 0;
group = 0;
data += ((*data & 0x7F) >> 4) + 1;
if ((*data & 0x80) != 0) {
group = 0;
data += ((*data & 0x7F) >> 4) + 1;
} else return 0;
while ((group & 0x80) == 0) {
group = *data++;
for (remaining = group & 15; remaining != 0; remaining--) {
unmatched = count;
countLeft = count;
cursor = ordinals;
while (unmatched > 0) {
value = data[0] | (data[1] << 8);
while (countLeft > 0) {
value = ((ziU32)(ziU16)data[1] << 8) |
((const ziEncodedOrdinal*)data)->low;
data += 2;
cursor++;
if (value != *cursor) break;
unmatched--;
if (value != *++cursor) break;
countLeft--;
if (value & 0x8000) break;
}
if (unmatched == 0) return 1;
if (countLeft == 0) return 1;
if (!(value & 0x8000)) {
data++;
while (!(*data & 0x80)) data += 2;
@@ -151,7 +158,7 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
Zi8LogError(0x2BD, __zi8_work_data);
return 0;
}
} else Zi8ReplaceLastError(0x26C, __zi8_work_data);
}
return 0;
}
ziWChar Zi8ConvertUC2UserKey(ziChar character, ziU8 language ZI_NEED_WORK) {

View File

@@ -309,7 +309,7 @@ ziU32 Zi8GetKOcandidates(ziGetParam* param, ZiKoreanCandidateOptions* options ZI
}
if (options->countOnly == 0) {
param->letters = 0;
param->unk_0x20 = 0;
param->count = 0;
param->candidates[0] = 0;
}
Zi8LogError(100, ZI_WORK);
@@ -365,22 +365,22 @@ match_word:
return options->maxCount;
}
param->candidates[search.candidateCount++] = search.character;
++param->unk_0x20;
++param->count;
if (++param->letters >= param->maxCandidates) {
return param->letters;
}
}
} else {
param->candidates[search.candidateCount++] = search.character;
++param->unk_0x20;
++param->count;
if (++param->letters >= param->maxCandidates) {
Zi8_814834AC(param, &search.remainingCandidates, &search.candidateCount, &search.inserted, ZI_WORK);
param->unk_0x20 = search.candidateCount;
param->count = search.candidateCount;
param->letters = search.candidateCount;
if (search.candidateCount < param->maxCandidates) goto skip_word;
if (options->countOnly != 0) {
if ((search.prefixCount += search.candidateCount) >= (ziS32)options->maxCount) return options->maxCount;
param->unk_0x20 = 0;
param->count = 0;
param->letters = 0;
search.candidateCount = 0;
} else {
@@ -395,17 +395,17 @@ match_word:
if ((search.candidateIndex == search.candidateCount) &&
(Zi8_814833F0(param, search.character, ZI_WORK) == 0)) {
param->candidates[search.candidateCount++] = search.character;
++param->unk_0x20;
++param->count;
if (++param->letters < param->maxCandidates) {
goto skip_word;
}
Zi8_814834AC(param, &search.remainingCandidates, &search.candidateCount, &search.inserted, ZI_WORK);
param->unk_0x20 = search.candidateCount;
param->count = search.candidateCount;
param->letters = search.candidateCount;
if (search.candidateCount < param->maxCandidates) goto skip_word;
if (options->countOnly != 0) {
if ((search.prefixCount += search.candidateCount) >= (ziS32)options->maxCount) return options->maxCount;
param->unk_0x20 = 0;
param->count = 0;
param->letters = 0;
search.candidateCount = 0;
} else {
@@ -435,7 +435,7 @@ search_table:
if ((search.prefixCount += search.candidateCount) >= (ziS32)options->maxCount) return options->maxCount;
search.resultCount = search.prefixCount;
}
param->unk_0x20 = search.candidateCount;
param->count = search.candidateCount;
param->letters = search.candidateCount;
}
if (param->elementCount > 9) {

View File

@@ -30,8 +30,7 @@ ziU8 Zi8MatchOEMdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* word
index = ZI_WORK->oemIdx;
if ((ziS32)index >= ZI_WORK->oemLen) goto failed;
if (ZI_WORK->oemMatch == 0) goto failed;
capacity--;
if ((ziS32)length >= (ziS32)capacity) {
if ((ziS32)length >= (ziS32)--capacity) {
failed:
return 0;
}
@@ -46,7 +45,7 @@ posEntry:
if (pattern[position] == Zi8ConvertWC2Key(word[position], language, __zi8_work_data)) continue;
break;
} else if (word[position] != pattern[position]) {
if (!ZI_WORK->unk_0x1F || language == 1) break;
if (!ZI_WORK->ignoreCase || language == 1) break;
folded = pattern[position];
if (!Zi8ChangeCharCase(1, &folded, language, __zi8_work_data) || folded != word[position]) break;
}

View File

@@ -239,7 +239,7 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
}
if ((request->getMode == '\x01') || (request->getMode == '\f')) {
match->nCand = Zi8GetPyPhonetic(request->elements,elementCount,match->phon,match->phon2,
&request->count,&match->first,&match->first2,__zi8_work_data);
&request->completion,&match->first,&match->first2,__zi8_work_data);
}
else {
initial = 0;
@@ -250,7 +250,7 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
previousFinal = 0;
buffers.phoneticInput = request->elements;
match->nCand = 0;
request->count = request->elementCount;
request->completion = request->elementCount;
phoneticLength = 1;
for (index = 0; index < elementCount; index++) {
stroke = Zi8GetBpmfPhonetic(buffers.phoneticInput,phoneticLength,&initial,&final,&bestInitial,&bestFinal,
@@ -287,7 +287,7 @@ savePhonetic:
goto savePhonetic;
}
if (match->nCand == 1) {
request->count = phoneticLength - 1;
request->completion = phoneticLength - 1;
}
buffers.phoneticInput = buffers.phoneticInput + phoneticLength - 1;
phoneticLength = 0;
@@ -306,7 +306,7 @@ savePhonetic:
}
}
if (((request->context & contextMask) != 0) &&
((1 < match->nCand || (request->count != elementCount)))) {
((1 < match->nCand || (request->completion != elementCount)))) {
match->phon[0] = 0xFFFF;
match->phon2[0] = 0xFFFF;
match->nCand = 0;

View File

@@ -152,10 +152,10 @@ u32 __SCGetConfBufSize();
typedef struct SC_BT_DEV_INFO {
u8 devName[20]; // 0x00
u8 unk_0x14;
u8 unk_0x15[0xB];
u8 pad_0x14; // 0x14
u8 pad_0x15[0xB]; // 0x15
LINK_KEY linkKey; // 0x20
u8 unk_0x30[0x10];
u8 pad_0x30[0x10]; // 0x30
} SC_BT_DEV_INFO;
typedef struct SCBtDeviceInfo {

View File

@@ -10,7 +10,7 @@ extern "C" {
#endif
typedef void (*USBCallback)(IOSError result, void* arg);
typedef void (*USBIsoCallback)(IOSError err, void* unkIsoArg, void* cbArg);
typedef void (*USBIsoCallback)(IOSError err, void* isoArg, void* cbArg);
IOSError IUSB_OpenLib();
IOSError IUSB_CloseLib();

View File

@@ -133,11 +133,11 @@ typedef struct WPADExtConfig {
union {
struct WPADFSConfig {
s16 stickXCenter; // 0x00
s16 unk_0x02; // 0x02
s16 unk_0x04; // 0x04
s16 stickXMin; // 0x02
s16 stickXMax; // 0x04
s16 stickYCenter; // 0x06
s16 unk_0x08; // 0x08
s16 unk_0x0A; // 0x0A
s16 stickYMin; // 0x08
s16 stickYMax; // 0x0A
s16 accX0g; // 0x0C
s16 accY0g; // 0x0E
@@ -150,18 +150,18 @@ typedef struct WPADExtConfig {
struct WPADCLConfig {
s16 lStickXCenter; // 0x00
s16 unk_0x02; // 0x02
s16 unk_0x04; // 0x04
s16 lStickXMin; // 0x02
s16 lStickXMax; // 0x04
s16 lStickYCenter; // 0x06
s16 unk_0x08; // 0x08
s16 unk_0x0A; // 0x0A
s16 lStickYMin; // 0x08
s16 lStickYMax; // 0x0A
s16 rStickXCenter; // 0x0C
s16 unk_0x0E; // 0x0E
s16 unk_0x10; // 0x10
s16 rStickXMin; // 0x0E
s16 rStickXMax; // 0x10
s16 rStickYCenter; // 0x12
s16 unk_0x14; // 0x14
s16 unk_0x16; // 0x16
s16 rStickYMin; // 0x14
s16 rStickYMax; // 0x16
u8 triggerLZero; // 0x18
u8 triggerRZero; // 0x19
@@ -171,7 +171,7 @@ typedef struct WPADExtConfig {
typedef struct WPADCB {
WPADGameInfo gameInfo; // 0x00
s32 unk_0x38[2];
s32 gameInfoStatus[2]; // 0x38
u8 rxBufMain[RX_BUFFER_SIZE]; // 0x40
u8 rxBufs[2][RX_BUFFER_SIZE]; // 0xA0
WPADCommandQueue stdCmdQueue; // 0x160
@@ -223,7 +223,7 @@ typedef struct WPADCB {
u16 filterDiffExt; // 0x900
u16 filterSameExt; // 0x902
s64 lastReportSendTime; // 0x908
u8 unk_0x910;
u8 suppressDisconnect; // 0x910
u8 calibrated; // 0x911
u16 comboHeld; // 0x912
u8 encryptionKey[16]; // 0x914
@@ -242,8 +242,8 @@ typedef struct WPADCB {
WPADCallback getInfoCB; // 0x988
u8 getInfoBusy; // 0x98C
u8 unk_0x98D; // 0x98D
u8 unk_0x98E; // 0x98E
u8 encStatus; // 0x98D
u8 continuous; // 0x98E
u8 unk_0x98F[0x9A0 - 0x990];
} WPADCB;
@@ -261,7 +261,7 @@ void WPADiExcludeButton(s32 chan);
void WPADiCopyOut(s32 chan);
BOOL WPADiSendSetPort(WPADCommandQueue* pQueue, u8 port, WPADCallback pCallback);
BOOL WPADiSendSetReportType(WPADCommandQueue* pQueue, s32 format, BOOL unk, WPADCallback pCallback);
BOOL WPADiSendSetReportType(WPADCommandQueue* pQueue, s32 format, BOOL continuous, WPADCallback pCallback);
BOOL WPADiSendEnableDPD(WPADCommandQueue* pQueue, BOOL enable, WPADCallback pCallback);
BOOL WPADiSendEnableSpeaker(WPADCommandQueue* pQueue, BOOL enable, WPADCallback pCallback);
BOOL WPADiSendGetContStat(WPADCommandQueue* pQueue, WPADInfo* pInfo, WPADCallback pCallback);

View File

@@ -24,7 +24,7 @@ typedef struct WPADMemBlock {
int unk_0x04; // 0x04
s16 unk_0x08; // 0x08
int unk_0x0C; // 0x0C
WPADCallback unk_0x10; // 0x10
WPADCallback callback; // 0x10
} WPADMemBlock;
typedef struct WPADGameInfo {

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,10 +52,10 @@ 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

View File

@@ -72,7 +72,11 @@ struct DVDCommandBlock {
DVDCommandBlock* prev; // 0x04
u32 command; // 0x08
#ifdef BS2_MACH_VOLATILE_DVD_STATE
volatile s32 state;
#else
s32 state; // 0x0C
#endif
u32 offset; // 0x10
u32 length; // 0x14

View File

@@ -20,13 +20,13 @@ 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 {
USBKBDCmdLED base; // 0x00
u8 unk_0x08[0x10];
u8 pad_0x08[0x10]; // 0x08
USBKBDCmdLEDCallback cb; // 0x18
void* cbArg; // 0x1C
} USBKBDCmdLEDAsync;

View File

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

View File

@@ -66,16 +66,16 @@
typedef struct
{
HC_BT_HDR *at_0x00[3]; // 0x00
UINT16 at_0x0c[3]; // 0x0c
UINT16 at_0x12; // 0x12
UINT8 at_0x14[3]; // 0x14
UINT8 at_0x17[3]; // 0x17
UINT8 at_0x1a[3]; // 0x1a
HC_BT_HDR *p_rx_msg[3]; // 0x00
UINT16 bytes_left[3]; // 0x0c
UINT16 buf_size; // 0x12
UINT8 pkt_type[3]; // 0x14
UINT8 len_hi[3]; // 0x17
UINT8 rx_state[3]; // 0x1a
char pad4_[1]; // 0x1d
UINT8 at_0x1e; // 0x1e
UINT8 at_0x1f; // 0x1f
UINT8 at_0x20; // 0x20
UINT8 open_state; // 0x1e
UINT8 task_id; // 0x1f
UINT8 mbox; // 0x20
char pad5_[2]; // 0x21
/* 1 byte padding */
} tHCISU_H2_CB; // size 0x24
@@ -135,7 +135,7 @@ UINT16 hcisu_h2_receive_msg(UINT16 pipe, tHCISU_H2_CB *p_cb)
UINT8 msg_received;
UINT16 r27;
if (p_cb->at_0x1e != 2)
if (p_cb->open_state != 2)
return 0;
r27 = pipe + 1;
@@ -148,36 +148,36 @@ UINT16 hcisu_h2_receive_msg(UINT16 pipe, tHCISU_H2_CB *p_cb)
++bytes_read;
msg_received = FALSE;
switch (p_cb->at_0x1a[pipe])
switch (p_cb->rx_state[pipe])
{
case 0:
if (r27 == 1)
{
p_cb->at_0x00[pipe] = GKI_getpoolbuf(GKI_POOL_ID_2);
p_cb->at_0x14[pipe] = 4;
p_cb->p_rx_msg[pipe] = GKI_getpoolbuf(GKI_POOL_ID_2);
p_cb->pkt_type[pipe] = 4;
}
else if (r27 == 2)
{
p_cb->at_0x00[pipe] = GKI_getpoolbuf(GKI_POOL_ID_3);
p_cb->at_0x14[pipe] = 2;
p_cb->p_rx_msg[pipe] = GKI_getpoolbuf(GKI_POOL_ID_3);
p_cb->pkt_type[pipe] = 2;
}
else if (r27 == 3)
{
p_cb->at_0x00[pipe] = GKI_getpoolbuf(GKI_POOL_ID_1);
p_cb->at_0x14[pipe] = 3;
p_cb->p_rx_msg[pipe] = GKI_getpoolbuf(GKI_POOL_ID_1);
p_cb->pkt_type[pipe] = 3;
}
else
{
break;
}
if (p_cb->at_0x00[pipe])
if (p_cb->p_rx_msg[pipe])
{
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;
p_cb->p_rx_msg[pipe]->len = 0;
p_cb->p_rx_msg[pipe]->event =
hcisu_msg_evt_table[p_cb->pkt_type[pipe] - 1];
p_cb->p_rx_msg[pipe]->offset = 0;
p_cb->rx_state[pipe] = 1;
}
else
{
@@ -185,54 +185,54 @@ UINT16 hcisu_h2_receive_msg(UINT16 pipe, tHCISU_H2_CB *p_cb)
"HCIS: Unable to allocate buffer for incoming HCI "
"message.");
p_cb->at_0x1a[pipe] = 2;
p_cb->rx_state[pipe] = 2;
}
p_cb->at_0x0c[pipe] =
hcisu_preamble_table[p_cb->at_0x14[pipe] - 1];
p_cb->bytes_left[pipe] =
hcisu_preamble_table[p_cb->pkt_type[pipe] - 1];
/* fallthrough */
case 1:
*((UINT8 *)(p_cb->at_0x00[pipe] + 1)
+ p_cb->at_0x00[pipe]->len++) = byte;
*((UINT8 *)(p_cb->p_rx_msg[pipe] + 1)
+ p_cb->p_rx_msg[pipe]->len++) = byte;
--p_cb->at_0x0c[pipe];
--p_cb->bytes_left[pipe];
if (p_cb->at_0x0c[pipe] == 0)
if (p_cb->bytes_left[pipe] == 0)
{
msg_len = byte;
if (p_cb->at_0x14[pipe] == 2)
if (p_cb->pkt_type[pipe] == 2)
{
msg_len = (msg_len << 8) + p_cb->at_0x17[pipe];
msg_len = (msg_len << 8) + p_cb->len_hi[pipe];
if ((p_cb->at_0x00[pipe] =
if ((p_cb->p_rx_msg[pipe] =
(HC_BT_HDR *)l2cap_link_chk_pkt_start(
(BT_HDR *)p_cb->at_0x00[pipe]))
(BT_HDR *)p_cb->p_rx_msg[pipe]))
== 0)
{
p_cb->at_0x0c[pipe] = msg_len;
p_cb->bytes_left[pipe] = msg_len;
if (msg_len == 0)
p_cb->at_0x1a[pipe] = 0;
p_cb->rx_state[pipe] = 0;
else
p_cb->at_0x1a[pipe] = 4;
p_cb->rx_state[pipe] = 4;
break;
}
}
p_cb->at_0x0c[pipe] = msg_len;
p_cb->bytes_left[pipe] = msg_len;
if (sizeof(HC_BT_HDR)
+ hcisu_preamble_table[p_cb->at_0x14[pipe] - 1]
+ hcisu_preamble_table[p_cb->pkt_type[pipe] - 1]
+ msg_len
> GKI_get_buf_size(p_cb->at_0x00[pipe]))
> GKI_get_buf_size(p_cb->p_rx_msg[pipe]))
{
GKI_freebuf(p_cb->at_0x00[pipe]);
p_cb->at_0x00[pipe] = NULL;
p_cb->at_0x1a[pipe] = 4;
GKI_freebuf(p_cb->p_rx_msg[pipe]);
p_cb->p_rx_msg[pipe] = NULL;
p_cb->rx_state[pipe] = 4;
BT_TRACE(HCI, ERROR,
"HCIS: Invalid length for incoming HCI message.");
@@ -242,85 +242,85 @@ UINT16 hcisu_h2_receive_msg(UINT16 pipe, tHCISU_H2_CB *p_cb)
if (msg_len != 0)
{
p_cb->at_0x1a[pipe] = 3;
p_cb->rx_state[pipe] = 3;
}
else
{
msg_received = TRUE;
p_cb->at_0x1a[pipe] = 0;
p_cb->rx_state[pipe] = 0;
}
}
else
{
p_cb->at_0x17[pipe] = byte;
p_cb->len_hi[pipe] = byte;
}
break;
case 2:
--p_cb->at_0x0c[pipe];
--p_cb->bytes_left[pipe];
if (p_cb->at_0x0c[pipe] == 0)
if (p_cb->bytes_left[pipe] == 0)
{
msg_len = byte;
if (p_cb->at_0x14[pipe] == 2)
msg_len = (msg_len << 8) + p_cb->at_0x17[pipe];
if (p_cb->pkt_type[pipe] == 2)
msg_len = (msg_len << 8) + p_cb->len_hi[pipe];
p_cb->at_0x0c[pipe] = msg_len;
p_cb->at_0x1a[pipe] = 4;
p_cb->bytes_left[pipe] = msg_len;
p_cb->rx_state[pipe] = 4;
}
else
{
p_cb->at_0x17[pipe] = byte;
p_cb->len_hi[pipe] = byte;
}
break;
case 3:
*((UINT8 *)(p_cb->at_0x00[pipe] + 1)
+ p_cb->at_0x00[pipe]->len++) = byte;
*((UINT8 *)(p_cb->p_rx_msg[pipe] + 1)
+ p_cb->p_rx_msg[pipe]->len++) = byte;
--p_cb->at_0x0c[pipe];
--p_cb->bytes_left[pipe];
len = UUSB_Read(pipe + 1,
(UINT8 *)(p_cb->at_0x00[pipe] + 1)
+ p_cb->at_0x00[pipe]->len,
p_cb->at_0x0c[pipe]);
(UINT8 *)(p_cb->p_rx_msg[pipe] + 1)
+ p_cb->p_rx_msg[pipe]->len,
p_cb->bytes_left[pipe]);
p_cb->at_0x00[pipe]->len += len;
p_cb->at_0x0c[pipe] -= len;
p_cb->p_rx_msg[pipe]->len += len;
p_cb->bytes_left[pipe] -= len;
bytes_read += len;
if (p_cb->at_0x0c[pipe] == 0)
if (p_cb->bytes_left[pipe] == 0)
{
if (p_cb->at_0x14[pipe] == 2
if (p_cb->pkt_type[pipe] == 2
&& l2cap_link_chk_pkt_end() == 0)
{
p_cb->at_0x1a[pipe] = 0;
p_cb->rx_state[pipe] = 0;
}
else
{
msg_received = TRUE;
p_cb->at_0x1a[pipe] = 0;
p_cb->rx_state[pipe] = 0;
}
}
break;
case 4:
--p_cb->at_0x0c[pipe];
--p_cb->bytes_left[pipe];
if (p_cb->at_0x0c[pipe] == 0)
p_cb->at_0x1a[pipe] = 0;
if (p_cb->bytes_left[pipe] == 0)
p_cb->rx_state[pipe] = 0;
break;
}
if (msg_received)
{
GKI_send_msg(hcisu_h2_cb.at_0x1f, 0, p_cb->at_0x00[pipe]);
p_cb->at_0x00[pipe] = NULL;
GKI_send_msg(hcisu_h2_cb.task_id, 0, p_cb->p_rx_msg[pipe]);
p_cb->p_rx_msg[pipe] = NULL;
}
}
@@ -382,7 +382,7 @@ void hcisu_h2_send_msg_now(tHCISU_H2_CB *cb, HC_BT_HDR *p_msg)
{
p_msg->event = MSG_HC_TO_STACK_L2C_SEG_XMIT;
GKI_send_msg(hcisu_h2_cb.at_0x1f, 0, p_msg);
GKI_send_msg(hcisu_h2_cb.task_id, 0, p_msg);
return;
}
@@ -405,15 +405,15 @@ void hcisu_h2_send_msg(tHCISU_H2_CB *p_cb, HC_BT_HDR *p_msg)
void hcisu_h2_init(UINT8 taskId, UINT8 mbox, UINT16 bufSize)
{
hcisu_h2_cb.at_0x1e = 0;
hcisu_h2_cb.open_state = 0;
hcisu_h2_cb.at_0x1a[0] = 0;
hcisu_h2_cb.at_0x1a[1] = 0;
hcisu_h2_cb.at_0x1a[2] = 0;
hcisu_h2_cb.rx_state[0] = 0;
hcisu_h2_cb.rx_state[1] = 0;
hcisu_h2_cb.rx_state[2] = 0;
hcisu_h2_cb.at_0x1f = taskId;
hcisu_h2_cb.at_0x20 = mbox;
hcisu_h2_cb.at_0x12 = bufSize;
hcisu_h2_cb.task_id = taskId;
hcisu_h2_cb.mbox = mbox;
hcisu_h2_cb.buf_size = bufSize;
}
BOOLEAN hcisu_h2_open(tHCI_CFG *_p_cfg)
@@ -424,9 +424,9 @@ BOOLEAN hcisu_h2_open(tHCI_CFG *_p_cfg)
uusb.at_0x0b = 0;
uusb.at_0x04 = p_cfg->at_0x00;
uusb.at_0x06 = p_cfg->at_0x02;
uusb.at_0x08 = hcisu_h2_cb.at_0x1f;
uusb.at_0x08 = hcisu_h2_cb.task_id;
hcisu_h2_cb.at_0x1e = 2;
hcisu_h2_cb.open_state = 2;
UUSB_Register(&uusb);
UUSB_Open(&uusb, &hcisu_h2_usb_cback);
@@ -436,7 +436,7 @@ BOOLEAN hcisu_h2_open(tHCI_CFG *_p_cfg)
void hcisu_h2_close(void)
{
hcisu_h2_cb.at_0x1e = 0;
hcisu_h2_cb.open_state = 0;
UUSB_Close();
UUSB_Unregister();
@@ -454,7 +454,7 @@ int hcisu_h2_handle_event(UINT16 len)
UINT16 bytes_read;
bytes_read = hcisu_h2_receive_msg(
len - sizeof(HC_BT_HDR) - hcisu_h2_cb.at_0x12, &hcisu_h2_cb);
len - sizeof(HC_BT_HDR) - hcisu_h2_cb.buf_size, &hcisu_h2_cb);
return 0;
}

View File

@@ -33,7 +33,7 @@ typedef struct
u8 bulkEndpoint1;
u8 bulkEndpoint2;
u8 intrEndpoint1;
char at_0x13; // intrEndpoint2?
u8 intrEndpoint2;
int vid;
int pid;
UINT8 cmd_buffer_pool;
@@ -46,9 +46,9 @@ typedef struct
char pad4_[1];
UINT8 reading_intr_data;
BUFFER_Q bulk_buffer_q;
UINT8 at_0x38;
UINT8 bulk_outstanding;
BUFFER_Q intr_buffer_q;
UINT8 at_0x48;
UINT8 intr_outstanding;
char pad8_[3];
} tUUSB_CB;
@@ -158,7 +158,7 @@ static void uusb_CloseDeviceCB(long result, void *p_data)
usb.bulkEndpoint1 = 0;
usb.bulkEndpoint2 = 0;
usb.intrEndpoint1 = 0;
usb.at_0x13 = 0;
usb.intrEndpoint2 = 0;
usb.fd = 0;
@@ -363,12 +363,12 @@ static void uusb_WriteCtrlDataCB(long result, void *p_data)
GKI_disable();
--usb.at_0x48;
--usb.intr_outstanding;
GKI_enable();
}
if (usb.at_0x48 >= 5)
if (usb.intr_outstanding >= 5)
return;
if (usb.intr_buffer_q.count == 0)
@@ -389,7 +389,7 @@ static void uusb_WriteCtrlDataCB(long result, void *p_data)
{
GKI_disable();
++usb.at_0x48;
++usb.intr_outstanding;
GKI_enable();
}
@@ -411,12 +411,12 @@ static void uusb_WriteBulkDataCB(long result, void *p_data)
GKI_disable();
--usb.at_0x38;
--usb.bulk_outstanding;
GKI_enable();
}
if (usb.at_0x38 >= 5)
if (usb.bulk_outstanding >= 5)
return;
if (usb.bulk_buffer_q.count == 0)
@@ -436,7 +436,7 @@ static void uusb_WriteBulkDataCB(long result, void *p_data)
{
GKI_disable();
++usb.at_0x38;
++usb.bulk_outstanding;
GKI_enable();
}
@@ -504,7 +504,7 @@ void UUSB_Register(tUUSB *uusb)
usb.bulkEndpoint1 = 0;
usb.bulkEndpoint2 = 0;
usb.intrEndpoint1 = 0;
usb.at_0x13 = 0;
usb.intrEndpoint2 = 0;
if (uusb_get_devId(usb.vid, usb.pid) < 0)
return;
@@ -512,13 +512,13 @@ void UUSB_Register(tUUSB *uusb)
usb.bulkEndpoint1 = 2;
usb.bulkEndpoint2 = 130;
usb.intrEndpoint1 = 129;
usb.at_0x13 = 0;
usb.intrEndpoint2 = 0;
GKI_init_q(&usb.bulk_buffer_q);
usb.at_0x38 = 0;
usb.bulk_outstanding = 0;
GKI_init_q(&usb.intr_buffer_q);
usb.at_0x48 = 0;
usb.intr_outstanding = 0;
usb.cmd_buffer_pool = GKI_create_pool(660, 45, 1, NULL);
usb.acl_buffer_pool = GKI_create_pool(1800, 30, 1, NULL);
@@ -607,7 +607,7 @@ UINT16 UUSB_Write(UINT8 pipe, void *p_data, UINT16 len, void *unused)
memcpy(p_buffer, p_data, len);
if (usb.at_0x48 < 5 && usb.intr_buffer_q.count == 0)
if (usb.intr_outstanding < 5 && usb.intr_buffer_q.count == 0)
{
ret = IUSB_WriteCtrlMsgAsync(usb.fd, 0x20, 0, 0, 0, len, p_buffer,
uusb_WriteCtrlDataCB, p_buf);
@@ -634,7 +634,7 @@ UINT16 UUSB_Write(UINT8 pipe, void *p_data, UINT16 len, void *unused)
{
GKI_disable();
++usb.at_0x48;
++usb.intr_outstanding;
GKI_enable();
}
@@ -658,7 +658,7 @@ UINT16 UUSB_Write(UINT8 pipe, void *p_data, UINT16 len, void *unused)
if (len > 190)
UUSBDBG(" woah ! thats pretty Big ! :%d", len);
if (usb.at_0x38 < 5 && usb.bulk_buffer_q.count == 0)
if (usb.bulk_outstanding < 5 && usb.bulk_buffer_q.count == 0)
{
ret = IUSB_WriteBlkMsgAsync(usb.fd, usb.bulkEndpoint1, len,
p_buffer, uusb_WriteBulkDataCB, p_buf);
@@ -685,7 +685,7 @@ UINT16 UUSB_Write(UINT8 pipe, void *p_data, UINT16 len, void *unused)
{
GKI_disable();
++usb.at_0x38;
++usb.bulk_outstanding;
GKI_enable();
}

View File

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

View File

@@ -11,7 +11,7 @@ typedef struct PFD_SDDRV_INFO {
u32 media_inserted;
u32 media_ejected;
s8 drive;
} PFD_SDDRV_INFO;
} ATTRIBUTE_ALIGN(8) PFD_SDDRV_INFO;
typedef union PFD_SDDEV_STORAGE {
SDDev device;

View File

@@ -86,9 +86,15 @@ s32 uhf_msc_blk_mount(FADisk* disk) {
return ((device->flags >> 2) & 1) - 1;
}
static inline u16 ReadTransferBlocks(u32 remaining, u32 limit) {
u16 count = limit;
if (remaining <= limit) { count = remaining; }
return count;
}
s32 uhf_msc_blk_pread(FADisk* disk, u8* buffer, u32 sector, u32 blocks, u32* completed) {
struct { UHF_MSC_DEVICE* device; u16 blocks; } transfer;
s32 error;
UHF_MSC_DEVICE* device;
u32 block_size;
u8* transfer_buffer;
u32 transfer_limit;
@@ -102,14 +108,24 @@ s32 uhf_msc_blk_pread(FADisk* disk, u8* buffer, u32 sector, u32 blocks, u32* com
if (blocks == 0) {
return 0;
}
device = uhf_msc_blk_find_device(disk);
if (device == NULL) {
transfer.device = NULL;
{
u32 index;
UHF_MSC_DEVICE* candidate;
for (candidate = uhg_msc_blk_device_tbl, index = 0; index < 8; candidate++, index++) {
if (candidate->disk == disk) {
transfer.device = &uhg_msc_blk_device_tbl[index];
break;
}
}
}
if (transfer.device == NULL) {
return -1;
}
if (!(device->flags & 4)) {
if (!(transfer.device->flags & 4)) {
return -1;
}
block_size = device->block_size;
block_size = transfer.device->block_size;
if (block_size == 0) {
return -1;
}
@@ -127,21 +143,18 @@ s32 uhf_msc_blk_pread(FADisk* disk, u8* buffer, u32 sector, u32 blocks, u32* com
transfer_buffer = buffer;
}
do {
u16 transfer_blocks = transfer_limit;
if (blocks <= transfer_limit) {
transfer_blocks = blocks;
}
error = usbh_msc_read10(device, sector, transfer_blocks, transfer_buffer, sense);
transfer.blocks = ReadTransferBlocks(blocks, transfer_limit);
error = usbh_msc_read10(transfer.device, sector, transfer.blocks, transfer_buffer, sense);
if (error == 0) {
if (!cacheable) {
memcpy(buffer, transfer_buffer, transfer_blocks * block_size);
buffer += transfer_blocks * block_size;
memcpy(buffer, transfer_buffer, transfer.blocks * block_size);
buffer += transfer.blocks * block_size;
} else {
transfer_buffer += transfer_blocks * block_size;
transfer_buffer += transfer.blocks * block_size;
}
blocks -= transfer_blocks;
sector += transfer_blocks;
*completed += transfer_blocks;
blocks -= transfer.blocks;
sector += transfer.blocks;
*completed += transfer.blocks;
if (blocks == 0) {
break;
}
@@ -151,8 +164,8 @@ s32 uhf_msc_blk_pread(FADisk* disk, u8* buffer, u32 sector, u32 blocks, u32* com
case 11:
break;
case 34:
if (device->disk != NULL) {
pdm_disk_notify_media_insert(device->disk);
if (transfer.device->disk != NULL) {
pdm_disk_notify_media_insert(transfer.device->disk);
}
break;
default:
@@ -186,7 +199,17 @@ s32 uhf_msc_blk_pwrite(FADisk* disk, u8* buffer, u32 sector, u32 blocks, u32* co
if (blocks == 0) {
return 0;
}
device = uhf_msc_blk_find_device(disk);
device = NULL;
{
u32 index;
UHF_MSC_DEVICE* candidate;
for (candidate = uhg_msc_blk_device_tbl, index = 0; index < 8; candidate++, index++) {
if (candidate->disk == disk) {
device = &uhg_msc_blk_device_tbl[index];
break;
}
}
}
if (device == NULL) {
return -1;
}

View File

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

View File

@@ -550,7 +550,15 @@ pf_s32 PFCACHE_DoWriteSector(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, const pf
#pragma dont_inline reset
#pragma dont_inline on
static inline pf_u32 PFCACHE_RecordPageEndOverlap(PF_CACHE_PAGE* p_page, pf_u32 end_sector, pf_u32* p_num_success, pf_u32* p_num_rest_sector) {
pf_u32 last_sector = end_sector - 1;
pf_u32 num_overlap = end_sector - p_page->sector;
*p_num_success += num_overlap;
*p_num_rest_sector -= num_overlap;
p_page->stat |= 2;
return last_sector;
}
pf_s32 PFCACHE_DoWriteNumSectorAndFreeIfNeeded(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, const pf_u8* p_buf, pf_u32 sector,
pf_u32 num_sector, pf_u32* p_num_success) {
PF_CACHE_PAGE* p_page = PF_NULL;
@@ -609,11 +617,9 @@ pf_s32 PFCACHE_DoWriteNumSectorAndFreeIfNeeded(PF_VOLUME* p_vol, PF_CACHE_PAGE**
(p_page->sector + p_page->size) >= (sector + num_sector)) {
pf_memcpy(p_page->buffer, (pf_u8*)&p_buf[(p_page->sector - sector) << p_vol->bpb.log2_bytes_per_sector],
(sector + num_sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector);
num_overlap = p_page->size - ((p_page->sector + p_page->size) - (num_sector + sector));
last_sector = p_page->sector + num_overlap - 1;
*p_num_success += num_overlap;
num_rest_sector -= num_overlap;
p_page->stat |= 2;
num_overlap = num_sector;
num_overlap += sector;
last_sector = PFCACHE_RecordPageEndOverlap(p_page, num_overlap, p_num_success, &num_rest_sector);
p_ebuf = &p_page->buffer[(last_sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector];
p_page->p_mod_sbuf = p_page->buffer;
if (p_page->p_mod_ebuf == NULL || p_page->p_mod_ebuf < p_ebuf) {

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;
@@ -599,31 +603,35 @@ pf_s32 PFCLUSTER_InsertCluster(PFCLUSTER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent,
pf_s32 PFCLUSTER_DeleteCluster(PFCLUSTER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent,
pf_u32 cluster_index, pf_u32 num_clusters, pf_u32* p_deleted_clusters) {
struct ClusterDeletion {
pf_u32 length;
pf_u32 cluster_size;
pf_u32 position;
};
struct ClusterDeletion deletion;
pf_s32 err;
pf_u32 previous_cluster;
pf_u32 next_cluster;
pf_u32 first_deleted_cluster;
pf_u32 last_deleted_cluster;
PF_VOLUME* p_vol;
pf_u32 cluster_size;
pf_u32 byte_position;
p_vol = p_ent->p_vol;
cluster_size = p_vol->bpb.bytes_per_sector << p_vol->bpb.log2_sectors_per_cluster;
byte_position = cluster_index * cluster_size;
deletion.cluster_size = p_vol->bpb.bytes_per_sector << p_vol->bpb.log2_sectors_per_cluster;
deletion.position = cluster_index * deletion.cluster_size;
err = PFFAT_TraceClustersChain(&p_iter->ffd, *p_iter->ffd.p_start_cluster,
byte_position, &previous_cluster, &first_deleted_cluster);
deletion.position, &previous_cluster, &first_deleted_cluster);
if (err != 0) return err;
if (cluster_index == 0) first_deleted_cluster = p_ent->start_cluster;
num_clusters = num_clusters * cluster_size;
if (num_clusters > p_ent->file_size - byte_position) num_clusters = p_ent->file_size - byte_position;
err = PFFAT_TraceClustersChain(&p_iter->ffd, first_deleted_cluster, num_clusters, &last_deleted_cluster, &next_cluster);
deletion.length = num_clusters * deletion.cluster_size;
if (deletion.length > p_ent->file_size - deletion.position) deletion.length = p_ent->file_size - deletion.position;
err = PFFAT_TraceClustersChain(&p_iter->ffd, first_deleted_cluster, deletion.length, &last_deleted_cluster, &next_cluster);
if (err != 0) return err;
if (cluster_index == 0) {
if (next_cluster == PFFAT_GetValueOfEOC2(p_vol)) next_cluster = 0;
p_ent->start_cluster = next_cluster;
}
p_ent->file_size -= num_clusters;
p_ent->file_size -= deletion.length;
PFENT_getcurrentDateTimeForEnt(&p_ent->modify_date, &p_ent->modify_time);
p_ent->access_date = p_ent->modify_date;
err = PFENT_updateEntry(p_ent, 1);
@@ -632,13 +640,13 @@ pf_s32 PFCLUSTER_DeleteCluster(PFCLUSTER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent,
err = PFCACHE_FlushDataCacheSpecific(p_vol, PF_NULL);
if (err != 0) return err;
}
err = PFFAT_FreeChain(&p_iter->ffd, first_deleted_cluster, -1U, num_clusters);
err = PFFAT_FreeChain(&p_iter->ffd, first_deleted_cluster, -1U, deletion.length);
if (err != 0) return err;
if (cluster_index != 0) {
err = PFFAT_WriteValueToSpecifiedCluster(p_vol, previous_cluster, next_cluster);
if (err != 0) return err;
}
*p_deleted_clusters = num_clusters / cluster_size;
if (num_clusters % cluster_size != 0) ++*p_deleted_clusters;
*p_deleted_clusters = deletion.length / deletion.cluster_size;
if (deletion.length % deletion.cluster_size != 0) ++*p_deleted_clusters;
return 0;
}

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