Compare commits

...

314 Commits

Author SHA1 Message Date
coah
0188680a57 decomp(memoryCard): match create_banner with banner texture helpers (rx7 astra max) (worker e78a3a35) 2026-10-05 11:12:41 +00:00
coah
6b57fb49a1 refactor: name placeholder fields in browser, TVRC, NHTTP and keyboard utilities; reformat NHTTP stdlib (rx21) (worker a5a11fba) (#1200) 2026-10-05 06:07:08 -05:00
coah
3620369944 refactor: name placeholder members in Setting, ChannelSelect, ChannelTitle and utilities (rx20) (worker f8ebca28) (#1199) 2026-10-05 06:01:41 -05:00
coah
ce2eff9497 decomp(TMC_JPEG): write make_huffdec in C (rx19 astra max) (worker 3c1da6c2) (#1198) 2026-10-05 05:58:59 -05:00
coah
a02d711ef5 decomp(eZiText): match ZiDAWGGetGraphInfo (rx14 astra max) (worker 7f33b2f1) (#1197) 2026-10-05 05:32:23 -05:00
coah
a06cbaa8af decomp(wad): match WADImportGetBlocks and WADImportDVDExForBS (rx10 astra max) (worker b00659fa) (#1196) 2026-10-05 05:22:22 -05:00
coah
e208b20510 decomp(cardSequence): match runCardMoveOrCopy with a temporary-file helper (rx7 astra max) (worker 2cd1accd) (#1195) 2026-10-05 05:19:37 -05:00
coah
c9860af4e9 link(keyboard): link tiCellPhone and tiSignWindow (function order, inline constructors) (rx6 astra max) (worker 6439ed29) (#1194) 2026-10-05 05:02:05 -05:00
coah
fbe34d0ab2 decomp(CHANSVm): match Blob.unpack with per-case element locals (rx1 astra max) (worker 120dcc53) (#1193) 2026-10-05 04:54:55 -05:00
coah
c6b3c56242 decomp(TMC_JPEG): match four RGB565 converters with per-pixel locals (rx13 astra max) (worker 4aa915db) (#1192) 2026-10-05 04:31:39 -05:00
coah
ea88e9efa1 decomp(keyboard): match CellPhone and SignWindow create with const pane tables (rx6 astra max) (worker 9f4ffda8) (#1191) 2026-10-05 04:27:19 -05:00
coah
b18153a1da decomp(kpad,nwc24): match KPADInit and NWC24InitDlTask; link KPAD and NWC24Download (perm2 astra max) (worker 9a2e5e79) (#1190) 2026-10-05 04:21:34 -05:00
coah
aced52f0e4 decomp(wad,sd_drv): match WADImportEx, export loop and MBR geometry (rx10 astra max) (worker ecc2ae60) (#1189) 2026-10-05 03:37:04 -05:00
coah
1a7f21dab7 decomp(memoryCard): match getComment with a comment trim helper (rx7 astra max) (worker 8ad31ecd) (#1188) 2026-10-05 02:56:34 -05:00
coah
124c4df09b decomp(kbd_lib): match kbdEventHandler with plain indexing and explicit status checks (rx6 astra max) (worker 5bc54dee) (#1187) 2026-10-05 02:32:46 -05:00
coah
5bdfe797a9 decomp(CDBRecord): match CDBRecordEncrypt with record-file helpers and link the unit (perm astra max) (worker bfaa3bab) (#1186) 2026-10-05 01:57:27 -05:00
coah
afabe7ca32 decomp(CHANSVm): match CHANSVmFormatString and VmStringSplit with properly typed locals (rx1 astra max) (worker ef7f5583) (#1185) 2026-10-05 01:43:47 -05:00
coah
974607ddd4 decomp(CDB): CDBFSIsCDBFileOnSD in C instead of asm (rx2 astra max) (worker bf7b55e1) (#1184) 2026-10-05 01:36:21 -05:00
coah
7d12fe2c76 link(iqdec_b65_frv32): mark Matching (orch) (worker da950e66) (#1183) 2026-10-05 01:30:34 -05:00
coah
e8dfcbef18 decomp(TMC_JPEG): three asm bodies to C, match exif_parse and decode_iquant via the register allocator debugger (rx5 astra max) (worker da1f1184) (#1182) 2026-10-05 01:26:49 -05:00
coah
48c6d3fcdf fix(TMC_JPEG): use the actual thumbnail parameter type (#1181) 2026-10-05 00:50:11 -05:00
coah
bfbaf84f16 decomp: exception_callback and ISD_GetCardSize in C, guided by the register allocator debugger (rx2 astra max) (worker 514344e8) (#1180) 2026-10-05 00:41:26 -05:00
coah
f7cc4a45a5 decomp(TMC_JPEG): init_buff_thumbnail in C instead of asm (g5 astra max) (worker 9d65a136) (#1179) 2026-10-05 00:17:19 -05:00
coah
21c5ceda39 fix(Button): make friend declaration consistent across translation units (#1178) 2026-10-04 23:10:42 -05:00
coah
f22468d1e8 decomp(md5): match ProcessBlock and link md5 (g3 astra max, orch cleanup) (worker 582c432b) (#1177) 2026-10-04 22:59:00 -05:00
coah
7b29f284c1 decomp: six asm bodies rewritten in C++ (sound, GUI, TVRC, button, channel select, input form) (da7 astra max) (worker 08481d4a) (#1176) 2026-10-04 22:25:10 -05:00
coah
78046280f4 decomp(TMC_JPEG): decode_iquant_rc in C instead of asm (da4 astra max) (worker 925c7716) (#1175) 2026-10-04 22:21:49 -05:00
coah
66ff3a4331 Initialize card operation result from target file value (#1174) 2026-10-04 21:55:58 -05:00
coah
0aa16c0792 fix(cdb): unify date helper signatures without code changes (#1173) 2026-10-04 21:44:23 -05:00
coah
f8957ca95b decomp(TMC_JPEG): imagestart, parse_para and parse_sos in C instead of asm (da4 astra max) (worker 086d70d1) (#1172) 2026-10-04 21:24:38 -05:00
coah
02fe1755d2 link(iplAddress): emit Pane::SetTranslate out of line at its original position and mark Matching (lnkaddr astra max) (worker 47585d6b) (#1171) 2026-10-04 21:21:00 -05:00
coah
5e7b5ad045 decomp(SDK): WPADiManageHandler and _CNTCACHEDeleteTitle in C; asm inventory (da5 astra max) (worker 9711c6cc) (#1170) 2026-10-04 21:17:23 -05:00
coah
ca031bd8ff decomp(MemoryCard): card-thread shared fields are volatile; match isBannerEnable and getBlocks (lv19 astra max) (worker 912ee959) (#1169) 2026-10-04 21:09:01 -05:00
coah
b276099f02 decomp(Address): match onEventDerived through the button-scene helper (f5 astra max) (worker 3bd0da30) (#1168) 2026-10-04 21:05:52 -05:00
coah
6bf8283ef1 decomp(RevoEX): replace 10 asm bodies in CDB, NWC24, VF and WD with C (da2 astra max) (worker ce42149c) (#1167) 2026-10-04 21:01:12 -05:00
coah
b7a912ce02 decomp(CHANSVm): write VmPushFuncReturnInfo in C instead of asm (da3 astra max) (worker d03b20da) (#1166) 2026-10-04 20:51:14 -05:00
coah
60341ca483 decomp(CdbBackup): C++ backup tasks with a volatile completion flag (orch) (worker e4439837) (#1165) 2026-10-04 20:42:50 -05:00
coah
7aa71d2930 decomp(cdb): recover exact search callback with REA (#1164) 2026-10-04 20:31:36 -05:00
coah
9d40859ee8 decomp(nup): match __nupGetTitleSize and __nupGetBootVersion with a typed TMD view and literal tag lookups (f14 astra max) (worker b4da4bd9) (#1163) 2026-10-04 20:10:16 -05:00
coah
0292750816 decomp: replace asm bodies of doSave, makeTmpList, pushTitleCache and compressGbaOdh with C++ (da1 astra max) (worker d78193c6) (#1162) 2026-10-04 20:02:52 -05:00
coah
bfe77b7f8e link(iplKeyboard): emit memo::Manager::getSaveData at its original position and mark Matching (lnkkbd astra max) (worker 0c8071ee) (#1161) 2026-10-04 19:24:12 -05:00
coah
a461786f08 decomp(iplKeyboard): match Manager::create (f12 astra max) (worker 7f64b0e8) (#1160) 2026-10-04 19:12:33 -05:00
coah
491bba6ae3 decomp(Address): match start_drag_event through the portrait accessor and root-pane lookup (f5 astra max) (worker 1a15738b) (#1159) 2026-10-04 19:03:19 -05:00
coah
f5874959b2 decomp(MemoryCardManager): match isMoveEnable/isCopyEnable by indexing the card directory directly (orch) (worker 799a643a) (#1158) 2026-10-04 18:16:09 -05:00
coah
4aaede9980 data(zi8cgetc 100%): align zi8InternalGetZH case layout with its four jump tables (sz2b astra max) (worker 66e2b232) (#1155) 2026-10-04 13:48:34 -05:00
coah
d1ad0d8238 data(ATERM 100%): RunConfigProtocol case layout and real protocol buffers (sz3 astra max) (worker bf49a5f7) (#1154) 2026-10-04 13:37:02 -05:00
coah
5acae0d661 data(zkokeyp, zprepare 100%): match function sizes for extab and jump-table layout (sz1 astra max) (worker a377ff13) (#1153) 2026-10-04 13:25:01 -05:00
coah
99ba99ee2f data(zi8alpha 100%): align Zi8AlphaGetCandidates case layout with the jump table (sz2 astra max) (worker 43f654d5) (#1152) 2026-10-04 13:14:24 -05:00
coah
f598e41020 Keep CHANS hexadecimal decoding in one value lifetime (#1151) 2026-10-03 22:08:33 -05:00
coah
631f31b7f8 Isolate the CHANSVm blob copy and padding block (#1150) 2026-10-03 21:39:40 -05:00
coah
4508f455db Align ATERM discovery record induction scheduling (#1149) 2026-10-03 20:42:08 -05:00
coah
f7a1067224 Recover ATERM discovery MAC loop and shared timeout exit (#1148) 2026-10-03 20:22:18 -05:00
coah
c5e1fe9cca Recover counted MAC-format loops in ATERM association request (#1147) 2026-10-03 19:26:15 -05:00
coah
9aa4a0d887 Improve card loader comment bounds with lazy shared rejection (#1146) 2026-10-03 18:27:11 -05:00
coah
db6157b693 decomp(tiZiString): split candidate buffers at original boundaries, match clearCandidates and setElementBuffer (agg astra max) (worker 8cb13c23) (#1145) 2026-10-03 16:58:37 -05:00
coah
6cc5d74418 Improve NWC24InitDlTask through existing writable validation helper (#1144) 2026-10-03 16:33:15 -05:00
coah
38cb84c8ab decomp(ATERM): match StartNetworkStack with real IP/interface config globals (h2b astra max) (worker 7d5610ae) (#1143) 2026-10-03 16:17:12 -05:00
coah
bd5efc9c56 Improve WADBackupEx file-owner initialization order (#1142) 2026-10-03 15:58:18 -05:00
coah
34858f3fe1 decomp(ATERM): match ParseAssociationResponse via hex-encode helper (h2 astra max) (worker e589875a) (#1141) 2026-10-03 15:43:48 -05:00
coah
ae5a5769e1 link(eggAudioExpMgr): restore thunk order with the dead-stripped ExpAudioMgr (orch) (worker 83b6503f) (#1140) 2026-10-03 15:39:05 -05:00
coah
924328eadb Improve WADBackupEx zero-initialization order with exact state proof (#1139) 2026-10-03 15:38:29 -05:00
coah
56f64ea49a decomp(tiCellPhone): match onKey via key lookup helpers (a23m astra max) (worker eaae1b60) (#1138) 2026-10-03 15:17:22 -05:00
coah
49be1c79c5 data(BS2Mach 100%): name boot info and device code (worker 7003f256) (#1137) 2026-10-03 15:00:35 -05:00
coah
5473a84f21 link(pf_cache, zconvert): mark as Matching (worker 01feb2d8) (#1136) 2026-10-03 14:52:27 -05:00
coah
0b671e4883 link(tiPcKeyboard): restore inline-method emission and destructor thunk order (lnkx astra xhigh) (worker 45d2d3ca) (#1135) 2026-10-03 14:50:36 -05:00
coah
5bfe5eaec0 match(zconvert 4/4) (a7m astra max) (worker 2a9742a0) (#1134) 2026-10-03 14:49:09 -05:00
coah
8621ed6c36 match(pf_cache 36/36): inline end-overlap expression (worker 554a8a8a) (#1133) 2026-10-03 14:47:32 -05:00
coah
4de92186c8 Improve CandidateBox create with right-scroll address captures (#1132) 2026-10-03 13:37:34 -05:00
coah
5af01fa8b9 match(tiCandidateBox 109/112) (a23h astra high) (worker 5e20580b) (#1131) 2026-10-03 13:11:40 -05:00
coah
d0c82cfe83 Improve CandidateBox create with explicit left-scroll name captures (#1130) 2026-10-03 13:08:21 -05:00
coah
b0abd1851f match(CHANSVm 224/233) (a5h2 astra high) (worker 1c37888a) (#1129) 2026-10-03 13:00:20 -05:00
coah
a120e4780c match(CHANSVm 223/233) (a5h astra high) (worker 89583696) (#1128) 2026-10-03 12:45:17 -05:00
coah
934587c4a9 Refine RGBA411 edge chroma-skip declaration allocation (#1127) 2026-10-03 12:34:37 -05:00
coah
f170531aa3 match(AOSS 17/21) (a4 astra) (worker 6f8307e2) (#1126) 2026-10-03 12:21:28 -05:00
coah
8479c50afd match(tiPcKeyboard 141/141): uninitialized key mode on invalid input (worker 3b354cf1) (#1125) 2026-10-03 12:17:43 -05:00
coah
30d968099a Retain candidate-window name address across pane lookups (#1124) 2026-10-03 12:11:46 -05:00
coah
1701b591a6 Improve RGBA411 edge declaration order using official fuzzy scores (#1123) 2026-10-03 12:06:41 -05:00
coah
b6fce1251c Improve AOSS hello RC4 scalar allocation with lifetime proof (#1122) 2026-10-03 12:00:27 -05:00
coah
201de1982d Align tiZiString case-loop increment order with original (#1121) 2026-10-03 11:48:11 -05:00
coah
57c17ebe2a Improve RGB565422 tile-width declaration allocation (#1120) 2026-10-03 11:29:52 -05:00
coah
da41bad952 Improve tiZiString case-conversion scalar allocation with restoration proof (#1119) 2026-10-03 11:24:46 -05:00
coah
b6786bb798 Improve RGBA422 edge declaration order using official fuzzy scores (#1118) 2026-10-03 11:20:03 -05:00
coah
bb662f37e6 Improve card icon-loader scalar declaration allocation (#1117) 2026-10-03 11:13:26 -05:00
coah
246c3f8056 Improve RGB565422 declaration allocation using official fuzzy scores (#1116) 2026-10-03 11:08:42 -05:00
coah
0fa58cf361 match(kbd_lib 17/21) (perm6b) (worker 2b9c7ebd) (#1115) 2026-10-03 11:01:05 -05:00
coah
86e5694193 Improve tiZiString candidate-copy scalar allocation with continuation evidence (#1114) 2026-10-03 10:53:26 -05:00
coah
a4a4374cd2 Improve RGB565420 row endpoint declaration allocation (#1113) 2026-10-03 10:33:37 -05:00
coah
1f260c24e5 Improve RGBA420 texture and tile-row declaration allocation (#1112) 2026-10-03 10:22:28 -05:00
coah
d4b9850a45 Improve RGB565420 declaration allocation with verified texture/yEnd order (#1111) 2026-10-03 10:13:13 -05:00
coah
636f8eb03a decomp(jpeg): refine RGBA420 tile row declaration order (#1110) 2026-10-03 09:57:55 -05:00
coah
1e0643fee3 decomp(jpeg): improve normal RGB565420 official-fuzzy declaration order (#1109) 2026-10-03 09:47:09 -05:00
coah
d124cf0530 decomp(jpeg): refine RGBA420 output declaration order (#1108) 2026-10-03 09:34:52 -05:00
coah
ccffee8af5 decomp(jpeg): improve RGBA420 order using official snapshot scores (#1107) 2026-10-03 09:15:01 -05:00
coah
36f0d43f2d decomp(jpeg): improve RGB565411 tile width declaration order (#1106) 2026-10-03 08:55:12 -05:00
coah
c1b8318a1d decomp(jpeg): improve RGBA422 order using official snapshot scores (#1105) 2026-10-03 08:45:56 -05:00
coah
07a021918e decomp(jpeg): improve RGB565411 red offset declaration order (#1104) 2026-10-03 08:38:09 -05:00
coah
e8c465a082 decomp(jpeg): improve RGB565411 allocation with fixed-neighbor audit (#1103) 2026-10-03 08:21:21 -05:00
coah
e7ade28ae7 decomp(jpeg): improve RGBA411 allocation with output declaration order (#1102) 2026-10-03 08:04:33 -05:00
coah
17e497e06d decomp(ATERM): initialize case-eight checksum before conversions (#1101) 2026-10-03 07:38:41 -05:00
coah
343d53bbb5 decomp(jpeg): improve Col allocation with done and a declarations (#1100) 2026-10-03 07:32:27 -05:00
coah
d901e5cf88 decomp(ATERM): initialize case-six checksum before conversions (#1099) 2026-10-03 07:23:12 -05:00
coah
405fc376c5 decomp(jpeg): retain best observed Col declaration swap (#1098) 2026-10-03 07:15:28 -05:00
coah
50d1494474 decomp(ATERM): align case-five option initialization order (#1097) 2026-10-03 07:04:41 -05:00
coah
02d634d30b decomp(aoss): improve decrypt allocation with fixed-neighbor audit (#1096) 2026-10-03 06:55:25 -05:00
coah
059ed52b0b decomp(jpeg): retain best fixed-neighborhood Lumi order (#1095) 2026-10-03 06:38:36 -05:00
coah
5a2bf89d0c decomp(aoss): retain fuzzy-best decrypt declaration order (#1094) 2026-10-03 06:33:52 -05:00
coah
b41f95f9fe decomp(jpeg): retain observed Lumi outer declaration order (#1093) 2026-10-03 06:20:06 -05:00
coah
ca5ac04a65 fix(ezitext): align Chinese table-address return contract (#1092) 2026-10-03 06:18:23 -05:00
coah
3dd12f63de decomp(jpeg): refine Lumi butterfly declaration order (#1091) 2026-10-03 06:00:04 -05:00
coah
f46483afaf decomp(jpeg): refine grouped edge chroma declarations (#1090) 2026-10-03 05:08:34 -05:00
coah
17130b4b26 decomp(jpeg): retain observed RGB565411 fuzzy-best order (#1089) 2026-10-03 04:50:15 -05:00
coah
180e620c37 decomp(aes): select best exhaustive state declaration order (#1088) 2026-10-03 04:22:54 -05:00
coah
9f39cd84ca decomp(jpeg): refine RGBA422 edge declaration order (#1087) 2026-10-03 04:21:12 -05:00
coah
b25e03773c fix(aoss): align status definition with caller contract (#1086) 2026-10-03 04:14:58 -05:00
coah
a2c008c486 fix(aoss): align sleep declaration with void definition (#1085) 2026-10-03 04:04:12 -05:00
coah
ce3cbf5f91 decomp(aes): refine decrypt state declaration order (#1084) 2026-10-03 04:02:29 -05:00
coah
9e8ca608aa decomp(jpeg): refine RGBA211 edge declaration order (#1083) 2026-10-03 03:59:15 -05:00
coah
7b32451989 decomp(jpeg): refine RGBA411 edge declaration order (#1082) 2026-10-03 03:42:26 -05:00
coah
2c7fa34189 decomp(jpeg): refine RGB565420 normal declaration order (#1081) 2026-10-03 03:40:44 -05:00
coah
dc3eede8d3 decomp(jpeg): refine RGBA422 declaration order (#1080) 2026-10-03 03:22:25 -05:00
coah
f3f295c628 decomp(bs2): capture loader address before publication (#1079) 2026-10-03 02:50:31 -05:00
coah
cd0db8fde0 decomp(fat): separate existing and new SD initialization (#1078) 2026-10-03 02:40:52 -05:00
coah
93e97b7ff1 decomp(bs2): restore disk-presence read before cover reset (#1077) 2026-10-03 02:37:39 -05:00
coah
d170fbb804 decomp(jpeg): refine RGBA420 local declaration order (#1076) 2026-10-03 02:25:22 -05:00
coah
f710d11ff5 decomp(jpeg): refine RGB565420 edge declaration order (#1075) 2026-10-03 02:22:07 -05:00
coah
84d0c74f0a decomp(keyboard): refine existing animation local order (#1074) 2026-10-03 02:06:49 -05:00
coah
bdac66bb07 match(tiCellPhone 84/86) (ult22b) (worker 96a80226) (#1073) 2026-10-03 02:01:40 -05:00
coah
6f96cb5274 decomp(md5): refine verified local declaration order (#1072) 2026-10-03 01:57:35 -05:00
coah
4aafd41e10 link(zi8pud2): mark as Matching (worker 2d8a2a2f) (#1071) 2026-10-03 01:48:17 -05:00
coah
83efd95924 match(zi8pud2 7/7) (ult25) (worker c7cdef3d) (#1070) 2026-10-03 01:46:52 -05:00
coah
43375de179 match(NWC24Download 29/30) (ult20b) (worker 8e26eab8) (#1069) 2026-10-03 01:41:07 -05:00
coah
a4d145c010 match(MemoryCardManager 19/26, tiInputForm 217/221) (ult22) (worker 3363cfb8) (#1068) 2026-10-03 01:30:03 -05:00
coah
e0d3ef0345 match(NWC24Download 28/30) (ult20) (worker 2146dd8f) (#1067) 2026-10-03 01:22:23 -05:00
coah
32be36cb4e decomp(sd-select): align the traversal title declaration lifetime (#1066) 2026-10-03 01:16:20 -05:00
coah
1b5b2da635 decomp(keyboard): group the animation traversal declarations (#1065) 2026-10-03 01:16:15 -05:00
coah
36cbab079f decomp(fat): align MBR traversal declarations (#1064) 2026-10-03 01:15:49 -05:00
coah
b7a06e9d82 decomp(nhttp): distinguish raw token bytes from signed folds (#1063) 2026-10-03 01:03:31 -05:00
coah
b7d9c4fb65 match(ATERM 17/26) (ult15) (worker c46e48b5) (#1062) 2026-10-03 01:01:35 -05:00
coah
e3095dfb97 decomp(jpeg): scope RGB565420 edge pixel values (#1061) 2026-10-03 00:54:15 -05:00
coah
f5a929c9d7 decomp(keyboard): express literal input through an output builder (#1060) 2026-10-03 00:54:10 -05:00
coah
a41f565889 decomp(card): scope the permission-check result (#1059) 2026-10-03 00:52:05 -05:00
coah
d54f8be29a decomp(nwc24): scope writable task validation (#1058) 2026-10-03 00:51:39 -05:00
coah
81ba279958 decomp(fat): clarify reserved-sector initialization success path (#1057) 2026-10-03 00:43:53 -05:00
coah
57ccda3883 fix(chans): assemble integer immediates without signed-shift overflow (#1056) 2026-10-03 00:27:04 -05:00
coah
fd49a94c00 decomp(sd-memory): reconstruct transfer-title scalar lifetimes (#1055) 2026-10-03 00:26:58 -05:00
coah
55ff13a222 decomp(md5): express sequential word consumption (#1054) 2026-10-03 00:26:52 -05:00
coah
d3f5682bc0 link(NWC24DateParser): mark as Matching (worker 566803d4) (#1053) 2026-10-03 00:21:36 -05:00
coah
404a8675f1 refactor(kpad): initialize rotation matrix through its global array (#1051) 2026-10-03 00:20:18 -05:00
coah
878fda2a94 match(NWC24DateParser 8/8) (perm8d) (worker 42a119d6) (#1052) 2026-10-03 00:19:25 -05:00
coah
9131f07806 fix(chans): use the boolean helper's scalar output contract (#1050) 2026-10-03 00:15:35 -05:00
coah
a3e3725c1f match(zi8match 9/10) (ult8) (worker 3f8379ba) (#1049) 2026-10-03 00:08:56 -05:00
coah
fc114afd44 fix(chans): preserve wrapped hex-count rounding without signed overflow (#1048) 2026-10-03 00:01:49 -05:00
coah
409ef82dd8 fix(ezitext): restore Chinese user-dictionary address contract (#1046) 2026-10-02 23:55:35 -05:00
coah
98d8a5220f match(pdm_partition 19/20) (perm8c) (worker 1bb708e7) (#1047) 2026-10-02 23:54:05 -05:00
coah
bb93f1dd8e match(KPAD 28/29) (perm7c) (worker d199502a) (#1045) 2026-10-02 23:52:36 -05:00
coah
140117ea91 fix(keyboard): declare KPRPutChar byte return (#1044) 2026-10-02 23:49:22 -05:00
coah
e58cd9e734 fix(card): match the OS thread entry parameter contract (#1043) 2026-10-02 23:46:07 -05:00
coah
a30b5cecb6 match(NHTTP_stdlib 12/14, NWC24Download 27/30) (perm2b) (worker 26173bfd) (#1042) 2026-10-02 23:44:03 -05:00
coah
5dcbc4372f fix(ezitext): restore version query workspace formals (#1040) 2026-10-02 23:38:24 -05:00
coah
98239e660a match(iplSDChannelSelect 123/129) (ult3) (worker 938cccae) (#1041) 2026-10-02 23:36:12 -05:00
coah
be7ded2fdc match(Texture_MCUtoRGB565 7/13) (tex1) (worker 1a706bf6) (#1039) 2026-10-02 23:26:08 -05:00
coah
fdd68ddd30 fix(aoss): restore WLAN arguments and complete key bounds (#1038) 2026-10-02 23:18:15 -05:00
coah
74dcb16a50 fix(bs2): preserve unsigned local DVD callback contract (#1037) 2026-10-02 23:05:56 -05:00
coah
7c582f0e41 link(FAAttach): mark as Matching (worker 23024341) (#1036) 2026-10-02 23:03:05 -05:00
coah
333eea81e9 match(iplSetting 111/112) (gk1) (worker 9f73134e) (#1035) 2026-10-02 22:57:26 -05:00
coah
a791e598a1 match(iplAddress 98/101) (gk3) (worker 34504409) (#1034) 2026-10-02 22:47:46 -05:00
coah
7654dc33e1 match(NWC24DateParser 7/8) (perm8b) (worker 48b04748) (#1033) 2026-10-02 22:39:49 -05:00
coah
9c7d87ab00 fix(ezitext): recover options receiver and workspace contracts (#1032) 2026-10-02 22:29:31 -05:00
coah
885cdfeee6 fix(fa): align attach adapter pointer contracts (#1031) 2026-10-02 22:22:46 -05:00
coah
cc94a7530c fix(aoss): match scan result output slot contract (#1030) 2026-10-02 22:16:11 -05:00
coah
82da7899a1 fix(fa): preserve the USB disk receiver and match FAAttach (#1029) 2026-10-02 22:14:03 -05:00
coah
bf8ebfa353 fix(chans): declare HMAC helpers with external linkage (#1028) 2026-10-02 21:55:22 -05:00
coah
7649d9b1ec fix(cdb): correct crypt-buffer ownership slot types (#1027) 2026-10-02 21:51:37 -05:00
coah
ce2130f867 fix(ezitext): correct conversion table address return contract (#1026) 2026-10-02 21:49:30 -05:00
coah
20ba34a80f fix(odh): represent Huffman trees as halfword nodes (#1025) 2026-10-02 21:32:37 -05:00
coah
634d8ab6a1 decomp(ezitext): pair current and best phonetic restoration (#1024) 2026-10-02 21:29:22 -05:00
coah
a5e49ea578 decomp(ezitext): recover PUD byte contracts and packed header decoding (#1023) 2026-10-02 21:26:06 -05:00
coah
5e0816c3f1 fix(chansvm): compare parsed indices without signed shift overflow (#1022) 2026-10-02 21:16:47 -05:00
coah
5d7760d341 fix(ezitext): reconcile one-key caller and parameter contracts (#1021) 2026-10-02 21:13:10 -05:00
coah
a894ff5cb7 decomp(aes): recover decrypt final-round dependency tree (#1020) 2026-10-02 21:08:24 -05:00
coah
adea4fb5d1 tools: audit direct call destinations against original DOL (#1019) 2026-10-02 21:05:09 -05:00
coah
e221614209 fix(keyboard): recover original cursor query evaluation order (#1018) 2026-10-02 21:01:53 -05:00
coah
6619098ea7 decomp(kpad): preserve read refinements alongside exact DPD math (#1014) 2026-10-02 20:58:37 -05:00
coah
e9c8986139 link(NWC24MsgSubject) (worker 4edf8de1) (#1017) 2026-10-02 20:42:12 -05:00
coah
b9bda11dea match(NWC24MsgSubject 12/12) (perm8) (worker af25492d) (#1016) 2026-10-02 20:39:46 -05:00
coah
7b8dbf2c96 fix(keyboard): declare cellphone reset on its owning class (#1015) 2026-10-02 20:32:23 -05:00
coah
b7a4105bd6 match(address): reconstruct nullable drag text measurement (#1013) 2026-10-02 20:31:57 -05:00
coah
bc2b18090b match(KPAD 26/29) (perm7, permuter) (worker 7dd8a460) (#1012) 2026-10-02 20:15:24 -05:00
coah
674722c158 decomp(sd): recover scissor projection expressions (#1011) 2026-10-02 20:08:42 -05:00
coah
e81aed2882 fix(sd): restore event metadata predicates (#1010) 2026-10-02 20:08:15 -05:00
coah
7d6057adf6 decomp: reconstruct AddressEdit balloon construction (#1009) 2026-10-02 19:54:25 -05:00
coah
16a170f944 decomp: restore Korean scan entry and lookup widths (#1008) 2026-10-02 19:53:58 -05:00
coah
0904bf9161 match(CHANSVm 222/233) (big1c) (worker bb2bb6af) (#1007) 2026-10-02 19:47:59 -05:00
coah
e5987de5ad fix(nwc24): use a defined unsigned retry mask (#1006) 2026-10-02 19:43:11 -05:00
coah
11bd51b3a9 fix(keyboard): use bounded OEM dictionary accessor (#1005) 2026-10-02 19:42:46 -05:00
coah
e4a9449256 decomp(keyboard): reconstruct candidate animation descriptor lifetimes (#1004) 2026-10-02 19:33:27 -05:00
coah
b940710632 decomp: align Bopomofo consumed-count return contract (#1003) 2026-10-02 19:25:17 -05:00
coah
1fa33882ae decomp(inputform): recover pane lookup and animation slot flow (#1002) 2026-10-02 19:15:58 -05:00
coah
aba50ea278 decomp: recover AOSS initialization guards and request lifetimes (#1001) 2026-10-02 19:15:32 -05:00
coah
14a8b23adb decomp: correct Chinese phonetic contracts and Zhuyin dispatch (#1000) 2026-10-02 19:07:43 -05:00
coah
b8931fae6f decomp: recover card rename retry reset boundary (#999) 2026-10-02 19:07:35 -05:00
coah
bcac23375a decomp(keyboard): correct prediction refresh and character flow (#998) 2026-10-02 19:07:28 -05:00
coah
ed49ada973 decomp: recover ATERM digest and payload lifetimes (#997) 2026-10-02 19:07:02 -05:00
coah
fa0cb9b7b4 decomp(nhttp): recover token loop and Base64 byte flow (#996) 2026-10-02 18:51:40 -05:00
coah
8ffaa9d25a decomp(bs2): preserve update publications and repeated entry reads (#995) 2026-10-02 18:49:17 -05:00
coah
cc812ad30e ci: live README progress badges from a progress-data branch (#994)
The README progress table only changed when a landing commit rewrote it, so
merges outside land.sh left it stale, and the decomp.dev badges showed
upstream's numbers. The progress workflow now publishes shields.io endpoint
JSON to an orphan progress-data branch (one force-pushed commit), so the
badges refresh on every push to main without extra commits on main.
The build badge now points at the workflow that actually builds (Build is
disabled: it needs upstream's private container).
2026-10-02 18:47:05 -05:00
coah
3d3448e3a8 decomp(kbd): reconstruct asynchronous LED dispatch and completion (#993) 2026-10-02 18:42:29 -05:00
coah
654c65dd27 decomp: align EXIF rational denominator address structure (#992) 2026-10-02 18:37:40 -05:00
coah
bb93684b95 decomp: reconstruct alpha boundary and output expressions (#991) 2026-10-02 18:37:35 -05:00
coah
39648c8aa6 decomp(aes): reconstruct final-round word dependencies (#990) 2026-10-02 18:37:29 -05:00
coah
230c3af28f decomp: recover typed partition word decoding (#989) 2026-10-02 18:37:04 -05:00
coah
13881c99fb match(kbd): reconstruct synchronous LED command reservation (#988) 2026-10-02 18:29:15 -05:00
coah
b26e248bb0 decomp: reconstruct BS2 partition and banner paths (#987) 2026-10-02 18:12:23 -05:00
coah
8350f2b4df decomp: recover EXIF entry aliasing and tag semantics (#986) 2026-10-02 18:11:57 -05:00
coah
3851d2cc74 decomp: reconstruct one-key phonetic and result widths (#985) 2026-10-02 18:10:11 -05:00
coah
7bdf4629fd decomp: refine AES table and inverse-key XOR dependencies (#984) 2026-10-02 18:09:45 -05:00
coah
5a222cdec4 match(fa): pfd_sddrv_get_total_sectors byte-identical (#983)
Fold the (max_multiplier - 9) shift count back into max_multiplier so the literal 1 stays in r0 and the count is an in-place clrlwi on r3.
2026-10-02 17:55:54 -05:00
coah
ac8d46d231 fix: model Run stack address independently of printf (#982) 2026-10-02 17:49:33 -05:00
coah
813660b96e match(iplSetting): Setting::draw byte-identical (#980)
draw is 632/632 against retail. The TU stays NonMatching, so the DOL is unchanged.
2026-10-02 17:36:11 -05:00
coah
e82417345a decomp: refine JPEG butterfly and color source structure (#978) 2026-10-02 17:32:07 -05:00
coah
230c2f8d34 decomp: reconstruct typed CHANSVm operands (#977) 2026-10-02 17:31:41 -05:00
coah
524350ed8f decomp: reconstruct alpha output and dictionary scan (#976) 2026-10-02 17:31:14 -05:00
coah
c62453dac9 decomp: recover ESMisc ticket scratch lifetime and cleanup flow (#975) 2026-10-02 17:30:27 -05:00
coah
6b17698b84 match(odh): cdj_c_colorConv byte-identical (#974)
Pad with a named remainder and declare sourceStride after rowIndex so cbPlane stays r22 and the stride stays r29. decompressLoop is unchanged.
2026-10-02 17:28:16 -05:00
devin-ai-integration[bot]
f9358f6e46 Decode BS2Mach Run asm + nup dead-static fossil (stays NonMatching) (#973)
* decomp: BS2Mach Run asm + CoverBlock/state decodes; nup dead-static fossil

- BS2Mach::Run: retail zeroes r0-r31 and installs a custom stack
  (__pformatter+640) before the dcbz/dcbf flush loop and tail jump —
  inexpressible in C, so asm with the exact retail sequence.
- BS2StartGCGame: CoverBlock.state direct member read (orig inlined
  DVDGetCommandBlockStatus accessor).
- BS2StateMachine: GamePartition!=0 polarity fold.
- nup.cpp __nupOp: 'static u32 lo' dead static reproduces orig's second
  .sbss word (orig .sbss=8: rvThread$2389 + 4B dead static).

Verified vs main: BS2Mach 25/29 fns byte-exact, nup 20/23 + .sbss 8=8.
Units stay NonMatching. Full build + DOL sha1 verified.

Co-authored-by: coah80 <usernamecole7@gmail.com>
Co-Authored-By: wch <usernamecole7@gmail.com>

* decomp: drop dead 'static u32 lo' padding from __nupOp

Per review: the extra .sbss word is a padding object — no relocation
references it, and nup data is already exact without it. Left unowned
for the linking pass.

Co-Authored-By: wch <usernamecole7@gmail.com>

---------

Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: coah80 <usernamecole7@gmail.com>
2026-10-02 17:26:43 -05:00
devin-ai-integration[bot]
3aa9daf94a decomp: emission gates for iplSDChannelTitle + MemoryCardManager decodes (#972)
IPL_SD_CHANNEL_TITLE_CPP gates move inline members to declarations so the
TU emits non-inlined calls like retail (same dedup-loss pattern as
#834's vtable restoration): iplInterporation::get, math::VEC3 ctor,
FaderSceneBase::initCalcNormal/calcCommonAfter, SceneBase::isReady/
isResetProcessDone/getParent/getChild/getNext/getPrev, NANDTask::
isFinished/checkData, Graphics::setOrthoTrans/setOrthoScale,
ut::Rect/RuntimeTypeInfo.

Verified vs main: iplSDChannelTitle 68/69 fns byte-exact (152B tail
residual in iplSDChannelTitle_flushSaveBeforeExit), iplMemoryCardManager
18/26. Units stay NonMatching; documented walls in revisit.attempts.md.

Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: coah80 <usernamecole7@gmail.com>
2026-10-02 17:22:10 -05:00
coah
dc48b109b0 match(odh): cdj_d_decompressLoop byte-identical (#971)
Keep the updated 2x2 plane in requiredBlockEnd so MWCC uses r15 for the
plane and r16 for the block end. 899/899, 0 diffs.
2026-10-02 17:15:30 -05:00
devin-ai-integration[bot]
b6f2304efc decomp(scene4): nested-switch guards + dead-store fossils (address/sdChannelSelect) (#970)
Decodes:
- start_drag_event: nested single-case switch emits the b<cond>+b
  two-branch guard (insn-identical, 7-word web-home residual)
- onEventDerived: no-break TRIG->ON_POINT fallthrough + || polarity fold
  (insn-identical, regname residuals)
- set_err_msg: default arm reads uninitialized messageId register,
  matching the orig's uninit-r4 retail bug (verified in base asm)
- movePane_onDrag width-accumulate scoping, FriendListCache::update
  member-chain regroup, AddressEdit::create/get_friendinfo arg marshals

All three units stay NonMatching; data 100% on all; documented walls in
tools/decomp-assist/scene4.attempts.md.

Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: coah80 <usernamecole7@gmail.com>
2026-10-02 17:13:22 -05:00
coah
7fac2b91ec decomp: refine MD5 rotation sums and word consumption (#969) 2026-10-02 17:09:45 -05:00
coah
6456e33a4c decomp: reconstruct AES last-round key cursor (#968) 2026-10-02 17:09:20 -05:00
coah
3244c6d7ff decomp: reconstruct CHANSVm opcode-local error paths (#967) 2026-10-02 16:59:59 -05:00
coah
b2089fbdba decomp: reconstruct alpha restriction gates and suffix fallback (#966) 2026-10-02 16:53:19 -05:00
coah
580b79f40d decomp: reconstruct MD5 endian-loaded rotation operands (#965) 2026-10-02 16:47:00 -05:00
coah
255f3e0530 decomp: reconstruct ESMisc cleanup helpers and return ABI (#964) 2026-10-02 16:42:08 -05:00
coah
d0e5483630 decomp: preserve CHANSVm string-load deletion errors (#963) 2026-10-02 16:35:31 -05:00
coah
d725e02301 link(ut_ArchiveFontBase): Matching after 23/23 code match (#962)
Flip NonMatching→Matching after #961 match(ut_ArchiveFontBase 23/23).
Full 43U rebuild keeps DOL SHA1 26116613f624061ba99c8d1a299aaa6efa85670d.

Co-authored-by: linker <linker@users.noreply.github.com>
2026-10-02 16:27:44 -05:00
devin-ai-integration[bot]
87eaad4a42 decomp(CDBRecord): dead-fn literal fossils + Encrypt 284/284 insn-equal (#960)
Restores ~15 link-deadstripped retail fns whose emitted .data fossil
literals exist in the orig object; DOL-verified byte-identical at the
expected vaddrs. CDBRecordEncrypt auto-inlines dead CDBRecordGetFileSize:
284/284 instructions identical. Unit stays NonMatching: Encrypt's 57-byte
residual is an equal-cost register-packing tie-break (18 source probes
documented in tools/decomp-assist/CDBRecord.attempts.md).

Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: coah80 <usernamecole7@gmail.com>
2026-10-02 16:25:40 -05:00
coah
e32aad81fb match(ut_ArchiveFontBase 23/23) (rt7f, prior-art ref) (worker 2fe052a9) (#961) 2026-10-02 16:23:57 -05:00
coah
449529d924 match(KPAD 25/29) (fz16j) (worker fe716b2a) (#959) 2026-10-02 16:10:06 -05:00
coah
8a07484e8a link(vi) (worker 5b1f07ee) (#957) 2026-10-02 16:07:02 -05:00
coah
2d3bc63c09 match(vi 30/30) (prior1, prior-art ref) (worker 999cdc11) (#956) 2026-10-02 16:04:28 -05:00
coah
3efb9d8676 match(iqdec_b65): port sibling semantics for decode_iquant (30→13 reg) (#955)
Port decode_iquant_rc-style table access / load_buff / conv_row patterns
into TMCJPEGDEC_decode_iquant. Cuts reg-only diffs 30→13 (276/276,
structural 0). Remaining wall is AC huff/zztbl/zz callee-saved
permutation (r29/r30/r24/r25 vs r25/r24/r29/r30).
2026-10-02 16:02:45 -05:00
coah
805e84045c match(NWC24Download 26/30) (pk2) (worker 9f86df06) (#954) 2026-10-02 15:50:50 -05:00
coah
26d7e1e052 link(wprintf): Matching after 9/9 code match (#952)
Flip MSL_Common/wprintf.c NonMatching → Matching.
Unit is instruction-exact (9/9, .text identical, weaks 0/0);
full 43U DOL SHA1 unchanged.

Co-authored-by: linker <linker@users.noreply.github.com>
2026-10-02 15:32:21 -05:00
coah
d78210528f match(KPAD 24/29) (fz16i) (worker f6bc72ec) (#953) 2026-10-02 15:30:01 -05:00
coah
e3457d11a2 match(wprintf 9/9) (#951)
__wpformatter → 100%: drop wideLength temp; narrow #s length via *buff_ptr
(MSL stale-pointer form used by matched TP/SS sources). DOL 26116613…

Co-authored-by: decomp worker 3 <decomp-worker-3@grok.local>
2026-10-02 15:16:41 -05:00
coah
b33a493cec data(MyTiManager, pf_path data 100%) (data-d16) (worker ecdb36e9) (#950) 2026-10-02 15:11:07 -05:00
coah
6f49df32b3 link(iplChannelObj native) (link3) (worker 76a29df1) (#948) 2026-10-02 15:02:31 -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
468 changed files with 84929 additions and 12417 deletions

View File

@@ -2,8 +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.
# it never commits to main: it rebuilds, publishes the numbers to the job summary, and force-pushes
# the README badge JSON as a single commit on the orphan progress-data branch.
on:
push:
branches: [main]
@@ -17,7 +17,7 @@ concurrency:
cancel-in-progress: true
permissions:
contents: read
contents: write
jobs:
progress:
@@ -55,3 +55,17 @@ jobs:
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
- name: Publish badges
if: github.ref == 'refs/heads/main'
run: |
out="$RUNNER_TEMP/progress-data"
rm -rf "$out"
python3 tools/progress_badges.py build/43U/report.json "$out"
cd "$out"
git init -q -b progress-data
git config user.name "github-actions[bot]"
git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
git add .
git commit -q -m "progress for $GITHUB_SHA"
git push -q -f "https://x-access-token:${{ github.token }}@github.com/$GITHUB_REPOSITORY.git" HEAD:refs/heads/progress-data

View File

@@ -7,23 +7,23 @@
<!--- Github Actions Badge -->
[Build Status]: https://github.com/coah80/wii-ipl/actions/workflows/build.yml/badge.svg
[actions]: https://github.com/coah80/wii-ipl/actions/workflows/build.yml
[Build Status]: https://github.com/coah80/wii-ipl/actions/workflows/readme-progress.yml/badge.svg?branch=main
[actions]: https://github.com/coah80/wii-ipl/actions/workflows/readme-progress.yml
<!--- Discord Badge -->
[Discord Badge]: https://img.shields.io/discord/727908905392275526?color=%237289DA&logo=discord&logoColor=%23FFFFFF
[discord]: https://discord.gg/hKx3FJJgrV
<!-- Progress links -->
<!-- Progress badges: JSON on the progress-data branch, refreshed by the README progress workflow on every push to main -->
[V43U]: https://decomp.dev/koopthekoopa/wii-ipl/43U
<!--- Version 4.3U progress Badge -->
[DecompBadgeV43U]: https://decomp.dev/koopthekoopa/wii-ipl/43U.svg?&measure=code&label=Decompiled&mode=shield&labelColor=%237c7c7c&color=%2333b8ff&style=plastic
[LinkBadgeV43U]: https://decomp.dev/koopthekoopa/wii-ipl/43U.svg?&measure=complete_code&label=Linked&mode=shield&labelColor=%237c7c7c&color=%2333b8ff&style=plastic
[FuncBadgeV43U]: https://decomp.dev/koopthekoopa/wii-ipl/43U.svg?&measure=functions&label=Functions&mode=shield&labelColor=%237c7c7c&color=%2333b8ff&style=plastic
[progress]: https://github.com/coah80/wii-ipl/actions/workflows/readme-progress.yml
[DecompiledBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Fdecompiled.json
[MatchedBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Fmatched.json
[LinkedBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Flinked.json
[DataBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Fdata.json
[FunctionsBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Ffunctions.json
[UnitsBadge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2Fcoah80%2Fwii-ipl%2Fprogress-data%2Funits.json
<!--- Header -->
@@ -43,28 +43,17 @@ Live decomp status
[![Build status]][actions]
Open the latest successful [Build workflow run][actions] and check its summary for the current objdiff metrics. It includes perfect-match/decompiled, fuzzy-match, fully linked, data, function, unit, and category breakdowns. The run also publishes the 43U report artifact and generated decomp-status report.
Every push to `main` rebuilds 4.3U, checks the DOL hash, and refreshes the progress badges below. Open the latest [README progress run][actions] for the full objdiff summary.
Supported versions:
- `43U` - Version **4.3U** (USA)
Progress
========
<!-- progress:start -->
| Decompiled | Matched | Linked | Data |
|:---:|:---:|:---:|:---:|
| 99.59% | 90.81% | 71.43% | 99.37% |
units 956/1027 complete, functions 12365/12563 matched.
[![DecompiledBadge]][progress] [![MatchedBadge]][progress] [![LinkedBadge]][progress] [![DataBadge]][progress]
[![FunctionsBadge]][progress] [![UnitsBadge]][progress]
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 -->
| Version | Progress |
|-----------------------|------------------------------------------------------------------------------|
| [Wii Menu 4.3U][V43U] | [![FuncBadgeV43U]][V43U] [![DecompBadgeV43U]][V43U] [![LinkBadgeV43U]][V43U] |
> You can see the full progress and its history by clicking on one of the versions in the table.
Dependencies
============

View File

@@ -37,6 +37,9 @@ force_active:
# textinput::toolbar::csPaneToAnimation points one past the end of csAninationFile.
block_relocations:
# Run establishes a fixed stack at 0x81600000, not __pformatter + 0x280.
- source: .text:0x8137B468
- source: .text:0x8137B46C
- source: .data:0x8165E15C
- source: .data:0x8165E19C

View File

@@ -95,11 +95,15 @@ AOSS_810BDF18 = .bss:0x810BDF18; // type:object size:0x6A0
AOSS_810BE5B8 = .bss:0x810BE5B8; // type:object size:0x280
AOSS_810BE838 = .bss:0x810BE838; // type:object size:0x68
AOSS_810BE8A0 = .bss:0x810BE8A0; // type:object size:0x400
ATERM_810BECA0 = .bss:0x810BECA0; // type:object size:0x924 data:4byte
gAtermIpConfig = .bss:0x810BECA0; // type:object size:0x7C4 data:4byte
gAtermIfConfig = .bss:0x810BF464; // type:object size:0x15E
ATERM_810BF5C4 = .bss:0x810BF5C4; // type:object size:0x24
ATERM_810BF5E8 = .bss:0x810BF5E8; // type:object size:0x258
ATERM_810BF840 = .bss:0x810BF840; // type:object size:0x900
ATERM_810C0140 = .bss:0x810C0140; // type:object size:0x818 data:2byte
gAtermConfigurationResult = .bss:0x810BF840; // type:object size:0xE8
gAtermAssociationRequest = .bss:0x810BF928; // type:object size:0x10
gAtermPacketBuffer = .bss:0x810BF938; // type:object size:0x800
gAtermDecodedResponse = .bss:0x810C0138; // type:object size:0x800 data:2byte
gAtermSession = .bss:0x810C0938; // type:object size:0x20
AtermThread = .bss:0x810C0958; // type:object size:0x318 scope:local align:32
Voices = .bss:0x810C0C80; // type:object size:0x1800 data:4byte
sZeroMem = .bss:0x810C2480; // type:object size:0x100 data:byte
@@ -114,7 +118,9 @@ ziStringColorRightDestructorRecord = .bss:0x810C65CC; // type:object size:0xC da
underlateColorDestructorRecord = .bss:0x810C65D8; // type:object size:0xC data:4byte
unInputedWCharColorSpaceDestructorRecord = .bss:0x810C65E4; // type:object size:0xC data:4byte
ElementBuffer__Q39textinput8tistring6WithZi = .bss:0x810C65F0; // type:object size:0x200 data:2byte
CandidatesBuffer__Q39textinput8tistring6WithZi = .bss:0x810C67F0; // type:object size:0x600 data:2byte
CandidatesBuffer__Q39textinput8tistring6WithZi = .bss:0x810C67F0; // type:object size:0x200 data:2byte
ElementWorkBuffer__Q39textinput8tistring6WithZi = .bss:0x810C69F0; // type:object size:0x200 data:2byte
PredictionBuffer__Q39textinput8tistring6WithZi = .bss:0x810C6BF0; // type:object size:0x200 data:2byte
CandidatedWord__Q39textinput8tistring6WithZi = .bss:0x810C6DF0; // type:object size:0x1400 data:2byte
LatestWord__Q39textinput8tistring6WithZi = .bss:0x810C81F0; // type:object size:0x80 data:2byte
snWidthTable__Q29textinput10textdrawer = .bss:0x810C8270; // type:object size:0x580 data:4byte
@@ -13904,10 +13910,15 @@ lbl_81610608 = .rodata:0x81610608; // type:object size:0x300
lbl_81610908 = .rodata:0x81610908; // type:object size:0x10
sCaptureSizes__Q23ipl5scene = .rodata:0x81610918; // type:object size:0x10
lbl_81610928 = .rodata:0x81610928; // type:object size:0x20 data:4byte
scAnmTable__Q23ipl5scene = .rodata:0x81610948; // type:object size:0x1A8 scope:local
lbl_81610AF0 = .rodata:0x81610AF0; // type:object size:0x30 data:4byte
lbl_81610B20 = .rodata:0x81610B20; // type:object size:0x60 data:4byte
lbl_81610B80 = .rodata:0x81610B80; // type:object size:0x20 data:wstring
scAnmTable__Q23ipl5scene = .rodata:0x81610948; // type:object size:0xE8 scope:local
@17203 = .rodata:0x81610A30; // type:object size:0x1C scope:local
@17212 = .rodata:0x81610A4C; // type:object size:0x30 scope:local
@17223 = .rodata:0x81610A7C; // type:object size:0x28 scope:local
@17227 = .rodata:0x81610AA4; // type:object size:0x30 scope:local
@17254 = .rodata:0x81610AD4; // type:object size:0x1C scope:local
@18816 = .rodata:0x81610AF0; // type:object size:0x30 scope:local data:4byte
@18818 = .rodata:0x81610B20; // type:object size:0x60 scope:local data:4byte
@19272 = .rodata:0x81610B80; // type:object size:0x20 scope:local data:wstring
scNumber__Q23ipl5scene = .rodata:0x81610BA0; // type:object size:0x14 scope:local data:2byte
scNumber2__Q23ipl5scene = .rodata:0x81610BB4; // type:object size:0x14 scope:local data:2byte
lbl_81610BC8 = .rodata:0x81610BC8; // type:object size:0x1000
@@ -16011,8 +16022,8 @@ mscBasePaneNames__Q33ipl5scene13ChannelSelect = .data:0x8164DC18; // type:object
@17309 = .data:0x8164DC42; // type:object size:0xB scope:local data:string
@17310 = .data:0x8164DC4D; // type:object size:0xB scope:local data:string
@17311 = .data:0x8164DC58; // type:object size:0xB scope:local data:string
mscUnk0PaneNames__Q33ipl5scene13ChannelSelect = .data:0x8164DC64; // type:object size:0x14 data:4byte
mscUnk1PaneNames__Q33ipl5scene13ChannelSelect = .data:0x8164DC78; // type:object size:0x14 data:4byte
mscPicturePaneNames__Q33ipl5scene13ChannelSelect = .data:0x8164DC64; // type:object size:0x14 data:4byte
mscEdgePaneNames__Q33ipl5scene13ChannelSelect = .data:0x8164DC78; // type:object size:0x14 data:4byte
@17317 = .data:0x8164DC8C; // type:object size:0x9 scope:local data:string
@17318 = .data:0x8164DC95; // type:object size:0x9 scope:local data:string
@17319 = .data:0x8164DC9E; // type:object size:0x9 scope:local data:string
@@ -16038,7 +16049,7 @@ mscClockPaneNames__Q33ipl5scene13ChannelSelect = .data:0x8164DCA8; // type:objec
@23740 = .data:0x8164DE49; // type:object size:0x1B scope:local data:string
scPaneName_N_GCIcon = .data:0x8164DE64; // type:object size:0x9 data:string
scPaneName_N_DiscUpdateIcon = .data:0x8164DE6D; // type:object size:0x11 data:string
updateDiskState_jumptable = .data:0x8164DE80; // type:object size:0x1C scope:local
@24295 = .data:0x8164DE80; // type:object size:0x1C scope:local
scSE_WSD_SELECT = .data:0x8164DE9C; // type:object size:0xB data:string
@24254 = .data:0x8164DEA7; // type:object size:0x10 scope:local data:string
@24282 = .data:0x8164DEB7; // type:object size:0x12 scope:local data:string
@@ -17165,7 +17176,23 @@ sSettingAPPaneNames__Q23ipl5scene = .data:0x81656978; // type:object size:0x68 d
sSettingAPAnimations__Q23ipl5scene = .data:0x81656B6C; // type:object size:0x4C data:4byte
@25442 = .data:0x81656BB8; // type:object size:0xF scope:local data:string
@25443 = .data:0x81656BC7; // type:object size:0x1C scope:local data:string
@25501 = .data:0x81656BE3; // type:object size:0xF scope:local data:string
@25502 = .data:0x81656BF2; // type:object size:0x14 scope:local data:string
@25503 = .data:0x81656C06; // type:object size:0x18 scope:local data:string
@25505 = .data:0x81656C1E; // type:object size:0x1A scope:local data:string
@25506 = .data:0x81656C38; // type:object size:0x13 scope:local data:string
@25508 = .data:0x81656C4B; // type:object size:0x9 scope:local data:string
@25509 = .data:0x81656C54; // type:object size:0x12 scope:local data:string
@25510 = .data:0x81656C66; // type:object size:0xC scope:local data:string
@25616 = .data:0x81656C72; // type:object size:0xD scope:local data:string
@25618 = .data:0x81656C7F; // type:object size:0xF scope:local data:string
@25620 = .data:0x81656C8E; // type:object size:0x14 scope:local data:string
@25621 = .data:0x81656CA2; // type:object size:0x1A scope:local data:string
@25622 = .data:0x81656CBC; // type:object size:0x19 scope:local data:string
@25623 = .data:0x81656CD5; // type:object size:0xE scope:local data:string
@25624 = .data:0x81656CE3; // type:object size:0x13 scope:local data:string
@25625 = .data:0x81656CF6; // type:object size:0x18 scope:local data:string
@25628 = .data:0x81656D0E; // type:object size:0x19 scope:local data:string
@17193 = .data:0x81656D27; // type:object size:0xC scope:local data:string
@17194 = .data:0x81656D33; // type:object size:0x20 scope:local data:string
@17197 = .data:0x81656D53; // type:object size:0xD scope:local data:string
@@ -17179,10 +17206,32 @@ sSettingAPAnimations__Q23ipl5scene = .data:0x81656B6C; // type:object size:0x4C
@17250 = .data:0x81656DFA; // type:object size:0x11 scope:local data:string
@17251 = .data:0x81656E0B; // type:object size:0x9 scope:local data:string
@17252 = .data:0x81656E14; // type:object size:0xD scope:local data:string
@25720 = .data:0x81656E21; // type:object size:0x23 scope:local data:string
@25721 = .data:0x81656E44; // type:object size:0xD scope:local data:string
@25722 = .data:0x81656E51; // type:object size:0xD scope:local data:string
@25723 = .data:0x81656E5E; // type:object size:0xD scope:local data:string
@25724 = .data:0x81656E6B; // type:object size:0x25 scope:local data:string
@25726 = .data:0x81656E90; // type:object size:0x15 scope:local data:string
@25747 = .data:0x81656EA5; // type:object size:0x1B scope:local data:string
@25766 = .data:0x81656EC0; // type:object size:0x1D scope:local data:string
@25767 = .data:0x81656EDD; // type:object size:0x11 scope:local data:string
@25768 = .data:0x81656EEE; // type:object size:0x1D scope:local data:string
@26292 = .data:0x81656F0B; // type:object size:0xF scope:local data:string
@26293 = .data:0x81656F1A; // type:object size:0xD scope:local data:string
@26294 = .data:0x81656F27; // type:object size:0x11 scope:local data:string
@26295 = .data:0x81656F38; // type:object size:0x11 scope:local data:string
@26296 = .data:0x81656F49; // type:object size:0xA scope:local data:string
@26297 = .data:0x81656F53; // type:object size:0xD scope:local data:string
@26300 = .data:0x81656F60; // type:object size:0x1A0 scope:local
@26299 = .data:0x81657100; // type:object size:0x48 scope:local
@26346 = .data:0x81657148; // type:object size:0x26 scope:local data:string
@26347 = .data:0x8165716E; // type:object size:0xF scope:local data:string
@26348 = .data:0x8165717D; // type:object size:0xE scope:local data:string
@26349 = .data:0x8165718B; // type:object size:0xA scope:local data:string
@26350 = .data:0x81657195; // type:object size:0xB scope:local data:string
@26351 = .data:0x816571A0; // type:object size:0x16 scope:local data:string
@26353 = .data:0x816571B6; // type:object size:0x11 scope:local data:string
@26354 = .data:0x816571C7; // type:object size:0x16 scope:local data:string
@26502 = .data:0x816571DD; // type:object size:0xF scope:local data:string
@26534 = .data:0x816571EC; // type:object size:0x18 scope:local data:string
@26536 = .data:0x81657204; // type:object size:0x44 scope:local
@@ -17216,6 +17265,11 @@ sSettingAPAnimations__Q23ipl5scene = .data:0x81656B6C; // type:object size:0x4C
@28326 = .data:0x81657642; // type:object size:0x2A scope:local data:string
@28370 = .data:0x8165766C; // type:object size:0x10 scope:local data:string
@28383 = .data:0x8165767C; // type:object size:0x14 scope:local data:string
@28436 = .data:0x81657690; // type:object size:0x16 scope:local data:string
@28437 = .data:0x816576A6; // type:object size:0xF scope:local data:string
@28438 = .data:0x816576B5; // type:object size:0x13 scope:local data:string
@28439 = .data:0x816576C8; // type:object size:0x1A scope:local data:string
@28440 = .data:0x816576E2; // type:object size:0x1B scope:local data:string
@28442 = .data:0x81657700; // type:object size:0x84 scope:local
__vt__Q33ipl5scene7APEvent = .data:0x81657784; // type:object size:0x18
__vt__Q33ipl5scene7Setting = .data:0x8165779C; // type:object size:0x68
@@ -18058,7 +18112,7 @@ __vt__Q49textinput6extend4memo15AppearMemoState = .data:0x81667FA0; // type:obje
__vt__Q49textinput6extend4memo13DispMemoState = .data:0x81667FF8; // type:object size:0x58
__vt__Q49textinput6extend4memo5State = .data:0x81668050; // type:object size:0x58
__vt__Q49textinput6extend4memo7Manager = .data:0x816680A8; // type:object size:0x140
lbl_816681E8 = .data:0x816681E8; // type:object size:0x28
lbl_816681E8 = .data:0x816681E8; // type:object size:0x24
lbl_81668210 = .data:0x81668210; // type:object size:0x9 data:string
lbl_8166821C = .data:0x8166821C; // type:object size:0x9 data:string
lbl_81668228 = .data:0x81668228; // type:object size:0x9 data:string
@@ -22373,93 +22427,93 @@ lbl_81696FD0 = .sdata:0x81696FD0; // type:object size:0x6 data:wstring
lbl_81696FD6 = .sdata:0x81696FD6; // type:object size:0x4 data:wstring
lbl_81696FDA = .sdata:0x81696FDA; // type:object size:0x7 data:string
lbl_81696FE1 = .sdata:0x81696FE1; // type:object size:0x7 data:string
lbl_81696FE8 = .sdata:0x81696FE8; // type:object size:0x6 data:string
lbl_81696FEE = .sdata:0x81696FEE; // type:object size:0x6 data:string
lbl_81696FF4 = .sdata:0x81696FF4; // type:object size:0x6 data:string
lbl_81696FFA = .sdata:0x81696FFA; // type:object size:0x6 data:string
lbl_81697000 = .sdata:0x81697000; // type:object size:0x7 data:string
lbl_81697007 = .sdata:0x81697007; // type:object size:0x7 data:string
lbl_81697010 = .sdata:0x81697010; // type:object size:0x8 data:4byte
lbl_81697018 = .sdata:0x81697018; // type:object size:0x8 data:string
lbl_81697020 = .sdata:0x81697020; // type:object size:0x8 data:string
lbl_81697028 = .sdata:0x81697028; // type:object size:0x8 data:string
lbl_81697030 = .sdata:0x81697030; // type:object size:0x8 data:string
lbl_81697038 = .sdata:0x81697038; // type:object size:0x8 data:string
lbl_81697040 = .sdata:0x81697040; // type:object size:0x8 data:string
lbl_81697048 = .sdata:0x81697048; // type:object size:0x6 data:string
lbl_8169704E = .sdata:0x8169704E; // type:object size:0x6 data:string
lbl_81697054 = .sdata:0x81697054; // type:object size:0x6 data:string
lbl_8169705A = .sdata:0x8169705A; // type:object size:0x6 data:string
lbl_81697060 = .sdata:0x81697060; // type:object size:0x6 data:string
lbl_81697066 = .sdata:0x81697066; // type:object size:0x6 data:string
lbl_8169706C = .sdata:0x8169706C; // type:object size:0x7 data:string
lbl_81697073 = .sdata:0x81697073; // type:object size:0x7 data:string
lbl_8169707A = .sdata:0x8169707A; // type:object size:0x8 data:string
lbl_81697082 = .sdata:0x81697082; // type:object size:0x7 data:string
lbl_81697089 = .sdata:0x81697089; // type:object size:0x6 data:string
lbl_8169708F = .sdata:0x8169708F; // type:object size:0x6 data:string
lbl_81697095 = .sdata:0x81697095; // type:object size:0x6 data:string
lbl_8169709B = .sdata:0x8169709B; // type:object size:0x6 data:string
lbl_816970A1 = .sdata:0x816970A1; // type:object size:0x6 data:string
lbl_816970A7 = .sdata:0x816970A7; // type:object size:0x6 data:string
lbl_816970AD = .sdata:0x816970AD; // type:object size:0x6 data:string
lbl_816970B3 = .sdata:0x816970B3; // type:object size:0x6 data:string
lbl_816970B9 = .sdata:0x816970B9; // type:object size:0x8 data:string
lbl_816970C1 = .sdata:0x816970C1; // type:object size:0x8 data:string
lbl_816970C9 = .sdata:0x816970C9; // type:object size:0x8 data:string
lbl_816970D1 = .sdata:0x816970D1; // type:object size:0x8 data:string
lbl_816970D9 = .sdata:0x816970D9; // type:object size:0x8 data:string
lbl_816970E1 = .sdata:0x816970E1; // type:object size:0x8 data:string
lbl_816970E9 = .sdata:0x816970E9; // type:object size:0x4 data:string
lbl_816970ED = .sdata:0x816970ED; // type:object size:0x4 data:string
lbl_816970F1 = .sdata:0x816970F1; // type:object size:0x5 data:string
lbl_816970F6 = .sdata:0x816970F6; // type:object size:0x4 data:string
lbl_816970FA = .sdata:0x816970FA; // type:object size:0x7 data:string
lbl_81697101 = .sdata:0x81697101; // type:object size:0x7 data:string
lbl_81697108 = .sdata:0x81697108; // type:object size:0x3 data:string
lbl_8169710B = .sdata:0x8169710B; // type:object size:0x6 data:string
lbl_81697111 = .sdata:0x81697111; // type:object size:0x7 data:string
lbl_81697118 = .sdata:0x81697118; // type:object size:0x6 data:string
lbl_8169711E = .sdata:0x8169711E; // type:object size:0x1
lbl_8169711F = .sdata:0x8169711F; // type:object size:0x6 data:string
lbl_81697125 = .sdata:0x81697125; // type:object size:0x6 data:string
lbl_8169712B = .sdata:0x8169712B; // type:object size:0x6 data:string
lbl_81697131 = .sdata:0x81697131; // type:object size:0x4 data:string
lbl_81697135 = .sdata:0x81697135; // type:object size:0x4 data:string
lbl_81697139 = .sdata:0x81697139; // type:object size:0x4 data:string
lbl_8169713D = .sdata:0x8169713D; // type:object size:0x4 data:string
lbl_81697141 = .sdata:0x81697141; // type:object size:0x4 data:string
lbl_81697145 = .sdata:0x81697145; // type:object size:0x4 data:string
lbl_81697149 = .sdata:0x81697149; // type:object size:0x4 data:string
lbl_8169714D = .sdata:0x8169714D; // type:object size:0x4 data:string
lbl_81697151 = .sdata:0x81697151; // type:object size:0x4 data:string
lbl_81697155 = .sdata:0x81697155; // type:object size:0x8 data:string
lbl_8169715D = .sdata:0x8169715D; // type:object size:0x6 data:string
lbl_81697163 = .sdata:0x81697163; // type:object size:0x7 data:string
lbl_8169716A = .sdata:0x8169716A; // type:object size:0x4 data:string
lbl_8169716E = .sdata:0x8169716E; // type:object size:0x5 data:string
lbl_81697173 = .sdata:0x81697173; // type:object size:0x7 data:string
lbl_8169717A = .sdata:0x8169717A; // type:object size:0x5 data:string
lbl_8169717F = .sdata:0x8169717F; // type:object size:0x5 data:string
lbl_81697184 = .sdata:0x81697184; // type:object size:0x5 data:string
lbl_8169718A = .sdata:0x8169718A; // type:object size:0x2
lbl_8169718C = .sdata:0x8169718C; // type:object size:0x3 data:string
lbl_8169718F = .sdata:0x8169718F; // type:object size:0x2 data:string
lbl_81697191 = .sdata:0x81697191; // type:object size:0x2 data:string
lbl_81697193 = .sdata:0x81697193; // type:object size:0x2 data:string
lbl_81697195 = .sdata:0x81697195; // type:object size:0x2 data:string
lbl_81697197 = .sdata:0x81697197; // type:object size:0x2 data:string
lbl_81697199 = .sdata:0x81697199; // type:object size:0x6 data:string
lbl_8169719F = .sdata:0x8169719F; // type:object size:0x6 data:string
lbl_816971A5 = .sdata:0x816971A5; // type:object size:0x6 data:string
lbl_816971AB = .sdata:0x816971AB; // type:object size:0x6 data:string
lbl_816971B1 = .sdata:0x816971B1; // type:object size:0x6 data:string
lbl_816971B7 = .sdata:0x816971B7; // type:object size:0x6 data:string
lbl_816971BD = .sdata:0x816971BD; // type:object size:0x6 data:string
lbl_816971C3 = .sdata:0x816971C3; // type:object size:0x6 data:string
lbl_816971C9 = .sdata:0x816971C9; // type:object size:0x7 data:string
lbl_816971D0 = .sdata:0x816971D0; // type:object size:0x3 data:string
lbl_816971D4 = .sdata:0x816971D4; // type:object size:0x8 data:wstring
@16789 = .sdata:0x81696FE8; // type:object size:0x6 data:string
@16790 = .sdata:0x81696FEE; // type:object size:0x6 data:string
@16791 = .sdata:0x81696FF4; // type:object size:0x6 data:string
@16792 = .sdata:0x81696FFA; // type:object size:0x6 data:string
@16793 = .sdata:0x81697000; // type:object size:0x7 data:string
@16794 = .sdata:0x81697007; // type:object size:0x7 data:string
sSettingArrowNames__Q23ipl5scene = .sdata:0x81697010; // type:object size:0x8 data:4byte
@16795 = .sdata:0x81697018; // type:object size:0x8 data:string
@16796 = .sdata:0x81697020; // type:object size:0x8 data:string
@16797 = .sdata:0x81697028; // type:object size:0x8 data:string
@16798 = .sdata:0x81697030; // type:object size:0x8 data:string
@16799 = .sdata:0x81697038; // type:object size:0x8 data:string
@16800 = .sdata:0x81697040; // type:object size:0x8 data:string
@16801 = .sdata:0x81697048; // type:object size:0x6 data:string
@16802 = .sdata:0x8169704E; // type:object size:0x6 data:string
@16803 = .sdata:0x81697054; // type:object size:0x6 data:string
@16804 = .sdata:0x8169705A; // type:object size:0x6 data:string
@16805 = .sdata:0x81697060; // type:object size:0x6 data:string
@16806 = .sdata:0x81697066; // type:object size:0x6 data:string
@16809 = .sdata:0x8169706C; // type:object size:0x7 data:string
@16810 = .sdata:0x81697073; // type:object size:0x7 data:string
@16811 = .sdata:0x8169707A; // type:object size:0x8 data:string
@16812 = .sdata:0x81697082; // type:object size:0x7 data:string
@16813 = .sdata:0x81697089; // type:object size:0x6 data:string
@16814 = .sdata:0x8169708F; // type:object size:0x6 data:string
@16815 = .sdata:0x81697095; // type:object size:0x6 data:string
@16816 = .sdata:0x8169709B; // type:object size:0x6 data:string
@16817 = .sdata:0x816970A1; // type:object size:0x6 data:string
@16818 = .sdata:0x816970A7; // type:object size:0x6 data:string
@16819 = .sdata:0x816970AD; // type:object size:0x6 data:string
@16820 = .sdata:0x816970B3; // type:object size:0x6 data:string
@16827 = .sdata:0x816970B9; // type:object size:0x8 data:string
@16828 = .sdata:0x816970C1; // type:object size:0x8 data:string
@16829 = .sdata:0x816970C9; // type:object size:0x8 data:string
@16830 = .sdata:0x816970D1; // type:object size:0x8 data:string
@16831 = .sdata:0x816970D9; // type:object size:0x8 data:string
@16832 = .sdata:0x816970E1; // type:object size:0x8 data:string
@25504 = .sdata:0x816970E9; // type:object size:0x4 data:string
@25507 = .sdata:0x816970ED; // type:object size:0x4 data:string
@25617 = .sdata:0x816970F1; // type:object size:0x5 data:string
@25619 = .sdata:0x816970F6; // type:object size:0x4 data:string
@25626 = .sdata:0x816970FA; // type:object size:0x7 data:string
@25627 = .sdata:0x81697101; // type:object size:0x7 data:string
@17202 = .sdata:0x81697108; // type:object size:0x3 data:string
@17205 = .sdata:0x8169710B; // type:object size:0x6 data:string
@17206 = .sdata:0x81697111; // type:object size:0x7 data:string
@17207 = .sdata:0x81697118; // type:object size:0x6 data:string
@17208 = .sdata:0x8169711E; // type:object size:0x1
@17209 = .sdata:0x8169711F; // type:object size:0x6 data:string
@17210 = .sdata:0x81697125; // type:object size:0x6 data:string
@17211 = .sdata:0x8169712B; // type:object size:0x6 data:string
@17214 = .sdata:0x81697131; // type:object size:0x4 data:string
@17215 = .sdata:0x81697135; // type:object size:0x4 data:string
@17216 = .sdata:0x81697139; // type:object size:0x4 data:string
@17217 = .sdata:0x8169713D; // type:object size:0x4 data:string
@17218 = .sdata:0x81697141; // type:object size:0x4 data:string
@17219 = .sdata:0x81697145; // type:object size:0x4 data:string
@17220 = .sdata:0x81697149; // type:object size:0x4 data:string
@17221 = .sdata:0x8169714D; // type:object size:0x4 data:string
@17222 = .sdata:0x81697151; // type:object size:0x4 data:string
@17248 = .sdata:0x81697155; // type:object size:0x8 data:string
@17249 = .sdata:0x8169715D; // type:object size:0x6 data:string
@17253 = .sdata:0x81697163; // type:object size:0x7 data:string
@25725 = .sdata:0x8169716A; // type:object size:0x4 data:string
@26352 = .sdata:0x8169716E; // type:object size:0x5 data:string
@26503 = .sdata:0x81697173; // type:object size:0x7 data:string
@26504 = .sdata:0x8169717A; // type:object size:0x5 data:string
@26505 = .sdata:0x8169717F; // type:object size:0x5 data:string
@26506 = .sdata:0x81697184; // type:object size:0x5 data:string
@26625 = .sdata:0x8169718A; // type:object size:0x2
@26851 = .sdata:0x8169718C; // type:object size:0x3 data:string
@18811 = .sdata:0x8169718F; // type:object size:0x2 data:string
@18812 = .sdata:0x81697191; // type:object size:0x2 data:string
@18813 = .sdata:0x81697193; // type:object size:0x2 data:string
@18814 = .sdata:0x81697195; // type:object size:0x2 data:string
@18815 = .sdata:0x81697197; // type:object size:0x2 data:string
@27404 = .sdata:0x81697199; // type:object size:0x6 data:string
@27405 = .sdata:0x8169719F; // type:object size:0x6 data:string
@27406 = .sdata:0x816971A5; // type:object size:0x6 data:string
@27407 = .sdata:0x816971AB; // type:object size:0x6 data:string
@27556 = .sdata:0x816971B1; // type:object size:0x6 data:string
@27557 = .sdata:0x816971B7; // type:object size:0x6 data:string
@27558 = .sdata:0x816971BD; // type:object size:0x6 data:string
@27559 = .sdata:0x816971C3; // type:object size:0x6 data:string
@27560 = .sdata:0x816971C9; // type:object size:0x7 data:string
@27862 = .sdata:0x816971D0; // type:object size:0x3 data:string
@28152 = .sdata:0x816971D4; // type:object size:0x8 data:wstring
@12299 = .sdata:0x816971E0; // type:object size:0x5 scope:local data:string
@12302 = .sdata:0x816971E5; // type:object size:0x5 scope:local data:string
lbl_816971F0 = .sdata:0x816971F0; // type:object size:0x4 data:string
@@ -23227,7 +23281,7 @@ lbl_81698388 = .sdata:0x81698388; // type:object size:0x2 data:string
lbl_8169838C = .sdata:0x8169838C; // type:object size:0x4 data:string
lbl_81698390 = .sdata:0x81698390; // type:object size:0x1 data:byte
lbl_81698391 = .sdata:0x81698391; // type:object size:0x1 data:byte
lbl_81698394 = .sdata:0x81698394; // type:object size:0x2 data:string
lbl_81698394 = .sdata:0x81698394; // type:object size:0x4 data:string
lbl_81698398 = .sdata:0x81698398; // type:object size:0x2 data:string
lbl_8169839C = .sdata:0x8169839C; // type:object size:0x4
drvInitFunc = .sdata:0x816983A0; // type:object size:0x8 scope:local data:4byte

View File

@@ -648,7 +648,7 @@ config.libs = [
Object(Matching, "system/iplDialogWindow.cpp"),
Object(Matching, "system/iplHomeButtonMenu.cpp"),
Object(Matching, "system/iplNandSDWorker.cpp"),
Object(Equivalent, "system/iplKeyboard.cpp"),
Object(Matching, "system/iplKeyboard.cpp"),
Object(Matching, "system/iplErrorHandler.cpp"),
Object(Matching, "system/iplResetHandler.cpp"),
Object(Matching, "system/iplWarningHandler.cpp"),
@@ -727,7 +727,7 @@ config.libs = [
]
),
IPLSection("address", [
Object(NonMatching, "scene/address/iplAddress.cpp"),
Object(Matching, "scene/address/iplAddress.cpp"),
Object(Matching, "scene/address/iplAddressAddSel.cpp"),
Object(NonMatching, "scene/address/iplAddressEdit.cpp"),
]
@@ -766,9 +766,9 @@ 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"),
Object(Matching, "scene/channelSelect/iplChannelObj.cpp"),
]
),
IPLSection("channelTitle", [
@@ -879,7 +879,7 @@ config.libs = [
Object(NonMatching, "scene/setting/AOSSLink.c"),
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"]),
Object(NonMatching, "scene/setting/ATERM.c", extra_cflags=["-O4,p", "-inline on"]),
]
),
IPLSection("settingSelect", [
@@ -908,13 +908,13 @@ config.libs = [
),
# it decides to do fast optimization for this one
IPLSection("keyboard", [
Object(NonMatching, "keyboard/tiPcKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiCellPhone.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiPcKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiCellPhone.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiInputForm.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiCandidateBox.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiToolBar.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiPredictLang.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiSignWindow.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiSignWindow.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiString.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiAtokString.cpp", extra_cflags=["-O4,p"]), # for 4.3J
Object(NonMatching, "keyboard/tiZiString.cpp", extra_cflags=["-O4,p"]), # for 4.3U and 4.3E
@@ -982,7 +982,7 @@ config.libs = [
),
ZI8Lib("zi8clib", [
Object(Matching, "clib/zaddress.c"),
Object(NonMatching, "clib/zconvert.c"),
Object(Matching, "clib/zconvert.c"),
Object(NonMatching, "clib/zi81key.c"),
Object(NonMatching, "clib/zi8alpha.c"),
Object(Matching, "clib/zi8alts.c"),
@@ -997,7 +997,7 @@ config.libs = [
Object(Matching, "clib/zi8is.c"),
Object(NonMatching, "clib/zi8match.c"),
Object(Matching, "clib/zi8misc.c"),
Object(NonMatching, "clib/zi8pud2.c"),
Object(Matching, "clib/zi8pud2.c"),
Object(Matching, "clib/Zi8punct.c"),
Object(Matching, "clib/zi8space.c"),
Object(NonMatching, "clib/zi8uwd.c"),
@@ -1022,7 +1022,7 @@ config.libs = [
Object(Matching, "cdb/CDBFileSystem.c"),
Object(Matching, "cdb/CDBFileSystemVF.c"),
Object(Matching, "cdb/CDBFileSystemSD.c"),
Object(NonMatching, "cdb/CDBRecord.c"),
Object(Matching, "cdb/CDBRecord.c"),
Object(Matching, "cdb/CDBRecordFile.c"),
Object(Matching, "cdb/CDBRecordKey.c"),
Object(Matching, "cdb/CDBIntArray.c"),
@@ -1043,7 +1043,7 @@ config.libs = [
RevoEXLib("net", [
Object(Matching, "net/nettime.c"),
Object(Matching, "net/crc.c"),
Object(NonMatching, "net/md5.c"),
Object(Matching, "net/md5.c"),
Object(Matching, "net/sha1.c"),
Object(Matching, "net/hmac.c"),
Object(Matching, "net/neterrorcode.c"),
@@ -1081,15 +1081,15 @@ config.libs = [
Object(Matching, "nwc24/NWC24Parser.c"),
Object(Matching, "nwc24/NWC24MsgCommit.c"),
Object(Matching, "nwc24/NWC24MsgRead.c"),
Object(NonMatching, "nwc24/NWC24MsgSubject.c"),
Object(Matching, "nwc24/NWC24MsgSubject.c"),
Object(Matching, "nwc24/NWC24Schedule.c"),
Object(NonMatching, "nwc24/NWC24DateParser.c"),
Object(Matching, "nwc24/NWC24DateParser.c"),
Object(Matching, "nwc24/NWC24FriendList.c"),
Object(Matching, "nwc24/NWC24SecretFList.c"),
Object(Matching, "nwc24/NWC24UserId.c"),
Object(Matching, "nwc24/NWC24Time.c"),
Object(Matching, "nwc24/NWC24Ipc.c"),
Object(Equivalent, "nwc24/NWC24Download.c"),
Object(Matching, "nwc24/NWC24Download.c"),
Object(Matching, "nwc24/NWC24CHJump.c"),
Object(Matching, "nwc24/NWC24System.c"),
]
@@ -1218,7 +1218,7 @@ config.libs = [
Object(NonMatching, "texturecvtr/Texture_MCUtoRGB565.c"),
Object(NonMatching, "texturecvtr/Texture_MCUtoRGBA8.c"),
Object(NonMatching, "b65/iqdec_b65_frv32.c"),
Object(Matching, "b65/iqdec_b65_frv32.c"),
]
),
# NW4R
@@ -1299,7 +1299,7 @@ config.libs = [
Object(Matching, "ut/ut_RomFont.cpp"),
Object(Matching, "ut/ut_ResFontBase.cpp"),
Object(Matching, "ut/ut_ResFont.cpp"),
Object(NonMatching, "ut/ut_ArchiveFontBase.cpp"),
Object(Matching, "ut/ut_ArchiveFontBase.cpp"),
Object(Matching, "ut/ut_ArchiveFont.cpp"),
Object(Matching, "ut/ut_CharWriter.cpp"),
Object(Matching, "ut/ut_TextWriterBase.cpp"),
@@ -1388,7 +1388,7 @@ config.libs = [
]
),
RVLSDKLib("vi", [
Object(NonMatching, "vi/vi.c"),
Object(Matching, "vi/vi.c"),
Object(Matching, "vi/i2c.c"),
Object(Matching, "vi/vi3in1.c"),
]
@@ -1559,7 +1559,7 @@ config.libs = [
]
),
RVLSDKLib("kpad", [
Object(NonMatching, "kpad/KPAD.c"),
Object(Matching, "kpad/KPAD.c"),
]
),
RVLSDKLib("euart", [
@@ -1691,7 +1691,7 @@ config.libs = [
Object(Matching, "fa/pdm_bpb.c"),
Object(Matching, "fa/pdm_disk.c"),
Object(NonMatching, "fa/pdm_partition.c"),
Object(NonMatching, "fa/pf_cache.c"),
Object(Matching, "fa/pf_cache.c"),
Object(Matching, "fa/pf_cluster.c"),
Object(Matching, "fa/pf_dir.c"),
Object(Matching, "fa/pf_entry.c"),
@@ -1826,7 +1826,7 @@ config.libs = [
Object(Matching, "fa/pfs_unmount.c"),
Object(Matching, "fa/pf_stub_unicode.c"),
Object(NonMatching, "fa/api/FAAttach.c"),
Object(Matching, "fa/api/FAAttach.c"),
Object(Matching, "fa/api/FABuffering.c"),
Object(Matching, "fa/api/FACreate.c"),
Object(Matching, "fa/api/FACreatedir.c"),
@@ -1908,7 +1908,7 @@ config.libs = [
[
Object(Matching, "core/eggAllocator.cpp"),
Object(Matching, "core/eggAudioArcPlayerMgr.cpp"),
Object(Equivalent, "core/eggAudioExpMgr.cpp"),
Object(Matching, "core/eggAudioExpMgr.cpp"),
Object(Matching, "core/eggAudioFxMgr.cpp"),
Object(Matching, "core/eggAudioMgr.cpp"),
Object(Matching, "core/eggAudioHeapMgr.cpp"),
@@ -1970,7 +1970,7 @@ config.libs = [
Object(Matching, "MSL_Common/time.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/wctype.c"),
Object(Matching, "MSL_Common/wmem.c"),
Object(NonMatching, "MSL_Common/wprintf.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/wprintf.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/wstring.c"),
Object(Matching, "MSL_Common/wchar_io.c"),
Object(Matching, "PPC_EABI/time.dolphin.c"),

View File

@@ -24,7 +24,7 @@ typedef struct BS2UpdateHeader {
typedef struct BS2UpdateEntry {
// Update Meta Data
u32 type; // 0x00
vu32 type; // 0x00
u32 attr; // 0x04
u32 size; // 0x08
u32 depend; // 0x0C

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

@@ -7,7 +7,7 @@ namespace ipl {
namespace memorycard {
typedef struct FileInfo {
u16 fileNo; // 0x00
u16 size; // 0x02
volatile u16 size; // 0x02
u8 canCopy; // 0x04
u8 canMove; // 0x05
u16 unk_0x06; // 0x06
@@ -28,7 +28,7 @@ namespace ipl {
} CardState; // 0x14
typedef struct IconState {
u8 bannerEnable; // 0x00
volatile u8 bannerEnable; // 0x00
u8 unk_0x01; // 0x01
u8 unk_0x02; // 0x02
u8 bannerType; // 0x03

View File

@@ -139,13 +139,13 @@ namespace www {
namespace ext_ead {
namespace www {
typedef struct ImeData {
u32 unk_0x00; // 0x00
u32 eventType; // 0x00
u32 imeID; // 0x04
char* text; // 0x08
u32 unk_0x0C; // 0x0c
u32 unk_0x10; // 0x10
u32 unk_0x14; // 0x14
u32 unk_0x18; // 0x18
u32 creationDataA; // 0x0c
u32 creationDataB; // 0x10
u32 creationDataC; // 0x14
u32 creationDataD; // 0x18
u32 maxLength; // 0x1c
ImeData& operator=(const ImeData&);
@@ -177,7 +177,7 @@ namespace ext_ead {
struct {
u32 imeID;
char* str;
u32 unk_0x0C;
u32 updateData;
} updateIme; // ID 4
u32 raw[6];
} data;
@@ -203,12 +203,12 @@ namespace ext_ead {
void CreateImeData(ImeData* data, const WWWIMEData* wwwData);
void DisposeImeData(ImeData* data);
void CommitIme(ImeData* data, const char* something);
void CommitIme(ImeData* data, const char* text);
void CommitImeCmdPacket(const CmdPacket* data);
void UpdateImeCmdPacket(const CmdPacket* data);
static void FlushCallback(WWWRect* rect, int unk);
static void FlushCallback(WWWRect* rect, int callbackData);
u32* GetRaster() { return mpRaster; }
WWWHandle* GetHandle() { return mpBrowserHandle; }
@@ -222,7 +222,7 @@ namespace ext_ead {
bool CheckThreadExit_();
void InitSurface_();
void InitFonts_(const char* unk);
void InitFonts_(const char* fontDirectory);
void SendKeyboardEvent_(u32 btnMask, u32 triggerFlag, u32 releaseFlag, WWWKeySym sym);
WWWKeySym GetKeyboardSym_(u32 input);

View File

@@ -23,7 +23,7 @@ namespace ext_ead {
void SendNotifyEvent(WWWEvent event, WWWHandleEventData* dataHandle);
void ExecuteEvent();
void UpdateTexture();
void* GetTextureBuffer(int a, bool b, WWWRect** rectPtrOut);
void* GetTextureBuffer(int pageOffset, bool forUpdate, WWWRect** rectPtrOut);
void SetWindowSize(int w, int h);
WWWHandlewindow* GetHandleWindow() { return mpWwwWindow; };
@@ -55,11 +55,11 @@ namespace ext_ead {
u32 mRenderingMode; // 0x2AC
public:
int unk_0x2B0; // 0x2B0
u32 unk_0x2B4[2]; // 0x2B4
u32 unk_0x2BC; // 0x2BC
u32 unk_0x2C0; // 0x2C0
u8 unk_0x2C4[6]; // 0x2C4
int mDisplayPageIndex; // 0x2B0
u32 mDisplayBufferIndices[2]; // 0x2B4
u32 mUpdateBufferIndex; // 0x2BC
u32 mUpdatePageIndex; // 0x2C0
u8 mPageLoadStatus[6]; // 0x2C4
};
} // namespace www
} // namespace ext_ead

View File

@@ -142,9 +142,6 @@ namespace textinput {
// TODO enum?
int getInputType() const;
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
void resetHoldingButton();
#endif
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
#if defined(MYTIMANAGER_IMPLEMENTATION) && defined(TI_CELLPHONE_IMPLEMENTATION)

View File

@@ -69,6 +69,9 @@
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data) override;
virtual bool updateInput(input::HKBManager& hkbManager) override;
#endif
#if defined(TI_CELLPHONE_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
void resetHoldingButton();
#endif
#ifdef TI_CELLPHONE_IMPLEMENTATION
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator) override;
@@ -95,7 +98,6 @@
virtual void changeSpaceKeyTop(const PaneNameToCharCode* keys);
void setUpperCaseJP(bool enabled);
void setLangKeyActive(bool enabled);
void resetHoldingButton();
private:
bool mbLineFeedButton;

View File

@@ -74,8 +74,16 @@ namespace textinput {
virtual void onEvent(GUIComponent& comp, u32 event, void* data) {} // 0x0C
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void setLatestEventCtrlNo(int ctrlNo);
#else
virtual void setLatestEventCtrlNo(int ctrlNo) { muLatestEventCtrlNo = ctrlNo; } // 0x10
#endif
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual int getLatestEventCtrlNo();
#else
virtual int getLatestEventCtrlNo() { return muLatestEventCtrlNo; } // 0x14
#endif
protected:
int muLatestEventCtrlNo; // 0x04
@@ -109,7 +117,11 @@ namespace textinput {
: GUIInterface(), mbInitialize(false), mDraggingButton(0xFFFF), mID(id), mbTriggerTarget(false), mpManager(NULL), mpListener(NULL) {
init();
}
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual ~GUIComponent();
#else
virtual ~GUIComponent() {} // 0x08
#endif
virtual u32 getID() { return mID; } // 0x20
@@ -146,7 +158,11 @@ namespace textinput {
}
virtual bool isTriggerTarget() { return mbTriggerTarget; } // 0x48
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void setTriggerTarget(bool bEnable);
#else
virtual void setTriggerTarget(bool bEnable) { mbTriggerTarget = bEnable; } // 0x4C
#endif
void setParentManager(GUIManager* manager) { mpManager = manager; }
GUIManager* getParentManager() { return mpManager; }

View File

@@ -52,17 +52,17 @@ namespace textinput {
const Manager *mgr() const { return mpManager; }
Manager* mpManager; // 0x10
u8 field_0x14; // 0x14
u8 mbShiftTapPending; // 0x14
#ifdef TIINPUTFORM_IMPLEMENTATION
u8 mbSingleQuoteClosing;
u8 mbDoubleQuoteClosing;
#else
#ifdef TIHWKEYBOARD_IMPLEMENTATION
bool field_0x15;
bool field_0x16;
bool mbSingleQuoteClosing;
bool mbDoubleQuoteClosing;
#else
u8 field_0x15; // 0x15
u8 field_0x16; // 0x16
u8 mbSingleQuoteClosing; // 0x15
u8 mbDoubleQuoteClosing; // 0x16
#endif
#endif
};

View File

@@ -47,7 +47,11 @@ namespace textinput {
#else
virtual Language getLanguage() const { return meLanguage; }
#endif
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void update();
#else
virtual void update() {}
#endif
#else
virtual Language getLanguage() const;
virtual void update();

View File

@@ -64,7 +64,11 @@ namespace textinput {
virtual void setWCString(const wchar_t* string);
virtual void setLanguage(Language language);
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual Language getLanguage() const;
#else
virtual Language getLanguage() const { return meLanguage; }
#endif
#ifdef MYTIMANAGER_IMPLEMENTATION
Language getLanguageForMemo() const { return meLanguage; }
#endif
@@ -125,14 +129,26 @@ namespace textinput {
#ifdef TIHWKEYBOARD_IMPLEMENTATION
EventObserver* getEventObserverForHardware() const { return mpEventObserver; }
#endif
#ifdef TISIGNWINDOW_IMPLEMENTATION
virtual InputForm* getInputForm();
#else
virtual InputForm* getInputForm() { return mpInputForm; }
#endif
virtual const InputForm* getInputForm() const { return mpInputForm; }
virtual keyboard::hwkey::HWKeyboard* getHWKeyboard() { return mpHWKeyboard; }
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual const keyboard::hwkey::HWKeyboard* getHWKeyboard() const;
#else
virtual const keyboard::hwkey::HWKeyboard* getHWKeyboard() const { return mpHWKeyboard; }
#endif
virtual keyboard::pctype::LayoutByNW4R* getPCKeyboard() { return mpPCKeyboard; }
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual const keyboard::pctype::LayoutByNW4R* getPCKeyboard() const;
#else
virtual const keyboard::pctype::LayoutByNW4R* getPCKeyboard() const { return mpPCKeyboard; }
#endif
virtual keyboard::cellphonetype::LayoutByNW4R* getCellPhoneKeyboard() { return mpCellPhoneKeyboard; }
virtual const keyboard::cellphonetype::LayoutByNW4R* getCellPhoneKeyboard() const { return mpCellPhoneKeyboard; }
@@ -149,7 +165,11 @@ namespace textinput {
virtual const candidatebox::LayoutByNW4R* getCandidateBox() const { return mpCandidateBox; }
virtual toolbar::LayoutByNW4R* getToolBar() { return mpToolBar; }
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual const toolbar::LayoutByNW4R* getToolBar() const;
#else
virtual const toolbar::LayoutByNW4R* getToolBar() const { return mpToolBar; }
#endif
#ifdef TIMANAGER_IMPLEMENTATION
virtual void* getPredictLanguageSelectDialog();

View File

@@ -36,7 +36,11 @@ namespace textinput {
virtual void onTiEvent(gui::PaneComponent* paneComponent, u32 event, Input* input) = 0; // 0x18
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void setEventObserver(EventObserver *event);
#else
virtual void setEventObserver(EventObserver *event) { mpEventObserver = event; } // 0x1C
#endif
protected:
EventObserver* mpEventObserver; // 0x08
@@ -97,25 +101,19 @@ namespace textinput {
virtual void calc(); // 0x0C
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void onAnmEvent(AnmPaneEvent) {}
virtual void onAnmEvent(AnmPaneEvent);
#else
virtual void onAnmEvent(AnmPaneEvent paneEvent);
#endif // 0x10
virtual void changeAnimation(u32 id); // 0x14
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual bool isInAnimation() { return mpCurrentAnim != NULL; }
virtual bool isInAnimation();
#else
virtual bool isInAnimation();
#endif // 0x18
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual Anim* searchAnimation(u32 id) {
for (Anim* animation = static_cast<Anim*>(nw4r::ut::List_GetNext(&mAnms, NULL)); animation != NULL;
animation = static_cast<Anim*>(nw4r::ut::List_GetNext(&mAnms, animation))) {
if (animation->muID == id) return animation;
}
return NULL;
}
virtual Anim* searchAnimation(u32 id);
#else
virtual Anim* searchAnimation(u32 id);
#endif // 0x1C
@@ -247,14 +245,22 @@ namespace textinput {
virtual bool updateInput(int point, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data); // 0x20
virtual bool updateInput(input::HKBManager& hkbManager); // 0x24
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual TiLayout* getLayout();
#else
virtual TiLayout* getLayout() { return mpLayout; } // 0x28
#endif
virtual nw4r::lyt::Pane* getPane(const char* paneName); // 0x2C
virtual const nw4r::lyt::Pane* getPane(const char* paneName) const; // 0x30
virtual u32 getFlightDuration(int point, const char* paneName); // 0x34
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void setAnimOn(bool flag);
#else
virtual void setAnimOn(bool flag) { mbAnimOn = flag; } // 0x38
#endif
virtual void drawPane(const char* paneName); // 0x3C
@@ -282,8 +288,16 @@ namespace textinput {
virtual AnmPane* searchAnmPane(const char* paneName); // 0x60
virtual AnmPane* searchAnmPane(wchar_t ch); // 0x64
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual nw4r::ut::List& getAnmPaneList();
#else
virtual nw4r::ut::List& getAnmPaneList() { return mAnmPanes; } // 0x68
#endif
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual gui::PaneManager* getPaneManager();
#else
virtual gui::PaneManager* getPaneManager() { return mpPaneManager; } // 0x6C
#endif
virtual void AdjustPaneMtx(Mtx& mtx, const nw4r::lyt::DrawInfo& drawInfo, const nw4r::math::MTX34& mGlobalMtx); // 0x70

View File

@@ -191,7 +191,11 @@ namespace textinput {
#endif
virtual ~Base();
virtual void create(MEMAllocator* allocator);
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void init();
#else
virtual inline void init();
#endif
virtual void updateFromReceiver(u32 command, void* data);
virtual void onKey(u32 event, void* data);
virtual int getType();
@@ -223,6 +227,9 @@ namespace textinput {
virtual void updateFixMode();
protected:
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
inline void initializeKeyState();
#endif
State mState;
const LanguageData* mpInitialLanguageData;
KeyState mKeyState;
@@ -301,6 +308,8 @@ namespace textinput {
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
: Base(manager), nw4rmanager::Layout(accessor, layoutName, observer), mpKeyboardEventHandler(NULL),
mShiftButton(1, this, this), mCapsButton(0, this, this), mModePanel(2, this, this) {}
#elif defined(TI_PC_KEYBOARD_IMPLEMENTATION)
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName);
#endif
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator);
@@ -352,6 +361,15 @@ namespace textinput {
UIModePanel mModePanel;
};
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
class Sample : public LayoutByNW4R {
public:
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
: LayoutByNW4R(manager, accessor, observer, layoutName) {}
virtual ~Sample() {}
};
#endif
class AnmPane : public nw4rmanager::AnmPane {
public:
AnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : nw4rmanager::AnmPane(pane, observer), mAnimation(0) {}

View File

@@ -18,6 +18,7 @@ struct LanguageDependency {
class Base : public KeyboardBase {
public:
Base(Manager* manager) : mpAllocator(NULL), mpManager(manager) {}
virtual ~Base();
virtual void create(MEMAllocator*) override;
virtual void init() override;
@@ -45,6 +46,8 @@ class EventHandler;
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public nw4rmanager::AnmObserver {
public:
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
: Base(manager), nw4rmanager::Layout(accessor, layoutName, observer), mbActive(false), mbInput(false), mpEventHandler(NULL), mpKeyboard(NULL) {}
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator*) override;
virtual void init() override;
@@ -75,7 +78,9 @@ public:
class Sample : public LayoutByNW4R {
public:
virtual ~Sample();
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
: LayoutByNW4R(manager, accessor, observer, layoutName) {}
virtual ~Sample() {}
};
class EventHandler : public nw4rmanager::TiEventHandler {

View File

@@ -14,9 +14,17 @@ namespace textinput {
Base(Manager* manager) : mQwerty(true), meLanguage(USA), mpAllocator(NULL), mpManager(manager) {}
#endif
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void create(MEMAllocator* allocator);
#else
virtual void create(MEMAllocator* allocator) { mpAllocator = allocator; }
#endif
virtual void init() {}
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual bool isQwerty() const;
#else
virtual bool isQwerty() const { return mQwerty; }
#endif
virtual void setQwerty(bool qwerty);
virtual void setLanguage(Language language) { meLanguage = language; }
virtual Language getLanguage() const { return meLanguage; }

View File

@@ -34,7 +34,7 @@ namespace textinput {
void replaceChar(char* dest, u32 destLen, const char* src, int replaceIdx, char newCh);
bool isAlphabet(wchar_t ch);
f32 hermiteInterporation(f32 arg0, f32 arg1, f32 arg2, f32 arg3, f32 arg4, f32 arg5, f32 arg6);
f32 hermiteInterporation(f32 time, f32 startTime, f32 startValue, f32 startTangent, f32 endTime, f32 endValue, f32 endTangent);
void getProjectionRect4x3(nw4r::ut::Rect* rect);
void getProjectionRect16x9(nw4r::ut::Rect* rect);

View File

@@ -39,7 +39,9 @@ public:
};
static u16 ElementBuffer[0x100];
static u16 CandidatesBuffer[0x300];
static u16 CandidatesBuffer[0x100];
static u16 ElementWorkBuffer[0x100];
static u16 PredictionBuffer[0x100];
static u16 CandidatedWord[0xa00];
static u16 LatestWord[0x40];

View File

@@ -113,37 +113,37 @@ namespace ipl {
void init(const T& start, const T& end, f32 maxFrame, f32 startTangent, f32 endTangent, int playback = ANIM_TYPE_FORWARD, f32 speed = 1.0f);
T get() const {
f32 var_f27 = mFrame;
f32 var_f28 = 1.0f / mMaxFrame;
f32 frame = mFrame;
f32 inverseDuration = 1.0f / mMaxFrame;
T r =
(mStart *
(1.0f + ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))))) -
(mEnd * ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))));
(1.0f + ((inverseDuration * (inverseDuration * (inverseDuration * (frame * (2.0f * frame * frame))))) -
(inverseDuration * (inverseDuration * (3.0f * frame * frame)))))) -
(mEnd * ((inverseDuration * (inverseDuration * (inverseDuration * (frame * (2.0f * frame * frame))))) -
(inverseDuration * (inverseDuration * (3.0f * frame * frame)))));
r +=
(mStartTangent *
(var_f27 +
((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (2.0f * var_f27 * var_f27))))) +
(mEndTangent * ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (var_f27 * var_f27))));
(frame +
((inverseDuration * (inverseDuration * (frame * (frame * frame)))) -
(inverseDuration * (2.0f * frame * frame))))) +
(mEndTangent * ((inverseDuration * (inverseDuration * (frame * (frame * frame)))) -
(inverseDuration * (frame * frame))));
return r;
/*f32 var_f27 = mMaxFrame;
f32 var_f28 = 1.0f / mMaxFrame;
T sp28 = mEnd * ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27))));
T sp1C = mStart * (1.0f + ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))));
T r = sp1C - sp28;
/*f32 maxFrame = mMaxFrame;
f32 inverseDuration = 1.0f / mMaxFrame;
T weightedEnd = mEnd * ((inverseDuration * (inverseDuration * (inverseDuration * (maxFrame * (2.0f * maxFrame * maxFrame))))) -
(inverseDuration * (inverseDuration * (3.0f * maxFrame * maxFrame))));
T weightedStart = mStart * (1.0f + ((inverseDuration * (inverseDuration * (inverseDuration * (maxFrame * (2.0f * maxFrame * maxFrame))))) -
(inverseDuration * (inverseDuration * (3.0f * maxFrame * maxFrame)))));
T r = weightedStart - weightedEnd;
f32 temp_f4 = var_f27 * var_f27;
f32 temp_f7 = var_f28 * (var_f28 * (var_f27 * temp_f4));
f32 temp_f3 =
(mStartTangent * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (mEndTangent * (temp_f7 - (var_f28 * temp_f4)));
r = r + temp_f3;
f32 frameSquared = maxFrame * maxFrame;
f32 scaledCubic = inverseDuration * (inverseDuration * (maxFrame * frameSquared));
f32 tangentContribution =
(mStartTangent * (maxFrame + (scaledCubic - (inverseDuration * (2.0f * maxFrame * maxFrame))))) + (mEndTangent * (scaledCubic - (inverseDuration * frameSquared)));
r = r + tangentContribution;
return r;*/
}
@@ -163,24 +163,28 @@ namespace ipl {
void init(const f32& start, const f32& end, f32 maxFrame, f32 startTangent, f32 endTangent, int playback = ANIM_TYPE_FORWARD,
f32 speed = 1.0f);
#ifdef IPL_SD_CHANNEL_TITLE_CPP
f32 get() const;
#else
f32 get() const {
f32 var_f27 = mFrame;
f32 var_f28 = 1.0f / mMaxFrame;
f32 frame = mFrame;
f32 inverseDuration = 1.0f / mMaxFrame;
f32 r =
(mStart *
(1.0f + ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))))) -
(mEnd * ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))));
(1.0f + ((inverseDuration * (inverseDuration * (inverseDuration * (frame * (2.0f * frame * frame))))) -
(inverseDuration * (inverseDuration * (3.0f * frame * frame)))))) -
(mEnd * ((inverseDuration * (inverseDuration * (inverseDuration * (frame * (2.0f * frame * frame))))) -
(inverseDuration * (inverseDuration * (3.0f * frame * frame)))));
r +=
(mStartTangent *
(var_f27 + ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (2.0f * var_f27 * var_f27))))) +
(mEndTangent * ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (var_f27 * var_f27))));
(frame + ((inverseDuration * (inverseDuration * (frame * (frame * frame)))) -
(inverseDuration * (2.0f * frame * frame))))) +
(mEndTangent * ((inverseDuration * (inverseDuration * (frame * (frame * frame)))) -
(inverseDuration * (frame * frame))));
return r;
}
#endif
protected:
f32 mStart;
@@ -227,35 +231,35 @@ namespace ipl {
}
#else
T get() const {
f32 var_f27 = mFrame;
f32 var_f28 = 1.0f / mMaxFrame;
f32 frame = mFrame;
f32 inverseDuration = 1.0f / mMaxFrame;
f32 t1t2 =
(var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) - (var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)));
(inverseDuration * (inverseDuration * (inverseDuration * (frame * (2.0f * frame * frame))))) - (inverseDuration * (inverseDuration * (3.0f * frame * frame)));
T r = (mStart * (1.0f + t1t2)) - (mEnd * t1t2);
f32 temp_f4 = var_f27 * var_f27;
f32 temp_f7 = var_f28 * (var_f28 * (var_f27 * temp_f4));
f32 temp_f3 =
(mStartTangent * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (mEndTangent * (temp_f7 - (var_f28 * temp_f4)));
f32 frameSquared = frame * frame;
f32 scaledCubic = inverseDuration * (inverseDuration * (frame * frameSquared));
f32 tangentContribution =
(mStartTangent * (frame + (scaledCubic - (inverseDuration * (2.0f * frame * frame))))) + (mEndTangent * (scaledCubic - (inverseDuration * frameSquared)));
r = r + temp_f3;
r = r + tangentContribution;
return r;
/*f32 var_f27 = mMaxFrame;
f32 var_f28 = 1.0f / mMaxFrame;
T sp28 = mEnd * ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27))));
T sp1C = mStart * (1.0f + ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))));
T r = sp1C - sp28;
/*f32 maxFrame = mMaxFrame;
f32 inverseDuration = 1.0f / mMaxFrame;
T weightedEnd = mEnd * ((inverseDuration * (inverseDuration * (inverseDuration * (maxFrame * (2.0f * maxFrame * maxFrame))))) -
(inverseDuration * (inverseDuration * (3.0f * maxFrame * maxFrame))));
T weightedStart = mStart * (1.0f + ((inverseDuration * (inverseDuration * (inverseDuration * (maxFrame * (2.0f * maxFrame * maxFrame))))) -
(inverseDuration * (inverseDuration * (3.0f * maxFrame * maxFrame)))));
T r = weightedStart - weightedEnd;
f32 temp_f4 = var_f27 * var_f27;
f32 temp_f7 = var_f28 * (var_f28 * (var_f27 * temp_f4));
f32 temp_f3 =
(mStartTangent * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (mEndTangent * (temp_f7 - (var_f28 * temp_f4)));
r = r + temp_f3;
f32 frameSquared = maxFrame * maxFrame;
f32 scaledCubic = inverseDuration * (inverseDuration * (maxFrame * frameSquared));
f32 tangentContribution =
(mStartTangent * (maxFrame + (scaledCubic - (inverseDuration * (2.0f * maxFrame * maxFrame))))) + (mEndTangent * (scaledCubic - (inverseDuration * frameSquared)));
r = r + tangentContribution;
return r;*/
}
#endif
@@ -266,6 +270,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

@@ -103,7 +103,7 @@ namespace ipl {
y = r.y;
z = 0.0f;
}
#if defined(IPL_ADDRESS_EDIT_CPP) || defined(IPL_SD_CHANNEL_SELECT_CPP) || defined(IPL_GC_WINDOW_CPP)
#if defined(IPL_ADDRESS_EDIT_CPP) || defined(IPL_SD_CHANNEL_SELECT_CPP) || defined(IPL_GC_WINDOW_CPP) || defined(IPL_SD_CHANNEL_TITLE_CPP)
VEC3(f32 fx, f32 fy, f32 fz);
#else
VEC3(f32 fx, f32 fy, f32 fz) {

View File

@@ -141,6 +141,9 @@ namespace ipl {
void init(nw4r::lyt::Pane* pane);
void set(u64 fdId);
void reset();
#ifdef IPL_ADDRESS_MATCHING
nigaoe::Object* getPortrait() const { return mpNigaoe; }
#endif
static void create_callback(nigaoe::Object* object, void* work);

View File

@@ -332,12 +332,12 @@ namespace ipl {
scroller mScroller; // 0x58
picture mPicture; // 0xC8
int unk_0xF8;
u8 unk_0xFC;
int mReservedWord;
u8 mReservedByte;
EGG::Allocator mGUIAlloc; // 0x100
wchar_t unk_0x114[6];
wchar_t mUrlTerminators[6];
u8* mpCmpArcData; // 0x120
u8* mpArcData; // 0x124

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

@@ -12,6 +12,7 @@
namespace ipl {
namespace scene {
extern "C" BOOL push_button_queue(void*, const void*);
class ButtonEventHandlerBase;
class OptOutButtonEventHandlerBase;
class SDMenuEventHandlerBase;
@@ -314,6 +315,7 @@ namespace ipl {
}
protected:
friend BOOL push_button_queue(void*, const void*);
typedef struct Command {
enum {
TYPE_ANIM = 0,

View File

@@ -40,7 +40,7 @@ namespace ipl {
void initExtModule(EGG::Heap* workHeap, channel::RsoThread* thread);
int calcExtModule(EGG::ExpHeap* expHeap, bool unk0, bool unk1);
int calcExtModule(EGG::ExpHeap* expHeap, bool canStartModule, bool onSceneChange);
void drawThumbnail();
void drawCursor();
@@ -57,14 +57,14 @@ namespace ipl {
BOOL isDiskChannel() const;
BOOL isValid() const;
void onPoint(int unk);
void onLeft(int unk);
void onPinch(bool unk);
void onPoint(int eventFlags);
void onLeft(int eventFlags);
void onPinch(bool pinched);
void setCursorDecideAnim();
void initCursorAnim(bool unk);
void initBalloonAnim(bool unk);
void initCursorAnim(bool resetPointCount);
void initBalloonAnim(bool resetPointCount);
void FillModuleCount();
@@ -83,15 +83,15 @@ namespace ipl {
void initCursor();
void calcCursor(const nw4r::math::VEC3& vec);
void setCursorAnim(int unk) NO_INLINE;
void setCursorAnim(int state) NO_INLINE;
void calcCursorAnim();
void startCursorAnim(int unk);
void startCursorAnim(int animationIndex);
void initBalloon();
void setBalloonText(const wchar_t* text);
void calcBalloon(const nw4r::math::VEC3& vec);
void setBalloonAnim(int unk) NO_INLINE;
void setBalloonAnim(int state) NO_INLINE;
void calcBalloonAnim();
void clearModuleParam();
@@ -107,7 +107,7 @@ namespace ipl {
}
private:
u8 unk_0x00[8];
u8 mListLinkStorage[8];
EGG::Heap* mpCursorHeap; // 0x08
EGG::Heap* mpBalloonHeap; // 0x0C
@@ -149,22 +149,22 @@ namespace ipl {
layout::Object* mpCursorLayout; // 0x48
layout::Animator* mpCursorAnims[ANIM_CURSOR_MAX]; // 0x4C
int unk_0x58;
int unk_0x5C;
int mCursorState;
int mPendingCursorState;
layout::Object* mpBalloonLayout; // 0x60
layout::Animator* mpBalloonAnim; // 0x64
int unk_0x68;
int unk_0x6C;
int unk_0x70;
int mBalloonState;
int mPendingBalloonState;
int mBalloonWaitFrame;
int unk_0x74;
int mPointCount;
nw4r::lyt::Group* mpNwc24NewGroup; // 0x78
layout::GroupAnimator* mpNwc24NewAnim; // 0x7C
bool mpNwc24NewPlayAnim; // 0x80
int unk_0x84;
u32 unk_0x88;
int mNewMessageState;
u32 mNewMessageFrame;
f32 mThumbWidth; // 0x8C
f32 mThumbHeight; // 0x90
@@ -188,7 +188,7 @@ namespace ipl {
channel::RsoThread* mpModuleThread; // 0xE8
int mExtModuleState; // 0xEC
nand::SharedFile* mpModuleFile; // 0xF0
bool unk_0xF4;
bool mbModuleFlag;
u32 mModuleCount; // 0xF8
u32 mMaxModuleCount; // 0xFC

View File

@@ -76,7 +76,7 @@ namespace ipl {
void appendToChannelList(int page, int index);
void destroyChannelObj(ChannelObj * channelObj);
void sortChannelList(int page);
void sortChannelListByPage(int page, int unk);
void sortChannelListByPage(int page, int edgeDirection);
ChannelObj* searchList(int page, int index) const;
void setupDiskChanObj();
@@ -87,7 +87,7 @@ namespace ipl {
void setChanFrameVisibility();
BOOL isChannelInView(int page, int index) const;
BOOL isChannelInCalc(int page, int index, int unk2) const;
BOOL isChannelInCalc(int page, int index, int currentPage) const;
BOOL isPageCreated(int page) const;
BOOL isPageCreatedAllDone(int page) const;
@@ -108,14 +108,14 @@ namespace ipl {
BOOL prepareRestarting(int page);
void restart(int page, int index);
nw4r::lyt::Pane* getChannelBasePane(int page, int index, int unk3) const;
nw4r::lyt::Pane* getChannelBasePane(int page, int index, int currentPage) const;
const nw4r::lyt::Pane* getChannelBasePane(int index) const;
nw4r::lyt::Pane* getChannelBasePane(int index);
nw4r::math::VEC3 getDispChanTrans(int index) const;
void setChannelScissor(const ChannelObj* channelObj) const;
void initChanZoomParam(const math::VEC3& pos, BOOL unk);
void initChanZoomParam(const math::VEC3& pos, BOOL zoomOut);
void calcChanZoomParam();
void setChanZoomOrtho();
@@ -148,11 +148,11 @@ namespace ipl {
void startResetting();
bool unkBool() {
return !unk_0x185 || unk_0x180 == 3;
return !mbWaitForModuleStop || mModuleState == 3;
}
void setSomething() {
mbModuleSceneChange = true;
unk_0x185 = 1;
mbWaitForModuleStop = 1;
}
enum {
@@ -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
@@ -274,25 +274,25 @@ namespace ipl {
clock mClock; // 0x108
s32 mPrevSDState; // 0x168
EGG::Heap* unk_0x16C;
EGG::Heap* mpThumbnailHeap;
EGG::Heap* mpDiskHeap; // 0x170
EGG::Heap* mpCursorHeap; // 0x174
EGG::Heap* mpBalloonHeap; // 0x178
EGG::Heap* unk_0x17C;
EGG::Heap* mpChannelObjHeap;
int unk_0x180;
int mModuleState;
bool mbModuleSceneChange; // 0x184
bool unk_0x185;
bool mbWaitForModuleStop;
ChannelObj* mpCurrentRsoChanObj; // 0x188
ChannelObj* unk_0x18C;
ChannelObj* mpPriorityModuleChanObj;
EGG::Heap* mpModuleWorkHeap; // 0x190
channel::RsoThread* mpModuleThread; // 0x194
EGG::ExpHeap* mpModuleHeaps[49]; // 0x198
bool unk_0x25C[49];
bool mbModuleHeapInUse[49];
nw4r::math::VEC2 mDragPos; // 0x290
int mConChan; // 0x298
@@ -300,21 +300,21 @@ namespace ipl {
int mMoveOldIndex; // 0x2A0
int mMoveNewPage; // 0x2A4
int mMoveNewIndex; // 0x2A8
int unk_0x2AC;
int unk_0x2B0;
int unk_0x2B4;
bool unk_0x2B8;
int mDragRightScrollFrame;
int mDragLeftScrollFrame;
int mReleaseWaitFrame;
bool mbDragReleased;
nand::File* mpSaveDataFile; // 0x2BC
ChannelObj* unk_0x2C0;
layout::Object* unk_0x2C4;
layout::Animator* unk_0x2C8;
ChannelObj* mpMovedChanObj;
layout::Object* mpMoveThumbnailLayout;
layout::Animator* mpMoveThumbnailAnim;
u32 unused_0x2CC;
static BOOL msInitFlag;
static const char* mscChanPaneNames[CHAN_SCROLL_MAX][MAX_CHANNEL_INDEX];
static const char* mscBasePaneNames[CHAN_SCROLL_MAX];
static const char* mscUnk0PaneNames[CHAN_SCROLL_MAX];
static const char* mscUnk1PaneNames[CHAN_SCROLL_MAX];
static const char* mscPicturePaneNames[CHAN_SCROLL_MAX];
static const char* mscEdgePaneNames[CHAN_SCROLL_MAX];
static const char* mscClockPaneNames[3];
static const char* mscMaskPaneName;

View File

@@ -112,7 +112,7 @@ namespace ipl {
void startChangeChannel(int page, int index);
void reserveNextScene();
void reserveSettingScene(bool unk);
void reserveSettingScene(bool skipConfirmation);
void prepareForBoot1(int sceneID);
void prepareForBoot2(int sceneID);
@@ -318,9 +318,9 @@ namespace ipl {
int mDiskState2; // 0x78
nw4r::math::VEC3 mDispTrans; // 0x7C
u32 unk_0x88;
int unk_0x8C;
bool unk_0x90;
u32 mBootWaitFrame;
int mStartButtonState;
bool mbBannerStartPending;
layout::GroupAnimator* mpGrpAnims[ANIM_GRP_MAX][ANIM_MAX]; // 0x94
layout::Animator* mpChangeAnims[ANIM_MAX]; // 0x1D4
@@ -352,8 +352,8 @@ namespace ipl {
layout::Object* mpDiskBnrLayout; // 0x254
layout::Animator* mpDiskBnrAnims[DISK_ANIM_GRP_MAX][DISK_ANIM_MAX]; // 0x258
undefined unk_0x320[4];
undefined unk_0x324;
undefined reservedAfterDiskAnims[4];
undefined mWiiDiskReady;
nand::LayoutFile* mpGCBannerFile; // 0x328
layout::Object* mpGCBannerLyt; // 0x32C
@@ -371,24 +371,24 @@ namespace ipl {
CsChanTtlButtonEventHandler* mpButtonEvent; // 0x354
utility::Capture* mpCapture; // 0x358
ESTmdView* mpCurTicket; // 0x35C
bool unk_0x360;
bool mbTmdReady;
u16 mCurGameCode; // 0x362
ESTitleId mTmpTitleID; // 0x368
bool unk_0x370;
bool unk_0x371;
bool mbTmpTitleCleanupDone;
bool mbTicketLimitReady;
u32 mLimitType; // 0x374
u32 mTimeLimitRemain; // 0x378
bool unk_0x37C;
bool mbStartButtonFocusPlayed;
int mModuleState; // 0x380
int mModuleType; // 0x384
volatile bool mbModuleSceneChange; // 0x388
bool mbRSODoneCalc; // 0x389
u32 unk_0x38C;
u32 unk_0x390;
u32 mModuleFrame;
u32 mModuleInterval;
nand::SharedFile* mpModuleFile; // 0x394
EGG::ExpHeap* mpRsoExpHeaps[2]; // 0x398
int mCurRsoExpHeap; // 0x39C

View File

@@ -31,8 +31,12 @@ namespace ipl {
virtual void calc();
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual void initCalcNormal();
#else
virtual void initCalcNormal() {
} // 0x4C
#endif
virtual void initCalcFadeout() {
} // 0x50
@@ -49,8 +53,12 @@ namespace ipl {
return FADER_SCN_NEXT;
} // 0x60
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual void calcCommonAfter();
#else
virtual void calcCommonAfter() {
} // 0x64
#endif
int getSceneFadeState() {
return mScnFadeState;

View File

@@ -62,7 +62,11 @@ namespace ipl {
virtual ~Base();
/** @brief If the scene is ready */
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual BOOL isReady() const;
#else
virtual BOOL isReady() const { return FALSE; }
#endif
/** @brief If the user can power off/reset the system */
#ifdef IPL_SD_CHANNEL_TITLE_CPP
@@ -73,7 +77,11 @@ namespace ipl {
/** @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 */
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual BOOL isResetProcessDone();
#else
virtual BOOL isResetProcessDone() { return TRUE; }
#endif
/** @brief Prepare to create scene */
virtual void prepare() {}
@@ -86,10 +94,17 @@ namespace ipl {
/** @brief Destroy the scene and clear from memory */
virtual void destroy() {}
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual Base* getParent();
virtual Base* getChild();
virtual Base* getNext();
virtual Base* getPrev();
#else
virtual Base* getParent() { return (Base*)mpParent; }
virtual Base* getChild() { return (Base*)mpChild; }
virtual Base* getNext() { return (Base*)mpNext; }
virtual Base* getPrev() { return (Base*)mpPrev; }
#endif
/** @brief Check if scene has been created.*/
bool isSceneCreated() const { return (mScnState & SCN_STATE_CREATED); }

View File

@@ -187,6 +187,22 @@ namespace ipl {
}
private:
GXTexObj* initBannerTexture(u8 slot, s32 file, void* data) {
GXInitTexObj(&mFileCell[slot][file].banner, data, 0x60, 0x20,
GX_TF_RGB5A3, GX_CLAMP, GX_CLAMP, GX_FALSE);
return &mFileCell[slot][file].banner;
}
void initBannerTextureCI(u8 slot, s32 file, void* data) {
GXInitTexObjCI(&mFileCell[slot][file].banner, data, 0x60, 0x20,
GX_TF_C8, GX_CLAMP, GX_CLAMP, GX_FALSE, GX_TLUT0);
}
GXTlutObj* initBannerPalette(u8 slot, s32 file, void* data) {
GXInitTlutObj(&mFileCell[slot][file].bannerTlut, data, GX_TL_RGB5A3, 0x100);
return &mFileCell[slot][file].bannerTlut;
}
u32 unk_0x04; // 0x00004
MCFile mFile[2][0x7F]; // 0x00008
MCFileCell mFileCell[2][0x7F]; // 0x00FE8

View File

@@ -44,7 +44,7 @@ namespace ipl {
#endif
struct SettingAPScanList {
u8 unknown[0x14];
u8 reservedHeader[0x14];
union {
struct {
u16 count;
@@ -180,33 +180,33 @@ namespace ipl {
ARG_SETUP,
ARG_UPDATE,
ARG_INTERNET_PAGE,
ARG_UNK_5,
ARG_UNK_6,
ARG_RESUME_SETUP,
ARG_DIRECT_PAGE,
};
private:
#ifdef IPL_SETTING_IMPLEMENTATION
int mUpdateTiming;
u8 unk_0x5C;
u8 unk_0x5D[3];
u8 mBrowserStopRequested;
u8 reservedAfterBrowserStop[3];
nand::Base* mpWWWLibraryFile;
nand::Base* mpSettingHTMLFile;
nand::Base* mpWWWArchiveFile;
nand::Base* mpFontFile;
nand::Base* mpBackgroundTPLFile;
int unk_0x74;
int unk_0x78;
int unk_0x7C;
int mDialogState;
int mAPScanState;
int mEULAState;
int mProfileIDMode;
int unk_0x84;
int mUSBAPState;
int mAOSSState;
int mRakuState;
int mFuncMsgPending;
int unk_0x94;
int mSafeModeDialogState;
ESTitleId mUpdateTitleId;
u32 mPrepareTick;
u8 mSettingData[0x16];
u8 unk_0xBA[2];
u8 reservedAfterSettingData[2];
nand::LayoutFile* mpSettingLayoutFile;
layout::Object* mpChangeLayout;
layout::Object* mpMainLayout;
@@ -221,25 +221,25 @@ namespace ipl {
APScanThread* mpAPScanThread;
SettingAPScanList mAPScanList;
void* mpMem1BrowserBuffer;
u32 unk_0x908;
u32 reservedBrowserWord;
void* mpMem2BrowserBuffer;
void* mpBrowserStringBuffer;
int unk_0x914;
int unk_0x918;
u8 unk_0x91C[4];
int mAPScrollOffset;
int mAPAnimationIndex;
u8 mUiStatus[4];
ext_ead::www::ImeData* mpBrowserData;
www::wiisetting::WiiData* mpWiiSettingData;
www::wiisetting::WiiFlag* mpWiiSettingFlag;
u8 unk_0x92C;
u8 unk_0x92D[3];
int unk_0x930;
u8 mActionFrame;
u8 reservedAfterActionFrame[3];
int mSupportCode;
www::wiisetting::SetStringBuf* mpStringBuffer;
#ifdef IPL_SETTING_IMPLEMENTATION
wchar_t unk_0x938[0x101];
wchar_t mInputText[0x101];
#else
u8 unk_0x938[0x202];
u8 mInputText[0x202];
#endif
u8 unk_0xB3A;
u8 reservedAfterInputText;
u8 mBrowserCreated;
keyboard::Manager::State mKeyboardState;
int mInitialArgument;
@@ -247,21 +247,21 @@ namespace ipl {
int mProgressiveMode;
int mEuRgb60Mode;
u8 mIsResetAcceptable;
u8 unk_0xB5D[3];
u8 reservedAfterResetFlag[3];
OSMessageQueue mFuncMessageQueue;
OSMessage mFuncMessages[5];
int unk_0xB94;
int mScreenModeChangeState;
int mState;
int unk_0xB9C;
int mInputDelayFrame;
OSTime mCreatePageTime;
u32 unk_0xBA8;
u8 unk_0xBAC;
u8 unk_0xBAD[3];
u8 unk_0xBB0[0x10];
u32 mConnectedControllerMask;
u8 mNetSettingResultSent;
u8 reservedAfterNetSettingResult[3];
u8 reservedTail[0x10];
static void* mem1Buffer_;
static void* mem2Buffer_;
#else
u8 unk_0x58[0xB68];
u8 mSettingStorage[0xB68];
#endif
};

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

@@ -40,8 +40,8 @@ enum {
typedef struct tagSTVRCSettings {
u32 magic; // 0x00
u32 unk_0x04;
u32 unk_0x08;
u32 formatVersion;
u32 configurationValid;
u32 modelMakerID; // 0x0C
u32 modelType; // 0x10
u8 commandMap[TVRC_COMMAND_MAP_MAX]; // 0x14

View File

@@ -65,7 +65,7 @@ namespace ipl {
STATE_FINISHED,
};
bool mbDoneProcess; // 0x00
volatile bool mbDoneProcess; // 0x00
int mCDBResult; // 0x04
int mPrevFreeSize; // 0x08

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

@@ -20,7 +20,7 @@ namespace ipl {
// here to avoid typing in long namespaces constantly :P
enum {
CHANS_VM_ALT_SND_STATE_UNAVAILABLE = 0,
CHANS_VM_ALT_SND_STATE_UNK1,
CHANS_VM_ALT_SND_STATE_FALLBACK,
CHANS_VM_ALT_SND_STATE_PLAY,
};
@@ -32,8 +32,8 @@ namespace ipl {
layout::Animator** anims; // 0x08
u64 titleId; // 0x10
bool threadTerminated; // 0x18
bool unk_0x19;
bool unk_0x1A;
bool isThumbnail;
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

@@ -65,8 +65,13 @@ namespace ipl {
/** @brief Writes the file contents. */
virtual void write(); // 0x10
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual bool isFinished();
virtual int checkData();
#else
virtual bool isFinished() { return mbDoneTask; } // 0x14
virtual int checkData() { return mResult; } // 0x18
#endif
virtual bool isFatalError(); // 0x1C
u8* getBuffer() const { return mpBuffer; }

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

@@ -55,27 +55,27 @@ namespace ipl {
STATE_12,
};
u32 unk_0x04;
u32 mbDisabledTriggerEnabled;
BOOL mbInitialized; // 0x08
nand::SharedFile* mpDBFile; // 0x0C
BOOL mbResetting; // 0x10
s32 mCurrentCommand; // 0x14
u32 unk_0x18;
u32 unk_0x1C;
u32 mRepeatCount;
u32 mbRepeatCommand;
u32 mModelMakerID; // 0x20
u32 mModelType; // 0x24
BOOL mbPrepTVRC; // 0x28
void* mpDatabaseArc; // 0x2C
OSTime unk_0x30;
OSTime unk_0x38;
OSTime unk_0x40;
OSTime unk_0x48;
OSTime mCommandTransitionTime;
OSTime mMuteStartTime;
OSTime mSoundShutupTime;
OSTime mLastCommandTime;
int mCmdMaps[TVRC_COMMAND_MAP_MAX]; // 0x50
u32 mState; // 0x70
OSTick unk_0x74;
OSTick mDisabledTriggerTick;
BOOL mbDisabled; // 0x78
BOOL unk_0x7C;
u8 unk_0x80;
BOOL mbDisabledTriggerPending;
u8 mDisabledTriggerState;
undefined unused_0x81[7];
};
} // namespace ipl

View File

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

View File

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

@@ -51,12 +51,17 @@ namespace ipl {
mArg.mOrthoScale = scale;
}
#ifdef IPL_SD_CHANNEL_TITLE_CPP
static void setOrthoTrans(const math::VEC3& translate);
static void setOrthoScale(const math::VEC2& scale);
#else
static void setOrthoTrans(const math::VEC3& translate) { mArg.mOrthoTrans = translate; }
static void setOrthoScale(const math::VEC2& scale) NO_INLINE {
mArg.mOrthoScale.x = scale.x;
mArg.mOrthoScale.y = scale.y;
}
#endif
private:
static Arg mArg;

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 mPointerPosition;
math::VEC2 mScrollOrigin;
f32 mSpeed; // 0x18
f32 mSoundFreq; // 0x1C
};
@@ -94,9 +94,9 @@ namespace ipl {
f32 mUpLimit; // 0x38
f32 unk_0x3C;
f32 mScroll; // 0x40
f32 unk_0x44;
f32 unk_0x48;
f32 unk_0x4C;
f32 mButtonScrollOrigin;
f32 mVelocityDecay;
f32 mScrollAcceleration;
};
} // namespace utility
} // namespace ipl

View File

@@ -21,6 +21,12 @@ namespace EGG {
virtual void initialize(IAudioMgr::Arg* arg);
};
class ExpAudioMgr : public SimpleAudioMgr, public AudioFxMgr {
public:
ExpAudioMgr();
virtual ~ExpAudioMgr();
};
} // namespace EGG
#endif // EGG_AUDIO_EXP_MGR_H

View File

@@ -29,4 +29,10 @@ namespace EGG {
mHeap.SaveState();
}
ExpAudioMgr::ExpAudioMgr() {
}
ExpAudioMgr::~ExpAudioMgr() {
}
} // namespace EGG

View File

@@ -1120,32 +1120,28 @@ 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"";
}
if (format.alternate_form) {
wchar_t first = *wcs_ptr++;
wideLength = (unsigned char)first;
num_chars = (unsigned char)*wcs_ptr++;
if (format.precision_specified && wideLength > format.precision) {
wideLength = format.precision;
if (format.precision_specified && num_chars > format.precision) {
num_chars = format.precision;
}
} else if (format.precision_specified) {
wideLength = format.precision;
num_chars = format.precision;
if ((string_end = wmemchr((wchar_t*)wcs_ptr, 0, wideLength)) != 0) {
wideLength = string_end - wcs_ptr;
if ((string_end = wmemchr(wcs_ptr, 0, num_chars)) != 0) {
num_chars = string_end - wcs_ptr;
}
} else {
wideLength = wcslen(wcs_ptr);
num_chars = wcslen(wcs_ptr);
}
num_chars = wideLength;
buff_ptr = wcs_ptr;
break;
} else {
@@ -1156,7 +1152,7 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
}
if (format.alternate_form) {
num_chars = (unsigned char)*(const wchar_t*)wcs_ptr;
num_chars = (unsigned char)*buff_ptr;
if (format.precision_specified && num_chars > format.precision) {
num_chars = format.precision;

View File

@@ -88,7 +88,7 @@ namespace nw4r {
PaneList& GetChildList() { return mChildList; }
const math::VEC3& GetTranslate() { return mTranslate; }
#ifdef IPL_SDMEMORY_SET_TRANSLATE_OUT_OF_LINE
#if defined(IPL_SDMEMORY_SET_TRANSLATE_OUT_OF_LINE) || defined(IPL_ADDRESS_MATCHING)
void SetTranslate(const math::VEC3& translate);
#else
void SetTranslate(const math::VEC3& translate) { mTranslate = translate; }

View File

@@ -9,7 +9,7 @@ namespace nw4r {
namespace ut {
class Rect {
public:
#ifdef IPL_SOUND_RECT_OUT_OF_LINE
#if defined(IPL_SOUND_RECT_OUT_OF_LINE) || defined(IPL_SD_CHANNEL_TITLE_CPP)
Rect();
#else
Rect() : left(), top(), right(), bottom() {}
@@ -20,7 +20,7 @@ namespace nw4r {
Rect(f32 l, f32 t, f32 r, f32 b) : left(l), top(t), right(r), bottom(b) {}
#endif
#if !defined(IPL_CONTROLLER_TRIVIAL_RECT_DTOR) && !defined(IPL_MEMORYCARD_BASE_CPP)
#if !defined(IPL_CONTROLLER_TRIVIAL_RECT_DTOR) && !defined(IPL_MEMORYCARD_BASE_CPP) && !defined(IPL_SD_CHANNEL_TITLE_CPP)
~Rect() {}
#endif

View File

@@ -37,7 +37,7 @@ namespace nw4r {
} // namespace detail
template <typename TDerived, typename TBase>
#if defined(IPL_BOARD_OBJECT_EXTERNAL_DYNAMIC_CAST) || defined(IPL_MEMORYCARD_BASE_CPP)
#if defined(IPL_BOARD_OBJECT_EXTERNAL_DYNAMIC_CAST) || defined(IPL_MEMORYCARD_BASE_CPP) || defined(IPL_SD_CHANNEL_TITLE_CPP)
TDerived DynamicCast(TBase* pPtr);
#else
inline TDerived DynamicCast(TBase* pPtr) {

View File

@@ -252,14 +252,17 @@ namespace nw4r {
}
inline void updateSheetFlags(const void* glgrHdr, u32 groupIdx, u16* sheetOffsets, u32 flagsStep, const u32* sheetFlags) {
const GlyphGroups* glgr = (GlyphGroups*)((u8*)glgrHdr + sizeof(BinaryBlockHeader));
for (int sheetI = 0; sheetI < glgr->sheetCount; sheetI++) {
u32 groupBitIdx = sheetI + groupIdx * flagsStep * 8;
const GlyphGroups* glgr = (const GlyphGroups*)((const u8*)glgrHdr + sizeof(BinaryBlockHeader));
int sheetIndex;
u32 groupBitOffset;
u16* sheetOffset = sheetOffsets;
groupBitOffset = groupIdx * flagsStep * 8;
for (sheetIndex = 0; sheetIndex < glgr->sheetCount; sheetOffset++, sheetIndex++) {
u32 groupBitIdx = sheetIndex + groupBitOffset;
const u32* bitBlockPtr = sheetFlags + (groupBitIdx & ~0x1F) / 32;
u32 bitBlock = *(u32*)bitBlockPtr;
u32 bitBlock = *bitBlockPtr;
if (((bitBlock << (groupBitIdx & 0x1F)) & 0x80000000) != 0) {
sheetOffsets[sheetI] = 1;
*sheetOffset = 1;
}
}
}
@@ -268,14 +271,16 @@ namespace nw4r {
const u32* bitBlocksPtr, u32 sheetFlagsSize) {
HeaderedGlyphGroups* pGlgr = (HeaderedGlyphGroups*)glgrHdr;
for (int i = 0; i < pGlgr->inner.sheetCount; i++) {
sheetOffsets[i] = 0;
int i;
u16* sheetOffset;
for (i = 0, sheetOffset = sheetOffsets; i < pGlgr->inner.sheetCount; sheetOffset++, i++) {
*sheetOffset = 0;
}
for (int i = 0; i < pGlgr->inner.nameCount; i++) {
const char* includedGroups = ctx->pIncludedGroups;
u16 offset = pGlgr->inner.nameOffsets[i];
char* name = (char*)((u8*)hdr + offset);
char* name = (char*)(offset + (u32)hdr);
if (*includedGroups != 0) {
if (!ArchiveFontBase::IncludeName(includedGroups, name)) {
continue;
@@ -288,21 +293,23 @@ namespace nw4r {
inline void convertSheetOffsetBooleansToOffsets(const void* glgrHdr, u16* sheetOffsets) {
HeaderedGlyphGroups* pGlgr = (HeaderedGlyphGroups*)glgrHdr;
int i;
u16 glyphIdxOffset = 0;
for (int i = 0; i < pGlgr->inner.sheetCount; i++) {
if (sheetOffsets[i] == 1) {
sheetOffsets[i] = glyphIdxOffset;
u16* sheetOffset;
for (i = 0, sheetOffset = sheetOffsets; i < pGlgr->inner.sheetCount; sheetOffset++, i++) {
if (*sheetOffset == 1) {
*sheetOffset = glyphIdxOffset;
} else {
sheetOffsets[i] = -1;
*sheetOffset = -1;
glyphIdxOffset += pGlgr->inner.sheetGlyphCount;
}
}
}
inline void copyFlagOffsets(ArchiveFontBase::ConstructContext* ctx, u16* sheetOffsetsScratch, u32 workSize, u32 scratchSize) {
inline void copyFlagOffsets(ArchiveFontBase::ConstructContext* ctx, u16* sheetOffsetsScratch, u32 workSize, const u16* sheetOffsetsScratchEnd) {
u8* sheetOffsets = ctx->pWorkCurr;
ctx->pWorkCurr = sheetOffsets + workSize;
memmove(sheetOffsets, sheetOffsetsScratch, scratchSize);
memmove(sheetOffsets, sheetOffsetsScratch, (sheetOffsetsScratchEnd - sheetOffsetsScratch) * sizeof(u16));
ctx->pSheetOffsets = (u16*)sheetOffsets;
}
@@ -311,31 +318,64 @@ namespace nw4r {
// *sheetOffsetsScratch = (u16*)ROUNDDOWN((u32)((u8*)fontData + remWorkSpace) - sheetOffsetsSize, 2);
// return sheetOffsetsSize;
// }
ArchiveFontBase::ConstructState ArchiveFontBase::ConstructOpAnalyzeGLGR(ConstructContext* ctx, CachedStreamReader* reader) {
u32 glgrInnerLen;
HeaderedGlyphGroups* pGlgr;
const ArchiveFontBinaryLayout* font;
u8* glgrEnd;
class FontGlyphGroupsAcs {
public:
explicit FontGlyphGroupsAcs(const ArchiveFontBinaryLayout* font)
: mFont(font), mGroups(&font->glgr) {}
const GlyphGroups& GetGroups() const { return mGroups->inner; }
void SetSheetFlags(u32 flagsStep, const u32* sheetFlags) {
mFlagsStep = flagsStep;
mSheetFlags = sheetFlags;
}
u16 GetNumSheet() const { return mGroups->inner.sheetCount; }
int GetGlyphsPerSheet() const { return mGroups->inner.sheetGlyphCount; }
u16 GetNumSet() const { return mGroups->inner.nameCount; }
const char* GetSetName(int groupIndex) const {
const u16 nameOffset = mGroups->inner.nameOffsets[groupIndex];
return (const char*)(nameOffset + (u32)mFont);
}
bool IsUseSheet(int groupIndex, int sheetIndex) const {
const u32 groupBitIndex = sheetIndex + groupIndex * mFlagsStep * 8;
const u32* bitBlock = mSheetFlags + (groupBitIndex & ~0x1F) / 32;
return ((*bitBlock << (groupBitIndex & 0x1F)) & 0x80000000) != 0;
}
private:
const ArchiveFontBinaryLayout* mFont;
const HeaderedGlyphGroups* mGroups;
u32 mFlagsStep;
const u32* mSheetFlags;
};
ArchiveFontBase::ConstructState ArchiveFontBase::ConstructOpAnalyzeGLGR(ConstructContext* ctx, CachedStreamReader* reader) {
const u32* flagsSheets;
u32 sheetOffsetsSize;
u32 flagsSheetsOff;
u32 glgrInnerLen;
const ArchiveFontBinaryLayout* font;
u16 sheetGlyphCount;
u32 countSheet;
HeaderedGlyphGroups* pGlgr;
u8* glgrEnd;
u32 expectedMaxSize;
u32 dataBlockCount;
u16* sheetOffsetsScratch;
int groupIndex;
font = (ArchiveFontBinaryLayout*)ctx->pWorkCurr;
glgrInnerLen = ctx->mNextBlockHdr.size - sizeof(BinaryBlockHeader);
// Check for RFNA
if (font->hdr.signature != SIGNATURE_FONT_ARCHIVE) {
return CONSTRUCT_STATE_FATAL_ERR;
}
// Check that there's enough data available, and the space to
// put that data
ENSURE_READER_HAS_SIZE(ctx, reader, glgrInnerLen);
ENSURE_WORK_HAS_SIZE(ctx, glgrInnerLen);
expectedMaxSize = ctx->mNextBlockHdr.size + sizeof(BinaryFileHeader);
// Copy the glgr to work
{
pGlgr = (HeaderedGlyphGroups*)&font->glgr;
glgrEnd = (u8*)pGlgr + (u32)ctx->mNextBlockHdr.size;
@@ -348,80 +388,45 @@ namespace nw4r {
return CONSTRUCT_STATE_FATAL_ERR;
}
// Before here is fine (other than regswaps)
// u16 sheetGlyphCount = FORCE_REACCESS_2(font->glgr.inner.sheetGlyphCount, u16); // 0x1C
// u16 dataBlockCount = FORCE_REACCESS_2(font->hdr.dataBlocks, u16); // 0x0E
// FORCE_REACCESS_2(font->glgr.inner.sheetCount, u16);
// return ConstructOpAnalyzeGLGRInner(ctx, font, pGlgr, glgrEnd);
FontGlyphGroupsAcs gg(font);
sheetGlyphCount = gg.GetGlyphsPerSheet();
dataBlockCount = font->hdr.dataBlocks;
countSheet = gg.GetNumSheet();
const u32 stepSheetFlags = detail::CalcSizeFlagSet(countSheet);
flagsSheetsOff = detail::CalcOffsetSheetFlags(gg.GetGroups().nameCount, countSheet, gg.GetGroups().smthCount_0x0a,
gg.GetGroups().smthCount_0x0c);
flagsSheets = (const u32*)((flagsSheetsOff & ~3) + (u32)font);
gg.SetSheetFlags(stepSheetFlags, flagsSheets);
// u32 fontSizeToEndOfGlgr;
u16 countSheet;
u16 sheetGlyphCount, dataBlockCount;
u32 stepSheetFlags;
u32 flagsSheetsOff;
const u32* flagsSheets;
u32 sheetOffsetsSize;
u16* sheetOffsetsScratch;
u32 sheetOffsetsScratchSize;
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;
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);
sheetOffsetsSize = ROUNDUP(countSheet * sizeof(u16), 4);
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;
// }
// Clear sheet offsets scratch
// for (s32 i = 0; i < pGlgr->inner.sheetCount; i++) {
// sheetOffsetsScratch[i] = 0;
// }
{
u16* sheetOffset;
int sheetIndex;
for (sheetIndex = 0, sheetOffset = sheetOffsetsScratch; sheetIndex < gg.GetNumSheet(); sheetOffset++, sheetIndex++) {
*sheetOffset = 0;
}
for (groupIndex = 0; groupIndex < gg.GetNumSet(); groupIndex++) {
const char* includedGroups = ctx->pIncludedGroups;
const char* name = gg.GetSetName(groupIndex);
if (*includedGroups && !ArchiveFontBase::IncludeName(includedGroups, name)) {
continue;
}
for (int sheetIndex = 0; sheetIndex < gg.GetNumSheet(); sheetIndex++) {
if (gg.IsUseSheet(groupIndex, sheetIndex)) {
sheetOffsetsScratch[sheetIndex] = 1;
}
}
}
}
// for (s32 i = 0; i < pGlgr->inner.nameCount; i++) {
// // const char* includedGroups = ctx->pIncludedGroups;
// u16 offset = pGlgr->inner.nameOffsets[i];
// const char* name = (char*)((u8*)font + offset);
// if (*ctx->pIncludedGroups != 0) {
// if (!ArchiveFontBase::IncludeName(ctx->pIncludedGroups, name)) {
// continue;
// }
// }
// updateSheetFlags(pGlgr, i, sheetOffsetsScratch, stepSheetFlags, flagsSheets);
// }
setSheetOffsetBooleans(ctx, pGlgr, font, sheetOffsetsScratch, flagsSheets, stepSheetFlags);
// u16 glyphIdxOffset = 0;
// for (s32 i = 0; i < pGlgr->inner.sheetCount; i++) {
// if (sheetOffsetsScratch[i] == 1) {
// sheetOffsetsScratch[i] = glyphIdxOffset;
// } else {
// sheetOffsetsScratch[i] = -1;
// glyphIdxOffset += pGlgr->inner.sheetGlyphCount;
// }
// }
convertSheetOffsetBooleansToOffsets(pGlgr, sheetOffsetsScratch);
sheetOffsetsScratchSize = (u32)countSheet << 1;
sheetOffsetsScratchSize += (sheetOffsetsScratchSize >> 31);
sheetOffsetsScratchSize &= ~1;
copyFlagOffsets(ctx, sheetOffsetsScratch, sheetOffsetsSize, sheetOffsetsScratchSize);
copyFlagOffsets(ctx, sheetOffsetsScratch, sheetOffsetsSize, sheetOffsetsScratch + (u16)countSheet);
ctx->mSheetCount = countSheet;
ctx->mGlyphsPerSheet = sheetGlyphCount;

View File

@@ -130,11 +130,11 @@ typedef struct WWWProtocolData {
typedef struct WWWIMEData {
u32 imeID; // 0x00
const char* text; // 0x04
u32 unk_0x08;
u32 unk_0x0C;
u32 unk_0x10;
u32 unk_0x14;
u32 unk_0x18;
u32 creationDataA;
u32 creationDataB;
u32 creationDataC;
u32 creationDataD;
u32 creationDataE;
u32 maxLength; // 0x1C
} WWWIMEData;
@@ -153,7 +153,7 @@ typedef union {
typedef struct WWWJSPluginValue {
s32 ty;
u8 unk_0x04[4];
u8 reserved[4];
WWWJSPluginValueData data;
} WWWJSPluginValue;
@@ -171,12 +171,12 @@ typedef struct JSCallbackSet {
typedef struct WWWJSCap {
const char** name;
int unk_0x04;
int capabilityWord;
JSGetterSetter getter;
void* unk_0x0C;
void* unk_0x10;
void* unk_0x14;
void* unk_0x18;
void* capabilityDataA;
void* capabilityDataB;
void* capabilityDataC;
void* capabilityDataD;
JSAllowAccess allowAccess;
} WWWJSCap;

View File

@@ -63,7 +63,7 @@ typedef struct {
u8 mcuYRem; // 0x0F
u16 mcuYCount; // 0x10
u16 mcuXCount2; // 0x12
u32 unk_0x14;
u32 mcuTotal; // 0x14
u8 remX; // 0x18
u8 remY; // 0x19
u8 compCount; // 0x1A
@@ -142,7 +142,7 @@ struct TMCCJPEGDecWork_t {
u8 mcuYRem; // 0x17FF
u16 mcuYCount; // 0x1800
u16 mcuXCount2; // 0x1802
u32 unk_0x1804;
u32 mcuTotal; // 0x1804
u8 remX; // 0x1808
u8 remY; // 0x1809
u8 compCount; // 0x180A
@@ -192,7 +192,7 @@ typedef struct {
u8 count; // 0x0C
} TMCHuffParam;
s32 TMCJPEGDEC_make_huffdec(const u8* dht_spec, const u8* tbl, TMCHuffParam* hp);
s32 TMCJPEGDEC_make_huffdec(const u8* dht_spec, u8* tbl, TMCHuffParam* hp);
void TMCJPEGDEC_set_HuffmanTable(TMCHuffParam* tbl, s32 tblType, s32 tblID, TMCUnknownInfo* work);
s32 TMCJPEGDEC_decompmcu(u32 maxMCU, u32 mcuCount, TMCCJPEGDecWork* work, void* buf);

View File

@@ -15,55 +15,8 @@ static void readHuffmanLimit(const TMCHuffmanEntry* entries, TMCHuffmanEntry* li
limit->symbol = entries->symbol;
}
static inline s32 decodeLongHuffman(s32 bitCount, const TMCHuffmanEntry* table, const u8* symbols, TMCCJPEGDecWork* work, TMCHuffmanEntry* limit, TMCHuffmanEntry* decoded) {
u32 bitData;
u32 code;
u32 length;
const TMCHuffmanEntry* entry;
if (bitCount <= 17) {
s32 result = TMCJPEGDEC_load_buff(work);
if (result < 0) {
return result;
}
}
bitCount = work->bitCount;
bitData = work->bitBuf;
bitCount -= 9;
code = (bitData >> bitCount) & 0x1FF;
work->bitCount = bitCount;
length = 9;
entry = table + 9;
goto read_entry;
while (1) {
length++;
entry++;
if (length > 16) {
return TMCC_ERROR_OVERFLOW;
}
bitCount = work->bitCount;
code <<= 1;
bitData = work->bitBuf;
bitCount--;
work->bitCount = bitCount;
code |= (bitData >> bitCount) & 1;
read_entry:
{
readHuffmanLimit(entry, limit);
*decoded = *limit;
if (code > (u32)decoded->bitLength) {
continue;
}
{
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, TMCHuffmanEntry* limit, TMCHuffmanEntry* decoded) {
static inline s32 decodeLongHuffman(s32 bitCount, u32* huff_tbl, u8* symbols, TMCCJPEGDecWork* work, TMCHuffmanEntry* limit, TMCHuffmanEntry* decoded) {
u16* entry;
u32 bitData;
u32 code;
u32 length;
@@ -75,16 +28,16 @@ static inline s32 decodeACHuffman(s32 bitCount, const TMCHuffmanEntry* entry, co
}
}
bitCount = work->bitCount;
entry = (u16*)(huff_tbl + 9);
bitData = work->bitBuf;
length = 9;
bitCount -= 9;
code = (bitData >> bitCount) & 0x1FF;
work->bitCount = bitCount;
length = 9;
entry += 9;
goto read_entry;
while (1) {
length++;
entry++;
entry += 2;
if (length > 16) {
return TMCC_ERROR_OVERFLOW;
}
@@ -96,28 +49,81 @@ static inline s32 decodeACHuffman(s32 bitCount, const TMCHuffmanEntry* entry, co
code |= (bitData >> bitCount) & 1;
read_entry:
{
readHuffmanLimit(entry, limit);
limit->bitLength = entry[0];
limit->symbol = entry[1];
*decoded = *limit;
if (code > (u32)decoded->bitLength) {
continue;
}
{
u32 relativeCode = code - entry->bitLength;
u32 symbolIndex = relativeCode + entry->symbol;
u32 relativeCode = code - limit->bitLength;
u32 symbolIndex = relativeCode + limit->symbol;
return symbols[symbolIndex & 0xFF];
}
}
}
}
static inline s32 decodeACHuffman(s32 bitCount, u32* huff_tbl, u8* symbols, TMCCJPEGDecWork* work, TMCHuffmanEntry* limit, TMCHuffmanEntry* decoded) {
u16* entry;
u32 bitData;
u32 code;
u32 length;
if (bitCount <= 17) {
s32 result = TMCJPEGDEC_load_buff(work);
if (result < 0) {
return result;
}
}
bitCount = work->bitCount;
entry = (u16*)(huff_tbl + 9);
bitData = work->bitBuf;
length = 9;
bitCount -= 9;
code = (bitData >> bitCount) & 0x1FF;
work->bitCount = bitCount;
goto read_entry;
while (1) {
length++;
entry += 2;
if (length > 16) {
return TMCC_ERROR_OVERFLOW;
}
bitCount = work->bitCount;
code <<= 1;
bitData = work->bitBuf;
bitCount--;
work->bitCount = bitCount;
code |= (bitData >> bitCount) & 1;
read_entry:
{
limit->bitLength = entry[0];
limit->symbol = entry[1];
*decoded = *limit;
if (code > (u32)decoded->bitLength) {
continue;
}
{
u32 relativeCode = code - limit->bitLength;
u32 symbolIndex = relativeCode + limit->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 dcDecoded;
TMCHuffmanEntry dcLimit;
TMCHuffmanEntry acDecoded;
TMCHuffmanEntry acLimit;
s32 zz;
const u8* zztbl;
u8* huff_sym;
const TMCHuffmanEntry* ac_fast;
u16* ac_fast;
s32 idx;
u32* huff_tbl;
s32 bit_pos;
@@ -128,13 +134,13 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
TMCHuffmanEntry acEntry;
s32 extra;
s32 t;
s32 zz;
s32 q;
const TMCHuffmanEntry* dc_fast;
const u8* zztbl;
u16* dc_fast;
s32* conv_row;
conv_row = (s32*)conv_row_ptr;
bit_pos = work->bitCount;
dc_fast = (const TMCHuffmanEntry*)work->pDCFast;
dc_fast = work->pDCFast;
if (bit_pos <= 8) {
r = TMCJPEGDEC_load_buff(work);
@@ -146,7 +152,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
bit_pos = work->bitCount;
bit_data = work->bitBuf;
{
dcEntry = readHuffmanEntry(dc_fast, (bit_data >> (bit_pos - 8)) & 0xFF);
dcEntry = readHuffmanEntry((const TMCHuffmanEntry*)dc_fast, (bit_data >> (bit_pos - 8)) & 0xFF);
r = dcEntry.bitLength;
extra = dcEntry.symbol;
}
@@ -157,30 +163,28 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
} else {
huff_sym = work->pDCHuffSym;
huff_tbl = work->pDCHuffTbl;
r = decodeLongHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work, &dcLimit, &dcDecoded);
r = decodeLongHuffman(bit_pos, huff_tbl, huff_sym, work, &dcLimit, &dcDecoded);
if (r < 0) {
return r;
}
}
blk0 = ((s32*)conv_row_ptr)[0];
blk0 = conv_row[0];
if (r != 0) {
bit_pos = work->bitCount;
if (bit_pos <= r) {
s32 load_ret = TMCJPEGDEC_load_buff(work);
if (load_ret < 0) {
if (work->bitCount <= r) {
s32 load_ret;
if (load_ret = TMCJPEGDEC_load_buff(work), load_ret < 0) {
return load_ret;
}
}
bit_pos = work->bitCount;
bit_data = work->bitBuf;
tmp = 1 << r;
extra = tmp - 1;
bit_pos -= r;
tmp = 1UL << r;
bit_pos = work->bitCount - r;
work->bitCount = bit_pos;
bit_data = work->bitBuf;
extra = tmp - 1;
extra = extra & (bit_data >> bit_pos);
if (((s32)tmp >> 1) > extra) {
extra -= tmp - 1;
extra -= (tmp - 1);
}
dc_predict_row_ptr[0] += extra;
}
@@ -188,9 +192,12 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
*block = dc_predict_row_ptr[0] * blk0;
{
ac_fast = (const TMCHuffmanEntry*)work->pACFast;
huff_tbl = work->pACHuffTbl;
huff_sym = work->pACHuffSym;
u32* ac_huff_tbl;
u8* ac_huff_sym;
ac_fast = work->pACFast;
ac_huff_tbl = work->pACHuffTbl;
ac_huff_sym = work->pACHuffSym;
memset(block + 1, 0, 0xFC);
@@ -206,7 +213,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
zztbl = TMCJPEGDEC_Zigzag_data;
bit_data = work->bitBuf;
t = bit_pos - 8;
acEntry = readHuffmanEntry(ac_fast, (bit_data >> t) & 0xFF);
acEntry = readHuffmanEntry((const TMCHuffmanEntry*)ac_fast, (bit_data >> t) & 0xFF);
do {
s32 ac_thresh = acEntry.bitLength;
@@ -217,7 +224,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, &acLimit, &acDecoded);
r = decodeACHuffman(bit_pos, ac_huff_tbl, ac_huff_sym, work, &acLimit, &acDecoded);
if (r < 0) {
return r;
}
@@ -241,19 +248,17 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
return r;
}
}
bit_pos = work->bitCount;
tmp = 1 << t;
bit_data = work->bitBuf;
extra = tmp - 1;
bit_pos -= t;
tmp = 1UL << t;
bit_pos = work->bitCount - t;
work->bitCount = bit_pos;
bit_data = work->bitBuf;
extra = (tmp - 1) & (bit_data >> bit_pos);
t = bit_pos - 8;
extra = extra & (bit_data >> bit_pos);
q = ((s32*)conv_row_ptr)[(u8)zz];
acEntry = readHuffmanEntry(ac_fast, (bit_data >> t) & 0xFF);
q = conv_row[(u8)zz];
acEntry = readHuffmanEntry((const TMCHuffmanEntry*)ac_fast, (bit_data >> t) & 0xFF);
if (((s32)tmp >> 1) > extra) {
extra -= tmp - 1;
extra -= (tmp - 1);
}
block[(u8)zz] = extra * q;
@@ -274,7 +279,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
bit_pos = work->bitCount;
t = bit_pos - 8;
tmp = ((bit_data >> t) & 0xFF) << 2;
acEntry = readHuffmanEntry(ac_fast, tmp >> 2);
acEntry = readHuffmanEntry((const TMCHuffmanEntry*)ac_fast, tmp >> 2);
idx += 16;
}

View File

@@ -1,79 +1,35 @@
#include <stddef.h>
#include <tmc_jpeg_internal.h>
#ifdef __MWERKS__
asm s32 TMCJPEGDEC_init_buff_thumbnail(register TMCCJPEGDecWork* work, register u8* dst, register u8* src) {
nofralloc
lwz r0, 4(r5)
cmpwi r0, 0
bne _init_buff_thumbnail_have_src1
li r3, -1
blr
_init_buff_thumbnail_have_src1:
lwz r0, 8(r5)
cmpwi r0, 0
bne _init_buff_thumbnail_have_src2
li r3, -1
blr
_init_buff_thumbnail_have_src2:
lwz r7, 0(r5)
li r0, 0
stw r7, 0x18(r4)
lwz r6, 4(r5)
stw r6, 0x1c(r4)
lwz r6, 8(r5)
stw r6, 0x20(r4)
lwz r6, 0xc(r5)
stw r6, 0x24(r4)
lwz r5, 0x10(r5)
stw r5, 0x28(r4)
stw r7, 8(r4)
lwz r6, 0x674(r3)
lwz r5, 0x66c(r3)
add r5, r6, r5
stw r5, 0xc(r4)
lwz r6, 0x670(r3)
li r3, 0
add r5, r5, r6
stw r0, 0x20(r4)
subi r0, r5, 0x22
stw r5, 0x10(r4)
stw r0, 0x14(r4)
blr
}
#else
s32 TMCJPEGDEC_init_buff_thumbnail(TMCCJPEGDecWork* work, u8* dst, u8* src) {
u32* src32;
u32* dst32;
u32 tmp;
TMCCJPEGDecWork* buffer = (TMCCJPEGDecWork*)dst;
const TMCCJPEGDecInitParam* input = (const TMCCJPEGDecInitParam*)(src - offsetof(TMCCJPEGDecInitParam, pBuf2));
s32 endAddress;
u8* start;
const TMCCJPEGDecExifData* exif = (const TMCCJPEGDecExifData*)work;
src32 = (u32*)src;
dst32 = (u32*)dst;
if (src32[1] == 0) {
if (input->buf2Size == 0) {
return -1;
}
if (src32[2] == 0) {
if (input->dataSize == 0) {
return -1;
}
tmp = src32[0];
dst32[6] = src32[0];
dst32[7] = src32[1];
dst32[8] = src32[2];
dst32[9] = src32[3];
dst32[10] = src32[4];
dst32[2] = tmp;
dst32[3] = work->thumbHuffSize[2] + work->thumbHuffSize[0];
dst32[4] = work->thumbHuffSize[1] + dst32[3];
dst32[5] = dst32[4] - 0x22;
dst32[8] = 0;
start = input->pBuf2;
buffer->pBufOrg = start;
buffer->bufLen = input->buf2Size;
buffer->remaining = input->dataSize;
buffer->pCallback = input->pCallback;
buffer->pCbCtx = input->pContext;
buffer->pBufStart = start;
buffer->pBufCur = exif->thumbnailData + exif->thumbnailOffset;
endAddress = exif->thumbnailLength;
endAddress = (u32)buffer->pBufCur + endAddress;
buffer->remaining = 0;
buffer->pBufEnd = (u8*)endAddress;
buffer->pBufMark = (u8*)((u32)endAddress - 0x22);
return 0;
}
#endif
s32 TMCJPEGDEC_init_buff(TMCCJPEGDecWork* work) {
work->bitBuf = 0;

View File

@@ -28,36 +28,36 @@ static s32 scalingClampU8(s32 value) {
void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigzag) {
s32 tmp[64];
s32* dst;
s32 done;
s32 iter;
s32 d;
s32 t;
s32 i;
s32 e;
s32 y;
s32 b2;
s32 b3;
s32 b1;
s32 b4;
s32 b5;
s32 b6;
s32 b7;
s32 v;
s32 n;
s32 m;
s32 a;
s32 d;
s32 done;
s32 z;
s32 o;
s32 v;
s32 p;
s32 p_part;
s32 t;
s32 m_part;
s32 u;
s32 r;
s32 n;
s32 y;
s32 o;
s32 x;
s32 x_factor;
s32 z_factor;
s32 m_part;
s32 iter;
s32 q;
s32 w;
s32 x;
s32 b1;
s32 e;
s32 b3;
r = (zigzag >> 4) * 8;
dst = tmp;
@@ -93,17 +93,19 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
} else {
s32 oddLowSum;
s32 oddHighSum;
s32 oddLowDifference;
s32 oddHighDifference;
s32 dcValue;
t = b2 - b6;
oddLowSum = b5 + b3;
b5 = b5 - b3;
oddLowDifference = b5 - b3;
oddHighSum = b1 + b7;
b1 = b1 - b7;
oddHighDifference = b1 - b7;
u = b6 + b2;
t = t * 0xB5 >> 8;
x_factor = oddHighSum - oddLowSum;
z_factor = b5 + b1;
z_factor = oddLowDifference + oddHighDifference;
dcValue = block[0];
a = dcValue - b4;
x = x_factor * 0xB5 >> 8;
@@ -113,14 +115,14 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
z = z_factor * 0x62 >> 8;
w = d + u;
y = d - u;
m_part = b1 * 0x14E >> 8;
m_part = oddHighDifference * 0x14E >> 8;
e = a - t;
m = m_part - z;
oddLowSum += m;
n = oddHighSum + oddLowSum;
o = x + m;
dst[0] = w + n;
p_part = b5 * 0x8B;
p_part = oddLowDifference * 0x8B;
dst[7] = w - n;
p_part >>= 8;
dst[1] = v + o;
@@ -225,7 +227,7 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
void TMCJPEGDEC_IdctBlock_Col(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigzag) {
s32 tmp[64];
s32* dst;
s32 done;
s32 a;
s32 iter;
s32 d;
s32 b1;
@@ -237,14 +239,14 @@ void TMCJPEGDEC_IdctBlock_Col(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigza
s32 b7;
s32 v;
s32 r;
s32 a;
s32 done;
s32 i;
s32 m;
s32 n;
s32 o;
s32 x;
s32 q;
s32 y;
s32 e;
s32 u;
s32 w;
s32 p;
@@ -254,7 +256,7 @@ void TMCJPEGDEC_IdctBlock_Col(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigza
s32 z_factor;
s32 m_part;
s32 p_part;
s32 e;
s32 y;
if (zigzag == 0x11) {
s32 val;

View File

@@ -3,292 +3,47 @@
extern void* memcpy(void* dest, const void* src, unsigned long size);
extern void* memset(void* dest, int value, unsigned long size);
#ifdef __MWERKS__
asm s32 TMCJPEGDEC_make_huffdec(register const u8* dht, register const u8* tb, register TMCHuffParam* hp) {
nofralloc
stwu r1, -0x840(r1)
mflr r0
li r6, 1
li r7, 1
stw r0, 0x844(r1)
stmw r20, 0x810(r1)
mr r26, r3
mr r27, r4
addi r4, r1, 0x408
addi r3, r3, 1
lwz r31, 0(r5)
lwz r30, 4(r5)
lwz r29, 8(r5)
lbz r28, 0xc(r5)
li r5, 0
_make_huffdec_count_loop:
lbz r0, 0(r3)
cmpw r7, r0
ble _make_huffdec_count_store
addi r6, r6, 1
li r7, 1
cmpwi r6, 0x10
addi r3, r3, 1
ble _make_huffdec_count_loop
slwi r0, r5, 2
addi r7, r1, 0x408
li r3, 0
stwx r3, r7, r0
b _make_huffdec_count_done
_make_huffdec_count_store:
addi r5, r5, 1
stw r6, 0(r4)
cmpw r5, r28
addi r4, r4, 4
ble _make_huffdec_count_next
li r3, -0x40
b _make_huffdec_return
_make_huffdec_count_next:
addi r7, r7, 1
b _make_huffdec_count_loop
_make_huffdec_count_done:
lwz r0, 0x408(r1)
addi r6, r1, 8
li r9, 0
li r8, 0
clrlwi r10, r0, 24
li r4, 1
b _make_huffdec_values_loop
_make_huffdec_values_inner:
clrlwi r5, r10, 24
slwi r3, r8, 2
b _make_huffdec_values_store_check
_make_huffdec_values_store:
clrlwi r0, r9, 16
addi r7, r7, 4
stwx r0, r6, r3
addi r8, r8, 1
addi r3, r3, 4
addi r9, r9, 1
_make_huffdec_values_store_check:
lwz r0, 0(r7)
clrlwi r0, r0, 24
cmplw r5, r0
beq _make_huffdec_values_store
clrlwi r3, r9, 16
slw r0, r4, r5
cmpw r3, r0
blt _make_huffdec_values_next
li r3, -0x40
b _make_huffdec_return
_make_huffdec_values_next:
clrlslwi r9, r9, 17, 1
addi r10, r10, 1
_make_huffdec_values_loop:
lwz r0, 0(r7)
cmpwi r0, 0
bne _make_huffdec_values_inner
mr r3, r30
li r4, 0
li r5, 0x44
bl memset
addi r4, r1, 0x408
addi r5, r1, 8
li r6, 0
mtctr r28
cmpwi r28, 0
ble _make_huffdec_valptr_done
_make_huffdec_valptr_loop:
lwz r0, 0(r4)
cmplwi r0, 0x10
bgt _make_huffdec_valptr_next
slwi r3, r0, 2
lwz r0, 0(r5)
add r3, r30, r3
sth r6, 2(r3)
sth r0, 0(r3)
_make_huffdec_valptr_next:
addi r4, r4, 4
addi r5, r5, 4
addi r6, r6, 1
bdnz _make_huffdec_valptr_loop
_make_huffdec_valptr_done:
addi r4, r1, 8
addi r12, r26, 1
li r6, 0
li r7, 1
lis r3, 0x8000
_make_huffdec_table_loop:
subfic r0, r7, 8
li r8, 1
slw r5, r8, r0
b _make_huffdec_table_count
_make_huffdec_table_store:
lwz r10, 0(r4)
cmpwi cr1, r5, 0
mr r9, r5
slw r10, r10, r0
ble cr1, _make_huffdec_table_next
cmpwi r5, 8
ble _make_huffdec_table_short
li r21, 0
blt cr1, _make_huffdec_table_short_check
addi r11, r3, 1
cmpw r5, r11
blt _make_huffdec_table_short_check
li r21, 1
_make_huffdec_table_short_check:
cmpwi r21, 0
beq _make_huffdec_table_short
subi r11, r5, 1
slwi r26, r10, 2
srwi r11, r11, 3
mtctr r11
cmpwi r5, 8
ble _make_huffdec_table_short
_make_huffdec_table_unrolled:
sthx r7, r31, r26
add r25, r31, r26
addi r11, r10, 1
addi r22, r10, 2
lbzx r24, r27, r6
slwi r21, r11, 2
addi r11, r10, 3
addi r30, r10, 6
sth r24, 2(r25)
slwi r23, r11, 2
addi r11, r10, 4
add r20, r31, r21
sthx r7, r31, r21
slwi r24, r11, 2
addi r11, r10, 5
slwi r22, r22, 2
lbzx r21, r27, r6
slwi r25, r11, 2
addi r11, r10, 7
slwi r30, r30, 2
sth r21, 2(r20)
add r20, r31, r23
add r21, r31, r24
slwi r11, r11, 2
sthux r7, r22, r31
add r23, r31, r25
add r25, r31, r11
add r24, r31, r30
lbzx r11, r27, r6
addi r10, r10, 8
addi r26, r26, 0x20
subi r9, r9, 8
sth r11, 2(r22)
sth r7, 0(r20)
lbzx r11, r27, r6
sth r11, 2(r20)
sth r7, 0(r21)
lbzx r11, r27, r6
sth r11, 2(r21)
sth r7, 0(r23)
lbzx r11, r27, r6
sth r11, 2(r23)
sthx r7, r31, r30
lbzx r11, r27, r6
sth r11, 2(r24)
sth r7, 0(r25)
lbzx r11, r27, r6
sth r11, 2(r25)
bdnz _make_huffdec_table_unrolled
_make_huffdec_table_short:
slwi r10, r10, 2
add r11, r31, r10
mtctr r9
cmpwi r9, 0
ble _make_huffdec_table_next
_make_huffdec_table_short_loop:
sth r7, 0(r11)
subi r9, r9, 1
lbzx r10, r27, r6
sth r10, 2(r11)
addi r11, r11, 4
bdnz _make_huffdec_table_short_loop
_make_huffdec_table_next:
addi r8, r8, 1
addi r4, r4, 4
addi r6, r6, 1
_make_huffdec_table_count:
lbz r9, 0(r12)
cmpw r8, r9
ble _make_huffdec_table_store
addi r7, r7, 1
addi r12, r12, 1
cmpwi r7, 8
ble _make_huffdec_table_loop
mr r3, r29
mr r4, r27
mr r5, r28
bl memcpy
li r3, 0
_make_huffdec_return:
lmw r20, 0x810(r1)
lwz r0, 0x844(r1)
mtlr r0
addi r1, r1, 0x840
blr
}
#else
s32 TMCJPEGDEC_make_huffdec(const u8* dht, const u8* tb, TMCHuffParam* hp) {
s32 TMCJPEGDEC_make_huffdec(const u8* dht, u8* tb, TMCHuffParam* hp) {
typedef struct {
u16 length;
u16 symbol;
} TMCHuffEntry;
u32 huffCount[256];
u32 huffVal[256];
u32* huffTable;
u32* destTable;
u8* valptr;
u32 count;
TMCHuffEntry* huffTable;
TMCHuffEntry* valptr;
u8* symbols;
s32 count;
{
u32* dest = huffCount;
s32 bit_len = 1;
s32 remaining = 1;
const u8* bits = dht + 1;
s32 sym_idx;
const u8* bits;
u32* sizes;
s32 index;
s32 bitLength;
s32 remaining;
huffTable = hp->huffTable;
valptr = hp->valptr;
destTable = hp->maxCode;
sizes = huffCount;
bitLength = 1;
remaining = 1;
bits = dht + 1;
huffTable = (TMCHuffEntry*)hp->huffTable;
valptr = (TMCHuffEntry*)hp->valptr;
symbols = (u8*)hp->maxCode;
count = hp->count;
sym_idx = 0;
index = 0;
for (;;) {
s32 cnt = *bits;
if (remaining > cnt) {
bit_len++;
if (remaining > *bits) {
bitLength++;
remaining = 1;
bits++;
if (bit_len > 16) {
huffCount[sym_idx] = 0;
if (bitLength > 16) {
huffCount[index] = 0;
break;
}
} else {
*dest = bit_len;
dest++;
sym_idx++;
if (sym_idx > (s32)count) {
*sizes++ = bitLength;
index++;
if (index > count) {
return -0x40;
}
remaining++;
@@ -297,76 +52,73 @@ s32 TMCJPEGDEC_make_huffdec(const u8* dht, const u8* tb, TMCHuffParam* hp) {
}
{
s32 sv_idx = 0;
s32 i = 0;
u32 cur = huffCount[0] & 0xFF;
u32* sizes = huffCount;
s32 index;
u16 code;
u8 size;
while (cur != 0) {
while (i < (s32)count && (huffCount[i] & 0xFF) == cur) {
huffVal[i] = sv_idx & 0xFFFF;
sv_idx++;
i++;
code = 0;
index = 0;
size = huffCount[0];
while (*sizes != 0) {
while (size == (u8)*sizes) {
sizes++;
huffVal[index++] = code;
code++;
}
if (sv_idx > (1 << cur)) {
if (code >= (1 << size)) {
return -0x40;
}
sv_idx <<= 1;
cur = huffCount[i] & 0xFF;
code <<= 1;
size++;
}
}
memset(valptr, 0, 0x44);
{
s32 i;
for (i = 0; i < (s32)count; i++) {
u32 bl = huffCount[i];
if (bl <= 16) {
valptr[bl] = (i << 16) | (huffVal[i] & 0xFFFF);
s32 index;
for (index = 0; index < count; index++) {
u32 length = huffCount[index];
if (length <= 16) {
valptr[length].symbol = index;
valptr[length].length = huffVal[index];
}
}
}
{
const u8* bits_ptr = dht + 1;
u32* hv_ptr = huffVal;
s32 sym = 0;
u32 bl;
u32 cnt;
u32 step;
u32 n;
u32 code;
u32 base;
s32 kk;
for (bl = 1; bl <= 8; bl++) {
cnt = *bits_ptr;
step = 1 << (8 - bl);
for (n = 0; n < cnt; n++) {
code = *hv_ptr;
hv_ptr++;
base = code << (8 - bl);
for (kk = 0; kk < (s32)step; kk++) {
((u16*)huffTable)[(base + kk) * 2] = bl;
((u16*)huffTable)[(base + kk) * 2 + 1] = tb[sym];
u32* codes;
s32 step;
s32 index;
s32 bitLength;
s32 entry;
s32 left;
s32 base;
codes = huffVal;
index = 0;
for (bitLength = 1; bitLength <= 8; bitLength++) {
s32 shift = 8 - bitLength;
entry = 1;
step = entry << shift;
while (entry <= dht[bitLength]) {
base = *codes << shift;
for (left = step; left > 0; left--) {
huffTable[base].length = bitLength;
huffTable[base].symbol = tb[index];
base++;
}
sym++;
entry++;
codes++;
index++;
}
bits_ptr++;
}
}
memcpy(destTable, tb, count);
memcpy(symbols, tb, count);
return 0;
}
#endif
void TMCJPEGDEC_set_HuffmanTable(TMCHuffParam* tbl, s32 tblType, s32 tblID, TMCUnknownInfo* info) {
TMCCJPEGDecWork* work = (TMCCJPEGDecWork*)info;

View File

@@ -3,7 +3,7 @@
#include <tmc_jpeg_internal.h>
static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData* pInfo);
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, const u8* entry);
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, u8* entry);
static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, const u8* entry);
static s32 TMCJPEGDEC_ThumbnailCheck(TMCCJPEGDecInitParam* param, TMCCJPEGDecExifInfo* info, u32 totalSize);
@@ -241,14 +241,20 @@ _error:
return -2;
}
static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData* pInfo) {
static s32 TMCJPEGDEC_exif_parse(const u8* entries, u32 size, TMCCJPEGDecExifData* pInfo) {
u16 byteOrder;
u32 ifdOffset;
const u8* entries;
const u8* data = entries;
const u8* exifEntries;
u32 exifCount;
u16 exifIndex;
const u8* ifd1Entries;
u32 ifd1Count;
u16 ifd1Index;
u16 remaining;
u16 index;
s32 entriesSize;
u16 count;
u32 count;
pInfo->thumbnailData = (u8*)data;
pInfo->dataEnd = (u8*)data + size;
pInfo->nextIfdOffset = 0;
@@ -273,17 +279,16 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
return -161;
}
count = readExifU16(entries, byteOrder);
entriesSize = count * 12;
entries += 2;
remaining -= 2;
if (remaining < entriesSize) {
if (remaining < (s32)count * 12) {
return -161;
}
for (index = 0; index < count; index++) {
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, entries);
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, (u8*)entries);
entries += 12;
}
remaining -= entriesSize;
remaining -= (s32)count * 12;
if (remaining < 4) {
return -161;
}
@@ -296,21 +301,20 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
return -161;
}
{
entries = data + ifdOffset;
ifd1Entries = data + ifdOffset;
remaining = size - (u16)ifdOffset;
if (remaining < 2) {
return -161;
}
count = readExifU16(entries, byteOrder);
entriesSize = count * 12;
entries += 2;
ifd1Count = readExifU16(ifd1Entries, byteOrder);
ifd1Entries += 2;
remaining -= 2;
if (remaining < entriesSize) {
if (remaining < (s32)ifd1Count * 12) {
return -161;
}
for (index = 0; index < count; index++) {
TMCJPEGDEC_IFD1_tag_parse(pInfo, byteOrder, entries);
entries += 12;
for (ifd1Index = 0; ifd1Index < ifd1Count; ifd1Index++) {
TMCJPEGDEC_IFD1_tag_parse(pInfo, byteOrder, ifd1Entries);
ifd1Entries += 12;
}
}
ifdOffset = pInfo->nextIfdOffset;
@@ -318,32 +322,31 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
return -161;
}
{
entries = data + ifdOffset;
exifEntries = data + ifdOffset;
remaining = size - (u16)ifdOffset;
if (remaining < 2) {
return -161;
}
count = readExifU16(entries, byteOrder);
entriesSize = count * 12;
entries += 2;
exifCount = readExifU16(exifEntries, byteOrder);
exifEntries += 2;
remaining -= 2;
if (remaining < entriesSize) {
if (remaining < (s32)exifCount * 12) {
return -161;
}
for (index = 0; index < count; index++) {
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, entries);
entries += 12;
for (exifIndex = 0; exifIndex < exifCount; exifIndex++) {
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, (u8*)exifEntries);
exifEntries += 12;
}
}
return 0;
}
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, const u8* entry) {
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, u8* entry) {
s32 tag;
u16 type;
u32 type;
tag = readU16(entry, byteOrder);
type = readU16(entry + 2, byteOrder);
tag = readExifU16(entry, byteOrder);
type = readExifU16(entry + 2, byteOrder);
switch (tag) {
case 0x0103:
@@ -366,7 +369,7 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
return;
}
pInfo->xResNum = readU32(p, byteOrder);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
p = pInfo->thumbnailData + (offset + 4);
if (pInfo->thumbnailData > p) {
return;
}
@@ -386,7 +389,7 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
return;
}
pInfo->yResNum = readU32(p, byteOrder);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
p = pInfo->thumbnailData + (offset + 4);
if (pInfo->thumbnailData > p) {
return;
}
@@ -501,6 +504,10 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
case 0x8769:
case 0x9000:
case 0x9101:
case 0x011C:
case 0xA000:
case 0xA001:
case 0xA002:
case 0xA003: {
break;
}
@@ -516,7 +523,7 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
return;
}
pInfo->xResNumIfd1 = readU32(p, byteOrder);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
p = pInfo->thumbnailData + (offset + 4);
if (pInfo->thumbnailData > p) {
return;
}
@@ -538,7 +545,7 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
return;
}
pInfo->planarConfigIfd1 = readU32(p, byteOrder);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
p = pInfo->thumbnailData + (offset + 4);
if (pInfo->thumbnailData > p) {
return;
}

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;

File diff suppressed because it is too large Load Diff

View File

@@ -4,219 +4,21 @@ extern void* memset(void* dest, int value, unsigned long size);
static s32 TMCJPEGDEC_vl_decode_rc(u32* huff_tbl, u8* huff_sym, TMCCJPEGDecWork* work);
#ifdef __MWERKS__
asm s32 TMCJPEGDEC_decode_iquant_rc(register s32* block, register u8* conv_row_ptr, register u32* dc_predict_row_ptr, register TMCCJPEGDecWork* work) {
nofralloc
static inline s32 readCoefficientBits(TMCCJPEGDecWork* work, s32 count) {
u32 range = 1UL << count;
u32 mask = range - 1;
s32 value;
stwu r1, -0x40(r1)
mflr r0
stw r0, 0x44(r1)
stmw r21, 0x14(r1)
mr r22, r3
mr r23, r4
mr r25, r5
mr r24, r6
lwz r0, 4(r6)
lwz r21, 0x498(r6)
cmpwi r0, 8
bgt _decode_iquant_rc_have_dc_bits
mr r3, r24
bl TMCJPEGDEC_load_buff
cmpwi r3, 0
bge _decode_iquant_rc_have_dc_bits
b _decode_iquant_rc_return
_decode_iquant_rc_have_dc_bits:
lwz r4, 4(r24)
lwz r3, 0(r24)
addi r0, r4, -8
srw r0, r3, r0
rlwinm r0, r0, 2, 0x16, 0x1d
lhzx r5, r21, r0
cmpwi r5, 0
beq _decode_iquant_rc_decode_dc
add r3, r21, r0
subf r0, r5, r4
lhz r21, 2(r3)
stw r0, 4(r24)
b _decode_iquant_rc_have_dc_value
_decode_iquant_rc_decode_dc:
lwz r3, 0x49c(r24)
mr r5, r24
lwz r4, 0x4a0(r24)
bl TMCJPEGDEC_vl_decode_rc
cmpwi r3, 0
mr r21, r3
bge _decode_iquant_rc_have_dc_value
b _decode_iquant_rc_return
_decode_iquant_rc_have_dc_value:
cmpwi r21, 0
beq _decode_iquant_rc_store_dc
lwz r0, 4(r24)
cmpw r0, r21
bgt _decode_iquant_rc_read_dc_bits
mr r3, r24
bl TMCJPEGDEC_load_buff
cmpwi r3, 0
bge _decode_iquant_rc_read_dc_bits
b _decode_iquant_rc_return
_decode_iquant_rc_read_dc_bits:
lwz r0, 4(r24)
li r4, 1
lwz r3, 0(r24)
slw r6, r4, r21
subf r4, r21, r0
addi r5, r6, -1
srwi r0, r6, 1
srw r3, r3, r4
stw r4, 4(r24)
and r3, r5, r3
cmplw r0, r3
ble _decode_iquant_rc_store_dc_bits
subf r3, r5, r3
_decode_iquant_rc_store_dc_bits:
lwz r0, 0(r25)
add r0, r0, r3
stw r0, 0(r25)
_decode_iquant_rc_store_dc:
lwz r5, 0(r25)
addi r3, r22, 4
lwz r0, 0(r23)
li r4, 0
mullw r0, r5, r0
stw r0, 0(r22)
lwz r30, 0x4a8(r24)
lwz r26, 0x4ac(r24)
lwz r25, 0x4b0(r24)
lwz r27, 0x1834(r24)
lwz r5, 0x1838(r24)
bl memset
lis r21, TMCJPEGDEC_Zigzag_data@ha
li r28, 1
addi r21, r21, TMCJPEGDEC_Zigzag_data@l
li r31, 1
_decode_iquant_rc_ac_loop:
lwz r0, 4(r24)
cmpwi r0, 8
bgt _decode_iquant_rc_have_ac_bits
mr r3, r24
bl TMCJPEGDEC_load_buff
cmpwi r3, 0
bge _decode_iquant_rc_have_ac_bits
b _decode_iquant_rc_return
_decode_iquant_rc_have_ac_bits:
lwz r4, 4(r24)
lwz r3, 0(r24)
addi r0, r4, -8
srw r0, r3, r0
rlwinm r0, r0, 2, 0x16, 0x1d
add r3, r30, r0
lhzx r0, r30, r0
cmpwi r0, 0
beq _decode_iquant_rc_decode_ac
lhz r3, 2(r3)
subf r0, r0, r4
stw r0, 4(r24)
b _decode_iquant_rc_have_ac_value
_decode_iquant_rc_decode_ac:
mr r3, r26
mr r4, r25
mr r5, r24
bl TMCJPEGDEC_vl_decode_rc
cmpwi r3, 0
bge _decode_iquant_rc_have_ac_value
b _decode_iquant_rc_return
_decode_iquant_rc_have_ac_value:
clrlwi. r29, r3, 0x1c
beq _decode_iquant_rc_no_ac_bits
lwz r0, 4(r24)
srawi r3, r3, 4
add r28, r28, r3
cmpw r0, r29
bgt _decode_iquant_rc_read_ac_bits
mr r3, r24
bl TMCJPEGDEC_load_buff
cmpwi r3, 0
bge _decode_iquant_rc_read_ac_bits
b _decode_iquant_rc_return
_decode_iquant_rc_read_ac_bits:
cmpw r28, r27
ble _decode_iquant_rc_store_ac
lwz r0, 4(r24)
cmpwi r28, 0x40
subf r0, r29, r0
stw r0, 4(r24)
blt _decode_iquant_rc_increment
li r3, -0x64
b _decode_iquant_rc_return
_decode_iquant_rc_increment:
addi r28, r28, 1
b _decode_iquant_rc_loop_check
_decode_iquant_rc_store_ac:
lwz r0, 4(r24)
slw r6, r31, r29
lwz r3, 0(r24)
addi r5, r6, -1
subf r4, r29, r0
srwi r0, r6, 1
srw r3, r3, r4
stw r4, 4(r24)
and r4, r5, r3
cmplw r0, r4
ble _decode_iquant_rc_have_extra
subf r4, r5, r4
_decode_iquant_rc_have_extra:
cmpwi r28, 0x40
blt _decode_iquant_rc_store_coeff
li r3, -0x64
b _decode_iquant_rc_return
_decode_iquant_rc_store_coeff:
lbzx r0, r21, r28
addi r28, r28, 1
slwi r3, r0, 2
lwzx r0, r23, r3
mullw r0, r4, r0
stwx r0, r22, r3
b _decode_iquant_rc_loop_check
_decode_iquant_rc_no_ac_bits:
cmpwi r3, 0
bne _decode_iquant_rc_zrl
li r3, 0
b _decode_iquant_rc_return
_decode_iquant_rc_zrl:
addi r28, r28, 0x10
_decode_iquant_rc_loop_check:
cmpwi r28, 0x40
blt _decode_iquant_rc_ac_loop
li r3, 0
_decode_iquant_rc_return:
lmw r21, 0x14(r1)
lwz r0, 0x44(r1)
mtlr r0
addi r1, r1, 0x40
blr
value = work->bitCount - count;
work->bitCount = value;
value = (work->bitBuf >> value) & mask;
if (range >> 1 > (u32)value) {
value -= mask;
}
return value;
}
#else
s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_row_ptr, TMCCJPEGDecWork* work) {
const u8* zztbl;
u16* ac_fast;
s32 t;
s32 idx;
@@ -231,7 +33,6 @@ s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_ro
s32 blk_mul;
s32 bit_pos;
u32 bit_data;
u16* dcf;
s32* conv_row;
@@ -248,7 +49,7 @@ s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_ro
tmp = (work->bitBuf >> (bit_pos - 8) & 0xFF) << 2;
val = dcf[tmp >> 1];
if (val != 0) {
tmp = *(u16*)((u8*)dcf + tmp + 2);
tmp = dcf[(tmp >> 1) + 1];
work->bitCount -= val;
val = tmp;
} else {
@@ -264,16 +65,7 @@ s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_ro
return r;
}
}
tmp = 1UL << val;
bit_pos = work->bitCount - val;
work->bitCount = bit_pos;
bit_data = work->bitBuf;
extra = tmp - 1;
extra = extra & (bit_data >> bit_pos);
if (tmp >> 1 > (u32)extra) {
extra -= (tmp - 1);
}
extra = readCoefficientBits(work, val);
dc_predict_row_ptr[0] += extra;
}
@@ -285,9 +77,8 @@ s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_ro
blk_size = work->blockSize;
blk_mul = work->blockSizeMul;
memset((u8*)block + 4, 0, blk_mul);
memset(block + 1, 0, blk_mul);
zztbl = TMCJPEGDEC_Zigzag_data;
idx = 1;
do {
if (work->bitCount <= 8) {
@@ -297,7 +88,7 @@ s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_ro
}
{
u16* ac_entry = (u16*)((u8*)ac_fast + ((work->bitBuf >> (work->bitCount - 8) & 0xFF) << 2));
u16* ac_entry = &ac_fast[(work->bitBuf >> (work->bitCount - 8) & 0xFF) * 2];
val = *ac_entry;
if (val != 0) {
tmp = val;
@@ -328,21 +119,12 @@ s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_ro
}
idx++;
} else {
bit_pos = work->bitCount - t;
work->bitCount = bit_pos;
bit_data = work->bitBuf;
tmp = 1UL << t;
extra = tmp - 1;
extra = extra & (bit_data >> bit_pos);
if (tmp >> 1 > extra) {
extra -= tmp - 1;
}
extra = readCoefficientBits(work, t);
if (idx >= 64) {
return TMCC_ERROR_OVERFLOW;
}
*(s32*)((u8*)block + zztbl[idx] * 4) = extra * conv_row[zztbl[idx]];
block[TMCJPEGDEC_Zigzag_data[idx]] = extra * conv_row[TMCJPEGDEC_Zigzag_data[idx]];
idx++;
}
} else {
@@ -355,7 +137,6 @@ s32 TMCJPEGDEC_decode_iquant_rc(s32* block, u8* conv_row_ptr, u32* dc_predict_ro
return 0;
}
#endif
static s32 TMCJPEGDEC_vl_decode_rc(u32* huff_tbl, u8* huff_sym, TMCCJPEGDecWork* work) {
s32 bit_pos;

View File

@@ -167,28 +167,28 @@ s32 TMCJPEGDEC_set_converterRGB565(TMCCJPEGDecWork* work) {
static void TMCJPEGDEC_converterYUV411toRGB565(TMCCJPEGDecWork* work, s32 x, s32 y) {
u16* output;
s32 lumaSkip;
s32 tileRow;
s32 cbValue;
s32 blue;
TMCCJPEGDecState* state;
u32 tileWidth;
s32 lumaSkip;
s32 crValue;
s32 width;
s32 height;
u8* cb;
s32 chromaSkip;
u8* texture;
u8* luminance;
s32 chromaSkip;
u8* cb;
u8* cr;
s32 column;
s32 xEnd;
s32 yEnd;
s32 redOffset;
s32 tileRow;
s32 blueOffset;
u8 value;
s32 red;
u32 tileWidth;
s32 greenOffset;
s32 redOffset;
s32 red;
s32 blueOffset;
s32 green;
luminance = work->convBuf + 4;
@@ -260,15 +260,38 @@ static void TMCJPEGDEC_converterYUV411toRGB565(TMCCJPEGDecWork* work, s32 x, s32
}
static void TMCJPEGDEC_converterYUV411toRGB565edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 lumaSkip;
s32 chromaSkip;
u16* output;
s32 tileRow;
s32 columnInTile;
u8* texture;
u8* luminance;
u8* cb;
u8* cr;
s32 column;
u8* luminance = work->convBuf + 4;
s8* cb = (s8*)&work->convBuf[260];
s8* cr = (s8*)&work->convBuf[324];
TMCCJPEGDecState* state = work->pState;
u32 tileWidth = state->convWidth >> 2;
u8* texture = state->pTexBuffer;
s32 width;
s32 xEnd;
s32 yEnd;
u32 tileWidth;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
s32 red;
s32 green;
s32 blue;
s32 height;
s32 width;
TMCCJPEGDecState* state;
s32 cbValue;
s8 crValue;
s32 value;
luminance = work->convBuf + 4;
cb = &work->convBuf[260];
cr = &work->convBuf[324];
state = work->pState;
tileWidth = state->convWidth >> 2;
texture = state->pTexBuffer;
if (state->dataSizeX == (u32)x) {
width = state->stepXExt;
} else {
@@ -279,69 +302,67 @@ static void TMCJPEGDEC_converterYUV411toRGB565edge(TMCCJPEGDecWork* work, s32 x,
} else {
height = 8 / state->scaleFactor;
}
{
s32 xEnd = x + width;
s32 yEnd = y + height;
s32 lumaSkip = 32 - width;
s32 chromaSkip = lumaSkip >> 2;
s32 redOffset, greenOffset, blueOffset;
ASSERTLINE((x & 3) == 0, __LINE__);
for (; y < yEnd; y++) {
s32 tileRow = (y >> 2) * tileWidth;
u16* output = (u16*)(texture + ((y & 3) << 3));
for (column = x; column < xEnd; column += 1) {
if ((column & 3) == 0) {
s32 cbValue = *cb++;
s32 crValue = *cr++;
redOffset = (crValue * 359) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
}
{
s32 value = *luminance++;
s32 green = value + greenOffset;
s32 red = value + redOffset;
s32 blue = value + blueOffset;
if ((blue | red | green) >> 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;
}
output[(column & 3) + ((((column) >> 2) + tileRow) << 4)] =
((blue & 0xF8) >> 3) + ((red & 0xF8) << 8) + ((green & 0xFC) << 3);
}
xEnd = x + width;
yEnd = y + height;
lumaSkip = 32 - width;
chromaSkip = lumaSkip >> 2;
ASSERTLINE((x & 3) == 0, __LINE__);
for (; y < yEnd; y++) {
output = (u16*)(texture + ((y & 3) << 3));
tileRow = (y >> 2) * tileWidth;
for (column = x; column < xEnd; column += 1) {
columnInTile = column & 3;
if (columnInTile == 0) {
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
redOffset = (crValue * 359) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
}
luminance += lumaSkip;
cb += chromaSkip;
cr += chromaSkip;
value = *luminance++;
red = value + redOffset;
blue = value + blueOffset;
green = value + greenOffset;
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;
}
output[columnInTile + (((column >> 2) + tileRow) << 4)] = ((blue & 0xF8) >> 3) + (((red & 0xF8) << 8) + ((green & 0xFC) << 3));
}
luminance += lumaSkip;
cb += chromaSkip;
cr += chromaSkip;
}
}
static void TMCJPEGDEC_converterYUV422toRGB565(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 chromaSkip;
s32 width;
s32 blue;
s32 lumaSkip;
s32 red;
s32 tileRow;
s32 chromaSkip;
u16* output;
u32 tileWidth;
s32 tileRow;
s32 redOffset;
s32 secondGreen;
s32 red;
s32 secondRed;
u8* texture;
TMCCJPEGDecState* state;
s32 crValue;
u8* luminance;
u8* cb;
u8* cr;
s32 height;
s32 column;
s32 cbValue;
s32 xEnd;
s32 yEnd;
s32 redOffset;
u32 tileWidth;
s32 greenOffset;
s32 blueOffset;
s32 green;
s32 blue;
s32 value;
TMCCJPEGDecState* state;
s32 width;
s32 height;
s32 crValue;
s32 cbValue;
luminance = work->convBuf + 4;
cb = &work->convBuf[132];
@@ -364,30 +385,26 @@ static void TMCJPEGDEC_converterYUV422toRGB565(TMCCJPEGDecWork* work, s32 x, s32
redOffset = (crValue * 359) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
blue = *luminance++;
green = blue + greenOffset;
red = blue + redOffset;
blue = blue + blueOffset;
if ((blue | red | green) >> 8) {
value = *luminance++;
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
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;
}
output[(column & 3) + (((column >> 2) + tileRow) << 4)] = ((blue & 0xF8) >> 3) + (((red & 0xF8) << 8) + ((green & 0xFC) << 3));
blue = *luminance++;
green = blue + greenOffset;
red = blue + redOffset;
blue = blue + blueOffset;
if ((blue | red | green) >> 8) {
value = *luminance++;
secondGreen = value + greenOffset;
secondRed = value + redOffset;
blue = value + blueOffset;
if ((secondRed | secondGreen | 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;
secondGreen = secondGreen > 255 ? 255 : secondGreen < 0 ? 0 : secondGreen;
secondRed = secondRed > 255 ? 255 : secondRed < 0 ? 0 : secondRed;
}
output[((column + 1) & 3) + ((((column + 1) >> 2) + tileRow) << 4)] = ((blue & 0xF8) >> 3) + (((red & 0xF8) << 8) + ((green & 0xFC) << 3));
output[((column + 1) & 3) + ((((column + 1) >> 2) + tileRow) << 4)] = ((blue & 0xF8) >> 3) + (((secondRed & 0xF8) << 8) + ((secondGreen & 0xFC) << 3));
}
luminance += lumaSkip;
cb += chromaSkip;
@@ -471,118 +488,107 @@ static void TMCJPEGDEC_converterYUV422toRGB565edge(TMCCJPEGDecWork* work, s32 x,
}
static void TMCJPEGDEC_converterYUV420toRGB565(TMCCJPEGDecWork* work, s32 x, s32 y) {
u16* output;
s32 width;
s32 redOffset;
s32 green;
u32 tileWidth;
u8* texture;
s32 chromaSkip;
s32 height;
s32 yEnd;
u8* luminance;
s32 crValue;
s32 value;
u8* cb;
s32 xEnd;
s32 column;
u8* cr;
s32 greenOffset;
s32 tileRow;
s32 cbValue;
s32 lumaSkip;
s32 blueOffset;
s32 chromaSkip;
s32 chromaWidth;
u16* output;
s32 tileRow;
s32 redOffset;
s32 secondGreen;
s32 red;
TMCCJPEGDecState* state;
s32 secondRed;
u8* texture;
u8* luminance;
u8* cb;
u8* cr;
s32 column;
s32 xEnd;
s32 yEnd;
u32 tileWidth;
s32 greenOffset;
s32 blueOffset;
s32 green;
s32 blue;
s32 value;
TMCCJPEGDecState* state;
s32 width;
s32 height;
s32 crValue;
s32 cbValue;
luminance = work->convBuf + 4;
cb = work->convBuf + 260;
cr = work->convBuf + 324;
cb = &work->convBuf[260];
cr = &work->convBuf[324];
state = work->pState;
tileWidth = state->convWidth >> 2;
texture = state->pTexBuffer;
width = 16 / state->scaleFactor;
height = 16 / state->scaleFactor;
{
xEnd = x + width;
yEnd = y + height;
lumaSkip = 16 - width;
chromaSkip = lumaSkip >> 1;
for (; y < yEnd; y++) {
tileRow = (y >> 2) * tileWidth;
output = (u16*)(texture + ((y & 3) << 3));
for (column = x; column < xEnd; column += 2) {
{
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
redOffset = (crValue * 359) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
}
{
value = *luminance++;
red = value + redOffset;
green = value + greenOffset;
blue = value + blueOffset;
if ((blue | red | green) >> 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;
}
output[(column & 3) + ((((column) >> 2) + tileRow) << 4)] =
((blue & 0xF8) >> 3) + ((red & 0xF8) << 8) + ((green & 0xFC) << 3);
}
{
value = *luminance++;
red = value + redOffset;
green = value + greenOffset;
blue = value + blueOffset;
if ((blue | red | green) >> 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;
}
output[(column + 1 & 3) + ((((column + 1) >> 2) + tileRow) << 4)] =
((blue & 0xF8) >> 3) + ((red & 0xF8) << 8) + ((green & 0xFC) << 3);
}
xEnd = x + width;
yEnd = y + height;
lumaSkip = 16 - width;
chromaSkip = lumaSkip >> 1;
chromaWidth = (width + 1) >> 1;
for (; y < yEnd; y++) {
output = (u16*)(texture + ((y & 3) << 3));
tileRow = (y >> 2) * tileWidth;
for (column = x; column < xEnd; column += 2) {
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
redOffset = (crValue * 359) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
value = *luminance++;
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
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;
}
luminance += lumaSkip;
if (y & 1) {
cb += chromaSkip;
cr += chromaSkip;
} else {
cb -= (width + 1) >> 1;
cr -= (width + 1) >> 1;
output[(column & 3) + (((column >> 2) + tileRow) << 4)] = ((blue & 0xF8) >> 3) + (((red & 0xF8) << 8) + ((green & 0xFC) << 3));
value = *luminance++;
secondGreen = value + greenOffset;
secondRed = value + redOffset;
blue = value + blueOffset;
if ((secondRed | secondGreen | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
secondGreen = secondGreen > 255 ? 255 : secondGreen < 0 ? 0 : secondGreen;
secondRed = secondRed > 255 ? 255 : secondRed < 0 ? 0 : secondRed;
}
output[((column + 1) & 3) + ((((column + 1) >> 2) + tileRow) << 4)] = ((blue & 0xF8) >> 3) + (((secondRed & 0xF8) << 8) + ((secondGreen & 0xFC) << 3));
}
luminance += lumaSkip;
if (y & 1) {
cb += chromaSkip;
cr += chromaSkip;
} else {
cb -= chromaWidth;
cr -= chromaWidth;
}
}
}
static void TMCJPEGDEC_converterYUV420toRGB565edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 lumaSkip;
s32 chromaSkip;
s32 chromaWidth;
u16* output;
s8 crValue;
s32 tileRow;
u8* texture;
u8* luminance;
s8* cb;
s32 width;
s8* cb;
s8 crValue;
s8* cr;
s8 cbValue;
s32 column;
s32 xEnd;
s8 cbValue;
s32 yEnd;
s32 red;
s32 blue;
u32 tileWidth;
s32 height;
TMCCJPEGDecState* state;
s32 green;
s32 lumaSkip;
s32 chromaSkip;
u32 tileWidth;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
@@ -607,6 +613,7 @@ static void TMCJPEGDEC_converterYUV420toRGB565edge(TMCCJPEGDecWork* work, s32 x,
yEnd = y + height;
lumaSkip = 16 - width;
chromaSkip = lumaSkip >> 1;
chromaWidth = (width + 1) >> 1;
ASSERTLINE((x & 1) == 0, __LINE__);
for (; y < yEnd; y++) {
output = (u16*)(texture + ((y & 3) << 3));
@@ -619,24 +626,26 @@ static void TMCJPEGDEC_converterYUV420toRGB565edge(TMCCJPEGDecWork* work, s32 x,
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
}
blue = *luminance++;
red = blue + redOffset;
green = blue + greenOffset;
blue = blue + blueOffset;
if ((blue | red | green) >> 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;
{
s32 value = *luminance++;
s32 red = value + redOffset;
s32 green = value + greenOffset;
s32 blue = value + blueOffset;
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;
}
output[(column & 3) + (((column >> 2) + tileRow) << 4)] = ((blue & 0xF8) >> 3) + (((red & 0xF8) << 8) + ((green & 0xFC) << 3));
}
output[(column & 3) + (((column >> 2) + tileRow) << 4)] = ((blue & 0xF8) >> 3) + ((red & 0xF8) << 8) + ((green & 0xFC) << 3);
}
luminance += lumaSkip;
if (y & 1) {
cb += chromaSkip;
cr += chromaSkip;
} else {
cb -= (width + 1) >> 1;
cr -= (width + 1) >> 1;
cb -= chromaWidth;
cr -= chromaWidth;
}
}
}
@@ -816,15 +825,11 @@ static void TMCJPEGDEC_converterYUV444toRGB565(TMCCJPEGDecWork* work, s32 x, s32
u8* luminance;
u8* cb;
u8* cr;
s32 value;
s32 column;
s32 xEnd;
s32 cbValue;
s32 yEnd;
u32 tileWidth;
s32 green;
s32 blue;
s32 red;
s32 height;
luminance = work->convBuf + 4;
@@ -844,17 +849,19 @@ static void TMCJPEGDEC_converterYUV444toRGB565(TMCCJPEGDecWork* work, s32 x, s32
for (column = x; column < xEnd; column++) {
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
value = *luminance++;
green = value + (-(cbValue * 88 + crValue * 183) >> 8);
red = value + ((crValue * 359) >> 8);
blue = value + ((cbValue * 454) >> 8);
if ((blue | green | red) >> 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;
{
s32 value = *luminance++;
s32 green = value + (-(cbValue * 88 + crValue * 183) >> 8);
s32 red = value + ((crValue * 359) >> 8);
s32 blue = value + ((cbValue * 454) >> 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;
}
output[(column & 3) + (((column >> 2) + tileRow) << 4)] =
((blue & 0xF8) >> 3) + (((red & 0xF8) << 8) + ((green & 0xFC) << 3));
}
output[(column & 3) + (((column >> 2) + tileRow) << 4)] =
((blue & 0xF8) >> 3) + ((red & 0xF8) << 8) + ((green & 0xFC) << 3);
}
luminance += rowSkip;
cb += rowSkip;

View File

@@ -179,7 +179,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
s32 yEnd;
s32 tileWidth;
s32 blueOffset;
u16* output;
s32 greenOffset;
s32 tileRow;
s32 lumaSkip;
s8 crValue;
@@ -188,7 +188,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
s32 cbValue;
u8 value;
s32 row;
s32 greenOffset;
u16* output;
s32 redOffset;
s32 blue;
@@ -285,9 +285,9 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
}
static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 chromaSkip;
u16* output;
s32 tileRow;
s32 xEnd;
s32 lumaSkip;
u8* texture;
TMCCJPEGDecState* state;
u8* luminance;
@@ -296,15 +296,15 @@ static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
s32 height;
u8* cr;
s32 column;
s32 lumaSkip;
s32 xEnd;
s32 yEnd;
s32 tileWidth;
u16* output;
s32 redOffset;
s32 cbValue;
s8 crValue;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
s32 chromaSkip;
s32 blue;
s32 red;
s32 green;
@@ -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 lumaSkip;
s32 cbValue;
s32 tileWidth;
TMCCJPEGDecState* state;
u16* output;
s32 cbValue;
s32 tileRow;
TMCCJPEGDecState* state;
s32 lumaSkip;
u8* texture;
s32 width;
s32 height;
@@ -381,8 +381,8 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
s32 column;
s32 xEnd;
s32 yEnd;
s32 tileWidth;
s32 redOffset;
s32 tileRow;
s32 greenOffset;
s32 blueOffset;
s32 value;
@@ -441,21 +441,21 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
}
static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 blue;
s32 chromaSkip;
u16* output;
s32 xEnd;
u8* cr;
s32 tileRow;
s32 lumaSkip;
TMCCJPEGDecState* state;
s32 tileWidth;
u8* texture;
u8* luminance;
s32 width;
s32 height;
u8* cb;
u8* texture;
u8* cr;
s32 column;
s32 chromaSkip;
s32 xEnd;
s32 yEnd;
s32 tileRow;
s32 tileWidth;
s32 cbValue;
s32 crValue;
s32 redOffset;
@@ -463,8 +463,8 @@ static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
s32 blueOffset;
s32 value;
s32 red;
s32 lumaSkip;
s32 green;
s32 blue;
luminance = work->convBuf + 4;
cb = &work->convBuf[132];
@@ -517,27 +517,27 @@ static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
}
static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 tileRow;
s8 crValue;
s32 chromaSkip;
u8* luminance;
s8 crValue;
s32 lumaSkip;
u16* output;
TMCCJPEGDecState* state;
u8* texture;
s32 tileRow;
s32 width;
s32 height;
s32 green;
s32 blue;
s32 lumaSkip;
s32 yEnd;
s32 xEnd;
u8* luminance;
u8* cb;
u8* cr;
s32 value;
s32 column;
u8* cr;
s32 greenOffset;
s32 xEnd;
s32 yEnd;
s32 tileWidth;
s32 redOffset;
u8* cb;
u16* output;
s32 greenOffset;
u8* texture;
s32 blueOffset;
s32 red;
s32 cbValue;
@@ -641,7 +641,9 @@ static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
s32 xEnd = x + width;
s32 lumaSkip = 16 - width;
s32 chromaSkip = lumaSkip >> 1;
s32 redOffset, greenOffset, blueOffset;
s32 redOffset;
s32 blueOffset;
s32 greenOffset;
ASSERTLINE((x & 1) == 0, __LINE__);
for (; y < yEnd; y++) {
u16* output = (u16*)(texture + ((y & 3) << 3));
@@ -656,10 +658,10 @@ static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
blueOffset = (cbValue * 454) >> 8;
}
{
s32 value = *luminance++;
s32 green = value + greenOffset;
s32 red = value + redOffset;
s32 blue = value + blueOffset;
s32 red = *luminance++;
s32 green = red + greenOffset;
s32 blue = red + blueOffset;
red = red + redOffset;
if ((green | red | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
@@ -768,7 +770,7 @@ static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
u16* output;
s32 lumaSkip;
s32 tileRow;
s32 blue;
u8* texture;
u8* luminance;
@@ -783,14 +785,14 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
s32 greenOffset;
s32 yEnd;
s32 cbValue;
s32 tileRow;
s32 tileWidth;
s32 blueOffset;
s32 red;
s8 crValue;
u8 value;
s32 green;
s32 redOffset;
s32 tileWidth;
s32 lumaSkip;
luminance = work->convBuf + 4;
cb = work->convBuf + 132;

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 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 cangjieEnabled; // 0x16
ziU8 unk_0x17;
ziU8 zhPudMinPrefix;
ziU8 subLanguage; // 0x18
ziU8 unk_0x19;
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;
@@ -265,22 +265,22 @@ struct __zi8_work_data_s {
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* dawgGroup; // 0x17F0
@@ -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

@@ -1,5 +1,20 @@
#include <zi8clib/zitypes.h>
typedef struct {
ziU8 countOnly;
ziU8 maxWordLength;
ziU8 lookupMode;
ziU8 suffixOnly;
ziU8 controls[8];
ziU32 maxCount;
ziU16 capacity;
ziU8 minWordLength;
ziU8 flags;
ziU16 candidateCapacity;
ziU8 checkOnly;
ziU8 reserved;
} ZiCandidateOptions;
const ziWChar Zi8PunctTable[40] = {
0xFF0C, 0x3002, 0x3001, 0xFF1A, 0xFF1F, 0xFF01, 0x3005, 0x2026,
0x2015, 0xFF1B, 0xFF0E, 0x30FB, 0x201C, 0x201D, 0xFF08, 0xFF09,
@@ -8,8 +23,8 @@ const ziWChar Zi8PunctTable[40] = {
0xFFE1, 0x20AC, 0x203B, 0xFF20, 0x0000,
};
ziS32 Zi8Punctuation(ziGetParam* param ZI_NEED_WORK) {
ziS32 limit = ((ziU16*)__zi8_work_data)[8] - 1;
ziU32 Zi8Punctuation(ziGetParam* param, ziPtr options ZI_NEED_WORK) {
ziS32 limit = ((ZiCandidateOptions*)options)->capacity - 1;
ziS32 count = 0;
ziU8 i = 0;
ziU16 fc = param->firstCandidate;
@@ -21,7 +36,7 @@ ziS32 Zi8Punctuation(ziGetParam* param ZI_NEED_WORK) {
}
if (fc == 0) {
count++;
if (ZI_WORK->unk_0x00 == 0) {
if (((ZiCandidateOptions*)options)->countOnly == 0) {
param->candidates[i++] = Zi8PunctTable[j];
if ((param->context & 0x10) != 0) {
param->candidates[i++] = 0x20;
@@ -33,7 +48,7 @@ ziS32 Zi8Punctuation(ziGetParam* param ZI_NEED_WORK) {
break;
}
} else {
if (count >= (ziS32)ZI_WORK->unk_0x0C) {
if (count >= (ziS32)((ZiCandidateOptions*)options)->maxCount) {
return count;
}
}
@@ -42,7 +57,7 @@ ziS32 Zi8Punctuation(ziGetParam* param ZI_NEED_WORK) {
}
j++;
}
if (ZI_WORK->unk_0x00 == 0) {
if (((ZiCandidateOptions*)options)->countOnly == 0) {
param->letters = count;
}
return count;

View File

@@ -1,3 +1,8 @@
#include <zi8clib/zitypes.h>
#undef ZI_NEED_WORK
#define ZI_NEED_WORK , struct __zi8_work_data_s* __zi8_work_data
#undef ZI_WORK
#define ZI_WORK __zi8_work_data
#include <zi8clib/zconvert.h>
#include <zi8clib/zierror.h>
@@ -23,7 +28,7 @@ typedef struct ziConversionTable {
} ziConversionTable;
const ziConversionTables Zi8CvrtTables = {0};
ziU16 Zi8GetTableCount(ziU8, ziU8 ZI_NEED_WORK);
ziPtr Zi8GetTableAddress(ziU8, ziU8 ZI_NEED_WORK);
ziU32 Zi8GetTableAddress(ziU8, ziU8 ZI_NEED_WORK);
ziWChar Zi8ConvertUC2UserKey(ziChar, ziU8 ZI_NEED_WORK);
ziWChar Zi8ConvertUC2WC(ziChar character, ziU8 language ZI_NEED_WORK) {
@@ -37,7 +42,7 @@ ziWChar Zi8ConvertUC2WC(ziChar character, ziU8 language ZI_NEED_WORK) {
return 0;
}
if (Zi8GetTableCount(language, 6, __zi8_work_data) != 0) {
table = Zi8GetTableAddress(language, 6, __zi8_work_data);
table = (ziU8*)Zi8GetTableAddress(language, 6, __zi8_work_data);
if (table == 0) {
Zi8LogError(0x6A4, __zi8_work_data);
return 0;
@@ -77,7 +82,7 @@ ziChar Zi8ConvertWC2UC(ziWChar character, ziU8 language ZI_NEED_WORK) {
return 0;
}
if (Zi8GetTableCount(language, 7, __zi8_work_data) != 0) {
table = Zi8GetTableAddress(language, 7, __zi8_work_data);
table = (ziConversionTable*)Zi8GetTableAddress(language, 7, __zi8_work_data);
if (table == 0) {
Zi8LogError(0x6AE, __zi8_work_data);
return 0;
@@ -137,7 +142,7 @@ ziWChar Zi8ConvertUC2Key(ziChar character, ziU8 language ZI_NEED_WORK) {
if (ZI_WORK->userKeys[language] != 0)
return Zi8ConvertUC2UserKey(character, language, __zi8_work_data);
if (Zi8GetTableCount(language, 8, __zi8_work_data) != 0) {
table = Zi8GetTableAddress(language, 8, __zi8_work_data);
table = (ziConversionTable*)Zi8GetTableAddress(language, 8, __zi8_work_data);
if (table == 0) {
Zi8LogError(0x6B8, __zi8_work_data);
return 0;

View File

@@ -15,28 +15,6 @@ typedef struct {
typedef struct { ziU8 keyLow; ziU8 keyHigh; ziU8 code; ziU8 flags; } Zi8AltSoundRecord;
typedef struct {
ziU8 language;
ziU8 getMode;
ziU8 subLanguage;
ziU8 context;
ziU8 getOptions;
ziWChar* elements;
ziU8 elementCount;
ziWChar* currentWord;
ziU8 wordCharCount;
ziWChar* candidates;
ziU8 maxCandidates;
ziU16 firstCandidate;
ziU8 wordCandidates;
ziU8 count;
ziU8 letters;
ziU8* scratch;
ziPtr workspace;
} Zi8OneKeyParam;
typedef struct {
ziU8 countOnly;
ziU8 maxSpellingLength;
@@ -203,15 +181,15 @@ const ziWChar zi8PYfinalSpelling[64][4] = {
const unsigned long long Zi8SOpinyinArray = 0x0303010705000000ULL;
extern Zi8UInt Zi8Ord2Ord(ziU16, ziPtr);
extern ziU16 Zi8Ord2Ord(ziU16, ziPtr);
extern ziU8 Zi8LangSupported(ziU8, ziPtr);
extern ziU16 Zi8GetTableCount(ziU8,ziU8,ziPtr);
extern Zi8UInt Zi8GetTableAddress(ziU8,ziU8,ziPtr);
extern void Zi8Memset();
extern int _Zi8GetCandidates();
extern void Zi8InitDupWordBuf();
extern ziU16 Zi8GetPInfo(ziU16,ziWChar *,ziU8,ziPtr);
extern ziU16 Zi8GetZInfo(ziU16,ziWChar *,ziU8,ziPtr);
extern ziU32 Zi8GetTableAddress(ziU8,ziU8,ziPtr);
extern void Zi8Memset(ziU8*,ziU32,ziS32);
extern ziU8 _Zi8GetCandidates(ziGetParam*,ziPtr);
extern void Zi8InitDupWordBuf(ziPtr);
extern ziU32 Zi8GetPInfo(ziU32,ziWChar *,ziU8,ziPtr);
extern ziU32 Zi8GetZInfo(ziU32,ziWChar *,ziU8,ziPtr);
extern ziBool Zi8IsDupWordW(ziWChar *,ziU8,ziPtr);
extern ziU8 Zi8GetFormatVersion(ziU8,ziPtr);
extern ziU16 Zi8Uni2Ord(ziWChar,ziPtr);
@@ -219,10 +197,10 @@ extern ziU16 Zi8GetPCode(ziU8 *,ziU8 *);
extern ziU8 Zi8MatchOEMdata(ziWChar *,ziU8,ziU8,ziWChar *,ziU16,ziU8,ziU8,ziPtr);
extern ziU8 Zi8MatchPUDdata(ziWChar *,ziU8,ziU8,ziWChar *,ziU16,ziU8,ziU8,ziPtr);
extern ziWChar Zi8Ord2Uni(ziU16,ziPtr);
extern Zi8UInt Zi8GetZHuwdPtr(ziU8 **,ziU16 *,ziPtr);
extern int Zi8GetPyPhonetic();
extern ziU8 Zi8GetBpmfPhonetic();
extern int _Zi8CheckCandidates();
extern ziU32 Zi8GetZHuwdPtr(ziU32*,ziU16*,ziPtr);
extern ziU8 Zi8GetPyPhonetic(ziWChar*,ziU8,ziU16*,ziU16*,ziU8*,ziU16*,ziU16*,ziPtr);
extern ziU8 Zi8GetBpmfPhonetic(ziWChar*,ziU8,ziU16*,ziU16*,ziU16*,ziU16*,ziPtr);
extern ziU8 _Zi8CheckCandidates(ziGetParam*,ziPtr);
Zi8UInt Zi8SpellingZY(ziU16 *output,Zi8UInt key,ziU8 includeTone)
{
@@ -311,21 +289,21 @@ Zi8UInt Zi8SpellingPY(ziU16 *output,Zi8UInt key,ziU8 includeTone)
return length;
}
ziU8 Zi8IsMatch1Key(ziU16 *input,Zi8UInt inputLength,Zi8UInt key,ziU8 requireFull,ziU8 usePinyin,ziU8 tone)
ziU8 Zi8IsMatch1Key(ziU16 *input,Zi8UInt inputLength,ziU16 key,ziU8 requireFull,ziU8 usePinyin,ziU8 tone)
{
ziU16 spelling[16];
Zi8UInt spellingLength;
if ((key & 0xffff) == 0) {
if (key == 0) {
return 0;
}
if ((inputLength & 0xff) == 0) {
return 1;
}
if (usePinyin != 0) {
spellingLength = Zi8SpellingPY(spelling,key & 0xffff,tone & 0xff);
spellingLength = Zi8SpellingPY(spelling,key,tone & 0xff);
} else {
spellingLength = Zi8SpellingZY(spelling,key & 0xffff,tone & 0xff);
spellingLength = Zi8SpellingZY(spelling,key,tone & 0xff);
}
if ((requireFull != 0) && ((inputLength & 0xff) != (spellingLength & 0xff))) {
return 0;
@@ -462,15 +440,15 @@ BACKWARD_SEARCH:
goto BINARY_SEARCH;
}
}
static Zi8UInt Zi8SetFindCand(ziU8 *foundCandidates,Zi8UInt ordinal,ziPtr work)
static Zi8UInt Zi8SetFindCand(ziU8 *foundCandidates,ziU16 ordinal,ziPtr work)
{
Zi8UInt result;
ordinal = Zi8Ord2Ord(ordinal,work);
result = (ziU8)((1 << ((int)(ordinal & 0xffff) % 8)) &
foundCandidates[(int)(ordinal & 0xffff) / 8]);
foundCandidates[(int)(ordinal & 0xffff) / 8] |=
1 << ((int)(ordinal & 0xffff) % 8);
result = (ziU8)((1 << ((int)ordinal % 8)) &
foundCandidates[(int)ordinal / 8]);
foundCandidates[(int)ordinal / 8] |=
1 << ((int)ordinal % 8);
return result;
}
@@ -506,7 +484,7 @@ LAB_return_false:
return 0;
}
Zi8UInt Zi8Get1KeyPressSpelling(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Zi8OneKeyWork *work)
ziU32 Zi8Get1KeyPressSpelling(ziGetParam *params,Zi8OneKeyOptions *options,Zi8OneKeyWork *work)
{
ziU8 candidateCount;
ziBool exactLength;
@@ -531,18 +509,18 @@ Zi8UInt Zi8Get1KeyPressSpelling(Zi8OneKeyParam *params,Zi8OneKeyOptions *options
ziU16 *output;
ziU8 *savedSearchOrder;
ziU16 spellingBuffer[8];
Zi8OneKeyParam searchParams;
ziGetParam searchParams;
candidateCount = 0;
totalCandidates = 0;
optionsMask = params->getOptions;
params->count = 0;
params->letters = 0;
params->completion = 0;
optionsMask = optionsMask & ~0x10;
optionsMask = optionsMask & ~0x20;
optionsMask = optionsMask & ~0x40;
if (options->maxSpellingLength == '\0') {
params->count = 0;
params->letters = 0;
Zi8LogError(100,work);
return 0;
}
@@ -820,7 +798,7 @@ Zi8UInt Zi8Get1KeyPressSpelling(Zi8OneKeyParam *params,Zi8OneKeyOptions *options
savedSearchCount = work->searchOrderCount;
convertedInput = false;
savedSearchFlags = work->searchFlags;
Zi8Memset(&searchParams,0,0x2c);
Zi8Memset((ziU8*)&searchParams,0,0x2c);
searchParams.getMode = 0;
searchParams.subLanguage = 0x80;
searchParams.context = 1;
@@ -918,7 +896,7 @@ Zi8UInt Zi8Get1KeyPressSpelling(Zi8OneKeyParam *params,Zi8OneKeyOptions *options
work->searchFlags = savedSearchFlags;
work->searchOrder = savedSearchOrder;
work->searchOrderCount = savedSearchCount;
params->count = searchParams.count;
params->letters = searchParams.letters;
work->spellingOnly = 0;
if (convertedInput) {
if (params->getMode == '\x03') {
@@ -937,7 +915,7 @@ Zi8UInt Zi8Get1KeyPressSpelling(Zi8OneKeyParam *params,Zi8OneKeyOptions *options
}
}
if ((options->countOnly == '\0') && (params->getMode == '\x03')) {
for (tableIndex = 0; tableIndex < params->count;) {
for (tableIndex = 0; tableIndex < params->letters;) {
while (*output != 0) {
if (*output != 0x27) {
*output++ |= 0xf300;
@@ -1022,12 +1000,12 @@ nextSpelling:
}
}
finishSpelling:
params->count = candidateCount;
params->letters = candidateCount;
Zi8LogError(100,work);
return totalCandidates;
}
int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Zi8OneKeyWork *work)
ziU32 Zi8Get1KeyPressCandidates(ziGetParam *params,Zi8OneKeyOptions *options,Zi8OneKeyWork *work)
{
ziU16 wordBuffer [64];
ziU16 spelling [8];
@@ -1046,7 +1024,7 @@ int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Z
ziU8 *phraseEntries;
ziU16 *currentWord;
ziU8 *entryCursor;
ziU8 *userEntries;
ziU32 userEntriesAddress;
int duplicateIndex;
ziU16 alternateCount;
ziU16 ordinalCount;
@@ -1148,8 +1126,8 @@ int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Z
}
languageMask = languageMask << 4;
remaining = params->firstCandidate;
params->count = 0;
params->letters = 0;
params->completion = 0;
inputLength = params->elementCount;
if (inputLength != 0) {
while (inputLength != 0) {
@@ -1271,7 +1249,7 @@ int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Z
tableCursor = Zi8GetTableCount(1,9,work);
}
if (8 < inputLimit) {
params->wordCandidates = 0;
params->count = 0;
goto finishCandidates;
}
for (index = 0; index < (int)(Zi8UInt)inputLimit; index++) {
@@ -1327,7 +1305,7 @@ int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Z
}
if (elementIndex == 0) continue;
if (!emitWords) {
if (trackDuplicates && Zi8SetFindCand(params->scratch,candidateOrdinal,work) != 0) continue;
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,candidateOrdinal,work) != 0) continue;
for (index = 0; index < candidateCount; index++) {
if (candidateCharacter == output[index]) break;
}
@@ -1357,7 +1335,7 @@ int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Z
output[outputIndex++] = candidateCharacter;
}
if (candidateCount >= params->maxCandidates || outputIndex > outputLimit) {
params->wordCandidates = candidateCount;
params->count = candidateCount;
goto finishCandidates;
}
} else {
@@ -1396,7 +1374,7 @@ int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Z
}
if (elementIndex == 0) continue;
if (!emitWords) {
if (trackDuplicates && Zi8SetFindCand(params->scratch,candidateOrdinal,work) != 0) continue;
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,candidateOrdinal,work) != 0) continue;
for (index = 0; index < candidateCount; index++) {
if (candidateCharacter == output[index]) break;
}
@@ -1426,7 +1404,7 @@ int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Z
output[outputIndex++] = candidateCharacter;
}
if (candidateCount >= params->maxCandidates || outputIndex > outputLimit) {
params->wordCandidates = candidateCount;
params->count = candidateCount;
goto finishCandidates;
}
} else {
@@ -1519,7 +1497,7 @@ int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Z
}
if (elementIndex == 0) goto nextPhrase;
if (!emitWords) {
if (trackDuplicates && Zi8SetFindCand(params->scratch,phraseCharacter,work) != 0) goto nextPhrase;
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,phraseCharacter,work) != 0) goto nextPhrase;
for (index = 0; index < candidateCount; index++) {
if (firstOrdinal == output[index]) goto nextPhrase;
}
@@ -1547,7 +1525,7 @@ int Zi8Get1KeyPressCandidates(Zi8OneKeyParam *params,Zi8OneKeyOptions *options,Z
output[outputIndex++] = firstOrdinal;
}
if (candidateCount >= params->maxCandidates || outputIndex > outputLimit) {
params->wordCandidates = candidateCount;
params->count = candidateCount;
goto finishCandidates;
}
} else {
@@ -1568,7 +1546,7 @@ nextPhrase:
else {
finishPhrases:
if (params->wordCharCount != '\0') {
params->wordCandidates = candidateCount;
params->count = candidateCount;
}
}
if ((options->countOnly == '\0') && (tableCursor != 0)) {
@@ -1601,7 +1579,7 @@ finishPhrases:
}
if (elementIndex == 0) goto nextSortedOrdinal;
if (!emitWords) {
if (trackDuplicates && Zi8SetFindCand(params->scratch,ordinal,work) != 0) goto nextSortedOrdinal;
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,ordinal,work) != 0) goto nextSortedOrdinal;
ordinal = Zi8Ord2Uni(ordinal,work);
for (index = 0; index < candidateCount; index++) {
if (ordinal == output[index]) break;
@@ -1629,11 +1607,11 @@ nextSortedOrdinal:
;
}
}
if ((options->countOnly == '\0') && Zi8GetZHuwdPtr(&userEntries,&userCount,work) != 0)
if ((options->countOnly == '\0') && (ziU8)Zi8GetZHuwdPtr(&userEntriesAddress,&userCount,work) != 0)
{
for (phraseOrdinal = 0; phraseOrdinal < userCount;) {
if ((params->elementCount == '\0') || ((userEntries[1] & 0x80) != 0)) {
userOrdinal = (userEntries[1] & 0x7f) << 8 | (ziU16)userEntries[2];
if ((params->elementCount == '\0') || ((((ziU8*)userEntriesAddress)[1] & 0x80) != 0)) {
userOrdinal = (ziU16)(((ziU8*)userEntriesAddress)[1] & 0x7f) << 8 | (ziU16)((ziU8*)userEntriesAddress)[2];
phraseTable = syllableTable + (Zi8UInt)userOrdinal * 0xc;
if (((*phraseTable & languageMask) != 0) &&
((characterSetTable == 0 || ((characterSet & characterSetTable[(Zi8UInt)userOrdinal]) != 0)))) {
@@ -1654,7 +1632,7 @@ nextSortedOrdinal:
}
if (elementIndex == 0) goto nextUserOrdinal;
if (!emitWords) {
if (trackDuplicates && Zi8SetFindCand(params->scratch,userOrdinal,work) != 0) goto nextUserOrdinal;
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,userOrdinal,work) != 0) goto nextUserOrdinal;
userCharacter = Zi8Ord2Uni(userOrdinal,work);
for (duplicateIndex = 0; duplicateIndex < candidateCount; duplicateIndex++) {
if (userCharacter == output[duplicateIndex]) break;
@@ -1677,7 +1655,7 @@ nextSortedOrdinal:
}
nextUserOrdinal:
phraseOrdinal++;
userEntries = userEntries + 3;
userEntriesAddress = userEntriesAddress + 3;
}
}
phraseTable = syllableTable;
@@ -1710,7 +1688,7 @@ nextUserOrdinal:
if (unicodeCharacter == previousCharacter) goto nextOrdinal;
previousCharacter = unicodeCharacter;
if (!emitWords) {
if (trackDuplicates && Zi8SetFindCand(params->scratch,ordinal,work) != 0) goto nextOrdinal;
if (trackDuplicates && (ziU8)Zi8SetFindCand(params->scratch,ordinal,work) != 0) goto nextOrdinal;
for (index = 0; index < candidateCount; index++) {
if (unicodeCharacter == output[index]) break;
}
@@ -1738,15 +1716,14 @@ nextOrdinal:
}
finishCandidates:
if ((emitWords) && (outputIndex != 0)) {
output[outputIndex] = 0;
outputIndex++;
output[outputIndex++] = 0;
}
params->count = candidateCount;
params->letters = candidateCount;
Zi8LogError(100,work);
return totalCandidates;
}
Zi8UInt Zi8ZHCheckSpelling(ziU16 *input,ziU16 *spelling,Zi8UInt inputLength,char *work)
ziBool Zi8ZHCheckSpelling(ziWChar *input,ziWChar *spelling,ziU8 inputLength,ziPtr work)
{
int index;
ziU8 result;
@@ -1761,11 +1738,11 @@ Zi8UInt Zi8ZHCheckSpelling(ziU16 *input,ziU16 *spelling,Zi8UInt inputLength,char
int syllableStart;
int syllableLength;
Zi8UInt tableOffset;
ziU8 candidateBuffer [32];
ziU8 phoneticCodes [32];
ziU8 phoneticMasks [32];
ziWChar candidateBuffer [16];
ziU16 phoneticCodes [16];
ziU16 phoneticMasks [16];
ziU16 convertedSpelling [64];
Zi8OneKeyParam getParam;
ziGetParam getParam;
ziU8 maskLow;
ziU8 codeLow;
ziU8 maskHigh;
@@ -1806,7 +1783,7 @@ Zi8UInt Zi8ZHCheckSpelling(ziU16 *input,ziU16 *spelling,Zi8UInt inputLength,char
}
index = 0;
syllableStart = index;
for (; index < (int)(inputLength & 0xff); index = index + 1) {
for (; index < (int)inputLength; index = index + 1) {
switch (spelling[index]) {
case 0xf331:
toneMask = 1;
@@ -1877,7 +1854,7 @@ nextInputCharacter:
}
else {
if ((input[index] == 0x27) || (input[index] == 0xf360)) {
if (index < (int)(inputLength & 0xff)) {
if (index < (int)inputLength) {
convertedSpelling[index] = input[index] = spelling[index];
}
else {
@@ -1919,7 +1896,7 @@ nextInputCharacter:
getParam.elementCount = (ziU8)index;
getParam.currentWord = 0;
getParam.wordCharCount = 0;
getParam.candidates = (ziWChar *)candidateBuffer;
getParam.candidates = candidateBuffer;
getParam.maxCandidates = 1;
getParam.firstCandidate = 0;
if ((ziU8)_Zi8CheckCandidates(&getParam,work) != 0) {

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

@@ -351,6 +351,7 @@ int Zi8AlphaGetCandidates(ziGetParam* parameters, ziPtr optionData, ziPtr workDa
int candidateCount;
ziU8 *keyLayout;
ziU8 *keyLayoutCursor;
ziPtr workspace;
ziU16 prefixTableFlags;
ziU16 prefixVowelFlags;
ziU8 prefixMode;
@@ -406,6 +407,7 @@ int Zi8AlphaGetCandidates(ziGetParam* parameters, ziPtr optionData, ziPtr workDa
contextEnabled = 0;
keyLayoutCount = 0;
keyLayout = 0;
workspace = workData;
phoneticInput = 0;
phoneticSeparator = 0;
if ((((((language == 0x7c) || (language == 0x7d)) || (language == 0x7b)) ||
@@ -920,9 +922,8 @@ selectDictionary:
if ((((wordLength == 0) && (*punctuationCursor != 0)) && (dictionaryExact != 0)) &&
((((ZiAlphaWork*)workData)->singleCharacter != 0 && (parameters->elementCount == 2)))) {
*wordCursor = ((ZiAlphaWork*)workData)->singleCharacter;
wordCursor[1] = *punctuationCursor;
punctuationCursor = punctuationCursor + 1;
wordCursor[2] = 0;
wordCursor[1] = *punctuationCursor++;
wordLength = 2;
}
if (((apostropheIndex != 0) && (wordLength != 0)) && (elementCount == parameters->elementCount)) {
@@ -1005,7 +1006,7 @@ filterVowelCandidate:
case 3:
case 7:
while( ZI8_TRUE ) {
wordLength = Zi8MatchUWDdata(elements,elementCount & 0xff,
wordLength = Zi8MatchUWDdata(elements,elementCount,
parameters->currentWord,parameters->wordCharCount,
language,wordCursor,wordCapacity & 0xffff,dictionaryExact,
dictionaryStatus[dictionaryKind] & 0xff,workData);
@@ -1016,8 +1017,8 @@ filterVowelCandidate:
case 4:
case 8:
if (elementCount != 0) {
wordLength = Zi8MatchOEMdata(elements,elementCount & 0xff,language,wordCursor,
wordCapacity & 0xffff,dictionaryExact,
wordLength = Zi8MatchOEMdata(elements,elementCount,language,wordCursor,
wordCapacity,dictionaryExact,
dictionaryStatus[dictionaryKind] & 0xff,workData);
}
break;
@@ -1068,7 +1069,7 @@ filterVowelCandidate:
(((ZiAlphaWork*)workData)->requiredLength != parameters->elementCount)) &&
(((((ZiAlphaWork*)workData)->prefixLength == '\0' ||
(((ZiAlphaWork*)workData)->prefixLength + 1 >= parameters->elementCount)) && (dictionaryExact != 0)))
))) && ((((completionAllowed && (prefixCount == 0)) && (dictionaryKind != 0xb)) &&
))) && ((((currentVowelRestriction && (prefixCount == 0)) && (dictionaryKind != 0xb)) &&
((((int)dictionaryIndex < (int)(unsigned int)((ZiAlphaWork*)workData)->dictionaryCount &&
(((ZiAlphaOptions*)optionData)->lookupMode == '\0')) &&
(((ZiAlphaWork*)workData)->dictionaries[language] == 0)))))) {
@@ -1084,7 +1085,7 @@ filterVowelCandidate:
goto retryDictionary;
}
}
if ((((((dictionaryExact == 0) || (!completionAllowed)) || (prefixCount != 0)) ||
if ((((((dictionaryExact == 0) || (!currentVowelRestriction)) || (prefixCount != 0)) ||
((dictionaryKind == 0xb ||
(dictionaryIndex >= ((ZiAlphaWork*)workData)->dictionaryCount)))) ||
(elements == 0)) ||
@@ -1139,7 +1140,7 @@ prepareCandidate:
Zi8ChangeWordCase(wordCursor - prefixCount,language,workData);
}
if ((((ZiAlphaOptions*)optionData)->suffixOnly != '\0') &&
((int)((ZiAlphaOptions*)optionData)->maxWordLength < (int)(wordLength + prefixCount))) {
((wordLength + prefixCount) > ((ZiAlphaOptions*)optionData)->maxWordLength)) {
wordLength = ((ZiAlphaOptions*)optionData)->maxWordLength - prefixCount;
wordCursor[wordLength] = 0;
}
@@ -1194,7 +1195,9 @@ checkKeyLayout:
break;
}
emitCandidate:
if (firstCandidate == 0) {
if (firstCandidate != 0) {
--firstCandidate;
} else {
if (((ZiAlphaOptions*)optionData)->countOnly != '\0') {
if (((ZiAlphaOptions*)optionData)->suffixOnly != '\0') {
if ((int)((ZiAlphaOptions*)optionData)->shortestWord > (int)(wordLength + prefixCount)) {
@@ -1204,20 +1207,17 @@ emitCandidate:
((ZiAlphaOptions*)optionData)->longestWord = wordLength + prefixCount;
}
}
candidateCount = candidateCount + 1;
if (((ZiAlphaOptions*)optionData)->maxResults <= candidateCount) goto finishCandidates;
if (++candidateCount >= ((ZiAlphaOptions*)optionData)->maxResults) goto finishCandidates;
} else {
if (((ZiAlphaOptions*)optionData)->lookupMode != '\0') {
for (index = 0;
(index <= (int)wordLength &&
(wordCursor[index] == ((ZiAlphaOptions*)optionData)->dictionary[index]));
index = index + 1) {
for (index = 0; index <= wordLength; index++) {
if (wordCursor[index] != ((ZiAlphaOptions*)optionData)->dictionary[index]) break;
}
if ((((((ZiAlphaWork*)workData)->operation != '\0') || ((int)wordLength <= index))
if ((((((ZiAlphaWork*)workData)->operation != '\0') || (index >= wordLength))
&& ((((ZiAlphaWork*)workData)->operation == '\0' ||
((exactLengthOnly == 0 ||
((int)(ziU16)Zi8WCharCount(((ZiAlphaOptions*)optionData)->dictionary,workData) <= index)))))) &&
((exactLengthOnly != 0 || ((int)wordLength <= index)))) {
(index >= (int)(ziU16)Zi8WCharCount(((ZiAlphaOptions*)optionData)->dictionary,workData))))))) &&
((exactLengthOnly != 0 || (index >= wordLength)))) {
candidateCount = 1;
goto finishCandidates;
}
@@ -1326,8 +1326,7 @@ emitCandidate:
wordCursor = wordCursor + wordLength;
wordCapacity = wordCapacity - wordLength;
}
candidateCount = candidateCount + 1;
if ((int)(unsigned int)parameters->maxCandidates <= candidateCount) {
if (++candidateCount >= (int)(unsigned int)parameters->maxCandidates) {
prefixCount = 0;
goto finishCandidates;
}
@@ -1359,15 +1358,12 @@ emitCandidate:
}
}
}
else {
firstCandidate = firstCandidate - 1;
}
}
}
}
}
retryDictionary:;
} while (dictionaryKind != 0);
} while (dictionaryIndex != 0);
}
finishDictionaryPass:;
}
@@ -1376,27 +1372,23 @@ finishDictionaryPass:;
(((parameters->elementCount == 1 &&
(((Zi8GetTableCount(parameters->language,0x1f,workData)) & 0x40) == 0)) &&
(*parameters->elements >= 0xeff1)))))) &&
((*parameters->elements < 0xf011 &&
((*parameters->elements <= 0xf010 &&
((Zi8getKeyLayout(parameters->language,*parameters->elements,&punctuationBuffer[0],1,workData)) != '\0')))) {
punctuationCandidate = ZI8_TRUE;
}
if (((candidateCount == 0) && (punctuationCandidate)) && (firstCandidate == 0)) {
candidateCount = 1;
if ((((ZiAlphaOptions*)optionData)->countOnly == '\0') && ((parameters->getOptions & 0xfd) != 0x81)) {
*encodedOutput = 0x3e;
encodedOutput[2] = 0;
encodedOutput[1] = 0;
}
else {
if (((ZiAlphaOptions*)optionData)->countOnly != 0 || (parameters->getOptions & 0xFD) == 0x81) {
if (parameters->getMode == 1) {
*wordCursor = *elements;
} else {
*wordCursor = 0x3E;
}
else {
*wordCursor = 0x3e;
}
wordCursor[2] = 0;
wordCursor[1] = 0;
wordCursor = wordCursor + 2;
wordCursor[1] = wordCursor[2] = 0;
wordCursor += 2;
} else {
*encodedOutput = 0x3E;
encodedOutput[1] = encodedOutput[2] = 0;
}
if (((ZiAlphaOptions*)optionData)->lookupMode == '\0') {
((ZiAlphaWork*)workData)->singleCharacter = 0;
@@ -1406,13 +1398,13 @@ finishDictionaryPass:;
secondLanguagePass = ZI8_TRUE;
languagePassCount = 0;
language = parameters->subLanguage;
completionAllowed = secondaryCompletionAllowed;
currentVowelRestriction = secondaryVowelRestriction;
dictionaryStatus[9] = 0;
dictionaryStatus[5] = 0;
dictionaryStatus[6] = 0;
dictionaryStatus[7] = 0;
dictionaryStatus[8] = 0;
completionAllowed = secondaryCompletionAllowed;
currentVowelRestriction = secondaryVowelRestriction;
if (switchedLanguage) {
secondLanguagePass = ZI8_FALSE;
dictionaryStatus[1] = 0;
@@ -1426,14 +1418,15 @@ finishDictionaryPass:;
if (language == 0) {
language = parameters->language;
}
completionAllowed = secondaryCompletionAllowed;
currentVowelRestriction = secondaryVowelRestriction;
if (language == parameters->language) {
completionAllowed = primaryCompletionAllowed;
currentVowelRestriction = primaryVowelRestriction;
} else {
completionAllowed = secondaryCompletionAllowed;
currentVowelRestriction = secondaryVowelRestriction;
}
if ((((ZiAlphaOptions*)optionData)->lookupMode != '\0') || ((!currentVowelRestriction && (!completionAllowed)))) goto finishCandidates;
if ((completionAllowed) &&
if ((((ZiAlphaOptions*)optionData)->lookupMode != '\0') || ((!completionAllowed && (!currentVowelRestriction)))) goto finishCandidates;
if ((currentVowelRestriction) &&
((((((ZiAlphaWork*)workData)->suffixMode == '\0' && (2 < (int)elementCount)) &&
(elements[elementCount - 2] == 0xeff1)) &&
((int)((ZiAlphaWork*)workData)->prefixCount == elementCount - 2)))) {
@@ -1444,66 +1437,65 @@ finishDictionaryPass:;
prefixPrepared = ZI8_TRUE;
goto preparePrefix;
}
if (!((((completionAllowed) && (((ZiAlphaWork*)workData)->suffixMode != '\0')) &&
((((ZiAlphaWork*)workData)->suffixLocked == '\0' && (2 < (int)elementCount)))) &&
(((elements[elementCount - 2] == 0xeff1 &&
((int)((ZiAlphaWork*)workData)->suffixCount == elementCount - 2)) ||
(((int)((ZiAlphaWork*)workData)->suffixCount == elementCount - 1 &&
((Zi8IsAlphaPunct(elements[elementCount - 1])) != '\0'))))))) {
tryAlternatePrefix:
if ((prefixPrepared) && (1 < ((ZiAlphaWork*)workData)->alternatePrefixCount)) {
if (language == parameters->language) {
if (primaryMatched) {
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
}
}
else if (secondaryMatched) {
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
}
if (((ZiAlphaWork*)workData)->alternatePrefixCount != '\0') {
if (currentVowelRestriction && ((ZiAlphaWork*)workData)->suffixMode != 0 &&
((ZiAlphaWork*)workData)->suffixLocked == 0 && elementCount > 2 &&
((elements[elementCount - 2] == 0xEFF1 &&
((ZiAlphaWork*)workData)->suffixCount == elementCount - 2) ||
(((ZiAlphaWork*)workData)->suffixCount == elementCount - 1 &&
Zi8IsAlphaPunct(elements[elementCount - 1]) != 0))) {
if (((ZiAlphaWork*)workData)->prefixEnabled >= 1 && elements[elementCount - 1] == 0xEFF1) {
goto checkPrefixPunctuation;
}
if (!primaryMatched && !secondaryMatched) {
((ZiAlphaWork*)workData)->suffixLocked = 1;
((ZiAlphaWork*)workData)->suffixElementCount = parameters->elementCount - 1;
if (prefixCount != 0) {
wordCursor -= prefixCount;
elements -= prefixCount;
elementCount = elementCount + prefixCount;
wordCapacity = wordCapacity + prefixCount;
prefixCount = 0;
prefixPrepared = ZI8_FALSE;
((ZiAlphaWork*)workData)->suffixMode = 0;
((ZiAlphaWork*)workData)->suffixLocked = 0;
((ZiAlphaWork*)workData)->suffixCount = 0;
for (index = 0; index < (int)(unsigned int)((ZiAlphaWork*)workData)->alternatePrefixCount; index = index + 1) {
((ZiAlphaWork*)workData)->prefix[index] =
((ZiAlphaWork*)workData)->alternatePrefix[index];
}
((ZiAlphaWork*)workData)->prefixCount = (ziU8)index;
if (((ZiAlphaWork*)workData)->language == parameters->language) {
((ZiAlphaWork*)workData)->language = parameters->subLanguage;
}
else {
((ZiAlphaWork*)workData)->language = parameters->language;
}
}
goto preparePrefix;
}
}
if ((prefixPrepared) && (1 < ((ZiAlphaWork*)workData)->alternatePrefixCount)) {
if (language == parameters->language) {
if (primaryMatched) {
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
}
}
if ((((primaryMatched) && (secondaryMatched)) || (elementCount == 0)) ||
(((language == parameters->language && (primaryMatched)) || ((language == parameters->subLanguage && (secondaryMatched))))))
goto finishCandidates;
if (completionAllowed) goto checkPrefixPunctuation;
} else {
if ((((ZiAlphaWork*)workData)->prefixEnabled == '\0') || (elements[elementCount - 1] != 0xeff1)) {
if ((!primaryMatched) && (!secondaryMatched)) {
((ZiAlphaWork*)workData)->suffixLocked = 1;
((ZiAlphaWork*)workData)->suffixElementCount = parameters->elementCount - 1;
if (prefixCount != 0) {
wordCursor -= prefixCount;
elements -= prefixCount;
elementCount = elementCount + prefixCount;
wordCapacity = wordCapacity + prefixCount;
prefixCount = 0;
}
goto preparePrefix;
}
goto tryAlternatePrefix;
else if (secondaryMatched) {
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
}
if (((ZiAlphaWork*)workData)->alternatePrefixCount != '\0') {
wordCursor -= prefixCount;
elements -= prefixCount;
elementCount = elementCount + prefixCount;
wordCapacity = wordCapacity + prefixCount;
prefixCount = 0;
prefixPrepared = ZI8_FALSE;
((ZiAlphaWork*)workData)->suffixMode = 0;
((ZiAlphaWork*)workData)->suffixLocked = 0;
((ZiAlphaWork*)workData)->suffixCount = 0;
for (index = 0; index < (int)(unsigned int)((ZiAlphaWork*)workData)->alternatePrefixCount; index = index + 1) {
((ZiAlphaWork*)workData)->prefix[index] =
((ZiAlphaWork*)workData)->alternatePrefix[index];
}
((ZiAlphaWork*)workData)->prefixCount = (ziU8)index;
if (((ZiAlphaWork*)workData)->language == parameters->language) {
((ZiAlphaWork*)workData)->language = parameters->subLanguage;
}
else {
((ZiAlphaWork*)workData)->language = parameters->language;
}
((ZiAlphaWork*)workData)->alternatePrefixCount = 0;
}
}
if ((((primaryMatched) && (secondaryMatched)) || (elementCount == 0)) ||
(((language == parameters->language && (primaryMatched)) || ((language == parameters->subLanguage && (secondaryMatched))))))
goto finishCandidates;
if (currentVowelRestriction) {
checkPrefixPunctuation:
if ((1 < ((ZiAlphaWork*)workData)->prefixEnabled) &&
(parameters->elements[parameters->elementCount - 1] != 0xEFF1))
@@ -1576,17 +1568,17 @@ checkPrefixFields:
finishCandidates:
((ZiAlphaWork*)workData)->usePrefixAsElements = 0;
if (((ZiAlphaOptions*)optionData)->countOnly == '\0') {
parameters->letters = candidateCount;
if (((ZiAlphaOptions*)optionData)->countOnly != '\0') {
parameters->letters = 0;
}
else {
parameters->letters = 0;
parameters->letters = candidateCount;
}
wordCursor[-prefixCount] = 0;
if (((((ZiAlphaOptions*)optionData)->countOnly == '\0') && (((ZiAlphaOptions*)optionData)->lookupMode == '\0')) && (parameters->elementCount != 0)) {
elementIndex = parameters->elementCount - 1;
if (((primaryVowelRestriction) || (secondaryVowelRestriction)) &&
((((ZiAlphaWork*)workData)->prefixEnabled < 2 ||
((((ZiAlphaWork*)workData)->prefixEnabled <= 1 ||
(parameters->elements[elementIndex] == 0xEFF1)))) {
index = 0;
while (elementIndex >= 0) {

View File

@@ -133,16 +133,16 @@ typedef struct {
ziU8 phonetics[11];
} ZiChineseRecord;
extern ziPtr Zi8GetTableAddress(ziU8 language, ziU8 table, ziPtr work);
extern ziU32 Zi8GetTableAddress(ziU8 language, ziU8 table, ziPtr work);
extern ziU16 Zi8GetTableCount(ziU8 language, ziU8 table, ziPtr work);
extern ziU8 Zi8IsDupWChar(ziWChar character, ziPtr work);
extern ziU8 Zi8IsDupWordW(ziWChar* word, ziU8 length, ziPtr work);
extern ziWChar Zi8Ord2Uni(ziU16 ordinal, ziPtr work);
extern ziU8 Zi8MatchPhonetic(ziU8* phonetics, ZiChineseRecord* records,
ziPtr indexTable, ziU16 indexCount, ziPtr dictionary,
ZiChineseRecord* record, ziU16* mask, ziU16* match,
ziU16* length, ZiChineseRecord** matchedRecord,
int* matchedIndex, ziU8 wordMode, ziU8 partial,
extern ziU8 Zi8MatchPhonetic(ziPtr phonetics, ziU8* records,
ziPtr indexTable, ziU16 indexCount, ziU32 dictionary,
ziU8* record, ziU16* mask, ziU16* match,
ziU16* length, ziU8** matchedRecord,
ziU8** matchedString, ziU8 wordMode, ziU8 partial,
ziU8 oneCharacter, ziU16 excludedMask,
ziU16 excludedMatch, ziU8 charset, ziU8 options,
ziU16 ordinal, ziU16* tone, ziU8 spellingOnly,
@@ -160,13 +160,13 @@ extern const ziU8 zi8CangjieCodes[25];
extern const ziWChar ziPuncts[4];
extern const ziWChar ziTones[4];
const ziWChar zi8tones[4];
extern ziU8 Zi8GetZHuwdPtr(ziU8** entries, ziU16* count, ziPtr work);
extern ziU32 Zi8GetZHuwdPtr(ziU32* entries, ziU16* count, ziPtr work);
extern ziBool Zi8IsComponent(ziWChar character, ziPtr work);
extern ziBool Zi8IsCharacter(ziWChar character, ziPtr work);
extern ziU8 Zi8MatchOEMdata(ziWChar* currentWord, ziU8 length, ziU8 language,
ziWChar* output, ziU16 capacity, ziU8 mode, ziU8 next, ziPtr work);
extern ziU16 Zi8Uni2Ord(ziWChar character, ziPtr work);
extern int Zi8GetPCode(ziU8* table, ziU8* record);
extern ziU16 Zi8GetPCode(ziU8* table, ziU8* record);
extern ziU16 Zi8MatchAltSound(ziPtr table, ziU16 count, ziPtr phonetics,
ziU16 ordinal, ziU16 mask, ziU16 value, ziU8 flags, ziPtr work);
extern ziU32 Zi8SecMatchChar(ziPtr record, ziU8* dictionary, ziMatchParam* match, ziU16* code, ziPtr work);
@@ -199,7 +199,7 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
ziU8 matchMode;
int index;
ziWChar* currentWord;
ziU8* userEntries;
ziU32 userEntriesAddress;
ziU16 ordinalIndex;
ziU16 tableIndex;
ziU16 phraseOrdinal;
@@ -425,8 +425,8 @@ 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 {
@@ -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 {
@@ -614,10 +614,10 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
case 56: case 59:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->fANDh) ordinalIndex = 0xF9FF;
break;
case 52: case 55:
case 60: case 63:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->bANDp) ordinalIndex = 0xF9FF;
break;
case 60: case 63:
case 52: case 55:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->gANDk) ordinalIndex = 0xF9FF;
break;
case 38:
@@ -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);
@@ -755,8 +755,8 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
componentOrdinals = (ziU8*)Zi8GetTableAddress(1, 7, work);
componentTable = componentCursor = (ziU8*)Zi8GetTableAddress(1, 2, work);
componentCursor += 8;
componentIndex = componentCount - 1;
--componentCount;
componentIndex = componentCount;
alternateCharacter = 0;
phoneticRetry = 1;
}
@@ -930,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;
}
}
@@ -981,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;
@@ -1108,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;
}
}
@@ -1299,16 +1299,16 @@ context_word_lookup:
if (emitWords) {
++emittedCount;
outputIndex += emittedWords;
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) {
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;
}
}
@@ -1321,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)) {
@@ -1336,7 +1336,7 @@ dictionary_search:
Zi8GetFormatVersion(1, work) >= 8) {
lastCharHigh = (request->currentWord[request->wordCharCount - 1] >> 8) & 0xFF;
lastCharLow = request->currentWord[request->wordCharCount - 1];
phoneticGroups = Zi8GetTableAddress(1, 28, work);
phoneticGroups = (ziU8*)Zi8GetTableAddress(1, 28, work);
rangeCount = Zi8GetTableCount(1, 28, work);
rangeIndex = 0;
while (rangeIndex < rangeCount) {
@@ -1384,7 +1384,7 @@ numeric_setup:
default: ordinalCount = 0; break;
}
}
if (ordinalCount) ordinalTable = Zi8GetTableAddress(1, 29, work);
if (ordinalCount) ordinalTable = (ziU8*)Zi8GetTableAddress(1, 29, work);
}
if (!request->elementCount && (getMode == 7 || getMode == 8 || getMode == 9)) {
resultFallback = 0;
@@ -1434,8 +1434,8 @@ candidate_dictionary_search:
if (emitWords) {
++emittedCount;
output[outputIndex++] = character;
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) goto engine_finish;
output[outputIndex] = ' ';
if (++outputIndex > outputLimit) goto engine_finish;
} else output[emittedCount++] = character;
if (emittedCount >= request->maxCandidates) goto engine_finish;
}
@@ -1451,7 +1451,7 @@ character_range_start:
firstOrdinal = 0;
rangeIndex = Zi8GetTableCount(1, 16, work);
if (Zi8GetFormatVersion(1, work) >= 4 && rangeIndex && elements[0] != 0xEF00) {
phoneticGroups = Zi8GetTableAddress(1, 16, work);
phoneticGroups = (ziU8*)Zi8GetTableAddress(1, 16, work);
rangeIndex = 0;
rangeCount = 0;
switch (phase) {
@@ -1612,9 +1612,9 @@ phonetic_ordinal_search:
record = records + phraseOrdinal * 12;
candidateCount = 0;
phoneticGroups = 0;
if (!Zi8MatchPhonetic(phoneticTable, (ZiChineseRecord*)records, alternateTable, alternateCount,
phraseTable, (ZiChineseRecord*)record, match.phon, match.phon2,
&candidateCount, (ZiChineseRecord**)&record, (int*)&phoneticGroups,
if (!Zi8MatchPhonetic(phoneticTable, records, alternateTable, alternateCount,
(ziU32)phraseTable, record, match.phon, match.phon2,
&candidateCount, &record, &phoneticGroups,
0, 1, match.nCand, phoneticMask, phoneticMatch, charset, requireFull,
phraseOrdinal, &candidateOrdinal, 0, work)) continue;
if (charsetTable) {
@@ -1676,8 +1676,8 @@ tone_candidates:
if (emitWords) {
++emittedCount;
output[outputIndex++] = character;
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) goto engine_finish;
output[outputIndex] = ' ';
if (++outputIndex > outputLimit) goto engine_finish;
} else output[emittedCount++] = character;
if (emittedCount >= request->maxCandidates) goto engine_finish;
} else if (totalResults >= options->maxResults) goto engine_finish;
@@ -1752,12 +1752,12 @@ 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)) {
(ziU8)Zi8GetZHuwdPtr(&userEntriesAddress, &userCount, work) && (getMode != 0 || match.nSeg <= 1)) {
userIndex = 0;
while (userIndex < userCount) {
candidateOrdinal = (ziU16)(userEntries[1] & 0x7F) << 8 | userEntries[2];
candidateOrdinal = (ziU16)(((ziU8*)userEntriesAddress)[1] & 0x7F) << 8 | ((ziU8*)userEntriesAddress)[2];
record = records + candidateOrdinal * 12;
if (!(record[0] & charset)) goto user_character_next;
character = ((ziU16)record[6] << 8) + record[7];
@@ -1792,7 +1792,7 @@ user_character_search:
(ziU8)Zi8SecMatchChar(record, componentTable, &match, 0, work)) candidateStatus = 1;
break;
case 1: case 2:
if (request->elementCount && !(userEntries[1] & 0x80)) candidateStatus = 0;
if (request->elementCount && !(((ziU8*)userEntriesAddress)[1] & 0x80)) candidateStatus = 0;
else {
candidateStatus = (match.first & (ziU16)Zi8GetPCode(phoneticTable, record)) == match.first2;
if (!candidateStatus && (record[0] & 0x80) && !requireFull &&
@@ -1827,7 +1827,7 @@ user_character_search:
}
user_character_next:
++userIndex;
userEntries += 3;
userEntriesAddress += 3;
}
}
if (!prefixLookup) goto phonetic_alt_continue;
@@ -1912,7 +1912,7 @@ cangjie_components:
Zi8GetTableCount(1, 16, work) && elements[0] != 0xEF00 && getMode != 5) {
rangeIndex = 0;
rangeCount = 0;
phoneticGroups = Zi8GetTableAddress(1, 16, work);
phoneticGroups = (ziU8*)Zi8GetTableAddress(1, 16, work);
switch (phase) {
case 0: rangeIndex = 0; rangeCount = 2; phase = 1; break;
case 1:
@@ -2052,7 +2052,7 @@ component_record_next:
if (getMode != 5) {
while (exactPhrase) {
while (match.count) {
if (!candidateCount--) goto frequency_range_retry;
if ((candidateCount -= 1) == 0xFFFF) goto frequency_range_retry;
if (match.arrD[0] == (record[0] & match.arr1[0]) &&
(ziU8)Zi8SecMatchChar(record, componentTable, &match, &candidateOrdinal, work)) goto frequency_accept;
record += 12;
@@ -2199,7 +2199,7 @@ phonetic_main:
if (Zi8GetFormatVersion(1, work) >= 4) rangeCount = Zi8GetTableCount(1, 23, work);
else rangeCount = 0;
if (rangeCount && match.nCand == 2 && emitWords) {
frequencyCursor = Zi8GetTableAddress(1, 24, work);
frequencyCursor = (ziU8*)Zi8GetTableAddress(1, 24, work);
frequencyEntry = frequencyCursor;
duplicateIndex = Zi8GetTableCount(1, 24, work);
if (!duplicateIndex) isFirstCandidate = 1;
@@ -2298,7 +2298,7 @@ phonetic_pair_next:
alternateCursor += 4;
}
phonetic_group_next:
++ordinalIndex;
ordinalIndex += 1;
frequencyCursor += 5;
}
}
@@ -2323,9 +2323,9 @@ phonetic_ordinals:
candidateCount = recordCount;
phoneticGroups = 0;
while (emittedCount < request->maxCandidates && candidateCount) {
if (!Zi8MatchPhonetic(phoneticTable, (ZiChineseRecord*)records, alternateTable, alternateCount,
phraseTable, (ZiChineseRecord*)record, match.phon, match.phon2,
&candidateCount, (ZiChineseRecord**)&record, (int*)&phoneticGroups,
if (!Zi8MatchPhonetic(phoneticTable, records, alternateTable, alternateCount,
(ziU32)phraseTable, record, match.phon, match.phon2,
&candidateCount, &record, &phoneticGroups,
emitWords, singleCharacterPass, match.nCand, phoneticMask, phoneticMatch, charset,
requireFull, recordCount, &candidateOrdinal, filteringMode, work)) break;
ordinalIndex = recordCount - candidateCount - 1;
@@ -2446,7 +2446,7 @@ engine_finish:
return totalResults;
filtered_search:
userIndex = Zi8GetTableCount(1, 31, work);
frequencyTable = Zi8GetTableAddress(1, 31, work);
frequencyTable = (ziU8*)Zi8GetTableAddress(1, 31, work);
for (; userIndex; --userIndex) {
index = frequencyTable[0] & 15;
if (!(*frequencyTable++ & charset)) goto filtered_next;
@@ -2572,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;
@@ -2608,10 +2608,10 @@ static int Zi8NewMatchPhonetic(ziGetParam* request, ZiChineseRecord* records,
ziU8* phonetics;
int totalResults;
int emittedCharacters;
ZiChineseRecord* matchedRecord;
ziU8* matchedRecord;
ziU8* phoneticGroups;
ziU8* candidateGroups;
int matchedIndex;
ziU8* matchedString;
int capacity;
ziU8* groupCandidates;
ziU16 phoneticCount;
@@ -2645,20 +2645,20 @@ static int Zi8NewMatchPhonetic(ziGetParam* request, ZiChineseRecord* records,
if ((mask & 7) == 7) {
stopAfterTone = match & 7;
}
phoneticOffsets = Zi8GetTableAddress(1, 13, work);
ordinalTable = Zi8GetTableAddress(1, 14, work);
phoneticOffsets = (ziU16*)Zi8GetTableAddress(1, 13, work);
ordinalTable = (ziU16*)Zi8GetTableAddress(1, 14, work);
if (pinyin) {
phonetics = Zi8GetTableAddress(1, 3, work);
phonetics = (ziU8*)Zi8GetTableAddress(1, 3, work);
phoneticCount = Zi8GetTableCount(1, 3, work);
phoneticGroups = Zi8GetTableAddress(1, 17, work);
phoneticGroups = (ziU8*)Zi8GetTableAddress(1, 17, work);
groupCount = Zi8GetTableCount(1, 17, work);
candidateGroups = Zi8GetTableAddress(1, 18, work);
candidateGroups = (ziU8*)Zi8GetTableAddress(1, 18, work);
} else {
phonetics = Zi8GetTableAddress(1, 4, work);
phonetics = (ziU8*)Zi8GetTableAddress(1, 4, work);
phoneticCount = Zi8GetTableCount(1, 4, work);
phoneticGroups = Zi8GetTableAddress(1, 19, work);
phoneticGroups = (ziU8*)Zi8GetTableAddress(1, 19, work);
groupCount = Zi8GetTableCount(1, 19, work);
candidateGroups = Zi8GetTableAddress(1, 20, work);
candidateGroups = (ziU8*)Zi8GetTableAddress(1, 20, work);
}
if (groupCount) {
@@ -2782,12 +2782,12 @@ next_group_candidate:
}
}
if (stopAfterTone) {
matchedRecord = records + character;
matchedRecord = (ziU8*)(records + character);
matchedLength = 0;
matchedIndex = 0;
if (!Zi8MatchPhonetic(phonetics, records, indexTable, indexCount,
dictionary, matchedRecord, &mask, &match,
&matchedLength, &matchedRecord, &matchedIndex,
matchedString = 0;
if (!Zi8MatchPhonetic(phonetics, (ziU8*)records, indexTable, indexCount,
(ziU32)dictionary, matchedRecord, &mask, &match,
&matchedLength, &matchedRecord, &matchedString,
wordMode, 1, 1, excludedMask, excludedMatch,
charset, request->getOptions & 0x40, character,
&matchedTone, 0, work)) {

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,36 +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) {
ZI_WORK->unk_0x1764 = (ziU8*)(tableAddress = Zi8GetTableAddress(language & 0xff,0xb,ZI_WORK));
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;
}
}
@@ -230,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) {
@@ -262,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;
}
}

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,7 +158,7 @@ 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;
@@ -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->countOnly == 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->countOnly = options->countOnly;
ZI_WORK->unk_0x00 = '\x01';
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->countOnly == 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->countOnly = options->countOnly;
ZI_WORK->unk_0x00 = '\x01';
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->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)) {
@@ -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;
*(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;
@@ -44,17 +44,17 @@ ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
ZI_WORK->unk_0x1874 = 0x2D;
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->zhPudMinPrefix = 5;
ZI_WORK->cangjieEnabled = Zi8GetFormatVersion(1, ZI_WORK) & 2;
ZI_WORK->unk_0x1B28.bits.msb = 1;
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);
@@ -62,7 +62,7 @@ ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
return 1;
}
ziU8 Zi8IsZicorpSignature(ziU16* p, ziU16 len) {
ziU8 Zi8IsZicorpSignature(ziU16* p, ziU16 len ZI_NEED_WORK) {
if ((ziU16)len > 6 && p[0] == 0x7A && p[1] == 0x69 && p[2] == 0x63 &&
p[3] == 0x6F && p[4] == 0x72 && p[5] == 0x70) {
return 1;

View File

@@ -254,7 +254,7 @@ ziBool Zi8PriMatchNextComp(ziU8* node, ziU8 mask0, ziU8 value0, ziU8 mask1, ziU8
return 0;
}
ziBool Zi8SecMatchComp(ziPtr nodeAddress, ziMatchParam* matchAddress, ziPtr dictionaryAddress) {
ziBool Zi8SecMatchComp(ziPtr nodeAddress, ziMatchParam* matchAddress, ziPtr dictionaryAddress ZI_NEED_WORK) {
int chainIndex;
ziU16 matchCode;
ziU16 targetCode;
@@ -506,7 +506,7 @@ pinyin_initial:
convertedCount = Zi8PinyinInitials[value];
if (convertedCount != 0) {
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
*resultCount += 1;
}
result++;
initial[outputIndex] = 0x7E00;
@@ -526,7 +526,7 @@ pinyin_initial:
value = *current;
if (value != 0x68 && value != 0xF368) goto scan_final;
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
*resultCount += 1;
}
final[outputIndex] += 0x200;
*bestInitial = initial[0];
@@ -567,7 +567,7 @@ scan_final:
value -= 0xF361;
if (value > 0x19) {
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
*resultCount += 1;
}
goto finish_final;
}
@@ -577,7 +577,7 @@ scan_final:
pinyin[index] = (ziU8)value + 1;
if (Zi8GetPyFinal(pinyin, &pyInitial, &pyFinal) == 0) goto try_final_extension;
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
*resultCount += 1;
}
current++;
index++;
@@ -592,7 +592,7 @@ try_final_extension:
pinyin[index + 1] = 0xFF;
if (Zi8GetPyFinal(pinyin, &pyInitial, &pyFinal) != 0) {
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
*resultCount += 1;
}
pinyin[index + 1] = 0;
current++;
@@ -615,7 +615,7 @@ try_final_extension:
finish_final:
if ((index > 3) && (count != 0) && (((value = *current) == 0x27) || (value == 0xF360) || (value == 0x20))) {
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
*resultCount += 1;
}
current++;
count--;
@@ -705,11 +705,10 @@ finish_final:
}
}
}
outputIndex++;
if (outputIndex > 0xf) break;
if (++outputIndex > 0xf) break;
}
if ((result > 1) && (text[*resultCount - 1] >= 0xF341) && (text[*resultCount - 1] <= 0xF35A)) {
*resultCount = *resultCount - 1;
*resultCount -= 1;
}
return result;
@@ -743,9 +742,9 @@ check_row:
return 0;
}
ziS32 Zi8GetBpmfPhonetic(ziWChar* text, ziU8 count, ziU16* initial, ziU16* final, ziU16* bestInitial, ziU16* bestFinal ZI_NEED_WORK) {
ziU8 Zi8GetBpmfPhonetic(ziWChar* text, ziU8 count, ziU16* initial, ziU16* final, ziU16* bestInitial, ziU16* bestFinal ZI_NEED_WORK) {
ziU16 value;
ziU32 resultCount = 0;
ziU8 resultCount = 0;
Zi8LogError(0x64, ZI_WORK);
if (count == 0) {

View File

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

@@ -17,7 +17,7 @@ typedef struct ziPudHeader {
ziU8 options[4];
ziPudSection sections[1];
} ziPudHeader;
ziU32 Zi8_8147FD7C(ziWChar*, ziU8, ziU8, ziWChar*, ziU16, ziU8, ziU8 ZI_NEED_WORK);
ziU8 Zi8_8147FD7C(ziWChar*, ziU8, ziU8, ziWChar*, ziU16, ziU8, ziU8 ZI_NEED_WORK);
ziU32 ZiIsPhoneticChar(ziWChar character) {
if ((character < 0xF305 || character > 0xF329) && (character < 0xF361 || character > 0xF37A)) return 0;
@@ -56,8 +56,11 @@ ziU8 ZADP_Zi8SetPDremoveOpt(ziU8 option, struct __zi8_work_data_s* __zi8_work_da
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 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziWChar* spelling, ziU16 spellingCapacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
struct {
int fallback;
ziPtr workspace;
} match;
ziU8* bytePattern;
ziWChar folded;
ziPudSection* section;
@@ -68,6 +71,8 @@ ziU32 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar*
ziU32 entrySize;
ziPudHeader* table;
ziU8* byteOutput;
match.workspace = __zi8_work_data;
match.fallback = 0;
if (!(ZI_WORK->pudCount <= 16 && ZI_WORK->pudCount != 0 && ZI_WORK->pudTable[ZI_WORK->pudCount - 1] != 0)) {
Zi8LogError(0x4B0, __zi8_work_data);
return 0;
@@ -88,8 +93,8 @@ ziU32 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar*
Zi8LogError(0x4F6, __zi8_work_data);
return 0;
}
ZI_WORK->unk_0x314 = section->count[0] * 0x100 + section->count[1];
ZI_WORK->unk_0x310 = (ziU32)table + section->offset[0] * 0x100 + section->offset[1];
ZI_WORK->unk_0x314 = ((ziU16)section->count[0] << 8) + (ziU16)section->count[1];
ZI_WORK->unk_0x310 = (ziU32)table + (((ziU16)section->offset[0] << 8) + (ziU16)section->offset[1]);
ZI_WORK->unk_0x318 = 0;
}
for (;;) {
@@ -102,7 +107,7 @@ ziU32 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar*
wordSize = *word++;
entrySize = wordSize;
if (language == 1) {
if (ZI_WORK->unk_0x17 > *word) goto next;
if (ZI_WORK->zhPudMinPrefix > *word) goto next;
wordSize--;
entrySize--;
word++;
@@ -126,11 +131,11 @@ matchText:
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->unk_0x1F || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[index])) goto next;
if (folded != pattern[index] && (!ZI_WORK->ignoreCase || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[index])) goto next;
}
}
matched:
if (fallback) {
if (match.fallback) {
ZI_WORK->unk_0x310 = 0;
ZI_WORK->unk_0x318 = 0;
ZI_WORK->unk_0x314 = 0;
@@ -164,7 +169,7 @@ matched:
}
if (length == 1 && complete != 0 && continuation == 0) {
complete = 0;
fallback = 1;
match.fallback = 1;
ZI_WORK->unk_0x318 = 0;
} else {
ZI_WORK->unk_0x310 = 0;
@@ -174,12 +179,12 @@ matched:
}
}
}
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;
ziU8 Zi8MatchPUDdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation, struct __zi8_work_data_s* __zi8_work_data) {
ziU8 result;
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 (result != 0) break;
if (++__zi8_work_data->pudCount <= 16) {
continuation = 0;
} else {
@@ -189,6 +194,6 @@ ziU32 Zi8MatchPUDdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* out
}
return result;
}
ziU32 Zi8_8147FD7C(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
ziU8 Zi8_8147FD7C(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
return Zi8MatchPUDdata_ZHS(pattern, length, language, output, capacity, 0, 0, complete, continuation, __zi8_work_data);
}

View File

@@ -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 && candidate->priority < word->priority) break;
if (ZI_WORK->uwdPrioritySort == 1 && candidate->priority < word->priority) break;
if (candidate->length == length) {
position = 0;
while (position < length) {
@@ -105,11 +105,11 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
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) {
text = (ziU8*)Zi8_814803F4(__zi8_work_data);
entryLength = 0;
@@ -148,7 +148,7 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
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);
}
@@ -192,7 +192,7 @@ next:
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->unk_0x1F || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[position])) goto next;
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) {

View File

@@ -1,13 +1,13 @@
#include <zi8clib/zitypes.h>
ziU16 Zi8GetVersion() {
ziU16 Zi8GetVersion(ziPtr __zi8_work_data) {
return 1802;
}
ziU16 Zi8GetBuildID() {
ziU16 Zi8GetBuildID(ziPtr __zi8_work_data) {
return 41;
}
ziU16 Zi8GetOEMID() {
ziU16 Zi8GetOEMID(ziPtr __zi8_work_data) {
return 249;
}

View File

@@ -163,9 +163,9 @@ ziU32 ZiDAWGGetGraph(ziPtr context) {
}
ziU32 ZiDAWGGetGraphInfo(zi8DawgCtx* context, ziU8* entry, ziU16* keys) {
ziU32 graph;
ziU8 depth;
ziU32 end;
ziU32 graph;
ziS32 result;
graph = ZiDAWGGetGraph(context);
@@ -199,10 +199,10 @@ checkEntry:
}
result = graph + (ziU32)entry[4] * 0x10000 + (((ziU16)entry[5] << 8) + entry[6]);
((zi8DawgCtx*)context)->unk_0x338 =
context->endNode =
graph + (ziU32)entry[7] * 0x10000 + (((ziU16)entry[8] << 8) + entry[9]);
if (((zi8DawgCtx*)context)->unk_0x338 == graph) {
((zi8DawgCtx*)context)->unk_0x338 = 0;
if (context->endNode == graph) {
context->endNode = 0;
}
if ((((ziU16)entry[0] << 8) + entry[1]) == 0) {

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

@@ -45,8 +45,8 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
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;
ziU32 savedFormats = ZI_WORK->formats;
ziU8 savedCount = ZI_WORK->formatCount;
ziSearchState search = {0};
Zi8LogError(100, __zi8_work_data);
if (word == 0 || *word == 0) {
@@ -73,22 +73,22 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
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 = 2;
else ZI_WORK->unk_0x1418 = 1;
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) {

View File

@@ -11,15 +11,15 @@ typedef struct {
ziU8 characterLow;
} ZiKoreanKeyEntry;
ziU32 Zi8_8148302C(ziU16 key, ziU8* table ZI_NEED_WORK) {
ziU16 Zi8_8148302C(ziU16 key, ziU8* table ZI_NEED_WORK) {
ziU32 value;
ziU16 count;
ziU32 i;
ziU16 i;
count = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
for (i = 0; (ziU16)i < count; i++) {
value = (ziU16)(((ziU16)table[((i & 0xFFFF) << 3) + (i & 0xFFFF) + 7] << 8) |
table[((i & 0xFFFF) << 3) + (i & 0xFFFF) + 8]);
for (i = 0; i < count; i++) {
value = (ziU16)(((ziU16)table[(i << 3) + i + 7] << 8) |
table[(i << 3) + i + 8]);
if (value == key) {
Zi8LogError(0x64, ZI_WORK);
return i;
@@ -119,28 +119,19 @@ ziU32 Zi8_814833F0(const ziGetParam* param, ziU16 key ZI_NEED_WORK) {
ziU32 Zi8_814834AC(ziGetParam* param, ziU16* remaining, ziU8* count,
ziU8* inserted ZI_NEED_WORK) {
struct {
ziBool matches;
ziU8 candidateIndex;
ziU16 tableCount;
ziS32 compactIndex;
ZiKoreanKeyEntry* entry;
ziU8* tableB;
ziU8* tableA;
union {
ziU32 firstWord;
ziU8 bytes[5];
} keys;
} filter;
ziU32 j;
ziU8* tableA;
ziU8* tableB;
ZiKoreanKeyEntry* entry;
ziS32 compactIndex;
ziU16 tableCount;
ziU32 j = 0;
ziU8 candidateIndex = 0;
ziU8 matched = 0;
ziBool matches;
ziU8 keys[5] = {0};
ziS32 i;
ziS32 candidate;
ziU8 matched;
j = 0;
filter.candidateIndex = 0;
matched = 0;
filter.keys.bytes[4] = filter.keys.firstWord = 0;
Zi8LogError(0x64, ZI_WORK);
if (param->elementCount == 0) {
if (*remaining >= *count) {
@@ -166,40 +157,40 @@ ziU32 Zi8_814834AC(ziGetParam* param, ziU16* remaining, ziU8* count,
return 0;
}
filter.tableA = (ziU8*)Zi8GetTableAddress(param->language, 9, ZI_WORK);
filter.tableB = (ziU8*)Zi8GetTableAddress(param->language, 10, ZI_WORK);
if (filter.tableA == 0) {
tableA = (ziU8*)Zi8GetTableAddress(param->language, 9, ZI_WORK);
tableB = (ziU8*)Zi8GetTableAddress(param->language, 10, ZI_WORK);
if (tableA == 0) {
Zi8ReplaceLastError(0x76C, ZI_WORK);
return 0;
} else if (filter.tableB == 0) {
} else if (tableB == 0) {
Zi8ReplaceLastError(0x776, ZI_WORK);
return 0;
} else {
filter.tableCount = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
Zi8_81483118(param, filter.keys.bytes);
tableCount = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
Zi8_81483118(param, keys);
i = 0;
while (i < filter.tableCount && matched < *count) {
filter.matches = ZI8_TRUE;
filter.entry = (ZiKoreanKeyEntry*)&filter.tableA[(i << 3) + i];
while (i < tableCount && matched < *count) {
matches = ZI8_TRUE;
entry = (ZiKoreanKeyEntry*)&tableA[(i << 3) + i];
j = 0;
if (param->elementCount > 1) {
for (j = 0; (int)(j & 0xFF) < (int)param->elementCount / 2; j++) {
if (filter.keys.bytes[j & 0xFF] != filter.entry->keyBytes[j & 0xFF]) {
filter.matches = ZI8_FALSE;
if (keys[j & 0xFF] != entry->keyBytes[j & 0xFF]) {
matches = ZI8_FALSE;
break;
}
}
}
if (filter.matches && (param->elementCount % 2) != 0 &&
((filter.keys.bytes[j & 0xFF] & 0xF0) != (filter.entry->keyBytes[j & 0xFF] & 0xF0))) {
filter.matches = ZI8_FALSE;
if (matches && (param->elementCount % 2) != 0 &&
((keys[j & 0xFF] & 0xF0) != (entry->keyBytes[j & 0xFF] & 0xF0))) {
matches = ZI8_FALSE;
}
if (filter.matches) {
for (filter.candidateIndex = 0; filter.candidateIndex < *count; filter.candidateIndex++) {
if (param->candidates[filter.candidateIndex] ==
(((ziU16)((ZiKoreanKeyEntry*)filter.tableA)[i].characterHigh << 8) | (ziU16)((ZiKoreanKeyEntry*)filter.tableA)[i].characterLow)) {
if (matches) {
for (candidateIndex = 0; candidateIndex < *count; candidateIndex++) {
if (param->candidates[candidateIndex] ==
(((ziU16)((ZiKoreanKeyEntry*)tableA)[i].characterHigh << 8) | (ziU16)((ZiKoreanKeyEntry*)tableA)[i].characterLow)) {
matched++;
param->candidates[filter.candidateIndex] &= 0x7FFF;
param->candidates[candidateIndex] &= 0x7FFF;
break;
}
}
@@ -225,10 +216,10 @@ ziU32 Zi8_814834AC(ziGetParam* param, ziU16* remaining, ziU8* count,
}
*remaining = 0;
} else {
for (filter.compactIndex = 0; filter.compactIndex < *count; filter.compactIndex++) {
if ((param->candidates[filter.compactIndex] & 0x8000) == 0) {
param->candidates[filter.compactIndex] |= 0x8000;
Zi8_81483308(param, param->candidates[filter.compactIndex], inserted, ZI_WORK);
for (compactIndex = 0; compactIndex < *count; compactIndex++) {
if ((param->candidates[compactIndex] & 0x8000) == 0) {
param->candidates[compactIndex] |= 0x8000;
Zi8_81483308(param, param->candidates[compactIndex], inserted, ZI_WORK);
}
}
*remaining = *remaining - matched;
@@ -287,8 +278,7 @@ ziU32 Zi8GetKOcandidates(ziGetParam* param, ZiKoreanCandidateOptions* options ZI
search.resultCount = 0;
search.packedKeys.firstWord = 0;
search.packedKeys.bytes[4] = 0;
search.remainingLetters = 0;
search.wordIndex = 0;
search.wordIndex = search.remainingLetters = 0;
search.candidateCount = 0;
search.keyByte = 0;
search.remainingCandidates = param->firstCandidate;
@@ -309,11 +299,12 @@ 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);
if (param->wordCharCount != 0) {
if (param->wordCharCount == 0) goto scan_key_table;
{
if (((search.keyIndex = Zi8_8148302C(param->currentWord[0], keyTable, ZI_WORK)) != 0xFFFF) &&
((((ZiKoreanKeyEntry*)(((search.keyIndex << 3) + search.keyIndex) + keyTable))->keyBytes[4] & 8) != 0)) {
search.wordOffset = ((ZiKoreanKeyEntry*)(((search.keyIndex << 3) + search.keyIndex) + keyTable))->childLow |
@@ -365,22 +356,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 +386,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,9 +426,10 @@ 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;
}
scan_key_table:
if (param->elementCount > 9) {
param->letters = 0;
return 0;

View File

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

@@ -21,6 +21,7 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
ziWChar bestFinal;
ziWChar previousInitial;
ziWChar previousFinal;
ziBool hasComponent;
ziU8 elementCount;
ziU8 elementIndex;
ziU8 stroke;
@@ -43,6 +44,7 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
stroke = 0;
contextMask = 0x20;
Zi8Memset(match,0,0x1ee);
hasComponent = 0;
nibbles = 0;
elementIndex = 0;
elementCount = request->elementCount;
@@ -58,13 +60,15 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
}
}
if (elementCount != 0) {
match->comp = element = request->elements[0];
element = request->elements[0];
match->comp = element;
if (Zi8IsComponent(element,__zi8_work_data) != 0) {
elementIndex++;
hasComponent = 1;
buffers.component = (ziU8*)Zi8GetTableAddress(1,2,__zi8_work_data);
buffers.componentIndex = (ziU8*)Zi8GetTableAddress(1,6,__zi8_work_data);
buffers.componentIndex += (element - 0xef10) * 2;
match->field22 = (((ziU16)buffers.componentIndex[1] & 0x3f) << 8) + *buffers.componentIndex;
match->field22 = ((buffers.componentIndex[1] & 0x3f) << 8) + *buffers.componentIndex;
buffers.component += (ziU32)match->field22 * 8;
switch(*buffers.component & 0xf) {
case 0:
@@ -219,13 +223,14 @@ ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode Z
Zi8Memcpy((ziU8 (*)[12])match->segs1 + match->nSeg,buffers.masks,0xc);
Zi8Memcpy((ziU8 (*)[12])match->segsD + match->nSeg,buffers.strokes,0xc);
match->nSeg++;
if (stroke != 0xff || elementIndex >= elementCount || match->nSeg >= 0x10) goto complete;
if (stroke != 0xff || elementIndex >= elementCount || match->nSeg >= 0x10) break;
Zi8Memset(buffers.masks,0,0xc);
Zi8Memset(buffers.strokes,0,0xc);
buffers.masks[0] = match->arr1[0] & 0xf0;
buffers.strokes[0] = match->arrD[0] & 0xf0;
nibbles = 1;
} while (1);
return 1;
}
match->length = nibbles;
if (elementCount != 0) {
@@ -239,20 +244,18 @@ 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;
final = 0;
bestInitial = 0;
bestFinal = 0;
previousInitial = 0;
previousFinal = 0;
bestFinal = bestInitial = 0;
previousFinal = previousInitial = 0;
buffers.phoneticInput = request->elements;
match->nCand = 0;
request->count = request->elementCount;
request->completion = request->elementCount;
phoneticLength = 1;
for (index = 0; index < elementCount; index++) {
for (index = 0; index < elementCount;) {
stroke = Zi8GetBpmfPhonetic(buffers.phoneticInput,phoneticLength,&initial,&final,&bestInitial,&bestFinal,
__zi8_work_data);
if (stroke != 0) {
@@ -280,19 +283,18 @@ savePhonetic:
}
if (buffers.phoneticInput[phoneticLength - 1] == 0xF360) {
match->nCand--;
bestInitial = previousInitial;
bestFinal = previousFinal;
final = bestFinal;
initial = bestInitial;
bestInitial = initial = previousInitial;
bestFinal = final = previousFinal;
goto savePhonetic;
}
if (match->nCand == 1) {
request->count = phoneticLength - 1;
request->completion = phoneticLength - 1;
}
buffers.phoneticInput = buffers.phoneticInput + phoneticLength - 1;
phoneticLength = 0;
index--;
}
index++;
phoneticLength++;
}
if (elementCount != 0) {
@@ -306,7 +308,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;
@@ -331,6 +333,5 @@ savePhonetic:
}
}
}
complete:
return 1;
}

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

@@ -26,7 +26,7 @@ typedef struct 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

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

@@ -242,61 +242,25 @@ L_2b0:
blr
}
asm void _CNTCACHEDeleteTitle() {
stwu r1, -0x20(r1)
mflr r0
li r3, 0
la r4, scCntCacheSpaceNl
stw r0, 0x24(r1)
stw r31, 0x1c(r1)
stw r30, 0x18(r1)
stw r29, 0x14(r1)
stw r28, 0x10(r1)
bl strtok
li r30, 0
li r31, -1
b L_370
L_304:
stw r30, errno(r0)
li r4, 0
li r5, 0x10
bl strtoull
lwz r0, errno(r0)
mr r28, r4
mr r29, r3
cmpwi r0, 0
bne L_364
and r0, r3, r31
cmplwi r0, 1
beq L_364
bl _CNTCACHEIsTitleRemovable
cmpwi r3, 1
bne L_350
mr r4, r28
mr r3, r29
bl ES_DeleteTitle
b L_364
L_350:
cmpwi r3, 0
bne L_364
mr r4, r28
mr r3, r29
bl ES_DeleteTitleContent
L_364:
li r3, 0
la r4, scCntCacheSpaceNl
bl strtok
L_370:
cmpwi r3, 0
bne L_304
lwz r0, 0x24(r1)
lwz r31, 0x1c(r1)
lwz r30, 0x18(r1)
lwz r29, 0x14(r1)
lwz r28, 0x10(r1)
mtlr r0
addi r1, r1, 0x20
blr
void _CNTCACHEDeleteTitle() {
char* token = strtok(NULL, scCntCacheSpaceNl);
while (token != NULL) {
ESTitleId titleId;
int removable;
errno = 0;
titleId = strtoull(token, NULL, 16);
if (errno == 0 && (u32)ES_TITLE_TYPE(titleId) != 1) {
removable = _CNTCACHEIsTitleRemovable(titleId);
if (removable == 1) {
ES_DeleteTitle(titleId);
} else if (removable == 0) {
ES_DeleteTitleContent(titleId);
}
}
token = strtok(NULL, scCntCacheSpaceNl);
}
}
asm int _CNTCACHEIsTitleRemovable(ESTitleId titleId) {

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