Compare commits

..

3 Commits

Author SHA1 Message Date
Devin AI
e9aea7f336 fa: pf_dir GetSDD byte-identical - 34/38 fns
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-09-30 09:12:21 +00:00
Devin AI
76a1a389c4 fa: pf_dir GetSDD/p_move improvements - 33/38 fns
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-09-30 09:08:53 +00:00
Devin AI
c34b48dcc0 fa: match pf dir/entry units - 6/8 linked, pf_dir 32/38, pf_cluster 5/8
Co-Authored-By: wch <usernamecole7@gmail.com>
2026-09-30 08:56:51 +00:00
336 changed files with 22055 additions and 119404 deletions

View File

@@ -53,9 +53,9 @@ Progress
<!-- progress:start -->
| Decompiled | Matched | Linked | Data |
|:---:|:---:|:---:|:---:|
| 99.37% | 87.79% | 62.05% | 92.06% |
| 94.06% | 82.26% | 58.17% | 89.35% |
units 918/1027 complete, functions 12216/12563 matched.
units 776/1027 complete, functions 11927/12563 matched.
decompiled = code with a C/C++ implementation (objdiff fuzzy), matched = byte-exact code, linked = code actually linked into the DOL, data = byte-exact data
<!-- progress:end -->

View File

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

View File

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

View File

@@ -1385,19 +1385,19 @@ getDiskBannerData__Q33ipl7channel7ManagerFib = .text:0x81339FB0; // type:functio
titleIDtoPageIndex__Q33ipl7channel7ManagerCFUxPiPi = .text:0x8133A2BC; // type:function size:0xA0
getLockedMsgFromBuf__Q33ipl7channel7ManagerCFPCQ33ipl7channel22SChanMgrDiskInMessages = .text:0x8133A35C; // type:function size:0xA8
nand_error_handling__Q33ipl7channel7ManagerFi = .text:0x8133A404; // type:function size:0xDC
findEntryByTitleId__Q33ipl7channel7ManagerFUx = .text:0x8133A4E0; // type:function size:0x9C
getBannerCSIdx__Q33ipl7channel7ManagerFUx = .text:0x8133A57C; // type:function size:0x3C
getSoundSize__Q33ipl7channel7ManagerFUx = .text:0x8133A5B8; // type:function size:0x38
needsNetSetting__Q33ipl7channel7ManagerFUx = .text:0x8133A5F0; // type:function size:0x44
usesAltSound__Q33ipl7channel7ManagerFUx = .text:0x8133A634; // type:function size:0x44
isMissingTicket__Q33ipl7channel7ManagerFUx = .text:0x8133A678; // type:function size:0x40
isNewsChannelV6Plus__Q33ipl7channel7ManagerFUx = .text:0x8133A6B8; // type:function size:0x84
isOperaChannel__Q33ipl7channel7ManagerFUx = .text:0x8133A73C; // type:function size:0x68
readBannerMetaAsync__Q33ipl7channel7ManagerFPQ23EGG4HeapUx = .text:0x8133A7A4; // type:function size:0xB8
readSoundMetaAsync__Q33ipl7channel7ManagerFPQ23EGG4HeapUx = .text:0x8133A85C; // type:function size:0xC8
readBannerCSAsync__Q33ipl7channel7ManagerFPQ23EGG4HeapUx = .text:0x8133A924; // type:function size:0xCC
clearTmpChannel__Q33ipl7channel7ManagerFv = .text:0x8133A9F0; // type:function size:0x60
unloadBanner__Q33ipl7channel7ManagerFUx = .text:0x8133AA50; // type:function size:0x30
fn_8133A4E0__Q33ipl7channel7ManagerFUx = .text:0x8133A4E0; // type:function size:0x9C
fn_8133A57C__Q33ipl7channel7ManagerFUx = .text:0x8133A57C; // type:function size:0x3C
fn_8133A5B8__Q33ipl7channel7ManagerFUx = .text:0x8133A5B8; // type:function size:0x38
fn_8133A5F0__Q33ipl7channel7ManagerFUx = .text:0x8133A5F0; // type:function size:0x44
fn_8133A634__Q33ipl7channel7ManagerFUx = .text:0x8133A634; // type:function size:0x44
fn_8133A678__Q33ipl7channel7ManagerFUx = .text:0x8133A678; // type:function size:0x40
fn_8133A6B8__Q33ipl7channel7ManagerFUx = .text:0x8133A6B8; // type:function size:0x84
fn_8133A73C__Q33ipl7channel7ManagerFUx = .text:0x8133A73C; // type:function size:0x68
fn_8133A7A4__Q33ipl7channel7ManagerFPQ23EGG4HeapUx = .text:0x8133A7A4; // type:function size:0xB8
fn_8133A85C__Q33ipl7channel7ManagerFPQ23EGG4HeapUx = .text:0x8133A85C; // type:function size:0xC8
fn_8133A924__Q33ipl7channel7ManagerFPQ23EGG4HeapUx = .text:0x8133A924; // type:function size:0xCC
fn_8133A9F0__Q33ipl7channel7ManagerFv = .text:0x8133A9F0; // type:function size:0x60
fn_8133AA50__Q33ipl7channel7ManagerFUx = .text:0x8133AA50; // type:function size:0x30
__ct__Q33ipl7channel20ChannelScriptManagerFv = .text:0x8133AA80; // type:function size:0x10
create__Q33ipl7channel20ChannelScriptManagerFPQ23EGG7ExpHeap = .text:0x8133AA90; // type:function size:0x90
init__Q33ipl7channel20ChannelScriptManagerFPQ33ipl4nand4FilePQ33ipl7channel9RsoThread = .text:0x8133AB20; // type:function size:0x3D4
@@ -1761,7 +1761,7 @@ update_sd_app_location_async__Q23ipl12NandSDWorkerFPUl = .text:0x81348E30; // ty
read_sd_app_location_async__Q23ipl12NandSDWorkerFPUl = .text:0x81348E44; // type:function size:0x14
check_for_sd_app_to_nand_async__Q23ipl12NandSDWorkerFUxPQ33ipl12NandSDWorker13AppBlocksInfoPQ33ipl12NandSDWorker13AppBlocksInfo = .text:0x81348E58; // type:function size:0x30
check_backup_fits_async__Q23ipl12NandSDWorkerFPQ33ipl12NandSDWorker11TitleIdListPQ33ipl12NandSDWorker11TitleIdList = .text:0x81348E88; // type:function size:0x20
check_sd_app_titles_async__Q23ipl12NandSDWorkerFPvPvPv = .text:0x81348EA8; // type:function size:0x2C
iplNandSD_81348EA8__Q23ipl12NandSDWorkerFPvPvPv = .text:0x81348EA8; // type:function size:0x2C
get_nand_save_size_async__Q23ipl12NandSDWorkerFUx = .text:0x81348ED4; // type:function size:0x18
get_nand_app_size_async__Q23ipl12NandSDWorkerFUx = .text:0x81348EEC; // type:function size:0x18
delete_nand_save_async__Q23ipl12NandSDWorkerFUx = .text:0x81348F04; // type:function size:0x18
@@ -1823,7 +1823,7 @@ do_read_sd_app_location__Q23ipl12NandSDWorkerFv = .text:0x8134BC60; // type:func
do_check_for_sd_app_to_nand__Q23ipl12NandSDWorkerFv = .text:0x8134BED0; // type:function size:0x3C8
check_backup_fits__Q23ipl12NandSDWorkerFv = .text:0x8134C298; // type:function size:0x3D8
do_list_nand_apps_usage__Q23ipl12NandSDWorkerFv = .text:0x8134C670; // type:function size:0x1C8
do_check_sd_app_titles__Q23ipl12NandSDWorkerFv = .text:0x8134C838; // type:function size:0x2D0
do_unk_8134C838__Q23ipl12NandSDWorkerFv = .text:0x8134C838; // type:function size:0x2D0
do_get_nand_save_size__Q23ipl12NandSDWorkerFv = .text:0x8134CB08; // type:function size:0x260
do_get_nand_app_size__Q23ipl12NandSDWorkerFv = .text:0x8134CD68; // type:function size:0x1F4
get_sd_save_size__Q23ipl12NandSDWorkerFUl = .text:0x8134CF5C; // type:function size:0x140
@@ -2042,8 +2042,8 @@ isEqualChannel__Q33ipl8savedata7ManagerFUxUx = .text:0x813594B0; // type:functio
isDefaultChannel__Q33ipl8savedata7ManagerFUlUl = .text:0x8135954C; // type:function size:0x50
updateVersion__Q33ipl8savedata7ManagerFUlUl = .text:0x8135959C; // type:function size:0xD4
setDefaultSDMenu__Q33ipl8savedata7ManagerFv = .text:0x81359670; // type:function size:0x48 scope:local
pushTitleCache__Q33ipl8savedata7ManagerFUx = .text:0x813596B8; // type:function size:0xE8
isTitleCached = .text:0x813597A0; // type:function size:0x40
iplSavedata_813596B8__Q33ipl8savedata7ManagerFUx = .text:0x813596B8; // type:function size:0xE8
iplSavedata_813597A0 = .text:0x813597A0; // type:function size:0x40 scope:local
nand_error_handling__Q33ipl8savedata7ManagerFi = .text:0x813597E0; // type:function size:0xDC
__ct__Q33ipl7channel9RsoThreadFPQ23EGG4Heap = .text:0x813598BC; // type:function size:0x6C
__dt__Q33ipl7channel9RsoThreadFv = .text:0x81359928; // type:function size:0x70
@@ -2095,7 +2095,7 @@ stt_wait_fns_msg__Q23ipl9CdbBackupFv = .text:0x8135B004; // type:function size:0
stt_clean_up_back__Q23ipl9CdbBackupFv = .text:0x8135B030; // type:function size:0x60
stt_wait_terminate__Q23ipl9CdbBackupFv = .text:0x8135B090; // type:function size:0x60
error_handling__Q23ipl9CdbBackupFv = .text:0x8135B0F0; // type:function size:0xD0
getProgressPercent__Q23ipl9CdbBackupFv = .text:0x8135B1C0; // type:function size:0x28
fn_8135B1C0__Q23ipl9CdbBackupFv = .text:0x8135B1C0; // type:function size:0x28
cdb_backup_delete_search_cb___3iplFPvP10_CDBRecord = .text:0x8135B1E8; // type:function size:0x8C
cdb_backup_delete_task___3iplFPv = .text:0x8135B274; // type:function size:0xDC
cdb_backup_move_search_cb___3iplFPvP10_CDBRecord = .text:0x8135B350; // type:function size:0xBC
@@ -5126,8 +5126,8 @@ __ct__Q33ipl5scene10AOSSThreadFPQ23EGG4Heap = .text:0x813FCA0C; // type:function
destroy__Q33ipl5scene10AOSSThreadFi = .text:0x813FCAA0; // type:function size:0x84
__dt__Q33ipl5scene10AOSSThreadFv = .text:0x813FCB24; // type:function size:0x70
start__Q33ipl5scene10AOSSThreadFv = .text:0x813FCB94; // type:function size:0xF8
aossAlloc__Q33ipl5scene10AOSSThreadFv = .text:0x813FCC8C; // type:function size:0x58
aossFree__Q33ipl5scene10AOSSThreadFv = .text:0x813FCCE4; // type:function size:0x50
AOSSThread_813FCC8C__Q33ipl5scene10AOSSThreadFv = .text:0x813FCC8C; // type:function size:0x58
AOSSThread_813FCCE4__Q33ipl5scene10AOSSThreadFv = .text:0x813FCCE4; // type:function size:0x50
Run__Q33ipl5scene10AOSSThreadFv = .text:0x813FCD34; // type:function size:0xEC
cancel__Q33ipl5scene10AOSSThreadFv = .text:0x813FCE20; // type:function size:0x50
finish__Q33ipl5scene10AOSSThreadFP13NCDAossConfigPi = .text:0x813FCE70; // type:function size:0x2FC
@@ -5267,10 +5267,10 @@ start_focusout_anm__Q33ipl5scene13SettingSelectFi = .text:0x814093D0; // type:fu
start_selected_anm__Q33ipl5scene13SettingSelectFi = .text:0x81409480; // type:function size:0x274
is_stopped_all_anm__Q33ipl5scene13SettingSelectCFv = .text:0x814096F4; // type:function size:0x74
onEvent__Q33ipl5scene13SettingSelectFUlUlPv = .text:0x81409768; // type:function size:0xFC
calc_exit_sequence__Q33ipl5scene13SettingSelectFv = .text:0x81409864; // type:function size:0x90
prepare_exit_abort__Q33ipl5scene13SettingSelectFv = .text:0x814098F4; // type:function size:0x94
start_exit_fade__Q33ipl5scene13SettingSelectFv = .text:0x81409988; // type:function size:0x64
finish_exit_reboot__Q33ipl5scene13SettingSelectFv = .text:0x814099EC; // type:function size:0x198
fn_81409864__Q33ipl5scene13SettingSelectFv = .text:0x81409864; // type:function size:0x90
fn_814098F4__Q33ipl5scene13SettingSelectFv = .text:0x814098F4; // type:function size:0x94
fn_81409988__Q33ipl5scene13SettingSelectFv = .text:0x81409988; // type:function size:0x64
fn_814099EC__Q33ipl5scene13SettingSelectFv = .text:0x814099EC; // type:function size:0x198
__dt__Q33ipl5scene13SettingSelectFv = .text:0x81409B84; // type:function size:0x58 scope:weak
@20@__dt__Q33ipl5scene13SettingSelectFv = .text:0x81409BDC; // type:function size:0x8 scope:weak
@84@onEvent__Q33ipl5scene13SettingSelectFUlUlPv = .text:0x81409BE4; // type:function size:0x8 scope:weak
@@ -5576,7 +5576,7 @@ __sinit_\tiPcKeyboard_cpp = .text:0x81416F34; // type:function size:0x1B0
@68@calc__Q49textinput8keyboard6pctype12LayoutByNW4RFv = .text:0x814170FC; // type:function size:0x8
@68@draw__Q49textinput8keyboard6pctype12LayoutByNW4RFv = .text:0x81417104; // type:function size:0x8
@68@init__Q49textinput8keyboard6pctype12LayoutByNW4RFv = .text:0x8141710C; // type:function size:0x8
@236@onEvent__Q49textinput8keyboard6pctype12LayoutByNW4RFPQ49textinput8keyboard6pctype5UIObjUlPv = .text:0x81417114; // type:function size:0x8
@236@onEvent__Q49textinput8keyboard6pctype12LayoutByNW4RFPQ49textinput8keyboard6pctype5 = .text:0x81417114; // type:function size:0x8
create__Q49textinput8keyboard13cellphonetype4BaseFP12MEMAllocator = .text:0x8141711C; // type:function size:0xAC
init__Q49textinput8keyboard13cellphonetype4BaseFv = .text:0x814171C8; // type:function size:0xA8
calc__Q49textinput8keyboard13cellphonetype4BaseFv = .text:0x81417270; // type:function size:0x4
@@ -5829,7 +5829,7 @@ doAfterDrawProcess__Q39textinput9inputform4BaseFPCwUlRCQ49textinput10textdrawer4
finishDraw__Q39textinput9inputform4BaseFUl = .text:0x81427DC0; // type:function size:0x4
addSender__Q29textinput15CommandReceiverFPQ29textinput13CommandSender = .text:0x81427DC4; // type:function size:0x8
getDrawModifyStartLine__Q39textinput10textdrawer4BaseCFv = .text:0x81427DCC; // type:function size:0x8
isEnableCursorCache__Q39textinput10textdrawer4BaseCFv = .text:0x81427DD4; // type:function size:0x8
isEnableCursorCache__Q39textinput10textdrawer4BaseCFvgetStartPos__Q39textinput10textdrawer4BaseCFv = .text:0x81427DD4; // type:function size:0x8
getStartPos__Q39textinput10textdrawer4BaseCFv = .text:0x81427DDC; // type:function size:0x8
setVIWidth__Q39textinput10textdrawer4BaseFf = .text:0x81427DE4; // type:function size:0x8
setCandidateBox__Q39textinput12candidatebox18CandidateBoxCallerFPQ39textinput12candidatebox4Base = .text:0x81427DEC; // type:function size:0x8
@@ -13113,7 +13113,7 @@ pfstub_com_massage = .text:0x815E6C40; // type:function size:0xE4
pfstub_store_result = .text:0x815E6D24; // type:function size:0xC4
PFSYS_initializeSYS = .text:0x815E6DE8; // type:function size:0x4
PFSYS_GetCurrentContextID = .text:0x815E6DEC; // type:function size:0x18
PFSYS_TimeStamp = .text:0x815E6E04; // type:function size:0x7C
PFSYS_TimeStamp = .text:0x815E6E04; // type:function size:0x74
pfstub_call_function_standard = .text:0x815E6E80; // type:function size:0x584
pfstub_attach = .text:0x815E7404; // type:function size:0x50
pfstub_buffering = .text:0x815E7454; // type:function size:0x50
@@ -13202,7 +13202,7 @@ pfd_sddrv_pread = .text:0x815EAADC; // type:function size:0x38
pfd_sddrv_pwrite = .text:0x815EAB14; // type:function size:0x38
pfd_sddrv_unmount = .text:0x815EAB4C; // type:function size:0x34
pfd_sddrv_finalize = .text:0x815EAB80; // type:function size:0xE4
pfd_sddrv_get_disk_info = .text:0x815EAC64; // type:function size:0x188
pfd_sddrv_get_disk_info = .text:0x815EAC64; // type:function size:0x180
pfd_sddrv_init_drv_tbl = .text:0x815EADEC; // type:function size:0x18
pfd_sddrv_registar_callback = .text:0x815EAE04; // type:function size:0x10
pfd_sddrv_is_media_insert = .text:0x815EAE14; // type:function size:0x98
@@ -13986,8 +13986,8 @@ lbl_81616AE4 = .rodata:0x81616AE4; // type:object size:0x30
lbl_81616B14 = .rodata:0x81616B14; // type:object size:0x74
lbl_81616B88 = .rodata:0x81616B88; // type:object size:0x40
lbl_81616BC8 = .rodata:0x81616BC8; // type:object size:0x10 data:4byte
scCountryMap_EU = .rodata:0x81616BD8; // type:object size:0xC
scCountryMap_NonEU = .rodata:0x81616BE4; // type:object size:0xC
lbl_81616BD8 = .rodata:0x81616BD8; // type:object size:0xC
lbl_81616BE4 = .rodata:0x81616BE4; // type:object size:0xC
lbl_81616BF0 = .rodata:0x81616BF0; // type:object size:0x88
CHANSVmConstStringObjectUndefined = .rodata:0x81616C78; // type:object size:0x10
lbl_81616C88 = .rodata:0x81616C88; // type:object size:0x10
@@ -14110,7 +14110,7 @@ hairColorTable$1737 = .rodata:0x8161DDDC; // type:object size:0xB4 scope:local
eyeColorTable$1742 = .rodata:0x8161DE90; // type:object size:0x1E scope:local
scDefaultData = .rodata:0x8161DEB0; // type:object size:0x1BC scope:local
scDayMax$1845 = .rodata:0x8161E070; // type:object size:0xD scope:local
scJpegAanScale = .rodata:0x8161E080; // type:object size:0x100 scope:local data:4byte
lbl_8161E080 = .rodata:0x8161E080; // type:object size:0x100 scope:local data:4byte
TMCJPEGDEC_SampleH_N = .rodata:0x8161E180; // type:object size:0x18 data:byte
TMCJPEGDEC_SampleV_N = .rodata:0x8161E198; // type:object size:0x18 data:byte
TMCJPEGDEC_Zigzag_data = .rodata:0x8161E1B0; // type:object size:0x40 data:byte
@@ -14736,7 +14736,7 @@ lbl_81639189 = .data:0x81639189; // type:object size:0x39 data:string
jumptable_816391C4 = .data:0x816391C4; // type:object size:0x30 scope:local
__vt__Q33ipl8savedata7Manager = .data:0x816391F4; // type:object size:0xC
__vt__Q33ipl7channel9RsoThread = .data:0x81639200; // type:object size:0x2C
scRsoFatalMsg = .data:0x81639230; // type:object size:0x41 data:string
lbl_81639230 = .data:0x81639230; // type:object size:0x41 data:string
jumptable_81639278 = .data:0x81639278; // type:object size:0x44 scope:local
lbl_816392BC = .data:0x816392BC; // type:object size:0xB data:string
lbl_816392C7 = .data:0x816392C7; // type:object size:0x11 data:string
@@ -14994,8 +14994,8 @@ __vt__Q37ext_ead3www14SurfaceManager = .data:0x81643AA0; // type:object size:0xC
@1183 = .data:0x81643AB8; // type:object size:0x21 scope:local data:string
__vt__Q37ext_ead3www9ut_thread = .data:0x81643ADC; // type:object size:0x28
lbl_81643B08 = .data:0x81643B08; // type:object size:0x38
scWwwTexBufFmt = .data:0x81643B40; // type:object size:0x1E data:string
scWwwNoBrowserWin = .data:0x81643B5E; // type:object size:0x24 data:string
lbl_81643B40 = .data:0x81643B40; // type:object size:0x1E data:string
lbl_81643B5E = .data:0x81643B5E; // type:object size:0x24 data:string
lbl_81643B82 = .data:0x81643B82; // type:object size:0x1B data:string
lbl_81643B9D = .data:0x81643B9D; // type:object size:0x2B data:string
lbl_81643BC8 = .data:0x81643BC8; // type:object size:0x12 data:string
@@ -15655,15 +15655,15 @@ lbl_8164C424 = .data:0x8164C424; // type:object size:0xB data:string
lbl_8164C42F = .data:0x8164C42F; // type:object size:0xD data:string
lbl_8164C43C = .data:0x8164C43C; // type:object size:0xD data:string
lbl_8164C449 = .data:0x8164C449; // type:object size:0xD data:string
scPaneName_T_CalMonth = .data:0x8164C458; // type:object size:0xC data:4byte
lbl_8164C458 = .data:0x8164C458; // type:object size:0xC data:4byte
lbl_8164C464 = .data:0x8164C464; // type:object size:0x9 data:string
lbl_8164C46D = .data:0x8164C46D; // type:object size:0x9 data:string
lbl_8164C476 = .data:0x8164C476; // type:object size:0x9 data:string
scPaneName_N_Cal = .data:0x8164C480; // type:object size:0xC
lbl_8164C480 = .data:0x8164C480; // type:object size:0xC
lbl_8164C48C = .data:0x8164C48C; // type:object size:0xB data:string
lbl_8164C497 = .data:0x8164C497; // type:object size:0xB data:string
lbl_8164C4A2 = .data:0x8164C4A2; // type:object size:0xB data:string
scPaneName_N_CalPos = .data:0x8164C4B0; // type:object size:0xC
lbl_8164C4B0 = .data:0x8164C4B0; // type:object size:0xC
lbl_8164C4BC = .data:0x8164C4BC; // type:object size:0x43
lbl_8164C4FF = .data:0x8164C4FF; // type:object size:0xF data:string
lbl_8164C50E = .data:0x8164C50E; // type:object size:0x14 data:string
@@ -15673,11 +15673,11 @@ lbl_8164C54E = .data:0x8164C54E; // type:object size:0x18
lbl_8164C566 = .data:0x8164C566; // type:object size:0xC
lbl_8164C572 = .data:0x8164C572; // type:object size:0xA
__vt__Q33ipl5scene8Calendar = .data:0x8164C57C; // type:object size:0xA4
scN_CalDay_r = .data:0x8164C620; // type:object size:0xB data:string
scDateAnimPaneNames = .data:0x8164C62C; // type:object size:0x14 data:4byte
scMyIplTopFBrlan = .data:0x8164C640; // type:object size:0x12 data:string
scN_CalDay_t = .data:0x8164C652; // type:object size:0xB data:string
scSEDateFocus = .data:0x8164C65D; // type:object size:0x13 data:string
lbl_8164C620 = .data:0x8164C620; // type:object size:0xB data:string
lbl_8164C62C = .data:0x8164C62C; // type:object size:0x14 data:4byte
lbl_8164C640 = .data:0x8164C640; // type:object size:0x12 data:string
lbl_8164C652 = .data:0x8164C652; // type:object size:0xB data:string
lbl_8164C65D = .data:0x8164C65D; // type:object size:0x13 data:string
__vt__Q33ipl5scene4Date = .data:0x8164C670; // type:object size:0x18
@12712 = .data:0x8164C688; // type:object size:0xC scope:local data:string
...data.0 = .data:0x8164C688; // type:label scope:local
@@ -15796,20 +15796,20 @@ __vt__Q33ipl5scene11ChannelEdit = .data:0x8164CC1C; // type:object size:0x4C
@17390 = .data:0x8164D00C; // type:object size:0x30 scope:local
__vt__Q33ipl5scene11ChanAppBase = .data:0x8164D03C; // type:object size:0x28
__vt__Q33ipl5scene13AnmController = .data:0x8164D0F8; // type:object size:0xC scope:weak
scBrlan_SaveDataIn = .data:0x8164D108; // type:object size:0x25 data:string
scBrlan_SaveDataOut = .data:0x8164D12D; // type:object size:0x26 data:string
scBrlan_SaveDataFocusIn = .data:0x8164D153; // type:object size:0x2B data:string
scBrlan_SaveDataFocusOut = .data:0x8164D17E; // type:object size:0x2C data:string
scPaneName_N_Data16x9 = .data:0x8164D1AA; // type:object size:0xB data:string
scPaneName_N_Data4x3 = .data:0x8164D1B5; // type:object size:0xA data:string
scPaneName_B_Data_01 = .data:0x8164D1BF; // type:object size:0xA data:string
scPaneName_B_Data_00 = .data:0x8164D1C9; // type:object size:0xA data:string
scPaneName_N_Atari16x9 = .data:0x8164D1D3; // type:object size:0xC data:string
scPaneName_N_Data_01 = .data:0x8164D1DF; // type:object size:0xA data:string
scPaneName_N_Atari4x3 = .data:0x8164D1E9; // type:object size:0xB data:string
scPaneName_N_Data_00 = .data:0x8164D1F4; // type:object size:0xA data:string
scPaneName_DataBaseCover_00 = .data:0x8164D1FE; // type:object size:0x11 data:string
scPaneName_DataBaseCover_01 = .data:0x8164D20F; // type:object size:0x11 data:string
lbl_8164D108 = .data:0x8164D108; // type:object size:0x25 data:string
lbl_8164D12D = .data:0x8164D12D; // type:object size:0x26 data:string
lbl_8164D153 = .data:0x8164D153; // type:object size:0x2B data:string
lbl_8164D17E = .data:0x8164D17E; // type:object size:0x2C data:string
lbl_8164D1AA = .data:0x8164D1AA; // type:object size:0xB data:string
lbl_8164D1B5 = .data:0x8164D1B5; // type:object size:0xA data:string
lbl_8164D1BF = .data:0x8164D1BF; // type:object size:0xA data:string
lbl_8164D1C9 = .data:0x8164D1C9; // type:object size:0xA data:string
lbl_8164D1D3 = .data:0x8164D1D3; // type:object size:0xC data:string
lbl_8164D1DF = .data:0x8164D1DF; // type:object size:0xA data:string
lbl_8164D1E9 = .data:0x8164D1E9; // type:object size:0xB data:string
lbl_8164D1F4 = .data:0x8164D1F4; // type:object size:0xA data:string
lbl_8164D1FE = .data:0x8164D1FE; // type:object size:0x11 data:string
lbl_8164D20F = .data:0x8164D20F; // type:object size:0x11 data:string
__vt__Q33ipl5scene10ChanAppBox = .data:0x8164D220; // type:object size:0x28
@18429 = .data:0x8164D2E8; // type:object size:0x20 scope:local data:string
@18431 = .data:0x8164D308; // type:object size:0x21 scope:local data:string
@@ -15940,19 +15940,19 @@ lbl_8164DCDF = .data:0x8164DCDF; // type:object size:0x35
jumptable_8164DD14 = .data:0x8164DD14; // type:object size:0x6C scope:local
lbl_8164DD80 = .data:0x8164DD80; // type:object size:0x37
lbl_8164DDB7 = .data:0x8164DDB7; // type:object size:0xAD
scPaneName_N_GCIcon = .data:0x8164DE64; // type:object size:0x9 data:string
scPaneName_N_DiscUpdateIcon = .data:0x8164DE6D; // type:object size:0x11 data:string
lbl_8164DE64 = .data:0x8164DE64; // type:object size:0x9 data:string
lbl_8164DE6D = .data:0x8164DE6D; // type:object size:0x11 data:string
jumptable_8164DE80 = .data:0x8164DE80; // type:object size:0x1C scope:local
scSE_WSD_SELECT = .data:0x8164DE9C; // type:object size:0xB data:string
lbl_8164DE9C = .data:0x8164DE9C; // type:object size:0xB data:string
lbl_8164DEA7 = .data:0x8164DEA7; // type:object size:0x10 data:string
lbl_8164DEB7 = .data:0x8164DEB7; // type:object size:0x114
scSE_WIPL_SE_CH_TARGETTING = .data:0x8164DFCB; // type:object size:0x16 data:string
scSE_WIPL_SE_CH_HOLD = .data:0x8164DFE1; // type:object size:0x10 data:string
scSE_WIPL_SE_CH_SET = .data:0x8164DFF1; // type:object size:0xF data:string
scSE_WIPL_SE_CH_NOT_MOVE = .data:0x8164E000; // type:object size:0x14 data:string
lbl_8164DFCB = .data:0x8164DFCB; // type:object size:0x16 data:string
lbl_8164DFE1 = .data:0x8164DFE1; // type:object size:0x10 data:string
lbl_8164DFF1 = .data:0x8164DFF1; // type:object size:0xF data:string
lbl_8164E000 = .data:0x8164E000; // type:object size:0x14 data:string
lbl_8164E014 = .data:0x8164E014; // type:object size:0x10 data:string
scSE_WIPL_SE_GRAY_BUTTON = .data:0x8164E024; // type:object size:0x14 data:string
scSE_WIPL_SE_DECIDE = .data:0x8164E038; // type:object size:0xF data:string
lbl_8164E024 = .data:0x8164E024; // type:object size:0x14 data:string
lbl_8164E038 = .data:0x8164E038; // type:object size:0xF data:string
__vt__Q33ipl4math29HermiteIntp<Q33ipl4math4VEC3> = .data:0x8164E048; // type:object size:0x20
__vt__Q33ipl5scene27CsChanSelSDMenuEventHandler = .data:0x8164E068; // type:object size:0x1C
__vt__Q33ipl5scene27CsChanSelButtonEventHandler = .data:0x8164E084; // type:object size:0x1C
@@ -15968,61 +15968,61 @@ s_time_num__Q23ipl5scene = .data:0x8164E1D8; // type:object size:0x28 scope:loca
@10797 = .data:0x8164E251; // type:object size:0x1A scope:local data:string
@10804 = .data:0x8164E26B; // type:object size:0x19 scope:local data:string
@10848 = .data:0x8164E284; // type:object size:0xA scope:local data:string
scCursur_a = .data:0x8164E290; // type:object size:0x9 data:string
lbl_8164E290 = .data:0x8164E290; // type:object size:0x9 data:string
lbl_8164E299 = .data:0x8164E299; // type:object size:0x1B data:string
lbl_8164E2B4 = .data:0x8164E2B4; // type:object size:0x1A data:string
lbl_8164E2CE = .data:0x8164E2CE; // type:object size:0x19 data:string
lbl_8164E2E8 = .data:0x8164E2E8; // type:object size:0xC
lbl_8164E2F4 = .data:0x8164E2F4; // type:object size:0xA data:string
lbl_8164E300 = .data:0x8164E300; // type:object size:0x28
scModuleData = .data:0x8164E328; // type:object size:0x387
scBrlan_RsoFmt = .data:0x8164E6AF; // type:object size:0x20
scBrlyt_my_IplTop_b = .data:0x8164E6CF; // type:object size:0x12 data:string
scBrlan_my_IplTop_b = .data:0x8164E6E1; // type:object size:0x12 data:string
scBrlyt_my_IplTop_d = .data:0x8164E6F3; // type:object size:0x12 data:string
scBrlyt_my_IplTopBalloon_a = .data:0x8164E705; // type:object size:0x19 data:string
scBrlan_BalloonInOut = .data:0x8164E71E; // type:object size:0x26 data:string
scSE_BALLOON = .data:0x8164E744; // type:object size:0x1F data:string
scGroup_G_FocusBtnA = .data:0x8164E768; // type:object size:0xC data:string
scGroup_G_FocusBtnB = .data:0x8164E774; // type:object size:0xC data:string
scGroup_G_SelectBtnA = .data:0x8164E780; // type:object size:0xD data:string
scGroup_G_SelectBtnB = .data:0x8164E78D; // type:object size:0xD data:string
scGroup_G_OnOffBtnA = .data:0x8164E79A; // type:object size:0xC data:string
scGroup_G_OnOffBtnB = .data:0x8164E7A6; // type:object size:0xC data:string
scGroup_G_ChangeTextA = .data:0x8164E7B2; // type:object size:0xE data:string
scGroup_G_ChangeTextB = .data:0x8164E7C0; // type:object size:0xE data:string
lbl_8164E328 = .data:0x8164E328; // type:object size:0x387
lbl_8164E6AF = .data:0x8164E6AF; // type:object size:0x20
lbl_8164E6CF = .data:0x8164E6CF; // type:object size:0x12 data:string
lbl_8164E6E1 = .data:0x8164E6E1; // type:object size:0x12 data:string
lbl_8164E6F3 = .data:0x8164E6F3; // type:object size:0x12 data:string
lbl_8164E705 = .data:0x8164E705; // type:object size:0x19 data:string
lbl_8164E71E = .data:0x8164E71E; // type:object size:0x26 data:string
lbl_8164E744 = .data:0x8164E744; // type:object size:0x1F data:string
lbl_8164E768 = .data:0x8164E768; // type:object size:0xC data:string
lbl_8164E774 = .data:0x8164E774; // type:object size:0xC data:string
lbl_8164E780 = .data:0x8164E780; // type:object size:0xD data:string
lbl_8164E78D = .data:0x8164E78D; // type:object size:0xD data:string
lbl_8164E79A = .data:0x8164E79A; // type:object size:0xC data:string
lbl_8164E7A6 = .data:0x8164E7A6; // type:object size:0xC data:string
lbl_8164E7B2 = .data:0x8164E7B2; // type:object size:0xE data:string
lbl_8164E7C0 = .data:0x8164E7C0; // type:object size:0xE data:string
scAnimGroups__Q23ipl5scene = .data:0x8164E7D0; // type:object size:0x24
scBrlan_my_ChTop_a_FocusBtnA_off = .data:0x8164E7F4; // type:object size:0x1F data:string
scBrlan_my_ChTop_a_FocusBtn_on = .data:0x8164E813; // type:object size:0x1D data:string
scBrlan_my_ChTop_a_SelectBtn_Ac = .data:0x8164E830; // type:object size:0x1E data:string
scBrlan_my_ChTop_a_OffBtn = .data:0x8164E84E; // type:object size:0x18 data:string
scBrlan_my_ChTop_a_OnBtn = .data:0x8164E866; // type:object size:0x17 data:string
scBrlan_my_ChTop_a_ChangeTextOut = .data:0x8164E87D; // type:object size:0x1F data:string
scBrlan_my_ChTop_a_ChangeTextIn = .data:0x8164E89C; // type:object size:0x1E data:string
scBrlan_my_ChTop_a_ChangeIn = .data:0x8164E8BA; // type:object size:0x1A data:string
scBrlan_my_ChTop_a_ChangeRoop = .data:0x8164E8D4; // type:object size:0x1C data:string
scBrlan_my_ChTop_a_ChangeOut = .data:0x8164E8F0; // type:object size:0x1B data:string
lbl_8164E7F4 = .data:0x8164E7F4; // type:object size:0x1F data:string
lbl_8164E813 = .data:0x8164E813; // type:object size:0x1D data:string
lbl_8164E830 = .data:0x8164E830; // type:object size:0x1E data:string
lbl_8164E84E = .data:0x8164E84E; // type:object size:0x18 data:string
lbl_8164E866 = .data:0x8164E866; // type:object size:0x17 data:string
lbl_8164E87D = .data:0x8164E87D; // type:object size:0x1F data:string
lbl_8164E89C = .data:0x8164E89C; // type:object size:0x1E data:string
lbl_8164E8BA = .data:0x8164E8BA; // type:object size:0x1A data:string
lbl_8164E8D4 = .data:0x8164E8D4; // type:object size:0x1C data:string
lbl_8164E8F0 = .data:0x8164E8F0; // type:object size:0x1B data:string
scAnimNames__Q23ipl5scene = .data:0x8164E90C; // type:object size:0x28
scBrlan_banner = .data:0x8164E934; // type:object size:0xD data:string
scBrlan_banner_Start = .data:0x8164E941; // type:object size:0x13 data:string
scBrlan_banner_Loop = .data:0x8164E954; // type:object size:0x12 data:string
lbl_8164E934 = .data:0x8164E934; // type:object size:0xD data:string
lbl_8164E941 = .data:0x8164E941; // type:object size:0x13 data:string
lbl_8164E954 = .data:0x8164E954; // type:object size:0x12 data:string
scBannerAnims__Q23ipl5scene = .data:0x8164E968; // type:object size:0xC
scGroup_G_Comment0 = .data:0x8164E974; // type:object size:0xB data:string
scGroup_G_DiskIn = .data:0x8164E97F; // type:object size:0x9 data:string
lbl_8164E974 = .data:0x8164E974; // type:object size:0xB data:string
lbl_8164E97F = .data:0x8164E97F; // type:object size:0x9 data:string
scDiskGroups__Q23ipl5scene = .data:0x8164E988; // type:object size:0x14 data:4byte
scBrlan_my_DiskCh_a_Start = .data:0x8164E99C; // type:object size:0x18 data:string
scBrlan_my_DiskCh_a_DiskStart = .data:0x8164E9B4; // type:object size:0x1C data:string
scBrlan_my_DiskCh_a_DiskLoop = .data:0x8164E9D0; // type:object size:0x1B data:string
scBrlan_my_DiskCh_a_DiskEnd = .data:0x8164E9EB; // type:object size:0x1A data:string
scBrlan_my_DiskCh_a_DiskLost = .data:0x8164EA05; // type:object size:0x1B data:string
scBrlan_my_DiskCh_a_DiskIn = .data:0x8164EA20; // type:object size:0x19 data:string
scBrlan_my_DiskCh_a_DiskEject = .data:0x8164EA39; // type:object size:0x1C data:string
scBrlan_my_DiskCh_a_Unknown = .data:0x8164EA55; // type:object size:0x1A data:string
scBrlan_my_DiskCh_a_UnknownLoop = .data:0x8164EA6F; // type:object size:0x1E data:string
scBrlan_my_DiskCh_a_UnknwnEject = .data:0x8164EA8D; // type:object size:0x1E data:string
lbl_8164E99C = .data:0x8164E99C; // type:object size:0x18 data:string
lbl_8164E9B4 = .data:0x8164E9B4; // type:object size:0x1C data:string
lbl_8164E9D0 = .data:0x8164E9D0; // type:object size:0x1B data:string
lbl_8164E9EB = .data:0x8164E9EB; // type:object size:0x1A data:string
lbl_8164EA05 = .data:0x8164EA05; // type:object size:0x1B data:string
lbl_8164EA20 = .data:0x8164EA20; // type:object size:0x19 data:string
lbl_8164EA39 = .data:0x8164EA39; // type:object size:0x1C data:string
lbl_8164EA55 = .data:0x8164EA55; // type:object size:0x1A data:string
lbl_8164EA6F = .data:0x8164EA6F; // type:object size:0x1E data:string
lbl_8164EA8D = .data:0x8164EA8D; // type:object size:0x1E data:string
scDiskAnimNames__Q23ipl5scene = .data:0x8164EAAC; // type:object size:0x28 data:4byte
scBrlyt_my_DiskCh_a = .data:0x8164EAD4; // type:object size:0x12 data:string
scBrlan_my_GCTop_a_BackLoop = .data:0x8164EAE6; // type:object size:0x1A data:string
lbl_8164EAD4 = .data:0x8164EAD4; // type:object size:0x12 data:string
lbl_8164EAE6 = .data:0x8164EAE6; // type:object size:0x1A data:string
scWidePanes__Q23ipl5scene = .data:0x8164EB00; // type:object size:0x30
lbl_8164EB30 = .data:0x8164EB30; // type:object size:0xC data:string
lbl_8164EB3C = .data:0x8164EB3C; // type:object size:0xCC
@@ -18149,7 +18149,7 @@ lbl_8166A6B1 = .data:0x8166A6B1; // type:object size:0xD data:string
lbl_8166A6BE = .data:0x8166A6BE; // type:object size:0xD data:string
lbl_8166A6CB = .data:0x8166A6CB; // type:object size:0xC data:string
lbl_8166A6D7 = .data:0x8166A6D7; // type:object size:0xC data:string
scCsFatalMsg = .data:0x8166A6E3; // type:object size:0x41 data:string
lbl_8166A6E3 = .data:0x8166A6E3; // type:object size:0x41 data:string
lbl_8166A728 = .data:0x8166A728; // type:object size:0xB data:string
lbl_8166A733 = .data:0x8166A733; // type:object size:0x9 data:string
lbl_8166A73C = .data:0x8166A73C; // type:object size:0xB data:string
@@ -18235,13 +18235,13 @@ jumptable_8166B3D0 = .data:0x8166B3D0; // type:object size:0x30 scope:local
@1137 = .data:0x8166B450; // type:object size:0x22 scope:local data:string
jumptable_8166B478 = .data:0x8166B478; // type:object size:0x30 scope:local
lbl_8166B4B8 = .data:0x8166B4B8; // type:object size:0x70
scCdbMsg_DatabaseClosed = .data:0x8166B528; // type:object size:0x25 data:string
scCdbMsg_CantCreateRecordClosed = .data:0x8166B550; // type:object size:0x29 data:string
scCdbMsg_CantCreateRecordReadonly = .data:0x8166B57C; // type:object size:0x2B data:string
scCdbMsg_InvalidKey = .data:0x8166B5A8; // type:object size:0xD data:string
scCdbMsg_FileNotFound = .data:0x8166B5B8; // type:object size:0x15 data:string
scCdbMsg_CantCleanupDirsClosed = .data:0x8166B5D0; // type:object size:0x46 data:string
scCdbMsg_CantCleanupDirsReadonly = .data:0x8166B618; // type:object size:0x48 data:string
lbl_8166B528 = .data:0x8166B528; // type:object size:0x25 data:string
lbl_8166B550 = .data:0x8166B550; // type:object size:0x29 data:string
lbl_8166B57C = .data:0x8166B57C; // type:object size:0x2B data:string
lbl_8166B5A8 = .data:0x8166B5A8; // type:object size:0xD data:string
lbl_8166B5B8 = .data:0x8166B5B8; // type:object size:0x15 data:string
lbl_8166B5D0 = .data:0x8166B5D0; // type:object size:0x46 data:string
lbl_8166B618 = .data:0x8166B618; // type:object size:0x48 data:string
@1360 = .data:0x8166B660; // type:object size:0x12 scope:local data:string
...data.0 = .data:0x8166B660; // type:label scope:local
@1362 = .data:0x8166B674; // type:object size:0x1C scope:local data:string
@@ -18453,7 +18453,7 @@ __FUNCTION__$1195 = .data:0x8166E0FC; // type:object size:0x1C scope:local data:
__FUNCTION__$1217 = .data:0x8166E118; // type:object size:0x1C scope:local data:string
__FUNCTION__$1255 = .data:0x8166E134; // type:object size:0x14 scope:local data:string
__FUNCTION__$1287 = .data:0x8166E148; // type:object size:0x18 scope:local data:string
scNwc24FlPath = .data:0x8166E160; // type:object size:0x1A data:string
lbl_8166E160 = .data:0x8166E160; // type:object size:0x1A data:string
@583 = .data:0x8166E180; // type:object size:0x1B scope:local data:string
__FUNCTION__$1123 = .data:0x8166E1A0; // type:object size:0x18 scope:local data:string
@1300 = .data:0x8166E1B8; // type:object size:0x11 scope:local data:string
@@ -18664,7 +18664,7 @@ __vt__Q34nw4r3lyt7Picture = .data:0x816717F4; // type:object size:0x6C
@5574 = .data:0x816718E8; // type:object size:0x41 scope:local data:string
__vt__Q34nw4r3lyt7TextBox = .data:0x8167192C; // type:object size:0x74
flipInfos$7849 = .data:0x816719A0; // type:object size:0x3C scope:local
scLytFatalMsg = .data:0x816719DC; // type:object size:0x41 data:string
lbl_816719DC = .data:0x816719DC; // type:object size:0x41 data:string
__vt__Q34nw4r3lyt6Window = .data:0x81671A20; // type:object size:0x7C
__vt__Q34nw4r3lyt8Bounding = .data:0x81671AA0; // type:object size:0x64
kColSels$4880 = .data:0x81671B08; // type:object size:0x20 scope:local data:4byte
@@ -19181,13 +19181,13 @@ base64_array = .data:0x816874A0; // type:object size:0x80 scope:local
@2185 = .data:0x816876A0; // type:object size:0x21 scope:local data:string
@654 = .data:0x816876C8; // type:object size:0x48 scope:local data:string
ShutdownFunctionInfo = .data:0x81687710; // type:object size:0x10 scope:local
scWpadVersionStr = .data:0x81687720; // type:object size:0x49 data:string
lbl_81687720 = .data:0x81687720; // type:object size:0x49 data:string
lbl_8168776C = .data:0x8168776C; // type:object size:0x1C data:string
lbl_81687788 = .data:0x81687788; // type:object size:0x1B data:string
lbl_816877A4 = .data:0x816877A4; // type:object size:0x2F data:string
lbl_816877D4 = .data:0x816877D4; // type:object size:0x27 data:string
ShutdownFunctionInfo = .data:0x81687800; // type:object size:0x10 scope:local
scWpadManageStrs = .data:0x81687810; // type:object size:0x58
lbl_81687810 = .data:0x81687810; // type:object size:0x58
lbl_81687868 = .data:0x81687868; // type:object size:0xC data:string
lbl_81687874 = .data:0x81687874; // type:object size:0x37 data:string
lbl_816878AC = .data:0x816878AC; // type:object size:0xB4
@@ -20016,7 +20016,7 @@ lbl_81691040 = .data:0x81691040; // type:object size:0x2D0
lbl_81691310 = .data:0x81691310; // type:object size:0x3B data:string
lbl_8169134C = .data:0x8169134C; // type:object size:0x3DC
st_uhs_msc_blk_func = .data:0x81691728; // type:object size:0x20
__sdPathData = .data:0x81691748; // type:object size:0x50
lbl_81691748 = .data:0x81691748; // type:object size:0x50
lbl_81691798 = .data:0x81691798; // type:object size:0x16 data:string
lbl_816917B0 = .data:0x816917B0; // type:object size:0xD data:string
lbl_816917C0 = .data:0x816917C0; // type:object size:0x15 data:string
@@ -20050,8 +20050,8 @@ lbl_816932D0 = .data:0x816932D0; // type:object size:0x48 data:string
lbl_81693318 = .data:0x81693318; // type:object size:0xA data:string
lbl_81693324 = .data:0x81693324; // type:object size:0x15 data:string
@466 = .data:0x81693340; // type:object size:0xD scope:local data:string
scCntCacheStrs = .data:0x81693350; // type:object size:0xD0
scCntCacheTitleDataFmt = .data:0x81693420; // type:object size:0x16 data:string
lbl_81693350 = .data:0x81693350; // type:object size:0xD0
lbl_81693420 = .data:0x81693420; // type:object size:0x16 data:string
__vt__Q23EGG9Allocator = .data:0x81693438; // type:object size:0x14
__vt__Q23EGG9ArcPlayer = .data:0x81693450; // type:object size:0x54
__vt__Q23EGG20SimpleAudioMgrWithFx = .data:0x816934A8; // type:object size:0x78
@@ -20107,12 +20107,12 @@ gDBCommTable = .data:0x816943C8; // type:object size:0x28
lbl_81694410 = .sdata2:0x81694410; // type:object size:0x4 align:4 data:float
lbl_81694418 = .sdata2:0x81694418; // type:object size:0x8 align:8 data:double
lbl_81694420 = .sdata2:0x81694420; // type:object size:0x4 align:4 data:float
scOrthoLeft = .sdata2:0x81694424; // type:object size:0x4 align:4 data:float
scOrthoRight = .sdata2:0x81694428; // type:object size:0x4 align:4 data:float
scOrthoBottom = .sdata2:0x8169442C; // type:object size:0x4 align:4 data:float
scOrthoTop = .sdata2:0x81694430; // type:object size:0x4 align:4 data:float
scWideOrthoLeft = .sdata2:0x81694434; // type:object size:0x4 align:4 data:float
scWideOrthoRight = .sdata2:0x81694438; // type:object size:0x4 align:4 data:float
lbl_81694424 = .sdata2:0x81694424; // type:object size:0x4 align:4 data:float
lbl_81694428 = .sdata2:0x81694428; // type:object size:0x4 align:4 data:float
lbl_8169442C = .sdata2:0x8169442C; // type:object size:0x4 align:4 data:float
lbl_81694430 = .sdata2:0x81694430; // type:object size:0x4 align:4 data:float
lbl_81694434 = .sdata2:0x81694434; // type:object size:0x4 align:4 data:float
lbl_81694438 = .sdata2:0x81694438; // type:object size:0x4 align:4 data:float
lbl_81694440 = .sdata2:0x81694440; // type:object size:0x4 align:4 data:float
lbl_81694444 = .sdata2:0x81694444; // type:object size:0x4 align:4 data:float
lbl_81694448 = .sdata2:0x81694448; // type:object size:0x8 align:8 data:double
@@ -20192,7 +20192,7 @@ lbl_816944EB = .sdata2:0x816944EB; // type:object size:0x1 data:byte
@23221 = .sdata2:0x81694588; // type:object size:0x8 scope:local align:8 data:double
lbl_81694590 = .sdata2:0x81694590; // type:object size:0x4 align:4 data:float
lbl_81694594 = .sdata2:0x81694594; // type:object size:0x4 align:4 data:float
scRsoZeroF = .sdata2:0x81694598; // type:object size:0x4 align:4 data:float
lbl_81694598 = .sdata2:0x81694598; // type:object size:0x4 align:4 data:float
lbl_816945A0 = .sdata2:0x816945A0; // type:object size:0x4 align:4 data:float
lbl_816945A4 = .sdata2:0x816945A4; // type:object size:0x4 align:4 data:float
lbl_816945A8 = .sdata2:0x816945A8; // type:object size:0x4 align:4 data:float
@@ -20201,10 +20201,10 @@ lbl_816945B0 = .sdata2:0x816945B0; // type:object size:0x4 align:4 data:float
lbl_816945B4 = .sdata2:0x816945B4; // type:object size:0x4 align:4 data:float
lbl_816945B8 = .sdata2:0x816945B8; // type:object size:0x8 align:8 data:double
lbl_816945C0 = .sdata2:0x816945C0; // type:object size:0x8 align:8 data:double
scTvrcMsPerSec = .sdata2:0x816945C8; // type:object size:0x4 align:4 data:float
scTvrcNsecPerSec = .sdata2:0x816945D0; // type:object size:0x8 align:8 data:double
scTvrcOne = .sdata2:0x816945D8; // type:object size:0x8 align:8 data:double
scTvrcFloatMagic = .sdata2:0x816945E0; // type:object size:0x8 align:8 data:double
lbl_816945C8 = .sdata2:0x816945C8; // type:object size:0x4 align:4 data:float
lbl_816945D0 = .sdata2:0x816945D0; // type:object size:0x8 align:8 data:double
lbl_816945D8 = .sdata2:0x816945D8; // type:object size:0x8 align:8 data:double
lbl_816945E0 = .sdata2:0x816945E0; // type:object size:0x8 align:8 data:double
lbl_816945E8 = .sdata2:0x816945E8; // type:object size:0x4 align:4 data:float
lbl_816945EC = .sdata2:0x816945EC; // type:object size:0x4 align:4 data:float
lbl_816945F0 = .sdata2:0x816945F0; // type:object size:0x4 align:4 data:float
@@ -20370,9 +20370,9 @@ lbl_816948E8 = .sdata2:0x816948E8; // type:object size:0x8 align:4 data:float
@16092 = .sdata2:0x816948F4; // type:object size:0x4 scope:local align:4 data:float
@16094 = .sdata2:0x816948F8; // type:object size:0x4 scope:local align:4 data:float
@16095 = .sdata2:0x816948FC; // type:object size:0x4 scope:local align:4 data:float
scHalfF = .sdata2:0x81694900; // type:object size:0x4 align:4 data:float
scTwoF = .sdata2:0x81694904; // type:object size:0x4 align:4 data:float
scF2IBias = .sdata2:0x81694908; // type:object size:0x8 align:8 data:double
lbl_81694900 = .sdata2:0x81694900; // type:object size:0x4 align:4 data:float
lbl_81694904 = .sdata2:0x81694904; // type:object size:0x4 align:4 data:float
lbl_81694908 = .sdata2:0x81694908; // type:object size:0x8 align:8 data:double
lbl_81694910 = .sdata2:0x81694910; // type:object size:0x4 align:4 data:float
lbl_81694914 = .sdata2:0x81694914; // type:object size:0x4 align:4 data:float
lbl_81694918 = .sdata2:0x81694918; // type:object size:0x4 align:4 data:float
@@ -20710,12 +20710,12 @@ lbl_81694ECC = .sdata2:0x81694ECC; // type:object size:0x4 align:4 data:float
@880 = .sdata2:0x81694ED4; // type:object size:0x4 scope:local align:4 data:float
@885 = .sdata2:0x81694ED8; // type:object size:0x4 scope:local align:4 data:float
@888 = .sdata2:0x81694EE0; // type:object size:0x8 scope:local align:8 data:double
scGuiZeroF = .sdata2:0x81694EE8; // type:object size:0x4 align:4 data:float
scGuiLineColorR = .sdata2:0x81694EEC; // type:object size:0x1 data:byte
scGuiLineColorG = .sdata2:0x81694EED; // type:object size:0x1 data:byte
scGuiLineColorB = .sdata2:0x81694EEE; // type:object size:0x1 data:byte
scGuiLineColorA = .sdata2:0x81694EEF; // type:object size:0x1 data:byte
scGuiHalfF = .sdata2:0x81694EF0; // type:object size:0x4 align:4 data:float
lbl_81694EE8 = .sdata2:0x81694EE8; // type:object size:0x4 align:4 data:float
lbl_81694EEC = .sdata2:0x81694EEC; // type:object size:0x1 data:byte
lbl_81694EED = .sdata2:0x81694EED; // type:object size:0x1 data:byte
lbl_81694EEE = .sdata2:0x81694EEE; // type:object size:0x1 data:byte
lbl_81694EEF = .sdata2:0x81694EEF; // type:object size:0x1 data:byte
lbl_81694EF0 = .sdata2:0x81694EF0; // type:object size:0x4 align:4 data:float
lbl_81694EF8 = .sdata2:0x81694EF8; // type:object size:0x8 data:4byte
lbl_81694F00 = .sdata2:0x81694F00; // type:object size:0x4 data:4byte
lbl_81694F08 = .sdata2:0x81694F08; // type:object size:0x8 align:8 data:double
@@ -20741,7 +20741,7 @@ lbl_81694FA0 = .sdata2:0x81694FA0; // type:object size:0x7 data:string
lbl_81694FA7 = .sdata2:0x81694FA7; // type:object size:0x5 data:string
lbl_81694FAC = .sdata2:0x81694FAC; // type:object size:0xC align:4
lbl_81694FB8 = .sdata2:0x81694FB8; // type:object size:0x8 align:8 data:double
scCsZeroF = .sdata2:0x81694FC0; // type:object size:0x4 align:4 data:float
lbl_81694FC0 = .sdata2:0x81694FC0; // type:object size:0x4 align:4 data:float
@10105 = .sdata2:0x81694FC8; // type:object size:0x4 scope:local align:4 data:float
@9941 = .sdata2:0x81694FD0; // type:object size:0x8 scope:local data:4byte
@10304 = .sdata2:0x81694FD8; // type:object size:0x8 scope:local align:8 data:double
@@ -20769,12 +20769,12 @@ NET_AES_BLOCK_MODE_CBC = .sdata2:0x81695040; // type:object size:0x8
@524 = .sdata2:0x81695050; // type:object size:0x2 scope:local data:byte
@1077 = .sdata2:0x81695054; // type:object size:0x2 scope:local data:byte
@1128 = .sdata2:0x81695058; // type:object size:0x2 scope:local data:byte
scRsnOui0 = .sdata2:0x81695060; // type:object size:0x1 data:byte
scRsnOui1 = .sdata2:0x81695061; // type:object size:0x1 data:byte
scRsnOui2 = .sdata2:0x81695062; // type:object size:0x1 data:byte
scWpaOui0 = .sdata2:0x81695064; // type:object size:0x1 data:byte
scWpaOui1 = .sdata2:0x81695065; // type:object size:0x1 data:byte
scWpaOui2 = .sdata2:0x81695066; // type:object size:0x1 data:byte
lbl_81695060 = .sdata2:0x81695060; // type:object size:0x1 data:byte
lbl_81695061 = .sdata2:0x81695061; // type:object size:0x1 data:byte
lbl_81695062 = .sdata2:0x81695062; // type:object size:0x1 data:byte
lbl_81695064 = .sdata2:0x81695064; // type:object size:0x1 data:byte
lbl_81695065 = .sdata2:0x81695065; // type:object size:0x1 data:byte
lbl_81695066 = .sdata2:0x81695066; // type:object size:0x1 data:byte
scFilePermissions = .sdata2:0x81695068; // type:object size:0x2 scope:local
cWhite = .sdata2:0x81695070; // type:object size:0x4 scope:local data:byte
@2829 = .sdata2:0x81695074; // type:object size:0x4 scope:local align:4 data:float
@@ -21025,10 +21025,10 @@ lbl_8169553B = .sdata2:0x8169553B; // type:object size:0x1 data:byte
lbl_8169553C = .sdata2:0x8169553C; // type:object size:0x4 align:4 data:float
lbl_81695540 = .sdata2:0x81695540; // type:object size:0x8 align:8 data:double
lbl_81695548 = .sdata2:0x81695548; // type:object size:0x8 align:8 data:double
scLytFatalColorR = .sdata2:0x81695550; // type:object size:0x1 data:byte
scLytFatalColorG = .sdata2:0x81695551; // type:object size:0x1 data:byte
scLytFatalColorB = .sdata2:0x81695552; // type:object size:0x1 data:byte
scLytFatalColorA = .sdata2:0x81695553; // type:object size:0x5 data:byte
lbl_81695550 = .sdata2:0x81695550; // type:object size:0x1 data:byte
lbl_81695551 = .sdata2:0x81695551; // type:object size:0x1 data:byte
lbl_81695552 = .sdata2:0x81695552; // type:object size:0x1 data:byte
lbl_81695553 = .sdata2:0x81695553; // type:object size:0x5 data:byte
@6184 = .sdata2:0x81695558; // type:object size:0x4 scope:local align:4 data:float
@6185 = .sdata2:0x8169555C; // type:object size:0x4 scope:local align:4 data:float
@6186 = .sdata2:0x81695560; // type:object size:0x4 scope:local align:4 data:float
@@ -21548,10 +21548,10 @@ lbl_81696220 = .sdata:0x81696220; // type:object size:0x2 data:string
lbl_81696222 = .sdata:0x81696222; // type:object size:0x2
lbl_81696224 = .sdata:0x81696224; // type:object size:0x6 data:wstring
lbl_8169622A = .sdata:0x8169622A; // type:object size:0x2
scRsoFatalColorR = .sdata:0x8169622C; // type:object size:0x1 data:byte
scRsoFatalColorG = .sdata:0x8169622D; // type:object size:0x1 data:byte
scRsoFatalColorB = .sdata:0x8169622E; // type:object size:0x1 data:byte
scRsoFatalColorA = .sdata:0x8169622F; // type:object size:0x1 data:byte
lbl_8169622C = .sdata:0x8169622C; // type:object size:0x1 data:byte
lbl_8169622D = .sdata:0x8169622D; // type:object size:0x1 data:byte
lbl_8169622E = .sdata:0x8169622E; // type:object size:0x1 data:byte
lbl_8169622F = .sdata:0x8169622F; // type:object size:0x1 data:byte
lbl_81696230 = .sdata:0x81696230; // type:object size:0x5 data:string
TVRC_FILE_HEADER__7LibTVRC = .sdata:0x81696238; // type:object size:0x4 data:4byte
__tienHoseiNsec__7LibTVRC = .sdata:0x8169623C; // type:object size:0x4 data:4byte
@@ -21589,7 +21589,7 @@ lbl_816962DB = .sdata:0x816962DB; // type:object size:0x8 data:string
lbl_816962E3 = .sdata:0x816962E3; // type:object size:0x1
lbl_816962E4 = .sdata:0x816962E4; // type:object size:0x8 data:string
lbl_816962F0 = .sdata:0x816962F0; // type:object size:0x8 data:string
scWwwErrorQ = .sdata:0x816962F8; // type:object size:0x8 data:string
lbl_816962F8 = .sdata:0x816962F8; // type:object size:0x8 data:string
globalNames__Q23www9trasition = .sdata:0x81696300; // type:object size:0x8 scope:local
@1425 = .sdata:0x81696308; // type:object size:0x1 scope:local
gEnableDpd = .sdata:0x81696310; // type:object size:0x4 data:4byte
@@ -21753,7 +21753,7 @@ lbl_816966E1 = .sdata:0x816966E1; // type:object size:0x6 data:string
lbl_816966E7 = .sdata:0x816966E7; // type:object size:0x7 data:string
lbl_816966EE = .sdata:0x816966EE; // type:object size:0x7 data:string
lbl_816966F5 = .sdata:0x816966F5; // type:object size:0x4 data:string
scPaneName_B_Stop = .sdata:0x816966F9; // type:object size:0x7 data:string
lbl_816966F9 = .sdata:0x816966F9; // type:object size:0x7 data:string
lbl_81696700 = .sdata:0x81696700; // type:object size:0x6 data:string
lbl_81696706 = .sdata:0x81696706; // type:object size:0x5 data:string
lbl_8169670B = .sdata:0x8169670B; // type:object size:0x6 data:string
@@ -21781,15 +21781,15 @@ lbl_81696797 = .sdata:0x81696797; // type:object size:0x8 data:string
lbl_8169679F = .sdata:0x8169679F; // type:object size:0x8 data:string
lbl_816967A7 = .sdata:0x816967A7; // type:object size:0x7 data:string
lbl_816967AE = .sdata:0x816967AE; // type:object size:0x7 data:string
scPaneName_T_Stop = .sdata:0x816967B5; // type:object size:0x7 data:string
lbl_816967B5 = .sdata:0x816967B5; // type:object size:0x7 data:string
lbl_816967C0 = .sdata:0x816967C0; // type:object size:0x4 data:string
lbl_816967C4 = .sdata:0x816967C4; // type:object size:0x6 data:string
lbl_816967CA = .sdata:0x816967CA; // type:object size:0x7 data:string
scW_Cal = .sdata:0x816967D8; // type:object size:0x6 data:string
scT_Cal = .sdata:0x816967DE; // type:object size:0x6 data:string
scCal_Ac = .sdata:0x816967E4; // type:object size:0x7 data:string
scInfo_a = .sdata:0x816967EB; // type:object size:0x7 data:string
scB_Cal = .sdata:0x816967F2; // type:object size:0x6 data:string
lbl_816967D8 = .sdata:0x816967D8; // type:object size:0x6 data:string
lbl_816967DE = .sdata:0x816967DE; // type:object size:0x6 data:string
lbl_816967E4 = .sdata:0x816967E4; // type:object size:0x7 data:string
lbl_816967EB = .sdata:0x816967EB; // type:object size:0x7 data:string
lbl_816967F2 = .sdata:0x816967F2; // type:object size:0x6 data:string
@16087 = .sdata:0x816967F8; // type:object size:0x4 scope:local data:string
@16350 = .sdata:0x816967FC; // type:object size:0x7 scope:local data:string
@16351 = .sdata:0x81696803; // type:object size:0x7 scope:local data:string
@@ -21802,8 +21802,8 @@ lbl_8169682A = .sdata:0x8169682A; // type:object size:0x7 data:string
lbl_81696831 = .sdata:0x81696831; // type:object size:0x7 data:string
lbl_81696838 = .sdata:0x81696838; // type:object size:0x7 data:string
lbl_8169683F = .sdata:0x8169683F; // type:object size:0x7 data:string
scGroup_G_Data = .sdata:0x81696848; // type:object size:0x7 data:string
scUnknownWstr = .sdata:0x81696850; // type:object size:0x8 data:wstring
lbl_81696848 = .sdata:0x81696848; // type:object size:0x7 data:string
lbl_81696850 = .sdata:0x81696850; // type:object size:0x8 data:wstring
s_all_pane_name__Q33ipl5scene10ChanAppBox = .sdata:0x81696858; // type:object size:0x6 data:string
lbl_81696860 = .sdata:0x81696860; // type:object size:0x7 data:string
lbl_81696867 = .sdata:0x81696867; // type:object size:0x7 data:string
@@ -21858,11 +21858,11 @@ lbl_816968F5 = .sdata:0x816968F5; // type:object size:0x4 data:string
@10922 = .sdata:0x81696992; // type:object size:0x3 scope:local data:string
@10923 = .sdata:0x81696995; // type:object size:0x3 scope:local data:string
lbl_81696998 = .sdata:0x81696998; // type:object size:0x4 data:4byte
scPaneName_T_Balloon = .sdata:0x8169699C; // type:object size:0x4 data:4byte
lbl_8169699C = .sdata:0x8169699C; // type:object size:0x4 data:4byte
lbl_816969A0 = .sdata:0x816969A0; // type:object size:0x7 data:string
scPaneName_W_Base = .sdata:0x816969A8; // type:object size:0x4 data:4byte
lbl_816969A8 = .sdata:0x816969A8; // type:object size:0x4 data:4byte
lbl_816969AC = .sdata:0x816969AC; // type:object size:0x8 data:string
scPaneName_W_Shade = .sdata:0x816969B4; // type:object size:0x4 data:4byte
lbl_816969B4 = .sdata:0x816969B4; // type:object size:0x4 data:4byte
lbl_816969B8 = .sdata:0x816969B8; // type:object size:0x4 data:string
lbl_816969BC = .sdata:0x816969BC; // type:object size:0x4 data:string
lbl_816969C0 = .sdata:0x816969C0; // type:object size:0x4 data:string
@@ -21872,41 +21872,41 @@ lbl_816969CC = .sdata:0x816969CC; // type:object size:0x4 data:string
lbl_816969D0 = .sdata:0x816969D0; // type:object size:0x4 data:string
lbl_816969D4 = .sdata:0x816969D4; // type:object size:0x4 data:string
lbl_816969D8 = .sdata:0x816969D8; // type:object size:0x4 data:string
scExport_Calc = .sdata:0x816969DC; // type:object size:0x5 data:string
scExport_Create = .sdata:0x816969E1; // type:object size:0x7 data:string
scArc = .sdata:0x816969E8; // type:object size:0x4 data:string
lbl_816969DC = .sdata:0x816969DC; // type:object size:0x5 data:string
lbl_816969E1 = .sdata:0x816969E1; // type:object size:0x7 data:string
lbl_816969E8 = .sdata:0x816969E8; // type:object size:0x4 data:string
lbl_816969EC = .sdata:0x816969EC; // type:object size:0x6 data:string
lbl_816969F2 = .sdata:0x816969F2; // type:object size:0x5 data:string
lbl_816969F7 = .sdata:0x816969F7; // type:object size:0x4 data:string
lbl_816969FB = .sdata:0x816969FB; // type:object size:0x4 data:string
lbl_816969FF = .sdata:0x816969FF; // type:object size:0x4 data:string
lbl_81696A03 = .sdata:0x81696A03; // type:object size:0x7 data:string
scPaneName_B_BtnA = .sdata:0x81696A10; // type:object size:0x7 data:string
scPaneName_B_BtnB = .sdata:0x81696A17; // type:object size:0x7 data:string
scPaneNames_B_Btn = .sdata:0x81696A20; // type:object size:0x8 data:4byte
scGroup_Change = .sdata:0x81696A28; // type:object size:0x7 data:string
scGroupNames_Change = .sdata:0x81696A30; // type:object size:0x4 data:4byte
scGroup_G_Wii = .sdata:0x81696A34; // type:object size:0x6 data:string
scGroup_G_GC = .sdata:0x81696A3A; // type:object size:0x5 data:string
lbl_81696A10 = .sdata:0x81696A10; // type:object size:0x7 data:string
lbl_81696A17 = .sdata:0x81696A17; // type:object size:0x7 data:string
lbl_81696A20 = .sdata:0x81696A20; // type:object size:0x8 data:4byte
lbl_81696A28 = .sdata:0x81696A28; // type:object size:0x7 data:string
lbl_81696A30 = .sdata:0x81696A30; // type:object size:0x4 data:4byte
lbl_81696A34 = .sdata:0x81696A34; // type:object size:0x6 data:string
lbl_81696A3A = .sdata:0x81696A3A; // type:object size:0x5 data:string
scLayoutNames__Q23ipl5scene = .sdata:0x81696A40; // type:object size:0x4 data:4byte
scGroup_G_Back = .sdata:0x81696A44; // type:object size:0x7 data:string
lbl_81696A44 = .sdata:0x81696A44; // type:object size:0x7 data:string
scGCAnimGroups__Q23ipl5scene = .sdata:0x81696A4C; // type:object size:0x4 data:4byte
scGCAnimNames__Q23ipl5scene = .sdata:0x81696A50; // type:object size:0x4 data:4byte
scPaneName_Fre_a = .sdata:0x81696A54; // type:object size:0x6 data:string
scPaneName_Fre_d = .sdata:0x81696A5A; // type:object size:0x6 data:string
scPaneName_Fre_i = .sdata:0x81696A60; // type:object size:0x6 data:string
scPaneName_Fre_l = .sdata:0x81696A66; // type:object size:0x6 data:string
scPaneName_Fre_e = .sdata:0x81696A6C; // type:object size:0x6 data:string
scPaneName_Fre_f = .sdata:0x81696A72; // type:object size:0x6 data:string
scPaneName_Fre_g = .sdata:0x81696A78; // type:object size:0x6 data:string
scPaneName_Fre_h = .sdata:0x81696A7E; // type:object size:0x6 data:string
scPaneName_Fre_b = .sdata:0x81696A84; // type:object size:0x6 data:string
scPaneName_Fre_c = .sdata:0x81696A8A; // type:object size:0x6 data:string
scPaneName_Fre_j = .sdata:0x81696A90; // type:object size:0x6 data:string
scPaneName_Fre_k = .sdata:0x81696A96; // type:object size:0x6 data:string
scPaneName_T_BtnA = .sdata:0x81696A9C; // type:object size:0x7 data:string
scPaneName_T_BtnB = .sdata:0x81696AA3; // type:object size:0x7 data:string
scPaneNames_T_Btn__Q23ipl5scene = .sdata:0x81696AAC; // type:object size:0x8 data:4byte
lbl_81696A54 = .sdata:0x81696A54; // type:object size:0x6 data:string
lbl_81696A5A = .sdata:0x81696A5A; // type:object size:0x6 data:string
lbl_81696A60 = .sdata:0x81696A60; // type:object size:0x6 data:string
lbl_81696A66 = .sdata:0x81696A66; // type:object size:0x6 data:string
lbl_81696A6C = .sdata:0x81696A6C; // type:object size:0x6 data:string
lbl_81696A72 = .sdata:0x81696A72; // type:object size:0x6 data:string
lbl_81696A78 = .sdata:0x81696A78; // type:object size:0x6 data:string
lbl_81696A7E = .sdata:0x81696A7E; // type:object size:0x6 data:string
lbl_81696A84 = .sdata:0x81696A84; // type:object size:0x6 data:string
lbl_81696A8A = .sdata:0x81696A8A; // type:object size:0x6 data:string
lbl_81696A90 = .sdata:0x81696A90; // type:object size:0x6 data:string
lbl_81696A96 = .sdata:0x81696A96; // type:object size:0x6 data:string
lbl_81696A9C = .sdata:0x81696A9C; // type:object size:0x7 data:string
lbl_81696AA3 = .sdata:0x81696AA3; // type:object size:0x7 data:string
lbl_81696AAC__Q23ipl5scene = .sdata:0x81696AAC; // type:object size:0x8 data:4byte
lbl_81696AB4 = .sdata:0x81696AB4; // type:object size:0x4
lbl_81696AB8 = .sdata:0x81696AB8; // type:object size:0x4
lbl_81696ABC = .sdata:0x81696ABC; // type:object size:0x4 data:string
@@ -22466,10 +22466,10 @@ lbl_81697824 = .sdata:0x81697824; // type:object size:0x8 data:string
lbl_8169782C = .sdata:0x8169782C; // type:object size:0x8 data:string
lbl_81697834 = .sdata:0x81697834; // type:object size:0x8 data:string
lbl_8169783C = .sdata:0x8169783C; // type:object size:0x8 data:string
scCsFatalColorR = .sdata:0x81697844; // type:object size:0x1 data:byte
scCsFatalColorG = .sdata:0x81697845; // type:object size:0x1 data:byte
scCsFatalColorB = .sdata:0x81697846; // type:object size:0x1 data:byte
scCsFatalColorA = .sdata:0x81697847; // type:object size:0x1 data:byte
lbl_81697844 = .sdata:0x81697844; // type:object size:0x1 data:byte
lbl_81697845 = .sdata:0x81697845; // type:object size:0x1 data:byte
lbl_81697846 = .sdata:0x81697846; // type:object size:0x1 data:byte
lbl_81697847 = .sdata:0x81697847; // type:object size:0x1 data:byte
lbl_81697848 = .sdata:0x81697848; // type:object size:0x8 data:string
lbl_81697850 = .sdata:0x81697850; // type:object size:0x6 data:string
lbl_81697858 = .sdata:0x81697858; // type:object size:0x6 data:string
@@ -22538,7 +22538,7 @@ lbl_816979C8 = .sdata:0x816979C8; // type:object size:0x5 data:string
lbl_816979D0 = .sdata:0x816979D0; // type:object size:0x5 data:string
lbl_816979D8 = .sdata:0x816979D8; // type:object size:0x4 data:string
lbl_816979E0 = .sdata:0x816979E0; // type:object size:0x8 data:string
CDBFSPathSeparator = .sdata:0x816979E8; // type:object size:0x1 data:byte
lbl_816979E8 = .sdata:0x816979E8; // type:object size:0x1 data:byte
@1433 = .sdata:0x816979F0; // type:object size:0x4 scope:local data:string
@1435 = .sdata:0x816979F4; // type:object size:0x1 scope:local
@1440 = .sdata:0x816979F8; // type:object size:0x6 scope:local data:string
@@ -22700,9 +22700,9 @@ __SSLVersion = .sdata:0x81697CE0; // type:object size:0x4 data:4byte
qErr$1631 = .sdata:0x81697D58; // type:object size:0x4 scope:local data:4byte
l_dev_nandflash_init_info = .sdata:0x81697D60; // type:object size:0x8 scope:local
l_dev_sd_direct_init_info = .sdata:0x81697D68; // type:object size:0x8 scope:local
scWpaFindOui0 = .sdata:0x81697D70; // type:object size:0x1 data:byte
scWpaFindOui1 = .sdata:0x81697D71; // type:object size:0x1 data:byte
scWpaFindOui2 = .sdata:0x81697D72; // type:object size:0x1 data:byte
lbl_81697D70 = .sdata:0x81697D70; // type:object size:0x1 data:byte
lbl_81697D71 = .sdata:0x81697D71; // type:object size:0x1 data:byte
lbl_81697D72 = .sdata:0x81697D72; // type:object size:0x1 data:byte
__RFLVersion = .sdata:0x81697D78; // type:object size:0x4 data:4byte
sRFLLastErrCode = .sdata:0x81697D7C; // type:object size:0x4 scope:local data:4byte
scResFileFullPathName = .sdata:0x81697D80; // type:object size:0x4 scope:local data:4byte
@@ -23109,7 +23109,7 @@ lbl_816983EC = .sdata:0x816983EC; // type:object size:0x6 data:string
__KBDVersion = .sdata:0x816985C8; // type:object size:0x4 data:4byte
__KPRVersion = .sdata:0x816985D0; // type:object size:0x4 data:4byte
__CNTCACHEVersion = .sdata:0x816985D8; // type:object size:0x4 data:4byte
scCntCacheSpaceNl = .sdata:0x816985DC; // type:object size:0x3 data:string
lbl_816985DC = .sdata:0x816985DC; // type:object size:0x3 data:string
@428 = .sdata:0x816985E0; // type:object size:0x4 scope:local data:string
@429 = .sdata:0x816985E4; // type:object size:0x3 scope:local data:string
@442 = .sdata:0x816985E7; // type:object size:0x8 scope:local data:string
@@ -23191,7 +23191,7 @@ _repeatBitLength__7LibTVRC = .sbss:0x81698768; // type:object size:0x4 data:4byt
_repeatBitArray__7LibTVRC = .sbss:0x8169876C; // type:object size:0x4 data:4byte
_tickT__7LibTVRC = .sbss:0x81698770; // type:object size:0x4 data:4byte
m_handle__Q23ipl11TVRCManager = .sbss:0x81698778; // type:object size:0x4 data:4byte
sTvrcStartDelay__3ipl = .sbss:0x8169877C; // type:object size:0x4 data:4byte
lbl_8169877C__3ipl = .sbss:0x8169877C; // type:object size:0x4 data:4byte
suIDCounter__Q23gui11PaneManager = .sbss:0x81698780; // type:object size:0x4 data:4byte
_bgmBlk__Q23ipl3snd = .sbss:0x81698788; // type:object size:0x4
_mainBGMHandle__Q23ipl3snd = .sbss:0x8169878C; // type:object size:0x4 data:4byte
@@ -23331,7 +23331,7 @@ opera_callbacks__Q23www10wiisetting = .sbss:0x816989A0; // type:object size:0x4
sStatus__Q23www9arcreader = .sbss:0x816989A8; // type:object size:0x4 scope:local data:4byte
lbl_816989B0 = .sbss:0x816989B0; // type:object size:0x4 data:4byte
sBatteryFlag__Q210homebutton10Controller = .sbss:0x816989B8; // type:object size:0x4
sAlarmCreated__Q210homebutton10Controller = .sbss:0x816989BC; // type:object size:0x4
lbl_816989BC__Q210homebutton10Controller = .sbss:0x816989BC; // type:object size:0x4
suIDCounter__Q310homebutton3gui11PaneManager = .sbss:0x816989C0; // type:object size:0x4 data:4byte
spInstance__Q210homebutton9RemoteSpk = .sbss:0x816989C8; // type:object size:0x4 data:4byte
InvalidShutdown = .sbss:0x816989D0; // type:object size:0x4 data:4byte

View File

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

View File

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

View File

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

View File

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

View File

@@ -35,8 +35,8 @@ namespace ext_ead {
class SurfaceManager {
public:
static void CreateManager(int surfaceW, int surfaceH, int browserW, int browserH, void* mem1Buf, u32 mem1BufSize, void* mem2Buf, u32 mem2BufSize,
void* libBuf, const char* arcPath);
static void CreateManager(int rectW0, int rectH0, int rectW1, int rectH1, void* mem1Buf, u32 mem1BufSize, void* mem2Buf, u32 mem2BufSize,
void* libBuf, const char* param_10);
static void DisposeManager();
static void RegisterArcFile(void* fileBuf);

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -133,11 +133,7 @@ namespace textinput {
friend class Base;
public:
RowInfoManager(u16 maxLength) : mpInfo(NULL), mMaxLength(maxLength), mpAllocator(NULL) {}
#ifdef TIINPUTFORM_IMPLEMENTATION
void init() __attribute__((never_inline));
#else
void init();
#endif
~RowInfoManager();
#endif
private:
@@ -149,7 +145,7 @@ namespace textinput {
#ifdef TISIGNWINDOW_IMPLEMENTATION
bool isAtokActive() const;
#endif
#if defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
#ifdef MYTILETTERFORM_IMPLEMENTATION
virtual void create(MEMAllocator* allocator);
virtual void init();
virtual void onCommand(INPUT_COMMAND command, void* data);
@@ -388,7 +384,7 @@ namespace textinput {
virtual void setRootPaneScaleFor16x9();
virtual void setRootPaneScaleFor4x3();
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION) || defined(MYTIINPUTFORM_IMPLEMENTATION)
#if defined(TIINPUTFORM_IMPLEMENTATION) || defined(TIMANAGER_IMPLEMENTATION) || defined(MYTILETTERFORM_IMPLEMENTATION)
virtual void onSE(sound::SE seId);
#endif

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -336,19 +336,19 @@ namespace ipl {
BOOL nand_error_handling(int code);
SEntry* findEntryByTitleId(ESTitleId titleId);
u32 getBannerCSIdx(ESTitleId titleId);
u32 getSoundSize(ESTitleId titleId);
BOOL needsNetSetting(ESTitleId titleId);
BOOL usesAltSound(ESTitleId titleId);
BOOL isMissingTicket(ESTitleId titleId);
BOOL isNewsChannelV6Plus(ESTitleId titleId);
BOOL isOperaChannel(ESTitleId titleId);
nand::MetaFile* readBannerMetaAsync(EGG::Heap* heap, ESTitleId titleId);
nand::MetaFile* readSoundMetaAsync(EGG::Heap* heap, ESTitleId titleId);
nand::SharedFile* readBannerCSAsync(EGG::Heap* heap, ESTitleId titleId);
void clearTmpChannel();
void unloadBanner(ESTitleId titleId);
SEntry* fn_8133A4E0(ESTitleId titleId);
u32 fn_8133A57C(ESTitleId titleId);
u32 fn_8133A5B8(ESTitleId titleId);
BOOL fn_8133A5F0(ESTitleId titleId);
BOOL fn_8133A634(ESTitleId titleId);
BOOL fn_8133A678(ESTitleId titleId);
BOOL fn_8133A6B8(ESTitleId titleId);
BOOL fn_8133A73C(ESTitleId titleId);
nand::MetaFile* fn_8133A7A4(EGG::Heap* heap, ESTitleId titleId);
nand::MetaFile* fn_8133A85C(EGG::Heap* heap, ESTitleId titleId);
nand::SharedFile* fn_8133A924(EGG::Heap* heap, ESTitleId titleId);
void fn_8133A9F0();
void fn_8133AA50(ESTitleId titleId);
BOOL isReady() { return mState == FINISH; }

View File

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

View File

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

View File

@@ -92,7 +92,7 @@ namespace ipl {
void read_sd_app_location_async(ESTitleId32* titleIds);
void check_for_sd_app_to_nand_async(ESTitleId titleId, AppBlocksInfo* usedBlocks, AppBlocksInfo* freeBlocks);
void check_backup_fits_async(TitleIdList* newTitles, TitleIdList* replacingTitles);
void check_sd_app_titles_async(void* ptrA, void* ptrB, void* ptrC);
void iplNandSD_81348EA8(void* ptrA, void* ptrB, void* ptrC);
void list_nand_apps_usage_async(void* ptrA, void* ptr);
@@ -514,7 +514,7 @@ namespace ipl {
void do_check_for_sd_app_to_nand();
void check_backup_fits();
void do_list_nand_apps_usage();
void do_check_sd_app_titles();
void do_unk_8134C838();
void do_move_nand_app_to_sd();
void do_move_sd_app_to_nand();

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -301,9 +301,9 @@ namespace nw4r {
}
if (error == OS_EXCEPTION_FLOATING_POINT_EXCEPTION) {
u32 fpcsr = sException.FPCSR_COPY;
fpcsr &= (((fpcsr & 0xf8) << 0x16) | 0x01f80700);
if ((fpcsr & 0x20000000) != 0) {
u32 uVar1 = sException.FPCSR_COPY;
uVar1 &= (((uVar1 & 0xf8) << 0x16) | 0x01f80700);
if ((uVar1 & 0x20000000) != 0) {
Exception_Printf_(" FPE: Invalid operation\n");
if ((sException.FPCSR_COPY & 0x1000000) != 0) {
Exception_Printf_(" SNaN\n");
@@ -333,16 +333,16 @@ namespace nw4r {
Exception_Printf_(" Invalid integer convert\n");
}
}
if ((fpcsr & 0x10000000) != 0) {
if ((uVar1 & 0x10000000) != 0) {
Exception_Printf_(" FPE: Overflow\n");
}
if ((fpcsr & 0x8000000) != 0) {
if ((uVar1 & 0x8000000) != 0) {
Exception_Printf_(" FPE: Underflow\n");
}
if ((fpcsr & 0x4000000) != 0) {
if ((uVar1 & 0x4000000) != 0) {
Exception_Printf_(" FPE: Zero division\n");
}
if ((fpcsr & 0x2000000) != 0) {
if ((uVar1 & 0x2000000) != 0) {
Exception_Printf_(" FPE: Inexact result\n");
}
}

View File

@@ -1,19 +1,19 @@
#include <nw4r/db/assert.h>
extern "C" const u8 scLytFatalColorR = 255;
extern "C" const u8 scLytFatalColorG = 255;
extern "C" const u8 scLytFatalColorB = 255;
extern "C" const u8 scLytFatalColorA = 0;
extern "C" char scLytFatalMsg[] = "Error#004\nAn error has occurred.\nThe system files are corrupted.";
extern "C" const u8 lbl_81695550 = 255;
extern "C" const u8 lbl_81695551 = 255;
extern "C" const u8 lbl_81695552 = 255;
extern "C" const u8 lbl_81695553 = 0;
extern "C" char lbl_816719DC[] = "Error#004\nAn error has occurred.\nThe system files are corrupted.";
#undef NW4R_ASSERT
#define NW4R_ASSERT(x) \
{ \
if (!(x)) { \
GXColor front = {*((volatile const u8*)&::scLytFatalColorR), *((volatile const u8*)&::scLytFatalColorG), \
*((volatile const u8*)&::scLytFatalColorB), *((volatile const u8*)&::scLytFatalColorA)}; \
GXColor front = {*((volatile const u8*)&::lbl_81695550), *((volatile const u8*)&::lbl_81695551), \
*((volatile const u8*)&::lbl_81695552), *((volatile const u8*)&::lbl_81695553)}; \
GXColor back = {0, 0, 0, 0}; \
OSFatal((GXColor)front, (GXColor)back, ::scLytFatalMsg); \
OSFatal((GXColor)front, (GXColor)back, ::lbl_816719DC); \
} \
}

View File

@@ -17,95 +17,7 @@ static TMCHuffmanEntry readHuffmanLimit(const TMCHuffmanEntry* entries) {
return limit;
}
static inline s32 decodeLongHuffman(s32 bitCount, const TMCHuffmanEntry* table, const u8* symbols, TMCCJPEGDecWork* work) {
u32 bitData;
u32 code;
u32 length;
const TMCHuffmanEntry* entry;
if (bitCount <= 17) {
s32 result = TMCJPEGDEC_load_buff(work);
if (result < 0) {
return result;
}
}
bitCount = work->bitCount;
bitData = work->bitBuf;
bitCount -= 9;
code = (bitData >> bitCount) & 0x1FF;
work->bitCount = bitCount;
length = 9;
entry = table + 9;
goto read_entry;
while (1) {
length++;
entry++;
if (length > 16) {
return TMCC_ERROR_OVERFLOW;
}
bitCount = work->bitCount;
code <<= 1;
bitData = work->bitBuf;
bitCount--;
work->bitCount = bitCount;
code |= (bitData >> bitCount) & 1;
read_entry:
{
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
if (code > (u32)decoded.bitLength) {
continue;
}
code = code - entry->bitLength + entry->symbol;
return symbols[code & 0xFF];
}
}
}
static inline s32 decodeACHuffman(s32 bitCount, const TMCHuffmanEntry* entry, const u8* symbols, TMCCJPEGDecWork* work) {
u32 bitData;
u32 code;
u32 length;
if (bitCount <= 17) {
s32 result = TMCJPEGDEC_load_buff(work);
if (result < 0) {
return result;
}
}
bitCount = work->bitCount;
bitData = work->bitBuf;
bitCount -= 9;
code = (bitData >> bitCount) & 0x1FF;
work->bitCount = bitCount;
length = 9;
entry += 9;
goto read_entry;
while (1) {
length++;
entry++;
if (length > 16) {
return TMCC_ERROR_OVERFLOW;
}
bitCount = work->bitCount;
code <<= 1;
bitData = work->bitBuf;
bitCount--;
work->bitCount = bitCount;
code |= (bitData >> bitCount) & 1;
read_entry:
{
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
if (code > (u32)decoded.bitLength) {
continue;
}
code = code - entry->bitLength + entry->symbol;
return symbols[code & 0xFF];
}
}
}
s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_ptr, TMCCJPEGDecWork* work) {
TMCHuffmanEntry dcEntry;
TMCHuffmanEntry acEntry;
const TMCHuffmanEntry* ac_fast;
u8* huff_sym;
@@ -138,7 +50,7 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
tmp = bit_pos - 8;
tmp = ((bit_data >> tmp) & 0xFF) << 2;
{
dcEntry = readHuffmanEntry(dc_fast, tmp >> 2);
TMCHuffmanEntry dcEntry = readHuffmanEntry(dc_fast, tmp >> 2);
r = dcEntry.bitLength;
extra = dcEntry.symbol;
}
@@ -148,9 +60,64 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
work->bitCount = bit_pos;
r = extra;
} else {
u32 code;
unsigned int i;
const TMCHuffmanEntry* entry;
s32 thresh;
s32 offs;
huff_sym = work->pDCHuffSym;
huff_tbl = work->pDCHuffTbl;
r = decodeLongHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work);
if (bit_pos <= 17) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0) {
return r;
}
}
bit_pos = work->bitCount;
bit_data = work->bitBuf;
bit_pos -= 9;
code = (bit_data >> bit_pos) & 0x1FF;
work->bitCount = bit_pos;
i = 9;
entry = (const TMCHuffmanEntry*)huff_tbl + 9;
goto dc_entry;
while (1) {
i++;
entry++;
if (i > 16) {
r = TMCC_ERROR_OVERFLOW;
goto dc_end;
}
bit_pos = work->bitCount;
code <<= 1;
bit_data = work->bitBuf;
bit_pos--;
work->bitCount = bit_pos;
code |= (bit_data >> bit_pos) & 1;
dc_entry:
{
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
thresh = decoded.bitLength;
offs = decoded.symbol;
}
if (code > (u32)thresh) {
continue;
}
code = code - entry->bitLength + offs;
r = huff_sym[code & 0xFF];
break;
}
dc_end:
if (r < 0) {
return r;
}
@@ -164,15 +131,15 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
if (load_ret < 0) {
return load_ret;
}
bit_pos = work->bitCount;
}
bit_pos = work->bitCount;
bit_data = work->bitBuf;
tmp = 1 << r;
extra = tmp - 1;
bit_pos -= r;
work->bitCount = bit_pos;
extra = extra & (bit_data >> bit_pos);
if (((s32)tmp >> 1) > extra) {
if (extra < (s32)tmp >> 1) {
extra -= tmp - 1;
}
dc_predict_row_ptr[0] += extra;
@@ -180,104 +147,156 @@ s32 TMCJPEGDEC_decode_iquant(s32* block, u8* conv_row_ptr, u32* dc_predict_row_p
*block = dc_predict_row_ptr[0] * blk0;
{
ac_fast = (const TMCHuffmanEntry*)work->pACFast;
huff_tbl = work->pACHuffTbl;
huff_sym = work->pACHuffSym;
ac_fast = (const TMCHuffmanEntry*)work->pACFast;
huff_tbl = work->pACHuffTbl;
huff_sym = work->pACHuffSym;
memset(block + 1, 0, 0xFC);
memset(block + 1, 0, 0xFC);
bit_pos = work->bitCount;
idx = 1;
if (bit_pos <= 8) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0)
bit_pos = work->bitCount;
idx = 1;
if (bit_pos <= 8) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0)
return r;
}
bit_pos = work->bitCount;
zztbl = TMCJPEGDEC_Zigzag_data;
bit_data = work->bitBuf;
t = bit_pos - 8;
acEntry = readHuffmanEntry(ac_fast, (bit_data >> t) & 0xFF);
while (idx < 64) {
s32 ac_thresh = acEntry.bitLength;
if (ac_thresh != 0) {
bit_pos = work->bitCount;
bit_pos -= ac_thresh;
work->bitCount = bit_pos;
r = acEntry.symbol;
} else {
u32 code;
unsigned int i;
const TMCHuffmanEntry* entry;
s32 thresh;
s32 offs;
bit_pos = work->bitCount;
if (bit_pos <= 17) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0) {
return r;
}
bit_pos = work->bitCount;
}
bit_data = work->bitBuf;
bit_pos -= 9;
code = (bit_data >> bit_pos) & 0x1FF;
work->bitCount = bit_pos;
i = 9;
entry = (const TMCHuffmanEntry*)huff_tbl + 9;
goto ac_entry_huff;
while (1) {
i++;
entry++;
if (i > 16) {
r = TMCC_ERROR_OVERFLOW;
goto ac_end;
}
bit_pos = work->bitCount;
code <<= 1;
bit_data = work->bitBuf;
bit_pos--;
work->bitCount = bit_pos;
code |= (bit_data >> bit_pos) & 1;
ac_entry_huff:
{
TMCHuffmanEntry decoded = readHuffmanLimit(entry);
thresh = decoded.bitLength;
offs = decoded.symbol;
}
if (code > (u32)thresh) {
continue;
}
code = code - entry->bitLength + offs;
r = huff_sym[code & 0xFF];
break;
}
ac_end:
if (r < 0) {
return r;
}
}
bit_pos = work->bitCount;
zztbl = TMCJPEGDEC_Zigzag_data;
bit_data = work->bitBuf;
t = bit_pos - 8;
acEntry = readHuffmanEntry(ac_fast, (bit_data >> t) & 0xFF);
t = r & 0x0F;
if (t != 0) {
r >>= 4;
idx += r;
do {
s32 ac_thresh = acEntry.bitLength;
if (ac_thresh != 0) {
if (idx >= 64) {
return TMCC_ERROR_OVERFLOW;
}
zz = zztbl[idx];
bit_pos = work->bitCount;
if (bit_pos <= t + 8) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0) {
return r;
}
bit_pos = work->bitCount;
bit_pos -= ac_thresh;
work->bitCount = bit_pos;
r = acEntry.symbol;
} else {
bit_pos = work->bitCount;
r = decodeACHuffman(bit_pos, (const TMCHuffmanEntry*)huff_tbl, huff_sym, work);
}
tmp = 1 << t;
bit_data = work->bitBuf;
extra = tmp - 1;
bit_pos -= t;
work->bitCount = bit_pos;
t = bit_pos - 8;
extra = extra & (bit_data >> bit_pos);
acEntry = readHuffmanEntry(ac_fast, (bit_data >> t) & 0xFF);
if (extra < (s32)tmp >> 1) {
extra -= tmp - 1;
}
q = ((s32*)conv_row_ptr)[zz];
block[zz] = extra * q;
idx++;
} else {
if (r == 0) {
break;
}
bit_pos = work->bitCount;
if (bit_pos <= 8) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0) {
return r;
}
}
bit_data = work->bitBuf;
bit_pos = work->bitCount;
t = bit_pos - 8;
tmp = ((bit_data >> t) & 0xFF) << 2;
acEntry = readHuffmanEntry(ac_fast, tmp >> 2);
t = r & 0x0F;
if (t != 0) {
r >>= 4;
idx += r;
if (idx >= 64) {
return TMCC_ERROR_OVERFLOW;
}
zz = zztbl[idx];
bit_pos = work->bitCount;
if (bit_pos <= t + 8) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0) {
return r;
}
}
bit_pos = work->bitCount;
tmp = 1 << t;
bit_data = work->bitBuf;
extra = tmp - 1;
bit_pos -= t;
work->bitCount = bit_pos;
t = bit_pos - 8;
extra = extra & (bit_data >> bit_pos);
q = ((s32*)conv_row_ptr)[(u8)zz];
acEntry = readHuffmanEntry(ac_fast, (bit_data >> t) & 0xFF);
if (((s32)tmp >> 1) > extra) {
extra -= tmp - 1;
}
block[(u8)zz] = extra * q;
idx++;
} else {
if (r == 0) {
break;
}
bit_pos = work->bitCount;
if (bit_pos <= 8) {
r = TMCJPEGDEC_load_buff(work);
if (r < 0) {
return r;
}
}
bit_data = work->bitBuf;
bit_pos = work->bitCount;
t = bit_pos - 8;
tmp = ((bit_data >> t) & 0xFF) << 2;
acEntry = readHuffmanEntry(ac_fast, tmp >> 2);
idx += 16;
}
} while (idx < 64);
if (idx > 64) {
return TMCC_ERROR_OVERFLOW;
idx += 16;
}
idx--;
return TMCJPEGDEC_Zigzag_loop[idx];
}
if (idx > 64) {
return TMCC_ERROR_OVERFLOW;
}
idx--;
return TMCJPEGDEC_Zigzag_loop[idx];
}

View File

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

View File

@@ -244,11 +244,6 @@ _error:
static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData* pInfo) {
u16 byteOrder;
u32 ifdOffset;
const u8* entries;
u16 remaining;
u16 count;
s32 entriesSize;
u16 index;
pInfo->thumbnailData = (u8*)data;
pInfo->dataEnd = (u8*)data + size;
pInfo->nextIfdOffset = 0;
@@ -267,8 +262,11 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
return -161;
}
{
entries = data + ifdOffset;
remaining = size - (u16)ifdOffset;
const u8* entries = data + ifdOffset;
u16 remaining = size - (u16)ifdOffset;
u16 count;
s32 entriesSize;
u16 index;
if (remaining < 2) {
return -161;
}
@@ -296,8 +294,11 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
return -161;
}
{
entries = data + ifdOffset;
remaining = size - (u16)ifdOffset;
const u8* entries = data + ifdOffset;
u16 remaining = size - (u16)ifdOffset;
u16 count;
s32 entriesSize;
u16 index;
if (remaining < 2) {
return -161;
}
@@ -318,8 +319,11 @@ static s32 TMCJPEGDEC_exif_parse(const u8* data, u32 size, TMCCJPEGDecExifData*
return -161;
}
{
entries = data + ifdOffset;
remaining = size - (u16)ifdOffset;
const u8* entries = data + ifdOffset;
u16 remaining = size - (u16)ifdOffset;
u16 count;
s32 entriesSize;
u16 index;
if (remaining < 2) {
return -161;
}
@@ -350,7 +354,7 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
case 0x0111:
case 0x0201:
case 0x0202: {
break;
return;
}
case 0x0112: {
pInfo->orientation = readU16(entry + 8, byteOrder);
@@ -470,19 +474,21 @@ static void TMCJPEGDEC_IFD0_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
return;
}
case 0xA002: {
if (type == 3) {
u32 offset = readU32(entry + 8, byteOrder);
if (type == 4) {
pInfo->pixelXDim = offset;
} else if (type == 3) {
pInfo->pixelXDim = readU16(entry + 8, byteOrder);
} else if (type == 4) {
pInfo->pixelXDim = readU32(entry + 8, byteOrder);
}
return;
}
case 0xA003: {
if (type == 3) {
u32 offset = readU32(entry + 8, byteOrder);
if (type == 4) {
pInfo->pixelYDim = offset;
} else if (type == 3) {
pInfo->pixelYDim = readU16(entry + 8, byteOrder);
} else if (type == 4) {
pInfo->pixelYDim = readU32(entry + 8, byteOrder);
}
return;
}
@@ -502,7 +508,7 @@ static void TMCJPEGDEC_IFD1_tag_parse(TMCCJPEGDecExifData* pInfo, u16 byteOrder,
case 0x9000:
case 0x9101:
case 0xA003: {
break;
return;
}
case 0x011A: {
u32 offset;

View File

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

View File

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

View File

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

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -457,7 +457,7 @@ void bta_dm_signal_strength(tBTA_DM_MSG *p_data);
void bta_dm_acl_change(tBTA_DM_MSG *p_data);
BOOLEAN bta_sys_check_compress(int id, UINT8 app_id, BD_ADDR peer_addr);
BOOLEAN bta_sys_check_compress(int, UINT8 app_id, BD_ADDR peer_addr);
void bta_dm_keep_acl(tBTA_DM_MSG *p_data);
void bta_dm_immediate_disable(void);

View File

@@ -151,7 +151,7 @@ UINT8 L2CA_SetTraceLevel(UINT8 new_level);
UINT8 L2CA_SetDesireRole(UINT8 new_role);
BOOLEAN L2CA_SetAclPriority(BD_ADDR bd_addr, UINT8 priority);
void L2CA_SetCompression(UINT16 local_cid, UINT8 pe_type, UINT8 mem_level,
UINT8 wbits, UINT8 direction, UINT8 config,
UINT8 wbits, UINT8 direction, UINT8 param_6,
UINT8 enable);
void L2CA_RegisterCompression(tL2CA_COMPRESS_CB *, signed);
UINT8 L2CA_Flush(UINT16 cid);

View File

@@ -3,7 +3,7 @@
#include <revolution/types.h>
s32 uhf_ker_create_sem(u32 initCount, int flags);
s32 uhf_ker_create_sem(u32 param_1, int param_2);
s32 uhf_ker_delete_sem(int sem);
s32 uhf_ker_get_sem(int sem);

View File

@@ -62,9 +62,9 @@ typedef struct CXUncompContextHuffman {
CXHuffmanDecodeTableEntry decodeTableData[0x200]; // 0x20
} CXUncompContextHuffman;
void CXInitUncompContextRL(CXUncompContextRL* context, u8* data);
void CXInitUncompContextLZ(CXUncompContextLZ* context, u8* data);
void CXInitUncompContextHuffman(CXUncompContextHuffman* context, u8* data);
void CXInitUncompContextRL(CXUncompContextRL* context, u8* param_2);
void CXInitUncompContextLZ(CXUncompContextLZ* context, u8* param_2);
void CXInitUncompContextHuffman(CXUncompContextHuffman* context, u8* param_2);
CXStreamingResult CXReadUncompRL(CXUncompContextRL* context, const void* src, u32 size);
CXStreamingResult CXReadUncompLZ(CXUncompContextLZ* context, const void* src, u32 size);

View File

@@ -40,7 +40,7 @@ ISD_Error ISD_ProbeCard(u32 slot);
ISD_Error ISD_MountCard(u32 slot, SDDev** dev);
ISD_Error ISD_UnmountCard(SDDev* dev);
ISD_Error ISD_GetHCRegister(SDDev* dev, u32 reg, u32* outValue, u32 size) NO_INLINE;
ISD_Error ISD_GetHCRegister(SDDev* dev, u32 param_2, u32* param_3, u32 param_4) NO_INLINE;
ISD_Error ISD_ReadBlock(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRespSize);
ISD_Error ISD_WriteBlock(SDDev* dev, u32 offset, u8* cmdResp, u32 cmdRespSize);

View File

@@ -33,8 +33,8 @@ typedef struct USBKBDCmdLEDAsync {
USBKBDErr USBKBDInitialize(USBKBDAttachCallback attachCb, USBKBDDetachCallback detachCb);
USBKBDErr USBKBDSetLED(u32 device, u8 ledBits, USBKBDCmdLED* cmd);
USBKBDErr USBKBDSetLEDAsync(u32 device, u8 ledBits, USBKBDCmdLEDAsync* cmd, USBKBDCmdLEDCallback cb, void* cbArg);
USBKBDErr USBKBDSetLED(u32, u8, USBKBDCmdLED* cmd);
USBKBDErr USBKBDSetLEDAsync(u32, u8, USBKBDCmdLEDAsync* cmd, USBKBDCmdLEDCallback cb, void* cbArg);
USBKBDErr USBKBDRegisterEventCallback(USBKBDEventCallback cb);

View File

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

View File

@@ -1376,7 +1376,7 @@ static void bta_dm_link_quality_cback(tBTM_LINK_QUALITY_RESULTS *p_result)
}
}
BOOLEAN bta_sys_check_compress(int id, UINT8 app_id, BD_ADDR peer_addr)
BOOLEAN bta_sys_check_compress(int param_1, UINT8 app_id, BD_ADDR peer_addr)
{
BOOLEAN status = FALSE;
int i;
@@ -1399,8 +1399,8 @@ BOOLEAN bta_sys_check_compress(int id, UINT8 app_id, BD_ADDR peer_addr)
}
static BOOLEAN bta_dm_l2cap_server_compress_cback(
BD_ADDR peer_addr, int pe_type, int mem_level, int wbits,
int direction, int config, int enable, UINT8 **p_mem_pool,
BD_ADDR peer_addr, int param_2, int param_3, int param_4,
int param_5, int param_6, int param_7, UINT8 **p_mem_pool,
UINT32 *mem_pool_size)
{
BOOLEAN status = FALSE;

View File

@@ -22,7 +22,7 @@ void bte_hcisu_send(HC_BT_HDR *p_msg, UINT16 event)
GKI_freebuf(p_msg);
}
void bte_hcisu_task(int unused)
void bte_hcisu_task(int param_1)
{
if (p_hcisu_if)
{

View File

@@ -152,11 +152,11 @@ void BTA_CleanUp(tBTA_APP_INFO_CBACK *p_cb)
GKI_shutdown();
}
void bta_usb_close_evt(INT8 status)
void bta_usb_close_evt(INT8 param_1)
{
if (_bte_app_info)
{
if (status >= 0)
if (param_1 >= 0)
(*_bte_app_info)(0);
else
(*_bte_app_info)(1);

View File

@@ -113,20 +113,20 @@ static UINT16 const hcisu_msg_evt_table[] =
MSG_HC_TO_STACK_HCI_EVT,
};
void hcisu_h2_usb_cback(UINT8 event, INT8 status)
void hcisu_h2_usb_cback(UINT8 param_1, INT8 param_2)
{
switch (event)
switch (param_1)
{
case 0:
break;
case 4:
bta_usb_close_evt(status);
bta_usb_close_evt(param_2);
break;
}
}
UINT16 hcisu_h2_receive_msg(UINT16 pipe, tHCISU_H2_CB *p_cb)
UINT16 hcisu_h2_receive_msg(UINT16 param_1, tHCISU_H2_CB *p_cb)
{
UINT16 bytes_read = 0;
UINT8 byte;
@@ -138,7 +138,7 @@ UINT16 hcisu_h2_receive_msg(UINT16 pipe, tHCISU_H2_CB *p_cb)
if (p_cb->at_0x1e != 2)
return 0;
r27 = pipe + 1;
r27 = param_1 + 1;
while (TRUE)
{
@@ -148,36 +148,36 @@ UINT16 hcisu_h2_receive_msg(UINT16 pipe, tHCISU_H2_CB *p_cb)
++bytes_read;
msg_received = FALSE;
switch (p_cb->at_0x1a[pipe])
switch (p_cb->at_0x1a[param_1])
{
case 0:
if (r27 == 1)
{
p_cb->at_0x00[pipe] = GKI_getpoolbuf(GKI_POOL_ID_2);
p_cb->at_0x14[pipe] = 4;
p_cb->at_0x00[param_1] = GKI_getpoolbuf(GKI_POOL_ID_2);
p_cb->at_0x14[param_1] = 4;
}
else if (r27 == 2)
{
p_cb->at_0x00[pipe] = GKI_getpoolbuf(GKI_POOL_ID_3);
p_cb->at_0x14[pipe] = 2;
p_cb->at_0x00[param_1] = GKI_getpoolbuf(GKI_POOL_ID_3);
p_cb->at_0x14[param_1] = 2;
}
else if (r27 == 3)
{
p_cb->at_0x00[pipe] = GKI_getpoolbuf(GKI_POOL_ID_1);
p_cb->at_0x14[pipe] = 3;
p_cb->at_0x00[param_1] = GKI_getpoolbuf(GKI_POOL_ID_1);
p_cb->at_0x14[param_1] = 3;
}
else
{
break;
}
if (p_cb->at_0x00[pipe])
if (p_cb->at_0x00[param_1])
{
p_cb->at_0x00[pipe]->len = 0;
p_cb->at_0x00[pipe]->event =
hcisu_msg_evt_table[p_cb->at_0x14[pipe] - 1];
p_cb->at_0x00[pipe]->offset = 0;
p_cb->at_0x1a[pipe] = 1;
p_cb->at_0x00[param_1]->len = 0;
p_cb->at_0x00[param_1]->event =
hcisu_msg_evt_table[p_cb->at_0x14[param_1] - 1];
p_cb->at_0x00[param_1]->offset = 0;
p_cb->at_0x1a[param_1] = 1;
}
else
{
@@ -185,54 +185,54 @@ UINT16 hcisu_h2_receive_msg(UINT16 pipe, tHCISU_H2_CB *p_cb)
"HCIS: Unable to allocate buffer for incoming HCI "
"message.");
p_cb->at_0x1a[pipe] = 2;
p_cb->at_0x1a[param_1] = 2;
}
p_cb->at_0x0c[pipe] =
hcisu_preamble_table[p_cb->at_0x14[pipe] - 1];
p_cb->at_0x0c[param_1] =
hcisu_preamble_table[p_cb->at_0x14[param_1] - 1];
/* fallthrough */
case 1:
*((UINT8 *)(p_cb->at_0x00[pipe] + 1)
+ p_cb->at_0x00[pipe]->len++) = byte;
*((UINT8 *)(p_cb->at_0x00[param_1] + 1)
+ p_cb->at_0x00[param_1]->len++) = byte;
--p_cb->at_0x0c[pipe];
--p_cb->at_0x0c[param_1];
if (p_cb->at_0x0c[pipe] == 0)
if (p_cb->at_0x0c[param_1] == 0)
{
msg_len = byte;
if (p_cb->at_0x14[pipe] == 2)
if (p_cb->at_0x14[param_1] == 2)
{
msg_len = (msg_len << 8) + p_cb->at_0x17[pipe];
msg_len = (msg_len << 8) + p_cb->at_0x17[param_1];
if ((p_cb->at_0x00[pipe] =
if ((p_cb->at_0x00[param_1] =
(HC_BT_HDR *)l2cap_link_chk_pkt_start(
(BT_HDR *)p_cb->at_0x00[pipe]))
(BT_HDR *)p_cb->at_0x00[param_1]))
== 0)
{
p_cb->at_0x0c[pipe] = msg_len;
p_cb->at_0x0c[param_1] = msg_len;
if (msg_len == 0)
p_cb->at_0x1a[pipe] = 0;
p_cb->at_0x1a[param_1] = 0;
else
p_cb->at_0x1a[pipe] = 4;
p_cb->at_0x1a[param_1] = 4;
break;
}
}
p_cb->at_0x0c[pipe] = msg_len;
p_cb->at_0x0c[param_1] = msg_len;
if (sizeof(HC_BT_HDR)
+ hcisu_preamble_table[p_cb->at_0x14[pipe] - 1]
+ hcisu_preamble_table[p_cb->at_0x14[param_1] - 1]
+ msg_len
> GKI_get_buf_size(p_cb->at_0x00[pipe]))
> GKI_get_buf_size(p_cb->at_0x00[param_1]))
{
GKI_freebuf(p_cb->at_0x00[pipe]);
p_cb->at_0x00[pipe] = NULL;
p_cb->at_0x1a[pipe] = 4;
GKI_freebuf(p_cb->at_0x00[param_1]);
p_cb->at_0x00[param_1] = NULL;
p_cb->at_0x1a[param_1] = 4;
BT_TRACE(HCI, ERROR,
"HCIS: Invalid length for incoming HCI message.");
@@ -242,85 +242,85 @@ UINT16 hcisu_h2_receive_msg(UINT16 pipe, tHCISU_H2_CB *p_cb)
if (msg_len != 0)
{
p_cb->at_0x1a[pipe] = 3;
p_cb->at_0x1a[param_1] = 3;
}
else
{
msg_received = TRUE;
p_cb->at_0x1a[pipe] = 0;
p_cb->at_0x1a[param_1] = 0;
}
}
else
{
p_cb->at_0x17[pipe] = byte;
p_cb->at_0x17[param_1] = byte;
}
break;
case 2:
--p_cb->at_0x0c[pipe];
--p_cb->at_0x0c[param_1];
if (p_cb->at_0x0c[pipe] == 0)
if (p_cb->at_0x0c[param_1] == 0)
{
msg_len = byte;
if (p_cb->at_0x14[pipe] == 2)
msg_len = (msg_len << 8) + p_cb->at_0x17[pipe];
if (p_cb->at_0x14[param_1] == 2)
msg_len = (msg_len << 8) + p_cb->at_0x17[param_1];
p_cb->at_0x0c[pipe] = msg_len;
p_cb->at_0x1a[pipe] = 4;
p_cb->at_0x0c[param_1] = msg_len;
p_cb->at_0x1a[param_1] = 4;
}
else
{
p_cb->at_0x17[pipe] = byte;
p_cb->at_0x17[param_1] = byte;
}
break;
case 3:
*((UINT8 *)(p_cb->at_0x00[pipe] + 1)
+ p_cb->at_0x00[pipe]->len++) = byte;
*((UINT8 *)(p_cb->at_0x00[param_1] + 1)
+ p_cb->at_0x00[param_1]->len++) = byte;
--p_cb->at_0x0c[pipe];
--p_cb->at_0x0c[param_1];
len = UUSB_Read(pipe + 1,
(UINT8 *)(p_cb->at_0x00[pipe] + 1)
+ p_cb->at_0x00[pipe]->len,
p_cb->at_0x0c[pipe]);
len = UUSB_Read(param_1 + 1,
(UINT8 *)(p_cb->at_0x00[param_1] + 1)
+ p_cb->at_0x00[param_1]->len,
p_cb->at_0x0c[param_1]);
p_cb->at_0x00[pipe]->len += len;
p_cb->at_0x0c[pipe] -= len;
p_cb->at_0x00[param_1]->len += len;
p_cb->at_0x0c[param_1] -= len;
bytes_read += len;
if (p_cb->at_0x0c[pipe] == 0)
if (p_cb->at_0x0c[param_1] == 0)
{
if (p_cb->at_0x14[pipe] == 2
if (p_cb->at_0x14[param_1] == 2
&& l2cap_link_chk_pkt_end() == 0)
{
p_cb->at_0x1a[pipe] = 0;
p_cb->at_0x1a[param_1] = 0;
}
else
{
msg_received = TRUE;
p_cb->at_0x1a[pipe] = 0;
p_cb->at_0x1a[param_1] = 0;
}
}
break;
case 4:
--p_cb->at_0x0c[pipe];
--p_cb->at_0x0c[param_1];
if (p_cb->at_0x0c[pipe] == 0)
p_cb->at_0x1a[pipe] = 0;
if (p_cb->at_0x0c[param_1] == 0)
p_cb->at_0x1a[param_1] = 0;
break;
}
if (msg_received)
{
GKI_send_msg(hcisu_h2_cb.at_0x1f, 0, p_cb->at_0x00[pipe]);
p_cb->at_0x00[pipe] = NULL;
GKI_send_msg(hcisu_h2_cb.at_0x1f, 0, p_cb->at_0x00[param_1]);
p_cb->at_0x00[param_1] = NULL;
}
}
@@ -403,7 +403,7 @@ void hcisu_h2_send_msg(tHCISU_H2_CB *p_cb, HC_BT_HDR *p_msg)
hcisu_h2_send_msg_now(p_cb, p_msg);
}
void hcisu_h2_init(UINT8 taskId, UINT8 mbox, UINT16 bufSize)
void hcisu_h2_init(UINT8 param_1, UINT8 param_2, UINT16 param_3)
{
hcisu_h2_cb.at_0x1e = 0;
@@ -411,9 +411,9 @@ void hcisu_h2_init(UINT8 taskId, UINT8 mbox, UINT16 bufSize)
hcisu_h2_cb.at_0x1a[1] = 0;
hcisu_h2_cb.at_0x1a[2] = 0;
hcisu_h2_cb.at_0x1f = taskId;
hcisu_h2_cb.at_0x20 = mbox;
hcisu_h2_cb.at_0x12 = bufSize;
hcisu_h2_cb.at_0x1f = param_1;
hcisu_h2_cb.at_0x20 = param_2;
hcisu_h2_cb.at_0x12 = param_3;
}
BOOLEAN hcisu_h2_open(tHCI_CFG *_p_cfg)

View File

@@ -478,7 +478,7 @@ BOOLEAN L2CA_SetAclPriority(BD_ADDR bd_addr, UINT8 priority)
}
void L2CA_SetCompression(UINT16 local_cid, UINT8 pe_type, UINT8 mem_level,
UINT8 wbits, UINT8 direction, UINT8 config,
UINT8 wbits, UINT8 direction, UINT8 param_6,
UINT8 enable)
{
tL2C_LCB *p_lcb;
@@ -506,7 +506,7 @@ void L2CA_SetCompression(UINT16 local_cid, UINT8 pe_type, UINT8 mem_level,
}
}
void L2CA_RegisterCompression(tL2CA_COMPRESS_CB *p_callback, int unused)
void L2CA_RegisterCompression(tL2CA_COMPRESS_CB *param_1, int param_2)
{
#if 0
/* ... */

View File

@@ -565,7 +565,7 @@ void UUSB_Open(tUUSB *uusb, tUUSB_CBACK *cback)
(void)uusb;
}
UINT16 UUSB_Read(UINT8 pipe, void *buf, UINT16 len)
UINT16 UUSB_Read(UINT8 param_1, void *param_2, UINT16 param_3)
{
return 0;
}
@@ -580,7 +580,7 @@ int UUSB_WriteBuf(/* ... */)
return 0;
}
UINT16 UUSB_Write(UINT8 pipe, void *p_data, UINT16 len, void *unused)
UINT16 UUSB_Write(UINT8 param_1, void *p_data, UINT16 len, void *param_4)
{
short sp18 = 0;
IOSError ret = 0;
@@ -591,7 +591,7 @@ UINT16 UUSB_Write(UINT8 pipe, void *p_data, UINT16 len, void *unused)
if (usb.state != 2)
return 0;
switch (pipe)
switch (param_1)
{
case 0:
p_buf = GKI_getpoolbuf(usb.cmd_buffer_pool);
@@ -656,7 +656,7 @@ UINT16 UUSB_Write(UINT8 pipe, void *p_data, UINT16 len, void *unused)
memcpy(p_buffer, p_data, len);
if (len > 190)
UUSBDBG(" woah ! thats pretty Big ! :%d", len);
UUSBDBG(" woah ! thats pretty Big ! :%d", param_3);
if (usb.at_0x38 < 5 && usb.bulk_buffer_q.count == 0)
{
@@ -696,7 +696,7 @@ UINT16 UUSB_Write(UINT8 pipe, void *p_data, UINT16 len, void *unused)
break;
}
(void)unused;
(void)param_4;
return ret;
}

View File

@@ -7,7 +7,7 @@
#include <stdlib.h>
#include <string.h>
char scCntCacheStrs[0xd0] = {
char lbl_81693350[0xd0] = {
0x3c, 0x3c, 0x20, 0x52, 0x56, 0x4c, 0x5f, 0x53, 0x44, 0x4b, 0x20, 0x2d, 0x20, 0x43, 0x4e, 0x54,
0x43, 0x41, 0x43, 0x48, 0x45, 0x20, 0x09, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x62,
0x75, 0x69, 0x6c, 0x64, 0x3a, 0x20, 0x41, 0x70, 0x72, 0x20, 0x32, 0x30, 0x20, 0x32, 0x30, 0x31,
@@ -22,12 +22,12 @@ char scCntCacheStrs[0xd0] = {
0x74, 0x20, 0x00, 0x00, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x69, 0x74, 0x6c, 0x65, 0x00,
0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x00, 0x00, 0x00
};
char scCntCacheTitleDataFmt[0x16] = {
char lbl_81693420[0x16] = {
0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x2f, 0x25, 0x30, 0x38, 0x78, 0x2f, 0x25, 0x30, 0x38, 0x78,
0x2f, 0x64, 0x61, 0x74, 0x61, 0x00,
};
const char* __CNTCACHEVersion = scCntCacheStrs;
char scCntCacheSpaceNl[3] = {0x20, 0x0a, 0x00};
const char* __CNTCACHEVersion = lbl_81693350;
char lbl_816985DC[3] = {0x20, 0x0a, 0x00};
extern void _savegpr_23();
extern void _restgpr_23();
@@ -72,9 +72,9 @@ asm void CNTCACHEClear() {
mr r11, r12
stw r0, 4(r12)
bl _savegpr_23
lis r30, scCntCacheStrs@ha
lis r30, lbl_81693350@ha
lis r3, _CNTCACHEMutex@ha
addi r30, r30, scCntCacheStrs@l
addi r30, r30, lbl_81693350@l
li r29, 0
addi r3, r3, _CNTCACHEMutex@l
bl OSLockMutex
@@ -146,7 +146,7 @@ L_184:
stb r31, 0(r4)
subf r23, r24, r4
mr r3, r24
la r4, scCntCacheSpaceNl
la r4, lbl_816985DC
bl strtok
cmpwi r3, 0
mr r29, r3
@@ -246,7 +246,7 @@ asm void _CNTCACHEDeleteTitle() {
stwu r1, -0x20(r1)
mflr r0
li r3, 0
la r4, scCntCacheSpaceNl
la r4, lbl_816985DC
stw r0, 0x24(r1)
stw r31, 0x1c(r1)
stw r30, 0x18(r1)
@@ -284,7 +284,7 @@ L_350:
bl ES_DeleteTitleContent
L_364:
li r3, 0
la r4, scCntCacheSpaceNl
la r4, lbl_816985DC
bl strtok
L_370:
cmpwi r3, 0
@@ -305,10 +305,10 @@ asm int _CNTCACHEIsTitleRemovable(ESTitleId titleId) {
subfic r11, r11, -0x2100
stwux r1, r1, r11
mflr r0
lis r5, scCntCacheTitleDataFmt@ha
lis r5, lbl_81693420@ha
stw r0, 4(r12)
li r0, 1
addi r5, r5, scCntCacheTitleDataFmt@l
addi r5, r5, lbl_81693420@l
stw r31, -4(r12)
stw r30, -8(r12)
mr r30, r3
@@ -403,7 +403,7 @@ asm void _CNTCACHEDeleteContent() {
stw r0, 4(r12)
bl _savegpr_26
li r3, 0
la r4, scCntCacheSpaceNl
la r4, lbl_816985DC
bl strtok
li r31, 0
li r4, 0
@@ -441,10 +441,10 @@ asm void _CNTCACHEDeleteContent() {
rlwinm. r0, r3, 0, 0x1b, 0x1b
beq L_6f0
li r3, 0
la r4, scCntCacheSpaceNl
la r4, lbl_816985DC
bl strtok
li r26, 1
lis r27, scCntCacheTitleDataFmt@ha
lis r27, lbl_81693420@ha
b L_6e8
L_5b0:
stw r31, errno(r0)
@@ -488,7 +488,7 @@ L_5e8:
li r0, -1
stw r26, 0x20(r1)
addi r3, r1, 0x40
addi r5, r27, scCntCacheTitleDataFmt@l
addi r5, r27, lbl_81693420@l
stw r26, 0x24(r1)
and r6, r30, r0
and r7, r29, r0
@@ -529,7 +529,7 @@ L_6d4:
bdnz L_5e8
L_6dc:
li r3, 0
la r4, scCntCacheSpaceNl
la r4, lbl_816985DC
bl strtok
L_6e8:
cmpwi r3, 0

View File

@@ -221,11 +221,11 @@ CXSecureResult CXSecureUncompressLZ(const void* src, u32 length, void* dst) {
return CX_SECURE_ERR_OK;
}
BOOL CXiVerifyHuffmanTable_(const void* table, u8 bitSize) {
const u8* a = table;
BOOL CXiVerifyHuffmanTable_(const void* param_1, u8 param_2) {
const u8* a = param_1;
const u8* b = a + 1;
u32 c = *a;
const u8* d = (u8*)table + ((c + 1) << 1);
const u8* d = (u8*)param_1 + ((c + 1) << 1);
u8 e[sizeof(u8) * 0x40];
u32 i;
@@ -233,7 +233,7 @@ BOOL CXiVerifyHuffmanTable_(const void* table, u8 bitSize) {
e[i] = 0;
}
if (bitSize == 4 && c >= 16) {
if (param_2 == 4 && c >= 16) {
return FALSE;
}

View File

@@ -4,8 +4,8 @@
static inline int CXiReadHeader(u8*, int*, const u8*, int, int);
static inline CXHuffmanDecodeTableEntry* GetNextNode(CXHuffmanDecodeTableEntry*, int);
void CXInitUncompContextRL(CXUncompContextRL* context, u8* data) {
context->unk_0x00 = data;
void CXInitUncompContextRL(CXUncompContextRL* context, u8* param_2) {
context->unk_0x00 = param_2;
context->unk_0x04 = 0;
context->unk_0x0e = 0;
context->unk_0x0C = 0;
@@ -13,8 +13,8 @@ void CXInitUncompContextRL(CXUncompContextRL* context, u8* data) {
context->size = 0;
}
void CXInitUncompContextLZ(CXUncompContextLZ* context, u8* data) {
context->unk_0x00 = data;
void CXInitUncompContextLZ(CXUncompContextLZ* context, u8* param_2) {
context->unk_0x00 = param_2;
context->unk_0x04 = 0;
context->unk_0x11 = 0;
context->unk_0x12 = 0;
@@ -125,7 +125,7 @@ CXStreamingResult CXReadUncompRL(CXUncompContextRL* context, const void* src, u3
return CX_STREAMING_ERR_OK;
}
static int CXiReadHeader(u8* pHdrLen, int* pOutLen, const u8* pSrc, int srcSize, int maxOutLen) {
static int CXiReadHeader(u8* pHdrLen, int* pOutLen, const u8* pSrc, int srcSize, int param_5) {
int bytesParsed = 0;
while (*pHdrLen) {
@@ -150,8 +150,8 @@ static int CXiReadHeader(u8* pHdrLen, int* pOutLen, const u8* pSrc, int srcSize,
}
}
if (maxOutLen > 0 && maxOutLen < *pOutLen) {
*pOutLen = maxOutLen;
if (param_5 > 0 && param_5 < *pOutLen) {
*pOutLen = param_5;
}
return bytesParsed;

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

File diff suppressed because it is too large Load Diff

View File

@@ -654,7 +654,7 @@ pf_s32 PFENT_MakeRootDir(PF_VOLUME* p_vol) {
return 7;
}
{
static pf_u8 default_volume_label[12] = "NO NAME ";
static pf_u8 default_volume_label[16] = "NO NAME ";
PFDRV_LoadVolumeLabelFromBuf(p_vol, default_volume_label);
}
return 0;

View File

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

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