Compare commits

..

1 Commits

Author SHA1 Message Date
devin
449fb9a66e Decode iplSDChannelTitle + ut_ArchiveFontBase (source-only, stays NonMatching)
- SDButton::setEventHandler was genuinely 1-arg in retail (dead second
  param): corrected decl/def/call sites + symbols.txt mangle. Fixes 5
  fns to instruction-identical and lifts iplSDChannelTitle data to
  .data/.rodata/.sdata/.sdata2 100% (was 12.1%).
- ut_ArchiveFontBase: reordered sheetOffsetsScratch decl/assign to
  match orig materialization.

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

Co-authored-by: coah80 <usernamecole7@gmail.com>
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-10-02 14:50:59 +00:00
407 changed files with 4215 additions and 88306 deletions

View File

@@ -2,8 +2,6 @@ name: README progress
# runs on the self-hosted runner on cole's server so it doesn't use hosted minutes.
# only push/schedule/manual triggers, never pull_request, so fork PRs can't reach this machine.
# it never commits to main: it rebuilds, publishes the numbers to the job summary, and force-pushes
# the README badge JSON as a single commit on the orphan progress-data branch.
on:
push:
branches: [main]
@@ -50,22 +48,15 @@ jobs:
- name: Report
run: build/tools/objdiff-cli report generate -p . -o build/43U/report.json -f json
- name: Summary
run: |
python3 tools/update_readme_progress.py build/43U/report.json README.md "$GITHUB_SHA"
sed -n '/progress:start/,/progress:end/p' README.md >> "$GITHUB_STEP_SUMMARY"
git checkout -- README.md
- name: Update README
run: python3 tools/update_readme_progress.py build/43U/report.json README.md "$GITHUB_SHA"
- name: Publish badges
if: github.ref == 'refs/heads/main'
- name: Commit
run: |
out="$RUNNER_TEMP/progress-data"
rm -rf "$out"
python3 tools/progress_badges.py build/43U/report.json "$out"
cd "$out"
git init -q -b progress-data
if git diff --quiet README.md; then exit 0; fi
git config user.name "github-actions[bot]"
git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
git add .
git commit -q -m "progress for $GITHUB_SHA"
git push -q -f "https://x-access-token:${{ github.token }}@github.com/$GITHUB_REPOSITORY.git" HEAD:refs/heads/progress-data
git add README.md
git commit -m "docs: update progress [skip ci]"
git pull --rebase origin main || { git rebase --abort; echo "main moved, next run will update"; exit 0; }
git push origin HEAD:main

View File

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

View File

@@ -11,8 +11,6 @@ splits: 'config/43U/splits.txt'
ldscript_template: 'config/ldscript_ipl2.lcf'
force_active:
- SOGetSockOpt
- SOSetInterfaceOpt
- fprintf
- leap_days
- __msl_time2tm
@@ -37,9 +35,6 @@ force_active:
# textinput::toolbar::csPaneToAnimation points one past the end of csAninationFile.
block_relocations:
# Run establishes a fixed stack at 0x81600000, not __pformatter + 0x280.
- source: .text:0x8137B468
- source: .text:0x8137B46C
- source: .data:0x8165E15C
- source: .data:0x8165E19C

View File

@@ -44,7 +44,7 @@ UpdateDiskID = .bss:0x810ADF60; // type:object size:0x20 align:32 data:4byte
TicketViewsBuf = .bss:0x810ADF80; // type:object size:0x3600 scope:local align:32
Flags0 = .bss:0x810B1580; // type:object size:0x800 scope:local
Flags1 = .bss:0x810B1D80; // type:object size:0x800 scope:local
Thread = .bss:0x810B2580; // type:object size:0x318 scope:local
Thread = .bss:0x810B2580; // type:object size:0x1318 scope:local
UpdateHeader0 = .bss:0x810B38A0; // type:object size:0x20 scope:local
UpdateHeader1 = .bss:0x810B38C0; // type:object size:0x20 scope:local
viewsBuf = .bss:0x810B38E0; // type:object size:0x3600 scope:local
@@ -87,28 +87,23 @@ m_allocator__Q23ipl5scene = .bss:0x810BD498; // type:object size:0x10
AOSSi_NcdIfConfig = .bss:0x810BD4A8; // type:object size:0x15E data:byte
AOSSi_NcdIpConfig = .bss:0x810BD608; // type:object size:0x7C4 data:4byte
sRakuAllocator = .bss:0x810BDDD0; // type:object size:0x10
sRakuStatus = .bss:0x810BDDE0; // type:object size:0xC data:4byte
sRakuConfiguration = .bss:0x810BDDEC; // type:object size:0xE8
sRakuStatus = .bss:0x810BDDE0; // type:object size:0xF4 data:4byte
sRakuMsgQueue = .bss:0x810BDED4; // type:object size:0x20
AOSS_810BDEF8 = .bss:0x810BDEF8; // type:object size:0x20 data:4byte
AOSS_810BDF18 = .bss:0x810BDF18; // type:object size:0x6A0
AOSS_810BE5B8 = .bss:0x810BE5B8; // type:object size:0x280
AOSS_810BE838 = .bss:0x810BE838; // type:object size:0x68
AOSS_810BE8A0 = .bss:0x810BE8A0; // type:object size:0x400
gAtermIpConfig = .bss:0x810BECA0; // type:object size:0x7C4 data:4byte
gAtermIfConfig = .bss:0x810BF464; // type:object size:0x15E
ATERM_810BECA0 = .bss:0x810BECA0; // type:object size:0x924 data:4byte
ATERM_810BF5C4 = .bss:0x810BF5C4; // type:object size:0x24
ATERM_810BF5E8 = .bss:0x810BF5E8; // type:object size:0x258
gAtermConfigurationResult = .bss:0x810BF840; // type:object size:0xE8
gAtermAssociationRequest = .bss:0x810BF928; // type:object size:0x10
gAtermPacketBuffer = .bss:0x810BF938; // type:object size:0x800
gAtermDecodedResponse = .bss:0x810C0138; // type:object size:0x800 data:2byte
gAtermSession = .bss:0x810C0938; // type:object size:0x20
ATERM_810BF840 = .bss:0x810BF840; // type:object size:0x900
ATERM_810C0140 = .bss:0x810C0140; // type:object size:0x818 data:2byte
AtermThread = .bss:0x810C0958; // type:object size:0x318 scope:local align:32
Voices = .bss:0x810C0C80; // type:object size:0x1800 data:4byte
sZeroMem = .bss:0x810C2480; // type:object size:0x100 data:byte
s_player_thread_stack = .bss:0x810C2580; // type:object size:0x4000 scope:local
lbl_810C6580 = .bss:0x810C6580; // type:object size:0xC
lbl_810C6580 = .bss:0x810C6580; // type:object size:0x10
layoutGatherDestructorRecord = .bss:0x810C6590; // type:object size:0xC data:4byte
unInputedWCharColorDestructorRecord = .bss:0x810C659C; // type:object size:0xC data:4byte
charColorDestructorRecord = .bss:0x810C65A8; // type:object size:0xC data:4byte
@@ -118,9 +113,7 @@ ziStringColorRightDestructorRecord = .bss:0x810C65CC; // type:object size:0xC da
underlateColorDestructorRecord = .bss:0x810C65D8; // type:object size:0xC data:4byte
unInputedWCharColorSpaceDestructorRecord = .bss:0x810C65E4; // type:object size:0xC data:4byte
ElementBuffer__Q39textinput8tistring6WithZi = .bss:0x810C65F0; // type:object size:0x200 data:2byte
CandidatesBuffer__Q39textinput8tistring6WithZi = .bss:0x810C67F0; // type:object size:0x200 data:2byte
ElementWorkBuffer__Q39textinput8tistring6WithZi = .bss:0x810C69F0; // type:object size:0x200 data:2byte
PredictionBuffer__Q39textinput8tistring6WithZi = .bss:0x810C6BF0; // type:object size:0x200 data:2byte
CandidatesBuffer__Q39textinput8tistring6WithZi = .bss:0x810C67F0; // type:object size:0x600 data:2byte
CandidatedWord__Q39textinput8tistring6WithZi = .bss:0x810C6DF0; // type:object size:0x1400 data:2byte
LatestWord__Q39textinput8tistring6WithZi = .bss:0x810C81F0; // type:object size:0x80 data:2byte
snWidthTable__Q29textinput10textdrawer = .bss:0x810C8270; // type:object size:0x580 data:4byte
@@ -4583,9 +4576,9 @@ enqueueNotice__Q33ipl5scene15SDChannelSelectFUlUlUl = .text:0x813DB254; // type:
enqueueLoadNotice__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB308; // type:function size:0x5C
enqueuePageNotice__Q33ipl5scene15SDChannelSelectFv = .text:0x813DB364; // type:function size:0x5C
enqueueResultNotice__Q33ipl5scene15SDChannelSelectFUl = .text:0x813DB3C0; // type:function size:0x5C
enqueueChannelNotice__Q33ipl5scene15SDChannelSelectFUxUl = .text:0x813DB41C; // type:function size:0x5C
enqueueChannelNotice__Q33ipl5scene15SDChannelSelectFUlUlUlUl = .text:0x813DB41C; // type:function size:0x5C
enqueueMoveNotice__Q33ipl5scene15SDChannelSelectFUlUlUl = .text:0x813DB478; // type:function size:0x5C
enqueueStateNotice__Q33ipl5scene15SDChannelSelectFUxUl = .text:0x813DB4D4; // type:function size:0x5C
enqueueStateNotice__Q33ipl5scene15SDChannelSelectFUlUlUlUl = .text:0x813DB4D4; // type:function size:0x5C
enqueueErrorNotice__Q33ipl5scene15SDChannelSelectFUlUl = .text:0x813DB530; // type:function size:0x5C
enqueueCommandNotice__Q33ipl5scene15SDChannelSelectFUlUlUl = .text:0x813DB58C; // type:function size:0x60
enqueueDeleteNotice__Q33ipl5scene15SDChannelSelectFUlUlUl = .text:0x813DB5EC; // type:function size:0x60
@@ -5165,7 +5158,7 @@ AOSSi_WLANConnect = .text:0x813FD72C; // type:function size:0x26C
AOSSi_Sleep = .text:0x813FD998; // type:function size:0x4
AOSSi_Status = .text:0x813FD99C; // type:function size:0x34
AOSS_SetCallback = .text:0x813FD9D0; // type:function size:0x34
syncRakuProgress__Q33ipl5scene14RakuRakuThreadFP12RakuProgress = .text:0x813FDA04; // type:function size:0x6C scope:local
syncRakuProgress__Q33ipl5scene14RakuRakuThreadFv = .text:0x813FDA04; // type:function size:0x6C scope:local
__ct__Q33ipl5scene14RakuRakuThreadFPQ23EGG4Heap = .text:0x813FDA70; // type:function size:0xD8
__dt__Q33ipl5scene14RakuRakuThreadFv = .text:0x813FDB48; // type:function size:0xA4
destroy__Q33ipl5scene14RakuRakuThreadFv = .text:0x813FDBEC; // type:function size:0xD8
@@ -13910,15 +13903,10 @@ lbl_81610608 = .rodata:0x81610608; // type:object size:0x300
lbl_81610908 = .rodata:0x81610908; // type:object size:0x10
sCaptureSizes__Q23ipl5scene = .rodata:0x81610918; // type:object size:0x10
lbl_81610928 = .rodata:0x81610928; // type:object size:0x20 data:4byte
scAnmTable__Q23ipl5scene = .rodata:0x81610948; // type:object size:0xE8 scope:local
@17203 = .rodata:0x81610A30; // type:object size:0x1C scope:local
@17212 = .rodata:0x81610A4C; // type:object size:0x30 scope:local
@17223 = .rodata:0x81610A7C; // type:object size:0x28 scope:local
@17227 = .rodata:0x81610AA4; // type:object size:0x30 scope:local
@17254 = .rodata:0x81610AD4; // type:object size:0x1C scope:local
@18816 = .rodata:0x81610AF0; // type:object size:0x30 scope:local data:4byte
@18818 = .rodata:0x81610B20; // type:object size:0x60 scope:local data:4byte
@19272 = .rodata:0x81610B80; // type:object size:0x20 scope:local data:wstring
scAnmTable__Q23ipl5scene = .rodata:0x81610948; // type:object size:0x1A8 scope:local
lbl_81610AF0 = .rodata:0x81610AF0; // type:object size:0x30 data:4byte
lbl_81610B20 = .rodata:0x81610B20; // type:object size:0x60 data:4byte
lbl_81610B80 = .rodata:0x81610B80; // type:object size:0x20 data:wstring
scNumber__Q23ipl5scene = .rodata:0x81610BA0; // type:object size:0x14 scope:local data:2byte
scNumber2__Q23ipl5scene = .rodata:0x81610BB4; // type:object size:0x14 scope:local data:2byte
lbl_81610BC8 = .rodata:0x81610BC8; // type:object size:0x1000
@@ -16161,11 +16149,6 @@ lbl_8164EF14 = .data:0x8164EF14; // type:object size:0x34
__vt__Q33ipl5scene27CsChanTtlButtonEventHandler = .data:0x8164EF48; // type:object size:0x1C
__vt__Q33ipl5scene24ChannelTitleEventHandler = .data:0x8164EF64; // type:object size:0x18
__vt__Q33ipl5scene12ChannelTitle = .data:0x8164EF7C; // type:object size:0x68
lbl_8164EFE4 = .data:0x8164EFE4; // type:object size:0x5C
lbl_8164F040 = .data:0x8164F040; // type:object size:0x18
lbl_8164F058 = .data:0x8164F058; // type:object size:0x20
lbl_8164F078 = .data:0x8164F078; // type:object size:0x20
lbl_8164F098 = .data:0x8164F098; // type:object size:0x20
@10125 = .data:0x8164F0B8; // type:object size:0xD scope:local data:string
...data.0 = .data:0x8164F0B8; // type:label scope:local
@10126 = .data:0x8164F0C5; // type:object size:0xD scope:local data:string
@@ -17176,23 +17159,7 @@ sSettingAPPaneNames__Q23ipl5scene = .data:0x81656978; // type:object size:0x68 d
sSettingAPAnimations__Q23ipl5scene = .data:0x81656B6C; // type:object size:0x4C data:4byte
@25442 = .data:0x81656BB8; // type:object size:0xF scope:local data:string
@25443 = .data:0x81656BC7; // type:object size:0x1C scope:local data:string
@25501 = .data:0x81656BE3; // type:object size:0xF scope:local data:string
@25502 = .data:0x81656BF2; // type:object size:0x14 scope:local data:string
@25503 = .data:0x81656C06; // type:object size:0x18 scope:local data:string
@25505 = .data:0x81656C1E; // type:object size:0x1A scope:local data:string
@25506 = .data:0x81656C38; // type:object size:0x13 scope:local data:string
@25508 = .data:0x81656C4B; // type:object size:0x9 scope:local data:string
@25509 = .data:0x81656C54; // type:object size:0x12 scope:local data:string
@25510 = .data:0x81656C66; // type:object size:0xC scope:local data:string
@25616 = .data:0x81656C72; // type:object size:0xD scope:local data:string
@25618 = .data:0x81656C7F; // type:object size:0xF scope:local data:string
@25620 = .data:0x81656C8E; // type:object size:0x14 scope:local data:string
@25621 = .data:0x81656CA2; // type:object size:0x1A scope:local data:string
@25622 = .data:0x81656CBC; // type:object size:0x19 scope:local data:string
@25623 = .data:0x81656CD5; // type:object size:0xE scope:local data:string
@25624 = .data:0x81656CE3; // type:object size:0x13 scope:local data:string
@25625 = .data:0x81656CF6; // type:object size:0x18 scope:local data:string
@25628 = .data:0x81656D0E; // type:object size:0x19 scope:local data:string
@17193 = .data:0x81656D27; // type:object size:0xC scope:local data:string
@17194 = .data:0x81656D33; // type:object size:0x20 scope:local data:string
@17197 = .data:0x81656D53; // type:object size:0xD scope:local data:string
@@ -17206,32 +17173,10 @@ sSettingAPAnimations__Q23ipl5scene = .data:0x81656B6C; // type:object size:0x4C
@17250 = .data:0x81656DFA; // type:object size:0x11 scope:local data:string
@17251 = .data:0x81656E0B; // type:object size:0x9 scope:local data:string
@17252 = .data:0x81656E14; // type:object size:0xD scope:local data:string
@25720 = .data:0x81656E21; // type:object size:0x23 scope:local data:string
@25721 = .data:0x81656E44; // type:object size:0xD scope:local data:string
@25722 = .data:0x81656E51; // type:object size:0xD scope:local data:string
@25723 = .data:0x81656E5E; // type:object size:0xD scope:local data:string
@25724 = .data:0x81656E6B; // type:object size:0x25 scope:local data:string
@25726 = .data:0x81656E90; // type:object size:0x15 scope:local data:string
@25747 = .data:0x81656EA5; // type:object size:0x1B scope:local data:string
@25766 = .data:0x81656EC0; // type:object size:0x1D scope:local data:string
@25767 = .data:0x81656EDD; // type:object size:0x11 scope:local data:string
@25768 = .data:0x81656EEE; // type:object size:0x1D scope:local data:string
@26292 = .data:0x81656F0B; // type:object size:0xF scope:local data:string
@26293 = .data:0x81656F1A; // type:object size:0xD scope:local data:string
@26294 = .data:0x81656F27; // type:object size:0x11 scope:local data:string
@26295 = .data:0x81656F38; // type:object size:0x11 scope:local data:string
@26296 = .data:0x81656F49; // type:object size:0xA scope:local data:string
@26297 = .data:0x81656F53; // type:object size:0xD scope:local data:string
@26300 = .data:0x81656F60; // type:object size:0x1A0 scope:local
@26299 = .data:0x81657100; // type:object size:0x48 scope:local
@26346 = .data:0x81657148; // type:object size:0x26 scope:local data:string
@26347 = .data:0x8165716E; // type:object size:0xF scope:local data:string
@26348 = .data:0x8165717D; // type:object size:0xE scope:local data:string
@26349 = .data:0x8165718B; // type:object size:0xA scope:local data:string
@26350 = .data:0x81657195; // type:object size:0xB scope:local data:string
@26351 = .data:0x816571A0; // type:object size:0x16 scope:local data:string
@26353 = .data:0x816571B6; // type:object size:0x11 scope:local data:string
@26354 = .data:0x816571C7; // type:object size:0x16 scope:local data:string
@26502 = .data:0x816571DD; // type:object size:0xF scope:local data:string
@26534 = .data:0x816571EC; // type:object size:0x18 scope:local data:string
@26536 = .data:0x81657204; // type:object size:0x44 scope:local
@@ -17265,11 +17210,6 @@ sSettingAPAnimations__Q23ipl5scene = .data:0x81656B6C; // type:object size:0x4C
@28326 = .data:0x81657642; // type:object size:0x2A scope:local data:string
@28370 = .data:0x8165766C; // type:object size:0x10 scope:local data:string
@28383 = .data:0x8165767C; // type:object size:0x14 scope:local data:string
@28436 = .data:0x81657690; // type:object size:0x16 scope:local data:string
@28437 = .data:0x816576A6; // type:object size:0xF scope:local data:string
@28438 = .data:0x816576B5; // type:object size:0x13 scope:local data:string
@28439 = .data:0x816576C8; // type:object size:0x1A scope:local data:string
@28440 = .data:0x816576E2; // type:object size:0x1B scope:local data:string
@28442 = .data:0x81657700; // type:object size:0x84 scope:local
__vt__Q33ipl5scene7APEvent = .data:0x81657784; // type:object size:0x18
__vt__Q33ipl5scene7Setting = .data:0x8165779C; // type:object size:0x68
@@ -18112,7 +18052,7 @@ __vt__Q49textinput6extend4memo15AppearMemoState = .data:0x81667FA0; // type:obje
__vt__Q49textinput6extend4memo13DispMemoState = .data:0x81667FF8; // type:object size:0x58
__vt__Q49textinput6extend4memo5State = .data:0x81668050; // type:object size:0x58
__vt__Q49textinput6extend4memo7Manager = .data:0x816680A8; // type:object size:0x140
lbl_816681E8 = .data:0x816681E8; // type:object size:0x24
lbl_816681E8 = .data:0x816681E8; // type:object size:0x28
lbl_81668210 = .data:0x81668210; // type:object size:0x9 data:string
lbl_8166821C = .data:0x8166821C; // type:object size:0x9 data:string
lbl_81668228 = .data:0x81668228; // type:object size:0x9 data:string
@@ -22427,93 +22367,93 @@ lbl_81696FD0 = .sdata:0x81696FD0; // type:object size:0x6 data:wstring
lbl_81696FD6 = .sdata:0x81696FD6; // type:object size:0x4 data:wstring
lbl_81696FDA = .sdata:0x81696FDA; // type:object size:0x7 data:string
lbl_81696FE1 = .sdata:0x81696FE1; // type:object size:0x7 data:string
@16789 = .sdata:0x81696FE8; // type:object size:0x6 data:string
@16790 = .sdata:0x81696FEE; // type:object size:0x6 data:string
@16791 = .sdata:0x81696FF4; // type:object size:0x6 data:string
@16792 = .sdata:0x81696FFA; // type:object size:0x6 data:string
@16793 = .sdata:0x81697000; // type:object size:0x7 data:string
@16794 = .sdata:0x81697007; // type:object size:0x7 data:string
sSettingArrowNames__Q23ipl5scene = .sdata:0x81697010; // type:object size:0x8 data:4byte
@16795 = .sdata:0x81697018; // type:object size:0x8 data:string
@16796 = .sdata:0x81697020; // type:object size:0x8 data:string
@16797 = .sdata:0x81697028; // type:object size:0x8 data:string
@16798 = .sdata:0x81697030; // type:object size:0x8 data:string
@16799 = .sdata:0x81697038; // type:object size:0x8 data:string
@16800 = .sdata:0x81697040; // type:object size:0x8 data:string
@16801 = .sdata:0x81697048; // type:object size:0x6 data:string
@16802 = .sdata:0x8169704E; // type:object size:0x6 data:string
@16803 = .sdata:0x81697054; // type:object size:0x6 data:string
@16804 = .sdata:0x8169705A; // type:object size:0x6 data:string
@16805 = .sdata:0x81697060; // type:object size:0x6 data:string
@16806 = .sdata:0x81697066; // type:object size:0x6 data:string
@16809 = .sdata:0x8169706C; // type:object size:0x7 data:string
@16810 = .sdata:0x81697073; // type:object size:0x7 data:string
@16811 = .sdata:0x8169707A; // type:object size:0x8 data:string
@16812 = .sdata:0x81697082; // type:object size:0x7 data:string
@16813 = .sdata:0x81697089; // type:object size:0x6 data:string
@16814 = .sdata:0x8169708F; // type:object size:0x6 data:string
@16815 = .sdata:0x81697095; // type:object size:0x6 data:string
@16816 = .sdata:0x8169709B; // type:object size:0x6 data:string
@16817 = .sdata:0x816970A1; // type:object size:0x6 data:string
@16818 = .sdata:0x816970A7; // type:object size:0x6 data:string
@16819 = .sdata:0x816970AD; // type:object size:0x6 data:string
@16820 = .sdata:0x816970B3; // type:object size:0x6 data:string
@16827 = .sdata:0x816970B9; // type:object size:0x8 data:string
@16828 = .sdata:0x816970C1; // type:object size:0x8 data:string
@16829 = .sdata:0x816970C9; // type:object size:0x8 data:string
@16830 = .sdata:0x816970D1; // type:object size:0x8 data:string
@16831 = .sdata:0x816970D9; // type:object size:0x8 data:string
@16832 = .sdata:0x816970E1; // type:object size:0x8 data:string
@25504 = .sdata:0x816970E9; // type:object size:0x4 data:string
@25507 = .sdata:0x816970ED; // type:object size:0x4 data:string
@25617 = .sdata:0x816970F1; // type:object size:0x5 data:string
@25619 = .sdata:0x816970F6; // type:object size:0x4 data:string
@25626 = .sdata:0x816970FA; // type:object size:0x7 data:string
@25627 = .sdata:0x81697101; // type:object size:0x7 data:string
@17202 = .sdata:0x81697108; // type:object size:0x3 data:string
@17205 = .sdata:0x8169710B; // type:object size:0x6 data:string
@17206 = .sdata:0x81697111; // type:object size:0x7 data:string
@17207 = .sdata:0x81697118; // type:object size:0x6 data:string
@17208 = .sdata:0x8169711E; // type:object size:0x1
@17209 = .sdata:0x8169711F; // type:object size:0x6 data:string
@17210 = .sdata:0x81697125; // type:object size:0x6 data:string
@17211 = .sdata:0x8169712B; // type:object size:0x6 data:string
@17214 = .sdata:0x81697131; // type:object size:0x4 data:string
@17215 = .sdata:0x81697135; // type:object size:0x4 data:string
@17216 = .sdata:0x81697139; // type:object size:0x4 data:string
@17217 = .sdata:0x8169713D; // type:object size:0x4 data:string
@17218 = .sdata:0x81697141; // type:object size:0x4 data:string
@17219 = .sdata:0x81697145; // type:object size:0x4 data:string
@17220 = .sdata:0x81697149; // type:object size:0x4 data:string
@17221 = .sdata:0x8169714D; // type:object size:0x4 data:string
@17222 = .sdata:0x81697151; // type:object size:0x4 data:string
@17248 = .sdata:0x81697155; // type:object size:0x8 data:string
@17249 = .sdata:0x8169715D; // type:object size:0x6 data:string
@17253 = .sdata:0x81697163; // type:object size:0x7 data:string
@25725 = .sdata:0x8169716A; // type:object size:0x4 data:string
@26352 = .sdata:0x8169716E; // type:object size:0x5 data:string
@26503 = .sdata:0x81697173; // type:object size:0x7 data:string
@26504 = .sdata:0x8169717A; // type:object size:0x5 data:string
@26505 = .sdata:0x8169717F; // type:object size:0x5 data:string
@26506 = .sdata:0x81697184; // type:object size:0x5 data:string
@26625 = .sdata:0x8169718A; // type:object size:0x2
@26851 = .sdata:0x8169718C; // type:object size:0x3 data:string
@18811 = .sdata:0x8169718F; // type:object size:0x2 data:string
@18812 = .sdata:0x81697191; // type:object size:0x2 data:string
@18813 = .sdata:0x81697193; // type:object size:0x2 data:string
@18814 = .sdata:0x81697195; // type:object size:0x2 data:string
@18815 = .sdata:0x81697197; // type:object size:0x2 data:string
@27404 = .sdata:0x81697199; // type:object size:0x6 data:string
@27405 = .sdata:0x8169719F; // type:object size:0x6 data:string
@27406 = .sdata:0x816971A5; // type:object size:0x6 data:string
@27407 = .sdata:0x816971AB; // type:object size:0x6 data:string
@27556 = .sdata:0x816971B1; // type:object size:0x6 data:string
@27557 = .sdata:0x816971B7; // type:object size:0x6 data:string
@27558 = .sdata:0x816971BD; // type:object size:0x6 data:string
@27559 = .sdata:0x816971C3; // type:object size:0x6 data:string
@27560 = .sdata:0x816971C9; // type:object size:0x7 data:string
@27862 = .sdata:0x816971D0; // type:object size:0x3 data:string
@28152 = .sdata:0x816971D4; // type:object size:0x8 data:wstring
lbl_81696FE8 = .sdata:0x81696FE8; // type:object size:0x6 data:string
lbl_81696FEE = .sdata:0x81696FEE; // type:object size:0x6 data:string
lbl_81696FF4 = .sdata:0x81696FF4; // type:object size:0x6 data:string
lbl_81696FFA = .sdata:0x81696FFA; // type:object size:0x6 data:string
lbl_81697000 = .sdata:0x81697000; // type:object size:0x7 data:string
lbl_81697007 = .sdata:0x81697007; // type:object size:0x7 data:string
lbl_81697010 = .sdata:0x81697010; // type:object size:0x8 data:4byte
lbl_81697018 = .sdata:0x81697018; // type:object size:0x8 data:string
lbl_81697020 = .sdata:0x81697020; // type:object size:0x8 data:string
lbl_81697028 = .sdata:0x81697028; // type:object size:0x8 data:string
lbl_81697030 = .sdata:0x81697030; // type:object size:0x8 data:string
lbl_81697038 = .sdata:0x81697038; // type:object size:0x8 data:string
lbl_81697040 = .sdata:0x81697040; // type:object size:0x8 data:string
lbl_81697048 = .sdata:0x81697048; // type:object size:0x6 data:string
lbl_8169704E = .sdata:0x8169704E; // type:object size:0x6 data:string
lbl_81697054 = .sdata:0x81697054; // type:object size:0x6 data:string
lbl_8169705A = .sdata:0x8169705A; // type:object size:0x6 data:string
lbl_81697060 = .sdata:0x81697060; // type:object size:0x6 data:string
lbl_81697066 = .sdata:0x81697066; // type:object size:0x6 data:string
lbl_8169706C = .sdata:0x8169706C; // type:object size:0x7 data:string
lbl_81697073 = .sdata:0x81697073; // type:object size:0x7 data:string
lbl_8169707A = .sdata:0x8169707A; // type:object size:0x8 data:string
lbl_81697082 = .sdata:0x81697082; // type:object size:0x7 data:string
lbl_81697089 = .sdata:0x81697089; // type:object size:0x6 data:string
lbl_8169708F = .sdata:0x8169708F; // type:object size:0x6 data:string
lbl_81697095 = .sdata:0x81697095; // type:object size:0x6 data:string
lbl_8169709B = .sdata:0x8169709B; // type:object size:0x6 data:string
lbl_816970A1 = .sdata:0x816970A1; // type:object size:0x6 data:string
lbl_816970A7 = .sdata:0x816970A7; // type:object size:0x6 data:string
lbl_816970AD = .sdata:0x816970AD; // type:object size:0x6 data:string
lbl_816970B3 = .sdata:0x816970B3; // type:object size:0x6 data:string
lbl_816970B9 = .sdata:0x816970B9; // type:object size:0x8 data:string
lbl_816970C1 = .sdata:0x816970C1; // type:object size:0x8 data:string
lbl_816970C9 = .sdata:0x816970C9; // type:object size:0x8 data:string
lbl_816970D1 = .sdata:0x816970D1; // type:object size:0x8 data:string
lbl_816970D9 = .sdata:0x816970D9; // type:object size:0x8 data:string
lbl_816970E1 = .sdata:0x816970E1; // type:object size:0x8 data:string
lbl_816970E9 = .sdata:0x816970E9; // type:object size:0x4 data:string
lbl_816970ED = .sdata:0x816970ED; // type:object size:0x4 data:string
lbl_816970F1 = .sdata:0x816970F1; // type:object size:0x5 data:string
lbl_816970F6 = .sdata:0x816970F6; // type:object size:0x4 data:string
lbl_816970FA = .sdata:0x816970FA; // type:object size:0x7 data:string
lbl_81697101 = .sdata:0x81697101; // type:object size:0x7 data:string
lbl_81697108 = .sdata:0x81697108; // type:object size:0x3 data:string
lbl_8169710B = .sdata:0x8169710B; // type:object size:0x6 data:string
lbl_81697111 = .sdata:0x81697111; // type:object size:0x7 data:string
lbl_81697118 = .sdata:0x81697118; // type:object size:0x6 data:string
lbl_8169711E = .sdata:0x8169711E; // type:object size:0x1
lbl_8169711F = .sdata:0x8169711F; // type:object size:0x6 data:string
lbl_81697125 = .sdata:0x81697125; // type:object size:0x6 data:string
lbl_8169712B = .sdata:0x8169712B; // type:object size:0x6 data:string
lbl_81697131 = .sdata:0x81697131; // type:object size:0x4 data:string
lbl_81697135 = .sdata:0x81697135; // type:object size:0x4 data:string
lbl_81697139 = .sdata:0x81697139; // type:object size:0x4 data:string
lbl_8169713D = .sdata:0x8169713D; // type:object size:0x4 data:string
lbl_81697141 = .sdata:0x81697141; // type:object size:0x4 data:string
lbl_81697145 = .sdata:0x81697145; // type:object size:0x4 data:string
lbl_81697149 = .sdata:0x81697149; // type:object size:0x4 data:string
lbl_8169714D = .sdata:0x8169714D; // type:object size:0x4 data:string
lbl_81697151 = .sdata:0x81697151; // type:object size:0x4 data:string
lbl_81697155 = .sdata:0x81697155; // type:object size:0x8 data:string
lbl_8169715D = .sdata:0x8169715D; // type:object size:0x6 data:string
lbl_81697163 = .sdata:0x81697163; // type:object size:0x7 data:string
lbl_8169716A = .sdata:0x8169716A; // type:object size:0x4 data:string
lbl_8169716E = .sdata:0x8169716E; // type:object size:0x5 data:string
lbl_81697173 = .sdata:0x81697173; // type:object size:0x7 data:string
lbl_8169717A = .sdata:0x8169717A; // type:object size:0x5 data:string
lbl_8169717F = .sdata:0x8169717F; // type:object size:0x5 data:string
lbl_81697184 = .sdata:0x81697184; // type:object size:0x5 data:string
lbl_8169718A = .sdata:0x8169718A; // type:object size:0x2
lbl_8169718C = .sdata:0x8169718C; // type:object size:0x3 data:string
lbl_8169718F = .sdata:0x8169718F; // type:object size:0x2 data:string
lbl_81697191 = .sdata:0x81697191; // type:object size:0x2 data:string
lbl_81697193 = .sdata:0x81697193; // type:object size:0x2 data:string
lbl_81697195 = .sdata:0x81697195; // type:object size:0x2 data:string
lbl_81697197 = .sdata:0x81697197; // type:object size:0x2 data:string
lbl_81697199 = .sdata:0x81697199; // type:object size:0x6 data:string
lbl_8169719F = .sdata:0x8169719F; // type:object size:0x6 data:string
lbl_816971A5 = .sdata:0x816971A5; // type:object size:0x6 data:string
lbl_816971AB = .sdata:0x816971AB; // type:object size:0x6 data:string
lbl_816971B1 = .sdata:0x816971B1; // type:object size:0x6 data:string
lbl_816971B7 = .sdata:0x816971B7; // type:object size:0x6 data:string
lbl_816971BD = .sdata:0x816971BD; // type:object size:0x6 data:string
lbl_816971C3 = .sdata:0x816971C3; // type:object size:0x6 data:string
lbl_816971C9 = .sdata:0x816971C9; // type:object size:0x7 data:string
lbl_816971D0 = .sdata:0x816971D0; // type:object size:0x3 data:string
lbl_816971D4 = .sdata:0x816971D4; // type:object size:0x8 data:wstring
@12299 = .sdata:0x816971E0; // type:object size:0x5 scope:local data:string
@12302 = .sdata:0x816971E5; // type:object size:0x5 scope:local data:string
lbl_816971F0 = .sdata:0x816971F0; // type:object size:0x4 data:string
@@ -23281,7 +23221,7 @@ lbl_81698388 = .sdata:0x81698388; // type:object size:0x2 data:string
lbl_8169838C = .sdata:0x8169838C; // type:object size:0x4 data:string
lbl_81698390 = .sdata:0x81698390; // type:object size:0x1 data:byte
lbl_81698391 = .sdata:0x81698391; // type:object size:0x1 data:byte
lbl_81698394 = .sdata:0x81698394; // type:object size:0x4 data:string
lbl_81698394 = .sdata:0x81698394; // type:object size:0x2 data:string
lbl_81698398 = .sdata:0x81698398; // type:object size:0x2 data:string
lbl_8169839C = .sdata:0x8169839C; // type:object size:0x4
drvInitFunc = .sdata:0x816983A0; // type:object size:0x8 scope:local data:4byte
@@ -23889,7 +23829,7 @@ result$1126 = .sbss:0x81698E48; // type:object size:0x4 data:4byte
soState = .sbss:0x81698E50; // type:object size:0x1 scope:local data:byte
soError = .sbss:0x81698E54; // type:object size:0x4 scope:local data:4byte
soRegistered = .sbss:0x81698E58; // type:object size:0x4 scope:local data:4byte
soSocketRegistered = .sbss:0x81698E60; // type:object size:0x4 scope:local data:4byte
soSocketRegistered = .sbss:0x81698E60; // type:object size:0x8 scope:local data:4byte
sslRegistered = .sbss:0x81698E68; // type:object size:0x4 scope:local data:4byte
l_initialized = .sbss:0x81698E6C; // type:object size:0x4 scope:local data:4byte
VFipf_sys_set = .sbss:0x81698E70; // type:object size:0x4 scope:global data:4byte

View File

@@ -648,7 +648,7 @@ config.libs = [
Object(Matching, "system/iplDialogWindow.cpp"),
Object(Matching, "system/iplHomeButtonMenu.cpp"),
Object(Matching, "system/iplNandSDWorker.cpp"),
Object(Matching, "system/iplKeyboard.cpp"),
Object(Equivalent, "system/iplKeyboard.cpp"),
Object(Matching, "system/iplErrorHandler.cpp"),
Object(Matching, "system/iplResetHandler.cpp"),
Object(Matching, "system/iplWarningHandler.cpp"),
@@ -766,13 +766,13 @@ config.libs = [
]
),
IPLSection("channelSelect", [
Object(Matching, "scene/channelSelect/iplChannelSelect.cpp"),
Object(Equivalent, "scene/channelSelect/iplChannelSelect.cpp"),
Object(Matching, "scene/channelSelect/iplClock.cpp"),
Object(Matching, "scene/channelSelect/iplChannelObj.cpp"),
Object(Equivalent, "scene/channelSelect/iplChannelObj.cpp"),
]
),
IPLSection("channelTitle", [
Object(Matching, "scene/channelTitle/iplChannelTitle.cpp"),
Object(Equivalent, "scene/channelTitle/iplChannelTitle.cpp"),
]
),
IPLSection("faceSelect", [
@@ -877,9 +877,9 @@ config.libs = [
Object(Matching, "scene/setting/iplUSBAPThread.cpp"),
Object(Matching, "scene/setting/iplAOSSThread.cpp"),
Object(NonMatching, "scene/setting/AOSSLink.c"),
Object(Matching, "scene/setting/iplRakuRakuThread.cpp"),
Object(NonMatching, "scene/setting/iplRakuRakuThread.cpp"),
Object(NonMatching, "scene/setting/AOSS.c", extra_cflags=["-O4,p", "-inline off"]),
Object(NonMatching, "scene/setting/ATERM.c", extra_cflags=["-O4,p", "-inline on"]),
Object(NonMatching, "scene/setting/ATERM.c", extra_cflags=["-O4,p", "-inline off"]),
]
),
IPLSection("settingSelect", [
@@ -908,7 +908,7 @@ config.libs = [
),
# it decides to do fast optimization for this one
IPLSection("keyboard", [
Object(Matching, "keyboard/tiPcKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiPcKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiCellPhone.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiInputForm.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiCandidateBox.cpp", extra_cflags=["-O4,p"]),
@@ -927,7 +927,7 @@ config.libs = [
Object(Matching, "keyboard/tiPkData.cpp", extra_cflags=["-O4,p"], shift_jis=False),
Object(Matching, "keyboard/tiLanguageIndependentData.cpp", extra_cflags=["-O4,p"], shift_jis=False),
Object(Matching, "keyboard/tiTextInputBase.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/MyTiManager.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/MyTiManager.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/MyTiInputForm.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/MyTiLetterForm.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/MyTiBg.cpp", extra_cflags=["-O4,p"]),
@@ -982,7 +982,7 @@ config.libs = [
),
ZI8Lib("zi8clib", [
Object(Matching, "clib/zaddress.c"),
Object(Matching, "clib/zconvert.c"),
Object(NonMatching, "clib/zconvert.c"),
Object(NonMatching, "clib/zi81key.c"),
Object(NonMatching, "clib/zi8alpha.c"),
Object(Matching, "clib/zi8alts.c"),
@@ -997,7 +997,7 @@ config.libs = [
Object(Matching, "clib/zi8is.c"),
Object(NonMatching, "clib/zi8match.c"),
Object(Matching, "clib/zi8misc.c"),
Object(Matching, "clib/zi8pud2.c"),
Object(NonMatching, "clib/zi8pud2.c"),
Object(Matching, "clib/Zi8punct.c"),
Object(Matching, "clib/zi8space.c"),
Object(NonMatching, "clib/zi8uwd.c"),
@@ -1005,7 +1005,7 @@ config.libs = [
Object(Matching, "clib/zi8ZHuwd.c"),
Object(NonMatching, "clib/zidawg1.c"),
Object(Matching, "clib/zikorean.c"),
Object(Matching, "clib/ziswordw.c"),
Object(NonMatching, "clib/ziswordw.c"),
Object(NonMatching, "clib/zkokeyp.c"),
Object(Matching, "clib/zierror.c"),
Object(NonMatching, "clib/zmtkey.c"),
@@ -1075,15 +1075,15 @@ config.libs = [
Object(Matching, "nwc24/NWC24Utils.c"),
Object(Matching, "nwc24/NWC24Manage.c"),
Object(Matching, "nwc24/NWC24MsgObj.c"),
Object(Matching, "nwc24/NWC24MBoxCtrl.c"),
Object(NonMatching, "nwc24/NWC24MBoxCtrl.c"),
Object(Matching, "nwc24/NWC24Mime.c"),
Object(Matching, "nwc24/NWC24Stream.c"),
Object(Matching, "nwc24/NWC24Parser.c"),
Object(Matching, "nwc24/NWC24MsgCommit.c"),
Object(NonMatching, "nwc24/NWC24MsgCommit.c"),
Object(Matching, "nwc24/NWC24MsgRead.c"),
Object(Matching, "nwc24/NWC24MsgSubject.c"),
Object(NonMatching, "nwc24/NWC24MsgSubject.c"),
Object(Matching, "nwc24/NWC24Schedule.c"),
Object(Matching, "nwc24/NWC24DateParser.c"),
Object(NonMatching, "nwc24/NWC24DateParser.c"),
Object(Matching, "nwc24/NWC24FriendList.c"),
Object(Matching, "nwc24/NWC24SecretFList.c"),
Object(Matching, "nwc24/NWC24UserId.c"),
@@ -1098,7 +1098,7 @@ config.libs = [
Object(Matching, "so/SOCommon.c"),
Object(NonMatching, "so/SOBasic.c"),
Object(Matching, "so/SOInformation.c"),
Object(Matching, "so/SOOption.c"),
Object(NonMatching, "so/SOOption.c"),
]
),
RevoEXLib("ssl", [
@@ -1212,7 +1212,7 @@ config.libs = [
Object(NonMatching, "exif/exif_parse.c"),
Object(Matching, "reschange/iqdec_resolution_change_a3.c"),
Object(Matching, "reschange/idct_resolution_change_var.c"),
Object(NonMatching, "reschange/idct_resolution_change_var.c"),
Object(NonMatching, "texturecvtr/Texture_MCUtoY8U8V8.c"),
Object(NonMatching, "texturecvtr/Texture_MCUtoRGB565.c"),
@@ -1299,7 +1299,7 @@ config.libs = [
Object(Matching, "ut/ut_RomFont.cpp"),
Object(Matching, "ut/ut_ResFontBase.cpp"),
Object(Matching, "ut/ut_ResFont.cpp"),
Object(Matching, "ut/ut_ArchiveFontBase.cpp"),
Object(NonMatching, "ut/ut_ArchiveFontBase.cpp"),
Object(Matching, "ut/ut_ArchiveFont.cpp"),
Object(Matching, "ut/ut_CharWriter.cpp"),
Object(Matching, "ut/ut_TextWriterBase.cpp"),
@@ -1388,7 +1388,7 @@ config.libs = [
]
),
RVLSDKLib("vi", [
Object(Matching, "vi/vi.c"),
Object(NonMatching, "vi/vi.c"),
Object(Matching, "vi/i2c.c"),
Object(Matching, "vi/vi3in1.c"),
]
@@ -1691,12 +1691,12 @@ config.libs = [
Object(Matching, "fa/pdm_bpb.c"),
Object(Matching, "fa/pdm_disk.c"),
Object(NonMatching, "fa/pdm_partition.c"),
Object(Matching, "fa/pf_cache.c"),
Object(NonMatching, "fa/pf_cache.c"),
Object(Matching, "fa/pf_cluster.c"),
Object(Matching, "fa/pf_dir.c"),
Object(Matching, "fa/pf_entry.c"),
Object(Matching, "fa/pf_entry_iterator.c"),
Object(Matching, "fa/pf_fat.c"),
Object(NonMatching, "fa/pf_entry_iterator.c"),
Object(NonMatching, "fa/pf_fat.c"),
Object(Matching, "fa/pf_fat12.c"),
Object(Matching, "fa/pf_fat16.c"),
Object(Matching, "fa/pf_fat32.c"),
@@ -1826,7 +1826,7 @@ config.libs = [
Object(Matching, "fa/pfs_unmount.c"),
Object(Matching, "fa/pf_stub_unicode.c"),
Object(Matching, "fa/api/FAAttach.c"),
Object(NonMatching, "fa/api/FAAttach.c"),
Object(Matching, "fa/api/FABuffering.c"),
Object(Matching, "fa/api/FACreate.c"),
Object(Matching, "fa/api/FACreatedir.c"),
@@ -1908,7 +1908,7 @@ config.libs = [
[
Object(Matching, "core/eggAllocator.cpp"),
Object(Matching, "core/eggAudioArcPlayerMgr.cpp"),
Object(Matching, "core/eggAudioExpMgr.cpp"),
Object(Equivalent, "core/eggAudioExpMgr.cpp"),
Object(Matching, "core/eggAudioFxMgr.cpp"),
Object(Matching, "core/eggAudioMgr.cpp"),
Object(Matching, "core/eggAudioHeapMgr.cpp"),
@@ -1970,7 +1970,7 @@ config.libs = [
Object(Matching, "MSL_Common/time.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/wctype.c"),
Object(Matching, "MSL_Common/wmem.c"),
Object(Matching, "MSL_Common/wprintf.c", extra_cflags=["-Cpp_exceptions on"]),
Object(NonMatching, "MSL_Common/wprintf.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/wstring.c"),
Object(Matching, "MSL_Common/wchar_io.c"),
Object(Matching, "PPC_EABI/time.dolphin.c"),

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -34,14 +34,14 @@ namespace gui {
virtual void draw(Mtx& mtx) {} // 0x14 (0x05)
virtual void draw() {} // 0x18 (0x06)
#if defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_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
};
#if defined(IPL_GC_WINDOW_NOVTABLE) || defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_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
#if defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
#if defined(IPL_CHANNEL_TITLE_NOVTABLE) || defined(IPL_GC_SAVEDATA_NOVTABLE) || defined(IPL_MEMORY_CARD_NOVTABLE)
virtual ~PaneManager();
#else
virtual ~PaneManager() {}

View File

@@ -163,9 +163,6 @@ namespace ipl {
void init(const f32& start, const f32& end, f32 maxFrame, f32 startTangent, f32 endTangent, int playback = ANIM_TYPE_FORWARD,
f32 speed = 1.0f);
#ifdef IPL_SD_CHANNEL_TITLE_CPP
f32 get() const;
#else
f32 get() const {
f32 var_f27 = mFrame;
f32 var_f28 = 1.0f / mMaxFrame;
@@ -184,7 +181,6 @@ namespace ipl {
return r;
}
#endif
protected:
f32 mStart;
@@ -270,32 +266,6 @@ namespace ipl {
};
#endif
#ifdef IPL_CHANNEL_SELECT_CPP
template <>
class HermiteIntp<f32> : public utility::FrameController {
public:
HermiteIntp() {}
virtual ~HermiteIntp() {}
void init(const f32& start, const f32& end, f32 maxFrame, f32 startTangent,
f32 endTangent, int playback = ANIM_TYPE_FORWARD, f32 speed = 1.0f) {
mStart = start;
mEnd = end;
utility::FrameController::init(playback, maxFrame, 0.0f, speed);
mStartTangent = startTangent;
mEndTangent = endTangent;
}
inline f32 get() const;
protected:
f32 mStart;
f32 mEnd;
f32 mStartTangent;
f32 mEndTangent;
};
#endif
#ifdef IPL_SD_CHANNEL_SELECT_CPP
} // namespace math
} // namespace ipl

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -145,7 +145,7 @@ namespace ipl {
ANIM_MAX,
};
int mAnimWait;
int unk_0x54;
layout::Object* mpLayout; // 0x58
nand::LayoutFile* mpLayoutFile; // 0x5C

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -65,13 +65,8 @@ namespace ipl {
/** @brief Writes the file contents. */
virtual void write(); // 0x10
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual bool isFinished();
virtual int checkData();
#else
virtual bool isFinished() { return mbDoneTask; } // 0x14
virtual int checkData() { return mResult; } // 0x18
#endif
virtual bool isFatalError(); // 0x1C
u8* getBuffer() const { return mpBuffer; }
@@ -150,13 +145,6 @@ namespace ipl {
mpCommonFile = commonFile;
mpLangFile = langFile;
}
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
virtual ~LangFile() {}
virtual void read() {}
virtual bool isFinished() { return false; }
virtual int checkData() { return 0; }
virtual bool isFatalError() { return false; }
#else
virtual ~LangFile(); // 0x08
virtual void read(); // 0x0C
@@ -164,7 +152,6 @@ namespace ipl {
virtual bool isFinished(); // 0x14
virtual int checkData(); // 0x18
virtual bool isFatalError(); // 0x1C
#endif
File* getCmnFile() const { return mpCommonFile; }
File* getLangFile() const { return mpLangFile; }
@@ -178,11 +165,7 @@ namespace ipl {
public:
LayoutFile(EGG::Heap* heap, const char* dirName, const char* fileName, ARCHandle* arc, bool bIsNandFile);
LayoutFile(File* commonFile, File* langFile = NULL) : LangFile(commonFile, langFile) {}
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
virtual ~LayoutFile() {} // 0x08
#else
virtual ~LayoutFile(); // 0x08
#endif
};
} // namespace nand
} // namespace ipl

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -1,5 +1,3 @@
#define EGG_AUDIO_EXPMGR_NO_INLINE_VIRTUALS
#include <egg/core.h>
namespace EGG {
@@ -29,10 +27,4 @@ namespace EGG {
mHeap.SaveState();
}
ExpAudioMgr::ExpAudioMgr() {
}
ExpAudioMgr::~ExpAudioMgr() {
}
} // namespace EGG

View File

@@ -1126,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;
@@ -1134,7 +1135,7 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
} else if (format.precision_specified) {
num_chars = format.precision;
if ((string_end = wmemchr(wcs_ptr, 0, num_chars)) != 0) {
if ((string_end = wmemchr((wchar_t*)wcs_ptr, 0, num_chars)) != 0) {
num_chars = string_end - wcs_ptr;
}
@@ -1152,7 +1153,7 @@ static int __wpformatter(void* (*write_proc)(void*, const wchar_t*, size_t),
}
if (format.alternate_form) {
num_chars = (unsigned char)*buff_ptr;
num_chars = (unsigned char)*(const wchar_t*)wcs_ptr;
if (format.precision_specified && num_chars > format.precision) {
num_chars = format.precision;

View File

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

View File

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

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

View File

@@ -63,7 +63,7 @@ typedef struct {
u8 mcuYRem; // 0x0F
u16 mcuYCount; // 0x10
u16 mcuXCount2; // 0x12
u32 mcuTotal; // 0x14
u32 unk_0x14;
u8 remX; // 0x18
u8 remY; // 0x19
u8 compCount; // 0x1A
@@ -142,7 +142,7 @@ struct TMCCJPEGDecWork_t {
u8 mcuYRem; // 0x17FF
u16 mcuYCount; // 0x1800
u16 mcuXCount2; // 0x1802
u32 mcuTotal; // 0x1804
u32 unk_0x1804;
u8 remX; // 0x1808
u8 remY; // 0x1809
u8 compCount; // 0x180A

View File

@@ -10,16 +10,18 @@ static TMCHuffmanEntry readHuffmanEntry(const TMCHuffmanEntry* entries, u32 inde
return entries[index];
}
static void readHuffmanLimit(const TMCHuffmanEntry* entries, TMCHuffmanEntry* limit) {
limit->bitLength = entries->bitLength;
limit->symbol = entries->symbol;
static TMCHuffmanEntry readHuffmanLimit(const TMCHuffmanEntry* entries) {
TMCHuffmanEntry limit;
limit.bitLength = entries->bitLength;
limit.symbol = entries->symbol;
return limit;
}
static inline s32 decodeLongHuffman(s32 bitCount, u32* huff_tbl, u8* symbols, TMCCJPEGDecWork* work, TMCHuffmanEntry* limit, TMCHuffmanEntry* decoded) {
u16* entry;
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);
@@ -28,16 +30,16 @@ static inline s32 decodeLongHuffman(s32 bitCount, u32* huff_tbl, u8* symbols, TM
}
}
bitCount = work->bitCount;
entry = (u16*)(huff_tbl + 9);
bitData = work->bitBuf;
length = 9;
bitCount -= 9;
code = (bitData >> bitCount) & 0x1FF;
work->bitCount = bitCount;
length = 9;
entry = table + 9;
goto read_entry;
while (1) {
length++;
entry += 2;
entry++;
if (length > 16) {
return TMCC_ERROR_OVERFLOW;
}
@@ -49,23 +51,17 @@ static inline s32 decodeLongHuffman(s32 bitCount, u32* huff_tbl, u8* symbols, TM
code |= (bitData >> bitCount) & 1;
read_entry:
{
limit->bitLength = entry[0];
limit->symbol = entry[1];
*decoded = *limit;
if (code > (u32)decoded->bitLength) {
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
if (code > (u32)decoded.bitLength) {
continue;
}
{
u32 relativeCode = code - limit->bitLength;
u32 symbolIndex = relativeCode + limit->symbol;
return symbols[symbolIndex & 0xFF];
}
code = code - entry->bitLength + entry->symbol;
return symbols[code & 0xFF];
}
}
}
static inline s32 decodeACHuffman(s32 bitCount, u32* huff_tbl, u8* symbols, TMCCJPEGDecWork* work, TMCHuffmanEntry* limit, TMCHuffmanEntry* decoded) {
u16* entry;
static inline s32 decodeACHuffman(s32 bitCount, const TMCHuffmanEntry* entry, const u8* symbols, TMCCJPEGDecWork* work) {
u32 bitData;
u32 code;
u32 length;
@@ -77,16 +73,16 @@ static inline s32 decodeACHuffman(s32 bitCount, u32* huff_tbl, u8* symbols, TMCC
}
}
bitCount = work->bitCount;
entry = (u16*)(huff_tbl + 9);
bitData = work->bitBuf;
length = 9;
bitCount -= 9;
code = (bitData >> bitCount) & 0x1FF;
work->bitCount = bitCount;
length = 9;
entry += 9;
goto read_entry;
while (1) {
length++;
entry += 2;
entry++;
if (length > 16) {
return TMCC_ERROR_OVERFLOW;
}
@@ -98,30 +94,20 @@ static inline s32 decodeACHuffman(s32 bitCount, u32* huff_tbl, u8* symbols, TMCC
code |= (bitData >> bitCount) & 1;
read_entry:
{
limit->bitLength = entry[0];
limit->symbol = entry[1];
*decoded = *limit;
if (code > (u32)decoded->bitLength) {
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
if (code > (u32)decoded.bitLength) {
continue;
}
{
u32 relativeCode = code - limit->bitLength;
u32 symbolIndex = relativeCode + limit->symbol;
return symbols[symbolIndex & 0xFF];
}
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) {
TMCHuffmanEntry dcEntry;
TMCHuffmanEntry dcDecoded;
TMCHuffmanEntry dcLimit;
TMCHuffmanEntry acDecoded;
TMCHuffmanEntry acLimit;
u8* huff_sym;
u16* ac_fast;
const TMCHuffmanEntry* ac_fast;
s32 idx;
u32* huff_tbl;
s32 bit_pos;
@@ -134,13 +120,11 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
s32 t;
s32 zz;
s32 q;
u16* dc_fast;
const TMCHuffmanEntry* dc_fast;
const u8* zztbl;
s32* conv_row;
conv_row = (s32*)conv_row_ptr;
bit_pos = work->bitCount;
dc_fast = work->pDCFast;
dc_fast = (const TMCHuffmanEntry*)work->pDCFast;
if (bit_pos <= 8) {
r = TMCJPEGDEC_load_buff(work);
@@ -152,7 +136,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
bit_pos = work->bitCount;
bit_data = work->bitBuf;
{
dcEntry = readHuffmanEntry((const TMCHuffmanEntry*)dc_fast, (bit_data >> (bit_pos - 8)) & 0xFF);
dcEntry = readHuffmanEntry(dc_fast, (bit_data >> (bit_pos - 8)) & 0xFF);
r = dcEntry.bitLength;
extra = dcEntry.symbol;
}
@@ -163,28 +147,30 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
} else {
huff_sym = work->pDCHuffSym;
huff_tbl = work->pDCHuffTbl;
r = decodeLongHuffman(bit_pos, huff_tbl, huff_sym, work, &dcLimit, &dcDecoded);
r = decodeLongHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work);
if (r < 0) {
return r;
}
}
blk0 = conv_row[0];
blk0 = ((s32*)conv_row_ptr)[0];
if (r != 0) {
if (work->bitCount <= r) {
s32 load_ret;
if (load_ret = TMCJPEGDEC_load_buff(work), load_ret < 0) {
bit_pos = work->bitCount;
if (bit_pos <= r) {
s32 load_ret = TMCJPEGDEC_load_buff(work);
if (load_ret < 0) {
return load_ret;
}
}
tmp = 1UL << r;
bit_pos = work->bitCount - r;
work->bitCount = bit_pos;
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 -= (tmp - 1);
extra -= tmp - 1;
}
dc_predict_row_ptr[0] += extra;
}
@@ -192,7 +178,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
*block = dc_predict_row_ptr[0] * blk0;
{
ac_fast = work->pACFast;
ac_fast = (const TMCHuffmanEntry*)work->pACFast;
huff_tbl = work->pACHuffTbl;
huff_sym = work->pACHuffSym;
@@ -210,7 +196,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
zztbl = TMCJPEGDEC_Zigzag_data;
bit_data = work->bitBuf;
t = bit_pos - 8;
acEntry = readHuffmanEntry((const TMCHuffmanEntry*)ac_fast, (bit_data >> t) & 0xFF);
acEntry = readHuffmanEntry(ac_fast, (bit_data >> t) & 0xFF);
do {
s32 ac_thresh = acEntry.bitLength;
@@ -221,7 +207,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
r = acEntry.symbol;
} else {
bit_pos = work->bitCount;
r = decodeACHuffman(bit_pos, huff_tbl, huff_sym, work, &acLimit, &acDecoded);
r = decodeACHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work);
if (r < 0) {
return r;
}
@@ -245,18 +231,19 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
return r;
}
}
tmp = 1UL << t;
bit_pos = work->bitCount - t;
work->bitCount = bit_pos;
bit_pos = work->bitCount;
tmp = 1 << t;
bit_data = work->bitBuf;
extra = tmp - 1;
extra = extra & (bit_data >> bit_pos);
bit_pos -= t;
work->bitCount = bit_pos;
t = bit_pos - 8;
q = conv_row[(u8)zz];
acEntry = readHuffmanEntry((const TMCHuffmanEntry*)ac_fast, (bit_data >> t) & 0xFF);
extra = extra & (bit_data >> bit_pos);
q = ((s32*)conv_row_ptr)[(u8)zz];
acEntry = readHuffmanEntry(ac_fast, (bit_data >> t) & 0xFF);
if (((s32)tmp >> 1) > extra) {
extra -= (tmp - 1);
extra -= tmp - 1;
}
block[(u8)zz] = extra * q;
@@ -277,7 +264,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
bit_pos = work->bitCount;
t = bit_pos - 8;
tmp = ((bit_data >> t) & 0xFF) << 2;
acEntry = readHuffmanEntry((const TMCHuffmanEntry*)ac_fast, tmp >> 2);
acEntry = readHuffmanEntry(ac_fast, tmp >> 2);
idx += 16;
}

View File

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

View File

@@ -3,7 +3,7 @@
#include <tmc_jpeg_internal.h>
static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData* pInfo);
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, u8* entry);
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, const u8* entry);
static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, const u8* entry);
static s32 TMCJPEGDEC_ThumbnailCheck(TMCCJPEGDecInitParam* param, TMCCJPEGDecExifInfo* info, u32 totalSize);
@@ -16,7 +16,7 @@ static u16 readU16(const u8* p, u16 byteOrder) {
}
static u16 readExifU16(const u8* data, u16 byteOrder) {
u16 value = data[0] | data[1] << 8;
u32 value = data[0] | data[1] << 8;
if (byteOrder == 0x4949) {
return (u16)value;
}
@@ -246,9 +246,9 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
u32 ifdOffset;
const u8* entries;
u16 remaining;
u16 index;
s32 entriesSize;
u16 count;
s32 entriesSize;
u16 index;
pInfo->thumbnailData = (u8*)data;
pInfo->dataEnd = (u8*)data + size;
pInfo->nextIfdOffset = 0;
@@ -280,7 +280,7 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
return -161;
}
for (index = 0; index < count; index++) {
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, (u8*)entries);
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, entries);
entries += 12;
}
remaining -= entriesSize;
@@ -331,19 +331,19 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
return -161;
}
for (index = 0; index < count; index++) {
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, (u8*)entries);
TMCJPEGDEC_IFD0_tag_parse(pInfo, byteOrder, entries);
entries += 12;
}
}
return 0;
}
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, u8* entry) {
s32 tag;
u32 type;
static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder, const u8* entry) {
u16 tag;
u16 type;
tag = readExifU16(entry, byteOrder);
type = readExifU16(entry + 2, byteOrder);
tag = readU16(entry, byteOrder);
type = readU16(entry + 2, byteOrder);
switch (tag) {
case 0x0103:
@@ -366,7 +366,7 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
return;
}
pInfo->xResNum = readU32(p, byteOrder);
p = pInfo->thumbnailData + (offset + 4);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
if (pInfo->thumbnailData > p) {
return;
}
@@ -386,7 +386,7 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
return;
}
pInfo->yResNum = readU32(p, byteOrder);
p = pInfo->thumbnailData + (offset + 4);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
if (pInfo->thumbnailData > p) {
return;
}
@@ -501,10 +501,6 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
case 0x8769:
case 0x9000:
case 0x9101:
case 0x011C:
case 0xA000:
case 0xA001:
case 0xA002:
case 0xA003: {
break;
}
@@ -520,7 +516,7 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
return;
}
pInfo->xResNumIfd1 = readU32(p, byteOrder);
p = pInfo->thumbnailData + (offset + 4);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
if (pInfo->thumbnailData > p) {
return;
}
@@ -542,7 +538,7 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
return;
}
pInfo->planarConfigIfd1 = readU32(p, byteOrder);
p = pInfo->thumbnailData + (offset + 4);
p = (const u8*)(pInfo->thumbnailData + offset + 4);
if (pInfo->thumbnailData > p) {
return;
}

View File

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

View File

@@ -567,7 +567,7 @@ s32 TMCJPEGDEC_scan_varinit(TMCCJPEGDecWork* work) {
p->mcuYCount = p->mcuYCount + ((u8)remX != 0 ? 1 : 0);
p->mcuXCount2 = p->mcuXCount2 + ((u8)remY != 0 ? 1 : 0);
p->mcuTotal = (u32)p->mcuYCount * (u32)p->mcuXCount2;
p->unk_0x14 = (u32)p->mcuYCount * (u32)p->mcuXCount2;
for (idx = 0; idx < (s32)p->scanCompCount; idx++) {
u8 compId;
@@ -1929,7 +1929,7 @@ static s32 TMCJPEGDEC_parse_sof(TMCCJPEGDecWork* work) {
mcuCountY += yr;
frameInfo->mcuYCount = mcuCountX;
frameInfo->mcuXCount2 = mcuCountY;
work->mcuTotal = (u32)mcuCountX * (u32)mcuCountY;
work->unk_0x1804 = (u32)mcuCountX * (u32)mcuCountY;
}
compCount2 = frameInfo->compCount;

View File

@@ -57,14 +57,15 @@ void TMCJPEGDEC_IdctBlock4x4(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigzag
{
u32 idx = 3;
s32* column = tmp + 3;
for (i = 0; i < 4; i++) {
u8* bp = conv_row_ptr + idx;
a = tmp[idx] + 0x40000;
b = tmp[idx + 8];
d = tmp[idx + 24];
c = tmp[idx + 16];
a = column[0] + 0x40000;
b = column[8];
d = column[24];
c = column[16];
evsum = a + c;
cd = a - c;
@@ -78,6 +79,7 @@ void TMCJPEGDEC_IdctBlock4x4(s32* block, u8* conv_row_ptr, u16 pitch, s32 zigzag
bp[pitch * 2] = clampU8((cd - rot) >> 11);
bp[pitch * 4 - pitch] = clampU8((evsum - oddrot) >> 11);
column--;
idx -= 1;
}
}

View File

@@ -167,28 +167,28 @@ s32 TMCJPEGDEC_set_converterRGB565(TMCCJPEGDecWork* work) {
static void TMCJPEGDEC_converterYUV411toRGB565(TMCCJPEGDecWork* work, s32 x, s32 y) {
u16* output;
s32 tileRow;
s32 lumaSkip;
s32 cbValue;
s32 blue;
TMCCJPEGDecState* state;
s32 lumaSkip;
u32 tileWidth;
s32 crValue;
s32 width;
s32 height;
s32 chromaSkip;
u8* cb;
u8* texture;
u8* luminance;
u8* cb;
s32 chromaSkip;
u8* cr;
s32 column;
s32 xEnd;
s32 yEnd;
u8 value;
u32 tileWidth;
s32 greenOffset;
s32 redOffset;
s32 red;
s32 tileRow;
s32 blueOffset;
u8 value;
s32 red;
s32 greenOffset;
s32 green;
luminance = work->convBuf + 4;
@@ -284,9 +284,7 @@ static void TMCJPEGDEC_converterYUV411toRGB565edge(TMCCJPEGDecWork* work, s32 x,
s32 yEnd = y + height;
s32 lumaSkip = 32 - width;
s32 chromaSkip = lumaSkip >> 2;
s32 redOffset;
s32 blueOffset;
s32 greenOffset;
s32 redOffset, greenOffset, blueOffset;
ASSERTLINE((x & 3) == 0, __LINE__);
for (; y < yEnd; y++) {
s32 tileRow = (y >> 2) * tileWidth;
@@ -324,11 +322,11 @@ static void TMCJPEGDEC_converterYUV422toRGB565(TMCCJPEGDecWork* work, s32 x, s32
s32 chromaSkip;
s32 width;
s32 blue;
u16* output;
s32 lumaSkip;
s32 red;
s32 tileRow;
s32 lumaSkip;
s32 redOffset;
u16* output;
u32 tileWidth;
u8* texture;
TMCCJPEGDecState* state;
s32 crValue;
@@ -340,7 +338,7 @@ static void TMCJPEGDEC_converterYUV422toRGB565(TMCCJPEGDecWork* work, s32 x, s32
s32 cbValue;
s32 xEnd;
s32 yEnd;
u32 tileWidth;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
s32 green;
@@ -477,22 +475,22 @@ static void TMCJPEGDEC_converterYUV420toRGB565(TMCCJPEGDecWork* work, s32 x, s32
s32 width;
s32 redOffset;
s32 green;
s32 tileRow;
s32 lumaSkip;
u32 tileWidth;
u8* texture;
s32 chromaSkip;
s32 height;
u8* texture;
s32 yEnd;
u8* luminance;
s32 crValue;
s32 value;
u8* cb;
u8* cr;
s32 column;
s32 xEnd;
s32 yEnd;
u32 tileWidth;
s32 cbValue;
s32 column;
u8* cr;
s32 greenOffset;
s32 tileRow;
s32 cbValue;
s32 lumaSkip;
s32 blueOffset;
s32 red;
TMCCJPEGDecState* state;
@@ -565,23 +563,26 @@ static void TMCJPEGDEC_converterYUV420toRGB565(TMCCJPEGDecWork* work, s32 x, s32
}
static void TMCJPEGDEC_converterYUV420toRGB565edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 chromaSkip;
u16* output;
s32 yEnd;
s8 crValue;
s32 tileRow;
u8* texture;
u8* luminance;
s32 width;
s8* cb;
s8 crValue;
s32 width;
s8* cr;
s8 cbValue;
s32 column;
s32 xEnd;
s8 cbValue;
s32 yEnd;
s32 red;
s32 blue;
u32 tileWidth;
s32 height;
TMCCJPEGDecState* state;
s32 green;
s32 lumaSkip;
u32 tileWidth;
s32 chromaSkip;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
@@ -618,18 +619,16 @@ static void TMCJPEGDEC_converterYUV420toRGB565edge(TMCCJPEGDecWork* work, s32 x,
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
}
{
s32 value = *luminance++;
s32 red = value + redOffset;
s32 blue = value + blueOffset;
s32 green = value + greenOffset;
if ((blue | red | green) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
}
output[(column & 3) + (((column >> 2) + tileRow) << 4)] = ((blue & 0xF8) >> 3) + ((red & 0xF8) << 8) + ((green & 0xFC) << 3);
blue = *luminance++;
red = blue + redOffset;
green = blue + greenOffset;
blue = blue + blueOffset;
if ((blue | red | green) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
}
output[(column & 3) + (((column >> 2) + tileRow) << 4)] = ((blue & 0xF8) >> 3) + ((red & 0xF8) << 8) + ((green & 0xFC) << 3);
}
luminance += lumaSkip;
if (y & 1) {
@@ -817,11 +816,15 @@ static void TMCJPEGDEC_converterYUV444toRGB565(TMCCJPEGDecWork* work, s32 x, s32
u8* luminance;
u8* cb;
u8* cr;
s32 value;
s32 column;
s32 xEnd;
s32 cbValue;
s32 yEnd;
u32 tileWidth;
s32 green;
s32 blue;
s32 red;
s32 height;
luminance = work->convBuf + 4;
@@ -841,19 +844,17 @@ static void TMCJPEGDEC_converterYUV444toRGB565(TMCCJPEGDecWork* work, s32 x, s32
for (column = x; column < xEnd; column++) {
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
{
s32 value = *luminance++;
s32 green = value + (-(cbValue * 88 + crValue * 183) >> 8);
s32 red = value + ((crValue * 359) >> 8);
s32 blue = value + ((cbValue * 454) >> 8);
if ((red | green | blue) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
}
output[(column & 3) + (((column >> 2) + tileRow) << 4)] =
((blue & 0xF8) >> 3) + (((red & 0xF8) << 8) + ((green & 0xFC) << 3));
value = *luminance++;
green = value + (-(cbValue * 88 + crValue * 183) >> 8);
red = value + ((crValue * 359) >> 8);
blue = value + ((cbValue * 454) >> 8);
if ((blue | green | red) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
}
output[(column & 3) + (((column >> 2) + tileRow) << 4)] =
((blue & 0xF8) >> 3) + ((red & 0xF8) << 8) + ((green & 0xFC) << 3);
}
luminance += rowSkip;
cb += rowSkip;

View File

@@ -166,29 +166,29 @@ s32 TMCJPEGDEC_set_converterRGBA8(TMCCJPEGDecWork* work) {
}
static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 red;
s8 crValue;
u8* luminance;
u8* cb;
u8* cr;
TMCCJPEGDecState* state;
u8* texture;
s32 height;
s32 column;
s32 yEnd;
s32 xEnd;
s32 green;
s32 yEnd;
s32 column;
s32 tileWidth;
s32 blueOffset;
s32 greenOffset;
u16* output;
s32 tileRow;
s32 lumaSkip;
s8 crValue;
s32 red;
s32 chromaSkip;
s32 width;
s32 cbValue;
u8 value;
s32 row;
u16* output;
s32 greenOffset;
s32 redOffset;
s32 blue;
@@ -216,7 +216,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
cbValue = (s8)*cb++;
crValue = (s8)*cr++;
redOffset = (crValue * 359) >> 8;
greenOffset = -(crValue * 183 + cbValue * 88) >> 8;
greenOffset = -(cbValue * 88 + crValue * 183) >> 8;
blueOffset = (cbValue * 454) >> 8;
}
{
@@ -224,7 +224,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((red | green | blue) >> 8) {
if ((blue | green | red) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -238,7 +238,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((red | green | blue) >> 8) {
if ((blue | green | red) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -252,7 +252,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((red | green | blue) >> 8) {
if ((blue | green | red) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -266,7 +266,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((red | green | blue) >> 8) {
if ((blue | green | red) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -285,26 +285,26 @@ static void TMCJPEGDEC_converterYUV411toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
}
static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
u16* output;
s32 tileRow;
s32 lumaSkip;
u8* texture;
TMCCJPEGDecState* state;
s32 column;
u8* luminance;
u8* cb;
u8* cr;
TMCCJPEGDecState* state;
s32 tileWidth;
u8* texture;
s32 width;
s32 height;
u8* cr;
s32 column;
s32 xEnd;
s32 yEnd;
s32 tileWidth;
s32 redOffset;
s32 lumaSkip;
s32 chromaSkip;
s32 tileRow;
u16* output;
s32 cbValue;
s8 crValue;
s32 redOffset;
s32 greenOffset;
s32 blueOffset;
s32 chromaSkip;
s32 blue;
s32 red;
s32 green;
@@ -345,7 +345,7 @@ static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
red = blue + redOffset;
green = blue + greenOffset;
blue = blue + blueOffset;
if ((green | red | blue) >> 8) {
if ((blue | red | green) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -366,11 +366,11 @@ static void TMCJPEGDEC_converterYUV411toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 chromaSkip;
u16* output;
s32 blue;
s32 cbValue;
s32 tileRow;
s32 tileWidth;
TMCCJPEGDecState* state;
s32 lumaSkip;
s32 xEnd;
u8* texture;
s32 width;
s32 height;
@@ -379,15 +379,15 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
s32 red;
u8* cr;
s32 column;
s32 xEnd;
u16* output;
s32 yEnd;
s32 tileWidth;
s32 redOffset;
s32 tileRow;
s32 greenOffset;
s32 blueOffset;
s32 value;
s32 green;
s32 blue;
s32 lumaSkip;
s32 crValue;
luminance = work->convBuf + 4;
@@ -415,7 +415,7 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((red | green | blue) >> 8) {
if ((blue | red | green) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -426,7 +426,7 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((red | green | blue) >> 8) {
if ((blue | red | green) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -441,21 +441,21 @@ static void TMCJPEGDEC_converterYUV422toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
}
static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 chromaSkip;
u16* output;
s32 tileRow;
s32 lumaSkip;
TMCCJPEGDecState* state;
u8* texture;
s32 column;
u8* luminance;
s32 width;
s32 height;
u8* cb;
u8* cr;
s32 column;
TMCCJPEGDecState* state;
s32 tileWidth;
u8* texture;
s32 width;
s32 height;
s32 xEnd;
s32 yEnd;
s32 tileWidth;
s32 lumaSkip;
s32 chromaSkip;
s32 tileRow;
u16* output;
s32 cbValue;
s32 crValue;
s32 redOffset;
@@ -463,8 +463,8 @@ static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
s32 blueOffset;
s32 value;
s32 red;
s32 green;
s32 blue;
s32 green;
luminance = work->convBuf + 4;
cb = &work->convBuf[132];
@@ -502,7 +502,7 @@ static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
red = value + redOffset;
blue = value + blueOffset;
green = value + greenOffset;
if ((red | green | blue) >> 8) {
if ((blue | red | green) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -517,28 +517,28 @@ static void TMCJPEGDEC_converterYUV422toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
}
static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
s32 chromaSkip;
s32 blue;
s8 crValue;
s32 lumaSkip;
u16* output;
s32 chromaSkip;
u8* luminance;
TMCCJPEGDecState* state;
s32 tileRow;
s32 xEnd;
s32 width;
s32 height;
s32 green;
s32 blue;
u8* luminance;
u8* cb;
u8* cr;
s32 blueOffset;
u8* texture;
s32 lumaSkip;
s32 yEnd;
s32 tileRow;
s32 value;
s32 column;
s32 xEnd;
s32 yEnd;
u8* cr;
s32 greenOffset;
s32 tileWidth;
s32 redOffset;
s32 greenOffset;
u8* texture;
s32 blueOffset;
u8* cb;
u16* output;
s32 green;
s32 red;
s32 cbValue;
@@ -578,7 +578,7 @@ static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
if ((red | green | blue) >> 8) {
if ((blue | green | red) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -593,7 +593,7 @@ static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((red | green | blue) >> 8) {
if ((blue | green | red) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -620,11 +620,11 @@ static void TMCJPEGDEC_converterYUV420toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
u8* luminance = work->convBuf + 4;
u8* cb = work->convBuf + 260;
s32 width;
u8* cr = work->convBuf + 324;
TMCCJPEGDecState* state = work->pState;
s32 tileWidth = (state->convWidth >> 2) << 1;
u8* texture = state->pTexBuffer;
u8* cr = work->convBuf + 324;
s32 width;
s32 height;
if (state->dataSizeX == (u32)x) {
width = state->stepXExt;
@@ -641,9 +641,7 @@ static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
s32 xEnd = x + width;
s32 lumaSkip = 16 - width;
s32 chromaSkip = lumaSkip >> 1;
s32 redOffset;
s32 blueOffset;
s32 greenOffset;
s32 redOffset, greenOffset, blueOffset;
ASSERTLINE((x & 1) == 0, __LINE__);
for (; y < yEnd; y++) {
u16* output = (u16*)(texture + ((y & 3) << 3));
@@ -658,11 +656,11 @@ static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
blueOffset = (cbValue * 454) >> 8;
}
{
s32 red = *luminance++;
s32 green = red + greenOffset;
s32 blue = red + blueOffset;
red = red + redOffset;
if ((green | red | blue) >> 8) {
s32 value = *luminance++;
s32 green = value + greenOffset;
s32 red = value + redOffset;
s32 blue = value + blueOffset;
if ((blue | red | green) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -688,7 +686,7 @@ static void TMCJPEGDEC_converterYUV420toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
u16* output;
s32 tileRow;
s32 column;
s32 redOffset;
TMCCJPEGDecState* state;
s32 lumaSkip;
@@ -697,7 +695,7 @@ static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
u8* cb;
u8* cr;
s32 height;
s32 column;
s32 tileRow;
s32 chromaSkip;
s32 width;
s32 xEnd;
@@ -744,7 +742,7 @@ static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((red | green | blue) >> 8) {
if ((blue | red | green) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -770,9 +768,9 @@ static void TMCJPEGDEC_converterYUV211toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x, s32 y) {
u16* output;
s32 tileRow;
s32 lumaSkip;
s32 blue;
u8* texture;
s32 tileRow;
u8* luminance;
u8* cb;
u8* cr;
@@ -785,14 +783,14 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
s32 greenOffset;
s32 yEnd;
s32 cbValue;
s32 tileWidth;
u8* texture;
s32 blueOffset;
s32 red;
s8 crValue;
u8 value;
s32 green;
s32 redOffset;
s32 lumaSkip;
s32 tileWidth;
luminance = work->convBuf + 4;
cb = work->convBuf + 132;
@@ -833,7 +831,7 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
green = value + greenOffset;
red = value + redOffset;
blue = value + blueOffset;
if ((red | green | blue) >> 8) {
if ((blue | red | green) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;
@@ -858,20 +856,20 @@ static void TMCJPEGDEC_converterYUV211toRGBA8edge(TMCCJPEGDecWork* work, s32 x,
static void TMCJPEGDEC_converterYUV444toRGBA8(TMCCJPEGDecWork* work, s32 x, s32 y) {
u16* output;
s32 tileWidth;
s32 tileRow;
s32 rowSkip;
u8* texture;
s32 xEnd;
u8* luminance;
u8* cb;
u8* cr;
TMCCJPEGDecState* state;
s32 crValue;
s8 crValue;
s32 height;
s32 width;
s32 column;
s32 xEnd;
s32 rowSkip;
s32 yEnd;
s32 tileWidth;
u8* texture;
s32 row;
s32 red;
s32 cbValue;
@@ -901,7 +899,7 @@ static void TMCJPEGDEC_converterYUV444toRGBA8(TMCCJPEGDecWork* work, s32 x, s32
green = value + (-(cbValue * 88 + crValue * 183) >> 8);
red = value + ((crValue * 359) >> 8);
blue = value + ((cbValue * 454) >> 8);
if ((red | green | blue) >> 8) {
if ((blue | red | green) >> 8) {
blue = blue > 255 ? 255 : blue < 0 ? 0 : blue;
green = green > 255 ? 255 : green < 0 ? 0 : green;
red = red > 255 ? 255 : red < 0 ? 0 : red;

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -18,7 +18,7 @@ static Zi8UInt Zi8SetFindCand(ziU8* foundCandidates, Zi8UInt ordinal, ziPtr work
}
ziWChar* ZiGetNextPhonetic(ziWChar* spelling, ziWChar* end ZI_NEED_WORK) {
while (*spelling && *spelling != ZI_WORK->separator && *spelling != 0xF360 && spelling < end) {
while (*spelling && *spelling != ZI_WORK->unk_0x1A && *spelling != 0xF360 && spelling < end) {
++spelling;
}
if (!*spelling || spelling == end) {
@@ -37,8 +37,8 @@ int ZiPartialMatch(ziWChar* spelling, ziWChar* spellingEnd,
if (spelling == spellingEnd || candidate == candidateEnd || !*spelling || !*candidate) {
return 1;
}
while (*spelling != ZI_WORK->separator && *spelling != 0xF360) {
if (*candidate == ZI_WORK->separator || *candidate == 0xF360) {
while (*spelling != ZI_WORK->unk_0x1A && *spelling != 0xF360) {
if (*candidate == ZI_WORK->unk_0x1A || *candidate == 0xF360) {
break;
}
if (*spelling != *candidate) {
@@ -133,16 +133,16 @@ typedef struct {
ziU8 phonetics[11];
} ZiChineseRecord;
extern ziU32 Zi8GetTableAddress(ziU8 language, ziU8 table, ziPtr work);
extern ziPtr Zi8GetTableAddress(ziU8 language, ziU8 table, ziPtr work);
extern ziU16 Zi8GetTableCount(ziU8 language, ziU8 table, ziPtr work);
extern ziU8 Zi8IsDupWChar(ziWChar character, ziPtr work);
extern ziU8 Zi8IsDupWordW(ziWChar* word, ziU8 length, ziPtr work);
extern ziWChar Zi8Ord2Uni(ziU16 ordinal, ziPtr work);
extern ziU8 Zi8MatchPhonetic(ziPtr phonetics, ziU8* records,
ziPtr indexTable, ziU16 indexCount, ziU32 dictionary,
ziU8* record, ziU16* mask, ziU16* match,
ziU16* length, ziU8** matchedRecord,
ziU8** matchedString, ziU8 wordMode, ziU8 partial,
extern ziU8 Zi8MatchPhonetic(ziU8* phonetics, ZiChineseRecord* records,
ziPtr indexTable, ziU16 indexCount, ziPtr dictionary,
ZiChineseRecord* record, ziU16* mask, ziU16* match,
ziU16* length, ZiChineseRecord** matchedRecord,
int* matchedIndex, ziU8 wordMode, ziU8 partial,
ziU8 oneCharacter, ziU16 excludedMask,
ziU16 excludedMatch, ziU8 charset, ziU8 options,
ziU16 ordinal, ziU16* tone, ziU8 spellingOnly,
@@ -160,13 +160,13 @@ extern const ziU8 zi8CangjieCodes[25];
extern const ziWChar ziPuncts[4];
extern const ziWChar ziTones[4];
const ziWChar zi8tones[4];
extern ziU32 Zi8GetZHuwdPtr(ziU32* entries, ziU16* count, ziPtr work);
extern ziU8 Zi8GetZHuwdPtr(ziU8** entries, ziU16* count, ziPtr work);
extern ziBool Zi8IsComponent(ziWChar character, ziPtr work);
extern ziBool Zi8IsCharacter(ziWChar character, ziPtr work);
extern ziU8 Zi8MatchOEMdata(ziWChar* currentWord, ziU8 length, ziU8 language,
ziWChar* output, ziU16 capacity, ziU8 mode, ziU8 next, ziPtr work);
extern ziU16 Zi8Uni2Ord(ziWChar character, ziPtr work);
extern ziU16 Zi8GetPCode(ziU8* table, ziU8* record);
extern int Zi8GetPCode(ziU8* table, ziU8* record);
extern ziU16 Zi8MatchAltSound(ziPtr table, ziU16 count, ziPtr phonetics,
ziU16 ordinal, ziU16 mask, ziU16 value, ziU8 flags, ziPtr work);
extern ziU32 Zi8SecMatchChar(ziPtr record, ziU8* dictionary, ziMatchParam* match, ziU16* code, ziPtr work);
@@ -199,7 +199,7 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
ziU8 matchMode;
int index;
ziWChar* currentWord;
ziU32 userEntriesAddress;
ziU8* userEntries;
ziU16 ordinalIndex;
ziU16 tableIndex;
ziU16 phraseOrdinal;
@@ -425,8 +425,8 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
charset <<= 4;
skipCount = request->firstCandidate;
request->letters = 0;
request->completion = 0;
request->count = 0;
request->unk_0x20 = 0;
if (getMode != 7 && getMode != 10 && getMode != 8 && getMode != 9) {
Zi8PrepareMatch(request, &match, 0, work);
} else {
@@ -577,27 +577,27 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
if (getMode == 1) {
switch ((int)match.phon2[index] >> 9) {
case 24: case 25:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->cANDch) ordinalIndex = 0xFDFF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->cANDch) ordinalIndex = 0xFDFF;
break;
case 26: case 27:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->sANDsh) ordinalIndex = 0xFDFF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->sANDsh) ordinalIndex = 0xFDFF;
break;
case 28: case 29:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->zANDzh) ordinalIndex = 0xFDFF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->zANDzh) ordinalIndex = 0xFDFF;
break;
case 56: case 59:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->fANDh) ordinalIndex = 0xF9FF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->fANDh) ordinalIndex = 0xF9FF;
break;
case 38:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->nANDl) ordinalIndex = 0xE5FF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->nANDl) ordinalIndex = 0xE5FF;
break;
case 43:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->nANDl && ((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->lANDr) ordinalIndex = 0xE1FF;
else if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->lANDr) ordinalIndex = 0xF1FF;
else if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->nANDl) ordinalIndex = 0xE5FF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->nANDl && ((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->lANDr) ordinalIndex = 0xE1FF;
else if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->lANDr) ordinalIndex = 0xF1FF;
else if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->nANDl) ordinalIndex = 0xE5FF;
break;
case 44:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->lANDr) ordinalIndex = 0xF1FF;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->lANDr) ordinalIndex = 0xF1FF;
break;
}
} else {
@@ -614,10 +614,10 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
case 56: case 59:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->fANDh) ordinalIndex = 0xF9FF;
break;
case 60: case 63:
case 52: case 55:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->bANDp) ordinalIndex = 0xF9FF;
break;
case 52: case 55:
case 60: case 63:
if (((ziFuzzyZYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B2C.word)->gANDk) ordinalIndex = 0xF9FF;
break;
case 38:
@@ -650,13 +650,13 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
if (getMode == 1) {
switch (match.phon2[index] & 0x1F0) {
case 0x10: case 0x80: case 0x100:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->anANDang) ordinalIndex = 0xFFF7;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->anANDang) ordinalIndex = 0xFFF7;
break;
case 0x180:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->enANDeng) ordinalIndex = 0xFFF7;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->enANDeng) ordinalIndex = 0xFFF7;
break;
case 0x60:
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->pyFuzzy.word)->inANDing) ordinalIndex = 0xFFF7;
if (((ziFuzzyPYPairs*)&((struct __zi8_work_data_s*)work)->unk_0x1B28.word)->inANDing) ordinalIndex = 0xFFF7;
break;
}
} else {
@@ -720,7 +720,7 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
return 0;
}
emitWords = 1;
if (request->completion) request->completion = request->elementCount;
if (request->count) request->count = request->elementCount;
}
if (!options->candidateMode) Zi8InitDupWordBuf(work);
records = (ziU8*)Zi8GetTableAddress(1, 0, work);
@@ -753,10 +753,11 @@ static int zi8InternalGetZH(ziGetParam* request, ZiChineseOptions* options, ziPt
if (!componentTable) {
componentCount = Zi8GetTableCount(1, 7, work);
componentOrdinals = (ziU8*)Zi8GetTableAddress(1, 7, work);
componentTable = componentCursor = (ziU8*)Zi8GetTableAddress(1, 2, work);
componentCursor = (ziU8*)Zi8GetTableAddress(1, 2, work);
componentTable = componentCursor;
componentCursor += 8;
componentIndex = componentCount - 1;
--componentCount;
componentIndex = componentCount;
alternateCharacter = 0;
phoneticRetry = 1;
}
@@ -930,13 +931,13 @@ engine_search:
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) {
request->letters = emittedCount;
request->count = emittedCount;
request->unk_0x20 = emittedCount;
goto engine_finish;
}
} else output[emittedCount++] = character;
if (emittedCount >= request->maxCandidates) {
request->letters = emittedCount;
request->count = emittedCount;
request->unk_0x20 = emittedCount;
goto engine_finish;
}
}
@@ -981,7 +982,7 @@ pud_candidate:
++rangeIndex;
}
if (rangeIndex == request->elementCount) {
if (!(request->context & 0x10)) request->completion = request->elementCount;
if (!(request->context & 0x10)) request->count = request->elementCount;
candidateStatus = 1;
character = currentSpelling[wordLength];
candidateOrdinal = 0xFFFF;
@@ -1108,13 +1109,13 @@ pud_charset:
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) {
request->letters = emittedCount;
request->count = emittedCount;
request->unk_0x20 = emittedCount;
goto engine_finish;
}
} else output[emittedCount++] = character;
if (emittedCount >= request->maxCandidates) {
request->letters = emittedCount;
request->count = emittedCount;
request->unk_0x20 = emittedCount;
goto engine_finish;
}
}
@@ -1299,16 +1300,16 @@ context_word_lookup:
if (emitWords) {
++emittedCount;
outputIndex += emittedWords;
output[outputIndex] = ' ';
if (++outputIndex > outputLimit) {
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) {
request->letters = emittedCount;
request->count = emittedCount;
request->unk_0x20 = emittedCount;
goto engine_finish;
}
} else output[emittedCount++] = previousOrdinal;
if (emittedCount >= request->maxCandidates) {
request->letters = emittedCount;
request->count = emittedCount;
request->unk_0x20 = emittedCount;
goto engine_finish;
}
}
@@ -1321,7 +1322,7 @@ context_phrase_next:
}
}
context_results_done:
if (request->wordCharCount) request->count = emittedCount;
if (request->wordCharCount) request->unk_0x20 = emittedCount;
if (getOptions == 5) goto engine_finish;
if ((wordLength && (getMode == 1 || getMode == 2) && match.nCand > 1) ||
(wordLength && getMode == 0 && match.nSeg > 1)) {
@@ -1336,7 +1337,7 @@ dictionary_search:
Zi8GetFormatVersion(1, work) >= 8) {
lastCharHigh = (request->currentWord[request->wordCharCount - 1] >> 8) & 0xFF;
lastCharLow = request->currentWord[request->wordCharCount - 1];
phoneticGroups = (ziU8*)Zi8GetTableAddress(1, 28, work);
phoneticGroups = Zi8GetTableAddress(1, 28, work);
rangeCount = Zi8GetTableCount(1, 28, work);
rangeIndex = 0;
while (rangeIndex < rangeCount) {
@@ -1384,7 +1385,7 @@ numeric_setup:
default: ordinalCount = 0; break;
}
}
if (ordinalCount) ordinalTable = (ziU8*)Zi8GetTableAddress(1, 29, work);
if (ordinalCount) ordinalTable = Zi8GetTableAddress(1, 29, work);
}
if (!request->elementCount && (getMode == 7 || getMode == 8 || getMode == 9)) {
resultFallback = 0;
@@ -1434,8 +1435,8 @@ candidate_dictionary_search:
if (emitWords) {
++emittedCount;
output[outputIndex++] = character;
output[outputIndex] = ' ';
if (++outputIndex > outputLimit) goto engine_finish;
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) goto engine_finish;
} else output[emittedCount++] = character;
if (emittedCount >= request->maxCandidates) goto engine_finish;
}
@@ -1451,7 +1452,7 @@ character_range_start:
firstOrdinal = 0;
rangeIndex = Zi8GetTableCount(1, 16, work);
if (Zi8GetFormatVersion(1, work) >= 4 && rangeIndex && elements[0] != 0xEF00) {
phoneticGroups = (ziU8*)Zi8GetTableAddress(1, 16, work);
phoneticGroups = Zi8GetTableAddress(1, 16, work);
rangeIndex = 0;
rangeCount = 0;
switch (phase) {
@@ -1612,9 +1613,9 @@ phonetic_ordinal_search:
record = records + phraseOrdinal * 12;
candidateCount = 0;
phoneticGroups = 0;
if (!Zi8MatchPhonetic(phoneticTable, records, alternateTable, alternateCount,
(ziU32)phraseTable, record, match.phon, match.phon2,
&candidateCount, &record, &phoneticGroups,
if (!Zi8MatchPhonetic(phoneticTable, (ZiChineseRecord*)records, alternateTable, alternateCount,
phraseTable, (ZiChineseRecord*)record, match.phon, match.phon2,
&candidateCount, (ZiChineseRecord**)&record, (int*)&phoneticGroups,
0, 1, match.nCand, phoneticMask, phoneticMatch, charset, requireFull,
phraseOrdinal, &candidateOrdinal, 0, work)) continue;
if (charsetTable) {
@@ -1676,8 +1677,8 @@ tone_candidates:
if (emitWords) {
++emittedCount;
output[outputIndex++] = character;
output[outputIndex] = ' ';
if (++outputIndex > outputLimit) goto engine_finish;
output[outputIndex++] = ' ';
if (outputIndex > outputLimit) goto engine_finish;
} else output[emittedCount++] = character;
if (emittedCount >= request->maxCandidates) goto engine_finish;
} else if (totalResults >= options->maxResults) goto engine_finish;
@@ -1752,12 +1753,12 @@ tone_candidates:
}
}
user_character_search:
if (((struct __zi8_work_data_s*)work)->uwdPtrCount && (getMode != 0 || !firstPhoneticPass) &&
if (((struct __zi8_work_data_s*)work)->unk_0x12C && (getMode != 0 || !firstPhoneticPass) &&
!options->countOnly && (match.nCand <= 1 || (getMode != 1 && getMode != 2)) &&
(ziU8)Zi8GetZHuwdPtr(&userEntriesAddress, &userCount, work) && (getMode != 0 || match.nSeg <= 1)) {
Zi8GetZHuwdPtr(&userEntries, &userCount, work) && (getMode != 0 || match.nSeg <= 1)) {
userIndex = 0;
while (userIndex < userCount) {
candidateOrdinal = (ziU16)(((ziU8*)userEntriesAddress)[1] & 0x7F) << 8 | ((ziU8*)userEntriesAddress)[2];
candidateOrdinal = (ziU16)(userEntries[1] & 0x7F) << 8 | userEntries[2];
record = records + candidateOrdinal * 12;
if (!(record[0] & charset)) goto user_character_next;
character = ((ziU16)record[6] << 8) + record[7];
@@ -1792,7 +1793,7 @@ user_character_search:
(ziU8)Zi8SecMatchChar(record, componentTable, &match, 0, work)) candidateStatus = 1;
break;
case 1: case 2:
if (request->elementCount && !(((ziU8*)userEntriesAddress)[1] & 0x80)) candidateStatus = 0;
if (request->elementCount && !(userEntries[1] & 0x80)) candidateStatus = 0;
else {
candidateStatus = (match.first & (ziU16)Zi8GetPCode(phoneticTable, record)) == match.first2;
if (!candidateStatus && (record[0] & 0x80) && !requireFull &&
@@ -1827,7 +1828,7 @@ user_character_search:
}
user_character_next:
++userIndex;
userEntriesAddress += 3;
userEntries += 3;
}
}
if (!prefixLookup) goto phonetic_alt_continue;
@@ -1912,7 +1913,7 @@ cangjie_components:
Zi8GetTableCount(1, 16, work) && elements[0] != 0xEF00 && getMode != 5) {
rangeIndex = 0;
rangeCount = 0;
phoneticGroups = (ziU8*)Zi8GetTableAddress(1, 16, work);
phoneticGroups = Zi8GetTableAddress(1, 16, work);
switch (phase) {
case 0: rangeIndex = 0; rangeCount = 2; phase = 1; break;
case 1:
@@ -2052,7 +2053,7 @@ component_record_next:
if (getMode != 5) {
while (exactPhrase) {
while (match.count) {
if ((candidateCount -= 1) == 0xFFFF) goto frequency_range_retry;
if (!candidateCount--) goto frequency_range_retry;
if (match.arrD[0] == (record[0] & match.arr1[0]) &&
(ziU8)Zi8SecMatchChar(record, componentTable, &match, &candidateOrdinal, work)) goto frequency_accept;
record += 12;
@@ -2199,7 +2200,7 @@ phonetic_main:
if (Zi8GetFormatVersion(1, work) >= 4) rangeCount = Zi8GetTableCount(1, 23, work);
else rangeCount = 0;
if (rangeCount && match.nCand == 2 && emitWords) {
frequencyCursor = (ziU8*)Zi8GetTableAddress(1, 24, work);
frequencyCursor = Zi8GetTableAddress(1, 24, work);
frequencyEntry = frequencyCursor;
duplicateIndex = Zi8GetTableCount(1, 24, work);
if (!duplicateIndex) isFirstCandidate = 1;
@@ -2298,7 +2299,7 @@ phonetic_pair_next:
alternateCursor += 4;
}
phonetic_group_next:
ordinalIndex += 1;
++ordinalIndex;
frequencyCursor += 5;
}
}
@@ -2323,9 +2324,9 @@ phonetic_ordinals:
candidateCount = recordCount;
phoneticGroups = 0;
while (emittedCount < request->maxCandidates && candidateCount) {
if (!Zi8MatchPhonetic(phoneticTable, records, alternateTable, alternateCount,
(ziU32)phraseTable, record, match.phon, match.phon2,
&candidateCount, &record, &phoneticGroups,
if (!Zi8MatchPhonetic(phoneticTable, (ZiChineseRecord*)records, alternateTable, alternateCount,
phraseTable, (ZiChineseRecord*)record, match.phon, match.phon2,
&candidateCount, (ZiChineseRecord**)&record, (int*)&phoneticGroups,
emitWords, singleCharacterPass, match.nCand, phoneticMask, phoneticMatch, charset,
requireFull, recordCount, &candidateOrdinal, filteringMode, work)) break;
ordinalIndex = recordCount - candidateCount - 1;
@@ -2446,7 +2447,7 @@ engine_finish:
return totalResults;
filtered_search:
userIndex = Zi8GetTableCount(1, 31, work);
frequencyTable = (ziU8*)Zi8GetTableAddress(1, 31, work);
frequencyTable = Zi8GetTableAddress(1, 31, work);
for (; userIndex; --userIndex) {
index = frequencyTable[0] & 15;
if (!(*frequencyTable++ & charset)) goto filtered_next;
@@ -2572,7 +2573,7 @@ filtered_accept:
if (totalResults >= options->maxResults) goto engine_finish;
} else if (!options->countOnly) {
if (++((ZiChineseWork*)work)->duplicateIndex >= 64) ((ZiChineseWork*)work)->duplicateIndex = 0;
if (filteringMode == 4) request->count = emittedCount + 1;
if (filteringMode == 4) request->unk_0x20 = emittedCount + 1;
if (emitWords) {
++emittedCount;
outputIndex += rangeCount;
@@ -2608,10 +2609,10 @@ static int Zi8NewMatchPhonetic(ziGetParam* request, ZiChineseRecord* records,
ziU8* phonetics;
int totalResults;
int emittedCharacters;
ziU8* matchedRecord;
ZiChineseRecord* matchedRecord;
ziU8* phoneticGroups;
ziU8* candidateGroups;
ziU8* matchedString;
int matchedIndex;
int capacity;
ziU8* groupCandidates;
ziU16 phoneticCount;
@@ -2645,20 +2646,20 @@ static int Zi8NewMatchPhonetic(ziGetParam* request, ZiChineseRecord* records,
if ((mask & 7) == 7) {
stopAfterTone = match & 7;
}
phoneticOffsets = (ziU16*)Zi8GetTableAddress(1, 13, work);
ordinalTable = (ziU16*)Zi8GetTableAddress(1, 14, work);
phoneticOffsets = Zi8GetTableAddress(1, 13, work);
ordinalTable = Zi8GetTableAddress(1, 14, work);
if (pinyin) {
phonetics = (ziU8*)Zi8GetTableAddress(1, 3, work);
phonetics = Zi8GetTableAddress(1, 3, work);
phoneticCount = Zi8GetTableCount(1, 3, work);
phoneticGroups = (ziU8*)Zi8GetTableAddress(1, 17, work);
phoneticGroups = Zi8GetTableAddress(1, 17, work);
groupCount = Zi8GetTableCount(1, 17, work);
candidateGroups = (ziU8*)Zi8GetTableAddress(1, 18, work);
candidateGroups = Zi8GetTableAddress(1, 18, work);
} else {
phonetics = (ziU8*)Zi8GetTableAddress(1, 4, work);
phonetics = Zi8GetTableAddress(1, 4, work);
phoneticCount = Zi8GetTableCount(1, 4, work);
phoneticGroups = (ziU8*)Zi8GetTableAddress(1, 19, work);
phoneticGroups = Zi8GetTableAddress(1, 19, work);
groupCount = Zi8GetTableCount(1, 19, work);
candidateGroups = (ziU8*)Zi8GetTableAddress(1, 20, work);
candidateGroups = Zi8GetTableAddress(1, 20, work);
}
if (groupCount) {
@@ -2782,12 +2783,12 @@ next_group_candidate:
}
}
if (stopAfterTone) {
matchedRecord = (ziU8*)(records + character);
matchedRecord = records + character;
matchedLength = 0;
matchedString = 0;
if (!Zi8MatchPhonetic(phonetics, (ziU8*)records, indexTable, indexCount,
(ziU32)dictionary, matchedRecord, &mask, &match,
&matchedLength, &matchedRecord, &matchedString,
matchedIndex = 0;
if (!Zi8MatchPhonetic(phonetics, records, indexTable, indexCount,
dictionary, matchedRecord, &mask, &match,
&matchedLength, &matchedRecord, &matchedIndex,
wordMode, 1, 1, excludedMask, excludedMatch,
charset, request->getOptions & 0x40, character,
&matchedTone, 0, work)) {
@@ -2868,7 +2869,7 @@ ziU8 Zi8GetElementCount(ziWChar* elements, ziU8 elementCount, ziU8 charCount ZI_
ziU8 count;
ziWChar spacedElements[256];
struct { ziWChar separator; } savedState;
savedState.separator = ZI_WORK->separator;
savedState.separator = ZI_WORK->unk_0x1A;
if (elementCount <= 1 || !charCount) {
return elementCount;
}
@@ -2881,9 +2882,9 @@ ziU8 Zi8GetElementCount(ziWChar* elements, ziU8 elementCount, ziU8 charCount ZI_
if (spacedIndex == elementCount) {
return elementCount;
}
ZI_WORK->separator = 0xF360;
ZI_WORK->unk_0x1A = 0xF360;
Zi8ZHaddSpace(elements, elementCount, spacedElements, 256, __zi8_work_data);
ZI_WORK->separator = savedState.separator;
ZI_WORK->unk_0x1A = savedState.separator;
spacedIndex = elementIndex = count = 0;
while (charCount && elementIndex < elementCount) {
if (spacedElements[spacedIndex] == 0xF360) {

View File

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

View File

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

View File

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

View File

@@ -18,12 +18,12 @@ ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
Zi8Memset(__zi8_work_data, 0, 0x1B44);
ZI_WORK->unk_0x08 = 1;
ZI_WORK->unk_0x09 = 1;
ZI_WORK->maxWordLength = 0xFF;
ZI_WORK->unk_0x0A = 0xFF;
ZI_WORK->unk_0x10 = 0x64;
*(ziU16*)&ZI_WORK->targetCount = 0xFFFF;
ZI_WORK->separator = 0x20;
*(ziU16*)&ZI_WORK->unk_0x0C = 0xFFFF;
ZI_WORK->unk_0x1A = 0x20;
ZI_WORK->unk_0x1C[2] = 0;
ZI_WORK->koAltTables = 0;
ZI_WORK->unk_0x1B30 = 0;
ZI_WORK->unk_0x1B3A = 0;
ZI_WORK->unk_0x1B36 = 0;
ZI_WORK->unk_0x1B32 = 0;
@@ -44,17 +44,17 @@ ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
ZI_WORK->unk_0x1874 = 0x2D;
ZI_WORK->language = 0;
ZI_WORK->unk_0x1C[3] = 0;
ZI_WORK->capacity = 0x100;
ZI_WORK->unk_0x141A = 0x100;
Zi8SetLatinSearchOrder(0, 0, ZI_WORK);
ZADP_Zi8SetPDremoveOpt(1, ZI_WORK);
ZI_WORK->zhPudMinPrefix = 5;
ZI_WORK->unk_0x17 = 5;
ZI_WORK->cangjieEnabled = Zi8GetFormatVersion(1, ZI_WORK) & 2;
ZI_WORK->pyFuzzy.bits.msb = 1;
ZI_WORK->unk_0x1B28.bits.msb = 1;
ZI_WORK->unk_0x1B2C.bits.msb = 1;
zyFuzzy = ZI_WORK->unk_0x1B2C.word;
pzyFuzzy = &zyFuzzy;
Zi8ZHsetZYfuzzyPairs(pzyFuzzy, ZI_WORK);
pyFuzzy = ZI_WORK->pyFuzzy.word;
pyFuzzy = ZI_WORK->unk_0x1B28.word;
ppyFuzzy = &pyFuzzy;
Zi8ZHsetPYfuzzyPairs(ppyFuzzy, ZI_WORK);
Zi8SetParentalControls(2, ZI_WORK);
@@ -62,7 +62,7 @@ ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
return 1;
}
ziU8 Zi8IsZicorpSignature(ziU16* p, ziU16 len ZI_NEED_WORK) {
ziU8 Zi8IsZicorpSignature(ziU16* p, ziU16 len) {
if ((ziU16)len > 6 && p[0] == 0x7A && p[1] == 0x69 && p[2] == 0x63 &&
p[3] == 0x6F && p[4] == 0x72 && p[5] == 0x70) {
return 1;

View File

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

View File

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

View File

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

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

View File

@@ -41,7 +41,7 @@ ziBool Zi8_81480224(ziUserWord* word ZI_NEED_WORK) {
current = ZI_WORK->uwdList;
while (current != 0) {
candidate = (ziUserWord*)current->word;
if (ZI_WORK->uwdPrioritySort == 1 && candidate->priority < word->priority) break;
if (ZI_WORK->unk_0x12E == 1 && word->priority > candidate->priority) break;
if (candidate->length == length) {
position = 0;
while (position < length) {
@@ -105,11 +105,11 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
int position;
int prefixLength;
Zi8LogError(100, __zi8_work_data);
if (!(ZI_WORK->uwdDictCount <= 2 && ZI_WORK->uwdDictCount != 0 && ZI_WORK->uwdDicts[ZI_WORK->uwdDictCount - 1] != 0)) {
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->uwdDicts[ZI_WORK->uwdDictCount - 1];
dictionary = ZI_WORK->unk_0x130[ZI_WORK->unk_0x138 - 1];
if (continuation != 0) {
text = (ziU8*)Zi8_814803F4(__zi8_work_data);
entryLength = 0;
@@ -148,7 +148,7 @@ ziU8 Zi8MatchUWDdata(ziWChar* pattern, ziU8 length, ziWChar* currentWord, ziU16
folded = currentWord[position];
ZI_WORK->unk_0x141[previousOffset] = Zi8ConvertWC2UC(folded, language, __zi8_work_data);
ZI_WORK->unk_0x184[previousOffset] = 0;
if (ZI_WORK->ignoreCase != 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);
}
@@ -192,7 +192,7 @@ next:
if (pattern[position] != Zi8ConvertUC2Key(text[position], language, __zi8_work_data)) goto next;
} else {
folded = Zi8ConvertUC2WC(text[position], language, __zi8_work_data);
if (folded != pattern[position] && (!ZI_WORK->ignoreCase || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[position])) goto next;
if (folded != pattern[position] && (!ZI_WORK->unk_0x1F || !Zi8ChangeCharCase(0, &folded, language, __zi8_work_data) || folded != pattern[position])) goto next;
}
}
if (ZI_WORK->unk_0x140 != 0) {

View File

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

View File

@@ -41,13 +41,6 @@ ziU32 ZiDAWGGetChild(ziU32 node) {
return node;
}
typedef struct ziDawgLongOffset {
ziU8 flags;
ziU8 middle;
ziU8 low;
} ziDawgLongOffset;
typedef char ziDawgLongOffsetSizeCheck[(sizeof(ziDawgLongOffset) == 3) ? 1 : -1];
ziU8* ZiDAWGGetSibling(ziU8* cursor) {
ziS32 depth;
ziU8* node;
@@ -77,14 +70,14 @@ ziU8* ZiDAWGGetSibling(ziU8* cursor) {
}
if ((*cursor & 0x80) != 0) {
node += (((const ziDawgLongOffset*)cursor)->flags & 0x7f) * 0x10000 +
(((ziU32)(ziU16)cursor[1] << 8) +
((const ziDawgLongOffset*)cursor)->low) + 0x8000;
node += (*cursor & 0x7f) * 0x10000 +
(((ziU32)cursor[1] << 8) + (ziU32)cursor[2]) + 0x8000;
} else {
node = cursor[1] + (node + (ziU16)*cursor * 0x100);
}
return node;
} else {
cursor = node;
do {
header = nodeHeaderTable[cursor[0] >> 4];
if ((cursor[0] & 0xf) == 0xf) {
@@ -199,10 +192,10 @@ checkEntry:
}
result = graph + (ziU32)entry[4] * 0x10000 + (((ziU16)entry[5] << 8) + entry[6]);
((zi8DawgCtx*)context)->endNode =
((zi8DawgCtx*)context)->unk_0x338 =
graph + (ziU32)entry[7] * 0x10000 + (((ziU16)entry[8] << 8) + entry[9]);
if (((zi8DawgCtx*)context)->endNode == graph) {
((zi8DawgCtx*)context)->endNode = 0;
if (((zi8DawgCtx*)context)->unk_0x338 == graph) {
((zi8DawgCtx*)context)->unk_0x338 = 0;
}
if ((((ziU16)entry[0] << 8) + entry[1]) == 0) {

View File

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

View File

@@ -25,12 +25,6 @@ ziU8 Zi8GetFormatVersion(ziU8 ZI_NEED_WORK);
ziPtr Zi8GetTableAddress(ziU8, ziU8 ZI_NEED_WORK);
ziU16 Zi8Uni2Ord(ziWChar ZI_NEED_WORK);
typedef struct ziEncodedOrdinal {
ziU8 low;
ziU8 high;
} ziEncodedOrdinal;
typedef char ziEncodedOrdinalSizeCheck[(sizeof(ziEncodedOrdinal) == 2) ? 1 : -1];
ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
ziChineseEntry* table = 0;
ziU8* baseData = 0;
@@ -45,8 +39,8 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
ziWChar* cursor;
ziU8* data;
ziU8 formats[8] = {1, 5, 0, 0, 0, 0, 0, 0};
ziU32 savedFormats = ZI_WORK->formats;
ziU8 savedCount = ZI_WORK->formatCount;
ziU32 savedFormats = ZI_WORK->unk_0x1410;
ziU8 savedCount = ZI_WORK->unk_0x1418;
ziSearchState search = {0};
Zi8LogError(100, __zi8_work_data);
if (word == 0 || *word == 0) {
@@ -73,22 +67,22 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
request.candidates = ordinals;
request.maxCandidates = 1;
request.firstCandidate = 0;
ZI_WORK->formats = (ziU32)formats;
ZI_WORK->unk_0x1410 = (ziU32)formats;
if (ZI_WORK->unk_0x1C[0] == 2) {
ZI_WORK->formatCount = 0;
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->formatCount++] = 1;
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->formatCount++] = 2;
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->formatCount++] = 3;
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->formatCount++] = 4;
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->formatCount++] = 5;
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->formatCount++] = 6;
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->formatCount++] = 7;
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->formatCount++] = 8;
} else if (ZI_WORK->unk_0x1C[0] != 0) ZI_WORK->formatCount = 2;
else ZI_WORK->formatCount = 1;
ZI_WORK->unk_0x1418 = 0;
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->unk_0x1418++] = 1;
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->unk_0x1418++] = 2;
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->unk_0x1418++] = 3;
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->unk_0x1418++] = 4;
if (ZI_WORK->unk_0x09 & 1) formats[ZI_WORK->unk_0x1418++] = 5;
if (ZI_WORK->unk_0x09 & 4) formats[ZI_WORK->unk_0x1418++] = 6;
if (ZI_WORK->unk_0x09 & 2) formats[ZI_WORK->unk_0x1418++] = 7;
if (ZI_WORK->unk_0x09 & 8) formats[ZI_WORK->unk_0x1418++] = 8;
} else if (ZI_WORK->unk_0x1C[0] != 0) ZI_WORK->unk_0x1418 = 2;
else ZI_WORK->unk_0x1418 = 1;
count = Zi8GetCandidatesOrCount(&request, &search, __zi8_work_data);
ZI_WORK->formats = savedFormats;
ZI_WORK->formatCount = savedCount;
ZI_WORK->unk_0x1410 = savedFormats;
ZI_WORK->unk_0x1418 = savedCount;
if (count != 0) return 1;
}
if (language != 1) {
@@ -140,10 +134,10 @@ ziBool Zi8IsWordW(ziWChar* word, ziU8 language ZI_NEED_WORK) {
countLeft = count;
cursor = ordinals;
while (countLeft > 0) {
value = ((ziU32)(ziU16)data[1] << 8) |
((const ziEncodedOrdinal*)data)->low;
value = (data[1] << 8) | data[0];
data += 2;
if (value != *++cursor) break;
cursor++;
if (value != *cursor) break;
countLeft--;
if (value & 0x8000) break;
}

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -26,7 +26,7 @@ typedef struct USBKBDCmdLED {
typedef struct USBKBDCmdLEDAsync {
USBKBDCmdLED base; // 0x00
u8 pad_0x08[0x10]; // 0x08
u8 unk_0x08[0x10];
USBKBDCmdLEDCallback cb; // 0x18
void* cbArg; // 0x1C
} USBKBDCmdLEDAsync;

View File

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

View File

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

View File

@@ -6,6 +6,11 @@ typedef struct FA_NAND_ATTACH {
u32 size;
} FA_NAND_ATTACH;
typedef struct FA_ATTACH_REQUEST {
FADrvTbl* table;
u32 count;
} FA_ATTACH_REQUEST;
FADisk* gOpenDisk[26];
FAPartition* gOpenPartition[26];
typedef struct FA_DISK_INIT {
@@ -29,13 +34,13 @@ static struct {
} drvInitFunc = {diskInitTbl, 3};
extern s32 pdm_open_disk(FA_DISK_INIT* table, FADisk** disk);
extern s32 pdm_open_partition(FADisk* disk, u32 index, FAPartition** partition);
extern s32 pfstub_attach(FADrvTbl** drives, const void* nand_data);
extern s32 pfstub_attach(FA_ATTACH_REQUEST* request, FA_NAND_ATTACH* nand);
extern s32 pfd_sddrv_is_media_insert(void);
extern s32 pfd_mscdrv_is_media_insert(FADisk* disk);
extern s32 pfd_mscdrv_is_media_insert(void);
FAError FAAttach(u32 device, char* nand_path, u32 nand_size, FADrvTbl* table) {
FADisk* disk;
FADrvTbl* drives[2];
FA_ATTACH_REQUEST request;
FA_NAND_ATTACH nand;
s32 error;
s32 index;
@@ -60,16 +65,16 @@ FAError FAAttach(u32 device, char* nand_path, u32 nand_size, FADrvTbl* table) {
return -1;
}
}
drives[0] = table;
drives[1] = NULL;
request.table = table;
request.count = 0;
if (device == 2) {
memcpy(nand.path, nand_path, 78);
nand.size = nand_size;
}
if (device == 2) {
error = pfstub_attach(drives, &nand);
error = pfstub_attach(&request, &nand);
} else {
error = pfstub_attach(drives, NULL);
error = pfstub_attach(&request, NULL);
}
if (error != 0) {
return -1;
@@ -80,11 +85,11 @@ FAError FAAttach(u32 device, char* nand_path, u32 nand_size, FADrvTbl* table) {
gOpenPartition[index] = table->pPart;
if (device == 0) {
if (pfd_sddrv_is_media_insert()) {
drives[0]->stat |= 0x10;
request.table->stat |= 0x10;
}
} else if (device == 1) {
if (pfd_mscdrv_is_media_insert(disk)) {
drives[0]->stat |= 0x10;
if (pfd_mscdrv_is_media_insert()) {
request.table->stat |= 0x10;
}
}
} else {

View File

@@ -3,7 +3,7 @@
static FAEjectCallback g_detach_func;
static FAInsertCallback g_attach_func;
extern s32 uhf_msc_is_media_insert(FADisk* disk);
extern s32 uhf_msc_is_media_insert(void);
s32 pfd_mscdrv_registar_callback(FAInsertCallback insert, FAEjectCallback eject) {
g_attach_func = insert;
@@ -11,6 +11,6 @@ s32 pfd_mscdrv_registar_callback(FAInsertCallback insert, FAEjectCallback eject)
return 0;
}
s32 pfd_mscdrv_is_media_insert(FADisk* disk) {
return uhf_msc_is_media_insert(disk);
s32 pfd_mscdrv_is_media_insert(void) {
return uhf_msc_is_media_insert();
}

View File

@@ -318,58 +318,58 @@ s32 pfd_sddrv_init(FADisk* disk) {
}
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 -44;
if (disk == g_pfd_sddrv_info.disk) {
return 0;
}
return -44;
}
if ((g_pfd_sddrv_info.flags & 4) == 0) {
g_pfd_sddrv_info.bytes_per_sector = 0x200;
pf_memset(&g_pfd_sddev, 0, 0x28);
sd_result = ISD_InitCard();
if (sd_result != 0) {
OSReport("ERR:Failed to init SD Card Driver in pfd_sddrv_init()\n");
return -40;
}
g_pfd_sddrv_info.flags |= 4;
}
pf_memset(&g_pfd_sddev, 0, 0x28);
device = &g_pfd_sddev.device;
sd_result = ISD_MountCard(0, &device);
if (sd_result != 0) {
OSReport("ERR SD card can not mount [ret = 0x%x]. pfd_sddrv_init()\n", sd_result);
return -41;
}
sd_result = ISD_GetDeviceStatus(device, &status);
if (sd_result != 0) {
OSReport("ERR Failed to get sd card status. [ret = 0x%x]\n", sd_result);
return 21;
}
if ((status & 1) != 0) {
g_pfd_sddrv_info.media_inserted = 1;
}
g_pfd_sddrv_info.device = device;
if (g_pfd_sddrv_info.media_inserted != 0) {
g_event = 2;
sd_result = ISD_RegisterDeviceIntrHandler(device, (SDDevIntrCallback)pfd_st_removal_callback, &g_event);
if (sd_result != 0) {
OSReport("ERR:Failed to regist intr handler1 [ret = 0x%x] pfd_sddrv_init()\n", sd_result);
ISD_UnmountCard(device);
g_pfd_sddrv_info.device = 0;
return -42;
}
} else {
if ((g_pfd_sddrv_info.flags & 4) == 0) {
g_pfd_sddrv_info.bytes_per_sector = 0x200;
pf_memset(&g_pfd_sddev, 0, 0x28);
sd_result = ISD_InitCard();
if (sd_result != 0) {
OSReport("ERR:Failed to init SD Card Driver in pfd_sddrv_init()\n");
return -40;
}
g_pfd_sddrv_info.flags |= 4;
}
pf_memset(&g_pfd_sddev, 0, 0x28);
device = &g_pfd_sddev.device;
sd_result = ISD_MountCard(0, &device);
g_event = 1;
sd_result = ISD_RegisterDeviceIntrHandler(device, (SDDevIntrCallback)pfd_st_inter_callback, &g_event);
if (sd_result != 0) {
OSReport("ERR SD card can not mount [ret = 0x%x]. pfd_sddrv_init()\n", sd_result);
return -41;
OSReport("ERR:Failed to regist intr handler1 [ret = 0x%x] pfd_sddrv_init()\n", sd_result);
ISD_UnmountCard(device);
g_pfd_sddrv_info.device = 0;
return -42;
}
sd_result = ISD_GetDeviceStatus(device, &status);
if (sd_result != 0) {
OSReport("ERR Failed to get sd card status. [ret = 0x%x]\n", sd_result);
return 21;
}
if ((status & 1) != 0) {
g_pfd_sddrv_info.media_inserted = 1;
}
g_pfd_sddrv_info.device = device;
if (g_pfd_sddrv_info.media_inserted != 0) {
g_event = 2;
sd_result = ISD_RegisterDeviceIntrHandler(device, (SDDevIntrCallback)pfd_st_removal_callback, &g_event);
if (sd_result != 0) {
OSReport("ERR:Failed to regist intr handler1 [ret = 0x%x] pfd_sddrv_init()\n", sd_result);
ISD_UnmountCard(device);
g_pfd_sddrv_info.device = 0;
return -42;
}
} else {
g_event = 1;
sd_result = ISD_RegisterDeviceIntrHandler(device, (SDDevIntrCallback)pfd_st_inter_callback, &g_event);
if (sd_result != 0) {
OSReport("ERR:Failed to regist intr handler1 [ret = 0x%x] pfd_sddrv_init()\n", sd_result);
ISD_UnmountCard(device);
g_pfd_sddrv_info.device = 0;
return -42;
}
}
g_pfd_sddrv_info.disk = disk;
g_pfd_sddrv_info.flags |= 1;
}
g_pfd_sddrv_info.disk = disk;
g_pfd_sddrv_info.flags |= 1;
return 0;
}
@@ -749,8 +749,7 @@ s32 pfd_sddrv_get_total_sectors(u32* sectors, u16* bytes_per_sector) {
minimum_multiplier = multiplier >= 9 ? multiplier : 9;
max_multiplier = minimum_multiplier <= 11 ? minimum_multiplier : 11;
multiplier_factor = 1;
max_multiplier = (u16)(max_multiplier - 9);
multiplier_factor = (u16)(multiplier_factor << max_multiplier);
multiplier_factor <<= (u16)(max_multiplier - 9);
*sectors = cluster_blocks * multiplier_factor;
} else {
*sectors = ((csd[1] >> 8 & 0x3fffff) + 1) * 0x400;
@@ -1361,20 +1360,19 @@ s32 pfd_sddrv_store_fat32_bpb_buf(PFD_SDDRV_FORMAT_DATA* format_data, u8* sector
static s32 pfd_sddrv_store_fat32_reserved_buf(u8* sector_buffer) {
PFD_SDDRV_RESERVED_BOOT_SECTOR* reserved_boot_sector;
s32 result = -30;
if (sector_buffer != 0) {
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.bytes[0] = 0x55;
reserved_boot_sector->signature.bytes[1] = 0xaa;
} else {
reserved_boot_sector->signature.value = 0x55aa;
}
result = 0;
if (sector_buffer == 0) {
return -30;
}
return result;
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.bytes[0] = 0x55;
reserved_boot_sector->signature.bytes[1] = 0xaa;
} else {
reserved_boot_sector->signature.value = 0x55aa;
}
return 0;
}
s32 pfd_sddrv_build_fat32_mbr_bpb(u32 total_sectors) {

View File

@@ -1,32 +1,25 @@
#include <private/fa/pdm.h>
#include <revolution/types.h>
#define MBR_WORD(buf, offset) \
((pf_u32)(buf)[offset] + ((pf_u32)(buf)[(offset) + 1] << 8) + \
((pf_u32)(buf)[(offset) + 2] << 16) + ((pf_u32)(buf)[(offset) + 3] << 24))
#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]);
}
static inline pf_u32 read_partition_u32(const pf_u8* buf, pf_u32 offset) {
return (((pf_u32)buf[offset + 2] << 16) + buf[offset]) +
(((pf_u32)buf[offset + 3] << 24) + ((pf_u32)buf[offset + 1] << 8));
}
pf_s32 pdm_part_is_master_boot_sector(pf_u8* buf, pf_u32 total, pf_bool* p_is_mbr) {
pf_u32* p_start;
pf_u32* p_count;
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++) {
*p_start = 0;
*p_start = read_partition_u32(buf, 454);
*p_count = read_partition_u32(buf, 458);
*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 {
@@ -78,20 +71,15 @@ pf_bool pdm_part_is_boot_sector(pf_u8* buf) {
return is_boot;
}
static inline pf_u32 read_relative_start_sector(pf_u32 base, const pf_u8* buf, pf_u32 offset) {
return base + (buf[offset] + ((unsigned int)buf[offset + 1] << 8) +
((unsigned int)buf[offset + 2] << 16) + ((unsigned int)buf[offset + 3] << 24));
}
pf_s32 pdm_part_get_start_sector(PDM_PARTITION* p_part) {
pf_u32 part_index = 0;
pf_u32 requested = p_part->part_id;
pf_u32 start[4];
pf_u32 count[4];
pf_u32 part_index = 0;
pf_u32 sector;
pf_u32 base;
pf_u16 index;
pf_u16 extended_index;
pf_u32 base;
pf_u32 sector;
pf_u32 length;
pf_bool is_mbr;
pf_u32 success;
@@ -124,14 +112,14 @@ pf_s32 pdm_part_get_start_sector(PDM_PARTITION* p_part) {
sector = base;
for (extended_index = 0; extended_index < 2; extended_index++) {
if (extended_index == 0) {
sector = read_relative_start_sector(sector, buf, 454);
sector = sector + MBR_WORD(buf, 454);
length = MBR_WORD(buf, 458);
err = pdm_disk_physical_read(p_part->p_disk, buf, sector, 1, 512, &success);
if (err != 0) { return err; }
if (requested == part_index) { p_part->start_sector = sector; p_part->total_sector = length; return 0; }
part_index++;
} else {
sector = read_relative_start_sector(base, buf, 470);
sector = base + MBR_WORD(buf, 470);
length = MBR_WORD(buf, 474);
if (sector == 0 || length == 0) { break; }
err = pdm_disk_physical_read(p_part->p_disk, buf, sector, 1, 512, &success);

View File

@@ -550,6 +550,7 @@ pf_s32 PFCACHE_DoWriteSector(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, const pf
#pragma dont_inline reset
#pragma dont_inline on
pf_s32 PFCACHE_DoWriteNumSectorAndFreeIfNeeded(PF_VOLUME* p_vol, PF_CACHE_PAGE** pp_head, const pf_u8* p_buf, pf_u32 sector,
pf_u32 num_sector, pf_u32* p_num_success) {
PF_CACHE_PAGE* p_page = PF_NULL;
@@ -557,6 +558,8 @@ pf_s32 PFCACHE_DoWriteNumSectorAndFreeIfNeeded(PF_VOLUME* p_vol, PF_CACHE_PAGE**
pf_u32 num_rest_sector = num_sector;
pf_u8* p_sbuf;
pf_u8* p_ebuf;
pf_u32 num_overlap;
pf_u32 last_sector;
*p_num_success = 0;
do {
if (p_page == PF_NULL) {
@@ -606,10 +609,12 @@ pf_s32 PFCACHE_DoWriteNumSectorAndFreeIfNeeded(PF_VOLUME* p_vol, PF_CACHE_PAGE**
(p_page->sector + p_page->size) >= (sector + num_sector)) {
pf_memcpy(p_page->buffer, (pf_u8*)&p_buf[(p_page->sector - sector) << p_vol->bpb.log2_bytes_per_sector],
(sector + num_sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector);
num_rest_sector -= p_page->size - ((p_page->sector + p_page->size) - (sector + num_sector));
*p_num_success += p_page->size - ((p_page->sector + p_page->size) - (sector + num_sector));
num_overlap = p_page->size - ((p_page->sector + p_page->size) - (num_sector + sector));
last_sector = p_page->sector + num_overlap - 1;
*p_num_success += num_overlap;
num_rest_sector -= num_overlap;
p_page->stat |= 2;
p_ebuf = &p_page->buffer[(p_page->size - ((p_page->sector + p_page->size) - (sector + num_sector)) - 1) << p_vol->bpb.log2_bytes_per_sector];
p_ebuf = &p_page->buffer[(last_sector - p_page->sector) << p_vol->bpb.log2_bytes_per_sector];
p_page->p_mod_sbuf = p_page->buffer;
if (p_page->p_mod_ebuf == NULL || p_page->p_mod_ebuf < p_ebuf) {
p_page->p_mod_ebuf = p_ebuf;

View File

@@ -511,8 +511,8 @@ pf_s32 PFENT_ITER_FindCluster(PF_DIR_ENT* p_ent, pf_u32 cluster, pf_bool* p_is_f
iter.ffd.cluster_link.buffer = PF_NULL;
iter.log2_entries_per_sector = p_ent->p_vol->bpb.log2_bytes_per_sector - 5;
iter.file_sector_index = sector_index;
iter.offset_mask = (1U << iter.log2_entries_per_sector) - 1;
entries_per_sector = 1U << iter.log2_entries_per_sector;
entries_per_sector = 1 << iter.log2_entries_per_sector;
iter.offset_mask = entries_per_sector - 1;
iter.p_vol = p_ent->p_vol;
iter.sector = p_ent->entry_sector;
iter.offset = p_ent->entry_offset;

View File

@@ -1458,19 +1458,6 @@ s32 PFFAT_CountFreeClusters(PF_VOLUME* volume, u32* numFreeClusters)
return 0;
}
static inline s32 PFFAT_ClearEntryWithBuf(PF_VOLUME* volume, u32 cluster, PF_CACHE_PAGE* page) {
switch (volume->bpb.fat_type) {
case FAT_12:
return PFFAT12_WriteFATEntryWithBuf(volume, (u16)cluster, 0, page);
case FAT_16:
return PFFAT16_WriteFATEntryWithBuf(volume, cluster, 0, page);
case FAT_32:
return PFFAT32_WriteFATEntryWithBuf(volume, cluster, 0, page);
default:
return 15;
}
}
s32 PFFAT_FreeChain(PFFAT_FFD* file, u32 startCluster, u32 chainIndex,
u32 size)
{
@@ -1536,9 +1523,9 @@ s32 PFFAT_FreeChain(PFFAT_FFD* file, u32 startCluster, u32 chainIndex,
}
if (nextCluster == 0) {
s32 firstFlushError;
u32 fatSector;
PF_CACHE_PAGE* flushPage;
u16 fatIndex;
const PF_CACHE_PAGE* flushPage;
u32 fatSector;
firstFlushError = 0;
flushPage = page;
@@ -1559,20 +1546,34 @@ s32 PFFAT_FreeChain(PFFAT_FFD* file, u32 startCluster, u32 chainIndex,
PFCACHE_FreeDataPage(volume, page);
return 0;
}
{
s32 writeError;
if (chainIndex != -1) {
writeError = PFFAT_WriteClusterWithBuf(file, startCluster, chainIndex,
0, 1, page);
chainIndex++;
} else {
writeError = PFFAT_ClearEntryWithBuf(volume, startCluster, page);
}
if (writeError != 0) {
PFCACHE_FreeDataPage(volume, page);
return writeError;
if (chainIndex != -1) {
error = PFFAT_WriteClusterWithBuf(file, startCluster, chainIndex,
0, 1, page);
chainIndex++;
} else {
currentPage = page;
switch (volume->bpb.fat_type) {
case FAT_12:
error = PFFAT12_WriteFATEntryWithBuf(
volume, (u16)startCluster, 0, currentPage);
break;
case FAT_16:
error = PFFAT16_WriteFATEntryWithBuf(volume, startCluster, 0,
currentPage);
break;
case FAT_32:
error = PFFAT32_WriteFATEntryWithBuf(volume, startCluster, 0,
currentPage);
break;
default:
error = 15;
break;
}
}
if (error != 0) {
PFCACHE_FreeDataPage(volume, page);
return error;
}
if (size != 0 && fileSize != 0) {
if (fileSize <= clusterSize) {
fileSize = 0;
@@ -1589,7 +1590,7 @@ s32 PFFAT_FreeChain(PFFAT_FFD* file, u32 startCluster, u32 chainIndex,
s32 firstFlushError;
u32 fatSector;
u16 fatIndex;
const PF_CACHE_PAGE* flushPage;
PF_CACHE_PAGE* flushPage;
firstFlushError = 0;
flushPage = page;

View File

@@ -1,12 +1,12 @@
#include <revolution/fa/pf_stub.h>
s32 pfstub_attach(FADrvTbl** drives, const void* nand_data) {
s32 pfstub_attach(FADrvTbl* drives, u32 mode) {
PF_STUB_MESSAGE message;
message.operation = 27;
message.object = drives;
message.callback = NULL;
message.data = nand_data;
message.data = (void*)mode;
if (pfstub_com_massage(&message) == -1) {
return -1;
}

View File

@@ -557,14 +557,18 @@ static void kbdSendKey(KBDKeyEventData* event) {
}
}
static inline u32 kbdChannelFlags(u32 channel) {
return kbdData[channel].flags;
}
static void kbd_led_handler(BOOL success, void* callbackArg) {
const KBDLEDCallbackData* callback;
s32 index;
u32 index;
u32 err;
index = (s32)callbackArg;
index = (u32)callbackArg;
callback = &kbdLCBuf[index];
kbdCmdBuf[index].device = 0;
if (callback->callbackAddress == (USBKBDCmdLEDCallback)(u32)kbdCmdBuf[(u32)callbackArg].device) {
if (callback->callbackAddress == (USBKBDCmdLEDCallback)(u32)kbdCmdBuf[index].device) {
return;
}
switch (success) {
@@ -575,12 +579,13 @@ static void kbd_led_handler(BOOL success, void* callbackArg) {
err = 0;
break;
}
kbdLCBuf[(u32)callbackArg].callbackAddress(err, kbdLCBuf[(u32)callbackArg].callbackArg);
kbdLCBuf[index].callbackAddress(err, kbdLCBuf[index].callbackArg);
}
USBKBDErr KBDSetLedsAsync(u32 channel, u32 leds, USBKBDCmdLEDCallback callback, void* callbackArg) {
s32 index;
u32 ofs;
u8 ledBits;
u32 index;
BOOL interrupts;
USBKBDErr result;
if (!kbdInitialized) {
@@ -589,18 +594,14 @@ USBKBDErr KBDSetLedsAsync(u32 channel, u32 leds, USBKBDCmdLEDCallback callback,
if (channel >= 4) {
return 4;
}
{
KBDChannel* data = &kbdData[(s32)channel];
if ((s32)data->flags == 1 || (s32)data->flags == 4) {
return 5;
}
if ((s32)kbdChannelFlags(channel) == 1 || (s32)kbdChannelFlags(channel) == 4) {
return 5;
}
ledBits = leds;
interrupts = OSDisableInterrupts();
for (index = 0; index < 12; index++) {
if (kbdCmdBuf[(s32)index].device == 0) {
KBDChannel* data = &kbdData[channel];
kbdCmdBuf[(s32)index].device = (u32)data->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;
}
}
@@ -608,14 +609,11 @@ USBKBDErr KBDSetLedsAsync(u32 channel, u32 leds, USBKBDCmdLEDCallback callback,
if (index == 12) {
return 7;
}
{
KBDChannel* data = &kbdData[channel];
kbdLCBuf[index].callbackAddress = callback;
kbdLCBuf[index].callbackArg = callbackArg;
result = USBKBDSetLEDAsync((u32)data->device, ledBits,
(USBKBDCmdLEDAsync*)&kbdCmdBuf[index],
kbd_led_handler, (void*)index);
}
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;
@@ -626,6 +624,7 @@ USBKBDErr KBDSetLedsAsync(u32 channel, u32 leds, USBKBDCmdLEDCallback callback,
USBKBDErr KBDSetLeds(u32 channel, u32 leds) {
u32 index;
KBDLEDCommand* command;
BOOL interrupts;
USBKBDErr result;
u8 ledBits;
@@ -635,16 +634,20 @@ USBKBDErr KBDSetLeds(u32 channel, u32 leds) {
if (channel >= 4) {
return 4;
}
if ((s32)kbdData[(s32)channel].flags == 1 || (s32)kbdData[(s32)channel].flags == 4) {
if ((s32)kbdChannelFlags(channel) == 1 || (s32)kbdChannelFlags(channel) == 4) {
return 5;
}
ledBits = leds & 0xff;
interrupts = OSDisableInterrupts();
for (index = 0; index < 12; index++) {
if (kbdCmdBuf[(s32)index].device == 0) {
kbdCmdBuf[(s32)index].device = (u32)kbdData[channel].device;
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) {
@@ -652,7 +655,7 @@ USBKBDErr KBDSetLeds(u32 channel, u32 leds) {
}
result = USBKBDSetLED((u32)kbdData[channel].device, ledBits,
(USBKBDCmdLED*)&kbdCmdBuf[index]);
kbdCmdBuf[(s32)index].device = 0;
kbdCmdBuf[index].device = 0;
switch (result) {
default:
return 7;

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