Compare commits

...

34 Commits

Author SHA1 Message Date
coah
eea728fa7c ci: self-hosted job that keeps readme progress numbers updated 2026-09-29 22:58:41 +00:00
coah
fddb035def Decompile tiPcKeyboard to 120/141 functions (gpt-6.1-sol medium) (worker 7ab3be61) (#292) 2026-09-29 17:46:52 -05:00
coah
e196e79bfd BS2Mach: 21/29 functions (gpt-6.1-sol low) (worker 115f25f2) (#291) 2026-09-29 17:37:35 -05:00
coah
a4854483dc iplSDChannelTitle: 64/69 functions (worker d788a5c0) (#290) 2026-09-29 17:11:49 -05:00
coah
5ed744554c Decompile MyTiInputForm: 84/84 functions, 100% code (gpt-6.1-sol medium) (worker 2013f10c) (#289) 2026-09-29 17:05:33 -05:00
coah
fcb5be85f7 Decompile iplSDChannelTitle to 63/69 functions (gpt-6.1-sol low) (worker b1c15e3d) (#288) 2026-09-29 17:02:20 -05:00
devin-ai-integration[bot]
1a697e61f9 zi8clib: link 8 matched clib units (alts,getc,getSW,initd,is,misc,punct,space) (#287)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-29 21:49:29 +00:00
coah
112e4e1a14 Decompile zi81key to 4/9 functions (gpt-6.1-sol medium) (worker d6b62eb7) (#286) 2026-09-29 16:44:51 -05:00
coah
0aca3c76ee Decompile zi8alpha to 10/12 functions (gpt-6.1-sol low) (worker 86690220) (#285) 2026-09-29 16:42:34 -05:00
coah
8882983861 Decompile zi8cinfo to 9/10 functions (gpt-6.1-sol medium) (worker 2c479148) (#284) 2026-09-29 16:25:13 -05:00
coah
7097003811 NHTTP_thread: 24/26 functions (gpt-6.1-sol low) (worker 15fd8451) (#283) 2026-09-29 16:15:02 -05:00
devin-ai-integration[bot]
e265d9664e setting: link iplAOSSThread (objdiff 100% code+data) (#282)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-29 21:13:55 +00:00
coah
a620eec6a4 Decompile NHTTP_thread to 23/26 functions (gpt-6.1-sol low) (worker 64796af8) (#281) 2026-09-29 16:07:10 -05:00
coah
5cdca2e8aa iplGCSaveData: replace hand-placed lbl_ strings with named data (worker e4de343a) (#280) 2026-09-29 15:51:33 -05:00
coah
3b286167ba Decompile NWC24Download to 7/30 functions (worker be3767b3) (#279) 2026-09-29 15:42:41 -05:00
devin-ai-integration[bot]
882a83064e memoryCard: link iplGCSaveData (objdiff 100% code+data) (#278)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-29 20:24:14 +00:00
coah
d9237cdbd3 Decompile RVL SDK nup to 11/23 functions (worker 626de3f9) (#277) 2026-09-29 14:31:27 -05:00
coah
a6ac8d34d0 Decompile PrFILE2 pf fat to 22/35 functions (worker 2abecd2b) (#276) 2026-09-29 14:30:40 -05:00
coah
58b5333a4e Decompile FA sd drv to 9/26 functions (worker 1602e65a) (#275) 2026-09-29 14:29:54 -05:00
coah
64f977ea3b Decompile MyTiManager to 84/91 functions (worker 8468d303) (#274) 2026-09-29 14:29:06 -05:00
coah
daf758ece1 Decompile AOSS to 7/21 functions (worker 5f0c95f9) (#273) 2026-09-29 10:34:38 -05:00
coah
6cdbe274bd pf_path: 25/27 functions (worker 7cc9ade3) (#272) 2026-09-29 10:27:18 -05:00
coah
2e63974b0c Decompile PrFILE2 pf_path to 24/27 functions (worker 7e56cc66) (#271) 2026-09-29 10:00:22 -05:00
coah
1c419b67a1 Decompile RVL SDK vi to 18/30 functions (worker 3a89b7c7) (#270) 2026-09-29 09:26:03 -05:00
devin-ai-integration[bot]
07459f685a nhttp: link 8 matched units (bgnend, control, list, os_RVL, request, response, d_nhttp, d_nhttp_common) (#269)
Co-authored-by: devin <devin@cognition.ai>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-29 14:08:45 +00:00
coah
3b93fc8664 iplSDChannelSelect: 90/129 functions (worker 9a63deb2) (#268) 2026-09-29 08:54:49 -05:00
coah
7f627435b5 Decompile ATERM to 3/26 functions plus its data (worker af65e648) (#267) 2026-09-29 08:50:37 -05:00
coah
74f1719bfd iplSDChannelSelect: 89/129 functions (worker f62627b8) (#266) 2026-09-29 08:17:16 -05:00
coah
506535db40 pf_file: 32/45 functions (worker 99e93149) (#265) 2026-09-29 06:13:58 -05:00
coah
2a4e4f85ed iplSetting: 88/112 functions (worker 77873dae) (#264) 2026-09-29 05:57:26 -05:00
coah
4402bd99a8 pf_file: 31/45 functions (worker 44d9c236) (#263) 2026-09-29 05:38:18 -05:00
coah
44f42d98ed pf_volume: 7/37 functions (worker 5930b324) (#262) 2026-09-29 04:57:07 -05:00
coah
db27a09ea3 iplSDMemory: 49/66 functions (worker ba5a48eb) (#261) 2026-09-29 04:39:51 -05:00
coah
c21dcc3d31 iplSDMemory: 48/66 functions (#260)
* sdmemory: carry over worker delta (sd channel select header changes left out)

* add SDChannelSelect state/worker accessors used by iplSDMemory
2026-09-29 04:21:39 -05:00
99 changed files with 39855 additions and 908 deletions

62
.github/workflows/readme-progress.yml vendored Normal file
View File

@@ -0,0 +1,62 @@
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.
on:
push:
branches: [main]
paths-ignore: [README.md]
schedule:
- cron: "*/30 * * * *"
workflow_dispatch:
concurrency:
group: readme-progress
cancel-in-progress: true
permissions:
contents: write
jobs:
progress:
runs-on: [self-hosted, wii-ipl-local]
timeout-minutes: 60
env:
ORIG_APP: /mnt/drive2/projects/wiichannels/wii-ipl/orig/43U/00000008.app
TOOL_CACHE: /mnt/drive2/projects/wiichannels/wii-ipl/build
NINJA: /home/cole/projects/tests/.venv/bin/ninja
steps:
- name: Checkout
uses: actions/checkout@v4
with:
ref: main
fetch-depth: 1
- name: Prepare
run: |
mkdir -p build orig/43U
cp "$ORIG_APP" orig/43U/00000008.app
[ -d build/compilers ] || cp -a "$TOOL_CACHE/compilers" build/
[ -d build/tools ] || cp -a "$TOOL_CACHE/tools" build/
- name: Build
run: |
python3 configure.py --version 43U
"$NINJA"
"$NINJA" build/43U/ok
- name: Report
run: build/tools/objdiff-cli report generate -p . -o build/43U/report.json -f json
- name: Update README
run: python3 tools/update_readme_progress.py build/43U/report.json README.md "$GITHUB_SHA"
- name: Commit
run: |
if git diff --quiet README.md; then exit 0; fi
git config user.name "github-actions[bot]"
git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
git add README.md
git commit -m "docs: update progress [skip ci]"
git pull --rebase origin main || { git rebase --abort; echo "main moved, next run will update"; exit 0; }
git push origin HEAD:main

View File

@@ -50,6 +50,16 @@ Supported versions:
Progress
========
<!-- progress:start -->
| Decompiled | Matched | Linked | Data |
|:---:|:---:|:---:|:---:|
| 80.98% | 72.11% | 56.76% | 86.16% |
units 748/1027 complete, functions 10570/12563 matched. updated 2026-09-29 22:58 UTC from `test` by the self-hosted progress job
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] |

View File

@@ -4596,21 +4596,21 @@ updateChannelNotices__Q33ipl5scene15SDChannelSelectFii = .text:0x813DC7EC; // ty
processWorkerState__Q33ipl5scene15SDChannelSelectFv = .text:0x813DC938; // type:function size:0x18C
updateDialogAnimation__Q33ipl5scene15SDChannelSelectFv = .text:0x813DCAC4; // type:function size:0x42C
setDialogMessage__Q33ipl5scene15SDChannelSelectFUlUl = .text:0x813DCEF0; // type:function size:0x24
iplSDChannelSelect_813DCF14 = .text:0x813DCF14; // type:function size:0xCC
iplSDChannelSelect_813DCFE0 = .text:0x813DCFE0; // type:function size:0xCC
iplSDChannelSelect_813DD0AC = .text:0x813DD0AC; // type:function size:0x194
iplSDChannelSelect_813DD240 = .text:0x813DD240; // type:function size:0x198
iplSDChannelSelect_813DD3D8 = .text:0x813DD3D8; // type:function size:0x1F8
iplSDChannelSelect_813DD5D0 = .text:0x813DD5D0; // type:function size:0x5A4
iplSDChannelSelect_813DDB74 = .text:0x813DDB74; // type:function size:0x40
iplSDChannelSelect_813DDBB4 = .text:0x813DDBB4; // type:function size:0xB4
iplSDChannelSelect_813DDC68 = .text:0x813DDC68; // type:function size:0x18
iplSDChannelSelect_813DDC80 = .text:0x813DDC80; // type:function size:0x58
iplSDChannelSelect_813DDCD8 = .text:0x813DDCD8; // type:function size:0x8C
iplSDChannelSelect_813DDD64 = .text:0x813DDD64; // type:function size:0x58
iplSDChannelSelect_813DDDBC = .text:0x813DDDBC; // type:function size:0x5C
iplSDChannelSelect_813DDE18 = .text:0x813DDE18; // type:function size:0x2C
iplSDChannelSelect_813DDE44 = .text:0x813DDE44; // type:function size:0x24
isCurrentTitleUsageEnough__Q33ipl5scene15SDChannelSelectCFPCl = .text:0x813DCF14; // type:function size:0xCC
getCurrentTitleUsage__Q33ipl5scene15SDChannelSelectCFPlPl = .text:0x813DCFE0; // type:function size:0xCC
collectTitlesByUsage__Q33ipl5scene15SDChannelSelectFPClPClPUxPcPUl = .text:0x813DD0AC; // type:function size:0x194
collectTitlesFromNandUsage__Q33ipl5scene15SDChannelSelectFPClPClPUxPcPUl = .text:0x813DD240; // type:function size:0x198
collectTitlesByChannelOrder__Q33ipl5scene15SDChannelSelectFPClPClPUxPcPUl = .text:0x813DD3D8; // type:function size:0x1F8
collectTitlesBySpecialChannels__Q33ipl5scene15SDChannelSelectFPClPClPUxPcPUl = .text:0x813DD5D0; // type:function size:0x5A4
collectTitlesForMode__Q33ipl5scene15SDChannelSelectFPClPClPUxPcPUli = .text:0x813DDB74; // type:function size:0x40
findAdjacentChannel__Q33ipl5scene15SDChannelSelectCFiPiPi = .text:0x813DDBB4; // type:function size:0xB4
setCurrentPageAndRefresh__Q33ipl5scene15SDChannelSelectFiiPQ33ipl5scene12SDChannelObj = .text:0x813DDC68; // type:function size:0x18
handleFourPageDialog__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDC80; // type:function size:0x58
flushSaveDataAndMountSD__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDCD8; // type:function size:0x8C
handleThreePageDialog__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDD64; // type:function size:0x58
finishCardDialog__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDDBC; // type:function size:0x5C
finishDialogOperation__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDE18; // type:function size:0x2C
finishDialogTransition__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDE44; // type:function size:0x24
isResetProcessDone__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDE68; // type:function size:0x28
calcCommon__Q33ipl5scene15SDChannelSelectFv = .text:0x813DDE90; // type:function size:0x1B0
calcFadein__Q33ipl5scene15SDChannelSelectFv = .text:0x813DE040; // type:function size:0x30
@@ -4623,60 +4623,60 @@ createBaseLayout__Q33ipl5scene15SDChannelSelectFv = .text:0x813DE9FC; // type:fu
updateChannelObjects__Q33ipl5scene15SDChannelSelectFv = .text:0x813DEE3C; // type:function size:0x5C
updateChannelObject__Q33ipl5scene15SDChannelSelectFPQ33ipl5scene12SDChannelObj = .text:0x813DEE98; // type:function size:0x78
calcChannelObjects__Q33ipl5scene15SDChannelSelectFv = .text:0x813DEF10; // type:function size:0x58
iplSDChannelSelect_813DEF68 = .text:0x813DEF68; // type:function size:0x27C
iplSDChannelSelect_813DF1E4 = .text:0x813DF1E4; // type:function size:0x14
drawChannelTransitionObjects__Q33ipl5scene15SDChannelSelectFv = .text:0x813DEF68; // type:function size:0x27C
isChannelReady__Q33ipl5scene15SDChannelSelectFPCQ33ipl5scene12SDChannelObj = .text:0x813DF1E4; // type:function size:0x14
drawChannelObjects__Q33ipl5scene15SDChannelSelectFv = .text:0x813DF1F8; // type:function size:0xB0
iplSDChannelSelect_813DF2A8 = .text:0x813DF2A8; // type:function size:0x138
iplSDChannelSelect_813DF3E0 = .text:0x813DF3E0; // type:function size:0x1C
iplSDChannelSelect_813DF3FC = .text:0x813DF3FC; // type:function size:0x110
iplSDChannelSelect_813DF50C = .text:0x813DF50C; // type:function size:0x4C
iplSDChannelSelect_813DF558 = .text:0x813DF558; // type:function size:0x178
iplSDChannelSelect_813DF6D0 = .text:0x813DF6D0; // type:function size:0x164
processNormalInput__Q33ipl5scene15SDChannelSelectFv = .text:0x813DF2A8; // type:function size:0x138
setPageActionFrame__Q33ipl5scene15SDChannelSelectFv = .text:0x813DF3E0; // type:function size:0x1C
finishPageScroll__Q33ipl5scene15SDChannelSelectFv = .text:0x813DF3FC; // type:function size:0x110
advancePageAnimation__Q33ipl5scene15SDChannelSelectFv = .text:0x813DF50C; // type:function size:0x4C
initializeNormalPage__Q33ipl5scene15SDChannelSelectFv = .text:0x813DF558; // type:function size:0x178
refreshPageObjects__Q33ipl5scene15SDChannelSelectFiPQ33ipl5scene12SDChannelObji = .text:0x813DF6D0; // type:function size:0x164
createChannelList__Q33ipl5scene15SDChannelSelectFib = .text:0x813DF834; // type:function size:0x110
createChannelObject__Q33ipl5scene15SDChannelSelectFii = .text:0x813DF944; // type:function size:0x84
destroyUnusedChannelObjects__Q33ipl5scene15SDChannelSelectFiPQ33ipl5scene12SDChannelObj = .text:0x813DF9C8; // type:function size:0xF8
refreshChannelList__Q33ipl5scene15SDChannelSelectFv = .text:0x813DFAC0; // type:function size:0xFC
refreshAfterSDTitleList__Q33ipl5scene15SDChannelSelectFv = .text:0x813DFBBC; // type:function size:0xE4
destroyChannelObject__Q33ipl5scene15SDChannelSelectFPQ33ipl5scene12SDChannelObj = .text:0x813DFCA0; // type:function size:0x50
iplSDChannelSelect_813DFCF0 = .text:0x813DFCF0; // type:function size:0x74
iplSDChannelSelect_813DFD64 = .text:0x813DFD64; // type:function size:0x154
updateChannelObjectOrder__Q33ipl5scene15SDChannelSelectFi = .text:0x813DFCF0; // type:function size:0x74
moveChannelObjectsToDrawOrder__Q33ipl5scene15SDChannelSelectFii = .text:0x813DFD64; // type:function size:0x154
findChannelObject__Q33ipl5scene15SDChannelSelectCFii = .text:0x813DFEB8; // type:function size:0x74
iplSDChannelSelect_813DFF2C = .text:0x813DFF2C; // type:function size:0x1C0
updateArrowVisibility__Q33ipl5scene15SDChannelSelectFv = .text:0x813DFF2C; // type:function size:0x1C0
hasChannelObject__Q33ipl5scene15SDChannelSelectCFii = .text:0x813E00EC; // type:function size:0x140
isChannelInCalc__Q33ipl5scene15SDChannelSelectCFiii = .text:0x813E022C; // type:function size:0x68
iplSDChannelSelect_813E0294 = .text:0x813E0294; // type:function size:0x104
iplSDChannelSelect_813E0398 = .text:0x813E0398; // type:function size:0x18
iplSDChannelSelect_813E03B0 = .text:0x813E03B0; // type:function size:0xA0
iplSDChannelSelect_813E0450 = .text:0x813E0450; // type:function size:0xEC
iplSDChannelSelect_813E053C = .text:0x813E053C; // type:function size:0x84
iplSDChannelSelect_813E05C0 = .text:0x813E05C0; // type:function size:0x64
iplSDChannelSelect_813E0624 = .text:0x813E0624; // type:function size:0xB4
isPageCreated__Q33ipl5scene15SDChannelSelectCFi = .text:0x813E0294; // type:function size:0x104
setStateAndPlaySelectSound__Q33ipl5scene15SDChannelSelectFi = .text:0x813E0398; // type:function size:0x18
setLayoutFrame__Q33ipl5scene15SDChannelSelectFi = .text:0x813E03B0; // type:function size:0xA0
selectChannel__Q33ipl5scene15SDChannelSelectFii = .text:0x813E0450; // type:function size:0xEC
tellStartingZoomAnm__Q33ipl5scene15SDChannelSelectFv = .text:0x813E053C; // type:function size:0x84
prepareRestarting__Q33ipl5scene15SDChannelSelectFi = .text:0x813E05C0; // type:function size:0x64
startPageTransition__Q33ipl5scene15SDChannelSelectFii = .text:0x813E0624; // type:function size:0xB4
getChannelBasePane__Q33ipl5scene15SDChannelSelectCFiii = .text:0x813E06D8; // type:function size:0xAC
getCenterChannelPane__Q33ipl5scene15SDChannelSelectCFi = .text:0x813E0784; // type:function size:0x30
getChannelPane__Q33ipl5scene15SDChannelSelectCFi = .text:0x813E07B4; // type:function size:0x30
getChannelPanePosition__Q33ipl5scene15SDChannelSelectFPQ33ipl5scene15SDChannelSelecti = .text:0x813E07E4; // type:function size:0x64
iplSDChannelSelect_813E0848 = .text:0x813E0848; // type:function size:0x3A4
iplSDChannelSelect_813E0BEC = .text:0x813E0BEC; // type:function size:0x294
setChannelScissor__Q33ipl5scene15SDChannelSelectCFPCQ33ipl5scene12SDChannelObj = .text:0x813E0848; // type:function size:0x3A4
initPageAnimations__Q33ipl5scene15SDChannelSelectFRCQ33ipl4math4VEC3i = .text:0x813E0BEC; // type:function size:0x294
calcPageAnimations__Q33ipl5scene15SDChannelSelectFv = .text:0x813E0E80; // type:function size:0x60
iplSDChannelSelect_813E0EE0 = .text:0x813E0EE0; // type:function size:0x26C
iplSDChannelSelect_813E114C = .text:0x813E114C; // type:function size:0x78
iplSDChannelSelect_813E11C4 = .text:0x813E11C4; // type:function size:0x3A4
iplSDChannelSelect_813E1568 = .text:0x813E1568; // type:function size:0x124
iplSDChannelSelect_813E168C = .text:0x813E168C; // type:function size:0x2D0
iplSDChannelSelect_813E195C = .text:0x813E195C; // type:function size:0x6C
iplSDChannelSelect_813E19C8 = .text:0x813E19C8; // type:function size:0x68
iplSDChannelSelect_813E1A30 = .text:0x813E1A30; // type:function size:0x208
iplSDChannelSelect_813E1C38 = .text:0x813E1C38; // type:function size:0x118
iplSDChannelSelect_813E1D50 = .text:0x813E1D50; // type:function size:0xFC
iplSDChannelSelect_813E1E4C = .text:0x813E1E4C; // type:function size:0x19C
iplSDChannelSelect_813E1FE8 = .text:0x813E1FE8; // type:function size:0x1A4
iplSDChannelSelect_813E218C = .text:0x813E218C; // type:function size:0x16C
iplSDChannelSelect_813E22F8 = .text:0x813E22F8; // type:function size:0x1E0
iplSDChannelSelect_813E24D8 = .text:0x813E24D8; // type:function size:0x204
iplSDChannelSelect_813E26DC = .text:0x813E26DC; // type:function size:0x74
iplSDChannelSelect_813E2750 = .text:0x813E2750; // type:function size:0x164
iplSDChannelSelect_813E28B4 = .text:0x813E28B4; // type:function size:0x2A0
iplSDChannelSelect_813E2B54 = .text:0x813E2B54; // type:function size:0x240
updatePageTransform__Q33ipl5scene15SDChannelSelectFv = .text:0x813E0EE0; // type:function size:0x26C
getCenterChannelIndex__Q33ipl5scene15SDChannelSelectCFPCc = .text:0x813E114C; // type:function size:0x78
createSceneLayouts__Q33ipl5scene15SDChannelSelectFv = .text:0x813E11C4; // type:function size:0x3A4
updateDragState__Q33ipl5scene15SDChannelSelectFv = .text:0x813E1568; // type:function size:0x124
updateDragPageTransition__Q33ipl5scene15SDChannelSelectFv = .text:0x813E168C; // type:function size:0x2D0
finishDragWait__Q33ipl5scene15SDChannelSelectFv = .text:0x813E195C; // type:function size:0x6C
finishDragPageTransition__Q33ipl5scene15SDChannelSelectFv = .text:0x813E19C8; // type:function size:0x68
applyChannelMove__Q33ipl5scene15SDChannelSelectFv = .text:0x813E1A30; // type:function size:0x208
finishChannelMove__Q33ipl5scene15SDChannelSelectFv = .text:0x813E1C38; // type:function size:0x118
resetDragPreview__Q33ipl5scene15SDChannelSelectFv = .text:0x813E1D50; // type:function size:0xFC
finishDragPageChange__Q33ipl5scene15SDChannelSelectFv = .text:0x813E1E4C; // type:function size:0x19C
onEventDerived__Q33ipl5scene15SDChannelSelectFPCcUlPQ33ipl10controller9Interface = .text:0x813E1FE8; // type:function size:0x1A4
onButtonEvent__Q33ipl5scene15SDChannelSelectFPCcUlPCQ33ipl10controller9Interface = .text:0x813E218C; // type:function size:0x16C
startDrag__Q33ipl5scene15SDChannelSelectFPCQ33ipl10controller9Interfaceii = .text:0x813E22F8; // type:function size:0x1E0
finishDrag__Q33ipl5scene15SDChannelSelectFv = .text:0x813E24D8; // type:function size:0x204
isChannelMoveTarget__Q33ipl5scene15SDChannelSelectCFii = .text:0x813E26DC; // type:function size:0x74
moveDrag__Q33ipl5scene15SDChannelSelectFv = .text:0x813E2750; // type:function size:0x164
onEvent__Q43ipl5scene32@unnamed@iplSDChannelSelect_cpp@27SDChannelSelectEventHandlerFUlUlPv = .text:0x813E28B4; // type:function size:0x2A0
onEventDerived__Q43ipl5scene32@unnamed@iplSDChannelSelect_cpp@33SDChannelSelectButtonEventHandlerFUlUlPCQ33ipl10controller9Interface = .text:0x813E2B54; // type:function size:0x240
startResetting__Q33ipl5scene15SDChannelSelectFv = .text:0x813E2D94; // type:function size:0x44
pop__Q33ipl5scene26SDChannelSelectNoticeQueueFv = .text:0x813E2DD8; // type:function size:0x4C
push__Q33ipl5scene27SDChannelSelectCommandQueueFRCQ33ipl5scene22SDChannelSelectCommand = .text:0x813E2E24; // type:function size:0x80
@@ -4694,7 +4694,7 @@ iplSDChannelObj_813E322C = .text:0x813E322C; // type:function size:0x9C
iplSDChannelObj_813E32C8 = .text:0x813E32C8; // type:function size:0x3C
iplSDChannelObj_813E3304 = .text:0x813E3304; // type:function size:0x8
iplSDChannelObj_813E330C = .text:0x813E330C; // type:function size:0x14
iplSDChannelObj_813E3320 = .text:0x813E3320; // type:function size:0x10
getTranslate__Q33ipl5scene12SDChannelObjCFv = .text:0x813E3320; // type:function size:0x10
iplSDChannelObj_813E3330 = .text:0x813E3330; // type:function size:0x24
iplSDChannelObj_813E3354 = .text:0x813E3354; // type:function size:0x98
iplSDChannelObj_813E33EC = .text:0x813E33EC; // type:function size:0x94
@@ -4837,7 +4837,7 @@ onEvent__Q33ipl5scene22SDMenuEventHandlerBaseFUlUlPv = .text:0x813EB51C; // type
onEventDerived__Q33ipl5scene22SDMenuEventHandlerBaseFUlUlPCQ33ipl10controller9Interface = .text:0x813EB5E8; // type:function size:0x4
__ct__Q33ipl5scene8SDMemoryFv = .text:0x813EB5EC; // type:function size:0x48
__dt__Q33ipl5scene8SDMemoryFv = .text:0x813EB634; // type:function size:0x5C
create__Q33ipl5scene8SDMemoryFPQ23EGG4HeapPQ33ipl4nand10LayoutFilePQ33ipl5scene17NandSDCardManager = .text:0x813EB690; // type:function size:0x10A0
create__Q33ipl5scene8SDMemoryFPQ23EGG4HeapPQ33ipl4nand10LayoutFilePQ33ipl5scene15SDChannelSelect = .text:0x813EB690; // type:function size:0x10A0
setTitleLists__Q33ipl5scene8SDMemoryFRCQ43ipl5scene8SDMemory10TitleRangeRCQ43ipl5scene8SDMemory10TitleRange = .text:0x813EC730; // type:function size:0xD4
setScrollLimit__Q33ipl5scene8SDMemoryFv = .text:0x813EC804; // type:function size:0x144
init__Q33ipl7utility8ScrollerFv = .text:0x813EC948; // type:function size:0x20
@@ -4879,28 +4879,28 @@ onDialogState21__Q33ipl5scene8SDMemoryFv = .text:0x813EEB94; // type:function si
onDialogState22__Q33ipl5scene8SDMemoryFv = .text:0x813EECDC; // type:function size:0x11C
onDialogState23__Q33ipl5scene8SDMemoryFv = .text:0x813EEDF8; // type:function size:0x78
onDialogState24__Q33ipl5scene8SDMemoryFv = .text:0x813EEE70; // type:function size:0xC0
iplSDMemory_813EEF30 = .text:0x813EEF30; // type:function size:0x88
iplSDMemory_813EEFB8 = .text:0x813EEFB8; // type:function size:0x70C
draw__Q33ipl5scene8SDMemoryFv = .text:0x813EEF30; // type:function size:0x88
drawTransferTitles__Q33ipl5scene8SDMemoryFv = .text:0x813EEFB8; // type:function size:0x70C
writeFourFlagBytes__Q23ipl5sceneFPUcUcUcUcUc = .text:0x813EF6C4; // type:function size:0x14
iplSDMemory_813EF6D8 = .text:0x813EF6D8; // type:function size:0x48
setTitleRowColors__Q23ipl5sceneFPQ34nw4r3lyt7TextBoxRCQ34nw4r2ut5ColorRCQ34nw4r2ut5Color = .text:0x813EF6D8; // type:function size:0x48
GetBeginIter__Q34nw4r2ut28LinkList<Q34nw4r3lyt4Pane,4>Fv = .text:0x813EF720; // type:function size:0x8
iplSDMemory_813EF728 = .text:0x813EF728; // type:function size:0x8
GetEndIter__Q34nw4r2ut28LinkList<Q34nw4r3lyt4Pane,4>Fv = .text:0x813EF728; // type:function size:0x8
__ne__Q24nw4r2utFQ44nw4r2ut28LinkList<Q34nw4r3lyt4Pane,4>8IteratorQ44nw4r2ut28LinkList<Q34nw4r3lyt4Pane,4>8Iterator = .text:0x813EF730; // type:function size:0x18
getControlPaneIndex__Q33ipl5scene8SDMemoryFPCc = .text:0x813EF748; // type:function size:0x74
iplSDMemory_813EF7BC = .text:0x813EF7BC; // type:function size:0x128
iplSDMemory_813EF8E4 = .text:0x813EF8E4; // type:function size:0xF0
iplSDMemory_813EF9D4 = .text:0x813EF9D4; // type:function size:0x120
iplSDMemory_813EFAF4 = .text:0x813EFAF4; // type:function size:0xD8
iplSDMemory_813EFBCC = .text:0x813EFBCC; // type:function size:0xC0
iplSDMemory_813EFC8C = .text:0x813EFC8C; // type:function size:0x160
iplSDMemory_813EFDEC = .text:0x813EFDEC; // type:function size:0x128
iplSDMemory_813EFF14 = .text:0x813EFF14; // type:function size:0x24C
iplSDMemory_813F0160 = .text:0x813F0160; // type:function size:0xD8
iplSDMemory_813F0238 = .text:0x813F0238; // type:function size:0x74
iplSDMemory_813F02AC = .text:0x813F02AC; // type:function size:0x144
iplSDMemory_813F03F0 = .text:0x813F03F0; // type:function size:0x10C
iplSDMemory_813F04FC = .text:0x813F04FC; // type:function size:0x1A0
iplSDMemory_813F069C = .text:0x813F069C; // type:function size:0xD8
activateControlPane__Q33ipl5scene8SDMemoryFPCcPQ23gui9Component = .text:0x813EF7BC; // type:function size:0x128
deactivateControlPane__Q33ipl5scene8SDMemoryFPCc = .text:0x813EF8E4; // type:function size:0xF0
cancelControlPane__Q33ipl5scene8SDMemoryFPCc = .text:0x813EF9D4; // type:function size:0x120
onEvent__Q43ipl5scene8SDMemory23ControlPaneEventHandlerFUlUlPv = .text:0x813EFAF4; // type:function size:0xD8
getTitlePaneIndex__Q33ipl5scene8SDMemoryFPCc = .text:0x813EFBCC; // type:function size:0xC0
activateTitlePane__Q33ipl5scene8SDMemoryFPCcPQ23gui9Component = .text:0x813EFC8C; // type:function size:0x160
deactivateTitlePane__Q33ipl5scene8SDMemoryFPCc = .text:0x813EFDEC; // type:function size:0x128
selectTitlePane__Q33ipl5scene8SDMemoryFPCc = .text:0x813EFF14; // type:function size:0x24C
onEvent__Q43ipl5scene8SDMemory21TitlePaneEventHandlerFUlUlPv = .text:0x813F0160; // type:function size:0xD8
getDialogPaneIndex__Q33ipl5scene8SDMemoryFPCc = .text:0x813F0238; // type:function size:0x74
activateDialogPane__Q33ipl5scene8SDMemoryFPCcPQ23gui9Component = .text:0x813F02AC; // type:function size:0x144
deactivateDialogPane__Q33ipl5scene8SDMemoryFPCc = .text:0x813F03F0; // type:function size:0x10C
selectDialogPane__Q33ipl5scene8SDMemoryFPCc = .text:0x813F04FC; // type:function size:0x1A0
onEvent__Q43ipl5scene8SDMemory22DialogPaneEventHandlerFUlUlPv = .text:0x813F069C; // type:function size:0xD8
__ct__Q33ipl5scene7SettingFPQ23EGG4Heapi = .text:0x813F0774; // type:function size:0xF8
isAnimating__Q33ipl5scene7SettingFv = .text:0x813F086C; // type:function size:0x3C
getFuncMsgQ__Q33ipl5scene7SettingFv = .text:0x813F08A8; // type:function size:0x68
@@ -16752,73 +16752,73 @@ __vt__Q33ipl5scene14ParentalDialog = .data:0x81653ED8; // type:object size:0x68
@10007 = .data:0x81653FD8; // type:object size:0xE scope:local data:string
__vt__Q33ipl5scene6Reboot = .data:0x81653FE8; // type:object size:0x4C
__vt__Q33ipl5scene9RootScene = .data:0x81654038; // type:object size:0x4C
lbl_81654088 = .data:0x81654088; // type:object size:0x9 data:string
lbl_81654091 = .data:0x81654091; // type:object size:0x9 data:string
lbl_8165409A = .data:0x8165409A; // type:object size:0x9 data:string
lbl_816540A3 = .data:0x816540A3; // type:object size:0x9 data:string
lbl_816540AC = .data:0x816540AC; // type:object size:0x9 data:string
lbl_816540B5 = .data:0x816540B5; // type:object size:0x9 data:string
lbl_816540BE = .data:0x816540BE; // type:object size:0x9 data:string
lbl_816540C7 = .data:0x816540C7; // type:object size:0x9 data:string
lbl_816540D0 = .data:0x816540D0; // type:object size:0x9 data:string
lbl_816540D9 = .data:0x816540D9; // type:object size:0x9 data:string
lbl_816540E2 = .data:0x816540E2; // type:object size:0x9 data:string
lbl_816540EB = .data:0x816540EB; // type:object size:0x9 data:string
lbl_816540F4 = .data:0x816540F4; // type:object size:0x9 data:string
lbl_816540FD = .data:0x816540FD; // type:object size:0x9 data:string
lbl_81654106 = .data:0x81654106; // type:object size:0x9 data:string
lbl_8165410F = .data:0x8165410F; // type:object size:0x9 data:string
lbl_81654118 = .data:0x81654118; // type:object size:0x9 data:string
lbl_81654121 = .data:0x81654121; // type:object size:0x9 data:string
lbl_8165412A = .data:0x8165412A; // type:object size:0x9 data:string
lbl_81654133 = .data:0x81654133; // type:object size:0x9 data:string
lbl_8165413C = .data:0x8165413C; // type:object size:0x9 data:string
lbl_81654145 = .data:0x81654145; // type:object size:0x9 data:string
lbl_8165414E = .data:0x8165414E; // type:object size:0x9 data:string
lbl_81654157 = .data:0x81654157; // type:object size:0x9 data:string
lbl_81654160 = .data:0x81654160; // type:object size:0x9 data:string
lbl_81654169 = .data:0x81654169; // type:object size:0x9 data:string
lbl_81654172 = .data:0x81654172; // type:object size:0x9 data:string
lbl_8165417B = .data:0x8165417B; // type:object size:0x9 data:string
lbl_81654184 = .data:0x81654184; // type:object size:0x9 data:string
lbl_8165418D = .data:0x8165418D; // type:object size:0x9 data:string
lbl_81654196 = .data:0x81654196; // type:object size:0x9 data:string
lbl_8165419F = .data:0x8165419F; // type:object size:0x9 data:string
lbl_816541A8 = .data:0x816541A8; // type:object size:0x9 data:string
lbl_816541B1 = .data:0x816541B1; // type:object size:0x9 data:string
lbl_816541BA = .data:0x816541BA; // type:object size:0x9 data:string
lbl_816541C3 = .data:0x816541C3; // type:object size:0x9 data:string
lbl_816541CC = .data:0x816541CC; // type:object size:0x9 data:string
lbl_816541D5 = .data:0x816541D5; // type:object size:0x9 data:string
lbl_816541DE = .data:0x816541DE; // type:object size:0x9 data:string
lbl_816541E7 = .data:0x816541E7; // type:object size:0x9 data:string
lbl_816541F0 = .data:0x816541F0; // type:object size:0x9 data:string
lbl_816541F9 = .data:0x816541F9; // type:object size:0x9 data:string
@16632 = .data:0x81654088; // type:object size:0x9 scope:local data:string
@16633 = .data:0x81654091; // type:object size:0x9 scope:local data:string
@16634 = .data:0x8165409A; // type:object size:0x9 scope:local data:string
@16635 = .data:0x816540A3; // type:object size:0x9 scope:local data:string
@16636 = .data:0x816540AC; // type:object size:0x9 scope:local data:string
@16637 = .data:0x816540B5; // type:object size:0x9 scope:local data:string
@16638 = .data:0x816540BE; // type:object size:0x9 scope:local data:string
@16639 = .data:0x816540C7; // type:object size:0x9 scope:local data:string
@16640 = .data:0x816540D0; // type:object size:0x9 scope:local data:string
@16641 = .data:0x816540D9; // type:object size:0x9 scope:local data:string
@16642 = .data:0x816540E2; // type:object size:0x9 scope:local data:string
@16643 = .data:0x816540EB; // type:object size:0x9 scope:local data:string
@16644 = .data:0x816540F4; // type:object size:0x9 scope:local data:string
@16645 = .data:0x816540FD; // type:object size:0x9 scope:local data:string
@16646 = .data:0x81654106; // type:object size:0x9 scope:local data:string
@16647 = .data:0x8165410F; // type:object size:0x9 scope:local data:string
@16648 = .data:0x81654118; // type:object size:0x9 scope:local data:string
@16649 = .data:0x81654121; // type:object size:0x9 scope:local data:string
@16650 = .data:0x8165412A; // type:object size:0x9 scope:local data:string
@16651 = .data:0x81654133; // type:object size:0x9 scope:local data:string
@16652 = .data:0x8165413C; // type:object size:0x9 scope:local data:string
@16653 = .data:0x81654145; // type:object size:0x9 scope:local data:string
@16654 = .data:0x8165414E; // type:object size:0x9 scope:local data:string
@16655 = .data:0x81654157; // type:object size:0x9 scope:local data:string
@16656 = .data:0x81654160; // type:object size:0x9 scope:local data:string
@16657 = .data:0x81654169; // type:object size:0x9 scope:local data:string
@16658 = .data:0x81654172; // type:object size:0x9 scope:local data:string
@16659 = .data:0x8165417B; // type:object size:0x9 scope:local data:string
@16660 = .data:0x81654184; // type:object size:0x9 scope:local data:string
@16661 = .data:0x8165418D; // type:object size:0x9 scope:local data:string
@16662 = .data:0x81654196; // type:object size:0x9 scope:local data:string
@16663 = .data:0x8165419F; // type:object size:0x9 scope:local data:string
@16664 = .data:0x816541A8; // type:object size:0x9 scope:local data:string
@16665 = .data:0x816541B1; // type:object size:0x9 scope:local data:string
@16666 = .data:0x816541BA; // type:object size:0x9 scope:local data:string
@16667 = .data:0x816541C3; // type:object size:0x9 scope:local data:string
@16668 = .data:0x816541CC; // type:object size:0x9 scope:local data:string
@16669 = .data:0x816541D5; // type:object size:0x9 scope:local data:string
@16670 = .data:0x816541DE; // type:object size:0x9 scope:local data:string
@16671 = .data:0x816541E7; // type:object size:0x9 scope:local data:string
@16672 = .data:0x816541F0; // type:object size:0x9 scope:local data:string
@16673 = .data:0x816541F9; // type:object size:0x9 scope:local data:string
lbl_81654204 = .data:0x81654204; // type:object size:0xF0
lbl_816542F4 = .data:0x816542F4; // type:object size:0xA data:string
lbl_816542FE = .data:0x816542FE; // type:object size:0xA data:string
lbl_81654308 = .data:0x81654308; // type:object size:0xA data:string
lbl_81654312 = .data:0x81654312; // type:object size:0xA data:string
@16674 = .data:0x816542F4; // type:object size:0xA scope:local data:string
@16675 = .data:0x816542FE; // type:object size:0xA scope:local data:string
@16676 = .data:0x81654308; // type:object size:0xA scope:local data:string
@16677 = .data:0x81654312; // type:object size:0xA scope:local data:string
lbl_8165431C = .data:0x8165431C; // type:object size:0x20
lbl_8165433C = .data:0x8165433C; // type:object size:0xB data:string
lbl_81654347 = .data:0x81654347; // type:object size:0xB data:string
lbl_81654352 = .data:0x81654352; // type:object size:0xB data:string
lbl_8165435D = .data:0x8165435D; // type:object size:0xB data:string
@16679 = .data:0x8165433C; // type:object size:0xB scope:local data:string
@16680 = .data:0x81654347; // type:object size:0xB scope:local data:string
@16681 = .data:0x81654352; // type:object size:0xB scope:local data:string
@16682 = .data:0x8165435D; // type:object size:0xB scope:local data:string
lbl_81654368 = .data:0x81654368; // type:object size:0x20
lbl_81654388 = .data:0x81654388; // type:object size:0x14 data:4byte
lbl_8165439C = .data:0x8165439C; // type:object size:0x70
lbl_8165440C = .data:0x8165440C; // type:object size:0x54
lbl_81654460 = .data:0x81654460; // type:object size:0x9 data:string
lbl_81654469 = .data:0x81654469; // type:object size:0x9 data:string
sFourPageDialogPages__Q23ipl5scene = .data:0x8165439C; // type:object size:0x70
sThreePageDialogPages__Q23ipl5scene = .data:0x8165440C; // type:object size:0x54
@16689 = .data:0x81654460; // type:object size:0x9 scope:local data:string
@16690 = .data:0x81654469; // type:object size:0x9 scope:local data:string
lbl_81654472 = .data:0x81654472; // type:object size:0x16
lbl_81654488 = .data:0x81654488; // type:object size:0xE data:string
lbl_81654496 = .data:0x81654496; // type:object size:0x11 data:string
lbl_816544A7 = .data:0x816544A7; // type:object size:0x19 data:string
lbl_816544C0 = .data:0x816544C0; // type:object size:0x1B data:string
@24438 = .data:0x81654488; // type:object size:0xE scope:local data:string
@24439 = .data:0x81654496; // type:object size:0x11 scope:local data:string
@24489 = .data:0x816544A7; // type:object size:0x19 scope:local data:string
@24490 = .data:0x816544C0; // type:object size:0x1B scope:local data:string
jumptable_816544DC = .data:0x816544DC; // type:object size:0x38 scope:local
jumptable_81654514 = .data:0x81654514; // type:object size:0x40 scope:local
lbl_81654554 = .data:0x81654554; // type:object size:0xB data:string
lbl_8165455F = .data:0x8165455F; // type:object size:0xE data:string
@24961 = .data:0x81654554; // type:object size:0xB scope:local data:string
@24962 = .data:0x8165455F; // type:object size:0xE scope:local data:string
jumptable_81654570 = .data:0x81654570; // type:object size:0x3C scope:local
jumptable_816545AC = .data:0x816545AC; // type:object size:0x40 scope:local
jumptable_816545EC = .data:0x816545EC; // type:object size:0x40 scope:local
@@ -16826,16 +16826,16 @@ jumptable_8165462C = .data:0x8165462C; // type:object size:0x40 scope:local
jumptable_8165466C = .data:0x8165466C; // type:object size:0x28 scope:local
jumptable_81654694 = .data:0x81654694; // type:object size:0x78 scope:local
lbl_8165473B = .data:0x8165473B; // type:object size:0xD4
lbl_8165480F = .data:0x8165480F; // type:object size:0xE data:string
lbl_8165481D = .data:0x8165481D; // type:object size:0xB data:string
lbl_81654828 = .data:0x81654828; // type:object size:0x10 data:string
@26032 = .data:0x8165480F; // type:object size:0xE scope:local data:string
@26047 = .data:0x8165481D; // type:object size:0xB scope:local data:string
@26062 = .data:0x81654828; // type:object size:0x10 scope:local data:string
lbl_81654838 = .data:0x81654838; // type:object size:0x146
lbl_8165497E = .data:0x8165497E; // type:object size:0x16 data:string
lbl_81654994 = .data:0x81654994; // type:object size:0x10 data:string
lbl_816549A4 = .data:0x816549A4; // type:object size:0xF data:string
lbl_816549B3 = .data:0x816549B3; // type:object size:0x14 data:string
lbl_816549C7 = .data:0x816549C7; // type:object size:0x10 data:string
lbl_816549D7 = .data:0x816549D7; // type:object size:0xF data:string
@26231 = .data:0x8165497E; // type:object size:0x16 scope:local data:string
@26266 = .data:0x81654994; // type:object size:0x10 scope:local data:string
@26311 = .data:0x816549A4; // type:object size:0xF scope:local data:string
@26312 = .data:0x816549B3; // type:object size:0x14 scope:local data:string
@26336 = .data:0x816549C7; // type:object size:0x10 scope:local data:string
@26559 = .data:0x816549D7; // type:object size:0xF scope:local data:string
lbl_81654A08 = .data:0x81654A08; // type:object size:0x1C
lbl_81654A24 = .data:0x81654A24; // type:object size:0x18
lbl_81654A3C = .data:0x81654A3C; // type:object size:0xFC
@@ -22014,20 +22014,20 @@ natType = .sdata:0x81696D30; // type:object size:0x4 scope:local data:4byte
@11124 = .sdata:0x81696D69; // type:object size:0x7 scope:local data:string
@11125 = .sdata:0x81696D70; // type:object size:0x7 scope:local data:string
@11250 = .sdata:0x81696D78; // type:object size:0x2 scope:local
lbl_81696D80 = .sdata:0x81696D80; // type:object size:0x1
lbl_81696D81 = .sdata:0x81696D81; // type:object size:0x6 data:string
lbl_81696D87 = .sdata:0x81696D87; // type:object size:0x6 data:string
lbl_81696D8D = .sdata:0x81696D8D; // type:object size:0x6 data:string
lbl_81696D93 = .sdata:0x81696D93; // type:object size:0x6 data:string
lbl_81696D99 = .sdata:0x81696D99; // type:object size:0x6 data:string
lbl_81696D9F = .sdata:0x81696D9F; // type:object size:0x7 data:string
@16631 = .sdata:0x81696D80; // type:object size:0x1 scope:local
@16684 = .sdata:0x81696D81; // type:object size:0x6 scope:local data:string
@16685 = .sdata:0x81696D87; // type:object size:0x6 scope:local data:string
@16686 = .sdata:0x81696D8D; // type:object size:0x6 scope:local data:string
@16687 = .sdata:0x81696D93; // type:object size:0x6 scope:local data:string
@16688 = .sdata:0x81696D99; // type:object size:0x6 scope:local data:string
@16692 = .sdata:0x81696D9F; // type:object size:0x7 scope:local data:string
lbl_81696DA8 = .sdata:0x81696DA8; // type:object size:0x4 data:4byte
lbl_81696DAC = .sdata:0x81696DAC; // type:object size:0x6 data:wstring
lbl_81696DB2 = .sdata:0x81696DB2; // type:object size:0x4 data:string
lbl_81696DB6 = .sdata:0x81696DB6; // type:object size:0x7 data:string
lbl_81696DBD = .sdata:0x81696DBD; // type:object size:0x1
lbl_81696DBE = .sdata:0x81696DBE; // type:object size:0x4 data:string
lbl_81696DC2 = .sdata:0x81696DC2; // type:object size:0x5 data:string
@25675 = .sdata:0x81696DB2; // type:object size:0x4 scope:local data:string
@25689 = .sdata:0x81696DB6; // type:object size:0x7 scope:local data:string
@25710 = .sdata:0x81696DBD; // type:object size:0x1 scope:local
@26199 = .sdata:0x81696DBE; // type:object size:0x4 scope:local data:string
@26201 = .sdata:0x81696DC2; // type:object size:0x5 scope:local data:string
lbl_81696DC7 = .sdata:0x81696DC7; // type:object size:0x8 data:string
lbl_81696DD0 = .sdata:0x81696DD0; // type:object size:0x4 data:4byte
lbl_81696DD4 = .sdata:0x81696DD4; // type:object size:0x4 data:4byte

View File

@@ -815,7 +815,7 @@ config.libs = [
Object(NonMatching, "scene/memoryCard/iplMemoryCard.cpp"),
Object(NonMatching, "scene/memoryCard/iplMemoryCardBase.cpp"),
Object(NonMatching, "scene/memoryCard/iplMemoryCardManager.cpp"),
Object(NonMatching, "scene/memoryCard/iplGCSaveData.cpp"),
Object(Matching, "scene/memoryCard/iplGCSaveData.cpp"),
Object(NonMatching, "scene/memoryCard/iplGCWindow.cpp"),
]
),
@@ -875,7 +875,7 @@ config.libs = [
Object(Matching, "scene/setting/iplAPScanThread.cpp"),
Object(NonMatching, "scene/setting/iplUSBAP.cpp"),
Object(NonMatching, "scene/setting/iplUSBAPThread.cpp"),
Object(NonMatching, "scene/setting/iplAOSSThread.cpp"),
Object(Matching, "scene/setting/iplAOSSThread.cpp"),
Object(NonMatching, "scene/setting/AOSSLink.c"),
Object(NonMatching, "scene/setting/iplRakuRakuThread.cpp"),
Object(NonMatching, "scene/setting/AOSS.c"),
@@ -985,21 +985,21 @@ config.libs = [
Object(NonMatching, "clib/zconvert.c"),
Object(NonMatching, "clib/zi81key.c"),
Object(NonMatching, "clib/zi8alpha.c"),
Object(NonMatching, "clib/zi8alts.c"),
Object(Matching, "clib/zi8alts.c"),
Object(NonMatching, "clib/zi8cgetc.c"),
Object(NonMatching, "clib/zi8cinfo.c"),
Object(Matching, "clib/zi8copy.c"),
Object(NonMatching, "clib/zi8dawg.c"),
Object(NonMatching, "clib/zi8getc.c"),
Object(Matching, "clib/zi8getc.c"),
Object(NonMatching, "clib/zi8getc2.c"),
Object(NonMatching, "clib/zi8getSW.c"),
Object(NonMatching, "clib/zi8initd.c"),
Object(NonMatching, "clib/zi8is.c"),
Object(Matching, "clib/zi8getSW.c"),
Object(Matching, "clib/zi8initd.c"),
Object(Matching, "clib/zi8is.c"),
Object(NonMatching, "clib/zi8match.c"),
Object(NonMatching, "clib/zi8misc.c"),
Object(Matching, "clib/zi8misc.c"),
Object(NonMatching, "clib/zi8pud2.c"),
Object(NonMatching, "clib/Zi8punct.c"),
Object(NonMatching, "clib/zi8space.c"),
Object(Matching, "clib/Zi8punct.c"),
Object(Matching, "clib/zi8space.c"),
Object(NonMatching, "clib/zi8uwd.c"),
Object(Matching, "clib/zi8ver.c"),
Object(Matching, "clib/zi8ZHuwd.c"),
@@ -1053,19 +1053,19 @@ config.libs = [
]
),
RevoEXLib("nhttp", [
Object(NonMatching, "nhttp/NHTTP_bgnend.c"),
Object(NonMatching, "nhttp/NHTTP_control.c"),
Object(NonMatching, "nhttp/NHTTP_list.c"),
Object(NonMatching, "nhttp/NHTTP_os_RVL.c"),
Object(Matching, "nhttp/NHTTP_bgnend.c"),
Object(Matching, "nhttp/NHTTP_control.c"),
Object(Matching, "nhttp/NHTTP_list.c"),
Object(Matching, "nhttp/NHTTP_os_RVL.c"),
Object(NonMatching, "nhttp/NHTTP_recvbuf.c"),
Object(NonMatching, "nhttp/NHTTP_request.c"),
Object(NonMatching, "nhttp/NHTTP_response.c"),
Object(Matching, "nhttp/NHTTP_request.c"),
Object(Matching, "nhttp/NHTTP_response.c"),
Object(NonMatching, "nhttp/NHTTP_socket_RVL.c"),
Object(NonMatching, "nhttp/NHTTP_stdlib_RVL.c"),
Object(NonMatching, "nhttp/NHTTP_thread.c"),
Object(NonMatching, "nhttp/d_nhttp_private.c"),
Object(NonMatching, "nhttp/d_nhttp.c"),
Object(NonMatching, "nhttp/d_nhttp_common.c"),
Object(Matching, "nhttp/d_nhttp.c"),
Object(Matching, "nhttp/d_nhttp_common.c"),
]
),
RevoEXLib("nwc24", [
@@ -1089,7 +1089,7 @@ config.libs = [
Object(Matching, "nwc24/NWC24UserId.c"),
Object(Matching, "nwc24/NWC24Time.c"),
Object(Matching, "nwc24/NWC24Ipc.c"),
Object(NonMatching, "nwc24/NWC24Download.c"),
Object(Equivalent, "nwc24/NWC24Download.c"),
Object(Matching, "nwc24/NWC24CHJump.c"),
Object(NonMatching, "nwc24/NWC24System.c"),
]

View File

@@ -0,0 +1,68 @@
#ifndef IPL_MEMORY_CARD_LIB_H
#define IPL_MEMORY_CARD_LIB_H
#include <revolution/types.h>
namespace ipl {
namespace memorycard {
typedef struct FileInfo {
u16 fileNo; // 0x00
u16 size; // 0x02
u8 canCopy; // 0x04
u8 canMove; // 0x05
u16 unk_0x06; // 0x06
u32 key; // 0x08
} FileInfo; // 0x0C
typedef struct CardState {
vu8 unk_0x00; // 0x00
vu8 changed; // 0x01
vs16 state; // 0x02
vu16 unk_0x04; // 0x04
vu16 unk_0x06; // 0x06
vu32 key; // 0x08
vu16 unk_0x0C; // 0x0C
vu16 unk_0x0E; // 0x0E
vu16 freeBlocks; // 0x10
vu16 unk_0x12; // 0x12
} CardState; // 0x14
typedef struct IconState {
u8 bannerEnable; // 0x00
u8 unk_0x01; // 0x01
u8 unk_0x02; // 0x02
u8 bannerType; // 0x03
s8 anmDelta; // 0x04
u8 anmType; // 0x05
u8 unk_0x06; // 0x06
u8 unk_0x07; // 0x07
u8 iconFmt[8]; // 0x08
u16 anmFrameBits; // 0x10
s16 anmMax; // 0x12
u32 bannerOffset; // 0x14
u32 bannerTlutOffset; // 0x18
u32 iconOffset[8]; // 0x1C
u32 iconTlutOffset; // 0x3C
} IconState; // 0x40
void probeCard();
CardState* getCardSlotState();
FileInfo* getCardDirState();
IconState* getIconStateArray();
long getCardLastSendCmd();
long getCardLastSrcSlot();
long getCardLastCMDFCmdResult();
void sendCardFormatCmd(u8 slot);
void sendCardCopyCmd(u8 slot, s16 fileNo);
void sendCardMoveCmd(u8 slot, s16 fileNo);
void sendCardDeleteCmd(u8 slot, s16 fileNo);
const char* getIconComment(u8 slot, s16 fileNo);
void initCardThread();
bool shutdownCardThread();
} // namespace memorycard
} // namespace ipl
#endif // IPL_MEMORY_CARD_LIB_H

View File

@@ -122,6 +122,14 @@ extern WWWProtocolFinalizeFn WWWProtocolFinished;
extern WWWProtocolFinalizeFn WWWProtocolFailed;
extern WWWAddProtocolFn WWWAddProtocol;
#ifdef IPL_SETTING_IMPLEMENTATION
namespace ipl {
namespace scene {
class Setting;
}
}
#endif
namespace www {
namespace arcreader {
class ArcContainer;
@@ -206,6 +214,9 @@ namespace ext_ead {
WWWHandle* GetHandle() { return mpBrowserHandle; }
private:
#ifdef IPL_SETTING_IMPLEMENTATION
friend class ::ipl::scene::Setting;
#endif
static BOOL SNotifyCallback_(WWWHandle* wwwBrowser, WWWHandlewindow* wwwWindow, WWWEvent event, WWWHandleEventData* eventData);
BOOL NotifyCallback_(WWWHandle* wwwBrowser, WWWHandlewindow* wwwWindow, WWWEvent event, WWWHandleEventData* eventData);

View File

@@ -14,7 +14,15 @@ namespace textinput {
class LayoutByNW4R : public Base, public nw4rmanager::Layout {
public:
#ifdef MYTIMANAGER_IMPLEMENTATION
LayoutByNW4R(nw4r::lyt::MultiArcResourceAccessor* multiArc, const char* layoutName, EventObserver* event)
: nw4rmanager::Layout(multiArc, layoutName, event) {}
#endif
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual ~LayoutByNW4R();
#else
virtual ~LayoutByNW4R() {}
#endif
virtual void create(MEMAllocator* allocator);
virtual void init();

View File

@@ -20,6 +20,10 @@ namespace textinput {
virtual void moveNigaoeButton() {}
};
#ifdef MYTIINPUTFORM_IMPLEMENTATION
class ScrollButton;
#endif
class InputForm : public textinput::InputForm {
public:
typedef enum EditMode {
@@ -30,14 +34,51 @@ namespace textinput {
EM_Last
} EditMode;
#ifdef MYTIMANAGER_IMPLEMENTATION
InputForm(textinput::Manager* manager, nw4r::lyt::MultiArcResourceAccessor* multiArc,
const char* layoutName, EventObserver* event, const char* fontName)
: textinput::InputForm(manager, multiArc, layoutName, event, fontName),
unk_0x308(NULL), unk_0x30C(NULL), unk_0x310(NULL), unk_0x314(NULL),
mfScroll(0.0f), mfScrollFrom(0.0f), mfScrollTo(0.0f), mnLine(0),
mDrawRect(), mDefaultDrawSize(), mDefaultBoundSize(), mExScrollAnm(),
mpNigaoeObserver(NULL), mpDefaultNigaoe(NULL), mpSendString(NULL),
mbEdited(false), mbGoodBye(false), mbEditScrollUp(false), mbEditScrollDown(false),
mbCloseWithSend(false), mpScrollButton(NULL), mbScrollUp(false), mbScrollDown(false),
meEditMode(EM_Disp) {}
#endif
~InputForm();
#ifdef MYTIINPUTFORM_IMPLEMENTATION
virtual void moveCursorUp();
virtual void moveCursorDown();
virtual void onCommand(INPUT_COMMAND command, void* data);
virtual void create(MEMAllocator* allocator, inputform::EditBuffer* editBuffer);
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data);
virtual bool updateInput(input::HKBManager& hkbManager);
virtual void init();
virtual void draw();
virtual void calc();
virtual void doScroll(Scroll* scroll);
virtual u32 calcCursorPos(f32 x, f32 y);
virtual void drawCursor(f32 x, f32 y);
virtual nw4r::math::VEC2 getScale() const;
virtual void preDraw(u32 pos);
virtual void doLineFeed();
virtual void finishDraw(u32 pos);
virtual bool isInScroll();
#endif
virtual void setScroll(f32 scroll);
virtual void setAddScroll(f32 scroll, bool up, bool down);
virtual f32 getScroll() { return mfScroll; }
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual f32 getScrollFrom();
virtual f32 getScrollTo();
#else
virtual f32 getScrollFrom() { return mfScrollFrom; }
virtual f32 getScrollTo() { return mfScrollTo; }
#endif
virtual void open();
virtual void close();
@@ -90,7 +131,11 @@ namespace textinput {
void setEditScrollDown(bool editScrollDown) { mbEditScrollUp = editScrollDown; }
void setCloseWithSend(bool closeWithSend) { mbCloseWithSend = closeWithSend; }
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
void setEditMode(EditMode editMode);
#else
void setEditMode(EditMode editMode) { meEditMode = editMode; }
#endif
bool isEdited() { return mbEdited; }
bool isGoodBye() { return mbGoodBye; }
@@ -103,9 +148,19 @@ namespace textinput {
tistring::Decolated* getSendString() { return mpSendString; }
private:
#ifdef MYTIINPUTFORM_IMPLEMENTATION
nw4r::lyt::Pane* mpMemoPane;
nw4r::lyt::Pane* mpMemoRootPane;
nw4r::lyt::Pane* mpBoundPane;
nw4r::lyt::Pane* mpDrawPane;
#else
#ifdef MYTIMANAGER_IMPLEMENTATION
undefined4* unk_0x308;
#endif
undefined4* unk_0x30C;
undefined4* unk_0x310;
undefined4* unk_0x314;
#endif
f32 mfScroll; // 0x318
f32 mfScrollFrom; // 0x31C
f32 mfScrollTo; // 0x320
@@ -117,7 +172,11 @@ namespace textinput {
nw4r::lyt::Size mDefaultBoundSize; // 0x358
Mtx mDrawMtx; // 0x360
Mtx mBoundMtx; // 0x390
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
util::Animation mExScrollAnm; // 0x3C0
#else
u8 /*todo*/ mExScrollAnm[32]; // 0x3C0
#endif
NigaoeEventObserver* mpNigaoeObserver; // 0x3E0
GXTexObj* mpDefaultNigaoe; // 0x3E4
tistring::Decolated* mpSendString; // 0x3E8
@@ -127,7 +186,11 @@ namespace textinput {
bool mbEditScrollDown; // 0x3EF
bool mbCloseWithSend; // 0x3F0
u8 padding[3]; // 0x3F1
undefined4* mpScrollButton; // 0x3F4
#ifdef MYTIINPUTFORM_IMPLEMENTATION
ScrollButton* mpScrollButton;
#else
undefined4* mpScrollButton;
#endif
bool mbScrollUp; // 0x3F8
bool mbScrollDown; // 0x3F9
EditMode meEditMode; // 0x3FC

View File

@@ -16,6 +16,13 @@ namespace textinput {
T_Last,
} Type;
#ifdef MYTIMANAGER_IMPLEMENTATION
InputForm(textinput::Manager* manager, nw4r::lyt::MultiArcResourceAccessor* multiArc,
const char* layoutName, EventObserver* event, const char* fontName)
: textinput::MemoInputForm(manager, multiArc, layoutName, event, fontName),
unk_0x400(0), mbPhotoDraw(false), meType(T_MailAddressSel) {}
#endif
virtual nw4r::lyt::Material* getPhotoPaneMaterial();
virtual void onPhotoTrig();

View File

@@ -28,6 +28,9 @@ namespace textinput {
CT_NumericWithSeparator,
CT_NormalWithoutLineFeedWithSign,
CT_PredictWithoutLineFeed,
#ifdef MYTIMANAGER_IMPLEMENTATION
CT_PredictBigText,
#endif
CT_Last
} ConfigType;
@@ -78,7 +81,11 @@ namespace textinput {
virtual void start();
virtual void end();
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual textinput::InputForm* createInputForm();
#else
virtual InputForm* createInputForm();
#endif
virtual void memoDraw();
@@ -93,8 +100,16 @@ namespace textinput {
virtual ConfigType getConfigType() { return meConfigType; }
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual void setSaveData();
#else
virtual void setSaveData_();
#endif
virtual void reflectSaveData();
#ifdef MYTIMANAGER_IMPLEMENTATION
void reflectSaveDataRev1();
void reflectSaveDataDefault();
#endif
virtual void configDefault();
virtual void configLetter();
@@ -111,10 +126,21 @@ namespace textinput {
virtual void configNormalWithoutLineFeedWithSign();
virtual void configPredictWithoutLineFeed();
virtual void configPredictBigText();
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual textinput::MemoInputForm* createMemoInputForm();
virtual textinput::LetterInputForm* createLetterInputForm();
virtual textinput::InputForm* createBigTextInputForm();
virtual void* createBG();
#else
virtual void createMemoInputForm();
virtual void createLetterInputForm();
virtual void createBigTextInputForm();
virtual void createBG();
#endif
#ifdef MYTIMANAGER_IMPLEMENTATION
void* getBackGround() const { return mpBackGround; }
#endif
private:
State* mpCurrentState; // 0x40
@@ -135,6 +161,11 @@ namespace textinput {
class State {
public:
#ifdef MYTIMANAGER_IMPLEMENTATION
State() : mpManager(NULL) {}
Manager* getManager() const { return mpManager; }
void setManager(Manager* manager) { mpManager = manager; }
#endif
virtual ~State();
virtual Manager::StateType getStateType();
@@ -153,6 +184,18 @@ namespace textinput {
virtual void start();
virtual void end();
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual InputForm* InputForm();
virtual keyboard::hwkey::HWKeyboard* HWKeyboard();
virtual keyboard::pctype::LayoutByNW4R* PCKeyboard();
virtual keyboard::cellphonetype::LayoutByNW4R* CellPhoneKeyboard();
virtual void* SignKeyboard();
virtual candidatebox::LayoutByNW4R* CandidateBox();
virtual toolbar::LayoutByNW4R* ToolBar();
virtual void* PredictLanguageSelectDialog();
virtual void* BG();
#endif
private:
Manager* mpManager; // 0x04
};

View File

@@ -309,7 +309,11 @@ namespace textinput {
virtual u16 getScroll() { return mTextArea.GetDispOffset(); } // 0x100
virtual bool isInScroll(); // 0x104
virtual void setActive(bool active); // 0x108
virtual bool isActive() const; // 0x10C
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual bool isActive() const { return mbActive; }
#else
virtual bool isActive() const;
#endif // 0x10C
virtual void setSelectedTextPane(int pane) { mTextArea.SetSelectedText(pane); } // 0x110
virtual void setFocusedTextPane(int pane) { mTextArea.SetFocusedText(pane); } // 0x114
virtual int getFocusedTextPane() { return mTextArea.GetFocusedText(); } // 0x118

View File

@@ -2,13 +2,57 @@
#define TEXTINPUT_CELL_PHONE_H
#include "tiNw4rManager.h"
#ifdef MYTIMANAGER_IMPLEMENTATION
#include "tiKeyboard.h"
#endif
namespace textinput {
namespace keyboard {
namespace cellphonetype {
#ifdef MYTIMANAGER_IMPLEMENTATION
class Base : public textinput::keyboard::KeyboardBase {
#else
class Base {
#endif
public:
// TODO
#ifdef MYTIMANAGER_IMPLEMENTATION
enum InputMode {
IM_00,
IM_01,
IM_02,
IM_03,
IM_04,
};
virtual ~Base();
virtual void create(MEMAllocator* allocator) override;
virtual void init() override;
virtual void updateFromReceiver(u32, void*) override;
virtual void onKey(u32, void*) override;
virtual void getType() override;
virtual void onActive() override;
virtual void calc();
virtual void draw();
virtual InputMode getInputMode() const;
virtual bool isLocked() const;
virtual bool isNumeric() const;
virtual bool isNumericWithDot() const;
virtual bool isHoldingButton() const;
virtual void doNumericMode(bool);
virtual void changeInputMode(InputMode);
virtual bool isUpperCase();
virtual void setInputMode(InputMode);
virtual void setUpperCaseJP(bool);
virtual void setLangKeyActive(bool);
virtual bool onClose();
virtual void goSignInputMode();
virtual void changePredictLanguage();
virtual void setAbcMode(bool);
virtual bool isZiActive();
virtual bool isAtokActive();
virtual void doInput();
virtual void updateFixMode();
#else
virtual void vt_0x08();
virtual void vt_0x0C();
virtual void vt_0x10();
@@ -30,7 +74,11 @@ namespace textinput {
virtual void vt_0x4C();
virtual void vt_0x50();
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual void doNumericMode(bool);
#else
virtual void vt_0x54();
#endif
virtual void vt_0x58();
virtual void vt_0x5C();
virtual void vt_0x60();
@@ -38,17 +86,48 @@ namespace textinput {
virtual void vt_0x68(bool);
virtual bool onClose();
#endif
// TODO enum?
int getInputType() const;
#ifdef MYTIMANAGER_IMPLEMENTATION
private:
u32 mPreviousInputMode;
u32 mCurrentInputMode;
bool mbInputModeLocked;
bool mbNumericMode;
bool mbNumericWithDotMode;
bool mbUpperCaseMode;
bool mbAbcMode;
bool mbLanguageKeyMode;
u32 mHoldingButton;
void* mpInputModeTable;
MEMAllocator* mpAllocator;
void* mpInputSettings;
u32 mInputState;
#endif
};
class LayoutByNW4R : public Base, public nw4rmanager::Layout {
public:
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual void doNumericMode(bool);
virtual void setPredictLanguageDialog(void*);
virtual void setSignWindow(void*);
virtual void doNumericWithDotMode(bool);
virtual void setLineFeedButton(bool);
virtual void setPredictLanguageButton(bool);
virtual void setSignWindowButton(bool);
#endif
virtual bool onClose();
void onPressedShift(bool shift);
void onReleasedShift();
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data) override;
virtual bool updateInput(input::HKBManager& hkbManager) override;
#endif
};
} // namespace cellphonetype

View File

@@ -19,6 +19,24 @@ namespace textinput {
u32 GetModifierState() const;
void SetModifierState(u32, u32);
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
class KeySet {
public:
u8 GetKey() const;
wchar_t GetWChar() const;
bool IsValid() const;
KeySet GetNext() const;
private:
const HKBManager* mpManager;
u8 mKind;
s8 mIndex;
u8 mDevice;
u16 mCharacter;
};
KeySet GetTriggeredKeySet() const;
KeySet GetRepeatedKeySet() const;
void SetForceModifierState(u32 mask, u32 state);
#else
class KeySet {
private:
keyboard::cellphonetype::PaneNameToCharCode* pPaneNameToCharCode; // 0x00
@@ -27,6 +45,7 @@ namespace textinput {
u16 uType; // 0x28
};
#endif
private:
u8 unk_0x00[0xFC];

View File

@@ -14,8 +14,15 @@ namespace textinput {
~HWKeyboard();
virtual void init();
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
wchar_t convertWCCode(wchar_t code) const;
#endif
#ifdef MYTIMANAGER_IMPLEMENTATION
void updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data);
#else
virtual void updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data);
#endif
virtual bool updateInput(input::HKBManager& hkbManager);
private:

View File

@@ -17,6 +17,9 @@ namespace textinput {
namespace inputform {
class EditBuffer {
public:
#ifdef MYTIMANAGER_IMPLEMENTATION
void create(MEMAllocator* allocator);
#endif
~EditBuffer();
private:
@@ -27,6 +30,10 @@ namespace textinput {
};
class DeadKeyStream {
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
public:
static wchar_t ToIndependentClass(wchar_t code);
#endif
private:
KPRQueue mKPRQueue; // 0x00
};
@@ -137,7 +144,12 @@ namespace textinput {
virtual void enableSpaceByRight(bool rightWithSpace);
virtual void onClose();
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
tistring::WithAtok* getCurrentString(bool fixed);
virtual bool canConvert() { return getCurrentString(false) == mpUnfixString; }
#else
virtual bool canConvert();
#endif
virtual void setString(const wchar_t* string);
@@ -167,6 +179,10 @@ namespace textinput {
virtual void onSE(sound::SE seId);
#ifdef MYTIMANAGER_IMPLEMENTATION
void dirtyCacheAll();
#endif
virtual void clear();
virtual u32 calcCursorPos(f32 x, f32 y);
@@ -183,8 +199,19 @@ namespace textinput {
virtual void makeUpCursorPos(CursorPos* cursorPos, u32 pos, s32 startLine, s32 endLine);
#ifdef MYTIINPUTFORM_IMPLEMENTATION
protected:
void setCursorPos(tistring::Decolated* string, u32 pos);
void resetRelation();
void calcCursorTimer();
#else
private:
Rect mRect; // 0x120
#endif
#ifdef MYTIINPUTFORM_IMPLEMENTATION
nw4r::ut::Rect mRect;
#else
Rect mRect;
#endif
nw4r::math::MTX34 mMtx; // 0x130
Destination meDestination; // 0x160
tistring::Decolated* mpString; // 0x164
@@ -228,6 +255,9 @@ namespace textinput {
class LayoutByNW4R : public Base, public nw4rmanager::Layout {
public:
#ifdef MYTIMANAGER_IMPLEMENTATION
LayoutByNW4R(textinput::Manager*, nw4r::lyt::MultiArcResourceAccessor*, const char*, EventObserver*, const char*);
#endif
~LayoutByNW4R();
virtual void init();
@@ -254,8 +284,31 @@ namespace textinput {
virtual void visibleSeparator(bool flag);
#ifdef MYTIINPUTFORM_IMPLEMENTATION
protected:
const void* mpLayoutData;
const void* mpLanguageData;
const char* mpFontName;
bool mbUpVisible;
bool mbDownVisible;
bool mbRepeat;
nw4rmanager::TiEventHandler* mpInputEventHandler;
nw4r::ut::ResFont mFont;
int mUpRepeat;
int mDownRepeat;
int mLeftRepeat;
int mRightRepeat;
int mDeleteRepeat;
int mConfirmRepeat;
u32 mRepeatButtons;
#else
private:
#ifdef MYTIMANAGER_IMPLEMENTATION
u8 unk_0x2C0[0x48];
#else
u8 unk_0x2C0[0x4C];
#endif
#endif
};
}
typedef inputform::LayoutByNW4R InputForm;

View File

@@ -9,16 +9,31 @@ namespace textinput {
class KeyboardBase : public CommandSender {
public:
virtual ~KeyboardBase() {}
#ifndef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void create(MEMAllocator* alloc) override;
virtual void init() override;
virtual void setCommandReceiver(CommandReceiver* receiver) override;
virtual void sendCommand(u32 command, void*) override;
#endif
virtual void updateFromReceiver(u32, void*) override;
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(TI_PC_KEYBOARD_IMPLEMENTATION)
virtual void onKey(u32, void*);
#else
virtual void onKey(u32);
#endif
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual int getType();
#else
virtual void getType();
#endif
virtual void setLanguage(Language language);
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual Language getLanguage() const { return meLanguage; }
virtual void update() {}
#else
virtual Language getLanguage() const;
virtual void update();
#endif
virtual void onActive();
protected:

View File

@@ -19,6 +19,10 @@ namespace textinput {
bool isHoldingShift() const {
return isHWPressedShift() || isPressedShiftB();
}
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
u8 isCapsLock() const { return mbCpasLock; }
void setPressedShiftB(bool pressed) { mbPressedShiftB = pressed; }
#endif
u8 isHWPressedShift() const { return mbPressedShift; }
u8 isPressedShiftB() const { return mbPressedShiftB; }
void setHWPressedShift(const u8& arg) { mbPressedShift = arg; }

View File

@@ -56,6 +56,9 @@ namespace textinput {
virtual void setLanguage(Language language);
virtual Language getLanguage() const { return meLanguage; }
#ifdef MYTIMANAGER_IMPLEMENTATION
Language getLanguageForMemo() const { return meLanguage; }
#endif
virtual void setDestination(Destination destination);
@@ -66,6 +69,30 @@ namespace textinput {
virtual void setAspectRatio(bool b4x3);
#ifdef MYTIMANAGER_IMPLEMENTATION
MEMAllocator* getAllocatorForMemo() const { return mpAllocator; }
inputform::EditBuffer* getEditBufferForMemo() const { return mpEditBuffer; }
void setEditBufferForMemo(inputform::EditBuffer* editBuffer) { mpEditBuffer = editBuffer; }
void setHWKeyboardForMemo(keyboard::hwkey::HWKeyboard* keyboard) { mpHWKeyboard = keyboard; }
nw4r::lyt::MultiArcResourceAccessor* getMultiArcForMemo() const { return mpMultiArcResourceAccessor; }
EventObserver* getEventObserverForMemo() const { return mpEventObserver; }
InputForm* getInputFormForMemo() const { return mpInputForm; }
void setInputFormForMemo(InputForm* inputForm) { mpInputForm = inputForm; }
toolbar::LayoutByNW4R* getToolBarForMemo() const { return mpToolBar; }
candidatebox::LayoutByNW4R* getCandidateBoxForMemo() const { return mpCandidateBox; }
void setPCKeyboardForMemo(keyboard::pctype::LayoutByNW4R* keyboard) { mpPCKeyboard = keyboard; }
void setCellPhoneKeyboardForMemo(keyboard::cellphonetype::LayoutByNW4R* keyboard) { mpCellPhoneKeyboard = keyboard; }
void setCandidateBoxForMemo(candidatebox::LayoutByNW4R* candidateBox) { mpCandidateBox = candidateBox; }
void setToolBarForMemo(toolbar::LayoutByNW4R* toolBar) { mpToolBar = toolBar; }
void setPredictLanguageDialogForMemo(void* dialog) { mpPredictLanguageDialog = dialog; }
void setSignWindowForMemo(void* signWindow) { mpSignWindow = signWindow; }
void* getSignWindowForMemo() const { return mpSignWindow; }
keyboard::pctype::LayoutByNW4R* getPCKeyboardForMemo() const { return mpPCKeyboard; }
keyboard::cellphonetype::LayoutByNW4R* getCellPhoneKeyboardForMemo() const { return mpCellPhoneKeyboard; }
Destination getDestinationForMemo() const { return meDestination; }
void initAspect();
#endif
virtual void setSecretInputMode(bool secretInputMode) { mpInputForm->setSecretModeOn(secretInputMode); }
#ifdef IPL_ADDRESS_EDIT_CPP
void enableKSXFilter(bool compatibleFilter);

View File

@@ -86,11 +86,29 @@ namespace textinput {
virtual void init() {} // 0x08
virtual void calc(); // 0x0C
virtual void onAnmEvent(AnmPaneEvent paneEvent); // 0x10
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void onAnmEvent(AnmPaneEvent) {}
#else
virtual void onAnmEvent(AnmPaneEvent paneEvent);
#endif // 0x10
virtual void changeAnimation(u32 id); // 0x14
virtual bool isInAnimation(); // 0x18
virtual Anim* searchAnimation(u32 id); // 0x1C
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual bool isInAnimation() { return mpCurrentAnim != NULL; }
#else
virtual bool isInAnimation();
#endif // 0x18
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual Anim* searchAnimation(u32 id) {
for (Anim* animation = static_cast<Anim*>(nw4r::ut::List_GetNext(&mAnms, NULL)); animation != NULL;
animation = static_cast<Anim*>(nw4r::ut::List_GetNext(&mAnms, animation))) {
if (animation->muID == id) return animation;
}
return NULL;
}
#else
virtual Anim* searchAnimation(u32 id);
#endif // 0x1C
virtual ~AnmPane(); // 0x20
@@ -128,6 +146,11 @@ namespace textinput {
class AnimPaneGroup {
public:
#ifdef MYTIINPUTFORM_IMPLEMENTATION
AnimPaneGroup(nw4r::lyt::Group* group) : mpGroup(group) {
nw4r::ut::List_Init(&mAnmPaneList, offsetof(AnmPane, mGroupLink));
}
#endif
virtual void create() {} // 0x08
virtual void init() {} // 0x0C
@@ -181,7 +204,11 @@ namespace textinput {
virtual nw4r::lyt::Pane* get(int i) { return mpaFifo[i]; } // 0x10
virtual nw4r::lyt::Pane* getLast() { // 0x14
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
for (int i = MAX_COUNT-1; i > -1; i--) {
#else
for (int i = MAX_COUNT-1; i > -1; i++) {
#endif
if (mpaFifo[i] != NULL) {
return mpaFifo[i];
}
@@ -226,8 +253,16 @@ namespace textinput {
virtual void setProjectionMtx(); // 0x48
virtual void setPaneLastDrawReceived(nw4r::lyt::Pane* paneLastDraw); // 0x4C
virtual void initPaneLastDrawReceived(); // 0x50
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void setPaneLastDrawReceived(nw4r::lyt::Pane* pane) { mAnmPaneFifo.push(pane); }
#else
virtual void setPaneLastDrawReceived(nw4r::lyt::Pane* paneLastDraw);
#endif // 0x4C
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void initPaneLastDrawReceived() { mAnmPaneFifo.init(); }
#else
virtual void initPaneLastDrawReceived();
#endif // 0x50
virtual void setVisible(const char* paneName, bool flag); // 0x54
virtual bool isVisible(const char* paneName, bool* result) const; // 0x58

View File

@@ -1,8 +1,15 @@
#ifndef TEXTINPUT_PC_KEYBOARD_H
#define TEXTINPUT_PC_KEYBOARD_H
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
#include "tiPcKeyboardImpl.h"
#else
#include "tiNw4rManager.h"
#include "tiTextInputBase.h"
#ifdef MYTIMANAGER_IMPLEMENTATION
#include "tiKeyboard.h"
#endif
namespace textinput {
class Manager;
@@ -11,8 +18,22 @@ namespace textinput {
namespace pctype {
#ifdef MYTIMANAGER_IMPLEMENTATION
class UIObj {
public:
class Listener {
public:
virtual void onEvent(UIObj*, u32, void*);
};
};
#endif
// TODO
#ifdef MYTIMANAGER_IMPLEMENTATION
class Base : public textinput::keyboard::KeyboardBase {
#else
class Base : public CommandSender {
#endif
public:
enum TranslateMode {
TM_00,
@@ -26,6 +47,48 @@ namespace textinput {
IT_04,
};
#ifdef MYTIMANAGER_IMPLEMENTATION
enum InputMode {
IM_00,
IM_01,
IM_02,
IM_03,
IM_04,
};
virtual ~Base();
virtual void create(MEMAllocator* allocator) override;
virtual void init() override;
virtual void updateFromReceiver(u32, void*) override;
virtual void onKey(u32, void*) override;
virtual void getType() override;
virtual void setLanguage(Language) override;
virtual void onActive() override;
virtual void inputCharCode(u16);
virtual void getState();
virtual bool isShiftOn() const;
virtual bool isCapsOn() const;
virtual bool isABC();
virtual void setABC(bool);
virtual InputMode getABCInputMode() const;
virtual InputMode getAIUInputMode() const;
virtual TranslateMode getTranslateMode() const;
virtual void setTranslateMode(TranslateMode);
virtual void onlyQwerty(bool);
virtual void setLangKeyActive(bool);
virtual void setInputModeJP(bool, u32, u32);
virtual void setInputModeCK(u32);
virtual void refreshState();
virtual void changeABCInputMode(InputMode);
virtual void changeAIUInputMode(InputMode);
virtual void onClose();
virtual void getWCCode(char*);
virtual void getControlKey(char*);
virtual void sendInputWChar(u16, bool);
virtual void goSignInputMode();
virtual void changePredictLanguage();
virtual void updateFixMode();
#else
virtual ~Base();
virtual void create(MEMAllocator* allocator);
virtual void init();
@@ -61,17 +124,57 @@ namespace textinput {
virtual void goSignInputMode();
virtual void changePredictLanguage();
virtual void updateFixMode();
#endif
#ifdef MYTIMANAGER_IMPLEMENTATION
private:
u8 mKeyboardInputFlags[8];
const void* mpKeyStateTable;
u32 mTranslateMode;
u32 mABCInputMode;
u32 mAIUInputMode;
u32 mCurrentInputType;
u32 mInputState;
const void* mpLanguageData;
bool mbOnlyQwerty;
bool mbLanguageKeyActive;
u16 mKeyboardFlags;
void* mpInputSettings;
void* mpCurrentKeyState;
public:
u32 getTranslateModeForMemo() const { return mTranslateMode; }
u32 getABCInputModeForMemo() const { return mABCInputMode; }
u32 getAIUInputModeForMemo() const { return mAIUInputMode; }
#endif
};
// TODO
class LayoutByNW4R : public Base, public nw4rmanager::Layout {
class LayoutByNW4R : public Base, public nw4rmanager::Layout
#ifdef MYTIMANAGER_IMPLEMENTATION
, public UIObj::Listener
#endif
{
public:
// TODO - ...
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual void draw();
virtual void calc();
virtual void setPredictLanguageDialog(void*);
virtual void setSignWindow(void*);
virtual void setLineFeedButton(bool);
virtual void setPredictLanguageButton(bool);
virtual void setSignWindowButton(bool);
#endif
virtual void onClose();
void onPressedShift(bool shift);
void onReleasedShift();
#ifdef MYTIMANAGER_IMPLEMENTATION
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data) override;
virtual bool updateInput(input::HKBManager& hkbManager) override;
#endif
};
} // namespace pctype
@@ -80,4 +183,5 @@ namespace textinput {
} // namespace textinput
#endif
#endif // TEXTINPUT_HW_KEYBOARD_H

View File

@@ -0,0 +1,311 @@
#ifndef TEXTINPUT_PC_KEYBOARD_IMPL_H
#define TEXTINPUT_PC_KEYBOARD_IMPL_H
#include "tiKeyboard.h"
#include "tiNw4rManager.h"
#include "tiPkData.h"
namespace textinput {
class Manager;
namespace predictlang {
class LayoutByNW4R;
}
namespace keyboard {
namespace signwindow {
class LayoutByNW4R;
}
}
namespace keyboard {
namespace signwindow {
class Base : public KeyboardBase {
public:
virtual bool isLocked();
virtual void setPage(u8 page);
virtual u8 getPage();
virtual void movePrevSignPage();
virtual void moveNextSignPage();
virtual void close();
};
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public nw4rmanager::AnmObserver {
public:
virtual void draw();
virtual void open(KeyboardBase* keyboard, bool repeat);
virtual bool isActive();
};
}
namespace pctype {
struct GridKey {
char paneName[18];
wchar_t codes[4];
};
struct ControlKey {
char paneName[20];
u32 key;
};
struct VisiblePanes {
u16 visibleCount;
u16 hiddenCount;
const char* visible[24];
const char* hidden[24];
};
struct Ablaut {
wchar_t code;
wchar_t alternatives[7];
};
struct LanguageData {
const PaneNameToCharCodeWithModeAscii* ascii;
const GridKey* grid;
const ControlKey* controls;
const VisiblePanes* panes;
const Ablaut* ablaut;
};
class Base : public KeyboardBase {
public:
enum TranslateMode {
TM_Direct,
TM_Roman,
TM_Kana
};
enum InputMode {
IM_Direct,
IM_01,
IM_02,
IM_03,
IM_04,
IM_05,
IM_Hiragana,
IM_Katakana
};
enum InputType {
IT_00,
IT_01,
IT_02,
IT_03,
IT_04
};
struct State {
bool rejected;
u8 inputFlags[7];
};
class KeyState {
public:
void refresh_();
void refreshText(nw4r::lyt::Pane* root);
void setABCFlag(u32 flags);
wchar_t getWCCode(u32 index);
wchar_t getWCCode(char* paneName);
void setABCMode(u32 mode) {
if ((abcFlags & 15) != mode) {
abcFlags = (abcFlags & ~15) | (mode & 15);
refresh_();
}
}
void setAIUMode(u32 mode) {
if ((aiuFlags & 15) != mode) {
aiuFlags = (aiuFlags & ~15) | (mode & 15);
refresh_();
}
}
u32 abcFlags;
u32 inputType;
u32 aiuFlags;
Language language;
const LanguageData* data;
Base* owner;
};
virtual ~Base();
virtual void create(MEMAllocator* allocator);
virtual void init();
virtual void updateFromReceiver(u32 command, void* data);
virtual void onKey(u32 event, void* data);
virtual int getType();
virtual void setLanguage(Language language);
virtual void onActive();
virtual void inputCharCode(wchar_t code);
virtual State* getState();
virtual bool isShiftOn() const;
virtual bool isCapsOn() const;
virtual bool isABC();
virtual void setABC(bool abc);
virtual InputMode getABCInputMode() const;
virtual InputMode getAIUInputMode() const;
virtual TranslateMode getTranslateMode() const;
virtual void setTranslateMode(TranslateMode mode);
virtual void onlyQwerty(bool only);
virtual void setLangKeyActive(bool active);
virtual void setInputModeJP(bool, u32, u32);
virtual void setInputModeCK(u32);
virtual void refreshState();
virtual void changeABCInputMode(InputMode mode);
virtual void changeAIUInputMode(InputMode mode);
virtual void onClose();
virtual wchar_t getWCCode(char* paneName);
virtual u32 getControlKey(char* paneName);
virtual void sendInputWChar(wchar_t code, bool repeat);
virtual void goSignInputMode();
virtual void changePredictLanguage();
virtual void updateFixMode();
protected:
State mState;
const LanguageData* mpInitialLanguageData;
KeyState mKeyState;
MEMAllocator* mpAllocator;
bool mbOnlyQwerty;
bool mbLanguageKeyActive;
Manager* mpManager;
};
class LayoutByNW4R;
class AnmPane : public nw4rmanager::AnmPane {
public:
AnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : nw4rmanager::AnmPane(pane, observer), mAnimation(0) {}
virtual void init();
virtual void changeAnimation(u32 animation);
virtual ~AnmPane();
virtual int getState() const { return mAnimation; }
virtual int getKeyType() const { return mKeyType; }
protected:
int mAnimation;
int mKeyType;
};
class NormalButtonAnmPane : public AnmPane {
public:
NormalButtonAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : AnmPane(pane, observer) { mKeyType = 0; }
virtual ~NormalButtonAnmPane();
virtual void onAnmEvent(AnmPaneEvent event);
};
class ShiftCapsAnmPane : public AnmPane {
public:
ShiftCapsAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : AnmPane(pane, observer), mbOn(false) { mKeyType = 1; }
virtual ~ShiftCapsAnmPane();
virtual void onAnmEvent(AnmPaneEvent event);
bool isFocused() const;
private:
bool mbOn;
};
class ToggleButtonAnmPane : public AnmPane {
public:
ToggleButtonAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : AnmPane(pane, observer) { mKeyType = 2; }
virtual ~ToggleButtonAnmPane();
virtual void onAnmEvent(AnmPaneEvent event);
};
class OnOffButtonAnmPane : public AnmPane {
public:
OnOffButtonAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : AnmPane(pane, observer) { mKeyType = 3; }
virtual ~OnOffButtonAnmPane();
virtual void onAnmEvent(AnmPaneEvent event);
};
class UIObj : public gui::EventHandler {
public:
class Listener {
public:
virtual void onEvent(UIObj*, u32, void*) = 0;
};
UIObj(u32 id, LayoutByNW4R* layout, Listener* listener) : mId(id), mpLayout(layout), mpListener(listener) {}
virtual ~UIObj();
virtual void onEvent(gui::GUIComponent& component, u32 event, void* data);
virtual void onGUIEvent(gui::PaneComponent& component, u32 event, nw4rmanager::TiEventHandler::Input* input);
protected:
u32 mId;
LayoutByNW4R* mpLayout;
Listener* mpListener;
};
class UIModifierButton : public UIObj {
public:
UIModifierButton(u32 id, LayoutByNW4R* layout, Listener* listener);
virtual ~UIModifierButton();
virtual void onGUIEvent(gui::PaneComponent& component, u32 event, nw4rmanager::TiEventHandler::Input* input);
gui::PaneComponent* mpPaneComponent;
gui::PaneComponent* mpBoundingComponent;
AnmPane* mpAnimation;
bool mbOn;
};
class UIModePanel : public UIObj {
public:
UIModePanel(u32 id, LayoutByNW4R* layout, Listener* listener);
virtual ~UIModePanel();
virtual void onGUIEvent(gui::PaneComponent& component, u32 event, nw4rmanager::TiEventHandler::Input* input);
void Create(nw4rmanager::Layout* layout);
u32 mMode;
gui::PaneComponent* mpPaneComponents[5];
gui::PaneComponent* mpBoundingComponents[5];
AnmPane* mpAnimations[5];
nw4r::lyt::Pane* mpEnglishText;
nw4r::lyt::Pane* mpHangulText;
nw4r::lyt::Pane* mpModeSelect;
GXTexObj mDirectTexture;
GXTexObj mPinyinTexture;
GXTexObj mEnglishTexture;
GXTexObj mHangulTexture;
};
class EventHandler : public nw4rmanager::TiEventHandler {
public:
EventHandler(LayoutByNW4R* layout) : mpKeyboard(layout) {}
virtual ~EventHandler();
virtual void onTiEvent(gui::PaneComponent* component, u32 event, Input* input);
private:
LayoutByNW4R* mpKeyboard;
};
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public UIObj::Listener {
public:
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator);
virtual void init();
virtual void updateFromReceiver(u32 command, void* data);
virtual void onKey(u32 event, void* data);
virtual void setLanguage(Language language);
virtual void onActive();
virtual void inputCharCode(wchar_t code);
virtual void setABC(bool abc);
virtual void setTranslateMode(TranslateMode mode);
virtual void onlyQwerty(bool only);
virtual void setLangKeyActive(bool active);
virtual void setInputModeJP(bool abc, u32 abcMode, u32 aiuMode);
virtual void setInputModeCK(u32 mode);
virtual void refreshState();
virtual void onClose();
virtual void sendInputWChar(wchar_t code, bool repeat);
virtual void goSignInputMode();
virtual void changePredictLanguage();
virtual void draw();
virtual void calc();
virtual void setPredictLanguageDialog(predictlang::LayoutByNW4R* dialog);
virtual void setSignWindow(signwindow::LayoutByNW4R* window);
virtual void setLineFeedButton(bool visible);
virtual void setPredictLanguageButton(bool visible);
virtual void setSignWindowButton(bool visible);
virtual bool updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data);
virtual bool updateInput(input::HKBManager& hkb);
virtual void changeAnimationAllToNormal();
virtual void throwReleaseForAll();
virtual void cancelStateFocusIn();
virtual void updatePredictLanguage(CommandReceiver::ChangePredictMode* mode);
virtual void updateDakuten();
virtual void initLayout();
virtual void onEvent(UIObj* object, u32 event, void* data);
void onPressedCaps();
void onPressedShift(bool shift);
void onReleasedShift();
void createAnmPane_(MEMAllocator* allocator);
private:
EventHandler* mpKeyboardEventHandler;
predictlang::LayoutByNW4R* mpPredictDialog;
signwindow::LayoutByNW4R* mpSignWindow;
bool mbLineFeed;
UIModifierButton mShiftButton;
UIModifierButton mCapsButton;
UIModePanel mModePanel;
};
}
}
}
#endif

View File

@@ -9,7 +9,11 @@
namespace textinput {
namespace textdrawer {
#if defined(MYTIMANAGER_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
class Base : public nw4r::ut::CharWriter {
#else
class Base : nw4r::ut::CharWriter {
#endif
public:
typedef struct ViewPort {
f32 xOrig; // 0x00
@@ -86,7 +90,14 @@ namespace textinput {
private:
u8 unk_0x50[0x78];
bool mbSecretMode; // 0xC8
#ifdef MYTIINPUTFORM_IMPLEMENTATION
protected:
u8 mDrawState[0x27];
f32 mfDrawScrollY;
u8 mDrawCacheState[0x14];
#else
u8 unk_0xCC[0x3C];
#endif
};
}
}

View File

@@ -50,11 +50,21 @@ namespace textinput {
class CommandSender;
class CommandReceiver : public Base {
public:
#ifdef MYTIINPUTFORM_IMPLEMENTATION
struct Scroll {
bool absY;
f32 x;
f32 y;
};
#endif
typedef enum INPUT_COMMAND {
INPUT_COMMAND_0 = 0,
INPUT_COMMAND_37 = 37,
} INPUT_COMMAND;
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
struct ChangePredictMode { u32 mode; bool enabled; };
#endif
virtual void clearSender();
virtual void onCommand(INPUT_COMMAND command, void* data);
virtual void addSender(CommandSender* cmdSend);
@@ -68,7 +78,13 @@ namespace textinput {
CommandSender() : mpCommandReceiver(NULL) {}
virtual void setCommandReceiver(CommandReceiver* cmdRecv);
#ifdef TI_PC_KEYBOARD_IMPLEMENTATION
virtual void sendCommand(u32 command, void* data) {
if (mpCommandReceiver != NULL) mpCommandReceiver->onCommand(static_cast<CommandReceiver::INPUT_COMMAND>(command), data);
}
#else
virtual void sendCommand(u32, void*);
#endif
virtual void updateFromReceiver(u32, void*) {}
nw4r::ut::Link mLink; // 0x00

View File

@@ -8,15 +8,21 @@
#include <cstring>
#include "global/decomp/utils.h"
namespace ipl {
namespace gui {
class PaneComponent : public ::gui::PaneComponent {};
class PaneManager : public ::gui::PaneManager {
public:
#ifdef IPL_GCW_PANEMANAGER_CTOR_OUT_OF_LINE
PaneManager(::gui::EventHandler* event, const nw4r::lyt::DrawInfo* drawInfo, EGG::Heap* heap, EGG::Allocator* allocator, bool bDisableCon = false) NO_INLINE;
#else
PaneManager(::gui::EventHandler* event, const nw4r::lyt::DrawInfo* drawInfo, EGG::Heap* heap, EGG::Allocator* allocator, bool bDisableCon = false) :
::gui::PaneManager(event, allocator, drawInfo),
mpHeap(heap),
mbDisableCon(bDisableCon) {}
#endif
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
virtual ~PaneManager();

View File

@@ -7,6 +7,10 @@
#include "utility/iplFrameController.h"
#ifdef IPL_GCW_INTP_CTOR_OUT_OF_LINE
#include "global/decomp/utils.h"
#endif
namespace ipl {
namespace math {
template <typename T>
@@ -37,6 +41,9 @@ namespace ipl {
template <typename T>
class LinearIntp : public Interporation<T> {
public:
#ifdef IPL_GCW_INTP_CTOR_OUT_OF_LINE
LinearIntp() NO_INLINE;
#endif
#ifdef IPL_BOARD_OBJECT_INLINE_INTERPOLATION_DTORS
virtual ~LinearIntp();
#endif
@@ -50,6 +57,7 @@ namespace ipl {
T get2() const { return (((mStart * (mMaxFrame - mFrame)) + (mEnd * mFrame)) / mMaxFrame); }
};
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
template <typename T>
class __declspec(novtable) HermiteIntp : public utility::FrameController {

View File

@@ -85,6 +85,9 @@ namespace ipl {
}
const utility::BScroller& getBInst() { return mBScroller; }
#ifdef IPL_SDMEMORY_SCROLLER_BINST_RESET
void resetBInst() { mBScroller.reset(); }
#endif
bool isDownEnd() const { return mScroller.isDownEnd(); }
bool isUpEnd() const { return mScroller.isUpEnd(); }
@@ -98,6 +101,9 @@ namespace ipl {
void setDownLimit(f32 v) { mScroller.setDownLimit(v); }
void setUpLimit(f32 v) { mScroller.setUpLimit(v); }
#ifdef IPL_SDMEMORY_SCROLLER_STATE_ACCESSOR
void setState(int state) { mScroller.setState(state); }
#endif
bool isActive() const { return mScroller.isActive(); }

View File

@@ -0,0 +1,44 @@
#ifndef IPL_SCENE_GC_SAVE_DATA_H
#define IPL_SCENE_GC_SAVE_DATA_H
#include <nw4r/ut.h>
#include "scene/memoryCard/iplMemoryCardBase.h"
#include "math/iplMathTypes.h"
namespace ipl {
namespace scene {
class GCSaveData : public MemoryBase {
friend class MemoryCard;
public:
GCSaveData(EGG::Heap* heap, nand::LayoutFile* layoutFile, const char* directory, const char* fileName,
math::VEC3 translate);
virtual ~GCSaveData();
virtual void onPoint(const char* paneName, controller::Interface* controller);
virtual void onLeft(const char* paneName);
virtual void onTrig(const char* paneName);
void calc();
void draw();
void update();
void init();
void setTranslate(const nw4r::math::VEC3& translate);
const nw4r::math::VEC3* getTranslate();
void setBalloon(TextBalloon* balloon);
private:
MemoryBaseEvent* mpEvent; // 0x34
TextBalloon* mpBalloon; // 0x38
u8 mSlot; // 0x3C
s16 mIndex; // 0x3E
nw4r::ut::Link mLink; // 0x40
};
} // namespace scene
} // namespace ipl
#endif // IPL_SCENE_GC_SAVE_DATA_H

View File

@@ -3,14 +3,87 @@
#include "iplSceneHeader.h"
#include "scene/memoryCard/iplMemoryCardBase.h"
#include "scene/memoryCard/iplMemoryCardManager.h"
#include "math/iplMathTypes.h"
namespace ipl {
namespace scene {
SCENE_CLASS(MemoryCard) {
class GCSaveData;
class GCWindow;
class SavedataEditWindow;
class MemoryCard : public Base, public MemoryBase {
public:
MemoryCard(EGG::Heap * heap);
MemoryCard(EGG::Heap* heap);
virtual ~MemoryCard();
virtual BOOL isResetAcceptable() const;
virtual void prepare();
virtual void create();
virtual void calc();
virtual void draw();
virtual void onPoint(const char* paneName, controller::Interface* controller);
virtual void onLeft(const char* paneName);
virtual void onTrig(const char* paneName);
void onFocus(void* data);
void onRelease();
MemoryCardManager* getManager() { return mpManager; }
private:
u8 unk_0x54[0x7C];
enum {
SLOT_A = 0,
SLOT_B,
};
void on_fadein1st();
void on_fadein2nd();
void on_normal();
void on_scroll_r();
void on_scroll_l();
void on_change_tag1st();
void on_change_tag2nd();
void on_fadeout1st();
void on_fadeout2nd();
void on_error();
void on_insert_card();
void on_detach_card();
void start_savedata_fadein();
void start_savedata_fadeout();
void start_errormessage_fadein();
int update_slot();
void show_arw();
void show_capacity(u8 slot);
void scroll_common();
void start_scroll_r();
void start_scroll_l();
private:
s32 mState; // 0x88
s32 mPrevState; // 0x8C
u8 mSlot; // 0x90
u8 unk_0x91[3]; // 0x91
s32 mSlotState[2]; // 0x94
s16 mIconIndex; // 0x9C
s16 mIconCount; // 0x9E
u8 mShowArwR; // 0xA0
u8 mShowArwL; // 0xA1
u8 unk_0xA2[2]; // 0xA2
MemoryCardManager* mpManager; // 0xA4
MemoryBaseEvent* mpEvent; // 0xA8
nw4r::ut::List mSaveDataList; // 0xAC
nand::LayoutFile* mBalloonLayoutFile; // 0xB8
nw4r::ut::List mBalloonList; // 0xBC
GCSaveData* mpFocusSaveData; // 0xC8
GCWindow* mpGCWindow; // 0xCC
};
} // namespace scene
} // namespace ipl

View File

@@ -0,0 +1,144 @@
#ifndef IPL_SCENE_MEMORY_CARD_BASE_H
#define IPL_SCENE_MEMORY_CARD_BASE_H
#include <nw4r/ut.h>
#include "layout/iplLayout.h"
#include "layout/iplGuiManager.h"
#include "system/iplController.h"
namespace ipl {
namespace scene {
class TextBalloon;
class SettingButton;
class MemoryBase;
}
namespace nand {
class LayoutFile;
}
namespace scene {
class MemoryBaseEvent : public ::gui::EventHandler {
public:
#ifdef IPL_MEMORYCARD_BASE_EVENT_OUT_OF_LINE
MemoryBaseEvent(MemoryBase* base);
#else
MemoryBaseEvent(MemoryBase* base) : mpBase(base) {}
#endif
virtual ~MemoryBaseEvent();
virtual void onEvent(u32 componentID, u32 event, void* data);
private:
MemoryBase* mpBase; // 0x0C
};
class MemoryBase {
public:
class Anm {
public:
Anm(layout::GroupAnimator* anim) : mAnim(anim) {}
virtual ~Anm();
layout::GroupAnimator* mAnim; // 0x04
nw4r::ut::Link mLink; // 0x08
};
class Button {
public:
Button(nw4r::lyt::Pane* pane) : unk_0x04(0), mPane(pane) {}
virtual ~Button();
u32 unk_0x04; // 0x04
nw4r::lyt::Pane* mPane; // 0x08
nw4r::ut::Link mLink; // 0x0C
};
class AnmButton {
public:
AnmButton(const char* name, Anm* anm1, Anm* anm2, Anm* anm3)
: unk_0x04(0), mName(name), mCurrentAnm(NULL), mAnm1(anm1), mAnm2(anm2), mAnm3(anm3),
unk_0x24(0), mLastCmd(0), mpBalloon(NULL) {}
virtual ~AnmButton();
void calc();
void onCmdRecv(int command);
void setBalloon(TextBalloon* balloon);
int unk_0x04; // 0x04
const char* mName; // 0x08
Anm* mCurrentAnm; // 0x0C
Anm* mAnm1; // 0x10
Anm* mAnm2; // 0x14
Anm* mAnm3; // 0x18
nw4r::ut::Link mLink; // 0x1C
u32 unk_0x24; // 0x24
int mLastCmd; // 0x28
TextBalloon* mpBalloon; // 0x2C
};
struct AnmName {
const char* anmFile;
const char* groupName;
};
#ifdef IPL_MEMORYCARD_BASE_CTOR_OUT_OF_LINE
MemoryBase();
#else
MemoryBase() : mpLayout(NULL), unk_0x08(NULL) {
nw4r::ut::List_Init(&mAnmList, offsetof(Anm, mLink));
nw4r::ut::List_Init(&mButtonList, offsetof(Button, mLink));
nw4r::ut::List_Init(&mAnmButtonList, offsetof(AnmButton, mLink));
}
#endif
#ifdef IPL_MEMORYCARD_BASE_OUT_OF_LINE
virtual ~MemoryBase();
#else
virtual ~MemoryBase() {}
#endif
virtual void onPoint(const char* paneName, controller::Interface* controller);
virtual void onLeft(const char* paneName);
virtual void onMove(const char* paneName);
virtual void onTrig(const char* paneName);
virtual void add_button(const char** paneNames, int count);
virtual void add_anmbutton(const char* paneName, Anm* anm1, Anm* anm2, Anm* anm3);
virtual Button* get_button(const char* paneName);
virtual AnmButton* get_anmbutton(const char* paneName);
virtual void clear_button(const char* paneName);
virtual void add_animation(const AnmName* anmNames, int count);
virtual Anm* get_animation(int index);
virtual void do_animation(int index);
virtual void do_animation(int index, bool flag);
virtual void stop_animation(int index);
virtual bool is_animation(int index);
virtual bool is_fadein_enable();
virtual void set_visible(const char* paneName, bool flag);
void set_textbox(const char* paneName, u32 message);
void set_textbox(const char* paneName, u32 message, int x, int y);
void set_textbox(const char* paneName, const wchar_t* text, f32 x, f32 y);
void set_textbox(const char* paneName, const wchar_t* text);
SettingButton* get_setting_button();
void change_button_text_close();
void change_button_text_return();
void change_button_text_ok();
void show_button_return();
void show_button_ok();
protected:
layout::Object* mpLayout; // 0x04
nand::LayoutFile* unk_0x08; // 0x08
gui::PaneManager* mpPaneManager; // 0x0C
nw4r::ut::List mAnmList; // 0x10
nw4r::ut::List mButtonList; // 0x1C
nw4r::ut::List mAnmButtonList; // 0x28
};
} // namespace scene
} // namespace ipl
#endif // IPL_SCENE_MEMORY_CARD_BASE_H

View File

@@ -0,0 +1,107 @@
#ifndef IPL_SCENE_MEMORY_CARD_MANAGER_H
#define IPL_SCENE_MEMORY_CARD_MANAGER_H
#include <revolution/types.h>
#include <revolution/gx.h>
#include <private/card.h>
#include <wchar.h>
#include "iplMemoryCardLib.h"
namespace ipl {
namespace scene {
class MemCardEventHandler {
public:
MemCardEventHandler() {}
virtual ~MemCardEventHandler();
virtual void onMemEvent(long event, u8 slot);
};
typedef struct MCFile {
u32 fileNo; // 0x00
u32 unk_0x04; // 0x04
u32 unk_0x08; // 0x08
s32 sortKey; // 0x0C
} MCFile; // 0x10
typedef struct MCFileCell {
wchar_t comment[2][0x40]; // 0x000
s16 iconAnmCounter; // 0x100
u16 unk_0x102; // 0x102
GXTexObj icon; // 0x104
GXTexObj banner; // 0x124
GXTlutObj iconTlut; // 0x144
GXTlutObj bannerTlut; // 0x150
} MCFileCell; // 0x15C
class MemoryCardManager {
public:
MemoryCardManager() {
MCFileCell* pCell = mFileCell[0];
do {
pCell->iconAnmCounter = 0;
wmemset(pCell->comment[0], 0, 0x40);
pCell++;
} while (pCell < mFileCell[2]);
mLastResult = 0;
mLastCmd = 0;
__CARDSetDiskID(NULL);
memorycard::initCardThread();
sort_file_array(0);
sort_file_array(1);
}
virtual ~MemoryCardManager();
void calc();
bool isSlotReady(u8 slot);
bool isSlotNoCard(u8 slot);
long isSlotWrongDevice(u8 slot);
void sort_file_array(u8 slot);
void sendCardCmdMove(u8 slot, s16 index);
void sendCardCmdCopy(u8 slot, s16 index);
void sendCardCmdDelete(u8 slot, s16 index);
void sendCardCmdFormat(u8 slot);
bool isDistSlot(u8 slot, long* pState);
bool isMoveEnable(u8 slot, u32 index, long* pCode);
bool isCopyEnable(u8 slot, u32 index, long* pCode);
bool isIconValidate(u8 slot, s16 index);
bool isBannerEnable(u8 slot, s16 index);
void update_icon_anm();
void update_file_array(u8 slot);
void update_change_cardstate(u8 slot);
GXTexObj* create_icon(u8 slot, s16 index);
GXTexObj* create_icon(u8 slot, s16 index, long start);
GXTexObj* _create_icon(u8 slot, s16 fileNo, long start);
const wchar_t* getComment(u8 slot, s16 index, int which);
GXTexObj* create_banner(u8 slot, s16 index);
u16 getBlocks(u8 slot, s16 index);
u16 getFreeBlocks(u8 slot);
void setEventHandler(MemCardEventHandler* eventHandler) {
mpEventHandler = eventHandler;
}
private:
u32 unk_0x04; // 0x00004
MCFile mFile[2][0x7F]; // 0x00008
MCFileCell mFileCell[2][0x7F]; // 0x00FE8
s32 mLastResult; // 0x16930
s32 mLastCmd; // 0x16934
u32 unk_0x16938; // 0x16938
MemCardEventHandler* mpEventHandler; // 0x1693C
};
} // namespace scene
} // namespace ipl
#endif // IPL_SCENE_MEMORY_CARD_MANAGER_H

View File

@@ -11,6 +11,12 @@
namespace ipl {
namespace scene {
#ifdef IPL_SD_CHANNEL_SELECT_CPP
namespace {
class SDChannelSelectButtonEventHandler;
}
#endif
class SDButtonEventHandlerBase : public ::gui::EventHandler {
public:
virtual void onEvent(u32 compId, u32 event, void* data);
@@ -91,8 +97,17 @@ namespace ipl {
void startLeftEvent(const char* paneName);
bool isActive() const;
#ifdef IPL_SD_CHANNEL_TITLE_CPP
bool isLeftArrowVisible() const { return mbArrowVisible[ARROW_BTN_LEFT]; }
static const char* getButtonName(int button) { return smButtonName[button]; }
#endif
#ifdef IPL_SD_CHANNEL_SELECT_CPP
void setEventHandler(::gui::EventHandler * event,
::gui::EventHandler * optOutEvent = NULL);
#else
void setEventHandler(::gui::EventHandler * event, ::gui::EventHandler * optOutEvent);
#endif
void setText(const char* paneName, u32 msgId);
void setText(const char* paneName, const wchar_t* text);
@@ -156,6 +171,10 @@ namespace ipl {
friend class SDArrow;
friend class SDButtonEventHandlerBase;
#ifdef IPL_SD_CHANNEL_SELECT_CPP
friend class SDChannelSelect;
friend class SDChannelSelectButtonEventHandler;
#endif
};
} // namespace scene
} // namespace ipl

View File

@@ -10,6 +10,8 @@
namespace ipl {
namespace scene {
class SDChannelSelect;
class SDMemory {
public:
struct TitleRange {
@@ -20,9 +22,10 @@ namespace ipl {
SDMemory();
~SDMemory();
void create(EGG::Heap* heap, nand::LayoutFile* layoutFile, NandSDCardManager* manager);
void create(EGG::Heap* heap, nand::LayoutFile* layoutFile, SDChannelSelect* channelSelect);
void setTitleLists(const TitleRange& nandTitles, const TitleRange& sdTitles);
bool calc();
void draw();
void setScrollLimit();
void updateSideArrows();
void resetScrollArrows();
@@ -36,8 +39,13 @@ namespace ipl {
void hideLeftArrow();
void hideRightArrow();
#ifdef IPL_SD_CHANNEL_TITLE_CPP
public:
#else
private:
#endif
s32 updateState();
void drawTransferTitles();
void onDialogState0();
void onDialogState2();
bool onDialogState3();
@@ -63,6 +71,44 @@ namespace ipl {
bool onDialogState24();
void resetDialogPaneAnimations();
s32 getControlPaneIndex(const char* paneName);
void activateControlPane(const char* paneName, ::gui::Component* component);
void deactivateControlPane(const char* paneName);
void cancelControlPane(const char* paneName);
s32 getTitlePaneIndex(const char* paneName);
void activateTitlePane(const char* paneName, ::gui::Component* component);
void deactivateTitlePane(const char* paneName);
void selectTitlePane(const char* paneName);
s32 getDialogPaneIndex(const char* paneName);
void activateDialogPane(const char* paneName, ::gui::Component* component);
void deactivateDialogPane(const char* paneName);
void selectDialogPane(const char* paneName);
class ControlPaneEventHandler : public ::gui::EventHandler {
public:
ControlPaneEventHandler(SDMemory* instance) : ::gui::EventHandler(), mpInstance(instance) {}
virtual void onEvent(u32 compId, u32 event, void* data);
private:
SDMemory* mpInstance;
};
class TitlePaneEventHandler : public ::gui::EventHandler {
public:
TitlePaneEventHandler(SDMemory* instance) : ::gui::EventHandler(), mpInstance(instance) {}
virtual void onEvent(u32 compId, u32 event, void* data);
private:
SDMemory* mpInstance;
};
class DialogPaneEventHandler : public ::gui::EventHandler {
public:
DialogPaneEventHandler(SDMemory* instance) : ::gui::EventHandler(), mpInstance(instance) {}
virtual void onEvent(u32 compId, u32 event, void* data);
private:
SDMemory* mpInstance;
};
layout::Object* mpMainLayout;
layout::Object* mpTitleLayout;
@@ -77,7 +123,7 @@ namespace ipl {
u32 mPanelStates[3];
u32 mTitlePanelStates[5];
u32 mPanelAnimationStates[4];
NandSDCardManager* mpNandSDCardManager;
SDChannelSelect* mpSDChannelSelect;
TitleRange mNandTitleRange;
TitleRange mSDTitleRange;
u32 mTitleCount;
@@ -86,11 +132,11 @@ namespace ipl {
ESTitleId mTitleIds[96];
wchar_t mTitleNames[96][21];
u32 mTitleNameCount;
u32 mNandTitleNameCount;
ESTitleId mNandTitleIds[96];
u32 mNandTitleCount;
u32 mSDTitleCount;
ESTitleId mSDTitleIds[96];
u32 mNandTitleCount;
u32 mNandTitleNameCount;
ESTitleId mNandTitleIds[96];
wchar_t mCurrentTitleName[0x840];
u8 mTransferFlags[4];
u32 mTransferStatus;
@@ -107,8 +153,10 @@ namespace ipl {
scroller mScroller;
s32 mButtonState;
u8 mControllerFlags[4];
#ifndef IPL_SD_CHANNEL_TITLE_CPP
u32 mFinalState[3];
u8 mFinalFlags[4];
#endif
};
} // namespace scene
} // namespace ipl

View File

@@ -10,6 +10,14 @@
namespace ipl {
namespace scene {
#ifdef IPL_SD_CHANNEL_SELECT_CPP
class SDChannelSelect;
namespace {
class SDChannelSelectEventHandler;
class SDChannelSelectButtonEventHandler;
}
#endif
class SDChannelObj {
public:
SDChannelObj(EGG::Heap* heap, int page, int index);
@@ -18,8 +26,13 @@ namespace ipl {
EGG::Heap* getHeap() const { return mpHeap; }
int getPage() const { return mPage; }
int getIndex() const { return mIndex; }
nw4r::math::VEC3& getTranslate() const;
#ifdef IPL_SD_CHANNEL_TITLE_CPP
public:
#else
private:
#endif
friend class SDChannelSelect;
nw4r::ut::Link mListLink;
@@ -60,10 +73,16 @@ namespace ipl {
extern "C" void iplSDChannelObj_813E311C(SDChannelObj* channel, EGG::ExpHeap* firstHeap,
EGG::ExpHeap* secondHeap);
extern "C" void iplSDChannelObj_813E322C(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E32C8(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E34E0(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E3178(SDChannelObj* channel, nw4r::lyt::Pane* pane);
extern "C" void iplSDChannelObj_813E3180(SDChannelObj* channel, nand::LayoutFile* layoutFile);
extern "C" void iplSDChannelObj_813E3304(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E330C(SDChannelObj* channel);
extern "C" void iplSDChannelObj_813E3354(SDChannelObj* channel, int state);
extern "C" void iplSDChannelObj_813E33EC(SDChannelObj* channel, int state);
extern "C" void iplSDChannelObj_813E3480(SDChannelObj* channel, bool selected);
extern "C" void iplSDChannelObj_813E34E8(SDChannelObj* channel, int enabled);
extern "C" void* iplSDChannelObj_813E3128(SDChannelObj* channel);
extern "C" bool iplSDChannelObj_813E3330(SDChannelObj* channel);
@@ -125,6 +144,11 @@ namespace ipl {
SDChannelSelect(EGG::Heap* heap);
virtual ~SDChannelSelect();
NandSDWorker::WorkSDState getSDState() const {
return static_cast<NandSDWorker::WorkSDState>(mCurrentSDState);
}
NandSDWorker* getWorker() const { return mpSDWorker; }
virtual BOOL isResetProcessDone();
virtual void startResetting();
virtual void prepare();
@@ -137,6 +161,14 @@ namespace ipl {
virtual FaderSceneCommand calcNormal();
virtual FaderSceneCommand calcFadeout();
void onButtonEvent(const char* paneName, u32 event,
const controller::Interface* controller);
BOOL onEventDerived(const char* paneName, u32 event,
controller::Interface* controller);
bool collectTitlesByUsage(const s32* firstUsage, const s32* secondUsage,
ESTitleId* titleIds, char* titleNames,
u32* titleCount);
static const char* mscChannelPaneNames[PAGE_COUNT][MAX_CHANNEL_INDEX];
static const char* mscBasePaneNames[PAGE_COUNT];
static const char* mscPicturePaneNames[PAGE_COUNT];
@@ -144,7 +176,15 @@ namespace ipl {
static const char* mscClockPaneNames[3];
static const char* mscMaskPaneName;
#ifdef IPL_SD_CHANNEL_TITLE_CPP
public:
#else
private:
#endif
#ifdef IPL_SD_CHANNEL_SELECT_CPP
friend class SDChannelSelectEventHandler;
friend class SDChannelSelectButtonEventHandler;
#endif
void enqueueStartNotice();
bool enqueueFinishNotice();
bool enqueueNotice(u32 highTitleId, u32 lowTitleId, u32 result);
@@ -162,16 +202,40 @@ namespace ipl {
void calcChannelObjects();
void updateChannelObjects();
void updateChannelObject(SDChannelObj* channel);
void drawChannelTransitionObjects();
void drawChannelObjects();
bool isChannelInCalc(int page, int index, int currentPage) const;
nw4r::lyt::Pane* getChannelBasePane(int page, int index, int currentPage) const;
int getCenterChannelIndex(const char* paneName) const;
nw4r::lyt::Pane* getCenterChannelPane(int index) const;
nw4r::lyt::Pane* getChannelPane(int index) const;
static math::VEC3 getChannelPanePosition(SDChannelSelect* scene, int index);
void calcPageAnimations();
void processNormalInput();
void updateArrowVisibility();
void processWorkerState();
void updateDialogAnimation();
void initializeNormalPage();
void updatePageTransform();
void setChannelScissor(const SDChannelObj* channel) const;
bool isCurrentTitleUsageEnough(const s32* usage) const;
void getCurrentTitleUsage(s32* bytes, s32* blocks) const;
bool collectTitlesByChannelOrder(const s32* firstUsage, const s32* secondUsage,
ESTitleId* titleIds, char* titleNames,
u32* titleCount);
bool collectTitlesFromNandUsage(const s32* firstUsage, const s32* secondUsage,
ESTitleId* titleIds, char* titleNames,
u32* titleCount);
bool collectTitlesBySpecialChannels(const s32* firstUsage, const s32* secondUsage,
ESTitleId* titleIds, char* titleNames,
u32* titleCount);
bool collectTitlesForMode(const s32* firstUsage, const s32* secondUsage,
ESTitleId* titleIds, char* titleNames,
u32* titleCount, int searchMode);
bool findAdjacentChannel(int direction, int* page, int* index) const;
void setStateAndPlaySelectSound(int state) NO_INLINE;
void finishDialogOperation();
void finishDialogTransition();
void processWorkerCommands();
void handleWorkerStartup();
void handleNandTitleCount();
@@ -205,9 +269,38 @@ namespace ipl {
SDChannelObj* findChannelObject(int page, int index) const;
void createChannelObject(int page, int index);
void createBaseLayout();
void updateNoCardLayouts();
void createChannelThumbnails();
void createSceneLayouts();
BOOL isChannelMoveTarget(int page, int index) const;
void selectChannel(int page, int index);
BOOL prepareRestarting(int page);
void startPageTransition(int page, int index);
void setCurrentPageAndRefresh(int page, int index, SDChannelObj* keepChannel);
void handleFourPageDialog();
void handleThreePageDialog();
void setPageActionFrame();
void advancePageAnimation();
void finishPageScroll();
void finishCardDialog();
void flushSaveDataAndMountSD();
void startDrag(const controller::Interface* controller, int page, int index);
void finishDrag();
void moveDrag();
void updateDragState();
void updateDragPageTransition();
void finishDragWait();
void finishDragPageTransition();
void applyChannelMove();
void finishChannelMove();
void resetDragPreview();
void finishDragPageChange();
BOOL isPageCreated(int page) const;
void refreshPageObjects(int page, SDChannelObj* keepChannel, int noticeIndex);
void updateChannelObjectOrder(int page);
void moveChannelObjectsToDrawOrder(int page, int mode);
void setLayoutFrame(int state);
BOOL tellStartingZoomAnm();
void initPageAnimations(const math::VEC3& position, int direction);
static BOOL isChannelReady(const SDChannelObj* channel);
nw4r::ut::List mChannelObjects;
nand::LayoutFile* mpLayoutFile;
layout::Object* mpLayout;
@@ -223,7 +316,7 @@ namespace ipl {
int mCurrentChannelIndex;
f32 mThumbOffsetX;
f32 mThumbOffsetY;
nw4r::math::VEC3 mPosition;
math::VEC3 mPosition;
math::VEC2 mScale;
f32 mAspectRatioScale;
bool mbLeftArrowVisible;
@@ -246,9 +339,9 @@ namespace ipl {
bool mbButtonEnabled;
bool mbDialogActive;
u16 mInputFlags;
SDChannelObj* mpCurrentChannel;
void* mpCurrentChannel;
layout::Object* mpStateLayout;
layout::Object* mpHelpLayout;
layout::Animator* mpHelpLayout;
EGG::ExpHeap* mpRsoHeap;
channel::RsoThread* mpRsoThread;
u32 mCommandQueueState;
@@ -264,8 +357,8 @@ namespace ipl {
ESTitleId32* mpSDTitleIds;
SDChannelSelectTitleInfo* mpSDTitleInfo;
NandSDWorker::TitleUsage* mpNandTitleInfo;
u32 mFirstTitleCount;
u32 mSecondTitleCount;
s32 mFirstTitleCount;
s32 mSecondTitleCount;
SDChannelObj* mpCurrentLoadedChannel;
u32 mSDTitleCount;
u32 mNandTitleCount;
@@ -279,8 +372,8 @@ namespace ipl {
u8 mbShowNoCardMessage;
u8 mbOperationActive;
u8 mbSDCardBroken;
u32 mOperationState;
u32 mDialogState;
int mOperationState;
int mDialogState;
nand::File* mpSaveDataFile;
u32 mAnimationState;
u32 mAnimationTarget;

View File

@@ -3,15 +3,104 @@
#include "iplSceneHeader.h"
#ifdef IPL_SD_CHANNEL_TITLE_CPP
#include "math/iplInterporation.h"
#include "scene/sdChannelMemory/iplSDMemory.h"
#include "system/iplChannelRsoThread.h"
#include "utility/iplCapture.h"
#include <private/es.h>
#include <nw4r/snd/SoundHandle.h>
#endif
namespace ipl {
namespace scene {
class SDChannelSelect;
class SDButtonEventHandlerBase;
FADER_SCENE_CLASS(SDChannelTitle) {
public:
SDChannelTitle(EGG::Heap * heap, SDChannelSelect * chanSel);
#ifdef IPL_SD_CHANNEL_TITLE_CPP
virtual ~SDChannelTitle();
virtual void prepare();
virtual void create();
virtual void calcCommon();
virtual FaderSceneCommand calcFadein();
virtual FaderSceneCommand calcNormal();
virtual void initCalcFadeout();
virtual FaderSceneCommand calcFadeout();
virtual void draw();
virtual void destroy();
BOOL isResetAcceptable();
virtual void startResetting();
using Base::reserveAllSceneDestruction;
using Base::createChildScene;
s32 mState;
EGG::ExpHeap* mpBannerHeap;
EGG::ExpHeap* mpCaptureHeap;
s32 mPage;
s32 mIndex;
s32 mPageCount;
s32 mNextScene;
s32 mParentalResult;
math::VEC3 mPosition;
u32 mLaunchFrame;
s32 mStartButtonState;
bool mbBannerStarting;
layout::Animator* mpButtonAnimations[7][6];
math::HermiteIntp<f32>* mpFade;
SDChannelSelect* mpChannelSelect;
nand::LayoutFile* mpLayoutFile;
layout::Object* mpLayout;
gui::PaneManager* mpPaneManager;
layout::Object* mpIconLayout;
EGG::ExpHeap* mpIconHeap;
layout::Object* mpProgressLayout;
s32 mLoadedIndex;
nand::LayoutFile* mpBannerFiles[2];
nand::File* mpSoundFiles[2];
layout::Object* mpBannerLayout;
layout::Animator* mpBannerAnimations[3];
nw4r::snd::SoundHandle* mpSoundHandle;
nand::File* mpSaveFile;
u32 mWpadStopTick;
s32 mHoverCounts[2];
SDButtonEventHandlerBase* mpButtonEventHandler;
utility::Capture* mpScreenCapture;
utility::Capture* mpBannerCapture;
ESTmdView* mpTmd;
u8 mbTmdReady;
u8 mTitleFlags;
u16 mMakerCode;
u8 mbStartAnimation;
s32 mScriptState;
s32 mScriptEnabled;
bool mbStopScript;
u32 mScriptFrame;
u32 mScriptDuration;
nand::File* mpScriptFile;
EGG::ExpHeap* mpScriptHeaps[2];
s32 mScriptHeapIndex;
channel::RsoThread* mpRsoThread;
EGG::ExpHeap* mpRsoHeap;
layout::Animator* mpScriptAnimations[16];
bool mbScriptFailed;
EGG::ExpHeap* mpScriptHeap;
ESTitleId mTitleId;
SDMemory::TitleRange mTitleRange;
u8 mUnknownTitleWork[0x800];
SDMemory mMemory;
u32 mErrorMessage;
s32 mChangeFrame;
u8 mbCopiedTitle;
u8 mbResetAcceptable;
nw4r::snd::SoundHandle* mpCopySound;
#else
private:
u8 unk_0x58[0x3460];
#endif
};
} // namespace scene
} // namespace ipl

View File

@@ -0,0 +1,32 @@
#ifndef IPL_SCENE_SETTING_AOSS_H
#define IPL_SCENE_SETTING_AOSS_H
#include <revolution/ncd/NCDTypes.h>
#include <revolution/types.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct AOSSInitInput {
u16 flags;
u8 mode;
u8 reserved;
u16 ssidLength;
u8 ssid[0x100];
s16 options[5];
u8 optionData[6];
u8 status;
u8 result[0x154];
} AOSSInitInput;
int AOSSi_Init(AOSSInitInput* input);
int AOSS_Init_old(AOSSInitInput* input);
void* AOSSi_Alloc(u32 size);
void AOSSi_Free(void* block);
#ifdef __cplusplus
}
#endif
#endif

View File

@@ -36,6 +36,11 @@
#define MAX_CHANNEL_INFO_SIZE CHANNEL_INFO_SIZE(MAX_CHANNEL_PAGE, MAX_CHANNEL_INDEX)
namespace ipl {
#ifdef IPL_SD_CHANNEL_SELECT_CPP
namespace scene {
class SDChannelSelect;
}
#endif
namespace channel {
enum {
PRIMARY_TYPE_NONE = 0,
@@ -368,6 +373,9 @@ namespace ipl {
char* getChJumpData() { return mChJumpData; }
private:
#ifdef IPL_SD_CHANNEL_SELECT_CPP
friend class ipl::scene::SDChannelSelect;
#endif
typedef struct MD5Head {
u8 magic[4]; // 0x00 (`IMD5`; "IPL MD5"?)
u32 length; // 0x04

View File

@@ -327,6 +327,9 @@ namespace ipl {
void setProgBarLength(int len) { mProgBarLen = len; }
/** @return The current length of the progress bar */
int getProgBarLength() { return mProgBarLen; }
#ifdef IPL_SDMEMORY_DIALOG_PROGRESS_FRAME_ACCESSOR
int getProgBarFrame() const { return mProgBarFrame; }
#endif
/**
* Dialog component handler (Automatically executed by the GUI manager)

View File

@@ -151,6 +151,10 @@ namespace ipl {
BOOL is_terminated();
BOOL is_working();
#ifdef IPL_SD_CHANNEL_SELECT_CPP
void requestCancel() { unk_0x04 = true; }
#endif
WIISaveBannerFile* get_cached_nand_save_banner(ESTitleId titleId);
void* get_cached_nand_app_thumbnail(ESTitleId titleId, u32*);
WIISaveBannerFile* get_cached_sd_save_banner(ESTitleId32 titleId);
@@ -179,6 +183,10 @@ namespace ipl {
static const int SD_APP_BACKUP_THUMBNAIL_LENGTH = 0xC800;
#ifdef IPL_SDMEMORY_COMPLETION_PCT_ACCESSOR
static int getCompletionPct() { return s_completion_pct; }
#endif
protected:
static const int FAT_PAGES = 8;
static const int DATA_PAGES = 32;

View File

@@ -15,6 +15,11 @@
#define SAVEDATA_VERSION 3
namespace ipl {
#ifdef IPL_SD_CHANNEL_SELECT_ACCESS
namespace scene {
class SDChannelSelect;
}
#endif
namespace channel {
class Manager;
}
@@ -29,6 +34,9 @@ namespace ipl {
void initManager();
void setPrevPage(int prevPage);
#ifdef IPL_SD_CHANNEL_TITLE_CPP
int& getSDPrevPage() { return mData.prevSDPage; }
#endif
void setChanInfo(int page, int index, const channel::SInfo& chanInfo);
void setMemoSetting(const textinput::extend::savedata::MemoSetting& memoSetting);
@@ -54,6 +62,7 @@ namespace ipl {
int getLastSDPrevPage() { return mLastSDPrevPage; }
void setLastSDPrevPage(int page) { mLastSDPrevPage = page; }
BOOL didntGotoSDMenu() const { return mData.didntGotoSDMenu; }
void setDidntGotoSDMenu(BOOL value) { mData.didntGotoSDMenu = value; }
#endif
bool hasPhotoMP3Dummy() { return mbPhotoMP3; }
@@ -68,6 +77,9 @@ namespace ipl {
void iplSavedata_813596B8(ESTitleId titleId);
private:
#ifdef IPL_SD_CHANNEL_SELECT_ACCESS
friend class ipl::scene::SDChannelSelect;
#endif
BOOL checkValidApp(ESTitleId titleId);
static void initManagerTask(void* work);

View File

@@ -73,6 +73,9 @@ namespace ipl {
void setDownLimit(f32 v) { mDownLimit = v; }
void setUpLimit(f32 v) { mUpLimit = v; }
#ifdef IPL_SDMEMORY_SCROLLER_STATE_ACCESSOR
void setState(int state) { mState = state; }
#endif
void addScroll(f32 v) { mScroll += v; }

View File

@@ -55,6 +55,12 @@ namespace nw4r {
NW4R_ASSERT(type < TEXTCOLOR_MAX);
return mTextColors[type];
}
#ifdef IPL_SDMEMORY_SET_TEXT_COLORS
void SetTextColors(const ut::Color& first, const ut::Color& second) {
mTextColors[0] = first;
mTextColors[1] = second;
}
#endif
void SetTextColor(u32 type, ut::Color value) {
NW4R_ASSERT(type < TEXTCOLOR_MAX);
mTextColors[type] = value;

View File

@@ -157,11 +157,15 @@ namespace nw4r {
y = pF[1];
z = pF[2];
}
#if defined(IPL_SD_CHANNEL_SELECT_CPP)
VEC3(f32 fx, f32 fy, f32 fz);
#else
VEC3(f32 fx, f32 fy, f32 fz) {
x = fx;
y = fy;
z = fz;
}
#endif
operator Vec*() { return reinterpret_cast<Vec*>(this); }
operator const Vec*() const { return reinterpret_cast<const Vec*>(this); }

View File

@@ -160,11 +160,12 @@ typedef struct _ziGetParam {
ziWChar* candidates; // 0x18
ziU8 maxCandidates; // 0x1C
ziWChar firstCandidate; // 0x1E
ziU8 wordCandidates; // 0x1F
ziU8 unk_0x20; // 0x20
ziU8 count; // 0x20
ziU8 letters; // 0x21
ziU8* scratch; // 0x22
ziU8 count; // 0x22
ziU8* scratch; // 0x24
ziU32 unk_0x28; // 0x28
} ziGetParam;
typedef struct _ziLanguageEntry {
@@ -172,20 +173,195 @@ typedef struct _ziLanguageEntry {
ziU8* tableData; // 0x04
} ziLanguageEntry;
typedef struct _zi8DawgRec {
ziU8* node;
ziU32 attr;
ziU16 key;
ziU8 unk_0x0A[2];
ziU8* back;
} zi8DawgRec;
typedef struct _zi8DawgCtx {
ziU8 lang; // 0x00
ziU8 key; // 0x01
ziU16 cnt; // 0x02
ziU16 cap; // 0x04
ziU8 unk_0x06[2];
ziU8* p08; // 0x08
ziU8* p0C; // 0x0C
ziU8* table; // 0x10
ziU8* p14; // 0x14
zi8DawgRec recs[0x32]; // 0x18
ziU32 unk_0x338; // 0x338
} zi8DawgCtx;
typedef struct _ziUwdNode {
struct _ziUwdNode* next;
ziU8* word;
} ziUwdNode;
struct __zi8_work_data_s {
ziU8 unk_0x00;
ziU8 unk_0x01;
ziU8 unk_0x02[2];
ziLanguageEntry* langEntries; // 0x04
ziU32 unk_0x08;
ziU8 unk_0x08;
ziU8 unk_0x09;
ziU8 unk_0x0A;
ziU8 unk_0x0B;
ziU32 unk_0x0C;
ziU32 unk_0x10;
ziU32 unk_0x14;
ziU16 unk_0x14;
ziU8 unk_0x16;
ziU8 unk_0x17;
ziU8 unk_0x18;
ziU8 unk_0x1C[0x108];
ziU8 unk_0x19;
ziU16 unk_0x1A;
ziU8 unk_0x1C[3];
ziU8 unk_0x1F;
ziU16 unk_0x20[0x40];
ziU16 unk_0xA0[0x42];
ziU16* unk_0x124[1];
ziU8* unk_0x128;
ziU8 unk_0x12C;
ziU8 unk_0x12D;
ziU8 unk_0x12E;
ziU8 unk_0x12F;
ziPtr unk_0x130[2];
ziU8 unk_0x138;
ziU8 unk_0x139[3];
ziU32 unk_0x13C;
ziU8 unk_0x140;
ziU8 unk_0x141[0x43];
ziU8 unk_0x184[0x43];
ziU8 uwdCount; // 0x1C7
ziUwdNode uwdNodes[0x20]; // 0x1C8
ziUwdNode* uwdList; // 0x2C8
ziU32 pudTable[0x10]; // 0x2CC
ziU8 pudCount; // 0x30C
ziU8 unk_0x30D[3];
ziU32 unk_0x310;
ziU32 unk_0x314;
ziU32 unk_0x318;
ziU8 pdRemoveOpt; // 0x31C
ziU8 unk_0x31D;
ziU8 unk_0x31E;
ziU8 unk_0x31F;
ziU8 (*oemMatch)(ziU16 idx, ziWChar* buf, ziU8 len, ziPtr data); //0x320
ziU16 oemLen; //0x324
ziU8 unk_0x326[2];
ziU32 oemIdx; //0x328
ziPtr oemData; //0x32C
ziU8 unk_0x330[8];
ziU32 unk_0x338;
ziU8 unk_0x33C[0x1FC];
ziU8 unk_0x538;
ziU8 unk_0x539;
ziU8 unk_0x53A[0x40];
ziWChar unk_0x57A[0x641];
ziPtr unk_0x11FC;
ziPtr userKeys[0x83]; // 0x1200
ziU8 unk_0x140C[4];
ziU32 unk_0x1410;
ziU8 unk_0x1414[4];
ziU8 unk_0x1418;
ziU8 unk_0x1419;
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* unk_0x1764; // 0x1764
ziU8 unk_0x1768;
ziU8 unk_0x1769[0x81];
ziU16 unk_0x17EA;
ziU8 unk_0x17EC;
ziU8 unk_0x17ED[3];
ziU8* unk_0x17F0;
ziWChar unk_0x17F4[0x40]; // 0x17F4..0x1874
ziU16 unk_0x1874;
ziU8 unk_0x1876;
ziU8 unk_0x1877;
ziU8 unk_0x1878;
ziU8 unk_0x1879;
ziWChar unk_0x187A[0x41];
ziU8 unk_0x18FC;
ziU8 unk_0x18FD;
ziWChar unk_0x18FE[0x41];
ziU8 unk_0x1980;
ziU8 unk_0x1981;
ziU8 unk_0x1982;
ziU8 unk_0x1983;
ziU8 unk_0x1984;
ziU8 unk_0x1985;
ziU8 unk_0x1986;
ziU8 unk_0x1987;
ziWChar unk_0x1988[0x41];
ziU8 unk_0x1A0A;
ziU8 unk_0x1A0B[0x85];
ziWChar unk_0x1A90;
ziWChar unk_0x1A92[0x41];
ziU8 unk_0x1B14;
ziU8 unk_0x1B15[3];
ziU16* unk_0x1B18;
ziU16 unk_0x1B1C;
ziU16 unk_0x1B1E;
ziU16 unk_0x1B20;
ziU16 unk_0x1B22;
ziU8 unk_0x1B24;
ziU8 unk_0x1B25[3];
union {
ziU32 word;
struct {
ziU32 msb : 1;
} bits;
} unk_0x1B28;
union {
ziU32 word;
struct {
ziU32 msb : 1;
} bits;
} unk_0x1B2C;
ziU8 unk_0x1B30;
ziU8 unk_0x1B31;
ziU16 unk_0x1B32;
ziU16 unk_0x1B34;
ziU16 unk_0x1B36;
ziU16 unk_0x1B38;
ziU8 unk_0x1B3A;
ziU8 unk_0x1B3B;
ziU8 unk_0x1B3C;
ziU8 unk_0x1B3D;
ziU8 unk_0x1B3E;
ziU8 unk_0x1B3F;
ziU16 unk_0x1B40;
ziU8 unk_0x1B42[2];
};
typedef struct ziMatchParam {
ziU8 count; // 0x00
ziU8 arr1[0xC]; // 0x01
ziU8 arrD[0xC]; // 0x0D
ziU8 arr19[4]; // 0x19
ziU8 arr1D[4]; // 0x1D
ziU8 pad_0x21; // 0x21
ziU16 field22; // 0x22
ziU8 length; // 0x24
ziU8 nCand; // 0x25
ziWChar phon[0x10]; // 0x26
ziWChar phon2[0x10]; // 0x46
ziWChar first; // 0x66
ziWChar first2; // 0x68
ziWChar comp; // 0x6A
ziU8 nSeg; // 0x6C
ziU8 segs1[0xC0]; // 0x6D
ziU8 segsD[0xC0]; // 0x12D
ziU8 pad_0x1ED; // 0x1ED
} ziMatchParam;
#define ZI_WORK ((struct __zi8_work_data_s*)__zi8_work_data)
#define ZI_NEED_WORK , ziPtr __zi8_work_data

View File

@@ -0,0 +1,49 @@
#include <zi8clib/zitypes.h>
const ziWChar Zi8PunctTable[40] = {
0xFF0C, 0x3002, 0x3001, 0xFF1A, 0xFF1F, 0xFF01, 0x3005, 0x2026,
0x2015, 0xFF1B, 0xFF0E, 0x30FB, 0x201C, 0x201D, 0xFF08, 0xFF09,
0x300C, 0x300D, 0xFF10, 0xFF11, 0xFF12, 0xFF13, 0xFF14, 0xFF15,
0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFF0F, 0xFF05, 0xFFE5, 0xFF04,
0xFFE1, 0x20AC, 0x203B, 0xFF20, 0x0000,
};
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;
ziU16 j = 0;
for (;;) {
if (Zi8PunctTable[j] == 0) {
break;
}
if (fc == 0) {
count++;
if (ZI_WORK->unk_0x00 == 0) {
param->candidates[i++] = Zi8PunctTable[j];
if ((param->context & 0x10) != 0) {
param->candidates[i++] = 0x20;
if ((ziU8)i >= limit) {
break;
}
}
if (count >= param->maxCandidates) {
break;
}
} else {
if (count >= (ziS32)ZI_WORK->unk_0x0C) {
return count;
}
}
} else {
fc--;
}
j++;
}
if (ZI_WORK->unk_0x00 == 0) {
param->letters = count;
}
return count;
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,108 @@
#include <zi8clib/zitypes.h>
ziU16 Zi8MatchAltSound(ziU8* elements, ziU16 count, ziU8* table, ziU16 ch,
ziU32 mask, ziU16 target, ziU8 flags ZI_NEED_WORK) {
ziU8 hi;
ziU8 lo;
ziS32 i;
ziS32 j;
ziS32 mid;
ziU16 off;
ziU16 w;
hi = (ziU8)((ziU16)ch >> 8);
lo = (ziU8)ch;
flags = (ziU8)(flags >> 3);
if (count == 0) {
return 0;
}
j = 0;
i = count - 1;
if ((elements + i * 4)[1] == hi && (elements + i * 4)[0] == lo) {
j = i;
goto up;
}
if ((elements + j * 4)[1] == hi && (elements + j * 4)[0] == lo) {
goto up;
}
goto search;
up:
i = j;
body:
if (((elements + i * 4)[3] & 0xE) == 0 ||
((elements + i * 4)[3] & flags) != 0) {
off = (ziU16)(((ziU16)(elements + i * 4)[2] |
(((ziU16)(elements + i * 4)[3] & 1) << 8)) << 1);
w = (ziU16)((((ziU16)(elements + i * 4)[3] & 0xF0) >> 4) |
(table[off] | ((ziU16)table[off + 1] << 8)));
if (target == (w & (ziU16)mask)) {
return w;
}
}
i++;
if (i >= count) {
goto down_start;
}
if ((elements + i * 4)[1] == hi && (elements + i * 4)[0] == lo) {
goto body;
}
down_start:
i = j;
goto dec;
down_body:
if (((elements + i * 4)[3] & 0xE) == 0 ||
((elements + i * 4)[3] & flags) != 0) {
off = (ziU16)(((ziU16)(elements + i * 4)[2] |
(((ziU16)(elements + i * 4)[3] & 1) << 8)) << 1);
w = (ziU16)((((ziU16)(elements + i * 4)[3] & 0xF0) >> 4) |
(table[off] | ((ziU16)table[off + 1] << 8)));
if (target == (w & (ziU16)mask)) {
return w;
}
}
dec:
i--;
if (i < 0) {
goto fail;
}
if ((elements + i * 4)[1] == hi && (elements + i * 4)[0] == lo) {
goto down_body;
}
fail:
return 0;
search:
if ((elements + j * 4)[1] == hi && (elements + j * 4)[0] == lo) {
goto up;
}
if ((((ziU16)(elements + j * 4)[1] << 8) | (ziU16)(elements + j * 4)[0]) > ch) {
return 0;
}
mid = (j + i) / 2;
if (mid == j) {
return 0;
}
if ((((ziU16)(elements + mid * 4)[1] << 8) | (ziU16)(elements + mid * 4)[0]) >= ch) {
i = mid;
goto hi_check;
}
j = mid;
goto search;
hi_check:
if ((elements + i * 4)[1] == hi && (elements + i * 4)[0] == lo) {
j = i;
goto up;
}
if ((((ziU16)(elements + i * 4)[1] << 8) | (ziU16)(elements + i * 4)[0]) < ch) {
return 0;
}
mid = (j + i) / 2;
if (mid == j) {
return 0;
}
if ((((ziU16)(elements + mid * 4)[1] << 8) | (ziU16)(elements + mid * 4)[0]) >= ch) {
i = mid;
goto hi_check;
}
j = mid;
goto search;
}

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,212 @@
#include <zi8clib/zierror.h>
extern ziU16 Zi8GetTableCount(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
extern ziU8 Zi8getKeyLayout(ziU8 lang, ziU16 key, ziWChar* layout, ziU8 mode ZI_NEED_WORK);
extern ziChar Zi8ConvertWC2UC(ziWChar ch, ziU8 language ZI_NEED_WORK);
extern ziU32 Zi8AlphaGetCandidates(ziGetParam* param, ziPtr sw ZI_NEED_WORK);
extern ziU8 Zi8SyllablesROMdata(ziWChar* keys, ziU8 count, ziU8 lang, ziWChar* out,
ziU16 a, ziU8 b, ziU8* cntOut, ziU8 c ZI_NEED_WORK);
typedef struct _ziSwParam {
ziU8 flag;
ziU8 unk_0x01[0xB];
ziS32 count;
ziU16 cap;
ziU8 unk_0x12[2];
} ziSwParam;
ziU32 Zi8GetSyllablesCandidates(ziGetParam* param, ziSwParam* sw ZI_NEED_WORK) {
ziWChar buf[0x40];
ziWChar buf2[0x32];
ziS32 rem;
ziS32 cur;
ziS32 firstCand;
ziS32 count;
ziWChar* pNext;
ziU16 err;
ziU8 flag14;
ziU8 flag13;
ziU8 flag12;
ziU8 flag11;
ziU8 sylCnt;
ziWChar* out;
ziU8* u28;
ziS32 i;
firstCand = param->firstCandidate;
count = 0;
u28 = 0;
pNext = 0;
flag14 = 1;
flag13 = 1;
flag12 = 0;
flag11 = 0;
sylCnt = 0;
err = 0x64;
if (param->currentWord != 0 && param->wordCharCount != 0 &&
param->currentWord[param->wordCharCount - 1] != 0x20) {
flag11 = 1;
}
if (param->elementCount == 0 || (param->elementCount == 1 && flag11 == 0)) {
count = Zi8AlphaGetCandidates(param, sw, ZI_WORK);
goto end;
}
if (sw->flag != 0 || (param->getOptions & 0xFD) != 0x81) {
out = buf;
rem = 0x40;
} else {
out = (ziWChar*)param->candidates;
rem = sw->cap - 1;
}
if ((param->getOptions & 0xFD) == 0x80) {
u28 = (ziU8*)param->candidates;
rem = sw->cap - 1;
}
if (rem <= param->elementCount) {
err = 0x168;
goto end;
}
if ((Zi8GetTableCount(param->language, 0x1F, ZI_WORK) & 8) != 0) {
flag14 = 0;
}
if (param->elements[0] == 0xEFF1 && param->elementCount > 1 && flag14 != 0) {
buf[0] = 0x2D;
} else {
Zi8getKeyLayout(param->language, param->elements[0], buf, 1, ZI_WORK);
}
out[0] = buf[0];
Zi8SyllablesROMdata(param->elements, param->elementCount, param->language, out,
(ziU16)rem, 0, &sylCnt, flag11, ZI_WORK);
if (sylCnt != 0) {
cur = sylCnt;
} else {
cur = 1;
}
if (cur == param->elementCount) goto L5dc;
if (firstCand != 0) {
firstCand--;
goto L5dc;
}
if (sw->flag != 0) {
if (++count >= sw->count) goto end;
goto L5dc;
}
for (i = cur; i < param->elementCount; i += sylCnt) {
if (param->elements[i] == 0xEFF1 && param->elementCount - i > 1 && flag14 != 0) {
buf2[0] = 0x2D;
} else {
Zi8getKeyLayout(param->language, param->elements[i], buf2, 1, ZI_WORK);
}
out[i] = buf2[0];
Zi8SyllablesROMdata(param->elements + i, param->elementCount - i, param->language,
out + i, (ziU16)rem, 0, &sylCnt, 1, ZI_WORK);
if (sylCnt == 0) {
sylCnt = 1;
}
}
if (u28 != 0) {
for (i = 0; i < param->elementCount; i++) {
u28[i] = Zi8ConvertWC2UC(out[i], param->language, ZI_WORK);
}
u28[i++] = 0;
u28[i] = 0;
u28 += i;
} else {
out[i++] = 0;
out[i] = 0;
out += i;
}
rem -= i;
if (++count >= param->maxCandidates) goto end;
if (rem > param->elementCount) goto L5dc;
goto end;
L5dc:
while (cur >= 1) {
flag12 = 0;
goto rom;
found:
flag12 = 1;
if (cur == 1) {
flag13 = 0;
}
L464:
if (out[0] >= 0xEFF1 && out[0] <= 0xF010) {
goto dec;
}
L464b:
if (firstCand != 0) {
firstCand--;
goto L560;
}
if (sw->flag != 0) {
if (++count >= sw->count) goto end;
goto L560;
}
if (u28 != 0) {
for (i = 0; i < cur; i++) {
u28[i] = Zi8ConvertWC2UC(out[i], param->language, ZI_WORK);
}
u28[i++] = 0;
u28[i] = 0;
u28 += i;
} else {
i = cur;
out[i++] = 0;
out[i] = 0;
out += i;
}
rem -= i;
if (++count >= param->maxCandidates) goto end;
if (rem <= cur) goto end;
L560:
if (pNext != 0) {
if (*pNext == 0) goto end;
out[0] = *pNext++;
goto L464b;
}
rom:
if (Zi8SyllablesROMdata(param->elements, (ziU8)cur, param->language, out,
(ziU16)rem, flag12, 0, flag11, ZI_WORK) != 0) {
goto found;
}
dec:
cur--;
}
if (flag13 == 0) goto end;
if (param->elements[0] == 0xEFF1 && param->elementCount > 1 && flag14 != 0) {
buf2[0] = 0x2D;
buf2[1] = 0;
Zi8getKeyLayout(param->language, param->elements[0], &buf2[1], 1, ZI_WORK);
for (i = 1; buf2[i] != 0; i++) {
if (buf2[i] == 0x2D) break;
}
while (buf2[i] != 0) {
buf2[i] = buf2[i + 1];
i++;
}
} else {
Zi8getKeyLayout(param->language, param->elements[0], buf2, 1, ZI_WORK);
}
cur = 1;
pNext = buf2;
goto L560;
end:
if (sw->flag != 0) {
param->letters = 0;
} else {
param->letters = (ziU8)count;
}
Zi8LogError(err, ZI_WORK);
return count;
}

View File

@@ -0,0 +1,15 @@
#include <zi8clib/zi8getc.h>
#include <zi8clib/zitypes.h>
extern ziU8 _Zi8GetCandidates(ziGetParam* getParam ZI_NEED_WORK);
ziU8 Zi8GetCandidates(ziGetParam* getParam ZI_NEED_WORK) {
ZI_WORK->unk_0x1B3A = 0;
ZI_WORK->unk_0x1B3C = 0;
ZI_WORK->unk_0x1B3B = 0;
ZI_WORK->unk_0x1B3D = 0;
ZI_WORK->unk_0x1B36 = 0;
ZI_WORK->unk_0x1B32 = 0;
ZI_WORK->unk_0x1B34 = 0;
return _Zi8GetCandidates(getParam, ZI_WORK);
}

View File

@@ -0,0 +1,75 @@
#include <zi8clib/zitypes.h>
#include <zi8clib/zierror.h>
extern void Zi8Memset(ziPtr p, ziU32 v, ziU32 len);
extern void Zi8SetLatinSearchOrder(ziU32 a, ziU8 b ZI_NEED_WORK);
extern void ZADP_Zi8SetPDremoveOpt(ziU8 a ZI_NEED_WORK);
extern ziU16 Zi8GetFormatVersion(ziU8 a ZI_NEED_WORK);
extern void Zi8ZHsetZYfuzzyPairs(ziU32* a ZI_NEED_WORK);
extern void Zi8ZHsetPYfuzzyPairs(ziU32* a ZI_NEED_WORK);
extern void Zi8SetParentalControls(ziU8 a ZI_NEED_WORK);
ziU8 Zi8InitializeDynamic(ziLanguageEntry* langEntries ZI_NEED_WORK) {
ziU32 zyFuzzy;
ziU32 pyFuzzy;
ziU32* pzyFuzzy;
ziU32* ppyFuzzy;
Zi8Memset(__zi8_work_data, 0, 0x1B44);
ZI_WORK->unk_0x08 = 1;
ZI_WORK->unk_0x09 = 1;
ZI_WORK->unk_0x0A = 0xFF;
ZI_WORK->unk_0x10 = 0x64;
*(ziU16*)&ZI_WORK->unk_0x0C = 0xFFFF;
ZI_WORK->unk_0x1A = 0x20;
ZI_WORK->unk_0x1C[2] = 0;
ZI_WORK->unk_0x1B30 = 0;
ZI_WORK->unk_0x1B3A = 0;
ZI_WORK->unk_0x1B36 = 0;
ZI_WORK->unk_0x1B32 = 0;
ZI_WORK->unk_0x1B34 = 0;
ZI_WORK->unk_0x1B3B = 0;
ZI_WORK->unk_0x1B3C = 0;
ZI_WORK->unk_0x1B40 = 0;
ZI_WORK->unk_0x1B38 = 0;
ZI_WORK->langEntries = langEntries;
if (ZI_WORK->langEntries == ZI8_NULL) {
Zi8LogError(0x578, ZI_WORK);
return 0;
}
if (ZI_WORK->langEntries->language == 0) {
Zi8LogError(0x582, ZI_WORK);
return 0;
}
ZI_WORK->unk_0x1874 = 0x2D;
ZI_WORK->unk_0x538 = 0;
ZI_WORK->unk_0x1C[3] = 0;
ZI_WORK->unk_0x141A = 0x100;
Zi8SetLatinSearchOrder(0, 0, ZI_WORK);
ZADP_Zi8SetPDremoveOpt(1, ZI_WORK);
ZI_WORK->unk_0x17 = 5;
ZI_WORK->unk_0x16 = Zi8GetFormatVersion(1, ZI_WORK) & 2;
ZI_WORK->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->unk_0x1B28.word;
ppyFuzzy = &pyFuzzy;
Zi8ZHsetPYfuzzyPairs(ppyFuzzy, ZI_WORK);
Zi8SetParentalControls(2, ZI_WORK);
Zi8LogError(0x64, ZI_WORK);
return 1;
}
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;
}
if ((ziU16)len > 6 && p[0] == 0x39 && p[1] == 0x34 && p[2] == 0x32 &&
p[3] == 0x36 && p[4] == 0x37 && p[5] == 0x37) {
return 1;
}
return 0;
}

View File

@@ -0,0 +1,138 @@
#include <zi8clib/zi8is.h>
#include <zi8clib/zierror.h>
extern ziU8 Zi8LangSupported(ziU8 lang ZI_NEED_WORK);
extern ziU16 Zi8GetTableCount(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
extern ziU32 Zi8GetTableAddress(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
extern ziU8 _Zi8GetCandidates(ziGetParam* getParam ZI_NEED_WORK);
extern void Zi8Memset(ziPtr p, ziU32 v, ziU32 len);
ziU8 Zi8GetZHCharSet(ziPtr workData) {
ziU8 charSet = 0;
ziU8 bak;
ziU16 v0;
ziU16 v1;
ziU16 v2;
ziU32 addr;
ziU8* p;
ziWChar candBuf[0x10];
ziGetParam getParam;
Zi8LogError(0x64, workData);
if (Zi8LangSupported(1, workData) == 0) {
Zi8ReplaceLastError(0x26C, workData);
return 0;
}
if (Zi8GetTableCount(1, 10, workData) != 0) {
bak = ((struct __zi8_work_data_s*)workData)->unk_0x18;
((struct __zi8_work_data_s*)workData)->unk_0x18 = 1;
addr = Zi8GetTableAddress(1, 10, workData);
p = (ziU8*)addr;
v0 = (ziU16)((ziU16)p[0] | ((ziU16)p[1] << 8));
((struct __zi8_work_data_s*)workData)->unk_0x18 = 0;
addr = Zi8GetTableAddress(1, 10, workData);
p = (ziU8*)addr;
v1 = (ziU16)((ziU16)p[2] | ((ziU16)p[3] << 8));
v2 = (ziU16)((ziU16)p[4] | ((ziU16)p[5] << 8));
((struct __zi8_work_data_s*)workData)->unk_0x18 = bak;
if (v0 != 0) {
if (v0 > 0x4E20) {
charSet |= 8;
} else {
charSet |= 1;
}
}
if (v1 != 0) {
if (v1 > 0x2710) {
charSet |= 2;
} else {
charSet |= 0x10;
}
}
if (v2 != 0) {
charSet |= 4;
}
return charSet;
}
Zi8Memset(&getParam, 0, 0x2C);
getParam.language = 1;
getParam.context = 1;
getParam.getOptions = 0;
getParam.candidates = candBuf;
getParam.maxCandidates = 1;
getParam.subLanguage = 1;
retry:
getParam.getMode = 0;
if (_Zi8GetCandidates(&getParam, workData) != 0) {
charSet |= getParam.subLanguage;
goto next;
}
getParam.getMode = 1;
if (_Zi8GetCandidates(&getParam, workData) != 0) {
charSet |= getParam.subLanguage;
goto next;
}
getParam.getMode = 2;
if (_Zi8GetCandidates(&getParam, workData) != 0) {
charSet |= getParam.subLanguage;
}
next:
if (getParam.subLanguage == 1) {
getParam.subLanguage = 4;
goto retry;
}
if (getParam.subLanguage == 4) {
getParam.subLanguage = 2;
goto retry;
}
return charSet;
}
ziBool Zi8IsComponent(ziWChar ch ZI_NEED_WORK) {
if (ch >= 0xEF10 && ch < 0xF305) {
return 1;
}
return 0;
}
ziBool Zi8IsCharacter(ziWChar ch ZI_NEED_WORK) {
ziU16 count;
ziU8 hi;
ziU8 lo;
ziU32 addr;
ziU8* table;
ziU16 i;
if (ch >= 0x3105 && ch <= 0x3129) {
return 1;
}
switch (ch) {
case 0x2C7:
case 0x2C9:
case 0x2CA:
case 0x2CB:
case 0x2D9:
return 1;
}
switch (ch) {
case 0x3002:
case 0xFF01:
case 0xFF0C:
case 0xFF1F:
return 1;
}
hi = (ziU8)(((ziU16)ch >> 8) & 0xFF);
lo = (ziU8)ch;
count = Zi8GetTableCount(1, 0, ZI_WORK);
addr = Zi8GetTableAddress(1, 0, ZI_WORK);
table = (ziU8*)addr;
for (i = 0; i < count; i++) {
if (table[6] == hi && table[7] == lo) {
return 1;
}
table += 0xC;
}
return 0;
}

View File

@@ -0,0 +1,144 @@
#include <zi8clib/zitypes.h>
#include <zi8clib/zierror.h>
extern ziU16 Zi8GetTableCount(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
extern ziU32 Zi8GetTableAddress(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
typedef struct { ziU8 b[0xC]; } ziE12;
#define WORKP ((struct __zi8_work_data_s*)__zi8_work_data)
ziU16 Zi8Uni2Ptr(ziU16 ch, ziE12* buf ZI_NEED_WORK) {
ziU8 hi;
ziU8 lo;
ziU16 count;
ziU32 table;
ziU32 table2;
ziU16 i;
ziU8* e;
ziU8* p;
hi = (ziU8)(((ziU16)ch >> 8) & 0xFF);
lo = (ziU8)ch;
count = Zi8GetTableCount(1, 0, __zi8_work_data);
table = Zi8GetTableAddress(1, 0, __zi8_work_data);
table2 = Zi8GetTableAddress(1, 1, __zi8_work_data);
if (buf == ZI8_NULL) {
for (i = 0; i < 0x40; i++) {
if (ch == WORKP->unk_0x20[i]) {
i = WORKP->unk_0xA0[i];
e = (ziU8*)table + i * 0xC;
if (i >= count) {
break;
}
if (hi != e[6] || lo != e[7]) {
break;
}
p = (ziU8*)(table2 +
(((e[9] & 0xF) << 16) |
(e[0xB] | (e[0xA] << 8))));
if (WORKP->unk_0x16 != 0) {
switch (p[0] & 7) {
case 2:
p += 2;
break;
case 3:
case 4:
p += 3;
break;
case 5:
p += 4;
break;
default:
p += 1;
break;
}
}
if ((p[0] & 0x80) == 0) {
break;
}
if (buf != ZI8_NULL) {
*buf = *(ziE12*)e;
}
return i;
}
}
}
e = (ziU8*)table;
if (WORKP->unk_0x1B18 != ZI8_NULL && WORKP->unk_0x1B24 == WORKP->unk_0x18) {
if ((ziU16)ch >= WORKP->unk_0x1B1C && (ziU16)ch <= WORKP->unk_0x1B1E) {
i = (ziU16)(ch - WORKP->unk_0x1B1C);
goto map;
}
if ((ziU16)ch >= WORKP->unk_0x1B20 && (ziU16)ch <= WORKP->unk_0x1B22) {
i = (ziU16)(WORKP->unk_0x1B1E + (ch - WORKP->unk_0x1B20) -
WORKP->unk_0x1B1C + 1);
goto map;
}
return 0xFFFF;
map:
i = WORKP->unk_0x1B18[i];
if (i != 0xFFFF) {
e = (ziU8*)table + i * 0xC;
if (hi == e[6] && lo == e[7]) {
if (buf != ZI8_NULL) {
*buf = *(ziE12*)e;
}
return i;
}
}
return 0xFFFF;
}
i = 0;
while (i < count) {
if (lo == e[7] && hi == e[6]) {
if (buf != ZI8_NULL) {
*buf = *(ziE12*)e;
}
return i;
}
e += 0xC;
i++;
}
return 0xFFFF;
}
ziU16 Zi8Uni2Ord(ziU16 ch ZI_NEED_WORK) {
return Zi8Uni2Ptr(ch, ZI8_NULL, __zi8_work_data);
}
ziU16 Zi8Ord2Uni(ziU16 ord ZI_NEED_WORK) {
ziU8* p;
if ((ziU16)ord >= Zi8GetTableCount(1, 0, __zi8_work_data)) {
Zi8LogError(0x132, __zi8_work_data);
return 0;
}
p = (ziU8*)Zi8GetTableAddress(1, 0, __zi8_work_data);
p += ord * 0xC;
Zi8LogError(0x64, __zi8_work_data);
return (ziU16)(((ziU16)p[6] << 8) + p[7]);
}
ziU16 Zi8Ord2Ord(ziU16 ord ZI_NEED_WORK) {
ziU32 table;
ziU16 count;
ziU8* p;
count = Zi8GetTableCount(1, 0, __zi8_work_data);
table = Zi8GetTableAddress(1, 0, __zi8_work_data);
if (ord == 0 || (ziU16)ord >= count) {
Zi8LogError(0x132, __zi8_work_data);
return ord;
}
p = (ziU8*)table + (ord - 1) * 0xC;
while (ord != 0) {
if (p[6] != p[0x12] || p[7] != p[0x13]) {
break;
}
p -= 0xC;
ord--;
}
Zi8LogError(0x64, __zi8_work_data);
return ord;
}

View File

@@ -0,0 +1,99 @@
#include <zi8clib/zi8space.h>
#include <zi8clib/zierror.h>
#include <zi8clib/zitypes.h>
extern ziU8 Zi8GetPyPhonetic(ziWChar* src, ziU8 i, ziWChar* a, ziWChar* b, ziU8* c,
ziU16* d, ziU16* e ZI_NEED_WORK);
extern ziU8 Zi8GetBpmfPhonetic(ziWChar* src, ziU8 i, ziWChar* a, ziWChar* b,
ziU16* d, ziU16* e ZI_NEED_WORK);
ziU8 Zi8ZHaddSpace(ziWChar* src, ziU8 count, ziWChar* dst,
ziU16 maxLen ZI_NEED_WORK) {
ziWChar candBuf[0x10];
ziWChar pyBuf[0x10];
ziU16 m;
ziU16 vE;
ziU16 vC;
ziU8 n;
ziU8 flag;
ziU8 v9;
ziU8 isPy;
int i;
int k;
ziWChar* psrc;
ziWChar* pdst;
psrc = src;
n = count;
pdst = dst;
m = maxLen;
if (n == 0) {
Zi8LogError(0x137, ZI_WORK);
return 0;
}
if ((psrc[0] >= 0xF361 && psrc[0] <= 0xF37A) ||
(psrc[0] >= 0xF341 && psrc[0] <= 0xF35A)) {
isPy = 1;
} else if (psrc[0] >= 0xF305 && psrc[0] <= 0xF329) {
isPy = 0;
} else {
goto fail;
}
i = 2;
while (i <= n) {
if (isPy) {
flag = Zi8GetPyPhonetic(psrc, i, candBuf, pyBuf, &v9, &vE, &vC, ZI_WORK);
if (i == v9) {
i++;
continue;
}
} else {
if ((psrc[i - 1] == 0xF360 && psrc[i - 2] != 0xF360) ||
Zi8GetBpmfPhonetic(psrc, i, candBuf, pyBuf, &vE, &vC, ZI_WORK) !=
0) {
i++;
continue;
}
}
if (i-- >= m - 1) {
goto fail;
}
m -= i + 1;
for (k = 0; k < i; k++) {
pdst[k] = psrc[k];
}
if (pdst[k - 1] != 0xF360 &&
(pdst[k - 1] < 0xF331 || pdst[k - 1] > 0xF335)) {
pdst[k++] = ZI_WORK->unk_0x1A;
}
psrc += i;
n -= i;
pdst += k;
i = 2;
}
if (i-- > m) {
goto fail;
}
for (k = 0; k < i; k++) {
pdst[k] = psrc[k];
}
pdst[k] = 0;
Zi8LogError(0x64, ZI_WORK);
return 1;
fail:
if ((ziU8)count >= (ziU16)maxLen) {
count = (ziU8)(maxLen - 1);
}
for (i = 0; i < count; i++) {
dst[i] = src[i];
}
dst[i] = 0;
Zi8LogError(0x64, ZI_WORK);
return 1;
}

View File

@@ -8,8 +8,13 @@ extern "C" {
#endif
void __VISetRGBModeImm();
#ifdef VI_MATCHING_SOURCE
BOOL __VIResetRFIdle();
BOOL __VIResetSIIdle();
#else
void __VIResetRFIdle();
void __VIResetSIIdle();
#endif
void __VIGetCurrentPosition(s16* x, s16* y);

View File

@@ -150,7 +150,11 @@ typedef struct DVDErrorInfo {
void DVDInit();
BOOL DVDReadAbsAsyncPrio(DVDCommandBlock* block, void* addr, s32 length, u32 offset, DVDCommandCallback callback, s32 prio);
#ifdef BS2_MACH_FIVE_ARG_READ
BOOL DVDReadAbsAsyncForBS(DVDCommandBlock* block, void* addr, s32 length, u32 offset, DVDCommandCallback callback);
#else
BOOL DVDReadAbsAsyncForBS(DVDCommandBlock* block, void* addr, s32 length, u32 offset, DVDCommandCallback callback, s32 prio);
#endif
BOOL DVDReadDiskID(DVDCommandBlock* block, DVDDiskID* diskID, DVDCommandCallback callback);
BOOL DVDCompareDiskID(const DVDDiskID* id1, const DVDDiskID* id2);

View File

@@ -27,8 +27,13 @@ void VISetNextFrameBuffer(void* fb);
void VISetBlack(BOOL setBlack);
void VISetTrapFilter(BOOL setTrap);
#ifdef VI_MATCHING_SOURCE
BOOL VIResetDimmingCount();
BOOL VIEnableDimming(BOOL enableDim);
#else
void VIResetDimmingCount();
void VIEnableDimming(BOOL enableDim);
#endif
u32 VIGetRetraceCount();
u32 VIGetDTVStatus();

File diff suppressed because it is too large Load Diff

2123
libs/RVL_SDK/src/fa/pf_fat.c Normal file

File diff suppressed because it is too large Load Diff

View File

@@ -390,12 +390,12 @@ pf_s32 PFFILE_Cursor_Read(PFFILE_FILE* file, pf_u8* buffer, pf_u32 size, pf_u32*
if (error != 0) {
return error;
}
if (size <= part_size) {
if (part_size >= size) {
return 0;
}
size -= part_size;
volume = file == PF_NULL ? PF_NULL : file->p_sfd->dir_entry.p_vol;
while (volume->bpb.bytes_per_sector <= size) {
while (size >= volume->bpb.bytes_per_sector) {
error = PFFILE_Cursor_ReadBodySectors(file, buffer + *size_read, size, &part_size);
*size_read += part_size;
if (error != 0) {
@@ -408,10 +408,10 @@ pf_s32 PFFILE_Cursor_Read(PFFILE_FILE* file, pf_u8* buffer, pf_u32 size, pf_u32*
}
error = PFFILE_Cursor_ReadTailSector(file, buffer + *size_read, size, &part_size);
*size_read += part_size;
if (error == 0) {
error = 0;
if (error != 0) {
return error;
}
return error;
return 0;
}
pf_s32 PFFILE_Cursor_WriteHeadSector(PFFILE_FILE* file, const pf_u8* buffer, pf_u32 size,
@@ -419,6 +419,11 @@ pf_s32 PFFILE_Cursor_WriteHeadSector(PFFILE_FILE* file, const pf_u8* buffer, pf_
pf_s32 error;
pf_u32 success_size;
pf_u32 next_position;
pf_u32 new_position;
pf_u32 current_sector;
pf_u32 written_size;
pf_u32 sector_advance;
pf_u32 next_sector;
PF_VOLUME* volume;
*size_written = 0;
@@ -447,16 +452,21 @@ pf_s32 PFFILE_Cursor_WriteHeadSector(PFFILE_FILE* file, const pf_u8* buffer, pf_
return error;
}
*size_written = success_size;
current_sector = file->cursor.sector;
written_size = success_size;
volume = file == PF_NULL ? PF_NULL : file->p_sfd->dir_entry.p_vol;
next_position = file->cursor.offset_in_sector + success_size;
next_position = file->cursor.offset_in_sector + written_size;
sector_advance = next_position >> volume->bpb.log2_bytes_per_sector;
next_sector = current_sector + sector_advance;
if (((volume->bpb.bytes_per_sector - 1) & next_position) != 0) {
file->cursor.sector += next_position >> volume->bpb.log2_bytes_per_sector;
file->cursor.sector = next_sector;
} else {
file->cursor.sector = -1;
}
file->cursor.position += success_size;
if (file->cursor.position > file->p_sfd->dir_entry.file_size) {
file->p_sfd->dir_entry.file_size = file->cursor.position;
new_position = file->cursor.position + success_size;
file->cursor.position = new_position;
if (new_position > file->p_sfd->dir_entry.file_size) {
file->p_sfd->dir_entry.file_size = new_position;
}
PFFILE_Cursor_Recalc(file);
PFCLUSTER_UpdateLastAccessCluster(file);
@@ -519,6 +529,11 @@ pf_s32 PFFILE_Cursor_WriteTailSector(PFFILE_FILE* file, const pf_u8* buffer, pf_
pf_s32 error;
pf_u32 success_size;
pf_u32 next_position;
pf_u32 current_sector;
pf_u32 written_size;
pf_u32 sector_advance;
pf_u32 next_sector;
pf_u32 new_position;
PF_VOLUME* volume;
*size_written = 0;
@@ -548,16 +563,21 @@ pf_s32 PFFILE_Cursor_WriteTailSector(PFFILE_FILE* file, const pf_u8* buffer, pf_
return error;
}
*size_written = success_size;
current_sector = file->cursor.sector;
written_size = success_size;
volume = file == PF_NULL ? PF_NULL : file->p_sfd->dir_entry.p_vol;
next_position = file->cursor.offset_in_sector + success_size;
next_position = file->cursor.offset_in_sector + written_size;
sector_advance = next_position >> volume->bpb.log2_bytes_per_sector;
next_sector = current_sector + sector_advance;
if (((volume->bpb.bytes_per_sector - 1) & next_position) != 0) {
file->cursor.sector += next_position >> volume->bpb.log2_bytes_per_sector;
file->cursor.sector = next_sector;
} else {
file->cursor.sector = -1;
}
file->cursor.position += success_size;
if (file->cursor.position > file->p_sfd->dir_entry.file_size) {
file->p_sfd->dir_entry.file_size = file->cursor.position;
new_position = file->cursor.position + success_size;
file->cursor.position = new_position;
if (new_position > file->p_sfd->dir_entry.file_size) {
file->p_sfd->dir_entry.file_size = new_position;
}
PFFILE_Cursor_Recalc(file);
PFCLUSTER_UpdateLastAccessCluster(file);
@@ -576,7 +596,6 @@ pf_s32 PFFILE_Cursor_Write(PFFILE_FILE* file, const pf_u8* buffer, pf_u32 size,
pf_u32 append_needed;
pf_u32 allocated_end;
pf_u32 requested_end;
pf_u32 remaining;
PF_VOLUME* volume;
PFFILE_VOLUME_DIRS* volume_dirs;
@@ -598,9 +617,9 @@ pf_s32 PFFILE_Cursor_Write(PFFILE_FILE* file, const pf_u8* buffer, pf_u32 size,
if (part_size >= size) {
return 0;
}
remaining = size - part_size;
size -= part_size;
error = PFFAT_CountAllocatedClusters(&file->p_sfd->ffd,
file->cursor.position + remaining, &num_clusters);
file->cursor.position + size, &num_clusters);
if (file == PF_NULL) {
volume = PF_NULL;
} else {
@@ -608,17 +627,17 @@ pf_s32 PFFILE_Cursor_Write(PFFILE_FILE* file, const pf_u8* buffer, pf_u32 size,
}
allocated_end = num_clusters << (volume->bpb.log2_bytes_per_sector +
volume->bpb.log2_sectors_per_cluster);
requested_end = file->cursor.position + remaining;
requested_end = file->cursor.position + size;
if (allocated_end < requested_end) {
append_needed = requested_end - allocated_end;
} else {
append_needed = 0;
}
append_size = 0;
while (append_needed != 0 || remaining >= volume->bpb.bytes_per_sector) {
while (append_needed != 0 || size >= volume->bpb.bytes_per_sector) {
if (append_needed != 0) {
error = PFCLUSTER_AppendCluster(file, append_needed, &append_size);
if (error != 0 && remaining == append_needed) {
if (error != 0 && size == append_needed) {
return error;
}
if (append_size == 0) {
@@ -626,9 +645,9 @@ pf_s32 PFFILE_Cursor_Write(PFFILE_FILE* file, const pf_u8* buffer, pf_u32 size,
}
append_needed -= append_size;
}
while (remaining >= append_needed + append_size &&
remaining >= volume->bpb.bytes_per_sector) {
error = PFFILE_Cursor_WriteBodySectors(file, buffer + *size_written, remaining,
while (size >= append_needed + append_size &&
size >= volume->bpb.bytes_per_sector) {
error = PFFILE_Cursor_WriteBodySectors(file, buffer + *size_written, size,
&part_size);
*size_written += part_size;
if (error != 0) {
@@ -637,13 +656,13 @@ pf_s32 PFFILE_Cursor_Write(PFFILE_FILE* file, const pf_u8* buffer, pf_u32 size,
if (part_size == 0) {
return 0;
}
remaining -= part_size;
if (remaining == 0) {
size -= part_size;
if (size == 0) {
break;
}
}
}
error = PFFILE_Cursor_WriteTailSector(file, buffer + *size_written, remaining, &part_size);
error = PFFILE_Cursor_WriteTailSector(file, buffer + *size_written, size, &part_size);
*size_written += part_size;
error = error & ((-error | error) >> 31);
return error;
@@ -1072,8 +1091,6 @@ pf_s32 PFFILE_p_finfo(PFFILE_FILE* file, PF_INFO* info) {
pf_u32 cluster_size;
pf_u32 file_size_remainder;
pf_u32 file_size;
pf_u32 nonempty_bytes;
pf_s32 sign_bits;
pf_s32 error;
file->p_sfd->ffd.p_hint = &file->hint;
@@ -1088,9 +1105,10 @@ pf_s32 PFFILE_p_finfo(PFFILE_FILE* file, PF_INFO* info) {
}
file_size = file->p_sfd->dir_entry.file_size;
file_size_remainder = file_size % cluster_size;
nonempty_bytes = cluster_size - file_size_remainder;
sign_bits = -(pf_s32)file_size_remainder | (pf_s32)file_size_remainder;
info->empty_size = info->allocated_size + (nonempty_bytes & (sign_bits >> 31));
info->empty_size = info->allocated_size +
(file_size_remainder != 0
? cluster_size - file_size_remainder
: 0);
} else {
info->allocated_size = 0;
info->empty_size = 0;
@@ -1108,11 +1126,10 @@ pf_s32 PFFILE_p_combine(PF_VOLUME* volume, PF_STR* first_path, PF_STR* second_pa
PFFILE_ENT_ITER second_iter_copy;
PF_DIR_ENT first_entry;
PF_DIR_ENT second_entry;
PFFILE_FFD first_ffd;
PFFILE_FFD second_ffd;
PF_FAT_HINT first_hint;
PF_FAT_HINT second_hint;
pf_u32 index;
pf_s32 found;
pf_s32 error;
error = PFENT_ITER_GetEntryOfPath(&first_iter, &first_entry, volume, first_path, 0);
@@ -1129,24 +1146,36 @@ pf_s32 PFFILE_p_combine(PF_VOLUME* volume, PF_STR* first_path, PF_STR* second_pa
if ((first_entry.attr & 1) != 0 || (second_entry.attr & 1) != 0) {
return 0x18;
}
found = 0;
for (index = 0; index < 5; index++) {
PFFILE_SFD* sfd = &((PFFILE_VOLUME_DIRS*)first_entry.p_vol)->sfds[index];
if ((sfd->stat & 3) == 3 && first_entry.p_vol == sfd->dir_entry.p_vol &&
if ((sfd->stat & 1) != 0 && (sfd->stat & 2) != 0 &&
first_entry.p_vol == sfd->dir_entry.p_vol &&
first_entry.entry_sector == sfd->dir_entry.entry_sector &&
first_entry.entry_offset == sfd->dir_entry.entry_offset) {
return 0x13;
found = 1;
break;
}
}
if (found != 0) {
return 0x13;
}
found = 0;
for (index = 0; index < 5; index++) {
PFFILE_SFD* sfd = &((PFFILE_VOLUME_DIRS*)second_entry.p_vol)->sfds[index];
if ((sfd->stat & 3) == 3 && second_entry.p_vol == sfd->dir_entry.p_vol &&
if ((sfd->stat & 1) != 0 && (sfd->stat & 2) != 0 &&
second_entry.p_vol == sfd->dir_entry.p_vol &&
second_entry.entry_sector == sfd->dir_entry.entry_sector &&
second_entry.entry_offset == sfd->dir_entry.entry_offset) {
return 0x13;
found = 1;
break;
}
}
if (found != 0) {
return 0x13;
}
if (first_entry.entry_sector == second_entry.entry_sector &&
first_entry.entry_offset == second_entry.entry_offset) {
return 0xA;
@@ -1155,9 +1184,9 @@ pf_s32 PFFILE_p_combine(PF_VOLUME* volume, PF_STR* first_path, PF_STR* second_pa
return 0x25;
}
PFFAT_InitHint(&first_hint);
PFFAT_InitFFD(&first_ffd, &first_hint, volume, &first_entry.start_cluster);
PFFAT_InitFFD(&first_iter.ffd, &first_hint, volume, &first_entry.start_cluster);
PFFAT_InitHint(&second_hint);
PFFAT_InitFFD(&second_ffd, &second_hint, volume, &second_entry.start_cluster);
PFFAT_InitFFD(&second_iter.ffd, &second_hint, volume, &second_entry.start_cluster);
pf_memcpy(&second_iter_copy, &second_iter, sizeof(second_iter_copy));
error = PFENT_RemoveEntry(&second_entry, &second_iter);
if (error != 0) {
@@ -1485,18 +1514,19 @@ pf_s32 PFFILE_FsexecOpenFile(PF_DIR_ENT* entry, PFFILE_ENT_ITER* iter,
file->p_sfd = sfd;
file->stat = 1;
file->open_mode = mode;
file->last_access_data.state.last_error = 0;
file->lock_count = 0;
PFFAT_InitHint(&file->hint);
file->cursor.sector = 0xFFFFFFFF;
file->last_access_data.state.last_error = 0;
file->cursor.position = 0;
PFFILE_Cursor_Recalc(file);
if ((mode & 1) != 0) {
sfd->stat |= 4;
file->p_sfd->stat |= 4;
}
if ((mode & 4) != 0) {
if ((file->open_mode & 4) != 0) {
PFFILE_Cursor_MoveToEnd(file);
}
sfd->handler_count++;
data->p_file = (PF_FILE*)file;
return 0;
}
@@ -1600,12 +1630,13 @@ pf_s32 PFFILE_fopen(PF_STR* path, pf_s32 mode, PFFILE_FILE** result) {
}
pf_s32 PFFILE_fclose(PFFILE_FILE* file) {
pf_s32 close_error = 0;
PF_VOLUME* volume = file == PF_NULL ? PF_NULL : file->p_sfd->dir_entry.p_vol;
PFFILE_VOLUME_DIRS* volume_dirs;
pf_s32 error;
error = PFVOL_CheckForWrite(volume);
if (error != 0 && (error != 0x0B || file->open_mode != 2)) {
if (error != 0 && (error != 0x0B || (pf_s32)file->open_mode != 2)) {
pf_vol_set.last_error = error;
((PFFILE_VOLUME_DIRS*)volume)->last_error = error;
return error;
@@ -1617,12 +1648,11 @@ pf_s32 PFFILE_fclose(PFFILE_FILE* file) {
return 10;
}
volume_dirs->cache_signature = file;
if (file->p_sfd->handler_count <= 1 && (file->p_sfd->dir_entry.attr & 0x19) == 0 &&
PFVOL_CheckForWrite(volume) == 0 &&
if (((pf_s32)file->p_sfd->handler_count - 1) <= 0 &&
(file->p_sfd->dir_entry.attr & 0x19) == 0 &&
(error & 0x0B) == 0 &&
((file->p_sfd->stat & 4) != 0 || (volume_dirs->file_config & 1) != 1)) {
error = PFENT_updateEntry(&file->p_sfd->dir_entry, 1);
} else {
error = 0;
close_error = PFENT_updateEntry(&file->p_sfd->dir_entry, 1);
}
if (file->lock_count != 0) {
if ((file->p_sfd->lock.mode & 1) != 0) {
@@ -1633,7 +1663,7 @@ pf_s32 PFFILE_fclose(PFFILE_FILE* file) {
}
file->p_sfd->lock.mode &= ~3;
} else if (file->p_sfd->lock.owner != (PF_FILE*)file) {
error = 0x19;
close_error = 0x19;
} else {
file->p_sfd->lock.count = 0;
file->lock_count = 0;
@@ -1642,36 +1672,38 @@ pf_s32 PFFILE_fclose(PFFILE_FILE* file) {
file->p_sfd->lock.mode &= ~3;
}
}
if (error != 0) {
pf_vol_set.last_error = error;
((PFFILE_VOLUME_DIRS*)file->p_sfd->ffd.p_vol)->last_error = error;
file->last_access_data.state.last_error = error;
} else if ((volume_dirs->cache_control & 2) != 0) {
error = PFCACHE_FlushFATCache(volume);
if (error != 0) {
pf_vol_set.last_error = error;
((PFFILE_VOLUME_DIRS*)file->p_sfd->ffd.p_vol)->last_error = error;
file->last_access_data.state.last_error = error;
if (close_error != 0) {
pf_vol_set.last_error = close_error;
((PFFILE_VOLUME_DIRS*)file->p_sfd->ffd.p_vol)->last_error = close_error;
file->last_access_data.state.last_error = close_error;
goto close_file_complete;
}
if ((volume_dirs->cache_control & 2) != 0) {
close_error = PFCACHE_FlushFATCache(volume);
if (close_error != 0) {
pf_vol_set.last_error = close_error;
((PFFILE_VOLUME_DIRS*)file->p_sfd->ffd.p_vol)->last_error = close_error;
file->last_access_data.state.last_error = close_error;
} else {
error = PFCACHE_FlushDataCacheSpecific(volume, file);
if (error != 0) {
pf_vol_set.last_error = error;
((PFFILE_VOLUME_DIRS*)file->p_sfd->ffd.p_vol)->last_error = error;
file->last_access_data.state.last_error = error;
close_error = PFCACHE_FlushDataCacheSpecific(volume, file);
if (close_error != 0) {
pf_vol_set.last_error = close_error;
((PFFILE_VOLUME_DIRS*)file->p_sfd->ffd.p_vol)->last_error = close_error;
file->last_access_data.state.last_error = close_error;
}
}
}
if (error == 0) {
file->p_sfd->handler_count--;
if (file->p_sfd->handler_count == 0) {
if (close_error == 0) {
if (--file->p_sfd->handler_count == 0) {
file->p_sfd->stat &= ~1U;
file->p_sfd->ffd.cluster_link.buffer = PF_NULL;
}
file->stat &= ~1U;
volume_dirs->num_opened_files--;
}
close_file_complete:
volume_dirs->cache_signature = PF_NULL;
return error;
return close_error;
}
pf_s32 PFFILE_fread(pf_u8* buffer, pf_u32 size, pf_u32 count,
@@ -1704,11 +1736,12 @@ pf_s32 PFFILE_fread(pf_u8* buffer, pf_u32 size, pf_u32 count,
pf_s32 PFFILE_fwrite(const pf_u8* buffer, pf_u32 size, pf_u32 count,
PFFILE_FILE* file, pf_u32* count_written) {
PF_VOLUME* volume = file == PF_NULL ? PF_NULL : file->p_sfd->dir_entry.p_vol;
PF_VOLUME* volume;
pf_u32 bytes_written;
pf_s32 error;
*count_written = 0;
volume = file == PF_NULL ? PF_NULL : file->p_sfd->dir_entry.p_vol;
error = PFVOL_CheckForWrite(volume);
if (error != 0) {
pf_vol_set.last_error = error;
@@ -1753,10 +1786,10 @@ pf_s32 PFFILE_feof(PFFILE_FILE* file) {
((PFFILE_VOLUME_DIRS*)volume)->last_error = 0x26;
return 0x26;
}
if (file->cursor.position < file->p_sfd->dir_entry.file_size) {
return 0;
if (file->cursor.position >= file->p_sfd->dir_entry.file_size) {
error = 1;
}
return 1;
return error;
}
pf_s32 PFFILE_fseek(PFFILE_FILE* file, pf_s32 offset, pf_s32 origin) {
@@ -1841,10 +1874,9 @@ pf_s32 PFFILE_fsetclstlink(PFFILE_FILE* file, pf_u32 mode,
file->p_sfd->ffd.cluster_link.position++;
}
if (file->p_sfd->ffd.p_hint != PF_NULL) {
PFFILE_FAT_HINT* hint = (PFFILE_FAT_HINT*)file->p_sfd->ffd.p_hint;
hint->chain_index = 0;
hint->cluster = 0;
hint->previous_cluster = 0;
((PFFILE_FAT_HINT*)file->p_sfd->ffd.p_hint)->chain_index = 0;
((PFFILE_FAT_HINT*)file->p_sfd->ffd.p_hint)->cluster = 0;
((PFFILE_FAT_HINT*)file->p_sfd->ffd.p_hint)->previous_cluster = 0;
}
file->p_sfd->ffd.last_cluster.num_last_cluster = 0;
file->p_sfd->ffd.last_cluster.max_chain_index = 0;
@@ -1933,8 +1965,10 @@ pf_s32 PFFILE_fappend(PFFILE_FILE* file, pf_u32 size, pf_u32* size_appended) {
pf_s32 PFFILE_fadjust(PFFILE_FILE* file) {
PF_VOLUME* volume = file == PF_NULL ? PF_NULL : file->p_sfd->dir_entry.p_vol;
PFFILE_CURSOR saved_cursor;
PF_FAT_HINT saved_hint;
pf_u32 saved_last_access_chain_index;
struct {
PF_FAT_HINT hint;
pf_u32 last_access_chain_index;
} saved_hint;
pf_u16 access_time;
pf_s32 error;
@@ -1952,9 +1986,9 @@ pf_s32 PFFILE_fadjust(PFFILE_FILE* file) {
}
((PFFILE_VOLUME_DIRS*)volume)->cache_signature = file;
saved_cursor = file->cursor;
saved_hint = file->hint;
saved_last_access_chain_index = file->last_access_data.last_access.chain_index;
if ((file->open_mode & 8) == 0 && (file->open_mode & 4) != 0) {
saved_hint.hint = file->hint;
saved_hint.last_access_chain_index = file->last_access_data.last_access.chain_index;
if ((file->open_mode & 8) == 0 && (file->open_mode & 2) != 0) {
error = 0x0A;
} else if ((file->p_sfd->lock.mode & 3) != 0 &&
((file->p_sfd->lock.mode & 1) != 0 ||
@@ -1965,8 +1999,8 @@ pf_s32 PFFILE_fadjust(PFFILE_FILE* file) {
error &= (-error | error) >> 31;
}
file->cursor = saved_cursor;
file->hint = saved_hint;
file->last_access_data.last_access.chain_index = saved_last_access_chain_index;
file->hint = saved_hint.hint;
file->last_access_data.last_access.chain_index = saved_hint.last_access_chain_index;
((PFFILE_VOLUME_DIRS*)volume)->cache_signature = PF_NULL;
if (error != 0) {
pf_vol_set.last_error = error;
@@ -1981,8 +2015,10 @@ pf_s32 PFFILE_fadjust(PFFILE_FILE* file) {
pf_s32 PFFILE_finfo(PFFILE_FILE* file, PF_INFO* info) {
PF_VOLUME* volume = file == PF_NULL ? PF_NULL : file->p_sfd->dir_entry.p_vol;
PFFILE_CURSOR saved_cursor;
PF_FAT_HINT saved_hint;
pf_u32 saved_last_access_chain_index;
struct {
PF_FAT_HINT hint;
pf_u32 last_access_chain_index;
} saved_hint;
pf_s32 error;
error = PFVOL_CheckForRead(volume);
@@ -1999,12 +2035,12 @@ pf_s32 PFFILE_finfo(PFFILE_FILE* file, PF_INFO* info) {
}
((PFFILE_VOLUME_DIRS*)volume)->cache_signature = file;
saved_cursor = file->cursor;
saved_hint = file->hint;
saved_last_access_chain_index = file->last_access_data.last_access.chain_index;
saved_hint.hint = file->hint;
saved_hint.last_access_chain_index = file->last_access_data.last_access.chain_index;
error = PFFILE_p_finfo(file, info);
file->cursor = saved_cursor;
file->hint = saved_hint;
file->last_access_data.last_access.chain_index = saved_last_access_chain_index;
file->hint = saved_hint.hint;
file->last_access_data.last_access.chain_index = saved_hint.last_access_chain_index;
((PFFILE_VOLUME_DIRS*)volume)->cache_signature = PF_NULL;
if (error != 0) {
pf_vol_set.last_error = error;

File diff suppressed because it is too large Load Diff

View File

@@ -786,6 +786,7 @@ s32 PFVOL_CheckForWrite(PFVOL_VOLUME* volume) {
s32 PFVOL_CheckCurrentDir(PFVOL_VOLUME* volume, u32 start_cluster) {
s32 context_id;
u32 current_dir_index;
s32 result = 0;
if ((volume->flags & 8) == 0) {
return 9;
@@ -801,9 +802,9 @@ s32 PFVOL_CheckCurrentDir(PFVOL_VOLUME* volume, u32 start_cluster) {
current_dir_index = 0;
}
if (start_cluster == volume->current_dir[current_dir_index].directory.start_cluster) {
return -1;
result = -1;
}
return 0;
return result;
}
s32 PFVOL_SetCurrentDir(PFVOL_VOLUME* volume, PFVOL_DIR_ENTRY* directory) {
@@ -824,13 +825,15 @@ s32 PFVOL_SetCurrentDir(PFVOL_VOLUME* volume, PFVOL_DIR_ENTRY* directory) {
}
}
if (current_dir_index == 4) {
for (context_index = 0; context_index < 3; context_index++) {
pf_vol_set.context[context_index].stat &= 1;
if (pf_vol_set.context[context_index].stat != 0 &&
pf_vol_set.context[context_index].context_id == context_id) {
context_registered = 1;
break;
}
if (((pf_vol_set.context[0].stat &= 1) != 0 &&
context_id == pf_vol_set.context[0].context_id) ||
((pf_vol_set.context[1].stat &= 1) != 0 &&
context_id == pf_vol_set.context[1].context_id) ||
((pf_vol_set.context[2].stat &= 1) != 0 &&
context_id == pf_vol_set.context[2].context_id)) {
context_registered = 1;
} else {
context_registered = 0;
}
if (context_registered != 0) {
for (current_dir_index = 1; current_dir_index < 4; current_dir_index++) {
@@ -865,13 +868,15 @@ s32 PFVOL_GetCurrentDir(PFVOL_VOLUME* volume, PFVOL_DIR_ENTRY* directory) {
}
}
if (current_dir_index == 4) {
for (context_index = 0; context_index < 3; context_index++) {
pf_vol_set.context[context_index].stat &= 1;
if (pf_vol_set.context[context_index].stat != 0 &&
pf_vol_set.context[context_index].context_id == context_id) {
context_registered = 1;
break;
}
if (((pf_vol_set.context[0].stat &= 1) != 0 &&
context_id == pf_vol_set.context[0].context_id) ||
((pf_vol_set.context[1].stat &= 1) != 0 &&
context_id == pf_vol_set.context[1].context_id) ||
((pf_vol_set.context[2].stat &= 1) != 0 &&
context_id == pf_vol_set.context[2].context_id)) {
context_registered = 1;
} else {
context_registered = 0;
}
if (context_registered != 0) {
for (current_dir_index = 1; current_dir_index < 4; current_dir_index++) {

1476
libs/RVL_SDK/src/nup/nup.cpp Normal file

File diff suppressed because it is too large Load Diff

1473
libs/RVL_SDK/src/vi/vi.c Normal file

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,182 @@
#ifndef PRIVATE_NHTTP_H
#define PRIVATE_NHTTP_H
#include <revolution/nhttp.h>
#include <revolution/os.h>
#include <revolution/ssl.h>
#define STR_POSTBOUND "--t9Sf4yfjf1RtvDu3AA"
#define LEN_POSTBOUND 18
#define LEN_URLBUF 256
#define MIN(AA, BB) (((AA) > (BB)) ? (BB) : (AA))
typedef struct NHTTPBgnEndInfo NHTTPBgnEndInfo;
typedef struct NHTTPRequestInfo NHTTPRequestInfo;
#define NHTTP_CONN_RECVBUF_SIZE 0x8000
typedef struct NHTTPConnectionInfo NHTTPConnectionInfo;
typedef enum NHTTPConnectionEvent
{
NHTTP_EVENT_NONE,
NHTTP_EVENT_POST_SEND,
NHTTP_EVENT_BODY_RECV_FULL,
NHTTP_EVENT_BODY_RECV_DONE,
NHTTP_EVENT_COMPLETE,
NHTTP_CALLBACK_EVENT_MAX,
} NHTTPConnectionEvent;
typedef s32 (*NHTTPConnectionCallback)(NHTTPConnectionInfo* connection,
NHTTPConnectionEvent event, void* arg);
typedef struct NHTTPConnectionCallbackParam
{
void* value;
u32 _unk4;
u32 _unk8;
u32 _unkC;
} NHTTPConnectionCallbackParam;
typedef struct NHTTPPostSendArg
{
const char* label;
char* buf;
u32 size;
u32 offset;
} NHTTPPostSendArg;
typedef struct NHTTPBodyBufArg
{
char* buf;
u32 size;
u32 offset;
} NHTTPBodyBufArg;
typedef struct NHTTPHeader
{
struct NHTTPHeader* next;
struct NHTTPHeader* prev;
char* name;
char* value;
u32 length;
u32 _unk14;
} NHTTPHeader;
typedef struct NHTTPReqQueue
{
struct NHTTPReqQueue* next;
struct NHTTPReqQueue* prev;
s32 requestId;
NHTTPRequestInfo* volatile request;
s32 _unk10;
} NHTTPReqQueue;
typedef struct NHTTPListInfo
{
NHTTPReqQueue* reqQueue;
s32 nextRequestId;
} NHTTPListInfo;
typedef struct NHTTPReqInfo
{
NHTTPReqQueue* reqQueue;
} NHTTPReqInfo;
typedef struct NHTTPi_HDRBUFLIST
{
struct NHTTPi_HDRBUFLIST* next_p;
u8 block[NHTTP_HDRRECVBUF_BLOCKLEN];
} NHTTPi_HDRBUFLIST;
typedef struct NHTTPResponseInfo
{
volatile s32 headerLen;
volatile s32 bodyLen;
volatile s32 totalBodyLen;
volatile s32 contentLength;
s32 isSuccess;
s32 isHeaderParse;
s32 httpStatus;
u32 recvBufLen;
char* allHeader_p;
char* foundHeader_p;
char* recvBuf_p;
NHTTPResponseCallback bufFull;
NHTTPResponseCleanup freeBuf;
NHTTPi_HDRBUFLIST* hdrBufBlock_p;
u8 hdrBufFirst[NHTTP_HDRRECVBUF_INILEN];
void* param_p;
} NHTTPResponseInfo;
struct NHTTPRequestInfo
{
BOOL cancel;
s32 state;
BOOL secure;
BOOL proxyEnabled;
BOOL isRawData;
s32 hostEnd;
s32 pathStart;
s32 method;
u32 port;
char* url;
char* host;
NHTTPResponseInfo* response;
NHTTPHeader* headers;
NHTTPHeader* postData;
char multipartBoundary[LEN_POSTBOUND + 2];
char authorization[0x5C];
s32 authorizationLength;
SSLId sslId;
const char* clientCertData;
u32 clientCertSize;
const char* privateKeyData;
u32 privateKeySize;
const char* rootCAData;
u32 rootCASize;
BOOL clientCertDefault;
u32 verifyOption;
NHTTPEncodingType encodingType;
void* _unkD4;
u32 builtinRootCA;
u32 builtinClientCert;
char proxyServer[0x100];
u32 proxyPort;
char proxyAuthorization[0x5C];
s32 proxyAuthorizationLength;
u32 recvBufferSize;
const void* postBuffer;
u32 postBufferSize;
void* _unk250;
};
struct NHTTPConnectionInfo
{
BOOL started;
s32 state;
s32 sslError;
u32 _unkC;
NHTTPRequestInfo* request;
NHTTPResponseInfo* response;
s32 requestId;
NHTTPConnectionCallback callback;
NHTTPConnectionInfo* next;
u32 _unk24;
u32 _unk28;
u32 virtualContentLength;
NHTTPReqCallback requestCallback;
u32 _unk34;
u32 _unk38;
u32 _unk3C;
u8 recvBuf[0x8000];
u32 recvBufOffset;
u32 recvBufDataLen;
u32 _unk8048;
u32 _unk804C;
u32 _unk8050;
u32 _unk8054;
u32 _unk8058;
u32 _unk805C;
};
#endif // PRIVATE_NHTTP_H

View File

@@ -1,4 +1,3 @@
#ifndef REVOLUTION_NHTTP_H
#define REVOLUTION_NHTTP_H
@@ -6,49 +5,80 @@
#include <revolution/nhttp/nhttp_err.h>
#define NHTTP_HDRRECVBUF_INILEN 1024
#define NHTTP_HDRRECVBUF_BLOCKSHIFT 9
#define NHTTP_HDRRECVBUF_BLOCKLEN (1 << NHTTP_HDRRECVBUF_BLOCKSHIFT)
#define NHTTP_HDRRECVBUF_BLOCKMASK (NHTTP_HDRRECVBUF_BLOCKLEN - 1)
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
typedef struct {
u8 dummy[1];
} NHTTPRequest;
typedef struct {
u8 dummy[1];
} NHTTPResponse;
typedef int NHTTPConnection;
typedef void* (*NHTTPAlloc)(u32 size, int align);
typedef void (*NHTTPFree)(void* buf);
typedef void (*NHTTPRequestCallback)(int, NHTTPResponse*);
typedef void (*NHTTPCleanupCallback)();
int NHTTPStartup(NHTTPAlloc alloc, NHTTPFree free, u32 priority);
int NHTTPCleanupAsync(NHTTPCleanupCallback);
int NHTTPGetError();
typedef struct NHTTPRequestInfo NHTTPRequest;
typedef struct NHTTPResponseInfo NHTTPResponse;
typedef s32 NHTTPConnection;
NHTTPRequest* NHTTPCreateRequest(char* url, undefined4, void* buf, u32 bufSize, NHTTPRequestCallback reqCallback, undefined4);
NHTTPRequest* NHTTPCreateRequestEx(char* url, undefined4, void* buf, u32 bufSize, NHTTPRequestCallback reqCallback, undefined4, undefined4,
undefined4);
int NHTTPDeleteRequest(NHTTPRequest* request);
typedef enum NHTTPReqMethod {
NHTTP_REQMETHOD_GET,
NHTTP_REQMETHOD_POST,
NHTTP_REQMETHOD_HEAD,
} NHTTPReqMethod;
typedef enum NHTTPEncodingType {
NHTTP_ENCODING_TYPE_AUTO,
NHTTP_ENCODING_TYPE_URL,
NHTTP_ENCODING_TYPE_MULTIPART,
NHTTP_ENCODING_TYPE_MAX,
} NHTTPEncodingType;
typedef void (*NHTTPReqCallback)();
typedef void* (*NHTTPResponseCallback)(void** buffer, void* data,
u32 contentLength, NHTTPAlloc alloc,
NHTTPFree free, void* userParam);
typedef void (*NHTTPResponseCleanup)(void* buffer, NHTTPFree free,
void* userParam);
s32 NHTTPStartup(NHTTPAlloc alloc, NHTTPFree free, u32 priority);
void NHTTPCleanupAsync(NHTTPCleanupCallback callback);
s32 NHTTPGetError(void);
NHTTPRequest* NHTTPCreateRequest(const char* url, NHTTPReqMethod method,
void* buffer, u32 bufferSize,
NHTTPReqCallback callback, void* userParam);
NHTTPRequest* NHTTPCreateRequestEx(const char* url, NHTTPReqMethod method,
void* buffer, u32 bufferSize,
NHTTPReqCallback callback, void* userParam,
NHTTPResponseCallback responseCallback,
NHTTPResponseCleanup cleanup);
s32 NHTTPAddHeaderField(NHTTPRequest* request, const char* name,
const char* value);
s32 NHTTPAddPostDataRaw(NHTTPRequest* request, const void* data,
u32 size, const char* label);
s32 NHTTPDeleteRequest(NHTTPRequest* request);
NHTTPConnection NHTTPSendRequestAsync(NHTTPRequest* request);
int NHTTPCancelRequestAsync(NHTTPConnection connection);
s32 NHTTPCancelRequestAsync(NHTTPConnection connection);
void NHTTPGetProgress(u32* complete, u32* total);
s32 NHTTPGetProgress(u32* complete, u32* total);
int NHTTPDestroyResponse(NHTTPResponse* response);
u32 NHTTPGetHeaderField(NHTTPResponse* response, const char* name, const char** value);
void NHTTPDestroyResponse(NHTTPResponse* response);
s32 NHTTPGetHeaderAll(NHTTPResponse* response, const char** header);
s32 NHTTPGetHeaderField(NHTTPResponse* response, const char* name,
const char** value);
int NHTTPGetResultCode(NHTTPResponse* res);
s32 NHTTPGetBodyAll(NHTTPResponse* response, void** buffer);
s32 NHTTPGetResultCode(NHTTPResponse* response);
int NHTTPSetVerifyOption(NHTTPRequest* request, u32 option);
int NHTTPSetProxyDefault(NHTTPRequest* request);
int NHTTPSetRootCADefault(NHTTPRequest* request);
int NHTTPSetClientCertDefault(NHTTPRequest* request);
s32 NHTTPSetVerifyOption(NHTTPRequest* request, u32 option);
s32 NHTTPSetProxy(NHTTPRequest* request, const char* server, u16 port,
const char* username, const char* password);
s32 NHTTPSetProxyDefault(NHTTPRequest* request);
s32 NHTTPSetClientCertDefault(NHTTPRequest* request);
s32 NHTTPSetRootCADefault(NHTTPRequest* request);
#ifdef __cplusplus
}

View File

@@ -102,13 +102,16 @@ struct SOAddrInfo {
SOAddrInfo* next; // 0x20
};
#define SO_ENOTCONN -56
int SOSocket(int pf, int type, int protocol);
int __SOCreateSocket(int pf, int type, int protocol);
int SOClose(int s);
int SOConnect(int s, void* sockAddr);
int SORecv(int s, void* buf, int len, int flags);
int SOSend(int s, void* buf, int len, int flags);
int SOSend(int s, const void* buf, int len, int flags);
int SOFcntl(int s, int cmd, ...);
int SOShutdown(int s, int how);

View File

@@ -14,6 +14,7 @@ typedef struct IPAddrEntry {
} IPAddrEntry;
int SOGetInterfaceOpt(void* unk, int level, int optname, void* optval, int* optlen);
int SOSetSockOpt(int s, int level, int optname, const void* optval, int optlen);
#ifdef __cplusplus
}

View File

@@ -0,0 +1,179 @@
#include <revolution/nhttp.h>
#include <revolution/ncd.h>
#include <revolution/os.h>
#include <stdio.h>
int SOClose(int s);
typedef struct NHTTPBgnEndInfo
{
NCDIpConfig ipConfig;
NHTTPAlloc alloc;
NHTTPFree free;
BOOL started;
s32 socket;
s32 sslError;
NHTTPErr error;
u32 _unk7DC;
void* threadStack;
u32 _unk7E4;
} NHTTPBgnEndInfo;
NHTTPBgnEndInfo* NHTTPi_GetSystemInfoP(void);
NHTTPBgnEndInfo* NHTTPi_GetBgnEndInfoP(void* systemInfo);
void* NHTTPi_GetListInfoP(void* systemInfo);
void* NHTTPi_GetReqInfoP(void* systemInfo);
void* NHTTPi_GetMutexInfoP(void* systemInfo);
void* NHTTPi_GetThreadInfoP(void* systemInfo);
void NHTTPi_InitListInfo(void* listInfo);
void NHTTPi_InitRequestInfo(void* reqInfo);
void NHTTPi_initLockReqList(void* mutexInfo);
void NHTTPi_exitLockReqList(void);
BOOL NHTTPi_createCommThread(void* threadInfo, u32 priority, void* stack);
void NHTTPi_destroyCommThread(void* threadInfo, NHTTPBgnEndInfo* bgnEndInfo);
void NHTTPi_CheckCurrentThread(void* threadInfo, BOOL allowCommThread);
void NHTTPi_cancelAllRequests(void* systemInfo);
int NHTTPi_GetConnectionListLength(void);
void NHTTPi_InitConnectionList(void);
void NHTTPi_InitBgnEndInfo(NHTTPBgnEndInfo* info)
{
info->sslError = 0;
info->error = NHTTP_ERROR_NONE;
info->alloc = NULL;
info->free = NULL;
info->started = FALSE;
info->socket = -1;
info->_unk7DC = 0;
info->threadStack = NULL;
info->_unk7E4 = 0;
}
void* NHTTPi_alloc(u32 size, int align)
{
NHTTPBgnEndInfo* info = NHTTPi_GetSystemInfoP();
if (info->alloc != NULL)
{
return info->alloc(size, align);
}
return NULL;
}
void NHTTPi_free(void* buf)
{
NHTTPBgnEndInfo* info = NHTTPi_GetSystemInfoP();
if (info->free != NULL)
{
info->free(buf);
}
}
void NHTTPi_SetError(NHTTPBgnEndInfo* info, NHTTPErr error)
{
info->error = error;
}
void NHTTPi_SetSSLError(NHTTPBgnEndInfo* info, s32 error)
{
info->sslError = error;
}
s32 NHTTPi_GetSSLError(NHTTPBgnEndInfo* info)
{
return info->sslError;
}
BOOL NHTTPi_Startup(void* systemInfo, NHTTPAlloc alloc, NHTTPFree free,
u32 priority)
{
NHTTPBgnEndInfo* bgnEndInfo = NHTTPi_GetBgnEndInfoP(systemInfo);
void* listInfo = NHTTPi_GetListInfoP(systemInfo);
void* reqInfo = NHTTPi_GetReqInfoP(systemInfo);
void* mutexInfo = NHTTPi_GetMutexInfoP(systemInfo);
void* threadInfo = NHTTPi_GetThreadInfoP(systemInfo);
void* stack;
NCDErr result;
bgnEndInfo->alloc = alloc;
bgnEndInfo->free = free;
bgnEndInfo->error = NHTTP_ERROR_NONE;
bgnEndInfo->sslError = 0;
bgnEndInfo->_unk7DC = 0;
NHTTPi_InitListInfo(listInfo);
NHTTPi_InitRequestInfo(reqInfo);
NHTTPi_initLockReqList(mutexInfo);
NHTTPi_InitConnectionList();
bgnEndInfo->socket = -1;
stack = NHTTPi_alloc(0x2000, 8);
bgnEndInfo->threadStack = stack;
if (stack == NULL)
{
bgnEndInfo->error = NHTTP_ERROR_ALLOC;
NHTTPi_exitLockReqList();
return FALSE;
}
if (!NHTTPi_createCommThread(threadInfo, priority, stack))
{
bgnEndInfo->error = NHTTP_ERROR_REVOLUTIONSDK;
NHTTPi_free(bgnEndInfo->threadStack);
bgnEndInfo->threadStack = NULL;
NHTTPi_exitLockReqList();
return FALSE;
}
result = NCDGetCurrentIpConfig(&bgnEndInfo->ipConfig);
if (result < 0)
{
OSReport("NCDGetCurrentIpConfig err = %d\n", result);
OSPanic("NHTTP_bgnend.c", 230, "NCDGetCurrentIpConfig");
}
bgnEndInfo->started = TRUE;
return TRUE;
}
void NHTTPi_CleanupAsync(void* systemInfo, NHTTPCleanupCallback callback)
{
NHTTPBgnEndInfo* bgnEndInfo = NHTTPi_GetBgnEndInfoP(systemInfo);
void* threadInfo = NHTTPi_GetThreadInfoP(systemInfo);
int connectionCount;
NHTTPi_CheckCurrentThread(threadInfo, TRUE);
NHTTPi_cancelAllRequests(systemInfo);
NHTTPi_destroyCommThread(threadInfo, bgnEndInfo);
NHTTPi_free(bgnEndInfo->threadStack);
bgnEndInfo->threadStack = NULL;
NHTTPi_exitLockReqList();
bgnEndInfo->started = FALSE;
if (callback != NULL)
{
callback();
}
connectionCount = NHTTPi_GetConnectionListLength();
if (connectionCount != 0)
{
printf("*warning: %d connections rests! Please free connections.\n",
connectionCount);
}
if (bgnEndInfo->socket >= 0)
{
SOClose(bgnEndInfo->socket);
bgnEndInfo->socket = -1;
}
}
s32 NHTTPi_GetError(NHTTPBgnEndInfo* info)
{
return info->error;
}

View File

@@ -0,0 +1,102 @@
#include <private/nhttp.h>
#include <stdio.h>
s32 NHTTPi_compareToken(const char* lhs, const char* rhs);
void* NHTTPi_alloc(u32 size, int align);
void NHTTPi_SetError(NHTTPBgnEndInfo* info, NHTTPErr error);
static BOOL addHdrList(NHTTPHeader** list, NHTTPBgnEndInfo* info, char* name,
char* value)
{
BOOL found = FALSE;
NHTTPHeader* header = *list;
if (header != NULL)
{
if (NHTTPi_compareToken(name, header->name) != 0)
{
header = header->prev;
while (header != *list)
{
if (NHTTPi_compareToken(name, header->name) == 0)
{
found = TRUE;
break;
}
header = header->prev;
}
}
else
{
found = TRUE;
}
}
if (found)
{
header->value = value;
}
else
{
header = NHTTPi_alloc(sizeof(NHTTPHeader), 4);
if (header == NULL)
{
printf("failed to allocate memory\n");
NHTTPi_SetError(info, NHTTP_ERROR_ALLOC);
return FALSE;
}
header->name = name;
header->value = value;
header->length = 0;
header->_unk14 = 0;
if (*list != NULL)
{
header->next = (*list)->next;
header->prev = *list;
(*list)->next->prev = header;
(*list)->next = header;
}
else
{
header->prev = header;
header->next = header;
*list = header;
}
}
return TRUE;
}
NHTTPHeader* NHTTPi_getHdrFromList(NHTTPHeader** list)
{
NHTTPHeader* header = *list;
if (header != NULL)
{
if (header != header->next)
{
header->next->prev = header->prev;
header->prev->next = header->next;
*list = header->prev;
}
else
{
*list = NULL;
}
}
return header;
}
BOOL NHTTP_AddHeaderField(NHTTPRequestInfo* request, NHTTPBgnEndInfo* info,
char* name, char* value)
{
if (request->state != 0)
{
return FALSE;
}
return addHdrList(&request->headers, info, name, value);
}

View File

@@ -0,0 +1,126 @@
#include <private/nhttp.h>
void* NHTTPi_alloc(u32 size, int align);
void NHTTPi_free(void* ptr);
NHTTPConnectionInfo* NHTTPi_Request2Connection(void* mutexInfo,
NHTTPRequestInfo* request);
void NHTTPi_destroyRequestObject(void* mutexInfo, NHTTPRequestInfo* request);
void NHTTPi_CompleteCallback(void* mutexInfo, NHTTPConnectionInfo* connection);
NHTTPHeader* NHTTPi_getHdrFromList(NHTTPHeader** list);
void NHTTPi_InitListInfo(NHTTPListInfo* info)
{
info->reqQueue = NULL;
info->nextRequestId = 0;
}
s32 NHTTPi_setReqQueue(NHTTPListInfo* info, NHTTPRequestInfo* request)
{
s32 requestId = -1;
NHTTPReqQueue* queue = NHTTPi_alloc(sizeof(NHTTPReqQueue), 4);
if (queue != NULL)
{
if (info->reqQueue != NULL)
{
queue->next = info->reqQueue->next;
queue->prev = info->reqQueue;
info->reqQueue->next->prev = queue;
info->reqQueue->next = queue;
}
else
{
queue->next = queue;
queue->prev = queue;
info->reqQueue = queue;
}
queue->requestId = info->nextRequestId++;
queue->request = request;
queue->_unk10 = -1;
requestId = queue->requestId;
if (info->nextRequestId < 0)
{
info->nextRequestId = 0;
}
}
return requestId;
}
BOOL NHTTPi_freeReqQueue(NHTTPListInfo* info, void* mutexInfo, s32 requestId)
{
NHTTPReqQueue* current;
NHTTPReqQueue* queue = info->reqQueue;
NHTTPReqQueue* found = NULL;
BOOL result = FALSE;
if (queue != NULL)
{
if (queue->requestId == requestId)
{
found = queue;
}
else
{
current = queue->prev;
while (current != queue)
{
if (current->requestId == requestId)
{
found = current;
break;
}
current = current->prev;
}
}
}
if (found != NULL)
{
NHTTPConnectionInfo* connection;
if (queue != queue->next)
{
found->next->prev = found->prev;
found->prev->next = found->next;
if (info->reqQueue == found)
{
info->reqQueue = found->prev;
}
}
else
{
info->reqQueue = NULL;
}
connection = NHTTPi_Request2Connection(mutexInfo, found->request);
NHTTPi_destroyRequestObject(mutexInfo, found->request);
NHTTPi_free(found);
if (connection != NULL)
{
connection->state = 8;
NHTTPi_CompleteCallback(mutexInfo, connection);
}
result = TRUE;
}
return result;
}
void NHTTPi_allFreeReqQueue(NHTTPListInfo* info, void* mutexInfo)
{
while (info->reqQueue != NULL)
{
NHTTPi_freeReqQueue(info, mutexInfo, info->reqQueue->requestId);
}
}
NHTTPReqQueue* NHTTPi_getReqFromReqQueue(NHTTPReqQueue** queue)
{
return (NHTTPReqQueue*)NHTTPi_getHdrFromList((NHTTPHeader**)queue);
}

View File

@@ -0,0 +1,120 @@
#include <revolution/nhttp.h>
#include <revolution/ncd.h>
#include <revolution/os.h>
typedef struct NHTTPMutexInfo
{
OSMutex mutex;
BOOL initialized;
} NHTTPMutexInfo;
typedef struct NHTTPBgnEndInfo
{
NCDIpConfig ipConfig;
NHTTPAlloc alloc;
NHTTPFree free;
BOOL started;
s32 socket;
s32 sslError;
NHTTPErr error;
u32 _unk7DC;
void* threadStack;
u32 _unk7E4;
} NHTTPBgnEndInfo;
typedef struct NHTTPThreadInfo
{
OSMessageQueue messageQueue;
OSMessage messages[3];
OSThread thread;
BOOL isCreateCommThreadMessageQueue;
u8 _unk34C[0x14];
char commBuf[0x100];
} NHTTPThreadInfo;
BOOL NHTTPi_IsCreateCommThreadMessageQueue(NHTTPThreadInfo* info);
void NHTTPi_IsCreateCommThreadMessageQueueOn(NHTTPThreadInfo* info);
void NHTTPi_CommThreadProcMain(void* argument);
void NHTTPi_InitMutexInfo(NHTTPMutexInfo* info)
{
info->initialized = FALSE;
}
void NHTTPi_initLockReqList(NHTTPMutexInfo* info)
{
if (!info->initialized)
{
OSInitMutex(&info->mutex);
info->initialized = TRUE;
}
}
void NHTTPi_exitLockReqList(void)
{
}
void NHTTPi_lockReqList(NHTTPMutexInfo* info)
{
OSLockMutex(&info->mutex);
}
void NHTTPi_unlockReqList(NHTTPMutexInfo* info)
{
OSUnlockMutex(&info->mutex);
}
void* NHTTPi_CommThreadProc(void* argument);
BOOL NHTTPi_createCommThread(NHTTPThreadInfo* info, s32 priority, void* stack)
{
if (!NHTTPi_IsCreateCommThreadMessageQueue(info))
{
OSInitMessageQueue(&info->messageQueue, info->messages, 3);
NHTTPi_IsCreateCommThreadMessageQueueOn(info);
}
OSCreateThread(&info->thread, NHTTPi_CommThreadProc, NULL, (u8*)stack + 0x2000, 0x2000, priority, 0);
OSResumeThread(&info->thread);
return TRUE;
}
void NHTTPi_destroyCommThread(NHTTPThreadInfo* info, NHTTPBgnEndInfo* bgnEndInfo)
{
bgnEndInfo->_unk7DC = 1;
OSSendMessage(&info->messageQueue, NULL, 0);
OSJoinThread(&info->thread, NULL);
}
void NHTTPi_idleCommThread(NHTTPThreadInfo* info)
{
OSMessage message;
OSReceiveMessage(&info->messageQueue, &message, OS_MESSAGE_BLOCK);
}
void NHTTPi_kickCommThread(NHTTPThreadInfo* info)
{
OSSendMessage(&info->messageQueue, NULL, 0);
}
void NHTTPi_CheckCurrentThread(NHTTPThreadInfo* info, BOOL notCommThread)
{
OSThread* current = OSGetCurrentThread();
OSThread* commThread = &info->thread;
if (current != NULL
&& ((!notCommThread && current != commThread)
|| (notCommThread && current == commThread)))
{
OSReport("%s:illegal thread\n", __FUNCTION__);
OSPanic(__FILE__, 223, "halt\n");
}
}
void* NHTTPi_CommThreadProc(void* argument)
{
NHTTPi_CommThreadProcMain(argument);
return NULL;
}

View File

@@ -0,0 +1,487 @@
#include <private/nhttp.h>
const char NHTTPi_strMultipartBound[] = STR_POSTBOUND;
void* NHTTPi_alloc(u32 size, int align);
void NHTTPi_free(void* ptr);
void NHTTPi_SetError(NHTTPBgnEndInfo* info, NHTTPErr error);
void* NHTTPi_memclr(void* destination, u32 size);
s32 NHTTPi_strlen(const char* string);
void* NHTTPi_memcpy(void* destination, const void* source, u32 size);
s32 NHTTPi_strnicmp(const char* left, const char* right, s32 size);
s32 NHTTPi_strToHex(const char* string, s32 length);
s32 NHTTPi_strtonum(const char* string, s32 length);
NHTTPBgnEndInfo* NHTTPi_GetBgnEndInfoP(void* systemInfo);
NHTTPListInfo* NHTTPi_GetListInfoP(void* systemInfo);
NHTTPReqInfo* NHTTPi_GetReqInfoP(void* systemInfo);
void* NHTTPi_GetMutexInfoP(void* systemInfo);
void* NHTTPi_GetThreadInfoP(void* systemInfo);
NHTTPConnectionInfo* NHTTPi_Request2Connection(void* mutexInfo,
NHTTPRequestInfo* request);
void NHTTPi_lockReqList(void* mutexInfo);
void NHTTPi_unlockReqList(void* mutexInfo);
s32 NHTTPi_setReqQueue(NHTTPListInfo* listInfo, NHTTPRequestInfo* request);
void NHTTPi_kickCommThread(void* threadInfo);
void NHTTPi_SocCancel(void* mutexInfo, NHTTPRequestInfo* request, s32 socket);
BOOL NHTTPi_freeReqQueue(NHTTPListInfo* listInfo, void* mutexInfo,
s32 requestId);
void NHTTPi_allFreeReqQueue(NHTTPListInfo* listInfo, void* mutexInfo);
void NHTTPi_InitRequestInfo(NHTTPReqInfo* info)
{
info->reqQueue = NULL;
}
NHTTPRequestInfo* NHTTP_CreateRequest(NHTTPBgnEndInfo* bgnEndInfo_p,
const char* url_p, s32 method, void* buf_p, u32 len, void* param_p,
NHTTPResponseCallback bufFull, NHTTPResponseCleanup freeBuf)
{
int i;
int suflen, urllen, prelen;
int nhostenc, deccount;
int declen, hostend;
int port;
int decode_urllen;
char a_url[LEN_URLBUF];
char* prefix_p;
NHTTPRequestInfo* req_p = NULL;
if (method >= 3 || method < 0)
{
NHTTPi_SetError(bgnEndInfo_p, NHTTP_ERROR_UNKNOWN);
goto errend;
}
req_p = NHTTPi_alloc(sizeof(NHTTPRequestInfo), 4);
if (!req_p)
{
NHTTPi_SetError(bgnEndInfo_p, NHTTP_ERROR_ALLOC);
goto errend;
}
NHTTPi_memclr(req_p, sizeof(NHTTPRequestInfo));
req_p->response = NHTTPi_alloc(sizeof(NHTTPResponseInfo), 4);
if (!req_p->response)
{
NHTTPi_SetError(bgnEndInfo_p, NHTTP_ERROR_ALLOC);
goto errend;
}
NHTTPi_memclr(req_p->response, sizeof(NHTTPResponseInfo));
req_p->response->recvBuf_p = buf_p;
req_p->response->recvBufLen = len;
req_p->response->bufFull = bufFull;
req_p->response->freeBuf = freeBuf;
urllen = NHTTPi_strlen(url_p);
if (urllen <= 7)
{
NHTTPi_SetError(bgnEndInfo_p, NHTTP_ERROR_DNS);
goto errend;
}
NHTTPi_memclr(a_url, urllen);
NHTTPi_memcpy(a_url, url_p, urllen);
req_p->port = 80;
suflen = 7;
if (NHTTPi_strnicmp(a_url, "http://", 7) != 0)
{
if (NHTTPi_strnicmp(a_url, "https://", 8) != 0)
{
NHTTPi_SetError(bgnEndInfo_p, NHTTP_ERROR_DNS);
goto errend;
}
req_p->secure = TRUE;
req_p->port = 443;
suflen = 8;
}
prefix_p = a_url + suflen;
prelen = urllen - suflen;
if (prelen <= 0)
{
NHTTPi_SetError(bgnEndInfo_p, NHTTP_ERROR_DNS);
goto errend;
}
for (i = 0, nhostenc = 0, deccount = 0;
(i < prelen) && (prefix_p[i] != '/'); i++)
{
if (deccount == 2)
{
deccount--;
}
else if (deccount == 1)
{
s8 c = (s8)NHTTPi_strToHex(&prefix_p[i - 1], 2);
deccount--;
if (c < 0)
{
NHTTPi_SetError(bgnEndInfo_p, NHTTP_ERROR_DNS);
goto errend;
}
if (c == '/')
{
nhostenc--;
break;
}
}
else if (prefix_p[i] == '%')
{
deccount = 2;
nhostenc++;
}
}
if (deccount)
{
NHTTPi_SetError(bgnEndInfo_p, NHTTP_ERROR_DNS);
goto errend;
}
decode_urllen = suflen + prelen - nhostenc * 2 + 1;
req_p->url = NHTTPi_alloc(decode_urllen, 4);
if (!req_p->url)
{
NHTTPi_SetError(bgnEndInfo_p, NHTTP_ERROR_ALLOC);
goto errend;
}
NHTTPi_memclr(req_p->url, decode_urllen);
NHTTPi_memcpy(req_p->url, a_url, suflen);
for (i = 0, declen = 0, deccount = 0, hostend = FALSE;
i < prelen; i++)
{
if (deccount == 2)
{
deccount--;
}
else if (deccount == 1)
{
char c = (char)NHTTPi_strToHex(&prefix_p[i - 1], 2);
deccount--;
req_p->url[suflen + declen - 1] = c;
if (c == '/')
{
hostend = TRUE;
}
}
else
{
if (prefix_p[i] == '/')
{
hostend = TRUE;
}
if (!hostend & (prefix_p[i] == '%'))
{
deccount = 2;
}
else
{
req_p->url[suflen + declen] = prefix_p[i];
}
declen++;
}
}
req_p->url[suflen + declen] = 0;
prefix_p = &req_p->url[suflen];
prelen = declen;
for (i = 0; i < prelen; i++)
{
if ((prefix_p[i] == '/') || (prefix_p[i] == ':'))
{
req_p->hostEnd = i + suflen;
break;
}
}
if (i == prelen)
{
req_p->pathStart = req_p->hostEnd = i + suflen;
}
else if (prefix_p[i] == '/')
{
req_p->pathStart = req_p->hostEnd;
}
else if (prefix_p[i] == ':')
{
for (; i < prelen; i++)
{
if (prefix_p[i] == '/')
{
req_p->pathStart = i + suflen;
break;
}
}
if (i == prelen)
{
req_p->pathStart = i + suflen;
}
else
{
port = NHTTPi_strtonum(&req_p->url[req_p->hostEnd + 1],
(int)(req_p->pathStart - (req_p->hostEnd + 1)));
if (port < 0)
{
port = req_p->port;
}
else if (port > 65535)
{
NHTTPi_SetError(bgnEndInfo_p, NHTTP_ERROR_DNS);
goto errend;
}
req_p->port = (u16)port;
}
}
{
u32 a_hostnameLen = (u32)(req_p->hostEnd - (req_p->secure ? 8 : 7));
req_p->host = NHTTPi_alloc(a_hostnameLen + 1, 4);
if (!req_p->host)
{
NHTTPi_SetError(bgnEndInfo_p, NHTTP_ERROR_ALLOC);
goto errend;
}
NHTTPi_memclr(req_p->host, (int)(a_hostnameLen + 1));
NHTTPi_memcpy(req_p->host,
req_p->url + (req_p->secure ? 8 : 7), (int)a_hostnameLen);
}
NHTTPi_memcpy(req_p->multipartBoundary, NHTTPi_strMultipartBound,
sizeof(req_p->multipartBoundary));
req_p->method = method;
req_p->sslId = 0;
req_p->clientCertData = NULL;
req_p->clientCertSize = 0;
req_p->privateKeyData = NULL;
req_p->privateKeySize = 0;
req_p->rootCAData = NULL;
req_p->rootCASize = 0;
req_p->clientCertDefault = FALSE;
req_p->verifyOption = 0;
req_p->_unkD4 = NULL;
req_p->response->param_p = param_p;
req_p->proxyEnabled = FALSE;
req_p->recvBufferSize = 0;
return req_p;
errend:
if (req_p)
{
if (req_p->url)
{
NHTTPi_free(req_p->url);
}
if (req_p->host)
{
NHTTPi_free(req_p->host);
}
if (req_p->response)
{
NHTTPi_free(req_p->response);
}
NHTTPi_free(req_p);
}
return NULL;
}
void NHTTP_DestroyRequest(void* systemInfo, NHTTPRequestInfo* request)
{
NHTTPConnectionInfo* connection;
NHTTPHeader* header;
NHTTPHeader* next;
NHTTPHeader* post;
NHTTPHeader* nextPost;
void* mutexInfo = NHTTPi_GetMutexInfoP(systemInfo);
connection = NHTTPi_Request2Connection(mutexInfo, request);
if (connection != NULL)
{
connection->response = NULL;
}
NHTTPi_free(request->response);
connection = NHTTPi_Request2Connection(mutexInfo, request);
if (connection != NULL)
{
connection->request = NULL;
}
header = request->headers;
while (header != NULL)
{
if (header != header->next)
{
next = header->next->next;
NHTTPi_free(header->next);
header->next = next;
}
else
{
NHTTPi_free(header);
header = NULL;
}
}
post = request->postData;
while (post != NULL)
{
if (post != post->next)
{
nextPost = post->next->next;
NHTTPi_free(post->next);
post->next = nextPost;
}
else
{
NHTTPi_free(post);
post = NULL;
}
}
NHTTPi_free(request->url);
NHTTPi_free(request->host);
NHTTPi_free(request);
}
BOOL NHTTPi_destroyRequestObject(void* mutexInfo, NHTTPRequestInfo* request)
{
NHTTPConnectionInfo* connection;
NHTTPHeader* header;
NHTTPHeader* next;
NHTTPHeader* post;
NHTTPHeader* nextPost;
connection = NHTTPi_Request2Connection(mutexInfo, request);
if (connection != NULL)
{
connection->request = NULL;
}
header = request->headers;
while (header != NULL)
{
if (header != header->next)
{
next = header->next->next;
NHTTPi_free(header->next);
header->next = next;
}
else
{
NHTTPi_free(header);
header = NULL;
}
}
post = request->postData;
while (post != NULL)
{
if (post != post->next)
{
nextPost = post->next->next;
NHTTPi_free(post->next);
post->next = nextPost;
}
else
{
NHTTPi_free(post);
post = NULL;
}
}
NHTTPi_free(request->url);
NHTTPi_free(request->host);
NHTTPi_free(request);
return TRUE;
}
s32 NHTTP_SendRequestAsync(void* systemInfo, NHTTPRequestInfo* request)
{
NHTTPBgnEndInfo* info = NHTTPi_GetBgnEndInfoP(systemInfo);
void* threadInfo = NHTTPi_GetThreadInfoP(systemInfo);
void* mutexInfo = NHTTPi_GetMutexInfoP(systemInfo);
s32 requestId;
if (request->state != 0)
{
NHTTPi_SetError(info, NHTTP_ERROR_UNKNOWN);
return -1;
}
NHTTPi_lockReqList(mutexInfo);
requestId = NHTTPi_setReqQueue(NHTTPi_GetListInfoP(systemInfo), request);
if (requestId >= 0)
{
request->state = 1;
NHTTPi_kickCommThread(threadInfo);
}
else
{
NHTTPi_SetError(info, NHTTP_ERROR_ALLOC);
}
NHTTPi_unlockReqList(mutexInfo);
return requestId;
}
BOOL NHTTP_CancelRequestAsync(void* sysInfo_p, s32 id)
{
BOOL rc = FALSE;
NHTTPReqInfo* reqInfo_p = NHTTPi_GetReqInfoP(sysInfo_p);
void* mutexInfo_p = NHTTPi_GetMutexInfoP(sysInfo_p);
volatile NHTTPReqQueue* reqCurrent_p = reqInfo_p->reqQueue;
NHTTPi_lockReqList(mutexInfo_p);
if (reqCurrent_p)
{
if (reqCurrent_p->requestId == id)
{
if (!reqCurrent_p->request->cancel)
{
reqCurrent_p->request->cancel = TRUE;
NHTTPi_SocCancel(mutexInfo_p, reqCurrent_p->request,
reqCurrent_p->_unk10);
rc = TRUE;
}
}
}
if (!rc)
{
NHTTPListInfo* listInfo_p = NHTTPi_GetListInfoP(sysInfo_p);
rc = NHTTPi_freeReqQueue(listInfo_p, mutexInfo_p, id);
}
NHTTPi_unlockReqList(mutexInfo_p);
return rc;
}
void NHTTPi_cancelAllRequests(void* sysInfo_p)
{
NHTTPReqInfo* reqInfo_p = NHTTPi_GetReqInfoP(sysInfo_p);
NHTTPListInfo* listInfo_p = NHTTPi_GetListInfoP(sysInfo_p);
void* mutexInfo_p = NHTTPi_GetMutexInfoP(sysInfo_p);
volatile NHTTPReqQueue* reqCurrent_p = reqInfo_p->reqQueue;
NHTTPi_lockReqList(mutexInfo_p);
if (reqCurrent_p)
{
if (!reqCurrent_p->request->cancel)
{
reqCurrent_p->request->cancel = TRUE;
NHTTPi_SocCancel(mutexInfo_p, reqCurrent_p->request,
reqCurrent_p->_unk10);
}
}
NHTTPi_allFreeReqQueue(listInfo_p, mutexInfo_p);
NHTTPi_unlockReqList(mutexInfo_p);
}

View File

@@ -0,0 +1,202 @@
#include <private/nhttp.h>
void* NHTTPi_alloc(u32 size, int align);
void NHTTPi_free(void* ptr);
void NHTTPi_SetError(NHTTPBgnEndInfo* info, NHTTPErr error);
s32 NHTTPi_loadFromHdrRecvBuf(NHTTPResponseInfo* res_p, char* dst, s32 pos,
s32 size);
s32 NHTTPi_strcmp(const char* lhs, const char* rhs);
s32 NHTTPi_getHeaderValue(const NHTTPResponseInfo* res_p, const char* label_p,
s32* pos_p);
NHTTPConnectionInfo* NHTTPi_Response2Connection(void* mutexInfo_p,
NHTTPResponseInfo* res_p);
s32 NHTTPi_findNextLineHdrRecvBuf(const NHTTPResponseInfo* res_p, s32 pos,
s32 limit, s32* colon_pos_p, s32* return_code_size_p);
s32 NHTTPi_compareTokenN_HdrRecvBuf(const NHTTPResponseInfo* res_p, s32 pos,
s32 limit, const char* str_p, s8 extdeli);
s32 NHTTPi_skipSpaceHdrRecvBuf(
const NHTTPResponseInfo* res_p, s32 pos, s32 limit);
void NHTTP_DestroyResponse(void* mutexInfo_p, NHTTPResponseInfo* res_p)
{
NHTTPi_HDRBUFLIST* list_p = NULL;
while (res_p->hdrBufBlock_p)
{
list_p = res_p->hdrBufBlock_p->next_p;
NHTTPi_free(res_p->hdrBufBlock_p);
res_p->hdrBufBlock_p = list_p;
}
if (res_p->allHeader_p)
{
NHTTPi_free(res_p->allHeader_p);
}
if (res_p->foundHeader_p)
{
NHTTPi_free(res_p->foundHeader_p);
}
if (res_p->freeBuf != NULL)
{
res_p->freeBuf(res_p->recvBuf_p, NHTTPi_free, res_p->param_p);
res_p->recvBuf_p = NULL;
res_p->recvBufLen = 0;
}
{
NHTTPConnectionInfo* connection_p =
NHTTPi_Response2Connection(mutexInfo_p, res_p);
if (connection_p != NULL)
{
connection_p->response = NULL;
}
}
NHTTPi_free(res_p);
}
s32 NHTTPi_getHeaderValue(const NHTTPResponseInfo* res_p, const char* label_p,
s32* pos_p)
{
s32 linetop, nextlinetop;
s32 labeltop, labelend;
s32 valuetop, valueend;
s32 return_code_size = 0;
linetop = NHTTPi_findNextLineHdrRecvBuf(
res_p, 12, res_p->headerLen, &labelend, &return_code_size);
while (linetop > 0)
{
nextlinetop = NHTTPi_findNextLineHdrRecvBuf(res_p, linetop,
res_p->headerLen, &labelend, &return_code_size);
if (labelend > 0)
{
labeltop = linetop;
if (NHTTPi_compareTokenN_HdrRecvBuf(
res_p, labeltop, labelend, label_p, 0)
== 0)
{
if (labelend + 1 < res_p->headerLen)
{
valueend = NHTTPi_findNextLineHdrRecvBuf(res_p,
labelend + 1, res_p->headerLen, NULL,
&return_code_size);
if (valueend <= 0)
{
valueend = res_p->headerLen;
}
else
{
if (valueend < return_code_size)
{
return -1;
}
valueend -= return_code_size;
}
valuetop = NHTTPi_skipSpaceHdrRecvBuf(
res_p, labelend + 1, valueend);
if (valuetop < 0)
{
valuetop = valueend;
}
*pos_p = valuetop;
return valueend - valuetop;
}
else
{
return 0;
}
}
}
linetop = nextlinetop;
}
return -1;
}
s32 NHTTP_GetHeaderField(NHTTPResponseInfo* res_p, const char* label_p,
const char** value_p)
{
s32 pos;
s32 length;
if (res_p->isHeaderParse == 0)
{
return -1;
}
if (res_p->foundHeader_p != NULL)
{
NHTTPi_free(res_p->foundHeader_p);
res_p->foundHeader_p = NULL;
}
length = NHTTPi_getHeaderValue(res_p, label_p, &pos);
if (length >= 0)
{
res_p->foundHeader_p = NHTTPi_alloc(length + 1, 4);
if (res_p->foundHeader_p == NULL)
{
return -1;
}
res_p->foundHeader_p[length] = 0;
NHTTPi_loadFromHdrRecvBuf(res_p, res_p->foundHeader_p, pos, length);
*value_p = res_p->foundHeader_p;
return length;
}
if (NHTTPi_strcmp("HTTPSTATUSCODE", label_p) == 0)
{
res_p->foundHeader_p = NHTTPi_alloc(4, 4);
if (res_p->foundHeader_p == NULL)
{
return -1;
}
res_p->foundHeader_p[3] = 0;
NHTTPi_loadFromHdrRecvBuf(res_p, res_p->foundHeader_p, 9, 3);
*value_p = res_p->foundHeader_p;
return 3;
}
return -1;
}
s32 NHTTP_GetHeaderAll(void* bgnEndInfo_p, NHTTPResponseInfo* res_p,
const char** header_p)
{
if (res_p->isHeaderParse == 0 || res_p->headerLen == 0)
{
return -1;
}
if (res_p->headerLen < NHTTP_HDRRECVBUF_INILEN)
{
*header_p = (const char*)res_p->hdrBufFirst;
}
else
{
if (res_p->allHeader_p == NULL)
{
res_p->allHeader_p = NHTTPi_alloc(res_p->headerLen, 4);
if (res_p->allHeader_p == NULL)
{
NHTTPi_SetError(bgnEndInfo_p, NHTTP_ERROR_ALLOC);
return -1;
}
NHTTPi_loadFromHdrRecvBuf(res_p, res_p->allHeader_p, 0,
res_p->headerLen);
}
*header_p = res_p->allHeader_p;
}
return res_p->headerLen;
}

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,673 @@
#include <private/nhttp.h>
#include <revolution/ncd.h>
#include <string.h>
#include <stdio.h>
struct NHTTPBgnEndInfo
{
NCDIpConfig ipConfig;
};
typedef s32 (*NHTTPPostSend)(const char* label, char** value_p,
u32* length_p, s32 offset, void* userParam);
void* NHTTPi_GetSystemInfoP(void);
NHTTPBgnEndInfo* NHTTPi_GetBgnEndInfoP(void* systemInfo);
void* NHTTPi_GetMutexInfoP(void* systemInfo);
BOOL NHTTPi_Startup(void* systemInfo, NHTTPAlloc alloc, NHTTPFree free,
u32 priority);
void NHTTPi_CleanupAsync(void* systemInfo, NHTTPCleanupCallback callback);
s32 NHTTPi_GetError(NHTTPBgnEndInfo* info);
void* NHTTPi_alloc(u32 size, int align);
void NHTTPi_free(void* buffer);
s32 NHTTPi_strlen(const char* string);
void* NHTTPi_memcpy(void* destination, const void* source, u32 size);
void* NHTTPi_memclr(void* destination, u32 size);
s32 NHTTPi_Base64Encode(char* destination, const char* source);
NHTTPConnectionInfo* NHTTPCreateConnection(const char* url, s32 method,
void* buffer, u32 bufferSize, NHTTPConnectionCallback callback,
void* userParam);
s32 NHTTPStartConnection(NHTTPConnectionInfo* connection);
s32 NHTTPGetBodyBuffer(NHTTPConnectionInfo* connection, void** buffer,
u32* bufferSize);
void* NHTTPGetUserParam(NHTTPConnectionInfo* connection);
s32 NHTTPGetConnectionError(NHTTPConnectionInfo* connection);
NHTTPConnectionInfo* NHTTPi_GetConnection(void* mutexInfo,
NHTTPConnectionInfo* connection);
NHTTPRequestInfo* NHTTPi_Connection2Request(void* mutexInfo,
NHTTPConnectionInfo* connection);
NHTTPResponseInfo* NHTTPi_Connection2Response(void* mutexInfo,
NHTTPConnectionInfo* connection);
NHTTPConnectionInfo* NHTTPi_Request2Connection(void* mutexInfo,
NHTTPRequestInfo* request);
NHTTPConnectionInfo* NHTTPi_Response2Connection(void* mutexInfo,
NHTTPResponseInfo* response);
NHTTPRequestInfo* NHTTPi_GetRequest(void* mutexInfo,
NHTTPRequestInfo* request);
NHTTPResponseInfo* NHTTPi_GetResponse(void* mutexInfo,
NHTTPResponseInfo* response);
s32 NHTTPi_OmitConnectionList(void* mutexInfo,
NHTTPConnectionInfo* connection);
u32 NHTTPi_GetVirtualContentLength(NHTTPConnectionInfo* connection);
BOOL NHTTP_AddHeaderField(NHTTPRequestInfo* request, NHTTPBgnEndInfo* info,
const char* name, const char* value);
BOOL NHTTP_AddPostDataAscii(NHTTPRequestInfo* request, NHTTPBgnEndInfo* info,
const char* name, const char* value);
BOOL NHTTP_CancelRequestAsync(void* systemInfo, s32 requestId);
void NHTTP_DestroyRequest(void* systemInfo, NHTTPRequestInfo* request);
void NHTTP_DestroyResponse(void* mutexInfo, NHTTPResponseInfo* response);
static s32 nhttpRegistered = 0;
const char* __NHTTPVersion = "<< RVL_SDK - NHTTP \trelease build: Jun 27 2007 16:27:59 (0x4199_60726) >>";
char __NHTTPUnofficialVersion[] = "<< RVL_SDK - NHTTP \trelease build: Jun 27 2007 16:27:59 (0x4199_60726) UNOFFICIAL >>";
s32 NHTTPStartup(NHTTPAlloc alloc, NHTTPFree free, u32 priority)
{
void* system = NHTTPi_GetSystemInfoP();
if (nhttpRegistered == 0)
{
OSRegisterVersion(__NHTTPVersion);
nhttpRegistered = TRUE;
}
return NHTTPi_Startup(system, alloc, free, priority) ? 0 : -1;
}
void NHTTPCleanupAsync(NHTTPCleanupCallback callback)
{
NHTTPi_CleanupAsync(NHTTPi_GetSystemInfoP(), callback);
}
s32 NHTTPGetError(void)
{
return NHTTPi_GetError(NHTTPi_GetSystemInfoP());
}
static s32 NHTTPi_PostSendCallbackWrap(void* mutexInfo_p,
NHTTPConnectionInfo* connection_p, void* arg_p)
{
if (connection_p != NULL)
{
NHTTPRequestInfo* req_p =
NHTTPi_Connection2Request(mutexInfo_p, connection_p);
if (req_p != NULL)
{
NHTTPPostSend postSend = (NHTTPPostSend)req_p->_unk250;
if (postSend != NULL)
{
NHTTPPostSendArg* postSendArg_p = arg_p;
return postSend(postSendArg_p->label,
&postSendArg_p->buf, &postSendArg_p->size,
postSendArg_p->offset,
NHTTPGetUserParam(connection_p));
}
}
}
return -1;
}
static s32 NHTTPi_BufFullCallbackWrap(void* mutexInfo_p,
NHTTPConnectionInfo* connection_p, void* arg_p)
{
if (connection_p != NULL)
{
NHTTPResponseInfo* res_p =
NHTTPi_Connection2Response(mutexInfo_p, connection_p);
if (res_p != NULL)
{
NHTTPResponseCallback bufFull = res_p->bufFull;
if (bufFull != NULL)
{
NHTTPBodyBufArg* bodyBufArg_p = arg_p;
char* oldBuf_p = bodyBufArg_p->buf;
u32 contentLength =
NHTTPi_GetVirtualContentLength(connection_p);
bodyBufArg_p->buf = bufFull((void**)&oldBuf_p,
&bodyBufArg_p->size, contentLength, NHTTPi_alloc,
NHTTPi_free, NHTTPGetUserParam(connection_p));
if (bodyBufArg_p->buf != NULL && oldBuf_p != NULL)
{
bodyBufArg_p->offset = 0;
}
}
}
}
return 0;
}
static s32 NHTTPi_CompleteCallbackWrap(void* mutexInfo_p,
NHTTPConnectionInfo* connection_p)
{
if (connection_p != NULL)
{
NHTTPReqCallback reqCallback = connection_p->requestCallback;
if (reqCallback != NULL)
{
NHTTPResponseInfo* res_p =
NHTTPi_Connection2Response(mutexInfo_p, connection_p);
if (res_p != NULL)
{
NHTTPErr result = NHTTPGetConnectionError(connection_p);
reqCallback(
result, res_p, NHTTPGetUserParam(connection_p));
}
}
}
return 0;
}
s32 NHTTPi_TemplateConnectionCallback(NHTTPConnectionInfo* handle,
NHTTPConnectionEvent event, void* arg_p)
{
void* sysInfo_p = NHTTPi_GetSystemInfoP();
void* mutexInfo_p = NHTTPi_GetMutexInfoP(sysInfo_p);
NHTTPConnectionInfo* connection_p =
NHTTPi_GetConnection(mutexInfo_p, handle);
s32 ret = 0;
switch (event)
{
case NHTTP_EVENT_POST_SEND:
ret = NHTTPi_PostSendCallbackWrap(
mutexInfo_p, connection_p, arg_p);
break;
case NHTTP_EVENT_BODY_RECV_FULL:
ret = NHTTPi_BufFullCallbackWrap(
mutexInfo_p, connection_p, arg_p);
break;
case NHTTP_EVENT_BODY_RECV_DONE:
break;
case NHTTP_EVENT_COMPLETE:
ret = NHTTPi_CompleteCallbackWrap(mutexInfo_p, connection_p);
break;
default:
break;
}
return ret;
}
NHTTPRequest* NHTTPCreateRequest(const char* url, NHTTPReqMethod method,
void* buffer, u32 bufferSize, NHTTPReqCallback callback, void* userParam)
{
return NHTTPCreateRequestEx(url, method, buffer, bufferSize, callback, userParam, NULL, NULL);
}
NHTTPRequest* NHTTPCreateRequestEx(const char* url, NHTTPReqMethod method,
void* buffer, u32 bufferSize, NHTTPReqCallback callback, void* userParam,
NHTTPResponseCallback responseCallback, NHTTPResponseCleanup cleanup)
{
void* systemInfo;
void* mutexInfo;
NHTTPConnectionInfo* connection;
NHTTPRequestInfo* request;
connection = NHTTPCreateConnection(url, method, buffer, bufferSize, NHTTPi_TemplateConnectionCallback, userParam);
request = NULL;
if (connection != NULL)
{
systemInfo = NHTTPi_GetSystemInfoP();
mutexInfo = NHTTPi_GetMutexInfoP(systemInfo);
connection = NHTTPi_GetConnection(mutexInfo, connection);
request = NHTTPi_Connection2Request(mutexInfo, connection);
if (request != NULL)
{
if (request->response != NULL)
{
connection->requestCallback = callback;
request->response->bufFull = responseCallback;
request->response->freeBuf = cleanup;
return request;
}
else
{
NHTTP_DestroyRequest(systemInfo, request);
NHTTPi_OmitConnectionList(mutexInfo, connection);
NHTTPi_free(connection);
request = NULL;
}
}
}
return request;
}
s32 NHTTPDeleteRequest(NHTTPRequest* request)
{
NHTTPConnectionInfo* connection = NHTTPi_Request2Connection(
NHTTPi_GetMutexInfoP(NHTTPi_GetSystemInfoP()), request);
if (connection != NULL)
{
NHTTPDeleteConnection(connection);
}
}
s32 NHTTPAddHeaderField(NHTTPRequest* handle, const char* name,
const char* value)
{
void* systemInfo;
NHTTPRequestInfo* request;
void* bgnEndInfo;
systemInfo = NHTTPi_GetSystemInfoP();
request = NHTTPi_GetRequest(NHTTPi_GetMutexInfoP(systemInfo), handle);
bgnEndInfo = NHTTPi_GetBgnEndInfoP(systemInfo);
if (request == NULL)
{
return -1;
}
if (request->state != 0)
{
static char name[] = "NHTTPAddHeaderField";
printf("%s can be called before NHTTPStartConnection()\n", name);
return -1;
}
return NHTTP_AddHeaderField(request, bgnEndInfo, name, value) ? 0 : -1;
}
s32 NHTTPAddPostDataAscii(NHTTPRequest* handle, const char* name,
const char* value)
{
NHTTPRequestInfo* request;
void* bgnEndInfo;
bgnEndInfo = NHTTPi_GetBgnEndInfoP(NHTTPi_GetSystemInfoP());
request = NHTTPi_GetRequest(
NHTTPi_GetMutexInfoP(NHTTPi_GetSystemInfoP()), handle);
if (request == NULL)
{
return -1;
}
if (request->state != 0)
{
printf("%s can be called before NHTTPStartConnection()\n",
"NHTTPAddPostDataAscii");
return -1;
}
return NHTTP_AddPostDataAscii(request, bgnEndInfo, name, value)
? 0
: -1;
}
s32 NHTTPAddPostDataBinary(NHTTPRequest* handle, const char* name,
const char* value)
{
NHTTPRequestInfo* request;
void* bgnEndInfo;
bgnEndInfo = NHTTPi_GetBgnEndInfoP(NHTTPi_GetSystemInfoP());
request = NHTTPi_GetRequest(
NHTTPi_GetMutexInfoP(NHTTPi_GetSystemInfoP()), handle);
if (request == NULL)
{
return -1;
}
if (request->state != 0)
{
printf("%s can be called before NHTTPStartConnection()\n",
"NHTTPAddPostDataBinary");
return -1;
}
return NHTTP_AddPostDataAscii(request, bgnEndInfo, name, value)
? 0
: -1;
}
s32 NHTTPAddPostDataRaw(NHTTPRequest* handle, const void* data,
u32 size, const char* label)
{
NHTTPRequestInfo* request;
request = NHTTPi_GetRequest(
NHTTPi_GetMutexInfoP(NHTTPi_GetSystemInfoP()), handle);
if (request == NULL)
{
return -1;
}
if (request->state != 0)
{
printf("%s can be called before NHTTPStartConnection()\n",
"NHTTPAddPostDataRaw");
return -1;
}
if (request->postData != NULL)
{
printf("already called NHTTPAddPostDataAscii or NHTTPAddPostDataBinary (exclusive fucntion)\n");
return -1;
}
request->isRawData = TRUE;
request->postBuffer = data;
request->postBufferSize = size;
return 0;
}
s32 NHTTPSetPostDataEncoding(NHTTPRequest* handle, u32 encodingType)
{
NHTTPRequestInfo* request;
request = NHTTPi_GetRequest(
NHTTPi_GetMutexInfoP(NHTTPi_GetSystemInfoP()), handle);
if (request == NULL)
{
return -1;
}
if (request->state != 0)
{
printf("%s can be called before NHTTPStartConnection()\n",
"NHTTPSetPostDataEncoding");
return -1;
}
request->encodingType = encodingType;
return 0;
}
NHTTPConnection NHTTPSendRequestAsync(NHTTPRequest* request)
{
NHTTPConnectionInfo* connection;
s32 result;
connection = NHTTPi_Request2Connection(
NHTTPi_GetMutexInfoP(NHTTPi_GetSystemInfoP()), request);
if (connection != NULL && NHTTPStartConnection(connection) == 0)
{
result = connection->requestId;
}
else
{
result = -1;
}
return result;
}
s32 NHTTPCancelRequestAsync(NHTTPConnection connection)
{
return NHTTP_CancelRequestAsync(NHTTPi_GetSystemInfoP(), connection)
? 0
: -1;
}
s32 NHTTPGetProgress(u32* complete, u32* total)
{
s32 result;
result = NHTTP_GetProgress(NHTTPi_GetSystemInfoP(), complete, total)
== 0;
return -result;
}
void NHTTPDestroyResponse(NHTTPResponse* handle)
{
void* mutexInfo;
NHTTPConnectionInfo* connection;
mutexInfo = NHTTPi_GetMutexInfoP(NHTTPi_GetSystemInfoP());
connection = NHTTPi_Response2Connection(mutexInfo, handle);
if (connection != NULL)
{
if (NHTTPi_Connection2Response(mutexInfo, connection) != NULL)
{
NHTTP_DestroyResponse(mutexInfo, connection->response);
}
NHTTPi_OmitConnectionList(mutexInfo, connection);
NHTTPi_free(connection);
}
}
s32 NHTTPGetHeaderField(NHTTPResponse* response, const char* name,
const char** value)
{
void* mutexInfo;
NHTTPResponseInfo* res;
mutexInfo = NHTTPi_GetMutexInfoP(NHTTPi_GetSystemInfoP());
res = NHTTPi_GetResponse(mutexInfo, response);
if (res == NULL)
{
return -1;
}
return NHTTP_GetHeaderField(res, name, value);
}
s32 NHTTPGetHeaderAll(NHTTPResponse* response, const char** header)
{
void* systemInfo;
NHTTPBgnEndInfo* bgnEndInfo;
NHTTPResponseInfo* res;
systemInfo = NHTTPi_GetSystemInfoP();
bgnEndInfo = NHTTPi_GetBgnEndInfoP(systemInfo);
res = NHTTPi_GetResponse(NHTTPi_GetMutexInfoP(systemInfo), response);
if (res == NULL)
{
return -1;
}
return NHTTP_GetHeaderAll(bgnEndInfo, res, header);
}
s32 NHTTPGetBodyAll(NHTTPResponse* response, void** buffer)
{
NHTTPConnectionInfo* connection;
u32 bufferSize;
s32 result;
connection = NHTTPi_Response2Connection(
NHTTPi_GetMutexInfoP(NHTTPi_GetSystemInfoP()), response);
if (connection != NULL)
{
bufferSize = 0;
result = NHTTPGetBodyBuffer(connection, buffer, &bufferSize);
}
else
{
result = -1;
}
return result;
}
s32 NHTTPGetResultCode(NHTTPResponse* handle)
{
NHTTPResponseInfo* response;
response = NHTTPi_GetResponse(
NHTTPi_GetMutexInfoP(NHTTPi_GetSystemInfoP()), handle);
if (response == NULL)
return -1;
if (response->isHeaderParse != FALSE)
return response->httpStatus;
return -1;
}
s32 NHTTPSetVerifyOption(NHTTPRequest* handle, u32 option)
{
NHTTPRequestInfo* request;
s32 result;
request = NHTTPi_GetRequest(
NHTTPi_GetMutexInfoP(NHTTPi_GetSystemInfoP()), handle);
if (request == NULL)
{
result = -1;
}
else
{
request->verifyOption = option;
result = 0;
}
return result;
}
s32 NHTTPSetProxy(NHTTPRequest* handle, const char* proxy_p, u16 port,
const char* username_p, const char* password_p)
{
void* sysInfo_p = NHTTPi_GetSystemInfoP();
void* mutexInfo_p = NHTTPi_GetMutexInfoP(sysInfo_p);
NHTTPRequestInfo* req_p = NHTTPi_GetRequest(mutexInfo_p, handle);
s32 proxyLen = 0;
if (req_p == NULL || proxy_p == NULL)
{
return -1;
}
proxyLen = NHTTPi_strlen(proxy_p);
if (proxyLen > 0x100)
{
printf("proxy-address exceeded 256 characters\n");
return -1;
}
NHTTPi_memcpy(req_p->proxyServer, proxy_p, proxyLen);
req_p->proxyPort = port;
if (username_p != NULL && password_p != NULL)
{
s32 username_len;
s32 password_len;
char tmpbuf[0x41];
username_len = NHTTPi_strlen(username_p);
password_len = NHTTPi_strlen(password_p);
if (username_len > 0x20)
{
printf("username exceeded 32 characters\n");
return -1;
}
if (password_len > 0x20)
{
printf("password exceeded 32 characters\n");
return -1;
}
NHTTPi_memclr(tmpbuf, sizeof(tmpbuf));
NHTTPi_memcpy(tmpbuf, username_p, username_len);
NHTTPi_memcpy(&(tmpbuf[username_len]), ":", 1);
NHTTPi_memcpy(
&(tmpbuf[(username_len + 1)]), password_p, password_len);
req_p->proxyAuthorizationLength =
NHTTPi_Base64Encode(req_p->proxyAuthorization, tmpbuf);
}
req_p->proxyEnabled = TRUE;
return 0;
}
s32 NHTTPSetProxyDefault(NHTTPRequest* handle)
{
NCDProxyServerProfile* proxy;
void* systemInfo;
NHTTPBgnEndInfo* bgnEndInfo;
NHTTPRequestInfo* request;
const char* username;
const char* password;
s32 result;
systemInfo = NHTTPi_GetSystemInfoP();
request = NHTTPi_GetRequest(NHTTPi_GetMutexInfoP(systemInfo), handle);
bgnEndInfo = NHTTPi_GetBgnEndInfoP(systemInfo);
if (request->secure != FALSE)
{
proxy = &bgnEndInfo->ipConfig.proxy.ssl;
}
else
{
proxy = &bgnEndInfo->ipConfig.proxy.http;
}
if (proxy->mode == 1)
{
username = NULL;
password = NULL;
if (proxy->authType == 1)
{
username = proxy->username;
password = proxy->password;
}
OSReport("Using proxy server %s:%d (%s/%s).\n", proxy->server, proxy->port, username != NULL ? username : "[no-auth]", password != NULL ? password : "[no-auth]");
result = NHTTPSetProxy(request, proxy->server, proxy->port, username, password);
if (result < 0)
{
OSReport("NHTTPSetProxy failed.(%d)\n", result);
OSPanic("d_nhttp.c", 0x37d, "NHTTPSetProxy");
}
else
{
return 0;
}
}
else
{
printf("NCD proxy-settings are disabled\n");
}
return -1;
}
s32 NHTTPSetRootCADefault(NHTTPRequest* handle)
{
s32 result;
NHTTPRequestInfo* request;
request = NHTTPi_GetRequest(
NHTTPi_GetMutexInfoP(NHTTPi_GetSystemInfoP()), handle);
if (request == NULL)
{
result = -1;
}
else
{
request->builtinRootCA = FALSE;
request->rootCAData = NULL;
request->rootCASize = 0;
result = 0;
}
return result;
}
s32 NHTTPSetClientCertDefault(NHTTPRequest* handle)
{
s32 result;
NHTTPRequestInfo* request;
request = NHTTPi_GetRequest(
NHTTPi_GetMutexInfoP(NHTTPi_GetSystemInfoP()), handle);
if (request == NULL)
{
result = -1;
}
else
{
request->builtinClientCert = FALSE;
request->clientCertDefault = TRUE;
request->clientCertData = NULL;
request->clientCertSize = 0;
request->privateKeyData = NULL;
request->privateKeySize = 0;
result = 0;
}
return result;
}
s32 NHTTPDisableVerifyOptionForDebug(NHTTPRequest* handle, u32 option)
{
NHTTPRequestInfo* request;
request = NHTTPi_GetRequest(
NHTTPi_GetMutexInfoP(NHTTPi_GetSystemInfoP()), handle);
if (request == NULL)
{
return -1;
}
if (request->state != 0)
{
printf("%s can be called before NHTTPStartConnection()\n",
"NHTTPDisableVerifyOptionForDebug");
return -1;
}
{
static s32 debugSet;
if (debugSet == 0)
{
debugSet = 1;
}
}
request->verifyOption &= ~option;
return 0;
}

View File

@@ -0,0 +1,421 @@
#include <private/nhttp.h>
#include <stdio.h>
typedef struct NHTTPSysInfo
{
u8 bgnEndInfo[0x800];
NHTTPListInfo listInfo;
NHTTPReqInfo reqInfo;
u8 mutexInfo[0x34];
u8 threadInfo[0x460];
} NHTTPSysInfo;
typedef struct NHTTPStaticResource
{
BOOL initialized;
OSMutex mutex;
OSCond cond;
u32 _unk24;
u8 _unk28[0x18];
} NHTTPStaticResource;
static NHTTPSysInfo sysInfo;
static NHTTPSysInfo* sysInfo_p;
static NHTTPConnectionInfo* sConnectionList;
static NHTTPStaticResource NHTTPiStaticResource;
void NHTTPi_lockReqList(void* mutexInfo);
void NHTTPi_unlockReqList(void* mutexInfo);
void NHTTPi_InitBgnEndInfo(NHTTPBgnEndInfo* info);
void NHTTPi_InitListInfo(NHTTPListInfo* info);
void NHTTPi_InitRequestInfo(NHTTPReqInfo* info);
void NHTTPi_InitMutexInfo(void* info);
void NHTTPi_InitThreadInfo(void* info);
NHTTPBgnEndInfo* NHTTPi_GetBgnEndInfoP(NHTTPSysInfo* sysInfo_p);
NHTTPListInfo* NHTTPi_GetListInfoP(NHTTPSysInfo* sysInfo_p);
NHTTPReqInfo* NHTTPi_GetReqInfoP(NHTTPSysInfo* sysInfo_p);
void* NHTTPi_GetThreadInfoP(NHTTPSysInfo* sysInfo_p);
void* NHTTPi_GetMutexInfoP(NHTTPSysInfo* sysInfo_p);
void NHTTPi_WaitForCompletion(NHTTPConnectionInfo* connection)
{
NHTTPStaticResource* res_p = &NHTTPiStaticResource;
if (!res_p->initialized)
{
OSInitMutex(&res_p->mutex);
OSInitCond(&res_p->cond);
res_p->initialized = TRUE;
}
OSLockMutex(&res_p->mutex);
while (connection->_unkC != 0)
{
OSWaitCond(&res_p->cond, &res_p->mutex);
}
OSUnlockMutex(&res_p->mutex);
}
void NHTTPi_NotifyCompletion(NHTTPConnectionInfo* connection)
{
NHTTPStaticResource* res_p = &NHTTPiStaticResource;
if (!res_p->initialized)
{
OSInitMutex(&res_p->mutex);
OSInitCond(&res_p->cond);
res_p->initialized = TRUE;
}
OSLockMutex(&res_p->mutex);
connection->_unkC = 0;
OSSignalCond(&res_p->cond);
OSUnlockMutex(&res_p->mutex);
}
NHTTPConnectionInfo* NHTTPi_ControlConnectionList(void* mutexInfo,
void* handle, u32 mode)
{
NHTTPConnectionInfo* connection;
NHTTPConnectionInfo* result;
NHTTPConnectionInfo** current;
result = NULL;
NHTTPi_lockReqList(mutexInfo);
if (mode == 3)
{
connection = handle;
connection->next = sConnectionList;
sConnectionList = connection;
result = connection;
}
else
{
current = &sConnectionList;
while (*current != NULL)
{
connection = *current;
switch (mode)
{
case 0:
if (connection == handle)
{
result = connection;
}
break;
case 1:
if (connection->request == handle)
{
result = connection;
}
break;
case 2:
if (connection->response == handle)
{
result = connection;
}
break;
case 4:
if (connection == handle)
{
*current = connection->next;
result = connection;
}
break;
}
if (result != NULL)
{
break;
}
current = &(*current)->next;
}
}
NHTTPi_unlockReqList(mutexInfo);
return result;
}
s32 NHTTPi_CommitConnectionList(void* mutexInfo_p,
NHTTPConnectionInfo* connection_p)
{
return ((NHTTPi_ControlConnectionList(mutexInfo_p, connection_p, 3)
!= NULL)
? 0
: -1);
}
s32 NHTTPi_OmitConnectionList(void* mutexInfo_p,
NHTTPConnectionInfo* connection_p)
{
return ((NHTTPi_ControlConnectionList(mutexInfo_p, connection_p, 4)
!= NULL)
? 0
: -1);
}
NHTTPRequestInfo* NHTTPi_Connection2Request(void* mutexInfo,
NHTTPConnectionInfo* connection)
{
connection = NHTTPi_ControlConnectionList(mutexInfo, connection, 0);
return connection != NULL ? connection->request : NULL;
}
NHTTPResponseInfo* NHTTPi_Connection2Response(void* mutexInfo,
NHTTPConnectionInfo* connection)
{
connection = NHTTPi_ControlConnectionList(mutexInfo, connection, 0);
return connection != NULL ? connection->response : NULL;
}
NHTTPConnectionInfo* NHTTPi_Request2Connection(void* mutexInfo,
NHTTPRequestInfo* request)
{
return NHTTPi_ControlConnectionList(
mutexInfo, request, 1);
}
NHTTPConnectionInfo* NHTTPi_Response2Connection(void* mutexInfo,
NHTTPResponseInfo* response)
{
return NHTTPi_ControlConnectionList(
mutexInfo, response, 2);
}
NHTTPConnectionInfo* NHTTPi_GetConnection(void* mutexInfo,
NHTTPConnectionInfo* connection)
{
return NHTTPi_ControlConnectionList(mutexInfo, connection, 0);
}
NHTTPRequestInfo* NHTTPi_GetRequest(void* mutexInfo,
NHTTPRequestInfo* request)
{
NHTTPConnectionInfo* connection;
connection = NHTTPi_ControlConnectionList(
mutexInfo, request, 0);
return connection != NULL ? connection->request : request;
}
NHTTPResponseInfo* NHTTPi_GetResponse(void* mutexInfo,
NHTTPResponseInfo* response)
{
NHTTPConnectionInfo* connection;
connection = NHTTPi_ControlConnectionList(
mutexInfo, response, 0);
return connection != NULL ? connection->response : response;
}
s32 NHTTPi_GetConnectionListLength(void)
{
NHTTPConnectionInfo* connection;
s32 length;
connection = sConnectionList;
length = 0;
while (connection != NULL)
{
connection = connection->next;
length++;
}
return length;
}
s32 NHTTPi_PostSendCallback(void* mutexInfo,
NHTTPConnectionInfo* connection, void* value, u32 arg)
{
u32 callbackArg4;
u32 callbackArg8;
s32 result;
NHTTPResponseInfo* response;
NHTTPConnectionCallbackParam param;
result = -1;
if (NHTTPi_GetConnection(mutexInfo, connection) != NULL)
{
response = NHTTPi_Connection2Response(mutexInfo, connection);
if (response != NULL && connection->callback != NULL)
{
param.value = value;
param._unk4 = connection->_unk24;
param._unk8 = connection->_unk28;
param._unkC = arg;
result = connection->callback(connection, 1, &param);
callbackArg8 = param._unk8;
callbackArg4 = param._unk4;
connection = NHTTPi_GetConnection(mutexInfo, connection);
if (connection != NULL)
{
connection->_unk24 = callbackArg4;
connection->_unk28 = callbackArg8;
}
}
}
return result;
}
void NHTTPi_BufferFullCallback(void* mutexInfo,
NHTTPConnectionInfo* connection)
{
void* buffer;
u32 bufferSize;
s32 responseResult;
NHTTPResponseInfo* response;
NHTTPConnectionCallbackParam param;
if (NHTTPi_GetConnection(mutexInfo, connection) != NULL)
{
response = NHTTPi_Connection2Response(mutexInfo, connection);
if (response != NULL && connection->callback != NULL)
{
param.value = response->recvBuf_p;
param._unk4 = response->recvBufLen;
param._unk8 = response->bodyLen;
connection->callback(connection, 2, &param);
responseResult = param._unk8;
bufferSize = param._unk4;
buffer = param.value;
connection = NHTTPi_GetConnection(mutexInfo, connection);
if (connection != NULL)
{
response = NHTTPi_Connection2Response(mutexInfo, connection);
if (response != NULL)
{
response->recvBuf_p = buffer;
response->recvBufLen = bufferSize;
response->bodyLen = responseResult;
}
}
}
}
}
void NHTTPi_ReceivedCallback(void* mutexInfo,
NHTTPConnectionInfo* connection)
{
void* buffer;
u32 bufferSize;
s32 responseResult;
NHTTPResponseInfo* response;
NHTTPConnectionCallbackParam param;
if (NHTTPi_GetConnection(mutexInfo, connection) != NULL)
{
response = NHTTPi_Connection2Response(mutexInfo, connection);
if (response != NULL && connection->callback != NULL)
{
param.value = response->recvBuf_p;
param._unk4 = response->recvBufLen;
param._unk8 = response->bodyLen;
connection->callback(connection, 3, &param);
responseResult = param._unk8;
bufferSize = param._unk4;
buffer = param.value;
connection = NHTTPi_GetConnection(mutexInfo, connection);
if (connection != NULL)
{
response = NHTTPi_Connection2Response(mutexInfo, connection);
if (response != NULL)
{
response->recvBuf_p = buffer;
response->recvBufLen = bufferSize;
response->bodyLen = responseResult;
}
}
}
}
}
void NHTTPi_CompleteCallback(void* mutexInfo,
NHTTPConnectionInfo* connection)
{
if (NHTTPi_GetConnection(mutexInfo, connection) != NULL
&& connection->callback != NULL)
{
connection->callback(connection, 4, NULL);
}
}
static void NHTTPi_InitSystemInfo(NHTTPSysInfo* sysInfo_p)
{
NHTTPi_InitBgnEndInfo(NHTTPi_GetBgnEndInfoP(sysInfo_p));
NHTTPi_InitListInfo(NHTTPi_GetListInfoP(sysInfo_p));
NHTTPi_InitRequestInfo(NHTTPi_GetReqInfoP(sysInfo_p));
NHTTPi_InitMutexInfo(NHTTPi_GetMutexInfoP(sysInfo_p));
NHTTPi_InitThreadInfo(NHTTPi_GetThreadInfoP(sysInfo_p));
}
NHTTPSysInfo* NHTTPi_GetSystemInfoP(void)
{
if (sysInfo_p == NULL)
{
sysInfo_p = &sysInfo;
NHTTPi_InitSystemInfo(sysInfo_p);
}
return sysInfo_p;
}
NHTTPBgnEndInfo* NHTTPi_GetBgnEndInfoP(NHTTPSysInfo* sysInfo_p)
{
return (NHTTPBgnEndInfo*)sysInfo_p->bgnEndInfo;
}
NHTTPListInfo* NHTTPi_GetListInfoP(NHTTPSysInfo* sysInfo_p)
{
return &sysInfo_p->listInfo;
}
NHTTPReqInfo* NHTTPi_GetReqInfoP(NHTTPSysInfo* sysInfo_p)
{
return &sysInfo_p->reqInfo;
}
void* NHTTPi_GetThreadInfoP(NHTTPSysInfo* sysInfo_p)
{
return sysInfo_p->threadInfo;
}
void* NHTTPi_GetMutexInfoP(NHTTPSysInfo* sysInfo_p)
{
return sysInfo_p->mutexInfo;
}
void NHTTPi_SetVirtualContentLength(NHTTPConnectionInfo* connection,
u32 length)
{
if (connection != NULL)
{
connection->virtualContentLength = length;
}
}
u32 NHTTPi_GetVirtualContentLength(NHTTPConnectionInfo* connection)
{
return connection != NULL ? connection->virtualContentLength : 0;
}
void NHTTPi_InitConnectionList(void)
{
NHTTPConnectionInfo* connection;
s32 count;
connection = sConnectionList;
if (connection != NULL)
{
count = 0;
while (connection != NULL)
{
connection = connection->next;
count++;
}
if (count != 0)
{
printf("*warning: %d connections rests! Please free connections.\n",
count);
}
}
sConnectionList = NULL;
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,796 @@
#define MYTIINPUTFORM_IMPLEMENTATION
#include "keyboard/MyTiInputForm.h"
#include "keyboard/tiUtil.h"
#include <nw4r/lyt/group.h>
#include <nw4r/lyt/material.h>
#include <nw4r/lyt/textbox.h>
#include <new>
namespace textinput {
namespace inputform {
class EventHandler : public nw4rmanager::TiEventHandler {
public:
EventHandler(textinput::InputForm* form) : mpInputForm(form) {}
virtual ~EventHandler() {}
virtual void onTiEvent(gui::PaneComponent*, u32, Input*);
protected:
textinput::InputForm* mpInputForm;
};
}
namespace extend {
namespace memo {
class AnmPane : public nw4rmanager::AnmPane {
protected:
AnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer)
: nw4rmanager::AnmPane(pane, observer), meState(0) {}
public:
virtual ~AnmPane();
virtual void init();
virtual void changeAnimation(u32 id);
virtual u32 getState();
virtual u32 getKeyType() const;
protected:
u32 meState;
u32 meKeyType;
};
class WholePane : public AnmPane {
public:
WholePane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : AnmPane(pane, observer) { meKeyType = 0; }
virtual ~WholePane() {}
virtual void onAnmEvent(AnmPaneEvent event);
};
class NigaoePane : public AnmPane {
public:
NigaoePane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : AnmPane(pane, observer) { meKeyType = 1; }
virtual ~NigaoePane() {}
virtual void onAnmEvent(AnmPaneEvent event);
};
class SimpleAnmPane : public nw4rmanager::AnmPane {
public:
SimpleAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer) : nw4rmanager::AnmPane(pane, observer) {}
virtual ~SimpleAnmPane() {}
virtual void init();
virtual void changeAnimation(u32 id);
};
class ScrollButton {
public:
ScrollButton(TiLayout* layout) : muGroup(0), muAnimation(0), mpLayout(layout), mbLeftPressed(false), mbRightPressed(false) {}
virtual void create(MEMAllocator*, nw4r::lyt::MultiArcResourceAccessor*);
virtual void init();
virtual void calc();
virtual void changeAnimation(bool left, u32 id);
private:
u32 muGroup;
u32 muAnimation;
TiLayout* mpLayout;
nw4rmanager::AnimPaneGroup* mGroups[9];
bool mbGroupChanged[9];
bool mbLeftPressed;
bool mbRightPressed;
};
class EventHandler : public inputform::EventHandler {
public:
EventHandler(InputForm* form) : inputform::EventHandler(form), mpMemoForm(form) {}
virtual ~EventHandler() {}
virtual void onTiEvent(gui::PaneComponent*, u32, Input*);
private:
InputForm* mpMemoForm;
};
static const char* scPaneName[] = {
"N_Header", "N_Body", "B_Body", "N_Footer", "Nigaoe",
"T_Nigaoe", "B_Nigaoe", "T_Letter", "T_TouchLetter"
};
struct AnimationFile {
u32 id;
char name[64];
};
static const AnimationFile csAninationFile[] = {
{0, "my_Memo_a_normal.brlan"},
{1, "my_Memo_a_MailIn.brlan"},
{2, "my_Memo_a_MailOut.brlan"},
{3, "my_Memo_a_SendOut.brlan"},
{4, "my_Memo_a_NigaoeFoucusIn.brlan"},
{5, "my_Memo_a_NigaoeFoucusOut.brlan"}
};
struct PaneAnimations {
u32 type;
const char* paneName;
u32 count;
const AnimationFile* animations[12];
};
static const PaneAnimations csPaneToAnimation[] = {
{0, "N_Memo", 4, {&csAninationFile[0], &csAninationFile[1], &csAninationFile[2], &csAninationFile[3]}},
{1, "Nigaoe", 2, {&csAninationFile[4], &csAninationFile[5]}}
};
static const AnimationFile csGroupAninationFile[] = {
{0, "my_Memo_a_Off.brlan"},
{1, "my_Memo_a_Appear.brlan"},
{2, "my_Memo_a_Lost.brlan"},
{3, "my_Memo_a_HDActionEnd.brlan"},
{4, "my_Memo_a_HDActionStart.brlan"},
{5, "my_Memo_a_Loop.brlan"},
{6, "my_Memo_a_Select.brlan"},
{7, "my_Memo_a_FocusOff.brlan"},
{8, "my_Memo_a_FocusOn.brlan"}
};
struct GroupAnimations {
u32 group;
u32 animations[3];
};
static const GroupAnimations csGroupToAnimation[] = {
{0, {5, 9, 9}}, {1, {8, 7, 9}}, {2, {8, 7, 9}},
{3, {6, 9, 9}}, {4, {6, 9, 9}}, {5, {2, 1, 9}},
{6, {2, 1, 9}}, {7, {4, 3, 9}}, {8, {4, 3, 9}}
};
InputForm::~InputForm() {
mpSendString->~Decolated();
MEMFreeToAllocator(mpAllocator, mpSendString);
MEMFreeToAllocator(mpAllocator, mpDefaultNigaoe);
}
void InputForm::setAddScroll(f32 scroll, bool up, bool down) {
setScroll(mfScroll + scroll);
if (up && !mbScrollUp) {
mpScrollButton->changeAnimation(false, 4);
} else if (down && !mbScrollDown) {
mpScrollButton->changeAnimation(true, 4);
}
if (!up && mbScrollUp) {
mpScrollButton->changeAnimation(false, 3);
} else if (!down && mbScrollDown) {
mpScrollButton->changeAnimation(true, 3);
}
mbScrollUp = up;
mbScrollDown = down;
}
void InputForm::moveCursorUp() {
f32 y = 1.0f + (mfCursorY - getLineHeight());
if (y <= 0.0f) {
u32 start, end;
mpString->getCursorPos(&start, &end);
if (start == 0 && end == 0) onSE(sound::SE_CHAR_CURSOR_FIX);
else onSE(sound::SE_CHAR_CURSOR);
setCursorPos(mpString, 0);
} else {
setCursorPos(mpString, calcCursorPos(mfCursorX, y - mfScroll));
onSE(sound::SE_CHAR_CURSOR);
}
meScrollFlag = SF_ScrollOn;
}
void InputForm::moveCursorDown() {
f32 y = 1.0f + (mfCursorY + getLineHeight());
if (y / getLineHeight() >= getLine()) {
u32 start, end;
mpString->getCursorPos(&start, &end);
if (start == mpString->getLength() && end == mpString->getLength()) onSE(sound::SE_CHAR_CURSOR_FIX);
else onSE(sound::SE_CHAR_CURSOR);
setCursorPos(mpString, mpString->getLength());
} else {
setCursorPos(mpString, calcCursorPos(mfCursorX, y - mfScroll));
onSE(sound::SE_CHAR_CURSOR);
}
meScrollFlag = SF_ScrollOn;
}
void InputForm::onCommand(INPUT_COMMAND command, void* data) {
if (meEditMode == EM_Edit) onCommandOnEditMode(command, data);
else if (meEditMode == EM_Disp) onCommandOnDispMode(command, data);
else {
switch (command) {
case 6: case 21: case 29: case 31:
textinput::InputForm::onCommand(command, data);
break;
case 7: case 8: case 9: case 10: case 11: case 12: case 13:
case 14: case 15: case 16: case 17: case 18: case 19: case 20:
case 22: case 23: case 24: case 25: case 26: case 27: case 28: case 30:
break;
}
}
}
void InputForm::onCommandOnEditMode(INPUT_COMMAND command, void* data) {
switch (command) {
case 24:
if (!mExScrollAnm.isActive()) {
if (static_cast<Scroll*>(data)->y < 0.0f)
mExScrollAnm.startAnm(NULL, mfScroll, mfScroll + getLineHeight(), 15.0f, NULL);
else
mExScrollAnm.startAnm(NULL, mfScroll, mfScroll - getLineHeight(), 15.0f, NULL);
onSE(sound::SE_LINE_SCROLL);
}
break;
default:
textinput::InputForm::onCommand(command, data);
break;
}
}
void InputForm::onCommandOnDispMode(INPUT_COMMAND command, void* data) {
switch (command) {
case 14: {
nw4r::math::VEC2 position = getGlobalLeftTopPos();
nw4r::math::VEC2* point = static_cast<nw4r::math::VEC2*>(data);
int line = (point->y - position.y) / getLineHeight();
if (line > getLine() - 1) line = getLine() - 1;
if (getLine() > 1 && line >= getLine() - 1) line = getLine() - 2;
mfScrollFrom = mfScroll;
mfScrollTo = line * getLineHeight();
nw4r::math::VEC2 editPoint;
editPoint.x = point->x;
editPoint.y = point->y - mfScroll;
textinput::InputForm::onCommand(static_cast<INPUT_COMMAND>(14), &editPoint);
int relationLine = line;
struct Relation { int type; int* line; } relation = {0, &relationLine};
textinput::InputForm::onCommand(INPUT_COMMAND_37, &relation);
mbEdited = true;
candidatebox::CandidateBoxCaller::resetCandidate();
candidatebox::CandidateBoxCaller::makeEmptyCandidate();
break;
}
case 29: case 31: case 41:
textinput::InputForm::onCommand(command, data);
break;
}
}
void InputForm::create(MEMAllocator* allocator, inputform::EditBuffer* editBuffer) {
textinput::InputForm::create(allocator, editBuffer);
void* stringMemory = MEMAllocFromAllocator(allocator, sizeof(tistring::Decolated));
mpSendString = new (stringMemory) tistring::Decolated(1024);
mpSendString->create(allocator);
MEMFreeToAllocator(allocator, mpInputEventHandler);
void* handlerMemory = MEMAllocFromAllocator(allocator, sizeof(EventHandler));
mpInputEventHandler = new (handlerMemory) EventHandler(this);
mpInputEventHandler->setEventObserver(mpEventObserver);
mpPaneManager->changeEventHandler(mpInputEventHandler);
mpDefaultNigaoe = static_cast<GXTexObj*>(MEMAllocFromAllocator(allocator, sizeof(GXTexObj)));
getNigaoePaneMaterial()->GetTexture(mpDefaultNigaoe, 0);
setVisible("P_2l_TextBox", true);
mpBoundPane = mpLayout->GetRootPane()->FindPaneByName("T_2l_TextBox", true);
mDefaultBoundTrans = mpBoundPane->GetTranslate();
mDefaultBoundSize = mpBoundPane->GetSize();
mpDrawPane = mpLayout->GetRootPane()->FindPaneByName("B_2l_TextBox", true);
mpPaneManager->getPaneComponentByPane(mpDrawPane)->setTriggerTarget(false);
mDrawRect = mpDrawPane->GetPaneRect(mDrawInfo);
mDefaultDrawTrans = mpDrawPane->GetTranslate();
mDefaultDrawSize = mpDrawPane->GetSize();
mpMemoPane = mpLayout->GetRootPane()->FindPaneByName("N_Memo", true);
mpMemoRootPane = mpLayout->GetRootPane()->FindPaneByName("N_MemoRoot", true);
setScroll(0.0f);
mnLine = 1;
mfScrollFrom = 0.0f;
mfScrollTo = 0.0f;
PSMTXIdentity(mDrawMtx);
PSMTXIdentity(mBoundMtx);
createAnimation(allocator);
void* scrollMemory = MEMAllocFromAllocator(allocator, sizeof(ScrollButton));
mpScrollButton = new (scrollMemory) ScrollButton(mpLayout);
mpScrollButton->create(allocator, mpMultiArcResourceAccessor);
}
void InputForm::createAnimation(MEMAllocator* allocator) {
for (u16 i = 0; i < 2; i++) {
const PaneAnimations& entry = csPaneToAnimation[i];
AnmPane* pane = NULL;
switch (entry.type) {
case 0: {
void* memory = MEMAllocFromAllocator(allocator, sizeof(WholePane));
pane = new (memory) WholePane(getPane(entry.paneName), NULL);
break;
}
case 1: {
void* memory = MEMAllocFromAllocator(allocator, sizeof(NigaoePane));
pane = new (memory) NigaoePane(getPane(entry.paneName), NULL);
break;
}
}
nw4r::ut::List_Append(&mAnmPanes, pane);
for (u16 j = 0; j < entry.count; j++) {
const void* resource = mpMultiArcResourceAccessor->GetResource(0, entry.animations[j]->name, NULL);
AnimTransformPane* transform = static_cast<AnimTransformPane*>(getLayout()->CreateAnimTransform(resource, mpMultiArcResourceAccessor));
pane->addAnimation(allocator, entry.animations[j]->id, transform, false, true);
}
}
}
AnmPane::~AnmPane() {}
static const char* csGroupName[] = {
"G_ArwRoop", "G_ArwR_Focus", "G_ArwL_Focus", "G_ArwR_Ac", "G_ArwL_Ac",
"G_ArwL_End", "G_ArwR_End", "G_ArwL_HDAc", "G_ArwR_HDAc"
};
void ScrollButton::create(MEMAllocator* allocator, nw4r::lyt::MultiArcResourceAccessor* accessor) {
for (int i = 0; i < 9; i++) {
mbGroupChanged[i] = false;
nw4r::lyt::Group* group = mpLayout->GetGroupContainer()->FindGroupByName(csGroupName[i]);
void* groupMemory = MEMAllocFromAllocator(allocator, sizeof(nw4rmanager::AnimPaneGroup));
mGroups[i] = new (groupMemory) nw4rmanager::AnimPaneGroup(group);
nw4r::lyt::PaneLinkList& panes = group->GetPaneList();
for (nw4r::lyt::PaneLinkList::Iterator it = panes.GetBeginIter(); it != panes.GetEndIter(); ++it) {
void* memory = MEMAllocFromAllocator(allocator, sizeof(SimpleAnmPane));
SimpleAnmPane* pane = new (memory) SimpleAnmPane(it->mTarget, NULL);
for (u16 j = 0; j < 3; j++) {
int id = csGroupToAnimation[i].animations[j];
if (id != 9) {
const void* resource = accessor->GetResource(0, csGroupAninationFile[id].name, NULL);
AnimTransformPane* transform = static_cast<AnimTransformPane*>(mpLayout->CreateAnimTransform(resource, accessor));
bool loop = false;
if (id == 5) loop = true;
pane->addAnimation(allocator, id, transform, loop, false);
}
}
mGroups[i]->addAnimPane(pane);
}
}
changeAnimation(true, 5);
changeAnimation(false, 5);
changeAnimation(true, 2);
changeAnimation(false, 2);
for (int i = 0; i < 10; i++) calc();
}
void ScrollButton::calc() {
for (int i = 0; i < 9; i++) mGroups[i]->calc();
}
void ScrollButton::changeAnimation(bool left, u32 id) {
muAnimation = id;
if (left) {
switch (id) {
case 0: muGroup = 0; break;
case 1: muGroup = 5; break;
case 2: muGroup = 5; break;
case 3: if (!mbLeftPressed) return; muGroup = 8; mbLeftPressed = false; break;
case 4: if (mbLeftPressed) return; muGroup = 8; mbLeftPressed = true; break;
case 5: muGroup = 0; break;
case 6: muGroup = 4; break;
case 7: muGroup = 2; break;
case 8: muGroup = 2; break;
}
} else {
switch (id) {
case 0: muGroup = 0; break;
case 1: muGroup = 6; break;
case 2: muGroup = 6; break;
case 3: if (!mbRightPressed) return; muGroup = 7; mbRightPressed = false; break;
case 4: if (mbRightPressed) return; muGroup = 7; mbRightPressed = true; break;
case 5: muGroup = 0; break;
case 6: muGroup = 3; break;
case 7: muGroup = 1; break;
case 8: muGroup = 1; break;
}
}
mbGroupChanged[muGroup] = true;
mGroups[muGroup]->changeAnimation(id);
}
void InputForm::onArrowRPoint() {
if (meEditMode == EM_Disp) {
mpScrollButton->changeAnimation(false, 8);
onSE(sound::SE_BT_TARGETTING);
}
}
void InputForm::onArrowRLeft() {
if (meEditMode == EM_Disp) mpScrollButton->changeAnimation(false, 7);
}
void InputForm::onArrowLPoint() {
if (meEditMode == EM_Disp) {
mpScrollButton->changeAnimation(true, 8);
onSE(sound::SE_BT_TARGETTING);
}
}
void InputForm::onArrowLLeft() {
if (meEditMode == EM_Disp) mpScrollButton->changeAnimation(true, 7);
}
void InputForm::onArrowRTrig() {
if (meEditMode == EM_Disp && !mExScrollAnm.isActive()) {
mpScrollButton->changeAnimation(false, 6);
f32 scroll = mfScroll - 3.0f * getLineHeight();
if (scroll <= getScrollMin()) scroll = getScrollMin();
mExScrollAnm.startAnm(NULL, mfScroll, scroll, 15.0f, NULL);
onSE(sound::SE_LINE_SCROLL);
}
}
void InputForm::onArrowLTrig() {
if (meEditMode == EM_Disp && !mExScrollAnm.isActive()) {
mpScrollButton->changeAnimation(true, 6);
f32 scroll = mfScroll + 3.0f * getLineHeight();
if (scroll >= getScrollMax()) scroll = getScrollMax();
mExScrollAnm.startAnm(NULL, mfScroll, scroll, 15.0f, NULL);
onSE(sound::SE_LINE_SCROLL);
}
}
bool InputForm::updateInput(int chan, f32 x, f32 y, u32 trig, u32 hold, u32 release, void* data) {
if (meEditMode == EM_Disp) {
if (hold & 0x400) return textinput::InputForm::updateInput(chan, 0.0f, 0.0f, 0, 0, 0, data);
if (trig & 8) mpScrollButton->changeAnimation(false, 4);
if (release & 8) mpScrollButton->changeAnimation(false, 3);
if (trig & 4) mpScrollButton->changeAnimation(true, 4);
if (release & 4) mpScrollButton->changeAnimation(true, 3);
if (hold & 8) {
if (getScrollMin() <= mfScroll) {
setScroll(mfScroll - 3.5f);
if (mfScroll <= getScrollMin()) setScroll(getScrollMin());
else onSE(sound::SE_MESSAGE_SCROLL);
}
mpScrollButton->changeAnimation(false, 4);
} else mpScrollButton->changeAnimation(false, 3);
if (hold & 4) {
if (getScrollMax() >= mfScroll) {
setScroll(3.5f + mfScroll);
if (mfScroll >= getScrollMax()) setScroll(getScrollMax());
else onSE(sound::SE_MESSAGE_SCROLL);
}
mpScrollButton->changeAnimation(true, 4);
} else mpScrollButton->changeAnimation(true, 3);
}
return textinput::InputForm::updateInput(chan, x, y, trig, hold, release, data);
}
bool InputForm::updateInput(input::HKBManager& hkbManager) {
return textinput::InputForm::updateInput(hkbManager);
}
void InputForm::init() {
if (mpBoundPane != NULL) mCharColor.Set(20, 20, 20, 255);
mbUpVisible = false;
mbDownVisible = false;
searchAnmPane("P_txtScrll_UP")->changeAnimation(7);
searchAnmPane("P_txtScrll_DOWN")->changeAnimation(7);
mbGoodBye = false;
mbEditScrollUp = false;
mbEditScrollDown = false;
setScroll(0.0f);
mfScrollFrom = 0.0f;
mfScrollTo = 0.0f;
resetRelation();
updateCandidateState_();
setLineDrawInfo(true, 10);
}
void InputForm::draw() {
setProjectionMtx();
drawHeader();
drawBody();
drawFooter();
if (meEditMode == EM_Edit) getPane("N_txt_scrl")->Draw(mDrawInfo);
inputform::Base::draw();
if (meEditMode == EM_Disp) {
setProjectionMtx();
getPane("N_TopBtn_00")->Animate(0);
getPane("N_TopBtn_00")->CalculateMtx(mDrawInfo);
getPane("N_TopBtn_00")->Draw(mDrawInfo);
}
mnLine = getLine();
if (mnLine <= 4) mnLine = 4;
}
void InputForm::setScroll(f32 scroll) {
mfScroll = scroll;
mfDrawScrollY = meEditMode == EM_Edit ? -mfScroll : 0.0f;
}
static nw4r::math::VEC2 transformedOrigin(const nw4r::ut::Rect& rect, const Mtx& matrix) {
nw4r::math::VEC3 position;
position.x = rect.left;
position.y = rect.bottom;
position.z = 0.0f;
PSMTXMultVec(matrix, reinterpret_cast<const Vec*>(&position), reinterpret_cast<Vec*>(&position));
return nw4r::math::VEC2(position.x, -position.y);
}
void InputForm::calc() {
nw4rmanager::Layout::calc();
muGlobalAlpha = getLayout()->GetRootPane()->GetAlpha();
mpLayout->Animate(0);
mpLayout->CalculateMtx(mDrawInfo);
mpLayout->GetRootPane()->FindPaneByName("N_Memo", true)->SetTranslate(nw4r::math::VEC2(0.0f, mfScroll));
f32 height = mnLine * getLineHeight();
f32 drawY = mDefaultDrawTrans.y - (height - mDefaultDrawSize.height) / 2.0f;
mpDrawPane->SetSize(nw4r::lyt::Size(mpDrawPane->GetSize().width, height));
mpDrawPane->SetTranslate(nw4r::math::VEC2(mDefaultDrawTrans.x, drawY));
mpDrawPane->CalculateMtx(mDrawInfo);
AdjustPaneMtx(mDrawMtx, mDrawInfo, mpDrawPane->GetGlobalMtx());
nw4r::ut::Rect rect;
rect = mpDrawPane->GetPaneRect(mDrawInfo);
nw4r::math::VEC2 scale(getScale().x, 1.0f);
nw4r::math::VEC2 position = transformedOrigin(rect, mDrawMtx);
mDrawRect.left = position.x;
mDrawRect.bottom = position.y;
mDrawRect.right = position.x + scale.x * (rect.right - rect.left);
mDrawRect.top = position.y + scale.y * (rect.top - rect.bottom);
height = mnLine * getLineHeight();
f32 halfHeight = height - mDefaultBoundSize.height;
halfHeight *= 0.5f;
f32 boundY = mDefaultBoundTrans.y - halfHeight;
if (meEditMode == EM_Edit) {
height = 2.0f * getLineHeight();
boundY = (mDefaultBoundTrans.y - (height - mDefaultBoundSize.height) / 2.0f) - mfScroll;
} else mfDrawScrollY = 0.0f;
mpBoundPane->SetSize(nw4r::lyt::Size(mpBoundPane->GetSize().width, height));
mpBoundPane->SetTranslate(nw4r::math::VEC2(mDefaultBoundTrans.x, boundY));
mpBoundPane->CalculateMtx(mDrawInfo);
AdjustPaneMtx(mBoundMtx, mDrawInfo, mpBoundPane->GetGlobalMtx());
AdjustPaneMtx(mMtx.m, mDrawInfo, mpBoundPane->GetGlobalMtx());
mRect = mpBoundPane->GetPaneRect(mDrawInfo);
muGlobalAlpha = mpBoundPane->GetAlpha();
mExScrollAnm.calc();
if (mExScrollAnm.isActive()) {
setScroll(mExScrollAnm.getValue());
} else if (meEditMode == EM_Edit) {
doAutoScroll();
if (!mExScrollAnm.isActive()) {
f32 halfLine = getLineHeight();
halfLine *= 0.5f;
if (mfScroll - halfLine > 0.0f) {
if (!mbUpVisible) {
searchAnmPane("P_txtScrll_UP")->changeAnimation(5);
mpPaneManager->getPaneComponentByPane(getPane("B_txtScrll_UP"))->init();
}
mbUpVisible = true;
} else {
if (mbUpVisible) searchAnmPane("P_txtScrll_UP")->changeAnimation(6);
mbUpVisible = false;
}
f32 textHeight = getLine() * getLineHeight();
f32 lowerHalfLine = getLineHeight();
lowerHalfLine *= 0.5f;
f32 lowerEdge = mfScroll + height;
lowerEdge += lowerHalfLine;
if (lowerEdge < textHeight) {
if (!mbDownVisible) {
searchAnmPane("P_txtScrll_DOWN")->changeAnimation(5);
mpPaneManager->getPaneComponentByPane(getPane("B_txtScrll_DOWN"))->init();
}
mbDownVisible = true;
} else {
if (mbDownVisible) searchAnmPane("P_txtScrll_DOWN")->changeAnimation(6);
mbDownVisible = false;
}
}
} else {
mbUpVisible = false;
mbDownVisible = false;
searchAnmPane("P_txtScrll_UP")->changeAnimation(7);
searchAnmPane("P_txtScrll_DOWN")->changeAnimation(7);
getPane("N_txt_scrl")->Animate(0);
getPane("N_txt_scrl")->CalculateMtx(mDrawInfo);
}
nw4r::lyt::Pane* scrollPane = getPane("N_txt_scrl");
scrollPane->SetTranslate(nw4r::math::VEC2(scrollPane->GetTranslate().x, 0.0f));
if (meEditMode == EM_Disp) {
mpScrollButton->calc();
if (!mbGoodBye) {
if (mbEditScrollUp && getScrollMin() >= mfScroll) {
mbEditScrollUp = false;
mpScrollButton->changeAnimation(false, 2);
} else if (!mbEditScrollUp && getScrollMin() < mfScroll) {
mbEditScrollUp = true;
mpScrollButton->changeAnimation(false, 1);
}
if (mbEditScrollDown && getScrollMax() <= mfScroll) {
mbEditScrollDown = false;
mpScrollButton->changeAnimation(true, 2);
}
if (!mbEditScrollDown && getScrollMax() > mfScroll) {
mbEditScrollDown = true;
mpScrollButton->changeAnimation(true, 1);
}
if (mpNigaoeObserver != NULL) mpNigaoeObserver->moveNigaoeButton();
}
}
calcCursorTimer();
}
void InputForm::doAutoScroll() {
if (!mExScrollAnm.isActive() && (meScrollFlag == SF_ScrollOn || meScrollFlag == SF_ScrollByBS)) {
if (meEditMode == EM_Edit) {
f32 lineHeight = getLineHeight();
lineHeight *= 0.5f;
f32 cursorBottom = mfCursorY + lineHeight;
if (mfScroll > cursorBottom) {
int lines = (mfScroll - mfCursorY) / getLineHeight();
mExScrollAnm.startAnm(NULL, mfScroll, mfScroll - lines * getLineHeight(), 15.0f, NULL);
onSE(sound::SE_LINE_SCROLL);
}
if (mfScroll + 2.0f * getLineHeight() < cursorBottom) {
f32 lineHeight = getLineHeight();
int lines = static_cast<int>((cursorBottom - (mfScroll + 2.0f * getLineHeight())) / lineHeight) + 1;
mExScrollAnm.startAnm(NULL, mfScroll, mfScroll + lines * getLineHeight(), 15.0f, NULL);
onSE(sound::SE_LINE_SCROLL);
}
}
meScrollFlag = SF_NoScroll;
}
}
void InputForm::beginDraw(const nw4r::ut::Rect&) {
if (mDrawRect.left == mDrawRect.right) mDrawRect.right += 0.1f;
if (mDrawRect.top == mDrawRect.bottom) mDrawRect.top += 0.1f;
textdrawer::Base::beginDraw(mDrawRect);
}
void InputForm::doScroll(Scroll*) {}
u32 InputForm::calcCursorPos(f32 x, f32 y) {
u32 lines = getLine();
if (lines > muLimitRowNum) lines = muLimitRowNum;
f32 lineHeight = getLineHeight();
f32 cursorY = y + mfScroll;
if (cursorY > lines * lineHeight) return inputform::Base::calcCursorPos(x, lines * getLineHeight());
return inputform::Base::calcCursorPos(x, cursorY);
}
void InputForm::drawCursor(f32 x, f32 y) {
if (meEditMode != EM_Disp) inputform::Base::drawCursor(x, y);
}
nw4r::math::VEC2 InputForm::getScale() const {
if (mpMemoRootPane == NULL) return nw4r::math::VEC2(1.0f, 1.0f);
return mpMemoRootPane->GetScale();
}
void InputForm::drawHeader() {
getPane(scPaneName[0])->Draw(mDrawInfo);
getPane("Nigaoe")->Draw(mDrawInfo);
getPane("T_Nigaoe")->Draw(mDrawInfo);
}
void InputForm::drawBody() {
nw4r::lyt::Pane* body = getPane(scPaneName[1]);
f32 y = 0.0f;
for (int i = 0; i < mnLine; i++) {
body->SetTranslate(nw4r::math::VEC2(0.0f, y));
body->CalculateMtx(mDrawInfo);
body->Draw(mDrawInfo);
y -= body->GetSize().height;
}
if (!mbEdited) getPane("T_TouchLetter")->Draw(mDrawInfo);
}
void InputForm::drawFooter() {
f32 y = (mnLine - 1) * (-1.0f * getPane(scPaneName[1])->GetSize().height);
nw4r::lyt::Pane* footer = getPane(scPaneName[3]);
footer->SetTranslate(nw4r::math::VEC2(0.0f, y));
footer->CalculateMtx(mDrawInfo);
footer->Draw(mDrawInfo);
}
void InputForm::open() {
setScroll(0.0f);
mfScrollFrom = 0.0f;
mfScrollTo = 0.0f;
mpLayout->GetRootPane()->SetTranslate(nw4r::math::VEC2(0.0f, 0.0f));
searchAnmPane("N_Memo")->changeAnimation(1);
searchAnmPane("P_txtScrll_UP")->changeAnimation(7);
searchAnmPane("P_txtScrll_DOWN")->changeAnimation(7);
}
void InputForm::close() {
if (!mbCloseWithSend) searchAnmPane("N_Memo")->changeAnimation(2);
else searchAnmPane("N_Memo")->changeAnimation(3);
if (mbEditScrollUp) {
mpScrollButton->changeAnimation(false, 2);
mbEditScrollUp = false;
}
if (mbEditScrollDown) {
mpScrollButton->changeAnimation(true, 2);
mbEditScrollDown = false;
}
mbGoodBye = true;
}
bool InputForm::isWholePaneInAnimation() {
return searchAnmPane("N_Memo")->isInAnimation();
}
void InputForm::setHeaderCaption(const wchar_t* caption) {
static_cast<nw4r::lyt::TextBox*>(mpLayout->GetRootPane()->FindPaneByName("T_Header", true))->SetString(caption, 0);
}
void InputForm::setMiiName(const wchar_t* name) {
static_cast<nw4r::lyt::TextBox*>(mpLayout->GetRootPane()->FindPaneByName("T_Nigaoe", true))->SetString(name, 0);
}
void InputForm::setTouchLetterCaption(const wchar_t* caption) {
static_cast<nw4r::lyt::TextBox*>(mpLayout->GetRootPane()->FindPaneByName("T_TouchLetter", true))->SetString(caption, 0);
mbEdited = false;
}
nw4r::lyt::Pane* InputForm::getNigaoePane() {
return getPane("Nigaoe");
}
nw4r::lyt::Material* InputForm::getNigaoePaneMaterial() {
return getPane("Nigaoe")->FindMaterialByName("Nigaoe", true);
}
f32 InputForm::getScrollMin() { return 0.0f; }
f32 InputForm::getScrollMax() { return getDrawBoxHeight() - 100.0f; }
f32 InputForm::getDrawBoxHeight() { return mnLine * getLineHeight(); }
void InputForm::onNigaoeButtonTrig() {
if (meEditMode == EM_Disp && mpNigaoeObserver != NULL && mpNigaoeObserver->onNigaoeButton()) onSE(sound::SE_DECIDE);
}
void InputForm::onNigaoeButtonPoint() {
if (meEditMode == EM_Disp) {
searchAnmPane("Nigaoe")->changeAnimation(4);
if (mpNigaoeObserver != NULL) mpNigaoeObserver->pointNigaoeButton();
onSE(sound::SE_BT_TARGETTING);
}
}
void InputForm::onNigaoeButtonLeft() {
if (meEditMode == EM_Disp) {
if (mpNigaoeObserver != NULL) mpNigaoeObserver->leftNigaoeButton();
searchAnmPane("Nigaoe")->changeAnimation(5);
}
}
void InputForm::setDefaultNigaoe() {
getNigaoePaneMaterial()->SetTexture(0, *mpDefaultNigaoe);
}
void InputForm::setEditMode(EditMode mode) {
meEditMode = mode;
switch (mode) {
case EM_Disp: getPane("N_txt_scrl")->SetVisible(false); break;
case EM_Edit: getPane("N_txt_scrl")->SetVisible(true); break;
case EM_Disappear:
onCommand(static_cast<INPUT_COMMAND>(6), NULL);
candidatebox::CandidateBoxCaller::resetCandidate();
candidatebox::CandidateBoxCaller::makeEmptyCandidate();
break;
}
}
void InputForm::preDraw(u32 pos) {
if (meEditMode == EM_Disp) mpSendString->clear();
inputform::Base::preDraw(pos);
}
void InputForm::doLineFeed() {
if (meEditMode == EM_Disp) mpSendString->pushBack(L'\n');
inputform::Base::doLineFeed();
}
void InputForm::put(wchar_t ch) {
if (meEditMode == EM_Disp) mpSendString->pushBack(ch);
textdrawer::Base::put(ch);
}
void InputForm::finishDraw(u32) {
if (meEditMode == EM_Disp) mpSendString->pushBack(0);
}
void WholePane::onAnmEvent(AnmPaneEvent) {}
void EventHandler::onTiEvent(gui::PaneComponent* component, u32 event, Input* input) {
inputform::EventHandler::onTiEvent(component, event, input);
const char* name = component->getPane()->GetName();
if (name[0] == 'B') {
if (event == 4 && (input->field_0x0C & 0x800)) {
if (util::strcmp("B_Nigaoe", name)) mpMemoForm->onNigaoeButtonTrig();
if (util::strcmp("B_ArwR", name)) mpMemoForm->onArrowRTrig();
if (util::strcmp("B_ArwL", name)) mpMemoForm->onArrowLTrig();
}
if (event == 0) {
if (util::strcmp("B_Nigaoe", name)) mpMemoForm->onNigaoeButtonPoint();
if (util::strcmp("B_ArwR", name)) mpMemoForm->onArrowRPoint();
if (util::strcmp("B_ArwL", name)) mpMemoForm->onArrowLPoint();
}
if (event == 1) {
if (util::strcmp("B_Nigaoe", name)) mpMemoForm->onNigaoeButtonLeft();
if (util::strcmp("B_ArwR", name)) mpMemoForm->onArrowRLeft();
if (util::strcmp("B_ArwL", name)) mpMemoForm->onArrowLLeft();
}
}
}
void SimpleAnmPane::changeAnimation(u32 id) { nw4rmanager::AnmPane::changeAnimation(id); }
void SimpleAnmPane::init() {}
void ScrollButton::init() {}
u32 AnmPane::getState() { return meState; }
void AnmPane::changeAnimation(u32 id) {
meState = id;
nw4rmanager::AnmPane::changeAnimation(id);
}
u32 AnmPane::getKeyType() const { return meKeyType; }
void AnmPane::init() { meState = 0; }
void NigaoePane::onAnmEvent(AnmPaneEvent) {}
bool InputForm::isInScroll() { return mExScrollAnm.isActive(); }
}
}
}

1130
src/keyboard/MyTiManager.cpp Normal file

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,147 @@
#define IPL_CHANNEL_TITLE_NOVTABLE
#include "scene/memoryCard/iplGCSaveData.h"
#include "scene/memoryCard/iplMemoryCard.h"
#include "scene/textBalloon/iplBalloon.h"
#include "iplSound.h"
#include "iplSystem.h"
#undef IPL_CHANNEL_TITLE_NOVTABLE
namespace ipl {
namespace scene {
static const MemoryBase::AnmName scAnmName[] = {
{"it_ObjCubeEdit_b_SaveDataIn.brlan", "G_Data"},
{"it_ObjCubeEdit_b_SaveDataOut.brlan", "G_Data"},
{"it_ObjCubeEdit_b_SaveDataFoucusIn.brlan", "G_Data"},
{"it_ObjCubeEdit_b_SaveDataFoucusOut.brlan", "G_Data"},
{"it_ObjCubeEdit_b_SaveDataFlash.brlan", "G_DataFlash"},
};
static const char* scDataPaneName = "B_Data_00";
GCSaveData::GCSaveData(EGG::Heap* heap, nand::LayoutFile* layoutFile, const char* directory, const char* fileName,
math::VEC3 translate) {
mpBalloon = NULL;
mpLayout = new layout::Object(heap, layoutFile, directory, fileName);
add_animation(scAnmName, 5);
mpLayout->finishBinding();
mpEvent = new MemoryBaseEvent(this);
mpPaneManager = new gui::PaneManager(mpEvent, mpLayout->getDrawInfo(), NULL, NULL, true);
mpPaneManager->setupScene(mpLayout);
mpPaneManager->setAllComponentTriggerTarget(false);
mpPaneManager->setTriggerTarget(mpLayout->FindPaneByName(scDataPaneName), true);
add_anmbutton(scDataPaneName, get_animation(2), get_animation(3), NULL);
setTranslate(translate);
}
void GCSaveData::calc() {
mpLayout->calc();
mpPaneManager->calc();
get_anmbutton(scDataPaneName)->calc();
}
void GCSaveData::draw() {
nw4r::lyt::Pane* pane = mpLayout->FindPaneByName("DataBanner_00");
nw4r::lyt::Material* material = pane->FindMaterialByName("DataBanner_00");
pane->SetVisible(true);
if (static_cast<MemoryCard*>(System::getScene(0xE))->getManager()->isIconValidate(mSlot, mIndex) &&
static_cast<MemoryCard*>(System::getScene(0xE))->getManager()->create_icon(mSlot, mIndex) != NULL) {
material->SetTexture(0, *static_cast<MemoryCard*>(System::getScene(0xE))
->getManager()
->create_icon(mSlot, mIndex));
} else {
pane->SetVisible(false);
}
if (mIndex >= 0 && mIndex < 0x7f) {
mpLayout->draw();
} else {
if (mpBalloon != NULL) {
mpBalloon->terminate();
}
}
}
void GCSaveData::update() {
if (mIndex < 0) {
return;
}
if (mIndex >= 0x7f) {
return;
}
mpPaneManager->update();
}
void GCSaveData::onPoint(const char* paneName, controller::Interface* controller) {
AnmButton* button = get_anmbutton(paneName);
if (button != NULL) {
if (button->unk_0x04 == 0) {
if (System::getScene(0xE) != NULL) {
if (static_cast<MemoryCard*>(System::getScene(0xE))
->getManager()
->isIconValidate(mSlot, mIndex)) {
mpBalloon->init(static_cast<MemoryCard*>(System::getScene(0xE))
->getManager()
->getComment(mSlot, mIndex, 0),
0);
get_anmbutton(scDataPaneName)->setBalloon(mpBalloon);
} else {
get_anmbutton(scDataPaneName)->setBalloon(NULL);
}
}
snd::getSystem()->startSE("WIPL_SE_BT_TARGETTING");
if (controller != NULL) {
controller->rumble(0);
}
button->onCmdRecv(1);
}
button->unk_0x04++;
}
}
void GCSaveData::onLeft(const char* paneName) {
AnmButton* button = get_anmbutton(paneName);
if (button != NULL) {
if (button->unk_0x04 == 1) {
button->onCmdRecv(2);
}
button->unk_0x04--;
}
}
void GCSaveData::onTrig(const char* paneName) {
if (static_cast<MemoryCard*>(System::getScene(0xE)) != NULL &&
static_cast<MemoryCard*>(System::getScene(0xE))->getManager()->isIconValidate(mSlot, mIndex) &&
get_anmbutton(paneName) != NULL) {
static_cast<MemoryCard*>(System::getScene(0xE))->onFocus(this);
}
}
void GCSaveData::setTranslate(const nw4r::math::VEC3& translate) {
mpLayout->FindPaneByName("N_Data_00")->SetTranslate(translate);
}
const nw4r::math::VEC3* GCSaveData::getTranslate() {
return &mpLayout->FindPaneByName("N_Data_00")->GetTranslate();
}
void GCSaveData::init() {
clear_button(scDataPaneName);
if (mpBalloon != NULL) {
mpBalloon->terminate();
}
}
void GCSaveData::setBalloon(TextBalloon* balloon) {
mpBalloon = balloon;
}
GCSaveData::~GCSaveData() {}
} // namespace scene
} // namespace ipl

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

2680
src/scene/setting/AOSS.c Normal file

File diff suppressed because it is too large Load Diff

2345
src/scene/setting/ATERM.c Normal file

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,290 @@
#include <revolution/os.h>
#include <cstring>
#include <egg/core.h>
#include <revolution/mem.h>
#include <revolution/net.h>
#include <revolution/soex.h>
#include <revolution/ncd.h>
#include "utility/iplThread.h"
extern "C" {
int AOSSi_Init(void* config);
int AOSSi_InitLocal(SOAlloc alloc, SOFree free_);
int AOSSi_EndLocal(void);
int AOSSi_Cancel(void);
int AOSS_SetCallback(void (*callback)(void));
}
namespace ipl {
namespace scene {
class USBAPThread {
public:
static void callback();
};
MEMAllocator m_allocator;
typedef struct AOSSResult {
u8 wep40Key[4][6]; // 0x000
char wep40Ssid[0x20]; // 0x018
u8 pad_0x38; // 0x038
u8 wep104Key[4][0xE]; // 0x039
char wep104Ssid[0x20]; // 0x071
u8 pad_0x91; // 0x091
char tkipKey[0x40]; // 0x092
char tkipSsid[0x20]; // 0x0D2
u8 pad_0xF2; // 0x0F2
char aesKey[0x40]; // 0x0F3
char aesSsid[0x20]; // 0x133
u8 pad_0x153[2]; // 0x153
} AOSSResult; // 0x155
typedef struct AOSSConfig {
u16 version; // 0x000
u8 unk_0x02; // 0x002
u16 unk_0x04; // 0x004
u8 name[3]; // 0x006
u8 pad_0x09[0xFD]; // 0x009
u16 unk_0x106; // 0x106
u16 unk_0x108; // 0x108
u16 unk_0x10A; // 0x10A
u16 unk_0x10C; // 0x10C
u16 unk_0x10E; // 0x10E
u8 mac[6]; // 0x110
u8 result; // 0x116
AOSSResult security; // 0x117
} AOSSConfig; // 0x26C
static u32 sAOSSStartTimeHi;
static u32 sAOSSStartTimeLo;
static s32 sAOSSState;
static s32 sAOSSUnk;
class AOSSThread : public utility::ut_thread {
public:
AOSSThread(EGG::Heap* heap);
virtual ~AOSSThread(); // 0x08
virtual void* Run(); // 0x0C
virtual void unk_0x2C() = 0; // 0x2C
void destroy(int flag);
int start();
int cancel();
int finish(NCDAossConfig* config, int* result);
void printInfo();
static void* AOSSThread_813FCC8C(u32 id, s32 size);
static void AOSSThread_813FCCE4(u32 id, void* ptr, s32 align);
private:
s32 mState; // 0x32C
s32 mThreadPriority; // 0x330
u8* mpStackBuffer; // 0x334
u8* mpHeapBuffer; // 0x338
MEMHeapHandle mpExpHeap; // 0x33C
AOSSConfig mAoss; // 0x340
};
AOSSThread::AOSSThread(EGG::Heap* heap) : utility::ut_thread() {
mpExpHeap = NULL;
sAOSSState = 0;
mpHeapBuffer = (u8*)heap->alloc(0x40000, 0x20);
mpStackBuffer = (u8*)heap->alloc(0x1000, 0x20);
}
void AOSSThread::destroy(int flag) {
if (sAOSSState != 0) {
if (IsThreadTerminated()) {
WaitForThreadExit();
SOFinish();
sAOSSState = 0;
}
}
if (mpExpHeap != NULL) {
MEMDestroyExpHeap(mpExpHeap);
mpExpHeap = NULL;
}
}
AOSSThread::~AOSSThread() {
destroy(1);
}
int AOSSThread::start() {
SOLibraryConfig config;
if (sAOSSState != 0) {
return 0;
}
config.alloc = AOSSThread_813FCC8C;
config.free = AOSSThread_813FCCE4;
BOOL level = OSDisableInterrupts();
OSTime t = OSGetTime();
sAOSSStartTimeLo = (u32)t;
sAOSSStartTimeHi = (u32)(t >> 32);
mpExpHeap = MEMCreateExpHeapEx(mpHeapBuffer, 0x40000, 2);
MEMInitAllocatorForExpHeap(&m_allocator, mpExpHeap, 0x20);
mThreadPriority = OSGetThreadPriority(OSGetCurrentThread()) - 2;
sAOSSState = 1;
SOInit(&config);
memset(mpStackBuffer, 0, 4);
Create(mpStackBuffer, 0x1000, mThreadPriority, TRUE);
OSRestoreInterrupts(level);
return 1;
}
void* AOSSThread::AOSSThread_813FCC8C(u32 id, s32 size) {
void* buffer;
BOOL level = OSDisableInterrupts();
buffer = MEMAllocFromAllocator(&m_allocator, size);
OSRestoreInterrupts(level);
return buffer;
}
void AOSSThread::AOSSThread_813FCCE4(u32 id, void* ptr, s32 align) {
BOOL level = OSDisableInterrupts();
MEMFreeToAllocator(&m_allocator, ptr);
OSRestoreInterrupts(level);
}
void* AOSSThread::Run() {
mState = 0xF;
AOSS_SetCallback(USBAPThread::callback);
if (AOSSi_InitLocal(AOSSThread_813FCC8C, AOSSThread_813FCCE4) == -1) {
return this;
}
memset(&mAoss, 0, sizeof(mAoss));
mAoss.version = 0xF;
mAoss.unk_0x106 = 0x32;
mAoss.unk_0x10A = 0x32;
mAoss.unk_0x108 = 0x64;
mAoss.unk_0x10C = 0x64;
mAoss.unk_0x10E = 0x4E20;
mAoss.unk_0x02 = 0x50;
memcpy(mAoss.name, "Wii", 3);
mAoss.unk_0x04 = 4;
NETGetWirelessMacAddress(mAoss.mac);
*(u32*)(mpStackBuffer + 0x3FC0) = 0x97654321;
mState = AOSSi_Init(&mAoss);
AOSSi_EndLocal();
OSCheckActiveThreads();
return this;
}
int AOSSThread::cancel() {
if (sAOSSState == 0) {
return 0;
}
BOOL level = OSDisableInterrupts();
AOSSi_Cancel();
OSRestoreInterrupts(level);
return 1;
}
int AOSSThread::finish(NCDAossConfig* config, int* result) {
if (sAOSSState == 0) {
*result = -0x63;
return 1;
}
if (IsThreadTerminated()) {
destroy(0);
}
else {
if (((u32)OSGetTime() - (u32)sAOSSStartTimeLo)
/ (OS_TIMER_CLOCK / 1000)
>= 90000)
{
BOOL level = OSDisableInterrupts();
AOSSi_Cancel();
OSRestoreInterrupts(level);
}
return 0;
}
if (mState == 0) {
BOOL level = OSDisableInterrupts();
AOSSResult* sec = &mAoss.security;
if ((mAoss.version & 0x0001) == 1) {
memcpy(config->wep40.ssid, sec->wep40Ssid, 0x20);
memcpy(config->wep40.key[0], sec->wep40Key[0], 5);
memcpy(config->wep40.key[1], sec->wep40Key[1], 5);
memcpy(config->wep40.key[2], sec->wep40Key[2], 5);
memcpy(config->wep40.key[3], sec->wep40Key[3], 5);
config->wep40.keyId = 1;
config->wep40.ssidLength = strlen(sec->wep40Ssid);
}
else {
memset(config->wep40.ssid, 0, 0x20);
config->wep40.ssidLength = 0;
}
if ((mAoss.version & 0x0002) == 2) {
memcpy(config->wep104.ssid, sec->wep104Ssid, 0x20);
memcpy(config->wep104.key[0], sec->wep104Key[0], 0xD);
memcpy(config->wep104.key[1], sec->wep104Key[1], 0xD);
memcpy(config->wep104.key[2], sec->wep104Key[2], 0xD);
memcpy(config->wep104.key[3], sec->wep104Key[3], 0xD);
config->wep104.keyId = 1;
config->wep104.ssidLength = strlen(sec->wep104Ssid);
}
else {
memset(config->wep104.ssid, 0, 0x20);
config->wep104.ssidLength = 0;
}
if ((mAoss.version & 0x0004) == 4) {
memcpy(config->tkip.ssid, sec->tkipSsid, 0x20);
memcpy(config->tkip.key, sec->tkipKey, 0x40);
config->tkip.ssidLength = strlen(sec->tkipSsid);
config->tkip.keyLen = strlen(sec->tkipKey);
}
else {
memset(config->tkip.ssid, 0, 0x20);
config->tkip.ssidLength = 0;
}
if ((mAoss.version & 0x0008) == 8) {
memcpy(config->aes.ssid, sec->aesSsid, 0x20);
memcpy(config->aes.key, sec->aesKey, 0x40);
config->aes.ssidLength = strlen(sec->aesSsid);
config->aes.keyLen = strlen(sec->aesKey);
}
else {
memset(config->aes.ssid, 0, 0x20);
config->aes.ssidLength = 0;
}
printInfo();
OSRestoreInterrupts(level);
}
else if (mState == -2) {
*result = -0x62;
}
*result = mAoss.result;
return 1;
}
#pragma dont_inline on
void AOSSThread::printInfo() {
}
#pragma dont_inline reset
} // namespace scene
} // namespace ipl

View File

@@ -15,6 +15,7 @@
#include "iplwww/www_wiisetting.h"
#include "iplwww/www_surface.h"
#include "iplwww/www_window.h"
#include "iplwww/www_trasition.h"
#include <cstdio>
@@ -31,6 +32,12 @@
extern "C" void __VISetAdjustingValues(s32 horizontal, s32 vertical);
namespace ipl {
namespace scene {
static s32 browserScrollDirection;
}
}
namespace ipl {
class SensitivityDrawing {
public:
@@ -137,7 +144,7 @@ namespace ipl {
"G_Lock1", "G_Lock2", "G_Lock3", "G_Lock4", "G_Lock5", "G_Lock6",
};
const char* sSettingAPAnimations[] = {
const char* sSettingAPAnimations[19] = {
"my_AP_a_ArwAppear.brlan", "my_AP_a_ArwLost.brlan", "my_AP_a_ArwFocusOn.brlan",
"my_AP_a_ArwFocusOff.brlan", "my_AP_a_ArwSelect.brlan", "my_AP_a_ScrollUp.brlan",
"my_AP_a_ScrollDown.brlan", "my_AP_a_BtnFocusOn.brlan", "my_AP_a_BtnFocusOff.brlan",
@@ -656,7 +663,8 @@ namespace ipl {
bool Setting::updateScreenMode() {
if (unk_0x91C[2] != 0) {
if (unk_0xB94 == 0) {
switch (unk_0xB94) {
case 0:
if (mEuRgb60Mode != SCGetEuRgb60Mode()) {
unk_0xB94 = 3;
} else if (mProgressiveMode != SCGetProgressiveMode()) {
@@ -668,6 +676,9 @@ namespace ipl {
mState = 0;
return true;
}
break;
default:
goto screenModeDispatch;
}
} else if (unk_0xB94 == 1 && unk_0x74 == 8) {
System::getFader()->fadeOut();
@@ -677,6 +688,7 @@ namespace ipl {
return true;
}
screenModeDispatch:
switch (unk_0xB94) {
case 1:
if (System::getFader()->getStatus() == EGG::Fader::PREPARE_IN) {
@@ -1261,63 +1273,67 @@ namespace ipl {
FaderSceneCommand Setting::calcFadeout() {
if (System::getFader()->getStatus() == EGG::Fader::PREPARE_IN) {
if (unk_0x5C == 0) {
const u8 surfaceState = unk_0x5C;
if (surfaceState == 0) {
unk_0x5C = 1;
ext_ead::www::SurfaceManager::GetInstance()->StopThreadAsync();
OSReport("!!!!!!!!!!!!! SCFlush !!!!!!!!!!!!!!\n");
SCFlush();
} else if (unk_0x7C == 5) {
if (mInitialArgument == 2 || mInitialArgument == 5) {
SCSetConfigDoneFlag(TRUE);
SCSetConfigDoneFlag2(TRUE);
SCSetUpdateType(0);
SCFlush();
}
if (surfaceState != 0) {
if (unk_0x7C == 5) {
if (mInitialArgument == 2 || mInitialArgument == 5) {
SCSetConfigDoneFlag(TRUE);
SCSetConfigDoneFlag2(TRUE);
SCSetUpdateType(0);
SCFlush();
}
while (WPADGetStatus() != 0 ||
System::getBS2Manager()->getIPLState() != bs2::IPL_STATE_8) {
snd::getSystem()->calc();
System::getBS2Manager()->update();
while (WPADGetStatus() != 0 ||
System::getBS2Manager()->getIPLState() != bs2::IPL_STATE_8) {
snd::getSystem()->calc();
System::getBS2Manager()->update();
VIWaitForRetrace();
if (WPADGetStatus() != 0) {
OSReport("wait for WPAD\n");
}
if (System::getBS2Manager()->getIPLState() != bs2::IPL_STATE_8) {
OSReport("wait for BS2\n");
}
}
VISetBlack(TRUE);
VIFlush();
VIWaitForRetrace();
if (WPADGetStatus() != 0) {
OSReport("wait for WPAD\n");
OSReport("VI Black\n");
while (!__OSSyncSram()) {
OSReport("sync sram\n");
}
if (System::getBS2Manager()->getIPLState() != bs2::IPL_STATE_8) {
OSReport("wait for BS2\n");
while (!System::isReceiveScheduleStopped()) {
OSReport("Wait ScheduleStopped\n");
OSSleepMilliseconds(5);
}
__OSLaunchTitlelForSystem(mUpdateTitleId, 0, NULL);
for (;;) {
OSReport(NULL);
}
} else if (ext_ead::www::SurfaceManager::GetInstance()->IsThreadStopped()) {
OSReport("reserve destroy\n");
ext_ead::www::SurfaceManager::DisposeManager();
OSReport("reserve destroy done\n");
if (mInitialArgument == 2 || mInitialArgument == 5) {
SCSetConfigDoneFlag(TRUE);
SCSetConfigDoneFlag2(TRUE);
SCSetUpdateType(0);
SCFlush();
reserveAllSceneDestruction(0x1a, NULL);
} else {
System::reloadDownloadTask();
reserveAllSceneDestruction(0x15, NULL);
}
delete mpBrowserData;
return FADER_SCN_NEXT;
}
VISetBlack(TRUE);
VIFlush();
VIWaitForRetrace();
OSReport("VI Black\n");
while (!__OSSyncSram()) {
OSReport("sync sram\n");
}
while (!System::isReceiveScheduleStopped()) {
OSReport("Wait ScheduleStopped\n");
OSSleepMilliseconds(5);
}
__OSLaunchTitlelForSystem(mUpdateTitleId, 0, NULL);
for (;;) {
OSReport(NULL);
}
} else if (ext_ead::www::SurfaceManager::GetInstance()->IsThreadStopped()) {
OSReport("reserve destroy\n");
ext_ead::www::SurfaceManager::DisposeManager();
OSReport("reserve destroy done\n");
if (mInitialArgument == 2 || mInitialArgument == 5) {
SCSetConfigDoneFlag(TRUE);
SCSetConfigDoneFlag2(TRUE);
SCSetUpdateType(0);
SCFlush();
reserveAllSceneDestruction(0x1a, NULL);
} else {
System::reloadDownloadTask();
reserveAllSceneDestruction(0x15, NULL);
}
delete mpBrowserData;
return FADER_SCN_NEXT;
}
}
@@ -1347,6 +1363,27 @@ namespace ipl {
return;
}
ext_ead::www::BrowserWindow* browserWindow =
static_cast<ext_ead::www::BrowserWindow*>(browser->mpBrowserWindows[0]);
if (browserWindow != NULL && browserWindow->unk_0x2C4[3] != 0) {
unk_0x91C[2] = 1;
mState = 0;
browserWindow->unk_0x2C4[3] = 0;
www::trasition::ScrollState scrollState = www::trasition::GetScrollState();
browserScrollDirection = scrollState == www::trasition::SCROLL_LEFT
? 1
: (scrollState == www::trasition::SCROLL_RIGHT ? -1 : 0);
www::trasition::ResetScrollState();
void* changedWideBuffer = browser->GetTextureBuffer(1, NULL);
void* changedStandardBuffer = browser->GetTextureBuffer(0, NULL);
OSReport("changed %p %p\n", changedStandardBuffer, changedWideBuffer);
ext_ead::www::Heap::reportLeaHeap();
}
bool showBrowserWindow =
mpSecondAnimation->state == 1 || mpFirstAnimation->state == 1;
mpChangeLayout->FindPaneByName("hoge")->SetVisible(showBrowserWindow);
WWWRect* wideRect = NULL;
WWWRect* standardRect = NULL;
void* wideBuffer = browser->GetTextureBuffer(1, &wideRect);
@@ -1355,12 +1392,6 @@ namespace ipl {
return;
}
if (www::trasition::GetScrollState() != www::trasition::SCROLL_RESET) {
www::trasition::ResetScrollState();
OSReport("changed %p %p\n", standardBuffer, wideBuffer);
ext_ead::www::Heap::reportLeaHeap();
}
nw4r::ut::Rect projection4x3;
nw4r::ut::Rect projection16x9;
System::getProjectionRect4x3(&projection4x3);
@@ -1373,6 +1404,10 @@ namespace ipl {
GXInitTexObjLOD(&standardTexture, GX_LINEAR, GX_LINEAR, 0.0f, 0.0f, 0.0f, GX_FALSE, GX_FALSE, GX_ANISO_1);
GXInitTexObjLOD(&wideTexture, GX_LINEAR, GX_LINEAR, 0.0f, 0.0f, 0.0f, GX_FALSE, GX_FALSE, GX_ANISO_1);
if (browserScrollDirection != 0) {
mpChangeLayout->FindPaneByName("hoge")->SetVisible(true);
}
utility::Graphics::setOrtho(0);
GXColor color = {0xFF, 0xFF, 0xFF, (u8)(mState * 0xFF / 20)};
utility::Graphics::drawTexture(projection4x3, standardTexture, color, 1);
@@ -1914,20 +1949,24 @@ namespace ipl {
memset(mpStringBuffer->securityKey, 0, sizeof(mpStringBuffer->securityKey));
s32 privacyMode = ncd::NCDSetting::getNCDPrivacyMode();
size_t keyLength;
if (privacyMode != 2) {
if (privacyMode < 2) {
if (privacyMode == 0) {
keyLength = 0;
} else {
keyLength = 5;
}
} else if (privacyMode < 7 && privacyMode > 3) {
keyLength = 64;
} else {
keyLength = 0;
}
} else {
switch (privacyMode) {
case 0:
keyLength = 0;
break;
case 1:
keyLength = 5;
break;
case 2:
keyLength = 13;
break;
case 4:
case 5:
case 6:
keyLength = 64;
break;
default:
keyLength = 0;
break;
}
if (keyLength != 0) {
memcpy(mpStringBuffer->securityKey, ncd::NCDSetting::getPrivacy(), keyLength);
@@ -2288,17 +2327,16 @@ namespace ipl {
int count = 0;
memset(ascii, 0, sizeof(ascii));
utility::CharacterCode::UTF8ToANSI(reinterpret_cast<u8*>(ascii), address);
char* converted = ascii;
int componentStart = 0;
u8* output = destination;
for (int index = 0; index < 0x10; ++index) {
u8 character = static_cast<u8>(converted[index]);
u8 character = static_cast<u8>(ascii[index]);
if (character == '.' || character == 0) {
if (character == 0) {
index = 0x10;
}
converted[index] = 0;
u32 value = atoi(converted + componentStart);
ascii[index] = 0;
u32 value = atoi(ascii + componentStart);
if (value > 0xff) {
value = 0xff;
}
@@ -2313,7 +2351,7 @@ namespace ipl {
++count;
++output;
if (count == 3 && index != 0x10) {
value = atoi(converted + componentStart);
value = atoi(ascii + componentStart);
if (value > 0xff) {
value = 0xff;
}
@@ -2811,16 +2849,15 @@ namespace ipl {
if (accessPoint != -1) {
int index = 0;
while (index <= mAPScanList.count) {
WDBssDesc_* descriptor = mAPScanList.currentDescriptor;
int recordLength = descriptor->length * 2;
int recordLength = mAPScanList.currentDescriptor->length * 2;
recordOffset += recordLength;
if (recordOffset > 0x800) {
break;
}
if (index == accessPoint + unk_0x914 + 1) {
u8 privacyMode = static_cast<u8>(WDGetPrivacyMode(descriptor));
u8 privacyMode = static_cast<u8>(WDGetPrivacyMode(mAPScanList.currentDescriptor));
char ssid[0x21];
memcpy(ssid, descriptor->ssid, 0x20);
memcpy(ssid, mAPScanList.currentDescriptor->ssid, 0x20);
ssid[0x20] = 0;
memset(mpStringBuffer->securityKey, 0, sizeof(mpStringBuffer->securityKey));
memset(mpStringBuffer->ssid, 0, sizeof(mpStringBuffer->ssid));
@@ -2838,7 +2875,9 @@ namespace ipl {
OSReport("SET DATA : %d %s %d\n", index, ssid, privacyMode);
break;
}
mAPScanList.currentDescriptorWords += recordLength / sizeof(u16);
mAPScanList.currentDescriptor =
reinterpret_cast<WDBssDesc_*>(
mAPScanList.entries + recordOffset - sizeof(mAPScanList.count));
++index;
}
unk_0x91C[2] = 0;
@@ -2857,7 +2896,7 @@ namespace ipl {
if (unk_0x914 == 1) {
mpMainLayout->FindPaneByName("N_AP0")->SetVisible(false);
}
} else {
} else if (arrow == 1) {
unk_0x91C[0] = 1;
if (mAPScanList.count == unk_0x914 + 5) {
mpMainLayout->FindPaneByName("N_AP7")->SetVisible(false);
@@ -3097,13 +3136,15 @@ namespace ipl {
}
u16 Setting::getProfileID() {
if (mProfileIDMode < 3) {
return ncd::NCDSetting::getID();
}
u16 profileID = ncd::NCDSetting::getUseProfileID();
ncd::NCDSetting::initSetID(profileID & 0xff);
if ((profileID & 0xff) == 3) {
profileID = 0;
u16 profileID;
if (mProfileIDMode >= 3) {
profileID = ncd::NCDSetting::getUseProfileID();
ncd::NCDSetting::initSetID(static_cast<u8>(profileID));
if (static_cast<u8>(profileID) == 3) {
profileID = 0;
}
} else {
profileID = ncd::NCDSetting::getID();
}
return profileID;
}
@@ -3239,7 +3280,7 @@ namespace ipl {
}
}
static const wchar_t errorFormat[] = L"\n%03d";
static const wchar_t errorFormat[] = L"%d\n";
void Setting::makeErrorMessage() {
const wchar_t* prefix = System::getMessage(400);
@@ -3399,7 +3440,7 @@ namespace ipl {
unk_0x84 = 1;
unk_0x91C[1] = 0;
resetFuncMsgQ();
}
}
}
void Setting::cancelUSBAP() {
@@ -3630,15 +3671,15 @@ namespace ipl {
case ::gui::EventHandler::ON_POINT:
mpSetting->start_point_event(paneName);
break;
case ::gui::EventHandler::ON_LEFT:
mpSetting->start_left_event(paneName);
break;
case ::gui::EventHandler::ON_TRIG:
controller::Interface* input = static_cast<controller::Interface*>(data);
if (input->downTrg(0x100800)) {
mpSetting->start_trig_event(paneName);
}
break;
case ::gui::EventHandler::ON_LEFT:
mpSetting->start_left_event(paneName);
break;
default:
break;
}

View File

@@ -0,0 +1,171 @@
# BS2Mach attempts
Baseline: 16/29 instruction-exact functions, code 2500/16980 bytes,
data 155472/158528 bytes. The fresh branch baseline gate passes.
Only this unit is changed. No linking changes are made.
The assembly and the existing object decompiler exports under /tmp were read.
Older /tmp source candidates were used as reference and audited before adapting
individual bodies. Their assembly, force_active pragmas, register qualifiers,
volatile additions, packed string blobs, and raw structure offsets are excluded.
## Object-order implementation, first pass
- Run: C cache-block zero/flush loop followed by the entry call. The original
clears nearly all GPRs, replaces the stack, and branches through LR. C cannot
express that register contract. The report gives no function score.
- BS2ESGetTicketViews: separate aligned title/count buffers produced 72/71
instructions and a 0x180 frame versus 0x160. A single 256-byte IPC workspace
with typed title/count arrays and boolean null checks gives 71/71, diffs 0.
- BS2Reboot: ordinary aligned ticket, IOS workspace, state flags and vectors
initially gave 137/137, eight stack-offset diffs. Reordering descriptor and
count declarations gives 137/137, diffs 0. No fabricated padding is used.
- BS2StartGame: implemented boot-cache close, state flags, IOS launch, DVD
reopen, and loader handoff. First score 96.48855%. Target contains sync/isync
and polls callback results; no new assembly or volatile was introduced.
- BS2StartGCGame: implemented configuration, SRAM fields, clock and MIOS launch.
First score 95.26755%.
- CheckDVDCommandStatus: original switch/state transitions, 102/102, diffs 0.
- BS2NANDDivideCallback: transfer accounting before buffer advance, separate
full/final chunk branches, first score 85.03906%.
- BS2NANDDivideReadAsync: original request setup and chunk branches with ordinary
globals, first score 60.31915%, 45/47 instructions. Compiler removes reloads.
- BS2NANDDivideWriteAsync: corresponding write setup, first score 60.31915%.
- CheckBS2CommandStatus: cache-writing state switch, first score 79.655174%.
- BS2InquiryAsync: boot-cache/DVD unencrypted read branches, instruction-exact.
- BS2ReadDiskID: boot-cache/DVD read branches, instruction-exact.
- BS2Tick: implementation pending at this checkpoint.
String pool: the first 56 strings are identical in order; the remaining 35
orig strings belong to BS2Tick. Checkpoint: 21/29 exact, code 4052/16980,
zero regressions, zero forbidden additions, zero readability warnings.
## Complete state machine and data review
BS2Tick was implemented last, preserving object order. All 91 ordinary string
literals now occur in the original order and at the original .data offsets.
A separate offset comparison found zero differences across all 91 strings.
The small writable GameCube language mapping, /dev/es and disc prefixes produce
an instruction-independent .sdata match of 32/32 bytes. The larger .data section
still has no objdiff match score; strings alone do not establish a data match.
Semantic review corrected the cover command block reset, replaced an unsafe
four-byte memset of separate char locals with a four-byte title array, used
DVDFileInfo fields for banner position/length, and changed the newly implemented
loader code to use the target's __DVDLayoutFormat rather than BS2LastMode.
All partition/TMD/SRAM field accesses use their existing structure definitions.
The allocation rounds down then adds one cache line to select the next aligned
banner address, as the target does. This is buffer alignment, not data padding.
The ES stack workspace follows the SDK's 256-byte IPC work-area convention.
It holds typed aligned title and count buffers. The reboot launch workspace is
also the SDK's 256-byte IPC workspace. No objects were added to move .data.
The SDK declaration of DVDReadAbsAsyncForBS has a sixth priority parameter,
but the implementation ignores it and this IPL object passes five arguments.
BS2_MACH_FIVE_ARG_READ is defined only by BS2Mach.c and guards the declaration
in the shared header. Other units keep their original declaration and output.
The NAND callback now declares its real second callback parameter. Passing NULL
on direct error notifications restores the missing r4 argument setup without
changing the already exact callback body.
## Remaining-function attempt coverage
Every remaining function has at least three distinct source-level attempts.
Percentages are advisory objdiff scores from the quick gates; none is called an
exact match. Final instruction counts come from fresh ctxdiff calls.
### Run
1. Per-block do/while DCZeroRange/DCFlushRange, then entry call: 28/43
instructions; objdiff reports None.
2. Counted for loop over cache blocks: objdiff 0.88372093%; register clearing,
stack replacement and LR handoff are still absent.
3. Bulk cache zero/flush followed by entry: 25/43 instructions, score None.
Retained the per-block form to preserve the target's cache-operation order.
The GPR-clearing trampoline cannot be expressed as ordinary portable C.
### BS2StartGame
1. Target-shaped nested error branches with empty polling loops: 96.48855%,
387/393 instructions. The compiler hoists reads out of unqualified polls.
2. Switch dispatch for disk/partition results: 94.18575%, 396/393 instructions.
3. Restored nested branches, used DVDGetCommandBlockStatus for the cover wait
and interrupt synchronization in low-level callback waits: 93.178116%,
406/393 instructions. This keeps polling functional without new volatile.
Compiler __sync/__isync intrinsics restore the real loader barriers without
adding asm functions or blocks. Final NAND callback ABI correction gives
95.496185%, 401/393. Calls and register scheduling still differ.
### BS2StartGCGame
1. Configuration/SRAM/MIOS implementation: 95.26755%, 228/228 instructions.
2. Reverse multiplication operands and pass the MIOS title as a real 64-bit
vararg, rather than unrelated 32-bit arguments: 95.4386%, 227/228.
3. Separate seconds/timerFrequency locals and use the DVD status API for the
cover wait: 98.11404%, 227/228. Retained this functional form. Differences
include the polling call, the target's additional MMIO read, and scheduling.
### BS2NANDDivideCallback
1. Update transferred count, advance buffer, and retain separate full/final
chunk paths: 85.03906%.
2. Cache the remaining length in a local shared across the paths: 70.859375%,
119/128. This changes allocation and removes more of the target's reloads.
3. Use typed file/buffer/completion globals and advance buffer before account
update: 85.0%. Final form retains the typed state but restores accounting
before buffer advance: 85.03906%, 119/128. Nine target instructions remain
missing, chiefly global reloads and callback setup ordering.
### BS2NANDDivideReadAsync
1. Original request setup order plus a total-length temporary: 60.31915%,
45/47. Two target reload instructions are absent.
2. Compare the stored total directly, removing the temporary: 60.31915%,
45/47. No improvement; optimizer produces the same sequence.
3. Typed request globals and file/buffer/length-first initialization:
60.29787%, 45/47. Retained readable typed state. Reloads and register/setup
order remain different.
### BS2NANDDivideWriteAsync
1. Original write setup plus total-length temporary: 60.31915%, 45/47.
2. Direct stored-length comparison: 60.31915%, 45/47; no instruction change.
3. Typed globals and file/buffer/length-first initialization: 60.29787%,
45/47. Same missing reloads and initialization scheduling as the read path.
### CheckBS2CommandStatus
1. Per-state cache write paths with shared result/exit: 79.655174%, 382/406.
2. Direct returns instead of shared goto exit: 79.655174%, 382/406. No change.
3. Compute the partition chunk length once from DVDGameTOC fields:
78.94089%. Final correct two-argument NAND callback notifications yield
80.133%, 387/406. Target retains repeated cache-length reloads, and setup
scheduling remains different. No volatile was added to manufacture them.
### BS2Tick
1. Complete switch in source-token order, typed fields and signed time checks:
74.99381%, 1896/1940. All 91 string contents match.
2. Four-byte title array, real partition iteration, correct layout global and
cover-block reset: 75.79124%, 1904/1940. All string offsets also match.
3. Region dispatch as readable switches and a forward ticket-byte scan:
75.50567%, 1906/1940. Retained the simpler switches and typed scan. Final
callback ABI/state cleanup gives 74.78608%, 1905/1940. Register allocation,
branch scheduling, and remaining reloads differ across many states.
## Fresh exact-function verification
- BS2ESGetTicketViews: 71/71 instructions, diffs 0.
- BS2Reboot: 137/137 instructions, diffs 0.
- CheckDVDCommandStatus: 102/102 instructions, diffs 0.
- BS2InquiryAsync: 39/39 instructions, diffs 0.
- BS2ReadDiskID: 39/39 instructions, diffs 0.
The original 16 exact functions remain exact. Final quick gate: 21/29 exact,
4052/16980 code bytes, 155504/158528 data bytes, zero regressions, zero forbidden
additions and zero readability warnings. The unit remains NonMatching.
Final full, non-quick gate: GATE PASS. Full build succeeds, main.dol SHA1 is
26116613f624061ba99c8d1a299aaa6efa85670d, regressions 0, forbidden additions 0,
readability warnings 0. No function or unit is claimed complete below 100%.

View File

@@ -0,0 +1,27 @@
# MyTiInputForm attempts
Unit: `src/keyboard/MyTiInputForm`, 4.3U only.
Implemented all 84 target functions, including the compiler-generated inheritance thunks, in object order. The original `ghidra_decomp.txt` contains no functions from this unit; implementation followed the extracted assembly and sibling headers.
The initial source had 42 instruction-exact functions. Correcting the guarded base layout with the existing font and six repeat counters brought objdiff to 73 functions. Ordinary string literals and the original animation records produced identical 29-string pools from the first build.
## Functions that required iteration
- `onCommandOnDispMode`: initially 143/130 instructions. Keeping the cursor line in a separate scalar until constructing the relation argument, qualifying the candidate calls, and passing command 14 directly reduced this to 130/130. Assigning the edit point fields individually removed the final floating-point scheduling differences. Exact.
- `InputForm::create`: initially 229/220 instructions. Removing redundant checks around placement new reduced this to 220/220. Correcting the GUI call to `setTriggerTarget(false)` fixed the last virtual-slot difference. Exact.
- `createAnimation`: initially 129/124 instructions with a cached animation pointer. Ordinary placement new reduced this to 123/124. Reloading the animation record through its table entry restored 124/124 with 22 differences. Moving the count variable outside the loop worsened allocation to 49 differences. Keeping the loop bound as `entry.count` and initializing each concrete pane's key type in its constructor produced zero differences. The base constructor is protected; both concrete constructors initialize the key type before use. Exact.
- `ScrollButton::create`: initially 160/154 instructions. Ordinary placement new and a signed animation ID corrected allocation checks and comparison instructions. Exact.
- `init`: initial fields were at wrong guarded layout offsets. After restoring the repeat fields, separate boolean and float assignments corrected store order; `updateCandidateState_()` corrected the virtual slot. Exact.
- `setScroll`: initially 9/10 instructions. Reading the stored scroll field when negating it preserved the original float rounding instruction. Exact.
- `calcCursorPos`: initially 69/68 instructions. Computing line height before the adjusted cursor Y removed the extra saved floating-point move. Exact.
- `open`: separate scroll-from and scroll-to stores fixed the last two differences. Exact.
- `setEditMode`: initially 57/51 instructions. Qualified candidate calls removed the extra virtual dispatch. Exact.
- `doAutoScroll`: initially 153/152 instructions. Casting the quotient to int before adding one restored the original conversion order and 152/152 instructions. Multiplication operand reversal and a named half-line value left one difference. Multiplying the line-height temporary in place removed it. Exact.
- `calc`: initial 624/629 instructions and a different frame layout. Explicit draw-size/position temporaries and VEC3 construction gave 626/629. A helper returning the transformed origin, with separate coordinate assignments, restored the packed VEC2 return and 629/629. Computing draw Y before setting pane size and expressing half-height separately reduced this to 14 differences. Guarding the rectangle member with its NW4R type and assigning the returned rectangle directly corrected ten stack offsets. Several half-height multiplication temporaries altered allocation without reaching exactness. Dividing the centered height differences by 2 and computing the lower edge in a named scalar removed every remaining difference. Exact: 629/629 instructions, diffs 0.
## Validation scope
The unit remains `NonMatching`. All original code functions match; data has separate unresolved differences and no linking claim is made. All shared-header changes are guarded by `MYTIINPUTFORM_IMPLEMENTATION`, defined only in this source file.
The default gate merge-base is `112e4e1a`, for which the supplied tools have no baseline report. Gates use the available parent snapshot explicitly: `--base 0aca3c76`. No supplied baseline or tool was edited. Regression checks against that snapshot remain zero.

View File

@@ -0,0 +1,93 @@
# NHTTP_thread leaf attempts
Target: Wii Menu 4.3U, libs/RevoEX/src/nhttp/NHTTP_thread.c.
Baseline: no source, 0/26 instruction-exact functions, 0/11292 matched code bytes,
0/504 matched data bytes. Implemented all 26 functions in object order using the
private nhttp structures. Other translation units and shared headers are unchanged.
Current: 23/26 instruction-exact functions, 8504/11292 matched code bytes,
88/504 matched data bytes. The eight-string .data pool is identical.
The unit remains NonMatching after a failed linking experiment.
## Remaining functions
### NHTTPi_RecvProxyConnectHeader: 99.92063%
126/126 instructions. Only the order of the two zero initializations differs:
source initializes r5 then r4; target initializes r4 then r5.
- Initial pointer/countdown scan: 90.2381%.
- Materialized communication buffer and a for loop: 96.74603%.
- Index-bounded scan: 98.690475%; pointer-end bound: 95.833336%.
- Declared request/response before the accepted flag: 99.44444%.
- Cursor declaration before index: 99.7619%; while-loop pointer increments:
99.92063%, retained.
- Initialized index before the end flag: still 99.92063%.
- Moved flag before cursor declarations: 99.24603%.
- Other scan declaration orders: 99.64286%, 99.32539%, 99.166664%.
- Inline header scan helper: 97.53968%, rejected and restored.
### NHTTPi_ThreadParseHeaderProc: 98.58639%
191/191 instructions. Differences remain in string-base and request registers,
and zero initialization/scheduling around the Keep-Alive comparison. There are
no missing branches or instructions in the retained version.
- Shared error label: 66.84293%; individual error returns: 85.125656%.
- Positive Content-Length branch first: 89.84293%.
- Positive header-value branches first: 94.84293%.
- Secure connection branch first, with all false assignments preserved:
98.03665%.
- Store computed chunked flag after its length branches: 98.58639%, retained.
- Default keepalive value before comparison, and declaration hoisting:
98.58639%, no improvement.
- Buffer declaration first: 98.50785%, rejected.
- Request declaration first: 98.58639%, no improvement.
### NHTTPi_ThreadRecvBodyProc: 99.1579%
379/380 instructions. Register assignment differs for system info, the chunk
count and the two-byte recent-character buffer. The ignored trailer-line return
lets the compiler reuse a zero-valued loop counter for scratch initialization;
the target emits a separate zero load. No undefined values are used.
- Initial implementation: 75.11053%.
- Half-open informational status range: 75.12631%.
- Incomplete fixed-length body branch first: 76.71842%.
- Hoisted chunk count: 76.86316%; scratch array scope variations: unchanged
or 76.71842%.
- Corrected Ghidra's apparent 64-bit chunk count to the assembly's 32-bit
count, and restored the consumed-byte return from the inline chunk-line
reader: 81.48421%.
- Positive chunk branch before zero-chunk trailers: 96.905266%.
- Handle end-of-stream success inside the receive loop: 99.1579%, retained.
- Unsigned recent-character local and function-scope recent array:
99.1579%, no improvement. Hoisted byte count: 98.07895%, rejected.
## Linking experiment
Temporarily changed only NHTTP_thread.c to Matching and built main.dol.
The final experiment produced SHA1 18abd4071ea17c4ef4708fa149dc479009c12b8d,
so configure.py was restored to NonMatching.
unitaudit.py reported 25 text symbols at their target addresses, with only the
following CommThreadProcMain shifted by -4. The next unit,
d_nhttp_private.c at 0x8149b390, and subsequent text also shifted by -4.
nm confirms the source .text is 11288 bytes, against 11292 target bytes.
The missing instruction is in ThreadRecvBodyProc.
The real named multipart string arrays were declared as ordinary const char
arrays. Source STR_POST_DISPOS starts at 0x0, STR_POST_TYPE_BIN at 0x28,
STR_POST_TYPE_URLENCODE at 0x74, and STR_POST_TYPE_MULTIPART at 0xa8. The target
object names these symbols at 0x0, 0x27, 0x74, and 0xa6. unitaudit reports
rodata deltas of 0, +1, and +2. Source section sizes are .data 194, .rodata 213,
.sdata 88; target sizes are .data 200, .rodata 216, .sdata 88. The pool's string
contents and offsets agree; section trailing alignment and named constant
boundaries still need investigation. No padding or address-pinning was added.
A byte comparison against orig/43U/00000008.app found 1305353 differing bytes,
first at file offset 0x5bb. Both files are 3867904 bytes. The text shift changes
relocated references outside this unit, so that count is not a count of local
instruction mismatches.
Final acceptance uses the full non-quick gate after restoring NonMatching.

View File

@@ -0,0 +1,82 @@
# SDChannelTitle attempts
Unit: `src/scene/sdChannelTitle/iplSDChannelTitle`, Wii Menu 4.3U.
All 69 original functions have C++ definitions. The source follows original object order;
the 55-string pool is identical. The unit remains NonMatching.
The default gate baseline `70970038` is absent from this checkout. Checks use the
available ancestor `e265d9664e73912f2dbf8dd02425f9dc64eac55b` through the gate's
supported `--base` option. Its unit baseline is zero instruction-exact functions.
## Initial remaining functions
| Function | Distinct source attempts | Final instruction evidence |
| --- | --- | --- |
| `calcFadein` | Reversed fade-playing branch; cached event-handler pointer; explicitly typed null callback; named fade-playing condition. The latter three all kept 48/47 instructions. | One extra `li r5,0` for the declared unused second `SDButton::setEventHandler` argument. |
| `initCalcFadeout` | Cached empty handler (50/49); explicitly typed null arguments (50/49); reloaded SDButton directly at cleanup (54/49, reverted). | One extra `li r5,0` for the same unused argument. |
| `813E6CCC` | Combined positive early-return guards corrected the final animation branch; passed the actual title-range output pointer; cached title halves (89/86); cached selector (88/86); named enqueue result (87/86). Reverted the latter three. | 87/86; explicit ignored controller argument adds `li r4,0`; call setup also schedules differently. |
| `813E6E24` | Explicit range copies replaced reference-only arguments; reversed usage-enough branch; combined positive early-return guards; named copied ranges and cached memory receiver; reversed copy declaration order and original range declaration order. Named copies produced 6, 8, or 9 differing instructions; restored temporary copies. | 95/95; five differences in copy-load register selection and receiver/argument setup order. |
| `813E7074` | Reversed title comparison operands and copied-title branch; cached title halves (77/76); cached selector (77/76); named enqueue result (77/76). Reverted the latter three. | 77/76; explicit ignored controller argument adds `li r4,0`, with argument-move ordering differing. |
| `813E8A20` | Supplied page/index output locals to `hasChannel`; stored the SD previous page through a scoped inline setter; evaluated save heap separately; used a scoped reference accessor instead of the setter. | 37/37; six register/load-order differences around save-manager and heap access. |
## Resolved iterations
Constructor, destructor/thunk, layout creation, common calculation, normal calculation,
fadeout calculation, drawing, destruction, reset checks and most state handlers now
match instruction-exactly. Notable successful source changes were:
- Original function order and event-case order restored all pooled strings.
- Explicit nullable-file checks reproduced virtual-destructor branches.
- Dialog last-result access corrected offset 0x24.
- Arrow visibility access used the real byte at offset 0x81.
- Text-pane names used a normal pointer table instead of direct literals.
- Named pane-handler and text-box temporaries restored allocation/call order.
- Script-data aggregate initialization and a real low-title-ID mask restored 120/120 instructions.
- Script-state heap-index temporary restored register selection.
- Separate result switch cases preserved the original dispatch tree.
- Event switches and a hover-count reference restored both event handlers.
- Combined positive early-return scene-state checks restored script calculation (66/66).
- Named capture-dimension table restored the full .rodata section.
- Fadeout used two-byte maker-code access and separately timed vector construction.
## Layout and interface uncertainties
The 0x800 bytes following the title-range output are preserved as opaque scene work
storage; their internal type is not recovered. This is instance layout, not linker padding.
The embedded SDMemory's original following-member offset requires size 0x2a78; its
existing header's unused 16-byte tail is excluded only for this translation unit.
The original nonconst `isResetAcceptable` symbol differs from Base's existing const
virtual declaration. This needs review before linking. The event handler classes use
ordinary forwarding virtual methods, whose weak metadata may differ from the original.
The original extracted object's weak data can be zero-filled after linker deduplication;
no artificial data or force-active workaround was added.
The two notice APIs declare an ignored controller argument that the target callers do
not initialize. The source supplies zero rather than depending on an uninitialized value.
The title-range output pointer is passed as the fourth channel-notice argument.
## Continuation from merged main
Starting main: `fcb5be85f76b17b4341b6868b768f22ded14f8e7`.
Its gate baseline became available during this continuation, so the final check uses
ordinary `origin/main`, with 63/69 exact functions and 17064/18624 matched code bytes.
`813E6E24` now has 95/95 instructions and zero differences. An inline helper takes
both title ranges by value, preserving the copies while evaluating the memory receiver
before their loads. This changes no other translation unit and adds no out-of-line helper.
The string pool remains identical.
Fresh attempts for every function still open:
| Function | Attempt 1 | Attempt 2 | Attempt 3 | Retained result |
| --- | --- | --- | --- | --- |
| `813E8A20` | Cached save manager through the flush: 36/37 instructions, missing reload. | Named previous-page reference: 37/37, same six differences. | Read save heap before the page store: 37/37, reordered loads and six differences. | Original 37/37, six register/load-order differences. Also tried guarded direct field access and an inline save-page helper; neither improved it. |
| `calcFadein` | Scoped inline SDButton method body: 51/47, virtual call expanded. | Scoped inline body with NO_INLINE: 48/47, null callback argument remains. | Scoped inline body using a named gui-manager receiver: 51/47, same expanded virtual call. | Original 48/47; all header trials reverted. |
| `initCalcFadeout` | Scoped inline SDButton method body: 52/49, virtual call expanded. | Scoped inline body with NO_INLINE: 50/49, null callback argument remains. | Scoped inline body using a named gui-manager receiver: 52/49, same expanded virtual call. | Original 50/49; all header trials reverted. |
| `813E6CCC` | Inline notice wrapper with title ID and range parameters: 87/86, unchanged call setup. | Title-ID union with named words: 91/86, extra stores and loads. | Named enqueue result and failure early return: 87/86, result branches also differed. | Original 87/86; extra ignored-controller initialization and argument setup differences. |
| `813E7074` | Inline notice wrapper with title ID and state parameters: 77/76, unchanged. | Title-ID union with named words: 77/76, worse register and stack allocation. | Named enqueue result and failure early return: 77/76, result branches also differed. | Original 77/76; extra ignored-controller initialization and argument move order. |
All unsuccessful source and shared-header trials were reverted. The retained source
change is the by-value range helper and its call. The unit remains NonMatching because
five functions still differ; the condition for trying a Matching link has not been reached.

View File

@@ -0,0 +1,216 @@
# PC keyboard attempts
Target: 43U, src/keyboard/tiPcKeyboard. Initial baseline: no source, 0 instruction-exact functions, 0 code/data bytes.
All trials below rebuild only this object. The retained source uses ordinary literals; shared declarations are guarded by TI_PC_KEYBOARD_IMPLEMENTATION. NonMatching remains unchanged.
## textinput::keyboard::pctype::Base::onActive()
Initial: objdiff 82.42857, instructions (133, 119), differing positions 73.
1. use a named KeyState reference: objdiff 82.42857, instructions (133, 119), differing positions 73, pool identical; reverted.
2. separate local declarations and assignments: objdiff 82.42857, instructions (133, 119), differing positions 73, pool identical; reverted.
3. reverse the first if/else direction and exchange its bodies: objdiff 72.27731, instructions (133, 119), differing positions 90, pool identical; reverted.
## textinput::keyboard::pctype::Base::getWCCode(char*)
Initial: objdiff None, instructions (56, 2), differing positions 56.
1. use a named KeyState reference: objdiff None, instructions (56, 2), differing positions 56, pool identical; reverted.
2. hold the returned character in a named local: objdiff None, instructions (56, 2), differing positions 56, pool identical; reverted.
3. use a named KeyState pointer: objdiff None, instructions (56, 2), differing positions 56, pool identical; reverted.
## textinput::keyboard::pctype::Base::getControlKey(char*)
Initial: objdiff 93.333336, instructions (36, 36), differing positions 8.
1. use a named KeyState reference: objdiff 93.333336, instructions (36, 36), differing positions 8, pool identical; reverted.
2. rewrite the first for loop as while with explicit update: objdiff 93.333336, instructions (36, 36), differing positions 8, pool identical; reverted.
3. use a named KeyState pointer: objdiff 93.333336, instructions (36, 36), differing positions 8, pool identical; reverted.
## textinput::keyboard::pctype::Base::sendInputWChar(wchar_t, bool)
Initial: objdiff 98.24074, instructions (107, 108), differing positions 104.
1. use a named KeyState reference: objdiff 94.75, instructions (108, 108), differing positions 26, pool identical; reverted.
2. separate local declarations and assignments: objdiff 98.24074, instructions (107, 108), differing positions 104, pool identical; reverted.
3. use a named KeyState pointer: objdiff 94.75, instructions (108, 108), differing positions 26, pool identical; reverted.
## textinput::keyboard::pctype::Base::updateFixMode()
Initial: objdiff 98.166664, instructions (59, 60), differing positions 32.
1. use a named KeyState reference: objdiff 98.166664, instructions (59, 60), differing positions 32, pool identical; reverted.
2. separate local declarations and assignments: objdiff 98.166664, instructions (59, 60), differing positions 32, pool identical; reverted.
3. use a named KeyState pointer: objdiff 98.166664, instructions (59, 60), differing positions 32, pool identical; reverted.
## textinput::keyboard::pctype::Base::setTranslateMode(textinput::keyboard::pctype::Base::TranslateMode)
Initial: objdiff 98.0, instructions (107, 105), differing positions 89.
1. use a named KeyState reference: objdiff 93.190475, instructions (110, 105), differing positions 103, pool identical; reverted.
2. separate local declarations and assignments: objdiff 98.0, instructions (107, 105), differing positions 89, pool identical; reverted.
3. use a named KeyState pointer: objdiff 93.190475, instructions (110, 105), differing positions 103, pool identical; reverted.
## textinput::keyboard::pctype::Base::KeyState::refresh_()
Initial: objdiff 98.77095, instructions (177, 179), differing positions 152.
1. access members through a named owner pointer: objdiff 98.77095, instructions (177, 179), differing positions 152, pool identical; reverted.
2. reverse the first if/else direction and exchange its bodies: objdiff 84.03911, instructions (177, 179), differing positions 152, pool identical; reverted.
3. hold the switch selector in a named signed local: objdiff 98.77095, instructions (177, 179), differing positions 152, pool identical; reverted.
## textinput::keyboard::pctype::Base::KeyState::refreshText(nw4r::lyt::Pane*)
Initial: objdiff 90.46154, instructions (170, 169), differing positions 107.
1. access members through a named owner pointer: objdiff 90.46154, instructions (170, 169), differing positions 107, pool identical; reverted.
2. rewrite the first for loop as while with explicit update: objdiff 90.46154, instructions (170, 169), differing positions 107, pool identical; reverted.
3. use a 32-bit unsigned loop index: objdiff 83.83432, instructions (170, 169), differing positions 160, pool identical; reverted.
## textinput::keyboard::pctype::Base::KeyState::getWCCode(unsigned long)
Initial: objdiff 98.8, instructions (124, 125), differing positions 109.
1. access members through a named owner pointer: objdiff 98.8, instructions (124, 125), differing positions 109, pool identical; reverted.
2. separate local declarations and assignments: objdiff 98.8, instructions (124, 125), differing positions 109, pool identical; reverted.
3. hold the returned character in a named local: compiler rejected the variant; retained original.
## textinput::keyboard::pctype::Base::KeyState::getWCCode(char*)
Initial: objdiff 96.14035, instructions (56, 57), differing positions 18.
1. access members through a named owner pointer: objdiff 96.14035, instructions (56, 57), differing positions 18, pool identical; reverted.
2. separate local declarations and assignments: objdiff 96.14035, instructions (56, 57), differing positions 18, pool identical; reverted.
3. rewrite the first for loop as while with explicit update: objdiff 96.14035, instructions (56, 57), differing positions 18, pool identical; reverted.
## textinput::keyboard::pctype::LayoutByNW4R::create(MEMAllocator*)
Initial: objdiff 87.49367, instructions (151, 158), differing positions 106.
1. use a named KeyState reference: objdiff 87.49367, instructions (151, 158), differing positions 106, pool identical; reverted.
2. separate local declarations and assignments: objdiff 87.49367, instructions (151, 158), differing positions 106, pool identical; reverted.
3. use a named KeyState pointer: objdiff 87.49367, instructions (151, 158), differing positions 106, pool identical; reverted.
## textinput::keyboard::pctype::LayoutByNW4R::createAnmPane_(MEMAllocator*)
Initial: objdiff 98.515625, instructions (192, 192), differing positions 55.
1. access members through a named owner pointer: objdiff 98.515625, instructions (192, 192), differing positions 55, pool identical; reverted.
2. separate local declarations and assignments: objdiff 98.515625, instructions (192, 192), differing positions 55, pool identical; reverted.
3. rewrite the first for loop as while with explicit update: objdiff 98.515625, instructions (192, 192), differing positions 55, pool identical; reverted.
## textinput::keyboard::pctype::LayoutByNW4R::init()
Initial: objdiff 75.89773, instructions (280, 352), differing positions 336.
1. access members through a named owner pointer: objdiff 75.89773, instructions (280, 352), differing positions 336, pool identical; reverted.
2. use a 32-bit unsigned loop index: objdiff 72.02841, instructions (275, 352), differing positions 347, pool identical; reverted.
3. express a conditional call with a short circuit expression: compiler rejected the variant; retained original.
## textinput::keyboard::pctype::LayoutByNW4R::initLayout()
Initial: objdiff 99.71429, instructions (384, 385), differing positions 66.
1. use a named KeyState reference: objdiff 99.71429, instructions (384, 385), differing positions 66, pool identical; reverted.
2. reverse the first if/else direction and exchange its bodies: objdiff 99.69091, instructions (384, 385), differing positions 71, pool identical; reverted.
3. use a named KeyState pointer: objdiff 99.71429, instructions (384, 385), differing positions 66, pool identical; reverted.
## textinput::keyboard::pctype::LayoutByNW4R::onPressedShift(bool)
Initial: objdiff 90.81633, instructions (45, 49), differing positions 42.
1. use a named KeyState reference: objdiff 90.81633, instructions (45, 49), differing positions 42, pool identical; reverted.
2. use a named KeyState pointer: objdiff 90.81633, instructions (45, 49), differing positions 42, pool identical; reverted.
3. access state through a named Base view: compiler rejected the variant; retained original.
## textinput::keyboard::pctype::LayoutByNW4R::onReleasedShift()
Initial: objdiff 89.871796, instructions (38, 39), differing positions 36.
1. use a named KeyState reference: objdiff 89.871796, instructions (38, 39), differing positions 36, pool identical; reverted.
2. use a named KeyState pointer: objdiff 89.871796, instructions (38, 39), differing positions 36, pool identical; reverted.
3. access state through a named Base view: compiler rejected the variant; retained original.
## textinput::keyboard::pctype::LayoutByNW4R::onKey(unsigned long, void*)
Initial: objdiff 66.72967, instructions (341, 418), differing positions 373.
1. use a named KeyState reference: objdiff 63.64593, instructions (338, 418), differing positions 408, pool identical; reverted.
2. use a named KeyState pointer: objdiff 63.64593, instructions (338, 418), differing positions 408, pool identical; reverted.
3. hold the switch selector in a named signed local: objdiff 66.72967, instructions (341, 418), differing positions 373, pool identical; reverted.
## textinput::keyboard::pctype::LayoutByNW4R::updateFromReceiver(unsigned long, void*)
Initial: objdiff 94.51613, instructions (30, 31), differing positions 16.
## textinput::keyboard::pctype::LayoutByNW4R::cancelStateFocusIn()
Initial: objdiff 60.854168, instructions (144, 144), differing positions 69.
1. access members through a named owner pointer: objdiff 60.854168, instructions (144, 144), differing positions 69, pool identical; reverted.
2. rewrite the first for loop as while with explicit update: objdiff 60.854168, instructions (144, 144), differing positions 69, pool identical; reverted.
3. hold the switch selector in a named signed local: objdiff 60.854168, instructions (144, 144), differing positions 69, pool identical; reverted.
## textinput::keyboard::pctype::LayoutByNW4R::sendInputWChar(wchar_t, bool)
Initial: objdiff 93.97727, instructions (42, 44), differing positions 35.
1. use a named KeyState reference: objdiff 93.97727, instructions (42, 44), differing positions 35, pool identical; reverted.
2. separate local declarations and assignments: objdiff 93.97727, instructions (42, 44), differing positions 35, pool identical; reverted.
3. use a named KeyState pointer: objdiff 93.97727, instructions (42, 44), differing positions 35, pool identical; reverted.
## textinput::keyboard::pctype::LayoutByNW4R::setInputModeJP(bool, unsigned long, unsigned long)
Initial: objdiff 86.92208, instructions (69, 77), differing positions 36.
1. use a named KeyState reference: objdiff 79.96104, instructions (72, 77), differing positions 71, pool identical; reverted.
2. use a named KeyState pointer: objdiff 79.96104, instructions (72, 77), differing positions 71, pool identical; reverted.
3. hold the switch selector in a named signed local: objdiff 86.92208, instructions (69, 77), differing positions 36, pool identical; reverted.
## textinput::keyboard::pctype::LayoutByNW4R::updateInput(int, float, float, unsigned long, unsigned long, unsigned long, void*)
Initial: objdiff 60.17143, instructions (135, 140), differing positions 101.
1. separate local declarations and assignments: objdiff 60.17143, instructions (135, 140), differing positions 101, pool identical; reverted.
2. reverse the first if/else direction and exchange its bodies: objdiff 95.25, instructions (135, 140), differing positions 92, pool identical; retained.
3. express a conditional call with a short circuit expression: objdiff 88.96429, instructions (140, 140), differing positions 59, pool identical; reverted.
## textinput::keyboard::pctype::LayoutByNW4R::updateInput(textinput::input::HKBManager&)
Initial: objdiff 84.687225, instructions (237, 227), differing positions 219.
1. access members through a named owner pointer: objdiff 84.687225, instructions (237, 227), differing positions 219, pool identical; reverted.
2. separate local declarations and assignments: objdiff 84.687225, instructions (237, 227), differing positions 219, pool identical; reverted.
3. reverse the first if/else direction and exchange its bodies: objdiff 74.48458, instructions (237, 227), differing positions 219, pool identical; reverted.
## textinput::keyboard::pctype::EventHandler::onTiEvent(textinput::gui::PaneComponent*, unsigned long, textinput::nw4rmanager::TiEventHandler::Input*)
Initial: objdiff 88.83249, instructions (196, 197), differing positions 176.
1. access members through a named owner pointer: objdiff 88.83249, instructions (196, 197), differing positions 176, pool identical; reverted.
2. separate local declarations and assignments: objdiff 88.83249, instructions (196, 197), differing positions 176, pool identical; reverted.
3. hold the switch selector in a named signed local: objdiff 88.83249, instructions (196, 197), differing positions 176, pool identical; reverted.
## @236@onEvent__Q49textinput8keyboard6pctype12LayoutByNW4RFPQ49textinput8keyboard6pctype5
The extracted target thunk name is truncated; MWCC emits the complete canonical C++ name. Symbol metadata was left unchanged.
1. early return for unrelated events: objdiff None, canonical thunk instructions 2/2, differing positions 0; target name remains absent. Reverted.
2. signed switch for listener events: objdiff None, canonical thunk instructions 2/2, differing positions 0; target name remains absent. Reverted.
3. named sound identifier before dispatch: objdiff None, canonical thunk instructions 2/2, differing positions 0; target name remains absent. Reverted.
Additional trial for textinput::keyboard::pctype::Base::KeyState::getWCCode(unsigned long): copy the final mapped character into a distinct return local; objdiff 98.8, instructions (124, 125), differing positions 109; reverted.
Additional trial for textinput::keyboard::pctype::LayoutByNW4R::init(): use mutable local vectors for the mode-selector positions; objdiff 75.89773, instructions (280, 352), differing positions 336; reverted.
## Final evidence
Clean full gate: GATE PASS. DOL SHA1: 26116613f624061ba99c8d1a299aaa6efa85670d. Regressions, forbidden additions, readability warnings: 0. Pool: 204/204 identical.
Instruction-exact 0 -> 120/141; objdiff code 0 -> 16240/28484; data 0 -> 5964/18564. .rodata: 100%; unit remains NonMatching.
Additional retained refinements: merge address-taken boolean command values in Base::onActive using typed single-field command structs (119/119 instructions, diffs 0); use signed switch dispatch in updateFromReceiver and updateFixMode (31/31 and 60/60, diffs 0); restore cancelStateFocusIn switch case order (144/144, diffs 0); restore normal/shift/toggle/onoff creation order (192/192, register differences remain); put ordinary Korean lookup tables after animation data (.rodata 100%).
The protected default branch in Base::setTranslateMode returns for invalid enum values. The original appears to use an unset temporary outside 0..2; this implementation deliberately retains defined behavior.
textinput::keyboard::pctype::Base::getWCCode(char*): objdiff None; src 0xe0 base 0x8 insns 56/2 | --- replace mine 0:56 base 0:2 | M 0 stwu r1, -0x20(r1) | M 1 mflr r0
textinput::keyboard::pctype::Base::getControlKey(char*): objdiff 93.333336; src 0x90 base 0x90 insns 36/36 | diffs 8: [4, 5, 10, 12, 15, 21, 24, 25] | 4 M stw r30, 0x18(r1) | B li r31, 0
textinput::keyboard::pctype::Base::sendInputWChar(wchar_t, bool): objdiff 98.24074; src 0x1ac base 0x1b0 insns 107/108 | --- insert mine 4:4 base 4:5 | B 4 li r0, 0 | --- replace mine 10:11 base 11:12
textinput::keyboard::pctype::Base::setTranslateMode(textinput::keyboard::pctype::Base::TranslateMode): objdiff 98.0; src 0x1ac base 0x1a4 insns 107/105 | --- replace mine 13:14 base 13:14 | M 13 b 348 | B 13 b 36
textinput::keyboard::pctype::Base::KeyState::refresh_(): objdiff 98.77095; src 0x2c4 base 0x2cc insns 177/179 | --- replace mine 26:27 base 26:27 | M 26 bgt 48 | B 26 bgt 56
textinput::keyboard::pctype::Base::KeyState::refreshText(nw4r::lyt::Pane*): objdiff 90.46154; src 0x2a8 base 0x2a4 insns 170/169 | --- replace mine 50:52 base 50:51 | M 50 beq 192 | M 51 stw r25, 0xc(r1)
textinput::keyboard::pctype::Base::KeyState::getWCCode(unsigned long): objdiff 98.8; src 0x1f0 base 0x1f4 insns 124/125 | --- replace mine 2:3 base 2:3 | M 2 li r8, 0 | B 2 li r7, 0
textinput::keyboard::pctype::Base::KeyState::getWCCode(char*): objdiff 96.14035; src 0xe0 base 0xe4 insns 56/57 | --- replace mine 34:35 base 34:35 | M 34 beq 48 | B 34 beq 52
textinput::keyboard::pctype::LayoutByNW4R::create(MEMAllocator*): objdiff 87.49367; src 0x25c base 0x278 insns 151/158 | --- replace mine 42:43 base 42:45 | M 42 mr r29, r31 | B 42 mr r26, r31
textinput::keyboard::pctype::LayoutByNW4R::createAnmPane_(MEMAllocator*): objdiff 98.515625; src 0x300 base 0x300 insns 192/192 | diffs 55: [19, 22, 23, 24, 40, 44, 48, 50, 51, 52, 53, 55, 56, 57, 63, 67, 71, 73, 74, 75] | 19 M li r22, 0 | B li r21, 0
textinput::keyboard::pctype::LayoutByNW4R::init(): objdiff 75.89773; src 0x460 base 0x580 insns 280/352 | --- replace mine 0:1 base 0:1 | M 0 stwu r1, -0x40(r1) | B 0 stwu r1, -0x60(r1)
textinput::keyboard::pctype::LayoutByNW4R::initLayout(): objdiff 99.71429; src 0x600 base 0x604 insns 384/385 | --- replace mine 317:318 base 317:318 | M 317 bne 196 | B 317 bne 200
textinput::keyboard::pctype::LayoutByNW4R::onPressedShift(bool): objdiff 90.81633; src 0xb4 base 0xc4 insns 45/49 | --- insert mine 7:7 base 7:8 | B 7 lwz r0, 0x20(r3) | --- replace mine 8:11 base 9:13
textinput::keyboard::pctype::LayoutByNW4R::onReleasedShift(): objdiff 89.871796; src 0x98 base 0x9c insns 38/39 | --- delete mine 3:4 base 3:3 | M 3 li r0, -0x90 | --- replace mine 6:9 base 5:10
textinput::keyboard::pctype::LayoutByNW4R::onKey(unsigned long, void*): objdiff 66.72967; src 0x554 base 0x688 insns 341/418 | --- replace mine 18:19 base 18:19 | M 18 bne 1244 | B 18 bne 1552
textinput::keyboard::pctype::LayoutByNW4R::sendInputWChar(wchar_t, bool): objdiff 93.97727; src 0xa8 base 0xb0 insns 42/44 | --- replace mine 9:10 base 9:11 | M 9 rlwinm. r31, r0, 0x19, 0x1f, 0x1f | B 9 rlwinm. r0, r0, 0, 0x18, 0x18
textinput::keyboard::pctype::LayoutByNW4R::setInputModeJP(bool, unsigned long, unsigned long): objdiff 86.92208; src 0x114 base 0x134 insns 69/77 | --- insert mine 31:31 base 31:34 | B 31 cmpwi r30, 1 | B 32 beq 76
textinput::keyboard::pctype::LayoutByNW4R::updateInput(int, float, float, unsigned long, unsigned long, unsigned long, void*): objdiff 95.25; src 0x21c base 0x230 insns 135/140 | --- replace mine 33:34 base 33:34 | M 33 beq 196 | B 33 beq 212
textinput::keyboard::pctype::LayoutByNW4R::updateInput(textinput::input::HKBManager&): objdiff 84.687225; src 0x3b4 base 0x38c insns 237/227 | --- replace mine 0:1 base 0:1 | M 0 stwu r1, -0x70(r1) | B 0 stwu r1, -0x60(r1)
textinput::keyboard::pctype::EventHandler::onTiEvent(textinput::gui::PaneComponent*, unsigned long, textinput::nw4rmanager::TiEventHandler::Input*): objdiff 88.83249; src 0x310 base 0x314 insns 196/197 | --- replace mine 17:18 base 17:18 | M 17 bne 692 | B 17 bne 696
@236@onEvent__Q49textinput8keyboard6pctype12LayoutByNW4RFPQ49textinput8keyboard6pctype5: objdiff None; target name absent; canonical thunk name differs

View File

@@ -0,0 +1,95 @@
# zi81key attempts
43U only. Baseline source absent; 0 of 9 exact functions, 0 of 21460 code bytes, 0 of 1388 data bytes.
Created the source from target assembly, the shared eZiText types, and prior decompiler scratch under /tmp. Removed the scratch source's volatile tone and parameter-storage padding. Replaced raw parameter/work offsets with local ABI structs, recovered readable local names, and retained all nine real functions in object order. Shared headers and other translation units were unchanged.
The local parameter ABI has result bytes at 0x20, 0x21, 0x22, scratch at 0x24, and a final workspace slot at 0x28. Unobserved work/options fields remain opaque. The shared ziGetParam differs from this observed ABI, so this unit uses its own struct.
Pool checked before compiler experiments: zero strings on either side, identical. All spelling tables and the search-order constant match their target data.
## Exact functions
Zi8IsMatch1Key: 97/97 instructions, diffs 0.
Zi8SetFindCand: 50/50 instructions, diffs 0.
ZiIsSupportedPhonetic: 81/81 instructions, diffs 0.
Zi8ZHCheckSpelling: initially 419/419 instructions with six frame-size differences. Restored the target's 64-character conversion buffer instead of the scratch source's 72-character array. Final 419/419 instructions, diffs 0.
## Remaining functions
Zi8SpellingZY | row pointer | src 0x1dc base 0x1ec insns 119/123 | --- replace mine 1:5 base 1:5
Zi8SpellingZY | reorder decoded components | src 0x1ec base 0x1ec insns 123/123 | diffs 6: [27, 28, 35, 36, 37, 38]
Zi8SpellingZY | typed length and key | src 0x21c base 0x1ec insns 135/123 | --- delete mine 7:8 base 7:7
Zi8SpellingPY | decode tone at use | src 0x268 base 0x274 insns 154/157 | --- insert mine 11:11 base 11:14
Zi8SpellingPY | byte length | src 0x2ac base 0x274 insns 171/157 | --- delete mine 4:5 base 4:4
Zi8SpellingPY | for spelling scans | src 0x278 base 0x274 insns 158/157 | --- delete mine 4:5 base 4:4
MatchAltSound1Key | short phonetic offset | src 0x564 base 0x554 insns 345/341 | --- replace mine 10:11 base 10:11
MatchAltSound1Key | unsigned record positions | src 0x53c base 0x554 insns 335/341 | --- replace mine 10:11 base 10:11
MatchAltSound1Key | signed key byte decode | src 0x54c base 0x554 insns 339/341 | --- replace mine 10:11 base 10:11
Zi8Get1KeyPressSpelling | reverse charset branch nesting | src 0x18bc base 0x1a90 insns 1583/1700 | --- replace mine 0:1 base 0:1
Zi8Get1KeyPressSpelling | return immediately on zero spelling limit | src 0x18e0 base 0x1a90 insns 1592/1700 | --- replace mine 0:1 base 0:1
Zi8Get1KeyPressSpelling | declare scan index before flags | src 0x18dc base 0x1a90 insns 1591/1700 | --- replace mine 0:1 base 0:1
Zi8Get1KeyPressCandidates | declare index before flags | src 0x2b7c base 0x2574 insns 2783/2397 | --- replace mine 0:1 base 0:1
Zi8Get1KeyPressCandidates | preserve signed character temporaries | src 0x2bac base 0x2574 insns 2795/2397 | --- replace mine 0:1 base 0:1
Zi8Get1KeyPressCandidates | postincrement initial input index | src 0x2b78 base 0x2574 insns 2782/2397 | --- replace mine 0:1 base 0:1
Zi8SpellingZY retains six register-choice differences at instructions 27, 28, 35, 36, 37, 38; its 123 instruction count is correct.
Zi8SpellingPY retains a register-held tone rather than the original stack tone, an extra saved register, and table-address register differences. Retained the ordinary non-volatile scalar rather than forcing a spill.
MatchAltSound1Key retains search/register and table-load ordering differences, 339/341 instructions. All three variants were rejected and the readable baseline was restored.
Zi8Get1KeyPressSpelling still differs in branch structure, automatic-variable allocation, and table access sequences. Fixed signedness of expansion count, subtype constants, and result byte offset after inspecting assembly. Final 1572/1700 instructions. No artificial register or stack constraints were used.
Zi8Get1KeyPressCandidates still differs in branch structure, automatic-variable allocation, and record access sequences. Recovered explicit includeTone/matchFull variables and the key-index decrement from assembly, corrected unsigned key comparisons, restored the target's 64-character word buffer, removed pointer/integer round trips, and retained the initial index postincrement variant. Final 2775/2397 instructions.
## Linking investigation
Temporarily switched only zi81key to Matching and built main.dol. It linked successfully but failed the required SHA1. Ran unitaudit.py, nm -n on both objects, and a full byte comparison with orig/43U/00000008.app.
Original/linked bytes: 3867904/3867904.
Linked SHA1: 003260ba28d079e13eab29ec2fce03bfd2c7d810.
First differing DOL byte: 0x5ba. Differing bytes: 2042540.
build/43U/obj/libs/RVLMiddleware/eZiText/src/clib/zi81key.o: text 0x53d4
Zi8IsMatch1Key: offset 0x460, size 0x184.
Zi8Get1KeyPressSpelling: offset 0xd44, size 0x1a90.
Zi8Get1KeyPressCandidates: offset 0x27d4, size 0x2574.
Zi8ZHCheckSpelling: offset 0x4d48, size 0x68c.
build/43U/src/libs/RVLMiddleware/eZiText/src/clib/zi81key.o: text 0x57b8
Zi8IsMatch1Key: offset 0x464, size 0x184.
Zi8Get1KeyPressSpelling: offset 0xd40, size 0x1890.
Zi8Get1KeyPressCandidates: offset 0x25d0, size 0x2b5c.
Zi8ZHCheckSpelling: offset 0x512c, size 0x68c.
Next unit Zi8SetParentalControls linked at 0x814655b0; target 0x814651cc; displacement +0x3e4.
INTERNAL .text 0x8145fdf8 libs/RVLMiddleware/eZiText/src/clib/zi81key.c {0: 2, 4: 2, -4: 2, -516: 1}
STEP .text 0x814651cc libs/RVLMiddleware/eZiText/src/clib/zi8alpha.c +0x0->+0x3e4 (prev unit libs/RVLMiddleware/eZiText/src/clib/zi81key.c)
The four exact functions do not make the whole unit linkable. Restored NonMatching in configure.py. The final full gate rebuilds the unlinked object and checks the original DOL hash, zero regressions, pool, forbidden patterns, and readability.
The meanings of opaque work/options members and the final workspace slot are not fully recovered. The large candidate/spelling routines remain a partial reconstruction; their fuzzy scores are not acceptance evidence.
## Final full gate
```text
full build: ok
main.dol sha1: 26116613f624061ba99c8d1a299aaa6efa85670d
[libs/RVLMiddleware/eZiText/src/clib/zi81key] pool: IDENTICAL
[libs/RVLMiddleware/eZiText/src/clib/zi81key] objdiff: code 2588/21460 data 1160/1388 functions 4/9 fuzzy 66.2913 linked code 0
[libs/RVLMiddleware/eZiText/src/clib/zi81key] instruction-exact functions: 4/9
[libs/RVLMiddleware/eZiText/src/clib/zi81key] section .data size 48 match None
[libs/RVLMiddleware/eZiText/src/clib/zi81key] section .rodata size 1152 match 100.0
[libs/RVLMiddleware/eZiText/src/clib/zi81key] section .sdata2 size 8 match 100.0
[libs/RVLMiddleware/eZiText/src/clib/zi81key] section .text size 21460 match 66.291336
[libs/RVLMiddleware/eZiText/src/clib/zi81key] section extab size 72 match 97.22222
[libs/RVLMiddleware/eZiText/src/clib/zi81key] section extabindex size 108 match 95.37037
[libs/RVLMiddleware/eZiText/src/clib/zi81key] below 100: Zi8SpellingZY 99.756096
[libs/RVLMiddleware/eZiText/src/clib/zi81key] below 100: Zi8SpellingPY 97.038216
[libs/RVLMiddleware/eZiText/src/clib/zi81key] below 100: MatchAltSound1Key 95.60117
[libs/RVLMiddleware/eZiText/src/clib/zi81key] below 100: Zi8Get1KeyPressSpelling 59.97
[libs/RVLMiddleware/eZiText/src/clib/zi81key] below 100: Zi8Get1KeyPressCandidates 53.775135
[libs/RVLMiddleware/eZiText/src/clib/zi81key] baseline: code None/21460 data None functions 0 fuzzy 0.0000
regressions vs baseline: 0
global matched_code_percent: 69.56702 -> 69.65343
global fuzzy_match_percent: 77.05006 -> 77.52503
global complete_code_percent: 56.50306 -> 56.50306
global matched_data_percent: 85.57046 -> 85.63375
forbidden patterns added (net, per file): 0
readability warnings (net, per file; must be 0 in the final result): 0
GATE PASS
```

View File

@@ -0,0 +1,83 @@
# zi8alpha attempts
Target: Wii Menu 4.3U, libs/RVLMiddleware/eZiText/src/clib/zi8alpha.
Baseline: e265d966, the nearest ancestor with an existing gate baseline. The
worktree's initial 70970038 merge-base has no baseline file. No branch changes
or baseline edits were made.
Ten functions are instruction-exact. Both remaining functions have at least
three distinct source-level attempts. The unit remains NonMatching.
## Zi8ChangeWordCase
1. Typed workspace argument and integer case selector: 44/44 instructions,
11 differences, all register assignments involving the word and workspace.
2. Local word cursor copied from the input argument: 45/44 instructions,
with an extra input spill. Rejected.
3. Void workspace argument accessed through the workspace structure: 44/44
instructions, eight differences involving r29/r30 for the case selector
and workspace. Final objdiff 99.09091%.
4. Tried a local workspace pointer, byte/short/long case selector types, and
an explicit lower/upper case enum. None removed the remaining register
differences. Kept the enum and void workspace argument.
## Zi8AlphaGetCandidates
1. Recovered the complete control flow, workspace fields, dictionary selection,
candidate emission, prefix/suffix handling, case conversion, and punctuation
from object decompilation and target assembly. Named the locals and replaced
byte-offset memory accesses with structure fields and array indexing.
4436/3946 instructions, frame 0x340 versus 0x2B0, objdiff 41.21566%.
2. Corrected the byte/halfword flag types, unsigned punctuation comparisons,
and workspace/options argument handling. Initialized the dictionary index
used by the early punctuation exit. 4399/3946 instructions, frame 0x330,
objdiff 43.85555%.
3. Recovered typed external function declarations and return widths rather
than leaving calls with unspecified argument types. 4452/3946 instructions,
frame 0x330, objdiff 44.43614%.
4. Combined the punctuation character and its continuation storage into one
actual 48-character buffer so pointer iteration stays within an array.
4452/3946 instructions, final clean-build objdiff 44.43563%.
The remaining candidate-engine differences include stack layout, extra loads,
argument conversions, register allocation, and reconstructed branch structure.
This is not a compiler tie-break-only result. The recovered field names and
external declarations remain provisional, and engine behavior has not been
validated independently of the original assembly.
## Other iterations
- Workspace arguments accessed directly through a typed structure removed
redundant pointer spills in Zi8IsWordW2 and Zi8SetHighlightedWordW.
- Signed length/index variables, branch direction for the single-character
case, and postfix suffix indexing made ZiprocessHighlightedW exact.
- Shared true-result exits made Zi8IsVowel's switch trees exact.
- A generic beginning pointer with typed character indexing made both
exclusion functions exact after signed-length and declaration-order trials.
- Zi8DeTokenization progressed from 692 to 811 to exactly 814 instructions
after using postfix output indexing, recovered character/count widths,
a 64-character output buffer, explicit input casts, and direct length return.
## Linking trial
Temporarily changed only zi8alpha to Matching and built main.dol. Linking
succeeded, but the DOL SHA1 was f7c92fc7a6790ae104636294803a7959ea628ddf.
Both original and trial DOLs were 3867904 bytes. 2045708 common bytes differed,
from file offset 0x5BA through 0x369301.
Original Zi8AlphaGetCandidates: offset 0xA40, size 0x3DA8.
Built Zi8AlphaGetCandidates: offset 0xA40, size 0x4590.
Original Zi8DeTokenization: offset 0x47E8.
Built Zi8DeTokenization: offset 0x4FD0.
unitaudit.py found 11 text symbols at their original addresses and one shifted
by 2024 bytes. The following zi8alts unit moved by +0x7E8. Later text shifts
changed to +0x7E0, and the following rodata began at +0x7C0.
The recovered exclusion tables have 330 meaningful bytes. The original rodata
section has 336 bytes, including its trailing zero alignment. No artificial
padding was added. The original anonymous French table symbol was given the
source name FrenchExcludePairs.
Restored NonMatching, rebuilt main.dol, and confirmed SHA1
26116613f624061ba99c8d1a299aaa6efa85670d. configure.py has no final changes.

View File

@@ -0,0 +1,63 @@
# zi8cinfo attempts
Baseline source was absent. All ten functions are implemented in object order.
Nine functions have objdiff 100.0 and ctxdiff diffs 0. All 1,848 data bytes match.
No shared headers or other units were changed.
## Zi8GetSInfo, still open
- Separate count decrement followed by the zero store: 99.09775, 133/133 instructions. Only instructions 43 and 44 are swapped. Retained this version.
- Prefix decrement inside the output index: 98.42105, 131/133 instructions. Constant loading moves before the decrement, but extraCount moves from the stack to r25, removing its store/load pair.
- Assign count minus one inside the index: 98.270676 with an 8-bit count. Adds truncation of the assigned count and still moves extraCount into r25. With an int count: 98.42105.
- Post-decrement minus one inside the index: 96.729324, worse indexing and register allocation.
- Named last-index temporary: 97.89474, additional indexing/register differences.
- Changing local declaration order with prefix decrement, three orders: all 98.42105. Does not restore extraCount's stack allocation.
- Unsigned extraCount with a signed loop-bound cast: 98.42105. Same unwanted r25 allocation.
- Comma expression in the output index: 97.14286. Rejected.
- Store at count minus one, then decrement count: 99.172935, 134/133 instructions. Duplicates the decrement for address calculation and count maintenance. Rejected despite the higher fuzzy score.
The retained code emits `addi r30,r30,-1; li r3,0`, while the target emits
`li r3,0; addi r30,r30,-1`. No register, volatile, assembly, or pragma hints used.
## Functions resolved
- Zi8GetCJInfo: first reconstruction 99.888885 with two differences. Separating the initial shift caused 12 register differences. Keeping the packed assignment within its shift expression reached 100.0, 90/90 instructions. A later typed-work/separate-shift alternative produced 14 register differences and was rejected.
- Zi8GetPInfo: first reconstruction 67.7494. Using an int output count, ordinary indexed stores, post-increment for multi-character spellings, source-order initial cases, and a tone switch reached 100.0, 830/830 instructions.
- Zi8GetZInfo: initial reconstruction reached 100.0, 765/765 instructions.
- zi8StrokeCode: initial switch reached 100.0, 53/53 instructions.
- Zi81KeyPYinfo: initial switch reached 100.0, 120/120 instructions.
- Zi81KeyZYinfo: initial switch reached 100.0, 153/153 instructions.
- Zi8GetCharInfo: wrapper reached 100.0, 21/21 instructions.
- ZiCharInfo2: initial reconstruction 37.02924. Moving normalization ahead of the general lookup and reconstructing table operations reached 80.38596. Initializing the phonetic-table pointer gave 80.37622. Reconstructing the alternate-search loop, element loop, record fields, and shared normalization block gave 92.70565. Using the actual normalization switch cases and returning from that block gave 97.38012. Separating table lookup from Zi8GetPCode gave 99.48538 and the correct register allocation. Reordering real local declarations and correcting 16-bit byte promotions gave 100.0, 513/513 instructions.
- Zi8GetCharInfo2: initial reconstruction 97.9661. A word-sized result/return gave 98.98305 with only work/state registers swapped. Swapping local declarations and initializing the saved state at declaration left 98.98305. A separate work pointer gave 96.52542; a word-sized saved state gave 97.28814. Giving the work argument its real struct-pointer type resolved the allocation tie: 100.0, 59/59 instructions.
## Linking investigation
Temporarily changed only zi8cinfo to Matching and built main.dol. The result was
3,867,904 bytes, the same as the original. SHA1 was
e216152519ae06ed2d325eefaa60d96030dbf381.
Exactly eight bytes differed, all within Zi8GetSInfo:
| DOL file offset | Original word | Rebuilt word |
| --- | --- | --- |
| 0x1486d8 | 38600000 | 3bdeffff |
| 0x1486dc | 3bdeffff | 38600000 |
unitaudit.py reported no address steps or internal layout disagreements.
`nm -n` showed identical function offsets and jump-table offsets; only compiler
local-symbol names differed. Restored NonMatching because the DOL was not exact.
## Validation baseline and type notes
The default gate cannot pass because baseline-a620eec6.json is absent. Used
`--base 5cdca2e8`, the immediate ancestor with an existing immutable baseline.
This baseline records zero exact functions, zero matched code bytes, and zero
matched data bytes for this unit. No baseline files were written or modified.
The existing public header declares Zi8GetCharInfo2's result as ziU8. This unit
uses a word-sized internal declaration/definition, as required by the observed
untruncated return and callers inside this object. Results remain character
counts within the byte range; the shared public header remains unchanged.
ZiInfoWork names the accessed fields at 0x16 and 0x18; prefix-field names do not
claim that the full work-data structure has been independently decompiled.

View File

@@ -0,0 +1,59 @@
#!/usr/bin/env python3
"""Rewrite the progress block in README.md from an objdiff report.
usage: update_readme_progress.py <report.json> <README.md> [commit]
"""
import datetime
import json
import sys
START = "<!-- progress:start -->"
END = "<!-- progress:end -->"
def pct(measures, key):
return float(measures.get(key) or 0.0)
def main():
report_path, readme_path = sys.argv[1], sys.argv[2]
commit = sys.argv[3][:8] if len(sys.argv) > 3 else ""
m = json.load(open(report_path))["measures"]
stamp = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
block = "\n".join([
START,
"| Decompiled | Matched | Linked | Data |",
"|:---:|:---:|:---:|:---:|",
f"| {pct(m, 'fuzzy_match_percent'):.2f}% | {pct(m, 'matched_code_percent'):.2f}% "
f"| {pct(m, 'complete_code_percent'):.2f}% | {pct(m, 'matched_data_percent'):.2f}% |",
"",
f"units {m.get('complete_units')}/{m.get('total_units')} complete, "
f"functions {m.get('matched_functions')}/{m.get('total_functions')} matched. "
f"updated {stamp}" + (f" from `{commit}`" if commit else "") + " by the self-hosted progress job",
"",
"decompiled = code with a C/C++ implementation (objdiff fuzzy), matched = byte-exact code, "
"linked = code actually linked into the DOL, data = byte-exact data",
END,
])
text = open(readme_path, encoding="utf-8").read()
if START in text and END in text:
head, rest = text.split(START, 1)
_, tail = rest.split(END, 1)
new = head + block + tail
else:
anchor = "Progress\n========\n"
if anchor not in text:
raise SystemExit("no progress anchor in README")
new = text.replace(anchor, anchor + block + "\n\n", 1)
if new != text:
open(readme_path, "w", encoding="utf-8").write(new)
print("README progress updated")
else:
print("README progress unchanged")
if __name__ == "__main__":
main()