Compare commits

...

191 Commits

Author SHA1 Message Date
Cursor Agent
4f654f72a9 data(NHTTP_request): match multipart boundary .rodata size
Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 22:16:06 +00:00
coah
5c20a11fa8 Restore truncated PC-keyboard event thunk name (#519) 2026-10-01 17:15:31 -05:00
coah
f85a98a6e3 cleanup(iplSettingSelect): name exit-sequence helpers (#516)
Rename Matching-only fn_* exit/reboot helpers to descriptive
snake_case names; update mangled symbols.txt entries.
2026-10-01 17:15:19 -05:00
coah
137ee3242a cleanup(iplCSPane): name fatal OSFatal color/msg and zero float (#511)
lbl_81697844..47 → scCsFatalColorR/G/B/A, lbl_8166A6E3 → scCsFatalMsg,
lbl_81694FC0 → scCsZeroF.
2026-10-01 17:15:08 -05:00
coah
2368a9a774 cleanup(tiHwKeyboard): name EU/non-EU country map tables (#515)
Rename Matching-only setLanguage country lookup tables and
symbols.txt entries.
2026-10-01 17:13:57 -05:00
coah
90399bb6cf cleanup(iplDate): name calendar date pane/string labels (#518)
Matching-only renames in scene/calendar/iplDate (+ symbols.txt).
2026-10-01 17:13:54 -05:00
coah
fc831357ea CDBDatabase: convert Close and FindByKey to matching C (#491)
* CDBDatabase: convert Close and FindByKey to matching C

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

* CDBDatabase: reuse labeled error strings for Close/FindByKey

Point CDBReportError at the existing lbl_ string pool entries so the
linked DOL matches baserom SHA1 26116613f624061ba99c8d1a299aaa6efa85670d.
2026-10-01 17:13:50 -05:00
coah
e2191ae933 cleanup(TVRC): name timing constants and file header (#509)
lbl_816945C8/D0/D8/E0 → scTvrcMsPerSec/NsecPerSec/One/FloatMagic;
lbl_81696230 → scTvrcFileHeader ("TVR0").
2026-10-01 17:11:51 -05:00
coah
7d77c095c0 cleanup(iplSystem): name ortho viewport float constants (#508)
lbl_81694424..38 → scOrthoLeft/Right/Bottom/Top and scWideOrthoLeft/Right.
2026-10-01 17:10:58 -05:00
coah
db8ff7e141 cleanup(www_window): name debug/error format strings (#507)
lbl_816962F8 → scWwwErrorQ, lbl_81643B40 → scWwwTexBufFmt,
lbl_81643B5E → scWwwNoBrowserWin.
2026-10-01 17:10:19 -05:00
github-actions[bot]
2cb6c2dfae docs: update progress [skip ci] 2026-10-01 22:09:43 +00:00
coah
6f96235605 cleanup(tiGUIManager): name sdata2 zero/half/line-color constants (#506)
lbl_81694EE8 → scGuiZeroF, lbl_81694EF0 → scGuiHalfF,
lbl_81694EEC..F → scGuiLineColorR/G/B/A.
2026-10-01 17:09:30 -05:00
coah
367b042e63 Restore memo input vtable declarations and emission order (#505) 2026-10-01 17:08:19 -05:00
coah
feb7ba400d cleanup(Contest): rename NHTTP callback error; drop dead locals (#504)
param_1 → error in sNHTTPReqCallback; remove unused Ghidra locals
from IPLContestInitialize.
2026-10-01 17:07:39 -05:00
coah
20f4af8beb cleanup(NakamuraTest): rename Ghidra locals (#503)
iVar8 → nupResult, iVar7 → startupErr; drop unused iVar1 in conntestthread.
2026-10-01 17:06:56 -05:00
coah
dca6cd9aef cleanup(HermiteIntp): name start/end tangents (#502)
Rename Ghidra param_5/param_6 and unkVal0/unkVal1 to startTangent/endTangent
and mStartTangent/mEndTangent across the HermiteIntp header and users.
2026-10-01 17:05:40 -05:00
coah
a0700bf908 cleanup(NetSetup): rename param_1 → connType (#501)
iSOStartupEXThread arg is mConnType (passed to NETGetStartupErrorCodeEx).
2026-10-01 17:04:56 -05:00
coah
de058b4298 cleanup(NCDSetting): rename uVar1 → privacyMode (#500)
Local mapped privacy mode in setWDPrivacyMode; Matching-only rename.
2026-10-01 17:04:38 -05:00
github-actions[bot]
c5468cbe50 docs: update progress [skip ci] 2026-10-01 22:04:12 +00:00
coah
62591733eb cleanup(BoardObject): rename local_28 → truncatedThumb (#499)
Local wchar temporary used when truncating thumbnail text; Matching-only rename.
2026-10-01 17:03:10 -05:00
coah
e2488b073a cleanup: rename OptOutButton pane name strings (#498)
Rename lbl_816966F9/lbl_816967B5 to scPaneName_B_Stop/T_Stop.
DOL sha1 unchanged.
2026-10-01 17:02:53 -05:00
coah
9a8de22195 Link fully matched letter input form (#497) 2026-10-01 17:01:45 -05:00
coah
a6bf0e5f4f cleanup: rename AOSSThread SO alloc/free callbacks (#495)
Rename AOSSThread_813FCC8C/E4 to aossAlloc/aossFree. DOL sha1 unchanged.
2026-10-01 17:00:23 -05:00
coah
d434f5b897 cleanup: rename CdbBackup progress percent helper (#494)
Rename fn_8135B1C0 to getProgressPercent. DOL sha1 unchanged.
2026-10-01 17:00:18 -05:00
github-actions[bot]
0adc759b42 docs: update progress [skip ci] 2026-10-01 21:58:44 +00:00
coah
9c55b47c1d Emit hardware keyboard country tables after input template (#493) 2026-10-01 16:57:52 -05:00
coah
081329daa8 cleanup: rename TVRCManager start-delay counter (#492)
Rename lbl_8169877C to sTvrcStartDelay. DOL sha1 unchanged.
2026-10-01 16:57:46 -05:00
coah
a348c9777a cleanup: rename HBMController alarm-created flag (#490)
Rename lbl_816989BC to sAlarmCreated. DOL sha1 unchanged.
2026-10-01 16:55:12 -05:00
github-actions[bot]
d5204f5c62 docs: update progress [skip ci] 2026-10-01 21:54:05 +00:00
coah
cedc1f1390 cleanup: rename SaveDataManager title-cache helpers (#488)
Rename address-suffixed title-cache helpers to readable names without
changing codegen. DOL sha1 unchanged.
2026-10-01 16:54:01 -05:00
coah
ff0cce33f6 Correct concatenated cursor-cache method symbol (#487) 2026-10-01 16:53:27 -05:00
github-actions[bot]
2beeb23a47 docs: update progress [skip ci] 2026-10-01 21:53:24 +00:00
coah
35d9ed53b1 Fix letter animation rodata ownership boundary (#486) 2026-10-01 16:52:47 -05:00
coah
015d50906c Match tiTextDrawer Base::beginDraw height half via / 2.0f (#485)
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: coah <coah80@users.noreply.github.com>
2026-10-01 16:52:23 -05:00
github-actions[bot]
348da5bd89 docs: update progress [skip ci] 2026-10-01 21:52:04 +00:00
coah
cdceb82200 tiInputForm 214/221, 3 asm bodies left (worker 756360e6) (#489) 2026-10-01 16:50:38 -05:00
coah
1b56ea5051 Fix Korean jump-table ownership and link zikorean (#483)
* Correct Korean jump-table ownership and link the exact unit

* Correct Korean jump-table ownership and link the exact unit
2026-10-01 16:50:22 -05:00
coah
3946983f96 KPAD 19/29, kbd_lib 15/21 (objdiff) (worker 2ecd44fa) (#482) 2026-10-01 16:29:36 -05:00
github-actions[bot]
85d75cd0cf docs: update progress [skip ci] 2026-10-01 21:27:27 +00:00
coah
af39f2678f Match SD disk-info success return and restore its epilogue extent (#481)
* Restore the SD disk-info function's original epilogue extent

* Match explicit SD disk-info success return and update code total

* Match explicit SD disk-info success return and update code total
2026-10-01 16:26:40 -05:00
github-actions[bot]
d613662c54 docs: update progress [skip ci] 2026-10-01 21:17:45 +00:00
coah
0e6e235004 Correct PFSYS_TimeStamp's truncated symbol extent (#479)
* Include original stack restore and return in PFSYS_TimeStamp extent

* Account for timestamp epilogue in verified code-byte total
2026-10-01 16:17:08 -05:00
coah
020e1b6f0b iplSetting 105/112 (worker e1b8983d) (#480) 2026-10-01 16:16:23 -05:00
coah
3440aab039 Handle objects without .data in pool_diff (#478)
* Treat absent .data sections as empty string pools

* Test absent and unequal string pools
2026-10-01 16:11:01 -05:00
coah
dab806eaa2 Correct the 43U completion guard's expected unit count (#477) 2026-10-01 16:10:57 -05:00
github-actions[bot]
f4fd16f88f docs: update progress [skip ci] 2026-10-01 21:04:39 +00:00
coah
3d8de1a356 Link the exact-matching NAND driver (#476)
* Link NAND driver with verified storage layout

* Link NAND driver with verified storage layout

* Link NAND driver with verified storage layout
2026-10-01 16:03:40 -05:00
coah
8e43db0528 tiInputForm 210/221 (+8 KB matched code) (worker dad5faf7) (#475) 2026-10-01 16:00:46 -05:00
coah
21c9b95b1b NWC24Download 23/30 (worker 58d80e3c) (#474) 2026-10-01 15:41:52 -05:00
coah
d4bdd3462c iplAddress 94/101 (worker 98388c1d) (#473) 2026-10-01 15:40:46 -05:00
coah
f7d81a0196 CHANSVm 220/233 (worker 2f51b24f) (#472) 2026-10-01 12:31:21 -05:00
coah
4f35874d02 fix: drop unreferenced lbl_ double pinned in iplMemoryCard (#471) 2026-10-01 10:55:24 -05:00
coah
0a5cbaf78e iplAddress 93/101 (worker 81732f71) (#470) 2026-10-01 10:53:32 -05:00
coah
6e7c016ae3 CHANSVm 218/233 (worker 19444f58) (#469) 2026-10-01 10:52:18 -05:00
github-actions[bot]
e60306db62 docs: update progress [skip ci] 2026-10-01 14:03:51 +00:00
devin-ai-integration[bot]
5d0ced6a15 Link scene/memoryCard/iplMemoryCardBase (clean subset) (#468)
Gate Rect.~Rect and RuntimeTypeInfo.DynamicCast behind
IPL_MEMORYCARD_BASE_CPP so this TU emits the weak destructors and the
out-of-line dynamic cast the original object contains.

Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: coah80 <usernamecole7@gmail.com>
2026-10-01 14:03:09 +00:00
github-actions[bot]
858a507ddf docs: update progress [skip ci] 2026-10-01 12:54:41 +00:00
devin-ai-integration[bot]
ce424f1a3e Link scene/memoryCard/iplMemoryCard (clean subset) (#467)
Model MemCardEventListener as a novtable abstract base and give
MemCardEventHandler its full pure-virtual surface so the GCWindow and
MemoryCardManager vtables reproduce the original zero-slot layout.
Declare lbl_81694A78 as a file-scope const so the object exports the
u64->f64 conversion constant that iplMemoryCardBase.o references.

Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: coah80 <usernamecole7@gmail.com>
2026-10-01 12:54:08 +00:00
github-actions[bot]
bcb37e07ef docs: update progress [skip ci] 2026-10-01 11:41:02 +00:00
devin-ai-integration[bot]
11094c638a Link clib/zi8cinfo (#466)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-10-01 11:40:25 +00:00
coah
cb49bde9c6 NWC24Download 21/30 (worker b7c38d52) (#465) 2026-10-01 05:43:26 -05:00
coah
df9fd72e87 iplAddress 91/101, tiZiString 26/29 (worker 5e1635f3) (#464) 2026-10-01 05:37:54 -05:00
coah
0c554a1602 CHANSVm 217/233 (worker e7171d72) (#463) 2026-10-01 05:08:52 -05:00
coah
f00336cc8b NWC24Download 19/30, nup 18/23 (worker 1ac4946e) (#462) 2026-10-01 05:07:41 -05:00
coah
842bbc6942 tiCandidateBox 108/112, iplSDChannelSelect 117/129 (worker 993eabbf) (#461) 2026-10-01 05:06:29 -05:00
coah
ab01520044 CHANSVm: small fuzzy gains (worker b60f5370) (#460) 2026-10-01 03:31:36 -05:00
coah
5f948d3f3a AOSS 96.8, zi8alpha 94.2 (worker 5906998c) (#459) 2026-10-01 03:26:27 -05:00
coah
699f844395 CHANSVm 216/233 (worker b8f00dfb) (#458) 2026-10-01 03:05:28 -05:00
coah
3afb9d8425 iplSDChannelSelect 116/129, tiCandidateBox 104/112 (worker f7b4ed19) (#457) 2026-10-01 02:58:57 -05:00
coah
72c3f4ba2d zi8cgetc: tiny gains (worker 4e5688ba) (#456) 2026-10-01 02:45:50 -05:00
coah
905c45b998 AOSS 96.5, zi8alpha 93.1 (worker 58992861) (#455) 2026-10-01 02:41:34 -05:00
coah
5a849425b1 zi8cgetc: GetZH fuzzy 85 -> 96.4% (worker 68034ea8) (#454) 2026-10-01 02:16:35 -05:00
coah
fd11ddb195 AOSS fuzzy 96.3 (worker fc04bcfa) (#453) 2026-10-01 02:03:34 -05:00
coah
d9b51418b9 CHANSVm: blob unpack, hmac, slice, float parse (worker e953cfc4) (#452) 2026-10-01 02:02:26 -05:00
coah
87e7ab6922 iplSDChannelSelect, tiCandidateBox: structural fixes (worker d5dcdbc0) (#451) 2026-10-01 02:01:17 -05:00
github-actions[bot]
d186251506 docs: update progress [skip ci] 2026-10-01 05:27:53 +00:00
devin-ai-integration[bot]
cb58211725 Link cdb/CDBIntArray (#450)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-10-01 05:27:17 +00:00
github-actions[bot]
2dbf80c418 docs: update progress [skip ci] 2026-10-01 04:38:36 +00:00
devin-ai-integration[bot]
faee1f779d Link fa msc units + msc_drv (#449)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-10-01 04:37:58 +00:00
github-actions[bot]
a324e9a843 docs: update progress [skip ci] 2026-10-01 04:37:27 +00:00
devin-ai-integration[bot]
2bddfcde52 Link pfk_api, pfd_cmn, pf_cp932, pf_fat16, pf_stub (#448)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-10-01 04:36:51 +00:00
coah
776b7981df declsearch tool; odh/wad/KPAD/pf_dir closer (worker 8e7ae0d1) (#447) 2026-09-30 22:42:40 -05:00
coah
539693c76a AOSS fuzzy 88 -> 95, zi8alpha 93 (worker 3d36d663) (#446) 2026-09-30 22:25:48 -05:00
coah
3134c4c05a zi8cgetc: GetZH 81 -> 83% (worker ca7cac87) (#445) 2026-09-30 22:18:17 -05:00
coah
d60d10868a asm to C: CDBDatabase 33 -> 15 asm bodies, iplSound 14 -> 3 (worker d04fb346) (#444) 2026-09-30 22:16:35 -05:00
coah
735b0ab878 odh 22/28 (idct_fast, fdct_fast, LineDeconv* exact) (worker 8060e828) (#443) 2026-09-30 22:15:03 -05:00
coah
ea8d4d3b8a zi8cgetc: GetZH instruction count now matches (deficit 0), 81.4% (worker 04fae432) (#442) 2026-09-30 21:36:48 -05:00
coah
7329402a2c BS2Mach 24/29: NAND state globals volatile at definition (worker ddd698b1) (#441) 2026-09-30 21:34:55 -05:00
coah
e46168062b kbd_lib: kbdProcMod 63 -> 99.9%, data 100% (worker aef57ff5) (#440) 2026-09-30 21:27:26 -05:00
coah
b2074a70d7 regalloc sweep 2: CDBRecord 27/29 (worker 03558e7c) (#439) 2026-09-30 21:24:09 -05:00
coah
98648d19bb AOSS, zi8alpha: deficits shrinking (worker 59064877) (#438) 2026-09-30 21:00:22 -05:00
coah
d03219249b regalloc sweep: pf_dir 35/38, NWC24Mime 12/16 (worker edd57acb) (#437) 2026-09-30 20:50:49 -05:00
coah
3c23585249 zi8cgetc: GetZH deficit 78 -> 62 insns (worker 7d22ea37) (#436) 2026-09-30 20:44:21 -05:00
coah
b4745ba2da pf_path, iplAddressEdit closer (worker 1bceaa8f) (#435) 2026-09-30 20:36:41 -05:00
coah
fb3e7bd49a sub-90 functions: SDChannelSelect, AddressEdit closer (worker 35852f84) (#434) 2026-09-30 20:34:31 -05:00
coah
e34eac26ef ATERM/AOSS: small fuzzy gains (worker 52d046e2) (#433) 2026-09-30 20:29:11 -05:00
coah
565d039c01 zconvert 2/4 (worst 78 -> 99.6%) (worker 9f5c4222) (#432) 2026-09-30 20:27:10 -05:00
coah
46d7bc07cf wad: small fuzzy gains (worker ca7a1e52) (#431) 2026-09-30 20:18:01 -05:00
coah
6ec48a1b9a TMC_JPEG: RGB565 6/13 (worker c0724c9e) (#430) 2026-09-30 20:01:28 -05:00
coah
07b3a2b579 ATERM 14/26 (fuzzy 92 -> 96) (worker 8f2e6497) (#429) 2026-09-30 19:59:08 -05:00
coah
e1b46d09e8 wad 34/40 (worker cfd01890) (#428) 2026-09-30 19:48:56 -05:00
coah
a4d46cf340 NWC24Download 18/30, iplSetting 105/112 (worker 363488f7) (#427) 2026-09-30 19:44:27 -05:00
github-actions[bot]
46e8217f2f docs: update progress [skip ci] 2026-10-01 00:07:00 +00:00
devin-ai-integration[bot]
028e36cce2 Link kbd_lib_map_us (#426)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-10-01 00:06:18 +00:00
github-actions[bot]
6abc1f9bd8 docs: update progress [skip ci] 2026-09-30 23:37:01 +00:00
devin-ai-integration[bot]
b004e2be89 Link net sha1 + neterrorcode (#425)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 23:36:27 +00:00
coah
5c1794ef25 wad 32/40 (fuzzy 98.5) (worker 37d1b10e) (#424) 2026-09-30 18:07:25 -05:00
coah
c393274640 sweep: kbd_lib, tiZiString, exif closer (worker 374f661e) (#423) 2026-09-30 17:57:39 -05:00
coah
3bfbb0c9c3 zi8alpha/zi81key: small fuzzy gains (worker 004853ec) (#422) 2026-09-30 17:54:43 -05:00
coah
cdc22045a7 TMC_JPEG: RGB565 3/13 (96%), RGBA8 89%, idct 88%, iqdec 99% (worker 7b4f8d49) (#421) 2026-09-30 17:43:46 -05:00
github-actions[bot]
976fbeb804 docs: update progress [skip ci] 2026-09-30 22:37:48 +00:00
devin-ai-integration[bot]
725599dba0 Link 28 fa tail units (pdm + pf stubs + pfs_*) (#420)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 22:37:10 +00:00
coah
4d0c9e70d6 odh/AOSS: small fuzzy gains (worker f272e078) (#419) 2026-09-30 17:24:56 -05:00
coah
131d8f743c sd_drv round 4 (worker d3d9dcba) (#418) 2026-09-30 17:17:34 -05:00
coah
23067a3477 wad 29/40 (fuzzy 92 -> 97) (worker 2a411d12) (#417) 2026-09-30 17:04:12 -05:00
coah
c7958e9f67 sd_drv round 3 (worker 503a78aa) (#416) 2026-09-30 16:50:52 -05:00
coah
d9ee532e07 vi 28/30 (data 100%), nup 17/23 (worker 53f0591e) (#415) 2026-09-30 16:49:32 -05:00
github-actions[bot]
1d5184b30e docs: update progress [skip ci] 2026-09-30 21:38:54 +00:00
devin-ai-integration[bot]
a27b6aa96e Link 47 fa units (finfo..xdivide + pf_w_* batch) (#414)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 21:38:17 +00:00
coah
112149c8e5 KPAD 18/29 (fuzzy 84 -> 98.5) (worker e7585e33) (#413) 2026-09-30 16:09:46 -05:00
coah
45a6d499ec pfd_cmn 1/1, sd_drv 15/26 (worker 64325785) (#412) 2026-09-30 16:06:22 -05:00
github-actions[bot]
813110e681 docs: update progress [skip ci] 2026-09-30 20:40:48 +00:00
devin-ai-integration[bot]
f4a48bd996 Link 15 fa pf units (cdelete..fconcat) (#411)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 20:40:01 +00:00
coah
f1590c832e wad 27/40 (fuzzy 86 -> 92) (worker c964c352) (#410) 2026-09-30 15:30:30 -05:00
coah
d6cafeab4d zi8cgetc: GetZH closer, data 24 -> 72 (worker bb87205d) (#409) 2026-09-30 15:18:11 -05:00
coah
c047b544c1 nand_drv 18/18, sd_drv 13/26 (no volatile casts) (worker 26ae07cf) (#408) 2026-09-30 15:16:57 -05:00
coah
82dbaac35d CHANSVm: CHANSVmStep 96.4% (worker 87e5a30c) (#407) 2026-09-30 14:46:29 -05:00
coah
e8d4107b11 BS2Mach/BS2Update: closer (fuzzy only) (worker fb7be869) (#406) 2026-09-30 14:33:27 -05:00
coah
1b96b3956b tiInputForm: fuzzy 97 -> 99.5, 3 more asm bodies to C (worker d126d226) (#405) 2026-09-30 14:30:55 -05:00
github-actions[bot]
81c36c4db0 docs: update progress [skip ci] 2026-09-30 19:12:04 +00:00
devin-ai-integration[bot]
355564cd77 Link pf_fat32, pf_sector, pf_volume_apiadd, pf_buffering (#404)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 19:11:15 +00:00
coah
17b5d5946b Texture_MCUtoY8U8V8: nine functions ~50% -> 99% (registers only) (worker b2970e86) (#403) 2026-09-30 13:55:41 -05:00
github-actions[bot]
ed5a62397d docs: update progress [skip ci] 2026-09-30 18:50:46 +00:00
coah
2a34d3703b Revert "Link fa/driver nand_drv + msc_drv (#400)" (#402)
This reverts commit 787aa9d334.
2026-09-30 13:50:09 -05:00
coah
3f5248be4c CHANSVm: data 100%, all 121 jump-table relocations match (worker 7c42cd13) (#401) 2026-09-30 13:48:47 -05:00
github-actions[bot]
59e127f89a docs: update progress [skip ci] 2026-09-30 18:41:42 +00:00
devin-ai-integration[bot]
787aa9d334 Link fa/driver nand_drv + msc_drv (#400)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 18:41:06 +00:00
coah
30809a5b05 BS2Mach: BS2Tick 77 -> 98% (worker 86b254ad) (#399) 2026-09-30 13:34:56 -05:00
coah
c21ae517d5 fix: replace lbl_ string pin in FAInit with a literal (#398) 2026-09-30 13:19:03 -05:00
coah
5c7d7ca74a zi8match 8/10 (data 100%) (worker 5d91f712) (#397) 2026-09-30 13:17:06 -05:00
github-actions[bot]
7a94e90a6e docs: update progress [skip ci] 2026-09-30 18:11:32 +00:00
devin-ai-integration[bot]
cec99e3cf8 Link vi/i2c + vi3in1 (#396)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 18:10:55 +00:00
github-actions[bot]
6172b57647 docs: update progress [skip ci] 2026-09-30 18:10:40 +00:00
devin-ai-integration[bot]
bed8e32e57 Link 18 fa/api units (#395)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 18:10:01 +00:00
coah
930e8f4ecf CHANSVm 208/233 (worker 662bd0e0) (#394) 2026-09-30 12:45:06 -05:00
coah
c835bedbc1 zikorean 3/3; zkokeyp 98.6, zprepare 96 (worker 58c15bd8) (#393) 2026-09-30 12:35:36 -05:00
coah
5981234728 scene units: small fuzzy gains (worker 0eaf4057) (#392) 2026-09-30 12:13:13 -05:00
github-actions[bot]
3b2304bd75 docs: update progress [skip ci] 2026-09-30 17:12:29 +00:00
devin-ai-integration[bot]
6ade163015 Link 7 MSL units (ansi_fp, locale, file_io, printf, scanf, strtold, time) (#391)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 17:11:03 +00:00
coah
e6496cc6a8 KPAD 14/29; BS2Mach/wad closer (worker e55f27dd) (#390) 2026-09-30 12:10:14 -05:00
coah
99cfa80f99 TMC_JPEG: Y8U8V8 fuzzy 58 -> 61 (worker cb27699d) (#389) 2026-09-30 11:36:28 -05:00
coah
dfb64b9747 zkokeyp fuzzy 81 -> 94, zprepare 86 (worker 57cfe99f) (#388) 2026-09-30 11:33:53 -05:00
coah
94e6d86223 iplAddressEdit 86/94 (worker 92e1ef1b) (#387) 2026-09-30 11:22:37 -05:00
coah
c923937c3b TMC_JPEG converters round (worker 268299bc) (#386) 2026-09-30 11:05:52 -05:00
coah
bf90a97c1a iplSetting 104/112 (fuzzy 93 -> 98) (worker e82cba45) (#385) 2026-09-30 11:04:42 -05:00
coah
884952a19b zi8dawg 5/6 (fuzzy 52 -> 100), zprepare 65 -> 82 (worker fc5440bc) (#384) 2026-09-30 10:44:22 -05:00
coah
70b04f1d72 iplAddressEdit 85/94, www_wiisetting 20/21 (worker 7ecb61e6) (#383) 2026-09-30 10:35:02 -05:00
coah
95d895d71a NWC24Mime 11/16 (fuzzy 90 -> 99) (worker 5c10efc5) (#382) 2026-09-30 10:14:38 -05:00
coah
6a2a3dd67f iplSDChannelSelect 102/129, iplSDMemory 63/66 (worker 68e4d339) (#381) 2026-09-30 10:01:16 -05:00
coah
341354dce2 zi81key 5/9 (MatchAltSound1Key exact) (worker c23b5c16) (#380) 2026-09-30 09:47:39 -05:00
coah
a22313e57e iplAddressEdit 81/94, iplAddress 90/101 (worker c3ba9e6a) (#379) 2026-09-30 09:43:25 -05:00
coah
91e65d765b tiCellPhone 83/86 (data 100%), NWC24Download 17/30 (worker b5116e0e) (#378) 2026-09-30 09:03:41 -05:00
coah
dc93ab5777 ATERM/AOSS: small fuzzy gains (worker 256344db) (#377) 2026-09-30 09:02:01 -05:00
coah
a3b04ad9ea zi81key and zi8alpha: big functions fully written (60/54/44% -> 97/95/82%) (worker 092b8946) (#376) 2026-09-30 08:54:35 -05:00
coah
55fd34f972 iplSDChannelSelect 98/129, iplSetting 102/112 (worker 1cf3ee73) (#375) 2026-09-30 08:40:18 -05:00
coah
7f055a587e AOSS: fuzzy 69 -> 88 (worker bee49f36) (#374) 2026-09-30 08:14:54 -05:00
coah
7a6efe8a2c pf_dir 34/38, NWC24Download 16/30, tiCellPhone 79/86 (worker 6e98b375) (#373) 2026-09-30 07:49:35 -05:00
github-actions[bot]
de2c8c4688 docs: update progress [skip ci] 2026-09-30 12:48:52 +00:00
devin-ai-integration[bot]
d08d7dec60 nup: link nup_mem (objdiff 100%) (#372)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 12:48:13 +00:00
coah
f20fc7b8e9 zi8cgetc: zi8InternalGetZH 77.5% (worker 7ee3b136) (#371) 2026-09-30 07:11:39 -05:00
coah
03ed29ccee ATERM 11/26, AOSS 15/21 (worker c09611c2) (#370) 2026-09-30 07:09:34 -05:00
coah
2058b121cc iplSetting 100/112, iplSDMemory 62/66 (worker dee954b8) (#369) 2026-09-30 06:57:39 -05:00
coah
4588eee6a9 KPAD data 7712/8032; odh, BS2Mach closer (worker 3e273fb5) (#368) 2026-09-30 06:38:39 -05:00
coah
ad3da3bb76 zi8cgetc: zi8InternalGetZH (42.7KB) translated, 77% fuzzy (worker 9b342d48) (#367) 2026-09-30 06:30:02 -05:00
coah
f9bd6755ba KPAD 13/29 (worker a6808c6c) (#366) 2026-09-30 05:58:34 -05:00
coah
4f78910f8b iplSetting 97/112, iplSDChannelSelect 94/129, iplSDMemory (worker 5693252e) (#365) 2026-09-30 05:55:11 -05:00
coah
9189c9bb9f ATERM 6/26 (fuzzy 89), AOSS 13/21 (worker abd0b0b9) (#364) 2026-09-30 05:53:15 -05:00
coah
eccd5f8c45 SDK: wad fuzzy 81 -> 86, nup +1 (worker 5f3d84f6) (#363) 2026-09-30 05:18:45 -05:00
coah
038cd6f939 zi8cgetc: 5/8 functions (worker 51eaab11) (#362) 2026-09-30 05:06:59 -05:00
coah
1c505b9708 ATERM: fuzzy 64 -> 83; AOSS 9/21 (worker 102f9d07) (#361) 2026-09-30 04:29:38 -05:00
coah
b646f1caaf TMC_JPEG: RGB565 grayscale converter 99.2% (worker e382e38c) (#360) 2026-09-30 04:24:51 -05:00
coah
46066115ab misc: 11 small SDK/eZiText units, 23 exact functions (worker 6d0baf10) (#359) 2026-09-30 04:23:36 -05:00
coah
bc6d67e3f5 SDK: sd_drv, wad 23/40, vi, nup round (worker 73e619c5) (#358) 2026-09-30 03:59:50 -05:00
github-actions[bot]
d399446f10 docs: update progress [skip ci] 2026-09-30 08:56:48 +00:00
devin-ai-integration[bot]
5c690a7da3 nwc24: link NWC24System (objdiff 100%) (#357)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 08:55:55 +00:00
github-actions[bot]
59a3bfc3b2 docs: update progress [skip ci] 2026-09-30 08:55:13 +00:00
devin-ai-integration[bot]
547c2f508f fa: link 6 dir/entry units (objdiff 100%) (#356)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 08:54:38 +00:00
coah
f34c0b3aa7 TMC_JPEG: exif_parse 3/6; partial texture converters, idct, iqdec (worker c8e8d278) (#355) 2026-09-30 03:29:46 -05:00
coah
dcc384b7fa misc: 8 small setting/SDK units, 45/54 functions (worker 4db219ff) (#354) 2026-09-30 03:03:53 -05:00
github-actions[bot]
3fef1bd99e docs: update progress [skip ci] 2026-09-30 07:47:12 +00:00
devin-ai-integration[bot]
fd30e881a1 sdk: link ncdsleep + WPADHIDParser (objdiff 100%) (#353)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-30 07:46:35 +00:00
314 changed files with 120859 additions and 19864 deletions

View File

@@ -53,9 +53,9 @@ Progress
<!-- progress:start -->
| Decompiled | Matched | Linked | Data |
|:---:|:---:|:---:|:---:|
| 93.35% | 82.03% | 57.21% | 89.10% |
| 99.37% | 87.69% | 61.93% | 91.37% |
units 768/1027 complete, functions 11879/12563 matched.
units 917/1027 complete, functions 12211/12563 matched.
decompiled = code with a C/C++ implementation (objdiff fuzzy), matched = byte-exact code, linked = code actually linked into the DOL, data = byte-exact data
<!-- progress:end -->

View File

@@ -11,12 +11,23 @@ splits: 'config/43U/splits.txt'
ldscript_template: 'config/ldscript_ipl2.lcf'
force_active:
- fprintf
- leap_days
- __msl_time2tm
- __tm2time
- clock
- mktime
- localtime
- emit
- __MSL_ISO8601NewYear
- __MSL_ISO8601Week
- strftime
- labs
- atol
- itoa
- strpbrk
- strspn
- strcspn
- atol
- padding__Q23ipl5scene
- lbl_81695063
- lbl_81695067

View File

@@ -1111,7 +1111,7 @@ src/keyboard/MyTiInputForm.cpp:
src/keyboard/MyTiLetterForm.cpp:
.text start:0x81444730 end:0x814454D8
.rodata start:0x816168B8 end:0x81616B88
.rodata start:0x816168B8 end:0x81616BC8
.data start:0x81668860 end:0x81668CD8
.sdata2 start:0x81694EB0 end:0x81694ED0
.sdata start:0x81697528 end:0x81697570
@@ -1138,7 +1138,7 @@ src/keyboard/tiHKBManager.cpp:
src/keyboard/tiHwKeyboard.cpp:
.bss start:0x810C8940 end:0x810C8950
.text start:0x81448AA4 end:0x81449C98
.rodata start:0x81616B88 end:0x81616C78
.rodata start:0x81616BC8 end:0x81616C78
.data start:0x81668EF8 end:0x81669018
.sdata2 start:0x81694EF8 end:0x81694F08
.sdata start:0x81697570 end:0x81697578
@@ -1405,7 +1405,7 @@ libs/RVLMiddleware/eZiText/src/clib/zikorean.c:
extab start:0x81330748 end:0x81330760
extabindex start:0x8133147C end:0x813314A0
.text start:0x814813FC end:0x81482840
.data start:0x8166B2B0 end:0x8166B3D0
.data start:0x8166B2B0 end:0x8166B3A8
libs/RVLMiddleware/eZiText/src/clib/ziswordw.c:
extab start:0x81330760 end:0x81330770
@@ -1417,6 +1417,7 @@ libs/RVLMiddleware/eZiText/src/clib/zkokeyp.c:
extab start:0x81330770 end:0x813307A8
extabindex start:0x813314B8 end:0x8133150C
.text start:0x8148302C end:0x8148447C
.data start:0x8166B3A8 end:0x8166B3D0
libs/RVLMiddleware/eZiText/src/clib/zierror.c:
.text start:0x8148447C end:0x81484484
@@ -4192,11 +4193,11 @@ libs/RVL_SDK/src/fa/driver/nand_drv.c:
.sbss start:0x816996C0 end:0x816996E0
libs/RVL_SDK/src/fa/driver/sd_drv.c:
.bss start:0x811AF460 end:0x811AF6C0
.bss start:0x811AF460 end:0x811AF6C0 align:32
.text start:0x815EA41C end:0x815ED20C
.rodata start:0x816329E8 end:0x81632B58
.data start:0x81690D18 end:0x81691728
.sbss start:0x816996E0 end:0x81699708
.sbss start:0x816996E0 end:0x81699708 align:32
libs/RVL_SDK/src/fa/driver/pfd_cmn.c:
.text start:0x815ED20C end:0x815ED324

View File

@@ -2042,8 +2042,8 @@ isEqualChannel__Q33ipl8savedata7ManagerFUxUx = .text:0x813594B0; // type:functio
isDefaultChannel__Q33ipl8savedata7ManagerFUlUl = .text:0x8135954C; // type:function size:0x50
updateVersion__Q33ipl8savedata7ManagerFUlUl = .text:0x8135959C; // type:function size:0xD4
setDefaultSDMenu__Q33ipl8savedata7ManagerFv = .text:0x81359670; // type:function size:0x48 scope:local
iplSavedata_813596B8__Q33ipl8savedata7ManagerFUx = .text:0x813596B8; // type:function size:0xE8
iplSavedata_813597A0 = .text:0x813597A0; // type:function size:0x40 scope:local
pushTitleCache__Q33ipl8savedata7ManagerFUx = .text:0x813596B8; // type:function size:0xE8
isTitleCached = .text:0x813597A0; // type:function size:0x40
nand_error_handling__Q33ipl8savedata7ManagerFi = .text:0x813597E0; // type:function size:0xDC
__ct__Q33ipl7channel9RsoThreadFPQ23EGG4Heap = .text:0x813598BC; // type:function size:0x6C
__dt__Q33ipl7channel9RsoThreadFv = .text:0x81359928; // type:function size:0x70
@@ -2095,7 +2095,7 @@ stt_wait_fns_msg__Q23ipl9CdbBackupFv = .text:0x8135B004; // type:function size:0
stt_clean_up_back__Q23ipl9CdbBackupFv = .text:0x8135B030; // type:function size:0x60
stt_wait_terminate__Q23ipl9CdbBackupFv = .text:0x8135B090; // type:function size:0x60
error_handling__Q23ipl9CdbBackupFv = .text:0x8135B0F0; // type:function size:0xD0
fn_8135B1C0__Q23ipl9CdbBackupFv = .text:0x8135B1C0; // type:function size:0x28
getProgressPercent__Q23ipl9CdbBackupFv = .text:0x8135B1C0; // type:function size:0x28
cdb_backup_delete_search_cb___3iplFPvP10_CDBRecord = .text:0x8135B1E8; // type:function size:0x8C
cdb_backup_delete_task___3iplFPv = .text:0x8135B274; // type:function size:0xDC
cdb_backup_move_search_cb___3iplFPvP10_CDBRecord = .text:0x8135B350; // type:function size:0xBC
@@ -5126,8 +5126,8 @@ __ct__Q33ipl5scene10AOSSThreadFPQ23EGG4Heap = .text:0x813FCA0C; // type:function
destroy__Q33ipl5scene10AOSSThreadFi = .text:0x813FCAA0; // type:function size:0x84
__dt__Q33ipl5scene10AOSSThreadFv = .text:0x813FCB24; // type:function size:0x70
start__Q33ipl5scene10AOSSThreadFv = .text:0x813FCB94; // type:function size:0xF8
AOSSThread_813FCC8C__Q33ipl5scene10AOSSThreadFv = .text:0x813FCC8C; // type:function size:0x58
AOSSThread_813FCCE4__Q33ipl5scene10AOSSThreadFv = .text:0x813FCCE4; // type:function size:0x50
aossAlloc__Q33ipl5scene10AOSSThreadFv = .text:0x813FCC8C; // type:function size:0x58
aossFree__Q33ipl5scene10AOSSThreadFv = .text:0x813FCCE4; // type:function size:0x50
Run__Q33ipl5scene10AOSSThreadFv = .text:0x813FCD34; // type:function size:0xEC
cancel__Q33ipl5scene10AOSSThreadFv = .text:0x813FCE20; // type:function size:0x50
finish__Q33ipl5scene10AOSSThreadFP13NCDAossConfigPi = .text:0x813FCE70; // type:function size:0x2FC
@@ -5267,10 +5267,10 @@ start_focusout_anm__Q33ipl5scene13SettingSelectFi = .text:0x814093D0; // type:fu
start_selected_anm__Q33ipl5scene13SettingSelectFi = .text:0x81409480; // type:function size:0x274
is_stopped_all_anm__Q33ipl5scene13SettingSelectCFv = .text:0x814096F4; // type:function size:0x74
onEvent__Q33ipl5scene13SettingSelectFUlUlPv = .text:0x81409768; // type:function size:0xFC
fn_81409864__Q33ipl5scene13SettingSelectFv = .text:0x81409864; // type:function size:0x90
fn_814098F4__Q33ipl5scene13SettingSelectFv = .text:0x814098F4; // type:function size:0x94
fn_81409988__Q33ipl5scene13SettingSelectFv = .text:0x81409988; // type:function size:0x64
fn_814099EC__Q33ipl5scene13SettingSelectFv = .text:0x814099EC; // type:function size:0x198
calc_exit_sequence__Q33ipl5scene13SettingSelectFv = .text:0x81409864; // type:function size:0x90
prepare_exit_abort__Q33ipl5scene13SettingSelectFv = .text:0x814098F4; // type:function size:0x94
start_exit_fade__Q33ipl5scene13SettingSelectFv = .text:0x81409988; // type:function size:0x64
finish_exit_reboot__Q33ipl5scene13SettingSelectFv = .text:0x814099EC; // type:function size:0x198
__dt__Q33ipl5scene13SettingSelectFv = .text:0x81409B84; // type:function size:0x58 scope:weak
@20@__dt__Q33ipl5scene13SettingSelectFv = .text:0x81409BDC; // type:function size:0x8 scope:weak
@84@onEvent__Q33ipl5scene13SettingSelectFUlUlPv = .text:0x81409BE4; // type:function size:0x8 scope:weak
@@ -5576,7 +5576,7 @@ __sinit_\tiPcKeyboard_cpp = .text:0x81416F34; // type:function size:0x1B0
@68@calc__Q49textinput8keyboard6pctype12LayoutByNW4RFv = .text:0x814170FC; // type:function size:0x8
@68@draw__Q49textinput8keyboard6pctype12LayoutByNW4RFv = .text:0x81417104; // type:function size:0x8
@68@init__Q49textinput8keyboard6pctype12LayoutByNW4RFv = .text:0x8141710C; // type:function size:0x8
@236@onEvent__Q49textinput8keyboard6pctype12LayoutByNW4RFPQ49textinput8keyboard6pctype5 = .text:0x81417114; // type:function size:0x8
@236@onEvent__Q49textinput8keyboard6pctype12LayoutByNW4RFPQ49textinput8keyboard6pctype5UIObjUlPv = .text:0x81417114; // type:function size:0x8
create__Q49textinput8keyboard13cellphonetype4BaseFP12MEMAllocator = .text:0x8141711C; // type:function size:0xAC
init__Q49textinput8keyboard13cellphonetype4BaseFv = .text:0x814171C8; // type:function size:0xA8
calc__Q49textinput8keyboard13cellphonetype4BaseFv = .text:0x81417270; // type:function size:0x4
@@ -5829,7 +5829,7 @@ doAfterDrawProcess__Q39textinput9inputform4BaseFPCwUlRCQ49textinput10textdrawer4
finishDraw__Q39textinput9inputform4BaseFUl = .text:0x81427DC0; // type:function size:0x4
addSender__Q29textinput15CommandReceiverFPQ29textinput13CommandSender = .text:0x81427DC4; // type:function size:0x8
getDrawModifyStartLine__Q39textinput10textdrawer4BaseCFv = .text:0x81427DCC; // type:function size:0x8
isEnableCursorCache__Q39textinput10textdrawer4BaseCFvgetStartPos__Q39textinput10textdrawer4BaseCFv = .text:0x81427DD4; // type:function size:0x8
isEnableCursorCache__Q39textinput10textdrawer4BaseCFv = .text:0x81427DD4; // type:function size:0x8
getStartPos__Q39textinput10textdrawer4BaseCFv = .text:0x81427DDC; // type:function size:0x8
setVIWidth__Q39textinput10textdrawer4BaseFf = .text:0x81427DE4; // type:function size:0x8
setCandidateBox__Q39textinput12candidatebox18CandidateBoxCallerFPQ39textinput12candidatebox4Base = .text:0x81427DEC; // type:function size:0x8
@@ -13113,7 +13113,7 @@ pfstub_com_massage = .text:0x815E6C40; // type:function size:0xE4
pfstub_store_result = .text:0x815E6D24; // type:function size:0xC4
PFSYS_initializeSYS = .text:0x815E6DE8; // type:function size:0x4
PFSYS_GetCurrentContextID = .text:0x815E6DEC; // type:function size:0x18
PFSYS_TimeStamp = .text:0x815E6E04; // type:function size:0x74
PFSYS_TimeStamp = .text:0x815E6E04; // type:function size:0x7C
pfstub_call_function_standard = .text:0x815E6E80; // type:function size:0x584
pfstub_attach = .text:0x815E7404; // type:function size:0x50
pfstub_buffering = .text:0x815E7454; // type:function size:0x50
@@ -13202,7 +13202,7 @@ pfd_sddrv_pread = .text:0x815EAADC; // type:function size:0x38
pfd_sddrv_pwrite = .text:0x815EAB14; // type:function size:0x38
pfd_sddrv_unmount = .text:0x815EAB4C; // type:function size:0x34
pfd_sddrv_finalize = .text:0x815EAB80; // type:function size:0xE4
pfd_sddrv_get_disk_info = .text:0x815EAC64; // type:function size:0x180
pfd_sddrv_get_disk_info = .text:0x815EAC64; // type:function size:0x188
pfd_sddrv_init_drv_tbl = .text:0x815EADEC; // type:function size:0x18
pfd_sddrv_registar_callback = .text:0x815EAE04; // type:function size:0x10
pfd_sddrv_is_media_insert = .text:0x815EAE14; // type:function size:0x98
@@ -13986,8 +13986,8 @@ lbl_81616AE4 = .rodata:0x81616AE4; // type:object size:0x30
lbl_81616B14 = .rodata:0x81616B14; // type:object size:0x74
lbl_81616B88 = .rodata:0x81616B88; // type:object size:0x40
lbl_81616BC8 = .rodata:0x81616BC8; // type:object size:0x10 data:4byte
lbl_81616BD8 = .rodata:0x81616BD8; // type:object size:0xC
lbl_81616BE4 = .rodata:0x81616BE4; // type:object size:0xC
scCountryMap_EU = .rodata:0x81616BD8; // type:object size:0xC
scCountryMap_NonEU = .rodata:0x81616BE4; // type:object size:0xC
lbl_81616BF0 = .rodata:0x81616BF0; // type:object size:0x88
CHANSVmConstStringObjectUndefined = .rodata:0x81616C78; // type:object size:0x10
lbl_81616C88 = .rodata:0x81616C88; // type:object size:0x10
@@ -14994,8 +14994,8 @@ __vt__Q37ext_ead3www14SurfaceManager = .data:0x81643AA0; // type:object size:0xC
@1183 = .data:0x81643AB8; // type:object size:0x21 scope:local data:string
__vt__Q37ext_ead3www9ut_thread = .data:0x81643ADC; // type:object size:0x28
lbl_81643B08 = .data:0x81643B08; // type:object size:0x38
lbl_81643B40 = .data:0x81643B40; // type:object size:0x1E data:string
lbl_81643B5E = .data:0x81643B5E; // type:object size:0x24 data:string
scWwwTexBufFmt = .data:0x81643B40; // type:object size:0x1E data:string
scWwwNoBrowserWin = .data:0x81643B5E; // type:object size:0x24 data:string
lbl_81643B82 = .data:0x81643B82; // type:object size:0x1B data:string
lbl_81643B9D = .data:0x81643B9D; // type:object size:0x2B data:string
lbl_81643BC8 = .data:0x81643BC8; // type:object size:0x12 data:string
@@ -15673,11 +15673,11 @@ lbl_8164C54E = .data:0x8164C54E; // type:object size:0x18
lbl_8164C566 = .data:0x8164C566; // type:object size:0xC
lbl_8164C572 = .data:0x8164C572; // type:object size:0xA
__vt__Q33ipl5scene8Calendar = .data:0x8164C57C; // type:object size:0xA4
lbl_8164C620 = .data:0x8164C620; // type:object size:0xB data:string
lbl_8164C62C = .data:0x8164C62C; // type:object size:0x14 data:4byte
lbl_8164C640 = .data:0x8164C640; // type:object size:0x12 data:string
lbl_8164C652 = .data:0x8164C652; // type:object size:0xB data:string
lbl_8164C65D = .data:0x8164C65D; // type:object size:0x13 data:string
scN_CalDay_r = .data:0x8164C620; // type:object size:0xB data:string
scDateAnimPaneNames = .data:0x8164C62C; // type:object size:0x14 data:4byte
scMyIplTopFBrlan = .data:0x8164C640; // type:object size:0x12 data:string
scN_CalDay_t = .data:0x8164C652; // type:object size:0xB data:string
scSEDateFocus = .data:0x8164C65D; // type:object size:0x13 data:string
__vt__Q33ipl5scene4Date = .data:0x8164C670; // type:object size:0x18
@12712 = .data:0x8164C688; // type:object size:0xC scope:local data:string
...data.0 = .data:0x8164C688; // type:label scope:local
@@ -18149,7 +18149,7 @@ lbl_8166A6B1 = .data:0x8166A6B1; // type:object size:0xD data:string
lbl_8166A6BE = .data:0x8166A6BE; // type:object size:0xD data:string
lbl_8166A6CB = .data:0x8166A6CB; // type:object size:0xC data:string
lbl_8166A6D7 = .data:0x8166A6D7; // type:object size:0xC data:string
lbl_8166A6E3 = .data:0x8166A6E3; // type:object size:0x41 data:string
scCsFatalMsg = .data:0x8166A6E3; // type:object size:0x41 data:string
lbl_8166A728 = .data:0x8166A728; // type:object size:0xB data:string
lbl_8166A733 = .data:0x8166A733; // type:object size:0x9 data:string
lbl_8166A73C = .data:0x8166A73C; // type:object size:0xB data:string
@@ -20107,12 +20107,12 @@ gDBCommTable = .data:0x816943C8; // type:object size:0x28
lbl_81694410 = .sdata2:0x81694410; // type:object size:0x4 align:4 data:float
lbl_81694418 = .sdata2:0x81694418; // type:object size:0x8 align:8 data:double
lbl_81694420 = .sdata2:0x81694420; // type:object size:0x4 align:4 data:float
lbl_81694424 = .sdata2:0x81694424; // type:object size:0x4 align:4 data:float
lbl_81694428 = .sdata2:0x81694428; // type:object size:0x4 align:4 data:float
lbl_8169442C = .sdata2:0x8169442C; // type:object size:0x4 align:4 data:float
lbl_81694430 = .sdata2:0x81694430; // type:object size:0x4 align:4 data:float
lbl_81694434 = .sdata2:0x81694434; // type:object size:0x4 align:4 data:float
lbl_81694438 = .sdata2:0x81694438; // type:object size:0x4 align:4 data:float
scOrthoLeft = .sdata2:0x81694424; // type:object size:0x4 align:4 data:float
scOrthoRight = .sdata2:0x81694428; // type:object size:0x4 align:4 data:float
scOrthoBottom = .sdata2:0x8169442C; // type:object size:0x4 align:4 data:float
scOrthoTop = .sdata2:0x81694430; // type:object size:0x4 align:4 data:float
scWideOrthoLeft = .sdata2:0x81694434; // type:object size:0x4 align:4 data:float
scWideOrthoRight = .sdata2:0x81694438; // type:object size:0x4 align:4 data:float
lbl_81694440 = .sdata2:0x81694440; // type:object size:0x4 align:4 data:float
lbl_81694444 = .sdata2:0x81694444; // type:object size:0x4 align:4 data:float
lbl_81694448 = .sdata2:0x81694448; // type:object size:0x8 align:8 data:double
@@ -20201,10 +20201,10 @@ lbl_816945B0 = .sdata2:0x816945B0; // type:object size:0x4 align:4 data:float
lbl_816945B4 = .sdata2:0x816945B4; // type:object size:0x4 align:4 data:float
lbl_816945B8 = .sdata2:0x816945B8; // type:object size:0x8 align:8 data:double
lbl_816945C0 = .sdata2:0x816945C0; // type:object size:0x8 align:8 data:double
lbl_816945C8 = .sdata2:0x816945C8; // type:object size:0x4 align:4 data:float
lbl_816945D0 = .sdata2:0x816945D0; // type:object size:0x8 align:8 data:double
lbl_816945D8 = .sdata2:0x816945D8; // type:object size:0x8 align:8 data:double
lbl_816945E0 = .sdata2:0x816945E0; // type:object size:0x8 align:8 data:double
scTvrcMsPerSec = .sdata2:0x816945C8; // type:object size:0x4 align:4 data:float
scTvrcNsecPerSec = .sdata2:0x816945D0; // type:object size:0x8 align:8 data:double
scTvrcOne = .sdata2:0x816945D8; // type:object size:0x8 align:8 data:double
scTvrcFloatMagic = .sdata2:0x816945E0; // type:object size:0x8 align:8 data:double
lbl_816945E8 = .sdata2:0x816945E8; // type:object size:0x4 align:4 data:float
lbl_816945EC = .sdata2:0x816945EC; // type:object size:0x4 align:4 data:float
lbl_816945F0 = .sdata2:0x816945F0; // type:object size:0x4 align:4 data:float
@@ -20710,12 +20710,12 @@ lbl_81694ECC = .sdata2:0x81694ECC; // type:object size:0x4 align:4 data:float
@880 = .sdata2:0x81694ED4; // type:object size:0x4 scope:local align:4 data:float
@885 = .sdata2:0x81694ED8; // type:object size:0x4 scope:local align:4 data:float
@888 = .sdata2:0x81694EE0; // type:object size:0x8 scope:local align:8 data:double
lbl_81694EE8 = .sdata2:0x81694EE8; // type:object size:0x4 align:4 data:float
lbl_81694EEC = .sdata2:0x81694EEC; // type:object size:0x1 data:byte
lbl_81694EED = .sdata2:0x81694EED; // type:object size:0x1 data:byte
lbl_81694EEE = .sdata2:0x81694EEE; // type:object size:0x1 data:byte
lbl_81694EEF = .sdata2:0x81694EEF; // type:object size:0x1 data:byte
lbl_81694EF0 = .sdata2:0x81694EF0; // type:object size:0x4 align:4 data:float
scGuiZeroF = .sdata2:0x81694EE8; // type:object size:0x4 align:4 data:float
scGuiLineColorR = .sdata2:0x81694EEC; // type:object size:0x1 data:byte
scGuiLineColorG = .sdata2:0x81694EED; // type:object size:0x1 data:byte
scGuiLineColorB = .sdata2:0x81694EEE; // type:object size:0x1 data:byte
scGuiLineColorA = .sdata2:0x81694EEF; // type:object size:0x1 data:byte
scGuiHalfF = .sdata2:0x81694EF0; // type:object size:0x4 align:4 data:float
lbl_81694EF8 = .sdata2:0x81694EF8; // type:object size:0x8 data:4byte
lbl_81694F00 = .sdata2:0x81694F00; // type:object size:0x4 data:4byte
lbl_81694F08 = .sdata2:0x81694F08; // type:object size:0x8 align:8 data:double
@@ -20741,7 +20741,7 @@ lbl_81694FA0 = .sdata2:0x81694FA0; // type:object size:0x7 data:string
lbl_81694FA7 = .sdata2:0x81694FA7; // type:object size:0x5 data:string
lbl_81694FAC = .sdata2:0x81694FAC; // type:object size:0xC align:4
lbl_81694FB8 = .sdata2:0x81694FB8; // type:object size:0x8 align:8 data:double
lbl_81694FC0 = .sdata2:0x81694FC0; // type:object size:0x4 align:4 data:float
scCsZeroF = .sdata2:0x81694FC0; // type:object size:0x4 align:4 data:float
@10105 = .sdata2:0x81694FC8; // type:object size:0x4 scope:local align:4 data:float
@9941 = .sdata2:0x81694FD0; // type:object size:0x8 scope:local data:4byte
@10304 = .sdata2:0x81694FD8; // type:object size:0x8 scope:local align:8 data:double
@@ -21552,7 +21552,7 @@ lbl_8169622C = .sdata:0x8169622C; // type:object size:0x1 data:byte
lbl_8169622D = .sdata:0x8169622D; // type:object size:0x1 data:byte
lbl_8169622E = .sdata:0x8169622E; // type:object size:0x1 data:byte
lbl_8169622F = .sdata:0x8169622F; // type:object size:0x1 data:byte
lbl_81696230 = .sdata:0x81696230; // type:object size:0x5 data:string
scTvrcFileHeader = .sdata:0x81696230; // type:object size:0x5 data:string
TVRC_FILE_HEADER__7LibTVRC = .sdata:0x81696238; // type:object size:0x4 data:4byte
__tienHoseiNsec__7LibTVRC = .sdata:0x8169623C; // type:object size:0x4 data:4byte
_limitMilli__7LibTVRC = .sdata:0x81696240; // type:object size:0x4 data:4byte
@@ -21589,7 +21589,7 @@ lbl_816962DB = .sdata:0x816962DB; // type:object size:0x8 data:string
lbl_816962E3 = .sdata:0x816962E3; // type:object size:0x1
lbl_816962E4 = .sdata:0x816962E4; // type:object size:0x8 data:string
lbl_816962F0 = .sdata:0x816962F0; // type:object size:0x8 data:string
lbl_816962F8 = .sdata:0x816962F8; // type:object size:0x8 data:string
scWwwErrorQ = .sdata:0x816962F8; // type:object size:0x8 data:string
globalNames__Q23www9trasition = .sdata:0x81696300; // type:object size:0x8 scope:local
@1425 = .sdata:0x81696308; // type:object size:0x1 scope:local
gEnableDpd = .sdata:0x81696310; // type:object size:0x4 data:4byte
@@ -21753,7 +21753,7 @@ lbl_816966E1 = .sdata:0x816966E1; // type:object size:0x6 data:string
lbl_816966E7 = .sdata:0x816966E7; // type:object size:0x7 data:string
lbl_816966EE = .sdata:0x816966EE; // type:object size:0x7 data:string
lbl_816966F5 = .sdata:0x816966F5; // type:object size:0x4 data:string
lbl_816966F9 = .sdata:0x816966F9; // type:object size:0x7 data:string
scPaneName_B_Stop = .sdata:0x816966F9; // type:object size:0x7 data:string
lbl_81696700 = .sdata:0x81696700; // type:object size:0x6 data:string
lbl_81696706 = .sdata:0x81696706; // type:object size:0x5 data:string
lbl_8169670B = .sdata:0x8169670B; // type:object size:0x6 data:string
@@ -21781,15 +21781,15 @@ lbl_81696797 = .sdata:0x81696797; // type:object size:0x8 data:string
lbl_8169679F = .sdata:0x8169679F; // type:object size:0x8 data:string
lbl_816967A7 = .sdata:0x816967A7; // type:object size:0x7 data:string
lbl_816967AE = .sdata:0x816967AE; // type:object size:0x7 data:string
lbl_816967B5 = .sdata:0x816967B5; // type:object size:0x7 data:string
scPaneName_T_Stop = .sdata:0x816967B5; // type:object size:0x7 data:string
lbl_816967C0 = .sdata:0x816967C0; // type:object size:0x4 data:string
lbl_816967C4 = .sdata:0x816967C4; // type:object size:0x6 data:string
lbl_816967CA = .sdata:0x816967CA; // type:object size:0x7 data:string
lbl_816967D8 = .sdata:0x816967D8; // type:object size:0x6 data:string
lbl_816967DE = .sdata:0x816967DE; // type:object size:0x6 data:string
lbl_816967E4 = .sdata:0x816967E4; // type:object size:0x7 data:string
lbl_816967EB = .sdata:0x816967EB; // type:object size:0x7 data:string
lbl_816967F2 = .sdata:0x816967F2; // type:object size:0x6 data:string
scW_Cal = .sdata:0x816967D8; // type:object size:0x6 data:string
scT_Cal = .sdata:0x816967DE; // type:object size:0x6 data:string
scCal_Ac = .sdata:0x816967E4; // type:object size:0x7 data:string
scInfo_a = .sdata:0x816967EB; // type:object size:0x7 data:string
scB_Cal = .sdata:0x816967F2; // type:object size:0x6 data:string
@16087 = .sdata:0x816967F8; // type:object size:0x4 scope:local data:string
@16350 = .sdata:0x816967FC; // type:object size:0x7 scope:local data:string
@16351 = .sdata:0x81696803; // type:object size:0x7 scope:local data:string
@@ -22466,10 +22466,10 @@ lbl_81697824 = .sdata:0x81697824; // type:object size:0x8 data:string
lbl_8169782C = .sdata:0x8169782C; // type:object size:0x8 data:string
lbl_81697834 = .sdata:0x81697834; // type:object size:0x8 data:string
lbl_8169783C = .sdata:0x8169783C; // type:object size:0x8 data:string
lbl_81697844 = .sdata:0x81697844; // type:object size:0x1 data:byte
lbl_81697845 = .sdata:0x81697845; // type:object size:0x1 data:byte
lbl_81697846 = .sdata:0x81697846; // type:object size:0x1 data:byte
lbl_81697847 = .sdata:0x81697847; // type:object size:0x1 data:byte
scCsFatalColorR = .sdata:0x81697844; // type:object size:0x1 data:byte
scCsFatalColorG = .sdata:0x81697845; // type:object size:0x1 data:byte
scCsFatalColorB = .sdata:0x81697846; // type:object size:0x1 data:byte
scCsFatalColorA = .sdata:0x81697847; // type:object size:0x1 data:byte
lbl_81697848 = .sdata:0x81697848; // type:object size:0x8 data:string
lbl_81697850 = .sdata:0x81697850; // type:object size:0x6 data:string
lbl_81697858 = .sdata:0x81697858; // type:object size:0x6 data:string
@@ -23191,7 +23191,7 @@ _repeatBitLength__7LibTVRC = .sbss:0x81698768; // type:object size:0x4 data:4byt
_repeatBitArray__7LibTVRC = .sbss:0x8169876C; // type:object size:0x4 data:4byte
_tickT__7LibTVRC = .sbss:0x81698770; // type:object size:0x4 data:4byte
m_handle__Q23ipl11TVRCManager = .sbss:0x81698778; // type:object size:0x4 data:4byte
lbl_8169877C__3ipl = .sbss:0x8169877C; // type:object size:0x4 data:4byte
sTvrcStartDelay__3ipl = .sbss:0x8169877C; // type:object size:0x4 data:4byte
suIDCounter__Q23gui11PaneManager = .sbss:0x81698780; // type:object size:0x4 data:4byte
_bgmBlk__Q23ipl3snd = .sbss:0x81698788; // type:object size:0x4
_mainBGMHandle__Q23ipl3snd = .sbss:0x8169878C; // type:object size:0x4 data:4byte
@@ -23331,7 +23331,7 @@ opera_callbacks__Q23www10wiisetting = .sbss:0x816989A0; // type:object size:0x4
sStatus__Q23www9arcreader = .sbss:0x816989A8; // type:object size:0x4 scope:local data:4byte
lbl_816989B0 = .sbss:0x816989B0; // type:object size:0x4 data:4byte
sBatteryFlag__Q210homebutton10Controller = .sbss:0x816989B8; // type:object size:0x4
lbl_816989BC__Q210homebutton10Controller = .sbss:0x816989BC; // type:object size:0x4
sAlarmCreated__Q210homebutton10Controller = .sbss:0x816989BC; // type:object size:0x4
suIDCounter__Q310homebutton3gui11PaneManager = .sbss:0x816989C0; // type:object size:0x4 data:4byte
spInstance__Q210homebutton9RemoteSpk = .sbss:0x816989C8; // type:object size:0x4 data:4byte
InvalidShutdown = .sbss:0x816989D0; // type:object size:0x4 data:4byte

View File

@@ -812,8 +812,8 @@ config.libs = [
]
),
IPLSection("memoryCard", [
Object(NonMatching, "scene/memoryCard/iplMemoryCard.cpp"),
Object(NonMatching, "scene/memoryCard/iplMemoryCardBase.cpp"),
Object(Matching, "scene/memoryCard/iplMemoryCard.cpp"),
Object(Matching, "scene/memoryCard/iplMemoryCardBase.cpp"),
Object(NonMatching, "scene/memoryCard/iplMemoryCardManager.cpp"),
Object(Matching, "scene/memoryCard/iplGCSaveData.cpp"),
Object(NonMatching, "scene/memoryCard/iplGCWindow.cpp"),
@@ -878,8 +878,8 @@ config.libs = [
Object(Matching, "scene/setting/iplAOSSThread.cpp"),
Object(NonMatching, "scene/setting/AOSSLink.c"),
Object(NonMatching, "scene/setting/iplRakuRakuThread.cpp"),
Object(NonMatching, "scene/setting/AOSS.c"),
Object(NonMatching, "scene/setting/ATERM.c"),
Object(NonMatching, "scene/setting/AOSS.c", extra_cflags=["-O4,p", "-inline off"]),
Object(NonMatching, "scene/setting/ATERM.c", extra_cflags=["-O4,p", "-inline off"]),
]
),
IPLSection("settingSelect", [
@@ -929,7 +929,7 @@ config.libs = [
Object(Matching, "keyboard/tiTextInputBase.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/MyTiManager.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/MyTiInputForm.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/MyTiLetterForm.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/MyTiLetterForm.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/MyTiBg.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiDebug.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiGUIManager.cpp", extra_cflags=["-O4,p"]),
@@ -987,7 +987,7 @@ config.libs = [
Object(NonMatching, "clib/zi8alpha.c"),
Object(Matching, "clib/zi8alts.c"),
Object(NonMatching, "clib/zi8cgetc.c"),
Object(NonMatching, "clib/zi8cinfo.c"),
Object(Matching, "clib/zi8cinfo.c"),
Object(Matching, "clib/zi8copy.c"),
Object(NonMatching, "clib/zi8dawg.c"),
Object(Matching, "clib/zi8getc.c"),
@@ -1004,7 +1004,7 @@ config.libs = [
Object(Matching, "clib/zi8ver.c"),
Object(Matching, "clib/zi8ZHuwd.c"),
Object(NonMatching, "clib/zidawg1.c"),
Object(NonMatching, "clib/zikorean.c"),
Object(Matching, "clib/zikorean.c"),
Object(NonMatching, "clib/ziswordw.c"),
Object(NonMatching, "clib/zkokeyp.c"),
Object(Matching, "clib/zierror.c"),
@@ -1025,7 +1025,7 @@ config.libs = [
Object(NonMatching, "cdb/CDBRecord.c"),
Object(Matching, "cdb/CDBRecordFile.c"),
Object(Matching, "cdb/CDBRecordKey.c"),
Object(NonMatching, "cdb/CDBIntArray.c"),
Object(Matching, "cdb/CDBIntArray.c"),
Object(Matching, "cdb/CDBSystem.c"),
Object(Matching, "cdb/CDBAttr.c"),
Object(Matching, "cdb/CDBFBridge.c"),
@@ -1037,16 +1037,16 @@ config.libs = [
),
RevoEXLib("ncd", [
Object(Matching, "ncd/ncdsystem.c"),
Object(NonMatching, "ncd/ncdsleep.c"),
Object(Matching, "ncd/ncdsleep.c"),
]
),
RevoEXLib("net", [
Object(Matching, "net/nettime.c"),
Object(Matching, "net/crc.c"),
Object(NonMatching, "net/md5.c"),
Object(NonMatching, "net/sha1.c"),
Object(Matching, "net/sha1.c"),
Object(NonMatching, "net/hmac.c"),
Object(NonMatching, "net/neterrorcode.c"),
Object(Matching, "net/neterrorcode.c"),
Object(Matching, "net/NETVersion.c"),
Object(NonMatching, "net/aes.c"),
Object(Matching, "net/wireless_macaddr.c"),
@@ -1091,7 +1091,7 @@ config.libs = [
Object(Matching, "nwc24/NWC24Ipc.c"),
Object(Equivalent, "nwc24/NWC24Download.c"),
Object(Matching, "nwc24/NWC24CHJump.c"),
Object(NonMatching, "nwc24/NWC24System.c"),
Object(Matching, "nwc24/NWC24System.c"),
]
),
RevoEXLib("so", [
@@ -1389,8 +1389,8 @@ config.libs = [
),
RVLSDKLib("vi", [
Object(NonMatching, "vi/vi.c"),
Object(NonMatching, "vi/i2c.c"),
Object(NonMatching, "vi/vi3in1.c"),
Object(Matching, "vi/i2c.c"),
Object(Matching, "vi/vi3in1.c"),
]
),
RVLSDKLib("mtx", [
@@ -1552,7 +1552,7 @@ config.libs = [
),
RVLSDKLib("wpad", [
Object(Matching, "wpad/WPAD.c"),
Object(NonMatching, "wpad/WPADHIDParser.c"),
Object(Matching, "wpad/WPADHIDParser.c"),
Object(Matching, "wpad/WPADMem.c"),
Object(Matching, "wpad/WPADEncrypt.c"),
Object(Matching, "wpad/debug_msg.c"),
@@ -1687,179 +1687,179 @@ config.libs = [
Object(Matching, "fa/pf_service.c"),
Object(Matching, "fa/pf_str.c"),
Object(Matching, "fa/pf_driver.c"),
Object(NonMatching, "fa/pdm_api.c"),
Object(NonMatching, "fa/pdm_bpb.c"),
Object(NonMatching, "fa/pdm_disk.c"),
Object(Matching, "fa/pdm_api.c"),
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(NonMatching, "fa/pf_cluster.c"),
Object(NonMatching, "fa/pf_dir.c"),
Object(NonMatching, "fa/pf_entry.c"),
Object(Matching, "fa/pf_entry.c"),
Object(NonMatching, "fa/pf_entry_iterator.c"),
Object(NonMatching, "fa/pf_fat.c"),
Object(NonMatching, "fa/pf_fat12.c"),
Object(NonMatching, "fa/pf_fat16.c"),
Object(NonMatching, "fa/pf_fat32.c"),
Object(Matching, "fa/pf_fat16.c"),
Object(Matching, "fa/pf_fat32.c"),
Object(Matching, "fa/pf_fatfs.c"),
Object(NonMatching, "fa/pf_file.c"),
Object(NonMatching, "fa/pf_path.c"),
Object(NonMatching, "fa/pf_sector.c"),
Object(Matching, "fa/pf_sector.c"),
Object(NonMatching, "fa/pf_volume.c"),
Object(NonMatching, "fa/pf_volume_apiadd.c"),
Object(NonMatching, "fa/pf_cp932.c"),
Object(Matching, "fa/pf_volume_apiadd.c"),
Object(Matching, "fa/pf_cp932.c"),
Object(Matching, "fa/pf_api_util.c"),
Object(Matching, "fa/pf_attach.c"),
Object(NonMatching, "fa/pf_buffering.c"),
Object(NonMatching, "fa/pf_cdelete.c"),
Object(NonMatching, "fa/pf_chdir.c"),
Object(NonMatching, "fa/pf_chdmod.c"),
Object(NonMatching, "fa/pf_chmod.c"),
Object(NonMatching, "fa/pf_cinsert.c"),
Object(Matching, "fa/pf_buffering.c"),
Object(Matching, "fa/pf_cdelete.c"),
Object(Matching, "fa/pf_chdir.c"),
Object(Matching, "fa/pf_chdmod.c"),
Object(Matching, "fa/pf_chmod.c"),
Object(Matching, "fa/pf_cinsert.c"),
Object(Matching, "fa/pf_closedir.c"),
Object(NonMatching, "fa/pf_combine.c"),
Object(NonMatching, "fa/pf_create.c"),
Object(NonMatching, "fa/pf_createdir.c"),
Object(NonMatching, "fa/pf_cut.c"),
Object(NonMatching, "fa/pf_derrnum.c"),
Object(Matching, "fa/pf_combine.c"),
Object(Matching, "fa/pf_create.c"),
Object(Matching, "fa/pf_createdir.c"),
Object(Matching, "fa/pf_cut.c"),
Object(Matching, "fa/pf_derrnum.c"),
Object(Matching, "fa/pf_detach.c"),
Object(NonMatching, "fa/pf_divide.c"),
Object(Matching, "fa/pf_divide.c"),
Object(Matching, "fa/pf_errnum.c"),
Object(NonMatching, "fa/pf_fadjust.c"),
Object(NonMatching, "fa/pf_fappend.c"),
Object(NonMatching, "fa/pf_fchdir.c"),
Object(Matching, "fa/pf_fadjust.c"),
Object(Matching, "fa/pf_fappend.c"),
Object(Matching, "fa/pf_fchdir.c"),
Object(Matching, "fa/pf_fclose.c"),
Object(NonMatching, "fa/pf_fconcat.c"),
Object(Matching, "fa/pf_fconcat.c"),
Object(Matching, "fa/pf_feof.c"),
Object(Matching, "fa/pf_ferror.c"),
Object(NonMatching, "fa/pf_finfo.c"),
Object(Matching, "fa/pf_finfo.c"),
Object(Matching, "fa/pf_flock.c"),
Object(Matching, "fa/pf_fopen.c"),
Object(NonMatching, "fa/pf_format.c"),
Object(Matching, "fa/pf_format.c"),
Object(Matching, "fa/pf_fread.c"),
Object(Matching, "fa/pf_fseek.c"),
Object(NonMatching, "fa/pf_fsetclstlink.c"),
Object(NonMatching, "fa/pf_fsexec.c"),
Object(Matching, "fa/pf_fsetclstlink.c"),
Object(Matching, "fa/pf_fsexec.c"),
Object(Matching, "fa/pf_fsfirst.c"),
Object(Matching, "fa/pf_fsnext.c"),
Object(Matching, "fa/pf_fstat.c"),
Object(Matching, "fa/pf_fsync.c"),
Object(Matching, "fa/pf_fwrite.c"),
Object(NonMatching, "fa/pf_getdev.c"),
Object(NonMatching, "fa/pf_getvol.c"),
Object(NonMatching, "fa/pf_getvolcfg.c"),
Object(NonMatching, "fa/pf_init_prfile2.c"),
Object(NonMatching, "fa/pf_insert.c"),
Object(NonMatching, "fa/pf_iswriteprotected.c"),
Object(Matching, "fa/pf_getdev.c"),
Object(Matching, "fa/pf_getvol.c"),
Object(Matching, "fa/pf_getvolcfg.c"),
Object(Matching, "fa/pf_init_prfile2.c"),
Object(Matching, "fa/pf_insert.c"),
Object(Matching, "fa/pf_iswriteprotected.c"),
Object(Matching, "fa/pf_mkdir.c"),
Object(Matching, "fa/pf_mount.c"),
Object(NonMatching, "fa/pf_move.c"),
Object(NonMatching, "fa/pf_opendir.c"),
Object(NonMatching, "fa/pf_readdir.c"),
Object(NonMatching, "fa/pf_regctx.c"),
Object(Matching, "fa/pf_move.c"),
Object(Matching, "fa/pf_opendir.c"),
Object(Matching, "fa/pf_readdir.c"),
Object(Matching, "fa/pf_regctx.c"),
Object(Matching, "fa/pf_remove.c"),
Object(Matching, "fa/pf_rename.c"),
Object(NonMatching, "fa/pf_rewinddir.c"),
Object(Matching, "fa/pf_rewinddir.c"),
Object(Matching, "fa/pf_rmdir.c"),
Object(NonMatching, "fa/pf_rmvvol.c"),
Object(NonMatching, "fa/pf_seekdir.c"),
Object(NonMatching, "fa/pf_setclstlink.c"),
Object(NonMatching, "fa/pf_setcode.c"),
Object(NonMatching, "fa/pf_setencode.c"),
Object(NonMatching, "fa/pf_settailbuf.c"),
Object(NonMatching, "fa/pf_setupfsi.c"),
Object(NonMatching, "fa/pf_setvol.c"),
Object(NonMatching, "fa/pf_setvolcfg.c"),
Object(NonMatching, "fa/pf_sync.c"),
Object(NonMatching, "fa/pf_telldir.c"),
Object(Matching, "fa/pf_rmvvol.c"),
Object(Matching, "fa/pf_seekdir.c"),
Object(Matching, "fa/pf_setclstlink.c"),
Object(Matching, "fa/pf_setcode.c"),
Object(Matching, "fa/pf_setencode.c"),
Object(Matching, "fa/pf_settailbuf.c"),
Object(Matching, "fa/pf_setupfsi.c"),
Object(Matching, "fa/pf_setvol.c"),
Object(Matching, "fa/pf_setvolcfg.c"),
Object(Matching, "fa/pf_sync.c"),
Object(Matching, "fa/pf_telldir.c"),
Object(Matching, "fa/pf_unmount.c"),
Object(NonMatching, "fa/pf_unregctx.c"),
Object(NonMatching, "fa/pf_xdivide.c"),
Object(Matching, "fa/pf_unregctx.c"),
Object(Matching, "fa/pf_xdivide.c"),
Object(Matching, "fa/pf_w_api_util.c"),
Object(NonMatching, "fa/pf_w_cdelete.c"),
Object(NonMatching, "fa/pf_w_chdir.c"),
Object(NonMatching, "fa/pf_w_chdmod.c"),
Object(NonMatching, "fa/pf_w_chmod.c"),
Object(NonMatching, "fa/pf_w_cinsert.c"),
Object(NonMatching, "fa/pf_w_combine.c"),
Object(NonMatching, "fa/pf_w_create.c"),
Object(NonMatching, "fa/pf_w_createdir.c"),
Object(NonMatching, "fa/pf_w_cut.c"),
Object(NonMatching, "fa/pf_w_divide.c"),
Object(NonMatching, "fa/pf_w_fconcat.c"),
Object(NonMatching, "fa/pf_w_fopen.c"),
Object(NonMatching, "fa/pf_w_fsexec.c"),
Object(NonMatching, "fa/pf_w_fsfirst.c"),
Object(NonMatching, "fa/pf_w_fsnext.c"),
Object(NonMatching, "fa/pf_w_fstat.c"),
Object(NonMatching, "fa/pf_w_insert.c"),
Object(NonMatching, "fa/pf_w_mkdir.c"),
Object(NonMatching, "fa/pf_w_move.c"),
Object(NonMatching, "fa/pf_w_opendir.c"),
Object(NonMatching, "fa/pf_w_remove.c"),
Object(NonMatching, "fa/pf_w_rename.c"),
Object(NonMatching, "fa/pf_w_rmdir.c"),
Object(NonMatching, "fa/pf_w_xdivide.c"),
Object(NonMatching, "fa/pf_filelock.c"),
Object(NonMatching, "fa/pf_stub.c"),
Object(NonMatching, "fa/pf_system.c"),
Object(NonMatching, "fa/pf_stub_standard.c"),
Object(NonMatching, "fa/pfs_attach.c"),
Object(NonMatching, "fa/pfs_buffering.c"),
Object(NonMatching, "fa/pfs_create.c"),
Object(NonMatching, "fa/pfs_createdir.c"),
Object(NonMatching, "fa/pfs_detach.c"),
Object(NonMatching, "fa/pfs_errnum.c"),
Object(NonMatching, "fa/pfs_fclose.c"),
Object(NonMatching, "fa/pfs_finfot.c"),
Object(NonMatching, "fa/pfs_fopen.c"),
Object(NonMatching, "fa/pfs_format.c"),
Object(NonMatching, "fa/pfs_fread.c"),
Object(NonMatching, "fa/pfs_fseek.c"),
Object(NonMatching, "fa/pfs_fsfirst.c"),
Object(NonMatching, "fa/pfs_fsnext.c"),
Object(NonMatching, "fa/pfs_fstat.c"),
Object(NonMatching, "fa/pfs_fwrite.c"),
Object(NonMatching, "fa/pfs_getdev.c"),
Object(NonMatching, "fa/pfs_init_prfile2.c"),
Object(NonMatching, "fa/pfs_mount.c"),
Object(NonMatching, "fa/pfs_remove.c"),
Object(NonMatching, "fa/pfs_unmount.c"),
Object(NonMatching, "fa/pf_stub_unicode.c"),
Object(Matching, "fa/pf_w_cdelete.c"),
Object(Matching, "fa/pf_w_chdir.c"),
Object(Matching, "fa/pf_w_chdmod.c"),
Object(Matching, "fa/pf_w_chmod.c"),
Object(Matching, "fa/pf_w_cinsert.c"),
Object(Matching, "fa/pf_w_combine.c"),
Object(Matching, "fa/pf_w_create.c"),
Object(Matching, "fa/pf_w_createdir.c"),
Object(Matching, "fa/pf_w_cut.c"),
Object(Matching, "fa/pf_w_divide.c"),
Object(Matching, "fa/pf_w_fconcat.c"),
Object(Matching, "fa/pf_w_fopen.c"),
Object(Matching, "fa/pf_w_fsexec.c"),
Object(Matching, "fa/pf_w_fsfirst.c"),
Object(Matching, "fa/pf_w_fsnext.c"),
Object(Matching, "fa/pf_w_fstat.c"),
Object(Matching, "fa/pf_w_insert.c"),
Object(Matching, "fa/pf_w_mkdir.c"),
Object(Matching, "fa/pf_w_move.c"),
Object(Matching, "fa/pf_w_opendir.c"),
Object(Matching, "fa/pf_w_remove.c"),
Object(Matching, "fa/pf_w_rename.c"),
Object(Matching, "fa/pf_w_rmdir.c"),
Object(Matching, "fa/pf_w_xdivide.c"),
Object(Matching, "fa/pf_filelock.c"),
Object(Matching, "fa/pf_stub.c"),
Object(Matching, "fa/pf_system.c"),
Object(Matching, "fa/pf_stub_standard.c"),
Object(Matching, "fa/pfs_attach.c"),
Object(Matching, "fa/pfs_buffering.c"),
Object(Matching, "fa/pfs_create.c"),
Object(Matching, "fa/pfs_createdir.c"),
Object(Matching, "fa/pfs_detach.c"),
Object(Matching, "fa/pfs_errnum.c"),
Object(Matching, "fa/pfs_fclose.c"),
Object(Matching, "fa/pfs_finfot.c"),
Object(Matching, "fa/pfs_fopen.c"),
Object(Matching, "fa/pfs_format.c"),
Object(Matching, "fa/pfs_fread.c"),
Object(Matching, "fa/pfs_fseek.c"),
Object(Matching, "fa/pfs_fsfirst.c"),
Object(Matching, "fa/pfs_fsnext.c"),
Object(Matching, "fa/pfs_fstat.c"),
Object(Matching, "fa/pfs_fwrite.c"),
Object(Matching, "fa/pfs_getdev.c"),
Object(Matching, "fa/pfs_init_prfile2.c"),
Object(Matching, "fa/pfs_mount.c"),
Object(Matching, "fa/pfs_remove.c"),
Object(Matching, "fa/pfs_unmount.c"),
Object(Matching, "fa/pf_stub_unicode.c"),
Object(NonMatching, "fa/api/FAAttach.c"),
Object(NonMatching, "fa/api/FABuffering.c"),
Object(NonMatching, "fa/api/FACreate.c"),
Object(NonMatching, "fa/api/FACreatedir.c"),
Object(NonMatching, "fa/api/FADetach.c"),
Object(NonMatching, "fa/api/FAErrnum.c"),
Object(Matching, "fa/api/FABuffering.c"),
Object(Matching, "fa/api/FACreate.c"),
Object(Matching, "fa/api/FACreatedir.c"),
Object(Matching, "fa/api/FADetach.c"),
Object(Matching, "fa/api/FAErrnum.c"),
Object(Matching, "fa/api/FAFclose.c"),
Object(Matching, "fa/api/FAFinfo.c"),
Object(NonMatching, "fa/api/FAFopen.c"),
Object(NonMatching, "fa/api/FAFormat.c"),
Object(Matching, "fa/api/FAFopen.c"),
Object(Matching, "fa/api/FAFormat.c"),
Object(Matching, "fa/api/FAFread.c"),
Object(NonMatching, "fa/api/FAFseek.c"),
Object(NonMatching, "fa/api/FAFsfirst.c"),
Object(NonMatching, "fa/api/FAFsnext.c"),
Object(NonMatching, "fa/api/FAFstat.c"),
Object(Matching, "fa/api/FAFseek.c"),
Object(Matching, "fa/api/FAFsfirst.c"),
Object(Matching, "fa/api/FAFsnext.c"),
Object(Matching, "fa/api/FAFstat.c"),
Object(Matching, "fa/api/FAFwrite.c"),
Object(NonMatching, "fa/api/FAGetdev.c"),
Object(NonMatching, "fa/api/FAInit.c"),
Object(Matching, "fa/api/FAGetdev.c"),
Object(Matching, "fa/api/FAInit.c"),
Object(Matching, "fa/api/FAInitDiskManager.c"),
Object(NonMatching, "fa/api/FAMount.c"),
Object(NonMatching, "fa/api/FARegistCB.c"),
Object(NonMatching, "fa/api/FARemove.c"),
Object(NonMatching, "fa/api/FASetThreadPriority.c"),
Object(NonMatching, "fa/api/FAUnmount.c"),
Object(Matching, "fa/api/FAMount.c"),
Object(Matching, "fa/api/FARegistCB.c"),
Object(Matching, "fa/api/FARemove.c"),
Object(Matching, "fa/api/FASetThreadPriority.c"),
Object(Matching, "fa/api/FAUnmount.c"),
Object(NonMatching, "fa/kernel/pfk_api.c"),
Object(Matching, "fa/kernel/pfk_api.c"),
Object(NonMatching, "fa/driver/nand_drv.c"),
Object(Matching, "fa/driver/nand_drv.c"),
Object(NonMatching, "fa/driver/sd_drv.c"),
Object(NonMatching, "fa/driver/pfd_cmn.c"),
Object(NonMatching, "fa/driver/msc_drv.c"),
Object(Matching, "fa/driver/pfd_cmn.c"),
Object(Matching, "fa/driver/msc_drv.c"),
Object(NonMatching, "fa/msc/puh_msc.c"),
Object(NonMatching, "fa/msc/puh_msc_cmd.c"),
Object(Matching, "fa/msc/puh_msc.c"),
Object(Matching, "fa/msc/puh_msc_cmd.c"),
Object(NonMatching, "fa/msc/puh_msc_blk.c"),
]
),
@@ -1870,7 +1870,7 @@ config.libs = [
RVLSDKLib("nup", [
Object(NonMatching, "nup/nup.cpp"),
Object(NonMatching, "nup/nup_nhttp.cpp"),
Object(NonMatching, "nup/nup_mem.cpp"),
Object(Matching, "nup/nup_mem.cpp"),
]
),
RVLSDKLib("scutil", [
@@ -1887,7 +1887,7 @@ config.libs = [
RVLSDKLib("kbd", [
Object(NonMatching, "kbd/kbd_lib.c"),
Object(NonMatching, "kbd/kbd_lib_map_jp.c"),
Object(NonMatching, "kbd/kbd_lib_map_us.c"),
Object(Matching, "kbd/kbd_lib_map_us.c"),
Object(NonMatching, "kbd/kbd_lib_map_eu.c"),
]
),
@@ -1944,30 +1944,30 @@ config.libs = [
Object(Matching, "MSL_Common/alloc.c"),
Object(Matching, "MSL_Common/errno.c"),
Object(Matching, "MSL_Common/ansi_files.c"),
Object(NonMatching, "MSL_Common_Embedded/ansi_fp.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common_Embedded/ansi_fp.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/ctype.c"),
Object(NonMatching, "MSL_Common/locale.c"),
Object(Matching, "MSL_Common/locale.c"),
Object(Matching, "MSL_Common/arith.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/bsearch.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/buffer_io.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/direct_io.c", extra_cflags=["-Cpp_exceptions on"]),
Object(NonMatching, "MSL_Common/file_io.c"),
Object(Matching, "MSL_Common/file_io.c"),
Object(Matching, "MSL_Common/FILE_POS.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/mbstring.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/mem.c"),
Object(Matching, "MSL_Common/mem_funcs.c"),
Object(Matching, "MSL_Common/math_api.c"),
Object(Matching, "MSL_Common/misc_io.c"),
Object(NonMatching, "MSL_Common/printf.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/printf.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/qsort.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/rand.c"),
Object(NonMatching, "MSL_Common/scanf.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/scanf.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/signal.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/string.c"),
Object(Matching, "MSL_Common/float.c"),
Object(NonMatching, "MSL_Common/strtold.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/strtold.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/strtoul.c", extra_cflags=["-Cpp_exceptions on"]),
Object(NonMatching, "MSL_Common/time.c", extra_cflags=["-Cpp_exceptions on"]),
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"]),

View File

@@ -14,7 +14,12 @@ enum {
typedef struct BS2UpdateHeader {
char timestamp[16]; // 0x00
u32 wadCount; // 0x10
#ifdef BS2_UPDATE_SOURCE
u32 extraCount;
u32 reserved[2];
#else
u32 reserved[3]; // 0x14
#endif
} BS2UpdateHeader;
typedef struct BS2UpdateEntry {
@@ -29,7 +34,12 @@ typedef struct BS2UpdateEntry {
u64 titleId; // 0x50
u16 titleVersion; // 0x58
#ifdef BS2_UPDATE_SOURCE
u16 reservedTitle;
u32 inodes;
#else
u8 padding[6]; // 0x5A
#endif
// Update Data
char dataName[0x40]; // 0x60

View File

@@ -96,7 +96,7 @@ CHANSVmNativeClass* CHANSVmAddNativeClass(CHANSVm* vm, const char* clsName, CHAN
/*** CHANS Image ***/
/************************/
typedef vmBoolInt (*CHANSVmImageCtorCallback)(CHANSVm* vm);
typedef vmBoolInt (*CHANSVmImageCtorCallback)(CHANSVm* vm, vmPtr data);
typedef vmPtr (*CHANSVmImageAllocatorCallback)(CHANSVm* vm, u32 size);
void CHANSVmImageRegisterAllocator(CHANSVmImageAllocatorCallback allocCb, CHANSVmImageCtorCallback ctorCb);

View File

@@ -75,7 +75,7 @@ namespace homebutton {
private:
static bool sBatteryFlag[WPAD_MAX_CONTROLLERS];
static bool lbl_816989BC[WPAD_MAX_CONTROLLERS];
static bool sAlarmCreated[WPAD_MAX_CONTROLLERS];
static OSAlarm sAlarm[WPAD_MAX_CONTROLLERS];
static OSAlarm sAlarmSoundOff[WPAD_MAX_CONTROLLERS];

View File

@@ -187,7 +187,19 @@ namespace textinput {
void SetFocusedText(s32 pane) { mnFocusedIdx = pane; }
s32 GetFocusedText() { return mnFocusedIdx; }
f32 GetWidthScale_() const { return 608.0f / mfScreenWidth; }
#ifdef TI_CANDIDATEBOX_IMPLEMENTATION
f32 GetMargin_() const {
f32 margin;
if (mfScreenWidth > 700.0f) {
margin = 10.0f;
} else {
margin = 20.0f;
}
return margin;
}
#else
f32 GetMargin_() const { return mfScreenWidth > 700.0f ? 10.0f : 20.0f; }
#endif
s32 GetNextPageIdx_(s32 page) const;
s32 GetPrevPageIdx_(s32 page) const;
s32 GetDispNum() const;

View File

@@ -183,125 +183,10 @@ namespace textinput {
#endif
};
class LayoutByNW4R : public Base, public nw4rmanager::Layout {
public:
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
#ifdef TIMANAGER_IMPLEMENTATION
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
: Base(manager), nw4rmanager::Layout(accessor, layoutName, observer), mpEventHandler(NULL) {}
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator);
virtual void init();
virtual void setCommandReceiver(CommandReceiver* receiver);
virtual void updateFromReceiver(u32 command, void* data);
virtual void onKey(u32 event, void* data);
virtual void setLanguage(Language language);
virtual void update();
virtual void onActive();
virtual void calc();
virtual void draw();
virtual void changeInputMode(InputMode mode);
virtual void setInputMode(InputMode mode);
virtual void setUpperCaseJP(bool upper);
virtual void setLangKeyActive(bool active);
virtual void goSignInputMode();
virtual void changePredictLanguage();
virtual void setAbcMode(bool abc);
virtual void doNumericMode(bool);
virtual void setPredictLanguageDialog(predictlang::LayoutByNW4R* dialog);
virtual void setSignWindow(signwindow::LayoutByNW4R* window);
#ifndef TI_CELLPHONE_MATCH_LAYOUT
#include "tiCellPhoneLayout.h"
#else
#if defined(MYTIMANAGER_IMPLEMENTATION) && defined(TI_CELLPHONE_SAMPLE_CLASS)
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer)
: Base(manager), nw4rmanager::Layout(resAccessor, "fs_VK_cellPhone_a.brlyt", observer), mpSignWindow(NULL) {}
#endif
virtual void doNumericMode(bool);
#ifdef TI_CELLPHONE_IMPLEMENTATION
virtual void setPredictLanguageDialog(predictlang::LayoutByNW4R*);
virtual void setSignWindow(signwindow::LayoutByNW4R*);
#else
virtual void setPredictLanguageDialog(void*);
virtual void setSignWindow(void*);
#endif
#endif
virtual void doNumericWithDotMode(bool);
virtual void setLineFeedButton(bool);
virtual void setPredictLanguageButton(bool);
virtual void setSignWindowButton(bool);
#endif
virtual bool onClose();
void onPressedShift(bool shift);
void onReleasedShift();
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
bool hasLineFeedButton() const { return mbLineFeedButton; }
private:
bool mbLineFeedButton;
#ifdef TIMANAGER_IMPLEMENTATION
GXTexObj mSpaceTexture;
GXTexObj mSpaceTextureCN;
GXTexObj mSpaceTextureKR;
nw4rmanager::TiEventHandler* mpEventHandler;
predictlang::LayoutByNW4R* mpPredictDialog;
signwindow::LayoutByNW4R* mpSignWindow;
#endif
public:
#endif
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
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
#ifdef TI_CELLPHONE_IMPLEMENTATION
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator) override;
virtual void init() override;
virtual void draw() override;
virtual void calc() override;
virtual void update() override;
virtual void onKey(u32 key, void* data) override;
virtual void onActive() override;
virtual void updateFromReceiver(u32 command, void* data) override;
virtual void changeInputMode(InputMode mode) override;
virtual void changePredictLanguage() override;
virtual void setAbcMode(bool enabled) override;
virtual void goSignInputMode() override;
virtual void setInputMode(InputMode mode) override;
virtual void setLanguage(Language language) override;
virtual void setCommandReceiver(CommandReceiver* receiver) override;
virtual CellPhoneAnmPane* getAnmPane(InputMode mode);
virtual void throwReleaseForAll();
virtual void changeAnimationAllToNormal();
virtual void updatePredictLanguage(CommandReceiver::ChangePredictMode* mode);
virtual void changeKeyTop(const PaneNameToCharCode* keys);
virtual void changeSpaceKeyTop(const PaneNameToCharCode* keys);
void setUpperCaseJP(bool enabled);
void setLangKeyActive(bool enabled);
void resetHoldingButton();
private:
bool mbLineFeedButton;
GXTexObj mTextures[3];
EventHandler* mpEventHandler;
predictlang::LayoutByNW4R* mpPredictLanguageDialog;
signwindow::LayoutByNW4R* mpSignWindow;
#elif defined(TIMANAGER_IMPLEMENTATION)
virtual nw4rmanager::AnmPane* getAnmPane(InputMode mode);
virtual void throwReleaseForAll();
virtual void changeAnimationAllToNormal();
virtual void updatePredictLanguage(CommandReceiver::ChangePredictMode* mode);
virtual void changeKeyTop(const struct PaneNameToCharCode* table);
virtual void changeSpaceKeyTop(const struct PaneNameToCharCode* table);
#endif
};
#ifdef TI_CELLPHONE_SAMPLE_CLASS
class Sample : public LayoutByNW4R {
public:
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer)
: LayoutByNW4R(manager, resAccessor, observer) {}
virtual ~Sample() {}
};
class LayoutByNW4R;
#endif
#ifdef TI_CELLPHONE_IMPLEMENTATION
@@ -322,10 +207,29 @@ namespace textinput {
KT_ControlButton,
};
#ifdef TI_CELLPHONE_MATCH_LAYOUT
class EventHandler : public nw4rmanager::TiEventHandler {
public:
EventHandler(LayoutByNW4R* layout) : mpLayoutByNW4R(layout) {}
virtual ~EventHandler();
virtual void onTiEvent(gui::PaneComponent* pane, u32 event, Input* input) override;
private:
LayoutByNW4R* mpLayoutByNW4R;
};
#endif
class CellPhoneAnmPane : public nw4rmanager::AnmPane {
public:
CellPhoneAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer)
#ifdef TI_CELLPHONE_MATCH_LAYOUT
: nw4rmanager::AnmPane(pane, observer), meState(ANM_Normal), meKeyType(KT_NormalButton) {
init();
changeAnimation(meState);
}
#else
: nw4rmanager::AnmPane(pane, observer), meState(ANM_Normal), meKeyType(KT_NormalButton) {}
#endif
virtual void init() override;
virtual void onAnmEvent(AnmPaneEvent event) override;
@@ -348,6 +252,7 @@ namespace textinput {
virtual ~CellPhoneControlAnmPane();
};
#ifndef TI_CELLPHONE_MATCH_LAYOUT
class EventHandler : public nw4rmanager::TiEventHandler {
public:
EventHandler(LayoutByNW4R* layout) : mpLayoutByNW4R(layout) {}
@@ -357,7 +262,12 @@ namespace textinput {
private:
LayoutByNW4R* mpLayoutByNW4R;
};
#endif
#endif
#ifdef TI_CELLPHONE_MATCH_LAYOUT
#include "tiCellPhoneLayout.h"
#endif
} // namespace cellphonetype

View File

@@ -0,0 +1,126 @@
#ifndef TEXTINPUT_CELL_PHONE_LAYOUT_H
#define TEXTINPUT_CELL_PHONE_LAYOUT_H
class LayoutByNW4R : public Base, public nw4rmanager::Layout {
public:
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
#ifdef TIMANAGER_IMPLEMENTATION
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
: Base(manager), nw4rmanager::Layout(accessor, layoutName, observer), mpEventHandler(NULL) {}
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator);
virtual void init();
virtual void setCommandReceiver(CommandReceiver* receiver);
virtual void updateFromReceiver(u32 command, void* data);
virtual void onKey(u32 event, void* data);
virtual void setLanguage(Language language);
virtual void update();
virtual void onActive();
virtual void calc();
virtual void draw();
virtual void changeInputMode(InputMode mode);
virtual void setInputMode(InputMode mode);
virtual void setUpperCaseJP(bool upper);
virtual void setLangKeyActive(bool active);
virtual void goSignInputMode();
virtual void changePredictLanguage();
virtual void setAbcMode(bool abc);
virtual void doNumericMode(bool);
virtual void setPredictLanguageDialog(predictlang::LayoutByNW4R* dialog);
virtual void setSignWindow(signwindow::LayoutByNW4R* window);
#else
#if defined(MYTIMANAGER_IMPLEMENTATION) && defined(TI_CELLPHONE_SAMPLE_CLASS)
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer)
: Base(manager), nw4rmanager::Layout(resAccessor, "fs_VK_cellPhone_a.brlyt", observer), mpSignWindow(NULL) {}
#endif
virtual void doNumericMode(bool);
#ifdef TI_CELLPHONE_IMPLEMENTATION
virtual void setPredictLanguageDialog(predictlang::LayoutByNW4R*);
virtual void setSignWindow(signwindow::LayoutByNW4R*);
#else
virtual void setPredictLanguageDialog(void*);
virtual void setSignWindow(void*);
#endif
#endif
virtual void doNumericWithDotMode(bool);
virtual void setLineFeedButton(bool);
virtual void setPredictLanguageButton(bool);
virtual void setSignWindowButton(bool);
#endif
virtual bool onClose();
void onPressedShift(bool shift);
void onReleasedShift();
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
bool hasLineFeedButton() const { return mbLineFeedButton; }
private:
bool mbLineFeedButton;
#ifdef TIMANAGER_IMPLEMENTATION
GXTexObj mSpaceTexture;
GXTexObj mSpaceTextureCN;
GXTexObj mSpaceTextureKR;
nw4rmanager::TiEventHandler* mpEventHandler;
predictlang::LayoutByNW4R* mpPredictDialog;
signwindow::LayoutByNW4R* mpSignWindow;
#endif
public:
#endif
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION)
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
#ifdef TI_CELLPHONE_IMPLEMENTATION
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator) override;
virtual void init() override;
virtual void draw() override;
virtual void calc() override;
virtual void update() override;
virtual void onKey(u32 key, void* data) override;
virtual void onActive() override;
virtual void updateFromReceiver(u32 command, void* data) override;
virtual void changeInputMode(InputMode mode) override;
virtual void changePredictLanguage() override;
virtual void setAbcMode(bool enabled) override;
virtual void goSignInputMode() override;
virtual void setInputMode(InputMode mode) override;
virtual void setLanguage(Language language) override;
virtual void setCommandReceiver(CommandReceiver* receiver) override;
virtual CellPhoneAnmPane* getAnmPane(InputMode mode);
virtual void throwReleaseForAll();
virtual void changeAnimationAllToNormal();
virtual void updatePredictLanguage(CommandReceiver::ChangePredictMode* mode);
virtual void changeKeyTop(const PaneNameToCharCode* keys);
virtual void changeSpaceKeyTop(const PaneNameToCharCode* keys);
void setUpperCaseJP(bool enabled);
void setLangKeyActive(bool enabled);
void resetHoldingButton();
private:
bool mbLineFeedButton;
GXTexObj mTextures[3];
EventHandler* mpEventHandler;
predictlang::LayoutByNW4R* mpPredictLanguageDialog;
signwindow::LayoutByNW4R* mpSignWindow;
#elif defined(TIMANAGER_IMPLEMENTATION)
virtual nw4rmanager::AnmPane* getAnmPane(InputMode mode);
virtual void throwReleaseForAll();
virtual void changeAnimationAllToNormal();
virtual void updatePredictLanguage(CommandReceiver::ChangePredictMode* mode);
virtual void changeKeyTop(const struct PaneNameToCharCode* table);
virtual void changeSpaceKeyTop(const struct PaneNameToCharCode* table);
#endif
};
#ifdef TI_CELLPHONE_SAMPLE_CLASS
class Sample : public LayoutByNW4R {
public:
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer)
: LayoutByNW4R(manager, resAccessor, observer) {}
virtual ~Sample() {}
};
#endif
#endif

View File

@@ -93,8 +93,13 @@ namespace textinput {
extern const KeySet csKeySetCNPinyin;
extern const KeySet csKeySetHangul;
#ifdef TI_CELLPHONE_MATCH_LAYOUT
extern const wchar_t* csSpaceZero;
extern const wchar_t* csSpace;
#else
extern const wchar_t csSpaceZero[3];
extern const wchar_t csSpace[3];
#endif
}
}
}

View File

@@ -151,6 +151,26 @@ namespace textinput {
u32 GetModifierState() const;
void SetModifierState(u32, u32);
#if defined(TI_CELLPHONE_HKB_KEYSET)
class KeySet {
public:
u8 GetKey() const;
u32 GetWChar() const;
bool IsValid() const;
KeySet GetNext() const;
KeySet(const KeySet& other)
: mpManager(other.mpManager), mKind(other.mKind), mIndex(other.mIndex),
mDevice(other.mDevice), mCharacter(other.mCharacter) {}
private:
const HKBManager* mpManager;
u8 mKind;
s8 mIndex;
u8 mDevice;
u16 mCharacter;
};
KeySet GetTriggeredKeySet() const;
KeySet GetRepeatedKeySet() const;
#else
#if defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TISIGNWINDOW_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION)
class KeySet {
public:
@@ -202,6 +222,7 @@ namespace textinput {
KeySet GetRepeatedKeySet() const;
#endif
#endif
#endif
private:
u8 unk_0x00[0xFC];

View File

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

View File

@@ -15,9 +15,12 @@ namespace textinput {
#if !(defined(TI_PC_KEYBOARD_IMPLEMENTATION) || defined(TIHWKEYBOARD_IMPLEMENTATION)) && !defined(TIMANAGER_IMPLEMENTATION) && !defined(TISIGNWINDOW_IMPLEMENTATION)
virtual void create(MEMAllocator* alloc) override;
virtual void init() override;
#ifndef TI_CELLPHONE_MATCH_LAYOUT
virtual void setCommandReceiver(CommandReceiver* receiver) override;
virtual void sendCommand(u32 command, void*) override;
#endif
#endif
#if !defined(TIMANAGER_IMPLEMENTATION) && !defined(TISIGNWINDOW_IMPLEMENTATION)
virtual void updateFromReceiver(u32, void*) override;
#endif

View File

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

View File

@@ -20,7 +20,11 @@ namespace gui {
class Manager;
class EventHandler;
#if defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
class __declspec(novtable) Interface {
#else
class Interface {
#endif
public:
virtual void create() {} // 0x08 (0x02)
@@ -30,14 +34,14 @@ namespace gui {
virtual void draw(Mtx& mtx) {} // 0x14 (0x05)
virtual void draw() {} // 0x18 (0x06)
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
#if defined(IPL_CHANNEL_TITLE_NOVTABLE) || defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
virtual ~Interface(); // 0x1C (0x07)
#else
virtual ~Interface() {} // 0x1C (0x07)
#endif
};
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
#if defined(IPL_CHANNEL_TITLE_NOVTABLE) || defined(IPL_GC_WINDOW_NOVTABLE) || defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
class __declspec(novtable) EventHandler {
#else
class EventHandler {

View File

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

View File

@@ -69,7 +69,7 @@ namespace ipl {
HermiteIntp() {}
virtual ~HermiteIntp();
void init(const T& start, const T& end, f32 maxFrame, f32 param_5, f32 param_6, int playback = ANIM_TYPE_FORWARD, f32 speed = 1.0f);
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;
@@ -81,11 +81,11 @@ namespace ipl {
(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)))));
r +=
(unkVal0 *
(mStartTangent *
(var_f27 +
((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (2.0f * var_f27 * var_f27))))) +
(unkVal1 * ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(mEndTangent * ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (var_f27 * var_f27))));
return r;
@@ -101,7 +101,7 @@ namespace ipl {
f32 temp_f4 = var_f27 * var_f27;
f32 temp_f7 = var_f28 * (var_f28 * (var_f27 * temp_f4));
f32 temp_f3 =
(unkVal0 * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (unkVal1 * (temp_f7 - (var_f28 * temp_f4)));
(mStartTangent * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (mEndTangent * (temp_f7 - (var_f28 * temp_f4)));
r = r + temp_f3;
return r;*/
}
@@ -109,8 +109,8 @@ namespace ipl {
protected:
T mStart;
T mEnd;
f32 unkVal0;
f32 unkVal1;
f32 mStartTangent;
f32 mEndTangent;
};
template <>
@@ -119,7 +119,7 @@ namespace ipl {
HermiteIntp() {}
virtual ~HermiteIntp();
void init(const f32& start, const f32& end, f32 maxFrame, f32 param_5, f32 param_6, int playback = ANIM_TYPE_FORWARD,
void init(const f32& start, const f32& end, f32 maxFrame, f32 startTangent, f32 endTangent, int playback = ANIM_TYPE_FORWARD,
f32 speed = 1.0f);
f32 get() const {
@@ -132,10 +132,10 @@ namespace ipl {
(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)))));
r +=
(unkVal0 *
(mStartTangent *
(var_f27 + ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (2.0f * var_f27 * var_f27))))) +
(unkVal1 * ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(mEndTangent * ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (var_f27 * var_f27))));
return r;
@@ -144,8 +144,8 @@ namespace ipl {
protected:
f32 mStart;
f32 mEnd;
f32 unkVal0;
f32 unkVal1;
f32 mStartTangent;
f32 mEndTangent;
};
#pragma dont_instantiate HermiteIntp<float>
@@ -155,14 +155,36 @@ namespace ipl {
public:
HermiteIntp() {}
void init(const T& start, const T& end, f32 maxFrame, f32 param_5, f32 param_6, int playback = ANIM_TYPE_FORWARD, f32 speed = 1.0f) {
void init(const T& start, const T& 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);
unkVal0 = param_5;
unkVal1 = param_6;
mStartTangent = startTangent;
mEndTangent = endTangent;
}
#ifdef IPL_SD_CHANNEL_SELECT_CPP
T get() const {
f32 frame = mFrame;
f32 inverseDuration = 1.0f / mMaxFrame;
T result =
(mStart * (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))));
f32 frameSquared = frame * frame;
f32 cubic = inverseDuration * (inverseDuration * (frame * frameSquared));
f32 tangent = mStartTangent * (frame + (cubic -
inverseDuration * (2.0f * frame * frame))) +
mEndTangent * (cubic - inverseDuration * frameSquared);
result.x += tangent;
result.y += tangent;
result.z += tangent;
return result;
}
#else
T get() const {
f32 var_f27 = mFrame;
f32 var_f28 = 1.0f / mMaxFrame;
@@ -174,7 +196,7 @@ namespace ipl {
f32 temp_f4 = var_f27 * var_f27;
f32 temp_f7 = var_f28 * (var_f28 * (var_f27 * temp_f4));
f32 temp_f3 =
(unkVal0 * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (unkVal1 * (temp_f7 - (var_f28 * temp_f4)));
(mStartTangent * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (mEndTangent * (temp_f7 - (var_f28 * temp_f4)));
r = r + temp_f3;
@@ -191,14 +213,55 @@ namespace ipl {
f32 temp_f4 = var_f27 * var_f27;
f32 temp_f7 = var_f28 * (var_f28 * (var_f27 * temp_f4));
f32 temp_f3 =
(unkVal0 * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (unkVal1 * (temp_f7 - (var_f28 * temp_f4)));
(mStartTangent * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (mEndTangent * (temp_f7 - (var_f28 * temp_f4)));
r = r + temp_f3;
return r;*/
}
#endif
protected:
f32 unkVal0;
f32 unkVal1;
f32 mStartTangent;
f32 mEndTangent;
};
#endif
#ifdef IPL_SD_CHANNEL_SELECT_CPP
} // namespace math
} // namespace ipl
#include "math/iplMathTypes.h"
namespace ipl {
namespace math {
template <>
class HermiteIntp<VEC3> : public utility::FrameController {
public:
HermiteIntp() {}
virtual ~HermiteIntp();
void init(const VEC3& start, const VEC3& end, f32 maxFrame, f32 startTangent, f32 endTangent, int playback = ANIM_TYPE_FORWARD, f32 speed = 1.0f);
VEC3 get() const {
f32 frame = mFrame;
f32 inverseDuration = 1.0f / mMaxFrame;
VEC3 result =
(mStart * (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))));
f32 frameSquared = frame * frame;
f32 cubic = inverseDuration * (inverseDuration * (frame * frameSquared));
f32 tangent = mStartTangent * (frame + (cubic -
inverseDuration * (2.0f * frame * frame))) +
mEndTangent * (cubic - inverseDuration * frameSquared);
result.x += tangent;
result.y += tangent;
result.z += tangent;
return result;
}
protected:
VEC3 mStart;
VEC3 mEnd;
f32 mStartTangent;
f32 mEndTangent;
};
#endif

View File

@@ -134,7 +134,15 @@ namespace ipl {
VEC3& operator/=(f32 val) { return operator*=(1.f / val); }
VEC3 operator+(const VEC3& rhs) const { return VEC3(x + rhs.x, y + rhs.y, z + rhs.z); }
VEC3 operator+(f32 v) const { return VEC3(x + v, y + v, z + v); }
#ifdef IPL_SD_CHANNEL_SELECT_CPP
nw4r::math::VEC3 operator-(const VEC3& rhs) const {
nw4r::math::VEC3 difference;
nw4r::math::VEC3Sub(&difference, this, &rhs);
return difference;
}
#else
VEC3 operator-(const VEC3& rhs) const { return VEC3(x - rhs.x, y - rhs.y, z - rhs.z); }
#endif
VEC3 operator*(f32 val) const { return VEC3(x * val, y * val, z * val); }
VEC3 operator*(f64 val) const {
nw4r::math::VEC3 vecOut;

View File

@@ -86,6 +86,7 @@ namespace ipl {
const utility::BScroller& getBInst() { return mBScroller; }
#ifdef IPL_SDMEMORY_SCROLLER_BINST_RESET
void initScroll() { mScroller.init(); }
void resetBInst() { mBScroller.reset(); }
#endif

View File

@@ -8,7 +8,7 @@
namespace ipl {
namespace scene {
class GCWindow : public MemoryBase, public MemCardEventHandler {
class GCWindow : public MemoryBase, public MemCardEventListener {
#ifdef IPL_MEMORY_CARD_CPP
friend class MemoryCard;
#endif
@@ -48,6 +48,25 @@ private:
void set_texture(const char*, const GXTexObj&);
public:
virtual void onMemEvent(long, u8);
#ifdef IPL_GC_WINDOW_CPP
virtual void on_wait_anim() = 0;
virtual void on_exit() = 0;
virtual void on_error() = 0;
virtual void on_format() = 0;
virtual void on_dialog_result() = 0;
virtual void on_select_in() = 0;
virtual void on_message_done() = 0;
virtual void on_button_trig() = 0;
#else
virtual void on_wait_anim();
virtual void on_exit();
virtual void on_error();
virtual void on_format();
virtual void on_dialog_result();
virtual void on_select_in();
virtual void on_message_done();
virtual void on_button_trig();
#endif
bool isProcess();
void stop_wait_anim();

View File

@@ -35,7 +35,11 @@ namespace ipl {
MemoryBase* mpBase; // 0x0C
};
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
class __declspec(novtable) MemoryBase {
#else
class MemoryBase {
#endif
public:
class Anm {
public:

View File

@@ -12,13 +12,61 @@
namespace ipl {
namespace scene {
class MemCardEventHandler {
class __declspec(novtable) MemCardEventListener {
public:
MemCardEventListener() {}
virtual ~MemCardEventListener() {}
virtual void onMemEvent(long event, u8 slot);
};
class MemCardEventHandler : public MemCardEventListener {
public:
MemCardEventHandler() {}
virtual ~MemCardEventHandler();
virtual void onMemEvent(long event, u8 slot);
virtual void onMount(u8 slot) = 0;
virtual void onUnmount(u8 slot) = 0;
virtual void onAttach(u8 slot) = 0;
virtual void onDetach(u8 slot) = 0;
virtual void onCheck(u8 slot) = 0;
virtual void onFormat(u8 slot) = 0;
virtual void onRepair(u8 slot) = 0;
virtual void onRead(u8 slot) = 0;
virtual void onWrite(u8 slot) = 0;
virtual void onOpen(u8 slot) = 0;
virtual void onClose(u8 slot) = 0;
virtual void onCreate(u8 slot) = 0;
virtual void onDelete(u8 slot) = 0;
virtual void onCopy(u8 slot) = 0;
virtual void onMove(u8 slot) = 0;
virtual void onRename(u8 slot) = 0;
virtual void onVerify(u8 slot) = 0;
virtual void onCommit(u8 slot) = 0;
virtual void onProbe(u8 slot) = 0;
virtual void onMountAsync(u8 slot) = 0;
virtual void onUnmountAsync(u8 slot) = 0;
virtual void onCheckAsync(u8 slot) = 0;
virtual void onFormatAsync(u8 slot) = 0;
virtual void onReadAsync(u8 slot) = 0;
virtual void onWriteAsync(u8 slot) = 0;
virtual void onCreateAsync(u8 slot) = 0;
virtual void onDeleteAsync(u8 slot) = 0;
virtual void onCopyAsync(u8 slot) = 0;
virtual void onMoveAsync(u8 slot) = 0;
virtual void onRenameAsync(u8 slot) = 0;
virtual void onVerifyAsync(u8 slot) = 0;
virtual void onCommitAsync(u8 slot) = 0;
virtual void onProbeAsync(u8 slot) = 0;
virtual void onFreeBlocks(u8 slot) = 0;
virtual void onGetLength(u8 slot) = 0;
virtual void onSetAttrib(u8 slot) = 0;
virtual void onGetAttrib(u8 slot) = 0;
virtual void onSlotStatus(u8 slot) = 0;
};
typedef struct MCFile {
@@ -56,6 +104,44 @@ namespace ipl {
}
virtual ~MemoryCardManager();
virtual void onMount(u8 slot) = 0;
virtual void onUnmount(u8 slot) = 0;
virtual void onAttach(u8 slot) = 0;
virtual void onDetach(u8 slot) = 0;
virtual void onCheck(u8 slot) = 0;
virtual void onFormat(u8 slot) = 0;
virtual void onRepair(u8 slot) = 0;
virtual void onRead(u8 slot) = 0;
virtual void onWrite(u8 slot) = 0;
virtual void onOpen(u8 slot) = 0;
virtual void onClose(u8 slot) = 0;
virtual void onCreate(u8 slot) = 0;
virtual void onDelete(u8 slot) = 0;
virtual void onCopy(u8 slot) = 0;
virtual void onMove(u8 slot) = 0;
virtual void onRename(u8 slot) = 0;
virtual void onVerify(u8 slot) = 0;
virtual void onCommit(u8 slot) = 0;
virtual void onProbe(u8 slot) = 0;
virtual void onMountAsync(u8 slot) = 0;
virtual void onUnmountAsync(u8 slot) = 0;
virtual void onCheckAsync(u8 slot) = 0;
virtual void onFormatAsync(u8 slot) = 0;
virtual void onReadAsync(u8 slot) = 0;
virtual void onWriteAsync(u8 slot) = 0;
virtual void onCreateAsync(u8 slot) = 0;
virtual void onDeleteAsync(u8 slot) = 0;
virtual void onCopyAsync(u8 slot) = 0;
virtual void onMoveAsync(u8 slot) = 0;
virtual void onRenameAsync(u8 slot) = 0;
virtual void onVerifyAsync(u8 slot) = 0;
virtual void onCommitAsync(u8 slot) = 0;
virtual void onProbeAsync(u8 slot) = 0;
virtual void onFreeBlocks(u8 slot) = 0;
virtual void onGetLength(u8 slot) = 0;
virtual void onSetAttrib(u8 slot) = 0;
virtual void onGetAttrib(u8 slot) = 0;
void calc();
bool isSlotReady(u8 slot);
@@ -96,7 +182,7 @@ namespace ipl {
u16 getFreeBlocks(u8 slot);
#endif
void setEventHandler(MemCardEventHandler* eventHandler) {
void setEventHandler(MemCardEventListener* eventHandler) {
mpEventHandler = eventHandler;
}
@@ -107,7 +193,7 @@ namespace ipl {
s32 mLastResult; // 0x16930
s32 mLastCmd; // 0x16934
u32 unk_0x16938; // 0x16938
MemCardEventHandler* mpEventHandler; // 0x1693C
MemCardEventListener* mpEventHandler; // 0x1693C
};
} // namespace scene
} // namespace ipl

View File

@@ -312,6 +312,33 @@ namespace ipl {
void setLayoutFrame(int state);
BOOL tellStartingZoomAnm();
void initPageAnimations(const math::VEC3& position, int direction);
#ifdef IPL_SD_CHANNEL_SELECT_CPP
void removeNandTitleInfo(ESTitleId titleId) {
u32 titleCount = mNandTitleCount;
u32 index = 0;
for (; index < titleCount; ++index) {
if (mpNandTitleInfo[index].curTitleId == titleId) {
break;
}
}
if (index < mNandTitleCount) {
for (; index < mNandTitleCount - 1; ++index) {
NandSDWorker::TitleUsage& nextTitle = mpNandTitleInfo[index + 1];
NandSDWorker::TitleUsage& currentTitle = mpNandTitleInfo[index];
currentTitle.curTitleId = nextTitle.curTitleId;
currentTitle.size = nextTitle.size;
currentTitle.inode = nextTitle.inode;
}
--mNandTitleCount;
}
}
nw4r::math::VEC3 getPageTransitionPosition(int index) const {
nw4r::math::VEC3 position(0.0f, 0.0f, 0.0f);
nw4r::lyt::Pane* pane = getCenterChannelPane(index);
PSMTXMultVec(pane->GetGlobalMtx(), position, position);
return position;
}
#endif
static BOOL isChannelReady(const SDChannelObj* channel);
nw4r::ut::List mChannelObjects;
nand::LayoutFile* mpLayoutFile;
@@ -368,9 +395,9 @@ namespace ipl {
NandSDWorker* mpSDWorker;
ESTitleId32* mpSDTitleIds;
SDChannelSelectTitleInfo* mpSDTitleInfo;
NandSDWorker::TitleUsage* mpNandTitleInfo;
s32 mFirstTitleCount;
s32 mSecondTitleCount;
mutable NandSDWorker::TitleUsage* mpNandTitleInfo;
mutable s32 mFirstTitleCount;
mutable s32 mSecondTitleCount;
SDChannelObj* mpCurrentLoadedChannel;
u32 mSDTitleCount;
u32 mNandTitleCount;

View File

@@ -29,6 +29,9 @@ namespace ipl {
class Setting;
class APScanThread;
#ifdef IPL_SETTING_IMPLEMENTATION
class APEvent;
#else
class APEvent : public ::gui::EventHandler {
public:
APEvent(Setting* setting) : ::gui::EventHandler(), mpSetting(setting) {}
@@ -38,16 +41,17 @@ namespace ipl {
private:
Setting* mpSetting;
};
struct SettingAnimation {
u8 unknown[0x14];
int state;
};
#endif
struct SettingAPScanList {
u8 unknown[0x14];
u16 count;
u8 entries[0x7fe];
union {
struct {
u16 count;
u8 entries[0x7fe];
};
u8 recordBuffer[0x800];
};
union {
WDBssDesc_* currentDescriptor;
u16* currentDescriptorWords;
@@ -86,7 +90,7 @@ namespace ipl {
void initHTMLText();
void initMessage();
void initKeyboard(const char* text);
bool checkInputString(const wchar_t* text);
bool checkInputString(const wchar_t* text) NO_INLINE;
int checkIPString(const wchar_t* text);
void setDefaultBackString();
void calcKeyboard();
@@ -158,7 +162,6 @@ namespace ipl {
virtual void destroy();
virtual void prepare();
virtual void create();
virtual void calc();
virtual void draw();
virtual FaderSceneCommand calcFadein();
virtual FaderSceneCommand calcNormal();
@@ -208,8 +211,8 @@ namespace ipl {
layout::Object* mpChangeLayout;
layout::Object* mpMainLayout;
layout::Object* mpWaitLayout;
SettingAnimation* mpFirstAnimation;
SettingAnimation* mpSecondAnimation;
utility::FrameController* mpFirstAnimation;
utility::FrameController* mpSecondAnimation;
APEvent* mpEventHandler;
gui::PaneManager* mpPaneManager;
void* mpUSBAPThread;
@@ -262,6 +265,17 @@ namespace ipl {
#endif
};
#ifdef IPL_SETTING_IMPLEMENTATION
class APEvent : public ::gui::EventHandler {
public:
APEvent(Setting* setting) : ::gui::EventHandler(), mpSetting(setting) {}
virtual void onEvent(u32 componentID, u32 event, void* data);
private:
Setting* mpSetting;
};
#endif
} // namespace scene
} // namespace ipl

View File

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

View File

@@ -38,21 +38,49 @@ namespace ipl {
int holdSE(const char* sndName);
int holdSEwithPosDis(const char* sndName, f32 x, f32 y);
#ifdef IPL_SOUND_MATCHING
void stopBGM(int unk = 0);
#else
int stopBGM(int unk = 0);
#endif
int stopBGM(nw4r::snd::SoundHandle* handle, int unk = 0);
int stopSE(nw4r::snd::SoundHandle* handle, int unk = 0);
void stopAllSound(int unk = 0);
int resetAllSound();
#ifdef IPL_SOUND_MATCHING
void muteOffBGM(int);
#else
int muteOffBGM(int);
#endif
#ifdef IPL_SOUND_MATCHING
void muteOnBGM(int);
#else
int muteOnBGM(int);
#endif
#ifdef IPL_SOUND_MATCHING
void pauseOnBGM();
#else
int pauseOnBGM();
#endif
#ifdef IPL_SOUND_MATCHING
void pauseOffBGM();
#else
int pauseOffBGM();
#endif
#ifdef IPL_SOUND_MATCHING
void pauseOnSE();
#else
int pauseOnSE();
#endif
#ifdef IPL_SOUND_MATCHING
void pauseOffSE();
#else
int pauseOffSE();
#endif
void setOutputMode(EAudioOutputMode mode);

View File

@@ -39,7 +39,7 @@ namespace ipl {
void stt_wait_fns_msg();
void stt_wait_terminate();
int fn_8135B1C0();
int getProgressPercent();
void error_handling();

View File

@@ -37,23 +37,41 @@ namespace ipl {
LETTER,
PHOTO_LETTER,
NUMERIC,
#ifdef IPL_SETTING_IMPLEMENTATION
NORMAL_WITHOUT_LINEFEED = 2,
NORMAL_WITHOUT_LINEFEED_WITH_SIGN = 4,
NORMAL_BIGTEXT_WITHOUT_LINEFEED = 6,
#else
NORMAL_WITHOUT_LINEFEED,
NORMAL_WITHOUT_LINEFEED_WITH_SIGN,
NORMAL_BIGTEXT_WITHOUT_LINEFEED,
#endif
ONLY_QWERTY_WITHOUT_LINEFEED_AND_SIGN,
ONLY_QWERTY_BIGTEXT_WITHOUT_LINEFEED_AND_SIGN,
#ifdef IPL_SETTING_IMPLEMENTATION
NUMERIC_WITH_DOT = 16,
NUMERIC_BIGTEXT_WITH_DOT = 10,
#else
NUMERIC_WITH_DOT,
NUMERIC_BIGTEXT_WITH_DOT,
#endif
NORMAL_BIGTEXT_WITHOUT_LINEFEED_WITH_SIGN,
NUMERIC_WITH_SEPERATOR,
PREDICT_WITHOUT_LINEFEED,
} KeyboardType;
typedef struct KeyboardSetting {
#ifdef IPL_SETTING_IMPLEMENTATION
u32 rowLimit;
const wchar_t* wcString;
u32 stringLimit;
KeyboardType type;
#else
KeyboardType type; // 0x00
const wchar_t* wcString; // 0x04
u32 stringLimit; // 0x08
u32 rowLimit; // 0x0C
#endif
#ifdef IPL_ADDRESS_EDIT_CPP
KeyboardSetting(KeyboardType keyboardType, const wchar_t* value, u32 limit, u32 rows);
#endif

View File

@@ -6,6 +6,9 @@
#include "system/iplMessage.h"
namespace ipl {
#ifdef IPL_SETTING_IMPLEMENTATION
namespace scene { class Setting; }
#endif
namespace message {
class Manager {
public:
@@ -16,6 +19,9 @@ namespace ipl {
void setResource(u8* msgData) const { mpMessage->setResource(msgData); }
private:
#ifdef IPL_SETTING_IMPLEMENTATION
friend class scene::Setting;
#endif
void initMessage();
Message* mpMessage; // 0x00

View File

@@ -24,7 +24,7 @@ namespace ipl {
class Manager;
}
namespace savedata {
extern "C" BOOL iplSavedata_813597A0(void* manager, ESTitleId titleId);
extern "C" BOOL isTitleCached(void* manager, ESTitleId titleId);
class Manager {
public:
@@ -65,6 +65,19 @@ namespace ipl {
void setDidntGotoSDMenu(BOOL value) { mData.didntGotoSDMenu = value; }
#endif
#ifdef IPL_SDMEMORY_TITLE_CACHE_ACCESS
const ESTitleId* getTitleCache() const { return &mData.titleCache[0][0]; }
ESTitleId getTitleCacheEntry(int index) const { return (&mData.titleCache[0][0])[index]; }
#endif
#ifdef IPL_SD_CHANNEL_SELECT_CPP
ESTitleId getCachedTitle(int index) const {
if (index < 0 || index >= MAX_CHANNEL_TOTAL) {
return 0;
}
return (&mData.titleCache[0][0])[index];
}
#endif
bool hasPhotoMP3Dummy() { return mbPhotoMP3; }
bool hasPhoto2Title() { return mbPhoto2; }
bool hasPhoto2DummyCheck() { return mbPhoto2Check; }
@@ -74,7 +87,7 @@ namespace ipl {
channel::SInfo& getChanInfo(int page, int index) { return mData.chanInfo[page][index]; }
textinput::extend::savedata::MemoSetting getMemoSetting() { return mData.memoSetting; }
void iplSavedata_813596B8(ESTitleId titleId);
void pushTitleCache(ESTitleId titleId);
private:
#ifdef IPL_SD_CHANNEL_SELECT_ACCESS
@@ -171,7 +184,7 @@ namespace ipl {
u8 unused_0x504[28];
friend class channel::Manager;
friend BOOL iplSavedata_813597A0(void* manager, ESTitleId titleId);
friend BOOL isTitleCached(void* manager, ESTitleId titleId);
};
} // namespace savedata
} // namespace ipl

View File

@@ -48,10 +48,14 @@ namespace EGG {
virtual bool prepareSound(nw4r::snd::SoundHandle* pHandle, u32 id) { return mSoundArchivePlayer.PrepareSound(pHandle, id); } // 0x44
virtual bool prepareSound(nw4r::snd::SoundHandle* pHandle, unsigned int id) { return mSoundArchivePlayer.PrepareSound(pHandle, id); } // 0x44
virtual bool prepareSound(nw4r::snd::SoundHandle* pHandle, const char* pName) {
#ifdef IPL_SOUND_MATCHING
u32 id = changeNameToId(pName);
#else
u32 id = nw4r::snd::SoundArchive::INVALID_ID;
if (mpArchive != NULL) {
id = changeNameToId(pName);
}
#endif
return mSoundArchivePlayer.PrepareSound(pHandle, id);
} // 0x48

View File

@@ -20,9 +20,13 @@ namespace EGG {
~SoundHeapMgr() { destroySoundHeap(); }
virtual bool loadState(s32 id) {
#ifdef IPL_SOUND_MATCHING
if (id > 0 && mHeap.GetCurrentLevel() >= id) {
#else
s32 level = mHeap.GetCurrentLevel();
if (id > 0 && level >= id) {
#endif
mHeap.LoadState(id);
return true;
}

View File

@@ -528,6 +528,7 @@ static char* double2hex(long double num, char* buff, print_format format) {
unsigned snum;
long exp;
print_format exp_format;
print_format* exp_fmt_ptr = &exp_format;
int hex_precision;
int mantissa_bit;
decform form;
@@ -602,7 +603,7 @@ static char* double2hex(long double num, char* buff, print_format format) {
exp = snum - 0x3FF;
p = long2str(exp, buff, exp_format);
p = long2str(exp, buff, *exp_fmt_ptr);
if (format.conversion_char == 'a')
*--p = 'p';
else
@@ -624,7 +625,7 @@ static char* double2hex(long double num, char* buff, print_format format) {
working_byte = (*(q + mantissa_byte)) >> (7 - (mantissa_bit & 7));
if ((mantissa_bit & ~7) != ((mantissa_bit - 4) & ~7)) {
working_byte |= (unsigned char)(((*(q + (mantissa_byte - 1))) << 8) >> (7 - ((mantissa_bit) & 7)));
working_byte |= (((*(q + (mantissa_byte - 1))) << 8) >> (7 - ((mantissa_bit) & 7)));
}
if (!TARGET_FLOAT_IMPLICIT_J_BIT) {
@@ -635,14 +636,14 @@ static char* double2hex(long double num, char* buff, print_format format) {
}
if ((working_byte &= 0xF) < 10) {
working_byte = (unsigned char)(working_byte + '0');
working_byte += '0';
}
else
if (format.conversion_char == 'a') {
working_byte = (unsigned char)(working_byte + 'a' - 10);
working_byte += 'a' - 10;
}
else {
working_byte = (unsigned char)(working_byte + 'A' - 10);
working_byte += 'A' - 10;
}
}
else {
@@ -967,6 +968,7 @@ int __pformatter(void* (*WriteProc)(void*, const char*, size_t), void* WriteProc
const char* format_ptr;
const char* curr_format;
print_format format;
print_format* fmt_ptr = &format;
signed long long_num;
signed long long long_long_num;
long double long_double_num;
@@ -1033,11 +1035,11 @@ int __pformatter(void* (*WriteProc)(void*, const char*, size_t), void* WriteProc
|| format.argument_options == intmax_argument
)
{
if (!(buff_ptr = longlong2str(long_long_num, buff + 512, format))) {
if (!(buff_ptr = longlong2str(long_long_num, buff + 512, *fmt_ptr))) {
goto conversion_error;
}
} else {
if (!(buff_ptr = long2str(long_num, buff + 512, format))) {
if (!(buff_ptr = long2str(long_num, buff + 512, *fmt_ptr))) {
goto conversion_error;
}
}
@@ -1079,11 +1081,11 @@ int __pformatter(void* (*WriteProc)(void*, const char*, size_t), void* WriteProc
|| format.argument_options == intmax_argument
)
{
if (!(buff_ptr = longlong2str(long_long_num, buff + 512, format))) {
if (!(buff_ptr = longlong2str(long_long_num, buff + 512, *fmt_ptr))) {
goto conversion_error;
}
} else {
if (!(buff_ptr = long2str(long_num, buff + 512, format))) {
if (!(buff_ptr = long2str(long_num, buff + 512, *fmt_ptr))) {
goto conversion_error;
}
}
@@ -1103,7 +1105,7 @@ int __pformatter(void* (*WriteProc)(void*, const char*, size_t), void* WriteProc
long_double_num = va_arg(arg, double);
}
if (!(buff_ptr = float2str(long_double_num, buff + 512, format))) {
if (!(buff_ptr = float2str(long_double_num, buff + 512, *fmt_ptr))) {
goto conversion_error;
}
@@ -1118,7 +1120,7 @@ int __pformatter(void* (*WriteProc)(void*, const char*, size_t), void* WriteProc
long_double_num = va_arg(arg, double);
}
if (!(buff_ptr = double2hex(long_double_num, buff + 512, format))) {
if (!(buff_ptr = double2hex(long_double_num, buff + 512, *fmt_ptr))) {
goto conversion_error;
}

View File

@@ -248,6 +248,8 @@ static char* find_name(const char* names, int index) {
return extracted_name;
}
#pragma exceptions off
char* asctime(const struct tm* timeptr) {
static char asctime_result[26];
char* result = asctime_result;
@@ -283,6 +285,8 @@ char* ctime(const time_t* timer) {
return result;
}
#pragma exceptions on
static time_t time(time_t* timer) {
time_t result = __get_time();
@@ -312,6 +316,8 @@ static struct tm* gmtime(const time_t* timer) {
return &gmtime_tm;
}
#pragma exceptions on
struct tm* localtime(const time_t* timer) {
static struct tm localtime_tm;

View File

@@ -521,6 +521,7 @@ static wchar_t* double2hex(long double num, wchar_t* buff, print_format format)
unsigned snum;
long exp;
print_format exp_format;
print_format* exp_fmt_ptr = &exp_format;
int hex_precision;
int mantissa_bit;
decform form;
@@ -595,7 +596,7 @@ static wchar_t* double2hex(long double num, wchar_t* buff, print_format format)
exp = snum - 0x3FF;
p = long2str(exp, buff, exp_format);
p = long2str(exp, buff, *exp_fmt_ptr);
if (format.conversion_char == 'a')
*--p = 'p';
else
@@ -617,7 +618,7 @@ static wchar_t* double2hex(long double num, wchar_t* buff, print_format format)
working_byte = (*(q + mantissa_byte)) >> (7 - (mantissa_bit & 7));
if ((mantissa_bit & ~7) != ((mantissa_bit - 4) & ~7)) {
working_byte |= (unsigned char)(((*(q + (mantissa_byte - 1))) << 8) >> (7 - ((mantissa_bit) & 7)));
working_byte |= (((*(q + (mantissa_byte - 1))) << 8) >> (7 - ((mantissa_bit) & 7)));
}
if (!TARGET_FLOAT_IMPLICIT_J_BIT) {
@@ -628,14 +629,14 @@ static wchar_t* double2hex(long double num, wchar_t* buff, print_format format)
}
if ((working_byte &= 0xF) < 10) {
working_byte = (unsigned char)(working_byte + '0');
working_byte += '0';
}
else
if (format.conversion_char == 'a') {
working_byte = (unsigned char)(working_byte + 'a' - 10);
working_byte += 'a' - 10;
}
else {
working_byte = (unsigned char)(working_byte + 'A' - 10);
working_byte += 'A' - 10;
}
}
else {
@@ -970,6 +971,7 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
const wchar_t* format_ptr;
const wchar_t* curr_format;
print_format format;
print_format* fmt_ptr = &format;
signed long long_num;
signed long long long_long_num;
long double long_double_num;
@@ -1027,11 +1029,11 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
if (format.argument_options == long_long_argument ||
format.argument_options == intmax_argument)
{
if (!(buff_ptr = longlong2str(long_long_num, buff + 512, format))) {
if (!(buff_ptr = longlong2str(long_long_num, buff + 512, *fmt_ptr))) {
goto conversion_error;
}
} else {
if (!(buff_ptr = long2str(long_num, buff + 512, format))) {
if (!(buff_ptr = long2str(long_num, buff + 512, *fmt_ptr))) {
goto conversion_error;
}
}
@@ -1069,11 +1071,11 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
|| format.argument_options == intmax_argument
)
{
if (!(buff_ptr = longlong2str(long_long_num, buff + 512, format))) {
if (!(buff_ptr = longlong2str(long_long_num, buff + 512, *fmt_ptr))) {
goto conversion_error;
}
} else {
if (!(buff_ptr = long2str(long_num, buff + 512, format))) {
if (!(buff_ptr = long2str(long_num, buff + 512, *fmt_ptr))) {
goto conversion_error;
}
}
@@ -1093,7 +1095,7 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
long_double_num = va_arg(args, double);
}
if (!(buff_ptr = float2str(long_double_num, buff + 512, format))) {
if (!(buff_ptr = float2str(long_double_num, buff + 512, *fmt_ptr))) {
goto conversion_error;
}
@@ -1108,7 +1110,7 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
long_double_num = va_arg(args, double);
}
if (!(buff_ptr = double2hex(long_double_num, buff + 512, format))) {
if (!(buff_ptr = double2hex(long_double_num, buff + 512, *fmt_ptr))) {
goto conversion_error;
}
@@ -1124,7 +1126,8 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
}
if (format.alternate_form) {
num_chars = (unsigned char)*wcs_ptr++;
wchar_t first = *wcs_ptr++;
num_chars = (unsigned char)first;
if (format.precision_specified && num_chars > format.precision) {
num_chars = format.precision;
@@ -1150,7 +1153,7 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
}
if (format.alternate_form) {
num_chars = (unsigned char)*wcs_ptr++;
num_chars = (unsigned char)*(const wchar_t*)wcs_ptr;
if (format.precision_specified && num_chars > format.precision) {
num_chars = format.precision;
@@ -1222,7 +1225,7 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
num_chars = 1;
break;
case 0xFF:
case 0xFFFF:
default:
conversion_error:
num_chars = wcslen(curr_format);

View File

@@ -93,7 +93,11 @@ namespace nw4r {
#else
void SetTranslate(const math::VEC3& translate) { mTranslate = translate; }
#endif
#ifdef IPL_SDMEMORY_SET_TRANSLATE_OUT_OF_LINE
void SetTranslate(const math::VEC2& translate);
#else
void SetTranslate(const math::VEC2& translate) { SetTranslate(math::VEC3(translate.x, translate.y, 0.0f)); }
#endif
const math::VEC3& GetRotate() const { return mRotate; }
void SetRotate(const math::VEC3& rotate) { mRotate = rotate; }

View File

@@ -11,7 +11,11 @@ namespace nw4r {
namespace snd {
class SoundHandle : private ut::NonCopyable {
public:
#ifdef IPL_SOUND_MATCHING
SoundHandle() NO_INLINE;
#else
SoundHandle() NO_INLINE : mSound(NULL) {}
#endif
~SoundHandle() { DetachSound(); }
void detail_AttachSound(detail::BasicSound* sound);

View File

@@ -31,7 +31,14 @@ namespace nw4r {
ut::detail::AutoLock<OSMutex> lock(mMutex);
return mFrameHeap.SaveState();
}
#ifdef IPL_SOUND_MATCHING
void LoadState(int id) {
ut::detail::AutoLock<OSMutex> lock(mMutex);
mFrameHeap.LoadState(id);
}
#else
void LoadState(int id);
#endif
bool IsValid() { return mFrameHeap.IsValid(); }

View File

@@ -14,9 +14,13 @@ namespace nw4r {
#else
Rect() : left(), top(), right(), bottom() {}
#endif
#ifdef IPL_SETTING_RECT_OUT_OF_LINE
Rect(f32 l, f32 t, f32 r, f32 b);
#else
Rect(f32 l, f32 t, f32 r, f32 b) : left(l), top(t), right(r), bottom(b) {}
#endif
#ifndef IPL_CONTROLLER_TRIVIAL_RECT_DTOR
#if !defined(IPL_CONTROLLER_TRIVIAL_RECT_DTOR) && !defined(IPL_MEMORYCARD_BASE_CPP)
~Rect() {}
#endif

View File

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

View File

@@ -106,7 +106,15 @@ typedef struct {
u16 outputHeight; // 0x2A
u32 convWidth; // 0x2C
u32 convHeight; // 0x30
#ifdef TMC_JPEG_PLANAR_OUTPUT
u32 chromaWidth;
u32 chromaHeight;
u8* pLumaBuffer;
u8* pCbBuffer;
u8* pCrBuffer;
#else
u8 unk_0x34[0x14]; // 0x34
#endif
void* pTexBuffer; // 0x48
u8 unk_0x4C[0x67C];
TMCCJPEGDecWork* pWorkBuf; // 0x6C8

View File

@@ -1,13 +1,118 @@
#include <string.h>
#include <tmc_jpeg_internal.h>
typedef struct {
u16 bitLength;
u16 symbol;
} TMCHuffmanEntry;
static TMCHuffmanEntry readHuffmanEntry(const TMCHuffmanEntry* entries, u32 index) {
return entries[index];
}
static TMCHuffmanEntry readHuffmanLimit(const TMCHuffmanEntry* entries) {
TMCHuffmanEntry limit;
limit.bitLength = entries->bitLength;
limit.symbol = entries->symbol;
return limit;
}
static inline s32 decodeLongHuffman(s32 bitCount, const TMCHuffmanEntry* table, const u8* symbols, TMCCJPEGDecWork* work) {
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:
{
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
if (code > (u32)decoded.bitLength) {
continue;
}
code = code - entry->bitLength + entry->symbol;
return symbols[code & 0xFF];
}
}
}
static inline s32 decodeACHuffman(s32 bitCount, const TMCHuffmanEntry* entry, const u8* symbols, TMCCJPEGDecWork* work) {
u32 bitData;
u32 code;
u32 length;
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 += 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:
{
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
if (code > (u32)decoded.bitLength) {
continue;
}
code = code - entry->bitLength + entry->symbol;
return symbols[code & 0xFF];
}
}
}
s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_ptr, TMCCJPEGDecWork* work) {
volatile u32 ac_comb;
u16* ac_fast;
TMCHuffmanEntry dcEntry;
TMCHuffmanEntry acEntry;
const TMCHuffmanEntry* ac_fast;
u8* huff_sym;
u32* huff_tbl;
s32 bit_pos;
u32 bit_data;
u16* dc_fast;
const TMCHuffmanEntry* dc_fast;
s32 r;
s32 blk0;
s32 idx;
@@ -19,29 +124,23 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
const u8* zztbl;
bit_pos = work->bitCount;
dc_fast = work->pDCFast;
dc_fast = (const TMCHuffmanEntry*)work->pDCFast;
if (bit_pos <= 8) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0) {
return r;
}
bit_pos = work->bitCount;
}
bit_pos = work->bitCount;
bit_data = work->bitBuf;
tmp = bit_pos - 8;
tmp = ((bit_data >> tmp) & 0xFF) << 2;
{
u16* dc_entry = (u16*)((u8*)dc_fast + tmp);
r = dc_entry[0];
extra = dc_entry[1];
}
{
volatile u32 dc_comb;
*(u16*)&dc_comb = r;
*((u16*)&dc_comb + 1) = extra;
dcEntry = readHuffmanEntry(dc_fast, tmp >> 2);
r = dcEntry.bitLength;
extra = dcEntry.symbol;
}
if (r != 0) {
@@ -49,74 +148,9 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
work->bitCount = bit_pos;
r = extra;
} else {
u32 code;
unsigned int i;
u16* entry;
s32 thresh;
s32 offs;
huff_sym = work->pDCHuffSym;
huff_tbl = work->pDCHuffTbl;
if (bit_pos <= 17) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0) {
return r;
}
}
bit_pos = work->bitCount;
bit_data = work->bitBuf;
bit_pos -= 9;
code = (bit_data >> bit_pos) & 0x1FF;
work->bitCount = bit_pos;
i = 9;
entry = (u16*)((u8*)huff_tbl + 0x24);
goto dc_entry;
while (1) {
i++;
entry += 2;
if (i > 16) {
r = TMCC_ERROR_OVERFLOW;
goto dc_end;
}
bit_pos = work->bitCount;
code <<= 1;
bit_data = work->bitBuf;
bit_pos--;
work->bitCount = bit_pos;
code |= (bit_data >> bit_pos) & 1;
dc_entry:
thresh = entry[0];
offs = entry[1];
{
volatile u16 p[2];
p[0] = thresh;
p[1] = offs;
tmp = *(u32*)p;
}
{
volatile u32 cw;
cw = tmp;
thresh = *(u16*)&cw;
}
if (code > (u32)thresh) {
continue;
}
code = code - entry[0] + offs;
r = huff_sym[code & 0xFF];
break;
}
dc_end:
r = decodeLongHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work);
if (r < 0) {
return r;
}
@@ -130,203 +164,120 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
if (load_ret < 0) {
return load_ret;
}
bit_pos = work->bitCount;
}
bit_pos = work->bitCount;
bit_data = work->bitBuf;
tmp = 1 << r;
extra = tmp - 1;
bit_pos -= r;
work->bitCount = bit_pos;
extra = extra & (bit_data >> bit_pos);
if ((s32)tmp >> 1 <= extra) {
extra = extra;
} else {
extra = extra - (tmp - 1);
if (((s32)tmp >> 1) > extra) {
extra -= tmp - 1;
}
dc_predict_row_ptr[0] += extra;
}
*block = dc_predict_row_ptr[0] * blk0;
ac_fast = work->pACFast;
huff_tbl = work->pACHuffTbl;
huff_sym = work->pACHuffSym;
memset((u8*)block + 4, 0, 0xFC);
bit_pos = work->bitCount;
idx = 1;
if (bit_pos <= 8) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0)
return r;
}
bit_pos = work->bitCount;
zztbl = TMCJPEGDEC_Zigzag_data;
bit_data = work->bitBuf;
t = bit_pos - 8;
{
u32 tbl_idx = ((bit_data >> t) & 0xFF) << 2;
s32 thresh_val = ac_fast[tbl_idx >> 1];
s32 offs_val = *(u16*)((u8*)ac_fast + tbl_idx + 2);
*(u16*)&ac_comb = thresh_val;
*((u16*)&ac_comb + 1) = offs_val;
}
ac_fast = (const TMCHuffmanEntry*)work->pACFast;
huff_tbl = work->pACHuffTbl;
huff_sym = work->pACHuffSym;
while (idx < 64) {
s32 ac_thresh = *(u16*)&ac_comb;
if (ac_thresh != 0) {
bit_pos = work->bitCount;
bit_pos -= ac_thresh;
work->bitCount = bit_pos;
r = *((u16*)&ac_comb + 1);
} else {
u32 code;
unsigned int i;
u16* entry;
s32 thresh;
s32 offs;
memset(block + 1, 0, 0xFC);
bit_pos = work->bitCount;
if (bit_pos <= 17) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0) {
return r;
}
bit_pos = work->bitCount;
}
bit_data = work->bitBuf;
bit_pos -= 9;
code = (bit_data >> bit_pos) & 0x1FF;
work->bitCount = bit_pos;
i = 9;
entry = (u16*)((u8*)work->pACHuffTbl + 0x24);
goto ac_entry_huff;
while (1) {
i++;
entry += 2;
if (i > 16) {
r = TMCC_ERROR_OVERFLOW;
goto ac_end;
}
bit_pos = work->bitCount;
code <<= 1;
bit_data = work->bitBuf;
bit_pos--;
work->bitCount = bit_pos;
code |= (bit_data >> bit_pos) & 1;
ac_entry_huff:
thresh = entry[0];
offs = entry[1];
{
volatile u16 p[2];
p[0] = thresh;
p[1] = offs;
tmp = *(u32*)p;
}
{
volatile u32 cw;
cw = tmp;
thresh = *(u16*)&cw;
}
if (code > (u32)thresh) {
continue;
}
code = code - entry[0] + offs;
r = huff_sym[code & 0xFF];
break;
}
ac_end:
if (r < 0) {
bit_pos = work->bitCount;
idx = 1;
if (bit_pos <= 8) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0)
return r;
}
}
t = r & 0x0F;
if (t != 0) {
r >>= 4;
idx += r;
bit_pos = work->bitCount;
zztbl = TMCJPEGDEC_Zigzag_data;
bit_data = work->bitBuf;
t = bit_pos - 8;
acEntry = readHuffmanEntry(ac_fast, (bit_data >> t) & 0xFF);
if (idx >= 64) {
return TMCC_ERROR_OVERFLOW;
}
zz = zztbl[idx];
bit_pos = work->bitCount;
if (bit_pos <= t + 8) {
r = TMCJPEGDEC_load_buff(work);
do {
s32 ac_thresh = acEntry.bitLength;
if (ac_thresh != 0) {
bit_pos = work->bitCount;
bit_pos -= ac_thresh;
work->bitCount = bit_pos;
r = acEntry.symbol;
} else {
bit_pos = work->bitCount;
r = decodeACHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work);
if (r < 0) {
return r;
}
}
t = r & 0x0F;
if (t != 0) {
r >>= 4;
idx += r;
if (idx >= 64) {
return TMCC_ERROR_OVERFLOW;
}
zz = zztbl[idx];
bit_pos = work->bitCount;
if (bit_pos <= t + 8) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0) {
return r;
}
}
bit_pos = work->bitCount;
}
tmp = 1 << t;
bit_data = work->bitBuf;
extra = tmp - 1;
bit_pos -= t;
work->bitCount = bit_pos;
t = bit_pos - 8;
{
u32 next_tbl = ((bit_data >> t) & 0xFF) << 2;
s32 next_th = ac_fast[next_tbl >> 1];
s32 next_of = *(u16*)((u8*)ac_fast + next_tbl + 2);
tmp = 1 << t;
bit_data = work->bitBuf;
extra = tmp - 1;
bit_pos -= t;
work->bitCount = bit_pos;
t = bit_pos - 8;
extra = extra & (bit_data >> bit_pos);
*(u16*)&ac_comb = next_th;
*((u16*)&ac_comb + 1) = next_of;
}
q = ((s32*)conv_row_ptr)[(u8)zz];
acEntry = readHuffmanEntry(ac_fast, (bit_data >> t) & 0xFF);
if ((s32)tmp >> 1 <= extra) {
extra = extra;
} else {
extra = extra - (tmp - 1);
}
q = ((s32*)conv_row_ptr)[zz];
block[zz] = extra * q;
idx++;
} else {
if (r == 0) {
break;
}
bit_pos = work->bitCount;
if (bit_pos <= 8) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0) {
return r;
if (((s32)tmp >> 1) > extra) {
extra -= tmp - 1;
}
}
bit_data = work->bitBuf;
bit_pos = work->bitCount;
t = bit_pos - 8;
tmp = ((bit_data >> t) & 0xFF) << 2;
{
s32 next_thresh = ac_fast[tmp >> 1];
s32 next_offs = *(u16*)((u8*)ac_fast + tmp + 2);
*(u16*)&ac_comb = next_thresh;
*((u16*)&ac_comb + 1) = next_offs;
}
idx += 16;
block[(u8)zz] = extra * q;
idx++;
} else {
if (r == 0) {
break;
}
bit_pos = work->bitCount;
if (bit_pos <= 8) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0) {
return r;
}
}
bit_data = work->bitBuf;
bit_pos = work->bitCount;
t = bit_pos - 8;
tmp = ((bit_data >> t) & 0xFF) << 2;
acEntry = readHuffmanEntry(ac_fast, tmp >> 2);
idx += 16;
}
} while (idx < 64);
if (idx > 64) {
return TMCC_ERROR_OVERFLOW;
}
}
if (idx > 64) {
return TMCC_ERROR_OVERFLOW;
idx--;
return TMCJPEGDEC_Zigzag_loop[idx];
}
idx--;
return TMCJPEGDEC_Zigzag_loop[idx];
}

View File

@@ -1,26 +1,28 @@
#include <string.h>
#include <tmc_jpeg_internal.h>
static u8 clampU8(s32 v) {
static s32 clampU8(s32 v) {
s32 ok;
ok = 0;
if (v < 256 && v > -1) {
ok = 1;
}
return (ok) ? v : ((v < 0) ? 0 : 255);
return ok ? v : (v < 0 ? 0 : 255);
}
static s8 clampS8(s32 v) {
return (v < 128 && v > -129) ? (s8)v : (v > 0) ? 127 : -128;
static s32 clampS8(s32 v) {
s32 inRange = 0;
if (v < 128 && v > -129) {
inRange = 1;
}
return inRange ? v : (v > 0) ? 127 : -128;
}
static s32 scalingClampU8(s32 val) {
s32 result = 0;
if (val >> 19 != 0)
result &= ~(val >> 31) & 0xFF;
else
result = (val >> 11);
return result;
static s32 scalingClampU8(s32 value) {
if ((value >> 19) == 0) {
return value >> 11;
}
return value < 0 ? 0 : 255;
}
void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigzag) {
@@ -29,17 +31,39 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
s32 done;
s32 iter;
s32 i;
s32 b1, b2, b3, b4, b5, b6, b7;
s32 v, e, a, d, n, o, p, q, t, u, w, x, y;
s32 x_factor, z_factor, m_part, p_part;
s32 r, z, m;
s32 e;
s32 b2;
s32 b3;
s32 b4;
s32 b5;
s32 b6;
s32 b7;
s32 v;
s32 m;
s32 a;
s32 d;
s32 z;
s32 o;
s32 p;
s32 p_part;
s32 t;
s32 u;
s32 r;
s32 n;
s32 y;
s32 x_factor;
s32 z_factor;
s32 m_part;
s32 q;
s32 w;
s32 x;
s32 b1;
r = (zigzag >> 4) * 8;
iter = (u32)(r + 7) >> 3;
dst = tmp;
done = 0;
if (r > 0) {
for (; iter > 0; iter--) {
{
for (; done < r; done += 8) {
u32 ac;
b4 = block[4];
b6 = block[6];
@@ -49,7 +73,13 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
b5 = block[5];
b3 = block[3];
ac = (u32)b4 | (u32)b6 | (u32)b2 | (u32)b1 | (u32)b7 | (u32)b5 | (u32)b3;
ac = (u32)b4;
ac |= (u32)b6;
ac |= (u32)b2;
ac |= (u32)b1;
ac |= (u32)b7;
ac |= (u32)b5;
ac |= (u32)b3;
if (ac == 0) {
s32 val = block[0];
dst[7] = val;
@@ -61,23 +91,39 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
dst[1] = val;
dst[0] = val;
} else {
t = (b2 - b6) * 0xB5 >> 8;
a = block[0] - b4;
d = block[0] + b4;
u = t + b6 + b2;
v = a + t;
e = a - t;
w = d + u;
x_factor = (b1 + b7) - (b5 + b3);
y = d - u;
z_factor = (b5 - b3) + (b1 - b7);
m_part = (b1 - b7) * 0x14E >> 8;
p_part = (b5 - b3) * 0x8B >> 8;
s32 oddLowSum;
s32 oddHighSum;
s32 dcValue;
t = b2 - b6;
oddLowSum = b5 + b3;
b5 = b5 - b3;
oddHighSum = b1 + b7;
b1 = b1 - b7;
u = b6 + b2;
t = t * 0xB5 >> 8;
x_factor = oddHighSum - oddLowSum;
z_factor = b5 + b1;
dcValue = block[0];
a = dcValue - b4;
x = x_factor * 0xB5 >> 8;
d = dcValue + b4;
u = t + u;
v = a + t;
z = z_factor * 0x62 >> 8;
w = d + u;
y = d - u;
m_part = b1 * 0x14E >> 8;
e = a - t;
m = m_part - z;
n = b1 + b7 + b5 + b3 + m;
oddLowSum += m;
n = oddHighSum + oddLowSum;
o = x + m;
dst[0] = w + n;
p_part = b5 * 0x8B;
dst[7] = w - n;
p_part >>= 8;
dst[1] = v + o;
p = z + p_part;
q = p + x;
dst[6] = v - o;
@@ -88,12 +134,11 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
}
block += 8;
dst += 8;
done += 8;
}
}
dst = tmp + done;
for (; done < 0x38; done += 8) {
for (; done <= 0x38; done += 8) {
memset(dst, 0, 0x20);
dst += 8;
}
@@ -114,7 +159,13 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
b5 = dst[0x28];
b3 = dst[0x18];
ac = (u32)b4 | (u32)b6 | (u32)b2 | (u32)b1 | (u32)b7 | (u32)b5 | (u32)b3;
ac = (u32)b4;
ac |= (u32)b6;
ac |= (u32)b2;
ac |= (u32)b1;
ac |= (u32)b7;
ac |= (u32)b5;
ac |= (u32)b3;
out = conv_row_ptr + i;
if (ac == 0) {
u8 val = clampU8((*dst >> 11) + 0x80);
@@ -127,24 +178,37 @@ void TMCJPEGDEC_IdctBlock_Lumi(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigz
out[pitch] = val;
out[0] = val;
} else {
t = (b2 - b6) * 0xB5 >> 8;
a = *dst - b4;
d = *dst + b4;
u = t + b6 + b2;
v = a + t;
e = a - t;
s32 oddLowSum;
s32 oddHighSum;
s32 dcValue;
t = b2 - b6;
oddLowSum = b5 + b3;
b5 = b5 - b3;
oddHighSum = b1 + b7;
b1 = b1 - b7;
u = b6 + b2;
b2 = t * 0xB5 >> 8;
x_factor = oddHighSum - oddLowSum;
z_factor = b5 + b1;
dcValue = *dst + 0x40000;
a = dcValue - b4;
x = x_factor * 0xB5 >> 8;
d = dcValue + b4;
u = b2 + u;
v = a + b2;
z_factor = z_factor * 0x62 >> 8;
w = d + u;
x = ((b1 + b7) - (b5 + b3)) * 0xB5 >> 8;
y = d - u;
z_factor = ((b5 - b3) + (b1 - b7)) * 0x62 >> 8;
m_part = ((b1 - b7) * 0x14E >> 8) - z_factor;
n = b1 + b7 + b5 + b3 + m_part;
m_part = b1 * 0x14E >> 8;
e = a - b2;
m_part = m_part - z_factor;
oddLowSum += m_part;
n = oddHighSum + oddLowSum;
o = x + m_part;
p = z_factor + ((b5 - b3) * 0x8B >> 8);
p_part = b5 * 0x8B >> 8;
p = z_factor + p_part;
q = p + x;
out[0] = scalingClampU8(w + n);
out[r] = scalingClampU8(w - n);
out[pitch] = scalingClampU8(v + o);
@@ -163,11 +227,34 @@ void TMCJPEGDEC_IdctBlock_Col(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigza
s32* dst;
s32 done;
s32 iter;
s32 i;
s32 b1, b2, b3, b4, b5, b6, b7;
s32 v, e, a, d, m, n, o, p, q, t, u, w, x, y, z;
s32 x_factor, z_factor, m_part, p_part;
s32 d;
s32 b1;
s32 b2;
s32 b3;
s32 b4;
s32 b5;
s32 b6;
s32 b7;
s32 v;
s32 r;
s32 a;
s32 i;
s32 m;
s32 n;
s32 o;
s32 x;
s32 q;
s32 y;
s32 u;
s32 w;
s32 p;
s32 t;
s32 z;
s32 x_factor;
s32 z_factor;
s32 m_part;
s32 p_part;
s32 e;
if (zigzag == 0x11) {
s32 val;
@@ -181,90 +268,42 @@ void TMCJPEGDEC_IdctBlock_Col(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigza
goto mode_gt_2;
}
{
s32 inner;
dst = tmp;
done = 0;
for (; done < r; done += 8) {
s32 dcValue;
s32 oddCoefficient;
dst = tmp;
done = 0;
iter = (r + 7) >> 3;
if (r > 0) {
inner = (r + 7) >> 4;
done = iter << 3;
if (inner != 0) {
for (; inner > 0; inner--) {
t = block[1] * 0xB5 >> 8;
v = block[1] * 0x62 >> 8;
u = v + t;
z = (block[1] * 0x14E >> 8) - v;
m = block[1] + z;
n = t + z;
b1 = block[0] + m;
dst[0] = b1;
dst[7] = block[0] - m;
dst[1] = block[0] + n;
dst[6] = block[0] - n;
dst[2] = block[0] + u;
dst[5] = block[0] - u;
dst[3] = block[0] + v;
dst[4] = block[0] - v;
t = block[9] * 0xB5 >> 8;
v = block[9] * 0x62 >> 8;
u = v + t;
z = (block[9] * 0x14E >> 8) - v;
m = block[9] + z;
n = t + z;
b2 = block[8] + m;
dst[8] = b2;
dst[15] = block[8] - m;
dst[9] = block[8] + n;
dst[14] = block[8] - n;
dst[10] = block[8] + u;
dst[13] = block[8] - u;
dst[11] = block[8] + v;
dst[12] = block[8] - v;
dst += 0x10;
block += 0x10;
}
iter = iter & 1;
if (iter == 0) {
goto zero_fill;
}
}
for (; iter > 0; iter--) {
t = block[1] * 0xB5 >> 8;
v = block[1] * 0x62 >> 8;
u = v + t;
z = (block[1] * 0x14E >> 8) - v;
m = block[1] + z;
n = t + z;
b1 = block[0] + m;
dst[0] = b1;
dst[7] = block[0] - m;
dst[1] = block[0] + n;
dst[6] = block[0] - n;
dst[2] = block[0] + u;
dst[5] = block[0] - u;
dst[3] = block[0] + v;
dst[4] = block[0] - v;
dst += 8;
block += 8;
}
}
zero_fill:
dst = tmp + done;
for (; done < 0x39; done += 8) {
memset(dst, 0, 0x20);
dst += 8;
}
oddCoefficient = block[1];
dcValue = block[0];
t = oddCoefficient * 0xB5 >> 8;
v = oddCoefficient * 0x62 >> 8;
u = v + t;
z = (oddCoefficient * 0x14E >> 8) - v;
m = oddCoefficient + z;
n = t + z;
dst[0] = dcValue + m;
dst[7] = dcValue - m;
dst[1] = dcValue + n;
dst[6] = dcValue - n;
dst[2] = dcValue + u;
dst[5] = dcValue - u;
dst[3] = dcValue + v;
dst[4] = dcValue - v;
dst += 8;
block += 8;
}
dst = tmp + done;
for (; done <= 0x38; done += 8) {
memset(dst, 0, 0x20);
dst += 8;
}
goto epilogue;
mode_gt_2:
dst = tmp;
done = 0;
if (r > 0) {
for (iter = (r + 7) >> 3; iter > 0; iter--) {
for (; done < r; done += 8) {
u32 ac;
b4 = block[4];
b6 = block[6];
@@ -293,23 +332,41 @@ mode_gt_2:
dst[1] = val;
dst[0] = val;
} else {
t = (b2 - b6) * 0xB5 >> 8;
a = block[0] - b4;
d = block[0] + b4;
u = t + b6 + b2;
v = a + t;
e = a - t;
w = d + u;
x_factor = (b1 + b7) - (b5 + b3);
y = d - u;
z_factor = (b5 - b3) + (b1 - b7);
m_part = (b1 - b7) * 0x14E >> 8;
p_part = (b5 - b3) * 0x8B >> 8;
s32 oddLowSum;
s32 oddLowDifference;
s32 oddHighSum;
s32 oddHighDifference;
s32 dcValue;
t = b2 - b6;
oddLowSum = b5 + b3;
oddLowDifference = b5 - b3;
oddHighSum = b1 + b7;
oddHighDifference = b1 - b7;
u = b6 + b2;
t = t * 0xB5 >> 8;
x_factor = oddHighSum - oddLowSum;
z_factor = oddLowDifference + oddHighDifference;
dcValue = block[0];
a = dcValue - b4;
x = x_factor * 0xB5 >> 8;
d = dcValue + b4;
u = t + u;
v = a + t;
z = z_factor * 0x62 >> 8;
w = d + u;
y = d - u;
m_part = oddHighDifference * 0x14E >> 8;
e = a - t;
m = m_part - z;
n = b1 + b7 + b5 + b3 + m;
oddLowSum += m;
n = oddHighSum + oddLowSum;
o = x + m;
dst[0] = w + n;
p_part = oddLowDifference * 0x8B;
dst[7] = w - n;
p_part >>= 8;
dst[1] = v + o;
p = z + p_part;
q = p + x;
dst[6] = v - o;
@@ -320,12 +377,10 @@ mode_gt_2:
}
block += 8;
dst += 8;
done += 8;
}
}
dst = tmp + done;
for (; done < 0x39; done += 8) {
for (; done <= 0x38; done += 8) {
memset(dst, 0, 0x20);
dst += 8;
}
@@ -335,7 +390,9 @@ epilogue:
dst = tmp + 7;
for (iter = 8, i = 7; iter > 0; iter--, i--) {
u32 ac;
u8* output;
b4 = dst[0x20];
output = conv_row_ptr + i;
b6 = dst[0x30];
b2 = dst[0x10];
b1 = dst[8];
@@ -353,40 +410,56 @@ epilogue:
if (ac == 0) {
s32 val;
val = clampS8(*dst >> 11);
conv_row_ptr[i + 56] = (u8)val;
conv_row_ptr[i + 48] = (u8)val;
conv_row_ptr[i + 40] = (u8)val;
conv_row_ptr[i + 32] = (u8)val;
conv_row_ptr[i + 24] = (u8)val;
conv_row_ptr[i + 16] = (u8)val;
conv_row_ptr[i + 8] = (u8)val;
conv_row_ptr[i] = (u8)val;
output[56] = (u8)val;
output[48] = (u8)val;
output[40] = (u8)val;
output[32] = (u8)val;
output[24] = (u8)val;
output[16] = (u8)val;
output[8] = (u8)val;
output[0] = (u8)val;
} else {
t = (b2 - b6) * 0xB5 >> 8;
a = *dst - b4;
d = *dst + b4;
u = t + b6 + b2;
s32 oddLowSum;
s32 oddLowDifference;
s32 oddHighSum;
s32 oddHighDifference;
s32 dcValue;
t = b2 - b6;
oddLowSum = b5 + b3;
oddLowDifference = b5 - b3;
oddHighSum = b1 + b7;
oddHighDifference = b1 - b7;
u = b6 + b2;
t = t * 0xB5 >> 8;
x_factor = oddHighSum - oddLowSum;
z_factor = oddLowDifference + oddHighDifference;
dcValue = *dst;
a = dcValue - b4;
x = x_factor * 0xB5 >> 8;
d = dcValue + b4;
u = t + u;
v = a + t;
e = a - t;
z = z_factor * 0x62 >> 8;
w = d + u;
x = ((b1 + b7) - (b5 + b3)) * 0xB5 >> 8;
y = d - u;
z = ((b5 - b3) + (b1 - b7)) * 0x62 >> 8;
m = ((b1 - b7) * 0x14E >> 8) - z;
n = b1 + b7 + b5 + b3 + m;
m_part = oddHighDifference * 0x14E >> 8;
e = a - t;
m = m_part - z;
oddLowSum += m;
n = oddHighSum + oddLowSum;
o = x + m;
p = z + ((b5 - b3) * 0x8B >> 8);
p_part = oddLowDifference * 0x8B >> 8;
p = z + p_part;
q = p + x;
conv_row_ptr[i] = (u8)clampS8((w + n) >> 11);
conv_row_ptr[i + 56] = (u8)clampS8((w - n) >> 11);
conv_row_ptr[i + 8] = (u8)clampS8((v + o) >> 11);
conv_row_ptr[i + 48] = (u8)clampS8((v - o) >> 11);
conv_row_ptr[i + 16] = (u8)clampS8((e + q) >> 11);
conv_row_ptr[i + 40] = (u8)clampS8((e - q) >> 11);
conv_row_ptr[i + 24] = (u8)clampS8((y + p) >> 11);
conv_row_ptr[i + 32] = (u8)clampS8((y - p) >> 11);
output[0] = (u8)clampS8((w + n) >> 11);
output[56] = (u8)clampS8((w - n) >> 11);
output[8] = (u8)clampS8((v + o) >> 11);
output[48] = (u8)clampS8((v - o) >> 11);
output[16] = (u8)clampS8((e + q) >> 11);
output[40] = (u8)clampS8((e - q) >> 11);
output[24] = (u8)clampS8((y + p) >> 11);
output[32] = (u8)clampS8((y - p) >> 11);
}
dst--;
}

View File

@@ -15,9 +15,16 @@ static u16 readU16(const u8* p, u16 byteOrder) {
return (u16)(raw >> 8 & 0xFF | (raw & 0xFF) << 8);
}
static u16 readExifU16(const u8* data, u16 byteOrder) {
u32 value = data[0] | data[1] << 8;
if (byteOrder == 0x4949) {
return (u16)value;
}
return (u16)(value >> 8 & 255 | (value & 255) << 8);
}
static u32 readU32(const u8* p, u16 byteOrder) {
u32 raw = p[0] | p[1] << 8;
raw = raw | p[3] << 24 | p[2] << 16;
u32 raw = p[1] << 8 | p[0] | p[2] << 16 | p[3] << 24;
if (byteOrder == 0x4949) {
return raw;
}
@@ -26,9 +33,9 @@ static u32 readU32(const u8* p, u16 byteOrder) {
s32 TMCCJPEGDecGetOffsetEXIF(u32* pOffset, u32* pSize, TMCCJPEGDecInitParam* pParam) {
TMCCJPEGDecWork* work;
u16 marker;
u32 dataSize;
u16 segSize;
u32 dataSize;
u16 marker;
s32 result;
u8 sig[4];
@@ -108,62 +115,26 @@ s32 TMCCJPEGDecGetOffsetEXIF(u32* pOffset, u32* pSize, TMCCJPEGDecInitParam* pPa
continue;
}
if (marker >= 0xFFD9) {
if (marker == 0xFFD9) {
switch (marker) {
case 0xFFC0:
case 0xFFC2:
case 0xFFC4:
case 0xFFDB:
case 0xFFDC:
case 0xFFDD:
case 0xFFFE:
result = TMCJPEGDEC_move_ptr(segSize, work);
if (result < 0) {
return result;
}
break;
case 0xFFDA:
return -2;
}
if (marker == 0xFFFE) {
result = TMCJPEGDEC_move_ptr(segSize, work);
if (result < 0) {
return result;
}
continue;
}
if (marker >= 0xFFDE)
case 0xFFD9:
return -2;
default:
return -0x2F;
if (marker >= 0xFFDB) {
result = TMCJPEGDEC_move_ptr(segSize, work);
if (result < 0) {
return result;
}
continue;
}
return -2;
}
if (marker >= 0xFFC2) {
if (marker == 0xFFC2) {
result = TMCJPEGDEC_move_ptr(segSize, work);
if (result < 0) {
return result;
}
continue;
}
if (marker == 0xFFC4) {
result = TMCJPEGDEC_move_ptr(segSize, work);
if (result < 0) {
return result;
}
continue;
}
return -0x2F;
}
if (marker == 0xFFC0) {
result = TMCJPEGDEC_move_ptr(segSize, work);
if (result < 0) {
return result;
}
continue;
}
return -0x2F;
}
}
@@ -271,114 +242,99 @@ _error:
}
static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData* pInfo) {
u32 ifd0Offset;
u32 ifd1Offset;
u32 exifIfdOffset;
u16 count;
u32 entriesSize;
u32 i;
const u8* p;
s32 sval;
u16 byteOrder;
u32 raw;
u32 ifdOffset;
const u8* entries;
u16 remaining;
u16 count;
s32 entriesSize;
u16 index;
pInfo->thumbnailData = (u8*)data;
pInfo->dataEnd = (u8*)data + size;
pInfo->nextIfdOffset = 0;
if (size < 8) {
return -161;
}
raw = data[0] | data[1] << 8;
byteOrder = raw;
byteOrder = data[0] | data[1] << 8;
if (byteOrder != 0x4D4D && byteOrder != 0x4949) {
return -161;
}
if (readU16(data + 2, byteOrder) != 0x002A) {
if (readExifU16(data + 2, byteOrder) != 42) {
return -161;
}
ifd0Offset = readU32(data + 4, byteOrder);
if (ifd0Offset > size) {
ifdOffset = readU32(data + 4, byteOrder);
if (size < ifdOffset) {
return -161;
}
sval = size - (u16)ifd0Offset;
if (sval < 2) {
return -161;
}
p = data + (u16)ifd0Offset;
count = readU16(p, byteOrder);
entriesSize = count * 12;
sval = (u32)(sval - 2);
if (sval < entriesSize) {
return -161;
}
p += 2;
for (i = 0; i < count; i++) {
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, p);
p += 12;
}
sval -= entriesSize;
if (sval < 4) {
return -161;
}
ifd1Offset = readU32(p, byteOrder);
if (ifd1Offset != 0) {
if (ifd1Offset > size) {
{
entries = data + ifdOffset;
remaining = size - (u16)ifdOffset;
if (remaining < 2) {
return -161;
}
sval = size - (u16)ifd1Offset;
if (sval < 2) {
return -161;
}
p = data + (u16)ifd1Offset;
count = readU16(p, byteOrder);
count = readExifU16(entries, byteOrder);
entriesSize = count * 12;
sval = (u32)(sval - 2);
if (sval < entriesSize) {
entries += 2;
remaining -= 2;
if (remaining < entriesSize) {
return -161;
}
p += 2;
for (i = 0; i < count; i++) {
TMCJPEGDEC_IFD1_tag_parse(pInfo, byteOrder, p);
p += 12;
for (index = 0; index < count; index++) {
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, entries);
entries += 12;
}
remaining -= entriesSize;
if (remaining < 4) {
return -161;
}
ifdOffset = readU32(entries, byteOrder);
}
if (ifdOffset == 0) {
return 0;
}
if (size < ifdOffset) {
return -161;
}
{
entries = data + ifdOffset;
remaining = size - (u16)ifdOffset;
if (remaining < 2) {
return -161;
}
count = readExifU16(entries, byteOrder);
entriesSize = count * 12;
entries += 2;
remaining -= 2;
if (remaining < entriesSize) {
return -161;
}
for (index = 0; index < count; index++) {
TMCJPEGDEC_IFD1_tag_parse(pInfo, byteOrder, entries);
entries += 12;
}
}
exifIfdOffset = pInfo->nextIfdOffset;
if (exifIfdOffset == 0 || exifIfdOffset > size) {
ifdOffset = pInfo->nextIfdOffset;
if (size < ifdOffset) {
return -161;
}
sval = size - (u16)exifIfdOffset;
if (sval < 2) {
return -161;
{
entries = data + ifdOffset;
remaining = size - (u16)ifdOffset;
if (remaining < 2) {
return -161;
}
count = readExifU16(entries, byteOrder);
entriesSize = count * 12;
entries += 2;
remaining -= 2;
if (remaining < entriesSize) {
return -161;
}
for (index = 0; index < count; index++) {
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, entries);
entries += 12;
}
}
p = data + (u16)exifIfdOffset;
count = readU16(p, byteOrder);
entriesSize = count * 12;
sval = (u32)(sval - 2);
if (sval < entriesSize) {
return -161;
}
p += 2;
for (i = 0; i < count; i++) {
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, p);
p += 12;
}
return 0;
}
@@ -391,8 +347,10 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
switch (tag) {
case 0x0103:
case 0x0111: {
return;
case 0x0111:
case 0x0201:
case 0x0202: {
break;
}
case 0x0112: {
pInfo->orientation = readU16(entry + 8, byteOrder);
@@ -401,18 +359,18 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
case 0x011A: {
u32 offset = readU32(entry + 8, byteOrder);
const u8* p = pInfo->thumbnailData + offset;
if (p < pInfo->thumbnailData) {
if (pInfo->thumbnailData > p) {
return;
}
if (p + 4 > pInfo->dataEnd) {
if (p > pInfo->dataEnd - 4) {
return;
}
pInfo->xResNum = readU32(p, byteOrder);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
if (p < pInfo->thumbnailData) {
if (pInfo->thumbnailData > p) {
return;
}
if (p + 4 > pInfo->dataEnd) {
if (p > pInfo->dataEnd - 4) {
return;
}
pInfo->xResDen = readU32(p, byteOrder);
@@ -421,18 +379,18 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
case 0x011B: {
u32 offset = readU32(entry + 8, byteOrder);
const u8* p = pInfo->thumbnailData + offset;
if (p < pInfo->thumbnailData) {
if (pInfo->thumbnailData > p) {
return;
}
if (p + 4 > pInfo->dataEnd) {
if (p > pInfo->dataEnd - 4) {
return;
}
pInfo->yResNum = readU32(p, byteOrder);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
if (p < pInfo->thumbnailData) {
if (pInfo->thumbnailData > p) {
return;
}
if (p + 4 > pInfo->dataEnd) {
if (p > pInfo->dataEnd - 4) {
return;
}
pInfo->yResDen = readU32(p, byteOrder);
@@ -444,19 +402,19 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
}
case 0x012D: {
u32 offset = readU32(entry + 8, byteOrder);
const u8* p = pInfo->thumbnailData + offset;
u32 j;
u32 i;
for (j = 0; j < 3; j++) {
for (i = 0; i < 256; i++) {
if (p < pInfo->thumbnailData) {
return;
u32 channel;
u32 index;
for (channel = 0; channel < 3; channel++) {
for (index = 0; index < 256; index++) {
const u8* p = pInfo->thumbnailData + offset;
if (pInfo->thumbnailData > p) {
break;
}
if (p + 2 > pInfo->dataEnd) {
return;
if (p > pInfo->dataEnd - 2) {
break;
}
pInfo->transferFunc[j][i] = readU16(p, byteOrder);
p += 2;
pInfo->transferFunc[channel][index] = readU16(p, byteOrder);
offset += 2;
}
}
return;
@@ -464,17 +422,18 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
case 0x0132: {
u32 offset = readU32(entry + 8, byteOrder);
const u8* p = pInfo->thumbnailData + offset;
if (p < pInfo->thumbnailData) {
if (pInfo->thumbnailData > p) {
return;
}
if (p + 20 > pInfo->dataEnd) {
if (p > pInfo->dataEnd - 20) {
return;
}
*(u32*)(pInfo->dateTime + 0) = *(u32*)(p + 0);
*(u32*)(pInfo->dateTime + 4) = *(u32*)(p + 4);
*(u32*)(pInfo->dateTime + 8) = *(u32*)(p + 8);
*(u32*)(pInfo->dateTime + 12) = *(u32*)(p + 12);
*(u32*)(pInfo->dateTime + 16) = *(u32*)(p + 16);
{
u32 index;
for (index = 0; index < 20; index++) {
pInfo->dateTime[index] = p[index];
}
}
return;
}
case 0x0213: {
@@ -511,21 +470,19 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
return;
}
case 0xA002: {
u32 offset = readU32(entry + 8, byteOrder);
if (type == 4) {
pInfo->pixelXDim = offset;
} else if (type == 3) {
if (type == 3) {
pInfo->pixelXDim = readU16(entry + 8, byteOrder);
} else if (type == 4) {
pInfo->pixelXDim = readU32(entry + 8, byteOrder);
}
return;
}
case 0xA003: {
u32 offset = readU32(entry + 8, byteOrder);
if (type == 4) {
pInfo->pixelYDim = offset;
} else if (type == 3) {
if (type == 3) {
pInfo->pixelYDim = readU16(entry + 8, byteOrder);
} else if (type == 4) {
pInfo->pixelYDim = readU32(entry + 8, byteOrder);
}
return;
}
@@ -538,52 +495,54 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
switch (tag) {
case 0x0132:
case 0x0111:
case 0x0112:
case 0x012D:
case 0x0213:
case 0x8769:
case 0x9000:
case 0x9101: {
return;
}
case 0x0103: {
pInfo->compressionIfd1 = readU16(entry + 8, byteOrder);
return;
case 0x9101:
case 0xA003: {
break;
}
case 0x011A: {
u32 offset = readU32(entry + 8, byteOrder);
const u8* p = pInfo->thumbnailData + offset;
if (p < pInfo->thumbnailData) {
u32 offset;
const u8* p;
offset = readU32(entry + 8, byteOrder);
p = pInfo->thumbnailData + offset;
if (pInfo->thumbnailData > p) {
return;
}
if (p + 4 > pInfo->dataEnd) {
if (p > pInfo->dataEnd - 4) {
return;
}
pInfo->xResNumIfd1 = readU32(p, byteOrder);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
if (p < pInfo->thumbnailData) {
if (pInfo->thumbnailData > p) {
return;
}
if (p + 4 > pInfo->dataEnd) {
if (p > pInfo->dataEnd - 4) {
return;
}
pInfo->xResDenIfd1 = readU32(p, byteOrder);
return;
}
case 0x011B: {
u32 offset = readU32(entry + 8, byteOrder);
const u8* p = pInfo->thumbnailData + offset;
if (p < pInfo->thumbnailData) {
u32 offset;
const u8* p;
offset = readU32(entry + 8, byteOrder);
p = pInfo->thumbnailData + offset;
if (pInfo->thumbnailData > p) {
return;
}
if (p + 4 > pInfo->dataEnd) {
if (p > pInfo->dataEnd - 4) {
return;
}
pInfo->planarConfigIfd1 = readU32(p, byteOrder);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
if (p < pInfo->thumbnailData) {
if (pInfo->thumbnailData > p) {
return;
}
if (p + 4 > pInfo->dataEnd) {
if (p > pInfo->dataEnd - 4) {
return;
}
pInfo->yResDenIfd1 = readU32(p, byteOrder);
@@ -593,6 +552,10 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
pInfo->resUnitIfd1 = readU16(entry + 8, byteOrder);
return;
}
case 0x0103: {
pInfo->compressionIfd1 = readU16(entry + 8, byteOrder);
return;
}
case 0x0201: {
pInfo->thumbnailOffset = readU32(entry + 8, byteOrder);
return;

View File

@@ -1411,131 +1411,22 @@ static s32 TMCJPEGDEC_parse_dht(s32 first, TMCCJPEGDecWork* work) {
}
#endif
#ifdef __MWERKS__
static asm s32 TMCJPEGDEC_parse_dqt(register TMCCJPEGDecWork* work) {
nofralloc
stwu r1, -0x130(r1)
mflr r0
lis r4, lbl_8161E080@ha
stw r0, 0x134(r1)
addi r4, r4, lbl_8161E080@l
li r0, 0x20
addi r6, r1, 0xc
stmw r24, 0x110(r1)
mr r30, r3
addi r5, r4, -4
mtctr r0
_parse_dqt_copy:
lwz r4, 4(r5)
lwzu r0, 8(r5)
stw r4, 4(r6)
stwu r0, 8(r6)
bdnz _parse_dqt_copy
addi r31, r3, 0x58
mr r4, r30
addi r3, r1, 0xa
bl TMCJPEGDEC_get_wbyte
cmpwi r3, 0
bge _parse_dqt_have_length
b _parse_dqt_return
_parse_dqt_have_length:
lhz r3, 0xa(r1)
addi r29, r1, 0x10
li r27, 1
lis r28, TMCJPEGDEC_Zigzag_data@ha
addi r0, r3, -2
sth r0, 0xa(r1)
_parse_dqt_table:
lhz r5, 0xa(r1)
mr r4, r30
addi r3, r1, 9
addi r0, r5, -0x41
sth r0, 0xa(r1)
bl TMCJPEGDEC_get_byte
cmpwi r3, 0
bge _parse_dqt_have_qt_info
b _parse_dqt_return
_parse_dqt_have_qt_info:
lbz r0, 9(r1)
cmplwi r0, 4
ble _parse_dqt_valid_qt_info
li r3, -0x41
b _parse_dqt_return
_parse_dqt_valid_qt_info:
add r3, r31, r0
addi r26, r28, TMCJPEGDEC_Zigzag_data@l
stb r27, 0x1790(r3)
li r25, 0
_parse_dqt_coeff:
lbz r24, 0(r26)
cmpwi r24, 0x3f
ble _parse_dqt_valid_coeff
li r3, -0x41
b _parse_dqt_return
_parse_dqt_valid_coeff:
mr r4, r30
addi r3, r1, 8
bl TMCJPEGDEC_get_byte
cmpwi r3, 0
bge _parse_dqt_have_coeff
b _parse_dqt_return
_parse_dqt_have_coeff:
slwi r4, r24, 2
lbz r3, 9(r1)
add r0, r4, r31
lbz r5, 8(r1)
lwzx r4, r29, r4
slwi r3, r3, 8
mullw. r4, r5, r4
stwx r4, r3, r0
bne _parse_dqt_nonzero
li r3, -0x41
b _parse_dqt_return
_parse_dqt_nonzero:
addi r25, r25, 1
addi r26, r26, 1
cmpwi r25, 0x40
blt _parse_dqt_coeff
lhz r0, 0xa(r1)
cmpwi r0, 0
bne _parse_dqt_table
li r3, 0
_parse_dqt_return:
lmw r24, 0x110(r1)
lwz r0, 0x134(r1)
mtlr r0
addi r1, r1, 0x130
blr
}
#else
static s32 TMCJPEGDEC_parse_dqt(TMCCJPEGDecWork* work) {
typedef struct {
u32 data[64];
} CopyBlock64;
u8* scaleInfo;
u32 tblCopy[65];
u32* tblPtr;
typedef struct { u32 coefficients[4][64]; } QuantizationTables;
QuantizationTables* scaleInfo;
u32 tblCopy[64];
u32* d;
u16 len;
s32 r;
d = tblCopy;
*(CopyBlock64*)(d + 1) = *(CopyBlock64*)lbl_8161E080;
*(CopyBlock64*)d = *(CopyBlock64*)lbl_8161E080;
scaleInfo = (u8*)work + 0x58;
scaleInfo = (QuantizationTables*)&work->scaleFlag;
r = TMCJPEGDEC_get_wbyte(&len, work);
if (r < 0) {
@@ -1543,8 +1434,6 @@ static s32 TMCJPEGDEC_parse_dqt(TMCCJPEGDecWork* work) {
}
len -= 2;
tblPtr = &tblCopy[1];
do {
u8 qtInfo;
const u8* zigPtr;
@@ -1563,11 +1452,10 @@ static s32 TMCJPEGDEC_parse_dqt(TMCCJPEGDecWork* work) {
return -0x41;
}
scaleInfo[qtInfo + 0x1790] = 1; // quantTblFlag[0..3]
((TMCUnknownInfo*)scaleInfo)->quantTblFlag[qtInfo] = 1;
zigPtr = TMCJPEGDEC_Zigzag_data;
for (zzIdx = 0; zzIdx < 64; zzIdx++) {
u32 tmp;
zz = *zigPtr;
if (zz > 0x3F) {
@@ -1579,9 +1467,8 @@ static s32 TMCJPEGDEC_parse_dqt(TMCCJPEGDecWork* work) {
return r;
}
tmp = (zz << 2) + ((u32)qtInfo << 8);
val = (u32)byte * tblPtr[zz];
*(u32*)(tmp + scaleInfo) = val;
val = (u32)byte * tblCopy[zz];
scaleInfo->coefficients[qtInfo][zz] = val;
if (val == 0) {
return -0x41;
}
@@ -1592,7 +1479,6 @@ static s32 TMCJPEGDEC_parse_dqt(TMCCJPEGDecWork* work) {
return 0;
}
#endif
#ifdef __MWERKS__
static asm s32 TMCJPEGDEC_parse_sof(register TMCCJPEGDecWork* work) {

View File

@@ -1,5 +1,874 @@
#define TMC_JPEG_PLANAR_OUTPUT
#include <tmc_jpeg_internal.h>
static void TMCJPEG_814EFEAC(TMCCJPEGDecWork*, s32, s32);
static void TMCJPEG_814F043C(TMCCJPEGDecWork*, s32, s32);
static void TMCJPEG_814F0A58(TMCCJPEGDecWork*, s32, s32);
static void TMCJPEG_814F11C4(TMCCJPEGDecWork*, s32, s32);
static void TMCJPEG_814F17E0(TMCCJPEGDecWork*, s32, s32);
static void TMCJPEG_814F1F48(TMCCJPEGDecWork*, s32, s32);
static void TMCJPEG_814F2570(TMCCJPEGDecWork*, s32, s32);
static void TMCJPEG_814F2B50(TMCCJPEGDecWork*, s32, s32);
static void TMCJPEG_814F3158(TMCCJPEGDecWork*, s32, s32);
static void TMCJPEG_814F32E4(TMCCJPEGDecWork*, s32, s32);
static void TMCJPEG_814F34A4(TMCCJPEGDecWork*, s32, s32);
static void TMCJPEG_814F372C(TMCCJPEGDecWork*, s32, s32);
s32 TMCJPEGDEC_set_converterY8U8V8(TMCCJPEGDecWork* work) {
u8* buffer;
s32 componentCount;
TMCCJPEGDecState* state;
buffer = work->convBuf;
componentCount = work->componentCount;
state = work->pState;
switch (componentCount) {
case 0: {
u8 mode;
u8* firstRow;
u8* secondRow;
u8* thirdRow;
u8* fourthRow;
u8* cbBlock;
u8* crBlock;
mode = work->idctMode;
firstRow = buffer + 4;
work->pConverterFunc = TMCJPEG_814EFEAC;
work->pConverterFuncEdge = TMCJPEG_814F043C;
secondRow = firstRow + mode;
thirdRow = secondRow + mode;
fourthRow = thirdRow + mode;
cbBlock = buffer + 260;
crBlock = buffer + 324;
work->pConvRowPtrs[0] = firstRow;
work->pConvRowPtrs[1] = secondRow;
work->pConvRowPtrs[2] = thirdRow;
work->pConvRowPtrs[3] = fourthRow;
work->pConvRowPtrs[5] = cbBlock;
work->pConvRowPtrs[6] = crBlock;
work->pitch = 32;
work->converterFlags = 0;
break;
}
case 1: {
u8 mode;
u8* firstRow;
u8* secondRow;
u8* cbBlock;
u8* crBlock;
mode = work->idctMode;
firstRow = buffer + 4;
work->pConverterFunc = TMCJPEG_814F0A58;
work->pConverterFuncEdge = TMCJPEG_814F11C4;
secondRow = firstRow + mode;
cbBlock = buffer + 132;
crBlock = buffer + 196;
work->pConvRowPtrs[0] = firstRow;
work->pConvRowPtrs[1] = secondRow;
work->pConvRowPtrs[5] = cbBlock;
work->pConvRowPtrs[6] = crBlock;
work->pitch = 16;
work->converterFlags = 0;
break;
}
case 2: {
u8 mode;
u8* firstRow;
u8* secondRow;
u8* thirdRow;
u8* fourthRow;
u8* cbBlock;
u8* crBlock;
mode = work->idctMode;
firstRow = buffer + 4;
work->pConverterFunc = TMCJPEG_814F17E0;
work->pConverterFuncEdge = TMCJPEG_814F1F48;
secondRow = firstRow + mode;
thirdRow = firstRow + mode * 16;
fourthRow = thirdRow + mode;
cbBlock = buffer + 260;
crBlock = buffer + 324;
work->pConvRowPtrs[0] = firstRow;
work->pConvRowPtrs[1] = secondRow;
work->pConvRowPtrs[2] = thirdRow;
work->pConvRowPtrs[3] = fourthRow;
work->pConvRowPtrs[5] = cbBlock;
work->pConvRowPtrs[6] = crBlock;
work->pitch = 16;
work->converterFlags = 0;
break;
}
case 3: {
u8 mode;
u8* firstRow;
u8* secondRow;
u8* cbBlock;
u8* crBlock;
mode = work->idctMode;
firstRow = buffer + 4;
work->pConverterFunc = TMCJPEG_814F2570;
work->pConverterFuncEdge = TMCJPEG_814F2B50;
secondRow = firstRow + mode * 8;
cbBlock = buffer + 132;
crBlock = buffer + 196;
work->pConvRowPtrs[0] = firstRow;
work->pConvRowPtrs[1] = secondRow;
work->pConvRowPtrs[5] = cbBlock;
work->pConvRowPtrs[6] = crBlock;
work->pitch = 8;
work->converterFlags = 0;
break;
}
case 4: {
TMCConverterFunc* converter;
TMCConverterFunc* edgeConverter;
converter = TMCJPEG_814F3158;
edgeConverter = TMCJPEG_814F32E4;
work->pConvRowPtrs[0] = buffer + 4;
work->pConvRowPtrs[5] = buffer + 0x44;
work->pConvRowPtrs[6] = buffer + 0x84;
work->pConverterFunc = converter;
work->pConverterFuncEdge = edgeConverter;
work->pitch = 0x08;
work->converterFlags = 0;
break;
}
case 5: {
TMCConverterFunc* converter;
TMCConverterFunc* edgeConverter;
converter = TMCJPEG_814F34A4;
edgeConverter = TMCJPEG_814F372C;
work->pConvRowPtrs[0] = buffer + 4;
work->pConverterFunc = converter;
work->pConverterFuncEdge = edgeConverter;
work->pitch = 0x08;
work->converterFlags = 0;
break;
}
default: {
return TMCC_ERROR_FORMAT;
}
}
{
s32 width = state->jpegWidth;
s32 height = state->jpegHeight;
state->convWidth = ((u32)width / 8 + (width % 8 != 0)) * 8;
state->convHeight = ((u32)height / 4 + (height % 4 != 0)) * 4;
width = state->outputWidth;
height = state->outputHeight;
state->chromaWidth = ((u32)width / 8 + (width % 8 != 0)) * 8;
state->chromaHeight = ((u32)height / 4 + (height % 4 != 0)) * 4;
}
return 0;
}
static void TMCJPEG_814EFEAC(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 rowSkip;
u8* output;
s32 chromaXEnd;
u32 tileRow;
u32 chromaTileWidth;
s32 chromaYEnd;
u8* lumaTexture;
TMCCJPEGDecState* state;
u8* luminance;
s32 column;
s32 row;
u8* cbTexture;
s32 xEnd;
s32 height;
u8* crTexture;
s32 yEnd;
u8* cb;
u8* cr;
u32 tileWidth;
s32 width;
row = y;
luminance = work->convBuf + 4;
cb = &work->convBuf[260];
cr = &work->convBuf[324];
state = work->pState;
tileWidth = state->convWidth >> 3;
lumaTexture = state->pLumaBuffer;
cbTexture = state->pCbBuffer;
crTexture = state->pCrBuffer;
width = 32 / state->scaleFactor;
height = 8 / state->scaleFactor;
xEnd = x + width;
yEnd = y + height;
rowSkip = 32 - width;
for (; row < yEnd; row++) {
output = lumaTexture + ((row & 3) << 3);
tileRow = (row >> 2) * tileWidth;
for (column = x; column < xEnd; column += 4) {
(output + (column & 7))[(s32)(((column >> 3) + tileRow) << 5)] = luminance[0];
(output + ((column + 1) & 7))[(s32)((((column + 1) >> 3) + tileRow) << 5)] = luminance[1];
(output + ((column + 2) & 7))[(s32)((((column + 2) >> 3) + tileRow) << 5)] = luminance[2];
(output + ((column + 3) & 7))[(s32)((((column + 3) >> 3) + tileRow) << 5)] = luminance[3];
luminance += 4;
}
luminance += rowSkip;
}
chromaTileWidth = state->chromaWidth >> 3;
x = (u32)x >> 2;
width = 8 / state->scaleFactor;
height = 8 / state->scaleFactor;
chromaXEnd = x + width;
chromaYEnd = y + height;
for (; y < chromaYEnd; y++) {
for (column = x; column < chromaXEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
cb++;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
cr++;
}
cb += 8 - width;
cr += 8 - width;
}
}
static void TMCJPEG_814F043C(TMCCJPEGDecWork* work, s32 x, s32 y) {
u32 chromaTileWidth;
TMCCJPEGDecState* state;
u8* lumaTexture;
u8* luminance;
s32 column;
s32 row;
s32 chromaEnd;
u8* cbTexture;
u8* crTexture;
u32 tileRow;
s32 height;
s32 yEnd;
u8* output;
u8* cb;
u8* cr;
s32 xEnd;
s32 tileOffset;
s32 width;
u32 tileWidth;
luminance = work->convBuf + 4;
cb = &work->convBuf[260];
cr = &work->convBuf[324];
state = work->pState;
tileWidth = state->convWidth >> 3;
lumaTexture = state->pLumaBuffer;
cbTexture = state->pCbBuffer;
crTexture = state->pCrBuffer;
if (state->dataSizeX == (u32)x) {
width = state->stepXExt;
} else {
width = 32 / state->scaleFactor;
}
if (state->dataSizeY == (u32)y) {
height = state->stepYExt;
} else {
height = 8 / state->scaleFactor;
}
xEnd = x + width;
yEnd = y + height;
for (row = y; row < yEnd; row++) {
for (column = x; column < xEnd; column += 1) {
tileRow = (row >> 2) * tileWidth;
tileOffset = ((column >> 3) + tileRow) << 5;
output = lumaTexture + ((row & 3) << 3) + (column & 7);
output[tileOffset] = *luminance++;
}
luminance += 32 - width;
}
x = (u32)x >> 2;
width = (width + 3) >> 2;
xEnd = x + width;
chromaTileWidth = state->chromaWidth >> 3;
chromaEnd = y + height;
for (; y < chromaEnd; y++) {
for (column = x; column < xEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
cb++;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
cr++;
}
cb += 8 - width;
cr += 8 - width;
}
}
static void TMCJPEG_814F0A58(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 chromaYEnd;
u8* lumaTexture;
u8* luminance;
s32 column;
s32 chromaXEnd;
s32 row;
u32 chromaTileWidth;
TMCCJPEGDecState* state;
s32 width;
s32 height;
u8* cbTexture;
s32 xEnd;
u8* crTexture;
s32 yEnd;
u8* cb;
u32 tileWidth;
u8* cr;
s32 chromaRowSkip;
row = y;
luminance = work->convBuf + 4;
cb = &work->convBuf[132];
cr = &work->convBuf[196];
state = work->pState;
tileWidth = state->convWidth >> 3;
lumaTexture = state->pLumaBuffer;
cbTexture = state->pCbBuffer;
crTexture = state->pCrBuffer;
width = 16 / state->scaleFactor;
height = 8 / state->scaleFactor;
xEnd = x + width;
yEnd = y + height;
for (; row < yEnd; row++) {
for (column = x; column < xEnd; column += 2) {
(lumaTexture + ((row & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (row >> 2) * tileWidth) << 5)] = *luminance++;
(lumaTexture + ((row & 3) << 3) + ((column + 1) & 7))[(s32)((((column + 1) >> 3) + (row >> 2) * tileWidth) << 5)] = *luminance++;
}
luminance += 16 - width;
}
x = (u32)x >> 1;
width = 8 / state->scaleFactor;
height = 8 / state->scaleFactor;
chromaXEnd = x + width;
chromaYEnd = y + height;
chromaTileWidth = state->chromaWidth >> 3;
chromaRowSkip = 8 - width;
for (; y < chromaYEnd; y++) {
for (column = x; column < chromaXEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
cb++;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
cr++;
}
cb += chromaRowSkip;
cr += 8 - width;
}
}
static void TMCJPEG_814F11C4(TMCCJPEGDecWork* work, s32 x, s32 y) {
u32 chromaTileWidth;
TMCCJPEGDecState* state;
u8* lumaTexture;
u8* luminance;
s32 column;
s32 row;
s32 chromaEnd;
u8* cbTexture;
u8* crTexture;
u32 tileRow;
s32 height;
s32 yEnd;
u8* output;
u8* cb;
u8* cr;
s32 xEnd;
s32 tileOffset;
s32 width;
u32 tileWidth;
luminance = work->convBuf + 4;
cb = &work->convBuf[132];
cr = &work->convBuf[196];
state = work->pState;
tileWidth = state->convWidth >> 3;
lumaTexture = state->pLumaBuffer;
cbTexture = state->pCbBuffer;
crTexture = state->pCrBuffer;
if (state->dataSizeX == (u32)x) {
width = state->stepXExt;
} else {
width = 16 / state->scaleFactor;
}
if (state->dataSizeY == (u32)y) {
height = state->stepYExt;
} else {
height = 8 / state->scaleFactor;
}
xEnd = x + width;
yEnd = y + height;
for (row = y; row < yEnd; row++) {
for (column = x; column < xEnd; column += 1) {
tileRow = (row >> 2) * tileWidth;
tileOffset = ((column >> 3) + tileRow) << 5;
output = lumaTexture + ((row & 3) << 3) + (column & 7);
output[tileOffset] = *luminance++;
}
luminance += 16 - width;
}
x = (u32)x >> 1;
width = (width + 1) >> 1;
xEnd = x + width;
chromaTileWidth = state->chromaWidth >> 3;
chromaEnd = y + height;
for (; y < chromaEnd; y++) {
for (column = x; column < xEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
cb++;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
cr++;
}
cb += 8 - width;
cr += 8 - width;
}
}
static void TMCJPEG_814F17E0(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 height;
s32 chromaYEnd;
s32 column;
u8* lumaTexture;
s32 chromaXEnd;
u8* luminance;
u32 chromaTileWidth;
u8* cbTexture;
s32 width;
u8* crTexture;
u32 tileWidth;
u8* cb;
TMCCJPEGDecState* state;
s32 yEnd;
s32 xEnd;
u8* cr;
s32 row;
row = y;
luminance = work->convBuf + 4;
cb = &work->convBuf[260];
cr = &work->convBuf[324];
state = work->pState;
tileWidth = state->convWidth >> 3;
lumaTexture = state->pLumaBuffer;
cbTexture = state->pCbBuffer;
crTexture = state->pCrBuffer;
width = 16 / state->scaleFactor;
height = 16 / state->scaleFactor;
xEnd = x + width;
yEnd = y + height;
for (; row < yEnd; row++) {
for (column = x; column < xEnd; column += 2) {
(lumaTexture + ((row & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (row >> 2) * tileWidth) << 5)] = *luminance++;
(lumaTexture + ((row & 3) << 3) + ((column + 1) & 7))[(s32)((((column + 1) >> 3) + (row >> 2) * tileWidth) << 5)] = *luminance++;
}
luminance += 16 - width;
}
x = (u32)x >> 1;
y = (u32)y >> 1;
width = 8 / state->scaleFactor;
height = 8 / state->scaleFactor;
chromaXEnd = x + width;
chromaYEnd = y + height;
chromaTileWidth = state->chromaWidth >> 3;
for (; y < chromaYEnd; y++) {
for (column = x; column < chromaXEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
cb++;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
cr++;
}
cb += 8 - width;
cr += 8 - width;
}
}
static void TMCJPEG_814F1F48(TMCCJPEGDecWork* work, s32 x, s32 y) {
u32 chromaTileWidth;
TMCCJPEGDecState* state;
u8* lumaTexture;
u8* luminance;
s32 column;
s32 row;
s32 chromaEnd;
u8* cbTexture;
u8* crTexture;
u32 tileRow;
s32 height;
s32 yEnd;
u8* output;
u8* cb;
u8* cr;
s32 xEnd;
s32 tileOffset;
s32 width;
u32 tileWidth;
luminance = work->convBuf + 4;
cb = &work->convBuf[260];
cr = &work->convBuf[324];
state = work->pState;
tileWidth = state->convWidth >> 3;
lumaTexture = state->pLumaBuffer;
cbTexture = state->pCbBuffer;
crTexture = state->pCrBuffer;
if (state->dataSizeX == (u32)x) {
width = state->stepXExt;
} else {
width = 16 / state->scaleFactor;
}
if (state->dataSizeY == (u32)y) {
height = state->stepYExt;
} else {
height = 16 / state->scaleFactor;
}
xEnd = x + width;
yEnd = y + height;
for (row = y; row < yEnd; row++) {
for (column = x; column < xEnd; column += 1) {
tileRow = (row >> 2) * tileWidth;
tileOffset = ((column >> 3) + tileRow) << 5;
output = lumaTexture + ((row & 3) << 3) + (column & 7);
output[tileOffset] = *luminance++;
}
luminance += 16 - width;
}
y = (u32)y >> 1;
x = (u32)x >> 1;
width = (width + 1) >> 1;
xEnd = x + width;
chromaTileWidth = state->chromaWidth >> 3;
chromaEnd = y + ((height + 1) >> 1);
for (; y < chromaEnd; y++) {
for (column = x; column < xEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
cb++;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
cr++;
}
cb += 8 - width;
cr += 8 - width;
}
}
static void TMCJPEG_814F2570(TMCCJPEGDecWork* work, s32 x, s32 y) {
u32 chromaTileWidth;
TMCCJPEGDecState* state;
u8* lumaTexture;
u8* luminance;
s32 column;
s32 row;
s32 chromaEnd;
u8* cbTexture;
u8* crTexture;
u32 tileRow;
s32 height;
s32 yEnd;
u8* output;
u8* cb;
u8* cr;
s32 xEnd;
s32 tileOffset;
s32 width;
u32 tileWidth;
luminance = work->convBuf + 4;
cb = &work->convBuf[132];
cr = &work->convBuf[196];
state = work->pState;
tileWidth = state->convWidth >> 3;
lumaTexture = state->pLumaBuffer;
cbTexture = state->pCbBuffer;
crTexture = state->pCrBuffer;
width = 8 / state->scaleFactor;
height = 16 / state->scaleFactor;
xEnd = x + width;
yEnd = y + height;
for (row = y; row < yEnd; row++) {
for (column = x; column < xEnd; column += 1) {
tileRow = (row >> 2) * tileWidth;
tileOffset = ((column >> 3) + tileRow) << 5;
output = lumaTexture + ((row & 3) << 3) + (column & 7);
output[tileOffset] = *luminance++;
}
luminance += 8 - width;
}
y = (u32)y >> 1;
chromaTileWidth = state->chromaWidth >> 3;
chromaEnd = y + 8 / state->scaleFactor;
for (; y < chromaEnd; y++) {
for (column = x; column < xEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
cb++;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
cr++;
}
cb += 8 - width;
cr += 8 - width;
}
}
static void TMCJPEG_814F2B50(TMCCJPEGDecWork* work, s32 x, s32 y) {
u32 chromaTileWidth;
TMCCJPEGDecState* state;
u8* lumaTexture;
u8* luminance;
s32 column;
s32 row;
s32 chromaEnd;
u8* cbTexture;
u8* crTexture;
u32 tileRow;
s32 height;
s32 yEnd;
u8* output;
u8* cb;
u8* cr;
s32 xEnd;
s32 tileOffset;
s32 width;
u32 tileWidth;
luminance = work->convBuf + 4;
cb = &work->convBuf[132];
cr = &work->convBuf[196];
state = work->pState;
tileWidth = state->convWidth >> 3;
lumaTexture = state->pLumaBuffer;
cbTexture = state->pCbBuffer;
crTexture = state->pCrBuffer;
if (state->dataSizeX == (u32)x) {
width = state->stepXExt;
} else {
width = 8 / state->scaleFactor;
}
if (state->dataSizeY == (u32)y) {
height = state->stepYExt;
} else {
height = 16 / state->scaleFactor;
}
xEnd = x + width;
yEnd = y + height;
for (row = y; row < yEnd; row++) {
for (column = x; column < xEnd; column += 1) {
tileRow = (row >> 2) * tileWidth;
tileOffset = ((column >> 3) + tileRow) << 5;
output = lumaTexture + ((row & 3) << 3) + (column & 7);
output[tileOffset] = *luminance++;
}
luminance += 8 - width;
}
y = (u32)y >> 1;
chromaTileWidth = state->chromaWidth >> 3;
chromaEnd = y + ((height + 1) >> 1);
for (; y < chromaEnd; y++) {
for (column = x; column < xEnd; column += 1) {
(cbTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cb + 128;
cb++;
(crTexture + ((y & 3) << 3) + (column & 7))[(s32)(((column >> 3) + (y >> 2) * chromaTileWidth) << 5)] = *cr + 128;
cr++;
}
cb += 8 - width;
cr += 8 - width;
}
}
static void TMCJPEG_814F3158(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 rowSkip;
u8* output;
s32 height;
s32 tileRow;
u8* cbOutput;
TMCCJPEGDecState* state;
u8* crOutput;
s32 pixelOffset;
s32 tileOffset;
u8* lumaTexture;
s32 width;
u32 rowOffset;
u8* cbTexture;
u8* crTexture;
u8* luminance;
u8* cb;
u8* cr;
s32 column;
s32 xEnd;
s32 yEnd;
u32 tileWidth;
luminance = work->convBuf + 4;
cb = &work->convBuf[68];
cr = &work->convBuf[132];
state = work->pState;
tileWidth = state->convWidth >> 3;
lumaTexture = state->pLumaBuffer;
cbTexture = state->pCbBuffer;
crTexture = state->pCrBuffer;
width = 8 / state->scaleFactor;
height = 8 / state->scaleFactor;
xEnd = x + width;
yEnd = y + height;
rowSkip = 8 - width;
for (; y < yEnd; y++) {
tileRow = (y >> 2) * tileWidth;
rowOffset = (y & 3) << 3;
output = lumaTexture + rowOffset;
cbOutput = cbTexture + rowOffset;
crOutput = crTexture + rowOffset;
for (column = x; column < xEnd;) {
tileOffset = ((column >> 3) + tileRow) << 5;
pixelOffset = column++ & 7;
(output + pixelOffset)[tileOffset] = *luminance++;
(cbOutput + pixelOffset)[tileOffset] = *cb++ + 128;
(crOutput + pixelOffset)[tileOffset] = *cr++ + 128;
}
luminance += rowSkip;
cb += rowSkip;
cr += rowSkip;
}
}
static void TMCJPEG_814F32E4(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 rowSkip;
u8* output;
s32 height;
s32 tileRow;
u8* cbOutput;
TMCCJPEGDecState* state;
u8* crOutput;
s32 pixelOffset;
s32 tileOffset;
u8* lumaTexture;
s32 width;
u32 rowOffset;
u8* cbTexture;
u8* crTexture;
u8* luminance;
u8* cb;
u8* cr;
s32 column;
s32 xEnd;
s32 yEnd;
u32 tileWidth;
luminance = work->convBuf + 4;
cb = &work->convBuf[68];
cr = &work->convBuf[132];
state = work->pState;
tileWidth = state->convWidth >> 3;
lumaTexture = state->pLumaBuffer;
cbTexture = state->pCbBuffer;
crTexture = state->pCrBuffer;
if (state->dataSizeX == (u32)x) {
width = state->stepXExt;
} else {
width = 8 / state->scaleFactor;
}
if (state->dataSizeY == (u32)y) {
height = state->stepYExt;
} else {
height = 8 / state->scaleFactor;
}
xEnd = x + width;
yEnd = y + height;
rowSkip = 8 - width;
for (; y < yEnd; y++) {
tileRow = (y >> 2) * tileWidth;
rowOffset = (y & 3) << 3;
output = lumaTexture + rowOffset;
cbOutput = cbTexture + rowOffset;
crOutput = crTexture + rowOffset;
for (column = x; column < xEnd;) {
tileOffset = ((column >> 3) + tileRow) << 5;
pixelOffset = column++ & 7;
(output + pixelOffset)[tileOffset] = *luminance++;
(cbOutput + pixelOffset)[tileOffset] = *cb++ + 128;
(crOutput + pixelOffset)[tileOffset] = *cr++ + 128;
}
luminance += rowSkip;
cb += rowSkip;
cr += rowSkip;
}
}
static void TMCJPEG_814F34A4(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 height;
u8* lumaTexture;
u8* luminance;
s32 column;
s32 xEnd;
s32 yEnd;
u8* output;
s32 width;
TMCCJPEGDecState* state;
u32 tileRow;
u32 tileWidth;
s32 tileOffset;
s32 row;
luminance = work->convBuf + 4;
state = work->pState;
tileWidth = state->convWidth >> 3;
lumaTexture = state->pLumaBuffer;
width = 8 / state->scaleFactor;
height = 8 / state->scaleFactor;
{
xEnd = x + width;
yEnd = y + height;
for (row = y; row < yEnd; row++) {
for (column = x; column < xEnd; column += 1) {
tileRow = (row >> 2) * tileWidth;
tileOffset = ((column >> 3) + tileRow) << 5;
output = lumaTexture + ((row & 3) << 3) + (column & 7);
output[tileOffset] = *luminance++;
}
luminance += 8 - width;
}
}
}
static void TMCJPEG_814F372C(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 height;
u8* lumaTexture;
u8* luminance;
s32 column;
s32 xEnd;
s32 yEnd;
u8* output;
s32 width;
TMCCJPEGDecState* state;
u32 tileRow;
u32 tileWidth;
s32 tileOffset;
s32 row;
luminance = work->convBuf + 4;
state = work->pState;
tileWidth = state->convWidth >> 3;
lumaTexture = state->pLumaBuffer;
if (state->dataSizeX == (u32)x) {
width = state->stepXExt;
} else {
width = 8 / state->scaleFactor;
}
if (state->dataSizeY == (u32)y) {
height = state->stepYExt;
} else {
height = 8 / state->scaleFactor;
}
{
xEnd = x + width;
yEnd = y + height;
for (row = y; row < yEnd; row++) {
for (column = x; column < xEnd; column += 1) {
tileRow = (row >> 2) * tileWidth;
tileOffset = ((column >> 3) + tileRow) << 5;
output = lumaTexture + ((row & 3) << 3) + (column & 7);
output[tileOffset] = *luminance++;
}
luminance += 8 - width;
}
}
}

View File

@@ -142,6 +142,9 @@ typedef struct ziFuzzyZYPairs {
int rANDn : 1;
int bANDp : 1;
int gANDk : 1;
int dANDt : 1;
int reserved : 20;
} ziFuzzyZYPairs;
typedef struct _ziGetParam {
@@ -357,8 +360,8 @@ typedef struct ziMatchParam {
ziWChar first2; // 0x68
ziWChar comp; // 0x6A
ziU8 nSeg; // 0x6C
ziU8 segs1[0xC0]; // 0x6D
ziU8 segsD[0xC0]; // 0x12D
ziU8 segs1[16][12]; // 0x6D
ziU8 segsD[16][12]; // 0x12D
ziU8 pad_0x1ED; // 0x1ED
} ziMatchParam;

View File

@@ -0,0 +1,191 @@
#include <zi8clib/zconvert.h>
#include <zi8clib/zierror.h>
typedef struct ziConversionRange {
ziU16 first, last;
union { ziPtr table; ziU32 character; } result;
} ziConversionRange;
typedef struct ziConversionRangeTable {
ziU16 count, flags;
ziConversionRange* entries;
} ziConversionRangeTable;
typedef struct ziConversionTables {
ziU16 first, last;
ziWChar* unicode;
ziConversionRangeTable reverse, keys, cases;
} ziConversionTables;
typedef struct ziConversionEntry {
ziU8 first[2], last[2], flags[2], value[2];
} ziConversionEntry;
typedef struct ziConversionTable {
ziU8 count[2], flags[2], minimum[2], maximum[2];
ziConversionEntry entries[1];
} ziConversionTable;
const ziConversionTables Zi8CvrtTables = {0};
ziU16 Zi8GetTableCount(ziU8, ziU8 ZI_NEED_WORK);
ziPtr Zi8GetTableAddress(ziU8, ziU8 ZI_NEED_WORK);
ziWChar Zi8ConvertUC2UserKey(ziChar, ziU8 ZI_NEED_WORK);
ziWChar Zi8ConvertUC2WC(ziChar character, ziU8 language ZI_NEED_WORK) {
ziU8* table;
ziWChar* mapped;
ziU8* cursor;
ziU16 first, last;
const ziConversionTables* defaults;
if (character == 0) {
Zi8LogError(0x133, __zi8_work_data);
return 0;
}
if (Zi8GetTableCount(language, 6, __zi8_work_data) != 0) {
table = Zi8GetTableAddress(language, 6, __zi8_work_data);
if (table == 0) {
Zi8LogError(0x6A4, __zi8_work_data);
return 0;
}
cursor = table;
first = (ziU16)cursor[0] << 8 | cursor[1];
last = (ziU16)cursor[2] << 8 | cursor[3];
if (character < first || character > last) {
Zi8LogError(0x132, __zi8_work_data);
return 0;
}
cursor += (character - first) * 2 + 8;
Zi8LogError(100, __zi8_work_data);
return (ziU16)cursor[0] << 8 | cursor[1];
}
defaults = &Zi8CvrtTables;
if (defaults == 0) {
Zi8LogError(0x6A4, __zi8_work_data);
return 0;
}
if (character < defaults->first || character > defaults->last) {
Zi8LogError(0x132, __zi8_work_data);
return 0;
}
mapped = defaults->unicode;
Zi8LogError(100, __zi8_work_data);
return mapped[character - defaults->first];
}
ziChar Zi8ConvertWC2UC(ziWChar character, ziU8 language ZI_NEED_WORK) {
ziU16 index, count, value, first, last;
ziU8* cursor;
ziConversionTable* table;
ziConversionRange* ranges;
ziConversionEntry* entry;
if (character == 0) {
Zi8LogError(0x133, __zi8_work_data);
return 0;
}
if (Zi8GetTableCount(language, 7, __zi8_work_data) != 0) {
table = Zi8GetTableAddress(language, 7, __zi8_work_data);
if (table == 0) {
Zi8LogError(0x6AE, __zi8_work_data);
return 0;
}
entry = (ziConversionEntry*)table;
count = (ziU16)entry->first[0] << 8 | entry->first[1];
entry++;
for (index = 0; index < count; index++) {
first = (ziU16)entry->first[0] << 8 | entry->first[1];
last = (ziU16)entry->last[0] << 8 | entry->last[1];
if (character < first || character > last) {
entry++;
continue;
}
value = (ziU16)entry->value[0] << 8 | entry->value[1];
if (first == last) {
Zi8LogError(100, __zi8_work_data);
return value & 0xFF;
}
entry = (ziConversionEntry*)((ziU8*)table + value + character - first + 8);
Zi8LogError(100, __zi8_work_data);
return *(ziU8*)entry;
}
Zi8LogError(0x6C2, __zi8_work_data);
return 0;
} else {
ranges = Zi8CvrtTables.reverse.entries;
if (ranges == 0) {
Zi8LogError(0x6AE, __zi8_work_data);
return 0;
}
count = Zi8CvrtTables.reverse.count;
for (index = 0; index < count; index++) {
if (character >= ranges[index].first && character <= ranges[index].last) {
Zi8LogError(100, __zi8_work_data);
if (ranges[index].first == ranges[index].last)
return ranges[index].result.character & 0xFF;
cursor = ranges[index].result.table;
return cursor[character - ranges[index].first];
}
}
Zi8LogError(0x6C2, __zi8_work_data);
return 0;
}
}
ziWChar Zi8ConvertUC2Key(ziChar character, ziU8 language ZI_NEED_WORK) {
ziU16 key = 0;
ziU16 index, count, first, last;
ziConversionTable* table;
ziWChar* mapped;
ziConversionRange* ranges;
ziConversionEntry* entry;
if (character == 0) {
Zi8LogError(0x133, __zi8_work_data);
return 0;
}
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);
if (table == 0) {
Zi8LogError(0x6B8, __zi8_work_data);
return 0;
}
entry = (ziConversionEntry*)table;
count = (ziU16)entry->first[0] << 8 | entry->first[1];
entry++;
for (index = 0; index < count; index++) {
first = (ziU16)entry->first[0] << 8 | entry->first[1];
last = (ziU16)entry->last[0] << 8 | entry->last[1];
if (character < first || character > last) {
entry++;
continue;
}
key = (ziU16)entry->value[0] << 8 | entry->value[1];
if (first == last) break;
entry = (ziConversionEntry*)((ziU8*)table + key + (character - first) * 2);
entry = (ziConversionEntry*)((ziU8*)entry + 8);
key = (ziU16)entry->first[0] << 8 | entry->first[1];
break;
}
} else {
ranges = Zi8CvrtTables.keys.entries;
if (ranges == 0) {
Zi8LogError(0x6B8, __zi8_work_data);
return 0;
}
count = Zi8CvrtTables.keys.count;
for (index = 0; index < count; index++) {
if (character >= ranges[index].first && character <= ranges[index].last) {
if (ranges[index].first == ranges[index].last) {
key = (ziU8)ranges[index].result.character;
break;
}
mapped = ranges[index].result.table;
key = mapped[character - ranges[index].first];
break;
}
}
}
if (key == 0) {
Zi8LogError(0x6C2, __zi8_work_data);
return 0xEFF1;
} else {
Zi8LogError(100, __zi8_work_data);
return key;
}
}
ziWChar Zi8ConvertWC2Key(ziWChar character, ziU8 language ZI_NEED_WORK) {
return Zi8ConvertUC2Key(Zi8ConvertWC2UC(character, language, __zi8_work_data), language, __zi8_work_data);
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -643,7 +643,7 @@ ziU32 Zi8GetSInfo(ziU8* strokes, ziU8* extraStrokes, ziWChar* outputBuffer, ziU8
{
int strokeIndex;
int outputCount;
int extraCount;
volatile int extraCount;
outputCount = 0;
Zi8LogError(100, work);
@@ -660,8 +660,7 @@ ziU32 Zi8GetSInfo(ziU8* strokes, ziU8* extraStrokes, ziWChar* outputBuffer, ziU8
goto lowStroke;
}
badStroke:
outputCount--;
outputBuffer[(ziU8)outputCount] = 0;
outputBuffer[(ziU8)--outputCount] = 0;
return outputCount;
lowStroke:
outputBuffer[(ziU8)outputCount] = zi8StrokeCode(strokes[strokeIndex] & 0xf, work);

View File

@@ -12,153 +12,140 @@ ziU8 ZiDAWGgetEOWattribute(ziU8* graph);
ziU8* ZiDAWGGetChild(ziU8* graph);
ziU8* ZiDAWGGetSibling(ziU8* graph);
ziU32 Zi8MatchROMdata0(ziWChar* elements, ziU32 count, ziU8 language,
ziU32 Zi8MatchROMdata0(ziWChar* elements, ziU8 count, ziU8 language,
ziWChar* output, ziU16 capacity, ziU8 mode, ziU8 status,
ziU8 graphTable, ziU8 keyTable, ziU8 acceptPrefix,
ziU8* prefixLength, zi8DawgCtx* context, ziU8* search,
ziPtr __zi8_work_data) {
ziBool searching;
ziS32 tableSize;
ziU8* graph;
ziU16 key;
ziU8 endOfWord;
zi8DawgRec* current;
ziU16 index;
ziU16 depth;
zi8DawgRec* records = context->recs;
ziU8 result = 0;
ziU32 keyCount;
ziU8* table;
ziU8* graphData;
ziU8* keyData;
ziS32 keyCount;
ziS32 convertedKey;
ziU16 searching;
ziU16 key;
ziU16 keys[3];
ziU16 index;
zi8DawgRec* current;
zi8DawgRec* records = context->recs;
if (language != context->lang || graphTable != context->key) {
records[0].key = 0;
}
if ((ziU8)count != 1 || mode == 0 || graphTable != 0xe) {
if (status != 0) {
if (records[context->cnt - 1].node == (ziU8*)context->unk_0x338) goto finish_graph;
for (index = 0; (ziU16)index < (ziU8)count; index++) {
if (records[(ziU16)index].key != elements[(ziU16)index] &&
(records[(ziU16)index].attr & 0xffff) != elements[(ziU16)index]) goto finish_graph;
}
if (mode == 1) acceptPrefix = 0;
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;
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;
} else {
if (ZI_WORK->unk_0x141E == 0 || graphTable != 0xc ||
(tableSize = Zi8GetTableSize(language, ZI_WORK->unk_0x141E, ZI_WORK)) == 0) {
tableSize = Zi8GetTableSize(language, graphTable, ZI_WORK);
if (tableSize == 0) {
Zi8LogError(0x961, ZI_WORK);
goto finish_graph;
}
table = (ziU8*)Zi8GetTableAddress(language, graphTable, ZI_WORK);
} else {
table = (ziU8*)Zi8GetTableAddress(language, ZI_WORK->unk_0x141E, ZI_WORK);
keyTable = ZI_WORK->unk_0x141E + 1;
}
context->table = table;
context->cap = (((ziU16)context->table[2] << 8) + (ziU16)context->table[3]) / 3;
context->p08 = context->table + 4;
context->p0C = context->table + context->cap * 2 + 4;
context->lang = language;
context->key = graphTable;
index = 0;
while ((ziU16)index < (ziU8)count && records[(ziU16)index].key == elements[(ziU16)index]) {
index++;
}
if ((ziU16)index < 2) {
key = Zi8GetTableSize(language, keyTable, ZI_WORK);
if (key == 0 || ZI_WORK->userKeys[language] != 0) {
graph = ZiDAWGGetGraph(context);
records[0].node = graph;
context->unk_0x338 = 0;
context->p14 = 0;
} else {
index = 0;
while (1) {
if ((ziU8)count < 2) keyCount = (ziU8)count;
else keyCount = 2;
if (keyCount <= (ziU16)index) break;
key = Zi8ConvertWC2Key(elements[(ziU16)index], language, ZI_WORK);
keys[(ziU16)index] = key;
if (keys[(ziU16)index] == 0) keys[(ziU16)index] = elements[(ziU16)index];
index++;
}
keys[(ziU16)index] = 0;
table = (ziU8*)Zi8GetTableAddress(language, keyTable, ZI_WORK);
context->p14 = table + 2;
records[0].node = ZiDAWGGetGraphInfo(context, table + context->cap * 2 + 2, (ziS16*)keys);
}
records[0].key = 0;
if (records[0].node == 0) goto finish_graph;
} else {
records[0].node = records[(ziU16)index - 1].back;
}
context->cnt = 1;
search[1] = count;
search[0] = 0;
if (mode == 1) {
search[0] = 1;
acceptPrefix = 0;
} else if (mode == 0 && acceptPrefix == 0) {
search[1]++;
if (Zi8GetTableSize(language, graphTable, ZI_WORK) == 0) {
Zi8LogError(0x961, ZI_WORK);
goto finish_graph;
}
graphData = (ziU8*)Zi8GetTableAddress(language, graphTable, ZI_WORK);
}
searching = 1;
depth = context->cnt;
while ((current = &records[depth - 1], searching) && context->cnt != 0 &&
current->node != (ziU8*)context->unk_0x338 && context->cnt <= capacity) {
current->attr = ZiDAWGgetCHARattribute(context, current->node, ZI_WORK);
if ((ziU8)count < context->cnt) {
check_word:
if (context->cnt < search[1]) goto descend;
if (search[0] == 0 || context->cnt <= search[1]) {
if (acceptPrefix != 0 || (endOfWord = ZiDAWGgetEOWattribute(current->node)) != 0) {
for (depth = 0; depth < context->cnt; depth++) {
output[depth] = records[depth].attr;
}
result = context->cnt;
searching = 0;
if (acceptPrefix != 0) goto next_sibling;
}
if (search[0] == 0 || context->cnt < search[1]) goto descend;
}
next_sibling:
while (context->cnt != 0) {
graph = ZiDAWGGetSibling(records[context->cnt - 1].node);
records[context->cnt - 1].node = graph;
if (records[context->cnt - 1].node != 0) break;
context->cnt--;
context->table = graphData;
context->cap = (((ziU16)context->table[2] << 8) + context->table[3]) / 3;
context->p08 = context->table + 4;
context->p0C = context->table + context->cap * 2 + 4;
context->lang = language;
context->key = graphTable;
index = 0;
while (index < count && records[index].key == elements[index]) index++;
if (index >= 2) {
records[0].node = records[index - 1].back;
} else {
key = Zi8GetTableSize(language, keyTable, ZI_WORK);
if (key != 0 && ZI_WORK->userKeys[language] == 0) {
index = 0;
goto check_keys;
next_key:
{
keys[index] = Zi8ConvertWC2Key(elements[index], language, ZI_WORK);
if (keys[index] == 0) keys[index] = elements[index];
index++;
}
check_keys:
if (count < 2) keyCount = count;
else keyCount = 2;
if (index < keyCount) goto next_key;
keys[index] = 0;
keyData = (ziU8*)Zi8GetTableAddress(language, keyTable, ZI_WORK);
context->p14 = keyData + 2;
keyData += context->cap * 2 + 2;
records[0].node = ZiDAWGGetGraphInfo(context, keyData, (ziS16*)keys);
} else {
if (context->p14 == 0) {
key = Zi8ConvertWC2Key(current->attr & 0xffff, language, ZI_WORK);
} else {
key = (ziU16)context->p14[(current->attr >> 24) * 2] * 0x100 +
(ziU16)context->p14[(current->attr >> 24) * 2 + 1];
}
if (key != elements[context->cnt - 1] &&
(current->attr & 0xffff) != elements[context->cnt - 1]) goto next_sibling;
if (current->key != elements[context->cnt - 1]) {
current->key = elements[context->cnt - 1];
current->back = records[0].node;
depth = context->cnt;
records[depth].key = 0;
}
if (prefixLength != 0 && *prefixLength < context->cnt &&
(endOfWord = ZiDAWGgetEOWattribute(current->node)) != 0) {
*prefixLength = context->cnt;
for (depth = 0; depth < context->cnt; depth++) output[depth] = records[depth].attr;
}
if ((ziU8)count <= context->cnt) goto check_word;
records[0].node = ZiDAWGGetGraph(context);
context->unk_0x338 = 0;
context->p14 = 0;
}
records[0].key = 0;
if (records[0].node == (ziU8*)0) goto finish_graph;
}
context->cnt = 1;
search[1] = count;
search[0] = 0;
if (mode == 1) {
search[0] = 1;
acceptPrefix = 0;
} else if (mode == 0 && acceptPrefix == 0) search[1]++;
}
searching = 1;
current = &records[context->cnt - 1];
while (searching && context->cnt != 0 && current->node != (ziU8*)context->unk_0x338) {
if (capacity < context->cnt) goto finish_graph;
current->attr = ZiDAWGgetCHARattribute(context, current->node, ZI_WORK);
if (context->cnt <= count) {
if (context->p14 == 0) {
convertedKey = Zi8ConvertWC2Key((ziU16)current->attr, language, ZI_WORK);
} else {
convertedKey = ((ziU16)context->p14[(current->attr >> 24) * 2] << 8) +
(context->p14 + (current->attr >> 24) * 2)[1];
}
key = convertedKey;
if (key != elements[context->cnt - 1] &&
(ziU16)current->attr != elements[context->cnt - 1]) goto next_sibling;
if (current->key != elements[context->cnt - 1]) {
current->key = elements[context->cnt - 1];
current->back = records[0].node;
records[context->cnt].key = 0;
}
if (prefixLength != 0 && *prefixLength < context->cnt &&
ZiDAWGgetEOWattribute(current->node) != 0) {
*prefixLength = context->cnt;
for (index = 0; index < context->cnt; index++) output[index] = (ziU16)records[index].attr;
}
if (context->cnt < count) goto descend;
}
if (context->cnt < search[1]) goto descend;
if (search[0] != 0 && context->cnt > search[1]) goto next_sibling;
if (acceptPrefix != 0 || ZiDAWGgetEOWattribute(current->node) != 0) {
for (index = 0; index < context->cnt; index++) output[index] = (ziU16)records[index].attr;
result = context->cnt;
searching = 0;
if (acceptPrefix != 0) goto next_sibling;
}
if (search[0] != 0 && context->cnt >= search[1]) goto next_sibling;
descend:
graph = ZiDAWGGetChild(records[context->cnt - 1].node);
records[context->cnt].node = graph;
if (records[context->cnt].node == 0) goto next_sibling;
context->cnt++;
if (ZI_WORK->unk_0x141F < context->cnt) ZI_WORK->unk_0x141F = context->cnt;
}
depth = context->cnt;
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;
goto update_current;
next_sibling:
while (context->cnt != 0) {
records[context->cnt - 1].node = ZiDAWGGetSibling(records[context->cnt - 1].node);
if (records[context->cnt - 1].node != (ziU8*)0) break;
context->cnt--;
}
update_current:
current = &records[context->cnt - 1];
}
finish_graph:
return result;
@@ -190,13 +177,13 @@ ziU8* NextDawgGroup(ziU8* group, ziU8 language, ziPtr __zi8_work_data)
return 0;
}
unsigned int Zi8MatchROMdata1(ziWChar *elements, ziU8 count, ziU8 language, ziWChar *output, ziU16 capacity, ziU8 mode, unsigned int status, ziU32 groupIndex, char *group, ziU8 acceptPrefix, ziPtr __zi8_work_data)
unsigned int Zi8MatchROMdata1(ziWChar *elements, ziU8 count, ziU8 language, ziWChar *output, ziU16 capacity, ziU8 mode, ziU8 status, ziU32 groupIndex, char *group, ziU8 acceptPrefix, ziPtr __zi8_work_data)
{
unsigned int result;
ziU32 tableAddress;
result = 0;
if ((status & 0xff) == 0) {
if (status == 0) {
ZI_WORK->unk_0x1764 = (ziU8*)group;
if (ZI_WORK->unk_0x1764 == 0) {
if (Zi8GetTableSize(language & 0xff,0xb,ZI_WORK) != 0) {
@@ -234,163 +221,139 @@ unsigned int Zi8MatchROMdata1(ziWChar *elements, ziU8 count, ziU8 language, ziWC
return result;
}
unsigned int Zi8MatchROMdata2(ziWChar *elements, unsigned int count, unsigned int language, ziWChar *output, unsigned int capacity, unsigned int mode, unsigned int status, ziU8 reservedMode, ziU8 *group, ziU8 acceptPrefix, ziPtr __zi8_work_data)
{
ziU16 character;
unsigned int result;
ziU8 prefixCount;
unsigned int index;
unsigned int remaining;
unsigned int Zi8MatchROMdata2(ziWChar* elements, ziU8 count, ziU8 language,
ziWChar* output, ziU16 capacity, ziU8 mode,
ziU8 status, ziU8 reservedMode, ziU8* group,
ziU8 acceptPrefix, ziPtr __zi8_work_data) {
unsigned int result = 0;
ziU8 index;
result = 0;
if (reservedMode != 0) return 0;
if ((status & 0xff) == 0) {
ZI_WORK->unk_0x1768 = 0;
ZI_WORK->unk_0x17EA = 0;
if ((((group == 0) || (*group != '\f')) || ((language & 0xff) != 10)) ||
(ZI_WORK->unk_0x141C == '\0')) {
ZI_WORK->unk_0x141E = 0;
}
else {
ZI_WORK->unk_0x141E = 0x10;
}
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;
} else {
ZI_WORK->unk_0x141E = 0;
}
}
search_segment:
ZI_WORK->unk_0x141F = 1;
result = Zi8MatchROMdata1(elements + (unsigned int)ZI_WORK->unk_0x17EA,
count - ZI_WORK->unk_0x17EA & 0xff,language & 0xff,
&ZI_WORK->unk_0x17F4[ZI_WORK->unk_0x17EA],
capacity & 0xffff,mode & 0xff,status & 0xff,
ZI_WORK->unk_0x1768,(char *)group,acceptPrefix,ZI_WORK);
if ((result & 0xff) == 0) {
if ((((status & 0xff) != 0) || ((count & 0xff) == 1)) ||
(((mode & 0xff) == 1 &&
((ZI_WORK->unk_0x1768 == 0 &&
(prefixCount = Zi8MatchROMdata1(elements + (unsigned int)ZI_WORK->unk_0x17EA,
count - ZI_WORK->unk_0x17EA & 0xff,language & 0xff,
&ZI_WORK->unk_0x17F4[ZI_WORK->unk_0x17EA],
capacity & 0xffff,0,status & 0xff,
ZI_WORK->unk_0x1768,(char *)group,acceptPrefix,ZI_WORK),
prefixCount != '\0')))))) goto finish_segments;
index = Zi8GetTableCount(language & 0xff,0x1f,ZI_WORK);
if ((index & 4) == 0) {
for (index = 0; (index & 0xff) < (count & 0xff); index = index + 1) {
if (elements[index & 0xff] == 0xeff1) goto finish_segments;
result = Zi8MatchROMdata1(elements + ZI_WORK->unk_0x17EA,
count - ZI_WORK->unk_0x17EA, language,
&ZI_WORK->unk_0x17F4[ZI_WORK->unk_0x17EA], 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--) {
output[index - 1] = ZI_WORK->unk_0x17F4[index - 1];
}
}
if ((capacity & 0xffff) < (unsigned int)ZI_WORK->unk_0x141F) goto finish_segments;
prefixCount = ZI_WORK->unk_0x141F;
for (; prefixCount != 0; prefixCount--) {
result = Zi8MatchROMdata1(elements + (unsigned int)ZI_WORK->unk_0x17EA,prefixCount,
language & 0xff,
&ZI_WORK->unk_0x17F4[ZI_WORK->unk_0x17EA],
capacity & 0xffff,1,0,ZI_WORK->unk_0x1768,(char *)group,
acceptPrefix,ZI_WORK);
if ((result & 0xff) != 0) break;
}
if (prefixCount == 0) goto finish_segments;
ZI_WORK->unk_0x17EA = ZI_WORK->unk_0x17EA + ((ziU16)result & 0xff);
if ((unsigned int)ZI_WORK->unk_0x17EA == (count & 0xff)) {
result = 0;
goto finish_segments;
}
ZI_WORK->unk_0x1768 = ZI_WORK->unk_0x1768 + 1;
status = 0;
ZI_WORK->unk_0x141E = 0;
if ((ZI_WORK->dawgCtx.key == 0) && ((language & 0xff) == 10)) {
for (result = 0; (result & 0xff) < (unsigned int)ZI_WORK->unk_0x17EA; result = result + 1) {
character = ZI_WORK->unk_0x17F4[result & 0xff];
if (character == 0x61 || character == 0x6f || character == 0x75) {
ZI_WORK->unk_0x141E = 0x10;
break;
}
result = (ziU8)(result + ZI_WORK->unk_0x17EA);
} 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,
0, status, ZI_WORK->unk_0x1768, (char*)group,
acceptPrefix, ZI_WORK) != 0) goto finish_segments;
if ((Zi8GetTableCount(language, 0x1f, ZI_WORK) & 4) == 0) {
for (index = 0; index < count; index++) {
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,
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->unk_0x1768++;
status = 0;
ZI_WORK->unk_0x141E = 0;
if (ZI_WORK->dawgCtx.key == 0 && language == 10) {
for (index = 0; index < ZI_WORK->unk_0x17EA; index++) {
switch (ZI_WORK->unk_0x17F4[index]) {
case 0x61:
case 0x6f:
case 0x75:
ZI_WORK->unk_0x141E = 0x10;
goto search_segment;
}
}
}
goto search_segment;
}
}
}
goto search_segment;
}
for (remaining = ZI_WORK->unk_0x17EA + result & 0xff; (remaining & 0xff) != 0;
remaining = remaining - 1) {
output[(remaining & 0xff) - 1] = ZI_WORK->unk_0x17F4[(remaining & 0xff) - 1];
}
result = result + ZI_WORK->unk_0x17EA & 0xff;
finish_segments:
return result;
return result;
}
ziU8 Zi8MatchROMdata(ziWChar *elements, ziU8 count, ziU8 language, ziWChar *output, ziU16 capacity, ziU8 mode, ziU8 status, ziU8 reservedMode, ziU8 acceptPrefix, ziPtr __zi8_work_data)
{
ziU8* group;
int tableSize;
ziU8 found;
unsigned int elementCount;
unsigned int result;
ziU32 Zi8MatchROMdata(ziWChar* elements, ziU8 count, ziU8 language,
ziWChar* output, ziU16 capacity, ziU8 mode, ziU8 status,
ziU8 reservedMode, ziU8 acceptPrefix, ziPtr __zi8_work_data) {
ziU32 result = 0;
ziS32 tableSize = 0;
elementCount = (unsigned int)count;
result = 0;
if ((capacity & 0xffff) < (elementCount & 0xff)) {
Zi8LogError(0x321,ZI_WORK);
}
else if ((status & 0xff) == 2) {
Zi8LogError(100,ZI_WORK);
}
else {
if ((status & 0xff) == 0) {
ZI_WORK->unk_0x17EC = 0;
group = NextDawgGroup(0,language & 0xff,ZI_WORK);
ZI_WORK->unk_0x17F0 = group;
}
else if (ZI_WORK->unk_0x17EC != '\0') {
Zi8LogError(100,ZI_WORK);
goto finish_match;
}
tableSize = Zi8GetTableSize(language & 0xff,0x1c,ZI_WORK);
if (tableSize == 0) {
result = Zi8MatchROMdata2(elements,elementCount & 0xff,language & 0xff,output,capacity & 0xffff,
mode & 0xff,status & 0xff,reservedMode & 0xff,0,acceptPrefix,ZI_WORK);
}
else {
while (((ZI_WORK->unk_0x17F0 != 0 &&
(result = Zi8MatchROMdata2(elements,elementCount & 0xff,language & 0xff,output,capacity & 0xffff,
mode & 0xff,status & 0xff,reservedMode & 0xff,
(ziU8 *)ZI_WORK->unk_0x17F0,acceptPrefix,ZI_WORK),
(result & 0xff) == 0)) &&
((status = 0, 1 < (elementCount & 0xff) || ((language & 0xff) != 0x36))))) {
group = NextDawgGroup(ZI_WORK->unk_0x17F0,language & 0xff,ZI_WORK);
ZI_WORK->unk_0x17F0 = group;
}
}
if (((((result & 0xff) == 0) && ((status & 0xff) == 0)) && ((mode & 0xff) == 1)) &&
(((elementCount & 0xff) == 1 && ((capacity & 0xffff) != 0)))) {
ZI_WORK->unk_0x17EC = 1;
if (tableSize == 0) {
found = Zi8MatchROMdata2(elements,elementCount & 0xff,language & 0xff,output,capacity & 0xffff,0,
status & 0xff,reservedMode & 0xff,0,acceptPrefix,ZI_WORK);
if (found != '\0') {
*output = *elements;
result = 1;
if (capacity < count) {
Zi8LogError(0x321, ZI_WORK);
} else if (status == 2) {
Zi8LogError(100, ZI_WORK);
} else {
if (status == 0) {
ZI_WORK->unk_0x17EC = 0;
ZI_WORK->unk_0x17F0 = NextDawgGroup(0, language, ZI_WORK);
} else if (ZI_WORK->unk_0x17EC != 0) {
Zi8LogError(100, ZI_WORK);
goto finish_match;
}
}
else {
group = NextDawgGroup(0,language & 0xff,ZI_WORK);
ZI_WORK->unk_0x17F0 = group;
while (ZI_WORK->unk_0x17F0 != 0) {
found = Zi8MatchROMdata2(elements,elementCount & 0xff,language & 0xff,output,capacity & 0xffff,0,
status & 0xff,reservedMode & 0xff,(ziU8 *)ZI_WORK->unk_0x17F0,
acceptPrefix,ZI_WORK);
if (found != '\0') {
*output = *elements;
result = 1;
break;
}
group = NextDawgGroup(ZI_WORK->unk_0x17F0,language & 0xff,ZI_WORK);
ZI_WORK->unk_0x17F0 = group;
tableSize = Zi8GetTableSize(language, 0x1c, ZI_WORK);
if (tableSize == 0) {
result = Zi8MatchROMdata2(elements, count, language, output, capacity,
mode, status, reservedMode, 0, acceptPrefix, ZI_WORK);
} else {
while (ZI_WORK->unk_0x17F0 != 0) {
result = Zi8MatchROMdata2(elements, count, language, output, capacity,
mode, status, reservedMode, ZI_WORK->unk_0x17F0,
acceptPrefix, ZI_WORK);
if ((ziU8)result != 0) break;
status = 0;
if (count <= 1 && language == 0x36) break;
ZI_WORK->unk_0x17F0 = NextDawgGroup(ZI_WORK->unk_0x17F0, language, ZI_WORK);
}
}
}
if ((ziU8)result == 0 && status == 0 && mode == 1 && count == 1 && capacity >= 1) {
mode = 0;
ZI_WORK->unk_0x17EC = 1;
if (tableSize != 0) {
ZI_WORK->unk_0x17F0 = NextDawgGroup(0, language, ZI_WORK);
while (ZI_WORK->unk_0x17F0 != 0) {
if ((ziU8)Zi8MatchROMdata2(elements, count, language, output, capacity,
mode, status, reservedMode, ZI_WORK->unk_0x17F0,
acceptPrefix, ZI_WORK) != 0) {
*output = *elements;
result = 1;
break;
}
ZI_WORK->unk_0x17F0 = NextDawgGroup(ZI_WORK->unk_0x17F0, language, ZI_WORK);
}
} else {
if ((ziU8)Zi8MatchROMdata2(elements, count, language, output, capacity,
mode, status, reservedMode, 0, acceptPrefix, ZI_WORK) != 0) {
*output = *elements;
result = 1;
}
}
}
Zi8LogError(100, ZI_WORK);
}
Zi8LogError(100,ZI_WORK);
}
finish_match:
return (ziU8)result;
return result;
}
void Zi8SyllablesROMdata(ziWChar *elements, ziU8 count, ziU8 language, ziWChar *output, ziU16 capacity, ziU8 status, ziU8* prefixLength, ziU8 reverseOrder, ziPtr __zi8_work_data)

View File

@@ -114,173 +114,167 @@ static ziU16 Zi8GetEngineSignature(ziU8* destination, ziPtr work) {
static ziBool Zi8AlphaSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED_WORK) {
ziU16 secondLength;
ziU16 firstLength;
ziU8* second;
ziU8* first;
ziU8 engine[32];
struct { ziU16 length; ziU8* second; ziU8* first; } signatures;
ziU8 dictionary[32];
ziU8 engine[32];
ziU16 length;
ziU16 candidateCount;
ziU8* current;
ziWChar* output = parameters->candidates;
second = 0;
firstLength = 0;
signatures.first = 0;
signatures.second = 0;
signatures.length = 0;
secondLength = 0;
Zi8LogError(100, ZI_WORK);
parameters->letters = 0;
length = Zi8GetDataSignature(dictionary, 0x20, parameters->language, ZI_WORK);
if (length == 0 || length < parameters->elementCount) {
first = engine;
if (length != 0 && parameters->elementCount <= length) {
signatures.first = dictionary;
signatures.second = engine;
signatures.length = length;
} else {
first = dictionary;
second = engine;
firstLength = length;
signatures.first = engine;
}
length = Zi8GetEngineSignature(engine, ZI_WORK);
if (length < parameters->elementCount) {
if (firstLength == 0) {
if (signatures.length != 0) {
signatures.second = 0;
length = 1;
} else {
Zi8ReplaceLastError(500, ZI_WORK);
return 0;
}
second = 0;
candidateCount = 1;
} else if (firstLength == 0) {
candidateCount = 1;
firstLength = length;
} else {
candidateCount = 2;
} else if (signatures.length != 0) {
secondLength = length;
length = 2;
} else {
signatures.length = length;
length = 1;
}
if (parameters->firstCandidate < candidateCount) {
candidateCount -= parameters->firstCandidate;
if (!countOnly) {
if (parameters->maxCandidates < candidateCount) {
candidateCount = parameters->maxCandidates;
}
parameters->letters = candidateCount;
if (!(parameters->getOptions & 0x80)) {
ZI_WORK->unk_0x538 = parameters->language;
parameters->candidates[0] = 0xfff0;
output = (ziWChar*)&ZI_WORK->unk_0x338;
}
if (parameters->firstCandidate != 0) {
first = second;
firstLength = secondLength;
}
if (ZI_WORK->unk_0x0A < firstLength) {
firstLength = ZI_WORK->unk_0x0A;
}
if ((parameters->elementCount < ZI_WORK->unk_0x140C[0] ||
(parameters->getOptions & 0x7e) == 2) &&
parameters->elementCount < firstLength) {
firstLength = parameters->elementCount;
}
while (firstLength-- != 0) {
*output++ = *first++;
}
*output++ = 0;
if (parameters->letters == 2) {
if (ZI_WORK->unk_0x0A < secondLength) {
secondLength = ZI_WORK->unk_0x0A;
}
if ((parameters->elementCount < ZI_WORK->unk_0x140C[0] ||
(parameters->getOptions & 0x7e) == 2) &&
parameters->elementCount < secondLength) {
secondLength = parameters->elementCount;
}
while (secondLength-- != 0) {
*output++ = *second++;
}
*output++ = 0;
}
*output = 0;
ZI_WORK->unk_0x0A = 0xff;
return 1;
}
parameters->letters = candidateCount;
if (parameters->firstCandidate >= length) {
Zi8ReplaceLastError(501, ZI_WORK);
return 0;
}
length = length - parameters->firstCandidate;
if (countOnly != 0) {
parameters->letters = length;
ZI_WORK->unk_0x0A = 0xff;
return 1;
}
Zi8ReplaceLastError(501, ZI_WORK);
return 0;
if (parameters->maxCandidates < length) length = parameters->maxCandidates;
parameters->letters = length;
if ((parameters->getOptions & 0x80) == 0) {
ZI_WORK->unk_0x538 = parameters->language;
parameters->candidates[0] = 0xfff0;
output = (ziWChar*)&ZI_WORK->unk_0x338;
}
if (parameters->firstCandidate != 0) {
current = signatures.second;
length = secondLength;
} else {
current = signatures.first;
length = signatures.length;
}
if (length > ZI_WORK->unk_0x0A) length = ZI_WORK->unk_0x0A;
if ((parameters->elementCount < ZI_WORK->unk_0x140C[0] ||
(parameters->getOptions & 0x7e) == 2) && length > parameters->elementCount) {
length = parameters->elementCount;
}
while (length-- != 0) *output++ = (ziU8)*current++;
*output++ = 0;
if (parameters->letters == 2) {
current = signatures.second;
length = secondLength;
if (length > ZI_WORK->unk_0x0A) length = ZI_WORK->unk_0x0A;
if ((parameters->elementCount < ZI_WORK->unk_0x140C[0] ||
(parameters->getOptions & 0x7e) == 2) && length > parameters->elementCount) {
length = parameters->elementCount;
}
while (length-- != 0) *output++ = (ziU8)*current++;
*output++ = 0;
}
*output++ = 0;
ZI_WORK->unk_0x0A = 0xff;
return 1;
}
static ziBool Zi8ZhSignature(ziGetParam* parameters, ziBool countOnly ZI_NEED_WORK) {
ziWChar* output = parameters->candidates;
ziU8* current = 0;
ziU16 copied;
ziU8 engine[32];
ziU8 dictionary[32];
ziU8 engine[32];
ziU16 dataLength;
ziU32 engineLength;
ziU32 candidateCount;
ziU8 available;
ziU16 engineLength;
ziU16 length;
Zi8LogError(100, ZI_WORK);
parameters->letters = 0;
dataLength = Zi8GetDataSignature(dictionary, 0x20, parameters->language, ZI_WORK);
engineLength = Zi8GetEngineSignature(engine, ZI_WORK);
if (!(parameters->context & 0x10)) {
candidateCount = dataLength + engineLength;
if ((parameters->context & 0x10) != 0) {
length = 0;
if (dataLength != 0) length++;
if (engineLength != 0) length++;
} else {
candidateCount = dataLength != 0;
if (engineLength != 0) candidateCount++;
length = dataLength + engineLength;
}
if (parameters->firstCandidate < candidateCount) {
available = candidateCount - parameters->firstCandidate;
if (!countOnly) {
if (parameters->maxCandidates < (ziU16)(candidateCount - parameters->firstCandidate)) {
available = parameters->maxCandidates;
}
parameters->letters = available;
if (!(parameters->context & 0x10)) {
copied = 0;
if (dataLength != 0) {
if (parameters->firstCandidate < dataLength) {
candidateCount = dataLength - parameters->firstCandidate;
current = dictionary + parameters->firstCandidate;
} else {
candidateCount = 0;
}
if (parameters->letters < candidateCount) candidateCount = parameters->letters;
copied = candidateCount;
while (candidateCount-- != 0) *output++ = *current++;
}
current = engine;
if (dataLength <= parameters->firstCandidate) {
dataLength += engineLength - parameters->firstCandidate;
current += engineLength - dataLength;
engineLength = dataLength;
}
if ((int)(parameters->letters - copied) < (int)engineLength) {
engineLength = parameters->letters - copied;
}
while (engineLength-- != 0) *output++ = *current++;
} else {
if (parameters->firstCandidate == 0 && dataLength != 0) {
current = dictionary;
} else {
if (parameters->firstCandidate != 0 && dataLength == 0) {
Zi8ReplaceLastError(500, ZI_WORK);
return 0;
}
current = engine;
dataLength = engineLength;
}
while (dataLength-- != 0) *output++ = *current++;
*output = 0x20;
if (parameters->letters == 2) {
current = engine;
while (++output, engineLength-- != 0) *output = *current++;
*output = 0x20;
}
}
return 1;
}
parameters->letters = available;
if (parameters->firstCandidate >= length) {
Zi8ReplaceLastError(502, ZI_WORK);
return 0;
}
length = length - parameters->firstCandidate;
if (countOnly != 0) {
parameters->letters = length;
ZI_WORK->unk_0x0A = 0xff;
return 1;
}
Zi8ReplaceLastError(502, ZI_WORK);
return 0;
if (parameters->maxCandidates < length) length = parameters->maxCandidates;
parameters->letters = length;
if ((parameters->context & 0x10) != 0) {
if (parameters->firstCandidate != 0 || dataLength == 0) {
if (parameters->firstCandidate != 0 && dataLength == 0) {
Zi8ReplaceLastError(500, ZI_WORK);
return 0;
}
current = engine;
length = engineLength;
} else {
current = dictionary;
length = dataLength;
}
while (length-- != 0) *output++ = (ziU8)*current++;
*output++ = 0x20;
if (parameters->letters == 2) {
current = engine;
length = engineLength;
while (length-- != 0) *output++ = (ziU8)*current++;
*output++ = 0x20;
}
} else {
copied = 0;
if (dataLength != 0) {
if (parameters->firstCandidate >= dataLength) {
length = 0;
} else {
length = dataLength - parameters->firstCandidate;
current = dictionary + parameters->firstCandidate;
}
if (parameters->letters < length) length = parameters->letters;
copied = length;
while (length-- != 0) *output++ = (ziU8)*current++;
}
current = engine;
if (parameters->firstCandidate >= dataLength) {
length = dataLength + (engineLength - parameters->firstCandidate);
current += engineLength - length;
} else {
length = engineLength;
}
if (parameters->letters - copied < length) length = parameters->letters - copied;
while (length-- != 0) *output++ = (ziU8)*current++;
}
return 1;
}
ziU8 _Zi8GetCandidates(ziGetParam* parameters ZI_NEED_WORK) {
@@ -298,33 +292,37 @@ ziU8 _Zi8CheckCandidates(ziGetParam* parameters ZI_NEED_WORK) {
ziU8 Zi8LangSupported(ziU8 language, ziPtr work);
ziBool Zi8IsCharacter(ziWChar character, ziPtr work);
ziU8 Zi8GetCharInfo(ziWChar character, ziWChar* output, ziU8 capacity, ziU8 type, ziPtr work);
ziU8 Zi8GetKOcandidates(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU8 Zi8GetKoreanCandidates(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU8 Zi8Punctuation(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU8 Zi8GetChineseCandidates(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU8 Zi8Get1KeyPressCandidates(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU8 Zi8Get1KeyPressSpelling(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU8 Zi8GetSyllablesCandidates(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU8 Zi8AlphaGetCandidates(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU32 Zi8GetKOcandidates(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU32 Zi8GetKoreanCandidates(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU32 Zi8Punctuation(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU32 Zi8GetChineseCandidates(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU32 Zi8Get1KeyPressCandidates(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU32 Zi8Get1KeyPressSpelling(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU32 Zi8GetSyllablesCandidates(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU32 Zi8AlphaGetCandidates(ziGetParam* parameters, ziPtr options, ziPtr work);
ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* options ZI_NEED_WORK) {
ziU8 savedElementCount;
ziU16 savedCharacter;
ziWChar* savedElements;
ziBool restoreCandidates;
ziU8 elementCount;
int error;
unsigned int candidateCount;
ziU8 savedOptions;
ziWChar* savedCandidates;
ziU16 characterInfo[16];
ziU16 lastInfoCharacter;
struct {
ziU8 savedGetMode;
ziU8 savedElementCount;
ziU8 convertedElementCount;
ziBool restoreCandidates;
ziU8 savedOptions;
ziU16 savedCharacter;
ziU16 lastInfoCharacter;
ziWChar* savedElements;
ziWChar* savedCandidates;
} saved;
ziU8 outputIndex;
ziU16 error;
unsigned int candidateCount;
error = 0;
savedOptions = 0;
savedCandidates = 0;
restoreCandidates = 0;
saved.savedOptions = 0;
saved.savedCandidates = 0;
saved.restoreCandidates = 0;
if (options->lookupMode == '\0') {
if (((ZI_WORK->unk_0x00 == '\t') && (parameters->elementCount != 0)) &&
(((parameters->elements[parameters->elementCount - 1] == 0xEFF8 &&
@@ -336,13 +334,11 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
parameters->letters = 0;
}
Zi8LogError(100,ZI_WORK);
goto finishCandidates;
return candidateCount;
}
if ((parameters->elementCount == 1) && (parameters->firstCandidate == 0)) {
elementCount = parameters->language;
if (elementCount == 0x11) goto latinSequence;
if (elementCount < 0x11) {
if (elementCount == 1) {
switch (parameters->language) {
case 1:
if ((ZI_WORK->unk_0x00 == '\0') || (ZI_WORK->unk_0x01 == options->countOnly)) {
switch(ZI_WORK->unk_0x00) {
case '\0':
@@ -351,22 +347,22 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
ZI_WORK->unk_0x00 = '\x01';
}
break;
case '\x01':
case '\x03':
case '\x05':
case '\a':
if (parameters->elements[0] == 0xEF01) {
ZI_WORK->unk_0x00 = ZI_WORK->unk_0x00 + '\x01';
case '\x02':
case '\x04':
case '\x06':
if (parameters->elements[0] == 0xEF04) {
++ZI_WORK->unk_0x00;
}
else {
ZI_WORK->unk_0x00 = '\0';
}
break;
case '\x02':
case '\x04':
case '\x06':
if (parameters->elements[0] == 0xEF04) {
ZI_WORK->unk_0x00 = ZI_WORK->unk_0x00 + '\x01';
case '\x01':
case '\x03':
case '\x05':
case '\a':
if (parameters->elements[0] == 0xEF01) {
++ZI_WORK->unk_0x00;
}
else {
ZI_WORK->unk_0x00 = '\0';
@@ -382,7 +378,7 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
parameters->letters = 0;
}
Zi8LogError(100,ZI_WORK);
goto finishCandidates;
return candidateCount;
}
default:
ZI_WORK->unk_0x00 = '\0';
@@ -391,12 +387,19 @@ ziU32 Zi8GetCandidatesOrCount(ziGetParam* parameters, ZiCandidateOptions* option
ZI_WORK->unk_0x00 = '\x01';
}
}
}
else if ((elementCount == 0) || (elementCount < 0x10)) goto latinSequence;
}
else if (elementCount < 0x77) {
if (0x12 < elementCount) {
latinSequence:
break;
case 0x10:
case 0x12:
case 0x77:
case 0x78:
case 0x79:
case 0x7A:
case 0x7B:
case 0x7C:
case 0x7D:
break;
case 0x11:
default:
if ((ZI_WORK->unk_0x00 == '\0') || (ZI_WORK->unk_0x01 == options->countOnly)) {
switch(ZI_WORK->unk_0x00) {
case '\0':
@@ -471,7 +474,7 @@ latinSequence:
parameters->letters = 0;
}
Zi8LogError(100,ZI_WORK);
goto finishCandidates;
return candidateCount;
}
default:
ZI_WORK->unk_0x00 = '\0';
@@ -480,23 +483,21 @@ latinSequence:
ZI_WORK->unk_0x00 = '\x01';
}
}
}
break;
}
else if (0x7d < elementCount) goto latinSequence;
}
else if (1 < parameters->elementCount) {
ZI_WORK->unk_0x00 = '\0';
}
}
ZI_WORK->unk_0x18 = parameters->subLanguage;
elementCount = Zi8GetFormatVersion(1,ZI_WORK);
ZI_WORK->unk_0x16 = elementCount & 2;
ZI_WORK->unk_0x16 = Zi8GetFormatVersion(1,ZI_WORK) & 2;
options->maxCount = ZI_WORK->unk_0x10;
options->maxWordLength = ZI_WORK->unk_0x0A;
ZI_WORK->unk_0x0A = -1;
if ((ziU8)Zi8LangSupported(parameters->language,ZI_WORK) == 0) {
Zi8LogError(0x163,ZI_WORK);
candidateCount = 0;
return 0;
}
else {
if (parameters->language == 0x10) {
@@ -504,7 +505,7 @@ latinSequence:
candidateCount = 0;
}
else if (parameters->language == 0x12) {
if ((parameters->elementCount == 0) || (0xeff0 < parameters->elements[0])) {
if ((parameters->elementCount == 0) || (parameters->elements[0] >= 0xeff1)) {
candidateCount = Zi8GetKOcandidates(parameters,options,ZI_WORK);
}
else {
@@ -518,29 +519,27 @@ latinSequence:
else if ((parameters->language == 1) &&
((((parameters->getOptions & 0xbf) == 4 && (parameters->elementCount != 0)) &&
((ziU8)Zi8IsCharacter(parameters->elements[0],ZI_WORK) != 0)))) {
elementCount = Zi8GetCharInfo(parameters->elements[0],characterInfo,0x10,1,ZI_WORK);
if (elementCount == 0) {
parameters->unk_0x20 = 0;
parameters->count = 0;
parameters->letters = 0;
saved.convertedElementCount = Zi8GetCharInfo(parameters->elements[0],characterInfo,0x10,1,ZI_WORK);
if (saved.convertedElementCount == 0) {
parameters->letters = parameters->count = parameters->unk_0x20 = 0;
candidateCount = 0;
error = 900;
}
else {
lastInfoCharacter = characterInfo[elementCount - 1];
if ((0xf330 < lastInfoCharacter) && (lastInfoCharacter < 0xf336)) {
characterInfo[elementCount - 1] = 0xf360;
saved.lastInfoCharacter = characterInfo[saved.convertedElementCount - 1];
if ((saved.lastInfoCharacter >= 0xf331) && (saved.lastInfoCharacter <= 0xf335)) {
characterInfo[saved.convertedElementCount - 1] = 0xf360;
}
savedElements = parameters->elements;
saved.savedElements = parameters->elements;
parameters->elements = characterInfo;
savedElementCount = parameters->elementCount;
parameters->elementCount = elementCount;
elementCount = parameters->getMode;
saved.savedElementCount = parameters->elementCount;
parameters->elementCount = saved.convertedElementCount;
saved.savedGetMode = parameters->getMode;
parameters->getMode = 1;
candidateCount = Zi8GetChineseCandidates(parameters,options,ZI_WORK);
parameters->elements = savedElements;
parameters->elementCount = savedElementCount;
parameters->getMode = elementCount;
parameters->elements = saved.savedElements;
parameters->elementCount = saved.savedElementCount;
parameters->getMode = saved.savedGetMode;
parameters->count = 1;
}
}
@@ -549,27 +548,22 @@ latinSequence:
candidateCount = 0;
}
else if ((parameters->language == 1) && ((parameters->getMode == 3 || (parameters->getMode == 4)))) {
if ((parameters->getOptions & 0x80) == 0) {
if (parameters->elementCount == 0) {
candidateCount = Zi8GetChineseCandidates(parameters,options,ZI_WORK);
}
else {
candidateCount = Zi8Get1KeyPressCandidates(parameters,options,ZI_WORK);
}
}
else {
if ((parameters->getOptions & 0x80) != 0) {
candidateCount = Zi8Get1KeyPressSpelling(parameters,options,ZI_WORK);
} else if (parameters->elementCount == 0) {
candidateCount = Zi8GetChineseCandidates(parameters,options,ZI_WORK);
} else {
candidateCount = Zi8Get1KeyPressCandidates(parameters,options,ZI_WORK);
}
}
else if ((parameters->language == 1) &&
((((parameters->getMode == 7 || (parameters->getMode == 8)) || (parameters->getMode == 10)) || (parameters->getMode == 9)))) {
if (ZI_WORK->unk_0x16 == '\0') {
if (ZI_WORK->unk_0x16 != '\0') {
candidateCount = Zi8GetChineseCandidates(parameters,options,ZI_WORK);
} else {
error = 0x708;
candidateCount = 0;
}
else {
candidateCount = Zi8GetChineseCandidates(parameters,options,ZI_WORK);
}
}
else if ((parameters->language == 1) && ((parameters->getMode == 0xb || (parameters->getMode == 0xe)))) {
error = 0x2ee;
@@ -581,52 +575,45 @@ latinSequence:
&& (((parameters->elements[parameters->elementCount - 1] == 0xF37A ||
(parameters->elements[parameters->elementCount - 1] == 0xF363)) ||
(parameters->elements[parameters->elementCount - 1] == 0xF373)))) {
savedCharacter = parameters->elements[parameters->elementCount];
elementCount = parameters->elementCount;
parameters->elements[elementCount] = 0xf368;
parameters->elementCount = elementCount + 1;
saved.savedCharacter = parameters->elements[parameters->elementCount];
parameters->elements[parameters->elementCount++] = 0xf368;
candidateCount = Zi8GetChineseCandidates(parameters,options,ZI_WORK);
elementCount = parameters->elementCount;
parameters->elementCount = elementCount - 1;
parameters->elements[(ziU8)(elementCount - 1)] = savedCharacter;
parameters->elements[--parameters->elementCount] = saved.savedCharacter;
}
}
else {
ZI_WORK->unk_0x538 = parameters->language;
restoreCandidates = (parameters->getOptions & 0x80) == 0;
if (restoreCandidates) {
savedOptions = parameters->getOptions;
savedCandidates = parameters->candidates;
parameters->getOptions = parameters->getOptions | 0x81;
if ((parameters->getOptions & 0x80) == 0) {
saved.restoreCandidates = 1;
saved.savedOptions = parameters->getOptions;
saved.savedCandidates = parameters->candidates;
parameters->getOptions |= 0x81;
parameters->candidates = (ziWChar*)&ZI_WORK->unk_0x338;
options->capacity = 0x100;
}
if (parameters->getMode == 2) {
candidateCount = Zi8GetTableCount(parameters->language,0x1f,ZI_WORK);
if ((candidateCount & 0x200) == 0) {
if ((Zi8GetTableCount(parameters->language,0x1f,ZI_WORK) & 0x200) != 0) {
candidateCount = Zi8GetSyllablesCandidates(parameters,options,ZI_WORK);
} else {
error = 0x44c;
candidateCount = 0;
}
else {
candidateCount = Zi8GetSyllablesCandidates(parameters,options,ZI_WORK);
}
}
else {
candidateCount = Zi8AlphaGetCandidates(parameters,options,ZI_WORK);
}
}
if (restoreCandidates) {
parameters->getOptions = savedOptions;
parameters->candidates = savedCandidates;
for (elementCount = 0; elementCount < parameters->letters; elementCount = elementCount + 1) {
parameters->candidates[elementCount] = elementCount - 0x10;
if (saved.restoreCandidates) {
parameters->getOptions = saved.savedOptions;
parameters->candidates = saved.savedCandidates;
for (outputIndex = 0; outputIndex < parameters->letters; outputIndex++) {
parameters->candidates[outputIndex] = 0xFFF0 + outputIndex;
}
}
if (error != 0) {
Zi8LogError(error,ZI_WORK);
}
}
finishCandidates:
return candidateCount;
}
@@ -665,9 +652,8 @@ ziBool Zi8IsDupWChar(ziWChar character ZI_NEED_WORK) {
}
ziBool Zi8IsDupWordW(ziWChar* word, ziU8 length ZI_NEED_WORK) {
ziU8 slot;
unsigned int slot;
ziBool duplicate = 0;
unsigned int position;
int index;
int character;
if (word == 0 || length == 0) {
@@ -681,21 +667,19 @@ ziBool Zi8IsDupWordW(ziWChar* word, ziU8 length ZI_NEED_WORK) {
for (index = 0; index < ZI_WORK->unk_0x539; index++) {
slot = ZI_WORK->unk_0x53A[index];
for (character = 0; character < length; character++) {
if (word[character] != ZI_WORK->unk_0x57A[slot * 21 + character]) break;
if (word[character] != ((ziWChar (*)[21])ZI_WORK->unk_0x57A)[slot][character]) break;
}
if (character >= length && ZI_WORK->unk_0x57A[slot * 21 + character] == 0) {
if (character >= length && ((ziWChar (*)[21])ZI_WORK->unk_0x57A)[slot][character] == 0) {
duplicate = 1;
break;
}
}
if (!duplicate) {
if (ZI_WORK->unk_0x539 < 64) {
position = ZI_WORK->unk_0x539;
ZI_WORK->unk_0x53A[ZI_WORK->unk_0x539] = ZI_WORK->unk_0x539;
slot = ZI_WORK->unk_0x53A[ZI_WORK->unk_0x539] = ZI_WORK->unk_0x539;
ZI_WORK->unk_0x539++;
} else {
slot = ZI_WORK->unk_0x53A[0];
position = slot;
for (index = 1; index < ZI_WORK->unk_0x539; index++) {
ZI_WORK->unk_0x53A[index - 1] = ZI_WORK->unk_0x53A[index];
}
@@ -703,16 +687,15 @@ ziBool Zi8IsDupWordW(ziWChar* word, ziU8 length ZI_NEED_WORK) {
}
} else {
slot = ZI_WORK->unk_0x53A[index];
position = slot;
for (; index < ZI_WORK->unk_0x539 - 1; index++) {
ZI_WORK->unk_0x53A[index] = ZI_WORK->unk_0x53A[index + 1];
}
ZI_WORK->unk_0x53A[index] = slot;
}
for (index = 0; index < length; index++) {
ZI_WORK->unk_0x57A[position * 21 + index] = word[index];
for (character = 0; character < length; character++) {
((ziWChar (*)[21])ZI_WORK->unk_0x57A)[slot][character] = word[character];
}
ZI_WORK->unk_0x57A[position * 21 + index] = 0;
((ziWChar (*)[21])ZI_WORK->unk_0x57A)[slot][character] = 0;
Zi8LogError(100, ZI_WORK);
return duplicate;
}

View File

@@ -289,139 +289,151 @@ ziBool Zi8SecMatchComp(ziPtr nodeAddress, ziMatchParam* matchAddress, ziPtr dict
extern ziU16 Zi8MatchAltSound(ziPtr soundTable, ziU16 soundCode, ziPtr pCodeTable, ziU16 index, ziU16 mask, ziU16 value, ziU8 flag ZI_NEED_WORK);
ziU16 Zi8GetPCode(ziU8* table, ziU8* node);
ziBool Zi8MatchPhonetic(ziPtr pCodeTable, ziPtr dictionary, ziPtr soundTable, ziU16 soundCode, ziU32 tableAddress, ziU8* node, ziU16* masks, ziU16* values, ziU16* count, ziU8** resultNode, ziU8** stringOffset, ziS8 partialMode, ziU8 strictMode, ziU8 numParts, ziU16 partMask, ziU16 partValue, ziU8 flag, ziU8 altMode, ziU16 initialCode, ziU16* resultCode, ziU8 lastMode ZI_NEED_WORK) {
ziBool hasString;
ziU32 matchedParts;
ziU32 altModeActive;
ziU8 partCode;
ziU8 partCount;
ziU8 partIndex;
ziU16 soundIndex;
ziU16 remaining;
ziU16 code;
ziU16 dictionaryIndex;
ziU8 nextCode;
ziBool Zi8MatchPhonetic(ziPtr pCodeTable, ziU8* dictionary, ziPtr soundTable, ziU16 soundCode, ziU32 tableAddress, ziU8* node, ziU16* masks, ziU16* values, ziU16* count, ziU8** resultNode, ziU8** stringOffset, ziU8 partialMode, ziU8 strictMode, ziU8 numParts, ziU16 partMask, ziU16 partValue, ziU8 flag, ziU8 altMode, ziU16 initialCode, ziU16* resultCode, ziU8 lastMode ZI_NEED_WORK) {
struct {
ziBool hasString;
ziU8 partIndex;
ziU8 partCount;
ziU8 nextCode;
ziU8 matchedParts;
ziU16 dictionaryIndex;
ziU16 soundIndex;
ziU16 remaining;
ziU16 code;
} traversal;
ziU8* sound;
ziU8* nextPart;
typedef struct {
ziU8 header;
ziU8 content[11];
} DictionaryNode;
if (*stringOffset != 0) {
hasString = 1;
traversal.hasString = 1;
} else {
hasString = 0;
traversal.hasString = 0;
}
if (*count == 0) {
remaining = 1;
if (*count != 0) {
traversal.remaining = *count;
} else {
remaining = *count;
traversal.remaining = 1;
}
matchedParts = 0;
altModeActive = altMode;
traversal.matchedParts = 0;
if ((lastMode != 0) && (numParts > 1)) {
altModeActive = 1;
altMode = 1;
}
while (remaining-- != 0) {
if ((node[0] & flag) != 0) {
code = Zi8GetPCode((ziU8*)pCodeTable, node);
if ((*values != (code & *masks)) && (altModeActive == 0) && ((node[0] & 0x80) != 0)) {
if (*count != 0) {
soundIndex = (initialCode - remaining) - 1;
} else {
soundIndex = initialCode;
}
code = Zi8MatchAltSound(soundTable, soundCode, pCodeTable, soundIndex, *masks, *values, flag, ZI_WORK);
}
if ((*values == (code & *masks)) && (partValue != (code & partMask))) {
matchedParts = 1;
sound = (ziU8*)((tableAddress + ((node[9] & 0xF) * 0x10000)) + node[0xB] + node[0xA] * 0x100);
if (ZI_WORK->unk_0x16 != 0) {
switch (sound[0] & 7) {
case 2:
sound += 2;
break;
case 3:
case 4:
sound += 3;
break;
case 5:
sound += 4;
break;
default:
sound++;
break;
}
}
if ((sound[0] & 0x80) != 0) {
sound += ((sound[0] & 0x7F) >> 4) + 1;
} else if (numParts > 1) {
goto next_node;
}
if (((ziU8)matchedParts == numParts) || (numParts == 0)) {
*resultNode = node;
*resultCode = ((ziU16)node[6] << 8) + node[7];
*count = remaining;
return 1;
}
do {
nextCode = *sound++;
partCount = nextCode & 0xF;
if ((nextCode & flag) == 0) {
for (; partCount != 0; partCount--) {
for (sound++; (*sound & 0x80) == 0; sound += 2) {
}
sound++;
}
}
for (; partCount != 0; partCount--) {
partIndex = 1;
if (hasString && (*stringOffset < sound)) {
hasString = 0;
}
nextPart = sound;
if (!hasString) {
*stringOffset = sound;
}
do {
partCode = nextPart[1];
dictionaryIndex = ((ziU16)partCode << 8) | nextPart[0];
sound = nextPart + 2;
if (hasString) {
goto phonetic_skip;
}
code = Zi8GetPCode((ziU8*)pCodeTable, (ziU8*)dictionary + (dictionaryIndex & 0x7FFF) * 0xC);
if (((code & masks[partIndex]) != values[partIndex]) && (altModeActive == 0) && (((ziU8*)dictionary)[(dictionaryIndex & 0x7FFF) * 0xC] & 0x80) != 0) {
code = Zi8MatchAltSound(soundTable, soundCode, pCodeTable, dictionaryIndex & 0x7FFF, masks[partIndex], values[partIndex], flag, ZI_WORK);
}
if ((code & masks[partIndex]) != values[partIndex]) {
goto phonetic_skip;
}
partIndex++;
if (partIndex == numParts) {
if ((partialMode != 0) && ((strictMode == 0 && (partCode & 0x80) != 0) || (strictMode != 0 && (partCode & 0x80) == 0))) {
goto phonetic_skip;
}
*resultNode = node;
code = ((ziU16)node[6] << 8) + node[7];
*resultCode = code;
*count = remaining;
return 1;
}
nextPart = sound;
} while ((partCode & 0x80) == 0);
continue;
phonetic_skip:
if ((partCode & 0x80) == 0) {
nextPart += 3;
while ((*nextPart & 0x80) == 0) {
nextPart += 2;
}
sound = nextPart + 1;
}
}
} while ((nextCode & 0x80) == 0);
}
}
while (traversal.remaining-- != 0) {
if ((node[0] & flag) != 0) goto decode_node;
next_node:
node += 0xC;
continue;
decode_node:
traversal.code = Zi8GetPCode((ziU8*)pCodeTable, node);
if ((*values != (traversal.code & *masks)) && (altMode == 0) && ((node[0] & 0x80) != 0)) {
if (*count != 0) {
traversal.soundIndex = (initialCode - traversal.remaining) - 1;
} else {
traversal.soundIndex = initialCode;
}
traversal.code = Zi8MatchAltSound(soundTable, soundCode, pCodeTable, traversal.soundIndex, *masks, *values, flag, ZI_WORK);
}
goto check_code;
match_code:
if (partValue == (traversal.code & partMask)) goto next_node;
traversal.matchedParts = 1;
if (*count != 0) {
traversal.soundIndex = (initialCode - traversal.remaining) - 1;
} else {
traversal.soundIndex = initialCode;
}
sound = (ziU8*)(tableAddress + ((node[9] & 0xF) * 0x10000 + (node[0xB] + node[0xA] * 0x100)));
if (ZI_WORK->unk_0x16 != 0) {
switch (sound[0] & 7) {
case 2:
sound += 2;
break;
case 3:
case 4:
sound += 3;
break;
case 5:
sound += 4;
break;
default:
sound++;
break;
}
}
if ((sound[0] & 0x80) != 0) {
sound += ((sound[0] & 0x7F) >> 4) + 1;
} else if (numParts > 1) {
goto next_node;
}
if (((ziU8)traversal.matchedParts == numParts) || (numParts == 0)) {
*resultNode = node;
*resultCode = ((ziU16)node[6] << 8) + node[7];
*count = traversal.remaining;
return 1;
}
next_group:
{
traversal.nextCode = *sound++;
traversal.partCount = traversal.nextCode & 0xF;
if ((traversal.nextCode & flag) == 0) {
for (; traversal.partCount != 0; traversal.partCount--) {
for (sound++; (*sound & 0x80) == 0; sound += 2) {
}
sound++;
}
}
for (; traversal.partCount != 0; traversal.partCount--) {
traversal.partIndex = 1;
if (traversal.hasString && (sound > *stringOffset)) {
traversal.hasString = 0;
}
if (!traversal.hasString) {
*stringOffset = sound;
}
do {
traversal.dictionaryIndex = sound[0] | ((ziU16)sound[1] << 8);
sound += 2;
if (traversal.hasString) {
goto phonetic_skip;
}
traversal.code = Zi8GetPCode((ziU8*)pCodeTable, dictionary + (traversal.dictionaryIndex & 0x7FFF) * sizeof(DictionaryNode));
if (((traversal.code & masks[traversal.partIndex]) != values[traversal.partIndex]) && (altMode == 0) && (dictionary[(traversal.dictionaryIndex & 0x7FFF) * sizeof(DictionaryNode)] & 0x80) != 0) {
traversal.code = Zi8MatchAltSound(soundTable, soundCode, pCodeTable, traversal.dictionaryIndex & 0x7FFF, masks[traversal.partIndex], values[traversal.partIndex], flag, ZI_WORK);
}
if ((traversal.code & masks[traversal.partIndex]) == values[traversal.partIndex]) {
goto phonetic_matched;
}
phonetic_skip:
if ((traversal.dictionaryIndex & 0x8000) == 0) {
sound++;
while ((*sound & 0x80) == 0) {
sound += 2;
}
sound++;
}
break;
phonetic_matched:
if (++traversal.partIndex == numParts) {
if (partialMode != 0) {
if (strictMode == 0 && (traversal.dictionaryIndex & 0x8000) != 0) goto phonetic_skip;
if (strictMode != 0 && (traversal.dictionaryIndex & 0x8000) == 0) goto phonetic_skip;
}
*resultNode = node;
*resultCode = ((ziU16)node[6] << 8) + node[7];
*count = traversal.remaining;
return 1;
}
} while ((traversal.dictionaryIndex & 0x8000) == 0);
}
}
if ((traversal.nextCode & 0x80) != 0) goto next_node;
goto next_group;
check_code:
if (*values == (traversal.code & *masks)) goto match_code;
goto next_node;
}
return 0;
}
@@ -429,46 +441,45 @@ next_node:
ziBool Zi8GetPyFinal(ziU8* pinyin, ziU8* initial, ziU8* final);
ziU8 Zi8GetPyPhonetic(ziWChar* text, ziU8 count, ziU16* initial, ziU16* final, ziU8* resultCount, ziU16* bestInitial, ziU16* bestFinal ZI_NEED_WORK) {
ziU8 firstInitial;
ziU8 pyFinal;
ziU8 pyInitial;
ziU8 pyFinal;
ziU8 convertedCount;
ziBool partial;
ziU8 result;
ziBool partial;
ziBool alternateInitial;
ziU8 outputIndex;
ziU8 partCount;
ziU16 value;
ziU8 index;
ziU16 value;
ziWChar converted[256];
ziWChar* current;
ziU8 pinyin[12];
ziWChar* current;
current = converted;
alternateInitial = 0;
result = 0;
*resultCount = 0;
if (count == 0) {
Zi8LogError(0x135, ZI_WORK);
return 0;
}
convertedCount = 0;
for (index = 0; index < count; index++) {
index = 0;
convertedCount = index;
for (; index < count; index++) {
if (((text[index] >= 0xF341) && (text[index] <= 0xF35A)) || ((text[index] >= 0x41) && (text[index] <= 0x5A))) {
if ((convertedCount != 0) && (current[convertedCount - 1] != 0xF360) && (current[convertedCount - 1] != 0x27)) {
current[convertedCount] = 0x27;
convertedCount++;
current[convertedCount++] = 0x27;
}
current[convertedCount] = (text[index] & 0xFF) + 0x20;
current[convertedCount++] = (text[index] & 0xFF) + 0x20;
} else {
current[convertedCount] = text[index];
current[convertedCount++] = text[index];
}
convertedCount++;
}
count = convertedCount;
outputIndex = 0;
*bestInitial = 0;
*bestFinal = 0;
while ((outputIndex < 0x10) && (count != 0)) {
while (count != 0) {
initial[outputIndex] = 0;
final[outputIndex] = 0;
value = *current;
@@ -482,41 +493,44 @@ check_pinyin_extension:
if (value < 0xF361) {
goto invalid_pinyin;
}
if (value <= 0xF37A) {
value += 0xC9F;
goto pinyin_initial;
}
if (value <= 0xF37A) goto pinyin_extension;
invalid_pinyin:
initial[0] = 0xFFFF;
final[0] = 0xFFFF;
*bestInitial = 0xFFFF;
*bestFinal = 0xFFFF;
*bestInitial = *bestFinal = initial[0] = final[0] = 0xFFFF;
return 1;
pinyin_extension:
value -= 0xF361;
goto pinyin_initial;
pinyin_ascii:
value -= 0x61;
pinyin_initial:
firstInitial = Zi8PinyinInitials[value];
if (firstInitial != 0) {
convertedCount = Zi8PinyinInitials[value];
if (convertedCount != 0) {
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
}
result++;
initial[outputIndex] = 0x7E00;
final[outputIndex] = (ziU16)firstInitial << 9;
*bestInitial = initial[outputIndex];
*bestFinal = final[outputIndex];
final[outputIndex] = (ziU16)(convertedCount & 0x7f) << 9;
*bestInitial = initial[0];
*bestFinal = final[0];
count--;
if (count == 0) {
break;
}
current += 1;
if (((firstInitial & 0x80) != 0) && ((current[0] == 0x68) || (current[0] == 0xF368))) {
if ((convertedCount & 0x80) != 0) {
if (alternateInitial) {
initial[outputIndex] &= 0xfdff;
final[outputIndex] &= 0xfdff;
}
value = *current;
if (value != 0x68 && value != 0xF368) goto scan_final;
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
}
final[outputIndex] += 0x200;
*bestInitial = initial[outputIndex];
*bestFinal = final[outputIndex];
*bestInitial = initial[0];
*bestFinal = final[0];
count--;
if (count == 0) {
break;
@@ -526,80 +540,80 @@ pinyin_initial:
} else if ((*current == 0xF369) || (*current == 0x69)) {
goto invalid_pinyin;
}
scan_final:
partial = 0;
for (index = 0; index < 4; index++) {
pinyin[index] = 0;
}
index = 0;
do {
while (1) {
if (index > 3) {
goto finish_final;
}
value = *current;
if ((value == 0x27) || (value == 0xF360) || (value == 0x20)) {
if (index != 0) {
partial = 1;
}
goto finish_final;
}
if ((value > 0xF330) && (value < 0xF336)) {
if (index != 0) {
partial = 1;
}
goto finish_final;
}
if ((value < 0x61) || (value > 0x7A)) {
if (value < 0xF361) {
goto finish_final;
}
value += 0xC9F;
if (value > 0x19) {
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
}
goto finish_final;
}
} else {
value -= 0x61;
}
pinyin[index] = (ziU8)value + 1;
if (Zi8GetPyFinal(pinyin, &pyInitial, &pyFinal) == 0) {
break;
}
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
}
current++;
index++;
count--;
if (count == 0) {
goto finish_final;
while (index < 4) {
value = *current;
if ((value == 0x27) || (value == 0xF360) || (value == 0x20)) {
if (index != 0) {
partial = 1;
}
goto finish_final;
}
if (index > 2) {
pinyin[index] = 0;
partial = 1;
break;
if ((value >= 0xF331) && (value < 0xF336)) {
if (index != 0) {
partial = 1;
}
goto finish_final;
}
pinyin[index + 1] = 0xFF;
if (Zi8GetPyFinal(pinyin, &pyInitial, &pyFinal) == 0) {
pinyin[index + 1] = 0;
pinyin[index] = 0;
partial = 1;
break;
if ((value < 0x61) || (value > 0x7A)) {
if (value < 0xF361) {
goto finish_final;
}
value -= 0xF361;
if (value > 0x19) {
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
}
goto finish_final;
}
} else {
value -= 0x61;
}
pinyin[index] = (ziU8)value + 1;
if (Zi8GetPyFinal(pinyin, &pyInitial, &pyFinal) == 0) goto try_final_extension;
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
}
pinyin[index + 1] = 0;
current++;
index++;
count--;
} while (count != 0);
if (count == 0) {
goto finish_final;
}
continue;
try_final_extension:
if (index < 3) {
pinyin[index + 1] = 0xFF;
if (Zi8GetPyFinal(pinyin, &pyInitial, &pyFinal) != 0) {
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
}
pinyin[index + 1] = 0;
current++;
index++;
count--;
if (count == 0) break;
} else {
pinyin[index + 1] = 0;
pinyin[index] = 0;
partial = 1;
break;
}
} else {
pinyin[index] = 0;
partial = 1;
break;
}
}
finish_final:
if ((index > 3) && (count != 0) && ((*current == 0x27) || (*current == 0xF360) || (*current == 0x20))) {
if ((index > 3) && (count != 0) && (((value = *current) == 0x27) || (value == 0xF360) || (value == 0x20))) {
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
}
@@ -609,35 +623,38 @@ finish_final:
if (index > 3) {
partial = 1;
}
if (!partial) {
pinyin[index] = 0xFF;
if (Zi8GetPyFinal(pinyin, &pyInitial, &pyFinal) == 0) {
pinyin[index] = 0;
if (Zi8GetPyFinal(pinyin, &pyInitial, &pyFinal) != 0) {
if (firstInitial == 0) {
result++;
initial[outputIndex] = 0x7E00;
final[outputIndex] = 0x200;
}
initial[outputIndex] |= (ziU16)pyInitial << 3;
final[outputIndex] |= (ziU16)pyFinal << 3;
*bestInitial = initial[outputIndex];
*bestFinal = final[outputIndex];
}
} else {
if (firstInitial == 0) {
if (partial && alternateInitial == 0) {
if (Zi8GetPyFinal(pinyin, &pyInitial, &pyFinal) != 0) {
if (convertedCount == 0) {
result++;
initial[outputIndex] = 0x7E00;
final[outputIndex] = 0x200;
}
initial[outputIndex] |= (ziU16)pyInitial << 3;
final[outputIndex] |= (ziU16)pyFinal << 3;
*bestInitial = initial[outputIndex];
*bestFinal = final[outputIndex];
*bestInitial = initial[0];
*bestFinal = final[0];
} else {
if ((index != 0) && (count != 0)) {
goto invalid_pinyin;
}
}
} else {
pinyin[index] = 0xFF;
if (Zi8GetPyFinal(pinyin, &pyInitial, &pyFinal) != 0) {
if (convertedCount == 0) {
result++;
initial[outputIndex] = 0x7E00;
final[outputIndex] = 0x200;
}
initial[outputIndex] |= (ziU16)pyInitial << 3;
final[outputIndex] |= (ziU16)pyFinal << 3;
*bestInitial = initial[0];
*bestFinal = final[0];
if ((outputIndex == 0) && (count == 0)) {
pinyin[index] = 0;
if (Zi8GetPyFinal(pinyin, &pyInitial, &pyFinal) != 0) {
if (firstInitial == 0) {
if (convertedCount == 0) {
*bestInitial = 0x7E00;
*bestFinal = 0x200;
}
@@ -645,45 +662,42 @@ finish_final:
*bestFinal |= (ziU16)pyFinal << 3;
}
}
}
} else {
if (Zi8GetPyFinal(pinyin, &pyInitial, &pyFinal) != 0) {
if (firstInitial == 0) {
result++;
initial[outputIndex] = 0x7E00;
final[outputIndex] = 0x200;
}
initial[outputIndex] |= (ziU16)pyInitial << 3;
final[outputIndex] |= (ziU16)pyFinal << 3;
*bestInitial = initial[outputIndex];
*bestFinal = final[outputIndex];
} else {
if ((index != 0) && (count != 0)) {
goto invalid_pinyin;
pinyin[index] = 0;
if (Zi8GetPyFinal(pinyin, &pyInitial, &pyFinal) != 0) {
if (convertedCount == 0) {
result++;
initial[outputIndex] = 0x7E00;
final[outputIndex] = 0x200;
}
initial[outputIndex] |= (ziU16)pyInitial << 3;
final[outputIndex] |= (ziU16)pyFinal << 3;
*bestInitial = initial[0];
*bestFinal = final[0];
}
}
}
convertedCount = count;
}
if (count != 0) {
value = *current;
if ((value == 0x27) || (value == 0xF360) || (value == 0x20)) {
current++;
convertedCount = count - 1;
count--;
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
}
} else if ((value > 0xF330) && ((ziU16)(value + 0xCCF) < 5)) {
} else if ((value >= 0xF331) && ((value -= 0xF331) <= 4)) {
value++;
initial[outputIndex] |= 7;
final[outputIndex] |= value + 0xCD0;
*bestInitial = initial[outputIndex];
*bestFinal = final[outputIndex];
convertedCount = count - 1;
final[outputIndex] |= value;
*bestInitial = initial[0];
*bestFinal = final[0];
count--;
current++;
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
}
if ((convertedCount != 0) && ((*current == 0x27) || (*current == 0xF360) || (*current == 0x20))) {
convertedCount = count - 2;
if ((count != 0) && (((value = *current) == 0x27) || (value == 0xF360) || (value == 0x20))) {
count--;
current++;
if (outputIndex == 0) {
*resultCount = *resultCount + 1;
@@ -691,10 +705,10 @@ finish_final:
}
}
}
count = convertedCount;
outputIndex++;
if (outputIndex > 0xf) break;
}
if ((*resultCount > 1) && (text[*resultCount - 1] > 0xF340) && (text[*resultCount - 1] < 0xF35B)) {
if ((result > 1) && (text[*resultCount - 1] >= 0xF341) && (text[*resultCount - 1] <= 0xF35A)) {
*resultCount = *resultCount - 1;
}
return result;

View File

@@ -0,0 +1,184 @@
#include <stddef.h>
#include <zi8clib/zitypes.h>
#include <zi8clib/zierror.h>
#include <zi8clib/zconvert.h>
#include <zi8clib/zmtkey.h>
typedef struct ziPudSection {
ziU8 flags;
ziU8 language;
ziU8 offset[2];
ziU8 count[2];
ziU8 reserved[2];
} ziPudSection;
typedef struct ziPudHeader {
ziU8 format[3];
ziU8 languageCount;
ziU8 options[4];
ziPudSection sections[1];
} ziPudHeader;
ziU32 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;
return 1;
}
int ZiGetZHWordSize(ziWChar* word, int size) {
int bytes;
ziWChar* cursor;
bytes = 0;
for (bytes = 0; bytes < size;) {
cursor = word;
if (ZiIsPhoneticChar(*cursor)) return bytes;
bytes += 2;
word++;
}
return bytes;
}
void Zi8CopyZHSpelling(ziU8* source, ziWChar* output, ziU16 capacity, int size, int start) {
int offset;
ziU8* cursor;
if (output != 0 && capacity != 0) {
*output = 0;
if (size > start) {
for (offset = 0; offset < size - start && offset < (int)((ziU32)capacity << 1); offset += 2) {
cursor = source + start + offset;
*output++ = *(ziWChar*)cursor;
}
*output = 0;
}
}
}
ziU8 ZADP_Zi8SetPDremoveOpt(ziU8 option ZI_NEED_WORK) {
ziU8 previous;
previous = ZI_WORK->pdRemoveOpt;
ZI_WORK->pdRemoveOpt = option;
Zi8LogError(100, __zi8_work_data);
return previous;
}
ziU32 Zi8MatchPUDdata_ZHS(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziWChar* spelling, ziU16 spellingCapacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
ziWChar folded;
ziU32 entrySize, wordSize, copied;
ziU8* entry;
ziU8* word;
int index;
int fallback = 0;
ziPudHeader* table;
ziPudSection* section;
if (!(ZI_WORK->pudCount <= 16 && ZI_WORK->pudCount != 0 && ZI_WORK->pudTable[ZI_WORK->pudCount - 1] != 0)) {
Zi8LogError(0x4B0, __zi8_work_data);
return 0;
}
if (language == 1) {
length &= 0x7F;
length *= 2;
}
if (continuation == 0) {
table = (ziPudHeader*)ZI_WORK->pudTable[ZI_WORK->pudCount - 1];
index = 0;
section = table->sections;
while (index < table->languageCount && section->language != language) {
index++;
section++;
}
if (table->languageCount <= index) {
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_0x318 = 0;
}
for (;;) {
entry = (ziU8*)ZI_WORK->unk_0x310;
if (entry == 0) {
Zi8LogError(0x4B3, __zi8_work_data);
return 0;
}
while ((ziS32)ZI_WORK->unk_0x318 < (ziS32)ZI_WORK->unk_0x314) {
word = entry + 1;
wordSize = *entry;
entrySize = wordSize;
if (language == 1) {
if (*word < ZI_WORK->unk_0x17) goto next;
entrySize = wordSize - 1;
word = entry + 2;
wordSize = ZiGetZHWordSize((ziWChar*)word, entrySize);
} else if (ZI_WORK->unk_0x31E != 0 && complete != 0 && wordSize > length && word[length] == 0x20) goto matchText;
if ((ziS32)length > (ziS32)wordSize || (complete != 0 && wordSize != length) || (complete == 0 && wordSize == length)) goto next;
if (language == 1) {
for (index = 0; index < length; index++) {
if (word[index] != ((ziU8*)pattern)[index]) goto next;
}
goto matched;
}
matchText:
for (index = 0; index < length; index++) {
if (pattern[index] < 0xEFF1 || pattern[index] > 0xF37F) {
folded = Zi8ConvertUC2WC(word[index], language, __zi8_work_data);
if (folded != pattern[index] && (!ZI_WORK->unk_0x1F || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[index])) goto next;
} else if (pattern[index] != Zi8ConvertUC2Key(word[index], language, __zi8_work_data)) goto next;
}
matched:
if (fallback) {
ZI_WORK->unk_0x310 = 0;
ZI_WORK->unk_0x318 = 0;
ZI_WORK->unk_0x314 = 0;
if (*pattern < 0xEFF1) *output = Zi8ConvertWC2Key(*pattern, language, __zi8_work_data);
else *output = *pattern;
return 1;
}
if (language == 1) {
index = 0;
for (copied = 0; index < (ziS32)wordSize && copied < capacity; copied++) {
((ziU8*)output)[index] = word[index];
((ziU8*)output)[index + 1] = word[index + 1];
index += 2;
}
Zi8CopyZHSpelling(word, spelling, spellingCapacity, entrySize, wordSize);
} else {
for (copied = 0; copied < wordSize && copied < capacity; copied++) {
output[copied] = Zi8ConvertUC2WC(word[copied], language, __zi8_work_data);
if (ZI_WORK->unk_0x31E != 0 && copied >= length && output[copied] == 0x20) {
if (complete != 0 || copied >= length) break;
goto next;
}
}
}
ZI_WORK->unk_0x318++;
ZI_WORK->unk_0x310 = (ziU32)(word + entrySize);
Zi8LogError(100, __zi8_work_data);
return (ziU8)copied;
next:
ZI_WORK->unk_0x318++;
entry = word + entrySize;
}
if (length != 1 || complete == 0 || continuation != 0) {
ZI_WORK->unk_0x310 = 0;
ZI_WORK->unk_0x318 = 0;
ZI_WORK->unk_0x314 = 0;
return 0;
}
complete = 0;
fallback = 1;
ZI_WORK->unk_0x318 = 0;
}
}
ziU32 Zi8MatchPUDdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
ziU32 result;
if (continuation == 0) ZI_WORK->pudCount = 1;
for (;;) {
result = Zi8_8147FD7C(pattern, length, language, output, capacity, complete, continuation, __zi8_work_data);
if ((ziU8)result != 0) break;
if (++ZI_WORK->pudCount <= 16) {
continuation = 0;
} else {
ZI_WORK->pudCount = 1;
break;
}
}
return result;
}
ziU32 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

@@ -0,0 +1,223 @@
#include <zi8clib/zitypes.h>
#include <zi8clib/zierror.h>
#include <zi8clib/zconvert.h>
#include <zi8clib/zmtkey.h>
typedef struct ziUserWord {
ziU8 size, language, length, priority;
ziU8 text[1];
} ziUserWord;
typedef struct ziUserDictionary {
ziU16 flags, end, current, boundary;
ziU8 entries[1];
} ziUserDictionary;
void Zi8Memset(ziPtr, ziU32, ziU32);
ziBool Zi8_81480224(ziUserWord* word ZI_NEED_WORK) {
ziU8 length;
ziU8 position;
ziUwdNode* previous;
ziUwdNode* current;
ziUwdNode* added;
ziUserWord* candidate;
if (ZI_WORK->uwdCount >= 32) {
Zi8LogError(0x19D, __zi8_work_data);
return 0;
}
if (word == 0) {
Zi8LogError(0x19F, __zi8_work_data);
return 0;
}
length = word->length;
if (length == 0) {
Zi8LogError(0x193, __zi8_work_data);
return 0;
}
if (length > 63) {
Zi8LogError(0x194, __zi8_work_data);
return 0;
}
previous = 0;
current = ZI_WORK->uwdList;
while (current != 0) {
candidate = (ziUserWord*)current->word;
if (ZI_WORK->unk_0x12E == 1 && word->priority > candidate->priority) break;
if (candidate->length == length) {
position = 0;
while (position < length) {
if (candidate->text[position] != word->text[position]) break;
position++;
}
if (position == length) {
Zi8LogError(100, __zi8_work_data);
return 0;
}
}
previous = current;
current = current->next;
}
length = ZI_WORK->uwdCount++;
added = &ZI_WORK->uwdNodes[length];
if (previous == 0) {
ZI_WORK->uwdList = added;
added->next = current;
} else {
previous->next = added;
added->next = current;
}
added->word = (ziU8*)word;
Zi8LogError(100, __zi8_work_data);
return 1;
}
ziUserWord* Zi8_814803F4(ziPtr __zi8_work_data) {
ziUserWord* word;
if (ZI_WORK->uwdCount != 0) {
ZI_WORK->uwdCount--;
word = (ziUserWord*)ZI_WORK->uwdList->word;
ZI_WORK->uwdList = ZI_WORK->uwdList->next;
Zi8LogError(100, __zi8_work_data);
return word;
}
Zi8LogError(0x19E, __zi8_work_data);
return 0;
}
void Zi8_8148047C(ziPtr __zi8_work_data) {
Zi8Memset(ZI_WORK->uwdNodes, 0, sizeof(ZI_WORK->uwdNodes));
ZI_WORK->uwdCount = 0;
ZI_WORK->uwdList = 0;
}
ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16 currentLength, ziU8 language, ziWChar* output, ziU16 capacity, ziU8 complete, ziU8 continuation ZI_NEED_WORK) {
ziWChar folded;
int fallback = 0;
int visited = 0;
int prefixLength;
int position, previousOffset;
ziU32 size;
ziU8 entryLanguage;
ziU32 entryLength;
ziU8* cursor;
ziU8* begin;
ziU8* boundary;
ziU8* end;
ziUserWord* candidate;
ziUserWord* previous;
ziUserWord* result;
ziUserDictionary* dictionary;
int firstSegment;
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)) {
Zi8ReplaceLastError(0x19C, __zi8_work_data);
return 0;
}
dictionary = ZI_WORK->unk_0x130[ZI_WORK->unk_0x138 - 1];
if (continuation != 0) {
result = Zi8_814803F4(__zi8_work_data);
entryLength = 0;
if (result != 0) {
entryLanguage = result->language;
entryLength = result->length;
if (entryLength >= capacity) {
Zi8_8148047C(__zi8_work_data);
return 0;
}
for (position = 0; position < (ziS32)entryLength; position++) output[position] = Zi8ConvertUC2WC(result->text[position], entryLanguage, __zi8_work_data);
}
return entryLength;
}
{
Zi8_8148047C(__zi8_work_data);
ZI_WORK->unk_0x13C = 0;
if (currentWord == 0 || currentLength == 0 || currentWord[currentLength - 1] != 0x20) ZI_WORK->unk_0x140 = 0;
else {
prefixLength = 0;
for (position = currentLength - 2; currentWord[position] != 0x20 && position >= 0; position--) prefixLength++;
position++;
if (prefixLength == 0 || prefixLength > 63) ZI_WORK->unk_0x140 = 0;
else {
ZI_WORK->unk_0x140 = 1;
ZI_WORK->unk_0x141[0] = prefixLength + 5;
ZI_WORK->unk_0x141[prefixLength + 4] = prefixLength + 5;
ZI_WORK->unk_0x141[1] = language;
ZI_WORK->unk_0x141[2] = prefixLength;
previousOffset = 4;
for (; prefixLength > 0; prefixLength--, position++) {
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 (!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);
}
if (ZI_WORK->unk_0x141[previousOffset++] == 0) {
ZI_WORK->unk_0x140 = 0;
break;
}
}
}
}
if (ZI_WORK->unk_0x140 == 0 && length == 0) return 0;
rescan:
begin = dictionary->entries + dictionary->current;
boundary = (ziU8*)dictionary + dictionary->boundary + 7;
end = (ziU8*)dictionary + dictionary->end + 7;
cursor = begin;
if (begin < boundary) firstSegment = 1;
else firstSegment = 0;
while (firstSegment ? cursor < boundary : cursor < end) {
size = *cursor;
candidate = (ziUserWord*)cursor;
position = visited++;
if ((ziS32)ZI_WORK->unk_0x13C <= position && (size & 0xC0) == 0) {
previous = (ziUserWord*)(cursor + size);
if ((ziU8*)previous > end) previous = (ziUserWord*)(cursor + ((ziU8*)dictionary - end) + 7);
entryLanguage = candidate->language;
entryLength = candidate->length;
if (entryLanguage == language && length <= entryLength && entryLength < capacity && (complete == 0 || entryLength == length) && (complete != 0 || entryLength != length)) {
for (position = 0; position < length; position++) {
if (pattern[position] < 0xEFF1 || pattern[position] > 0xF010) {
folded = Zi8ConvertUC2WC(candidate->text[position], language, __zi8_work_data);
if (folded != pattern[position] && (!ZI_WORK->unk_0x1F || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[position])) goto next;
} else if (pattern[position] != Zi8ConvertUC2Key(candidate->text[position], language, __zi8_work_data)) goto next;
}
if (ZI_WORK->unk_0x140 != 0) {
if (ZI_WORK->unk_0x141[0] != previous->size || ZI_WORK->unk_0x141[1] != previous->language || ZI_WORK->unk_0x141[2] != previous->length) goto next;
for (position = 4; position < ZI_WORK->unk_0x141[2] + 4; position++) {
if (ZI_WORK->unk_0x141[position] != ((ziU8*)previous)[position] && ZI_WORK->unk_0x184[position] != ((ziU8*)previous)[position]) goto next;
}
}
Zi8_81480224(candidate, __zi8_work_data);
}
}
next:
cursor += size;
if (end < cursor) {
if (firstSegment) break;
firstSegment = 1;
cursor = dictionary->entries + (cursor - end - 1);
}
}
if (ZI_WORK->unk_0x140 != 0 && length != 0) {
ZI_WORK->unk_0x140 = 0;
visited = 0;
goto rescan;
}
if (complete == 1 && length != 0 && continuation == 0) {
complete = 0;
fallback = 1;
visited = 0;
goto rescan;
}
}
result = Zi8_814803F4(__zi8_work_data);
entryLength = 0;
if (result != 0) {
entryLanguage = result->language;
entryLength = result->length;
if (entryLength >= capacity) {
Zi8_8148047C(__zi8_work_data);
return 0;
}
for (position = 0; position < (ziS32)entryLength; position++) output[position] = Zi8ConvertUC2WC(result->text[position], entryLanguage, __zi8_work_data);
}
return entryLength;
}

View File

@@ -0,0 +1,215 @@
#include <zi8clib/zierror.h>
#include <zi8clib/zitypes.h>
extern ziU16 nodeHeaderTable[16];
ziU32 ZiDAWGGetChild(ziU32 node) {
ziU32 base;
ziU16 header;
ziS32 offset;
base = node;
header = nodeHeaderTable[*(ziU8*)node >> 4];
if (((ziU32)header & 1) == 0) {
node = 0;
} else {
if ((*(ziU8*)node & 0xf) == 0xf) {
offset = 2;
} else {
offset = 1;
}
node += offset;
if (((ziU32)header & 2) != 0) {
if ((*(ziU8*)node & 0x80) != 0) {
offset = (*(ziU8*)node & 0x7f) * 0x10000 + ((ziU32)*((ziU8*)node + 1) & 0xffff) * 0x100 + 0x8000;
offset += *((ziU8*)node + 2);
} else {
offset = ((ziU32)*(ziU8*)node & 0xffff) * 0x100;
offset += (ziU32)*((ziU8*)node + 1);
}
} else if (((ziU32)header & 8) != 0) {
if ((*(ziU8*)node & 0x80) != 0) {
offset += 3;
} else {
offset += 2;
}
}
node = base + offset;
}
return node;
}
ziU8* ZiDAWGGetSibling(ziU8* node) {
ziU16 header;
ziU8* cursor = node;
ziS32 depth;
ziS32 offset;
depth = 0;
offset = 0;
header = nodeHeaderTable[node[0] >> 4];
if ((header & 4) == 0) {
node = 0;
} else {
if ((header & 8) != 0) {
if ((node[0] & 0xf) == 0xf) {
node += 2;
} else {
node += 1;
}
if ((header & 2) != 0) {
if ((*node & 0x80) == 0) {
node += 2;
} else {
node += 3;
}
}
if ((*node & 0x80) != 0) {
node += (*node & 0x7f) * 0x10000 + (ziU32)node[1] * 0x100 +
(ziU32)node[2] + 0x8000;
} else {
node += (ziU16)*node * 0x100 + (ziU32)node[1];
}
} else {
cursor = node;
do {
header = nodeHeaderTable[cursor[0] >> 4];
if ((cursor[0] & 0xf) == 0xf) {
cursor += 2;
offset += 2;
} else {
cursor++;
offset++;
}
if ((header & 1) != 0) {
if ((header & 2) == 0) {
depth++;
} else if ((*cursor & 0x80) != 0) {
cursor += 3;
offset += 3;
} else {
cursor += 2;
offset += 2;
}
}
if ((header & 4) == 0) {
depth--;
} else if ((header & 8) != 0) {
if ((*cursor & 0x80) != 0) {
cursor += 3;
offset += 3;
} else {
cursor += 2;
offset += 2;
}
depth--;
}
} while (0 < depth);
node += offset;
}
}
return node;
}
ziU8 ZiDAWGgetEOWattribute(ziU32 node) {
return (nodeHeaderTable[*(ziU8*)node >> 4] & 0x10) > 0;
}
ziU32 ZiDAWGgetCHARattribute(ziPtr context, ziU32 node, ziPtr __zi8_work_data) {
ziU8 key;
ziU32 attribute;
if ((*(ziU8*)node & 0xf) == 0xf) {
key = (ziU32)*((ziU8*)node + 1) + 0xf;
} else {
key = (ziU32)*(ziU8*)node & 0xf;
}
if (key > ((zi8DawgCtx*)context)->cap) {
Zi8LogError(0x138b, __zi8_work_data);
return 0;
}
attribute = key << 24;
attribute |= ((ziU8*)((zi8DawgCtx*)context)->p0C)[key] << 16;
attribute += ((ziU32)((ziU8*)((zi8DawgCtx*)context)->p08)[key * 2] & 0xFFFF) << 8;
attribute += ((ziU8*)((zi8DawgCtx*)context)->p08)[key * 2 + 1];
Zi8LogError(0x64, __zi8_work_data);
return attribute;
}
ziU32 ZiDAWGGetGraph(ziPtr context) {
return (((ziU32)((zi8DawgCtx*)context)->table[2] & 0xFFFF) << 8) +
((zi8DawgCtx*)context)->table[3] +
((ziU32)((zi8DawgCtx*)context)->table + 4);
}
ziU32 ZiDAWGGetGraphInfo(zi8DawgCtx* context, ziU8* entry, ziU16* keys) {
ziU32 graph;
ziS32 result;
ziU32 end;
ziU8 depth;
ziU32 pair;
graph = ZiDAWGGetGraph(context);
result = 0;
pair = (((ziU16)entry[0] << 8) + entry[1]);
if (pair != 0) {
return 0;
}
pair = (((ziU16)entry[2] << 8) + entry[3]);
if (pair == 0) {
end = (ziU32)(entry + (((ziU16)entry[4] << 8) + entry[5] + 1) * 10);
entry += 10;
depth = 0;
while ((depth < 2) && (*keys != 0)) {
if ((*keys < 0xeff1) || (0xf010 < *keys)) {
break;
}
while (1) {
if (*keys == (ziS32)(entry[3] + ((ziU16)entry[2] << 8))) {
break;
}
entry += (entry[1] + ((ziU16)entry[0] << 8)) * 10 + 10;
if (((ziU32)entry >= end) ||
(*keys == (ziS32)(entry[3] + ((ziU16)entry[2] << 8)))) {
break;
}
}
if ((ziU32)entry >= end) {
return 0;
}
result = graph + (ziU32)entry[4] * 0x10000 + ((ziU16)entry[5] << 8) +
entry[6];
((zi8DawgCtx*)context)->unk_0x338 =
graph + (ziU32)entry[7] * 0x10000 + ((ziU16)entry[8] << 8) +
entry[9];
if (((zi8DawgCtx*)context)->unk_0x338 == graph) {
((zi8DawgCtx*)context)->unk_0x338 = 0;
}
if ((entry[1] + ((ziU16)entry[0] << 8)) == 0) {
break;
}
end = (ziU32)(entry + (entry[1] + ((ziU16)entry[0] << 8)) * 10 + 10);
entry += 10;
depth++;
keys++;
}
}
return result;
}

View File

@@ -25,13 +25,12 @@ ziU8 Zi8_814813FC(ziWChar character, ziU8* result, ziU16* index, ziPtr workData)
ziU8 Zi8_81481E6C(ziU16* resultIndex, ziU16* input, ziU8 type, ziU16 count, ziPtr workData);
ziU8 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
ziPtr workData) {
ziU32 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
ziPtr workData) {
struct {
ziU8 characterIndex;
ziU8 matched;
ziU8 elementIndex;
ziU8 reserved;
ziU16 index;
ziU16 currentCandidate;
ziU16 inputIndex;
@@ -45,7 +44,7 @@ ziU8 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
ziU8* table1;
} state;
ziU16 buffer[100];
unsigned int result;
ziU8 result;
ziU16 currentCharacter;
ziU8* selectedTable;
@@ -53,9 +52,7 @@ ziU8 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
result = 0;
state.characterIndex = 0xFF;
state.currentCandidate = params->firstCandidate;
params->unk_0x20 = 0;
params->count = 0;
params->letters = 0;
params->letters = params->count = params->unk_0x20 = 0;
if ((argument != 0) && (*argument != 0)) {
Zi8LogError(0x7D0, workData);
return 0;
@@ -75,40 +72,39 @@ ziU8 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
state.tableCount31 = Zi8GetTableCount(ZI8_LANG_KO, 0x31, workData);
for (state.elementIndex = 0; state.elementIndex < params->elementCount;
state.elementIndex++) {
state.elementIndex++) {
currentCharacter = params->elements[state.elementIndex];
if ((currentCharacter >= 0x61) && (currentCharacter <= 0x7A)) {
buffer[state.elementIndex] = state.table1[(currentCharacter - 0x61) * 2];
} else if ((currentCharacter >= 0x41) && (currentCharacter <= 0x5A)) {
buffer[state.elementIndex] = state.table1[(currentCharacter - 0x41) * 2 + 1];
buffer[state.elementIndex] = (state.table1 + (currentCharacter - 0x41) * 2)[1];
} else {
state.matched = 0;
for (; state.table2[state.matched * 3] != 0; state.matched++) {
if (currentCharacter == state.table2[state.matched * 3]) break;
}
if (state.table2[(state.matched * 3)] == 0) {
if (state.table2[state.matched * 3] != 0) {
buffer[state.elementIndex] =
((ziU16)(state.table2 + state.matched * 3)[1] << 8) |
(state.table2 + state.matched * 3)[2];
} else {
Zi8LogError(0x161, workData);
return 0;
}
buffer[state.elementIndex] =
(state.table2[(state.matched * 3) + 1] << 8) |
state.table2[(state.matched * 3) + 2];
}
}
result = 0;
for (currentCharacter = 0; currentCharacter < state.elementIndex; currentCharacter++) {
state.inputIndex = 0;
if (Zi8_814813FC(buffer[currentCharacter], (ziU8*)&state.characterIndex,
(ziU16*)&state.inputIndex, workData) == 0) {
state.matched = 0;
} else {
state.matched = Zi8_81481E6C((ziU16*)&state.nextIndex,
&buffer[currentCharacter + 1],
state.characterIndex,
(state.elementIndex - currentCharacter) - 1,
workData);
if ((((struct __zi8_work_data_s*)workData)->unk_0x1B30 == 1) && (state.characterIndex < 0x1F)) {
if (Zi8_814813FC(buffer[currentCharacter], &state.characterIndex,
&state.inputIndex, workData) != 0) {
state.matched = Zi8_81481E6C(&state.nextIndex,
buffer + currentCharacter + 1,
state.characterIndex,
(state.elementIndex - currentCharacter) - 1,
workData);
if ((((struct __zi8_work_data_s*)workData)->unk_0x1B30 == 1)) {
switch (state.characterIndex) {
case 1:
selectedTable = (ziU8*)Zi8GetTableAddress(ZI8_LANG_KO, 0x1E, workData);
@@ -171,38 +167,33 @@ ziU8 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
break;
}
}
} else {
state.matched = 0;
}
if (state.matched == 0) {
if (state.currentCandidate == 0) {
for (state.index = 0; state.index < state.tableCount31; state.index++) {
if (((ziU16)state.table31[(state.index * 3)] == buffer[currentCharacter]) &&
((ziU16)state.table31[(state.index * 3) + 1] == buffer[currentCharacter + 1])) {
if (currentCharacter == 0) {
params->count = 1;
}
params->candidates[result] =
state.tableCount0 + state.table31[(state.index * 3) + 2];
result++;
currentCharacter++;
break;
}
}
if (state.index == state.tableCount31) {
params->candidates[result] = buffer[currentCharacter];
if (buffer[currentCharacter] < 0xFF) {
if (currentCharacter == 0) {
params->count = 1;
}
params->candidates[result] += state.tableCount0;
result++;
}
}
if (state.matched != 0) {
if (state.tableCount6 == 0) {
state.nextIndex += state.inputIndex * state.tableCount3;
}
if (state.currentCandidate != 0) {
state.currentCandidate--;
} 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)) {
params->candidates[(ziU8)result] += state.inputIndex * state.tableCount3;
}
result++;
}
if (currentCharacter == 0) {
params->count = state.matched + 1;
}
currentCharacter += state.matched;
} else {
if (state.currentCandidate != 0) {
state.index = 0;
while ((state.index < state.tableCount31) &&
(((ziU16)state.table31[(state.index * 3)] != buffer[currentCharacter]) ||
((ziU16)state.table31[(state.index * 3) + 1] != buffer[currentCharacter + 1]))) {
state.index++;
for (; state.index < state.tableCount31; state.index++) {
if (state.table31[state.index * 3] == buffer[currentCharacter] &&
(state.table31 + state.index * 3)[1] == buffer[currentCharacter + 1]) break;
}
if (state.index == state.tableCount31) {
state.currentCandidate--;
@@ -210,25 +201,30 @@ ziU8 Zi8GetKoreanCandidates(ziGetParam* params, ziU8* argument,
if (currentCharacter == 0) {
params->count = 1;
}
}
} else {
if (state.tableCount6 == 0) {
state.nextIndex += state.inputIndex * state.tableCount3;
}
if (state.currentCandidate == 0) {
params->candidates[result] =
(selectedTable[state.nextIndex * 2] << 8) | selectedTable[state.nextIndex * 2 + 1];
if ((state.tableCount6 != 0) && (((struct __zi8_work_data_s*)workData)->unk_0x1B30 == 0)) {
params->candidates[result] += state.inputIndex * state.tableCount3;
}
result++;
} else {
state.currentCandidate--;
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->candidates[(ziU8)result] =
state.tableCount0 + (state.table31 + state.index * 3)[2];
result++;
currentCharacter++;
break;
}
}
if (state.index == state.tableCount31) {
if ((params->candidates[(ziU8)result] = buffer[currentCharacter]) < 0xFF) {
if (currentCharacter == 0) {
params->count = 1;
}
params->candidates[(ziU8)result] += state.tableCount0;
result++;
}
}
}
if (currentCharacter == 0) {
params->count = state.matched + 1;
}
currentCharacter += state.matched;
}
if (result >= params->maxCandidates) {
break;

View File

@@ -0,0 +1,176 @@
#include <stddef.h>
#include <zi8clib/zitypes.h>
#include <zi8clib/zierror.h>
typedef struct ziSearchState {
ziU32 flags;
ziWChar* word;
ziU32 length;
ziU32 position;
ziU32 capacity;
ziU32 options;
} ziSearchState;
typedef struct ziUserKeys {
ziWChar* upper[32];
ziWChar* lower[32];
} ziUserKeys;
typedef struct ziChineseEntry {
ziU8 data[9];
ziU8 offsetHigh;
ziU8 offsetLow[2];
} ziChineseEntry;
ziU8 Zi8GetCandidatesOrCount(ziGetParam*, ziSearchState* ZI_NEED_WORK);
ziU8 Zi8GetFormatVersion(ziU8 ZI_NEED_WORK);
ziPtr Zi8GetTableAddress(ziU8, ziU8 ZI_NEED_WORK);
ziU16 Zi8Uni2Ord(ziWChar ZI_NEED_WORK);
ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
int count;
int offset;
ziU8 group;
ziU8 remaining;
ziU16 value;
ziWChar* cursor;
ziSearchState search;
ziGetParam request;
ziWChar ordinals[65];
int length;
int unmatched;
ziChineseEntry* entry;
ziU8* data;
ziU8 formats[8] = {1, 5, 0, 0, 0, 0, 0, 0};
ziU32 savedFormats = ZI_WORK->unk_0x1410;
ziU8 savedCount = ZI_WORK->unk_0x1418;
search.flags = 0;
search.word = 0;
search.length = 0;
search.position = 0;
search.capacity = 0;
search.options = 0;
Zi8LogError(100, __zi8_work_data);
if (word == 0 || *word == 0) {
Zi8ReplaceLastError(300, __zi8_work_data);
return 0;
}
if (language != 1) {
for (length = 0; word[length] != 0; length++) {
if (word[length] >= 0xEFF1 || length == 64) return 0;
}
((ziU8*)&search.length)[0] = length;
((ziU8*)&search.flags)[2] = 1;
((ziU16*)&search.capacity)[0] = 64;
search.word = word;
request.language = language;
request.getMode = 0;
request.subLanguage = 7;
request.context = 1;
request.getOptions = 0x81;
request.elements = word;
request.elementCount = length;
request.currentWord = 0;
request.wordCharCount = 0;
request.candidates = ordinals;
request.maxCandidates = 1;
request.firstCandidate = 0;
ZI_WORK->unk_0x1410 = (ziU32)formats;
if (ZI_WORK->unk_0x1C[0] == 2) {
ZI_WORK->unk_0x1418 = 0;
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->unk_0x1418++] = 1;
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->unk_0x1418++] = 2;
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->unk_0x1418++] = 3;
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->unk_0x1418++] = 4;
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->unk_0x1418++] = 5;
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->unk_0x1418++] = 6;
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->unk_0x1418++] = 7;
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->unk_0x1418++] = 8;
} else if (ZI_WORK->unk_0x1C[0] == 0) ZI_WORK->unk_0x1418 = 1;
else ZI_WORK->unk_0x1418 = 2;
count = Zi8GetCandidatesOrCount(&request, &search, __zi8_work_data);
ZI_WORK->unk_0x1410 = savedFormats;
ZI_WORK->unk_0x1418 = savedCount;
if (count != 0) return 1;
}
if (language == 1) {
length = 0;
do {
ordinals[length] = Zi8Uni2Ord(word[length], __zi8_work_data);
if (ordinals[length] == 0xFFFF) return 0;
length++;
if (length == 64) return 0;
} while (word[length] != 0);
{
if (length == 1) return 1;
count = --length;
ordinals[count] |= 0x8000;
ZI_WORK->unk_0x16 = Zi8GetFormatVersion(1, __zi8_work_data) & 2;
entry = (ziChineseEntry*)Zi8GetTableAddress(1, 0, __zi8_work_data) + ordinals[0];
data = (ziU8*)Zi8GetTableAddress(1, 1, __zi8_work_data) + ((entry->offsetHigh & 15) << 16 | ((entry->offsetLow[0] << 8) | entry->offsetLow[1]));
if (ZI_WORK->unk_0x16 != 0) {
switch (*data & 7) {
case 2:
offset = 2;
break;
case 3:
case 4:
offset = 3;
break;
case 5:
offset = 4;
break;
default:
offset = 1;
break;
}
data += offset;
}
if ((*data & 0x80) == 0) return 0;
group = 0;
data += ((*data & 0x7F) >> 4) + 1;
while ((group & 0x80) == 0) {
group = *data++;
for (remaining = group & 15; remaining != 0; remaining--) {
unmatched = count;
cursor = ordinals;
while (unmatched > 0) {
value = data[0] | (data[1] << 8);
data += 2;
cursor++;
if (value != *cursor) break;
unmatched--;
if (value & 0x8000) break;
}
if (unmatched == 0) return 1;
if (!(value & 0x8000)) {
data++;
while (!(*data & 0x80)) data += 2;
data++;
}
}
}
Zi8LogError(0x2BD, __zi8_work_data);
return 0;
}
} else Zi8ReplaceLastError(0x26C, __zi8_work_data);
return 0;
}
ziWChar Zi8ConvertUC2UserKey(ziChar character, ziU8 language ZI_NEED_WORK) {
ziUserKeys* keys;
ziU16 key;
ziWChar* cursor;
if (character == 0 || language > 0x82 || (keys = ZI_WORK->userKeys[language]) == 0) return 0;
for (key = 0; key < 32; key++) {
for (cursor = keys->lower[key]; cursor != 0 && *cursor != 0; cursor++) {
if ((ziU16)*cursor == (ziU16)character) goto found;
}
for (cursor = keys->upper[key]; cursor != 0 && *cursor != 0; cursor++) {
if ((ziU16)*cursor == (ziU16)character) goto found;
}
}
found:
if (key >= 32) return 0;
if (key == 0) return 0xEFFA;
if (key >= 1 && key <= 9) return key + 0xEFF0;
if (key <= 31) return key + 0xEFF1;
return 0;
}

View File

@@ -3,6 +3,14 @@
extern ziU16 Zi8GetTableCount(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
extern ziU32 Zi8GetTableAddress(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
typedef struct {
ziU8 keyBytes[5];
ziU8 childHigh;
ziU8 childLow;
ziU8 characterHigh;
ziU8 characterLow;
} ZiKoreanKeyEntry;
ziU32 Zi8_8148302C(ziU16 key, ziU8* table ZI_NEED_WORK) {
ziU32 value;
ziU16 count;
@@ -12,7 +20,7 @@ ziU32 Zi8_8148302C(ziU16 key, ziU8* table ZI_NEED_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]);
if (key == value) {
if (value == key) {
Zi8LogError(0x64, ZI_WORK);
return i;
}
@@ -91,7 +99,7 @@ ziU32 Zi8_81483308(ziGetParam* param, ziU16 key, ziU8* count ZI_NEED_WORK) {
return 0;
}
ziBool Zi8_814833F0(const ziGetParam* param, ziU16 key ZI_NEED_WORK) {
ziU32 Zi8_814833F0(const ziGetParam* param, ziU16 key ZI_NEED_WORK) {
ziU8 i;
Zi8LogError(0x64, ZI_WORK);
@@ -111,23 +119,28 @@ ziBool Zi8_814833F0(const ziGetParam* param, ziU16 key ZI_NEED_WORK) {
ziU32 Zi8_814834AC(ziGetParam* param, ziU16* remaining, ziU8* count,
ziU8* inserted ZI_NEED_WORK) {
ziBool matches;
ziS32 entry;
ziS32 tableA;
ziS32 tableB;
ziU16 tableCount;
ziU8 matched;
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;
ziS32 i;
ziU8 candidateIndex;
union {
ziU32 words[13];
ziU8 bytes[52];
} local;
ziS32 candidate;
ziU8 matched;
j = 0;
filter.candidateIndex = 0;
matched = 0;
local.words[0] = 0;
local.bytes[4] = 0;
filter.keys.bytes[4] = filter.keys.firstWord = 0;
Zi8LogError(0x64, ZI_WORK);
if (param->elementCount == 0) {
if (*remaining >= *count) {
@@ -141,394 +154,354 @@ ziU32 Zi8_814834AC(ziGetParam* param, ziU16* remaining, ziU8* count,
Zi8_81483308(param, param->candidates[i], inserted, ZI_WORK);
}
for (i = 0; i < ((ziS32)*count - (ziS32)*remaining); i++) {
param->candidates[i] = param->candidates[(ziU32)*remaining + i];
param->candidates[i] = param->candidates[*remaining + i];
}
*count = *count - (ziU8)*remaining;
*count -= *remaining;
*remaining = 0;
}
return 1;
} else if (param->elementCount <= 9) {
tableA = Zi8GetTableAddress(param->language, 9, ZI_WORK);
tableB = Zi8GetTableAddress(param->language, 10, ZI_WORK);
if (tableA == 0) {
}
if (param->elementCount > 9) {
*count = 0;
return 0;
}
filter.tableA = (ziU8*)Zi8GetTableAddress(param->language, 9, ZI_WORK);
filter.tableB = (ziU8*)Zi8GetTableAddress(param->language, 10, ZI_WORK);
if (filter.tableA == 0) {
Zi8ReplaceLastError(0x76C, ZI_WORK);
return 0;
} else if (tableB == 0) {
} else if (filter.tableB == 0) {
Zi8ReplaceLastError(0x776, ZI_WORK);
return 0;
} else {
tableCount = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
Zi8_81483118(param, local.bytes);
filter.tableCount = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
Zi8_81483118(param, filter.keys.bytes);
i = 0;
while (i < tableCount && matched < *count) {
matches = ZI8_TRUE;
entry = (i << 3) + tableA + i;
while (i < filter.tableCount && matched < *count) {
filter.matches = ZI8_TRUE;
filter.entry = (ZiKoreanKeyEntry*)&filter.tableA[(i << 3) + i];
j = 0;
if (param->elementCount > 1) {
for (j = 0; (j & 0xFF) < (ziU32)(param->elementCount >> 1); j++) {
if (local.bytes[j & 0xFF] != *((ziU8*)entry + (j & 0xFF))) {
matches = ZI8_FALSE;
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;
break;
}
}
}
if (matches && (param->elementCount & 1) != 0 &&
((local.bytes[j & 0xFF] & 0xF0) != (*((ziU8*)entry + (j & 0xFF)) & 0xF0))) {
matches = ZI8_FALSE;
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) {
for (candidateIndex = 0; candidateIndex < *count; candidateIndex++) {
if (param->candidates[candidateIndex] ==
(ziU16)((*((ziU8*)entry + 7) << 8) | *((ziU8*)entry + 8))) {
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)) {
matched++;
param->candidates[candidateIndex] =
param->candidates[candidateIndex] & 0x7FFF;
param->candidates[filter.candidateIndex] &= 0x7FFF;
break;
}
}
}
i++;
}
if ((ziU16)matched >= *remaining) {
if (matched >= *remaining) {
matched = *count;
*count = 0;
for (i = 0; i < matched; i++) {
if ((param->candidates[i] & 0x8000) == 0) {
param->candidates[i] = param->candidates[i] | 0x8000;
if (*remaining == 0) {
if (*count != i) {
param->candidates[*count] = param->candidates[i];
}
*count = *count + 1;
for (candidate = 0; candidate < matched; candidate++) {
if ((param->candidates[candidate] & 0x8000) == 0) {
param->candidates[candidate] |= 0x8000;
if (*remaining != 0) {
--*remaining;
Zi8_81483308(param, param->candidates[candidate], inserted, ZI_WORK);
} else {
*remaining = *remaining - 1;
Zi8_81483308(param, param->candidates[i], inserted, ZI_WORK);
if (*count != candidate) {
param->candidates[*count] = param->candidates[candidate];
}
++*count;
}
}
}
*remaining = 0;
} else {
for (i = 0; i < *count; i++) {
if ((param->candidates[i] & 0x8000) == 0) {
param->candidates[i] = param->candidates[i] | 0x8000;
Zi8_81483308(param, param->candidates[i], inserted, ZI_WORK);
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);
}
}
*remaining = *remaining - (ziU16)matched;
*remaining = *remaining - matched;
*count = 0;
}
}
} else {
*count = 0;
return 0;
}
return 0;
}
ziU32 Zi8GetKOcandidates(ziGetParam* param, ziU8* options ZI_NEED_WORK) {
ziBool bVar1;
ziU8 bVar2;
ziS32 iVar4;
ziU32 uVar6;
ziU8* pbVar7;
union {
ziU32 words[10];
ziU8 bytes[40];
} local_28;
ziU8 local_57;
ziU8 local_56;
ziU8 local_55;
ziU8 local_54;
ziU8 local_53;
ziS8 local_52;
ziU16 local_50;
ziU16 local_4E;
ziU16 local_4C;
ziU16 local_4A;
ziU16 local_48;
ziS32 local_44;
ziS32 local_2C;
ziS32 local_30;
ziU32 local_34;
ziU32 local_38;
ziU32 local_3C;
ziU32 local_40;
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;
} ZiKoreanCandidateOptions;
local_4E = 0xFFFF;
local_34 = 0;
local_28.words[0] = 0;
local_28.bytes[4] = 0;
local_52 = 0;
local_53 = 0;
local_54 = 0;
local_55 = 0;
local_50 = param->firstCandidate;
local_3C = 0;
local_40 = 0;
local_57 = 0;
ziU32 Zi8GetKOcandidates(ziGetParam* param, ZiKoreanCandidateOptions* options ZI_NEED_WORK) {
struct {
ziBool matches;
ziU8 inserted;
ziU8 matchPass;
ziU8 keyByte;
ziU8 candidateCount;
ziU8 wordIndex;
ziU8 remainingLetters;
ziU16 remainingCandidates;
ziU16 previousIndex;
ziU16 character;
ziU16 tableCount;
ziU16 keyIndex;
ZiKoreanKeyEntry* entry;
ziS32 candidateIndex;
ziS32 prefixCount;
ziU32 wordOffset;
ziS32 resultCount;
ziS32 tableIndex;
ziU8* wordTable;
union {
ziU32 firstWord;
ziU8 bytes[5];
} packedKeys;
} search;
ziU8* keyTable;
ziU8* wordNode;
search.previousIndex = 0xFFFF;
search.resultCount = 0;
search.packedKeys.firstWord = 0;
search.packedKeys.bytes[4] = 0;
search.remainingLetters = 0;
search.wordIndex = 0;
search.candidateCount = 0;
search.keyByte = 0;
search.remainingCandidates = param->firstCandidate;
search.prefixCount = 0;
search.candidateIndex = 0;
search.inserted = 0;
Zi8LogError(100, ZI_WORK);
Zi8_81483264(param, ZI_WORK);
iVar4 = Zi8GetTableAddress(ZI8_LANG_KO, 9, ZI_WORK);
local_2C = Zi8GetTableAddress(ZI8_LANG_KO, 10, ZI_WORK);
if (iVar4 == 0) {
keyTable = (ziU8*)Zi8GetTableAddress(ZI8_LANG_KO, 9, ZI_WORK);
search.wordTable = (ziU8*)Zi8GetTableAddress(ZI8_LANG_KO, 10, ZI_WORK);
if (keyTable == 0) {
Zi8ReplaceLastError(0x76C, ZI_WORK);
uVar6 = 0;
return 0;
} else {
if (local_2C == 0) {
if (search.wordTable == 0) {
Zi8ReplaceLastError(0x776, ZI_WORK);
uVar6 = 0;
goto LAB_000114C4;
return 0;
}
if (*options == 0) {
if (options->countOnly == 0) {
param->letters = 0;
param->count = 0;
param->unk_0x20 = 0;
param->candidates[0] = 0;
}
Zi8LogError(100, ZI_WORK);
if (param->wordCharCount != 0) {
local_48 = Zi8_8148302C(param->currentWord[0], (ziU8*)iVar4, ZI_WORK);
if ((local_48 != 0xFFFF) &&
((((ziU8*)iVar4)[((ziU32)local_48 * 9) + 4] & 8) != 0)) {
local_38 = (ziU32)((ziU8*)iVar4)[((ziU32)local_48 * 9) + 6] |
((ziU32)((ziU8*)iVar4)[((ziU32)local_48 * 9) + 4] & 3) << 16 |
(ziU32)((ziU8*)iVar4)[((ziU32)local_48 * 9) + 5] << 8;
local_52 = param->wordCharCount - 1;
local_53 = 1;
pbVar7 = (ziU8*)(local_2C + local_38);
LAB_00010D44:
if (local_52 != 0) {
local_48 = Zi8_8148302C(param->currentWord[local_53], (ziU8*)iVar4, ZI_WORK);
if (local_48 == (ziU16)((*pbVar7 & 0x1F) << 8 | pbVar7[1])) {
local_52 = local_52 - 1;
local_53 = local_53 + 1;
if ((*pbVar7 & 0x40) == 0) {
pbVar7 = pbVar7 + 2;
goto LAB_00010D44;
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 |
((((ZiKoreanKeyEntry*)(((search.keyIndex << 3) + search.keyIndex) + keyTable))->keyBytes[4] & 3) << 16 |
((ZiKoreanKeyEntry*)(((search.keyIndex << 3) + search.keyIndex) + keyTable))->childHigh << 8);
search.remainingLetters = param->wordCharCount - 1;
search.wordIndex = 1;
wordNode = search.wordTable + search.wordOffset;
match_word:
while (search.remainingLetters != 0) {
search.keyIndex = Zi8_8148302C(param->currentWord[search.wordIndex], (ziU8*)keyTable, ZI_WORK);
if (search.keyIndex == (((ziU16)*wordNode & 0x1F) << 8 | (ziU16)wordNode[1])) {
--search.remainingLetters;
++search.wordIndex;
if ((*wordNode & 0x40) != 0) {
search.remainingLetters = param->wordCharCount - 1;
search.wordIndex = 1;
break;
}
local_52 = param->wordCharCount - 1;
local_53 = 1;
wordNode += 2;
} else {
local_53 = 1;
local_52 = param->wordCharCount - 1;
search.wordIndex = 1;
search.remainingLetters = param->wordCharCount - 1;
break;
}
}
if (local_52 == 0) {
local_48 = (*pbVar7 & 0x1F) << 8 | pbVar7[1];
local_4C = (ziU16)(((ziU8*)((ziU32)local_48 * 9 + (ziU32)local_48 + (ziU32)iVar4))[7] << 8 |
((ziU8*)((ziU32)local_48 * 9 + (ziU32)local_48 + (ziU32)iVar4))[8]);
if (search.remainingLetters == 0) {
search.keyIndex = ((ziU16)*wordNode & 0x1F) << 8 | (ziU16)wordNode[1];
search.character = (ziU16)((ziU16)((ZiKoreanKeyEntry*)(((search.keyIndex << 3) + search.keyIndex) + keyTable))->characterHigh << 8 |
((ZiKoreanKeyEntry*)(((search.keyIndex << 3) + search.keyIndex) + keyTable))->characterLow);
if (param->wordCharCount == 1) {
if (local_48 == local_4E) {
for (; (*pbVar7 & 0x40) == 0; pbVar7 = pbVar7 + 2) {
if (search.keyIndex == search.previousIndex) {
for (; (*wordNode & 0x40) == 0; wordNode = wordNode + 2) {
}
local_52 = param->wordCharCount;
goto LAB_00011114;
wordNode += 2;
search.remainingLetters = param->wordCharCount - 1;
search.wordIndex = 1;
goto next_word;
}
local_4E = local_48;
search.previousIndex = search.keyIndex;
if (param->elementCount == 0) {
if (local_50 == 0) {
if (*options != 0) {
local_3C = local_3C + 1;
if ((ziS32)local_3C < *(ziS32*)(options + 0xC)) {
goto LAB_000110E8;
}
uVar6 = *(ziU32*)(options + 0xC);
goto LAB_000114C4;
}
param->candidates[local_54] = local_4C;
local_54 = local_54 + 1;
param->count = param->count + 1;
bVar2 = param->letters + 1;
param->letters = bVar2;
if (param->maxCandidates <= bVar2) {
uVar6 = param->letters;
goto LAB_000114C4;
}
if (search.remainingCandidates != 0) {
--search.remainingCandidates;
} else {
local_50 = local_50 + -1;
if (options->countOnly != 0) {
if (++search.prefixCount < (ziS32)options->maxCount) {
goto skip_word;
}
return options->maxCount;
}
param->candidates[search.candidateCount++] = search.character;
++param->unk_0x20;
if (++param->letters >= param->maxCandidates) {
return param->letters;
}
}
} else {
param->candidates[local_54] = local_4C;
local_54 = local_54 + 1;
param->count = param->count + 1;
bVar2 = param->letters + 1;
param->letters = bVar2;
if (param->maxCandidates <= bVar2) {
Zi8_814834AC(param, &local_50, &local_54, &local_57, ZI_WORK);
param->count = local_54;
param->letters = local_54;
if (param->maxCandidates <= local_54) {
if (*options == 0) {
uVar6 = local_54;
goto LAB_000114C4;
}
local_3C = local_3C + local_54;
if (*(ziS32*)(options + 0xC) <= (ziS32)local_3C) {
uVar6 = *(ziU32*)(options + 0xC);
goto LAB_000114C4;
}
param->count = 0;
param->candidates[search.candidateCount++] = search.character;
++param->unk_0x20;
if (++param->letters >= param->maxCandidates) {
Zi8_814834AC(param, &search.remainingCandidates, &search.candidateCount, &search.inserted, ZI_WORK);
param->unk_0x20 = 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->letters = 0;
local_54 = 0;
search.candidateCount = 0;
} else {
return search.candidateCount;
}
}
}
} else {
for (local_40 = 0;
(local_40 < local_54 &&
(local_4C != param->candidates[local_40]));
local_40 = local_40 + 1) {
for (search.candidateIndex = 0; search.candidateIndex < search.candidateCount; search.candidateIndex++) {
if (search.character == param->candidates[search.candidateIndex]) break;
}
if ((local_40 == local_54) &&
(Zi8_814833F0(param, local_4C, ZI_WORK) == 0)) {
param->candidates[local_54] = local_4C;
local_54 = local_54 + 1;
param->count = param->count + 1;
bVar2 = param->letters + 1;
param->letters = bVar2;
if (bVar2 < param->maxCandidates) {
goto LAB_000110E8;
if ((search.candidateIndex == search.candidateCount) &&
(Zi8_814833F0(param, search.character, ZI_WORK) == 0)) {
param->candidates[search.candidateCount++] = search.character;
++param->unk_0x20;
if (++param->letters < param->maxCandidates) {
goto skip_word;
}
Zi8_814834AC(param, &local_50, &local_54, &local_57, ZI_WORK);
param->count = local_54;
param->letters = local_54;
if (param->maxCandidates <= local_54) {
if (*options == 0) {
uVar6 = local_54;
goto LAB_000114C4;
}
local_3C = local_3C + local_54;
if (*(ziS32*)(options + 0xC) <= (ziS32)local_3C) {
uVar6 = *(ziU32*)(options + 0xC);
goto LAB_000114C4;
}
param->count = 0;
Zi8_814834AC(param, &search.remainingCandidates, &search.candidateCount, &search.inserted, ZI_WORK);
param->unk_0x20 = 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->letters = 0;
local_54 = 0;
search.candidateCount = 0;
} else {
return search.candidateCount;
}
}
}
}
LAB_000110E8:
for (; (*pbVar7 & 0x40) == 0; pbVar7 = pbVar7 + 2) {
skip_word:
for (; (*wordNode & 0x40) == 0; wordNode = wordNode + 2) {
}
local_52 = param->wordCharCount;
LAB_00011114:
local_52 = local_52 + -1;
local_53 = 1;
pbVar7 = pbVar7 + 2;
if ((*pbVar7 & 0x80) != 0) {
goto LAB_00011124;
wordNode += 2;
search.remainingLetters = param->wordCharCount - 1;
search.wordIndex = 1;
next_word:
if ((*wordNode & 0x80) != 0) {
goto search_table;
}
goto LAB_00010D44;
goto match_word;
}
}
LAB_00011124:
local_34 = local_3C;
if (local_54 != 0) {
Zi8_814834AC(param, &local_50, &local_54, &local_57, ZI_WORK);
uVar6 = local_34;
if ((*options != 0) &&
(local_3C = local_3C + local_54, uVar6 = local_3C,
*(ziS32*)(options + 0xC) <= (ziS32)local_3C)) {
uVar6 = *(ziU32*)(options + 0xC);
goto LAB_000114C4;
search_table:
search.resultCount = search.prefixCount;
if (search.candidateCount != 0) {
Zi8_814834AC(param, &search.remainingCandidates, &search.candidateCount, &search.inserted, ZI_WORK);
if (options->countOnly != 0) {
if ((search.prefixCount += search.candidateCount) >= (ziS32)options->maxCount) return options->maxCount;
search.resultCount = search.prefixCount;
}
local_34 = uVar6;
param->count = local_54;
param->letters = local_54;
param->unk_0x20 = search.candidateCount;
param->letters = search.candidateCount;
}
if (param->elementCount < 10) {
if ((param->elementCount == 0) || (*options != 0)) {
local_56 = 1;
if (param->elementCount > 9) {
param->letters = 0;
return 0;
}
{
if (param->elementCount != 0 && options->countOnly == 0) {
search.matchPass = 0;
} else {
local_56 = 0;
search.matchPass = 1;
}
local_4A = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
Zi8_81483118(param, local_28.bytes);
search.tableCount = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
Zi8_81483118(param, search.packedKeys.bytes);
do {
for (local_30 = 0; local_30 < (ziS32)(ziU32)local_4A; local_30 = local_30 + 1) {
bVar1 = ZI8_TRUE;
local_44 = iVar4 + local_30 * 9;
local_55 = 0;
for (search.tableIndex = 0; search.tableIndex < search.tableCount; search.tableIndex = search.tableIndex + 1) {
search.matches = ZI8_TRUE;
search.entry = (ZiKoreanKeyEntry*)(((search.tableIndex << 3) + search.tableIndex) + keyTable);
search.keyByte = 0;
if (1 < param->elementCount) {
for (local_55 = 0;
(ziU32)local_55 < (ziU32)((ziS32)(ziU32)param->elementCount >> 1);
local_55 = local_55 + 1) {
if (local_28.bytes[local_55] != *(ziU8*)(local_44 + local_55)) {
bVar1 = ZI8_FALSE;
for (search.keyByte = 0;
(ziS32)search.keyByte < (int)param->elementCount / 2;
search.keyByte++) {
if (search.packedKeys.bytes[search.keyByte] != search.entry->keyBytes[search.keyByte]) {
search.matches = ZI8_FALSE;
break;
}
}
}
if ((bVar1 && ((param->elementCount & 1) != 0)) &&
((local_28.bytes[local_55] & 0xF0) !=
(*(ziU8*)(local_44 + local_55) & 0xF0))) {
bVar1 = ZI8_FALSE;
if ((search.matches && ((param->elementCount % 2) != 0)) &&
((search.packedKeys.bytes[search.keyByte] & 0xF0) !=
(search.entry->keyBytes[search.keyByte] & 0xF0))) {
search.matches = ZI8_FALSE;
}
if (bVar1) {
bVar2 = local_56;
if ((param->elementCount & 1) == 0) {
if ((*(ziU8*)(local_44 + local_55) & 0xF0) == 0) {
if (local_56 == 0) {
goto LAB_000113B0;
}
bVar2 = *options;
}
if (bVar2 == 0) {
goto LAB_00011478;
if (search.matches) {
if (param->elementCount % 2 != 0) {
if ((search.entry->keyBytes[search.keyByte] & 0xF) != 0) {
if (search.matchPass == 0) goto next_entry;
} else if (search.matchPass != 0 && options->countOnly == 0) {
goto next_entry;
}
} else {
if ((*(ziU8*)(local_44 + local_55) & 0xF) != 0) {
goto LAB_000113AC;
}
if (local_56 != 0) {
bVar2 = *options;
goto LAB_000113AC;
if ((search.entry->keyBytes[search.keyByte] & 0xF0) != 0) {
if (search.matchPass == 0) goto next_entry;
} else if (search.matchPass != 0 && options->countOnly == 0) {
goto next_entry;
}
}
LAB_000113AC:
if (bVar2 == 0) {
goto LAB_00011478;
}
LAB_000113B0:
if (local_50 == 0) {
if (*options == 0) {
param->candidates[local_54] =
(ziU16)((*(ziU8*)(local_30 * 9 + iVar4 + 7) << 8) |
*(ziU8*)(local_30 * 9 + iVar4 + 8));
local_54 = local_54 + 1;
bVar2 = param->letters + 1;
param->letters = bVar2;
if (param->maxCandidates <= bVar2) {
uVar6 = param->letters;
goto LAB_000114C4;
}
} else {
local_34 = local_34 + 1;
if (*(ziS32*)(options + 0xC) <= (ziS32)local_34) {
uVar6 = *(ziU32*)(options + 0xC);
goto LAB_000114C4;
}
}
if (search.remainingCandidates != 0) {
--search.remainingCandidates;
} else if (options->countOnly != 0) {
if (++search.resultCount >= (ziS32)options->maxCount) return options->maxCount;
} else {
local_50 = local_50 + -1;
param->candidates[search.candidateCount++] =
(ziU16)((ziU16)((ZiKoreanKeyEntry*)(((search.tableIndex << 3) + search.tableIndex) + keyTable))->characterHigh << 8 |
((ZiKoreanKeyEntry*)(((search.tableIndex << 3) + search.tableIndex) + keyTable))->characterLow);
if (++param->letters >= param->maxCandidates) return param->letters;
}
}
LAB_00011478:
next_entry:
;
}
local_56 = local_56 + 1;
} while (local_56 < 2);
uVar6 = local_34;
if (*options == 0) {
uVar6 = param->letters;
}
} else {
param->letters = 0;
uVar6 = 0;
} while (++search.matchPass < 2);
}
if (options->countOnly != 0) return search.resultCount;
return param->letters;
}
LAB_000114C4:
return uVar6;
return 0;
}

View File

@@ -0,0 +1,214 @@
#include <zi8clib/zconvert.h>
#include <zi8clib/zierror.h>
#include <zi8clib/zmtkey.h>
typedef struct ziUserKeyMap { ziWChar* upper[32]; ziWChar* lower[32]; } ziUserKeyMap;
ziU16 Zi8GetTableCount(ziU8 language, ziU8 tableIndex, ziPtr __zi8_work_data);
ziU32 Zi8GetTableAddress(ziU8 language, ziU8 tableIndex, ziPtr __zi8_work_data);
ziU8 Zi8getKeyLayout(ziU8 language, ziWChar key, ziWChar* chars, ziU8 mode, ziPtr __zi8_work_data);
ziBool Zi8_81484484(ziWChar character, ziWChar* output, ziPtr __zi8_work_data) {
if (character == 0xeffa) {
*output = 0;
} else if ((character >= 0xeff1) && (character <= 0xeff9)) {
*output = character - 0xeff0;
} else if ((character >= 0xeffb) && (character <= 0xf010)) {
*output = character - 0xeff1;
} else {
return 0;
}
return 1;
}
static ziU8 ziNumKeysWithChars(ziU8 language, ziPtr __zi8_work_data) {
ziU16 tableCount;
ziU8* table;
ziU32 totalCharacters;
ziU32 keyIndex;
tableCount = Zi8GetTableCount(language, 0x1e, __zi8_work_data);
table = (ziU8*)Zi8GetTableAddress(language, 0x1e, __zi8_work_data);
if (tableCount == 0) {
return 0x0c;
}
keyIndex = totalCharacters = 0;
for (; (ziU16)keyIndex < 0x20; keyIndex++) {
totalCharacters += table[(ziU16)keyIndex];
}
if ((ziS32)tableCount >= (((ziS32)(totalCharacters & 0xffff) * 4) + 0x20)) {
return 0x20;
}
return 0x0c;
}
ziBool Zi8getKeyLayout(ziU8 language, ziWChar key, ziWChar* chars, ziU8 mode, ziPtr __zi8_work_data) {
ziU16 tableCount;
ziU8 numKeys;
ziU8* dataAddress;
ziUserKeyMap* customTable;
ziU16 charCount;
ziU16 keyIndex;
ziWChar* keyChars;
dataAddress = 0;
numKeys = ziNumKeysWithChars(language, __zi8_work_data);
Zi8LogError(0x64, __zi8_work_data);
*chars = 0;
if (ZI_WORK->userKeys[language] != 0) {
customTable = ZI_WORK->userKeys[language];
if (!Zi8_81484484(key, &key, __zi8_work_data)) {
return 0;
}
keyChars = customTable->lower[key];
for (keyIndex = 0; keyChars[(ziU16)keyIndex] != 0; keyIndex++) {
chars[(ziU16)keyIndex] = keyChars[(ziU16)keyIndex];
}
chars[(ziU16)keyIndex] = 0;
return 1;
} else {
if (mode == 1) {
goto table_1e;
}
if ((tableCount = Zi8GetTableCount(language, 0x1d, __zi8_work_data)) == 0) {
goto table_1e;
}
{
dataAddress = (ziU8*)Zi8GetTableAddress(language, 0x1d, __zi8_work_data);
goto tables_ready;
}
table_1e:
if ((tableCount = Zi8GetTableCount(language, 0x1e, __zi8_work_data)) != 0) {
dataAddress = (ziU8*)Zi8GetTableAddress(language, 0x1e, __zi8_work_data);
}
tables_ready:
if (dataAddress == 0) {
Zi8ReplaceLastError(0x962, __zi8_work_data);
return 0;
}
if (!Zi8_81484484(key, &key, __zi8_work_data) || (key >= numKeys)) {
Zi8ReplaceLastError(300, __zi8_work_data);
return 0;
}
tableCount = 0;
keyIndex = tableCount;
for (; (ziU16)keyIndex < key; keyIndex++) {
tableCount += dataAddress[(ziU16)keyIndex];
}
if ((charCount = (ziU8)dataAddress[key]) == 0) {
return 0;
}
dataAddress = dataAddress + numKeys + (tableCount * 2);
keyIndex = 0;
for (; (ziU16)keyIndex < charCount; keyIndex++) {
chars[(ziU16)keyIndex] = (ziU16)dataAddress[(ziU16)keyIndex * 2] |
((ziU16)dataAddress[((ziU16)keyIndex * 2) + 1] << 8);
}
chars[(ziU16)keyIndex] = 0;
return 1;
}
}
ziBool Zi8ChangeCharCase(ziBool upper, ziWChar* character, ziU8 language ZI_NEED_WORK) {
ziU8 changed;
ziU16 total;
ziU16 tableCount;
ziU8* dataAddress;
ziUserKeyMap* customTables;
ziU8 numKeys;
ziS16 direction;
ziU16 result;
ziS32 keyIndex;
ziPtr from;
ziPtr to;
ziS32 characterIndex;
customTables = 0;
dataAddress = 0;
changed = 0;
numKeys = 0x20;
Zi8LogError(0x64, ZI_WORK);
if (ZI_WORK->userKeys[language] != 0) {
customTables = (ziUserKeyMap*)ZI_WORK->userKeys[language];
} else if (ZI_WORK->unk_0x11FC != 0) {
customTables = (ziUserKeyMap*)ZI_WORK->unk_0x11FC;
} else {
tableCount = Zi8GetTableCount(language, 0x1e, ZI_WORK);
if (tableCount != 0) {
dataAddress = (ziU8*)Zi8GetTableAddress(language, 0x1e, ZI_WORK);
numKeys = ziNumKeysWithChars(language, ZI_WORK);
} else {
Zi8ReplaceLastError(0x138d, ZI_WORK);
return 0;
}
}
if (customTables != 0) {
for (keyIndex = 0; (changed == 0) && (keyIndex < (ziS32)(ziU32)numKeys); keyIndex++) {
if (upper != 0) {
from = (ziPtr)customTables->lower[keyIndex];
to = (ziPtr)customTables->upper[keyIndex];
} else {
from = (ziPtr)customTables->upper[keyIndex];
to = (ziPtr)customTables->lower[keyIndex];
}
if ((from != 0) && (to != 0)) {
for (characterIndex = 0; ((ziU16)((ziS16*)from)[characterIndex]) != 0; characterIndex++) {
if ((ziU16)((ziS16*)from)[characterIndex] == *character) {
*character = (ziU16)((ziWChar*)to)[characterIndex];
changed = 1;
break;
}
}
}
}
}
else if (dataAddress != 0) {
total = 0;
for (keyIndex = 0; keyIndex < (ziS32)(ziU32)numKeys; keyIndex++) {
total += dataAddress[keyIndex];
}
dataAddress = dataAddress + numKeys;
direction = 1;
if (upper == 0) {
dataAddress = dataAddress + ((ziU32)total * 2);
direction = -1;
}
for (keyIndex = 0; keyIndex < (ziS32)(ziU32)total; keyIndex++) {
tableCount = (ziU16)(dataAddress[(keyIndex * 2)] |
((ziU16)dataAddress[(keyIndex * 2) + 1] << 8));
if (tableCount == *character) {
dataAddress = dataAddress + ((ziS32)direction * ((ziU32)total * 2));
*character = (ziU16)(dataAddress[(keyIndex * 2)] |
((ziU16)dataAddress[(keyIndex * 2) + 1] << 8));
changed = 1;
break;
}
}
}
if (changed == 0) {
result = 0;
if (upper != 0) {
if (((*character >= 0x61) && (*character <= 0x7a)) || ((*character >= 0xf1) && (*character <= 0xf6)) ||
((*character >= 0xf8) && (*character <= 0xfe)) || ((*character >= 0xe0) && (*character <= 0xef))) {
result = *character - 0x20;
} else if (*character == 0xff) {
result = 0x178;
}
} else {
if (((*character >= 0x41) && (*character <= 0x5a)) || ((*character >= 0xd1) && (*character <= 0xd6)) ||
((*character >= 0xd8) && (*character <= 0xde)) || ((*character >= 0xc0) && (*character <= 0xcf))) {
result = *character + 0x20;
} else if (*character == 0x178) {
result = 0xff;
}
}
if ((result != 0) && Zi8ConvertWC2UC(result, language, ZI_WORK)) {
*character = result;
changed = 1;
}
}
return changed;
}

View File

@@ -0,0 +1,82 @@
#include <stddef.h>
#include <zi8clib/zitypes.h>
#include <zi8clib/zierror.h>
#include <zi8clib/zconvert.h>
#include <zi8clib/zmtkey.h>
ziU8 Zi8AttachOEMdata(ziU8 (*match)(ziU16, ziWChar*, ziU8, ziPtr), ziU16 count, ziPtr data ZI_NEED_WORK) {
ZI_WORK->oemMatch = match;
ZI_WORK->oemLen = count;
ZI_WORK->oemData = data;
Zi8LogError(100, __zi8_work_data);
return 1;
}
ziU8 Zi8DetachOEMdata(ziU8 id ZI_NEED_WORK) {
Zi8LogError(100, __zi8_work_data);
if (id != 1 || ZI_WORK->oemMatch == 0) return 0;
{
ZI_WORK->oemMatch = 0;
ZI_WORK->oemLen = 0;
return 1;
}
return 0;
}
ziU8 Zi8MatchOEMdata(ziWChar* pattern, ziU8 length, ziU8 language, ziWChar* word, ziU16 capacity, ziBool complete, ziBool continuation ZI_NEED_WORK) {
ziWChar folded;
ziS32 index;
ziU32 position;
ziU32 fallback = 0;
if (!continuation) ZI_WORK->oemIdx = 0;
index = ZI_WORK->oemIdx;
if ((ziS32)index >= ZI_WORK->oemLen) goto failed;
if (ZI_WORK->oemMatch == 0) goto failed;
capacity--;
if ((ziS32)length >= (ziS32)capacity) {
failed:
return 0;
}
word[capacity] = 0;
if (complete) word[length] = 1; else word[length] = 0;
goto matchRetry;
posEntry:
position = 0;
if ((complete && word[length] == 0) || (!complete && word[length] != 0)) {
for (; (ziS32)position < length; position++) {
if (pattern[position] >= 0xEFF1 && pattern[position] <= 0xF37F) {
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;
folded = pattern[position];
if (!Zi8ChangeCharCase(1, &folded, language, __zi8_work_data) || folded != word[position]) break;
}
}
}
if ((ziS32)position < length) {
if (complete) word[length] = 1; else word[length] = 0;
index++;
if ((ziS32)index >= ZI_WORK->oemLen) goto oemFailed;
goto matchRetry;
}
if (fallback) {
index = 0;
*word = *pattern;
return 1;
}
index++;
ZI_WORK->oemIdx = index;
while (word[position] != 0) position++;
return position;
matchRetry:
if ((ziS32)index >= ZI_WORK->oemLen) goto oemFailed;
if (!ZI_WORK->oemMatch(index, word, capacity, ZI_WORK->oemData)) goto oemFailed;
goto posEntry;
oemFailed:
if (length != 1 || !complete || continuation) goto tail0;
complete = 0;
fallback = 1;
index = 0;
goto matchRetry;
tail0:
return 0;
}

View File

@@ -0,0 +1,336 @@
#include <zi8clib/zitypes.h>
void Zi8Memset(ziPtr, ziU32, ziU32);
void Zi8Memcpy(ziPtr, ziPtr, ziU32);
ziBool Zi8IsComponent(ziWChar ZI_NEED_WORK);
ziU32 Zi8GetTableAddress(ziU8, ziU8 ZI_NEED_WORK);
ziU16 Zi8GetTableCount(ziU8, ziU8 ZI_NEED_WORK);
ziU8 Zi8GetPyPhonetic(ziWChar*, ziU8, ziWChar*, ziWChar*, ziU8*, ziWChar*, ziWChar* ZI_NEED_WORK);
ziU8 Zi8GetBpmfPhonetic(ziWChar*, ziU8, ziWChar*, ziWChar*, ziWChar*, ziWChar* ZI_NEED_WORK);
ziBool Zi8PrepareMatch(ziGetParam* request, ziMatchParam* match, ziU8 skipMode ZI_NEED_WORK) {
ziU16 element;
ziU16 phoneticCount;
ziU16 phoneticInitial;
ziU16 phoneticMask;
ziU16 phoneticCode;
ziU16 phoneticLength;
ziWChar initial;
ziWChar final;
ziWChar bestInitial;
ziWChar bestFinal;
ziWChar previousInitial;
ziWChar previousFinal;
ziU8 elementCount;
ziU8 elementIndex;
ziU8 stroke;
ziU8 contextMask;
ziU8 mode;
ziU8 savedNibbles;
struct {
ziWChar* phoneticInput;
ziU8* phoneticTable;
ziU8 strokePrefix[4];
ziU8 maskPrefix[4];
ziU8* componentIndex;
ziU8* component;
ziU8 strokes[12];
ziU8 masks[12];
} buffers;
ziU8 nibbles;
ziU8 index;
stroke = 0;
contextMask = 0x20;
Zi8Memset(match,0,0x1ee);
nibbles = 0;
elementIndex = 0;
elementCount = request->elementCount;
while (elementCount != 0) {
if (request->elements[elementCount - 1] != 0xEF09) break;
elementCount--;
}
match->count = elementCount;
for (index = 0; index < elementCount; index++) {
if (request->elements[index] != 0xEF00) {
match->count = 0;
break;
}
}
if (elementCount != 0) {
match->comp = element = request->elements[0];
if (Zi8IsComponent(element,__zi8_work_data) != 0) {
elementIndex++;
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;
buffers.component += (ziU32)match->field22 * 8;
switch(*buffers.component & 0xf) {
case 0:
case 9:
case 10:
default:
break;
case 1:
match->comp = 0xEF00 + 4;
break;
case 2:
match->comp = 0xEF00 + 1;
break;
case 3:
case 0xb:
match->comp = 0xEF00 + 7;
break;
case 4:
match->comp = 0xEF00 + 6;
break;
case 5:
match->comp = 0xEF00 + 3;
break;
case 6:
match->comp = 0xEF00 + 5;
break;
case 7:
match->comp = 0xEF00 + 8;
break;
case 8:
match->comp = 0xEF00 + 2;
}
for (index = 0; index < (buffers.component[5] >> 1) + 1; index++) {
if (index < 4) {
match->arrD[index] = buffers.component[index];
match->arr1[index] = 0xff;
}
}
if ((index != 0) && ((buffers.component[5] & 1) == 0)) {
index--;
match->arrD[index] &= 0xf0;
match->arr1[index] &= 0xf0;
}
nibbles = (ziU8)(buffers.component[5] + 1);
if (8 < nibbles) {
nibbles++;
}
}
}
match->arr1[0] &= 0xf;
match->arrD[0] &= 0xf;
if (skipMode == '\0') {
mode = 0;
if ((request->subLanguage & 0x80) != 0 || (request->subLanguage & 0x40) != 0) {
mode = 1;
} else if ((request->subLanguage & 8) != 0) {
mode = 4;
} else if ((request->subLanguage & 0x20) != 0 || (request->subLanguage & 0x10) != 0) {
mode = 2;
}
if (mode == 0) {
mode = request->subLanguage;
}
switch (mode) {
case 1:
case 2:
case 4:
match->arr1[0] |= (ziU8)(mode << 4);
match->arrD[0] |= (ziU8)(mode << 4);
break;
}
}
if (nibbles == 0) {
nibbles = 1;
}
if (((request->getMode == '\0') || (request->getMode == '\x10')) ||
(request->getMode == '\x05')) {
Zi8Memcpy(buffers.masks,match->arr1,0xc);
Zi8Memcpy(buffers.strokes,match->arrD,0xc);
do {
while (elementIndex < elementCount) {
element = request->elements[elementIndex++];
switch (element) {
case 0xef02: stroke = 0; break;
case 0xef04: stroke = 1; break;
case 0xef01: stroke = 2; break;
case 0xef07: stroke = 3; break;
case 0xef06: stroke = 4; break;
case 0xef03: stroke = 5; break;
case 0xef05: stroke = 6; break;
case 0xef08: stroke = 7; break;
case 0xef0b: stroke = 8; break;
case 0xef0a: stroke = 4; break;
case 0xf360: stroke = 0xff; break;
default: stroke = 0; break;
}
if (stroke == 0xff) break;
if (0x17 < nibbles) {
match->length = 0x18;
return 0;
}
if (nibbles == 8) {
nibbles++;
}
if ((nibbles & 1) != 0) {
buffers.strokes[nibbles >> 1] |= stroke;
if (element == 0xef0b) {
buffers.masks[nibbles >> 1] |= 8;
}
else if (element == 0xef0a) {
buffers.masks[nibbles >> 1] |= 4;
}
else if (element != 0xef00) {
buffers.masks[nibbles >> 1] |= 7;
}
} else {
buffers.strokes[nibbles >> 1] |= stroke << 4;
if (element == 0xef0b) {
buffers.masks[nibbles >> 1] |= 0x80;
}
else if (element == 0xef0a) {
buffers.masks[nibbles >> 1] |= 0x40;
}
else if (element != 0xef00) {
buffers.masks[nibbles >> 1] |= 0x70;
}
}
nibbles++;
}
savedNibbles = nibbles;
for (index = 0; index < 4; index++) {
buffers.maskPrefix[index] = buffers.masks[index];
buffers.strokePrefix[index] = buffers.strokes[index];
}
if ((1 < nibbles) && (nibbles < 8)) {
index = nibbles >> 1;
if ((nibbles & 1) != 0) {
buffers.maskPrefix[index] = buffers.maskPrefix[index] | 0xf;
buffers.strokePrefix[index] = buffers.strokePrefix[index] | 0xf;
} else {
buffers.maskPrefix[index] = buffers.maskPrefix[index] | 0xf0;
buffers.strokePrefix[index] = buffers.strokePrefix[index] | 0xf0;
}
}
if (match->nSeg == 0) {
Zi8Memcpy(match->arr1,buffers.masks,0xc);
Zi8Memcpy(match->arrD,buffers.strokes,0xc);
Zi8Memcpy(match->arr19,buffers.maskPrefix,4);
Zi8Memcpy(match->arr1D,buffers.strokePrefix,4);
match->length = savedNibbles;
}
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;
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);
}
match->length = nibbles;
if (elementCount != 0) {
if ((request->getMode == '\x01') || (request->getMode == '\f')) {
buffers.phoneticTable = (ziU8*)Zi8GetTableAddress(1,3,__zi8_work_data);
phoneticCount = Zi8GetTableCount(1,3,__zi8_work_data);
}
else {
buffers.phoneticTable = (ziU8*)Zi8GetTableAddress(1,4,__zi8_work_data);
phoneticCount = Zi8GetTableCount(1,4,__zi8_work_data);
}
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);
}
else {
initial = 0;
final = 0;
bestInitial = 0;
bestFinal = 0;
previousInitial = 0;
previousFinal = 0;
buffers.phoneticInput = request->elements;
match->nCand = 0;
request->count = request->elementCount;
phoneticLength = 1;
for (index = 0; index < elementCount; index++) {
stroke = Zi8GetBpmfPhonetic(buffers.phoneticInput,phoneticLength,&initial,&final,&bestInitial,&bestFinal,
__zi8_work_data);
if (stroke != 0) {
previousInitial = bestInitial;
previousFinal = bestFinal;
savePhonetic:
match->phon[match->nCand] = initial;
match->phon2[match->nCand] = final;
if (match->nCand == 0) {
match->first = bestInitial;
match->first2 = bestFinal;
}
}
else {
if ((index == 0) ||
((((1 < phoneticLength && (buffers.phoneticInput[phoneticLength - 2] == 0xF360)) &&
(buffers.phoneticInput[phoneticLength - 1] == 0xF360)) ||
(++match->nCand == 0x10)))) {
initial = 0xffff;
final = 0xffff;
bestInitial = 0xffff;
bestFinal = 0xffff;
match->nCand = 0;
break;
}
if (buffers.phoneticInput[phoneticLength - 1] == 0xF360) {
match->nCand--;
bestInitial = previousInitial;
bestFinal = previousFinal;
final = bestFinal;
initial = bestInitial;
goto savePhonetic;
}
if (match->nCand == 1) {
request->count = phoneticLength - 1;
}
buffers.phoneticInput = buffers.phoneticInput + phoneticLength - 1;
phoneticLength = 0;
index--;
}
phoneticLength++;
}
if (elementCount != 0) {
match->phon[match->nCand] = initial;
match->phon2[match->nCand] = final;
if (match->nCand == 0) {
match->first = bestInitial;
match->first2 = bestFinal;
}
match->nCand++;
}
}
if (((request->context & contextMask) != 0) &&
((1 < match->nCand || (request->count != elementCount)))) {
match->phon[0] = 0xFFFF;
match->phon2[0] = 0xFFFF;
match->nCand = 0;
}
if (((request->getOptions & 0x20) == 0) &&
((match->phon[0] != 0xFFFF || (match->phon2[0] != 0xFFFF)))) {
if (match->nCand > 1) {
phoneticInitial = match->phon[match->nCand - 1] & 0xfff8;
phoneticMask = match->phon2[match->nCand - 1] & 0xfff8;
}
else {
phoneticInitial = match->phon[0] & 0xfff8;
phoneticMask = match->phon2[0] & 0xfff8;
}
for (phoneticLength = 0; phoneticLength < phoneticCount; phoneticLength++) {
phoneticCode = buffers.phoneticTable[phoneticLength * 2] | ((ziU16)buffers.phoneticTable[phoneticLength * 2 + 1] << 8);
if (phoneticMask == (phoneticCode & phoneticInitial)) break;
}
if (phoneticLength == phoneticCount) {
match->phon[0] = 0xFFFF;
match->phon2[0] = 0xFFFF;
}
}
}
complete:
return 1;
}

View File

@@ -0,0 +1,220 @@
#include <private/axfx.h>
#include <revolution/axfx.h>
#include <revolution/os.h>
#include <string.h>
static BOOL __InitParams(AXFX_CHORUS_EXP* fx);
static void __CalcLFO(s32* output, AXFX_CHORUS_EXP_LFO* lfo);
static BOOL __AllocDelayLine(AXFX_CHORUS_EXP* fx) {
u32 channel;
for (channel = 0; channel < 3; channel++) {
fx->delay.line[channel] = __AXFXAlloc(fx->delay.size * sizeof(f32));
if (fx->delay.line[channel] == NULL) return FALSE;
}
return TRUE;
}
static BOOL __BzeroDelayLine(AXFX_CHORUS_EXP* fx) {
u32 channel;
for (channel = 0; channel < 3; channel++) {
if (fx->delay.line[channel] == NULL) return FALSE;
memset(fx->delay.line[channel], 0, fx->delay.size * sizeof(f32));
}
fx->delay.inPos = 0;
fx->delay.outPos = (fx->delay.size - (u32)(32.0f * fx->delayTime)) << 16;
fx->delay.lastPos = fx->delay.outPos;
fx->delay.sizeFP = fx->delay.size << 16;
return TRUE;
}
u32 AXFXChorusExpGetMemSize(const AXFX_CHORUS_EXP* fx) {
return 0x9600;
}
BOOL AXFXChorusExpInit(AXFX_CHORUS_EXP* fx) {
BOOL enabled = OSDisableInterrupts();
fx->active |= 1;
fx->delay.size = 3200;
if (!__AllocDelayLine(fx)) {
AXFXChorusExpShutdown(fx);
OSRestoreInterrupts(enabled);
return FALSE;
}
if (!__BzeroDelayLine(fx)) {
AXFXChorusExpShutdown(fx);
OSRestoreInterrupts(enabled);
return FALSE;
}
if (!__InitParams(fx)) {
AXFXChorusExpShutdown(fx);
OSRestoreInterrupts(enabled);
return FALSE;
}
fx->active &= ~1;
OSRestoreInterrupts(enabled);
return TRUE;
}
BOOL AXFXChorusExpSettings(AXFX_CHORUS_EXP* fx) {
BOOL result;
BOOL enabled = OSDisableInterrupts();
fx->active |= 1;
AXFXChorusExpShutdown(fx);
result = AXFXChorusExpInit(fx);
if (!result) {
AXFXChorusExpShutdown(fx);
OSRestoreInterrupts(enabled);
return FALSE;
}
fx->active = (fx->active | 2) & ~1;
OSRestoreInterrupts(enabled);
return result;
}
void AXFXChorusExpShutdown(AXFX_CHORUS_EXP* fx) {
BOOL enabled = OSDisableInterrupts();
u32 channel;
fx->active |= 1;
for (channel = 0; channel < 3; channel++) {
if (fx->delay.line[channel] != NULL) __AXFXFree(fx->delay.line[channel]);
fx->delay.line[channel] = NULL;
}
OSRestoreInterrupts(enabled);
}
void AXFXChorusExpCallback(AXFX_BUFFERUPDATE* update, AXFX_CHORUS_EXP* fx) {
s32* output[3];
s32* input[3];
s32* send[3];
s32 modulation[96];
u32 sample;
if (fx->active != 0) {
fx->active &= ~2;
return;
}
output[0] = update->left;
output[1] = update->right;
output[2] = update->surround;
if (fx->busIn != NULL) {
input[0] = fx->busIn->left;
input[1] = fx->busIn->right;
input[2] = fx->busIn->surround;
}
if (fx->busOut != NULL) {
send[0] = fx->busOut->left;
send[1] = fx->busOut->right;
send[2] = fx->busOut->surround;
}
__CalcLFO(modulation, &fx->lfo);
for (sample = 0; sample < 96; sample++) {
s32 position = fx->delay.outPos + modulation[sample];
u32 distance;
u32 whole, fraction, source, history, channel;
f32* coefficients;
if (position >= (s32)fx->delay.sizeFP) position -= fx->delay.sizeFP;
else if (position < 0) position += fx->delay.sizeFP;
distance = position - fx->delay.lastPos;
if ((s32)distance < 0) distance += fx->delay.sizeFP;
whole = (u32)distance >> 16;
fraction = distance & 0xFFFF;
source = fx->delay.lastPos >> 16;
history = fx->histIndex;
while (whole != 0) {
fx->history[0][history] = fx->delay.line[0][source];
fx->history[1][history] = fx->delay.line[1][source];
fx->history[2][history] = fx->delay.line[2][source];
history = (history + 1) & 3;
source++;
if (source >= fx->delay.size) source = 0;
whole--;
}
fx->delay.lastPos = position & 0xFFFF0000;
coefficients = __AXFXGetSrcCoef((fraction >> 9) & 0x7F);
for (channel = 0; channel < 3; channel++) {
f32 filtered = 0.0f;
f32 dry;
filtered += coefficients[0] * fx->history[channel][history];
history = (history + 1) & 3;
filtered += coefficients[1] * fx->history[channel][history];
history = (history + 1) & 3;
filtered += coefficients[2] * fx->history[channel][history];
history = (history + 1) & 3;
filtered += coefficients[3] * fx->history[channel][history];
history = (history + 1) & 3;
if (fx->busIn != NULL) dry = *input[channel]++ + *output[channel];
else dry = *output[channel];
fx->delay.line[channel][fx->delay.inPos] = dry + filtered * fx->feedback;
*output[channel]++ = filtered * fx->outGain;
if (fx->busOut != NULL) *send[channel]++ = filtered * fx->sendGain;
}
fx->histIndex = history;
fx->delay.inPos++;
if (fx->delay.inPos >= fx->delay.size) fx->delay.inPos = 0;
fx->delay.outPos += 0x10000;
if (fx->delay.outPos >= fx->delay.sizeFP) fx->delay.outPos = 0;
}
}
static BOOL __InitParams(AXFX_CHORUS_EXP* fx) {
f32 delay, depth, step;
if (fx->delayTime < 0.1f || fx->delayTime > 50.0f) return FALSE;
if (fx->depth < 0.0f || fx->depth > 1.0f) return FALSE;
if (fx->rate < 0.1f || fx->rate > 2.0f) return FALSE;
if (fx->feedback < 0.0f || fx->feedback >= 1.0f) return FALSE;
if (fx->outGain < 0.0f || fx->outGain > 1.0f) return FALSE;
if (fx->sendGain < 0.0f || fx->sendGain > 1.0f) return FALSE;
fx->lfo.table = __AXFXGetLfoSinTable();
delay = 32.0f * fx->delayTime;
depth = delay * fx->depth;
if (delay <= depth) {
depth -= 1.0f;
if (depth < 0.0f) depth = 0.0f;
}
fx->lfo.depthSamp = 65536.0f * depth;
fx->lfo.phaseAdd = 65536.0f * (256.0f * fx->rate / 32000.0f);
step = (32000.0f / fx->rate) * (1.0f / 256.0f);
fx->lfo.stepSamp = 65536.0f * step;
fx->lfo.gradFactor = 65536.0f * (depth / step);
fx->lfo.lastNum = -1;
fx->lfo.phase = 0;
fx->lfo.sign = 0;
fx->lfo.lastValue = 0;
fx->lfo.grad = 0;
fx->history[0][0] = 0.0f;
fx->history[0][1] = 0.0f;
fx->history[0][2] = 0.0f;
fx->history[0][3] = 0.0f;
fx->history[1][0] = 0.0f;
fx->history[1][1] = 0.0f;
fx->history[1][2] = 0.0f;
fx->history[1][3] = 0.0f;
fx->history[2][0] = 0.0f;
fx->history[2][1] = 0.0f;
fx->history[2][2] = 0.0f;
fx->history[2][3] = 0.0f;
fx->histIndex = 0;
return TRUE;
}
static void __CalcLFO(s32* output, AXFX_CHORUS_EXP_LFO* lfo) {
u32 remaining = 96;
do {
s32 value;
u32 phase = lfo->phase & 0xFFFF0000;
if (phase != lfo->lastNum) {
s32 start, difference;
s64 product;
lfo->lastNum = phase;
phase >>= 16;
start = lfo->table[phase];
difference = lfo->table[(phase + 1) & 0x7F] - start;
product = (s64)start * lfo->depthSamp;
value = ((u32)(product >> 32) << 8) | ((u32)product >> 24);
product = (s64)difference * lfo->gradFactor;
lfo->grad = ((u32)(product >> 32) << 8) | ((u32)product >> 24);
}
else value = lfo->lastValue + lfo->grad;
lfo->lastValue = value;
if (lfo->sign != 0) value = -value;
lfo->phase += lfo->phaseAdd;
if (lfo->phase & 0xFF800000) {
lfo->phase &= 0x7FFFFF;
lfo->sign ^= 1;
}
*output++ = value;
remaining--;
} while (remaining != 0);
}

View File

@@ -1,9 +1,9 @@
#include <revolution/fa.h>
#include <revolution/os.h>
char* __FAVersion = "<< RVL_SDK - FA \trelease build: Apr 20 2010 11:20:14 (0x4199_60831) >>";
s32 FAFileSysInitialized;
char* __FAVersion[2] = {"<< RVL_SDK - FA \trelease build: Apr 20 2010 11:20:14 (0x4199_60831) >>", NULL};
s32 FAInInitializing;
s32 FAFileSysInitialized;
extern s32 FADiskInitialized;
extern s32 pdm_init_diskmanager(s32 config, void* parameter);
extern s32 pfstub_init_prfile2(s32 config, void* parameter);
@@ -31,6 +31,6 @@ FAError FAInit(int flag) {
}
}
FAInInitializing = 0;
OSRegisterVersion(__FAVersion);
OSRegisterVersion(__FAVersion[0]);
return 0;
}

View File

@@ -1,7 +1,7 @@
#include <revolution/fa.h>
static FAInsertCallback g_attach_func;
static FAEjectCallback g_detach_func;
static FAInsertCallback g_attach_func;
extern s32 uhf_msc_is_media_insert(void);

View File

@@ -24,9 +24,9 @@ char NAND_Org_Path[64];
NAND_DISK_INFO nanddisk_info[23];
NAND_SEMAPHORE csem;
NAND_SEMAPHORE osem;
s32 Nanddisk_Internal_Info_Init;
s32 NAND_Init;
s32 fa_nanad_semid;
s32 Nanddisk_Internal_Info_Init = 0;
s32 NAND_Init = 0;
s32 fa_nanad_semid = 0;
static inline s32 find_disk(PDM_DISK* disk, NAND_DISK_INFO** result) {
NAND_DISK_INFO* info;
@@ -169,13 +169,14 @@ static s32 fa_nanddrv_ParseCreateNANDFile(NAND_DISK_INFO* info) {
if (error == 0 || error == -6 || error == -1) {
error = NANDChangeDir(name);
if (error != 0) { return error; }
path++;
pf_memset(name, 0, 16);
next = name;
length = 0;
break;
} else {
return error;
}
return error;
path++;
pf_memset(name, 0, 16);
next = name;
length = 0;
break;
case 0:
if (length > 12) { return -20; }
error = NANDCreate(name, 0x30, 0);
@@ -403,8 +404,8 @@ s32 fa_nanddrv_init_drv_tbl(PDM_DISK_TBL* table, u32 extension) {
return 0;
}
s32 fa_nanddrv_NotifyNANDFile(const char* path, u32 size) {
NAND_DISK_INFO* info;
u16 index;
if (pf_strlen(path) >= 76) { return -20; }
if (Nanddisk_Internal_Info_Init == 0) {
pf_memset(nanddisk_info, 0, sizeof(nanddisk_info));
@@ -416,10 +417,9 @@ s32 fa_nanddrv_NotifyNANDFile(const char* path, u32 size) {
if (fa_nanad_semid == 0) { return -21; }
}
for (index = 0; index < 23; index++) {
info = &nanddisk_info[index];
if (pf_strcmp(info->path, path) == 0) { return 0; }
if (pf_strcmp(nanddisk_info[index].path, path) == 0) { return 0; }
if (nanddisk_info[index].disk == 0) {
pf_strcpy(info->path, path);
pf_strcpy(nanddisk_info[index].path, path);
nanddisk_info[index].file_size = size;
break;
}
@@ -481,15 +481,15 @@ static s32 fa_nanddrv_physical_read(u32 count, u8* buf, u32 block, u32 bps, u32*
return error;
}
static s32 fa_nanddrv_physical_write(u32 count, const u8* buf, u32 block, u32 bps, u32* success, PDM_DISK* disk) {
u32 remaining;
u32 wanted;
u32 file_size;
NAND_DISK_INFO* info = 0;
u32 wanted;
u32 remaining;
u16 index;
u32 offset;
u32 position;
s32 error;
u8 work[512] __attribute__((aligned(32)));
NAND_DISK_INFO* info = 0;
for (index = 0; index < 23; index++) {
if (nanddisk_info[index].disk == disk) { info = &nanddisk_info[index]; break; }
}

View File

@@ -6,11 +6,11 @@ extern pf_s32 pdm_part_is_attached_partition(PDM_PARTITION* partition);
pf_u8 pfd_get_media_drv_char(PDM_DISK* disk, pf_s8* drives, pf_u32 capacity) {
pf_u32 partition_index;
PDM_PARTITION* partition;
PF_VOLUME* volume;
pf_u8 count;
pf_s8* next_drive;
pf_u32 volume_index;
PDM_PARTITION* partition;
pf_u16 volume_index;
PF_VOLUME* volume;
if (drives == NULL || capacity == 0) {
return 0;
}
@@ -20,8 +20,7 @@ pf_u8 pfd_get_media_drv_char(PDM_DISK* disk, pf_s8* drives, pf_u32 capacity) {
for (partition_index = 0; partition_index < 26; partition_index++, partition++) {
if (pdm_part_is_attached_partition(partition) && partition->p_disk == disk) {
volume = pf_vol_set.volumes;
for (volume_index = 0; volume_index < 26; volume++) {
volume_index++;
for (volume_index = 0; volume_index < 26; volume_index++, volume++) {
if (volume->p_part == partition) {
count++;
*next_drive++ = volume->drv_char;

View File

@@ -1,3 +1,4 @@
#include <stddef.h>
#include <revolution/fa/types.h>
#include <revolution/os.h>
#include <revolution/sdi.h>
@@ -32,8 +33,8 @@ PFD_SDDRV_INFO g_pfd_sddrv_info;
PFD_SDDEV_STORAGE g_pfd_sddev;
u8 g_pfd_sddrv_buf[0x200];
static FAInsertCallback g_attach_func;
static FAEjectCallback g_detach_func;
static FAInsertCallback g_attach_func = 0;
static FAEjectCallback g_detach_func = 0;
u32 g_event;
extern u8 pfd_get_media_drv_char(FADisk*, s8*, u32);
@@ -135,23 +136,35 @@ typedef union PFD_SDDRV_U16_BYTES {
u8 bytes[2];
} PFD_SDDRV_U16_BYTES;
static inline void pfd_sddrv_store_le16(u8* field, u16 value) {
if (((u32)field & 1) != 0) {
field[0] = (u8)value;
field[1] = (u8)(value >> 8);
} else {
*(u16*)field = (u16)((value >> 8) | (value << 8));
}
}
#define pfd_sddrv_store_le16(buffer, field, offset, value) \
do { \
if (((u32)(field) & 1) != 0) { \
(field)[0] = (u8)(value); \
(field)[1] = (u8)((value) >> 8); \
} else { \
((u16*)(buffer))[(offset) / 2 + (offset) % 2] = (((value) & 0xff) << 8) | (((value) & 0xff00) >> 8); \
} \
} while (0)
static inline void pfd_sddrv_store_le32(u8* field, u32 value) {
if (((u32)field & 3) != 0) {
field[0] = (u8)value;
field[1] = (u8)(value >> 8);
field[2] = (u8)(value >> 16);
field[3] = (u8)(value >> 24);
} else {
*(u32*)field = (value << 24) | ((value & 0xff00) << 8) | ((value >> 8) & 0xff00) | (value >> 24);
#define pfd_sddrv_store_le32(buffer, field, offset, value) \
do { \
if (((u32)(field) & 3) != 0) { \
(field)[0] = (u8)(value); \
(field)[1] = (u8)((value) >> 8); \
(field)[2] = (u8)((value) >> 16); \
(field)[3] = (u8)((value) >> 24); \
} else { \
((u32*)(buffer))[(offset) / 4 + (offset) % 4] = (((value) & 0xff) << 24 | ((value) & 0xff00) << 8) | \
(((value) & 0xff000000) >> 24 | ((value) & 0xff0000) >> 8); \
} \
} while (0)
static inline void pfd_sddrv_copy_bytes(u8* destination, const u8* source, u32 size) {
u32 index;
if (destination != 0 && source != 0) {
for (index = 0; index < size; index++) {
destination[index] = source[index];
}
}
}
@@ -230,23 +243,39 @@ static inline void clear_mount_flag(void) {
g_pfd_sddrv_info.flags &= ~2;
}
static inline u32 pfd_sddrv_flags(const PFD_SDDRV_INFO* info) {
return info->flags;
}
static inline SDDev* pfd_sddrv_device(const PFD_SDDRV_INFO* info) {
return info->device;
}
static inline FADisk* pfd_sddrv_disk(const PFD_SDDRV_INFO* info) {
return info->disk;
}
static inline s8 pfd_sddrv_drive(const PFD_SDDRV_INFO* info) {
return info->drive;
}
s32 pfd_st_inter_callback(s32 status, void* data) {
s32 result;
if ((status & 1) != 1) {
return 0;
}
if (g_pfd_sddrv_info.device != 0) {
if (pfd_sddrv_device(&g_pfd_sddrv_info) != 0) {
g_event = 2;
result = ISD_RegisterDeviceIntrHandler(g_pfd_sddrv_info.device, (SDDevIntrCallback)pfd_st_removal_callback, &g_event);
if (result != 0) {
OSReport("ERR:Failed to regist intr handler. pfd_st_inter_callback()\n");
}
}
if (g_pfd_sddrv_info.disk != 0) {
if (pfd_sddrv_disk(&g_pfd_sddrv_info) != 0) {
update_media_drive();
pdm_disk_notify_media_insert(g_pfd_sddrv_info.disk);
if (g_pfd_sddrv_info.drive != 0 && g_attach_func != 0) {
if (pfd_sddrv_drive(&g_pfd_sddrv_info) != 0 && g_attach_func != 0) {
g_attach_func(g_pfd_sddrv_info.drive);
}
}
@@ -262,17 +291,17 @@ s32 pfd_st_removal_callback(s32 status, void* data) {
return 0;
}
g_pfd_sddrv_info.media_inserted = 0;
if (g_pfd_sddrv_info.device != 0) {
if (pfd_sddrv_device(&g_pfd_sddrv_info) != 0) {
g_event = 1;
result = ISD_RegisterDeviceIntrHandler(g_pfd_sddrv_info.device, (SDDevIntrCallback)pfd_st_inter_callback, &g_event);
if (result != 0) {
OSReport("ERR:Failed to regist intr handler. pfd_st_removal_callback()\n");
}
}
if (g_pfd_sddrv_info.disk != 0) {
if (pfd_sddrv_disk(&g_pfd_sddrv_info) != 0) {
update_media_drive();
pdm_disk_notify_media_eject(g_pfd_sddrv_info.disk);
if (g_pfd_sddrv_info.drive != 0 && g_detach_func != 0) {
if (pfd_sddrv_drive(&g_pfd_sddrv_info) != 0 && g_detach_func != 0) {
g_detach_func(g_pfd_sddrv_info.drive);
}
}
@@ -287,7 +316,7 @@ s32 pfd_sddrv_init(FADisk* disk) {
if (disk == 0) {
return -30;
}
if ((g_pfd_sddrv_info.flags & 1) != 0) {
if ((pfd_sddrv_flags(&g_pfd_sddrv_info) & 1) != 0) {
OSReport("INFO SD Card driver is already initialize. pfd_sddrv_init()\n");
if (disk == g_pfd_sddrv_info.disk) {
return 0;
@@ -444,7 +473,7 @@ s32 pfd_sddrv_unmount(FADisk* disk) {
if (disk == 0) {
return -30;
}
if ((g_pfd_sddrv_info.flags & 2) != 0) {
if ((pfd_sddrv_flags(&g_pfd_sddrv_info) & 2) != 0) {
clear_mount_flag();
}
return 0;
@@ -456,7 +485,7 @@ s32 pfd_sddrv_finalize(FADisk* disk) {
if (disk == 0) {
return -30;
}
if ((g_pfd_sddrv_info.flags & 2) != 0) {
if ((pfd_sddrv_flags(&g_pfd_sddrv_info) & 2) != 0) {
clear_mount_flag();
}
if ((g_pfd_sddrv_info.flags & 1) != 0) {
@@ -472,7 +501,6 @@ s32 pfd_sddrv_finalize(FADisk* disk) {
}
g_pfd_sddrv_info.flags = g_pfd_sddrv_info.flags & 0xfffffffe;
g_pfd_sddrv_info.media_inserted = 0;
g_pfd_sddrv_info.media_ejected = 0;
g_pfd_sddrv_info.disk = 0;
g_pfd_sddrv_info.drive = 0;
return 0;
@@ -563,7 +591,7 @@ s32 pfd_sddrv_is_media_insert(void) {
static s32 pfd_sddrv_physical_read(u32 blocks, u8* buffer, u32 sector, u32 bytes_per_sector, u32* blocks_read) {
s32 result;
u32 current_sector;
s32 current_sector;
u32 completed;
u8* current_buffer;
if ((g_pfd_sddrv_info.flags & 2) == 0) {
@@ -628,7 +656,7 @@ static s32 pfd_sddrv_physical_read(u32 blocks, u8* buffer, u32 sector, u32 bytes
s32 pfd_sddrv_physical_write(u32 blocks, u8* buffer, u32 sector, u32 bytes_per_sector, u32* blocks_written) {
s32 result;
u32 current_sector;
s32 current_sector;
u32 completed;
u8* current_buffer;
if ((g_pfd_sddrv_info.flags & 2) == 0) {
@@ -718,15 +746,10 @@ s32 pfd_sddrv_get_total_sectors(u32* sectors, u16* bytes_per_sector) {
c_size = (((csd[2] & 3) << 10 | csd[1] >> 22) + 1);
cluster_blocks = c_size * read_block_size;
multiplier = (csd[2] >> 8) & 0xf;
minimum_multiplier = 9;
if (multiplier >= 9) {
minimum_multiplier = multiplier;
}
max_multiplier = 11;
if (minimum_multiplier <= 11) {
max_multiplier = minimum_multiplier;
}
multiplier_factor = 1 << (u16)(max_multiplier - 9);
minimum_multiplier = multiplier >= 9 ? multiplier : 9;
max_multiplier = minimum_multiplier <= 11 ? minimum_multiplier : 11;
multiplier_factor = 1;
multiplier_factor <<= (u16)(max_multiplier - 9);
*sectors = cluster_blocks * multiplier_factor;
} else {
*sectors = ((csd[1] >> 8 & 0x3fffff) + 1) * 0x400;
@@ -735,247 +758,267 @@ s32 pfd_sddrv_get_total_sectors(u32* sectors, u16* bytes_per_sector) {
return 0;
}
static inline u32 pfd_sddrv_encode_serial(s32 year, s32 month, s32 day, s32 hour, s32 minute, s32 second) {
u32 date;
u32 time;
date = (day & 0x1f) | ((month & 0xf) << 5) | (((year - 1900) & 0x7f) << 9);
time = (second & 0x1f) | ((minute & 0x3f) << 5) | ((hour & 0x1f) << 11);
return (date << 16) + time;
}
s32 pfd_sddrv_calc_mbr_bpb(PFD_SDDRV_FORMAT_DATA* format_data) {
const PFD_SDDRV_SIZE_DEPEND* size_entry;
PFD_SDDRV_SIZE_SETTINGS settings;
u32 entry_index;
u32 fat_entry_bits;
u32 requested_sectors;
const PFD_SDDRV_SIZE_DEPEND* size_entry;
u32 current_start;
u32 reserved_sectors;
u32 total_sectors;
u32 fat_sectors;
u32 fat_entry_bits;
u32 fixed_sectors;
u32 start_sector;
u32 next_fat_sectors;
u64 total_sectors;
u64 reserved_sectors;
u64 fixed_sectors;
u64 start_sector;
u64 current_start;
u64 clusters;
u64 cluster_count_plus_one;
u64 candidate_fat_sectors;
u32 clusters;
u32 candidate_fat_sectors;
u32 reserve_count;
int moved_start;
int moved_start = 0;
s32 result;
OSCalendarTime current_time;
if (format_data == 0) {
return -30;
}
pf_memset(&settings, 0, 0x10);
pf_memset(&settings, 0, sizeof(settings));
requested_sectors = format_data->total_sectors;
size_entry = sddrv_size_depend_tbl;
for (entry_index = 0; entry_index < 14; entry_index++, size_entry++) {
if (size_entry->min_sectors < format_data->total_sectors && format_data->total_sectors <= size_entry->max_sectors) {
settings.reserved_sectors = size_entry->reserved_sectors;
settings.fat_copies = size_entry->fat_copies;
settings.root_entries = size_entry->root_entries;
settings.sectors_per_cluster = size_entry->sectors_per_cluster;
for (entry_index = 0; entry_index < 14; size_entry++, entry_index++) {
if (size_entry->min_sectors < requested_sectors && size_entry->max_sectors >= requested_sectors) {
settings.reserved_sectors = sddrv_size_depend_tbl[entry_index].reserved_sectors;
settings.fat_copies = sddrv_size_depend_tbl[entry_index].fat_copies;
settings.root_entries = sddrv_size_depend_tbl[entry_index].root_entries;
settings.sectors_per_cluster = sddrv_size_depend_tbl[entry_index].sectors_per_cluster;
break;
}
}
if (entry_index == 14) {
result = entry_index == 14 ? -30 : 0;
if (result != 0) {
OSReport("ERR Failed to get values with total sectors. pfd_sddrv_get_value_with_total_sectors()\n");
return -30;
return result;
}
format_data->sectors_per_cluster = settings.sectors_per_cluster;
total_sectors = format_data->total_sectors;
clusters = total_sectors / settings.sectors_per_cluster;
if (total_sectors % settings.sectors_per_cluster != 0) {
clusters++;
}
clusters = total_sectors / format_data->sectors_per_cluster;
if (clusters < 0x1005) {
fat_entry_bits = 12;
} else {
if (clusters > 0xfff4) {
return -31;
}
} else if (clusters < 0xfff5) {
fat_entry_bits = 16;
} else {
return -31;
}
if (total_sectors % format_data->sectors_per_cluster != 0) {
clusters++;
}
candidate_fat_sectors = clusters * fat_entry_bits;
fat_sectors = (u32)(candidate_fat_sectors >> 12);
fat_sectors = candidate_fat_sectors >> 12;
if ((candidate_fat_sectors & 0xfff) != 0) {
fat_sectors++;
}
reserved_sectors = settings.reserved_sectors;
for (;;) {
u64 previous_fat_sectors = fat_sectors;
fixed_sectors = previous_fat_sectors * 2 + 0x21;
fixed_sectors = fat_sectors * 2 + 0x21;
reserve_count = 1;
current_start = reserved_sectors;
do {
for (;;) {
start_sector = current_start - fixed_sectors;
if ((s64)start_sector >= 1) {
if ((s32)start_sector > 0) {
break;
}
reserve_count++;
current_start += reserved_sectors;
} while (1);
current_start = (u64)reserve_count * reserved_sectors;
start_sector = current_start - fixed_sectors;
moved_start = 0;
reserve_count++;
}
current_start = reserve_count * reserved_sectors;
for (;;) {
for (;;) {
if (!moved_start && reserved_sectors != (u32)start_sector) {
start_sector += reserved_sectors;
}
moved_start = 0;
clusters = ((total_sectors - start_sector) - fixed_sectors) / settings.sectors_per_cluster;
cluster_count_plus_one = clusters + 1;
if (cluster_count_plus_one >= 0xfe5 && cluster_count_plus_one <= 0x1004) {
break;
}
if (moved_start == 0 && reserved_sectors != start_sector) {
start_sector += reserved_sectors;
}
moved_start = 0;
clusters = (total_sectors - start_sector - fixed_sectors) / format_data->sectors_per_cluster + 1;
if (clusters >= 0xfe5 && clusters < 0x1005) {
current_start += reserved_sectors;
start_sector = current_start - fixed_sectors;
continue;
}
candidate_fat_sectors = clusters * fat_entry_bits + 2;
next_fat_sectors = (u32)(candidate_fat_sectors >> 12);
candidate_fat_sectors = (clusters - 1) * fat_entry_bits + 2;
next_fat_sectors = candidate_fat_sectors >> 12;
if ((candidate_fat_sectors & 0xfff) != 0) {
next_fat_sectors++;
}
if (next_fat_sectors <= previous_fat_sectors) {
if (next_fat_sectors <= fat_sectors) {
break;
}
start_sector += reserved_sectors;
moved_start = 1;
}
fat_sectors = next_fat_sectors;
if (fat_sectors == previous_fat_sectors) {
if (next_fat_sectors == fat_sectors) {
break;
}
fat_sectors = next_fat_sectors;
}
format_data->sectors_per_fat = fat_sectors;
format_data->partition_start_sector = (u32)start_sector;
format_data->partition_sector_count = format_data->total_sectors - (u32)start_sector;
if (((format_data->partition_sector_count - (fat_sectors * 2 + 0x21)) / format_data->sectors_per_cluster + 1) < 0xff5) {
format_data->partition_start_sector = start_sector;
format_data->partition_sector_count = format_data->total_sectors - start_sector;
clusters = (format_data->partition_sector_count - (format_data->sectors_per_fat * 2 + 0x21)) / format_data->sectors_per_cluster + 1;
if (clusters < 0xff5) {
format_data->fat_type = 0;
} else {
} else if (clusters >= 0xff5) {
format_data->fat_type = 1;
} else {
return -31;
}
OSTicksToCalendarTime(OSGetTime(), &current_time);
format_data->volume_serial_number = ((((current_time.year - 1900) & 0x7f) << 9) |
((current_time.mon & 0xf) << 5) |
(current_time.mday & 0x1f)) * 0x10000 +
(((current_time.hour & 0x1f) << 11) |
((current_time.min & 0x3f) << 5) |
(current_time.sec & 0x1f));
format_data->volume_serial_number = pfd_sddrv_encode_serial(current_time.year, current_time.mon, current_time.mday,
current_time.hour, current_time.min, current_time.sec);
return 0;
}
s32 pfd_sddrv_store_bpb_buf(PFD_SDDRV_FORMAT_DATA* format_data, u8* sector_buffer) {
const PFD_SDDRV_SIZE_DEPEND* size_entry;
PFD_SDDRV_SIZE_SETTINGS settings;
PFD_SDDRV_BPB* boot_sector;
u32 entry_index;
u32 sectors_16;
u32 requested_sectors;
const PFD_SDDRV_SIZE_DEPEND* size_entry;
u16 sectors_16;
s32 result;
u32 sectors_32;
if (format_data == 0 || sector_buffer == 0) {
if (format_data == 0) {
return -30;
}
size_entry = sddrv_size_depend_tbl;
pf_memset(&settings, 0, 0x10);
for (entry_index = 0; entry_index < 14; entry_index++, size_entry++) {
if (size_entry->min_sectors < format_data->total_sectors && format_data->total_sectors <= size_entry->max_sectors) {
settings.reserved_sectors = size_entry->reserved_sectors;
settings.fat_copies = size_entry->fat_copies;
settings.root_entries = size_entry->root_entries;
settings.sectors_per_cluster = size_entry->sectors_per_cluster;
requested_sectors = format_data->total_sectors;
size_entry = sddrv_size_depend_tbl;
for (entry_index = 0; entry_index < 14; size_entry++, entry_index++) {
if (size_entry->min_sectors < requested_sectors && size_entry->max_sectors >= requested_sectors) {
settings.reserved_sectors = sddrv_size_depend_tbl[entry_index].reserved_sectors;
settings.fat_copies = sddrv_size_depend_tbl[entry_index].fat_copies;
settings.root_entries = sddrv_size_depend_tbl[entry_index].root_entries;
settings.sectors_per_cluster = sddrv_size_depend_tbl[entry_index].sectors_per_cluster;
break;
}
}
if (entry_index == 14) {
result = entry_index == 14 ? -30 : 0;
if (result != 0) {
OSReport("ERR Failed to get values with total sectors. pfd_sddrv_get_value_with_total_sectors()\n");
return -30;
return result;
}
if (format_data->partition_sector_count == 0) {
return -30;
}
if (format_data->partition_sector_count <= 0xffff) {
sectors_16 = format_data->partition_sector_count;
sectors_32 = format_data->partition_sector_count;
if (sectors_32 != 0 && sectors_32 < 0x10000) {
sectors_16 = sectors_32;
sectors_32 = 0;
} else {
} else if (sectors_32 >= 0x10000) {
sectors_16 = 0;
sectors_32 = format_data->partition_sector_count;
} else {
return -30;
}
pf_memset(sector_buffer, 0, 0x200);
boot_sector = (PFD_SDDRV_BPB*)sector_buffer;
pfd_sddrv_copy_bytes(boot_sector->oem_name, (const u8*)" ", 8);
pfd_sddrv_copy_bytes(boot_sector->volume_label, (const u8*)"NO NAME ", 11);
if (format_data->fat_type == 0) {
pfd_sddrv_copy_bytes(boot_sector->file_system_type, (const u8*)"FAT12 ", 8);
} else {
pfd_sddrv_copy_bytes(boot_sector->file_system_type, (const u8*)"FAT16 ", 8);
}
boot_sector->jump[0] = 0xeb;
boot_sector->jump[1] = 0;
boot_sector->jump[2] = 0x90;
pf_memcpy(boot_sector->oem_name, " ", 8);
pfd_sddrv_store_le16(boot_sector->bytes_per_sector, 0x200);
pfd_sddrv_store_le16(sector_buffer, boot_sector->bytes_per_sector, offsetof(PFD_SDDRV_BPB, bytes_per_sector), 0x200);
boot_sector->sectors_per_cluster = format_data->sectors_per_cluster;
pfd_sddrv_store_le16(boot_sector->reserved_sector_count, 1);
pfd_sddrv_store_le16(sector_buffer, boot_sector->reserved_sector_count, offsetof(PFD_SDDRV_BPB, reserved_sector_count), 1);
boot_sector->fat_count = 2;
pfd_sddrv_store_le16(boot_sector->root_entry_count, 0x200);
pfd_sddrv_store_le16(boot_sector->total_sectors_16, (u16)sectors_16);
pfd_sddrv_store_le16(sector_buffer, boot_sector->root_entry_count, offsetof(PFD_SDDRV_BPB, root_entry_count), 0x200);
pfd_sddrv_store_le16(sector_buffer, boot_sector->total_sectors_16, offsetof(PFD_SDDRV_BPB, total_sectors_16), (u16)sectors_16);
boot_sector->media_descriptor = 0xf8;
pfd_sddrv_store_le16(boot_sector->sectors_per_fat_16, (u16)format_data->sectors_per_fat);
pfd_sddrv_store_le16(boot_sector->sectors_per_track, (u16)settings.root_entries);
pfd_sddrv_store_le16(boot_sector->heads, (u16)settings.fat_copies);
pfd_sddrv_store_le32(boot_sector->hidden_sectors, format_data->partition_start_sector);
pfd_sddrv_store_le32(boot_sector->total_sectors_32, sectors_32);
pfd_sddrv_store_le16(sector_buffer, boot_sector->sectors_per_fat_16, offsetof(PFD_SDDRV_BPB, sectors_per_fat_16), (u16)format_data->sectors_per_fat);
pfd_sddrv_store_le16(sector_buffer, boot_sector->sectors_per_track, offsetof(PFD_SDDRV_BPB, sectors_per_track), (u16)settings.root_entries);
pfd_sddrv_store_le16(sector_buffer, boot_sector->heads, offsetof(PFD_SDDRV_BPB, heads), (u16)settings.fat_copies);
pfd_sddrv_store_le32(sector_buffer, boot_sector->hidden_sectors, offsetof(PFD_SDDRV_BPB, hidden_sectors), format_data->partition_start_sector);
pfd_sddrv_store_le32(sector_buffer, boot_sector->total_sectors_32, offsetof(PFD_SDDRV_BPB, total_sectors_32), sectors_32);
boot_sector->drive_number = 0x80;
boot_sector->extended_signature = 0x29;
pfd_sddrv_store_le32(boot_sector->volume_serial_number, format_data->volume_serial_number);
pf_memcpy(boot_sector->volume_label, "NO NAME ", 11);
if (format_data->fat_type == 0) {
pf_memcpy(boot_sector->file_system_type, "FAT12 ", 8);
} else {
pf_memcpy(boot_sector->file_system_type, "FAT16 ", 8);
}
pfd_sddrv_store_le16(boot_sector->signature, 0xaa55);
pfd_sddrv_store_le32(sector_buffer, boot_sector->volume_serial_number, offsetof(PFD_SDDRV_BPB, volume_serial_number), format_data->volume_serial_number);
boot_sector->signature[0] = 0x55;
boot_sector->signature[1] = 0xaa;
return 0;
}
s32 pfd_sddrv_store_mbr_buf(PFD_SDDRV_FORMAT_DATA* format_data, u8* sector_buffer) {
const PFD_SDDRV_SIZE_DEPEND* size_entry;
PFD_SDDRV_SIZE_SETTINGS settings;
PFD_SDDRV_MBR* master_boot_record;
PFD_SDDRV_PARTITION_ENTRY* partition;
u32 entry_index;
u32 sectors_per_cylinder;
u32 start_cylinder;
u32 end_cylinder;
u32 start_sector;
u32 end_sector;
u32 requested_sectors;
const PFD_SDDRV_SIZE_DEPEND* size_entry;
s32 result;
u8 partition_type;
u8 start_head;
u16 start_sector;
u16 start_cylinder;
u8 end_head;
u16 end_sector;
u16 end_cylinder;
if (format_data == 0 || sector_buffer == 0) {
if (format_data == 0) {
return -30;
}
size_entry = sddrv_size_depend_tbl;
pf_memset(&settings, 0, 0x10);
for (entry_index = 0; entry_index < 14; entry_index++, size_entry++) {
if (size_entry->min_sectors < format_data->total_sectors && format_data->total_sectors <= size_entry->max_sectors) {
settings.reserved_sectors = size_entry->reserved_sectors;
settings.fat_copies = size_entry->fat_copies;
settings.root_entries = size_entry->root_entries;
settings.sectors_per_cluster = size_entry->sectors_per_cluster;
requested_sectors = format_data->total_sectors;
size_entry = sddrv_size_depend_tbl;
for (entry_index = 0; entry_index < 14; size_entry++, entry_index++) {
if (size_entry->min_sectors < requested_sectors && size_entry->max_sectors >= requested_sectors) {
settings.reserved_sectors = sddrv_size_depend_tbl[entry_index].reserved_sectors;
settings.fat_copies = sddrv_size_depend_tbl[entry_index].fat_copies;
settings.root_entries = sddrv_size_depend_tbl[entry_index].root_entries;
settings.sectors_per_cluster = sddrv_size_depend_tbl[entry_index].sectors_per_cluster;
break;
}
}
if (entry_index == 14 || format_data->partition_sector_count == 0) {
result = entry_index == 14 ? -30 : 0;
if (result != 0) {
OSReport("ERR Failed to get values with total sectors. pfd_sddrv_get_value_with_total_sectors()\n");
return result;
}
start_cylinder = format_data->partition_start_sector / (settings.fat_copies * settings.root_entries);
start_head = (format_data->partition_start_sector % (settings.fat_copies * settings.root_entries)) / settings.root_entries;
start_sector = format_data->partition_start_sector % settings.root_entries + 1;
end_cylinder = (format_data->total_sectors - 1) / (settings.fat_copies * settings.root_entries);
end_head = ((format_data->total_sectors - 1) % (settings.fat_copies * settings.root_entries)) / settings.root_entries;
end_sector = (format_data->total_sectors - 1) % settings.root_entries + 1;
if (format_data->partition_sector_count == 0) {
return -30;
}
sectors_per_cylinder = settings.fat_copies * settings.root_entries;
start_cylinder = format_data->partition_start_sector / sectors_per_cylinder;
end_cylinder = (format_data->total_sectors - 1) / sectors_per_cylinder;
start_sector = format_data->partition_start_sector % settings.root_entries + 1;
end_sector = (format_data->total_sectors - 1) % settings.root_entries + 1;
if (format_data->partition_sector_count != 0 && format_data->partition_sector_count < 0x7fa8) {
partition_type = 1;
} else if (format_data->partition_sector_count >= 0x7fa8 && format_data->partition_sector_count < 0x10000) {
partition_type = 4;
} else {
partition_type = 6;
}
pf_memset(sector_buffer, 0, 0x200);
master_boot_record = (PFD_SDDRV_MBR*)sector_buffer;
partition = &master_boot_record->partitions[0];
partition->boot_indicator = 0;
partition->start_head = (format_data->partition_start_sector / settings.root_entries) % settings.fat_copies;
partition->start_sector_cylinder[0] = (u8)((start_sector & 0x3f) | ((start_cylinder >> 2) & 0xc0));
partition->start_sector_cylinder[1] = (u8)start_cylinder;
if (format_data->partition_sector_count < 0x7fa8) {
partition->partition_type = 1;
} else if (format_data->partition_sector_count > 0xffff) {
partition->partition_type = 6;
} else {
partition->partition_type = 4;
}
partition->end_head = ((format_data->total_sectors - 1) / settings.root_entries) % settings.fat_copies;
partition->end_sector_cylinder[0] = (u8)((end_sector & 0x3f) | ((end_cylinder >> 2) & 0xc0));
partition->end_sector_cylinder[1] = (u8)end_cylinder;
pfd_sddrv_store_le32(partition->first_sector, format_data->partition_start_sector);
pfd_sddrv_store_le32(partition->sector_count, format_data->partition_sector_count);
partition->start_head = start_head;
pfd_sddrv_store_le16(sector_buffer, partition->start_sector_cylinder, offsetof(PFD_SDDRV_MBR, partitions) + offsetof(PFD_SDDRV_PARTITION_ENTRY, start_sector_cylinder),
((start_cylinder & 0xff) << 8) + ((start_sector & 0x3f) | ((start_cylinder & 0x300) >> 2)));
partition->partition_type = partition_type;
partition->end_head = end_head;
pfd_sddrv_store_le16(sector_buffer, partition->end_sector_cylinder, offsetof(PFD_SDDRV_MBR, partitions) + offsetof(PFD_SDDRV_PARTITION_ENTRY, end_sector_cylinder),
((end_cylinder & 0xff) << 8) + ((end_sector & 0x3f) | ((end_cylinder & 0x300) >> 2)));
pfd_sddrv_store_le32(sector_buffer, partition->first_sector, offsetof(PFD_SDDRV_MBR, partitions) + offsetof(PFD_SDDRV_PARTITION_ENTRY, first_sector), format_data->partition_start_sector);
pfd_sddrv_store_le32(sector_buffer, partition->sector_count, offsetof(PFD_SDDRV_MBR, partitions) + offsetof(PFD_SDDRV_PARTITION_ENTRY, sector_count), format_data->partition_sector_count);
master_boot_record->signature[0] = 0x55;
master_boot_record->signature[1] = 0xaa;
return 0;
@@ -1030,11 +1073,13 @@ s32 pfd_sddrv_build_mbr_bpb(u32 total_sectors) {
}
s32 pfd_sddrv_calc_fat32_mbr_bpb(PFD_SDDRV_FORMAT_DATA* format_data) {
u32 available_sectors;
u8 sectors_per_cluster;
u32 fat_sector_count;
u32 available_sectors;
u32 fat_sectors;
u32 cluster_count;
u32 entry_index;
u32 requested_sectors;
const PFD_SDDRV_SIZE_DEPEND* size_entry;
PFD_SDDRV_SIZE_SETTINGS settings;
u32 reserved_sectors = 0;
@@ -1043,23 +1088,21 @@ s32 pfd_sddrv_calc_fat32_mbr_bpb(PFD_SDDRV_FORMAT_DATA* format_data) {
u32 attempts;
s32 result;
u32 next_data_region;
u32 date;
u32 time;
u32 total_sectors;
u8 sectors_per_cluster;
OSCalendarTime current_time;
if (format_data == 0) {
return -30;
}
pf_memset(&settings, 0, 0x10);
requested_sectors = format_data->total_sectors;
total_sectors = format_data->total_sectors;
size_entry = sddrv_size_depend_tbl;
for (entry_index = 0; entry_index < 14; entry_index++, size_entry++) {
if (size_entry->min_sectors >= total_sectors) {
for (entry_index = 0; entry_index < 14; size_entry++, entry_index++) {
if (size_entry->min_sectors >= requested_sectors) {
continue;
}
if (size_entry->max_sectors < total_sectors) {
if (size_entry->max_sectors < requested_sectors) {
continue;
}
settings.reserved_sectors = sddrv_size_depend_tbl[entry_index].reserved_sectors;
@@ -1075,9 +1118,10 @@ s32 pfd_sddrv_calc_fat32_mbr_bpb(PFD_SDDRV_FORMAT_DATA* format_data) {
}
sectors_per_cluster = settings.sectors_per_cluster;
format_data->sectors_per_cluster = sectors_per_cluster;
total_sectors = format_data->total_sectors;
cluster_count = total_sectors / sectors_per_cluster;
fat_sectors = (cluster_count >> 7) & 0xfffff;
if ((cluster_count & 0x7f) != 0) {
if ((cluster_count * 32 & 0xfe0) != 0) {
fat_sectors++;
}
fat_sector_count = fat_sectors * 2;
@@ -1099,7 +1143,7 @@ s32 pfd_sddrv_calc_fat32_mbr_bpb(PFD_SDDRV_FORMAT_DATA* format_data) {
for (;;) {
cluster_count = (available_sectors - data_start_sector) / sectors_per_cluster + 2;
calculated_fat_sectors = (cluster_count >> 7) & 0xfffff;
if ((cluster_count & 0x7f) != 0) {
if ((cluster_count * 32 & 0xfe0) != 0) {
calculated_fat_sectors++;
}
if (calculated_fat_sectors <= fat_sectors) {
@@ -1120,41 +1164,39 @@ s32 pfd_sddrv_calc_fat32_mbr_bpb(PFD_SDDRV_FORMAT_DATA* format_data) {
format_data->sectors_per_fat = fat_sectors;
format_data->reserved_sectors = reserved_sectors;
format_data->partition_start_sector = 0x2000;
format_data->partition_sector_count = total_sectors - 0x2000;
format_data->partition_sector_count = format_data->total_sectors - 0x2000;
OSTicksToCalendarTime(OSGetTime(), &current_time);
time = ((current_time.hour & 0x1f) << 11) |
((current_time.min & 0x3f) << 5) |
(current_time.sec & 0x1f);
date = (((current_time.year - 1900) & 0x7f) << 9) |
((current_time.mon & 0xf) << 5) |
(current_time.mday & 0x1f);
format_data->volume_serial_number = time + date * 0x10000;
format_data->volume_serial_number = pfd_sddrv_encode_serial(current_time.year, current_time.mon, current_time.mday,
current_time.hour, current_time.min, current_time.sec);
return 0;
}
s32 pfd_sddrv_store_fat32_mbr_buf(PFD_SDDRV_FORMAT_DATA* format_data, u8* sector_buffer) {
PFD_SDDRV_SIZE_SETTINGS settings;
const PFD_SDDRV_SIZE_DEPEND* size_entry;
PFD_SDDRV_MBR* master_boot_record;
PFD_SDDRV_PARTITION_ENTRY* partition;
u32 entry_index;
u32 requested_sectors;
const PFD_SDDRV_SIZE_DEPEND* size_entry;
s32 result;
u32 cylinder_size;
u32 start_cylinder;
u32 start_head;
u32 start_sector;
u32 end_cylinder;
u32 end_head;
u32 end_sector;
u32 partition_end;
u8 partition_type;
u8 start_head;
u16 start_sector;
u16 start_cylinder;
u8 end_head;
u16 end_sector;
u16 end_cylinder;
u32 partition_end;
if (format_data == 0 || sector_buffer == 0) {
return -30;
}
pf_memset(&settings, 0, 0x10);
requested_sectors = format_data->total_sectors;
size_entry = sddrv_size_depend_tbl;
for (entry_index = 0; entry_index < 14; size_entry++, entry_index++) {
if (size_entry->min_sectors < format_data->total_sectors && format_data->total_sectors <= size_entry->max_sectors) {
if (size_entry->min_sectors < requested_sectors && size_entry->max_sectors >= requested_sectors) {
settings.reserved_sectors = sddrv_size_depend_tbl[entry_index].reserved_sectors;
settings.fat_copies = sddrv_size_depend_tbl[entry_index].fat_copies;
settings.root_entries = sddrv_size_depend_tbl[entry_index].root_entries;
@@ -1162,46 +1204,47 @@ s32 pfd_sddrv_store_fat32_mbr_buf(PFD_SDDRV_FORMAT_DATA* format_data, u8* sector
break;
}
}
if (entry_index == 14) {
result = entry_index == 14 ? -30 : 0;
if (result != 0) {
OSReport("ERR Failed to get values with total sectors. pfd_sddrv_get_value_with_total_sectors()\n");
return -30;
return result;
}
cylinder_size = settings.fat_copies * settings.root_entries;
partition_end = format_data->total_sectors - 1;
partition_type = 0x0b;
if (format_data->partition_start_sector <= 0xfb0400) {
start_cylinder = format_data->partition_start_sector / cylinder_size;
start_head = (format_data->partition_start_sector % cylinder_size) / settings.root_entries;
start_sector = format_data->partition_start_sector % settings.root_entries + 1;
} else {
start_cylinder = 0x3ff;
if (format_data->partition_start_sector > 0xfb0400) {
start_head = 0xfe;
start_sector = 0x3f;
}
if (partition_end <= 0xfb0400) {
end_cylinder = partition_end / cylinder_size;
end_head = (partition_end % cylinder_size) / settings.root_entries;
end_sector = partition_end % settings.root_entries + 1;
start_cylinder = 0x3ff;
} else {
end_cylinder = 0x3ff;
start_cylinder = format_data->partition_start_sector / (settings.fat_copies * settings.root_entries);
start_head = (format_data->partition_start_sector % (settings.fat_copies * settings.root_entries)) / settings.root_entries;
start_sector = format_data->partition_start_sector % settings.root_entries + 1;
}
if (format_data->total_sectors > 0xfb0400) {
end_head = 0xfe;
end_sector = 0x3f;
end_cylinder = 0x3ff;
partition_type = 0x0c;
} else {
partition_end = format_data->total_sectors - 1;
partition_type = 0x0b;
end_cylinder = partition_end / (settings.fat_copies * settings.root_entries);
end_head = (partition_end % (settings.fat_copies * settings.root_entries)) / settings.root_entries;
end_sector = partition_end % settings.root_entries + 1;
}
pf_memset(sector_buffer, 0, 0x200);
master_boot_record = (PFD_SDDRV_MBR*)sector_buffer;
partition = &master_boot_record->partitions[0];
partition->boot_indicator = 0;
partition->start_head = (u8)start_head;
pfd_sddrv_store_le16(partition->start_sector_cylinder,
(u16)((start_cylinder << 8) | ((start_sector & 0x3f) | ((start_cylinder >> 2) & 0xc0))));
pfd_sddrv_store_le16(sector_buffer, partition->start_sector_cylinder, offsetof(PFD_SDDRV_MBR, partitions) + offsetof(PFD_SDDRV_PARTITION_ENTRY, start_sector_cylinder),
((start_cylinder & 0xff) << 8) + ((start_sector & 0x3f) | ((start_cylinder & 0x300) >> 2)));
partition->partition_type = partition_type;
partition->end_head = (u8)end_head;
pfd_sddrv_store_le16(partition->end_sector_cylinder,
(u16)((end_cylinder << 8) | ((end_sector & 0x3f) | ((end_cylinder >> 2) & 0xc0))));
pfd_sddrv_store_le32(partition->first_sector, format_data->partition_start_sector);
pfd_sddrv_store_le32(partition->sector_count, format_data->partition_sector_count);
pfd_sddrv_store_le16(master_boot_record->signature, 0xaa55);
pfd_sddrv_store_le16(sector_buffer, partition->end_sector_cylinder, offsetof(PFD_SDDRV_MBR, partitions) + offsetof(PFD_SDDRV_PARTITION_ENTRY, end_sector_cylinder),
((end_cylinder & 0xff) << 8) + ((end_sector & 0x3f) | ((end_cylinder & 0x300) >> 2)));
pfd_sddrv_store_le32(sector_buffer, partition->first_sector, offsetof(PFD_SDDRV_MBR, partitions) + offsetof(PFD_SDDRV_PARTITION_ENTRY, first_sector), format_data->partition_start_sector);
pfd_sddrv_store_le32(sector_buffer, partition->sector_count, offsetof(PFD_SDDRV_MBR, partitions) + offsetof(PFD_SDDRV_PARTITION_ENTRY, sector_count), format_data->partition_sector_count);
master_boot_record->signature[0] = 0x55;
master_boot_record->signature[1] = 0xaa;
return 0;
}
@@ -1255,65 +1298,63 @@ s32 pfd_sddrv_store_fat32_fsi_buf(u8* sector_buffer) NO_INLINE {
s32 pfd_sddrv_store_fat32_bpb_buf(PFD_SDDRV_FORMAT_DATA* format_data, u8* sector_buffer) {
PFD_SDDRV_SIZE_SETTINGS settings;
const PFD_SDDRV_SIZE_DEPEND* size_entry;
PFD_SDDRV_FAT32_BPB* boot_sector;
u32 entry_index;
u32 sector_value;
u32 requested_sectors;
const PFD_SDDRV_SIZE_DEPEND* size_entry;
s32 result;
if (format_data == 0 || sector_buffer == 0) {
return -30;
}
pf_memset(&settings, 0, 0x10);
requested_sectors = format_data->total_sectors;
size_entry = sddrv_size_depend_tbl;
for (entry_index = 0; entry_index < 14; entry_index++, size_entry++) {
if (size_entry->min_sectors < format_data->total_sectors && format_data->total_sectors <= size_entry->max_sectors) {
settings.reserved_sectors = size_entry->reserved_sectors;
settings.fat_copies = size_entry->fat_copies;
settings.root_entries = size_entry->root_entries;
settings.sectors_per_cluster = size_entry->sectors_per_cluster;
for (entry_index = 0; entry_index < 14; size_entry++, entry_index++) {
if (size_entry->min_sectors < requested_sectors && size_entry->max_sectors >= requested_sectors) {
settings.reserved_sectors = sddrv_size_depend_tbl[entry_index].reserved_sectors;
settings.fat_copies = sddrv_size_depend_tbl[entry_index].fat_copies;
settings.root_entries = sddrv_size_depend_tbl[entry_index].root_entries;
settings.sectors_per_cluster = sddrv_size_depend_tbl[entry_index].sectors_per_cluster;
break;
}
}
if (entry_index == 14) {
result = entry_index == 14 ? -30 : 0;
if (result != 0) {
OSReport("ERR Failed to get values with total sectors. pfd_sddrv_get_value_with_total_sectors()\n");
return -30;
return result;
}
pf_memset(sector_buffer, 0, 0x200);
boot_sector = (PFD_SDDRV_FAT32_BPB*)sector_buffer;
pfd_sddrv_copy_bytes(boot_sector->oem_name, (const u8*)" ", 8);
pfd_sddrv_copy_bytes(boot_sector->volume_label, (const u8*)"NO NAME ", 11);
pfd_sddrv_copy_bytes(boot_sector->filesystem_type, (const u8*)"FAT32 ", 8);
boot_sector->jump[0] = 0xeb;
boot_sector->jump[1] = 0;
boot_sector->jump[2] = 0x90;
pf_memcpy(boot_sector->oem_name, " ", 8);
pfd_sddrv_store_le16(boot_sector->bytes_per_sector, 0x200);
pfd_sddrv_store_le16(sector_buffer, boot_sector->bytes_per_sector, offsetof(PFD_SDDRV_FAT32_BPB, bytes_per_sector), 0x200);
boot_sector->sectors_per_cluster = format_data->sectors_per_cluster;
sector_value = format_data->reserved_sectors;
pfd_sddrv_store_le16(boot_sector->reserved_sector_count, (u16)sector_value);
pfd_sddrv_store_le16(sector_buffer, boot_sector->reserved_sector_count, offsetof(PFD_SDDRV_FAT32_BPB, reserved_sector_count), format_data->reserved_sectors);
boot_sector->fat_count = 2;
pfd_sddrv_store_le16(boot_sector->root_entry_count, 0);
pfd_sddrv_store_le16(boot_sector->total_sectors_16, 0);
pfd_sddrv_store_le16(sector_buffer, boot_sector->root_entry_count, offsetof(PFD_SDDRV_FAT32_BPB, root_entry_count), 0);
pfd_sddrv_store_le16(sector_buffer, boot_sector->total_sectors_16, offsetof(PFD_SDDRV_FAT32_BPB, total_sectors_16), 0);
boot_sector->media_descriptor = 0xf8;
pfd_sddrv_store_le16(boot_sector->sectors_per_fat_16, 0);
pfd_sddrv_store_le16(boot_sector->sectors_per_track, (u16)settings.root_entries);
pfd_sddrv_store_le16(boot_sector->heads, (u16)settings.fat_copies);
pfd_sddrv_store_le32(boot_sector->hidden_sectors, format_data->partition_start_sector);
pfd_sddrv_store_le32(boot_sector->total_sectors_32, format_data->partition_sector_count);
pfd_sddrv_store_le32(boot_sector->sectors_per_fat_32, format_data->sectors_per_fat);
pfd_sddrv_store_le16(boot_sector->ext_flags, 0);
pfd_sddrv_store_le16(boot_sector->filesystem_version, 0);
pfd_sddrv_store_le32(boot_sector->root_cluster, 2);
pfd_sddrv_store_le16(boot_sector->fsinfo_sector, 1);
pfd_sddrv_store_le16(boot_sector->backup_boot_sector, 6);
pfd_sddrv_store_le16(sector_buffer, boot_sector->sectors_per_fat_16, offsetof(PFD_SDDRV_FAT32_BPB, sectors_per_fat_16), 0);
pfd_sddrv_store_le16(sector_buffer, boot_sector->sectors_per_track, offsetof(PFD_SDDRV_FAT32_BPB, sectors_per_track), (u16)settings.root_entries);
pfd_sddrv_store_le16(sector_buffer, boot_sector->heads, offsetof(PFD_SDDRV_FAT32_BPB, heads), (u16)settings.fat_copies);
pfd_sddrv_store_le32(sector_buffer, boot_sector->hidden_sectors, offsetof(PFD_SDDRV_FAT32_BPB, hidden_sectors), format_data->partition_start_sector);
pfd_sddrv_store_le32(sector_buffer, boot_sector->total_sectors_32, offsetof(PFD_SDDRV_FAT32_BPB, total_sectors_32), format_data->partition_sector_count);
pfd_sddrv_store_le32(sector_buffer, boot_sector->sectors_per_fat_32, offsetof(PFD_SDDRV_FAT32_BPB, sectors_per_fat_32), format_data->sectors_per_fat);
pfd_sddrv_store_le16(sector_buffer, boot_sector->ext_flags, offsetof(PFD_SDDRV_FAT32_BPB, ext_flags), 0);
pfd_sddrv_store_le16(sector_buffer, boot_sector->filesystem_version, offsetof(PFD_SDDRV_FAT32_BPB, filesystem_version), 0);
pfd_sddrv_store_le32(sector_buffer, boot_sector->root_cluster, offsetof(PFD_SDDRV_FAT32_BPB, root_cluster), 2);
pfd_sddrv_store_le16(sector_buffer, boot_sector->fsinfo_sector, offsetof(PFD_SDDRV_FAT32_BPB, fsinfo_sector), 1);
pfd_sddrv_store_le16(sector_buffer, boot_sector->backup_boot_sector, offsetof(PFD_SDDRV_FAT32_BPB, backup_boot_sector), 6);
boot_sector->drive_number = 0x80;
boot_sector->extended_signature = 0x29;
pfd_sddrv_store_le32(boot_sector->volume_serial_number, format_data->volume_serial_number);
pf_memcpy(boot_sector->volume_label, "NO NAME ", 11);
pf_memcpy(boot_sector->filesystem_type, "FAT32 ", 8);
if (((u32)boot_sector->signature & 1) != 0) {
boot_sector->signature[0] = 0x55;
boot_sector->signature[1] = 0xaa;
} else {
*(u16*)boot_sector->signature = 0x55aa;
}
pfd_sddrv_store_le32(sector_buffer, boot_sector->volume_serial_number, offsetof(PFD_SDDRV_FAT32_BPB, volume_serial_number), format_data->volume_serial_number);
boot_sector->signature[0] = 0x55;
boot_sector->signature[1] = 0xaa;
return 0;
}
@@ -1325,11 +1366,11 @@ static s32 pfd_sddrv_store_fat32_reserved_buf(u8* sector_buffer) {
}
pf_memset(sector_buffer, 0, 0x200);
reserved_boot_sector = (PFD_SDDRV_RESERVED_BOOT_SECTOR*)sector_buffer;
if (((u32)reserved_boot_sector->signature.bytes & 1) == 0) {
reserved_boot_sector->signature.value = 0x55aa;
} else {
if (((u32)reserved_boot_sector->signature.bytes & 1) != 0) {
reserved_boot_sector->signature.bytes[0] = 0x55;
reserved_boot_sector->signature.bytes[1] = 0xaa;
} else {
reserved_boot_sector->signature.value = 0x55aa;
}
return 0;
}
@@ -1337,7 +1378,6 @@ static s32 pfd_sddrv_store_fat32_reserved_buf(u8* sector_buffer) {
s32 pfd_sddrv_build_fat32_mbr_bpb(u32 total_sectors) {
PFD_SDDRV_FORMAT_DATA format_data;
s32 result;
u32 partition_start_sector;
pf_memset(&format_data, 0, 0x20);
format_data.total_sectors = total_sectors;
result = pfd_sddrv_calc_fat32_mbr_bpb(&format_data);
@@ -1350,19 +1390,18 @@ s32 pfd_sddrv_build_fat32_mbr_bpb(u32 total_sectors) {
OSReport("ERR Failed to store BPB values to buf. pfd_sddrv_store_fat32_bpb_buf()\n");
return result;
}
partition_start_sector = format_data.partition_start_sector;
if (g_pfd_sddrv_info.media_inserted == 0) {
return -33;
}
if (g_pfd_sddrv_info.media_ejected != 0) {
return -33;
}
result = ISD_WriteBlock(g_pfd_sddrv_info.device, partition_start_sector, g_pfd_sddrv_buf, 1);
result = ISD_WriteBlock(g_pfd_sddrv_info.device, format_data.partition_start_sector, g_pfd_sddrv_buf, 1);
if (result != 0) {
OSReport("ERR Failed to write BPB fields. ISD_WriteBlock()\n");
return -36;
}
result = ISD_WriteBlock(g_pfd_sddrv_info.device, partition_start_sector + 6, g_pfd_sddrv_buf, 1);
result = ISD_WriteBlock(g_pfd_sddrv_info.device, format_data.partition_start_sector + 6, g_pfd_sddrv_buf, 1);
if (result != 0) {
OSReport("ERR Failed to write BPB fields. ISD_WriteBlock()\n");
return -36;
@@ -1378,12 +1417,12 @@ s32 pfd_sddrv_build_fat32_mbr_bpb(u32 total_sectors) {
if (g_pfd_sddrv_info.media_ejected != 0) {
return -33;
}
result = ISD_WriteBlock(g_pfd_sddrv_info.device, partition_start_sector + 1, g_pfd_sddrv_buf, 1);
result = ISD_WriteBlock(g_pfd_sddrv_info.device, format_data.partition_start_sector + 1, g_pfd_sddrv_buf, 1);
if (result != 0) {
OSReport("ERR Failed to write BPB fields. ISD_WriteBlock()\n");
return -36;
}
result = ISD_WriteBlock(g_pfd_sddrv_info.device, partition_start_sector + 7, g_pfd_sddrv_buf, 1);
result = ISD_WriteBlock(g_pfd_sddrv_info.device, format_data.partition_start_sector + 7, g_pfd_sddrv_buf, 1);
if (result != 0) {
OSReport("ERR Failed to write BPB fields. ISD_WriteBlock()\n");
return -36;
@@ -1400,12 +1439,12 @@ s32 pfd_sddrv_build_fat32_mbr_bpb(u32 total_sectors) {
if (g_pfd_sddrv_info.media_ejected != 0) {
return -33;
}
result = ISD_WriteBlock(g_pfd_sddrv_info.device, partition_start_sector + 2, g_pfd_sddrv_buf, 1);
result = ISD_WriteBlock(g_pfd_sddrv_info.device, format_data.partition_start_sector + 2, g_pfd_sddrv_buf, 1);
if (result != 0) {
OSReport("ERR Failed to write BPB fields. ISD_WriteBlock()\n");
return -36;
}
result = ISD_WriteBlock(g_pfd_sddrv_info.device, partition_start_sector + 8, g_pfd_sddrv_buf, 1);
result = ISD_WriteBlock(g_pfd_sddrv_info.device, format_data.partition_start_sector + 8, g_pfd_sddrv_buf, 1);
if (result != 0) {
OSReport("ERR Failed to write BPB fields. ISD_WriteBlock()\n");
return -36;

View File

@@ -1,9 +1,9 @@
#include <private/fa/puh_msc.h>
static s32 st_uhs_msc_status;
static s32 st_uhs_msc_msgid;
static s32 st_uhs_msc_tskid;
s32 uhg_msc_memid_8169971C;
static s32 st_uhs_msc_tskid;
static s32 st_uhs_msc_msgid;
static s32 st_uhs_msc_status;
static s32 _uhf_msc_api_send_message(UHF_MSC_PARAMETERS* parameters, u32 command);
s32 usbh_msc_read10(UHF_MSC_DEVICE* device, u32 sector, u16 count, void* buffer, void* sense) {

View File

@@ -26,11 +26,10 @@ FAFuncTbl st_uhs_msc_blk_func = {
};
static inline UHF_MSC_DEVICE* uhf_msc_blk_find_device(FADisk* disk) {
UHF_MSC_DEVICE* entry = uhg_msc_blk_device_tbl;
UHF_MSC_DEVICE* device = NULL;
u32 index;
for (index = 0; index < 8; entry++, index++) {
if (entry->disk == disk) {
for (index = 0; index < 8; index++) {
if (uhg_msc_blk_device_tbl[index].disk == disk) {
device = &uhg_msc_blk_device_tbl[index];
break;
}
@@ -88,9 +87,8 @@ s32 uhf_msc_blk_mount(FADisk* disk) {
}
s32 uhf_msc_blk_pread(FADisk* disk, u8* buffer, u32 sector, u32 blocks, u32* completed) {
u16 transfer_blocks;
UHF_MSC_DEVICE* device;
s32 error;
UHF_MSC_DEVICE* device;
u32 block_size;
u8* transfer_buffer;
u32 transfer_limit;
@@ -129,7 +127,7 @@ s32 uhf_msc_blk_pread(FADisk* disk, u8* buffer, u32 sector, u32 blocks, u32* com
transfer_buffer = buffer;
}
do {
transfer_blocks = transfer_limit;
u16 transfer_blocks = transfer_limit;
if (blocks <= transfer_limit) {
transfer_blocks = blocks;
}

View File

@@ -1,6 +1,6 @@
#include <private/fa/pdm.h>
#include <revolution/types.h>
#define MBR_WORD(buf, offset) (((pf_u32)(buf)[(offset) + 2] << 16) + (buf)[offset] + (((pf_u32)(buf)[(offset) + 3] << 24) + ((pf_u32)(buf)[(offset) + 1] << 8)))
#define MBR_WORD(buf, offset) (((pf_u32)(buf)[(offset) + 3] << 24) + ((pf_u32)(buf)[(offset) + 2] << 16) + ((pf_u32)(buf)[(offset) + 1] << 8) + (buf)[offset])
static inline pf_u16 read_boot_u16(pf_u8* buf, pf_u32 offset) {
if ((pf_u32)&buf[offset] & 1) { return (buf[offset + 1] << 8) | buf[offset]; }
return PF_SWAP_16(*(pf_u16*)&buf[(offset + 1) & ~1]);
@@ -10,24 +10,34 @@ pf_s32 pdm_part_is_master_boot_sector(pf_u8* buf, pf_u32 total, pf_bool* p_is_mb
pf_s16 index;
pf_u32 start[4];
pf_u32 count[4];
pf_u32* p_start;
pf_u32* p_count;
*p_is_mbr = 0;
if (buf[510] != 0x55 || buf[511] != 0xAA) { return 2; }
p_start = start;
p_count = count;
for (index = 0; index < 4; index++) {
start[index] = 0;
start[index] = (((pf_u32)buf[456] << 16) + buf[454]) + (((pf_u32)buf[457] << 24) + ((pf_u32)buf[455] << 8));
count[index] = (((pf_u32)buf[460] << 16) + buf[458]) + (((pf_u32)buf[461] << 24) + ((pf_u32)buf[459] << 8));
if (start[index] != 0 && count[index] != 0) {
*p_start = 0;
*p_start = (((pf_u32)buf[456] << 16) + buf[454]) + (((pf_u32)buf[457] << 24) + ((pf_u32)buf[455] << 8));
*p_count = (((pf_u32)buf[460] << 16) + buf[458]) + (((pf_u32)buf[461] << 24) + ((pf_u32)buf[459] << 8));
if (*p_start != 0 && *p_count != 0) {
if (index == 0) { *p_is_mbr = 1; }
} else {
if (index == 0) { return 2; }
}
p_start++;
p_count++;
buf += 16;
}
p_start = start;
p_count = count;
for (index = 0; index < 4; index++) {
if (start[index] + count[index] > total) {
if (*p_start + *p_count > total) {
if (index == 0) { *p_is_mbr = 0; }
return 2;
}
p_start++;
p_count++;
}
return 0;
}

View File

@@ -1,4 +1,3 @@
#define PF_FA_CP932_TABLE
#define VFiPFCODE_CP932_OEM2Unicode PFCODE_CP932_OEM2Unicode
#define VFiPFCODE_CP932_OEMCharWidth PFCODE_CP932_OEMCharWidth
#define VFiPFCODE_CP932_Unicode2OEM PFCODE_CP932_Unicode2OEM

File diff suppressed because it is too large Load Diff

View File

@@ -653,7 +653,10 @@ pf_s32 PFENT_MakeRootDir(PF_VOLUME* p_vol) {
default:
return 7;
}
PFDRV_LoadVolumeLabelFromBuf(p_vol, (pf_u8*)"NO NAME ");
{
static pf_u8 default_volume_label[16] = "NO NAME ";
PFDRV_LoadVolumeLabelFromBuf(p_vol, default_volume_label);
}
return 0;
}
@@ -722,7 +725,8 @@ pf_s32 PFENT_RemoveEntry(PF_DIR_ENT* p_ent, PFENTRY_ENT_ITER* p_iter) {
pf_u16 entry_offset;
pf_u32 i;
PF_VOLUME* p_vol = PF_NULL;
const pf_u8 dir_fb_free[1] = {0xE5};
pf_u8 dir_fb_free[8] = {0xE5};
pf_u8 del = dir_fb_free[0];
p_vol = p_ent->p_vol;
entry_sector = p_ent->entry_sector;
@@ -735,7 +739,7 @@ pf_s32 PFENT_RemoveEntry(PF_DIR_ENT* p_ent, PFENTRY_ENT_ITER* p_iter) {
}
entry_sector = p_iter->sector;
entry_offset = p_iter->offset;
err = PFSEC_WriteData(p_vol, (pf_u8*)&dir_fb_free, entry_sector, entry_offset, 1, &success_size, 0);
err = PFSEC_WriteData(p_vol, &del, entry_sector, entry_offset, 1, &success_size, 0);
if (err != 0) {
return err;
}
@@ -744,7 +748,7 @@ pf_s32 PFENT_RemoveEntry(PF_DIR_ENT* p_ent, PFENTRY_ENT_ITER* p_iter) {
}
}
}
err = PFSEC_WriteData(p_vol, (pf_u8*)&dir_fb_free, p_ent->entry_sector, p_ent->entry_offset, 1, &success_size, 0);
err = PFSEC_WriteData(p_vol, &del, p_ent->entry_sector, p_ent->entry_offset, 1, &success_size, 0);
if (err != 0) {
return err;
}

View File

@@ -347,7 +347,7 @@ pf_s32 PFENT_ITER_DoGetEntry(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent, PF_VOLU
if (err != 0) {
return err;
}
if (PFSTR_StrNumChar(p_path, 1) == 1 && (PFSTR_StrNCmp(p_path, (pf_s8*)"\0", 2, 0, 1) == 0)) {
if (PFSTR_StrNumChar(p_path, 1) == 1 && (PFSTR_StrNCmp(p_path, (pf_s8*)"\0\0\0", 2, 0, 1) == 0)) {
return 0;
}
} else {
@@ -366,7 +366,7 @@ pf_s32 PFENT_ITER_DoGetEntry(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent, PF_VOLU
if (err != 0) {
return err;
}
if (no_look_last_token != 0 && (PFSTR_StrNCmp(&token, (pf_s8*)"\0", 2, 0, 1) == 0)) {
if (no_look_last_token != 0 && (PFSTR_StrNCmp(&token, (pf_s8*)"\0\0\0", 2, 0, 1) == 0)) {
break;
}
@@ -424,7 +424,7 @@ pf_s32 PFENT_ITER_DoGetEntry(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent, PF_VOLU
}
if ((p_ent->attr & 0x10) == 0 || p_ent->short_name[0] != '.') {
p_ent->path_len = (PFSTR_StrNumChar(&token, 1) + 1) + p_ent->path_len;
if ((PFSTR_StrNCmp(&token, (pf_s8*)"\0", 2, 0, 1) != 0)) {
if ((PFSTR_StrNCmp(&token, (pf_s8*)"\0\0\0", 2, 0, 1) != 0)) {
p_ent->path_len -= PFSTR_StrNumChar(&token, 2);
}
}
@@ -689,7 +689,7 @@ pf_s32 PFENT_ITER_FindEntry(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent, PF_STR*
if (PFSTR_StrNCmp(p_pattern, (pf_s8*)"\\", 1, 0, 1) == 0 || PFSTR_StrNCmp(p_pattern, (pf_s8*)"/", 1, 0, 1) == 0) {
err = PFENT_GetRootDir(p_iter->p_vol, p_ent);
if (err != 0) return err;
if (PFSTR_StrNumChar(p_pattern, 1) == 1 && PFSTR_StrNCmp(p_pattern, (pf_s8*)"\0", 2, 0, 1) == 0) return 0;
if (PFSTR_StrNumChar(p_pattern, 1) == 1 && PFSTR_StrNCmp(p_pattern, (pf_s8*)"\0\0\0", 2, 0, 1) == 0) return 0;
} else {
err = PFVOL_GetCurrentDir(p_iter->p_vol, p_ent);
if (err != 0) return err;
@@ -728,20 +728,23 @@ pf_s32 PFENT_ITER_GetEntryOfIter(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent) {
pf_s32 PFENT_ITER_GetLFNEntryName(PFITER_ENT_ITER* p_iter, PF_DIR_ENT* p_ent) {
pf_u32 i;
pf_u32 index;
pf_s32 err;
if (p_ent->num_entry_LFNs != 0 && !(p_ent->small_letter_flag & 0x18)) {
index = 0;
for (i = 0; i < p_ent->num_entry_LFNs; ++i) {
pf_u16* destination;
err = PFENT_ITER_Retreat(p_iter, 0);
if (err != 0) return err;
err = PFENT_ITER_LoadEntry(p_iter);
if (err != 0) return err;
destination = &p_ent->long_name[(i * 26U) / 2U];
destination = &p_ent->long_name[index];
pf_memcpy(destination, &p_iter->buf[1], 10);
pf_memcpy(destination + 5, &p_iter->buf[14], 12);
pf_memcpy(destination + 11, &p_iter->buf[28], 4);
index += 13;
}
p_ent->long_name[(p_ent->num_entry_LFNs * 26U) / 2U] = 0;
p_ent->long_name[index] = 0;
}
return 0;
}

View File

@@ -1852,13 +1852,15 @@ s32 PFFAT_RefreshFSINFO(PF_VOLUME* volume)
s32 alreadyAllocated;
u32 completedBytes;
s32 error;
s32 error2;
error = 0;
if ((volume->fsi_flag & 4) != 0) {
error = PFCACHE_AllocateDataPage(volume, -1, &page,
&alreadyAllocated);
if (error != 0) { goto finished; }
{
error2 = PFCACHE_AllocateDataPage(volume, -1, &page,
&alreadyAllocated);
if (error2 != 0) {
return error2;
} else {
error = PFSEC_ReadData(
volume, page->p_buf, volume->bpb.fs_info_sector, 0,
volume->bpb.bytes_per_sector, &completedBytes, 0);

View File

@@ -126,6 +126,7 @@ pf_s32 PFFAT12_WriteFATEntryWithBuf(PF_VOLUME* p_vol, pf_s16 cluster, pf_u16 val
pf_s32 fat_offset;
pf_u32 fat_sector;
pf_s32 result;
pf_u32 next_sector;
fat_offset = (pf_u16)(cluster + (cluster >> 1));
fat_sector = (pf_u16)(p_vol->bpb.active_FAT_sector + (fat_offset >> p_vol->bpb.log2_bytes_per_sector));
offset_in_sector = fat_offset & (p_vol->bpb.bytes_per_sector - 1);
@@ -146,10 +147,10 @@ pf_s32 PFFAT12_WriteFATEntryWithBuf(PF_VOLUME* p_vol, pf_s16 cluster, pf_u16 val
p_page->p_buf[(pf_u16)offset_in_sector] = (p_page->p_buf[(pf_u16)offset_in_sector] & 0xF) | ((value << 4) & 0xF0);
if ((pf_u16)offset_in_sector == (pf_u32)(p_vol->bpb.bytes_per_sector - 1)) {
FLUSH_FAT_BUFFER();
offset_in_sector = fat_sector + 1;
err = VFiPFSEC_ReadFAT(p_vol, p_page->p_buf, offset_in_sector, 0, p_vol->bpb.bytes_per_sector);
next_sector = fat_sector + 1;
err = VFiPFSEC_ReadFAT(p_vol, p_page->p_buf, next_sector, 0, p_vol->bpb.bytes_per_sector);
if (err != 0) { return err; }
p_page->sector = offset_in_sector;
p_page->sector = next_sector;
p_page->p_buf[0] = value >> 4;
} else {
((pf_u16)offset_in_sector + p_page->p_buf)[1] = value >> 4;
@@ -158,10 +159,10 @@ pf_s32 PFFAT12_WriteFATEntryWithBuf(PF_VOLUME* p_vol, pf_s16 cluster, pf_u16 val
p_page->p_buf[(pf_u16)offset_in_sector] = value;
if ((pf_u16)offset_in_sector == (pf_u32)(p_vol->bpb.bytes_per_sector - 1)) {
FLUSH_FAT_BUFFER();
offset_in_sector = fat_sector + 1;
err = VFiPFSEC_ReadFAT(p_vol, p_page->p_buf, offset_in_sector, 0, p_vol->bpb.bytes_per_sector);
next_sector = fat_sector + 1;
err = VFiPFSEC_ReadFAT(p_vol, p_page->p_buf, next_sector, 0, p_vol->bpb.bytes_per_sector);
if (err != 0) { return err; }
p_page->sector = offset_in_sector;
p_page->sector = next_sector;
p_page->p_buf[0] = (p_page->p_buf[0] & 0xF0) | ((pf_u8)(value >> 8));
} else {
((pf_u16)offset_in_sector + p_page->p_buf)[1] = (((pf_u16)offset_in_sector + p_page->p_buf)[1] & 0xF0) | ((pf_u8)(value >> 8));

View File

@@ -102,7 +102,7 @@ pf_s32 PFFAT16_WriteFATEntryWithBuf(PF_VOLUME* p_vol, pf_u32 cluster, pf_u32 val
err = VFiPFSEC_ReadFAT(p_vol, p_page->p_buf, fat_sector, 0, p_vol->bpb.bytes_per_sector);
}
p_page->p_buf[offset_in_sector] = value;
(offset_in_sector + p_page->p_buf)[1] = value >> 8;
p_page->p_buf[offset_in_sector + 1] = value >> 8;
if (err != 0) {
result = err;
}

View File

@@ -1,34 +1,33 @@
#include <revolution/fa.h>
typedef struct PF_API_STRING {
const s8* head;
const s8* tail;
const s8* current;
typedef struct PFF2_STR {
const s8* p_head;
const s8* p_tail;
const s8* p_current;
u32 code_mode;
} PF_API_STRING;
} PFF2_STR;
typedef struct PF_API_VOLUME_SET {
typedef struct PFF2_VOL_SET {
u8 reserved[0x40];
s32 last_error;
} PF_API_VOLUME_SET;
} PFF2_VOL_SET;
extern PF_API_VOLUME_SET pf_vol_set;
extern s32 PFSTR_InitStr(PF_API_STRING* string, const s8* text, u32 mode);
extern s32 PFAPI_convertReturnValue(s32 error);
extern s32 PFDIR_opendir(PF_API_STRING* path, FADIR** directory);
extern void* PFAPI_convertReturnValue2NULL(s32 error, void* stream);
extern PFF2_VOL_SET pf_vol_set;
extern s32 PFSTR_InitStr(PFF2_STR* path, const s8* text, u32 code_mode);
extern s32 PFDIR_opendir(PFF2_STR* path, FADIR** result);
extern FAFILE* PFAPI_convertReturnValue2NULL(s32 err, FAFILE* p_stream);
FADIR* pf2_opendir(const char* path) {
PF_API_STRING path_string;
FADIR* directory;
s32 error;
FADIR* p_dir;
PFF2_STR path_str;
s32 err;
error = PFSTR_InitStr(&path_string, (const s8*)path, 1);
if (error == 0) {
error = PFDIR_opendir(&path_string, &directory);
err = PFSTR_InitStr(&path_str, (const s8*)path, 1);
if (err == 0) {
err = PFDIR_opendir(&path_str, &p_dir);
} else {
pf_vol_set.last_error = error;
pf_vol_set.last_error = err;
}
return PFAPI_convertReturnValue2NULL(error, directory);
p_dir = PFAPI_convertReturnValue2NULL(err, p_dir);
return p_dir;
}

View File

@@ -400,20 +400,22 @@ pf_s32 PFPATH_cmpNameImpl(const pf_s8* name, const pf_s8* pattern, pf_u32* match
case '*': {
do {
pattern_width = volume->codeset.oem_char_width(pattern);
if (pattern_width == 1) {
pattern_char = pf_toupper(*pattern);
if (pattern_width != 1) {
read_char = (pf_u16)PF_GET_LE_U16((const pf_u8*)pattern);
} else {
pattern_char = PF_GET_LE_U16((const pf_u8*)pattern);
read_char = pf_toupper(*pattern);
}
pattern_char = (pf_u16)read_char;
pattern += pattern_width;
if (pattern_char == '?') {
if (name_char == 0) { return 1; }
name += name_width;
name_width = volume->codeset.oem_char_width(name);
if (name_width == 1) { name_char = pf_toupper(*name); }
else { name_char = PF_GET_LE_U16((const pf_u8*)name); }
if (name_width == 1) { read_char = pf_toupper(*name); }
else { read_char = (pf_u16)PF_GET_LE_U16((const pf_u8*)name); }
name_char = (pf_u16)read_char;
}
} while (pattern_char == '*' || pattern_char == '?');
} while (pattern_char == '?' || pattern_char == '*');
if (pattern_char == 0) {
return 0;
}
@@ -428,21 +430,21 @@ pf_s32 PFPATH_cmpNameImpl(const pf_s8* name, const pf_s8* pattern, pf_u32* match
}
name_width = volume->codeset.oem_char_width(name);
if (name_width == 1) {
name_char = pf_toupper(*name);
read_char = pf_toupper(*name);
} else {
name_char = PF_GET_LE_U16((const pf_u8*)name);
read_char = (pf_u16)PF_GET_LE_U16((const pf_u8*)name);
}
name_char = (pf_u16)read_char;
}
if (*name == 0 || *pattern == 0) {
*matched_end = 1;
}
return 1;
}
default:
if (name_char != pattern_char) { return 1; }
break;
}
name += name_width;
if (*name == 0 || *pattern == 0) {
*matched_end = 1;
}
}
return *name != 0;
}
@@ -1014,7 +1016,7 @@ void PFPATH_SetSearchPattern(pf_s8* p_buf_local, pf_u16* p_buf_unicode, PF_STR*
pf_u32 PFPATH_CheckExtShortNameSignature(PF_STR* p_str) {
pf_u32 result = 0;
pf_s8 sig[2] = {1, 2};
pf_s8 sig[2] = "\x01\x02";
if (PFSTR_StrNCmp(p_str, sig, 1, 0, 2) == 0) {
result = 1;
@@ -1027,7 +1029,7 @@ pf_u32 PFPATH_CheckExtShortName(PF_STR* p_str, pf_u32 target, pf_bool wildcard)
pf_s16 i;
pf_s16 num;
pf_bool is_wildcard = PF_FALSE;
pf_s8 sig[2] = {1, 2};
pf_s8 sig[2] = "\x01\x02";
pf_s8* p_c;
pf_u16* p_wc;
@@ -1035,7 +1037,7 @@ pf_u32 PFPATH_CheckExtShortName(PF_STR* p_str, pf_u32 target, pf_bool wildcard)
(PFSTR_StrNCmp(p_str, (pf_s8*)"?", target, 0, 1) == 0 &&
(PFSTR_StrNCmp(p_str, (pf_s8*)"?", target, 1, 1) == 0 || PFSTR_StrNCmp(p_str, (pf_s8*)"*", target, 0, 1) == 0)) ||
PFSTR_StrNCmp(p_str, (pf_s8*)"*", target, 0, 1) == 0) {
for (i = 2; i < 8 && PF_IS_PATH_SEPERATOR(p_str, target, i) == PF_FALSE && PFSTR_StrNCmp(p_str, (pf_s8*)" ", target, i, 1) != 0 &&
for (i = 2; i < 8 && PF_IS_PATH_SEPERATOR(p_str, target, i) == PF_FALSE && PFSTR_StrNCmp(p_str, (pf_s8*)"\x20\0\0", target, i, 1) != 0 &&
PF_IS_PATH_NOT_NULL(p_str, target, i);
i++) {
if (PFSTR_GetCodeMode(p_str) == 1) {
@@ -1059,7 +1061,7 @@ pf_u32 PFPATH_CheckExtShortName(PF_STR* p_str, pf_u32 target, pf_bool wildcard)
}
}
if (i == 8 || is_wildcard == PF_TRUE) {
if (PFSTR_StrNCmp(p_str, (pf_s8*)" ", target, i, 1) == 0 || PF_IS_PATH_SEPERATOR(p_str, target, i) == 0 ||
if (PFSTR_StrNCmp(p_str, (pf_s8*)"\x20\0\0", target, i, 1) == 0 || PF_IS_PATH_SEPERATOR(p_str, target, i) == 0 ||
PF_IS_PATH_NULL(p_str, target, i)) {
result = i;
}
@@ -1073,7 +1075,7 @@ pf_u32 PFPATH_GetExtShortNameIndex(PF_STR* p_str, pf_u32* p_index) {
pf_s16 i;
pf_s16 num;
pf_u32 index;
pf_s8 sig[2] = {1, 2};
pf_s8 sig[2] = "\x01\x02";
pf_s8* p_c;
pf_u16* p_wc;

View File

@@ -1,8 +1,12 @@
#include <revolution/fa.h>
extern s32 PFDIR_readdir(FADIR* directory, void* result);
extern s32 PFAPI_convertReturnValue(s32 error);
typedef struct FADirEnt FADirEnt;
s32 pf2_readdir(FADIR* directory, void* result) {
return PFAPI_convertReturnValue(PFDIR_readdir(directory, result));
extern s32 PFDIR_readdir(FADIR* dir, FADirEnt* result);
extern s32 PFAPI_convertReturnValue(s32 err);
FAError pf2_readdir(FADIR* dir, FADirEnt* result) {
s32 err = PFDIR_readdir(dir, result);
err = PFAPI_convertReturnValue(err);
return err;
}

View File

@@ -1,8 +1,10 @@
#include <revolution/fa.h>
extern s32 PFDIR_seekdir(FADIR* directory, u32 position);
extern s32 PFAPI_convertReturnValue(s32 error);
extern s32 PFDIR_seekdir(FADIR* dir, u32 position);
extern s32 PFAPI_convertReturnValue(s32 err);
s32 pf2_rewinddir(FADIR* directory) {
return PFAPI_convertReturnValue(PFDIR_seekdir(directory, 0));
FAError pf2_rewinddir(FADIR* dir) {
s32 err = PFDIR_seekdir(dir, 0);
err = PFAPI_convertReturnValue(err);
return err;
}

View File

@@ -1,8 +1,10 @@
#include <revolution/fa.h>
extern s32 PFDIR_seekdir(FADIR* directory, u32 position);
extern s32 PFAPI_convertReturnValue(s32 error);
extern s32 PFDIR_seekdir(FADIR* dir, u32 position);
extern s32 PFAPI_convertReturnValue(s32 err);
s32 pf2_seekdir(FADIR* directory, u32 position) {
return PFAPI_convertReturnValue(PFDIR_seekdir(directory, position));
FAError pf2_seekdir(FADIR* dir, u32 position) {
s32 err = PFDIR_seekdir(dir, position);
err = PFAPI_convertReturnValue(err);
return err;
}

View File

@@ -58,7 +58,7 @@ void* pfstub_entry(void* argument) {
pf_vol_set.context_id = message->task_id;
if (message->operation >= 0 && message->operation < 100) {
pfstub_call_function_standard(message);
} else if (received->operation >= 100 && received->operation < 200) {
} else if (((s32*)received)[1] >= 100 && ((s32*)received)[1] < 200) {
pfstub_call_function_unicode(message);
} else {
message->result.status = -1;

View File

@@ -1,8 +1,10 @@
#include <revolution/fa.h>
extern s32 PFDIR_telldir(FADIR* directory, u32* position);
extern s32 PFAPI_convertReturnValue(s32 error);
extern s32 PFDIR_telldir(FADIR* dir, u32* position);
extern s32 PFAPI_convertReturnValue(s32 err);
s32 pf2_telldir(FADIR* directory, u32* position) {
return PFAPI_convertReturnValue(PFDIR_telldir(directory, position));
FAError pf2_telldir(FADIR* dir, u32* position) {
s32 err = PFDIR_telldir(dir, position);
err = PFAPI_convertReturnValue(err);
return err;
}

View File

@@ -224,6 +224,9 @@ typedef struct PFVOL_SET {
PFVOL_SET pf_vol_set;
static s8 default_volume_label[12] = "NO NAME ";
static const u8 deleted_entry_mark[8] = {0xE5};
extern s32 PFDRV_mount(PFVOL_VOLUME* volume);
extern s32 PFDRV_unmount(PFVOL_VOLUME* volume, u32 mode);
extern s32 PFDRV_format(PFVOL_VOLUME* volume, const u8* format_options);
@@ -370,12 +373,7 @@ static inline s32 finalize_volume(PFVOL_VOLUME* volume) {
return 0;
}
static inline s32 copy_codeset(const PFVOL_CHARCODE* code_set) {
pf_vol_set.codeset.oem2unicode = code_set->oem2unicode;
pf_vol_set.codeset.unicode2oem = code_set->unicode2oem;
pf_vol_set.codeset.oem_char_width = code_set->oem_char_width;
pf_vol_set.codeset.is_oem_mb_char = code_set->is_oem_mb_char;
pf_vol_set.codeset.unicode_char_width = code_set->unicode_char_width;
pf_vol_set.codeset.is_unicode_mb_char = code_set->is_unicode_mb_char;
pf_vol_set.codeset = *code_set;
return 0;
}
s32 PFVOL_DoMountVolume(PFVOL_VOLUME* volume) {
@@ -500,7 +498,9 @@ s32 PFVOL_p_setvol(PFVOL_VOLUME* volume, const s8* label) {
s32 error;
error = PFENT_GetRootDir(volume, &root_entry);
if (error == 0) {
if (error != 0) {
return error;
} else {
PFFAT_InitFFD(&ffd, &hint, volume, &root_entry.start_cluster);
PFSTR_InitStr(&path, "*", 1);
PFSTR_SetLocalStr(&path, 0);
@@ -514,7 +514,7 @@ s32 PFVOL_p_setvol(PFVOL_VOLUME* volume, const s8* label) {
entry.start_cluster = 0;
}
} else {
PFSTR_InitStr(&path, "", 1);
PFSTR_InitStr(&path, "\0\0\0", 1);
PFSTR_SetLocalStr(&path, 0);
error = PFENT_allocateEntry(&entry, 1, &ffd, previous_cluster, &path);
if (error != 0) {
@@ -584,7 +584,7 @@ s32 PFVOL_p_rmvvol(PFVOL_VOLUME* volume) {
u32 logical_position;
u32 entry_position;
u32 processed;
u8 deleted = (u8)"\xE5"[0];
u8 deleted = deleted_entry_mark[0];
s32 error;
error = PFENT_GetRootDir(volume, &root_entry);
@@ -913,7 +913,7 @@ s32 PFVOL_getvol(s8 drive, PFVOL_VOLUME_INFO* volume_info) {
} else {
volume = &pf_vol_set.volumes[volume_index];
}
if (pf_memcmp(volume->label, "NO NAME ", 11) == 0) {
if (pf_memcmp(volume->label, default_volume_label, 11) == 0) {
pf_vol_set.last_error = 3;
volume->last_error = 3;
return 3;
@@ -945,7 +945,7 @@ s32 PFVOL_rmvvol(s8 drive) {
} else {
volume = &pf_vol_set.volumes[volume_index];
}
if (pf_memcmp(volume->label, "NO NAME ", 11) == 0) {
if (pf_memcmp(volume->label, default_volume_label, 11) == 0) {
pf_vol_set.last_error = 3;
volume->last_error = 3;
return 3;
@@ -956,7 +956,7 @@ s32 PFVOL_rmvvol(s8 drive) {
volume->last_error = error;
return error;
}
error = PFDRV_StoreVolumeLabelToBPB(volume, (const s8*)"NO NAME ");
error = PFDRV_StoreVolumeLabelToBPB(volume, default_volume_label);
if (error != 0) {
pf_vol_set.last_error = error;
volume->last_error = error;
@@ -1536,3 +1536,4 @@ s32 PFVOL_setencode(u32 mode) {
pf_vol_set.setting = pf_vol_set.setting & ~3 | mode;
return 0;
}

View File

@@ -69,17 +69,17 @@ typedef struct {
} KBDChannel;
typedef struct {
u32 callbackAddress;
USBKBDCmdLEDCallback callbackAddress;
void* callbackArg;
} KBDLEDCallbackData;
const char* __KBDVersion =
"<< RVL_SDK - KBD \trelease build: Apr 20 2010 11:21:43 (0x4199_60831) >>";
static BOOL kbdInitialized;
static USBKBDAttachCallback kbdDevAttachCallback;
static USBKBDDetachCallback kbdDevDetachCallback;
static void (*kbdKeyCallback)(KBDKeyEventData* event);
static USBKBDDetachCallback kbdDevDetachCallback;
static USBKBDAttachCallback kbdDevAttachCallback;
static BOOL kbdInitialized;
KBDKeyMapTable kbdKeyMaps = {0};
typedef struct {
@@ -346,7 +346,6 @@ static void kbdProcKey(u32 key, u32 pressed, u32 channel) {
event.channel = channel;
event.state = pressed;
event.modifiers = 0;
kbdGetModState(channel, &event.modifiers);
map = &kbdKeyMaps.maps[data->country];
keyCount = map->keypadCount;
@@ -402,86 +401,86 @@ static void kbdProcKey(u32 key, u32 pressed, u32 channel) {
static void kbdProcMod(u32 key, u32 pressed, u32 channel) {
KBDChannel* data;
u32 modState;
s32 delta;
u8 flags;
KBDModifierState state;
u32 finalState;
s8 value;
data = &kbdData[channel];
delta = (pressed & 1) != 0 ? 1 : -1;
flags = kbdKeyMaps.maps[data->country].flags;
state.value = data->modState;
kbdGetModState(channel, &state.value);
kbdGetModState(channel, &modState);
switch (key) {
case 0xF001:
if (data->lockState != 0) {
if ((pressed & 1) != 0) {
state.value ^= 2;
modState ^= 2;
}
} else {
value = data->lockCount[1] + delta;
data->lockCount[1] = value;
state.keys.rightControl = (u8)value != 0;
modState = (modState & ~0x2) | (((u8)value != 0) << 1);
}
break;
case 0xF005:
if (data->lockState != 0) {
if ((pressed & 1) != 0) {
state.value ^= 0x20;
modState ^= 0x20;
}
} else {
value = data->lockCount[4] + delta;
data->lockCount[4] = value;
state.keys.rightAlt = (u8)value != 0;
modState = (modState & ~0x20) | (((u8)value != 0) << 5);
}
break;
case 0xF000:
if (data->lockState != 0) {
if ((pressed & 1) != 0) {
state.value ^= 1;
modState ^= 1;
}
} else {
value = data->lockCount[0] + delta;
data->lockCount[0] = value;
state.keys.leftControl = (u8)value != 0;
modState = (modState & ~0x1) | ((u8)value != 0);
}
break;
case 0xF008:
if (((pressed & 1) != 0) && (data->lockProcessing != 0)) {
state.value ^= 0x200;
modState ^= 0x200;
}
break;
case 0xF007:
if (((pressed & 1) != 0) && (data->lockProcessing != 0)) {
state.value ^= 0x100;
modState ^= 0x100;
}
break;
case 0xF006:
if (((pressed & 1) != 0) && (data->lockProcessing != 0)) {
u32 oldState;
u32 lockState;
oldState = state.value;
oldState = modState;
lockState = oldState & 0xC0;
switch (lockState) {
case 0:
if ((flags & 1) == 1) {
state.value = oldState | 0x40;
modState = oldState | 0x40;
}
break;
case 0x40:
{
state.value = oldState & 0xFFFFFFBF;
modState = oldState & 0xFFFFFFBF;
if ((flags & 4) == 4) {
state.value = oldState & 0xFFFFFFBF | 0x80;
modState = oldState & 0xFFFFFFBF | 0x80;
}
}
break;
case 0x80:
state.value = oldState & 0xFFFFFF7F;
modState = oldState & 0xFFFFFF7F;
break;
case 0xC0:
state.value = oldState & 0xFFFFFF3F;
modState = oldState & 0xFFFFFF3F;
break;
}
}
@@ -489,43 +488,43 @@ static void kbdProcMod(u32 key, u32 pressed, u32 channel) {
case 0xF002:
if (data->lockState != 0) {
if ((pressed & 1) != 0) {
state.value ^= 4;
modState ^= 4;
}
} else {
value = data->lockCount[2] + delta;
data->lockCount[2] = value;
state.keys.leftShift = (u8)value != 0;
modState = (modState & ~0x4) | (((u8)value != 0) << 2);
}
break;
case 0xF003:
if (data->lockState != 0) {
if ((pressed & 1) != 0) {
state.value ^= 8;
modState ^= 8;
}
} else {
value = data->lockCount[3] + delta;
data->lockCount[3] = value;
state.keys.rightShift = (u8)value != 0;
modState = (modState & ~0x8) | (((u8)value != 0) << 3);
}
break;
case 0xF004:
if (data->lockState != 0) {
if ((pressed & 1) != 0) {
state.value ^= 0x10;
modState ^= 0x10;
}
} else {
value = data->lockCount[5] + delta;
data->lockCount[5] = value;
state.keys.leftAlt = (u8)value != 0;
modState = (modState & ~0x10) | (((u8)value != 0) << 4);
}
break;
case 0xF021:
if (((pressed & 1) != 0) && (data->lockProcessing != 0)) {
state.value ^= 0x400;
modState ^= 0x400;
}
break;
}
finalState = state.value | 0x1000;
finalState = modState | 0x1000;
KBDSetModState(channel, finalState);
}
@@ -564,28 +563,26 @@ static inline u32 kbdChannelFlags(u32 channel) {
static void kbd_led_handler(BOOL success, void* callbackArg) {
u32 index;
u32 result;
u32 callbackAddress;
u32 err;
index = (u32)callbackArg;
callbackAddress = kbdLCBuf[index].callbackAddress;
kbdCmdBuf[index].device = 0;
if (callbackAddress == 0) {
if (kbdLCBuf[index].callbackAddress == (USBKBDCmdLEDCallback)(u32)kbdCmdBuf[index].device) {
return;
}
switch (success) {
case TRUE:
result = 0;
break;
default:
result = 7;
err = 7;
break;
case TRUE:
err = 0;
break;
}
((USBKBDCmdLEDCallback)kbdLCBuf[index].callbackAddress)(result, kbdLCBuf[index].callbackArg);
kbdLCBuf[index].callbackAddress(err, kbdLCBuf[index].callbackArg);
}
USBKBDErr KBDSetLedsAsync(u32 channel, u32 leds, USBKBDCmdLEDCallback callback, void* callbackArg) {
u32 index;
s32 index;
u32 ofs;
u8 ledBits;
BOOL interrupts;
USBKBDErr result;
@@ -595,62 +592,66 @@ USBKBDErr KBDSetLedsAsync(u32 channel, u32 leds, USBKBDCmdLEDCallback callback,
if (channel >= 4) {
return 4;
}
if ((s32)kbdData[(u8)channel].flags == 1 || (s32)kbdData[(u8)channel].flags == 4) {
return 5;
}
ledBits = leds;
interrupts = OSDisableInterrupts();
for (index = 0; index < 12; index++) {
if (kbdCmdBuf[index].device == 0) {
kbdCmdBuf[index].device = (u32)kbdData[channel].device;
break;
}
}
OSRestoreInterrupts(interrupts);
if (index == 12) {
return 7;
}
kbdLCBuf[index].callbackAddress = (u32)callback;
kbdLCBuf[index].callbackArg = callbackArg;
result = USBKBDSetLEDAsync((u32)kbdData[channel].device, ledBits,
(USBKBDCmdLEDAsync*)&kbdCmdBuf[index],
kbd_led_handler, (void*)index);
switch (result) {
case 0:
return 0;
default:
return 7;
}
}
USBKBDErr KBDSetLeds(u32 channel, u32 leds) {
u32 index;
BOOL interrupts;
USBKBDErr result;
if (!kbdInitialized) {
return 2;
}
if (channel >= 4) {
return 4;
}
if ((s32)kbdChannelFlags(channel) == 1 || (s32)kbdChannelFlags(channel) == 4) {
return 5;
}
leds &= 0xff;
ledBits = leds;
interrupts = OSDisableInterrupts();
index = 0;
while (index < 12) {
if ((kbdCmdBuf + index)->device == 0) {
kbdCmdBuf[index].device = (u32)kbdData[channel].device;
for (index = 0, ofs = 0; index < 12; index++, ofs += sizeof(KBDLEDCommand)) {
if (*(u32*)&((u8*)kbdCmdBuf)[ofs] == 0) {
*(u32*)&((u8*)kbdCmdBuf)[ofs] = (u32)kbdData[channel].device;
break;
}
index++;
}
OSRestoreInterrupts(interrupts);
if (index == 12) {
return 7;
}
result = USBKBDSetLED((u32)kbdData[channel].device, leds,
kbdLCBuf[index].callbackAddress = callback;
kbdLCBuf[index].callbackArg = callbackArg;
result = USBKBDSetLEDAsync((u32)kbdData[channel].device, ledBits,
(USBKBDCmdLEDAsync*)&kbdCmdBuf[index],
kbd_led_handler, (void*)index);
switch (result) {
default:
return 7;
case 0:
return 0;
}
}
USBKBDErr KBDSetLeds(u32 channel, u32 leds) {
u32 index;
KBDLEDCommand* command;
BOOL interrupts;
USBKBDErr result;
u8 ledBits;
if (!kbdInitialized) {
return 2;
}
if (channel >= 4) {
return 4;
}
if ((s32)kbdChannelFlags(channel) == 1 || (s32)kbdChannelFlags(channel) == 4) {
return 5;
}
ledBits = leds & 0xff;
interrupts = OSDisableInterrupts();
index = 0;
command = kbdCmdBuf;
while (index < 12) {
if (command->device == 0) {
command->device = (u32)kbdData[channel].device;
break;
}
index++;
command++;
}
OSRestoreInterrupts(interrupts);
if (index == 12) {
return 7;
}
result = USBKBDSetLED((u32)kbdData[channel].device, ledBits,
(USBKBDCmdLED*)&kbdCmdBuf[index]);
kbdCmdBuf[index].device = 0;
switch (result) {
@@ -837,30 +838,28 @@ USBKBDErr KBDSetModState(u32 channel, u32 value) {
kbdData[channel].modState = value & ~0x1000;
} else {
BOOL interrupts;
KBDModifierState* state;
KBDModifierState oldState;
KBDModifierState newState;
interrupts = OSDisableInterrupts();
state = (KBDModifierState*)&kbdData[channel].modState;
newState.value = value & 0xfc0;
oldState = *state;
oldState.value = kbdData[channel].modState;
newState.bits.physical = oldState.bits.physical;
*state = newState;
kbdData[channel].modState = newState.value;
OSRestoreInterrupts(interrupts);
}
return 0;
}
u16 KBDTranslateHidCode(u32 keyCode, u32 modifiers, s32 country) {
KBDKeyMap* map;
u16* table;
u32 keyIndex;
u16 entry;
s32 mask;
u16* table;
u16 activeFlag;
u16 entry;
KBDKeyMap* map;
s32 offset;
s32 group;
u32 shiftFlag;
u16 activeFlag;
u32 keyIndex;
if (kbdInitialized == FALSE) {
return 0xFFFF;

View File

@@ -0,0 +1,240 @@
#include <revolution/types.h>
void kbdInitMapIntl(void);
void kbdInitMap(u32 country, u8 codeCount, u8 flags, u16* keyMap, u16* modifierMap,
u8 lockIndex, u8 shiftIndex, u8 altIndex, u8 maxCode, s32 keypadType);
static u16 kbdKeyMapCANADA[400] = {
0x003F, 0x0061, 0x0041, 0x0000, 0x003F, 0x0062, 0x0042, 0x0000,
0x003F, 0x0063, 0x0043, 0x0000, 0x003F, 0x0064, 0x0044, 0x0000,
0x003F, 0x0065, 0x0045, 0x0000, 0x003F, 0x0066, 0x0046, 0x0000,
0x003F, 0x0067, 0x0047, 0x0000, 0x003F, 0x0068, 0x0048, 0x0000,
0x003F, 0x0069, 0x0049, 0x0000, 0x003F, 0x006A, 0x004A, 0x0000,
0x003F, 0x006B, 0x004B, 0x0000, 0x003F, 0x006C, 0x004C, 0x0000,
0x003F, 0x006D, 0x004D, 0x0000, 0x003F, 0x006E, 0x004E, 0x0000,
0x003F, 0x006F, 0x004F, 0x0000, 0x003F, 0x0070, 0x0050, 0x0000,
0x003F, 0x0071, 0x0051, 0x0000, 0x003F, 0x0072, 0x0052, 0x0000,
0x003F, 0x0073, 0x0053, 0x0000, 0x003F, 0x0074, 0x0054, 0x0000,
0x003F, 0x0075, 0x0055, 0x0000, 0x003F, 0x0076, 0x0056, 0x0000,
0x003F, 0x0077, 0x0057, 0x0000, 0x003F, 0x0078, 0x0058, 0x00BB,
0x003F, 0x0079, 0x0059, 0x0000, 0x003F, 0x007A, 0x005A, 0x00AB,
0x0000, 0x0031, 0x0021, 0x0000, 0x0000, 0x0032, 0x0040, 0x0000,
0x0000, 0x0033, 0x0023, 0x0000, 0x0000, 0x0034, 0x0024, 0x0000,
0x0000, 0x0035, 0x0025, 0x0000, 0x0000, 0x0036, 0x003F, 0x0000,
0x0000, 0x0037, 0x0026, 0x007B, 0x0000, 0x0038, 0x002A, 0x007D,
0x0000, 0x0039, 0x0028, 0x005B, 0x0000, 0x0030, 0x0029, 0x005D,
0x0000, 0xF1CD, 0xF1CD, 0xF1CD, 0x0000, 0xF1DB, 0xF1DB, 0xF1DB,
0x0000, 0xF1C8, 0xF1C8, 0xF1C8, 0x0000, 0xF1C9, 0xF1C9, 0xF1C9,
0x0000, 0x0020, 0x0020, 0x0020, 0x0000, 0x002D, 0x005F, 0x0000,
0x0000, 0x003D, 0x002B, 0x00AC, 0x0000, 0x0302, 0x0308, 0x0300,
0x003F, 0x00E7, 0x00C7, 0x0303, 0x0000, 0x0000, 0x0000, 0x0000,
0x003F, 0x00E0, 0x00C0, 0x0000, 0x0000, 0x003B, 0x003A, 0x00B0,
0x003F, 0x00E8, 0x00C8, 0x0000, 0x0000, 0x002F, 0x005C, 0x007C,
0x0000, 0x002C, 0x0027, 0x003C, 0x0000, 0x002E, 0x0022, 0x003E,
0x003F, 0x00E9, 0x00C9, 0x0000, 0xC000, 0xF008, 0xF008, 0xF008,
0x0000, 0xF061, 0xF061, 0xF061, 0x0000, 0xF062, 0xF062, 0xF062,
0x0000, 0xF063, 0xF063, 0xF063, 0x0000, 0xF064, 0xF064, 0xF064,
0x0000, 0xF065, 0xF065, 0xF065, 0x0000, 0xF066, 0xF066, 0xF066,
0x0000, 0xF067, 0xF067, 0xF067, 0x0000, 0xF068, 0xF068, 0xF068,
0x0000, 0xF069, 0xF069, 0xF069, 0x0000, 0xF06A, 0xF06A, 0xF06A,
0x0000, 0xF06B, 0xF06B, 0xF06B, 0x0000, 0xF06C, 0xF06C, 0xF06C,
0xC000, 0xF020, 0xF020, 0xF020, 0xC000, 0xF021, 0xF021, 0xF021,
0xC000, 0xF022, 0xF022, 0xF022, 0x0000, 0xF1B0, 0xF1B0, 0xF1B0,
0x0000, 0xF1B7, 0xF1B7, 0xF1B7, 0x0000, 0xF1B9, 0xF1B9, 0xF1B9,
0x0000, 0xF1AE, 0xF1AE, 0xF1AE, 0x0000, 0xF1B1, 0xF1B1, 0xF1B1,
0x0000, 0xF1B3, 0xF1B3, 0xF1B3, 0x0000, 0xF1B6, 0xF1B6, 0xF1B6,
0x0000, 0xF1B4, 0xF1B4, 0xF1B4, 0x0000, 0xF1B2, 0xF1B2, 0xF1B2,
0x0000, 0xF1B8, 0xF1B8, 0xF1B8, 0xC000, 0xF007, 0xF007, 0xF007,
0x0000, 0xF12F, 0xF12F, 0xF12F, 0x0000, 0xF12A, 0xF12A, 0xF12A,
0x0000, 0xF12D, 0xF12D, 0xF12D, 0x0000, 0xF12B, 0xF12B, 0xF12B,
0x0000, 0xF10D, 0xF10D, 0xF10D, 0x80FF, 0xF171, 0xF131, 0x0000,
0x80FF, 0xF172, 0xF132, 0x0000, 0x80FF, 0xF173, 0xF133, 0x0000,
0x80FF, 0xF174, 0xF134, 0x0000, 0x80FF, 0xF175, 0xF135, 0x0000,
0x80FF, 0xF176, 0xF136, 0x0000, 0x80FF, 0xF177, 0xF137, 0x0000,
0x80FF, 0xF178, 0xF138, 0x0000, 0x80FF, 0xF179, 0xF139, 0x0000,
0x80FF, 0xF170, 0xF130, 0x0000, 0x80FF, 0xF16E, 0xF12E, 0x0000,
0x003F, 0x00F9, 0x00D9, 0x0000, 0xC000, 0xF02F, 0xF02F, 0xF02F,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xF13D, 0xF13D, 0xF13D,
};
static u16 kbdModifierMapCANADA[32] = {
0xC000, 0xF000, 0xF000, 0xF000, 0xC000, 0xF001, 0xF001, 0xF001,
0xC000, 0xF002, 0xF002, 0xF002, 0xC000, 0xF003, 0xF003, 0xF003,
0xC000, 0xF000, 0xF000, 0xF000, 0xC000, 0xF001, 0xF001, 0xF001,
0xC000, 0xF005, 0xF005, 0xF005, 0xC000, 0xF003, 0xF003, 0xF003,
};
static u16 kbdKeyMapCANADA_FR[400] = {
0x003F, 0x0061, 0x0041, 0x0000, 0x003F, 0x0062, 0x0042, 0x0000,
0x003F, 0x0063, 0x0043, 0x0000, 0x003F, 0x0064, 0x0044, 0x0000,
0x003F, 0x0065, 0x0045, 0x0000, 0x003F, 0x0066, 0x0046, 0x0000,
0x003F, 0x0067, 0x0047, 0x0000, 0x003F, 0x0068, 0x0048, 0x0000,
0x003F, 0x0069, 0x0049, 0x0000, 0x003F, 0x006A, 0x004A, 0x0000,
0x003F, 0x006B, 0x004B, 0x0000, 0x003F, 0x006C, 0x004C, 0x0000,
0x003F, 0x006D, 0x004D, 0x00B5, 0x003F, 0x006E, 0x004E, 0x0000,
0x003F, 0x006F, 0x004F, 0x00A7, 0x003F, 0x0070, 0x0050, 0x00B6,
0x003F, 0x0071, 0x0051, 0x0000, 0x003F, 0x0072, 0x0052, 0x0000,
0x003F, 0x0073, 0x0053, 0x0000, 0x003F, 0x0074, 0x0054, 0x0000,
0x003F, 0x0075, 0x0055, 0x0000, 0x003F, 0x0076, 0x0056, 0x0000,
0x003F, 0x0077, 0x0057, 0x0000, 0x003F, 0x0078, 0x0058, 0x0000,
0x003F, 0x0079, 0x0059, 0x0000, 0x003F, 0x007A, 0x005A, 0x0000,
0x0000, 0x0031, 0x0021, 0x00B1, 0x0000, 0x0032, 0x0022, 0x0040,
0x0000, 0x0033, 0x002F, 0x00A3, 0x0000, 0x0034, 0x0024, 0x00A2,
0x0000, 0x0035, 0x0025, 0x00A4, 0x0000, 0x0036, 0x003F, 0x00AC,
0x0000, 0x0037, 0x0026, 0x00A6, 0x0000, 0x0038, 0x002A, 0x00B2,
0x0000, 0x0039, 0x0028, 0x00B3, 0x0000, 0x0030, 0x0029, 0x00BC,
0x0000, 0xF1CD, 0xF1CD, 0xF1CD, 0x0000, 0xF1DB, 0xF1DB, 0xF1DB,
0x0000, 0xF1C8, 0xF1C8, 0xF1C8, 0x0000, 0xF1C9, 0xF1C9, 0xF1C9,
0x0000, 0x0020, 0x0020, 0x0020, 0x0000, 0x002D, 0x005F, 0x00BD,
0x0000, 0x003D, 0x002B, 0x00BE, 0x0000, 0x0302, 0x0302, 0x005B,
0x0000, 0x0327, 0x0308, 0x005D, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x003C, 0x003E, 0x007D, 0x0000, 0x003B, 0x003A, 0x007E,
0x0000, 0x0300, 0x0300, 0x007B, 0x0000, 0x0023, 0x007C, 0x005C,
0x0000, 0x002C, 0x0027, 0x00AF, 0x0000, 0x002E, 0x002E, 0x002D,
0x003F, 0x00E9, 0x00C9, 0x0301, 0xC000, 0xF008, 0xF008, 0xF008,
0x0000, 0xF061, 0xF061, 0xF061, 0x0000, 0xF062, 0xF062, 0xF062,
0x0000, 0xF063, 0xF063, 0xF063, 0x0000, 0xF064, 0xF064, 0xF064,
0x0000, 0xF065, 0xF065, 0xF065, 0x0000, 0xF066, 0xF066, 0xF066,
0x0000, 0xF067, 0xF067, 0xF067, 0x0000, 0xF068, 0xF068, 0xF068,
0x0000, 0xF069, 0xF069, 0xF069, 0x0000, 0xF06A, 0xF06A, 0xF06A,
0x0000, 0xF06B, 0xF06B, 0xF06B, 0x0000, 0xF06C, 0xF06C, 0xF06C,
0xC000, 0xF020, 0xF020, 0xF020, 0xC000, 0xF021, 0xF021, 0xF021,
0xC000, 0xF022, 0xF022, 0xF022, 0x0000, 0xF1B0, 0xF1B0, 0xF1B0,
0x0000, 0xF1B7, 0xF1B7, 0xF1B7, 0x0000, 0xF1B9, 0xF1B9, 0xF1B9,
0x0000, 0xF1AE, 0xF1AE, 0xF1AE, 0x0000, 0xF1B1, 0xF1B1, 0xF1B1,
0x0000, 0xF1B3, 0xF1B3, 0xF1B3, 0x0000, 0xF1B6, 0xF1B6, 0xF1B6,
0x0000, 0xF1B4, 0xF1B4, 0xF1B4, 0x0000, 0xF1B2, 0xF1B2, 0xF1B2,
0x0000, 0xF1B8, 0xF1B8, 0xF1B8, 0xC000, 0xF007, 0xF007, 0xF007,
0x0000, 0xF12F, 0xF12F, 0xF12F, 0x0000, 0xF12A, 0xF12A, 0xF12A,
0x0000, 0xF12D, 0xF12D, 0xF12D, 0x0000, 0xF12B, 0xF12B, 0xF12B,
0x0000, 0xF10D, 0xF10D, 0xF10D, 0x80FF, 0xF171, 0xF131, 0x0000,
0x80FF, 0xF172, 0xF132, 0x0000, 0x80FF, 0xF173, 0xF133, 0x0000,
0x80FF, 0xF174, 0xF134, 0x0000, 0x80FF, 0xF175, 0xF135, 0x0000,
0x80FF, 0xF176, 0xF136, 0x0000, 0x80FF, 0xF177, 0xF137, 0x0000,
0x80FF, 0xF178, 0xF138, 0x0000, 0x80FF, 0xF179, 0xF139, 0x0000,
0x80FF, 0xF170, 0xF130, 0x0000, 0x80FF, 0xF16E, 0xF12E, 0x0000,
0x0000, 0x00AB, 0x00BB, 0x00B0, 0x0000, 0xF02F, 0xF02F, 0xF02F,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xF13D, 0xF13D, 0xF13D,
};
static u16 kbdModifierMapCANADA_FR[32] = {
0xC000, 0xF000, 0xF000, 0xF000, 0xC000, 0xF001, 0xF001, 0xF001,
0xC000, 0xF002, 0xF002, 0xF002, 0xC000, 0xF003, 0xF003, 0xF003,
0xC000, 0xF000, 0xF000, 0xF000, 0xC000, 0xF001, 0xF001, 0xF001,
0xC000, 0xF005, 0xF005, 0xF005, 0xC000, 0xF003, 0xF003, 0xF003,
};
static u16 kbdKeyMapLATIN_AMERICA[400] = {
0x003F, 0x0061, 0x0041, 0x0000, 0x003F, 0x0062, 0x0042, 0x0000,
0x003F, 0x0063, 0x0043, 0x0000, 0x003F, 0x0064, 0x0044, 0x0000,
0x003F, 0x0065, 0x0045, 0x0000, 0x003F, 0x0066, 0x0046, 0x0000,
0x003F, 0x0067, 0x0047, 0x0000, 0x003F, 0x0068, 0x0048, 0x0000,
0x003F, 0x0069, 0x0049, 0x0000, 0x003F, 0x006A, 0x004A, 0x0000,
0x003F, 0x006B, 0x004B, 0x0000, 0x003F, 0x006C, 0x004C, 0x0000,
0x003F, 0x006D, 0x004D, 0x0000, 0x003F, 0x006E, 0x004E, 0x0000,
0x003F, 0x006F, 0x004F, 0x0000, 0x003F, 0x0070, 0x0050, 0x0000,
0x003F, 0x0071, 0x0051, 0x0040, 0x003F, 0x0072, 0x0052, 0x0000,
0x003F, 0x0073, 0x0053, 0x0000, 0x003F, 0x0074, 0x0054, 0x0000,
0x003F, 0x0075, 0x0055, 0x0000, 0x003F, 0x0076, 0x0056, 0x0000,
0x003F, 0x0077, 0x0057, 0x0000, 0x003F, 0x0078, 0x0058, 0x0000,
0x003F, 0x0079, 0x0059, 0x0000, 0x003F, 0x007A, 0x005A, 0x0000,
0x0000, 0x0031, 0x0021, 0x0000, 0x0000, 0x0032, 0x0022, 0x0000,
0x0000, 0x0033, 0x0023, 0x0000, 0x0000, 0x0034, 0x0024, 0x0000,
0x0000, 0x0035, 0x0025, 0x0000, 0x0000, 0x0036, 0x0026, 0x0000,
0x0000, 0x0037, 0x002F, 0x0000, 0x0000, 0x0038, 0x0028, 0x0000,
0x0000, 0x0039, 0x0029, 0x0000, 0x0000, 0x0030, 0x003D, 0x0000,
0x0000, 0xF1CD, 0xF1CD, 0xF1CD, 0x0000, 0xF1DB, 0xF1DB, 0xF1DB,
0x0000, 0xF1C8, 0xF1C8, 0xF1C8, 0x0000, 0xF1C9, 0xF1C9, 0xF1C9,
0x0000, 0x0020, 0x0020, 0x0020, 0x0000, 0x0027, 0x003F, 0x005C,
0x0000, 0x00BF, 0x00A1, 0x0000, 0x0000, 0x0301, 0x0308, 0x0000,
0x0000, 0x002B, 0x002A, 0x007E, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x007D, 0x005D, 0x0300, 0x003F, 0x00F1, 0x00D1, 0x0000,
0x0000, 0x007B, 0x005B, 0x0302, 0x0000, 0x007C, 0x00B0, 0x00AC,
0x0000, 0x002C, 0x003B, 0x0000, 0x0000, 0x002E, 0x003A, 0x0000,
0x0000, 0x002D, 0x005F, 0x0000, 0xC000, 0xF008, 0xF008, 0xF008,
0x0000, 0xF061, 0xF061, 0xF061, 0x0000, 0xF062, 0xF062, 0xF062,
0x0000, 0xF063, 0xF063, 0xF063, 0x0000, 0xF064, 0xF064, 0xF064,
0x0000, 0xF065, 0xF065, 0xF065, 0x0000, 0xF066, 0xF066, 0xF066,
0x0000, 0xF067, 0xF067, 0xF067, 0x0000, 0xF068, 0xF068, 0xF068,
0x0000, 0xF069, 0xF069, 0xF069, 0x0000, 0xF06A, 0xF06A, 0xF06A,
0x0000, 0xF06B, 0xF06B, 0xF06B, 0x0000, 0xF06C, 0xF06C, 0xF06C,
0xC000, 0xF020, 0xF020, 0xF020, 0xC000, 0xF021, 0xF021, 0xF021,
0xC000, 0xF022, 0xF022, 0xF022, 0x0000, 0xF1B0, 0xF1B0, 0xF1B0,
0x0000, 0xF1B7, 0xF1B7, 0xF1B7, 0x0000, 0xF1B9, 0xF1B9, 0xF1B9,
0x0000, 0xF1AE, 0xF1AE, 0xF1AE, 0x0000, 0xF1B1, 0xF1B1, 0xF1B1,
0x0000, 0xF1B3, 0xF1B3, 0xF1B3, 0x0000, 0xF1B6, 0xF1B6, 0xF1B6,
0x0000, 0xF1B4, 0xF1B4, 0xF1B4, 0x0000, 0xF1B2, 0xF1B2, 0xF1B2,
0x0000, 0xF1B8, 0xF1B8, 0xF1B8, 0xC000, 0xF007, 0xF007, 0xF007,
0x0000, 0xF12F, 0xF12F, 0xF12F, 0x0000, 0xF12A, 0xF12A, 0xF12A,
0x0000, 0xF12D, 0xF12D, 0xF12D, 0x0000, 0xF12B, 0xF12B, 0xF12B,
0x0000, 0xF10D, 0xF10D, 0xF10D, 0x80FF, 0xF171, 0xF131, 0x0000,
0x80FF, 0xF172, 0xF132, 0x0000, 0x80FF, 0xF173, 0xF133, 0x0000,
0x80FF, 0xF174, 0xF134, 0x0000, 0x80FF, 0xF175, 0xF135, 0x0000,
0x80FF, 0xF176, 0xF136, 0x0000, 0x80FF, 0xF177, 0xF137, 0x0000,
0x80FF, 0xF178, 0xF138, 0x0000, 0x80FF, 0xF179, 0xF139, 0x0000,
0x80FF, 0xF170, 0xF130, 0x0000, 0x80FF, 0xF16E, 0xF12E, 0x0000,
0x0000, 0x003C, 0x003E, 0x0000, 0xC000, 0xF02F, 0xF02F, 0xF02F,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0xF13D, 0xF13D, 0xF13D,
};
static u16 kbdModifierMapLATIN_AMERICA[32] = {
0xC000, 0xF000, 0xF000, 0xF000, 0xC000, 0xF001, 0xF001, 0xF001,
0xC000, 0xF002, 0xF002, 0xF002, 0xC000, 0xF003, 0xF003, 0xF003,
0xC000, 0xF000, 0xF000, 0xF000, 0xC000, 0xF001, 0xF001, 0xF001,
0xC000, 0xF005, 0xF005, 0xF005, 0xC000, 0xF003, 0xF003, 0xF003,
};
static u16 kbdKeyMapUSA[300] = {
0x003F, 0x0061, 0x0041, 0x003F, 0x0062, 0x0042, 0x003F, 0x0063,
0x0043, 0x003F, 0x0064, 0x0044, 0x003F, 0x0065, 0x0045, 0x003F,
0x0066, 0x0046, 0x003F, 0x0067, 0x0047, 0x003F, 0x0068, 0x0048,
0x003F, 0x0069, 0x0049, 0x003F, 0x006A, 0x004A, 0x003F, 0x006B,
0x004B, 0x003F, 0x006C, 0x004C, 0x003F, 0x006D, 0x004D, 0x003F,
0x006E, 0x004E, 0x003F, 0x006F, 0x004F, 0x003F, 0x0070, 0x0050,
0x003F, 0x0071, 0x0051, 0x003F, 0x0072, 0x0052, 0x003F, 0x0073,
0x0053, 0x003F, 0x0074, 0x0054, 0x003F, 0x0075, 0x0055, 0x003F,
0x0076, 0x0056, 0x003F, 0x0077, 0x0057, 0x003F, 0x0078, 0x0058,
0x003F, 0x0079, 0x0059, 0x003F, 0x007A, 0x005A, 0x0000, 0x0031,
0x0021, 0x0000, 0x0032, 0x0040, 0x0000, 0x0033, 0x0023, 0x0000,
0x0034, 0x0024, 0x0000, 0x0035, 0x0025, 0x0000, 0x0036, 0x005E,
0x0000, 0x0037, 0x0026, 0x0000, 0x0038, 0x002A, 0x0000, 0x0039,
0x0028, 0x0000, 0x0030, 0x0029, 0x0000, 0xF1CD, 0xF1CD, 0x0000,
0xF1DB, 0xF1DB, 0x0000, 0xF1C8, 0xF1C8, 0x0000, 0xF1C9, 0xF1C9,
0x0000, 0x0020, 0x0020, 0x0000, 0x002D, 0x005F, 0x0000, 0x003D,
0x002B, 0x0000, 0x005B, 0x007B, 0x0000, 0x005D, 0x007D, 0x0000,
0x005C, 0x007C, 0x0000, 0x0000, 0x0000, 0x0000, 0x003B, 0x003A,
0x0000, 0x0027, 0x0022, 0x0000, 0x0060, 0x007E, 0x0000, 0x002C,
0x003C, 0x0000, 0x002E, 0x003E, 0x0000, 0x002F, 0x003F, 0xC000,
0xF008, 0xF008, 0x0000, 0xF061, 0xF061, 0x0000, 0xF062, 0xF062,
0x0000, 0xF063, 0xF063, 0x0000, 0xF064, 0xF064, 0x0000, 0xF065,
0xF065, 0x0000, 0xF066, 0xF066, 0x0000, 0xF067, 0xF067, 0x0000,
0xF068, 0xF068, 0x0000, 0xF069, 0xF069, 0x0000, 0xF06A, 0xF06A,
0x0000, 0xF06B, 0xF06B, 0x0000, 0xF06C, 0xF06C, 0xC000, 0xF020,
0xF020, 0xC000, 0xF021, 0xF021, 0xC000, 0xF022, 0xF022, 0x0000,
0xF1B0, 0xF1B0, 0x0000, 0xF1B7, 0xF1B7, 0x0000, 0xF1B9, 0xF1B9,
0x0000, 0xF1AE, 0xF1AE, 0x0000, 0xF1B1, 0xF1B1, 0x0000, 0xF1B3,
0xF1B3, 0x0000, 0xF1B6, 0xF1B6, 0x0000, 0xF1B4, 0xF1B4, 0x0000,
0xF1B2, 0xF1B2, 0x0000, 0xF1B8, 0xF1B8, 0xC000, 0xF007, 0xF007,
0x0000, 0xF12F, 0xF12F, 0x0000, 0xF12A, 0xF12A, 0x0000, 0xF12D,
0xF12D, 0x0000, 0xF12B, 0xF12B, 0x0000, 0xF10D, 0xF10D, 0x80FF,
0xF171, 0xF131, 0x80FF, 0xF172, 0xF132, 0x80FF, 0xF173, 0xF133,
0x80FF, 0xF174, 0xF134, 0x80FF, 0xF175, 0xF135, 0x80FF, 0xF176,
0xF136, 0x80FF, 0xF177, 0xF137, 0x80FF, 0xF178, 0xF138, 0x80FF,
0xF179, 0xF139, 0x80FF, 0xF170, 0xF130, 0x80FF, 0xF16E, 0xF12E,
0x0000, 0x0000, 0x0000, 0xC000, 0xF02F, 0xF02F, 0x0000, 0x0000,
0x0000, 0x0000, 0xF13D, 0xF13D,
};
static u16 kbdModifierMapUSA[24] = {
0xC000, 0xF000, 0xF000, 0xC000, 0xF001, 0xF001, 0xC000, 0xF002,
0xF002, 0xC000, 0xF003, 0xF003, 0xC000, 0xF000, 0xF000, 0xC000,
0xF001, 0xF001, 0xC000, 0xF002, 0xF002, 0xC000, 0xF003, 0xF003,
};
void KBDInitRegionUS(void) {
kbdInitMapIntl();
kbdInitMap(3, 4, 0x10, kbdKeyMapCANADA, kbdModifierMapCANADA, 0, 0, 3, 100, 2);
kbdInitMap(4, 4, 0x10, kbdKeyMapCANADA_FR, kbdModifierMapCANADA_FR, 0, 0, 3, 100, 2);
kbdInitMap(17, 4, 0x10, kbdKeyMapLATIN_AMERICA, kbdModifierMapLATIN_AMERICA, 0, 0, 3, 100, 2);
kbdInitMap(33, 3, 0, kbdKeyMapUSA, kbdModifierMapUSA, 0, 0, 0, 100, 0);
}

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,337 @@
#include <revolution/kpr.h>
#include <revolution/os.h>
struct KPRDeadKey {
u16 accent;
u16 base;
u16 composed;
};
const struct KPRDeadKey kprDeadKeyMap[] = {
{0x0300, 0x0300, 0x0060},
{0x0300, 0x0041, 0x00C0},
{0x0300, 0x0045, 0x00C8},
{0x0300, 0x0049, 0x00CC},
{0x0300, 0x004F, 0x00D2},
{0x0300, 0x0055, 0x00D9},
{0x0300, 0x0061, 0x00E0},
{0x0300, 0x0065, 0x00E8},
{0x0300, 0x0069, 0x00EC},
{0x0300, 0x006F, 0x00F2},
{0x0300, 0x0075, 0x00F9},
{0x0301, 0x0301, 0x00B4},
{0x0301, 0x0041, 0x00C1},
{0x0301, 0x0045, 0x00C9},
{0x0301, 0x0049, 0x00CD},
{0x0301, 0x004F, 0x00D3},
{0x0301, 0x0055, 0x00DA},
{0x0301, 0x0059, 0x00DD},
{0x0301, 0x0061, 0x00E1},
{0x0301, 0x0065, 0x00E9},
{0x0301, 0x0069, 0x00ED},
{0x0301, 0x006F, 0x00F3},
{0x0301, 0x0075, 0x00FA},
{0x0301, 0x0079, 0x00FD},
{0x0302, 0x0302, 0x005E},
{0x0302, 0x0041, 0x00C2},
{0x0302, 0x0045, 0x00CA},
{0x0302, 0x0049, 0x00CE},
{0x0302, 0x004F, 0x00D4},
{0x0302, 0x0055, 0x00DB},
{0x0302, 0x0061, 0x00E2},
{0x0302, 0x0065, 0x00EA},
{0x0302, 0x0069, 0x00EE},
{0x0302, 0x006F, 0x00F4},
{0x0302, 0x0075, 0x00FB},
{0x0303, 0x0303, 0x007E},
{0x0303, 0x0041, 0x00C3},
{0x0303, 0x004E, 0x00D1},
{0x0303, 0x004F, 0x00D5},
{0x0303, 0x0061, 0x00E3},
{0x0303, 0x006E, 0x00F1},
{0x0303, 0x006F, 0x00F5},
{0x0308, 0x0308, 0x00A8},
{0x0308, 0x0041, 0x00C4},
{0x0308, 0x0045, 0x00CB},
{0x0308, 0x0049, 0x00CF},
{0x0308, 0x004F, 0x00D6},
{0x0308, 0x0055, 0x00DC},
{0x0308, 0x0059, 0x0178},
{0x0308, 0x0061, 0x00E4},
{0x0308, 0x0065, 0x00EB},
{0x0308, 0x0069, 0x00EF},
{0x0308, 0x006F, 0x00F6},
{0x0308, 0x0075, 0x00FC},
{0x0308, 0x0079, 0x00FF},
{0x0327, 0x0327, 0x00B8},
{0x0327, 0x0043, 0x00C7},
{0x0327, 0x0063, 0x00E7},
{0x030D, 0x030D, 0x0027},
{0x030D, 0x0041, 0x00C1},
{0x030D, 0x0045, 0x00C9},
{0x030D, 0x0049, 0x00CD},
{0x030D, 0x004F, 0x00D3},
{0x030D, 0x0055, 0x00DA},
{0x030D, 0x0059, 0x00DD},
{0x030D, 0x0043, 0x00C7},
{0x030D, 0x0061, 0x00E1},
{0x030D, 0x0065, 0x00E9},
{0x030D, 0x0069, 0x00ED},
{0x030D, 0x006F, 0x00F3},
{0x030D, 0x0075, 0x00FA},
{0x030D, 0x0079, 0x00FD},
{0x030D, 0x0063, 0x00E7},
{0x030E, 0x030E, 0x0022},
{0x030E, 0x0041, 0x00C4},
{0x030E, 0x0045, 0x00CB},
{0x030E, 0x0049, 0x00CF},
{0x030E, 0x004F, 0x00D6},
{0x030E, 0x0055, 0x00DC},
{0x030E, 0x0059, 0x0178},
{0x030E, 0x0061, 0x00E4},
{0x030E, 0x0065, 0x00EB},
{0x030E, 0x0069, 0x00EF},
{0x030E, 0x006F, 0x00F6},
{0x030E, 0x0075, 0x00FC},
{0x030E, 0x0079, 0x00FF},
{0x0344, 0x0344, 0x0385},
{0x0344, 0x03B9, 0x0390},
{0x0344, 0x03C5, 0x03B0},
{0x0308, 0x0399, 0x03AA},
{0x0308, 0x03A5, 0x03AB},
{0x0308, 0x03B9, 0x03CA},
{0x0308, 0x03C5, 0x03CB},
{0x0301, 0x0391, 0x0386},
{0x0301, 0x0395, 0x0388},
{0x0301, 0x0397, 0x0389},
{0x0301, 0x0399, 0x038A},
{0x0301, 0x039F, 0x038C},
{0x0301, 0x03A5, 0x038E},
{0x0301, 0x03A9, 0x038F},
{0x0301, 0x03B1, 0x03AC},
{0x0301, 0x03B5, 0x03AD},
{0x0301, 0x03B7, 0x03AE},
{0x0301, 0x03B9, 0x03AF},
{0x0301, 0x03BF, 0x03CC},
{0x0301, 0x03C5, 0x03CD},
{0x0301, 0x03C9, 0x03CE},
{0x0000, 0x0000, 0x0000},
};
const u16 kprLookupTable1252[] = {
0x20AC, 0x0000, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x0000, 0x017D, 0x0000,
0x0000, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x0000, 0x017E, 0x0178,
};
const u16 kprLookupTable437[] = {
0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
0x00FF, 0x00D6, 0x00DC, 0x00A2, 0x00A3, 0x00A5, 0x20A7, 0x0192,
0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
0x00BF, 0x2310, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556,
0x2555, 0x2563, 0x2551, 0x2557, 0x255D, 0x255C, 0x255B, 0x2510,
0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x255E, 0x255F,
0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x2567,
0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256B,
0x256A, 0x2518, 0x250C, 0x2588, 0x2584, 0x258C, 0x2590, 0x2580,
0x03B1, 0x00DF, 0x0393, 0x03C0, 0x03A3, 0x03C3, 0x00B5, 0x03C4,
0x03A6, 0x0398, 0x03A9, 0x03B4, 0x221E, 0x03C6, 0x03B5, 0x2229,
0x2261, 0x00B1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00F7, 0x2248,
0x00B0, 0x2219, 0x00B7, 0x221A, 0x207F, 0x00B2, 0x25A0, 0x00A0,
};
static void (*kprProcDeadKeysFP)(KPRQueue* queue);
static void (*kprProcRomajiFP)(KPRQueue* queue);
const char* __KPRVersion = "<< RVL_SDK - KPR \trelease build: Apr 20 2010 11:21:44 (0x4199_60831) >>";
void KPRProcessDeadKeys(KPRQueue* queue);
BOOL KPRProcessAltKeypad(KPRQueue* queue, u16 character);
void KPRInitRegionUS(void) {
kprProcDeadKeysFP = KPRProcessDeadKeys;
}
void KPRInitQueue(KPRQueue* queue) {
static union { u64 align; u8 flag; } once;
if (!once.flag) {
OSRegisterVersion(__KPRVersion);
once.flag = TRUE;
}
queue->mode = KPR_MODE_ALT_KEYPAD;
queue->oCount = 0;
queue->iCount = 0;
queue->altVal = 0;
}
void KPRClearQueue(KPRQueue* queue) {
queue->oCount = 0;
queue->iCount = 0;
queue->altVal = 0;
}
void KPRSetMode(KPRQueue* queue, KPRMode mode) {
queue->mode = mode;
queue->oCount = 0;
queue->iCount = 0;
queue->altVal = 0;
}
u8 KPRPutChar(KPRQueue* queue, u16 character) {
BOOL interrupts;
if (queue->oCount + queue->iCount + 1 >= 5) {
OSPanic("kpr_lib.c", 215, "KPRPutChar: Overflow");
}
interrupts = OSDisableInterrupts();
if (!(queue->mode & KPR_MODE_ALT_KEYPAD) || !KPRProcessAltKeypad(queue, character)) {
queue->text[queue->oCount + queue->iCount] = character;
++queue->iCount;
if (queue->mode & KPR_MODE_DEADKEY) {
kprProcDeadKeysFP(queue);
} else if ((queue->mode & KPR_MODE_JP_ROMAJI_KATAKANA) || (queue->mode & KPR_MODE_JP_ROMAJI_HIRAGANA)) {
kprProcRomajiFP(queue);
} else {
queue->oCount = queue->iCount;
queue->iCount = 0;
}
if (character == 0xFFFF) {
--queue->oCount;
}
}
OSRestoreInterrupts(interrupts);
return queue->oCount;
}
u16 KPRGetChar(KPRQueue* queue) {
BOOL interrupts;
u16 character;
u16* source;
u32 index;
if (!queue->oCount) {
return 0;
}
interrupts = OSDisableInterrupts();
character = queue->text[0];
source = &queue->text[1];
for (index = 1; index < queue->iCount + queue->oCount; ++index) {
source[-1] = *source;
++source;
}
--queue->oCount;
OSRestoreInterrupts(interrupts);
return character;
}
u8 KPRLookAhead(KPRQueue* queue, u16* destination, u32 capacity) {
BOOL interrupts;
u8 index;
if (destination == NULL || capacity == 0) {
return queue->iCount + queue->oCount;
}
interrupts = OSDisableInterrupts();
for (index = 0; index < queue->iCount + queue->oCount && index < capacity; ++index) {
destination[index] = queue->text[index];
}
if (index < capacity) {
destination[index] = 0;
}
OSRestoreInterrupts(interrupts);
return queue->iCount + queue->oCount;
}
BOOL KPRProcessAltKeypad(KPRQueue* queue, u16 character) {
if (queue->altVal != 0) {
u32 accumulator = queue->altVal & 0x7FFFFFFF;
u32 value;
u32 leadingZero = queue->altVal & 0x80000000;
queue->altVal = accumulator;
if (character >= 0xF130 && character <= 0xF139) {
if (accumulator > 0x6666666) {
return TRUE;
}
queue->altVal = leadingZero | (character - 0xF130 + accumulator * 10);
return TRUE;
}
value = queue->altVal;
if (value >= 128 && value <= 255) {
if (leadingZero) {
if (value < 160) {
value = kprLookupTable1252[value - 128];
}
} else {
value = kprLookupTable437[value - 128];
}
} else if (value > 255) {
u32 converted = 32;
if (value <= 0x6666666) {
converted = (u8)value;
}
value = converted;
}
{
u16* destination;
int index = queue->oCount + queue->iCount;
destination = &queue->text[index];
for (; index > queue->oCount; --index, --destination) {
*destination = destination[-1];
}
}
queue->text[queue->oCount] = value;
queue->altVal = 0;
++queue->oCount;
return character == 0;
}
if (character >= 0xF130 && character <= 0xF139) {
if (character == 0xF130) {
queue->altVal = 0x80000000;
} else {
queue->altVal = character - 0xF130;
}
return TRUE;
}
if (character == 0) {
return TRUE;
}
return FALSE;
}
void KPRProcessDeadKeys(KPRQueue* queue) {
int index;
int firstFallback;
u32 secondFallback;
if (queue->iCount == 1) {
for (index = 0; index < 107; ++index) {
if (queue->text[queue->oCount] == kprDeadKeyMap[index].accent) {
return;
}
}
++queue->oCount;
queue->iCount = 0;
return;
}
secondFallback = 107;
for (index = 0; index < 107; ++index) {
if (queue->text[queue->oCount] == kprDeadKeyMap[index].accent && queue->text[queue->oCount + 1] == kprDeadKeyMap[index].base) {
queue->text[queue->oCount] = kprDeadKeyMap[index].composed;
queue->iCount = 0;
++queue->oCount;
return;
}
if (queue->text[queue->oCount] == kprDeadKeyMap[index].accent && queue->text[queue->oCount] == kprDeadKeyMap[index].base) {
firstFallback = index;
}
if (queue->text[queue->oCount + 1] == kprDeadKeyMap[index].accent && queue->text[queue->oCount + 1] == kprDeadKeyMap[index].base) {
secondFallback = index;
}
}
queue->text[queue->oCount] = kprDeadKeyMap[firstFallback].composed;
if (secondFallback < 107) {
queue->text[queue->oCount + 1] = kprDeadKeyMap[secondFallback].composed;
}
queue->iCount = 0;
queue->oCount += 2;
return;
}

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,50 @@
#include <revolution/mem.h>
namespace nup {
static MEMAllocator* __mem;
void* __nupMallocAlign(unsigned long size, unsigned long alignment) {
if (__mem == NULL) {
return NULL;
}
MEMHeapHandle heap = (MEMHeapHandle)__mem->heap;
if (heap->magic != 0x45585048) {
return NULL;
}
return MEMAllocFromExpHeapEx(heap, size, alignment);
}
void* __nupMalloc(unsigned long size) {
if (__mem == NULL) {
return NULL;
}
MEMHeapHandle heap = (MEMHeapHandle)__mem->heap;
if (heap->magic != 0x45585048) {
return NULL;
}
return MEMAllocFromExpHeapEx(heap, size, 32);
}
void __nupFree(void* block) {
if (__mem != NULL) {
MEMHeapHandle heap = (MEMHeapHandle)__mem->heap;
if (heap->magic == 0x45585048 && block != NULL) {
MEMFreeToExpHeap(heap, block);
}
}
}
int __nupRegisterAllocator(MEMAllocator* allocator) {
int result = 0;
if (allocator == NULL) {
result = -5011;
} else {
if (((MEMHeapHandle)allocator->heap)->magic != 0x45585048) {
result = -5011;
} else {
__mem = allocator;
}
}
return result;
}
}

View File

@@ -0,0 +1,256 @@
#include <revolution/os.h>
#include <revolution/ncd.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
namespace nup {
void* __nupMalloc(unsigned long size);
void __nupFree(void* block);
}
enum NHTTPReqMethod { NHTTP_GET, NHTTP_POST };
typedef void (*ProgressCallback)(void*, unsigned long);
typedef long (*FlushCallback)(u8*, unsigned long, unsigned long, void*);
struct HttpState {
int error;
unsigned long limit;
unsigned long received;
ProgressCallback progress;
void* progressContext;
FlushCallback flush;
void* flushContext;
void* response;
int done;
int result;
OSTime lastActivity;
};
struct HttpString {
u8* buffer;
unsigned long capacity;
unsigned long length;
unsigned long growth;
unsigned long maximumGrowth;
};
extern "C" {
void* NHTTPCreateRequestEx(char*, NHTTPReqMethod, void*, u32, void (*)(int, void*, HttpState*), HttpState*, u8* (*)(u8**, unsigned long*, unsigned long, void*, void*, HttpState*), void (*)(void*));
int NHTTPGetError();
int NHTTPSetSocketBufferSize(void*, u32);
int NHTTPAddHeaderField(void*, const char*, const char*);
int NHTTPSetClientCertDefault(void*);
int NHTTPSetRootCADefault(void*);
int NHTTPSetVerifyOption(void*, u32);
int NHTTPSetProxyDefault(void*);
int NHTTPAddPostDataRaw(void*, u8*, unsigned long);
int NHTTPSendRequestAsync(void*);
void NHTTPDeleteRequest(void*);
int NHTTPGetProgress(unsigned long*, unsigned long*);
int NHTTPGetBodyAll(void*, u8**);
int NHTTPGetHeaderAll(void*, char**);
void NHTTPCancelRequestAsync(int);
void NHTTPDestroyResponse(void*);
static u8* __nupNhttpBufFull(u8** buffer, unsigned long* length, unsigned long requested, void*, void*, HttpState* state) {
u8* next = NULL;
if (state->progress != NULL && *length != 0) {
state->progress(state->progressContext, *length);
}
if ((state->received + *length) < state->received) {
if (state->error == 0) state->error = -5012;
}
state->received += *length;
if (state->error == 0) {
if (state->limit != 0 && state->received > state->limit) {
state->error = -5012;
goto done;
} else {
if (*buffer != NULL && state->flush != NULL) {
state->error = state->flush(*buffer, *length, requested, state->flushContext);
if (state->error != 0) goto done;
}
next = *buffer;
if (next == NULL) {
if (requested != 0 && requested < 0x8000) {} else requested = 0x8000;
next = (u8*)nup::__nupMalloc(requested);
if (next == NULL) {
state->error = -5000;
goto done;
}
*length = requested;
}
if (*length != 0) state->lastActivity = OSGetTime();
}
}
done:
if (state->error != 0) {
next = NULL;
*length = 0;
}
return next;
}
static void __nupNhttpBufFree(void* block) {
if (block != NULL) nup::__nupFree(block);
}
static void __nupNhttpReqDone(int result, void* response, HttpState* state) {
if (state != NULL) {
state->response = response;
state->done = 1;
state->result = result;
}
}
}
static int __nupNhttpOp(char* url, NHTTPReqMethod method, char* headers, u8* body, unsigned long bodyLength, unsigned long limit, ProgressCallback progress, void* progressContext, FlushCallback flush, void* flushContext) {
unsigned long transferred, expected;
int length;
char* responseHeaders = NULL;
u8* responseBody = NULL;
HttpState state;
int status;
state.error = 0;
state.limit = limit;
state.received = 0;
state.progress = progress;
state.progressContext = progressContext;
state.flush = flush;
state.flushContext = flushContext;
state.response = NULL;
state.done = 0;
state.result = 0;
state.lastActivity = 0;
int result = 0;
int requestId = 0;
char* headerCopy = NULL;
void* request = NHTTPCreateRequestEx(url, method, NULL, 0, __nupNhttpReqDone, &state, __nupNhttpBufFull, __nupNhttpBufFree);
if (request == NULL) { result = -7000 - NHTTPGetError(); goto cleanup; }
if (NHTTPSetSocketBufferSize(request, 0x8000) != 0) { result = -7000 - NHTTPGetError(); goto cleanup; }
if (headers != NULL) {
unsigned long size = strlen(headers) + 1;
headerCopy = (char*)nup::__nupMalloc(size);
if (headerCopy == NULL) { result = -5000; goto cleanup; }
memcpy(headerCopy, headers, size);
char* field = headerCopy;
while (*field != 0) {
char* colon = strchr(field, ':');
if (colon == NULL) break;
char* end = strstr(colon, "\r\n");
if (end == NULL) break;
*colon = 0;
*end = 0;
while (*field && isspace(*field)) field++;
do { colon++; } while (*colon && isspace(*colon));
if (NHTTPAddHeaderField(request, field, colon) != 0) { result = -7000 - NHTTPGetError(); goto cleanup; }
field = end + 2;
}
}
if (NHTTPAddHeaderField(request, "Accept", "text/html, image/gif, image/jpeg, */*") != 0) { result = -7000 - NHTTPGetError(); goto cleanup; }
if (NHTTPAddHeaderField(request, "Content-type", "text/xml; charset=utf-8") != 0) { result = -7000 - NHTTPGetError(); goto cleanup; }
if (NHTTPAddHeaderField(request, "Connection", "Keep-Alive") != 0) { result = -7000 - NHTTPGetError(); goto cleanup; }
if (NHTTPSetClientCertDefault(request) != 0) { result = -7000 - NHTTPGetError(); goto cleanup; }
if (NHTTPSetRootCADefault(request) != 0) { result = -7000 - NHTTPGetError(); goto cleanup; }
if (NHTTPSetVerifyOption(request, 11) != 0) { result = -7000 - NHTTPGetError(); goto cleanup; }
NHTTPSetProxyDefault(request);
if (method == NHTTP_POST && body != NULL && bodyLength != 0 && NHTTPAddPostDataRaw(request, body, bodyLength) != 0) { result = -7000 - NHTTPGetError(); goto cleanup; }
requestId = NHTTPSendRequestAsync(request);
if (requestId < 0) {
int error = NHTTPGetError();
NHTTPDeleteRequest(request);
result = -7000 - error;
goto cleanup;
}
state.lastActivity = OSGetTime();
for (;;) {
if (NHTTPGetProgress(&expected, &transferred) != 0 && state.done != 0) {
if (state.result != 0) { result = -7000 - state.result; goto cleanup; }
if (state.response != NULL) {
length = NHTTPGetBodyAll(state.response, &responseBody);
if (length < 0) { result = -5007; goto cleanup; }
__nupNhttpBufFull(&responseBody, (unsigned long*)&length, 0, NULL, NULL, &state);
}
result = state.error;
if (result != 0 || state.response == NULL) goto cleanup;
length = NHTTPGetHeaderAll(state.response, &responseHeaders);
if (length < 0) { result = -5007; goto cleanup; }
char* protocol = strstr(responseHeaders, "HTTP/");
if (protocol != NULL && sscanf(protocol, "HTTP/%*d.%*d %d", &status) == 1) {
if (status != 200 && status != 202) result = -5000 - status;
goto cleanup;
}
result = -5007;
goto cleanup;
}
if (OSGetTime() - state.lastActivity >= OSMillisecondsToTicks(90000)) break;
NCDSleep(OSMillisecondsToTicks(100));
}
if (requestId >= 0) {
NHTTPCancelRequestAsync(requestId);
NCDSleep(OSMillisecondsToTicks(100));
}
result = -5009;
cleanup:
if (state.response != NULL || result == -5009) NHTTPDestroyResponse(state.response);
if (headerCopy != NULL) nup::__nupFree(headerCopy);
return result;
}
extern "C" {
static long __nupHttpStringFlush(u8* data, unsigned long length, unsigned long requested, void* context) {
HttpString* text = (HttpString*)context;
unsigned long total;
total = length + text->length;
long result = 0;
if (total > text->capacity) {
if (requested >= total) {} else {
requested = text->growth + total;
text->growth <<= 1;
if (text->growth < text->maximumGrowth) {} else text->growth = text->maximumGrowth;
}
u8* next = (u8*)nup::__nupMalloc(requested);
if (next == NULL) { result = -5000; goto done; }
if (text->buffer != NULL) {
memcpy(next, text->buffer, text->length);
nup::__nupFree(text->buffer);
}
text->buffer = next;
}
memcpy(text->buffer + text->length, data, length);
text->length += length;
done:
return result;
}
}
static int __nupNhttpOpString(u8** output, unsigned long* outputLength, char* url, NHTTPReqMethod method, char* headers, u8* body, unsigned long bodyLength, unsigned long limit, ProgressCallback progress, void* context) NO_INLINE;
static int __nupNhttpOpString(u8** output, unsigned long* outputLength, char* url, NHTTPReqMethod method, char* headers, u8* body, unsigned long bodyLength, unsigned long limit, ProgressCallback progress, void* context) {
HttpString text;
text.buffer = *output;
text.capacity = *outputLength;
text.growth = 0x400;
text.maximumGrowth = 0x10000;
text.length = 0;
int result = __nupNhttpOp(url, method, headers, body, bodyLength, limit, progress, context, __nupHttpStringFlush, &text);
if (result == 0) {
*output = text.buffer;
*outputLength = text.length;
}
if (result != 0) {
if (text.buffer != NULL) nup::__nupFree(text.buffer);
*output = NULL;
*outputLength = 0;
}
return result;
}
int __nupHttpGetFull(char* url, u8** output, unsigned long* length, unsigned long limit, ProgressCallback progress, void* context) {
return __nupNhttpOpString(output, length, url, NHTTP_GET, NULL, NULL, 0, limit, progress, context);
}
int __nupHttpPostFull(char* url, char* headers, char* body, u8** output, unsigned long* length, unsigned long limit, ProgressCallback progress, void* context) {
int result = __nupNhttpOpString(output, length, url, NHTTP_POST, headers, (u8*)body, strlen(body), limit, progress, context);
if (result != 0) {
if (*output != NULL) nup::__nupFree(*output);
*output = NULL;
*length = 0;
}
return result;
}
int __nupHttpGetIncr(char* url, unsigned long limit, ProgressCallback progress, void* progressContext, FlushCallback flush, void* context) {
return __nupNhttpOp(url, NHTTP_GET, NULL, NULL, 0, limit, progress, progressContext, flush, context);
}

116
libs/RVL_SDK/src/vi/i2c.c Normal file
View File

@@ -0,0 +1,116 @@
#include <revolution/os.h>
#include <private/os/OSTime.h>
#include <private/bus.h>
static volatile int __i2c_ident_flag = 1;
static u32 __i2c_ident_first;
#define I2C_OUT 0xCD8000C0
#define I2C_DIR 0xCD8000C4
#define I2C_IN 0xCD8000C8
static inline void delay(void) {
OSTime start = __OSGetSystemTime();
while (OSTicksToMicroseconds(__OSGetSystemTime() - start) < 2) {}
}
static inline void setData(int high) {
if (high) {
if (__i2c_ident_flag == 0) {
BUSWrite32(I2C_OUT, BUSRead32(I2C_OUT) & ~0x8000);
} else {
BUSWrite32(I2C_OUT, (BUSRead32(I2C_OUT) & ~0x8000) | 0x8000);
}
} else {
if (__i2c_ident_flag == 0) {
BUSWrite32(I2C_OUT, (BUSRead32(I2C_OUT) & ~0x8000) | 0x8000);
} else {
BUSWrite32(I2C_OUT, BUSRead32(I2C_OUT) & ~0x8000);
}
}
}
static int sendSlaveAddr(u8 address) {
int bit;
if (__i2c_ident_flag == 0) {
BUSWrite32(I2C_OUT, (BUSRead32(I2C_OUT) & ~0x8000) | 0x8000);
} else {
BUSWrite32(I2C_OUT, BUSRead32(I2C_OUT) & ~0x8000);
}
delay();
BUSWrite32(I2C_OUT, BUSRead32(I2C_OUT) & ~0x4000);
for (bit = 0; bit < 8; bit++) {
setData(address & 0x80);
delay();
BUSWrite32(I2C_OUT, (BUSRead32(I2C_OUT) & ~0x4000) | 0x4000);
delay();
BUSWrite32(I2C_OUT, BUSRead32(I2C_OUT) & ~0x4000);
address = (address & 0x7F) << 1;
}
BUSWrite32(I2C_DIR, (BUSRead32(I2C_DIR) & ~0x8000) | 0x4000);
delay();
BUSWrite32(I2C_OUT, (BUSRead32(I2C_OUT) & ~0x4000) | 0x4000);
delay();
if ((u32)__i2c_ident_flag == 1) {
if ((BUSRead32(I2C_IN) >> 15) & 1) {
return 0;
}
}
setData(0);
BUSWrite32(I2C_DIR, (BUSRead32(I2C_DIR) & ~0x8000) | 0xC000);
BUSWrite32(I2C_OUT, BUSRead32(I2C_OUT) & ~0x4000);
return 1;
}
int __VISendI2CData(u8 address, u8* data, int length) {
int enabled;
if (__i2c_ident_first == 0) {
__i2c_ident_flag = 1;
__i2c_ident_first = 1;
}
enabled = OSDisableInterrupts();
BUSWrite32(I2C_DIR, (BUSRead32(I2C_DIR) & ~0x8000) | 0xC000);
BUSWrite32(I2C_OUT, (BUSRead32(I2C_OUT) & ~0x4000) | 0x4000);
setData(1);
delay();
delay();
if (!sendSlaveAddr(address)) {
OSRestoreInterrupts(enabled);
return 0;
}
BUSWrite32(I2C_DIR, (BUSRead32(I2C_DIR) & ~0x8000) | 0xC000);
while (length != 0) {
int bit;
u8 value = *data++;
for (bit = 0; bit < 8; bit++) {
setData(value & 0x80);
delay();
BUSWrite32(I2C_OUT, (BUSRead32(I2C_OUT) & ~0x4000) | 0x4000);
delay();
BUSWrite32(I2C_OUT, BUSRead32(I2C_OUT) & ~0x4000);
value = (value & 0x7F) << 1;
}
BUSWrite32(I2C_DIR, (BUSRead32(I2C_DIR) & ~0x8000) | 0x4000);
delay();
BUSWrite32(I2C_OUT, (BUSRead32(I2C_OUT) & ~0x4000) | 0x4000);
delay();
if ((u32)__i2c_ident_flag == 1) {
if ((BUSRead32(I2C_IN) >> 15) & 1) {
OSRestoreInterrupts(enabled);
return 0;
}
}
setData(0);
BUSWrite32(I2C_DIR, (BUSRead32(I2C_DIR) & ~0x8000) | 0xC000);
BUSWrite32(I2C_OUT, BUSRead32(I2C_OUT) & ~0x4000);
length--;
}
BUSWrite32(I2C_DIR, (BUSRead32(I2C_DIR) & ~0x8000) | 0xC000);
setData(0);
delay();
BUSWrite32(I2C_OUT, (BUSRead32(I2C_OUT) & ~0x4000) | 0x4000);
delay();
setData(1);
OSRestoreInterrupts(enabled);
return 1;
}

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