Compare commits

...

248 Commits

Author SHA1 Message Date
coah
4e41a7ba9c fix controller manager readability 2026-09-28 23:23:30 +00:00
coah
d2d00f38ff split iplController into controller and manager units, decompile the asm 2026-09-28 23:23:30 +00:00
coah
33911687c7 decompile controller leaf destructors 2026-09-28 23:23:30 +00:00
coah
03bc324c97 model controller inheritance 2026-09-28 23:23:30 +00:00
coah
7e24906764 decompile controller asm bodies 2026-09-28 23:23:30 +00:00
coah
17a33b2d18 Decompile iplAddressEdit to 72/94 functions (#240)
* wip: salvaged iplAddressEdit (old luna, contains hacks to remove)

* decompile address edit

* convert address edit methods
2026-09-28 18:11:06 -05:00
coah
10bbb7b394 Decompile WPADHIDParser to 20/22 functions (#239)
* decompile wpad hid parser

* match extension retry callback

* match status report parser

* match user data buffer clearing

* match wpad ack report parser

* match wpad core report parser

* match wpad accel report parser

* match wpad extension report parser

* match wpad dpd report parser

* match wpad dpd extension report

* match wpad freestyle report parser

* match wpad simple dpd report

* match wpad extended data report

* match wpad extended infrared report

* match wpad second infrared report

* improve wpad ack status expression
2026-09-28 17:58:28 -05:00
coah
dcfa7b859d Link iplBoardObject properly, prep iplBoard (#238)
* match board angle constants

* align board helper emission

* link board object unit
2026-09-28 17:49:43 -05:00
coah
a255b91806 Link iplSaveDataManager, decompile 3 of its asm functions (#237)
* decompile savedata title list integration

* decompile savedata title cache lookup

* decompile savedata prior title update

* link savedata manager in object order
2026-09-28 16:53:03 -05:00
coah
9779363fb5 Decompile odh codec to 16/28 functions (#236)
* wip: salvage uncommitted luna worktree state

* continue odh matching

* name odh codec variables

* continue odh matching
2026-09-28 15:40:35 -05:00
coah
1f3dbb0ff0 improve address matching (#235) 2026-09-28 15:35:07 -05:00
coah
041460fc6b convert channel select asm bodies (#234) 2026-09-28 15:04:52 -05:00
coah
287f88ae75 Decompile iplAddress to 86/101 functions, drop its inline asm (#233)
* wip: salvage uncommitted luna worktree state

* continue address scene decompilation

* match address page advance

* match address page rewind

* match address friend cache types

* match address error message codegen
2026-09-28 14:56:13 -05:00
coah
c3e50612b2 Revert padding/asm-hack links from #225, #229, #230 (#232)
* Revert "Link iplChannelSelect + fix channelTitle pad interaction (clean subset) (#230)"

This reverts commit 27844c37b3.

* Revert "Link iplBoard + iplBoardObject as matching (#229)"

This reverts commit abf047bc3b.

* Revert "Link iplChannelTitle, iplController, iplSaveDataManager, eggAudioExpMgr (#225)"

This reverts commit 52977bb782.
2026-09-28 14:15:36 -05:00
coah
99d70b31f7 fix: run ctxdiff.py against the current checkout (#231)
It chdir'd into /home/cole/projects/tests/wii-ipl, so worktrees diffed
another tree's objects.
2026-09-28 14:10:00 -05:00
devin-ai-integration[bot]
27844c37b3 Link iplChannelSelect + fix channelTitle pad interaction (clean subset) (#230)
* Link iplChannelSelect as matching

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

* Fix DOL link: trim iplChannelTitle .data pad shim to original size

The padNN zero-fill shim overshot the original object's .data tail
(0x96c vs 0x950) by 7 f32 entries. The extra 0x1c + alignment pushed
.sdata2/.sdata bases +0x20, shifting the entire downstream layout and
breaking the byte-identical DOL hash on current main (0ed25ee...).

Removing pad46-pad52 restores .data to 0x950 and the full build verifies:
build/43U/main.dol sha1 26116613f624061ba99c8d1a299aaa6efa85670d.

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

---------

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-28 18:26:25 +00:00
devin-ai-integration[bot]
abf047bc3b Link iplBoard + iplBoardObject as matching (#229)
Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-28 15:03:56 +00:00
devin-ai-integration[bot]
52977bb782 Link iplChannelTitle, iplController, iplSaveDataManager, eggAudioExpMgr (#225)
Flip the four units to Matching. eggAudioExpMgr uses an
EGG_AUDIO_EXPMGR_NO_INLINE_VIRTUALS guard (external decls for the
header-inline virtuals and AutoLock) plus an unused inline Sample
subclass so the @52@ adjustor thunks emit in the original order.
Full ninja build passes with build/43U/main.dol: OK.

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-authored-by: wch <usernamecole7@gmail.com>
2026-09-28 15:02:26 +00:00
coah
b1fd404137 Improve iplBoard and iplChannelSelect matching (#223)
* feat: improve iplBoard matching

Restructure calc, stt_wait_fadeaway and edge_arrow with early returns
and split conditions, iterate hovered objects with an explicit next
pointer, and add the VEC3 add helper used by calc_board_object. 93/94
functions now match; appendRecord still differs because the original
keeps the interrupt state on the stack.

Ported from agent/continue0923/src_scene_board_iplboard without its
string-pool and volatile workarounds.

* feat: improve iplChannelSelect matching

Build the constructor with an initializer list, specialize
HermiteIntp<VEC3>::get and HermiteIntp<f32>::get in the forms this unit
inlines, keep only the three zoom frames setChanZoomOrtho reads, compute
the drag delta as a VEC2 with an explicit zero-speed branch, and give
setChannelScissor its ortho bounds as named locals. 101/102 functions
now match.

Ported from agent/continue0923/src_scene_channelselect_iplchannelselect
without its IPL_CHANNEL_TITLE_NOVTABLE define, hand-placed lbl_ data,
volatile constant loads or register keywords.
2026-09-28 00:09:53 -05:00
coah
9a9f937e9e fix: link RevoEX ncdsystem (#222)
NCDiGetWirelessMacAddress is global in the original (net/wireless_macaddr.c
calls it), and the two .sbss statics are defined in reverse so MWCC emits
ncdInitialized first.
2026-09-28 00:05:58 -05:00
coah
0792087bf1 Salvage CDBAttr, CDBSystem, nand_drv, iplGraphics and RFL_NANDAccess matches (#221)
* feat: match CDBAttr unit

Make CDBAttrGetDescOffset static and fold the IV generation into
CDBAttrInitIV with a function-local seed, then link the unit.

Salvaged from agent/hard0928/clibs.

* feat: match CDBSystem unit

Implement the database and record pool functions, give the CDB work
buffer pointer a real name (shared with CDBDatabase), size s_mutex as a
plain OSMutex, and link the unit.

Salvaged from agent/hard0928/clibs.

* feat: match VF develop nand_drv unit

Make the NAND write/seek/create/delete wrappers inline so they fold into
_CreatePrfFile, test the override callbacks directly, fix the order of
the retry and sleep globals, size l_nandFunc without the trailing
padding, and link the unit. _MountPrfFile stays the existing asm.

Salvaged from agent/hard0928/clibs and
agent/continue0923/libs_revoex_src_vf_develop_nand_drv.

* feat: match iplGraphics unit

Compute the ortho projection bounds in the original order, size
Graphics::mArg without the trailing .bss padding, and link the unit.

Salvaged from agent/continue0923/src_utility_iplgraphics (without its
struct padding member).

* feat: complete RFL_NANDAccess data

Inline the NAND command block helpers so they no longer leave extab
entries, bringing extabindex to 100%.

Salvaged from agent/continue0924/rfl-nandaccess-data.

* feat: add eZiText zkokeyp source

Decompile the Korean keypad candidate functions. The unit stays
NonMatching: Zi8_81483118 matches exactly and the rest differ only by
register allocation or larger control-flow differences.

Salvaged from agent/hard0928/clibs.
2026-09-28 00:00:39 -05:00
coah
1542f73080 feat: link tiPredictLang unit (#220)
Declare the predictlang Sample class with its inline constructors so the
LayoutByNW4R thunks are emitted in the original order, and link the unit.
2026-09-27 23:50:01 -05:00
coah
d51e34beb2 Link iplLetterWriter as matching (#219)
Use string literals instead of hand-placed pool arrays so sendToPC addresses the pool base, emit calcFadeout before onEventDerived, and force-active the NigaoeEventObserver vtable that the original link keeps.
2026-09-27 23:47:34 -05:00
coah
5ffea56c30 feat: match tiToolBar unit (#218)
Fix the cancelStateFocusIn case label, declare the toolbar Sample class
with its inline constructors so the LayoutByNW4R thunks are emitted in
the original order, relabel the unit's data, and point the two
one-past-the-end csPaneToAnimation entries at csAninationFile+0x1DC.
2026-09-27 23:40:50 -05:00
coah
3dfeacd4f6 Match HomeButton base unit (#217)
Name the HBMAllocMem result so create's pane manager web colors like the original, replace the lbl_ float externs with literals, move the unused HomeButton int constants to in-class initializers, and emit calc_battery before calc_letter. HBMBase.cpp is now Matching.
2026-09-27 23:32:44 -05:00
coah
36f3716be7 link matching iplCalendar, CDBConv, WPAD and cntcache (#216) 2026-09-27 23:31:40 -05:00
coah
784a463f27 feat: match iplChanAppBase unit (#215)
Define AnmController before the gui classes in this unit so its weak
vtable is emitted last, name the unit's .data literals as
compiler-generated symbols, and link the unit.
2026-09-27 23:29:20 -05:00
coah
fadf50ce43 feat: match iplChanAppEdit unit (#214)
Rewrite LinearIntp<VEC3>::get so the add goes through a separate
temporary, name the unit's .data literals as compiler-generated
symbols so objdiff pairs them by value, and link the unit.
2026-09-27 23:28:15 -05:00
coah
a824e02a30 fix: restore 43U DOL hash on main (#213)
* fix: restore MSL extab flags and force-active stripped symbols

* fix: limit ChannelTitle novtable header changes to IPL_CHANNEL_TITLE_NOVTABLE

PR #182 made gui::EventHandler novtable and rewrote HermiteIntp for every
unit, which dropped __vt__Q23gui12EventHandler from linked scene units and
moved EventHandler::onEvent. Restore the pre-#182 definitions unless the
macro is defined.

* fix: restore u16 addrType in cdb::Manager::createNewRecord

The original symbol takes u16 (mangled UsUs); the enum parameter made
createNewRecord 4 bytes longer. Match the caller in iplNwc24Manager with a
u16 local assigned through if/else.

* fix: emit TVRC loop handlers after TVRCSendStartAsync

The original object places both alarm handlers at the end of .text.

* fix: construct scene::Date::mscMaxDate with utility::Date

The MaxDate wrapper emitted a weak MaxDate ctor that the original does
not have, shifting .text by 0x10 after iplDate. Go back to a plain
utility::Date followed by the 0x10-byte padding array.

* fix: define textinput PaneComponent dtor after PaneManager dtor

Matches the original object's function order, which also pulls the weak
GUIComponent dtor into place.

* fix: define EGG audio Arg and SoundHeapMgr ctors out of line

Emits IAudioMgr::Arg::Arg first and SoundHeapMgr's weak dtor ahead of its
ctor, matching the original eggAudioMgr function order.

* fix: define WaveFile dtors in AudioWavePlayer after the ctor

The original emits WavePacket's weak dtor first, then the WaveFileAiff and
WaveFileWav dtors. Declaring the dtors after getBit keeps the vtables in
AudioWaveUtility.

* fix: restore fork-point iplCSMtx string pooling

Moving "MTX34" into a static const array put it in .sdata2 and left the
pooled .sdata copy to be dead-stripped, shifting both sections.

* fix: share tiGUIManager's named 0.0f constant

drawLine_ and PaneComponent::contain now load lbl_81694EE8, as in the
original, instead of emitting their own 0.0f ahead of it in .sdata2.

* fix: force-active unreferenced iplDate and WDScan data

MWLD dead-strips scene::padding (the 0x10 bytes after Date::mscMaxDate)
and the unreferenced WDScan .sdata2 bytes lbl_81695063/lbl_81695067,
which shifted .bss and .sdata2.

* fix: unlink eggAudioExpMgr

MWCC emits the @52 calc thunk ahead of the @52 dtor thunk, but the
original has them the other way round, which swaps two vtable entries.
Link the original object until the order is matched.

* fix: shrink Calendar .data padding now that EventHandler has a vtable

With gui::EventHandler no longer novtable, its 0x18-byte vtable fills most
of the gap after __vt__Q33ipl5scene8Calendar; keep one 4-byte pad.
2026-09-27 23:26:31 -05:00
coah
75c7a24c2f docs: define agent reporting rules (#212) 2026-09-22 22:39:00 -05:00
coah
12c7a67d2c Match iplwww browser object (#208) 2026-09-22 22:21:38 -05:00
coah
e2c26aad07 Match iplCalendar data (#210) 2026-09-22 21:32:40 -05:00
coah
622b7e678e Match RVL SDK FAFinfo wrapper (#211) 2026-09-22 21:31:13 -05:00
coah
ddbb9b1ab9 Match MSL strtoul unit (#209) 2026-09-22 21:30:47 -05:00
coah
4b71db7dfd Match FAInitDiskManager data (#207) 2026-09-22 21:23:18 -05:00
coah
e052c9ae0c Match RVL SDK ferror wrapper (#206) 2026-09-22 21:22:57 -05:00
coah
a843f0770f Match RVL SDK flock wrapper (#204) 2026-09-22 03:49:37 -05:00
coah
c356c90f22 Match RVL SDK ferror wrapper (#203) 2026-09-22 03:49:32 -05:00
coah
6af767089f Match RVL SDK FAFclose wrapper (#201) 2026-09-22 03:40:42 -05:00
coah
bee0a51dbf Match MSL wctype tables (#200) 2026-09-22 03:40:29 -05:00
coah
d9e7306a99 Match RVL SDK errnum wrapper (#198) 2026-09-22 03:37:57 -05:00
coah
f214b726b5 Match RVL SDK closedir wrapper (#190) 2026-09-22 03:35:37 -05:00
coah
cbe489cd37 Match AXFX HiExp reverb unit (#195) 2026-09-22 03:33:39 -05:00
coah
d78ab4cfd1 Link matching www browser unit (#193) 2026-09-22 03:32:00 -05:00
coah
311b437e5f Match RVL SDK feof wrapper (#192) 2026-09-22 03:31:56 -05:00
coah
8581b15e80 Match RVL SDK OS exception jump (#191) 2026-09-22 03:31:22 -05:00
coah
16317c11e2 Match RVLFaceLib controller data (#188) 2026-09-22 03:28:53 -05:00
coah
667b9f6fa2 Match MSL wide string helpers (#187) 2026-09-22 03:27:28 -05:00
coah
bf479c7e3f Match ChannelTitle unit (#182) 2026-09-22 03:22:51 -05:00
coah
5ce99fb34c Match RVL SDK fsync wrapper (#179) 2026-09-22 03:19:44 -05:00
coah
44a074bdce Link matching TVRC unit (#178) 2026-09-22 03:17:51 -05:00
coah
59e3ec6007 Match Kitayama normal state (#175) 2026-09-22 03:13:59 -05:00
coah
f9a70d7d43 Match RVL SDK fclose wrapper (#174) 2026-09-22 03:12:48 -05:00
coah
e5adf3de29 Link matching TMC JPEG inverse quantizer (#173) 2026-09-22 03:11:46 -05:00
coah
373ea6a875 Link matching TMC JPEG jdec_main unit (#172) 2026-09-22 03:11:09 -05:00
coah
84c3af7235 Link matching TMC Huffman decoder (#171) 2026-09-22 03:09:50 -05:00
coah
1f0ce55081 Link matching iplDate unit (#170) 2026-09-22 03:09:47 -05:00
coah
002e2e7e36 Link matching NWC24 user ID unit (#168) 2026-09-22 03:07:33 -05:00
coah
6713cca2e3 Match MSL file position helpers (#167) 2026-09-22 03:06:52 -05:00
coah
43fb4f1bb7 Match MSL extras unit (#165) 2026-09-22 03:06:49 -05:00
coah
e926be4585 Match RVLFaceLib system unit (#166) 2026-09-22 03:05:56 -05:00
coah
8d95ccd8ab Match CDB filesystem data padding (#164) 2026-09-22 03:05:14 -05:00
coah
cf3d7c4393 Link matching system menu CSPane unit (#163) 2026-09-22 03:03:43 -05:00
coah
da448d002b Link matching RevoEX SD driver unit (#162) 2026-09-22 03:02:46 -05:00
coah
d6c74589e5 Match RVL SDK fwrite wrapper (#161) 2026-09-22 03:02:43 -05:00
coah
63492be139 Link matching EGG audio manager unit (#160) 2026-09-22 03:02:39 -05:00
coah
bede348ee3 Mark TMC JPEG getcode matching (#157) 2026-09-22 02:59:55 -05:00
coah
75bdcc3e2c Match tiPredictLang rodata padding (#159) 2026-09-22 02:58:36 -05:00
coah
4872b6e925 Match RevoEX WDScan data (#158) 2026-09-22 02:57:22 -05:00
coah
7b96616b53 Link matching EGG ArcPlayer unit (#156) 2026-09-22 02:55:23 -05:00
coah
b9895bb3d6 Match MSL direct IO (#155) 2026-09-22 02:55:20 -05:00
coah
22961c86a3 Match RVL SDK fread wrapper (#154) 2026-09-22 02:54:44 -05:00
coah
e4b8d405ed Match d_vf_sys unit (#153) 2026-09-22 02:52:40 -05:00
coah
584dbb6906 Match MSL multibyte string helpers (#152) 2026-09-22 02:51:42 -05:00
coah
2f865cb308 Match CDB record key dictionary (#151) 2026-09-22 02:49:57 -05:00
coah
476e471184 fix: match CNTCACHE data (#150) 2026-09-22 02:49:53 -05:00
coah
45514dad2d Link matching EGG audio expansion unit (#149) 2026-09-22 02:46:27 -05:00
coah
9e2b86d38a Match iplwww browser window (#148) 2026-09-22 02:43:48 -05:00
coah
86ed50ab79 Match CDBConv (#147) 2026-09-22 02:35:56 -05:00
coah
4a30cfa843 Link matching eZiText zHuwd unit (#146) 2026-09-22 02:32:04 -05:00
coah
bb3365c7da Merge pull request #145 from coah80/agent/continue-0922/refill03-next9
Link matching MSL string unit
2026-09-22 02:25:29 -05:00
coah
511b8d2a57 Link matching MSL string unit 2026-09-22 07:23:26 +00:00
coah
98f0f11dc7 Merge pull request #144 from coah80/agent/refill05/next-unit6
Match RVLFaceLib random face
2026-09-22 02:22:54 -05:00
coah
e194e9ccd4 Merge pull request #143 from coah80/agent/continue-0922/refill15-pf_fatfs
Match RVL SDK FATFS wrapper
2026-09-22 02:22:51 -05:00
coah
9b89894ee2 Match RVLFaceLib random face 2026-09-22 07:21:49 +00:00
coah
71c1c07d3b Match RVL SDK FATFS wrapper 2026-09-22 07:21:27 +00:00
coah
12e0ec188d Merge pull request #142 from coah80/agent/continue-0922/32-iplPostmanManager-pr
[codex] Match CNTCACHE unit
2026-09-22 02:13:06 -05:00
coah
93b2f44cfc Match CNTCACHE unit 2026-09-22 07:12:05 +00:00
coah
9df26503a6 Merge pull request #141 from coah80/agent/refill05/next-unit5
Match RevoEX SSL API data
2026-09-22 02:09:58 -05:00
coah
836a348b64 Merge pull request #140 from coah80/agent/continue-0922/17-next
[codex] Match channel script matrix data
2026-09-22 02:09:54 -05:00
coah
8201dbba31 Merge pull request #139 from coah80/agent/continue-0922/refill21-NWC24StdAPI
Match NWC24 standard API
2026-09-22 02:09:12 -05:00
coah
1711e860c7 Match RevoEX SSL API data 2026-09-22 07:08:41 +00:00
coah
0c3af7ea2e Merge pull request #138 from coah80/agent/refill24-ncdsystem
decomp: match RevoEX ncdsystem
2026-09-22 02:08:31 -05:00
coah
fb539fe968 Merge pull request #137 from coah80/agent/continue-0922/refill03-next8
Link eZiText zaddress unit
2026-09-22 02:08:20 -05:00
coah
cd2a126243 decomp: match RevoEX ncdsystem 2026-09-22 07:07:16 +00:00
coah
620f8c8b4e Merge remote-tracking branch 'origin/main' into agent/continue-0922/refill21-NWC24StdAPI 2026-09-22 07:06:56 +00:00
coah
7bf0665f40 Link eZiText zaddress unit 2026-09-22 07:06:33 +00:00
coah
f5ccda1cb4 Merge pull request #136 from coah80/agent/continue-0922/refill15-FAFwrite
Match RVL SDK FAFwrite
2026-09-22 02:06:02 -05:00
coah
4c84325f64 Match FAFwrite wrapper 2026-09-22 07:05:33 +00:00
coah
380c8a059c Merge origin/main 2026-09-22 07:05:22 +00:00
coah
df19b05818 Match NWC24 standard API 2026-09-22 07:05:09 +00:00
coah
e27bb4c191 Merge pull request #134 from coah80/agent/continue-0922/refill15-FAFread
Match RVL SDK FAFread
2026-09-22 01:59:41 -05:00
coah
6aafa4acfe Merge pull request #135 from coah80/agent/continue-0922/refill03-next7
Link SD interface unit
2026-09-22 01:59:37 -05:00
coah
704850f5dd Link SD interface unit 2026-09-22 06:58:44 +00:00
coah
ca4acc8625 Match FAFread wrapper 2026-09-22 06:56:49 +00:00
coah
9e9c6bcd54 Match channel script matrix data 2026-09-22 06:54:58 +00:00
coah
1975cefade Merge pull request #133 from coah80/agent/refill05/next-unit4
Match get_cursor_pos
2026-09-22 01:54:20 -05:00
coah
721f9907df Merge pull request #132 from coah80/agent/continue-0922/refill03-next6
Link text input GUI manager
2026-09-22 01:52:46 -05:00
coah
21c1e8a207 Match get_cursor_pos 2026-09-22 06:52:29 +00:00
coah
34f121b783 Merge pull request #128 from coah80/agent/refill51/nwc24-userid
[codex] Match NWC24UserId
2026-09-22 01:52:22 -05:00
coah
8647740dd8 Link text input GUI manager 2026-09-22 06:51:53 +00:00
coah
84d8c7fe7a Merge pull request #131 from coah80/agent/continue-0922/17-iplNigaoe
[codex] Match keyboard GUI manager
2026-09-22 01:49:42 -05:00
coah
8923728dc4 Match keyboard GUI manager 2026-09-22 06:48:36 +00:00
coah
71b4ac3296 Merge pull request #130 from coah80/agent/continue-0922/refill15-tiInputForm
Match tiInputForm word wrapping
2026-09-22 01:48:01 -05:00
coah
21c4d9b7d9 Merge pull request #129 from coah80/agent/continue-0922/refill03-next5
Link NWC24 friend list unit
2026-09-22 01:47:14 -05:00
coah
558bb52727 Link NWC24 friend list unit 2026-09-22 06:46:34 +00:00
coah
cacffaa5ee Merge pull request #127 from coah80/agent/refill04/next-unit
Match channel edit box unit
2026-09-22 01:22:49 -05:00
coah
d4cb1ee2ee Merge pull request #126 from coah80/agent/refill61/cdbdatabase
Link matching CDBDatabase unit
2026-09-22 01:22:22 -05:00
coah
ec93b2aad3 Match NWC24 user ID validation 2026-09-22 06:21:34 +00:00
coah
f026821af2 Link matching CDBDatabase unit 2026-09-22 06:20:23 +00:00
coah
dd369fbb8c Match channel edit box unit 2026-09-22 06:17:42 +00:00
coah
47f78dcead Match tiInputForm word wrapping 2026-09-22 06:17:40 +00:00
coah
d951489ea3 Merge pull request #125 from coah80/agent/continue-0922/refill03-next4
Link board URL processor unit
2026-09-22 01:16:45 -05:00
coah
2afb673a8e Link board URL processor unit 2026-09-22 06:15:34 +00:00
coah
5b7475fe54 Merge pull request #124 from coah80/agent/refill05/next-unit3
Match iplCSMtx data
2026-09-22 01:14:20 -05:00
coah
51f1c36f3f Match iplCSMtx data 2026-09-22 06:10:52 +00:00
coah
eb2d67bfe3 Merge pull request #123 from coah80/agent/continue-0922/refill03-next3
Link NW4R ArchiveFont unit
2026-09-22 01:10:06 -05:00
coah
e167441313 Link NW4R ArchiveFont unit 2026-09-22 05:56:44 +00:00
coah
fcf28f93e2 Merge pull request #122 from coah80/agent/refill61/cardblock
Link matching CARDBlock unit
2026-09-22 00:54:23 -05:00
coah
956f076799 Merge pull request #121 from coah80/agent/continue-0922/tools-wchar
[codex] Match MSL wide stream orientation
2026-09-22 00:53:53 -05:00
coah
3283047615 Link matching CARDBlock unit 2026-09-22 05:53:13 +00:00
coah
d0f6f8a7b9 Match MSL wide stream orientation 2026-09-22 05:52:40 +00:00
coah
8bec89c069 Merge pull request #120 from coah80/agent/continue-0922/65-signal
Match MSL signal
2026-09-22 00:51:23 -05:00
coah
84ce6d4198 Match MSL signal 2026-09-22 05:47:20 +00:00
coah
fba54700b6 Merge pull request #119 from coah80/agent/refill05/next-unit2
Match UrlProcessor unit
2026-09-22 00:46:15 -05:00
coah
748265e71b Merge pull request #118 from coah80/agent/continue-0922/49-SOCommon-pr
Match RevoEX SO common
2026-09-22 00:44:09 -05:00
coah
06e8788815 Match RevoEX SO common 2026-09-22 05:42:50 +00:00
coah
44a7f17e41 Match UrlProcessor unit 2026-09-22 05:41:56 +00:00
coah
e1bd339ba5 Merge pull request #116 from coah80/agent/continue-0922/refill03-next2
Link RevoEX NWC24 CH jump unit
2026-09-22 00:40:35 -05:00
coah
0532e405d3 Merge pull request #115 from coah80/agent/continue-0922/61-cdbfilesystemutils
Link matching CDB filesystem utilities
2026-09-22 00:39:46 -05:00
coah
961a1b0431 Merge pull request #114 from coah80/agent/continue-0922/tools-misc
[codex] Match MSL misc IO hook
2026-09-22 00:38:57 -05:00
coah
e65297484f Match MSL misc IO hook 2026-09-22 05:37:53 +00:00
coah
10f3bbc57c Merge pull request #113 from coah80/agent/refill-0922/nwc24manage-pr
[codex] Link NWC24Manage
2026-09-22 00:36:05 -05:00
coah
747e87959f Link matching CDB filesystem utilities 2026-09-22 05:35:39 +00:00
coah
0f89a4218d Link RevoEX NWC24 CH jump unit 2026-09-22 05:34:33 +00:00
coah
d0127008b2 Link NWC24Manage 2026-09-22 05:33:12 +00:00
coah
8f31470be5 Merge pull request #102 from coah80/agent/continue-0922/04-iplSystem
Match iplSystem unit
2026-09-22 00:32:43 -05:00
coah
8a46eaae2d Merge pull request #112 from coah80/agent/continue-0922/tools-buffer
[codex] Link matching MSL buffer IO
2026-09-22 00:32:04 -05:00
coah
55946192bf Merge pull request #111 from coah80/agent/continue-0922/65-qsort
Match MSL qsort
2026-09-22 00:31:17 -05:00
coah
f5486c85f4 Link matching MSL buffer IO 2026-09-22 05:31:04 +00:00
coah
bcbffb2c06 Match MSL qsort 2026-09-22 05:28:43 +00:00
coah
3793ce8c4e Match iplSystem unit 2026-09-22 05:28:25 +00:00
coah
5cd7bcb31f Merge pull request #110 from coah80/agent/refill05/next-unit
Match NWC24 friend list
2026-09-22 00:27:48 -05:00
coah
c6ae812dd3 Match NWC24 friend list 2026-09-22 05:24:44 +00:00
coah
eeb6e310cf Merge pull request #109 from coah80/agent/continue-0922/refill03-next
Match RevoEX NWC24MsgObj
2026-09-22 00:24:40 -05:00
coah
2242c861de Merge pull request #108 from coah80/agent/continue-0922/tools-bsearch
[codex] Match MSL bsearch
2026-09-22 00:22:43 -05:00
coah
ded8d62531 Match MSL bsearch 2026-09-22 05:21:31 +00:00
coah
2c9e8eb028 Merge pull request #107 from coah80/agent/refill-0922/zi8ZHuwd
[codex] Match Zi8GetZHuwdPtr
2026-09-22 00:20:10 -05:00
coah
a8c6bcf550 Match Zi8GetZHuwdPtr 2026-09-22 05:19:33 +00:00
coah
aa72085db7 Match NWC24 message object 2026-09-22 05:19:14 +00:00
coah
4f747f363b Merge pull request #106 from coah80/agent/continue-0922/65-HBMBase
Match MSL math_sun
2026-09-22 00:19:12 -05:00
coah
2dce7103d1 Merge pull request #105 from coah80/agent/continue-0922/cdb-database
[codex] Match CDBDatabase
2026-09-22 00:17:34 -05:00
coah
f812a3bf87 Match MSL math_sun 2026-09-22 05:16:12 +00:00
coah
25177c690e Match CDBDatabase 2026-09-22 05:14:14 +00:00
coah
912546fd58 Merge pull request #104 from coah80/integrate/audio-wave-0922
Match and link AudioWavePlayer
2026-09-22 00:13:48 -05:00
coah
39aef1c7c0 Link matching AudioWavePlayer unit 2026-09-22 05:13:22 +00:00
coah
872f55c573 Merge pull request #103 from coah80/integrate/letterwriter-0922
Match and link iplLetterWriter
2026-09-22 00:12:44 -05:00
coah
ba46047e4d Match LetterWriter init calculation 2026-09-22 05:12:31 +00:00
coah
3e41051d36 Merge pull request #101 from coah80/agent/continue-0922/tools-arith
[codex] Match MSL arithmetic helpers
2026-09-22 00:10:58 -05:00
coah
fa2c5714ad Match MSL arithmetic helpers 2026-09-22 05:09:50 +00:00
coah
cebdd7236d Merge pull request #99 from coah80/agent/continue-0922/iplCalendar
Match iplCalendar completely
2026-09-21 23:35:17 -05:00
coah
87cf5dacc3 Merge pull request #100 from coah80/agent/continue-0922/21-iplNwc24Manager
Match iplNwc24Manager
2026-09-21 23:34:51 -05:00
coah
9424c50f7b Match Calendar data padding 2026-09-22 04:32:20 +00:00
coah
020ba288c3 Match Calendar date positioning 2026-09-22 04:32:20 +00:00
coah
1ab4726f50 Merge pull request #98 from coah80/integrate/nwc24-manager-0922
Match and link NWC24 manager
2026-09-21 23:32:04 -05:00
coah
2b016f9144 Match iplNwc24Manager 2026-09-22 04:31:50 +00:00
coah
29984adbed Merge pull request #97 from coah80/integrate/wdscan-0922
Match and link WDScan
2026-09-21 23:30:58 -05:00
coah
e2832af0d2 Match RevoEX WDScan 2026-09-22 04:30:41 +00:00
coah
df3f27980e Merge pull request #96 from coah80/integrate/sd-drv-0922
Match and link SD driver
2026-09-21 23:30:24 -05:00
coah
28a693c7ad Match RevoEX SD driver 2026-09-22 04:30:16 +00:00
coah
1d16705416 Match iplNwc24Manager 2026-09-22 04:29:48 +00:00
coah
1ccf72e0d5 Merge pull request #95 from coah80/integrate/archivefont-0922
Match and link NW4R ArchiveFont
2026-09-21 23:29:14 -05:00
coah
11b63fc609 Match NW4R ArchiveFont 2026-09-22 04:29:02 +00:00
coah
3ae7c32d1c Merge pull request #94 from coah80/integrate/iplDate-0922
Match and link iplDate
2026-09-21 23:25:56 -05:00
coah
1171037c9b Match iplDate static data 2026-09-22 04:25:34 +00:00
coah
0a6a722237 Match and link www_window (#93)
* Match BrowserWindow tile blit

* Match BrowserWindow tile row setup

* Link matching BrowserWindow unit
2026-09-21 23:23:06 -05:00
coah
18e76c8e59 Revert "Match MSL printf (#91)" (#92)
This reverts commit b9ceb6a11a.
2026-09-21 23:20:59 -05:00
coah
0391409f25 Match iplSystem init (#90) 2026-09-21 23:17:29 -05:00
coah
b9ceb6a11a Match MSL printf (#91)
* Match MSL printf

* Link MSL printf match
2026-09-21 23:17:03 -05:00
coah
cc637c0b19 Match MSL allocator (#89) 2026-09-21 23:15:28 -05:00
coah
7c26f15caa Match systemmenu CSPane (#88) 2026-09-21 23:13:23 -05:00
coah
e505b1cf9e Require complete data gates for workers (#87) 2026-09-21 23:10:16 -05:00
coah
39c8fe9e3a Match WPAD storage and SDA layout (#86)
* Match WPAD BSS storage layout

* Match WPAD SDA operands
2026-09-21 23:08:09 -05:00
coah
b5423d6815 Match MSL ansi files (#85) 2026-09-21 23:06:19 -05:00
coah
cf00659e46 Match iplController data (#84) 2026-09-21 23:03:41 -05:00
coah
0eedd89260 Match tiInputForm helper functions (#83) 2026-09-21 23:02:58 -05:00
coah
69ff7c2582 Match and link iplSaveDataManager (#82)
* Match save data manager initialization

* Match save data manager empty string
2026-09-21 22:57:22 -05:00
coah
a95c8a4b1d Match and link RsoSystem (#79) 2026-09-21 22:45:45 -05:00
coah
953b301d76 Link matching iplUtility unit (#77)
* Link matching iplUtility unit

* Mark utility constructor shim weak
2026-09-21 22:29:28 -05:00
coah
5166ef739e Match PlayTimeLog record creation (#76) 2026-09-21 22:27:54 -05:00
coah
f86495f54a Update worker capacity guidelines in AGENTS.md 2026-09-21 20:15:45 -05:00
coah
537c072886 Merge pull request #73 from coah80/agent/scroller-calc-20260922
Match Scroller calc
2026-09-21 20:11:20 -05:00
coah
1e9dd58f0d Match Scroller calc 2026-09-22 01:10:49 +00:00
coah
e174009388 Merge pull request #72 from coah80/agent/update-agent-cap-20260922
Raise worker pool guidance
2026-09-21 20:09:21 -05:00
coah
7760bedf22 Raise worker pool guidance 2026-09-22 01:09:09 +00:00
coah
e55aea86ee Merge pull request #71 from coah80/agent/scene-manager-link-20260922
Link SceneManager
2026-09-21 20:07:25 -05:00
coah
8b42d4167b Link SceneManager 2026-09-22 01:07:01 +00:00
coah
d05fcb1f10 Merge pull request #70 from coah80/agent/button-link-20260922
Link matching iplButton
2026-09-21 20:05:01 -05:00
coah
532b492c2a Link matching iplButton 2026-09-22 01:04:35 +00:00
coah
3ec0698529 Merge pull request #69 from coah80/agent/cdbcrypt-link-20260922
Link CDBCrypt
2026-09-21 20:03:35 -05:00
coah
649ad2fe37 Link CDBCrypt 2026-09-22 01:03:18 +00:00
coah
a1be1860d9 Merge pull request #68 from coah80/agent/update-agents-workflow-20260922
Update agent matching workflow
2026-09-21 20:02:53 -05:00
coah
af7a696da6 Update agent matching workflow 2026-09-22 01:02:42 +00:00
coah
0105e3de85 Merge pull request #67 from coah80/agent/odh-decompress-loop-20260922
Match cdj_d_decompressLoop
2026-09-21 19:59:05 -05:00
coah
a1167cd128 Match cdj_d_decompressLoop 2026-09-22 00:58:39 +00:00
coah
1bb030e16a Merge pull request #66 from coah80/agent/www-surface-link-20260922
Link www surface unit
2026-09-21 19:42:53 -05:00
coah
41f01f5012 Link www surface unit 2026-09-22 00:42:23 +00:00
coah
4b24a65552 Merge pull request #65 from coah80/agent/textwriter-link-20260922
Link TextWriter unit
2026-09-21 19:22:18 -05:00
coah
44e895f70b Link TextWriter unit 2026-09-22 00:21:42 +00:00
coah
42173aa970 Merge pull request #64 from coah80/agent/nand-shared-link-20260922
Link iplNandShared
2026-09-21 19:16:24 -05:00
coah
c936e893db Link iplNandShared 2026-09-22 00:15:55 +00:00
coah
4fdd7f9cd5 Merge pull request #51 from coah80/codex/nwc24-friend-search-exact-20260921
Match NWC24 friend search
2026-09-21 18:56:45 -05:00
coah
914007736f Merge pull request #63 from coah80/agent/candidate-box-next-20260921
Match candidate page navigation
2026-09-21 18:53:10 -05:00
coah
def5006961 Match candidate page navigation 2026-09-21 23:52:49 +00:00
coah
a5b26387d3 Merge pull request #62 from coah80/agent/ti-input-form-exact-20260921
Match tiInputForm input paths
2026-09-21 18:50:58 -05:00
coah
e46089fbb9 Match tiInputForm input paths 2026-09-21 23:50:28 +00:00
coah
1683c2bb9c Merge pull request #61 from coah80/agent/board-object-20260921
Match BoardObject stt_create
2026-09-21 18:48:24 -05:00
coah
1f04477528 Match BoardObject stt_create 2026-09-21 23:48:04 +00:00
coah
87377fa984 Merge pull request #60 from coah80/agent/channel-title-20260921
Match ChannelTitle module loader
2026-09-21 18:47:50 -05:00
coah
2a2f0f8868 Match ChannelTitle module loader 2026-09-21 23:47:14 +00:00
coah
cd729d24cb Merge PR #59: Match channel object helpers
Match channel object helpers
2026-09-21 18:45:17 -05:00
coah
a6ac7282b7 Match channel object helpers 2026-09-21 23:45:01 +00:00
coah
bd1ebcb624 Merge PR #58: Match keyboard save
Match keyboard save
2026-09-21 18:44:18 -05:00
coah
cfe2a8bc1a Match keyboard save 2026-09-21 23:44:04 +00:00
coah
b62e543654 Merge PR #57: Match board key table
Match board key table
2026-09-21 18:40:46 -05:00
coah
349e33fb24 Match board key table 2026-09-21 23:40:35 +00:00
coah
1eaf680f40 Merge PR #56: Match system warning loop
Match system warning loop
2026-09-21 18:34:26 -05:00
coah
3e35807542 Match system warning loop 2026-09-21 23:34:11 +00:00
coah
bbce167648 Merge PR #55: Match TVRC data
Match TVRC data
2026-09-21 18:30:49 -05:00
coah
2c1b255aa2 Match TVRC data 2026-09-21 23:30:38 +00:00
coah
171cd52bab Merge PR #54: Match EGG DVD archive open
Match EGG DVD archive open
2026-09-21 18:27:49 -05:00
coah
7f1fb7e588 Match EGG DVD archive open 2026-09-21 23:27:36 +00:00
coah
aa825369da Merge PR #53: Fix CDB filesystem build
Fix CDB filesystem build
2026-09-21 18:27:14 -05:00
coah
42390e0343 Fix CDB filesystem build 2026-09-21 23:26:58 +00:00
coah
5c1af96b02 Merge PR #52: Match CDB filesystem helpers
Match CDB filesystem helpers
2026-09-21 18:24:54 -05:00
coah
ce15782426 Match CDB filesystem helpers 2026-09-21 23:24:41 +00:00
coah
cb232daee1 Match NWC24 friend search 2026-09-21 23:21:48 +00:00
coah
46c6772ada Merge PR #50: Match button data
Match button data
2026-09-21 18:18:02 -05:00
148 changed files with 28859 additions and 5313 deletions

View File

@@ -2,6 +2,8 @@
Guidance for AI agents working in this repository.
Keep code comments to cases where they are necessary.
## CRITICAL RULE: never touch upstream
**Do not open a pull request against `koopthekoopa/wii-ipl`. Do not push to it.
@@ -156,51 +158,34 @@ and `splits.txt`), not in whatever order looks convenient.
7. `ctxdiff.py` next. Work through the instruction diff.
8. Only then look at register allocation.
## ReAgent and parallel worker workflow
## Subagent and PR workflow
This repository targets only Wii Menu 4.3U. Do not configure or build 43E,
43J, or 43K while doing matching work.
Use the installed ReAgent environment for evidence-driven reversal work:
Most workers should pursue exact matching or safe linking; assign the remainder
to decompilation. Keep up to 75 live workers when the runtime allows it, while
reserving capacity for fixer and validation workers. Fill completed slots with
disjoint tasks. Never duplicate a source file or function
range. Workers return changed paths, exact objdiff measurements, and validation
results. Fuzzy-only results are not accepted.
```
/home/cole/projects/tests/reagent-venv/bin/re-agent doctor
/home/cole/projects/tests/reagent-venv/bin/re-agent status
```
Workers must do the work through tool calls and avoid conversational messages.
Send findings to the parent only through the collaboration tool, with concise
paths, measurements, and validation evidence. Put PR discussion on the PR when
needed. Do not send user-facing status chatter; the orchestrator follows the
reporting rule below.
ReAgent should use the authenticated local Codex provider with the requested
model and a small per-function call cap. The Codex provider uses the local
Codex login rather than an API key; API billing is not created by ReAgent, but
the account's normal model or plan usage still applies. Do not start a model
run until `doctor` reports the backend and acceptance configuration clearly.
### Worker loop
If the launcher cannot import, or `doctor` reports `ready: false`, record the
exact failure and do not claim ReAgent evidence. Repair a broken editable
install with a fresh checkout and a non-editable install before retrying. If
the decompile capability still lacks Java/Ghidra, workers may continue only in
the explicitly labeled manual/objdiff fallback using fresh object builds,
`pool_diff.py`, `ctxdiff.py`, full 43U builds, and the DOL hash. The fallback
does not count as ReAgent execution.
For parallel work, orchestrate up to ten workers at once when the agent runtime
has the capacity. Use `gpt-5.6-luna` at maximum reasoning effort with the fast
service tier when those settings are available. If the runtime cannot host ten
live workers, queue the remainder; never duplicate a source file or function
range just to fill a slot. Each worker must own a disjoint translation unit or
function range and return the changed paths, exact-match measurements, and
validation results. Workers may propose code, but a candidate is not accepted
when it is only fuzzy, uses an uninitialized value, or hides a mismatch behind
artificial assembly.
### Ten-worker exact-match loop
The worker keeps iterating on its assigned function until exact-name `objdiff`
reports `100.0%`. A worker must not stop at a fuzzy score, push to a remote,
open a PR, or merge. It may make a local commit on its isolated leaf branch if
needed to preserve its work. If the worker believes the remaining difference is
a compiler tie-break, it reports the evidence and waits for the orchestrator to
terminate or reassign the leaf; it does not self-accept a near-match. Reaching
`100.0%` is only the handoff point; it is not acceptance.
Workers iterate until exact-name `objdiff` reports `100.0%`. They must not stop
at a fuzzy score, push, open a PR, or merge. A local commit is fine. Compiler
tie-breaks should be reported with evidence, not hidden behind artificial
assembly or uninitialized values. Exact matching is the handoff point, not
acceptance. A candidate is incomplete until every owned code and data section
and its link metrics are 100%; matching a few functions alone is not enough.
Write new matches as readable C or C++ and keep new inline assembly out of the
source unless the existing target structure makes it unavoidable.
Worker measurements are advisory. Only a fresh orchestrator verification can
accept, push, open, or merge a candidate. Workers are persistent across
@@ -219,9 +204,11 @@ The orchestrator must independently rebuild the owned object and verify:
1. `pool_diff.py` reports identical pools, with no first divergence.
2. Exact-name `objdiff` reports `100.0%` for the requested symbol.
3. `ctxdiff.py` reports `diffs 0` and identical instruction counts.
4. The focused source diff is minimal, readable, and free of artificial
4. Unit-level code, data, function, and link measures for the owned range are
100%, including every owned section.
5. The focused source diff is minimal, readable, and free of artificial
assembly, uninitialized values, or unrelated edits.
5. The full 4.3U build passes and `build/43U/main.dol` has SHA1
6. The full 4.3U build passes and `build/43U/main.dol` has SHA1
`26116613f624061ba99c8d1a299aaa6efa85670d`.
If any orchestrator gate fails, do not promote, push, open a PR, or merge the
@@ -238,8 +225,9 @@ For each candidate, the worker must:
4. Iterate until exact-name objdiff reaches `100.0%`, while preserving the
pool and source-quality requirements above.
5. Return the focused exact match to the parent agent for review. The parent
reruns every gate and runs `/home/cole/projects/tests/.venv/bin/ninja -C .
build/43U/ok`; the worker does not push, open a PR, or merge.
reruns every gate, runs `tools/decomp_status.py` and
`tools/check_decomp_complete.py`, and runs `/home/cole/projects/tests/.venv/bin/ninja -C . build/43U/ok`;
the worker does not push, open a PR, or merge.
The main agent reviews every worker result before accepting it. After each
accepted merge, record the new report from `build/43U/report.json` and keep
@@ -259,9 +247,8 @@ candidate fails validation, return it to its worker; do not fix the candidate
inline in the orchestrator.
A new thread must begin by reading this file, checking the live 43U report and
remote branch, running the ReAgent doctor/status checks, and then dispatching
the worker pool. The orchestrator must not claim a match based on its own
decompilation because it must not do that work.
remote branch, and dispatching the worker pool. The parent must not claim a
match without fresh independent verification.
### Worktrees, branches, and PR integration
@@ -318,6 +305,21 @@ After a successful merge:
worktree and local branch. A failed or conflicted leaf keeps its worktree
and worker alive.
### User-facing progress reports
Keep user-facing messages to a minimum and use as few tokens as possible.
Do not send routine status updates or commentary while workers are running or
PRs are open. After each matching-work PR is merged and the live progress
report has been regenerated, send only the current linked, fuzzy, and data
percentages in this format:
```
Linked: <percent> | Fuzzy: <percent> | Data: <percent>
```
Do not report stale values, unmerged PR results, or add other text to that
update. Continue all required verification and coordination silently.
## Goal completion contract
The decompilation loop does not stop after a successful wave, a convenient

View File

@@ -10,6 +10,33 @@ splits: 'config/43U/splits.txt'
ldscript_template: 'config/ldscript_ipl2.lcf'
force_active:
- labs
- itoa
- strpbrk
- strspn
- strcspn
- atol
- padding__Q23ipl5scene
- lbl_81695063
- lbl_81695067
- __vt__Q49textinput6extend4memo19NigaoeEventObserver
# textinput::toolbar::csPaneToAnimation points one past the end of csAninationFile.
block_relocations:
- source: .data:0x8165E15C
- source: .data:0x8165E19C
add_relocations:
- source: .data:0x8165E15C
type: abs
target: csAninationFile__Q29textinput7toolbar
addend: 0x1DC
- source: .data:0x8165E19C
type: abs
target: csAninationFile__Q29textinput7toolbar
addend: 0x1DC
quick_analysis: true
fill_gaps: false

View File

@@ -37,11 +37,16 @@ src/system/iplSystem.cpp:
.sdata start:0x81696060 end:0x81696080
src/system/iplController.cpp:
.text start:0x81335CCC end:0x81337978
.text start:0x81335CCC end:0x81337318
.rodata start:0x8160D2C0 end:0x8160D2D0
.data start:0x816346A8 end:0x81634A28
.sdata2 start:0x81694440 end:0x81694490
.data start:0x816346A8 end:0x81634910
.sdata2 start:0x81694440 end:0x81694478
.sdata start:0x81696080 end:0x81696088
src/system/iplControllerManager.cpp:
.text start:0x81337318 end:0x81337978
.data start:0x81634910 end:0x81634A28
.sdata2 start:0x81694478 end:0x81694490
.sbss start:0x81698680 end:0x81698690
src/system/iplChannelManager.cpp:

View File

@@ -7,7 +7,7 @@ mMac__Q33ipl6socket13SocketSetting = .bss:0x81089720; // type:object size:0x40
_database__7LibTVRC = .bss:0x81089760; // type:object size:0x20 data:4byte
_alarm__7LibTVRC = .bss:0x81089780; // type:object size:0x30
_tickWait__7LibTVRC = .bss:0x810897B0; // type:object size:0x10 data:4byte
mArg__Q33ipl7utility8Graphics = .bss:0x810897C0; // type:object size:0x88
mArg__Q33ipl7utility8Graphics = .bss:0x810897C0; // type:object size:0x84
unk__Q23ipl3snd = .bss:0x81089848; // type:object size:0xC
_seBlk__Q23ipl3snd = .bss:0x81089854; // type:object size:0xD8 data:4byte
sSystem__Q23ipl3snd = .bss:0x8108992C; // type:object size:0x63C data:4byte
@@ -123,7 +123,7 @@ CDB_SD_ROOT_PATH_LS = .bss:0x810C8A08; // type:object size:0x20
CDB_SD_VFF_FILE_NAME = .bss:0x810C8A28; // type:object size:0x48
lbl_810C8A80 = .bss:0x810C8A80; // type:object size:0x40 align:32
lbl_810C8AC0 = .bss:0x810C8AC0; // type:object size:0x40 align:32
s_mutex = .bss:0x810C8B00; // type:object size:0x20 scope:local
s_mutex = .bss:0x810C8B00; // type:object size:0x18 scope:local
s_cdbWiiId = .bss:0x810C8B20; // type:object size:0x40 scope:local
ncdMutex = .bss:0x810C8B60; // type:object size:0x20
ncdCommonResult = .bss:0x810C8B80; // type:object size:0x20 align:32 data:4byte
@@ -161,7 +161,7 @@ l_dev_init_info_table = .bss:0x810F55C0; // type:object size:0xD0 scope:local
l_tmpWName = .bss:0x810F5690; // type:object size:0x10 scope:local data:2byte
hashTable = .bss:0x810F56A0; // type:object size:0x22E scope:local data:byte
l_driveInfo = .bss:0x810F58D0; // type:object size:0x208 scope:local data:4byte
l_nandFunc = .bss:0x810F5AD8; // type:object size:0x1A8 scope:local
l_nandFunc = .bss:0x810F5AD8; // type:object size:0x1A0 scope:local
l_event = .bss:0x810F5C80; // type:object size:0x340 scope:local
l_sddrv_info = .bss:0x810F5FC0; // type:object size:0x80 scope:local
sZeroBuffer__Q44nw4r3snd6detail9AxManager = .bss:0x810F6040; // type:object size:0x100
@@ -13835,8 +13835,8 @@ scAnmTable__10homebutton = .rodata:0x8160F378; // type:object size:0x60 scope:lo
scGroupAnmTable__10homebutton = .rodata:0x8160F3D8; // type:object size:0x250 scope:local data:4byte
__DVDErrorMessage = .rodata:0x8160F628; // type:object size:0x28
lbl_8160F650 = .rodata:0x8160F650; // type:object size:0x16 data:2byte
lbl_8160F668 = .rodata:0x8160F668; // type:object size:0xB data:byte
lbl_8160F673 = .rodata:0x8160F673; // type:object size:0xC data:byte
specials$18760 = .rodata:0x8160F668; // type:object size:0xB data:byte
@19145 = .rodata:0x8160F673; // type:object size:0xC data:byte
lbl_8160F67F = .rodata:0x8160F67F; // type:object size:0xD data:byte
lbl_8160F690 = .rodata:0x8160F690; // type:object size:0x18 data:2byte
scAnmFrame__Q23ipl5scene = .rodata:0x8160F6A8; // type:object size:0x20 scope:local
@@ -13938,7 +13938,7 @@ pppURLCheck = .rodata:0x816152A8; // type:object size:0x28 scope:local
lbl_816152D0 = .rodata:0x816152D0; // type:object size:0x10 scope:local data:4byte
csAninationFile__Q29textinput12candidatebox = .rodata:0x816152E0; // type:object size:0x378 scope:local
lbl_81615658 = .rodata:0x81615658; // type:object size:0xA0 scope:local data:4byte
csAninationFile__Q29textinput7toolbar = .rodata:0x816156F8; // type:object size:0x1E0 scope:local data:4byte
csAninationFile__Q29textinput7toolbar = .rodata:0x816156F8; // type:object size:0x1DC scope:local data:4byte
csAninationFile__Q29textinput11predictlang = .rodata:0x816158D8; // type:object size:0x268 scope:local
csAninationFileForSign__Q39textinput8keyboard10signwindow = .rodata:0x81615B40; // type:object size:0x268 scope:local
csPaneNameToControlKey__Q39textinput8keyboard10signwindow = .rodata:0x81615DA8; // type:object size:0x48 scope:local
@@ -15435,26 +15435,46 @@ __vt__Q33ipl5scene7Address = .data:0x81647B70; // type:object size:0x120
@11177 = .data:0x81647D9A; // type:object size:0xF scope:local data:string
__vt__Q33ipl5scene18AddressAddSelEvent = .data:0x81647DAC; // type:object size:0x18
__vt__Q33ipl5scene13AddressAddSel = .data:0x81647DC4; // type:object size:0x88
lbl_81647EE0 = .data:0x81647EE0; // type:object size:0xD data:string
lbl_81647EED = .data:0x81647EED; // type:object size:0xD data:string
lbl_81647EFA = .data:0x81647EFA; // type:object size:0xD data:string
lbl_81647F07 = .data:0x81647F07; // type:object size:0xE data:string
lbl_81647F15 = .data:0x81647F15; // type:object size:0xC data:string
lbl_81647F24 = .data:0x81647F24; // type:object size:0x14
lbl_81647F38 = .data:0x81647F38; // type:object size:0xE data:string
lbl_81647F46 = .data:0x81647F46; // type:object size:0x83
lbl_81647FC9 = .data:0x81647FC9; // type:object size:0xC data:string
lbl_81647FD5 = .data:0x81647FD5; // type:object size:0x128
lbl_816480FD = .data:0x816480FD; // type:object size:0xE data:string
lbl_8164810B = .data:0x8164810B; // type:object size:0x1F5
jumptable_81648300 = .data:0x81648300; // type:object size:0xC0 scope:local
jumptable_816483C0 = .data:0x816483C0; // type:object size:0xC0 scope:local
lbl_8164848D = .data:0x8164848D; // type:object size:0x16 data:string
lbl_816484A3 = .data:0x816484A3; // type:object size:0xF data:string
jumptable_816484B4 = .data:0x816484B4; // type:object size:0x44 scope:local
jumptable_81648508 = .data:0x81648508; // type:object size:0x58 scope:local
jumptable_81648560 = .data:0x81648560; // type:object size:0x8C scope:local
lbl_816485EC = .data:0x816485EC; // type:object size:0xC data:wstring
@16959 = .data:0x81647EE0; // type:object size:0xD data:string
@16960 = .data:0x81647EED; // type:object size:0xD data:string
@16961 = .data:0x81647EFA; // type:object size:0xD data:string
@16962 = .data:0x81647F07; // type:object size:0xE data:string
@16963 = .data:0x81647F15; // type:object size:0xC data:string
sButtonPaneNames = .data:0x81647F24; // type:object size:0x14
@16964 = .data:0x81647F38; // type:object size:0xE data:string
@23886 = .data:0x81647F46; // type:object size:0xC data:string
@24207 = .data:0x81647F52; // type:object size:0x12 data:string
@24208 = .data:0x81647F64; // type:object size:0x1C data:string
@24209 = .data:0x81647F80; // type:object size:0xF data:string
@24210 = .data:0x81647F8F; // type:object size:0x19 data:string
@24211 = .data:0x81647FA8; // type:object size:0xB data:string
@24212 = .data:0x81647FB3; // type:object size:0xB data:string
@24213 = .data:0x81647FBE; // type:object size:0xB data:string
@24214 = .data:0x81647FC9; // type:object size:0xC data:string
@24215 = .data:0x81647FD5; // type:object size:0xE data:string
@24216 = .data:0x81647FE3; // type:object size:0x1A data:string
@24217 = .data:0x81647FFD; // type:object size:0x1A data:string
@24218 = .data:0x81648017; // type:object size:0x1D data:string
@24219 = .data:0x81648034; // type:object size:0x1E data:string
@24220 = .data:0x81648052; // type:object size:0xC data:string
@24221 = .data:0x8164805E; // type:object size:0x22 data:string
@24222 = .data:0x81648080; // type:object size:0x9 data:string
@24223 = .data:0x81648089; // type:object size:0x23 data:string
@24224 = .data:0x816480AC; // type:object size:0x1C data:string
@24225 = .data:0x816480C8; // type:object size:0xD data:string
@24226 = .data:0x816480D5; // type:object size:0xD data:string
@24227 = .data:0x816480E2; // type:object size:0xD data:string
@24228 = .data:0x816480EF; // type:object size:0xE data:string
@24229 = .data:0x816480FD; // type:object size:0xE data:string
@24231 = .data:0x8164810B; // type:object size:0x1F5
@25188 = .data:0x81648300; // type:object size:0xC0 scope:local
@25187 = .data:0x816483C0; // type:object size:0xC0 scope:local
@25711 = .data:0x8164848D; // type:object size:0x16 data:string
@25835 = .data:0x816484A3; // type:object size:0xF data:string
@25838 = .data:0x816484B4; // type:object size:0x44 scope:local
@26007 = .data:0x81648508; // type:object size:0x58 scope:local
@26006 = .data:0x81648560; // type:object size:0x8C scope:local
@26030 = .data:0x816485EC; // type:object size:0xC data:wstring
__vt__Q33ipl5scene17AddressInputEvent = .data:0x816485F8; // type:object size:0x18
__vt__Q33ipl5scene16AddressEditEvent = .data:0x81648610; // type:object size:0x18
__vt__Q33ipl5scene11AddressEdit = .data:0x81648628; // type:object size:0x120
@@ -15733,47 +15753,47 @@ panes__Q23ipl5scene = .data:0x8164C8A4; // type:object size:0xB4 scope:local
@16662 = .data:0x8164CBF4; // type:object size:0xC scope:local data:string
@16898 = .data:0x8164CC00; // type:object size:0x1A scope:local data:string
__vt__Q33ipl5scene11ChannelEdit = .data:0x8164CC1C; // type:object size:0x4C
lbl_8164CC68 = .data:0x8164CC68; // type:object size:0x21 data:string
lbl_8164CC89 = .data:0x8164CC89; // type:object size:0xA data:string
lbl_8164CC93 = .data:0x8164CC93; // type:object size:0x22 data:string
lbl_8164CCB5 = .data:0x8164CCB5; // type:object size:0x23 data:string
lbl_8164CCD8 = .data:0x8164CCD8; // type:object size:0x9 data:string
lbl_8164CCE1 = .data:0x8164CCE1; // type:object size:0x2C data:string
lbl_8164CD0D = .data:0x8164CD0D; // type:object size:0xC data:string
lbl_8164CD19 = .data:0x8164CD19; // type:object size:0x2D data:string
lbl_8164CD46 = .data:0x8164CD46; // type:object size:0x29 data:string
lbl_8164CD6F = .data:0x8164CD6F; // type:object size:0x25 data:string
lbl_8164CD94 = .data:0x8164CD94; // type:object size:0xB data:string
lbl_8164CD9F = .data:0x8164CD9F; // type:object size:0x26 data:string
lbl_8164CDC5 = .data:0x8164CDC5; // type:object size:0x28 data:string
lbl_8164CDED = .data:0x8164CDED; // type:object size:0x20 data:string
lbl_8164CE0D = .data:0x8164CE0D; // type:object size:0x20 data:string
lbl_8164CE2D = .data:0x8164CE2D; // type:object size:0x21 data:string
lbl_8164CE4E = .data:0x8164CE4E; // type:object size:0xA data:string
lbl_8164CE58 = .data:0x8164CE58; // type:object size:0xA data:string
lbl_8164CE62 = .data:0x8164CE62; // type:object size:0x22 data:string
lbl_8164CE84 = .data:0x8164CE84; // type:object size:0xD data:string
lbl_8164CE91 = .data:0x8164CE91; // type:object size:0xD data:string
lbl_8164CE9E = .data:0x8164CE9E; // type:object size:0x23 data:string
lbl_8164CEC1 = .data:0x8164CEC1; // type:object size:0x1F data:string
lbl_8164CEE0 = .data:0x8164CEE0; // type:object size:0xA data:string
lbl_8164CEEA = .data:0x8164CEEA; // type:object size:0x21 data:string
lbl_8164CF0B = .data:0x8164CF0B; // type:object size:0xB data:string
lbl_8164CF16 = .data:0x8164CF16; // type:object size:0xB data:string
lbl_8164CF21 = .data:0x8164CF21; // type:object size:0x1F data:string
lbl_8164CF40 = .data:0x8164CF40; // type:object size:0x25 data:string
lbl_8164CF65 = .data:0x8164CF65; // type:object size:0xB data:string
lbl_8164CF70 = .data:0x8164CF70; // type:object size:0x26 data:string
lbl_8164CF96 = .data:0x8164CF96; // type:object size:0xF data:string
lbl_8164CFA5 = .data:0x8164CFA5; // type:object size:0xF data:string
lbl_8164CFB4 = .data:0x8164CFB4; // type:object size:0xE data:string
lbl_8164CFC2 = .data:0x8164CFC2; // type:object size:0xE data:string
lbl_8164CFD0 = .data:0x8164CFD0; // type:object size:0xB data:string
lbl_8164CFDB = .data:0x8164CFDB; // type:object size:0xA data:string
lbl_8164CFE5 = .data:0x8164CFE5; // type:object size:0xA data:string
lbl_8164CFEF = .data:0x8164CFEF; // type:object size:0xF data:string
lbl_8164CFFE = .data:0x8164CFFE; // type:object size:0xE data:string
jumptable_8164D00C = .data:0x8164D00C; // type:object size:0x30 scope:local
@17285 = .data:0x8164CC68; // type:object size:0x21 scope:local data:string
@17286 = .data:0x8164CC89; // type:object size:0xA scope:local data:string
@17287 = .data:0x8164CC93; // type:object size:0x22 scope:local data:string
@17288 = .data:0x8164CCB5; // type:object size:0x23 scope:local data:string
@17289 = .data:0x8164CCD8; // type:object size:0x9 scope:local data:string
@17290 = .data:0x8164CCE1; // type:object size:0x2C scope:local data:string
@17291 = .data:0x8164CD0D; // type:object size:0xC scope:local data:string
@17292 = .data:0x8164CD19; // type:object size:0x2D scope:local data:string
@17293 = .data:0x8164CD46; // type:object size:0x29 scope:local data:string
@17294 = .data:0x8164CD6F; // type:object size:0x25 scope:local data:string
@17295 = .data:0x8164CD94; // type:object size:0xB scope:local data:string
@17296 = .data:0x8164CD9F; // type:object size:0x26 scope:local data:string
@17297 = .data:0x8164CDC5; // type:object size:0x28 scope:local data:string
@17298 = .data:0x8164CDED; // type:object size:0x20 scope:local data:string
@17300 = .data:0x8164CE0D; // type:object size:0x20 scope:local data:string
@17301 = .data:0x8164CE2D; // type:object size:0x21 scope:local data:string
@17302 = .data:0x8164CE4E; // type:object size:0xA scope:local data:string
@17303 = .data:0x8164CE58; // type:object size:0xA scope:local data:string
@17304 = .data:0x8164CE62; // type:object size:0x22 scope:local data:string
@17305 = .data:0x8164CE84; // type:object size:0xD scope:local data:string
@17306 = .data:0x8164CE91; // type:object size:0xD scope:local data:string
@17307 = .data:0x8164CE9E; // type:object size:0x23 scope:local data:string
@17308 = .data:0x8164CEC1; // type:object size:0x1F scope:local data:string
@17309 = .data:0x8164CEE0; // type:object size:0xA scope:local data:string
@17310 = .data:0x8164CEEA; // type:object size:0x21 scope:local data:string
@17311 = .data:0x8164CF0B; // type:object size:0xB scope:local data:string
@17312 = .data:0x8164CF16; // type:object size:0xB scope:local data:string
@17313 = .data:0x8164CF21; // type:object size:0x1F scope:local data:string
@17314 = .data:0x8164CF40; // type:object size:0x25 scope:local data:string
@17315 = .data:0x8164CF65; // type:object size:0xB scope:local data:string
@17316 = .data:0x8164CF70; // type:object size:0x26 scope:local data:string
@17317 = .data:0x8164CF96; // type:object size:0xF scope:local data:string
@17318 = .data:0x8164CFA5; // type:object size:0xF scope:local data:string
@17319 = .data:0x8164CFB4; // type:object size:0xE scope:local data:string
@17320 = .data:0x8164CFC2; // type:object size:0xE scope:local data:string
@17321 = .data:0x8164CFD0; // type:object size:0xB scope:local data:string
@17325 = .data:0x8164CFDB; // type:object size:0xA scope:local data:string
@17326 = .data:0x8164CFE5; // type:object size:0xA scope:local data:string
@17329 = .data:0x8164CFEF; // type:object size:0xF scope:local data:string
@17330 = .data:0x8164CFFE; // type:object size:0xE scope:local data:string
@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
lbl_8164D108 = .data:0x8164D108; // type:object size:0x25 data:string
@@ -15791,56 +15811,56 @@ 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
lbl_8164D2E8 = .data:0x8164D2E8; // type:object size:0x20 data:string
lbl_8164D308 = .data:0x8164D308; // type:object size:0x21 data:string
lbl_8164D329 = .data:0x8164D329; // type:object size:0x26 data:string
lbl_8164D34F = .data:0x8164D34F; // type:object size:0x27 data:string
lbl_8164D376 = .data:0x8164D376; // type:object size:0x23 data:string
lbl_8164D399 = .data:0x8164D399; // type:object size:0xC data:string
lbl_8164D3A5 = .data:0x8164D3A5; // type:object size:0x25 data:string
lbl_8164D3CA = .data:0x8164D3CA; // type:object size:0x26 data:string
lbl_8164D3F0 = .data:0x8164D3F0; // type:object size:0x22 data:string
lbl_8164D412 = .data:0x8164D412; // type:object size:0xB data:string
lbl_8164D41D = .data:0x8164D41D; // type:object size:0x23 data:string
lbl_8164D440 = .data:0x8164D440; // type:object size:0x9 data:string
lbl_8164D449 = .data:0x8164D449; // type:object size:0x24 data:string
lbl_8164D46D = .data:0x8164D46D; // type:object size:0x26 data:string
lbl_8164D493 = .data:0x8164D493; // type:object size:0x1E data:string
lbl_8164D4B1 = .data:0x8164D4B1; // type:object size:0x26 data:string
lbl_8164D4D7 = .data:0x8164D4D7; // type:object size:0x26 data:string
lbl_8164D4FD = .data:0x8164D4FD; // type:object size:0x27 data:string
lbl_8164D524 = .data:0x8164D524; // type:object size:0x23 data:string
lbl_8164D547 = .data:0x8164D547; // type:object size:0xC data:string
lbl_8164D553 = .data:0x8164D553; // type:object size:0xA data:string
lbl_8164D55D = .data:0x8164D55D; // type:object size:0xA data:string
lbl_8164D567 = .data:0x8164D567; // type:object size:0x9 data:string
lbl_8164D570 = .data:0x8164D570; // type:object size:0xB data:string
lbl_8164D57B = .data:0x8164D57B; // type:object size:0xB data:string
lbl_8164D586 = .data:0x8164D586; // type:object size:0xD data:string
lbl_8164D593 = .data:0x8164D593; // type:object size:0xB data:string
lbl_8164D59E = .data:0x8164D59E; // type:object size:0xB data:string
lbl_8164D5A9 = .data:0x8164D5A9; // type:object size:0xB data:string
lbl_8164D5B4 = .data:0x8164D5B4; // type:object size:0xB data:string
lbl_8164D5BF = .data:0x8164D5BF; // type:object size:0x9 data:string
lbl_8164D5C8 = .data:0x8164D5C8; // type:object size:0xB data:string
lbl_8164D5D3 = .data:0x8164D5D3; // type:object size:0xB data:string
lbl_8164D5DE = .data:0x8164D5DE; // type:object size:0xA data:string
lbl_8164D5E8 = .data:0x8164D5E8; // type:object size:0xB data:string
lbl_8164D5F3 = .data:0x8164D5F3; // type:object size:0xD data:string
lbl_8164D600 = .data:0x8164D600; // type:object size:0x10 data:string
lbl_8164D610 = .data:0x8164D610; // type:object size:0xB data:string
lbl_8164D61B = .data:0x8164D61B; // type:object size:0xE data:string
lbl_8164D629 = .data:0x8164D629; // type:object size:0xA data:string
lbl_8164D633 = .data:0x8164D633; // type:object size:0xA data:string
lbl_8164D63D = .data:0x8164D63D; // type:object size:0x9 data:string
jumptable_8164D648 = .data:0x8164D648; // type:object size:0x34 scope:local
lbl_8164D67C = .data:0x8164D67C; // type:object size:0xF data:string
lbl_8164D68B = .data:0x8164D68B; // type:object size:0xE data:string
lbl_8164D699 = .data:0x8164D699; // type:object size:0xA data:string
lbl_8164D6A3 = .data:0x8164D6A3; // type:object size:0xC data:string
lbl_8164D6AF = .data:0x8164D6AF; // type:object size:0xC data:string
lbl_8164D6BB = .data:0x8164D6BB; // type:object size:0xB data:string
lbl_8164D6C6 = .data:0x8164D6C6; // type:object size:0xF data:string
@18429 = .data:0x8164D2E8; // type:object size:0x20 scope:local data:string
@18431 = .data:0x8164D308; // type:object size:0x21 scope:local data:string
@18432 = .data:0x8164D329; // type:object size:0x26 scope:local data:string
@18434 = .data:0x8164D34F; // type:object size:0x27 scope:local data:string
@18435 = .data:0x8164D376; // type:object size:0x23 scope:local data:string
@18436 = .data:0x8164D399; // type:object size:0xC scope:local data:string
@18437 = .data:0x8164D3A5; // type:object size:0x25 scope:local data:string
@18439 = .data:0x8164D3CA; // type:object size:0x26 scope:local data:string
@18440 = .data:0x8164D3F0; // type:object size:0x22 scope:local data:string
@18441 = .data:0x8164D412; // type:object size:0xB scope:local data:string
@18442 = .data:0x8164D41D; // type:object size:0x23 scope:local data:string
@18443 = .data:0x8164D440; // type:object size:0x9 scope:local data:string
@18444 = .data:0x8164D449; // type:object size:0x24 scope:local data:string
@18445 = .data:0x8164D46D; // type:object size:0x26 scope:local data:string
@18446 = .data:0x8164D493; // type:object size:0x1E scope:local data:string
@18448 = .data:0x8164D4B1; // type:object size:0x26 scope:local data:string
@18450 = .data:0x8164D4D7; // type:object size:0x26 scope:local data:string
@18452 = .data:0x8164D4FD; // type:object size:0x27 scope:local data:string
@18453 = .data:0x8164D524; // type:object size:0x23 scope:local data:string
@18454 = .data:0x8164D547; // type:object size:0xC scope:local data:string
@18455 = .data:0x8164D553; // type:object size:0xA scope:local data:string
@18456 = .data:0x8164D55D; // type:object size:0xA scope:local data:string
@18457 = .data:0x8164D567; // type:object size:0x9 scope:local data:string
@18458 = .data:0x8164D570; // type:object size:0xB scope:local data:string
@18460 = .data:0x8164D57B; // type:object size:0xB scope:local data:string
@18461 = .data:0x8164D586; // type:object size:0xD scope:local data:string
@18462 = .data:0x8164D593; // type:object size:0xB scope:local data:string
@18463 = .data:0x8164D59E; // type:object size:0xB scope:local data:string
@18464 = .data:0x8164D5A9; // type:object size:0xB scope:local data:string
@18465 = .data:0x8164D5B4; // type:object size:0xB scope:local data:string
@18467 = .data:0x8164D5BF; // type:object size:0x9 scope:local data:string
@18469 = .data:0x8164D5C8; // type:object size:0xB scope:local data:string
@18470 = .data:0x8164D5D3; // type:object size:0xB scope:local data:string
@18471 = .data:0x8164D5DE; // type:object size:0xA scope:local data:string
@18472 = .data:0x8164D5E8; // type:object size:0xB scope:local data:string
@18473 = .data:0x8164D5F3; // type:object size:0xD scope:local data:string
@18474 = .data:0x8164D600; // type:object size:0x10 scope:local data:string
@18475 = .data:0x8164D610; // type:object size:0xB scope:local data:string
@18476 = .data:0x8164D61B; // type:object size:0xE scope:local data:string
@18477 = .data:0x8164D629; // type:object size:0xA scope:local data:string
@18478 = .data:0x8164D633; // type:object size:0xA scope:local data:string
@18479 = .data:0x8164D63D; // type:object size:0x9 scope:local data:string
@18554 = .data:0x8164D648; // type:object size:0x34 scope:local
@18692 = .data:0x8164D67C; // type:object size:0xF scope:local data:string
@18693 = .data:0x8164D68B; // type:object size:0xE scope:local data:string
@18695 = .data:0x8164D699; // type:object size:0xA scope:local data:string
@18696 = .data:0x8164D6A3; // type:object size:0xC scope:local data:string
@18697 = .data:0x8164D6AF; // type:object size:0xC scope:local data:string
@18698 = .data:0x8164D6BB; // type:object size:0xB scope:local data:string
@18826 = .data:0x8164D6C6; // type:object size:0xF scope:local data:string
__vt__Q33ipl5scene11ChanAppEdit = .data:0x8164D6D8; // type:object size:0x28
@15167 = .data:0x8164D7C0; // type:object size:0x7C scope:local
...data.0 = .data:0x8164D7C0; // type:label scope:local
@@ -17535,20 +17555,20 @@ __vt__Q39textinput12candidatebox4Base = .data:0x8165DFA8; // type:object size:0x
__vt__Q39textinput12candidatebox18CandidateBoxCaller = .data:0x8165DFFC; // type:object size:0x1C
__vt__Q39textinput11nw4rmanager11AnmObserver = .data:0x8165E018; // type:object size:0x4C
__vt__Q39textinput4util12AnimObserver = .data:0x8165E064; // type:object size:0xC
lbl_8165E070 = .data:0x8165E070; // type:object size:0xC data:string
lbl_8165E080 = .data:0x8165E080; // type:object size:0x10 data:string
lbl_8165E090 = .data:0x8165E090; // type:object size:0xD data:string
lbl_8165E0A0 = .data:0x8165E0A0; // type:object size:0xC data:string
@6142 = .data:0x8165E070; // type:object size:0xC scope:local data:string
@6143 = .data:0x8165E080; // type:object size:0x10 scope:local data:string
@6144 = .data:0x8165E090; // type:object size:0xD scope:local data:string
@6145 = .data:0x8165E0A0; // type:object size:0xC scope:local data:string
csPaneToAnimation__Q29textinput7toolbar = .data:0x8165E0B0; // type:object size:0x100
lbl_8165E1B0 = .data:0x8165E1B0; // type:object size:0xD data:string
lbl_8165E1C0 = .data:0x8165E1C0; // type:object size:0xC data:string
lbl_8165E1CC = .data:0x8165E1CC; // type:object size:0xD data:string
lbl_8165E1DC = .data:0x8165E1DC; // type:object size:0xC data:string
lbl_8165E1E8 = .data:0x8165E1E8; // type:object size:0xC data:string
lbl_8165E1F8 = .data:0x8165E1F8; // type:object size:0x10 data:string
jumptable_8165E208 = .data:0x8165E208; // type:object size:0x30 scope:local
lbl_8165E238 = .data:0x8165E238; // type:object size:0xC data:string
jumptable_8165E244 = .data:0x8165E244; // type:object size:0x1C scope:local
@6802 = .data:0x8165E1B0; // type:object size:0xD scope:local data:string
@6805 = .data:0x8165E1C0; // type:object size:0xC scope:local data:string
@6808 = .data:0x8165E1CC; // type:object size:0xD scope:local data:string
@6812 = .data:0x8165E1DC; // type:object size:0xC scope:local data:string
@6816 = .data:0x8165E1E8; // type:object size:0xC scope:local data:string
@6817 = .data:0x8165E1F8; // type:object size:0x10 scope:local data:string
@6837 = .data:0x8165E208; // type:object size:0x30 scope:local
@6894 = .data:0x8165E238; // type:object size:0xC scope:local data:string
@6937 = .data:0x8165E244; // type:object size:0x1C scope:local
__vt__Q39textinput7toolbar19ToggleButtonAnmPane = .data:0x8165E260; // type:object size:0x2C
__vt__Q39textinput7toolbar19NormalButtonAnmPane = .data:0x8165E28C; // type:object size:0x2C
__vt__Q39textinput7toolbar7AnmPane = .data:0x8165E2B8; // type:object size:0x2C
@@ -21691,7 +21711,7 @@ lbl_816965C4 = .sdata:0x816965C4; // type:object size:0x6 data:string
lbl_816965CA = .sdata:0x816965CA; // type:object size:0x4
smButtonName__Q33ipl5scene13AddressAddSel = .sdata:0x816965D0; // type:object size:0x8
@10971 = .sdata:0x816965D8; // type:object size:0x4 scope:local data:string
lbl_816965E0 = .sdata:0x816965E0; // type:object size:0x4 data:4byte
sInputPaneName = .sdata:0x816965E0; // type:object size:0x4 data:4byte
lbl_816965E4 = .sdata:0x816965E4; // type:object size:0x4 data:string
lbl_816965E8 = .sdata:0x816965E8; // type:object size:0x2
lbl_816965EA = .sdata:0x816965EA; // type:object size:0x6 data:string
@@ -22266,10 +22286,10 @@ lbl_816973C4 = .sdata:0x816973C4; // type:object size:0x4 data:4byte
lbl_816973C8 = .sdata:0x816973C8; // type:object size:0x8
lbl_816973D0 = .sdata:0x816973D0; // type:object size:0x8 data:string
lbl_816973D8 = .sdata:0x816973D8; // type:object size:0x8 data:string
lbl_816973E0 = .sdata:0x816973E0; // type:object size:0x4 data:4byte
lbl_816973E4 = .sdata:0x816973E4; // type:object size:0x4 data:4byte
lbl_816973E8 = .sdata:0x816973E8; // type:object size:0x5 data:string
lbl_816973F0 = .sdata:0x816973F0; // type:object size:0x7 data:string
COMMON_BUTTON_ANIM__Q29textinput7toolbar = .sdata:0x816973E0; // type:object size:0x4 scope:local data:4byte
COMMON_CHG_ANIM__Q29textinput7toolbar = .sdata:0x816973E4; // type:object size:0x4 scope:local data:4byte
@6901 = .sdata:0x816973E8; // type:object size:0x5 scope:local data:string
@6908 = .sdata:0x816973F0; // type:object size:0x7 scope:local data:string
lbl_816973F8 = .sdata:0x816973F8; // type:object size:0x4 data:4byte
lbl_81697400 = .sdata:0x81697400; // type:object size:0x4 data:4byte
lbl_81697404 = .sdata:0x81697404; // type:object size:0x4 data:4byte
@@ -23523,7 +23543,7 @@ s_fatalVFFlag = .sbss:0x81698D7C; // type:object size:0x4 scope:local data:4byte
CDBPrintDebugLevel = .sbss:0x81698D80; // type:object size:0x4 data:4byte
s_lastNANDError = .sbss:0x81698D84; // type:object size:0x4 scope:local data:4byte
s_lastVFError = .sbss:0x81698D88; // type:object size:0x4 scope:local data:4byte
lbl_81698D8C = .sbss:0x81698D8C; // type:object size:0x4 scope:local data:4byte
CDBDatabaseWorkBuf = .sbss:0x81698D8C; // type:object size:0x4 data:4byte
s_recordPool = .sbss:0x81698D90; // type:object size:0x4 scope:local data:4byte
s_databasePool = .sbss:0x81698D94; // type:object size:0x4 scope:local data:4byte
lbl_81698D98 = .sbss:0x81698D98; // type:object size:0x4 data:4byte

View File

@@ -8,6 +8,7 @@ MEMORY {
}
SECTIONS {
IPL_WWW_SURFACE_ZERO__Q37ext_ead3www5print = 0;
GROUP: {
.init ALIGN(0x20): {}
extab ALIGN(0x20): {}
@@ -35,3 +36,7 @@ SECTIONS {
__ArenaLo = (_db_stack_addr + 0x1F) & ~0x1F;
__ArenaHi = $ARENAHI;
}
FORCEACTIVE {
$FORCEACTIVE
}

View File

@@ -623,12 +623,13 @@ config.libs = [
Object(Matching, "system/enc_dummy.c"),
Object(Matching, "system/rvl_dec.c"),
Object(Matching, "system/RIPL_BoardRecord.c"),
Object(Equivalent, "system/iplSystem.cpp"),
Object(Matching, "system/iplSystem.cpp"),
Object(NonMatching, "system/iplController.cpp"),
Object(NonMatching, "system/iplControllerManager.cpp"),
Object(Matching, "system/iplChannelManager.cpp"),
Object(Matching, "system/iplChannelScriptManager.cpp"),
Object(Matching, "system/iplNand.cpp"),
Object(NonMatching, "system/iplNandShared.cpp"),
Object(Matching, "system/iplNandShared.cpp"),
Object(Matching, "system/iplNandMeta.cpp"),
Object(Matching, "system/iplNandManager.cpp"),
Object(Matching, "system/iplNandWall.cpp"),
@@ -641,7 +642,7 @@ config.libs = [
Object(Matching, "system/iplCdbManager.cpp"),
Object(Matching, "system/iplCdbWrapper.cpp"),
Object(Matching, "system/iplPlayTimeLog.cpp"),
Object(Equivalent, "system/iplNwc24Manager.cpp"),
Object(Matching, "system/iplNwc24Manager.cpp"),
Object(Matching, "system/iplPointer.cpp"),
Object(Matching, "system/iplPointerCore.cpp"),
Object(Matching, "system/iplDialogWindow.cpp"),
@@ -653,16 +654,16 @@ config.libs = [
Object(Matching, "system/iplWarningHandler.cpp"),
Object(Matching, "system/iplSocketSetting.cpp"),
Object(Matching, "system/iplPostmanManager.cpp"),
Object(NonMatching, "system/iplSaveDataManager.cpp"),
Object(Matching, "system/iplSaveDataManager.cpp"),
Object(Matching, "system/iplChannelRsoThread.cpp"),
Object(Equivalent, "system/RsoSystem.cpp"),
Object(Matching, "system/RsoSystem.cpp"),
Object(Matching, "system/iplCdbBackup.cpp"),
Object(NonMatching, "system/odh.cpp"),
Object(Matching, "system/iplSDVFWorker.cpp"),
Object(Matching, "system/iplNandWrapper.cpp"),
Object(Matching, "system/main.cpp"),
Object(Matching, "system/iplBS2Manager.cpp"),
Object(NonMatching, "system/TVRC.cpp"),
Object(Matching, "system/TVRC.cpp"),
Object(Matching, "system/iplTVRCManager.cpp"),
Object(Matching, "system/_DATA_.c"),
]
@@ -671,9 +672,9 @@ config.libs = [
Object(Matching, "utility/iplTVRCUtils.cpp"),
Object(Matching, "utility/iplTree.cpp"),
Object(Matching, "utility/iplFrameController.cpp"),
Object(Equivalent, "utility/iplGraphics.cpp"),
Object(Matching, "utility/iplGraphics.cpp"),
Object(Matching, "utility/iplCapture.cpp"),
Object(Equivalent, "utility/iplUtility.cpp"),
Object(Matching, "utility/iplUtility.cpp"),
Object(Matching, "utility/iplThread.cpp"),
Object(Matching, "utility/iplMessageBase.cpp"),
Object(Matching, "utility/iplJpegDecoder.cpp"),
@@ -692,19 +693,19 @@ config.libs = [
]
),
IPLSection("iplwww", [
Object(Equivalent, "iplwww/www_browser.cpp"),
Object(Matching, "iplwww/www_browser.cpp"),
Object(Matching, "iplwww/www_message.cpp"),
Object(Equivalent, "iplwww/www_surface.cpp"),
Object(Matching, "iplwww/www_surface.cpp"),
Object(Matching, "iplwww/www_thread.cpp"),
Object(Matching, "iplwww/www_print.cpp"),
Object(Equivalent, "iplwww/www_window.cpp"),
Object(Matching, "iplwww/www_window.cpp"),
Object(Matching, "iplwww/www_trasition.cpp"),
Object(Equivalent, "iplwww/www_wiisetting.cpp"),
Object(Matching, "iplwww/www_arcreader.cpp"),
]
),
IPLSection("homebutton", [
Object(Equivalent, "homebutton/HBMBase.cpp"),
Object(Matching, "homebutton/HBMBase.cpp"),
Object(Matching, "homebutton/HBMAnmController.cpp"),
Object(Matching, "homebutton/HBMController.cpp"),
Object(Matching, "homebutton/HBMFrameController.cpp"),
@@ -738,27 +739,27 @@ config.libs = [
),
IPLSection("board", [
Object(Equivalent, "scene/board/iplBoard.cpp"),
Object(Equivalent, "scene/board/iplBoardObject.cpp"),
Object(Matching, "scene/board/iplBoardObject.cpp"),
Object(Matching, "scene/board/iplBoardSD.cpp"),
Object(Equivalent, "scene/board/iplUrlProcessor.cpp"),
Object(Matching, "scene/board/iplUrlProcessor.cpp"),
Object(Equivalent, "scene/board/iplFocusObject.cpp"),
]
),
IPLSection("button", [
Object(Equivalent, "scene/button/iplButton.cpp"),
Object(Matching, "scene/button/iplButton.cpp"),
Object(Matching, "scene/button/iplArrow.cpp"),
]
),
IPLSection("calendar", [
Object(Equivalent, "scene/calendar/iplCalendar.cpp"),
Object(Equivalent, "scene/calendar/iplDate.cpp"),
Object(Matching, "scene/calendar/iplCalendar.cpp"),
Object(Matching, "scene/calendar/iplDate.cpp"),
]
),
IPLSection("channelEdit", [
Object(Matching, "scene/channelEdit/iplChannelEdit.cpp"),
Object(Equivalent, "scene/channelEdit/iplChanAppBase.cpp"),
Object(Equivalent, "scene/channelEdit/iplChanAppBox.cpp"),
Object(Equivalent, "scene/channelEdit/iplChanAppEdit.cpp"),
Object(Matching, "scene/channelEdit/iplChanAppBase.cpp"),
Object(Matching, "scene/channelEdit/iplChanAppBox.cpp"),
Object(Matching, "scene/channelEdit/iplChanAppEdit.cpp"),
Object(Matching, "scene/channelEdit/iplAnmController.cpp"),
Object(Matching, "scene/channelEdit/iplNandSDCardManager.cpp"),
Object(Matching, "scene/channelEdit/iplThumbnail.cpp"),
@@ -783,12 +784,12 @@ config.libs = [
]
),
IPLSection("kitayamaTest", [
Object(Equivalent, "scene/kitayamaTest/iplKitayamaTest.cpp"),
Object(Matching, "scene/kitayamaTest/iplKitayamaTest.cpp"),
Object(Matching, "scene/kitayamaTest/nandsdworker_autotest.cpp"),
]
),
IPLSection("letterWriter", [
Object(Equivalent, "scene/letterWriter/iplLetterWriter.cpp"),
Object(Matching, "scene/letterWriter/iplLetterWriter.cpp"),
]
),
IPLSection("limitOver", [
@@ -890,16 +891,16 @@ config.libs = [
IPLSection("sceneSystem", [
Object(Matching, "scene/sceneSystem/iplSceneBase.cpp"),
Object(Matching, "scene/sceneSystem/iplSceneCreator.cpp"),
Object(Equivalent, "scene/sceneSystem/iplSceneManager.cpp"),
Object(Matching, "scene/sceneSystem/iplSceneManager.cpp"),
Object(Matching, "scene/sceneSystem/iplFaderSceneBase.cpp"),
]
),
IPLSection("textWriter", [
Object(Equivalent, "scene/textWriter/iplTextWriter.cpp"),
Object(Matching, "scene/textWriter/iplTextWriter.cpp"),
]
),
IPLSection("bannerSound", [
Object(Equivalent, "bannerSound/AudioWavePlayer.cpp"),
Object(Matching, "bannerSound/AudioWavePlayer.cpp"),
Object(Equivalent, "bannerSound/AxAdpcmPlayer.cpp"),
Object(Matching, "bannerSound/BannerSoundPlayer.cpp"),
Object(Matching, "bannerSound/AudioWaveUtility.cpp"),
@@ -911,8 +912,8 @@ config.libs = [
Object(NonMatching, "keyboard/tiCellPhone.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiInputForm.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiCandidateBox.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiToolBar.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiPredictLang.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiToolBar.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiPredictLang.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiSignWindow.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiString.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiAtokString.cpp", extra_cflags=["-O4,p"]), # for 4.3J
@@ -931,7 +932,7 @@ config.libs = [
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(Equivalent, "keyboard/tiGUIManager.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiGUIManager.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiHKBManager.cpp", extra_cflags=["-O4,p"]),
Object(NonMatching, "keyboard/tiHwKeyboard.cpp", extra_cflags=["-O4,p"]),
Object(Matching, "keyboard/tiLayout.cpp", extra_cflags=["-O4,p"]),
@@ -944,7 +945,7 @@ config.libs = [
Object(Matching, "channelScript/systemmenu/VmSystem.c"),
Object(Matching, "channelScript/systemmenu/iplCSSystem.cpp"),
Object(Matching, "channelScript/systemmenu/iplCSLayout.cpp"),
Object(Equivalent, "channelScript/systemmenu/iplCSPane.cpp"),
Object(Matching, "channelScript/systemmenu/iplCSPane.cpp"),
Object(Matching, "channelScript/systemmenu/iplCSMaterial.cpp"),
Object(Matching, "channelScript/systemmenu/iplCSTexture.cpp"),
Object(Matching, "channelScript/systemmenu/iplCSSavedata.cpp"),
@@ -980,7 +981,7 @@ config.libs = [
]
),
ZI8Lib("zi8clib", [
Object(NonMatching, "clib/zaddress.c"),
Object(Matching, "clib/zaddress.c"),
Object(NonMatching, "clib/zconvert.c"),
Object(NonMatching, "clib/zi81key.c"),
Object(NonMatching, "clib/zi8alpha.c"),
@@ -1001,7 +1002,7 @@ config.libs = [
Object(NonMatching, "clib/zi8space.c"),
Object(NonMatching, "clib/zi8uwd.c"),
Object(Matching, "clib/zi8ver.c"),
Object(NonMatching, "clib/zi8ZHuwd.c"),
Object(Matching, "clib/zi8ZHuwd.c"),
Object(NonMatching, "clib/zidawg1.c"),
Object(NonMatching, "clib/zikorean.c"),
Object(NonMatching, "clib/ziswordw.c"),
@@ -1015,27 +1016,27 @@ config.libs = [
# RevoEX
RevoEXLib("cdb", [
Object(Matching, "cdb/cdb.c"),
Object(Equivalent, "cdb/CDBConv.c"), # hmm
Object(NonMatching, "cdb/CDBDatabase.c"),
Object(Equivalent, "cdb/CDBFileSystemUtils.c"),
Object(Matching, "cdb/CDBConv.c"), # hmm
Object(Matching, "cdb/CDBDatabase.c"),
Object(Matching, "cdb/CDBFileSystemUtils.c"),
Object(Matching, "cdb/CDBFileSystem.c"),
Object(Matching, "cdb/CDBFileSystemVF.c"),
Object(Matching, "cdb/CDBFileSystemSD.c"),
Object(NonMatching, "cdb/CDBRecord.c"),
Object(Matching, "cdb/CDBRecordFile.c"),
Object(NonMatching, "cdb/CDBRecordKey.c"),
Object(Matching, "cdb/CDBRecordKey.c"),
Object(NonMatching, "cdb/CDBIntArray.c"),
Object(NonMatching, "cdb/CDBSystem.c"),
Object(Equivalent, "cdb/CDBAttr.c"),
Object(Matching, "cdb/CDBSystem.c"),
Object(Matching, "cdb/CDBAttr.c"),
Object(Matching, "cdb/CDBFBridge.c"),
Object(Matching, "cdb/CDBFBridgeVF.c"),
Object(Matching, "cdb/CDBFBridgeSD.c"),
Object(Matching, "cdb/CDBId.c"),
Object(NonMatching, "cdb/CDBCrypt.c"),
Object(Matching, "cdb/CDBCrypt.c"),
]
),
RevoEXLib("ncd", [
Object(NonMatching, "ncd/ncdsystem.c"),
Object(Matching, "ncd/ncdsystem.c"),
Object(NonMatching, "ncd/ncdsleep.c"),
]
),
@@ -1068,12 +1069,12 @@ config.libs = [
]
),
RevoEXLib("nwc24", [
Object(NonMatching, "nwc24/NWC24StdAPI.c"),
Object(Matching, "nwc24/NWC24StdAPI.c"),
Object(Matching, "nwc24/NWC24FileAPI.c"),
Object(Matching, "nwc24/NWC24Config.c"),
Object(Matching, "nwc24/NWC24Utils.c"),
Object(NonMatching, "nwc24/NWC24Manage.c"),
Object(NonMatching, "nwc24/NWC24MsgObj.c"),
Object(Matching, "nwc24/NWC24Manage.c"),
Object(Matching, "nwc24/NWC24MsgObj.c"),
Object(NonMatching, "nwc24/NWC24MBoxCtrl.c"),
Object(NonMatching, "nwc24/NWC24Mime.c"),
Object(Matching, "nwc24/NWC24Stream.c"),
@@ -1083,18 +1084,18 @@ config.libs = [
Object(NonMatching, "nwc24/NWC24MsgSubject.c"),
Object(Matching, "nwc24/NWC24Schedule.c"),
Object(NonMatching, "nwc24/NWC24DateParser.c"),
Object(Equivalent, "nwc24/NWC24FriendList.c"),
Object(Matching, "nwc24/NWC24FriendList.c"),
Object(Matching, "nwc24/NWC24SecretFList.c"),
Object(NonMatching, "nwc24/NWC24UserId.c"),
Object(Matching, "nwc24/NWC24UserId.c"),
Object(Matching, "nwc24/NWC24Time.c"),
Object(Matching, "nwc24/NWC24Ipc.c"),
Object(NonMatching, "nwc24/NWC24Download.c"),
Object(Equivalent, "nwc24/NWC24CHJump.c"),
Object(Matching, "nwc24/NWC24CHJump.c"),
Object(NonMatching, "nwc24/NWC24System.c"),
]
),
RevoEXLib("so", [
Object(NonMatching, "so/SOCommon.c"),
Object(Matching, "so/SOCommon.c"),
Object(NonMatching, "so/SOBasic.c"),
Object(NonMatching, "so/SOInformation.c"),
Object(NonMatching, "so/SOOption.c"),
@@ -1159,19 +1160,19 @@ config.libs = [
Object(Matching, "vf/system/pf_system.c"),
Object(Matching, "vf/develop/d_vf.c"),
Object(NonMatching, "vf/develop/d_vf_sys.c"),
Object(Matching, "vf/develop/d_vf_sys.c"),
Object(Matching, "vf/develop/d_hash.c"),
Object(Matching, "vf/develop/d_time.c"),
Object(Matching, "vf/develop/d_common.c"),
Object(NonMatching, "vf/develop/nand_drv.c"),
Object(NonMatching, "vf/develop/sd_drv.c"),
Object(Matching, "vf/develop/nand_drv.c"),
Object(Matching, "vf/develop/sd_drv.c"),
]
),
RevoEXLib("wd", [
Object(Matching, "wd/wd_misc.c"),
Object(Matching, "wd/wd_request.c"),
Object(Matching, "wd/wd_init.c"),
Object(NonMatching, "wd/WDScan.c"),
Object(Matching, "wd/WDScan.c"),
]
),
# RVLFaceLib
@@ -1197,20 +1198,20 @@ config.libs = [
# TMC JPEG
TMCJpegLib(
[
Object(NonMatching, "buffer/mkhdec3.c"),
Object(Matching, "buffer/mkhdec3.c"),
Object(Matching, "buffer/buffer_system.c"),
Object(Equivalent, "buffer/getcode.c"),
Object(Matching, "buffer/getcode.c"),
Object(NonMatching, "buffer/idct_block_var.c"),
Object(Matching, "api/decapi.c"),
Object(Matching, "jpegdec/jdec.c"),
Object(NonMatching, "jpegdec/jdec_main.c"),
Object(Matching, "jpegdec/jdec_main.c"),
Object(Matching, "jpegdec/jpformat.c"),
Object(NonMatching, "exif/exif_parse.c"),
Object(Equivalent, "reschange/iqdec_resolution_change_a3.c"),
Object(Matching, "reschange/iqdec_resolution_change_a3.c"),
Object(NonMatching, "reschange/idct_resolution_change_var.c"),
Object(NonMatching, "texturecvtr/Texture_MCUtoY8U8V8.c"),
@@ -1299,7 +1300,7 @@ config.libs = [
Object(Matching, "ut/ut_ResFontBase.cpp"),
Object(Matching, "ut/ut_ResFont.cpp"),
Object(NonMatching, "ut/ut_ArchiveFontBase.cpp"),
Object(NonMatching, "ut/ut_ArchiveFont.cpp"),
Object(Matching, "ut/ut_ArchiveFont.cpp"),
Object(Matching, "ut/ut_CharWriter.cpp"),
Object(Matching, "ut/ut_TextWriterBase.cpp"),
]
@@ -1446,7 +1447,7 @@ config.libs = [
RVLSDKLib("axfx", [
Object(Matching, "axfx/AXFXReverbHi.c"),
Object(Matching, "axfx/AXFXReverbHiDpl2.c"),
Object(NonMatching, "axfx/AXFXReverbHiExp.c"),
Object(Matching, "axfx/AXFXReverbHiExp.c"),
Object(NonMatching, "axfx/AXFXReverbHiExpDpl2.c"),
Object(Matching, "axfx/AXFXDelay.c"),
Object(Matching, "axfx/AXFXReverbStd.c"),
@@ -1483,7 +1484,7 @@ config.libs = [
Object(Matching, "card/CARDBios.c"),
Object(Matching, "card/CARDUnlock.c"),
Object(Matching, "card/CARDRdwr.c"),
Object(Equivalent, "card/CARDBlock.c"),
Object(Matching, "card/CARDBlock.c"),
Object(Matching, "card/CARDDir.c"),
Object(Matching, "card/CARDCheck.c"),
Object(Matching, "card/CARDMount.c"),
@@ -1550,7 +1551,7 @@ config.libs = [
]
),
RVLSDKLib("wpad", [
Object(Equivalent, "wpad/WPAD.c"),
Object(Matching, "wpad/WPAD.c"),
Object(NonMatching, "wpad/WPADHIDParser.c"),
Object(Matching, "wpad/WPADMem.c"),
Object(Matching, "wpad/WPADEncrypt.c"),
@@ -1699,7 +1700,7 @@ config.libs = [
Object(NonMatching, "fa/pf_fat12.c"),
Object(NonMatching, "fa/pf_fat16.c"),
Object(NonMatching, "fa/pf_fat32.c"),
Object(NonMatching, "fa/pf_fatfs.c"),
Object(Matching, "fa/pf_fatfs.c"),
Object(NonMatching, "fa/pf_file.c"),
Object(NonMatching, "fa/pf_path.c"),
Object(NonMatching, "fa/pf_sector.c"),
@@ -1714,7 +1715,7 @@ config.libs = [
Object(NonMatching, "fa/pf_chdmod.c"),
Object(NonMatching, "fa/pf_chmod.c"),
Object(NonMatching, "fa/pf_cinsert.c"),
Object(NonMatching, "fa/pf_closedir.c"),
Object(Matching, "fa/pf_closedir.c"),
Object(NonMatching, "fa/pf_combine.c"),
Object(NonMatching, "fa/pf_create.c"),
Object(NonMatching, "fa/pf_createdir.c"),
@@ -1722,27 +1723,27 @@ config.libs = [
Object(NonMatching, "fa/pf_derrnum.c"),
Object(NonMatching, "fa/pf_detach.c"),
Object(NonMatching, "fa/pf_divide.c"),
Object(NonMatching, "fa/pf_errnum.c"),
Object(Matching, "fa/pf_errnum.c"),
Object(NonMatching, "fa/pf_fadjust.c"),
Object(NonMatching, "fa/pf_fappend.c"),
Object(NonMatching, "fa/pf_fchdir.c"),
Object(NonMatching, "fa/pf_fclose.c"),
Object(Matching, "fa/pf_fclose.c"),
Object(NonMatching, "fa/pf_fconcat.c"),
Object(NonMatching, "fa/pf_feof.c"),
Object(NonMatching, "fa/pf_ferror.c"),
Object(Matching, "fa/pf_feof.c"),
Object(Matching, "fa/pf_ferror.c"),
Object(NonMatching, "fa/pf_finfo.c"),
Object(NonMatching, "fa/pf_flock.c"),
Object(Matching, "fa/pf_flock.c"),
Object(NonMatching, "fa/pf_fopen.c"),
Object(NonMatching, "fa/pf_format.c"),
Object(NonMatching, "fa/pf_fread.c"),
Object(Matching, "fa/pf_fread.c"),
Object(NonMatching, "fa/pf_fseek.c"),
Object(NonMatching, "fa/pf_fsetclstlink.c"),
Object(NonMatching, "fa/pf_fsexec.c"),
Object(NonMatching, "fa/pf_fsfirst.c"),
Object(NonMatching, "fa/pf_fsnext.c"),
Object(NonMatching, "fa/pf_fstat.c"),
Object(NonMatching, "fa/pf_fsync.c"),
Object(NonMatching, "fa/pf_fwrite.c"),
Object(Matching, "fa/pf_fsync.c"),
Object(Matching, "fa/pf_fwrite.c"),
Object(NonMatching, "fa/pf_getdev.c"),
Object(NonMatching, "fa/pf_getvol.c"),
Object(NonMatching, "fa/pf_getvolcfg.c"),
@@ -1831,19 +1832,19 @@ config.libs = [
Object(NonMatching, "fa/api/FACreatedir.c"),
Object(NonMatching, "fa/api/FADetach.c"),
Object(NonMatching, "fa/api/FAErrnum.c"),
Object(NonMatching, "fa/api/FAFclose.c"),
Object(NonMatching, "fa/api/FAFinfo.c"),
Object(Matching, "fa/api/FAFclose.c"),
Object(Matching, "fa/api/FAFinfo.c"),
Object(NonMatching, "fa/api/FAFopen.c"),
Object(NonMatching, "fa/api/FAFormat.c"),
Object(NonMatching, "fa/api/FAFread.c"),
Object(Matching, "fa/api/FAFread.c"),
Object(NonMatching, "fa/api/FAFseek.c"),
Object(NonMatching, "fa/api/FAFsfirst.c"),
Object(NonMatching, "fa/api/FAFsnext.c"),
Object(NonMatching, "fa/api/FAFstat.c"),
Object(NonMatching, "fa/api/FAFwrite.c"),
Object(Matching, "fa/api/FAFwrite.c"),
Object(NonMatching, "fa/api/FAGetdev.c"),
Object(NonMatching, "fa/api/FAInit.c"),
Object(NonMatching, "fa/api/FAInitDiskManager.c"),
Object(Matching, "fa/api/FAInitDiskManager.c"),
Object(NonMatching, "fa/api/FAMount.c"),
Object(NonMatching, "fa/api/FARegistCB.c"),
Object(NonMatching, "fa/api/FARemove.c"),
@@ -1863,7 +1864,7 @@ config.libs = [
]
),
RVLSDKLib("sdi", [
Object(NonMatching, "sdi/sdi_api.c"),
Object(Matching, "sdi/sdi_api.c"),
]
),
RVLSDKLib("nup", [
@@ -1899,17 +1900,17 @@ config.libs = [
]
),
RVLSDKLib("cntcache", [
Object(NonMatching, "cntcache/cntcache.c"),
Object(Matching, "cntcache/cntcache.c"),
]
),
# EGG library (for Nintendo EAD software)
EGGLib(
[
Object(Matching, "core/eggAllocator.cpp"),
Object(Equivalent, "core/eggAudioArcPlayerMgr.cpp"),
Object(Matching, "core/eggAudioArcPlayerMgr.cpp"),
Object(Equivalent, "core/eggAudioExpMgr.cpp"),
Object(Matching, "core/eggAudioFxMgr.cpp"),
Object(Equivalent, "core/eggAudioMgr.cpp"),
Object(Matching, "core/eggAudioMgr.cpp"),
Object(Matching, "core/eggAudioHeapMgr.cpp"),
Object(Matching, "core/eggColorFader.cpp"),
Object(Matching, "core/eggDisposer.cpp"),
@@ -1940,44 +1941,44 @@ config.libs = [
),
# MSL Library
MSLLib("MSL_C.PPCEABI.bare.H", [
Object(NonMatching, "MSL_Common/alloc.c"),
Object(Matching, "MSL_Common/alloc.c"),
Object(Matching, "MSL_Common/errno.c"),
Object(NonMatching, "MSL_Common/ansi_files.c"),
Object(Matching, "MSL_Common/ansi_files.c"),
Object(NonMatching, "MSL_Common_Embedded/ansi_fp.c"),
Object(Matching, "MSL_Common/ctype.c"),
Object(NonMatching, "MSL_Common/locale.c"),
Object(NonMatching, "MSL_Common/arith.c"),
Object(NonMatching, "MSL_Common/bsearch.c"),
Object(NonMatching, "MSL_Common/buffer_io.c"),
Object(NonMatching, "MSL_Common/direct_io.c"),
Object(Matching, "MSL_Common/arith.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/bsearch.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/buffer_io.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/direct_io.c", extra_cflags=["-Cpp_exceptions on"]),
Object(NonMatching, "MSL_Common/file_io.c"),
Object(NonMatching, "MSL_Common/FILE_POS.c"),
Object(NonMatching, "MSL_Common/mbstring.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(NonMatching, "MSL_Common/misc_io.c"),
Object(Matching, "MSL_Common/misc_io.c"),
Object(NonMatching, "MSL_Common/printf.c"),
Object(NonMatching, "MSL_Common/qsort.c"),
Object(Matching, "MSL_Common/qsort.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/rand.c"),
Object(NonMatching, "MSL_Common/scanf.c"),
Object(NonMatching, "MSL_Common/signal.c"),
Object(NonMatching, "MSL_Common/string.c"),
Object(Matching, "MSL_Common/signal.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/string.c"),
Object(Matching, "MSL_Common/float.c"),
Object(NonMatching, "MSL_Common/strtold.c"),
Object(NonMatching, "MSL_Common/strtoul.c"),
Object(Matching, "MSL_Common/strtoul.c", extra_cflags=["-Cpp_exceptions on"]),
Object(NonMatching, "MSL_Common/time.c"),
Object(NonMatching, "MSL_Common/wctype.c"),
Object(Matching, "MSL_Common/wctype.c"),
Object(Matching, "MSL_Common/wmem.c"),
Object(NonMatching, "MSL_Common/wprintf.c"),
Object(NonMatching, "MSL_Common/wstring.c"),
Object(NonMatching, "MSL_Common/wchar_io.c"),
Object(Matching, "MSL_Common/wstring.c"),
Object(Matching, "MSL_Common/wchar_io.c"),
Object(Matching, "PPC_EABI/time.dolphin.c"),
Object(Matching, "PPC_EABI/sysenv.GCN.c"),
Object(Matching, "PPC_EABI/uart_console_io_gcn.c"),
Object(Matching, "PPC_EABI/abort_exit_ppc_eabi.c"),
Object(NonMatching, "MSL_Common/math_sun.c"),
Object(NonMatching, "MSL_Common/extras.c"),
Object(Matching, "MSL_Common/math_sun.c", extra_cflags=["-Cpp_exceptions on"]),
Object(Matching, "MSL_Common/extras.c"),
Object(Matching, "MSL_Common_Embedded/Math/e_acos.c"),
Object(Matching, "MSL_Common_Embedded/Math/e_asin.c"),

View File

@@ -30,9 +30,9 @@ private:
class WaveFileAiff : public WaveFile {
public:
WaveFileAiff();
virtual ~WaveFileAiff() {}
virtual u32 getBit() const override;
virtual ~WaveFileAiff();
virtual int getChannels() const override { return mNumChans; }
virtual f64 getSamplingRate() const override { return mSamplingRate; }
virtual s32 getFrames() const override;
@@ -67,9 +67,9 @@ private:
class WaveFileWav : public WaveFile {
public:
WaveFileWav();
virtual ~WaveFileWav() {}
virtual u32 getBit() const override;
virtual ~WaveFileWav();
virtual int getChannels() const override { return mNumChans; }
virtual f64 getSamplingRate() const override { return mSamplingRate; }
virtual s32 getFrames() const override;

View File

@@ -272,20 +272,20 @@ namespace homebutton {
f32 mFadeOutSeTime; // 0x798
private:
static const int scSoundHeapSize_but2;
static const int scSoundHeapSize_but3;
static const int scSoundThreadPrio;
static const int scDvdThreadPrio;
static const int scSoundHeapSize_but2 = 0x60000;
static const int scSoundHeapSize_but3 = 0x6f800;
static const int scSoundThreadPrio = 4;
static const int scDvdThreadPrio = 3;
static const int scReConnectTime;
static const int scReConnectTime2;
static const int scPadDrawWaitTime;
static const int scGetPadInfoTime;
static const int scForcusSEWaitTime;
static const int scReConnectTime = 3600;
static const int scReConnectTime2 = 3570;
static const int scPadDrawWaitTime = 5;
static const int scGetPadInfoTime = 100;
static const int scForcusSEWaitTime = 2;
static const f32 scOnPaneVibTime;
static const f32 scOnPaneVibWaitTime;
static const int scWaitStopMotorTime;
static const int scWaitDisConnectTime;
static const int scWaitStopMotorTime = 30;
static const int scWaitDisConnectTime = 180;
static const char* scCursorLytName[res::eCursorLyt_Max];
static const char* scCursorPaneName;

View File

@@ -139,6 +139,9 @@ namespace ext_ead {
u32 unk_0x14; // 0x14
u32 unk_0x18; // 0x18
u32 maxLength; // 0x1c
ImeData& operator=(const ImeData&);
} ImeData;
class BrowserThread : public ut_thread {
@@ -170,6 +173,9 @@ namespace ext_ead {
} updateIme; // ID 4
u32 raw[6];
} data;
CmdPacket& operator=(const CmdPacket&);
};
BrowserThread();

View File

@@ -48,13 +48,21 @@ namespace ext_ead {
extern const char* Message[6];
// TODO: sort out this messy match hack
#ifdef IPL_WWW_SURFACE_MESSAGE
#define IPL_WWW_SURFACE_ZERO_DECL __declspec(weak) extern const char IPL_WWW_SURFACE_ZERO[];
#define IPL_WWW_STRIPPED_MESSAGE print::IPL_WWW_SURFACE_ZERO
#else
#define IPL_WWW_SURFACE_ZERO_DECL
#define IPL_WWW_STRIPPED_MESSAGE ""
#endif
IPL_WWW_SURFACE_ZERO_DECL
#define IPL_WWW_REPORT_REDEFINE_MESSAGE(RESPECT_STRIP) \
char MSG_TICK_TIMER_TAG[12] = "[TickTimer]"; \
char MSG_WARNING_TAG[10] = "[Warning]"; \
char MSG_EVENT_TAG[10] = "[[Event]]"; \
const char* Message[] = { \
RESPECT_STRIP ? NULL : MSG_TICK_TIMER_TAG, RESPECT_STRIP ? NULL : MSG_WARNING_TAG, RESPECT_STRIP ? NULL : "[Info]", \
RESPECT_STRIP ? NULL : "[Debug]", RESPECT_STRIP ? "" : MSG_EVENT_TAG, RESPECT_STRIP ? NULL : "", \
RESPECT_STRIP ? NULL : "[Debug]", RESPECT_STRIP ? IPL_WWW_STRIPPED_MESSAGE : MSG_EVENT_TAG, RESPECT_STRIP ? NULL : "", \
};
} // namespace print
} // namespace www

View File

@@ -290,7 +290,7 @@ namespace textinput {
public:
PaneComponent(u32 id) : GUIComponent(id) { mpPane = NULL; }
virtual ~PaneComponent() {} // 0x08
virtual ~PaneComponent(); // 0x08
virtual void draw(); // 0x1C

View File

@@ -162,6 +162,7 @@ namespace textinput {
virtual void autoScroll();
virtual bool doWordWrap(const wchar_t* string, u32, f32);
f32 getWordWrapRectWidth() const { return mRect.right - mRect.left; }
virtual void drawFixString(u32);
virtual void onSE(sound::SE seId);

View File

@@ -67,6 +67,9 @@ namespace textinput {
virtual void setAspectRatio(bool b4x3);
virtual void setSecretInputMode(bool secretInputMode) { mpInputForm->setSecretModeOn(secretInputMode); }
#ifdef IPL_ADDRESS_EDIT_CPP
void enableKSXFilter(bool compatibleFilter);
#endif
virtual void setDefaultPredictionJP(int num, const char** predicts);
virtual void setFixedPredictionJP(int num, const char** predicts);

View File

@@ -14,6 +14,10 @@ namespace textinput {
class Base : public CommandSender {
public:
#ifdef TI_PREDICTLANG_SAMPLE_CLASS
Base(Manager* manager) : mePredictMode(inputform::Base::PM_USEn), mpAllocator(NULL), mpManager(manager) {}
#endif
virtual void create(MEMAllocator* allocator) override { mpAllocator = allocator; }
virtual void setPredictMode(inputform::Base::PredictMode mode) { mePredictMode = mode; }
@@ -28,6 +32,12 @@ namespace textinput {
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public nw4rmanager::AnmObserver {
public:
#ifdef TI_PREDICTLANG_SAMPLE_CLASS
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer)
: Base(manager), nw4rmanager::Layout(resAccessor, "fs_prdicSelWidw_a.brlyt", observer), mbActive(false), mbInput(false),
mpEventHandler(NULL), meDestination(DST_US), mpCaller(NULL) {}
#endif
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator) override;
virtual void init() override;
@@ -58,6 +68,15 @@ namespace textinput {
keyboard::KeyboardBase* mpCaller; // 0xD4
};
#ifdef TI_PREDICTLANG_SAMPLE_CLASS
class Sample : public LayoutByNW4R {
public:
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer)
: LayoutByNW4R(manager, resAccessor, observer) {}
virtual ~Sample() {}
};
#endif
class EventHandler : public nw4rmanager::TiEventHandler {
public:
EventHandler(LayoutByNW4R* layout) : mpLayoutByNW4R(layout) {}

View File

@@ -79,7 +79,7 @@ namespace textinput {
virtual void isEnableCursorCache();
virtual void getDrawModifyStartLine();
virtual void getDrawModifyEndLine();
virtual void getDrawCacheStartPos();
virtual u32 getDrawCacheStartPos() const;
virtual void dirtyDrawCache();
virtual void dirtyCursorCache();

View File

@@ -10,6 +10,10 @@ namespace textinput {
namespace toolbar {
class Base {
public:
#ifdef TI_TOOLBAR_SAMPLE_CLASS
Base(Manager* manager) : mQwerty(true), meLanguage(USA), mpAllocator(NULL), mpManager(manager) {}
#endif
virtual void create(MEMAllocator* allocator) { mpAllocator = allocator; }
virtual void init() {}
virtual bool isQwerty() const { return mQwerty; }
@@ -31,6 +35,12 @@ namespace textinput {
class LayoutByNW4R : public Base, public nw4rmanager::Layout {
public:
#ifdef TI_TOOLBAR_SAMPLE_CLASS
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer)
: Base(manager), nw4rmanager::Layout(resAccessor, "fs_VK_toolbar_a.brlyt", observer), mpEventHandler(NULL),
mbIsEnableQwertyChg(false) {}
#endif
virtual ~LayoutByNW4R();
virtual void create(MEMAllocator* allocator) override;
virtual void init() override;
@@ -107,7 +117,16 @@ namespace textinput {
KeyType meKeyType; // 0x30
};
#ifdef TI_TOOLBAR_SAMPLE_CLASS
class Sample : public LayoutByNW4R {
public:
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* resAccessor, EventObserver* observer)
: LayoutByNW4R(manager, resAccessor, observer) {}
virtual ~Sample() {}
};
#else
class Sample {};
#endif
class NormalButtonAnmPane : public AnmPane {
public:

View File

@@ -30,10 +30,18 @@ namespace gui {
virtual void draw(Mtx& mtx) {} // 0x14 (0x05)
virtual void draw() {} // 0x18 (0x06)
virtual ~Interface() {} // 0x1C (0x07)
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
virtual ~Interface(); // 0x1C (0x07)
#else
virtual ~Interface() {} // 0x1C (0x07)
#endif
};
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
class __declspec(novtable) EventHandler {
#else
class EventHandler {
#endif
public:
enum {
ON_TRIG = 0,

View File

@@ -11,14 +11,18 @@
namespace ipl {
namespace gui {
class PaneComponent : public ::gui::PaneComponent {};
class PaneManager : public ::gui::PaneManager {
class PaneManager : public ::gui::PaneManager {
public:
PaneManager(::gui::EventHandler* event, const nw4r::lyt::DrawInfo* drawInfo, EGG::Heap* heap, EGG::Allocator* allocator, bool bDisableCon = false) :
::gui::PaneManager(event, allocator, drawInfo),
mpHeap(heap),
mbDisableCon(bDisableCon) {}
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
virtual ~PaneManager();
#else
virtual ~PaneManager() {}
#endif
void update();
void update(int chan);

View File

@@ -12,6 +12,9 @@ namespace ipl {
template <typename T>
class Interporation : public utility::FrameController {
public:
#ifdef IPL_BOARD_OBJECT_INLINE_INTERPOLATION_DTORS
virtual ~Interporation();
#endif
void init(int playback, f32 maxFrame, f32 minFrame, const T& start, const T& end, f32 speed = 1.0f) {
mStart = start;
mEnd = end;
@@ -34,6 +37,9 @@ namespace ipl {
template <typename T>
class LinearIntp : public Interporation<T> {
public:
#ifdef IPL_BOARD_OBJECT_INLINE_INTERPOLATION_DTORS
virtual ~LinearIntp();
#endif
T get() const {
T r = mEnd * getCurrentFrame();
T b = mStart * (mMaxFrame - mFrame);
@@ -44,6 +50,94 @@ namespace ipl {
T get2() const { return (((mStart * (mMaxFrame - mFrame)) + (mEnd * mFrame)) / mMaxFrame); }
};
#ifdef IPL_CHANNEL_TITLE_NOVTABLE
template <typename T>
class __declspec(novtable) HermiteIntp : public utility::FrameController {
public:
HermiteIntp() {}
virtual ~HermiteIntp();
void init(const T& start, const T& end, f32 maxFrame, f32 param_5, f32 param_6, int playback = ANIM_TYPE_FORWARD, f32 speed = 1.0f);
T get() const {
f32 var_f27 = mFrame;
f32 var_f28 = 1.0f / mMaxFrame;
T r =
(mStart *
(1.0f + ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))))) -
(mEnd * ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))));
r +=
(unkVal0 *
(var_f27 +
((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (2.0f * var_f27 * var_f27))))) +
(unkVal1 * ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (var_f27 * var_f27))));
return r;
/*f32 var_f27 = mMaxFrame;
f32 var_f28 = 1.0f / mMaxFrame;
T sp28 = mEnd * ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27))));
T sp1C = mStart * (1.0f + ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))));
T r = sp1C - sp28;
f32 temp_f4 = var_f27 * var_f27;
f32 temp_f7 = var_f28 * (var_f28 * (var_f27 * temp_f4));
f32 temp_f3 =
(unkVal0 * (var_f27 + (temp_f7 - (var_f28 * (2.0f * var_f27 * var_f27))))) + (unkVal1 * (temp_f7 - (var_f28 * temp_f4)));
r = r + temp_f3;
return r;*/
}
protected:
T mStart;
T mEnd;
f32 unkVal0;
f32 unkVal1;
};
template <>
class HermiteIntp<f32> : public utility::FrameController {
public:
HermiteIntp() {}
virtual ~HermiteIntp();
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 {
f32 var_f27 = mFrame;
f32 var_f28 = 1.0f / mMaxFrame;
f32 r =
(mStart *
(1.0f + ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))))) -
(mEnd * ((var_f28 * (var_f28 * (var_f28 * (var_f27 * (2.0f * var_f27 * var_f27))))) -
(var_f28 * (var_f28 * (3.0f * var_f27 * var_f27)))));
r +=
(unkVal0 *
(var_f27 + ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (2.0f * var_f27 * var_f27))))) +
(unkVal1 * ((var_f28 * (var_f28 * (var_f27 * (var_f27 * var_f27)))) -
(var_f28 * (var_f27 * var_f27))));
return r;
}
protected:
f32 mStart;
f32 mEnd;
f32 unkVal0;
f32 unkVal1;
};
#pragma dont_instantiate HermiteIntp<float>
#else
template <typename T>
class HermiteIntp : public Interporation<T> {
public:
@@ -94,6 +188,8 @@ namespace ipl {
f32 unkVal0;
f32 unkVal1;
};
#endif
} // namespace math
} // namespace ipl

View File

@@ -35,6 +35,10 @@ namespace ipl {
return x;
}
}
#ifdef IPL_CONTROLLER_OUT_OF_LINE_ABS_CLAMP
template <>
f32 abs_clamp<f32>(const f32& x, const f32& y);
#endif
typedef struct MTX33 : public nw4r::math::MTX33 {
} MTX33;
@@ -55,19 +59,27 @@ namespace ipl {
x = r.x;
y = r.y;
}
#ifdef IPL_CONTROLLER_OUT_OF_LINE_VEC2
VEC2(f32 fx, f32 fy);
#else
VEC2(f32 fx, f32 fy) {
x = fx;
y = fy;
}
#endif
void operator=(const VEC2& r);
VEC2 operator*(f32 val) const { return VEC2(x * val, y * val); }
#ifdef IPL_CONTROLLER_OUT_OF_LINE_VEC2
void set(f32 fx, f32 fy);
#else
void set(f32 fx, f32 fy) {
x = fx;
y = fy;
}
#endif
void clear() {
y = 0;
@@ -91,11 +103,15 @@ namespace ipl {
y = r.y;
z = 0.0f;
}
#ifdef IPL_ADDRESS_EDIT_CPP
VEC3(f32 fx, f32 fy, f32 fz);
#else
VEC3(f32 fx, f32 fy, f32 fz) {
x = fx;
y = fy;
z = fz;
}
#endif
VEC3& operator+=(const VEC3& rhs) {
VEC3Add(this, this, &rhs);

View File

@@ -1,44 +1,277 @@
#ifndef IPL_SCENE_ADDRESS_H
#define IPL_SCENE_ADDRESS_H
#include "iplSceneHeader.h"
#include "iplSceneUIHeader.h"
#include "scene/button/iplButton.h"
#include <revolution/nwc24.h>
namespace ipl {
namespace nigaoe {
class Object;
}
namespace scene {
class AddressEvent;
class FriendListCache {
public:
enum {
FRIEND_MAX = 100,
};
FriendListCache() : mbOpened(false) {}
BOOL init();
void fin();
void add(u32 index, const NWC24FriendInfo& info);
void update(u32 index, const wchar_t* name, u64 fdId);
void del(u32 index);
void swap(u32 index1, u32 index2);
BOOL isValidId(const NWC24UserId& userId);
BOOL isDupId(const NWC24UserId& userId);
BOOL isDupMail(const char* mailAddr);
void sendRegisterMail(u32 index);
s32 check();
s32 getErrCode() const;
const NWC24FriendInfo& getInfo(int index) const { return mInfos[index]; }
BOOL isThere(u32 index) const { return mbThere[index]; }
u32 getRegFriendNum() const { return mRegFriendNum; }
NWC24UserId getMyUserId() const { return mMyUserId; }
s32 getLastErr() const { return mErrCode; }
private:
NWC24FriendInfo mInfos[100];
NWC24FriendInfo mInfos[FRIEND_MAX]; // 0x0000
u8 mbThere[FRIEND_MAX]; // 0x7D00
NWC24UserId mMyUserId; // 0x7D68
u32 mRegFriendNum; // 0x7D70
u8 mSendWork[0x2000]; // 0x7D74
s32 mErrCode; // 0x9D74
bool mbOpened; // 0x9D78
};
FADER_SCENE_CLASS(Address) {
FADER_SCENE_CLASS(Address), public ButtonEventHandlerBase {
public:
Address(EGG::Heap * heap, int);
virtual void destroy() override;
Address(EGG::Heap * heap, int mode);
virtual ~Address();
virtual void prepare();
virtual void create();
virtual void draw();
virtual void destroy();
virtual FaderSceneCommand calcFadein();
virtual void initCalcNormal();
virtual FaderSceneCommand calcNormal();
virtual void initCalcFadeout();
virtual FaderSceneCommand calcFadeout();
virtual void calcCommonAfter();
virtual void onEventDerived(u32 compId, u32 event, const controller::Interface* con);
enum {
SCENE_ADD_WII = 1,
SCENE_ADD_EMAIL,
};
enum {
BTN_MAX = 5,
BTN_SPACE_MAX = BTN_MAX - 1,
PAGE_MAX = 20,
};
int getChosenFriendIndex() {
return unk_0xC0;
return mChosenFriend;
}
FriendListCache* getFriendCache() {
return unk_0x274;
return mpFriendCache;
}
private:
u8 unk_0x58[0x68];
int unk_0xC0;
u8 unk_0xC4[0x1B0];
FriendListCache* unk_0x274;
u8 unk_0x278[0x28];
enum {
FADEIN_STATE_WAIT_OPEN = 0,
FADEIN_STATE_FADEIN,
FADEIN_STATE_DONE,
};
enum {
STATE_INIT = 0,
STATE_COVER_NORMAL,
STATE_COVER_FORWARD,
STATE_COVER_BACKWARD,
STATE_NORMAL,
STATE_FORWARD,
STATE_BACKWARD,
STATE_LOOP_FORWARD,
STATE_LOOP_BACKWARD,
STATE_DECIDE,
STATE_DRAG,
STATE_RELEASE,
STATE_WAIT_CHILD_CST,
STATE_WAIT_CHILD_DST,
STATE_WAIT_CHILD_FADEOUT,
STATE_MSG_NET,
STATE_WAIT_PARENTAL,
STATE_WAIT_PARENTAL_DST,
STATE_MSG_WC,
STATE_WAIT_PARENTAL_WC,
STATE_WAIT_PARENTAL_DST_WC,
STATE_MSG_NWC24_ERROR,
STATE_MSG_FI_FULL,
STATE_MSG_PARENTAL,
STATE_MSG_OPEN_FAILURE,
STATE_WAIT_DIALOG,
STATE_DONE,
};
class MiiObj {
public:
MiiObj();
~MiiObj();
void init(nw4r::lyt::Pane* pane);
void set(u64 fdId);
void reset();
static void create_callback(nigaoe::Object* object, void* work);
GXTexObj mTexObj; // 0x00
nigaoe::Object* mpNigaoe; // 0x20
nw4r::lyt::Material* mpMaterial; // 0x24
};
struct DragInfo {
nw4r::math::VEC2 mPos; // 0x00
int mChan; // 0x08
int mPage; // 0x0C
int mButton; // 0x10
int mNextCount; // 0x14
int mPrevCount; // 0x18
int unk_0x1C; // 0x1C
bool mbDragging; // 0x20
};
void fistt_wait_open();
void fistt_fadein();
void onInitFriendList();
void stt_cover_normal();
void stt_cover_forward();
void stt_cover_backward();
void stt_normal();
void stt_forward();
void stt_backward();
void stt_loop_forward();
void stt_loop_backward();
void stt_decide();
void stt_drag();
void stt_release();
void stt_wait_child_cst();
void stt_wait_child_dst();
void stt_wait_child_fadeout();
void stt_msg_net();
void stt_wait_parental();
void stt_wait_parental_dst();
void stt_msg_wc();
void stt_wait_parental_wc();
void stt_wait_parental_dst_wc();
void stt_msg_nwc24_error();
void stt_msg_fi_full();
void stt_msg_parental();
void stt_msg_open_failure();
void stt_wait_dialog();
void add_translate(nw4r::lyt::Pane* pane, const math::VEC2& offset);
void set_friend(const char* paneName, u32 friendNo, u32 buttonNo, MiiObj& miiObj, bool bDrag);
void set_page_text(const char* paneName, int page);
void set_textbox(const char* paneName, const wchar_t* text);
void set_textbox(const char* paneName, u32 msgId);
void reset_friend();
void start_point_event(const char* paneName, controller::Interface* con);
void start_left_event(const char* paneName);
void start_trig_event(const char* paneName);
void start_drag_event(const char* paneName, const controller::Interface* con);
void start_drag_point_event(const char* paneName, controller::Interface* con);
void start_drag_left_event(const char* paneName);
void start_release_event(const char* paneName);
void on_point_event(int buttonNo, controller::Interface* con);
void left_point_event(int buttonNo);
int get_button_no(const char* paneName);
int get_button_space_no(const char* paneName);
void reset_gui(bool bKeepPointed);
BOOL is_selectable(u32 friendNo);
void onNextPage();
void onPreviousPage();
void set_err_msg(wchar_t* errMsg, u32 errMsgLen, NWC24Err err);
void entry_friend();
bool isReleasableArea(int page, int buttonNo);
void changePage_onDrag();
void movePane_onDrag();
DragInfo mDrag; // 0x64
int mMode; // 0x88
layout::Object* mpLayout; // 0x8C
int unk_0x90; // 0x90
AddressEvent* mpEvent; // 0x94
gui::PaneManager* mpGui; // 0x98
layout::Object* mpBackLayout; // 0x9C
layout::Object* mpDialogLayout; // 0xA0
int mFadeinState; // 0xA4
int mWaitOpenCount; // 0xA8
int mState; // 0xAC
int mPage; // 0xB0
int mNextPageNum; // 0xB4
int mPrevPageNum; // 0xB8
int mSelectedButton; // 0xBC
u32 mChosenFriend; // 0xC0
bool mbFaceValid[BTN_MAX]; // 0xC4
int mPointCount[BTN_MAX]; // 0xCC
bool mbParentalOK; // 0xE0
bool mbCover; // 0xE1
MiiObj mMiiObj[BTN_MAX]; // 0xE4
MiiObj mNextMiiObj[BTN_MAX]; // 0x1AC
FriendListCache* mpFriendCache; // 0x274
GXTexObj mDragTexObj; // 0x278
u8* mpWork; // 0x298
f32 mDragOffsetX; // 0x29C
static const math::VEC2 smcPageOffset;
friend class AddressEvent;
#ifdef IPL_ADDRESS_EDIT_CPP
friend class AddressEdit;
#endif
};
class AddressEvent : public ::gui::EventHandler {
public:
AddressEvent(Address* instance) : ::gui::EventHandler(), mpInstance(instance) {}
virtual void onEvent(u32 compId, u32 event, void* data);
private:
Address* mpInstance; // 0x0C
int mTrigChan; // 0x10
};
} // namespace scene
} // namespace ipl

View File

@@ -2,22 +2,125 @@
#define IPL_SCENE_ADDRESS_EDIT_H
#include "iplSceneHeader.h"
#include "scene/button/iplButton.h"
#include <RFL_Types.h>
#include <revolution/nwc24.h>
namespace ipl {
namespace nigaoe {
class Object;
}
namespace scene {
FADER_SCENE_CLASS(AddressEdit) {
class AddressEditEvent;
class AddressInputEvent;
class FriendListCache;
FADER_SCENE_CLASS(AddressEdit), public ButtonEventHandlerBase {
public:
AddressEdit(EGG::Heap * heap, int friendCode);
virtual ~AddressEdit();
virtual void prepare();
virtual void create();
virtual void draw();
virtual void initCalcNormal();
virtual void initCalcFadeout();
virtual void calcCommonAfter();
virtual FaderSceneCommand calcFadein();
virtual FaderSceneCommand calcNormal();
virtual FaderSceneCommand calcFadeout();
virtual void onEventDerived(u32 compId, u32 event, const controller::Interface* con);
void stt_msg_code_add();
void stt_msg_code_edit();
void stt_msg_parental();
void stt_msg_nwc24_error();
void reset_gui();
void start_point_event(const char* paneName, controller::Interface* controller);
void start_left_event(const char* paneName);
void start_trig_event(const char* paneName);
void start_ipt_point_event(const char* paneName, int channel);
void start_ipt_left_event(const char* paneName, int channel);
void start_ipt_trig_event(const char* paneName, int channel);
int get_button_no(const char*);
void add_friendinfo();
void delete_friendinfo();
void set_textbox(nw4r::lyt::Pane*, const wchar_t*);
void setDefaultTitleText(const wchar_t*, bool);
static void wiiid_utf16(u64, wchar_t*);
static void nigaoe_create_callback_add(ipl::nigaoe::Object*, void*);
static void nigaoe_create_callback_edit(ipl::nigaoe::Object*, void*);
void set_err_msg(wchar_t*, u32, NWC24Err);
void get_friendinfo();
static u64 utf16_wiiid(const wchar_t*);
void stt_add_code_fadein();
void stt_add_code_fadeout();
void stt_add_code_input();
void stt_add_code_normal();
void stt_add_confirm_fadein();
void stt_add_confirm_fadeout();
void stt_add_confirm_normal();
void stt_add_mii_fadein();
void stt_add_mii_fadeout();
void stt_add_mii_input();
void stt_add_mii_normal();
void stt_add_name_fadein();
void stt_add_name_fadeout();
void stt_add_name_input();
void stt_add_name_normal();
void stt_ipt_input();
void stt_ipt_normal();
void stt_ipt_wait_fadein();
void stt_ipt_wait_fadeout();
void stt_msg_add_rlt();
void stt_msg_code_invalid();
void stt_msg_del_rlt();
void stt_msg_dup_email();
void stt_msg_dup_wii_no();
void stt_msg_my_wii_no();
void stt_msg_net();
void stt_msg_no_established();
void stt_msg_no_mii();
void stt_msg_no_mii_add();
void stt_msg_wc();
void stt_select_mii();
void stt_wait_btn_fadein();
void stt_wait_btn_fadeout();
void stt_wait_del_msg_fadein();
void stt_wait_del_msg_fadeout();
void stt_wait_del_msg_fadeout_to_rlt();
void stt_wait_delete();
void stt_wait_decide_anm_add();
void stt_wait_parental();
void stt_wait_parental_dst();
void stt_wait_parental_dst_wc();
void stt_wait_parental_wc();
void stt_normal();
void stt_wait_decide_anm();
void update_friendinfo();
void requestSceneChange(int sceneId, void* args) { reserveSceneChange(sceneId, args); }
u32 getPreviousScene() const { return getPrevSceneID(); }
EGG::Heap* getHeap() { return getSceneHeap(); }
::gui::Manager* getGuiManager() { return mpManager; }
class String {
public:
void clear();
const wchar_t* getDispCodeLong() const;
void setName(const wchar_t* value);
void setEMail(const wchar_t* value);
void setWiiNo(const wchar_t* value);
wchar_t mValue[0x102];
wchar_t mName[0x0c];
wchar_t mDisplayText[0x102];
bool mbValidMail;
bool mbNameNotEmpty;
bool mbHasWiiNo;
};
enum {
@@ -25,8 +128,28 @@ namespace ipl {
SCENE_ADD_EMAIL,
};
private:
u8 unk_0x58[0x498];
int mState;
layout::Object* mpCodeLayout;
AddressEditEvent* mpEditEvent;
gui::PaneManager* mpEditGui;
layout::Object* mpNameLayout;
AddressInputEvent* mpInputEvent;
gui::PaneManager* mpInputGui;
layout::Object* mpBackgroundLayout;
int mMode;
int mSelectedButton;
int mSubState;
s32 mPointCount[5];
u32 mSelectedFriend;
TextBalloon* mpBalloon;
nand::LayoutFile* mpBalloonFile;
String mString;
AddressEdit* mpCallbackOwner;
bool mbParentalOK;
nigaoe::Object* mpNigaoe;
RFLCreateID mCreateID;
int mNigaoeState;
FriendListCache* mpFriendCache;
};
} // namespace scene
} // namespace ipl

View File

@@ -19,6 +19,13 @@
namespace ipl {
namespace scene {
extern wchar_t scTextDateJpnFormat[];
extern wchar_t scTextDateKorFormat[];
extern wchar_t scTextDateGerFormat[];
extern wchar_t scTextDatePalengFormat[];
#ifdef IPL_BOARD_DATE_HELPERS_INLINE
extern const u32 scWeekMsgId[];
#endif
class focus_object;
SCENE_CLASS(Board), public ButtonEventHandlerBase {
public:
@@ -81,13 +88,57 @@ namespace ipl {
void set_text_date();
void set_text_date(const utility::Date& date, const char* paneName);
#ifdef IPL_BOARD_DATE_HELPERS_INLINE
void get_text_jpn(const utility::Date& date, wchar_t* text, u32 textLen) {
message::Manager* msgMgr = System::getMessageManager();
const wchar_t* week = msgMgr->getMessage(scWeekMsgId[utility::Calendar::getWeek(date)]);
const wchar_t* sep1 = msgMgr->getMessage(MESG_CALENDAR_MONDAY);
const wchar_t* sep2 = msgMgr->getMessage(MESG_CALENDAR_MONDAY);
const wchar_t* weekStart = msgMgr->getMessage(MESG_CALENDAR_WEEK_START);
const wchar_t* weekEnd = msgMgr->getMessage(MESG_CALENDAR_WEEK_END);
swprintf(text, textLen, scTextDateJpnFormat, date.month, sep1, date.day, sep2, weekStart, week, weekEnd);
}
void get_text_kor(const utility::Date& date, wchar_t* text, u32 textLen) {
message::Manager* msgMgr = System::getMessageManager();
const wchar_t* week = msgMgr->getMessage(scWeekMsgId[utility::Calendar::getWeek(date)]);
const wchar_t* sep1 = msgMgr->getMessage(MESG_CALENDAR_MONDAY);
const wchar_t* sep2 = msgMgr->getMessage(MESG_CALENDAR_MONDAY);
const wchar_t* weekStart = msgMgr->getMessage(MESG_CALENDAR_WEEK_START);
const wchar_t* weekEnd = msgMgr->getMessage(MESG_CALENDAR_WEEK_END);
swprintf(text, textLen, scTextDateKorFormat, date.month, sep1, date.day, sep2, weekStart, week, weekEnd);
}
#else
void get_text_jpn(const utility::Date& date, wchar_t* text, u32 textLen);
void get_text_kor(const utility::Date& date, wchar_t* text, u32 textLen);
#endif
void get_text_spa(const utility::Date& date, wchar_t* text, u32 textLen);
#ifdef IPL_BOARD_DATE_HELPERS_INLINE
void get_text_ger(const utility::Date& date, wchar_t* text, u32 textLen) {
message::Manager* msgMgr = System::getMessageManager();
const wchar_t* week = msgMgr->getMessage(scWeekMsgId[utility::Calendar::getWeek(date)]);
const wchar_t* weekStart = msgMgr->getMessage(MESG_CALENDAR_WEEK_START);
const wchar_t* weekEnd = msgMgr->getMessage(MESG_CALENDAR_WEEK_END);
swprintf(text, textLen, scTextDateGerFormat, date.day, date.month, weekStart, week, weekEnd);
}
#else
void get_text_ger(const utility::Date& date, wchar_t* text, u32 textLen);
#endif
void get_text_usaeng(const utility::Date& date, wchar_t* text, u32 textLen);
void get_text_usafre(const utility::Date& date, wchar_t* text, u32 textLen);
#ifdef IPL_BOARD_DATE_HELPERS_INLINE
void get_text_paleng(const utility::Date& date, wchar_t* text, u32 textLen) {
message::Manager* msgMgr = System::getMessageManager();
const wchar_t* week = msgMgr->getMessage(scWeekMsgId[utility::Calendar::getWeek(date)]);
swprintf(text, textLen, scTextDatePalengFormat, week, date.day, date.month);
}
#else
void get_text_paleng(const utility::Date& date, wchar_t* text, u32 textLen);
#endif
void show_ricon();
void hide_ricon();
@@ -226,8 +277,17 @@ namespace ipl {
STATE_DONE,
};
#ifdef IPL_BOARD_INLINE_GETTERS
static Button* get_button() {
return static_cast<Button*>(System::getScene(SCENE_BUTTON));
}
static Arrow* get_arrow() {
return static_cast<Arrow*>(System::getScene(SCENE_ARROW));
}
#else
static Button* get_button();
static Arrow* get_arrow();
#endif
static const int OBJECTS_ON_SCREEN = 10;

View File

@@ -3,7 +3,15 @@
#include <revolution/types.h>
#ifdef IPL_ANM_CONTROLLER_FORWARD_GUI
namespace ipl {
namespace gui {
class PaneManager;
}
}
#else
#include "layout/iplGuiManager.h"
#endif
#include "layout/iplLayout.h"
namespace ipl {

View File

@@ -404,7 +404,12 @@ namespace ipl {
int mModuleIndex; // 0x400
EGG::ExpHeap* mpCSHeap; // 0x404
static ESTicketView msTicketView;
struct TicketViewStorage {
ESTicketView view;
u8 pad[8];
};
static TicketViewStorage msTicketView;
static ESTicketView msUnlockTicket;
static const char* mscBtnNames[BTN_MAX];

View File

@@ -35,7 +35,14 @@ namespace ipl {
virtual void onSend();
virtual int sendMessageByNWC24(NWC24UserId userId, const wchar_t* wcString);
#ifdef IPL_ADDRESS_MATCHING
virtual void setFriendInfo(const NWC24FriendInfo& info) {
mbToFriend = true;
mFriendInfo = info;
}
#else
virtual void setFriendInfo(const NWC24FriendInfo& info);
#endif
virtual void setPhoto(const GXTexObj& texObj);
virtual int sendToWii(NWC24UserId userId, const wchar_t* wcString);

View File

@@ -62,6 +62,200 @@ namespace ipl {
};
// clang-format on
#ifdef IPL_CONTROLLER_NATIVE_HIERARCHY
#ifdef IPL_CONTROLLER_INLINE_INTERFACE
#define IPL_CONTROLLER_DEFAULT_VIRTUAL(signature, implementation) virtual signature implementation
#else
#define IPL_CONTROLLER_DEFAULT_VIRTUAL(signature, implementation) virtual signature;
#endif
class Interface {
public:
virtual ~Interface() = 0;
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getType() const, { return -1; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getChannel() const, { return -1; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(bool down(u32 button) const, { return false; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(bool downTrg(u32 button) const, { return false; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(bool upTrg(u32 button) const, { return false; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int pinch() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int pinchTrg() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int pinchOffTrg() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int decide() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(bool repeat(u32 button) const, { return false; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(BOOL rumble(int type = 0), { return FALSE; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(void cancelRumbling(), { })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getHoldFlag() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getTrigFlag() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getReleaseFlag() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getClassicHoldFlag() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getClassicTrigFlag() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getClassicReleaseFlag() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(math::VEC2 getDpdPos() const, { return math::VEC2(0.0f, 0.0f); })
IPL_CONTROLLER_DEFAULT_VIRTUAL(math::VEC2 getDpdProjectionPos() const, { return math::VEC2(0.0f, 0.0f); })
IPL_CONTROLLER_DEFAULT_VIRTUAL(math::VEC2 getHorizon() const, { return math::VEC2(0.0f, 0.0f); })
IPL_CONTROLLER_DEFAULT_VIRTUAL(f32 getDpdDistance() const, { return 0.0f; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(KPADStatus* getKPADStatus() const, { return NULL; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(PADStatus* getPADStatus() const, { return NULL; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(bool isValidBtn() const, { return false; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(bool isValidDpd() const, { return false; })
virtual void setForceInvalid(bool flag) = 0;
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getMainStickX() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getMainStickY() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getSubStickX() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(int getSubStickY() const, { return 0; })
IPL_CONTROLLER_DEFAULT_VIRTUAL(void read(), { })
};
#undef IPL_CONTROLLER_DEFAULT_VIRTUAL
#ifdef IPL_CONTROLLER_INLINE_INTERFACE
inline Interface::~Interface() {}
#endif
class Base : public Interface {
public:
Base(int chan, KPADStatus& status) {
mButton = 0;
unk_0x08 = 0;
mLastRumbleTime = 0;
mRumbleType = -1;
mChan = chan;
mType = 2;
unk_0x1C = 0;
KPADEnableDPD(chan);
unk_0x1D = 0;
unk_0x1E = 0;
unk_0x20 = &status;
}
Base(int chan, int type, KPADStatus& status) {
mButton = 0;
unk_0x08 = 0;
mLastRumbleTime = 0;
mRumbleType = -1;
mChan = chan;
mType = type;
unk_0x1C = 0;
KPADEnableDPD(chan);
}
virtual ~Base();
virtual int getType() const override;
virtual int getChannel() const override;
virtual int decide() const override;
virtual BOOL rumble(int timer = 0) override;
virtual void cancelRumbling() override;
virtual void setForceInvalid(bool flag) override;
virtual void read() override;
protected:
u8 mButton;
u32 unk_0x08;
OSTick mLastRumbleTime;
s32 mRumbleType;
u32 mChan;
u32 mType;
u8 unk_0x1C;
u8 unk_0x1D;
u8 unk_0x1E;
KPADStatus* unk_0x20;
};
class Revolution : public Base {
public:
Revolution(int chan, KPADStatus& status) : Base(chan, status) {}
Revolution(int chan, int type, KPADStatus& status);
virtual ~Revolution();
virtual bool down(u32 button) const override;
virtual bool downTrg(u32 button) const override;
virtual bool upTrg(u32 button) const override;
virtual int pinch() const override;
virtual int pinchTrg() const override;
virtual int pinchOffTrg() const override;
virtual bool repeat(u32 button) const override;
virtual f32 getDpdDistance() const override;
virtual KPADStatus* getKPADStatus() const override;
virtual int getReleaseFlag() const override;
virtual int getTrigFlag() const override;
virtual int getHoldFlag() const override;
virtual math::VEC2 getDpdPos() const override;
virtual math::VEC2 getDpdProjectionPos() const override;
virtual math::VEC2 getHorizon() const override;
virtual bool isValidBtn() const override;
virtual bool isValidDpd() const override;
virtual void read() override;
};
class Classic : public Revolution {
public:
Classic(int chan, KPADStatus& status);
virtual ~Classic();
virtual bool down(u32 button) const override;
virtual bool downTrg(u32 button) const override;
virtual bool upTrg(u32 button) const override;
virtual int getClassicHoldFlag() const override;
virtual int getClassicTrigFlag() const override;
virtual int getClassicReleaseFlag() const override;
virtual math::VEC2 getDpdPos() const override;
virtual math::VEC2 getDpdProjectionPos() const override;
virtual math::VEC2 getHorizon() const override;
virtual bool isValidDpd() const override;
virtual void read() override;
virtual BOOL isValidDpdClassic() const;
private:
math::VEC2 unk_0x24;
int unk_0x2C;
};
class Master : public Interface {
public:
Master(Interface** controllers) : mpControllers(controllers) {}
virtual ~Master();
virtual bool down(u32 button) const override;
virtual bool downTrg(u32 button) const override;
virtual bool upTrg(u32 button) const override;
virtual bool repeat(u32 button) const override;
virtual int decide() const override;
virtual void setForceInvalid(bool flag) override;
private:
bool call(u32 button, bool (Interface::*func)(u32) const) const;
Interface** mpControllers;
};
class Core : public Revolution {
public:
Core(int chan, int type, KPADStatus& status) : Revolution(chan, type, status) {}
virtual ~Core();
};
class FreeStyle : public Revolution {
public:
FreeStyle(int chan, int type, KPADStatus& status) : Revolution(chan, type, status) {}
virtual ~FreeStyle();
};
class Manager {
public:
Manager(EGG::Heap* heap);
void read();
Interface* getController(int chan);
Interface* getMasterController();
Interface* getYoungController();
static void* alloc(u32 size);
static int free(void* ptr);
private:
static void* mpBuf;
static EGG::Heap* mpParentHeap;
static EGG::ExpHeap* mpHeap;
static EGG::Allocator* mpAllocator;
Interface* mControllers[4];
u32 mControllerStorage[4][12];
Master mMaster;
KPADStatus mKPADStatus[4];
s32 mInvalidCount[4];
};
#else
class Base {
public:
Base(int chan, KPADStatus& arg1) {
@@ -118,11 +312,11 @@ namespace ipl {
virtual bool setForceInvalid(bool flag); // 0x74
virtual f32 getMainStickX() const; // 0x78
virtual f32 getMainStickY() const; // 0x7C
virtual int getMainStickX() const; // 0x78
virtual int getMainStickY() const; // 0x7C
virtual f32 getSubStickX() const; // 0x80
virtual f32 getSubStickY() const; // 0x84
virtual int getSubStickX() const; // 0x80
virtual int getSubStickY() const; // 0x84
virtual void read(); // 0x88
@@ -169,10 +363,10 @@ namespace ipl {
virtual math::VEC2 getDpdPos() const override;
virtual math::VEC2 getDpdProjectionPos() const override;
virtual math::VEC2 getHorizon() const override;
virtual f32 getMainStickX() const override;
virtual f32 getMainStickY() const override;
virtual f32 getSubStickX() const override;
virtual f32 getSubStickY() const override;
virtual int getMainStickX() const override;
virtual int getMainStickY() const override;
virtual int getSubStickX() const override;
virtual int getSubStickY() const override;
virtual BOOL rumble(int type = 0) override;
virtual void read() override;
};
@@ -228,6 +422,7 @@ namespace ipl {
class Classic : public Revolution {
public:
Classic(int arg0, KPADStatus& arg1);
virtual ~Classic();
virtual bool down(u32 button) const override;
virtual bool downTrg(u32 button) const override;
@@ -268,6 +463,7 @@ namespace ipl {
static EGG::Allocator* mpAllocator;
u8 dummy[0x2F8];
};
#endif
} // namespace controller
} // namespace ipl

View File

@@ -54,6 +54,9 @@ namespace ipl {
const wchar_t* wcString; // 0x04
u32 stringLimit; // 0x08
u32 rowLimit; // 0x0C
#ifdef IPL_ADDRESS_EDIT_CPP
KeyboardSetting(KeyboardType keyboardType, const wchar_t* value, u32 limit, u32 rows);
#endif
} KeyboardSetting;
typedef struct State {

View File

@@ -38,6 +38,9 @@ namespace ipl {
}
const GXTexObj& getIconTexture() const { return mFaceTexObj; }
#ifdef IPL_ADDRESS_MATCHING
u8* getIconImage() const { return mpIconTex; }
#endif
u32 getIndex() const { return mFaceId; }
BOOL created() const { return mbCreated; }

View File

@@ -19,6 +19,8 @@ namespace ipl {
class Manager;
}
namespace savedata {
extern "C" BOOL iplSavedata_813597A0(void* manager, ESTitleId titleId);
class Manager {
public:
Manager(EGG::Heap* heap);
@@ -151,6 +153,7 @@ namespace ipl {
u8 unused_0x504[28];
friend class channel::Manager;
friend BOOL iplSavedata_813597A0(void* manager, ESTitleId titleId);
};
} // namespace savedata
} // namespace ipl

View File

@@ -20,7 +20,12 @@ namespace ipl {
Date() : year(MIN_YEAR), month(MIN_MONTH), day(MIN_DAY) {}
Date(int myYear, int myMonth, int myDay) : year(myYear), month(myMonth), day(myDay) {}
#ifdef IPL_BOARD_DATE_CTOR_OUT_OF_LINE
Date(const OSCalendarTime& cal);
#else
Date(const OSCalendarTime& cal) : year(cal.year), month(cal.mon + 1), day(cal.mday) {}
#endif
#line 24 "include/utility/iplCalendar.h"
Date(const Date& date) : year(date.year), month(date.month), day(date.day) {}
static Date getMaxDate() {
@@ -127,6 +132,9 @@ namespace ipl {
return days[month - 1];
}
#ifdef IPL_BOARD_WEEK_FUNCTION_OUT_OF_LINE
static int getWeek(const Date& date) NO_INLINE;
#else
static int getWeek(const Date& date) NO_INLINE {
int month, year, day;
month = date.month;
@@ -138,6 +146,8 @@ namespace ipl {
}
return (day + (((month * 13) + 8) / 5) + ((year / 400) + ((year + (year / 4)) - (year / 100)))) % 7;
}
#endif
#line 147 "include/utility/iplCalendar.h"
static int getWeek(int year, int month, int day) NO_INLINE {
if (month <= 2) {

View File

@@ -15,7 +15,7 @@ namespace EGG {
class SoundHeapMgr {
public:
SoundHeapMgr() NO_INLINE {}
SoundHeapMgr();
~SoundHeapMgr() { destroySoundHeap(); }

View File

@@ -17,14 +17,7 @@ namespace EGG {
s32 soundThreadPrio; // 0x08
s32 dvdThreadPrio; // 0x0C
Arg() NO_INLINE {
pHeap = NULL;
soundThreadPrio = nw4r::snd::SoundSystem::DEFAULT_SOUND_THREAD_PRIORITY;
dvdThreadPrio = nw4r::snd::SoundSystem::DEFAULT_DVD_THREAD_PRIORITY;
unk_0x04 = 0;
}
Arg();
};
public:

View File

@@ -44,32 +44,32 @@ namespace EGG {
mpArchive = &mDvdSoundArchive;
if (pDvdArchive->Open(pPath)) {
u32 headerSize;
u32 setupSize;
u32 strmSize;
u32 stringSize;
mbIsOpeningArchive = true;
headerSize = pDvdArchive->GetHeaderSize();
u32 headerSize = pDvdArchive->GetHeaderSize();
void* pHeaderBuffer = pHeap->Alloc(headerSize, NULL, NULL);
if (!pDvdArchive->LoadHeader(pHeaderBuffer, headerSize)) {
if (!pDvdArchive->LoadHeader(pHeap->Alloc(headerSize, NULL, NULL), headerSize)) {
return NULL;
}
u32 setupSize = mSoundArchivePlayer.GetRequiredMemSize(pDvdArchive);
u32 strmSize = mSoundArchivePlayer.GetRequiredStrmBufferSize(pDvdArchive);
void* pSetupBuffer = pHeap->Alloc(setupSize, NULL, NULL);
void* pStrmBuffer = pHeap->Alloc(strmSize, NULL, NULL);
setupSize = mSoundArchivePlayer.GetRequiredMemSize(pDvdArchive);
strmSize = mSoundArchivePlayer.GetRequiredStrmBufferSize(pDvdArchive);
if (!mSoundArchivePlayer.Setup(pDvdArchive, pSetupBuffer, setupSize, pStrmBuffer, strmSize)) {
if (!mSoundArchivePlayer.Setup(pDvdArchive, pHeap->Alloc(setupSize, NULL, NULL), setupSize,
pHeap->Alloc(strmSize, NULL, NULL), strmSize)) {
mbIsOpeningArchive = false;
return NULL;
}
u32 stringSize = pDvdArchive->GetLabelStringDataSize();
void* pStringBuffer = pHeap->Alloc(stringSize, NULL, NULL);
stringSize = pDvdArchive->GetLabelStringDataSize();
pDvdArchive->LoadLabelStringData(pStringBuffer, stringSize);
pDvdArchive->LoadLabelStringData(pHeap->Alloc(stringSize, NULL, NULL), stringSize);
mStorage = SARC_STORAGE_DVD;
mbIsOpeningArchive = false;
mStorage = SARC_STORAGE_DVD;
return &mSoundArchivePlayer;
}

View File

@@ -7,6 +7,15 @@
#include <revolution/ax.h>
namespace EGG {
IAudioMgr::Arg::Arg() {
pHeap = NULL;
soundThreadPrio = nw4r::snd::SoundSystem::DEFAULT_SOUND_THREAD_PRIORITY;
dvdThreadPrio = nw4r::snd::SoundSystem::DEFAULT_DVD_THREAD_PRIORITY;
unk_0x04 = 0;
}
SimpleAudioMgr::SimpleAudioMgrArg::SimpleAudioMgrArg() {
soundHeapSize = DEFAULT_SOUND_HEAP_SIZE;
}
@@ -14,6 +23,8 @@ namespace EGG {
SimpleAudioMgr::SimpleAudioMgr() : ArcPlayer(&getSoundHeap()) {
}
SoundHeapMgr::SoundHeapMgr() {}
SimpleAudioMgr::~SimpleAudioMgr() {
}

View File

@@ -5,6 +5,19 @@
extern "C" {
#endif
#define SIGNAL_ACTION_DEFAULT ((__signal_func_ptr)0)
#define SIGNAL_ACTION_IGNORE ((__signal_func_ptr)1)
#define SIGNAL_ABORT 1
#define SIGNAL_UNK2 2
#define SIGNAL_UNK3 3
#define SIGNAL_UNK4 4
#define SIGNAL_UNK5 5
#define SIGNAL_UNK6 6
#define SIGNAL_UNK7 7
typedef void (*__signal_func_ptr)(int);
int raise(int signal);
#ifdef __cplusplus

View File

@@ -0,0 +1,112 @@
#include <errno.h>
#include <internal/file_struct.h>
#include <stdio.h>
enum file_kinds {
file_closed,
file_disk,
file_console,
file_unavailable
};
enum io_states {
neutral,
writing,
reading,
rereading
};
enum io_modes {
io_read = 1,
io_write = 2,
io_append = 4
};
int __flush_buffer(FILE* file, size_t* pos);
long _ftell(FILE* file) {
int buf = 0;
int pos;
unsigned char file_kind = file->mode.file_kind;
if (!(file_kind == file_disk || file_kind == file_console) || file->state.error) {
errno = EFPOS;
return -1;
}
if (file->state.io_state == neutral) {
return file->pos;
}
pos = file->buffer_pos + (file->buffer_ptr - file->buffer);
if (file->state.io_state >= rereading) {
buf = file->state.io_state - reading;
pos -= buf;
}
if (!file->mode.binary_io) {
int n = file->buffer_ptr - file->buffer - buf;
unsigned char* p = file->buffer;
while (n-- != 0) {
if (*p++ == '\n') {
pos++;
}
}
}
return pos;
}
long ftell(FILE* stream) {
return _ftell(stream);
}
int _fseek(FILE* file, long offset, int whence) {
if (file->mode.file_kind != file_disk || file->state.error != 0) {
errno = EFPOS;
return -1;
}
if (file->state.io_state == writing) {
if (__flush_buffer(file, 0) != 0) {
file->state.error = 1;
file->buffer_len = 0;
errno = EFPOS;
return -1;
}
}
if (whence == 1) {
whence = 0;
offset += _ftell(file);
}
if ((whence != 2) && file->mode.io_mode != (io_read | io_write) && (file->state.io_state == reading || file->state.io_state == rereading)) {
if ((offset >= file->pos) || offset < file->buffer_pos) {
file->state.io_state = neutral;
} else {
file->buffer_ptr = file->buffer + (offset - file->buffer_pos);
file->buffer_len = file->pos - offset;
file->state.io_state = reading;
}
} else {
file->state.io_state = neutral;
}
if (file->state.io_state == neutral) {
if (file->pos_proc != 0 && (*file->pos_proc)(file->handle, &offset, whence, file->ref)) {
file->state.error = 1;
file->buffer_len = 0;
errno = EFPOS;
return -1;
}
file->state.eof = 0;
file->pos = offset;
file->buffer_len = 0;
}
return 0;
}

View File

@@ -3,144 +3,151 @@
#pragma exceptions on
extern void __sys_free(void* ptr);
typedef struct Block {
struct Block* prev;
struct Block* next;
unsigned int max_size;
unsigned int size;
} Block;
typedef struct SubBlock {
unsigned int size;
Block* block;
struct SubBlock* prev;
struct SubBlock* next;
} SubBlock;
struct FixSubBlock;
typedef struct FixBlock {
struct FixBlock* prev_;
struct FixBlock* next_;
unsigned int client_size_;
struct FixSubBlock* start_;
unsigned int n_allocated_;
} FixBlock;
typedef struct FixSubBlock {
FixBlock* block_;
struct FixSubBlock* next_;
} FixSubBlock;
typedef struct FixStart {
FixBlock* tail_;
FixBlock* head_;
} FixStart;
typedef struct __mem_pool_obj {
Block* start_;
FixStart fix_start[6];
} __mem_pool_obj;
extern void* __sys_alloc(unsigned int size);
typedef struct __mem_pool {
void* reserved[14];
} __mem_pool;
typedef int tag_word;
typedef struct Block {
struct Block* pPrev;
struct Block* pNext;
unsigned int maxSize;
unsigned int size;
} Block;
typedef struct block_header {
tag_word tag;
struct block_header* prev;
struct block_header* next;
} block_header;
typedef struct SubBlock {
unsigned int size;
Block* pBlock;
struct SubBlock* pPrev;
struct SubBlock* pNext;
} SubBlock;
typedef struct list_header {
block_header* rover;
block_header header;
} list_header;
struct FixSubBlock;
typedef struct heap_header {
struct heap_header* prev;
struct heap_header* next;
} heap_header;
typedef struct FixBlock {
struct FixBlock* pPrev;
struct FixBlock* pNext;
unsigned int clientSize;
struct FixSubBlock* pStart;
unsigned int allocatedSize;
} FixBlock;
struct mem_pool_obj;
typedef void* (*sys_alloc_ptr)(unsigned int, struct mem_pool_obj*);
typedef void (*sys_free_ptr)(void*, struct mem_pool_obj*);
typedef struct FixSubBlock {
FixBlock* pBlock;
struct FixSubBlock* pNext;
} FixSubBlock;
typedef struct pool_options {
sys_alloc_ptr sys_alloc_func;
sys_free_ptr sys_free_func;
unsigned int min_heap_size;
int always_search_first;
} pool_options;
typedef struct FixStart {
FixBlock* pTail;
FixBlock* pHead;
} FixStart;
typedef struct mem_pool_obj {
list_header free_list;
pool_options options;
heap_header* heap_list;
void* userData;
} mem_pool_obj;
mem_pool_obj __malloc_pool;
static int initialized = 0;
typedef struct __mem_pool_obj {
Block* pStart;
FixStart fixStart[6];
} __mem_pool_obj;
static SubBlock* SubBlock_merge_prev(SubBlock*, SubBlock**);
static void SubBlock_merge_next(SubBlock*, SubBlock**);
static SubBlock* Block_subBlock(Block*, unsigned int, unsigned int*);
static void* allocate_from_var_pools(__mem_pool_obj*, unsigned int, unsigned int*);
static void* soft_allocate_from_var_pools(__mem_pool_obj*, unsigned int, unsigned int*);
static void FixBlock_construct(FixBlock*, FixBlock*, FixBlock*, unsigned int, void*, unsigned int);
static void* allocate_from_fixed_pools(__mem_pool_obj*, unsigned int, unsigned int*);
static unsigned int __pool_allocate_resize(__mem_pool_obj*, void*, unsigned int, unsigned int*);
static const unsigned int fix_pool_sizes[] = {4, 12, 20, 36, 52, 68};
const unsigned int fix_pool_sizes[] = {4, 12, 20, 36, 52, 68};
#define SubBlock_size(ths) ((ths)->size & 0xFFFFFFF8)
#define SubBlock_block(ths) ((Block*)((unsigned int)((ths)->block) & ~0x1))
#define SubBlock_block(ths) ((Block*)((unsigned int)((ths)->pBlock) & ~0x1))
#define Block_size(ths) ((ths)->size & 0xFFFFFFF8)
#define Block_start(ths) (*(SubBlock**)((char*)(ths) + Block_size((ths)) - sizeof(unsigned int)))
#define SubBlock_set_free(ths) \
unsigned int this_size = SubBlock_size((ths)); \
(ths)->size &= ~0x2; \
*(unsigned int*)((char*)(ths) + this_size) &= ~0x4; \
((SubBlock*)((char*)(ths) + this_size))->size &= ~0x4; \
*(unsigned int*)((char*)(ths) + this_size - sizeof(unsigned int)) = this_size
#define SubBlock_is_free(ths) !((ths)->size & 2)
#define SubBlock_set_size(ths, sz) \
(ths)->size &= ~0xFFFFFFF8; \
(ths)->size |= (sz) & 0xFFFFFFF8; \
if (SubBlock_is_free((ths))) \
*(unsigned int*)((char*)(ths) + (sz) - sizeof(unsigned int)) = (sz)
if (SubBlock_is_free((ths))) { \
*(unsigned int*)((char*)(ths) + (sz) - sizeof(unsigned int)) = (sz); \
}
#define SubBlock_from_pointer(ptr) ((SubBlock*)((char*)(ptr) - 8))
#define FixSubBlock_from_pointer(ptr) ((FixSubBlock*)((char*)(ptr) - 4))
#define FixBlock_client_size(ths) ((ths)->client_size_)
#define FixSubBlock_size(ths) (FixBlock_client_size((ths)->block_))
#define FixBlock_client_size(ths) ((ths)->clientSize)
#define FixSubBlock_size(ths) (FixBlock_client_size((ths)->pBlock))
#define classify(ptr) (*(unsigned int*)((char*)(ptr) - sizeof(unsigned int)) & 1)
#define classify(ptr) ((unsigned int)FixSubBlock_from_pointer(ptr)->pBlock & 1)
#define __msize_inline(ptr) (!classify(ptr) ? FixSubBlock_size(FixSubBlock_from_pointer(ptr)) : SubBlock_size(SubBlock_from_pointer(ptr)) - 8)
#define Block_empty(ths) (_sb = (SubBlock*)((char*)(ths) + 16)), SubBlock_is_free(_sb) && SubBlock_size(_sb) == Block_size((ths)) - 24
#define Block_empty(ths) (_sb = (SubBlock*)(ths + 1)), SubBlock_is_free(_sb) && SubBlock_size(_sb) == Block_size((ths)) - 24
void Block_link(Block* ths, SubBlock* sb) {
SubBlock** st;
SubBlock_set_free(sb);
st = &Block_start(ths);
void Block_link(Block*, SubBlock*);
void deallocate_from_fixed_pools(__mem_pool_obj*, void*, unsigned int);
void* malloc(unsigned int);
void* calloc(unsigned int, unsigned int);
void* realloc(void*, unsigned int);
void free(void*);
if (*st != 0) {
sb->prev = (*st)->prev;
sb->prev->next = sb;
sb->next = *st;
(*st)->prev = sb;
*st = sb;
*st = SubBlock_merge_prev(*st, st);
SubBlock_merge_next(*st, st);
} else {
*st = sb;
sb->prev = sb;
sb->next = sb;
static void SubBlock_construct(SubBlock* ths, unsigned int size, Block* bp, int prev_alloc, int this_alloc) {
ths->pBlock = (Block*)((unsigned int)bp | 1);
ths->size = size;
if (prev_alloc) {
ths->size |= 4;
}
if (this_alloc) {
ths->size |= 2;
((SubBlock*)((char*)ths + size))->size |= 4;
} else {
*(unsigned int*)((char*)ths + size - sizeof(unsigned int)) = size;
}
}
static SubBlock* SubBlock_split(SubBlock* ths, unsigned int sz) {
unsigned int origsize;
int isfree;
int isprevalloc;
SubBlock* np;
Block* bp;
origsize = SubBlock_size(ths);
isfree = SubBlock_is_free(ths);
isprevalloc = (int)(ths->size & 4);
np = (SubBlock*)((char*)ths + sz);
bp = SubBlock_block(ths);
SubBlock_construct(ths, sz, bp, isprevalloc, !isfree);
SubBlock_construct(np, origsize - sz, bp, !isfree, !isfree);
if (isfree) {
np->pNext = ths->pNext;
np->pNext->pPrev = np;
np->pPrev = ths;
ths->pNext = np;
}
return np;
}
static void Block_unlink(Block* ths, SubBlock* sb) {
SubBlock** st;
unsigned int this_size = SubBlock_size(sb);
sb->size |= 2;
((SubBlock*)((char*)sb + this_size))->size |= 4;
st = &Block_start(ths);
if (*st == sb) {
*st = sb->pNext;
}
if (*st == sb) {
*st = NULL;
ths->maxSize = 0;
} else {
sb->pNext->pPrev = sb->pPrev;
sb->pPrev->pNext = sb->pNext;
}
if (ths->max_size < SubBlock_size(*st))
ths->max_size = SubBlock_size(*st);
}
static SubBlock* SubBlock_merge_prev(SubBlock* ths, SubBlock** start) {
@@ -149,72 +156,39 @@ static SubBlock* SubBlock_merge_prev(SubBlock* ths, SubBlock** start) {
if (!(ths->size & 0x04)) {
prevsz = *(unsigned int*)((char*)ths - sizeof(unsigned int));
if (prevsz & 0x2)
if (prevsz & 0x2) {
return ths;
}
p = (SubBlock*)((char*)ths - prevsz);
SubBlock_set_size(p, prevsz + SubBlock_size(ths));
if (*start == ths)
*start = (*start)->next;
ths->next->prev = ths->prev;
ths->next->prev->next = ths->next;
if (*start == ths) {
*start = (*start)->pNext;
}
ths->pNext->pPrev = ths->pPrev;
ths->pNext->pPrev->pNext = ths->pNext;
return p;
}
return ths;
}
static void SubBlock_merge_next(SubBlock* pBlock, SubBlock** pStart) {
SubBlock* next_sub_block;
unsigned int this_cur_size;
next_sub_block = (SubBlock*)((char*)pBlock + (pBlock->size & 0xFFFFFFF8));
if (!(next_sub_block->size & 2)) {
this_cur_size = (pBlock->size & 0xFFFFFFF8) + (next_sub_block->size & 0xFFFFFFF8);
pBlock->size &= ~0xFFFFFFF8;
pBlock->size |= this_cur_size & 0xFFFFFFF8;
if (!(pBlock->size & 2)) {
*(unsigned int*)((char*)(pBlock) + (this_cur_size)-4) = (this_cur_size);
}
if (!(pBlock->size & 2)) {
*(unsigned int*)((char*)pBlock + this_cur_size) &= ~4;
} else {
*(unsigned int*)((char*)pBlock + this_cur_size) |= 4;
}
if (*pStart == next_sub_block) {
*pStart = (*pStart)->next;
}
if (*pStart == next_sub_block) {
*pStart = 0;
}
next_sub_block->next->prev = next_sub_block->prev;
next_sub_block->prev->next = next_sub_block->next;
}
}
static Block* __unlink(__mem_pool_obj* pool_obj, Block* bp) {
Block* result = bp->next;
Block* result = bp->pNext;
if (result == bp) {
result = 0;
result = NULL;
}
if (pool_obj->start_ == bp) {
pool_obj->start_ = result;
if (pool_obj->pStart == bp) {
pool_obj->pStart = result;
}
if (result != 0) {
result->prev = bp->prev;
result->prev->next = result;
if (result != NULL) {
result->pPrev = bp->pPrev;
result->pPrev->pNext = result;
}
bp->next = 0;
bp->prev = 0;
bp->pNext = NULL;
bp->pPrev = NULL;
return result;
}
@@ -231,12 +205,13 @@ static void deallocate_from_var_pools(__mem_pool_obj* pool_obj, void* ptr) {
}
}
void __init_pool_obj(__mem_pool* pool_obj) {
static void __init_pool_obj(__mem_pool* pool_obj) {
memset(pool_obj, 0, sizeof(__mem_pool_obj));
}
__mem_pool protopool;
static __mem_pool* get_malloc_pool() {
static __mem_pool protopool;
static unsigned char init = 0;
if (!init) {
__init_pool_obj(&protopool);
@@ -246,67 +221,11 @@ static __mem_pool* get_malloc_pool() {
return &protopool;
}
void deallocate_from_fixed_pools(__mem_pool_obj* pool_obj, void* ptr, unsigned int size) {
unsigned int i = 0;
FixSubBlock* p;
FixBlock* b;
FixStart* fs;
while (size > fix_pool_sizes[i]) {
++i;
}
fs = &pool_obj->fix_start[i];
p = FixSubBlock_from_pointer(ptr);
b = p->block_;
if (b->start_ == 0 && fs->head_ != b) {
if (fs->tail_ == b) {
fs->head_ = fs->head_->prev_;
fs->tail_ = fs->tail_->prev_;
} else {
b->prev_->next_ = b->next_;
b->next_->prev_ = b->prev_;
b->next_ = fs->head_;
b->prev_ = b->next_->prev_;
b->prev_->next_ = b;
b->next_->prev_ = b;
fs->head_ = b;
}
}
p->next_ = b->start_;
b->start_ = p;
if (--b->n_allocated_ == 0) {
if (fs->head_ == b) {
fs->head_ = b->next_;
}
if (fs->tail_ == b) {
fs->tail_ = b->prev_;
}
b->prev_->next_ = b->next_;
b->next_->prev_ = b->prev_;
if (fs->head_ == b) {
fs->head_ = 0;
}
if (fs->tail_ == b) {
fs->tail_ = 0;
}
deallocate_from_var_pools(pool_obj, b);
}
}
void __pool_free(__mem_pool* pool, void* ptr) {
static void __pool_free(__mem_pool* pool, void* ptr) {
__mem_pool_obj* pool_obj;
unsigned int size;
if (ptr == 0) {
if (ptr == NULL) {
return;
}
@@ -320,6 +239,559 @@ void __pool_free(__mem_pool* pool, void* ptr) {
}
}
static void link(__mem_pool_obj* pool, Block* bp) {
if (pool->pStart != NULL) {
bp->pPrev = pool->pStart->pPrev;
bp->pPrev->pNext = bp;
bp->pNext = pool->pStart;
pool->pStart->pPrev = bp;
pool->pStart = bp;
} else {
pool->pStart = bp;
bp->pPrev = bp;
bp->pNext = bp;
}
}
static void Block_construct(Block* ths, unsigned int size) {
SubBlock* sb;
ths->size = size | 3;
((SubBlock*)((char*)ths + size - 8))->size = ths->size;
sb = (SubBlock*)(ths + 1);
sb->pBlock = (Block*)((unsigned int)ths | 1);
sb->size = size - 0x18;
*(unsigned int*)((char*)sb + (size - 0x18) - sizeof(unsigned int)) = size - 0x18;
ths->maxSize = size - 0x18;
Block_start(ths) = NULL;
Block_link(ths, sb);
}
static Block* link_new_block(__mem_pool_obj* pool, unsigned int size) {
Block* bp;
size = (size + 31) & ~7;
if (size < 0x10000) {
size = 0x10000;
}
bp = (Block*)__sys_alloc(size);
if (bp == NULL) {
return NULL;
}
Block_construct(bp, size);
link(pool, bp);
return bp;
}
static SubBlock* Block_subBlock(Block* bp, unsigned int size, unsigned int* out) {
SubBlock* st;
SubBlock* sb;
unsigned int sb_size;
unsigned int max_found;
st = Block_start(bp);
if (st == NULL) {
bp->maxSize = 0;
return NULL;
}
sb = st;
sb_size = SubBlock_size(sb);
max_found = sb_size;
while (sb_size < size) {
sb = sb->pNext;
sb_size = SubBlock_size(sb);
if (max_found < sb_size) {
max_found = sb_size;
}
if (sb == st) {
bp->maxSize = max_found;
if (out != NULL) {
*out = max_found - 8;
}
return NULL;
}
}
if (sb_size - size >= 0x50) {
SubBlock_split(sb, size);
}
Block_start(bp) = sb->pNext;
Block_unlink(bp, sb);
if (out != NULL) {
*out = SubBlock_size(sb) - 8;
}
return sb;
}
static void Block_link(Block* ths, SubBlock* sb) {
SubBlock** st;
SubBlock_set_free(sb);
st = &Block_start(ths);
if (*st != NULL) {
sb->pPrev = (*st)->pPrev;
sb->pPrev->pNext = sb;
sb->pNext = *st;
(*st)->pPrev = sb;
*st = sb;
*st = SubBlock_merge_prev(*st, st);
SubBlock_merge_next(*st, st);
} else {
*st = sb;
sb->pPrev = sb;
sb->pNext = sb;
}
if (ths->maxSize < SubBlock_size(*st)) {
ths->maxSize = SubBlock_size(*st);
}
}
static void SubBlock_merge_next(SubBlock* pBlock, SubBlock** pStart) {
SubBlock* next_sub_block;
unsigned int this_cur_size;
next_sub_block = (SubBlock*)((char*)pBlock + (pBlock->size & 0xFFFFFFF8));
if (!(next_sub_block->size & 2)) {
this_cur_size = (pBlock->size & 0xFFFFFFF8) + (next_sub_block->size & 0xFFFFFFF8);
pBlock->size &= ~0xFFFFFFF8;
pBlock->size |= this_cur_size & 0xFFFFFFF8;
if (!(pBlock->size & 2)) {
*(unsigned int*)((char*)pBlock + this_cur_size - sizeof(unsigned int)) = this_cur_size;
}
if (!(pBlock->size & 2)) {
((SubBlock*)((char*)pBlock + this_cur_size))->size &= ~4;
} else {
((SubBlock*)((char*)pBlock + this_cur_size))->size |= 4;
}
if (*pStart == next_sub_block) {
*pStart = (*pStart)->pNext;
}
if (*pStart == next_sub_block) {
*pStart = NULL;
}
next_sub_block->pNext->pPrev = next_sub_block->pPrev;
next_sub_block->pPrev->pNext = next_sub_block->pNext;
}
}
static void* allocate_from_var_pools(__mem_pool_obj* pool, unsigned int size, unsigned int* out) {
Block* bp;
SubBlock* ptr;
if (out != NULL) {
*out = 0;
}
size = (size + 15) & ~7;
if (size < 0x50) {
size = 0x50;
}
bp = pool->pStart != NULL ? pool->pStart : link_new_block(pool, size);
if (bp == NULL) {
return NULL;
}
do {
if (size <= bp->maxSize) {
ptr = Block_subBlock(bp, size, out);
if (ptr != NULL) {
pool->pStart = bp;
break;
}
}
bp = bp->pNext;
if (bp == pool->pStart) {
bp = link_new_block(pool, size);
if (bp == NULL) {
return NULL;
}
ptr = Block_subBlock(bp, size, out);
break;
}
} while (1);
return (char*)ptr + 8;
}
static void* soft_allocate_from_var_pools(__mem_pool_obj* pool, unsigned int size, unsigned int* out) {
register Block* bp;
register SubBlock* ptr;
size = (size + 15) & ~7;
if (size < 0x50) {
size = 0x50;
}
*out = 0;
bp = pool->pStart;
if (bp == NULL) {
return NULL;
}
do {
if (size <= bp->maxSize) {
ptr = Block_subBlock(bp, size, NULL);
if (ptr != NULL) {
pool->pStart = bp;
break;
}
}
if (bp->maxSize > 8 && *out < bp->maxSize - 8) {
*out = bp->maxSize - 8;
}
bp = bp->pNext;
if (bp == pool->pStart) {
return NULL;
}
} while (1);
return (char*)ptr + 8;
}
static void FixBlock_construct(FixBlock* this, FixBlock* prev, FixBlock* next, unsigned int poolIdx, void* start, unsigned int totalSize) {
unsigned int fixSubBlockSize;
unsigned int n;
char* p;
unsigned int i;
char* np;
this->pPrev = prev;
this->pNext = next;
prev->pNext = this;
next->pPrev = this;
this->clientSize = fix_pool_sizes[poolIdx];
fixSubBlockSize = fix_pool_sizes[poolIdx] + 4;
n = totalSize / fixSubBlockSize;
p = (char*)start;
for (i = 0; i < n - 1; ++i) {
np = p + fixSubBlockSize;
((FixSubBlock*)p)->pBlock = this;
((FixSubBlock*)p)->pNext = (FixSubBlock*)np;
p = np;
}
((FixSubBlock*)p)->pBlock = this;
((FixSubBlock*)p)->pNext = NULL;
this->pStart = (FixSubBlock*)start;
this->allocatedSize = 0;
}
static void* allocate_from_fixed_pools(__mem_pool_obj* pool, unsigned int size, unsigned int* out) {
unsigned int i = 0;
FixSubBlock* p;
FixStart* fs;
while (size > fix_pool_sizes[i]) {
++i;
}
fs = &pool->fixStart[i];
if (fs->pHead == NULL || fs->pHead->pStart == NULL) {
unsigned int size_requested = 0x1000;
char* newblock;
unsigned int size_received;
unsigned int n, nsave, size_has;
n = (size_requested - sizeof(FixBlock)) / (fix_pool_sizes[i] + 4);
if (n > 0x100) {
n = 0x100;
}
nsave = n;
while (n >= 10) {
size_requested = n * (fix_pool_sizes[i] + 4) + sizeof(FixBlock);
newblock = (char*)soft_allocate_from_var_pools(pool, size_requested, &size_has);
if (newblock != NULL) {
break;
}
if (size_has > sizeof(FixBlock)) {
n = (size_has - sizeof(FixBlock)) / (fix_pool_sizes[i] + 4);
} else {
n = 0;
}
}
if (newblock == NULL) {
unsigned int cr_backup;
n = nsave;
while (1) {
size_requested = n * (fix_pool_sizes[i] + 4) + sizeof(FixBlock);
newblock = (char*)allocate_from_var_pools(pool, size_requested, &cr_backup);
if (newblock != NULL) {
break;
}
n = cr_backup / (fix_pool_sizes[i] + sizeof(FixBlock) + 4);
if (n < 10) {
if (out != NULL) {
*out = 0;
}
return NULL;
}
}
}
size_received = __msize_inline(newblock);
if (fs->pHead == NULL) {
fs->pHead = (FixBlock*)newblock;
fs->pTail = (FixBlock*)newblock;
}
FixBlock_construct((FixBlock*)newblock, fs->pTail, fs->pHead, i, (FixSubBlock*)((FixBlock*)newblock + 1), size_received - sizeof(FixBlock));
fs->pHead = (FixBlock*)newblock;
}
p = fs->pHead->pStart;
fs->pHead->pStart = p->pNext;
++fs->pHead->allocatedSize;
if (fs->pHead->pStart == NULL) {
fs->pHead = fs->pHead->pNext;
fs->pTail = fs->pTail->pNext;
}
if (out != NULL) {
*out = fix_pool_sizes[i];
}
return (char*)p + 4;
}
void deallocate_from_fixed_pools(__mem_pool_obj* pool_obj, void* ptr, unsigned int size) {
unsigned int i = 0;
FixSubBlock* p;
FixBlock* b;
FixStart* fs;
while (size > fix_pool_sizes[i]) {
++i;
}
fs = &pool_obj->fixStart[i];
p = FixSubBlock_from_pointer(ptr);
b = p->pBlock;
if (b->pStart == NULL && fs->pHead != b) {
if (fs->pTail == b) {
fs->pHead = fs->pHead->pPrev;
fs->pTail = fs->pTail->pPrev;
} else {
b->pPrev->pNext = b->pNext;
b->pNext->pPrev = b->pPrev;
b->pNext = fs->pHead;
b->pPrev = b->pNext->pPrev;
b->pPrev->pNext = b;
b->pNext->pPrev = b;
fs->pHead = b;
}
}
p->pNext = b->pStart;
b->pStart = p;
if (--b->allocatedSize == 0) {
if (fs->pHead == b) {
fs->pHead = b->pNext;
}
if (fs->pTail == b) {
fs->pTail = b->pPrev;
}
b->pPrev->pNext = b->pNext;
b->pNext->pPrev = b->pPrev;
if (fs->pHead == b) {
fs->pHead = NULL;
}
if (fs->pTail == b) {
fs->pTail = NULL;
}
deallocate_from_var_pools(pool_obj, b);
}
}
static unsigned int __pool_allocate_resize(__mem_pool_obj* pool, void* ptr, unsigned int size, unsigned int* out) {
unsigned int sz;
unsigned int this_size;
unsigned int orig_size;
SubBlock* sb;
SubBlock* next_sub;
orig_size = __msize_inline(ptr);
if (size == orig_size) {
if (out != NULL) {
*out = orig_size;
}
return 1;
}
if (classify(ptr)) {
if (size > 0xFFFFFF7F) {
size = 0xFFFFFF7F;
}
sz = size + 8;
sz = (sz + 7) & ~7;
if (sz < 0x50) {
sz = 0x50;
}
sb = SubBlock_from_pointer(ptr);
this_size = orig_size + 8;
next_sub = (SubBlock*)((char*)sb + this_size);
if (SubBlock_is_free(next_sub) && sz <= this_size + SubBlock_size(next_sub)) {
SubBlock_merge_next(sb, &Block_start(SubBlock_block(sb)));
this_size = SubBlock_size(sb);
}
if (this_size >= sz + 0x50) {
Block_link(SubBlock_block(sb), SubBlock_split(sb, sz));
this_size = SubBlock_size(sb);
}
this_size -= 8;
if (out != NULL) {
*out = this_size;
}
if (size > orig_size) {
if (out != NULL && size > this_size && SubBlock_is_free(next_sub)) {
*out += SubBlock_size(next_sub);
}
return size <= this_size;
}
return this_size < orig_size;
}
if (out != NULL) {
*out = orig_size;
}
return 0;
}
void* malloc(register unsigned int size) {
void* rv;
register __mem_pool_obj* pool_obj;
if (size == 0) {
goto null_return;
}
pool_obj = (__mem_pool_obj*)get_malloc_pool();
if (size > ~0x30u) {
return NULL;
}
if (size <= 68) {
rv = allocate_from_fixed_pools(pool_obj, size, NULL);
} else {
rv = allocate_from_var_pools(pool_obj, size, NULL);
}
return rv;
null_return:
return NULL;
}
void free(void* ptr) {
__pool_free(get_malloc_pool(), ptr);
}
void* realloc(void* ptr, unsigned int size) {
register unsigned int rv = size;
register __mem_pool_obj* pool;
unsigned int current_size;
unsigned int orig_size;
pool = (__mem_pool_obj*)get_malloc_pool();
if (ptr == NULL) {
if (rv > ~0x30u) {
return NULL;
}
if (rv <= 68) {
return allocate_from_fixed_pools(pool, rv, NULL);
}
return allocate_from_var_pools(pool, rv, NULL);
}
if (rv == 0) {
if (ptr != NULL) {
current_size = __msize_inline(ptr);
if (current_size <= 68) {
deallocate_from_fixed_pools(pool, ptr, current_size);
} else {
deallocate_from_var_pools(pool, ptr);
}
}
return NULL;
}
orig_size = __msize_inline(ptr);
{
unsigned int result = __pool_allocate_resize(pool, ptr, rv, NULL);
if (result || rv <= orig_size) {
return ptr;
}
}
if (rv > ~0x30u) {
rv = 0;
} else if (rv <= 68) {
rv = (unsigned int)allocate_from_fixed_pools(pool, rv, NULL);
} else {
rv = (unsigned int)allocate_from_var_pools(pool, rv, NULL);
}
if (rv != 0) {
memcpy((void*)rv, ptr, orig_size);
if (ptr != NULL) {
unsigned int cur_sz = __msize_inline(ptr);
if (cur_sz <= 68) {
deallocate_from_fixed_pools(pool, ptr, cur_sz);
} else {
deallocate_from_var_pools(pool, ptr);
}
}
}
return (void*)rv;
}
void* calloc(unsigned int nmemb, unsigned int size) {
register void* ptr;
register unsigned int total;
__mem_pool_obj* pool_obj;
pool_obj = (__mem_pool_obj*)get_malloc_pool();
total = size * nmemb;
if (total > ~0x30u) {
ptr = NULL;
} else if (total <= 68) {
ptr = allocate_from_fixed_pools(pool_obj, total, NULL);
} else {
ptr = allocate_from_var_pools(pool_obj, total, NULL);
}
if (ptr != NULL) {
memset(ptr, 0, total);
}
return ptr;
}

View File

@@ -0,0 +1,123 @@
#include <stdio.h>
#include <stdlib.h>
extern int __read_console(unsigned long, unsigned char*, size_t*, void*);
extern int __write_console(unsigned long, unsigned char*, size_t*, void*);
extern int __close_console(unsigned long);
#pragma exceptions on
unsigned char stdin_buff[0x100];
unsigned char stdout_buff[0x100];
unsigned char stderr_buff[0x100];
FILE __files[4] = {
{
0,
{0, 1, 1, 2, 0, 0},
{0, 0, 0, 0},
0,
0,
0,
{0, 0},
{0, 0},
0,
stdin_buff,
0x100,
stdin_buff,
0,
0,
0,
0,
0,
__read_console,
__write_console,
__close_console,
0,
&__files[1],
},
{
1,
{0, 2, 1, 2, 0, 0},
{0, 0, 0, 0},
0,
0,
0,
{0, 0},
{0, 0},
0,
stdout_buff,
0x100,
stdout_buff,
0,
0,
0,
0,
0,
__read_console,
__write_console,
__close_console,
0,
&__files[2],
},
{
2,
{0, 2, 0, 2, 0, 0},
{0, 0, 0, 0},
0,
0,
0,
{0, 0},
{0, 0},
0,
stderr_buff,
0x100,
stderr_buff,
0,
0,
0,
0,
0,
__read_console,
__write_console,
__close_console,
0,
&__files[3],
},
{0},
};
void __close_all(void) {
FILE* file;
FILE* current;
for (file = __files; file != 0;) {
if (file->mode.file_kind != 0) {
fclose(file);
}
current = file;
file = file->next_file;
if (current->is_dyn_alloc != 0) {
free(current);
} else {
current->mode.file_kind = 3;
if (file != 0 && file->is_dyn_alloc != 0) {
current->next_file = 0;
}
}
}
}
int __flush_all(void) {
int result = 0;
FILE* file;
for (file = __files; file != 0; file = file->next_file) {
if (file->mode.file_kind != 0 && fflush(file) != 0) {
result = -1;
}
}
return result;
}

View File

@@ -0,0 +1,142 @@
#include <limits.h>
#include <math.h>
typedef struct ldiv_t {
long quot;
long rem;
} ldiv_t;
#undef abs
int abs(int n) {
int mask = n >> 31;
return (mask ^ n) - mask;
}
long labs(long n) {
long mask = n >> 31;
return (mask ^ n) - mask;
}
div_t div(int numerator, int denominator) {
int n_sign, d_sign;
div_t value;
n_sign = 1;
d_sign = 1;
if (numerator < 0) {
numerator = -numerator;
n_sign = -1;
}
if (denominator < 0) {
denominator = -denominator;
d_sign = -1;
}
value.quot = (numerator / denominator) * (n_sign * d_sign);
value.rem = (numerator * n_sign) - (value.quot * denominator * d_sign);
return value;
}
int __msl_add(int* a, int b) {
int val = *a;
if (b < 0) {
if (val < 0 && b < (-LONG_MAX - 1) - val) {
return 0;
}
} else if (val > 0 && b > LONG_MAX - val) {
return 0;
}
*a = val + b;
return 1;
}
int __msl_ladd(long* a, long b) {
long val = *a;
if (b < 0) {
if (val < 0 && b < (-LONG_MAX - 1L) - val) {
return 0;
}
} else if (val > 0 && b > LONG_MAX - val) {
return 0;
}
*a = val + b;
return 1;
}
int __msl_lmul(long* a, long b) {
long val = *a;
int sign = (val < 0) ^ (b < 0) ? -1 : 1;
if (val < 0) {
val = -val;
}
if (b < 0) {
b = -b;
}
if (val > LONG_MAX / b) {
return 0;
}
*a = val * b * sign;
return 1;
}
ldiv_t __msl_div(long a, long b) {
ldiv_t ret;
long quotient, a_sign, b_sign, sign, remainder;
a_sign = 1;
b_sign = 1;
if (a < 0) {
a = -a;
a_sign = -1;
}
if (b < 0) {
b = -b;
b_sign = -1;
}
sign = a_sign * b_sign;
quotient = (a / b) * sign;
remainder = a * a_sign - b_sign * (quotient * b);
if (remainder != 0 && sign < 0) {
quotient--;
remainder += b * b_sign;
}
ret.quot = quotient;
ret.rem = remainder;
return ret;
}
int __msl_mod(int a, int b) {
int quotient, remainder, a_sign, b_sign, sign;
a_sign = 1;
b_sign = 1;
if (a < 0) {
a = -a;
a_sign = -1;
}
if (b < 0) {
b = -b;
b_sign = -1;
}
sign = a_sign * b_sign;
quotient = (a / b) * sign;
remainder = (a * a_sign) - (quotient * b * b_sign);
if (remainder && sign < 0) {
quotient -= 1;
remainder += b * b_sign;
}
return remainder;
}

View File

@@ -0,0 +1,43 @@
#include <search.h>
void* bsearch(const void* key, const void* ptr, size_t count, size_t size, COMPARE_FUNC comp) {
const char* p;
int cmp;
size_t low, high, mid;
if (key == NULL || ptr == NULL || count == 0 || size == 0 || comp == NULL) {
return NULL;
}
p = (const char*)ptr;
cmp = comp(key, p);
if (cmp == 0) {
return (void*)p;
}
if (cmp < 0) {
return NULL;
}
low = 1;
high = count - 1;
while (low <= high) {
mid = (low + high) >> 1;
p = (const char*)ptr + size * mid;
cmp = comp(key, p);
if (cmp == 0) {
return (void*)p;
}
if (cmp < 0) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return NULL;
}

View File

@@ -0,0 +1,146 @@
#include <internal/file_struct.h>
#include <stddef.h>
#include <string.h>
#include <wchar.h>
enum file_kinds {
file_closed,
file_disk,
file_console,
file_unavailable
};
enum io_states {
neutral,
writing,
reading,
rereading
};
enum io_modes {
io_read = 1,
io_write = 2,
io_append = 4
};
enum buffer_modes {
buffer_none,
buffer_full,
buffer_line
};
void __prep_buffer(FILE* file);
int __flush_buffer(FILE* file, size_t* pos);
void __stdio_atexit(void);
int _fseek(FILE* file, long offset, int whence);
void* __memrchr(const void* ptr, int ch, size_t count);
size_t __fwrite(const void* ptr, size_t memb_size, size_t num_memb, FILE* file) {
unsigned char* cur_ptr;
size_t num_bytes, rem_bytes, bytes_written;
int res, buff;
if (fwide(file, 0) == 0) {
fwide(file, -1);
}
rem_bytes = memb_size * num_memb;
if (rem_bytes == 0 || file->state.error || file->mode.file_kind == file_closed) {
return 0;
}
if (file->mode.file_kind == file_console) {
__stdio_atexit();
}
buff = !file->mode.binary_io || file->mode.buffer_mode == buffer_line || file->mode.buffer_mode == buffer_full;
if (file->state.io_state == neutral && file->mode.io_mode & io_write) {
if (file->mode.io_mode & io_append) {
if (_fseek(file, 0, 2)) {
return 0;
}
}
file->state.io_state = writing;
__prep_buffer(file);
}
if (file->state.io_state != writing) {
file->state.error = 1;
file->buffer_len = 0;
return 0;
}
cur_ptr = (unsigned char*)ptr;
bytes_written = 0;
if (rem_bytes && (file->buffer_ptr != file->buffer || buff)) {
file->buffer_len = file->buffer_size - (file->buffer_ptr - file->buffer);
do {
unsigned char* nw = NULL;
num_bytes = file->buffer_len;
if (num_bytes > rem_bytes) {
num_bytes = rem_bytes;
}
if (file->mode.buffer_mode == buffer_full && num_bytes) {
if ((nw = (unsigned char*)__memrchr(cur_ptr, '\n', num_bytes)) != NULL) {
num_bytes = nw + 1 - cur_ptr;
}
}
if (num_bytes != 0) {
memcpy(file->buffer_ptr, cur_ptr, num_bytes);
cur_ptr += num_bytes;
rem_bytes -= num_bytes;
file->buffer_ptr += num_bytes;
file->buffer_len -= num_bytes;
}
if (file->buffer_len == 0 || nw != 0 || file->mode.buffer_mode == buffer_none) {
res = __flush_buffer(file, 0);
if (res != 0) {
file->state.error = 1;
file->buffer_len = 0;
rem_bytes = 0;
break;
}
}
bytes_written += num_bytes;
} while (rem_bytes && buff);
}
if (rem_bytes && buff == 0) {
unsigned char* save_buf = file->buffer;
size_t save_size = file->buffer_size;
file->buffer = cur_ptr;
file->buffer_size = rem_bytes;
file->buffer_ptr = cur_ptr + rem_bytes;
if (__flush_buffer(file, &num_bytes) != 0) {
file->state.error = 1;
file->buffer_len = 0;
} else {
bytes_written += num_bytes;
}
file->buffer = save_buf;
file->buffer_size = save_size;
__prep_buffer(file);
file->buffer_len = 0;
}
if (file->mode.buffer_mode != buffer_line) {
file->buffer_len = 0;
}
return bytes_written / memb_size;
}

View File

@@ -0,0 +1,73 @@
#include <ctype.h>
#include <internal/locale.h>
#include <stdbool.h>
#include <string.h>
extern int __msl_strnicmp(const char*, const char*, int);
extern char* __msl_itoa(int, char*, int);
int stricmp(const char* s1, const char* s2) {
char c1, c2;
while (true) {
c1 = tolower(*s1++);
c2 = tolower(*s2++);
if (c1 < c2) {
return -1;
}
if (c1 > c2) {
return 1;
}
if (c1 == 0) {
return 0;
}
}
}
int strnicmp(const char* s1, const char* s2, size_t n) {
return __msl_strnicmp(s1, s2, n);
}
int strcmpi(const char* s1, const char* s2) {
return stricmp(s1, s2);
}
char* itoa(int value, char* buffer, int radix) {
return __msl_itoa(value, buffer, radix);
}
int wcsnicmp(const char* s1, const char* s2, size_t n) {
const wchar_t* p1 = (const wchar_t*)s1;
const wchar_t* p2 = (const wchar_t*)s2;
unsigned int c1;
unsigned int c2;
struct _loc_ctype_cmpt* ctype_cmpt = _current_locale.ctype_cmpt_ptr;
size_t i;
for (i = 0; i < n; i++) {
c1 = *p1++;
c1 = (c1 >= 256) ? c1 : ctype_cmpt->wlower_map_ptr[(unsigned short)c1];
c1 &= 0xFFFF;
c2 = *p2++;
c2 = (c2 >= 256) ? c2 : ctype_cmpt->wlower_map_ptr[(unsigned short)c2];
c2 &= 0xFFFF;
if (c1 < c2) {
return -1;
}
if (c1 > c2) {
return 1;
}
if (c1 == 0) {
return 0;
}
}
return 0;
}

View File

@@ -0,0 +1,10 @@
#include <math.h>
double scalbn(double x, int n) {
double man;
int exponent;
man = frexp(x, &exponent);
exponent += n;
return ldexp(man, exponent);
}

View File

@@ -0,0 +1,97 @@
#include <internal/locale.h>
#include <string.h>
int mbtowc(wchar_t* pwc, const char* s, size_t n) {
return _current_locale.ctype_cmpt_ptr->decode_mb(pwc, s, n);
}
int __mbtowc_noconv(wchar_t* pwc, const char* s, size_t n) {
if (s == NULL) {
return 0;
}
if (n == 0) {
return -1;
}
if (pwc != NULL) {
*pwc = (unsigned char)*s;
}
if (!*s) {
return 0;
}
return 1;
}
int __wctomb_noconv(char* s, wchar_t wchar) {
if (s == NULL) {
return 0;
}
*s = (char)wchar;
return 1;
}
size_t mbstowcs(wchar_t* dest, const char* src, size_t len) {
int count;
char* src_ptr;
size_t slen;
slen = strlen(src);
if (dest != NULL) {
src_ptr = (char*)src;
for (count = 0; count < len; count++) {
if (*src_ptr) {
int res = mbtowc(dest++, src_ptr, slen);
if (res > 0) {
src_ptr += res;
slen -= res;
} else {
return -1;
}
} else {
*dest = 0;
break;
}
}
} else {
count = 0;
}
return count;
}
size_t wcstombs(char* s, const wchar_t* pwcs, size_t n) {
int result;
int chars_written = 0;
char temp[3];
wchar_t* source;
if (s == NULL || pwcs == NULL) {
return 0;
}
source = (wchar_t*)pwcs;
while (chars_written <= n) {
if (!*source) {
*(s + chars_written) = '\0';
break;
}
result = _current_locale.ctype_cmpt_ptr->encode_wc(temp, *source++);
if (chars_written + result > n) {
break;
}
strncpy(s + chars_written, temp, result);
chars_written += result;
}
return chars_written;
}

View File

@@ -0,0 +1,6 @@
extern void (*__stdio_exit)(void);
void __close_all(void);
void __stdio_atexit(void) {
__stdio_exit = __close_all;
}

View File

@@ -0,0 +1,73 @@
#include <search.h>
#define swap(dst, src, cnt) \
do { \
char* p; \
char* q; \
size_t n = cnt; \
unsigned long tmp; \
for (p = (char*)src - 1, q = (char*)dst - 1, n++; --n;) { \
tmp = *++q; \
*q = *++p; \
*p = tmp; \
} \
} while (0)
void qsort(void* table_base, size_t num_members, size_t member_size, COMPARE_FUNC compare_members) {
size_t cur_ofs;
size_t neg_size;
size_t l, r, j;
char* lp;
char* rp;
char* ip;
char* jp;
char* kp;
if (num_members < 2) {
return;
}
r = num_members;
l = (r / 2) + 1;
lp = (char*)table_base + member_size * (l - 1);
rp = (char*)table_base + member_size * (r - 1);
neg_size = (long)(member_size - member_size * 2);
cur_ofs = l * member_size;
for (;;) {
if (l > 1) {
l--;
cur_ofs -= member_size;
lp -= member_size;
} else {
swap(lp, rp, member_size);
if (--r == 1) {
return;
}
rp -= member_size;
}
j = l;
jp = (char*)table_base + (cur_ofs + neg_size);
while (j * 2 <= r) {
j *= 2;
ip = jp;
jp = (char*)table_base + member_size * (j - 1);
if (j < r) {
kp = jp + member_size;
if (compare_members(jp, kp) < 0) {
j++;
jp = kp;
}
}
if (compare_members(ip, jp) < 0) {
swap(ip, jp, member_size);
} else {
break;
}
}
}
}

View File

@@ -0,0 +1,30 @@
#include <signal.h>
int exit(int);
__signal_func_ptr signal_funcs[8];
int raise(int sig) {
__signal_func_ptr signal_func;
if (sig < SIGNAL_ABORT || sig > SIGNAL_UNK7) {
return -1;
}
signal_func = signal_funcs[sig - 1];
if (signal_func != SIGNAL_ACTION_IGNORE) {
signal_funcs[sig - 1] = SIGNAL_ACTION_DEFAULT;
}
if (signal_func == SIGNAL_ACTION_IGNORE || (signal_func == SIGNAL_ACTION_DEFAULT && sig == SIGNAL_ABORT)) {
return 0;
}
if (signal_func == SIGNAL_ACTION_DEFAULT) {
exit(0);
}
(*signal_func)(sig);
return 0;
}

View File

@@ -0,0 +1,382 @@
#include <ctype.h>
#include <errno.h>
enum __ReadProcActions {
__GetAChar,
__UngetAChar,
__TestForError
};
typedef struct {
char* spNextChar;
int nullCharDetected;
} __InStrCtrl;
int __StringRead(void* ptr, int ch, int act);
#include <limits.h>
#include <stddef.h>
enum scan_states {
start = 0x01,
check_for_zero = 0x02,
leading_zero = 0x04,
need_digit = 0x08,
digit_loop = 0x10,
finished = 0x20,
failure = 0x40
};
#define final_state(scan_state) (scan_state & (finished | failure))
#define success(scan_state) (scan_state & (leading_zero | digit_loop | finished))
#define fetch() (count++, (*ReadProc)(ReadProcArg, 0, __GetAChar))
#define unfetch(c) (*ReadProc)(ReadProcArg, c, __UngetAChar)
unsigned long __strtoul(int base, int max_width, int (*ReadProc)(void*, int, int), void* ReadProcArg, int* chars_scanned, int* negative,
int* overflow) {
int scan_state = start;
int count = 0;
int spaces = 0;
unsigned long value = 0;
unsigned long value_max = 0;
int c;
*negative = *overflow = 0;
if (base < 0 || base == 1 || base > 36 || max_width < 1) {
scan_state = failure;
} else {
c = fetch();
}
if (base != 0) {
value_max = ULONG_MAX / base;
}
while (count <= max_width && c != -1 && !final_state(scan_state)) {
switch (scan_state) {
case start: {
if (isspace(c)) {
c = fetch();
count--;
spaces++;
break;
}
if (c == '+') {
c = fetch();
} else if (c == '-') {
c = fetch();
*negative = 1;
}
scan_state = check_for_zero;
break;
}
case check_for_zero: {
if (base == 0 || base == 16) {
if (c == '0') {
scan_state = leading_zero;
c = fetch();
break;
}
}
scan_state = need_digit;
break;
}
case leading_zero: {
if (c == 'X' || c == 'x') {
base = 16;
scan_state = need_digit;
c = fetch();
break;
}
if (base == 0) {
base = 8;
}
scan_state = digit_loop;
break;
}
case need_digit:
case digit_loop: {
if (base == 0) {
base = 10;
}
if (!value_max) {
value_max = ULONG_MAX / base;
}
if (isdigit(c)) {
if ((c -= '0') >= base) {
if (scan_state == digit_loop) {
scan_state = finished;
} else {
scan_state = failure;
}
c += '0';
break;
}
} else if (!isalpha(c) || (toupper(c) - 'A' + 10) >= base) {
if (scan_state == digit_loop) {
scan_state = finished;
} else {
scan_state = failure;
}
break;
} else {
c = toupper(c) - 'A' + 10;
}
if (value > value_max) {
*overflow = 1;
}
value *= base;
if (c > (ULONG_MAX - value)) {
*overflow = 1;
}
value += c;
scan_state = digit_loop;
c = fetch();
break;
}
}
}
if (!success(scan_state)) {
count = 0;
value = 0;
*chars_scanned = 0;
} else {
count--;
*chars_scanned = count + spaces;
}
unfetch(c);
return value;
}
unsigned long long __strtoull(int base, int max_width, int (*ReadProc)(void*, int, int), void* ReadProcArg, int* chars_scanned, int* negative,
int* overflow) {
int scan_state = start;
int count = 0;
int spaces = 0;
unsigned long long value = 0;
unsigned long long value_max = 0;
int c;
*negative = *overflow = 0;
if (base < 0 || base == 1 || base > 36 || max_width < 1) {
scan_state = failure;
} else {
c = fetch();
}
if (base != 0) {
value_max = ULLONG_MAX / base;
}
while (count <= max_width && c != -1 && !final_state(scan_state)) {
switch (scan_state) {
case start: {
if (isspace(c)) {
c = fetch();
count--;
spaces++;
break;
}
if (c == '+') {
c = fetch();
} else if (c == '-') {
c = fetch();
*negative = 1;
}
scan_state = check_for_zero;
break;
}
case check_for_zero: {
if (base == 0 || base == 16) {
if (c == '0') {
scan_state = leading_zero;
c = fetch();
break;
}
}
scan_state = need_digit;
break;
}
case leading_zero: {
if (c == 'X' || c == 'x') {
base = 16;
scan_state = need_digit;
c = fetch();
break;
}
if (base == 0) {
base = 8;
}
scan_state = digit_loop;
break;
}
case need_digit:
case digit_loop: {
if (base == 0) {
base = 10;
}
if (!value_max) {
value_max = ULLONG_MAX / base;
}
if (isdigit(c)) {
if ((c -= '0') >= base) {
if (scan_state == digit_loop) {
scan_state = finished;
} else {
scan_state = failure;
}
c += '0';
break;
}
} else if (!isalpha(c) || (toupper(c) - 'A' + 10) >= base) {
if (scan_state == digit_loop) {
scan_state = finished;
} else {
scan_state = failure;
}
break;
} else {
c = toupper(c) - 'A' + 10;
}
if (value > value_max) {
*overflow = 1;
}
value *= base;
if (c > (ULLONG_MAX - value)) {
*overflow = 1;
}
value += c;
scan_state = digit_loop;
c = fetch();
break;
}
}
}
if (!success(scan_state)) {
count = 0;
value = 0;
*chars_scanned = 0;
} else {
count--;
*chars_scanned = count + spaces;
}
unfetch(c);
return value;
}
unsigned long strtoul(const char* str, char** end, int base) {
unsigned long value;
int count, negative, overflow;
__InStrCtrl isc;
isc.spNextChar = (char*)str;
isc.nullCharDetected = 0;
value = __strtoul(base, INT_MAX, &__StringRead, &isc, &count, &negative, &overflow);
if (end) {
*end = (char*)str + count;
}
if (overflow) {
value = ULONG_MAX;
errno = ERANGE;
} else if (negative) {
value = -value;
}
return value;
}
unsigned long long strtoull(const char* str, char** end, int base) {
unsigned long long value;
int count, negative, overflow;
__InStrCtrl isc;
isc.spNextChar = (char*)str;
isc.nullCharDetected = 0;
value = __strtoull(base, INT_MAX, &__StringRead, &isc, &count, &negative, &overflow);
if (end) {
*end = (char*)str + count;
}
if (overflow) {
value = ULLONG_MAX;
errno = ERANGE;
} else if (negative) {
value = -value;
}
return value;
}
long strtol(const char* str, char** end, int base) {
unsigned long uvalue;
long svalue;
int count, negative, overflow;
__InStrCtrl isc;
isc.spNextChar = (char*)str;
isc.nullCharDetected = 0;
uvalue = __strtoul(base, INT_MAX, &__StringRead, &isc, &count, &negative, &overflow);
if (end) {
*end = (char*)str + count;
}
if (overflow || (!negative && uvalue > LONG_MAX) || (negative && uvalue > -(unsigned long)LONG_MIN)) {
svalue = (negative ? -(unsigned long)LONG_MIN : LONG_MAX);
errno = ERANGE;
} else {
svalue = (negative ? -(long)uvalue : (long)uvalue);
}
return svalue;
}
int atoi(const char* str) {
return (int)strtol(str, NULL, 10);
}
long atol(const char* str) {
return strtol(str, NULL, 10);
}

View File

@@ -0,0 +1,44 @@
#include "internal/file_struct.h"
enum file_kinds {
file_closed
};
enum file_orientation {
file_unoriented,
file_char_oriented,
file_wide_oriented
};
int fwide(FILE* file, int file_mode) {
int orientation;
int res;
if (file == NULL || file->mode.file_kind == file_closed) {
return 0;
}
orientation = file->mode.file_orientation;
switch (orientation) {
case file_unoriented:
if (file_mode > 0) {
file->mode.file_orientation = file_wide_oriented;
} else if (file_mode < 0) {
file->mode.file_orientation = file_char_oriented;
}
res = file_mode;
break;
case file_wide_oriented:
res = 1;
break;
case file_char_oriented:
res = -1;
break;
}
return res;
}

View File

@@ -0,0 +1,104 @@
const unsigned int __wctype_mapC[128] = {
0x00040004, 0x00040004, 0x00040004, 0x00040004,
0x00040106, 0x01040104, 0x01040104, 0x00040004,
0x00040004, 0x00040004, 0x00040004, 0x00040004,
0x00040004, 0x00040004, 0x00040004, 0x00040004,
0x014200D0, 0x00D000D0, 0x00D000D0, 0x00D000D0,
0x00D000D0, 0x00D000D0, 0x00D000D0, 0x00D000D0,
0x04580458, 0x04580458, 0x04580458, 0x04580458,
0x04580458, 0x00D000D0, 0x00D000D0, 0x00D000D0,
0x00D00651, 0x06510651, 0x06510651, 0x06510251,
0x02510251, 0x02510251, 0x02510251, 0x02510251,
0x02510251, 0x02510251, 0x02510251, 0x02510251,
0x02510251, 0x025100D0, 0x00D000D0, 0x00D000D0,
0x00D00471, 0x04710471, 0x04710471, 0x04710071,
0x00710071, 0x00710071, 0x00710071, 0x00710071,
0x00710071, 0x00710071, 0x00710071, 0x00710071,
0x00710071, 0x007100D0, 0x00D000D0, 0x00D00004,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
};
const unsigned int __wlower_mapC[128] = {
0x00000001, 0x00020003, 0x00040005, 0x00060007,
0x00080009, 0x000A000B, 0x000C000D, 0x000E000F,
0x00100011, 0x00120013, 0x00140015, 0x00160017,
0x00180019, 0x001A001B, 0x001C001D, 0x001E001F,
0x00200021, 0x00220023, 0x00240025, 0x00260027,
0x00280029, 0x002A002B, 0x002C002D, 0x002E002F,
0x00300031, 0x00320033, 0x00340035, 0x00360037,
0x00380039, 0x003A003B, 0x003C003D, 0x003E003F,
0x00400061, 0x00620063, 0x00640065, 0x00660067,
0x00680069, 0x006A006B, 0x006C006D, 0x006E006F,
0x00700071, 0x00720073, 0x00740075, 0x00760077,
0x00780079, 0x007A005B, 0x005C005D, 0x005E005F,
0x00600061, 0x00620063, 0x00640065, 0x00660067,
0x00680069, 0x006A006B, 0x006C006D, 0x006E006F,
0x00700071, 0x00720073, 0x00740075, 0x00760077,
0x00780079, 0x007A007B, 0x007C007D, 0x007E007F,
0x00800081, 0x00820083, 0x00840085, 0x00860087,
0x00880089, 0x008A008B, 0x008C008D, 0x008E008F,
0x00900091, 0x00920093, 0x00940095, 0x00960097,
0x00980099, 0x009A009B, 0x009C009D, 0x009E009F,
0x00A000A1, 0x00A200A3, 0x00A400A5, 0x00A600A7,
0x00A800A9, 0x00AA00AB, 0x00AC00AD, 0x00AE00AF,
0x00B000B1, 0x00B200B3, 0x00B400B5, 0x00B600B7,
0x00B800B9, 0x00BA00BB, 0x00BC00BD, 0x00BE00BF,
0x00C000C1, 0x00C200C3, 0x00C400C5, 0x00C600C7,
0x00C800C9, 0x00CA00CB, 0x00CC00CD, 0x00CE00CF,
0x00D000D1, 0x00D200D3, 0x00D400D5, 0x00D600D7,
0x00D800D9, 0x00DA00DB, 0x00DC00DD, 0x00DE00DF,
0x00E000E1, 0x00E200E3, 0x00E400E5, 0x00E600E7,
0x00E800E9, 0x00EA00EB, 0x00EC00ED, 0x00EE00EF,
0x00F000F1, 0x00F200F3, 0x00F400F5, 0x00F600F7,
0x00F800F9, 0x00FA00FB, 0x00FC00FD, 0x00FE00FF,
};
const unsigned int __wupper_mapC[128] = {
0x00000001, 0x00020003, 0x00040005, 0x00060007,
0x00080009, 0x000A000B, 0x000C000D, 0x000E000F,
0x00100011, 0x00120013, 0x00140015, 0x00160017,
0x00180019, 0x001A001B, 0x001C001D, 0x001E001F,
0x00200021, 0x00220023, 0x00240025, 0x00260027,
0x00280029, 0x002A002B, 0x002C002D, 0x002E002F,
0x00300031, 0x00320033, 0x00340035, 0x00360037,
0x00380039, 0x003A003B, 0x003C003D, 0x003E003F,
0x00400041, 0x00420043, 0x00440045, 0x00460047,
0x00480049, 0x004A004B, 0x004C004D, 0x004E004F,
0x00500051, 0x00520053, 0x00540055, 0x00560057,
0x00580059, 0x005A005B, 0x005C005D, 0x005E005F,
0x00600041, 0x00420043, 0x00440045, 0x00460047,
0x00480049, 0x004A004B, 0x004C004D, 0x004E004F,
0x00500051, 0x00520053, 0x00540055, 0x00560057,
0x00580059, 0x005A007B, 0x007C007D, 0x007E007F,
0x00800081, 0x00820083, 0x00840085, 0x00860087,
0x00880089, 0x008A008B, 0x008C008D, 0x008E008F,
0x00900091, 0x00920093, 0x00940095, 0x00960097,
0x00980099, 0x009A009B, 0x009C009D, 0x009E009F,
0x00A000A1, 0x00A200A3, 0x00A400A5, 0x00A600A7,
0x00A800A9, 0x00AA00AB, 0x00AC00AD, 0x00AE00AF,
0x00B000B1, 0x00B200B3, 0x00B400B5, 0x00B600B7,
0x00B800B9, 0x00BA00BB, 0x00BC00BD, 0x00BE00BF,
0x00C000C1, 0x00C200C3, 0x00C400C5, 0x00C600C7,
0x00C800C9, 0x00CA00CB, 0x00CC00CD, 0x00CE00CF,
0x00D000D1, 0x00D200D3, 0x00D400D5, 0x00D600D7,
0x00D800D9, 0x00DA00DB, 0x00DC00DD, 0x00DE00DF,
0x00E000E1, 0x00E200E3, 0x00E400E5, 0x00E600E7,
0x00E800E9, 0x00EA00EB, 0x00EC00ED, 0x00EE00EF,
0x00F000F1, 0x00F200F3, 0x00F400F5, 0x00F600F7,
0x00F800F9, 0x00FA00FB, 0x00FC00FD, 0x00FE00FF,
};

View File

@@ -0,0 +1,160 @@
#include <wchar.h>
size_t wcslen(const wchar_t* str) {
const wchar_t* p = str - 1;
size_t len = -1;
do {
len++;
} while (*++p != 0);
return len;
}
wchar_t* wcscpy(wchar_t* dest, const wchar_t* src) {
const wchar_t* s = src - 1;
wchar_t* d = dest - 1;
wchar_t c;
do {
c = *++s;
*++d = c;
} while (c != 0);
return dest;
}
wchar_t* wcsncpy(wchar_t* dest, const wchar_t* src, size_t num) {
const wchar_t* s = src - 1;
wchar_t* d = dest - 1;
wchar_t c;
size_t n = num + 1;
while (--n != 0) {
c = *++s;
*++d = c;
if (c == 0) {
while (--n != 0) {
*++d = 0;
}
break;
}
}
return dest;
}
wchar_t* wcscat(wchar_t* dest, const wchar_t* src) {
const wchar_t* s = src - 1;
wchar_t* d = dest - 1;
while (*++d != 0)
;
d--;
do {
*++d = *++s;
} while (*s != 0);
return dest;
}
wchar_t* wcsncat(wchar_t* dest, const wchar_t* src, size_t num) {
const wchar_t* s = src - 1;
wchar_t* d = dest - 1;
wchar_t c;
size_t n;
while (*++d != 0)
;
d--;
n = num + 1;
while (--n != 0) {
c = *++s;
*++d = c;
if (c == 0) {
d--;
break;
}
}
*++d = 0;
return dest;
}
int wcsncmp(const wchar_t* s1, const wchar_t* s2, size_t num) {
wchar_t c2;
wchar_t c1;
const wchar_t* p1;
const wchar_t* p2;
size_t n;
p1 = s1 - 1;
p2 = s2 - 1;
n = num + 1;
while (--n != 0) {
c1 = *++p1;
c2 = *++p2;
if (c1 != c2) {
return (int)(c1 - c2);
}
if (c1 == 0) {
break;
}
}
return 0;
}
wchar_t* wcschr(wchar_t* ws, wchar_t wc) {
wchar_t* p = ws - 1;
wchar_t ch;
while ((ch = *++p) != 0) {
if (ch == wc) {
return p;
}
}
if (wc == 0) {
return p;
}
return 0;
}
wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2) {
const wchar_t* p1;
wchar_t c;
wchar_t c1;
wchar_t c2;
c = *s2;
p1 = s1 - 1;
if (c == 0) {
return (wchar_t*)s1;
}
while ((c1 = *++p1) != 0) {
if (c1 == c) {
wchar_t ic1;
const wchar_t* ps1;
const wchar_t* p2;
ps1 = p1 - 1;
p2 = s2 - 1;
do {
ic1 = *++ps1;
c2 = *++p2;
if (ic1 != c2) {
break;
}
} while (ic1 != 0);
if (c2 == 0) {
return (wchar_t*)p1;
}
}
}
return 0;
}

View File

@@ -50,6 +50,10 @@ namespace nw4r {
f32 FrSqrt(f32 x);
u32 CntBit1(u32 x);
#ifdef IPL_ADDRESS_MATCHING
inline f32 FSqrt(f32 x) { return (x <= 0.0f) ? 0.0f : x * FrSqrt(x); }
#endif
} // namespace math
} // namespace nw4r

View File

@@ -118,6 +118,10 @@ namespace nw4r {
return *this;
}
#ifdef IPL_ADDRESS_MATCHING
VEC2 operator-() const { return VEC2(-x, -y); }
#endif
VEC2 operator+(const VEC2& rhs) const { return VEC2(x + rhs.x, y + rhs.y); }
VEC2 operator-(const VEC2& rhs) const { return VEC2(x - rhs.x, y - rhs.y); }
VEC2 operator*(f32 val) const { return VEC2(val * x, val * y); }
@@ -130,6 +134,10 @@ namespace nw4r {
bool operator!=(const VEC2& rhs) const { return x != rhs.x || y != rhs.y; }
} VEC2;
#ifdef IPL_ADDRESS_MATCHING
inline f32 VEC2LenSq(const VEC2* p) { return p->x * p->x + p->y * p->y; }
#endif
typedef struct VEC3 VEC3;
inline VEC3* VEC3Transform(VEC3* pOut, const MTX34* pMtx, const VEC3* pVec);

View File

@@ -59,7 +59,7 @@ namespace nw4r {
b = blue;
a = alpha;
}
} Color;
} ATTRIBUTE_ALIGN(4) Color;
} // namespace ut
} // namespace nw4r

View File

@@ -16,7 +16,9 @@ namespace nw4r {
#endif
Rect(f32 l, f32 t, f32 r, f32 b) : left(l), top(t), right(r), bottom(b) {}
#ifndef IPL_CONTROLLER_TRIVIAL_RECT_DTOR
~Rect() {}
#endif
void SetWidth(f32 width) { right = left + width; }
void SetHeight(f32 height) { bottom = top + height; }

View File

@@ -37,6 +37,9 @@ namespace nw4r {
} // namespace detail
template <typename TDerived, typename TBase>
#ifdef IPL_BOARD_OBJECT_EXTERNAL_DYNAMIC_CAST
TDerived DynamicCast(TBase* pPtr);
#else
inline TDerived DynamicCast(TBase* pPtr) {
const detail::RuntimeTypeInfo* pDerivedTypeInfo = detail::GetTypeInfoFromPtr_(static_cast<TDerived>(NULL));
if (pPtr->GetRuntimeTypeInfo()->IsDerivedFrom(pDerivedTypeInfo)) {
@@ -44,6 +47,7 @@ namespace nw4r {
}
return NULL;
}
#endif
} // namespace ut
} // namespace nw4r

View File

@@ -34,20 +34,29 @@ namespace nw4r {
const u32* flags0A;
const u32* flags0C;
int i, j;
int i;
int entryI;
const HeaderedGlyphGroups* offsetPGlgr;
const u8* offsetFlags;
u32 loadedSheetCount, loadedSmth0ASize, loadedSmth0CSize;
u32 flagWord;
const u8* offsetFlags;
const char* groupName;
const u32* offsetData;
int j;
u32 sheetOffsetsSize;
u32 loadedSheetsSize;
u32 neededCharacterSize;
u32 baseSize;
u32 count0CWork;
u32& neededCharacterSizeRef = neededCharacterSize;
u32 loadedSizeRef;
u32 groupOffset;
if (!ArchiveFontBase::IsValidResource(fontData, 0x4000)) {
return 0;
}
@@ -55,29 +64,30 @@ namespace nw4r {
font = (ArchiveFontBinaryLayout*)fontData;
pGlgr = &font->glgr;
countName = font->glgr.inner.nameCount;
countSheet = font->glgr.inner.sheetCount;
count0A = font->glgr.inner.smthCount_0x0a;
count0C = font->glgr.inner.smthCount_0x0c;
countName = pGlgr->inner.nameCount;
countSheet = pGlgr->inner.sheetCount;
count0A = pGlgr->inner.smthCount_0x0a;
count0C = pGlgr->inner.smthCount_0x0c;
count0CWork = count0C;
stepSheets = ((s32)countSheet + 0x1f) / 32 * 4;
step0A = ((s32)count0A + 0x1f) / 32 * 4;
step0C = ((s32)count0C + 0x1f) / 32 * 4;
step0C = ((s32)count0CWork + 0x1f) / 32 * 4;
dataSheetsOff = ROUNDUP(offsetof(ArchiveFontBinaryLayout, glgr.inner.nameOffsets) + countName * sizeof(u16), 4);
data0AOff = ROUNDUP(dataSheetsOff + countSheet * sizeof(u32), 4);
data0COff = ROUNDUP(data0AOff + count0A * sizeof(u32), 4);
dataSheets = lyt::detail::ConvertOffsToPtr<u32>(fontData, dataSheetsOff);
data0A = lyt::detail::ConvertOffsToPtr<u32>(fontData, data0AOff);
data0C = lyt::detail::ConvertOffsToPtr<u32>(fontData, data0COff);
dataSheets = (const u32*)((u32)dataSheetsOff + (u32)fontData);
data0A = (const u32*)((u32)data0AOff + (u32)fontData);
data0C = (const u32*)((u32)data0COff + (u32)fontData);
flagsSheetsOff = ROUNDUP(data0COff + count0C * sizeof(u32), 4);
flagsSheetsOff = ROUNDUP(data0COff + count0CWork * sizeof(u32), 4);
flags0AOff = ROUNDUP(flagsSheetsOff + stepSheets * countName, 4);
flags0COff = ROUNDUP(flags0AOff + step0A * countName, 4);
flagsSheets = lyt::detail::ConvertOffsToPtr<u32>(fontData, flagsSheetsOff);
flags0A = lyt::detail::ConvertOffsToPtr<u32>(fontData, flags0AOff);
flags0C = lyt::detail::ConvertOffsToPtr<u32>(fontData, flags0COff);
flagsSheets = (const u32*)((u32)flagsSheetsOff + (u32)fontData);
flags0A = (const u32*)((u32)flags0AOff + (u32)fontData);
flags0C = (const u32*)((u32)flags0COff + (u32)fontData);
loadedSheetCount = 0;
loadedSmth0ASize = 0;
@@ -90,7 +100,7 @@ namespace nw4r {
flagWord = 0;
for (j = 0, offsetPGlgr = pGlgr; j < pGlgr->inner.nameCount;
offsetPGlgr = (const HeaderedGlyphGroups*)((const u8*)offsetPGlgr + 2), j++) {
groupName = (const char*)fontData + offsetPGlgr->inner.nameOffsets[0];
groupName = (const char*)((u32)offsetPGlgr->inner.nameOffsets[0] + (u32)fontData);
if (*includedGroups == '\0' || detail::ArchiveFontBase::IncludeName(includedGroups, groupName)) {
flagWord |= *(const u32*)((const u8*)offsetFlags + ROUNDDOWN(j * stepSheets, 4));
}
@@ -101,12 +111,13 @@ namespace nw4r {
// getLoadedSheetCount(pGlgr, flagsSheets, stepSheets, fontData, includedGroups, &loadedSheetCount);
// Get the SIZE of unk_0x0a that should be loaded
for (i = 0, entryI = 0; entryI < pGlgr->inner.smthCount_0x0a; entryI += 32, i++) {
for (i = 0; i * 32 < pGlgr->inner.smthCount_0x0a; i++) {
offsetFlags = (const u8*)flags0A + i * sizeof(u32);
flagWord = 0;
for (j = 0; j < pGlgr->inner.nameCount; j++) {
groupName = (const char*)fontData + pGlgr->inner.nameOffsets[j];
groupOffset = pGlgr->inner.nameOffsets[j];
groupName = (const char*)(groupOffset + (u32)fontData);
if (*includedGroups == '\0' || detail::ArchiveFontBase::IncludeName(includedGroups, groupName)) {
flagWord |= *(const u32*)((const u8*)offsetFlags + ROUNDDOWN(j * step0A, 4));
}
@@ -121,12 +132,13 @@ namespace nw4r {
}
// Get the SIZE of unk_0x0C that should be loaded
for (i = 0, entryI = 0; entryI < pGlgr->inner.smthCount_0x0c; entryI += 32, i++) {
for (i = 0; i * 32 < pGlgr->inner.smthCount_0x0c; i++) {
offsetFlags = (const u8*)flags0C + i * sizeof(u32);
flagWord = 0;
for (j = 0; j < pGlgr->inner.nameCount; j++) {
groupName = (const char*)fontData + pGlgr->inner.nameOffsets[j];
groupOffset = pGlgr->inner.nameOffsets[j];
groupName = (const char*)(groupOffset + (u32)fontData);
if (*includedGroups == '\0' || detail::ArchiveFontBase::IncludeName(includedGroups, groupName)) {
flagWord |= *(const u32*)((const u8*)offsetFlags + ROUNDDOWN(j * step0C, 4));
}
@@ -145,13 +157,14 @@ namespace nw4r {
sheetOffsetsSize = ROUNDUP(pGlgr->inner.sheetCount * 2, 4);
loadedSheetsSize = ROUNDUP(loadedSheetCount * pGlgr->inner.uncompSheetSize, 4);
neededCharacterSize = sizeof(CXUncompContextHuffman);
if (loadedSmth0ASize + loadedSmth0CSize >= sizeof(CXUncompContextHuffman)) {
neededCharacterSize = loadedSmth0ASize + loadedSmth0CSize;
loadedSizeRef = loadedSmth0ASize + loadedSmth0CSize;
neededCharacterSizeRef = sizeof(CXUncompContextHuffman);
if (loadedSizeRef >= sizeof(CXUncompContextHuffman)) {
neededCharacterSize = loadedSizeRef;
}
baseSize = OSRoundUp32B(sizeof(FontInformation) + sizeof(FontTextureGlyph) + sheetOffsetsSize);
return baseSize + neededCharacterSize + loadedSheetsSize;
return (baseSize + loadedSheetsSize) + neededCharacterSize;
}
detail::ArchiveFontBase::ConstructState ArchiveFont::StreamingConstruct(ConstructContext* ctx, const void* fontData, u32 fontDataSize) {
@@ -164,8 +177,9 @@ namespace nw4r {
}
state = CONSTRUCT_STATE_WORKING;
reader = &ctx->mReader;
reader->Attach(fontData, fontDataSize);
CachedStreamReader& readerRef = ctx->mReader;
reader = &readerRef;
readerRef.Attach(fontData, fontDataSize);
while (state == CONSTRUCT_STATE_WORKING) {
switch (ctx->mNextCmd) {

View File

@@ -57,6 +57,46 @@ void RFLiInitCtrlBuf(MEMiHeapHead* sysHeap) {
}
}
int RFLiGetControllerData(RFLiCharInfo* dst, s32 chan, u8 index, BOOL hiddenAvailable) {
RFLiCtrlManager* manager;
RFLiCtrlBuffer* buffer;
u16 flag;
RFLi_ASSERTLINE_RANGE(chan, 0, WPAD_MAX_CONTROLLERS, 1412);
RFLi_ASSERTLINE_RANGE(index, 0, RFL_MAX_CTRL_BUFFER, 1413);
if (chan < 0 || chan >= WPAD_MAX_CONTROLLERS) {
return FALSE;
}
if (index >= RFL_MAX_CTRL_BUFFER) {
return FALSE;
}
manager = RFLiGetCtrlBufManager();
if (manager == NULL) {
return FALSE;
}
if (!manager->mIsLoaded[chan]) {
return FALSE;
}
flag = (1 << index);
buffer = manager->mBuffer[chan];
if (!RFLiIsValidID((RFLCreateID*)&buffer->mData[index].createID)) {
return FALSE;
}
if (!hiddenAvailable && (buffer->mSecretFlag & flag) != 0) {
return FALSE;
}
RFLiConvertRaw2Info(&buffer->mData[index], dst);
return TRUE;
}
BOOL RFLiCheckCtrlBufferCore(const RFLiCtrlBuffer* buffer, u8 index, RFLiCtrlCheckType type) {
u16 flag = (1 << index);
@@ -771,46 +811,6 @@ int RFLiSetControllerData(const RFLiCharInfo* src, s32 chan, u8 index) {
return setDataCore_(src, chan, index, FALSE);
}
int RFLiGetControllerData(RFLiCharInfo* dst, s32 chan, u8 index, BOOL hiddenAvailable) {
RFLiCtrlManager* manager;
RFLiCtrlBuffer* buffer;
u16 flag;
RFLi_ASSERTLINE_RANGE(chan, 0, WPAD_MAX_CONTROLLERS, 1412);
RFLi_ASSERTLINE_RANGE(index, 0, RFL_MAX_CTRL_BUFFER, 1413);
if (chan < 0 || chan >= WPAD_MAX_CONTROLLERS) {
return FALSE;
}
if (index >= RFL_MAX_CTRL_BUFFER) {
return FALSE;
}
manager = RFLiGetCtrlBufManager();
if (manager == NULL) {
return FALSE;
}
if (!manager->mIsLoaded[chan]) {
return FALSE;
}
flag = (1 << index);
buffer = manager->mBuffer[chan];
if (!RFLiIsValidID((RFLCreateID*)&buffer->mData[index].createID)) {
return FALSE;
}
if (!hiddenAvailable && (buffer->mSecretFlag & flag) != 0) {
return FALSE;
}
RFLiConvertRaw2Info(&buffer->mData[index], dst);
return TRUE;
}
RFLErrcode RFLUnloadController(s32 chan) {
RFLi_ASSERTLINE_RANGE(chan, 0, WPAD_MAX_CONTROLLERS, 1461);

View File

@@ -204,7 +204,7 @@ void RFLi_MakeRandomFace_Core(RFLiCharInfo* pCharInfo, RFLi_SEX argSex, RFLi_AGE
pCharInfo->personal.localonly = FALSE;
}
u8 RFLi_GetFacelineType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
static u8 RFLi_GetFacelineType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
// clang-format off
static const u8 facelineTypeTable[RFLSex_All * RFLAge_All * RFLRace_All][10] = {
/* Male, Child, Black */ {0, 0, 0, 1, 1, 1, 2, 3, 4, 5},
@@ -272,7 +272,7 @@ u8 RFLi_GetHairType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
return hair_parts[index][RFLi_GetRandU32(hair_parts_num[index])];
}
u8 RFLi_GetEyeType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
static u8 RFLi_GetEyeType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
// clang-format off
u8 eye_parts[RFLSex_All * RFLAge_All * RFLRace_All][48] = {
/* Male, Child, Black */ { 2, 3, 5, 7, 8, 9, 11, 12, 13, 15, 16, 18, 27, 29, 32, 34, 36, 38, 39, 41, 43, 47, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
@@ -307,7 +307,7 @@ u8 RFLi_GetEyeType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
return eye_parts[index][RFLi_GetRandU32(eye_parts_num[index])];
}
u8 RFLi_GetEyebrowType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
static u8 RFLi_GetEyebrowType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
// clang-format off
static const u8 eyebrow_parts[RFLSex_All * RFLAge_All * RFLRace_All][24] = {
/* Male, Child, Black */ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 17, 18, 20, 0, 0, 0, 0, 0, 0},
@@ -342,7 +342,7 @@ u8 RFLi_GetEyebrowType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
return eyebrow_parts[index][RFLi_GetRandU32(eyebrow_parts_num[index])];
}
u8 RFLi_GetNoseType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
static u8 RFLi_GetNoseType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
// clang-format off
u8 nose_parts[RFLSex_All * RFLAge_All * RFLRace_All][12] = {
/* Male, Child, Black */ { 0, 1, 2, 3, 4, 5, 7, 8, 10, 0, 0, 0},
@@ -377,7 +377,7 @@ u8 RFLi_GetNoseType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
return nose_parts[index][RFLi_GetRandU32(nose_parts_num[index])];
}
u8 RFLi_GetMouthType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
static u8 RFLi_GetMouthType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
// clang-format off
u8 mouth_parts[RFLSex_All * RFLAge_All * RFLRace_All][24] = {
/* Male, Child, Black */ { 0, 2, 3, 6, 7, 8, 9, 10, 12, 14, 15, 17, 18, 19, 21, 22, 23, 0, 0, 0, 0, 0, 0, 0},
@@ -412,7 +412,7 @@ u8 RFLi_GetMouthType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
return mouth_parts[index][RFLi_GetRandU32(mouth_parts_num[index])];
}
u8 RFLi_GetFaceTexType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
static u8 RFLi_GetFaceTexType(RFLi_SEX sex, RFLi_AGE age, RFLi_RACE race) {
// clang-format off
static const u8 faceTexTypeTable[RFLSex_All * RFLAge_All * RFLRace_All][20] = {
/* Male, Child, Black */ { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3},
@@ -507,7 +507,7 @@ u8 RFLi_GetGlassType(RFLi_AGE age) {
}
}
u8 RFLi_GetFaceColor(RFLi_SEX sex, RFLi_RACE race) {
static u8 RFLi_GetFaceColor(RFLi_SEX sex, RFLi_RACE race) {
// clang-format off
static const u8 faceColorTable[RFLSex_All * RFLRace_All][10] = {
/* Male, Black */ { 2, 2, 4, 4, 4, 4, 5, 5, 5, 5 },
@@ -526,7 +526,7 @@ u8 RFLi_GetFaceColor(RFLi_SEX sex, RFLi_RACE race) {
return faceColorTable[(sex * RFLRace_All) + race][RFLi_GetRandU32(GET_ARRAY_LENGTH(faceColorTable[0]))];
}
u8 RFLi_GetHairColor(RFLi_AGE age, RFLi_RACE race) {
static u8 RFLi_GetHairColor(RFLi_AGE age, RFLi_RACE race) {
// clang-format off
static const u8 hairColorTable[RFLAge_All * RFLRace_All][20] = {
/* Black, Child */ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
@@ -547,7 +547,7 @@ u8 RFLi_GetHairColor(RFLi_AGE age, RFLi_RACE race) {
return hairColorTable[(race * 4 - race) + age][RFLi_GetRandU32(GET_ARRAY_LENGTH(hairColorTable[0]))];
}
u8 RFLi_GetEyeColor(RFLi_RACE race) {
static u8 RFLi_GetEyeColor(RFLi_RACE race) {
// clang-format off
static const u8 eyeColorTable[RFLRace_All][10] = {
/* Black */ {0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
@@ -561,6 +561,6 @@ u8 RFLi_GetEyeColor(RFLi_RACE race) {
return eyeColorTable[race][RFLi_GetRandU32(GET_ARRAY_LENGTH(eyeColorTable[0]))];
}
u32 RFLi_GetRandU32(u32 max) {
static u32 RFLi_GetRandU32(u32 max) {
return OSGetTick() % max;
}

View File

@@ -133,7 +133,7 @@ void RFLiEndWorking(RFLErrcode errcode) {
RFLiEndWorkingReason(errcode, 0);
}
NANDCommandBlock* RFLiSetCommandBlock(RFLiFileType type, RFLiAsyncTag tag) {
inline NANDCommandBlock* RFLiSetCommandBlock(RFLiFileType type, RFLiAsyncTag tag) {
NANDCommandBlock* block = &RFLiGetAccInfo(type)->commandBlock;
RFLiCallbackTag* store = &RFLiGetAccInfo(type)->callbackTag;
@@ -147,7 +147,7 @@ NANDCommandBlock* RFLiSetCommandBlock(RFLiFileType type, RFLiAsyncTag tag) {
return block;
}
RFLiAsyncTag RFLiGetTag(NANDCommandBlock* block) {
inline RFLiAsyncTag RFLiGetTag(NANDCommandBlock* block) {
RFLiCallbackTag* stored;
RFLi_ASSERTLINE_NULL(block, 312);
@@ -159,7 +159,7 @@ RFLiAsyncTag RFLiGetTag(NANDCommandBlock* block) {
return stored->tag;
}
RFLiFileType RFLiGetType(NANDCommandBlock* block) {
inline RFLiFileType RFLiGetType(NANDCommandBlock* block) {
RFLiCallbackTag* stored;
RFLi_ASSERTLINE_NULL(block, 335);
@@ -171,7 +171,7 @@ RFLiFileType RFLiGetType(NANDCommandBlock* block) {
return stored->type;
}
NANDFileInfo* RFLiGetWorkingFile(RFLiFileType type) {
inline NANDFileInfo* RFLiGetWorkingFile(RFLiFileType type) {
RFLi_ASSERTLINE_RANGE(type, RFLiFileType_Database, RFLiFileType_Max, 356);
if (!RFLAvailable()) {

View File

@@ -202,7 +202,7 @@ void RFLExit() {
}
}
RFLErrcode RFLiBootLoad() {
static inline RFLErrcode RFLiBootLoad() {
RFLiBootLoadAsync();
return RFLWaitAsync();
}
@@ -223,7 +223,7 @@ static void bootloadDB2Res_() {
}
}
RFLErrcode RFLiBootLoadAsync() {
static inline RFLErrcode RFLiBootLoadAsync() {
return RFLiBootLoadDatabaseAsync(bootloadDB2Res_);
}
@@ -249,7 +249,7 @@ void RFLiFree(void* block) {
MEMFreeToExpHeap(RFLiGetManager()->mTmpHeap, block);
}
u32 RFLiGetUsedWorkSize() {
static inline u32 RFLiGetUsedWorkSize() {
if (RFLAvailable()) {
MEMiHeapHead* heap = RFLiGetManager()->mTmpHeap;
return MEMGetAllocatableSizeForExpHeap(heap) - MEMGetTotalFreeSizeForExpHeap(heap);
@@ -397,7 +397,7 @@ BOOL RFLiNeedRepairError() {
return ((*list & (1 << RFLiFileBrokenType_DBBroken)) != 0) ? TRUE : FALSE;
}
BOOL RFLiCriticalError() {
static inline BOOL RFLiCriticalError() {
u8* list = &sRFLBrokenType;
BOOL ret = FALSE; // Unused

View File

@@ -9,7 +9,7 @@ ziU32 Zi8GetZHuwdPtr(ziU32* arg0, ziU16* arg1 ZI_NEED_WORK) {
return 0;
} else {
*arg1 = ZI_WORK->unk_0x124[ZI_WORK->unk_0x12C - 1][1] / 3;
*arg0 = ZI_WORK->unk_0x124[ZI_WORK->unk_0x12C - 1][0];
*arg0 = (ziU32)ZI_WORK->unk_0x124[ZI_WORK->unk_0x12C - 1];
*arg0 += 8;
Zi8LogError(0x64, ZI_WORK);
return 1;

View File

@@ -0,0 +1,534 @@
#include <zi8clib/zierror.h>
extern ziU16 Zi8GetTableCount(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
extern ziU32 Zi8GetTableAddress(ziU8 lang, ziU8 tableIdx ZI_NEED_WORK);
ziU32 Zi8_8148302C(ziU16 key, ziU8* table ZI_NEED_WORK) {
ziU32 value;
ziU16 count;
ziU32 i;
count = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
for (i = 0; (ziU16)i < count; i++) {
value = (ziU16)(((ziU16)table[((i & 0xFFFF) << 3) + (i & 0xFFFF) + 7] << 8) |
table[((i & 0xFFFF) << 3) + (i & 0xFFFF) + 8]);
if (key == value) {
Zi8LogError(0x64, ZI_WORK);
return i;
}
}
Zi8LogError(0x96A, ZI_WORK);
return 0xFFFF;
}
void Zi8_81483118(ziGetParam* param, ziU8* output) {
ziU8 i;
for (i = 0; i < 5; i++) {
output[i] = 0;
}
switch (param->elementCount) {
case 9:
output[4] |= (ziU8)((param->elements[8] & 0xF) << 4);
case 8:
output[3] = param->elements[7] & 0xF;
case 7:
output[3] |= (ziU8)((param->elements[6] & 0xF) << 4);
case 6:
output[2] = param->elements[5] & 0xF;
case 5:
output[2] |= (ziU8)((param->elements[4] & 0xF) << 4);
case 4:
output[1] = param->elements[3] & 0xF;
case 3:
output[1] |= (ziU8)((param->elements[2] & 0xF) << 4);
case 2:
output[0] = param->elements[1] & 0xF;
case 1:
output[0] |= (ziU8)((param->elements[0] & 0xF) << 4);
case 0:
break;
}
}
ziU32 Zi8_81483264(const ziGetParam* param ZI_NEED_WORK) {
ziU8 i;
if (param->scratch == ZI8_NULL) {
Zi8LogError(0x164, ZI_WORK);
return 1;
}
for (i = 0; i < param->maxCandidates; i++) {
((ziU16*)param->scratch)[i] = 0;
}
Zi8LogError(0x64, ZI_WORK);
return 0;
}
ziU32 Zi8_81483308(ziGetParam* param, ziU16 key, ziU8* count ZI_NEED_WORK) {
ziU8 i;
Zi8LogError(0x64, ZI_WORK);
if (param->scratch == ZI8_NULL) {
Zi8ReplaceLastError(0x164, ZI_WORK);
return 1;
}
for (i = 0; i < param->maxCandidates; i++) {
if (key == ((ziU16*)param->scratch)[i]) {
return 1;
}
}
((ziU16*)param->scratch)[*count] = key;
if (++*count >= param->maxCandidates) {
*count = 0;
}
return 0;
}
ziBool Zi8_814833F0(const ziGetParam* param, ziU16 key ZI_NEED_WORK) {
ziU8 i;
Zi8LogError(0x64, ZI_WORK);
if (param->scratch == ZI8_NULL) {
Zi8ReplaceLastError(0x164, ZI_WORK);
return 0;
}
for (i = 0; i < param->maxCandidates; i++) {
if (key == ((ziU16*)param->scratch)[i]) {
return 1;
}
}
return 0;
}
ziU32 Zi8_814834AC(ziGetParam* param, ziU16* remaining, ziU8* count,
ziU8* inserted ZI_NEED_WORK) {
ziBool matches;
ziS32 entry;
ziS32 tableA;
ziS32 tableB;
ziU16 tableCount;
ziU8 matched;
ziU32 j;
ziS32 i;
ziU8 candidateIndex;
union {
ziU32 words[13];
ziU8 bytes[52];
} local;
matched = 0;
local.words[0] = 0;
local.bytes[4] = 0;
Zi8LogError(0x64, ZI_WORK);
if (param->elementCount == 0) {
if (*remaining >= *count) {
for (i = 0; i < *count; i++) {
Zi8_81483308(param, param->candidates[i], inserted, ZI_WORK);
}
*remaining = *remaining - *count;
*count = 0;
} else {
for (i = 0; i < *remaining; i++) {
Zi8_81483308(param, param->candidates[i], inserted, ZI_WORK);
}
for (i = 0; i < ((ziS32)*count - (ziS32)*remaining); i++) {
param->candidates[i] = param->candidates[(ziU32)*remaining + i];
}
*count = *count - (ziU8)*remaining;
*remaining = 0;
}
return 1;
} else if (param->elementCount <= 9) {
tableA = Zi8GetTableAddress(param->language, 9, ZI_WORK);
tableB = Zi8GetTableAddress(param->language, 10, ZI_WORK);
if (tableA == 0) {
Zi8ReplaceLastError(0x76C, ZI_WORK);
return 0;
} else if (tableB == 0) {
Zi8ReplaceLastError(0x776, ZI_WORK);
return 0;
} else {
tableCount = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
Zi8_81483118(param, local.bytes);
i = 0;
while (i < tableCount && matched < *count) {
matches = ZI8_TRUE;
entry = (i << 3) + tableA + i;
j = 0;
if (param->elementCount > 1) {
for (j = 0; (j & 0xFF) < (ziU32)(param->elementCount >> 1); j++) {
if (local.bytes[j & 0xFF] != *((ziU8*)entry + (j & 0xFF))) {
matches = ZI8_FALSE;
break;
}
}
}
if (matches && (param->elementCount & 1) != 0 &&
((local.bytes[j & 0xFF] & 0xF0) != (*((ziU8*)entry + (j & 0xFF)) & 0xF0))) {
matches = ZI8_FALSE;
}
if (matches) {
for (candidateIndex = 0; candidateIndex < *count; candidateIndex++) {
if (param->candidates[candidateIndex] ==
(ziU16)((*((ziU8*)entry + 7) << 8) | *((ziU8*)entry + 8))) {
matched++;
param->candidates[candidateIndex] =
param->candidates[candidateIndex] & 0x7FFF;
break;
}
}
}
i++;
}
if ((ziU16)matched >= *remaining) {
matched = *count;
*count = 0;
for (i = 0; i < matched; i++) {
if ((param->candidates[i] & 0x8000) == 0) {
param->candidates[i] = param->candidates[i] | 0x8000;
if (*remaining == 0) {
if (*count != i) {
param->candidates[*count] = param->candidates[i];
}
*count = *count + 1;
} else {
*remaining = *remaining - 1;
Zi8_81483308(param, param->candidates[i], inserted, ZI_WORK);
}
}
}
*remaining = 0;
} else {
for (i = 0; i < *count; i++) {
if ((param->candidates[i] & 0x8000) == 0) {
param->candidates[i] = param->candidates[i] | 0x8000;
Zi8_81483308(param, param->candidates[i], inserted, ZI_WORK);
}
}
*remaining = *remaining - (ziU16)matched;
*count = 0;
}
}
} else {
*count = 0;
return 0;
}
return 0;
}
ziU32 Zi8GetKOcandidates(ziGetParam* param, ziU8* options ZI_NEED_WORK) {
ziBool bVar1;
ziU8 bVar2;
ziS32 iVar4;
ziU32 uVar6;
ziU8* pbVar7;
union {
ziU32 words[10];
ziU8 bytes[40];
} local_28;
ziU8 local_57;
ziU8 local_56;
ziU8 local_55;
ziU8 local_54;
ziU8 local_53;
ziS8 local_52;
ziU16 local_50;
ziU16 local_4E;
ziU16 local_4C;
ziU16 local_4A;
ziU16 local_48;
ziS32 local_44;
ziS32 local_2C;
ziS32 local_30;
ziU32 local_34;
ziU32 local_38;
ziU32 local_3C;
ziU32 local_40;
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);
iVar4 = Zi8GetTableAddress(ZI8_LANG_KO, 9, ZI_WORK);
local_2C = Zi8GetTableAddress(ZI8_LANG_KO, 10, ZI_WORK);
if (iVar4 == 0) {
Zi8ReplaceLastError(0x76C, ZI_WORK);
uVar6 = 0;
} else {
if (local_2C == 0) {
Zi8ReplaceLastError(0x776, ZI_WORK);
uVar6 = 0;
goto LAB_000114C4;
}
if (*options == 0) {
param->letters = 0;
param->count = 0;
param->candidates[0] = 0;
}
Zi8LogError(100, ZI_WORK);
if (param->wordCharCount != 0) {
local_48 = Zi8_8148302C(param->currentWord[0], (ziU8*)iVar4, ZI_WORK);
if ((local_48 != 0xFFFF) &&
((((ziU8*)iVar4)[((ziU32)local_48 * 9) + 4] & 8) != 0)) {
local_38 = (ziU32)((ziU8*)iVar4)[((ziU32)local_48 * 9) + 6] |
((ziU32)((ziU8*)iVar4)[((ziU32)local_48 * 9) + 4] & 3) << 16 |
(ziU32)((ziU8*)iVar4)[((ziU32)local_48 * 9) + 5] << 8;
local_52 = param->wordCharCount - 1;
local_53 = 1;
pbVar7 = (ziU8*)(local_2C + local_38);
LAB_00010D44:
if (local_52 != 0) {
local_48 = Zi8_8148302C(param->currentWord[local_53], (ziU8*)iVar4, ZI_WORK);
if (local_48 == (ziU16)((*pbVar7 & 0x1F) << 8 | pbVar7[1])) {
local_52 = local_52 - 1;
local_53 = local_53 + 1;
if ((*pbVar7 & 0x40) == 0) {
pbVar7 = pbVar7 + 2;
goto LAB_00010D44;
}
local_52 = param->wordCharCount - 1;
local_53 = 1;
} else {
local_53 = 1;
local_52 = param->wordCharCount - 1;
}
}
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 (local_48 == local_4E) {
for (; (*pbVar7 & 0x40) == 0; pbVar7 = pbVar7 + 2) {
}
local_52 = param->wordCharCount;
goto LAB_00011114;
}
local_4E = local_48;
if (param->elementCount == 0) {
if (local_50 == 0) {
if (*options != 0) {
local_3C = local_3C + 1;
if ((ziS32)local_3C < *(ziS32*)(options + 0xC)) {
goto LAB_000110E8;
}
uVar6 = *(ziU32*)(options + 0xC);
goto LAB_000114C4;
}
param->candidates[local_54] = local_4C;
local_54 = local_54 + 1;
param->count = param->count + 1;
bVar2 = param->letters + 1;
param->letters = bVar2;
if (param->maxCandidates <= bVar2) {
uVar6 = param->letters;
goto LAB_000114C4;
}
} else {
local_50 = local_50 + -1;
}
} else {
param->candidates[local_54] = local_4C;
local_54 = local_54 + 1;
param->count = param->count + 1;
bVar2 = param->letters + 1;
param->letters = bVar2;
if (param->maxCandidates <= bVar2) {
Zi8_814834AC(param, &local_50, &local_54, &local_57, ZI_WORK);
param->count = local_54;
param->letters = local_54;
if (param->maxCandidates <= local_54) {
if (*options == 0) {
uVar6 = local_54;
goto LAB_000114C4;
}
local_3C = local_3C + local_54;
if (*(ziS32*)(options + 0xC) <= (ziS32)local_3C) {
uVar6 = *(ziU32*)(options + 0xC);
goto LAB_000114C4;
}
param->count = 0;
param->letters = 0;
local_54 = 0;
}
}
}
} else {
for (local_40 = 0;
(local_40 < local_54 &&
(local_4C != param->candidates[local_40]));
local_40 = local_40 + 1) {
}
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, &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;
local_54 = 0;
}
}
}
}
LAB_000110E8:
for (; (*pbVar7 & 0x40) == 0; pbVar7 = pbVar7 + 2) {
}
local_52 = param->wordCharCount;
LAB_00011114:
local_52 = local_52 + -1;
local_53 = 1;
pbVar7 = pbVar7 + 2;
if ((*pbVar7 & 0x80) != 0) {
goto LAB_00011124;
}
goto LAB_00010D44;
}
}
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;
}
local_34 = uVar6;
param->count = local_54;
param->letters = local_54;
}
if (param->elementCount < 10) {
if ((param->elementCount == 0) || (*options != 0)) {
local_56 = 1;
} else {
local_56 = 0;
}
local_4A = Zi8GetTableCount(ZI8_LANG_KO, 9, ZI_WORK);
Zi8_81483118(param, local_28.bytes);
do {
for (local_30 = 0; local_30 < (ziS32)(ziU32)local_4A; local_30 = local_30 + 1) {
bVar1 = ZI8_TRUE;
local_44 = iVar4 + local_30 * 9;
local_55 = 0;
if (1 < param->elementCount) {
for (local_55 = 0;
(ziU32)local_55 < (ziU32)((ziS32)(ziU32)param->elementCount >> 1);
local_55 = local_55 + 1) {
if (local_28.bytes[local_55] != *(ziU8*)(local_44 + local_55)) {
bVar1 = ZI8_FALSE;
break;
}
}
}
if ((bVar1 && ((param->elementCount & 1) != 0)) &&
((local_28.bytes[local_55] & 0xF0) !=
(*(ziU8*)(local_44 + local_55) & 0xF0))) {
bVar1 = ZI8_FALSE;
}
if (bVar1) {
bVar2 = local_56;
if ((param->elementCount & 1) == 0) {
if ((*(ziU8*)(local_44 + local_55) & 0xF0) == 0) {
if (local_56 == 0) {
goto LAB_000113B0;
}
bVar2 = *options;
}
if (bVar2 == 0) {
goto LAB_00011478;
}
} else {
if ((*(ziU8*)(local_44 + local_55) & 0xF) != 0) {
goto LAB_000113AC;
}
if (local_56 != 0) {
bVar2 = *options;
goto LAB_000113AC;
}
}
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 {
local_50 = local_50 + -1;
}
}
LAB_00011478:
;
}
local_56 = local_56 + 1;
} while (local_56 < 2);
uVar6 = local_34;
if (*options == 0) {
uVar6 = param->letters;
}
} else {
param->letters = 0;
uVar6 = 0;
}
}
LAB_000114C4:
return uVar6;
}

View File

@@ -247,7 +247,12 @@ typedef struct WPADCB {
u8 unk_0x98F[0x9A0 - 0x990];
} WPADCB;
extern WPADCB _wpd[WPAD_MAX_CONTROLLERS];
typedef struct WPADStorage {
WPADCB controllers[WPAD_MAX_CONTROLLERS];
u8 unk_0x26C0[0x48];
} WPADStorage;
extern WPADStorage _wpd;
extern WPADCB* _wpdcb[WPAD_MAX_CONTROLLERS];
void WPADiInitSub();

View File

@@ -55,7 +55,7 @@ typedef struct AXFX_REVERBHI_EXP {
f32 sendGain; // 0x144
} AXFX_REVERBHI_EXP;
u32 AXFXReverbHiExpGetMemSize(const AXFX_REVERBHI_EXP* fx);
u32 AXFXReverbHiExpGetMemSize(AXFX_REVERBHI_EXP* fx);
BOOL AXFXReverbHiExpInit(AXFX_REVERBHI_EXP* fx);
void AXFXReverbHiExpShutdown(AXFX_REVERBHI_EXP* fx);
BOOL AXFXReverbHiExpSettings(AXFX_REVERBHI_EXP* fx);

View File

@@ -10,7 +10,16 @@ extern "C" {
#endif
typedef struct _GXColor {
#ifdef IPL_SYSTEM_COLOR_ALIGNMENT
union {
struct {
u8 r, g, b, a;
};
u32 value;
};
#else
u8 r, g, b, a; // 0x00
#endif
} GXColor;
typedef struct _GXColorS10 {

View File

@@ -0,0 +1,447 @@
#include <private/axfx.h>
#include <revolution/AXFX.h>
#include <revolution/MEM.h>
#include <revolution/OS.h>
#include <math.h>
#include <string.h>
static BOOL __AllocDelayLine(AXFX_REVERBHI_EXP* fx);
static void __BzeroDelayLines(AXFX_REVERBHI_EXP* fx);
static void __FreeDelayLine(AXFX_REVERBHI_EXP* fx);
static BOOL __InitParams(AXFX_REVERBHI_EXP* fx);
static u32 __EarlySizeTable[8][3] = {{157, 479, 829}, {317, 809, 1117}, {479, 941, 1487}, {641, 1259, 1949},
{797, 1667, 2579}, {967, 1901, 2903}, {1123, 2179, 3413}, {1279, 2477, 3889}};
static f32 __EarlyCoefTable[8][3] = {{0.4f, -1.0f, 0.3f}, {0.5f, -0.95f, 0.3f}, {0.6f, -0.9f, 0.3f}, {0.75f, -0.85f, 0.3f},
{-0.9f, 0.8f, 0.3f}, {-1.0f, 0.7f, 0.3f}, {-1.0f, 0.7f, 0.3f}, {-1.0f, 0.7f, 0.3f}};
static u32 __FilterSizeTable[7][8] = {{1789, 1999, 2333, 433, 149, 47, 73, 67}, {149, 293, 449, 251, 103, 47, 73, 67},
{947, 1361, 1531, 433, 137, 47, 73, 67}, {1279, 1531, 1973, 509, 149, 47, 73, 67},
{1531, 1847, 2297, 563, 179, 47, 73, 67}, {1823, 2357, 2693, 571, 137, 47, 73, 67},
{1823, 2357, 2693, 571, 179, 47, 73, 67}};
u32 AXFXReverbHiExpGetMemSize(AXFX_REVERBHI_EXP* fx) {
u32 sum = 0;
u32 i = 0;
sum += __EarlySizeTable[7][2];
sum += (int)(fx->preDelayTimeMax * 32000);
for (i = 0; i < 5; i++) {
sum += __FilterSizeTable[6][i];
}
sum *= 3;
for (i = 5; i < 8; i++) {
sum += __FilterSizeTable[6][i];
}
sum *= 4;
return sum;
}
BOOL AXFXReverbHiExpInit(AXFX_REVERBHI_EXP* fx) {
u32 ch, i;
BOOL result = TRUE;
BOOL mask = OSDisableInterrupts();
fx->active = 1;
if (fx->preDelayTimeMax < 0.0f) {
AXFXReverbHiExpShutdown(fx);
OSRestoreInterrupts(mask);
return FALSE;
}
fx->earlyMaxLength = __EarlySizeTable[8 - 1][2];
fx->preDelayMaxLength = (u32)(fx->preDelayTimeMax * 32000);
for (i = 0; i < 3; i++) {
fx->combMaxLength[i] = __FilterSizeTable[6][i];
}
for (i = 0; i < 2; i++) {
fx->allpassMaxLength[i] = __FilterSizeTable[6][3 + i];
}
for (ch = 0; ch < 3; ch++) {
fx->lastAllpassMaxLength[ch] = __FilterSizeTable[6][5 + ch];
}
result = __AllocDelayLine(fx);
if (result == FALSE) {
AXFXReverbHiExpShutdown(fx);
OSRestoreInterrupts(mask);
return FALSE;
}
__BzeroDelayLines(fx);
result = __InitParams(fx);
if (result == FALSE) {
AXFXReverbHiExpShutdown(fx);
OSRestoreInterrupts(mask);
return FALSE;
}
fx->active &= ~1;
OSRestoreInterrupts(mask);
return TRUE;
}
BOOL AXFXReverbHiExpSettings(AXFX_REVERBHI_EXP* fx) {
BOOL mask = OSDisableInterrupts();
fx->active = fx->active | 1;
AXFXReverbHiExpShutdown(fx);
if (!AXFXReverbHiExpInit(fx)) {
AXFXReverbHiExpShutdown(fx);
OSRestoreInterrupts(mask);
return FALSE;
} else {
fx->active |= 2;
fx->active &= ~1;
OSRestoreInterrupts(mask);
return TRUE;
}
}
void AXFXReverbHiExpShutdown(AXFX_REVERBHI_EXP* fx) {
BOOL mask = OSDisableInterrupts();
fx->active |= 1;
__FreeDelayLine(fx);
OSRestoreInterrupts(mask);
}
void AXFXReverbHiExpCallback(AXFX_BUFFERUPDATE* bufferUpdate, AXFX_REVERBHI_EXP* fx) {
u32 ch, i;
u32 samp;
s32* input[3];
f32 data;
f32 output[3];
f32* earlyLine;
f32 earlyOut;
f32* preDelayLine;
f32 preDelayOut;
f32 filterOut;
f32* combLine;
f32 combOutOne;
f32* allpass;
f32 outTmp;
f32 allpassIn;
f32 allpassCoef;
f32 lpfOut;
f32 lpfCoef1;
f32 lpfCoef2;
f32 fusedOut[3];
f32 fusedGain;
f32 crosstalkGain;
f32 crosstalkL;
f32 crosstalkR;
f32 crosstalkS;
s32* inBusData[3];
s32* outBusData[3];
if (fx->active != 0) {
fx->active &= ~2;
return;
}
input[0] = bufferUpdate->left;
input[1] = bufferUpdate->right;
input[2] = bufferUpdate->surround;
if (fx->busIn != NULL) {
inBusData[0] = fx->busIn->left;
inBusData[1] = fx->busIn->right;
inBusData[2] = fx->busIn->surround;
}
if (fx->busOut != NULL) {
outBusData[0] = fx->busOut->left;
outBusData[1] = fx->busOut->right;
outBusData[2] = fx->busOut->surround;
}
lpfCoef1 = 1.0f - fx->lpfCoef;
lpfCoef2 = fx->lpfCoef;
allpassCoef = fx->allpassCoef;
fusedGain = fx->fusedGain * 0.6f;
crosstalkGain = fx->crosstalk * 0.5f;
for (samp = 0; samp < 96; samp++) {
for (ch = 0; ch < 3; ch++) {
if (fx->busIn != NULL) {
data = (f32)(*(input[ch]) + *(inBusData[ch]++));
} else {
data = (f32)(*input[ch]);
}
earlyLine = fx->earlyLine[ch];
earlyOut = earlyLine[fx->earlyPos[0]] * fx->earlyCoef[0] + earlyLine[fx->earlyPos[1]] * fx->earlyCoef[1] +
earlyLine[fx->earlyPos[2]] * fx->earlyCoef[2];
earlyLine[fx->earlyPos[2]] = data;
if (fx->preDelayLength != 0) {
preDelayLine = fx->preDelayLine[ch];
preDelayOut = preDelayLine[fx->preDelayPos];
preDelayLine[fx->preDelayPos] = data;
} else {
preDelayOut = data;
}
filterOut = 0.0f;
for (i = 0; i < 3; i++) {
combLine = fx->combLine[ch][i];
combOutOne = combLine[fx->combPos[i]];
combLine[fx->combPos[i]] = preDelayOut + (combOutOne * fx->combCoef[i]);
filterOut += combOutOne;
}
for (i = 0; i < 2; i++) {
allpass = fx->allpassLine[ch][i];
outTmp = allpass[fx->allpassPos[i]];
allpassIn = filterOut + outTmp * allpassCoef;
allpass[fx->allpassPos[i]] = allpassIn;
filterOut = outTmp - allpassIn * allpassCoef;
}
lpfOut = lpfCoef1 * filterOut + lpfCoef2 * fx->lastLpfOut[ch];
fx->lastLpfOut[ch] = lpfOut;
allpass = fx->lastAllpassLine[ch];
outTmp = allpass[fx->lastAllpassPos[ch]];
allpassIn = lpfOut + outTmp * allpassCoef;
allpass[fx->lastAllpassPos[ch]] = allpassIn;
fusedOut[ch] = outTmp - allpassIn * allpassCoef;
if (++fx->lastAllpassPos[ch] >= fx->lastAllpassLength[ch]) {
fx->lastAllpassPos[ch] = 0;
}
fusedOut[ch] *= fusedGain;
fusedOut[ch] += earlyOut;
}
crosstalkL = fusedOut[1] + fusedOut[2];
crosstalkR = fusedOut[0] + fusedOut[2];
crosstalkS = fusedOut[0] + fusedOut[1];
output[0] = fusedOut[0] + crosstalkL * crosstalkGain;
output[1] = fusedOut[1] + crosstalkR * crosstalkGain;
output[2] = fusedOut[2] + crosstalkS * crosstalkGain;
*(input[0]++) = (s32)(output[0] * fx->outGain);
*(input[1]++) = (s32)(output[1] * fx->outGain);
*(input[2]++) = (s32)(output[2] * fx->outGain);
if (fx->busOut != NULL) {
*(outBusData[0]++) = (s32)(output[0] * fx->sendGain);
*(outBusData[1]++) = (s32)(output[1] * fx->sendGain);
*(outBusData[2]++) = (s32)(output[2] * fx->sendGain);
}
for (i = 0; i < 3; i++) {
if (++fx->earlyPos[i] >= fx->earlyLength) {
fx->earlyPos[i] = 0;
}
}
if (fx->preDelayLength != 0) {
if (++fx->preDelayPos >= fx->preDelayLength) {
fx->preDelayPos = 0;
}
}
for (i = 0; i < 3; i++) {
if (++fx->combPos[i] >= fx->combLength[i]) {
fx->combPos[i] = 0;
}
}
for (i = 0; i < 2; i++) {
if (++fx->allpassPos[i] >= fx->allpassLength[i]) {
fx->allpassPos[i] = 0;
}
}
}
}
static BOOL __AllocDelayLine(AXFX_REVERBHI_EXP* fx) {
u32 ch, i;
for (ch = 0; ch < 3; ch++) {
fx->earlyLine[ch] = (f32*)__AXFXAlloc(sizeof(f32) * fx->earlyMaxLength);
if (fx->earlyLine[ch] == NULL)
return FALSE;
if (fx->preDelayMaxLength != 0) {
fx->preDelayLine[ch] = (f32*)__AXFXAlloc(sizeof(f32) * fx->preDelayMaxLength);
if (fx->preDelayLine[ch] == NULL)
return FALSE;
} else {
fx->preDelayLine[ch] = NULL;
}
for (i = 0; i < 3; i++) {
fx->combLine[ch][i] = (f32*)__AXFXAlloc(sizeof(f32) * fx->combMaxLength[i]);
if (fx->combLine[ch][i] == NULL)
return FALSE;
}
for (i = 0; i < 2; i++) {
fx->allpassLine[ch][i] = (f32*)__AXFXAlloc(sizeof(f32) * fx->allpassMaxLength[i]);
if (fx->allpassLine[ch][i] == NULL)
return FALSE;
}
fx->lastAllpassLine[ch] = (f32*)__AXFXAlloc(sizeof(f32) * fx->lastAllpassMaxLength[ch]);
if (fx->lastAllpassLine[ch] == NULL)
return FALSE;
}
return TRUE;
}
static void __BzeroDelayLines(AXFX_REVERBHI_EXP* fx) {
u32 ch, i;
for (ch = 0; ch < 3; ch++) {
if (fx->earlyLine[ch] != NULL) {
memset(fx->earlyLine[ch], 0, sizeof(f32) * fx->earlyMaxLength);
}
if (fx->preDelayLine[ch] != NULL) {
memset(fx->preDelayLine[ch], 0, sizeof(f32) * fx->preDelayMaxLength);
}
for (i = 0; i < 3; i++) {
if (fx->combLine[ch][i] != NULL) {
memset(fx->combLine[ch][i], 0, sizeof(f32) * fx->combMaxLength[i]);
}
}
for (i = 0; i < 2; i++) {
if (fx->allpassLine[ch][i] != NULL) {
memset(fx->allpassLine[ch][i], 0, sizeof(f32) * fx->allpassMaxLength[i]);
}
}
if (fx->lastAllpassLine[ch] != NULL) {
memset(fx->lastAllpassLine[ch], 0, sizeof(f32) * fx->lastAllpassMaxLength[ch]);
}
}
}
static void __FreeDelayLine(AXFX_REVERBHI_EXP* fx) {
u32 ch, i;
for (ch = 0; ch < 3; ch++) {
if (fx->earlyLine[ch] != NULL) {
__AXFXFree(fx->earlyLine[ch]);
fx->earlyLine[ch] = NULL;
}
if (fx->preDelayLine[ch] != NULL) {
__AXFXFree(fx->preDelayLine[ch]);
fx->preDelayLine[ch] = NULL;
}
for (i = 0; i < 3; i++) {
if (fx->combLine[ch][i] != NULL) {
__AXFXFree(fx->combLine[ch][i]);
fx->combLine[ch][i] = NULL;
}
}
for (i = 0; i < 2; i++) {
if (fx->allpassLine[ch][i] != NULL) {
__AXFXFree(fx->allpassLine[ch][i]);
fx->allpassLine[ch][i] = NULL;
}
}
if (fx->lastAllpassLine[ch] != NULL) {
__AXFXFree(fx->lastAllpassLine[ch]);
fx->lastAllpassLine[ch] = NULL;
}
}
}
DECOMP_FORCE_LITERAL(AXFXReverbHiExp_c, -3.0f, 10.0);
static BOOL __InitParams(AXFX_REVERBHI_EXP* reverb) {
u32 ch, i;
if (reverb->earlyMode >= 8)
return FALSE;
if (reverb->preDelayTime < 0.0f || reverb->preDelayTime > reverb->preDelayTimeMax)
return FALSE;
if (reverb->fusedMode >= 6)
return FALSE;
if (reverb->fusedTime < 0.0f)
return FALSE;
if (reverb->coloration < 0.0f || reverb->coloration > 1.0f)
return FALSE;
if (reverb->damping < 0.0f || reverb->damping > 1.0f)
return FALSE;
if (reverb->crosstalk < 0.0f || reverb->crosstalk > 1.0f)
return FALSE;
if (reverb->earlyGain < 0.0f || reverb->earlyGain > 1.0f)
return FALSE;
if (reverb->fusedGain < 0.0f || reverb->fusedGain > 1.0f)
return FALSE;
if (reverb->outGain < 0.0f || reverb->outGain > 1.0f)
return FALSE;
if (reverb->sendGain < 0.0f || reverb->sendGain > 1.0f)
return FALSE;
reverb->earlyLength = __EarlySizeTable[reverb->earlyMode][2];
for (i = 0; i < 3; i++) {
reverb->earlyPos[i] = reverb->earlyLength - __EarlySizeTable[reverb->earlyMode][i];
reverb->earlyCoef[i] = __EarlyCoefTable[reverb->earlyMode][i] * reverb->earlyGain * 0.6f;
}
reverb->preDelayPos = 0;
reverb->preDelayLength = (u32)(reverb->preDelayTime * (f32)32000);
for (i = 0; i < 3; i++) {
reverb->combPos[i] = 0;
reverb->combLength[i] = __FilterSizeTable[reverb->fusedMode][i];
reverb->combCoef[i] = pow(10.0f, (-3.0f * (f32)(reverb->combLength[i]) / (f32)(reverb->fusedTime * 32000)));
}
for (i = 0; i < 2; i++) {
reverb->allpassPos[i] = 0;
reverb->allpassLength[i] = __FilterSizeTable[reverb->fusedMode][3 + i];
}
for (ch = 0; ch < 3; ch++) {
reverb->lastAllpassPos[ch] = 0;
reverb->lastAllpassLength[ch] = __FilterSizeTable[reverb->fusedMode][5 + ch];
}
reverb->allpassCoef = reverb->coloration;
reverb->lpfCoef = 1.0f - reverb->damping;
if (reverb->lpfCoef > 0.95f)
reverb->lpfCoef = 0.95f;
for (ch = 0; ch < 3; ch++) {
reverb->lastLpfOut[ch] = 0.0f;
}
return TRUE;
}

View File

@@ -1,35 +1,55 @@
#include <revolution/verdefs.h>
#include <revolution/os.h>
#include <private/nand.h>
#include <revolution/nand.h>
#include <private/es.h>
#include <errno.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
SDKDefineVersion(CNTCACHE, "Apr 20 2010", "14:15:28");
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,
0x30, 0x20, 0x31, 0x34, 0x3a, 0x31, 0x35, 0x3a, 0x32, 0x38, 0x20, 0x28, 0x30, 0x78, 0x34, 0x31,
0x39, 0x39, 0x5f, 0x36, 0x30, 0x38, 0x33, 0x31, 0x29, 0x20, 0x3e, 0x3e, 0x00, 0x00, 0x00, 0x00,
0x2f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x32, 0x2f, 0x63, 0x6e, 0x74, 0x63, 0x61, 0x63, 0x68,
0x65, 0x2e, 0x74, 0x78, 0x74, 0x00, 0x00, 0x00, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x54, 0x69,
0x74, 0x6c, 0x65, 0x20, 0x00, 0x00, 0x00, 0x00, 0x25, 0x30, 0x31, 0x36, 0x6c, 0x6c, 0x78, 0x20,
0x00, 0x00, 0x00, 0x00, 0x2f, 0x74, 0x6d, 0x70, 0x2f, 0x63, 0x6e, 0x74, 0x63, 0x61, 0x63, 0x68,
0x65, 0x2e, 0x74, 0x78, 0x74, 0x00, 0x00, 0x00, 0x2f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x64, 0x32,
0x00, 0x00, 0x00, 0x00, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e,
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 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 = lbl_81693350;
char lbl_816985DC[3] = {0x20, 0x0a, 0x00};
extern void _savegpr_23();
extern void _restgpr_23();
extern void _savegpr_26();
extern void _restgpr_26();
OSMutex _CNTCACHEMutex;
int _CNTCACHEUnused816997A8;
long long _CNTCACHEUnused816997A8;
int _CNTCACHEUnused816997A4;
BOOL _CNTCACHEInitialized;
void CNTCACHEClear();
BOOL _CNTCACHEIsTitleRemovable(ESTitleId titleId);
void _CNTCACHEDeleteTitle();
void _CNTCACHEDeleteContent();
void CNTCACHEInit(int unk0, int unk1) {
if (_CNTCACHEInitialized == FALSE) {
BOOL old;
OSRegisterVersion(GetVersion(CNTCACHE));
OSRegisterVersion(__CNTCACHEVersion);
OSInitMutex(&_CNTCACHEMutex);
ES_InitLib();
@@ -41,87 +61,492 @@ void CNTCACHEInit(int unk0, int unk1) {
CNTCACHEClear();
_CNTCACHEUnused816997A4 = unk0;
_CNTCACHEUnused816997A8 = unk1;
*((int*)&_CNTCACHEUnused816997A8) = unk1;
}
asm void CNTCACHEClear() {
clrlwi r11, r1, 0x1b
mr r12, r1
subfic r11, r11, -0x500
stwux r1, r1, r11
mflr r0
mr r11, r12
stw r0, 4(r12)
bl _savegpr_23
lis r30, lbl_81693350@ha
lis r3, _CNTCACHEMutex@ha
addi r30, r30, lbl_81693350@l
li r29, 0
addi r3, r3, _CNTCACHEMutex@l
bl OSLockMutex
addi r3, r30, 0x50
addi r4, r1, 0x24
li r27, 1
li r5, 3
bl NANDPrivateOpen
cmpwi r3, -0xc
mr r28, r3
bne L_d4
li r28, 0
b L_28c
L_d4:
cmpwi r3, 0
beq L_e0
b L_268
L_e0:
addi r3, r1, 0x24
addi r4, r1, 0x20
bl NANDGetLength
cmpwi r3, 0
mr r28, r3
beq L_fc
b L_268
L_fc:
li r26, 0
li r31, 0
b L_25c
L_108:
lwz r25, 0x20(r1)
cmplwi r25, 0x400
ble L_118
li r25, 0x400
L_118:
addi r24, r1, 0xc0
addi r0, r25, 0x1f
addi r3, r1, 0x24
mr r4, r24
rlwinm r5, r0, 0, 0, 0x1a
bl NANDRead
cmpw r3, r25
beq L_140
li r28, -0x14b3
b L_268
L_140:
mr r4, r24
li r28, 0
mtctr r25
cmplwi r25, 0
ble L_16c
L_154:
lbz r0, 0(r4)
cmpwi r0, 0xa
bne L_164
b L_170
L_164:
addi r4, r4, 1
bdnz L_154
L_16c:
li r4, 0
L_170:
cmpwi r4, 0
bne L_224
li r28, 0
b L_268
b L_224
L_184:
stb r31, 0(r4)
subf r23, r24, r4
mr r3, r24
la r4, lbl_816985DC
bl strtok
cmpwi r3, 0
mr r29, r3
beq L_1d4
addi r4, r30, 0xb4
bl strcmp
cmpwi r3, 0
bne L_1bc
bl _CNTCACHEDeleteTitle
b L_1d4
L_1bc:
mr r3, r29
addi r4, r30, 0xc0
bl strcmp
cmpwi r3, 0
bne L_1d4
bl _CNTCACHEDeleteContent
L_1d4:
lwz r0, 0x20(r1)
addi r23, r23, 1
add r24, r24, r23
subf r0, r23, r0
subf r25, r23, r25
mr r4, r24
stw r0, 0x20(r1)
add r26, r26, r23
mtctr r25
cmplwi r25, 0
ble L_218
L_200:
lbz r0, 0(r4)
cmpwi r0, 0xa
bne L_210
b L_21c
L_210:
addi r4, r4, 1
bdnz L_200
L_218:
li r4, 0
L_21c:
cmpwi r4, 0
beq L_22c
L_224:
cmpwi r25, 0
bgt L_184
L_22c:
lwz r0, 0x20(r1)
cmpwi r0, 0
beq L_25c
mr r4, r26
addi r3, r1, 0x24
li r5, 0
bl NANDSeek
cmplw r3, r26
beq L_258
li r28, -0x14b3
b L_268
L_258:
li r28, 0
L_25c:
lwz r0, 0x20(r1)
cmpwi r0, 0
bne L_108
L_268:
addi r3, r1, 0x24
bl NANDClose
addi r3, r30, 0x50
li r29, 0
bl NANDPrivateDelete
cmpwi r3, 0
addi r3, r30, 0x84
bl NANDPrivateDelete
cmpwi r3, 0
L_28c:
cmpwi r29, 0
beq L_29c
addi r3, r1, 0x24
bl NANDClose
L_29c:
cmpwi r27, 0
beq L_2b0
lis r3, _CNTCACHEMutex@ha
addi r3, r3, _CNTCACHEMutex@l
bl OSUnlockMutex
L_2b0:
mr r3, r28
lwz r10, 0(r1)
mr r11, r10
bl _restgpr_23
lwz r0, 4(r10)
mtlr r0
mr r1, r10
blr
}
void _CNTCACHEDeleteTitle() {
char* tok = strtok(NULL, " \n");
while (tok != NULL) {
ESTitleId titleId;
errno = 0;
titleId = strtoull(tok, NULL, 16);
if (errno == 0 && NANDTitleIdHi(titleId) != 0x00000001) {
BOOL result = _CNTCACHEIsTitleRemovable(titleId);
if (result == TRUE) {
ES_DeleteTitle(titleId);
} else if (result == FALSE) {
ES_DeleteTitleContent(titleId);
}
}
tok = strtok(NULL, " \n");
}
asm void _CNTCACHEDeleteTitle() {
stwu r1, -0x20(r1)
mflr r0
li r3, 0
la r4, lbl_816985DC
stw r0, 0x24(r1)
stw r31, 0x1c(r1)
stw r30, 0x18(r1)
stw r29, 0x14(r1)
stw r28, 0x10(r1)
bl strtok
li r30, 0
li r31, -1
b L_370
L_304:
stw r30, errno(r0)
li r4, 0
li r5, 0x10
bl strtoull
lwz r0, errno(r0)
mr r28, r4
mr r29, r3
cmpwi r0, 0
bne L_364
and r0, r3, r31
cmplwi r0, 1
beq L_364
bl _CNTCACHEIsTitleRemovable
cmpwi r3, 1
bne L_350
mr r4, r28
mr r3, r29
bl ES_DeleteTitle
b L_364
L_350:
cmpwi r3, 0
bne L_364
mr r4, r28
mr r3, r29
bl ES_DeleteTitleContent
L_364:
li r3, 0
la r4, lbl_816985DC
bl strtok
L_370:
cmpwi r3, 0
bne L_304
lwz r0, 0x24(r1)
lwz r31, 0x1c(r1)
lwz r30, 0x18(r1)
lwz r29, 0x14(r1)
lwz r28, 0x10(r1)
mtlr r0
addi r1, r1, 0x20
blr
}
static int GetSavePath(ESTitleId titleId) {
char nandPath[64] ALIGN32;
s32 ret;
u32 usedBlocks = 1;
u32 usedINodes = 1;
snprintf(nandPath, (int)sizeof(nandPath), "/title/%08x/%08x/data", NANDTitleIdHi(titleId), NANDTitleIdLo(titleId));
ret = NANDSecretGetUsage(nandPath, &usedBlocks, &usedINodes);
if (ret == NAND_RESULT_NOEXISTS) {
ret = 2;
} else if (ret >= NAND_RESULT_OK) {
if (usedINodes == 1 && usedBlocks == 0) {
ret = 1;
} else {
ret = 0;
}
}
return ret;
asm int _CNTCACHEIsTitleRemovable(ESTitleId titleId) {
clrlwi r11, r1, 0x1b
mr r12, r1
subfic r11, r11, -0x2100
stwux r1, r1, r11
mflr r0
lis r5, lbl_81693420@ha
stw r0, 4(r12)
li r0, 1
addi r5, r5, lbl_81693420@l
stw r31, -4(r12)
stw r30, -8(r12)
mr r30, r3
addi r3, r1, 0x40
stw r29, -0xc(r12)
mr r29, r4
li r4, -1
stw r0, 0x20(r1)
and r6, r30, r4
and r7, r29, r4
li r4, 0x40
stw r0, 0x24(r1)
crclr 4*cr1+eq
bl snprintf
addi r3, r1, 0x40
addi r4, r1, 0x20
addi r5, r1, 0x24
bl NANDSecretGetUsage
cmpwi r3, -0xc
mr r4, r3
bne L_418
li r4, 2
b L_444
L_418:
cmpwi r3, 0
blt L_444
lwz r0, 0x24(r1)
cmplwi r0, 1
bne L_440
lwz r0, 0x20(r1)
cmpwi r0, 0
bne L_440
li r4, 1
b L_444
L_440:
li r4, 0
L_444:
cmpwi r4, 1
bne L_4bc
mr r4, r29
mr r3, r30
addi r31, r1, 0x80
addi r6, r1, 0x28
li r5, 0
bl ES_GetTmdView
cmpwi r3, 0
beq L_470
b L_4c0
L_470:
lwz r0, 0x28(r1)
cmplwi r0, 0x2060
ble L_484
li r3, -0x400
b L_4c0
L_484:
mr r4, r29
mr r3, r30
mr r5, r31
addi r6, r1, 0x28
bl ES_GetTmdView
cmpwi r3, 0
beq L_4a4
b L_4c0
L_4a4:
lhz r0, 0xd8(r1)
rlwinm. r0, r0, 0x18, 0x18, 0x1f
bne L_4b8
li r4, 1
b L_4bc
L_4b8:
li r4, 0
L_4bc:
mr r3, r4
L_4c0:
lwz r10, 0(r1)
lwz r0, 4(r10)
lwz r31, -4(r10)
lwz r30, -8(r10)
lwz r29, -0xc(r10)
mtlr r0
mr r1, r10
blr
}
static int GetTmdView(ESTitleId titleId, ESTmdView* tmdView) {
s32 ret;
u32* tmdSize = NULL;
ret = ES_GetTmdView(titleId, NULL, tmdSize);
if (ret != ES_ERR_OK) {
return ret;
}
if (*tmdSize > OSRoundUp32B(sizeof(ESTmdView))) {
ret = -1024;
goto out;
}
ret = ES_GetTmdView(titleId, tmdView, tmdSize);
out:
return ret;
}
int _CNTCACHEIsTitleRemovable(ESTitleId titleId) {
ESTmdView tmd ALIGN32;
s32 ret = -1;
ret = GetSavePath(titleId);
if (ret == 1) {
ret = GetTmdView(titleId, &tmd);
if (ret != ES_ERR_OK) {
return ret;
}
if (tmd.head.titleVersion >> 8 == 0) {
ret = 1;
} else {
ret = 0;
}
goto out;
}
out:
return ret;
asm void _CNTCACHEDeleteContent() {
clrlwi r11, r1, 0x1b
mr r12, r1
subfic r11, r11, -0x2100
stwux r1, r1, r11
mflr r0
mr r11, r12
stw r0, 4(r12)
bl _savegpr_26
li r3, 0
la r4, lbl_816985DC
bl strtok
li r31, 0
li r4, 0
stw r31, errno(r0)
li r5, 0x10
bl strtoull
lwz r0, errno(r0)
mr r29, r4
mr r30, r3
cmpwi r0, 0
bne L_708
li r0, -1
and r5, r3, r0
addis r0, r5, -1
cmplwi r0, 5
bne L_708
addi r28, r1, 0x80
addi r6, r1, 0x28
li r5, 0
bl ES_GetTmdView
cmpwi r3, -0x6a
beq L_708
cmpwi r3, 0
bne L_708
mr r4, r29
mr r3, r30
mr r5, r28
addi r6, r1, 0x28
bl ES_GetTmdView
cmpwi r3, 0
bne L_708
lwz r3, 0x94(r1)
rlwinm. r0, r3, 0, 0x1c, 0x1c
beq L_6f0
rlwinm. r0, r3, 0, 0x1b, 0x1b
beq L_6f0
li r3, 0
la r4, lbl_816985DC
bl strtok
li r26, 1
lis r27, lbl_81693420@ha
b L_6e8
L_5b0:
stw r31, errno(r0)
li r4, 0
li r5, 0xa
bl strtoul
lwz r0, errno(r0)
cmpwi r0, 0
bne L_6dc
cmplwi r3, 0x1fe
bgt L_6dc
lhz r0, 0xda(r1)
li r4, 0
mtctr r0
cmplwi r0, 0
ble L_6dc
L_5e8:
add r5, r28, r4
lhz r0, 0x60(r5)
cmplw r3, r0
bne L_6d4
lhz r0, 0x62(r5)
rlwinm. r0, r0, 0, 0x10, 0x10
bne L_6dc
lwz r5, 0x5c(r5)
mr r4, r29
mr r3, r30
bl ES_DeleteContent
cmpwi r3, 0
bne L_6dc
mr r4, r29
mr r3, r30
addi r6, r1, 0x2c
li r5, 0
bl ES_ListTitleContentsOnCard
cmpwi r3, 0
bne L_6dc
lwz r0, 0x2c(r1)
cmpwi r0, 0
bne L_6dc
li r0, -1
stw r26, 0x20(r1)
addi r3, r1, 0x40
addi r5, r27, lbl_81693420@l
stw r26, 0x24(r1)
and r6, r30, r0
and r7, r29, r0
li r4, 0x40
crclr 4*cr1+eq
bl snprintf
addi r3, r1, 0x40
addi r4, r1, 0x20
addi r5, r1, 0x24
bl NANDSecretGetUsage
cmpwi r3, -0xc
mr r0, r3
bne L_690
li r0, 2
b L_6bc
L_690:
cmpwi r3, 0
blt L_6bc
lwz r0, 0x24(r1)
cmplwi r0, 1
bne L_6b8
lwz r0, 0x20(r1)
cmpwi r0, 0
bne L_6b8
li r0, 1
b L_6bc
L_6b8:
li r0, 0
L_6bc:
cmpwi r0, 1
bne L_6dc
mr r4, r29
mr r3, r30
bl ES_DeleteTitle
b L_6dc
L_6d4:
addi r4, r4, 0x10
bdnz L_5e8
L_6dc:
li r3, 0
la r4, lbl_816985DC
bl strtok
L_6e8:
cmpwi r3, 0
bne L_5b0
L_6f0:
lwz r5, 0x28(r1)
addi r3, r1, 0x80
li r4, 0
addi r0, r5, 0x1f
rlwinm r5, r0, 0, 0, 0x1a
bl memset
L_708:
lwz r10, 0(r1)
mr r11, r10
bl _restgpr_26
lwz r0, 4(r10)
mtlr r0
mr r1, r10
blr
}

View File

@@ -0,0 +1,8 @@
#include <revolution/fa.h>
extern s32 pfstub_fclose(FAFILE* stream);
FAError FAFclose(FAFILE* stream) {
s32 error = pfstub_fclose(stream);
return (-error | error) >> 31;
}

View File

@@ -0,0 +1,8 @@
#include <revolution/fa.h>
extern s32 pfstub_finfo(FAFILE* stream, FAFileInfo* info);
FAError FAFinfo(FAFILE* stream, FAFileInfo* info) {
s32 error = pfstub_finfo(stream, info);
return (-error | error) >> 31;
}

View File

@@ -0,0 +1,7 @@
#include <revolution/fa.h>
extern size_t pfstub_fread(void* buffer, size_t size, size_t count, FAFILE* stream);
size_t FAFread(void* buffer, size_t size, size_t count, FAFILE* stream) {
return pfstub_fread(buffer, size, count, stream);
}

View File

@@ -0,0 +1,7 @@
#include <revolution/fa.h>
extern size_t pfstub_fwrite(void* buffer, size_t size, size_t count, FAFILE* stream);
size_t FAFwrite(void* buffer, size_t size, size_t count, FAFILE* stream) {
return pfstub_fwrite(buffer, size, count, stream);
}

View File

@@ -0,0 +1,2 @@
int FADiskInitializedPadding;
int FADiskInitialized;

View File

@@ -0,0 +1,10 @@
typedef int s32;
extern s32 PFDIR_closedir(void* dir);
extern s32 PFAPI_convertReturnValue(s32 err);
s32 pf2_closedir(void* dir) {
s32 err = PFDIR_closedir(dir);
err = PFAPI_convertReturnValue(err);
return err;
}

View File

@@ -0,0 +1,10 @@
#include <revolution/fa.h>
extern s32 PFVOL_errnum(void);
extern s32 PFAPI_convertError(s32 error);
FAError pf2_errnum() {
s32 error = PFVOL_errnum();
error = PFAPI_convertError(error);
return error;
}

View File

@@ -0,0 +1,7 @@
#include <revolution/types.h>
extern s32 PFVOL_InitModule(u32 config, void* param);
s32 PFFATFS_initializeFATFS(u32 config, void* param) {
return PFVOL_InitModule(config, param);
}

View File

@@ -0,0 +1,10 @@
#include <revolution/fa.h>
extern s32 PFFILE_fclose(FAFILE* stream);
extern s32 PFAPI_convertReturnValue(s32 error);
FAError pf2_fclose(FAFILE* stream) {
s32 error = PFFILE_fclose(stream);
error = PFAPI_convertReturnValue(error);
return error;
}

View File

@@ -0,0 +1,10 @@
#include <revolution/fa.h>
extern s32 PFFILE_feof(FAFILE* stream);
extern s32 PFAPI_convertReturnValue4feof(s32 error);
FAError pf2_feof(FAFILE* stream) {
s32 error = PFFILE_feof(stream);
error = PFAPI_convertReturnValue4feof(error);
return error;
}

View File

@@ -0,0 +1,10 @@
#include <revolution/fa.h>
extern s32 PFFILE_ferror(FAFILE* stream);
extern s32 PFAPI_convertError(s32 error);
FAError pf2_ferror(FAFILE* stream) {
s32 error = PFFILE_ferror(stream);
error = PFAPI_convertError(error);
return error;
}

View File

@@ -0,0 +1,12 @@
#include <revolution/fa.h>
extern s32 PFFILE_flock(FAFILE* stream, s32 mode);
extern s32 PFAPI_convertReturnValue(s32 error);
FAError pf2_flock(FAFILE* stream, s32 mode) {
s32 error;
mode |= 8;
error = PFFILE_flock(stream, mode);
error = PFAPI_convertReturnValue(error);
return error;
}

View File

@@ -0,0 +1,9 @@
#include <revolution/fa.h>
extern s32 PFFILE_fread(void* buffer, size_t size, size_t count, FAFILE* stream, size_t* countRead);
size_t pf2_fread(void* buffer, size_t size, size_t count, FAFILE* stream) {
size_t countRead;
PFFILE_fread(buffer, size, count, stream, &countRead);
return countRead;
}

View File

@@ -0,0 +1,10 @@
#include <revolution/fa.h>
extern s32 PFFILE_fsync(FAFILE* stream);
extern s32 PFAPI_convertReturnValue(s32 error);
FAError pf2_fsync(FAFILE* stream) {
s32 error = PFFILE_fsync(stream);
error = PFAPI_convertReturnValue(error);
return error;
}

View File

@@ -0,0 +1,9 @@
#include <revolution/fa.h>
extern s32 PFFILE_fwrite(void* buffer, size_t size, size_t count, FAFILE* stream, size_t* countWritten);
size_t pf2_fwrite(void* buffer, size_t size, size_t count, FAFILE* stream) {
size_t countWritten;
PFFILE_fwrite(buffer, size, count, stream, &countWritten);
return countWritten;
}

View File

@@ -66,6 +66,7 @@ void __OSEVStart();
void __OSEVEnd();
#define __OSEVSize ((u32)__OSEVEnd - (u32)__OSEVStart)
void __OSEVSetNumber();
void __OSDBJumpTarget();
void __DBVECTOR();
@@ -795,7 +796,7 @@ static asm void __OSDBJump() {
#ifdef __MWERKS__
nofralloc
entry __OSDBJUMPSTART
bla OS_ADDR_DB_INTEGRATOR_HOOK
bla __OSDBJumpTarget
entry __OSDBJUMPEND
#endif // __MWERKS__
// clang-format on
@@ -831,6 +832,7 @@ entry __OSEVStart
mflr r3
stw r3, OSContext.lr(r4)
mfctr r3
entry __OSDBJumpTarget
stw r3, OSContext.ctr(r4)
mfxer r3
stw r3, OSContext.xer(r4)

View File

@@ -31,7 +31,7 @@
char lbl_81687720[] = "<< RVL_SDK - WPAD \trelease build: Apr 20 2010 11:20:55 (0x4199_60831) >>";
const char* __WPADVersion = lbl_81687720;
WPADCB _wpd[WPAD_MAX_CONTROLLERS];
WPADStorage _wpd;
WPADCB* _wpdcb[WPAD_MAX_CONTROLLERS];
u8 __WPADiManageHandlerStack[0x1000] ALIGN32;
@@ -636,30 +636,30 @@ static asm void WPADiManageHandler(OSAlarm* pAlarm, OSContext* pContext) {
beq WPADiManageHandler_8AC8
cmpwi r3, 0x2
bne WPADiManageHandler_91D8
lwz r0, _initialized(r13)
lwz r0, _initialized(r0)
cmpwi r0, 0x0
bne WPADiManageHandler_91D8
li r0, 0x1
lis r3, WPADiConnCallback@ha
stw r0, _initialized(r13)
stw r0, _initialized(r0)
addi r3, r3, WPADiConnCallback@l
bl WUDSetHidConnCallback
lis r3, WPADiRecvCallback@ha
addi r3, r3, WPADiRecvCallback@l
bl WUDSetHidRecvCallback
li r0, 0x32
stw r0, _recCnt(r13)
stw r0, _recCnt(r0)
b WPADiManageHandler_91D8
WPADiManageHandler_8AC8:
lwz r4, _recCnt(r13)
lwz r19, _recFlag(r13)
lwz r4, _recCnt(r0)
lwz r19, _recFlag(r0)
cntlzw r3, r4
subi r0, r4, 0x1
extrwi r3, r3, 1, 26
cmpwi r19, 0x0
neg r3, r3
andc r0, r0, r3
stw r0, _recCnt(r13)
stw r0, _recCnt(r0)
blt WPADiManageHandler_8B28
cmpwi r0, 0x0
bne WPADiManageHandler_91D8
@@ -1001,13 +1001,13 @@ WPADiManageHandler_8FC8:
WPADiManageHandler_8FCC:
stb r0, 0x0(r23)
WPADiManageHandler_8FD0:
lbz r0, _checkCnt(r13)
lbz r0, _checkCnt(r0)
cmplwi r0, 0x5
bne WPADiManageHandler_8FE4
mr r3, r22
bl WPADiCheckContInputs
WPADiManageHandler_8FE4:
lhz r0, _senseCnt(r13)
lhz r0, _senseCnt(r0)
cmplwi r0, 0xa
bne WPADiManageHandler_8FF8
mr r3, r22
@@ -1026,7 +1026,7 @@ WPADiManageHandler_900C:
addi r24, r24, 0x4
addi r23, r23, 0x1
blt WPADiManageHandler_8B48
lhz r0, _afhCnt(r13)
lhz r0, _afhCnt(r0)
cmplwi r0, 0xea60
bne WPADiManageHandler_9090
lis r21, 0x8000
@@ -1036,31 +1036,31 @@ WPADiManageHandler_900C:
addi r3, r28, 0x108
crclr 4*cr1+eq
bl DEBUGPrint
lbz r3, _afhChannel(r13)
lbz r3, _afhChannel(r0)
lbz r0, 0x31a2(r21)
extsb r3, r3
cmpw r3, r0
beq WPADiManageHandler_9090
bl OSDisableInterrupts
lbz r0, 0x31a2(r21)
stb r0, _afhChannel(r13)
stb r0, _afhChannel(r0)
bl OSRestoreInterrupts
lbz r4, 0x31a2(r21)
addi r3, r28, 0x130
crclr 4*cr1+eq
bl DEBUGPrint
lbz r0, _afhChannel(r13)
lbz r0, _afhChannel(r0)
extsb r3, r0
bl WUDSetDisableChannel
WPADiManageHandler_9090:
lhz r6, _senseCnt(r13)
lhz r6, _senseCnt(r0)
lis r3, 0x1
subi r0, r3, 0x15a0
lbz r9, _checkCnt(r13)
lbz r9, _checkCnt(r0)
subi r4, r6, 0xa
subfic r3, r6, 0xa
nor r3, r4, r3
lhz r10, _afhCnt(r13)
lhz r10, _afhCnt(r0)
srawi r8, r3, 31
addi r7, r6, 0x1
clrlwi r0, r0, 16
@@ -1070,7 +1070,7 @@ WPADiManageHandler_9090:
nor r5, r4, r3
subf r4, r0, r10
subf r3, r10, r0
lbz r0, _scFlush(r13)
lbz r0, _scFlush(r0)
srawi r6, r5, 31
addi r5, r9, 0x1
nor r4, r4, r3
@@ -1079,9 +1079,9 @@ WPADiManageHandler_9090:
andc r5, r5, r6
andc r3, r3, r4
cmpwi r0, 0x0
sth r7, _senseCnt(r13)
stb r5, _checkCnt(r13)
sth r3, _afhCnt(r13)
sth r7, _senseCnt(r0)
stb r5, _checkCnt(r0)
sth r3, _afhCnt(r0)
beq WPADiManageHandler_9138
bl SCCheckStatus
cmpwi r3, 0x0
@@ -1094,9 +1094,9 @@ WPADiManageHandler_9090:
li r3, 0x0
bl SCFlushAsync
li r0, 0x0
stb r0, _scFlush(r13)
stb r0, _scFlush(r0)
WPADiManageHandler_9138:
lbz r0, _scSetting(r13)
lbz r0, _scSetting(r0)
cmpwi r0, 0x0
beq WPADiManageHandler_91D4
bl SCCheckStatus
@@ -1112,19 +1112,19 @@ WPADiManageHandler_9164:
ble WPADiManageHandler_9170
li r0, 0x5
WPADiManageHandler_9170:
stb r0, _dpdSensitivity(r13)
stb r0, _dpdSensitivity(r0)
bl SCGetWpadSensorBarPosition
clrlwi r3, r3, 24
subi r0, r3, 0x1
cntlzw r0, r0
extrwi r0, r0, 8, 19
stb r0, _sensorBarPos(r13)
stb r0, _sensorBarPos(r0)
bl SCGetWpadMotorMode
clrlwi r3, r3, 24
subi r0, r3, 0x1
cntlzw r0, r0
srwi r0, r0, 5
stw r0, _rumble(r13)
stw r0, _rumble(r0)
bl SCGetWpadSpeakerVolume
clrlwi. r0, r3, 24
mr r4, r3
@@ -1137,8 +1137,8 @@ WPADiManageHandler_91B8:
li r4, 0x7f
WPADiManageHandler_91C8:
li r0, 0x0
stb r4, _speakerVolume(r13)
stb r0, _scSetting(r13)
stb r4, _speakerVolume(r0)
stb r0, _scSetting(r0)
WPADiManageHandler_91D4:
bl BTA_HhGetAclQueueInfo
WPADiManageHandler_91D8:
@@ -1338,12 +1338,12 @@ void WPADiInitSub() {
DEBUGPrint("WPADInit()\n");
for (chan = 0; chan < WPAD_MAX_CONTROLLERS; chan++) {
_wpdcb[chan] = &_wpd[chan];
_wpdcb[chan] = &_wpd.controllers[chan];
_chan_active_state[chan] = FALSE;
_wpdcb[chan]->connectCB = NULL;
__ClearControlBlock(chan);
OSInitThreadQueue(&_wpd[chan].threadQueue);
OSInitThreadQueue(&_wpd.controllers[chan].threadQueue);
_extCnt[chan] = 0;
_rumbleCnt[chan] = 0;

File diff suppressed because it is too large Load Diff

View File

@@ -46,7 +46,7 @@ void CDBRecordKeyGetKeyStr(CDBRecordKey* recordKey, char* keyString);
void CDBRecordKeySetSerialNumber(CDBRecordKey* recordKey, int serialNum);
void CDBRecordKeyCopy(CDBRecordKey* recordKey, CDBRecordKey* newRecordKey);
void CDBRecordKeyCopy(CDBRecordKey* recordKey, const CDBRecordKey* newRecordKey);
BOOL CDBRecordKeyCompare(CDBRecordKey* recordKey1, CDBRecordKey* recordKey2);
int CDBRecordKeyCompareByDate(CDBRecordKey* recordKey1, CDBRecordKey* recordKey2);

View File

@@ -16,7 +16,7 @@ int STD_strnlen(const char* str, u32 len);
int Util_xtoi(char ch);
void* Mail_memcpy(void* dest, void* src, u32 len);
void* Mail_memcpy(void* dest, const void* src, u32 len);
void* Mail_memset(void* dest, int fill, u32 count);
int Mail_strlen(const char* str);

View File

@@ -11,9 +11,7 @@ static char CDB_ATTR_MAGIC[] = "CDBFILE";
static const u32 CDB_ATTR_VERSION = 0x02000000;
static const u32 CDB_ATTR_VERSION_PADDING = 0;
static u32 s_seed = 0;
u32 CDBAttrGetDescOffset(CDBAttr* attr) {
static u32 CDBAttrGetDescOffset(CDBAttr* attr) {
return attr->buf.version == 1 ? 0x0D : offsetof(CDBAttrBuf, descLength);
}
@@ -171,28 +169,18 @@ void CDBAttrGetKeyStr(CDBAttr* attr, char* keyString) {
memcpy(keyString, attr->buf.keyString, CDB_ATTR_BUF_KEY_STRING_LEN);
}
u32 CDBAttrSetIV(CDBAttr* attr, u32 seed);
void CDBAttrInitIV(CDBAttr* attr) {
int i, j;
u32 seed;
static u32 s_seed = 0;
int i;
if (s_seed == 0) {
s_seed = OSGetTick();
}
s_seed = CDBAttrSetIV(attr, s_seed);
}
u32 CDBAttrSetIV(CDBAttr* attr, u32 seed) {
int i, j;
for (i = 0; i < 2; i++) {
for (j = 0; j < 8; j++) {
seed = 1566083941 * seed + 2531011;
attr->buf.iv[(i * 8) + j] = (s8)(seed >> 16);
}
for (i = 0; i < CDB_ATTR_BUF_KEY_IV_LEN; i++) {
s_seed = 1566083941 * s_seed + 2531011;
attr->buf.iv[i] = (s8)(s_seed >> 16);
}
return seed;
}
void CDBAttrGetIV(CDBAttr* attr, u8* iv) {

View File

@@ -324,25 +324,37 @@ CDBErr CDBConvKeyToFullPath(CDBRecordKey* recordKey, char* fullPath) {
}
void CDBConvKeyStrToFullPath_(char* keyString, char* fullPath, CDBLocation location, u64* wiiId) {
char fileNameStr[8];
char yearStr[8];
char monthStr[8];
char dayStr[8];
char hourStr[8];
char minStr[8];
char codeStr[8];
char typeStr[8];
char serialNumStr[8];
char fileNameStr[8];
char typeStr[5];
CDBDate epoch;
int year;
int month;
int day;
int hour;
int min;
char serialNumStr[4];
char fileSerial[4];
CDBDate fileEpoch;
char fileEpochStr[40];
CDBConvKeyStrToEpochValue(keyString, &epoch);
{
union {
char storage[20];
struct {
char prefix[8];
char value[12];
} epoch;
} epochBuffer;
strncpy(epochBuffer.epoch.value, CDBKeyStrEpoch(keyString), CDB_KEYSTR_EPOCH_SIZE);
epochBuffer.epoch.value[CDB_KEYSTR_EPOCH_SIZE] = 0;
sscanf(epochBuffer.epoch.value, "%ul", &epoch);
}
CDBConvEpochValueToDate(epoch, &year, &month, &day, &hour, &min, NULL);
CDBConvYearValueToYearStr(yearStr, year);
@@ -354,7 +366,12 @@ void CDBConvKeyStrToFullPath_(char* keyString, char* fullPath, CDBLocation locat
CDBConvKeyStrToCode(keyString, codeStr);
CDBConvKeyStrToSerialNumber(keyString, serialNumStr);
CDBConvKeyStrToType(keyString, typeStr);
CDBConvKeyStrToFileName(keyString, fileNameStr);
strncpy(fileEpochStr, CDBKeyStrEpoch(keyString), CDB_KEYSTR_EPOCH_SIZE);
fileEpochStr[CDB_KEYSTR_EPOCH_SIZE] = 0;
sscanf(fileEpochStr, "%ul", &fileEpoch);
strncpy(fileSerial, CDBKeyStrSerialNumber(keyString), CDB_KEYSTR_SERIAL_NUMBER_SIZE);
fileSerial[CDB_KEYSTR_SERIAL_NUMBER_SIZE] = 0;
sprintf(fileNameStr, "%08X.%s", fileEpoch, fileSerial);
if (location == CDB_FS_LOCATION_NAND || location == CDB_FS_LOCATION_SD) {
CDBConvFileNameStrToFullPath(fullPath, yearStr, monthStr, dayStr, hourStr, minStr, codeStr, typeStr, fileNameStr, location, wiiId);

File diff suppressed because it is too large Load Diff

View File

@@ -6,8 +6,13 @@
#include <stdlib.h>
#include <string.h>
#pragma push
#pragma section sconst_type ".sdata"
extern const char lbl_816979E8[8] = "/\0\0\0\0\0\0\0";
#pragma pop
void CDBFSConcatenatePath(char* path, const char* concatPath) {
strcat(path, "/");
strcat(path, lbl_816979E8);
strcat(path, concatPath);
}
@@ -106,6 +111,167 @@ BOOL CDBFSIsTypeDirName(char* dirName) {
return FALSE;
}
#ifdef __MWERKS__
asm BOOL CDBFSIsCDBFileOnSD(register char* fileName) {
nofralloc
stwu r1, -0x10(r1)
mflr r0
li r4, 0xd
stw r0, 0x14(r1)
stw r31, 0xc(r1)
mr r31, r3
bl CDBSafeStrLen
cmpwi r3, 0xc
bne CDBFSIsCDBFileOnSD_invalid
lis r4, _current_locale@ha
li r0, 0x4
addi r4, r4, _current_locale@l
mr r3, r31
lwz r6, 0x38(r4)
li r7, 0
mtctr r0
CDBFSIsCDBFileOnSD_loop:
lbz r5, 0(r3)
li r0, 0
extsb. r5, r5
blt CDBFSIsCDBFileOnSD_digit1_invalid
cmpwi r5, 0x100
blt CDBFSIsCDBFileOnSD_digit1_check
CDBFSIsCDBFileOnSD_digit1_invalid:
li r0, 1
CDBFSIsCDBFileOnSD_digit1_check:
cmpwi r0, 0
beq CDBFSIsCDBFileOnSD_digit1_map
li r0, 0
b CDBFSIsCDBFileOnSD_digit1_done
CDBFSIsCDBFileOnSD_digit1_map:
lwz r4, 8(r6)
slwi r0, r5, 1
lhzx r0, r4, r0
rlwinm r0, r0, 0, 21, 21
CDBFSIsCDBFileOnSD_digit1_done:
cmpwi r0, 0
bne CDBFSIsCDBFileOnSD_first_next
li r3, 0
b CDBFSIsCDBFileOnSD_return
CDBFSIsCDBFileOnSD_first_next:
lbz r5, 1(r3)
li r0, 0
extsb. r5, r5
blt CDBFSIsCDBFileOnSD_digit2_invalid
cmpwi r5, 0x100
blt CDBFSIsCDBFileOnSD_digit2_check
CDBFSIsCDBFileOnSD_digit2_invalid:
li r0, 1
CDBFSIsCDBFileOnSD_digit2_check:
cmpwi r0, 0
beq CDBFSIsCDBFileOnSD_digit2_map
li r0, 0
b CDBFSIsCDBFileOnSD_digit2_done
CDBFSIsCDBFileOnSD_digit2_map:
lwz r4, 8(r6)
slwi r0, r5, 1
lhzx r0, r4, r0
rlwinm r0, r0, 0, 21, 21
CDBFSIsCDBFileOnSD_digit2_done:
cmpwi r0, 0
bne CDBFSIsCDBFileOnSD_pair_next
li r3, 0
b CDBFSIsCDBFileOnSD_return
CDBFSIsCDBFileOnSD_pair_next:
addi r7, r7, 1
addi r3, r3, 2
bdnz CDBFSIsCDBFileOnSD_loop
lbz r0, 8(r31)
cmpwi r0, 0x2e
beq CDBFSIsCDBFileOnSD_extension
li r3, 0
b CDBFSIsCDBFileOnSD_return
CDBFSIsCDBFileOnSD_extension:
lbz r4, 9(r31)
li r0, 0
extsb. r4, r4
blt CDBFSIsCDBFileOnSD_digit3_invalid
cmpwi r4, 0x100
blt CDBFSIsCDBFileOnSD_digit3_check
CDBFSIsCDBFileOnSD_digit3_invalid:
li r0, 1
CDBFSIsCDBFileOnSD_digit3_check:
cmpwi r0, 0
beq CDBFSIsCDBFileOnSD_digit3_map
li r0, 0
b CDBFSIsCDBFileOnSD_digit3_done
CDBFSIsCDBFileOnSD_digit3_map:
lwz r3, 8(r6)
slwi r0, r4, 1
lhzx r0, r3, r0
rlwinm r0, r0, 0, 21, 21
CDBFSIsCDBFileOnSD_digit3_done:
cmpwi r0, 0
bne CDBFSIsCDBFileOnSD_digit4
li r3, 0
b CDBFSIsCDBFileOnSD_return
CDBFSIsCDBFileOnSD_digit4:
lbz r4, 0xa(r31)
li r0, 0
extsb. r4, r4
blt CDBFSIsCDBFileOnSD_digit4_invalid
cmpwi r4, 0x100
blt CDBFSIsCDBFileOnSD_digit4_check
CDBFSIsCDBFileOnSD_digit4_invalid:
li r0, 1
CDBFSIsCDBFileOnSD_digit4_check:
cmpwi r0, 0
beq CDBFSIsCDBFileOnSD_digit4_map
li r0, 0
b CDBFSIsCDBFileOnSD_digit4_done
CDBFSIsCDBFileOnSD_digit4_map:
lwz r3, 8(r6)
slwi r0, r4, 1
lhzx r0, r3, r0
rlwinm r0, r0, 0, 21, 21
CDBFSIsCDBFileOnSD_digit4_done:
cmpwi r0, 0
bne CDBFSIsCDBFileOnSD_digit5
li r3, 0
b CDBFSIsCDBFileOnSD_return
CDBFSIsCDBFileOnSD_digit5:
lbz r4, 0xb(r31)
li r0, 0
extsb. r4, r4
blt CDBFSIsCDBFileOnSD_digit5_invalid
cmpwi r4, 0x100
blt CDBFSIsCDBFileOnSD_digit5_check
CDBFSIsCDBFileOnSD_digit5_invalid:
li r0, 1
CDBFSIsCDBFileOnSD_digit5_check:
cmpwi r0, 0
beq CDBFSIsCDBFileOnSD_digit5_map
li r0, 0
b CDBFSIsCDBFileOnSD_digit5_done
CDBFSIsCDBFileOnSD_digit5_map:
lwz r3, 8(r6)
slwi r0, r4, 1
lhzx r0, r3, r0
rlwinm r0, r0, 0, 21, 21
CDBFSIsCDBFileOnSD_digit5_done:
cmpwi r0, 0
bne CDBFSIsCDBFileOnSD_valid
li r3, 0
b CDBFSIsCDBFileOnSD_return
CDBFSIsCDBFileOnSD_valid:
li r3, 1
b CDBFSIsCDBFileOnSD_return
CDBFSIsCDBFileOnSD_invalid:
li r3, 0
CDBFSIsCDBFileOnSD_return:
lwz r0, 0x14(r1)
lwz r31, 0xc(r1)
mtlr r0
addi r1, r1, 0x10
blr
}
#else
BOOL CDBFSIsCDBFileOnSD(char* fileName) {
if (CDBSafeStrLen(fileName, 12 + 1) == 12) {
char* ptr = fileName;
@@ -133,6 +299,7 @@ BOOL CDBFSIsCDBFileOnSD(char* fileName) {
return FALSE;
}
#endif
BOOL CDBFSIsMCGCDirNameOnSD(char* dirName) {
if (CDBSafeStrLen(dirName, 7 + 1) == 7) {

View File

@@ -29,23 +29,25 @@ BOOL CDBRecordKeyIsValid(CDBRecordKey* recordKey) {
}
void CDBRecordKeyInit(CDBRecordKey* recordKey, CDBDate epoch, int gameCode, u16 makerCode, int serialNumber, char* fileType, int unk) {
char typeStr[8];
char gcStr[8];
char mcStr[8];
struct {
char mcStr[4];
char typeStr[8];
char gcStr[8];
} strings;
u32 typeLength;
CDBConvMCValueToMCStr(makerCode, mcStr);
CDBConvGCValueToGCStr(gameCode, gcStr);
CDBConvMCValueToMCStr(makerCode, strings.mcStr);
CDBConvGCValueToGCStr(gameCode, strings.gcStr);
recordKey->wiiId = CDBGetWiiId();
recordKey->location = unk;
typeLength = strlen(typeStr);
strcpy(typeStr, fileType);
CDBToLower(typeStr, typeLength);
typeLength = strlen(fileType);
strcpy(strings.typeStr, fileType);
CDBToLower(((char*)strings.typeStr), typeLength);
sprintf(recordKey->keyString, "%010u_%s_%s_%03d.%s", epoch, gcStr, mcStr, serialNumber, typeStr);
sprintf(recordKey->keyString, "%010u_%s_%s_%03d.%s", epoch, strings.gcStr, strings.mcStr, serialNumber, strings.typeStr);
}
void CDBRecordKeySetSerialNumber(CDBRecordKey* recordKey, int serialNum) {
@@ -72,9 +74,8 @@ void CDBRecordKeyInitFromFileName2(CDBRecordKey* recordKey, char* keyString, cha
recordKey->location = CDB_FS_LOCATION_SD;
}
void CDBRecordKeyCopy(CDBRecordKey* recordKey, CDBRecordKey* newRecordKey) {
void CDBRecordKeyCopy(CDBRecordKey* recordKey, const CDBRecordKey* newRecordKey) {
strcpy(recordKey->keyString, newRecordKey->keyString);
recordKey->wiiId = newRecordKey->wiiId;
recordKey->location = newRecordKey->location;
}
@@ -136,6 +137,156 @@ CDBRecordKey* CDBRecordKeyArrayEnd(CDBRecordKeyArray* recordArray) {
return recordArray->records + recordArray->size;
}
#pragma dont_inline on
int CDBRecordKeyArrayDicInsertR(CDBRecordKeyArray* recordArray, CDBRecordKey* recordKey, int first, int last) {
int index;
int result;
if (first == last || first == last - 1) {
result = CDBRecordKeyCompare(recordKey, recordArray->records + first);
if (result < 0) {
return first;
}
result = CDBRecordKeyCompare(recordKey, recordArray->records + last);
if (result >= 0) {
last++;
}
return last;
}
index = first + (last - first) / 2;
result = CDBRecordKeyCompare(recordKey, recordArray->records + index);
if (result < 0) {
return CDBRecordKeyArrayDicInsertR(recordArray, recordKey, first, index);
}
if (result > 0) {
return CDBRecordKeyArrayDicInsertR(recordArray, recordKey, index, last);
}
return index;
}
CDBRecordKey* CDBRecordKeyArrayDicInsert(CDBRecordKeyArray* recordArray, CDBRecordKey* recordKey) {
int size = recordArray->size;
int index;
int moveCount;
CDBRecordKey* record;
if (size == 0) {
if (size < recordArray->capacity) {
record = recordArray->records + size;
CDBRecordKeyCopy(record, recordKey);
recordArray->size++;
}
return recordKey;
}
if (recordArray->capacity <= size) {
if (recordArray->reverse == 1) {
if (size != 0) {
record = recordArray->records + (size - 1);
} else {
record = recordArray->records;
}
if (CDBRecordKeyCompare(record, recordKey) < 0) {
return record;
}
recordArray->size--;
index = CDBRecordKeyArrayDicInsertR(recordArray, recordKey, 0, recordArray->size - 1);
moveCount = (recordArray->size - index) * sizeof(CDBRecordKey);
if (recordArray->capacity <= recordArray->size) {
moveCount -= sizeof(CDBRecordKey);
}
if (moveCount > 0) {
memmove((CDBRecordKey*)((char*)recordArray->records + (index + 1) * sizeof(CDBRecordKey)),
(CDBRecordKey*)((char*)recordArray->records + index * sizeof(CDBRecordKey)),
moveCount);
}
CDBRecordKeyCopy((CDBRecordKey*)((char*)recordArray->records + index * sizeof(CDBRecordKey)), recordKey);
if (recordArray->size < recordArray->capacity) {
recordArray->size++;
}
return (CDBRecordKey*)((char*)recordArray->records + index * sizeof(CDBRecordKey));
}
record = recordArray->records;
if (CDBRecordKeyCompare(recordKey, record) < 0) {
return record;
}
recordArray->size--;
if (recordArray->size >= 0 && recordArray->capacity - 1 >= 0) {
memmove(recordArray->records, recordArray->records + 1, recordArray->size * sizeof(CDBRecordKey));
}
index = CDBRecordKeyArrayDicInsertR(recordArray, recordKey, 0, recordArray->size - 1);
moveCount = (recordArray->size - index) * sizeof(CDBRecordKey);
if (recordArray->capacity <= recordArray->size) {
moveCount -= sizeof(CDBRecordKey);
}
if (moveCount > 0) {
memmove((CDBRecordKey*)((char*)recordArray->records + (index + 1) * sizeof(CDBRecordKey)),
(CDBRecordKey*)((char*)recordArray->records + index * sizeof(CDBRecordKey)),
moveCount);
}
CDBRecordKeyCopy((CDBRecordKey*)((char*)recordArray->records + index * sizeof(CDBRecordKey)), recordKey);
if (recordArray->size < recordArray->capacity) {
recordArray->size++;
}
return (CDBRecordKey*)((char*)recordArray->records + index * sizeof(CDBRecordKey));
}
index = CDBRecordKeyArrayDicInsertR(recordArray, recordKey, 0, size - 1);
moveCount = (recordArray->size - index) * sizeof(CDBRecordKey);
if (recordArray->capacity <= recordArray->size) {
moveCount -= sizeof(CDBRecordKey);
}
if (moveCount > 0) {
memmove((CDBRecordKey*)((char*)recordArray->records + (index + 1) * sizeof(CDBRecordKey)),
(CDBRecordKey*)((char*)recordArray->records + index * sizeof(CDBRecordKey)),
moveCount);
}
CDBRecordKeyCopy((CDBRecordKey*)((char*)recordArray->records + index * sizeof(CDBRecordKey)), recordKey);
if (recordArray->size < recordArray->capacity) {
recordArray->size++;
}
return (CDBRecordKey*)((char*)recordArray->records + index * sizeof(CDBRecordKey));
}
int CDBRecordKeyArrayDicFindR(CDBRecordKeyArray* recordArray, CDBRecordKey* recordKey, int first, int last) {
int index;
int result;
if (first == last || first == last - 1) {
result = CDBRecordKeyCompare(recordKey, recordArray->records + first);
if (result == 0) {
return first;
}
result = CDBRecordKeyCompare(recordKey, recordArray->records + last);
if (result != 0) {
return -1;
}
return last;
}
index = first + (last - first) / 2;
result = CDBRecordKeyCompare(recordKey, recordArray->records + index);
if (result < 0) {
return CDBRecordKeyArrayDicFindR(recordArray, recordKey, first, index);
}
if (result > 0) {
return CDBRecordKeyArrayDicFindR(recordArray, recordKey, index, last);
}
return index;
}
#pragma dont_inline reset
CDBRecordKey* CDBRecordKeyArrayDicFind(CDBRecordKeyArray* recordArray, CDBRecordKey* recordKey) {
int size = recordArray->size;
int index;

View File

@@ -9,19 +9,32 @@
#include <revolution/dvd.h>
#include <revolution/os.h>
typedef struct {
u32 used;
u8 padding[0xC00C];
u32 flags;
u32 unk;
} CDBDatabaseInstanceWork;
static OSMutex s_mutex;
static BOOL s_mutexInitialized = FALSE;
static BOOL s_fatalVFFlag = FALSE;
// This was likely a local originally, but oh well!
s32 CDBPrintDebugLevel = CDB_VERBOSE_LEVEL_NONE;
static u8 s_cdbWiiId[OSRoundUp32B(CDB_WIIID_DAT_SIZE)] ALIGN32;
static CDBDatabaseInstanceWork* s_databasePool;
static u8* s_recordPool;
u8* CDBDatabaseWorkBuf;
static VFErr s_lastVFError;
static s32 s_lastNANDError;
static u8 s_cdbWiiId[OSRoundUp32B(CDB_WIIID_DAT_SIZE)] ALIGN32;
static u8* s_recordPool;
extern void CDBDatabaseInstanceInit(void* instance, int flag, CDBDatabase* database);
extern BOOL CDBDatabaseInstanceIsUsed(void* instance);
extern void CDBRecordInstanceInit(void* instance, CDBRecord* record, int flag);
extern BOOL CDBRecordInstanceIsUsed(void* instance);
extern BOOL CDBRecordKeyCompare(CDBRecordKey* recordKey1, CDBRecordKey* recordKey2);
void MutexInitialized() {
s_mutexInitialized = TRUE;
@@ -35,6 +48,216 @@ void CDBUnlock() {
OSUnlockMutex(&s_mutex);
}
void CDBDatabaseInstancePoolInit(void* work) {
u32* workPointer = (u32*)work;
s_databasePool = (CDBDatabaseInstanceWork*)workPointer;
s_databasePool[0].used = 0;
s_databasePool[1].used = 0;
if (((u32)(workPointer + 0x7880) & 0x3f) != 0) {
CDBReportWarn("割り当てられた領域が64バイトアライメントされていません(%d)\n", (u64)((u32)(workPointer + 0x7880) & 0x3f));
}
CDBCryptBufSysInit((CDBCryptBuf*)(workPointer + 0x7880));
if (!s_mutexInitialized) {
OSInitMutex(&s_mutex);
}
CDBDatabaseWorkBuf = (u8*)workPointer + 0x19660;
}
void CDBRecordPoolInit(void* work) {
int i;
s_recordPool = (u8*)work + 0x18030;
for (i = 0; i < 5; i++) {
*(u32*)(s_recordPool + i * 0x470 + 0x18) = 0;
if (!s_mutexInitialized) {
OSInitMutex((OSMutex*)(s_recordPool + i * 0x470));
}
}
}
CDBErr CDBDatabaseAllocate(CDBDatabase* database, u32 flag) {
CDBDatabaseInstanceWork* databaseInstance;
CDBDatabaseInstanceWork* requestedInstance;
u32 writeFlag;
int i;
if (s_recordPool == NULL) {
OSPanic(__FILE__, 0x185, "(CDB) error : CDBInit() is not called\n");
}
OSLockMutex(&s_mutex);
requestedInstance = database->instance;
if (requestedInstance != NULL) {
for (i = 0, databaseInstance = s_databasePool; i < 2; i++, databaseInstance++) {
if (requestedInstance == databaseInstance) {
if (requestedInstance->flags == 0) {
CDBReportFatal("CDBDatabaseAllocate system error\n");
OSUnlockMutex(&s_mutex);
return CDB_ERROR_FATAL_ERROR;
}
CDBReportError("database descripter has opened already\n");
OSUnlockMutex(&s_mutex);
return 0x1c;
}
}
CDBReportError("database descripter is not initialized\n");
OSUnlockMutex(&s_mutex);
return 0x18;
}
writeFlag = flag & CDB_RECORD_ALLOC_WRITE;
for (i = 0, databaseInstance = s_databasePool; i < 2; i++, databaseInstance++) {
if (databaseInstance->used != 0) {
if ((databaseInstance->flags & CDB_RECORD_ALLOC_WRITE) != 0) {
CDBReportError("can't open the database as WRITE mode; another database discripter opened the database as WRITE mode\n");
OSUnlockMutex(&s_mutex);
return 0x19;
}
if (writeFlag != 0) {
CDBReportError("can't open the database as WRITE mode; other database discripter(s) opened the database as READ mode\n");
OSUnlockMutex(&s_mutex);
return 0x19;
}
}
}
for (i = 0; i < 2; i++) {
if (s_databasePool[i].used == 0) {
CDBDatabaseInstanceInit(s_databasePool + i, flag, database);
database->instance = s_databasePool + i;
OSUnlockMutex(&s_mutex);
return CDB_ERROR_OK;
}
}
CDBReportError("can't open databases any more\n");
OSUnlockMutex(&s_mutex);
return CDB_ERROR_CRYPT_ALLOC_FAIL;
}
CDBErr CDBDatabaseFree(CDBDatabase* database) {
int offset;
int i;
u32* databaseInstance = database->instance;
BOOL hasOpenRecord = FALSE;
if (databaseInstance == NULL) {
return 0x1b;
}
OSLockMutex(&s_mutex);
for (i = 0, offset = 0; i < 5; i++, offset += 0x470) {
if (CDBRecordInstanceIsUsed(s_recordPool + offset) &&
*(CDBDatabase**)(s_recordPool + offset + 0x468) == database) {
CDBReportError("can't close database; record %s is opened\n", s_recordPool + offset + 0x438);
hasOpenRecord = TRUE;
}
}
if (hasOpenRecord) {
OSUnlockMutex(&s_mutex);
return 0x21;
}
databaseInstance[0] = 0;
database->instance = NULL;
OSUnlockMutex(&s_mutex);
return CDB_ERROR_OK;
}
CDBErr CDBDatabaseCheckOpenDatabase() {
int i;
BOOL hasOpenDatabase = FALSE;
OSLockMutex(&s_mutex);
for (i = 0; i < 2; i++) {
if (CDBDatabaseInstanceIsUsed(s_databasePool + i)) {
CDBReportError("database is opened\n");
hasOpenDatabase = TRUE;
}
}
OSUnlockMutex(&s_mutex);
if (hasOpenDatabase) {
return 0x22;
}
return CDB_ERROR_OK;
}
CDBErr CDBDatabaseCheckOpenRecord() {
int offset;
int i;
BOOL hasOpenRecord = FALSE;
OSLockMutex(&s_mutex);
for (i = 0, offset = 0; i < 5; i++, offset += 0x470) {
if (CDBRecordInstanceIsUsed(s_recordPool + offset)) {
CDBReportError("record %s is opened\n", s_recordPool + offset + 0x438);
hasOpenRecord = TRUE;
}
}
OSUnlockMutex(&s_mutex);
if (hasOpenRecord) {
return 0x21;
}
return CDB_ERROR_OK;
}
char s_recordOnSDMessage[] = "record %s on SD is opened\n";
CDBErr CDBRecordAllocate(CDBRecord* record, int flag) {
int writeFlag;
int offset;
int i;
CDBDatabaseInstanceWork* databaseInstance = ((CDBDatabase*)*(CDBDatabase**)record)->instance;
OSLockMutex(&s_mutex);
if (databaseInstance == NULL) {
CDBReportError("can't open the record; database is closed\n");
OSUnlockMutex(&s_mutex);
return 0x1b;
}
if ((databaseInstance->flags & CDB_RECORD_ALLOC_WRITE) == 0 && (flag & CDB_RECORD_ALLOC_WRITE) != 0) {
CDBReportError("can't open the record as WRITE mode; database is readonly mode\n");
OSUnlockMutex(&s_mutex);
return 0x1a;
}
writeFlag = flag & CDB_RECORD_ALLOC_WRITE;
for (i = 0, offset = 0; i < 5; i++, offset += 0x470) {
if (CDBRecordInstanceIsUsed(s_recordPool + offset) &&
CDBRecordKeyCompare(&record->key, (CDBRecordKey*)(s_recordPool + offset + 0x438)) == FALSE &&
*(s32*)((u8*)record + 0x30) == *(s32*)(s_recordPool + offset + 0x460)) {
if ((*(u32*)(s_recordPool + offset + 0x1c) & CDB_RECORD_ALLOC_WRITE) != 0) {
CDBReportError("can't open the record as WRITE mode; another record discripter opened the record as WRITE mode\n");
OSUnlockMutex(&s_mutex);
return 0x19;
}
if (writeFlag != 0) {
CDBReportError("can't open the record as WRITE mode; other record discripter(s) opened the record as READ mode \n");
OSUnlockMutex(&s_mutex);
return 0x19;
}
}
}
for (i = 0; i < 5; i++) {
if (!CDBRecordInstanceIsUsed(s_recordPool + i * 0x470)) {
offset = i * 0x470;
CDBRecordInstanceInit(s_recordPool + offset, record, flag);
record->file = s_recordPool + offset;
OSUnlockMutex(&s_mutex);
return CDB_ERROR_OK;
}
}
CDBReportError("can't open record any more\n");
OSUnlockMutex(&s_mutex);
return CDB_ERROR_CRYPT_ALLOC_FAIL;
}
CDBErr CDBRecordFree(CDBRecord* record) {
CDBRecordFile* recordFile = record->file;
@@ -73,18 +296,6 @@ void CDBSetFatalVFErrorFlag() {
s_fatalVFFlag = TRUE;
}
void CDBRecordPoolInit(void* work) {
int i;
s_recordPool = (u8*)work + 0x18030;
for (i = 0; i < 5; i++) {
*(u32*)(s_recordPool + i * 0x470 + 0x18) = 0;
if (!s_mutexInitialized) {
OSInitMutex((OSMutex*)(s_recordPool + i * 0x470));
}
}
}
void CDBTryToCreate_wiiiddat(u8* data) {
NANDFileInfo fileInfo;
u32 nandCheck;
@@ -92,7 +303,7 @@ void CDBTryToCreate_wiiiddat(u8* data) {
// Requires 1 NAND block and 1 NAND node
s32 ret = NANDCheck(1, 1, &nandCheck);
if (ret != NAND_RESULT_OK) {
CDBReportError("failed NANDCheck\n");
CDBReportFatal("failed NANDCheck\n");
return;
}
@@ -327,6 +538,29 @@ void CDBCheckMakerCodeStr(char* makerCodeStr) {
}
}
BOOL CDBRecordBelongedDBOpenedAsRW(CDBRecord* record) {
int i;
CDBDatabaseInstanceWork* databaseInstance = NULL;
CDBDatabaseInstanceWork* databasePool;
if (record == NULL) {
return FALSE;
}
databasePool = s_databasePool;
for (i = 0; i < 2; i++) {
if (databasePool[i].used != 0 && (databasePool[i].flags & CDB_RECORD_ALLOC_WRITE) != 0) {
databaseInstance = databasePool + i;
break;
}
}
if (databaseInstance == NULL) {
return FALSE;
}
return TRUE;
}
static int s_vfSync = 1;
CDBErr CDBSetVFSyncMode(int sync) {

View File

@@ -0,0 +1,585 @@
#include <private/ipc.h>
#include <private/ios.h>
#include <private/nwc24/NWC24Schedule.h>
#include <revolution/ncd.h>
#include <revolution/os.h>
#include <string.h>
#define NCD_IPC_HEAP_SIZE 0x1B60
#define NCD_MAX_PROFILE 3
static NCDConfig* ncdCommonBuffer;
static u32 ncdInitialized;
struct NCDMutex {
OSMutex mutex;
u8 padding[8];
} ncdMutex;
s32 ncdCommonResult[8] ATTRIBUTE_ALIGN(32);
IOSIoVector ncdCommonVector[4] ATTRIBUTE_ALIGN(32);
const char* __NCDVersion = "<< RVL_SDK - NCD \trelease build: Dec 12 2008 03:06:03 (0x4199_60831) >>";
const char* __NCDUnofficialVersion = "<< RVL_SDK - NCD \trelease build: Dec 12 2008 03:06:03 (0x4199_60831) UNOFFICIAL >>";
static void LockRight(void);
static NCDErr ExecConfigCommand(const char* name, NCDConfig* config, u32 command);
NCDErr NCDiGetWirelessMacAddress(u8* macAddr);
NCDErr NCDReadConfig(NCDConfig* config) {
if (config == NULL) {
return -3;
}
return ExecConfigCommand("NCDReadConfig", config, 5);
}
NCDErr NCDWriteConfig(const NCDConfig* config) {
BOOL enabled;
enabled = OSDisableInterrupts();
if (!(ncdInitialized & 2)) {
OSRegisterVersion(__NCDUnofficialVersion);
ncdInitialized |= 2;
}
OSRestoreInterrupts(enabled);
if (config == NULL) {
return -3;
}
return ExecConfigCommand("NCDWriteConfig", (NCDConfig*)config, 6);
}
NCDErr NCDSetIfConfig(NCDIfConfig* ifConfig) {
union {
BOOL enabled;
NCDConfig* config;
} state;
NCDErr lockErr;
NCDProfile* profile;
NCDErr result;
s32 i;
u32 count;
state.enabled = OSDisableInterrupts();
if (!(ncdInitialized & 2)) {
OSRegisterVersion(__NCDUnofficialVersion);
ncdInitialized |= 2;
}
OSRestoreInterrupts(state.enabled);
if (ifConfig == NULL) {
return -3;
}
if (!OSGetCurrentThread()) {
return -5;
}
LockRight();
lockErr = NWC24iLockSocket();
if (lockErr == 0) {
result = ExecConfigCommand("NCDSetIfConfig", NULL, 3);
if (result == 0) {
state.config = ncdCommonBuffer;
if (ifConfig->selectedMedia != 1 && ifConfig->selectedMedia != 2) {
state.config->selectedMedia = 0;
} else {
state.config->selectedMedia = ifConfig->selectedMedia;
profile = state.config->profiles;
i = 0;
state.config->linkTimeout = ifConfig->linkTimeout;
count = 0;
for (; i < NCD_MAX_PROFILE; i++, profile++) {
if (state.config->profiles[i].flags & 0x80) {
switch (ifConfig->selectedMedia) {
case 1:
state.config->profiles[i].flags &= ~1;
memcpy(&profile->netif, &ifConfig->netif, 0x15c);
break;
case 2:
state.config->profiles[i].flags |= 1;
memcpy(&profile->netif, &ifConfig->netif, 4);
break;
}
count++;
}
}
if (count == 0) {
state.config->profiles[0].flags |= 0x80;
switch (ifConfig->selectedMedia) {
case 1:
state.config->profiles[0].flags &= ~1;
memcpy(&state.config->profiles[0].netif.wireless, &ifConfig->netif, 0x15c);
break;
case 2:
state.config->profiles[0].flags |= 1;
memcpy(&state.config->profiles[0].netif.wired, &ifConfig->netif, 4);
break;
}
memset(&state.config->profiles[0].adjust, 0, 0xc);
state.config->profiles[0].flags |= 6;
memset(&state.config->profiles[0].ip, 0, 0x14);
state.config->profiles[0].flags &= ~0x10;
memset(&state.config->profiles[0].proxy, 0, 0x79c);
}
}
result = ExecConfigCommand("NCDSetIfConfig", NULL, 4);
}
NWC24iUnlockSocket();
} else if (lockErr == -0x16) {
result = -4;
} else if (lockErr == -0x1d) {
result = -8;
} else {
result = -2;
}
OSUnlockMutex((OSMutex*)&ncdMutex);
return result;
}
NCDErr NCDSetIpConfig(NCDIpConfig* ipConfig) {
NCDErr err;
BOOL enabled;
s32 i;
u32 count;
NCDConfig* config;
enabled = OSDisableInterrupts();
if (!(ncdInitialized & 2)) {
OSRegisterVersion(__NCDUnofficialVersion);
ncdInitialized |= 2;
}
OSRestoreInterrupts(enabled);
if (ipConfig == NULL) {
return -3;
}
if (!OSGetCurrentThread()) {
return -5;
}
LockRight();
err = NWC24iLockSocket();
if (err == 0) {
err = ExecConfigCommand("NCDSetIpConfig", NULL, 3);
if (err == 0) {
i = 0;
count = 0;
config = ncdCommonBuffer;
for (; i < NCD_MAX_PROFILE; i++) {
if (config->profiles[i].flags & 0x80) {
NCDProfile* profile = &config->profiles[i];
memcpy(&profile->adjust, &ipConfig->adjust, 0xc);
if (ipConfig->useDhcp == 1) {
config->profiles[i].flags |= 6;
memcpy(&profile->ip, &ipConfig->ip, 0x14);
} else {
config->profiles[i].flags &= ~6;
memcpy(&profile->ip, &ipConfig->ip, 0x14);
}
if (ipConfig->useProxy == 1) {
config->profiles[i].flags |= 0x10;
memcpy(&profile->proxy, &ipConfig->proxy, 0x79c);
} else {
config->profiles[i].flags &= ~0x10;
memset(&profile->proxy, 0, 0x79c);
}
count++;
}
}
if (count == 0) {
NCDProfile* profile = config->profiles;
profile->flags |= 0x80;
memcpy(&profile->adjust, &ipConfig->adjust, 0xc);
if (ipConfig->useDhcp == 1) {
profile->flags |= 6;
memcpy(&profile->ip, &ipConfig->ip, 0x14);
} else {
profile->flags &= ~6;
memcpy(&profile->ip, &ipConfig->ip, 0x14);
}
if (ipConfig->useProxy == 1) {
profile->flags |= 0x10;
memcpy(&profile->proxy, &ipConfig->proxy, 0x79c);
} else {
profile->flags &= ~0x10;
memset(&profile->proxy, 0, 0x79c);
}
profile->flags = profile->flags & ~1;
memset(&profile->netif, 0, 0x15c);
}
err = ExecConfigCommand("NCDSetIpConfig", NULL, 4);
}
NWC24iUnlockSocket();
} else if (err == -0x16) {
err = -4;
} else if (err == -0x1d) {
err = -8;
} else {
err = -2;
}
OSUnlockMutex((OSMutex*)&ncdMutex);
return err;
}
NCDErr NCDGetCurrentIpConfig(NCDIpConfig* ipConfig) {
NCDErr err = 0;
NCDConfig* config;
s32 idx;
if (ipConfig == NULL) {
return -3;
}
LockRight();
err = ExecConfigCommand("NCDGetCurrentIpConfig", 0, 3);
if (err == 0) {
config = ncdCommonBuffer;
idx = ncdCommonResult[1];
if (idx < 0 || idx >= NCD_MAX_PROFILE) {
err = -7;
} else {
memcpy(&ipConfig->adjust, &config->profiles[idx].adjust, 0xc);
if (config->profiles[idx].flags & 0x6) {
ipConfig->useDhcp = TRUE;
memcpy(&ipConfig->ip, &config->profiles[idx].ip, 0x14);
} else {
ipConfig->useDhcp = FALSE;
memcpy(&ipConfig->ip, &config->profiles[idx].ip, 0x14);
}
if (config->profiles[idx].flags & 0x10) {
ipConfig->useProxy = TRUE;
memcpy(&ipConfig->proxy, &config->profiles[idx].proxy, 0x79c);
} else {
ipConfig->useProxy = FALSE;
memset(&ipConfig->proxy, 0, 0x79c);
}
}
}
OSUnlockMutex((OSMutex*)&ncdMutex);
return err;
}
NCDErr NCDGetLinkStatus(void) {
NCDErr err;
s32 fd;
if (!OSGetCurrentThread()) {
return -5;
}
LockRight();
fd = IOS_Open("/dev/net/ncd/manage", 0);
if (fd < 0) {
if (fd == -6) {
err = -8;
} else {
err = -2;
}
} else {
ncdCommonVector[0].base = (u8*)ncdCommonResult;
ncdCommonVector[0].length = sizeof(ncdCommonResult);
if (IOS_Ioctlv(fd, 7, 0, 1, ncdCommonVector) < 0) {
err = -2;
} else {
err = ncdCommonResult[0];
if (err == 0) {
err = ncdCommonResult[1];
err = err >= 0 ? err : -1;
}
}
if (IOS_Close(fd) < 0) {
err = -1;
}
}
OSUnlockMutex((OSMutex*)&ncdMutex);
return err;
}
BOOL NCDIsInterfaceDecided(void) {
NCDErr err = NCDGetLinkStatus();
switch (err) {
case 3:
case 4:
case 5:
return TRUE;
default:
return FALSE;
}
}
NCDErr NCDGetWirelessMacAddress(u8* macAddr) {
return NCDiGetWirelessMacAddress(macAddr);
}
NCDErr NCDiGetWirelessMacAddress(u8* macAddr) {
NCDErr err = 0;
s32 fd;
if (macAddr == NULL) {
return -3;
}
if (!OSGetCurrentThread()) {
return -5;
}
LockRight();
fd = IOS_Open("/dev/net/ncd/manage", 0);
if (fd < 0) {
if (fd == -6) {
err = -8;
} else {
err = -2;
}
} else {
ncdCommonVector[0].base = (u8*)ncdCommonResult;
ncdCommonVector[0].length = sizeof(ncdCommonResult);
ncdCommonVector[1].base = (u8*)ncdCommonBuffer;
ncdCommonVector[1].length = NCD_MAC_ADDRESS_LENGTH;
if (IOS_Ioctlv(fd, 8, 0, 2, ncdCommonVector) < 0) {
err = -2;
} else {
err = ncdCommonResult[0];
if (err == 0) {
memcpy(macAddr, ncdCommonBuffer, NCD_MAC_ADDRESS_LENGTH);
}
}
if (IOS_Close(fd) < 0) {
err = -1;
}
}
OSUnlockMutex((OSMutex*)&ncdMutex);
return err;
}
NCDErr NCDLockWirelessDriver(void) {
NCDErr err;
s32 fd;
if (!OSGetCurrentThread()) {
return -5;
}
LockRight();
fd = IOS_Open("/dev/net/ncd/manage", 0);
if (fd < 0) {
if (fd == -6) {
err = -8;
} else {
err = -2;
}
} else {
ncdCommonVector[0].base = (u8*)ncdCommonResult;
ncdCommonVector[0].length = sizeof(ncdCommonResult);
if (IOS_Ioctlv(fd, 1, 0, 1, ncdCommonVector) < 0) {
err = -2;
} else {
err = ncdCommonResult[0];
if (err == 0) {
err = ncdCommonResult[1];
err = err > 0 ? err : -1;
}
}
if (IOS_Close(fd) < 0) {
err = -1;
}
}
OSUnlockMutex((OSMutex*)&ncdMutex);
return err;
}
NCDErr NCDUnlockWirelessDriver(s32 id) {
NCDErr err;
s32 fd;
if (id <= 0) {
return -3;
}
if (!OSGetCurrentThread()) {
return -5;
}
LockRight();
fd = IOS_Open("/dev/net/ncd/manage", 0);
if (fd < 0) {
if (fd == -6) {
err = -8;
} else {
err = -2;
}
} else {
ncdCommonVector[0].base = (u8*)ncdCommonBuffer;
ncdCommonVector[0].length = 4;
ncdCommonVector[1].base = (u8*)ncdCommonResult;
ncdCommonVector[1].length = sizeof(ncdCommonResult);
ncdCommonBuffer->version = id;
if (IOS_Ioctlv(fd, 2, 1, 1, ncdCommonVector) < 0) {
err = -2;
} else {
err = ncdCommonResult[0];
}
if (IOS_Close(fd) < 0) {
err = -1;
}
}
OSUnlockMutex((OSMutex*)&ncdMutex);
return err;
}
s32 NCDRestoreConfig(void) {
NCDErr err;
if (!OSGetCurrentThread()) {
return -5;
}
LockRight();
err = NWC24iLockSocket();
if (err == 0) {
err = ExecConfigCommand("NCDRestoreConfig", NULL, 5);
if (err == 0) {
err = ExecConfigCommand("NCDRestoreConfig", NULL, 4);
}
NWC24iUnlockSocket();
} else if (err == -0x16) {
err = -4;
} else if (err == -0x1d) {
err = -8;
} else {
err = -2;
}
OSUnlockMutex((OSMutex*)&ncdMutex);
return err;
}
NCDErr NCDiGetEnabledConfigList(u32* list0, u32* list1, u32* list2) {
NCDErr err;
u32 mask0 = 0;
u32 mask1 = 0;
u32 mask2 = 0;
u8 flags;
u32 i;
LockRight();
err = ExecConfigCommand("NCDiGetEnabledConfigList", NULL, 3);
if (err == 0) {
for (i = 0; i < NCD_MAX_PROFILE; i++) {
NCDProfile* profile = &ncdCommonBuffer->profiles[i];
flags = profile->flags;
if (flags & 0x80) {
if (flags & 1) {
mask0 |= 1 << i;
} else {
if (profile->netif.wireless.configMethod != 1) {
mask1 |= 1 << i;
}
if (ncdCommonBuffer->profiles[i].netif.wireless.configMethod == 1) {
mask2 |= 1 << i;
}
}
}
}
}
OSUnlockMutex((OSMutex*)&ncdMutex);
if (list0 != NULL) {
*list0 = mask0;
}
if (list1 != NULL) {
*list1 = mask1;
}
if (list2 != NULL) {
*list2 = mask2;
}
return err;
}
static NCDErr ExecConfigCommand(const char* name, NCDConfig* config, u32 command) {
NCDErr err = 0;
s32 fd;
if (!OSGetCurrentThread()) {
return -5;
}
LockRight();
fd = IOS_Open("/dev/net/ncd/manage", 0);
if (fd < 0) {
if (fd == -6) {
err = -8;
} else {
err = -2;
}
} else {
ncdCommonVector[0].base = (u8*)ncdCommonBuffer;
ncdCommonVector[0].length = sizeof(NCDConfig);
ncdCommonVector[1].base = (u8*)ncdCommonResult;
ncdCommonVector[1].length = sizeof(ncdCommonResult);
switch (command) {
case 3:
case 5:
if (IOS_Ioctlv(fd, command, 0, 2, ncdCommonVector) < 0) {
err = -2;
} else {
err = ncdCommonResult[0];
if (err == 0 && config != NULL) {
memcpy(config, ncdCommonBuffer, sizeof(NCDConfig));
}
}
break;
case 4:
case 6:
if (config != NULL) {
memcpy(ncdCommonBuffer, config, sizeof(NCDConfig));
}
if (IOS_Ioctlv(fd, command, 1, 1, ncdCommonVector) < 0) {
err = -2;
} else {
err = ncdCommonResult[0];
}
break;
}
if (IOS_Close(fd) < 0) {
err = -1;
}
}
OSUnlockMutex((OSMutex*)&ncdMutex);
return err;
}
static void LockRight(void) {
BOOL enabled;
void* lo;
enabled = OSDisableInterrupts();
if (!(ncdInitialized & 1)) {
OSRegisterVersion(__NCDVersion);
OSInitMutex((OSMutex*)&ncdMutex);
lo = (void*)OSRoundUp32B(IPCGetBufferLo());
if ((u32)IPCGetBufferHi() - (u32)lo < NCD_IPC_HEAP_SIZE) {
OSPanic("ncdsystem.c", 0x5B1, "Could not reserve heap for NCD library from IPC arena");
}
IPCSetBufferLo((u8*)lo + NCD_IPC_HEAP_SIZE);
ncdCommonBuffer = (NCDConfig*)lo;
memset(ncdCommonBuffer, 0, NCD_IPC_HEAP_SIZE);
memset(ncdCommonResult, 0, sizeof(ncdCommonResult));
memset(ncdCommonVector, 0, sizeof(ncdCommonVector));
ncdInitialized |= 1;
}
OSRestoreInterrupts(enabled);
OSLockMutex((OSMutex*)&ncdMutex);
}

View File

@@ -18,10 +18,16 @@ enum {
#define FRIEND_LIST_MAGIC 'WcFl'
#define FRIEND_LIST_VERSION 2
static const char* FLFilePath = "/shared2/wc24/nwc24fl.bin";
const char lbl_8166E160[26] __attribute__((section(".data"), aligned(8))) = "/shared2/wc24/nwc24fl.bin";
void* const lbl_8166E160_pad __attribute__((section(".data"))) = (void*)0;
static const char* FLFilePath = lbl_8166E160;
const u32 FLFilePath_pad __attribute__((section(".sdata"), aligned(1))) = 0;
const char g_SpecialsChars[16] = { '(', ')', '<', '>', '[', ']', ':', ';', '\\', ',', '"' };
static NWC24Err GetCachedFLHeader(NWC24FLHeader** header);
static ChkHostNameError CheckHostName(const char* hostName, u32 hostNameLength);
static inline NWC24Err CheckFriendInfo(const NWC24FriendInfo* friendInfo);
static u32 GetUnkFlag(u32 index) {
NWC24Err result;
@@ -127,7 +133,7 @@ NWC24Err NWC24WriteFriendInfo(const NWC24FriendInfo* friendInfo, u32 index) {
return NWC24_ERR_ALIGNMENT;
}
result = NWC24CheckFriendInfo(friendInfo);
result = CheckFriendInfo(friendInfo);
if (result != NWC24_OK) {
return result;
}
@@ -219,63 +225,6 @@ NWC24Err NWC24WriteFriendInfo(const NWC24FriendInfo* friendInfo, u32 index) {
return result;
}
NWC24Err NWC24DeleteFriendInfo(u32 index) {
NWC24Err result;
NWC24Err resultWrite;
NWC24FLHeader* header;
NWC24FriendInfo* tmpFriendInfo;
NWC24File file;
u32 fileOffset;
if (!NWC24IsMsgLibOpened() && !NWC24IsMsgLibOpenedByTool()) {
return NWC24_ERR_LIB_NOT_OPENED;
}
result = GetCachedFLHeader(&header);
if (result != NWC24_OK) {
return result;
}
if (index >= header->infoCount) {
return NWC24_ERR_INVALID_VALUE;
}
if (header->friendIds[index] == 0) {
return NWC24_ERR_NULL;
}
tmpFriendInfo = (NWC24FriendInfo*)nwc24Work->mainWork;
Mail_memset(tmpFriendInfo, 0, sizeof(NWC24FriendInfo));
result = NWC24FOpen(&file, FLFilePath, NWC24_OPEN_RW);
if (result != NWC24_OK) {
return result;
}
fileOffset = (index * sizeof(NWC24FriendInfo)) + sizeof(NWC24FLHeader);
NWC24FSeek(&file, fileOffset, NWC24_SEEK_BEG);
resultWrite = NWC24FWrite(tmpFriendInfo, sizeof(NWC24FriendInfo), &file);
if (resultWrite == NWC24_OK) {
header->friendIds[index] = 0;
header->registeredCount--;
result = SetUnkFlag(index, 0);
if (result == NWC24_OK) {
NWC24FSeek(&file, 0, NWC24_SEEK_BEG);
resultWrite = NWC24FWrite(header, sizeof(NWC24FLHeader), &file);
}
}
result = NWC24FClose(&file);
if (resultWrite != NWC24_OK) {
result = resultWrite;
}
return result;
}
NWC24Err NWC24UpdateFriendInfo(const NWC24FriendInfo* friendInfo, u32 index) {
NWC24Err result;
NWC24Err resultFile;
@@ -296,7 +245,7 @@ NWC24Err NWC24UpdateFriendInfo(const NWC24FriendInfo* friendInfo, u32 index) {
return NWC24_ERR_ALIGNMENT;
}
result = NWC24CheckFriendInfo(friendInfo);
result = CheckFriendInfo(friendInfo);
if (result != NWC24_OK) {
return result;
}
@@ -358,6 +307,63 @@ out:
return result;
}
NWC24Err NWC24DeleteFriendInfo(u32 index) {
NWC24Err result;
NWC24Err resultWrite;
NWC24FLHeader* header;
NWC24FriendInfo* tmpFriendInfo;
NWC24File file;
u32 fileOffset;
if (!NWC24IsMsgLibOpened() && !NWC24IsMsgLibOpenedByTool()) {
return NWC24_ERR_LIB_NOT_OPENED;
}
result = GetCachedFLHeader(&header);
if (result != NWC24_OK) {
return result;
}
if (index >= header->infoCount) {
return NWC24_ERR_INVALID_VALUE;
}
if (header->friendIds[index] == 0) {
return NWC24_ERR_NULL;
}
tmpFriendInfo = (NWC24FriendInfo*)nwc24Work->mainWork;
Mail_memset(tmpFriendInfo, 0, sizeof(NWC24FriendInfo));
result = NWC24FOpen(&file, FLFilePath, NWC24_OPEN_RW);
if (result != NWC24_OK) {
return result;
}
fileOffset = (index * sizeof(NWC24FriendInfo)) + sizeof(NWC24FLHeader);
NWC24FSeek(&file, fileOffset, NWC24_SEEK_BEG);
resultWrite = NWC24FWrite(tmpFriendInfo, sizeof(NWC24FriendInfo), &file);
if (resultWrite == NWC24_OK) {
header->friendIds[index] = 0;
header->registeredCount--;
result = SetUnkFlag(index, 0);
if (result == NWC24_OK) {
NWC24FSeek(&file, 0, NWC24_SEEK_BEG);
resultWrite = NWC24FWrite(header, sizeof(NWC24FLHeader), &file);
}
}
result = NWC24FClose(&file);
if (resultWrite != NWC24_OK) {
result = resultWrite;
}
return result;
}
NWC24Err NWC24SwapFriendInfos(u32 index1, u32 index2) {
NWC24Err result;
NWC24Err resultFile;
@@ -476,8 +482,8 @@ NWC24Err NWC24SearchFriendInfoByAddr(const NWC24FriendAddr* addr, u32* index) {
NWC24Err result;
NWC24FLHeader* header;
NWC24FriendAddr* tmpFriendAddr;
NWC24FriendInfo* tmpFriendInfo;
int cmpResult;
u32 i;
@@ -498,10 +504,12 @@ NWC24Err NWC24SearchFriendInfoByAddr(const NWC24FriendAddr* addr, u32* index) {
}
tmpFriendInfo = (NWC24FriendInfo*)&nwc24Work->mainWork;
tmpFriendAddr = (NWC24FriendAddr*)&tmpFriendInfo->addr.mailAddr[sizeof(NWC24UserId)];
for (i = 0; i < header->infoCount; i++) {
if (friendValue == header->friendIds[i]) {
result = NWC24ReadFriendInfo(tmpFriendInfo, i);
result = NWC24ReadFriendInfo(
(NWC24FriendInfo*)((u8*)tmpFriendAddr - sizeof(NWC24FriendAttr) - sizeof(NWC24UserId)), i);
if (result != NWC24_OK) {
return result;
}
@@ -748,7 +756,7 @@ static NWC24Err GetCachedFLHeader(NWC24FLHeader** header) {
return NWC24_OK;
}
NWC24Err NWC24CheckFriendInfo(const NWC24FriendInfo* friendInfo) {
static inline NWC24Err CheckFriendInfo(const NWC24FriendInfo* friendInfo) {
NWC24Err result;
if (friendInfo == NULL) {
@@ -773,8 +781,6 @@ NWC24Err NWC24CheckPublicMailAddr(const char* addr) {
int len;
BOOL readingDomain;
static const char specials[] = { '(', ')', '<', '>', '[', ']', ':', ';', '\\', ',', '"' };
// Check parameters
if (addr == NULL) {
return NWC24_ERR_NULL;
@@ -810,8 +816,8 @@ NWC24Err NWC24CheckPublicMailAddr(const char* addr) {
}
// If the character is special, invalid!
for (j = 0; j < sizeof(specials); j++) {
if (ch == specials[j]) {
for (j = 0; j < 11; j++) {
if (ch == g_SpecialsChars[j]) {
return NWC24_ERR_FORMAT;
}
}

View File

@@ -382,28 +382,6 @@ NWC24Err NWC24GetMsgType(const NWC24MsgObj* msg, NWC24MsgType* type) {
return NWC24_OK;
}
NWC24Err NWC24GetMsgAppId(const NWC24MsgObj* msg, u32* appId) {
const NWC24MsgObjPrivate* msgObj = (const NWC24MsgObjPrivate*)msg;
*appId = msgObj->appId;
return NWC24_OK;
}
NWC24Err NWC24GetMsgGroupId(const NWC24MsgObj* msg, u16* groupId) {
const NWC24MsgObjPrivate* msgObj = (const NWC24MsgObjPrivate*)msg;
*groupId = msgObj->groupId;
return NWC24_OK;
}
NWC24Err NWC24GetMsgNumAttached(const NWC24MsgObj* msg, u32* numAttach) {
const NWC24MsgObjPrivate* msgObj = (const NWC24MsgObjPrivate*)msg;
u8 numAttached = msgObj->numAttached;
*numAttach = numAttached;
if (numAttached > NWC24_MSG_ATTACHMENT_MAX) {
return NWC24_ERR_BROKEN;
}
return NWC24_OK;
}
NWC24Err NWC24GetMsgSubjectSize(const NWC24MsgObj* msg, u32* subjectSize) {
const NWC24MsgObjPrivate* msgObj = (const NWC24MsgObjPrivate*)msg;
u32 size = msgObj->subject.size;
@@ -431,6 +409,16 @@ NWC24Err NWC24GetMsgTextSize(const NWC24MsgObj* msg, u32* textSize) {
return NWC24_OK;
}
NWC24Err NWC24GetMsgNumAttached(const NWC24MsgObj* msg, u32* numAttach) {
const NWC24MsgObjPrivate* msgObj = (const NWC24MsgObjPrivate*)msg;
u8 numAttached = msgObj->numAttached;
*numAttach = numAttached;
if (numAttached > NWC24_MSG_ATTACHMENT_MAX) {
return NWC24_ERR_BROKEN;
}
return NWC24_OK;
}
NWC24Err NWC24GetMsgAttachedSize(const NWC24MsgObj* msg, u32 attachIndex, u32* attachSize) {
const NWC24MsgObjPrivate* msgObj = (const NWC24MsgObjPrivate*)msg;
@@ -463,6 +451,18 @@ NWC24Err NWC24GetMsgAttachedType(const NWC24MsgObj* msg, u32 attachIndex, NWC24M
return NWC24_OK;
}
NWC24Err NWC24GetMsgAppId(const NWC24MsgObj* msg, u32* appId) {
const NWC24MsgObjPrivate* msgObj = (const NWC24MsgObjPrivate*)msg;
*appId = msgObj->appId;
return NWC24_OK;
}
NWC24Err NWC24GetMsgGroupId(const NWC24MsgObj* msg, u16* groupId) {
const NWC24MsgObjPrivate* msgObj = (const NWC24MsgObjPrivate*)msg;
*groupId = msgObj->groupId;
return NWC24_OK;
}
NWC24Err NWC24GetMsgFromId(const NWC24MsgObj* msg, NWC24UserId* fromId) {
const NWC24MsgObjPrivate* msgObj = (const NWC24MsgObjPrivate*)msg;

View File

@@ -3,48 +3,91 @@
#include <ctype.h>
char* Mail_strcpy(char* dest, const char* src) {
char* pDest;
char cSrc;
for (pDest = dest; *src != 0; pDest++) {
cSrc = *src++;
*pDest = cSrc;
char* Mail_strcpy(char* pDst, const char* pSrc) {
char* pOrigin = pDst;
while (*pSrc != '\0') {
*pDst++ = *pSrc++;
}
*pDest = 0;
return dest;
*pDst = '\0';
return pOrigin;
}
int Mail_strlen(const char* str) {
int i;
for (i = 0; *str != 0; i++, str++) {
int Mail_strlen(const char* pStr) {
int len = 0;
while (pStr[len] != '\0') {
len++;
}
return i;
return len;
}
char* Mail_strcat(char* dest, const char* src) {
int i;
char* pDest;
int STD_strnlen(const char* pStr, size_t maxlen) {
size_t len = 0;
pDest = dest;
for (i = 0; *pDest != 0; pDest++, i++) {
}
pDest = dest + i;
while (*src != 0) {
*pDest++ = *src++;
}
*pDest = 0;
return dest;
}
int STD_strnlen(const char* str, u32 len) {
int i;
for (i = 0; i < len; i++, str++) {
if (*str == 0) {
for (; len < maxlen; len++) {
if (pStr[len] == '\0') {
break;
}
}
return i;
return len;
}
void* Mail_memcpy(void* pDst, const void* pSrc, u32 n) {
size_t i;
for (i = 0; i < n; i++) {
((u8*)pDst)[i] = ((u8*)pSrc)[i];
}
return pDst;
}
void* Mail_memset(void* pDst, int ch, u32 n) {
size_t i;
for (i = 0; i < n; i++) {
((u8*)pDst)[i] = ch;
}
return pDst;
}
char* Mail_strncpy(char* dest, const char* src, u32 len) {
u32 i;
i = 0;
for (; i < len; i++) {
dest[i] = src[i];
if (src[i] == 0) {
while (++i < len) {
dest[i] = 0;
}
return dest;
}
}
return dest;
}
char* Mail_strcat(char* pDst, const char* pSrc) {
Mail_strcpy(pDst + Mail_strlen(pDst), pSrc);
return pDst;
}
char* Mail_strncat(char* pDst, const char* pSrc, u32 maxlen) {
int len = Mail_strlen(pDst);
int i;
for (i = 0; i < maxlen && pSrc[i] != '\0'; i++) {
pDst[len + i] = pSrc[i];
}
pDst[len + i] = '\0';
return pDst;
}
int Mail_strncmp(const char* str1, const char* str2, u32 len) {
@@ -98,3 +141,271 @@ int Mail_tolower(int ch) {
}
return ch;
}
static void set_to_head(char* pStr, char ch) {
int i;
for (i = Mail_strlen(pStr); i >= 0; i--) {
pStr[i + 1] = pStr[i];
}
*pStr = ch;
}
static void set_to_tail(char* pStr, char ch) {
int i = Mail_strlen(pStr);
pStr[i++] = ch;
pStr[i] = '\0';
}
static s32 convNum(char* pDst, u32 number, s32 numberBase, char charBase,
BOOL isSigned, s32 width, char specifierChar,
char justifyChar) {
s32 charsWritten;
s32 digitsWritten;
char remainder;
if (isSigned && (number & 0x80000000)) {
isSigned = TRUE;
number = -number;
} else {
isSigned = FALSE;
number = number;
}
charsWritten = digitsWritten = 0;
while (number != 0) {
remainder = number % numberBase;
number /= numberBase;
set_to_head(pDst, remainder + (char)(remainder > 9 ? charBase : '0'));
digitsWritten++;
charsWritten++;
}
if (*pDst == '\0') {
set_to_head(pDst, '0');
digitsWritten++;
charsWritten++;
}
if (specifierChar != '0') {
specifierChar = ' ';
}
digitsWritten += isSigned;
while (digitsWritten < width) {
if (justifyChar == 'L') {
set_to_tail(pDst, ' ');
charsWritten++;
} else {
set_to_head(pDst, specifierChar);
charsWritten++;
}
digitsWritten++;
}
if (isSigned) {
set_to_head(pDst, '-');
}
return charsWritten;
}
int Mail_sprintf(char* pDst, char* pFmt, ...) {
va_list argv;
int ret;
va_start(argv, pFmt);
ret = Mail_vsprintf(pDst, pFmt, &argv);
va_end(argv);
return ret;
}
int Mail_vsprintf(char* pDst, char* pFmt, va_list* argv) {
int charsWritten;
BOOL isNumberFormat;
BOOL isSigned;
s32 stringLength;
s32 numberBase;
s32 width;
char formatChar;
char justifyChar;
char specifierChar;
char charBase;
char* pStrArg;
char longFlag;
u32 number;
*pDst = 0;
charsWritten = 0;
while ((formatChar = *pFmt++) != '\0') {
while (*pDst != '\0') {
pDst++;
}
if (formatChar == '%') {
formatChar = *pFmt++;
if (formatChar == '%') {
set_to_tail(pDst++, formatChar);
charsWritten++;
} else {
justifyChar = formatChar;
if (formatChar == '-') {
formatChar = *pFmt++;
}
specifierChar = formatChar;
isSigned = FALSE;
numberBase = 10;
charBase = '0';
isNumberFormat = FALSE;
if (formatChar == '*') {
width = va_arg(*argv, s32);
formatChar = *pFmt++;
} else {
width = 0;
while (formatChar >= '0' && formatChar <= '9') {
width = width * 10 + formatChar - '0';
formatChar = *pFmt++;
}
}
if ((longFlag = formatChar & (u8)~0x20) == 'L') {
formatChar = *pFmt++;
}
switch (formatChar) {
case 'd': {
isNumberFormat = TRUE;
isSigned = TRUE;
break;
}
case 'o': {
isNumberFormat = TRUE;
numberBase = 8;
break;
}
case 'u': {
isNumberFormat = TRUE;
break;
}
case 'x': {
isNumberFormat = TRUE;
numberBase = 16;
charBase = 'a' - 10;
break;
}
case 'X': {
isNumberFormat = TRUE;
numberBase = 16;
charBase = 'A' - 10;
break;
}
case 'c': {
formatChar = va_arg(*argv, s32);
set_to_tail(pDst++, formatChar);
charsWritten++;
break;
}
case 's': {
pStrArg = va_arg(*argv, char*);
if (pStrArg) {
stringLength = Mail_strlen(pStrArg);
Mail_strcat(pDst, pStrArg);
} else {
stringLength = 0;
}
charsWritten += stringLength;
while (stringLength < width) {
charsWritten++;
if (justifyChar == '-') {
set_to_tail(pDst, ' ');
} else {
set_to_head(pDst, ' ');
}
stringLength++;
}
break;
}
}
if (isNumberFormat) {
if (longFlag == 'L') {
number = va_arg(*argv, u32);
} else if (isSigned) {
number = va_arg(*argv, s32);
} else {
number = va_arg(*argv, u32);
}
charsWritten +=
convNum(pDst, number, numberBase, charBase, isSigned,
width, specifierChar, justifyChar);
}
}
} else {
set_to_tail(pDst++, formatChar);
charsWritten++;
}
}
return charsWritten;
}
int Mail_strnicmp(const char* str1, const char* str2, int len) {
int i;
int c2;
int c1;
int result;
result = 0;
for (i = 0; i < len; i++) {
c1 = *str1;
c2 = *str2;
if (c1 >= 'A') {
if (c1 <= 'Z') {
c1 += 0x20;
}
}
if (c2 >= 'A') {
if (c2 <= 'Z') {
c2 += 0x20;
}
}
result = c1 - c2;
if (result != 0) {
break;
}
if (c2 == 0) {
break;
}
str2++;
str1++;
}
return result;
}

View File

@@ -1,21 +1,79 @@
#include <private/nwc24.h>
#include <revolution/nwc24.h>
const u8 TtableInv[] = {13, 5, 9, 7, 0, 15, 10, 2, 12, 3, 14, 1, 8, 6, 11, 4};
const u8 ExcTable[] = {1, 5, 0, 4, 2, 3, 6, 7};
static const u8 TtableInv[] = {13, 5, 9, 7, 0, 15, 10, 2, 12, 3, 14, 1, 8, 6, 11, 4};
extern void _savegpr_27(void);
extern void _restgpr_27(void);
extern void __shr2u(void);
extern void __shl2i(void);
static u8 getbyte(NWC24UserId value, u8 index);
static NWC24UserId setbyte(NWC24UserId value, u8 index, u8 set);
NWC24UserId getUnScrambleId(NWC24UserId id);
static int checkCRC(NWC24UserId id);
static u8 getbyte(NWC24UserId value, u8 index) {
return (value >> (index * 8)) & 0xFF;
}
static NWC24UserId setbyte(NWC24UserId value, u8 index, u8 set) {
return (value & ~(((u64)0xFF << (index * 8)))) | (((u64)set << (index * 8)));
static NWC24UserId getUnScrambleId(NWC24UserId id);
asm NWC24Err NWC24CheckUserId(register NWC24UserId id) {
stwu r1,-0x30(r1)
mfspr r0,LR
stw r0,0x34(r1)
addi r11,r1,0x30
bl _savegpr_27
or r28,r3,r3
or r27,r4,r4
addi r3,r1,0x8
bl NWC24GetMyUserId
lwz r3,0x8(r1)
lwz r4,0xc(r1)
xor r0,r3,r28
xor r5,r4,r27
or. r0,r5,r0
bne NWC24CheckUserId_not_same
li r3,-0x23
b NWC24CheckUserId_return
NWC24CheckUserId_not_same:
bl getUnScrambleId
or r4,r27,r27
rlwinm r27,r3,0x11,0x1d,0x1f
or r3,r28,r28
bl getUnScrambleId
or r30,r4,r4
or r31,r3,r3
rlwinm r28,r3,0x11,0x1d,0x1f
li r29,0
NWC24CheckUserId_crc_loop:
addi r0,r29,1
or r3,r31,r31
or r4,r30,r30
subfic r5,r0,0x35
bl __shr2u
rlwinm. r0,r4,0,0x1f,0x1f
beq NWC24CheckUserId_crc_next
subfic r5,r29,0x2a
li r4,0x635
li r3,0
bl __shl2i
xor r30,r30,r4
xor r31,r31,r3
NWC24CheckUserId_crc_next:
addi r29,r29,1
cmpwi r29,0x2b
blt NWC24CheckUserId_crc_loop
or. r0,r30,r31
beq NWC24CheckUserId_crc_ok
li r3,-0x25
b NWC24CheckUserId_return
NWC24CheckUserId_crc_ok:
cmpwi r27,0
bne NWC24CheckUserId_return_ok
cmpwi r28,0
beq NWC24CheckUserId_return_ok
li r3,-0x7
b NWC24CheckUserId_return
NWC24CheckUserId_return_ok:
li r3,0
NWC24CheckUserId_return:
addi r11,r1,0x30
bl _restgpr_27
lwz r0,0x34(r1)
mtspr LR,r0
addi r1,r1,0x30
blr
}
NWC24Err NWC24iCheckUserIdCRC(NWC24UserId id) {
@@ -33,3 +91,167 @@ NWC24Err NWC24iCheckUserIdCRC(NWC24UserId id) {
}
return NWC24_OK;
}
static asm NWC24UserId getUnScrambleId(register NWC24UserId id) {
li r9,-1
lis r7,0x20
lis r6,0x5e5e
stwu r1,-0x20(r1)
subi r7,r7,1
and r8,r4,r9
addi r0,r6,0x5e5e
stw r31,0x1c(r1)
and r3,r3,r7
lis r5,-1
xor r8,r8,r0
stw r30,0x18(r1)
and r8,r8,r9
xori r3,r3,0x5e5e
rlwinm r0,r8,0x15,0xa,0xa
li r6,-0x100
and r3,r3,r7
rlwinm r8,r8,0x1f,0,0x1f
or r3,r3,r0
stw r29,0x14(r1)
rlwimi r8,r3,0x1f,0,0
lis r4,-0xff
rlwinm r7,r3,0x1f,1,0x1f
addi r5,r5,0xff
rlwinm r30,r8,0x18,0,0x1f
rlwinm r29,r3,0x17,0x18,0x1f
and r12,r7,r9
li r0,0
rlwimi r30,r3,0x17,0,7
and r31,r8,r6
rlwimi r31,r30,0,0x18,0x1f
rlwinm r11,r3,0x1f,0x10,0x17
and r30,r31,r5
and r12,r12,r9
rlwimi r0,r29,8,0x18,0x1f
subi r4,r4,1
or r12,r12,r0
or r11,r30,r11
and r30,r11,r4
rlwinm r31,r8,0,0x18,0x1f
li r0,0
rlwinm r11,r8,0x10,8,0xf
lis r10,0x100
and r12,r12,r9
rlwimi r0,r31,0x10,0x10,0x1f
or r30,r30,r11
or r29,r12,r0
rlwinm r12,r3,0x1f,0x18,0x1f
subi r0,r10,1
li r10,0
rlwimi r10,r12,0x18,8,0x1f
and r11,r29,r9
and r12,r30,r0
rlwinm r3,r3,0x17,0,7
or r3,r12,r3
or r12,r11,r10
and r10,r3,r9
lis r3,TtableInv@ha
and r31,r10,r9
rlwinm r30,r8,0x10,0,0x1f
rlwinm r11,r31,0x1c,0x1c,0x1f
addi r3,r3,TtableInv@l
rlwimi r30,r7,0x10,0,0xf
rlwinm r10,r31,0,0x1c,0x1f
and r29,r12,r6
rlwinm r12,r8,8,0,0x1f
lbzx r11,r3,r11
rlwimi r12,r7,8,0,0x17
lbzx r7,r3,r10
rlwimi r29,r30,0,0x18,0x1f
rlwinm r8,r11,4,0,0x1b
rlwinm r10,r12,8,0x10,0x17
and r11,r29,r5
or r10,r11,r10
or r7,r8,r7
and r11,r31,r6
li r8,0
rlwimi r11,r7,0,0x18,0x1f
and r12,r10,r9
rlwinm r10,r11,0x18,0,0x1f
li r7,0
rlwimi r10,r12,0x18,0,7
and r31,r11,r5
rlwinm r11,r10,0x1c,0x1c,0x1f
and r12,r12,r9
rlwinm r10,r10,0,0x1c,0x1f
lbzx r11,r3,r11
lbzx r10,r3,r10
rlwinm r11,r11,4,0,0x1b
or r10,r11,r10
rlwinm r11,r10,0,0x18,0x1f
rlwinm r10,r10,8,0x10,0x17
rlwimi r8,r11,8,0x18,0x1f
or r10,r31,r10
or r8,r12,r8
rlwinm r12,r10,0x10,0,0x1f
and r11,r10,r4
rlwimi r12,r8,0x10,0,0xf
and r10,r8,r9
rlwinm r8,r12,0x1c,0x1c,0x1f
rlwinm r4,r12,0,0x1c,0x1f
lbzx r8,r3,r8
lbzx r4,r3,r4
rlwinm r8,r8,4,0,0x1b
or r4,r8,r4
rlwinm r8,r4,0,0x18,0x1f
rlwinm r4,r4,0x10,8,0xf
or r29,r11,r4
rlwimi r7,r8,0x10,0x10,0x1f
or r11,r10,r7
lis r4,1
rlwinm r8,r29,8,0,0x1f
and r31,r29,r0
rlwimi r8,r11,8,0,0x17
and r12,r11,r9
rlwinm r10,r8,0x1c,0x1c,0x1f
subi r0,r4,0x4c4d
lbzx r11,r3,r10
rlwinm r8,r8,0,0x1c,0x1f
lbzx r10,r3,r8
li r8,0
rlwinm r11,r11,4,0,0x1b
lis r7,-0x4c4c
or r11,r11,r10
rlwinm r10,r11,0,0x18,0x1f
subi r7,r7,0x4c4d
rlwimi r8,r10,0x18,8,0x1f
rlwinm r4,r11,0x18,0,7
or r10,r12,r8
rlwinm r8,r10,0x1c,0x1c,0x1f
or r12,r31,r4
rlwinm r4,r10,0,0x1c,0x1f
lbzx r8,r3,r8
and r11,r10,r6
lbzx r4,r3,r4
rlwinm r6,r8,4,0,0x1b
and r8,r12,r9
or r4,r6,r4
rlwimi r11,r4,0,0x18,0x1f
and r10,r8,r9
rlwinm r6,r11,0x14,0x1c,0x1f
rlwinm r4,r11,0x18,0x1c,0x1f
lbzx r6,r3,r6
lbzx r3,r3,r4
and r8,r11,r5
rlwinm r5,r6,4,0,0x1b
and r4,r10,r9
or r3,r5,r3
rlwinm r3,r3,8,0x10,0x17
or r3,r8,r3
rlwinm r5,r3,0xa,0xb,0x15
rlwinm r3,r3,0x15,0x16,0x1f
rlwimi r5,r4,0xa,0x16,0x1f
rlwimi r3,r4,0xa,0,0x15
xor r4,r3,r7
xor r3,r5,r0
lwz r31,0x1c(r1)
lwz r30,0x18(r1)
lwz r29,0x14(r1)
addi r1,r1,0x20
blr
}

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