From 9649319ec4926457ef85e6094f8207474c977c2d Mon Sep 17 00:00:00 2001 From: Luke Street Date: Sun, 1 Mar 2026 15:35:36 -0700 Subject: Reorganize library code into `libs/` (#3119) * Reorganize files into libs/{dolphin,JSystem,PowerPC_EABI_Support,revolution,TRK_MINNOW_DOLPHIN} * Update configure.py and project.py for new libs structure * Refactor `#include ` -> `` * Remove `__REVOLUTION_SDK__` forwards from dolphin * Fix dolphin/ references in revolution * Wrap `#include ` in `!__REVOLUTION_SDK__` * Always build TRK against dolphin headers * Resolve revolution SDK header resolution issues --- libs/JSystem/src/JMessage/processor.cpp | 662 ++++++++++++++++++++++++++++++++ 1 file changed, 662 insertions(+) create mode 100644 libs/JSystem/src/JMessage/processor.cpp (limited to 'libs/JSystem/src/JMessage/processor.cpp') diff --git a/libs/JSystem/src/JMessage/processor.cpp b/libs/JSystem/src/JMessage/processor.cpp new file mode 100644 index 0000000000..eef50e7516 --- /dev/null +++ b/libs/JSystem/src/JMessage/processor.cpp @@ -0,0 +1,662 @@ +#include "JSystem/JSystem.h" // IWYU pragma: keep + +#include "JSystem/JMessage/processor.h" +#include "JSystem/JMessage/control.h" +#include "JSystem/JUtility/JUTAssert.h" +#include + +JMessage::TReference::~TReference() {} + +const char* JMessage::TReference::do_word(u32 param_0) const { + return NULL; +} + +JMessage::TProcessor::~TProcessor() {} + +void JMessage::TProcessor::reset() { + on_resetStatus_(NULL); + do_reset(); +} + +void JMessage::TProcessor::stack_pushCurrent(char const* pszText) { + if (pszText != NULL) { + if (!oStack_.IsPushable()) { + JGADGET_WARNMSG(113, "stack full"); + return; + } + + stack_pushCurrent_(pszText); + } +} + +void JMessage::TProcessor::stack_popCurrent() { + JGADGET_ASSERTWARN(122, !oStack_.empty()); + stack_popCurrent_(); +} + +const JMessage::TResource* JMessage::TProcessor::getResource_groupID(u16 u16GroupID) const { + if (isResourceCache_groupID(u16GroupID)) { + return pResourceCache_; + } + + pResourceCache_ = getResource_groupID_uncached(u16GroupID); + return pResourceCache_; +} + +u32 JMessage::TProcessor::toMessageCode_messageID(u32 uMsgID, u32 param_1, bool* pbValid) const { + const TResource* pResourceCache = (const TResource*)getResourceCache(); + if (pResourceCache != NULL) { + u16 u16Index = pResourceCache->toMessageIndex_messageID(uMsgID, param_1, pbValid); + if (u16Index != 0xFFFF) { + return u16Index | (pResourceCache->getGroupID() << 16); + } + } + + TResourceContainer* pResourceContainer = getResourceContainer(); + if (pResourceContainer == NULL) { + return 0xFFFFFFFF; + } + + JGadget::TContainerEnumerator_const enumerator(pResourceContainer->getResourceContainer()); + const TResource* pResource; + while (enumerator) { + pResource = (const TResource*)&(*enumerator); + if (pResource != pResourceCache) { + u16 u16Index = pResource->toMessageIndex_messageID(uMsgID, param_1, pbValid); + if (u16Index != 0xFFFF) { + ((JMessage::TProcessor*)this)->pResourceCache_ = pResource; + return u16Index | (pResource->getGroupID() << 16); + } + } + } + + return 0xFFFFFFFF; +} + +void JMessage::TProcessor::on_select_begin(char const* (*pfn)(JMessage::TProcessor*), + void const* pOffset, char const* pcBase, u32 uNumber) { + JUT_ASSERT(191, uNumber>0); + + if (!stack_isPushable()) { + JGADGET_WARNMSG(194, "stack full"); + } else { + oProcess_.reset_select(); + + oProcess_.rData.pfn = pfn; + oProcess_.rData.pcBase = pcBase; + oProcess_.rData.pOffset = pOffset; + oProcess_.rData.uRest = uNumber; + + JUT_ASSERT(205, pfn!=NULL); + const char* psz = pfn(this); + JUT_ASSERT(207, psz!=NULL); + + stack_pushCurrent_(psz); + do_select_begin(uNumber); + } +} + +void JMessage::TProcessor::on_select_end() { + TProcess_::rdata& rData = oProcess_.rData; + JUT_ASSERT(219, rData.uRest==0); + oProcess_.reset_normal(); + + JUT_ASSERT(223, stack_isPushable()); + stack_popCurrent_(); + do_select_end(); +} + +void JMessage::TProcessor::on_select_separate() { + stack_popCurrent_(); + JUT_ASSERT(234, stack_isPushable()); + + TProcess_::rdata& rData = oProcess_.rData; + JUT_ASSERT(237, rData.uRest>0); + + const char* (*pfn)(TProcessor*) = rData.pfn; + JUT_ASSERT(240, pfn!=NULL); + + const char* psz = pfn(this); + JUT_ASSERT(242, psz!=NULL); + + stack_pushCurrent_(psz); + do_select_separate(); +} + +void JMessage::TProcessor::do_reset() {} + +void JMessage::TProcessor::do_begin(void const* pEntry, char const* pszText) {} + +void JMessage::TProcessor::do_end() {} + +void JMessage::TProcessor::do_character(int iCharacter) {} + +bool JMessage::TProcessor::do_tag(u32 uTag, void const* pData, u32 uSize) { + return false; +} + +void JMessage::TProcessor::do_select_begin(u32 uNumber) {} + +void JMessage::TProcessor::do_select_end() {} + +void JMessage::TProcessor::do_select_separate() {} + +void JMessage::TProcessor::on_tag_() { + u32 uSize; + char* psz = (char*)getCurrent(); + JUT_ASSERT(292, psz!=NULL); + JUT_ASSERT(293, psz[-1]==data::gcTagBegin); + + uSize = *(u8*)psz; + pszCurrent_ = uSize + psz - 1; + + psz++; + + u32 uTag = *(u8*)psz & 0xFF; + psz++; + + uTag <<= 8; + uTag |= *(u8*)psz & 0xFF; + psz++; + + uTag <<= 8; + uTag |= *(u8*)psz & 0xFF; + psz++; + + on_tag(uTag, psz, uSize - 5); +} + +void JMessage::TProcessor::do_resetStatus_(char const* pszText) {} + +bool JMessage::TProcessor::do_setBegin_isReady_() const { + return true; +} + +void JMessage::TProcessor::do_tag_(u32 uTag, void const* pData, u32 uSize) { + u8 uGroupID = data::getTagGroup(uTag); + unsigned int uCode = data::getTagCode(uTag); + + switch (uGroupID) { + case 0xFF: + switch (uCode & 0xFFFF) { + case 4: + JUT_ASSERT(331, uSize==4); + stack_pushCurrent(on_word(JGadget::binary::TParseValue >::parse(pData))); + break; + case 5: + JUT_ASSERT(341, uSize==4); + stack_pushCurrent(on_message(JGadget::binary::TParseValue >::parse(pData))); + break; + default: + JGADGET_WARNMSG1(351, "unknown system-tag-code : ", uCode & 0xFFFF); + } + break; + case 0xFE: + JUT_ASSERT(356, uSize==0); + stack_pushCurrent(on_word(uCode & 0xFFFF)); + break; + case 0xFD: + JUT_ASSERT(361, uSize==0); + stack_pushCurrent(on_message_limited(uCode)); + break; + case 0xF6: { + u32 uNumber = uCode & 0xFFFF; + JUT_ASSERT(368, uSize==4*uNumber); + on_select_begin(process_onSelect_limited_, pData, (char*)pData + uSize, uCode); + break; + } + case 0xF5: + u32 uNumber = uCode & 0xFFFF; + JUT_ASSERT(377, uSize==4*uNumber); + on_select_begin(process_onSelect_, pData, (char*)pData + uSize, uCode); + break; + } + + JGADGET_WARNMSG4(387, "unknown tag-value : [", (unsigned int)uGroupID, "-", uCode & 0xFFFF, ']'); +} + +bool JMessage::TProcessor::process_character_() { + JUT_ASSERT(397, pszCurrent_!=NULL); + int iCharacter = on_parseCharacter(&pszCurrent_); + + switch (iCharacter) { + case 0: + if (!oProcess_.pfnProcess_onCharacterEnd(this)) { + return false; + } + break; + case data::gcTagBegin: + on_tag_(); + break; + default: + on_character(iCharacter); + } + + return true; +} + +bool JMessage::TProcessor::process_onCharacterEnd_normal_(JMessage::TProcessor* pThis) { + JUT_ASSERT(420, pThis->oProcess_.pfnProcess_onCharacterEnd== &process_onCharacterEnd_normal_); + + if (!pThis->oStack_.empty()) { + pThis->stack_popCurrent(); + return true; + } + + pThis->on_end(); + return false; +} + +bool JMessage::TProcessor::process_onCharacterEnd_select_(JMessage::TProcessor* pThis) { + JUT_ASSERT(435, pThis->oProcess_.pfnProcess_onCharacterEnd== &process_onCharacterEnd_select_); + JUT_ASSERT(436, !pThis->oStack_.empty()); + + TProcess_::rdata& rData = pThis->oProcess_.rData; + rData.uRest--; + + u32 uRest = rData.uRest; + if (uRest != 0) { + pThis->on_select_separate(); + return true; + } + + pThis->on_select_end(); + return true; +} + +const char* JMessage::TProcessor::process_onSelect_limited_(JMessage::TProcessor* pThis) { + TProcess_::rdata& rData = pThis->oProcess_.rData; + JUT_ASSERT(454, rData.pfn==&process_onSelect_limited_); + JUT_ASSERT(455, rData.pcBase!=NULL); + JUT_ASSERT(456, rData.pOffset!=NULL); + JUT_ASSERT(457, rData.uRest>0); + + u16* puOffset = (u16*)rData.pOffset; + u16 uData = JGadget::binary::TParseValue >::parse(puOffset); + + rData.pOffset = (void*)(puOffset + 1); + return &rData.pcBase[uData]; +} + +const char* JMessage::TProcessor::process_onSelect_(JMessage::TProcessor* pThis) { + TProcess_::rdata& rData = pThis->oProcess_.rData; + JUT_ASSERT(471, rData.pfn==&process_onSelect_); + JUT_ASSERT(472, rData.pcBase!=NULL); + JUT_ASSERT(473, rData.pOffset!=NULL); + JUT_ASSERT(474, rData.uRest>0); + + u32* puOffset = (u32*)rData.pOffset; + u32 uData = JGadget::binary::TParseValue >::parse(puOffset); + + rData.pOffset = (void*)(puOffset + 1); + return &rData.pcBase[uData]; +} + +JMessage::TSequenceProcessor::TSequenceProcessor(JMessage::TReference const* pReference, + JMessage::TControl* pControl) + : TProcessor(pReference), + pControl_(pControl), + eStatus_(STATUS_READY) + {} + +JMessage::TSequenceProcessor::~TSequenceProcessor() {} + +const char* JMessage::TSequenceProcessor::process(char const* pszText) { + do { + switch (eStatus_) { + case STATUS_NORMAL: + break; + case STATUS_JUMP: { + JUT_ASSERT(549, pControl_!=NULL); + + if (!on_jump_isReady()) { + return pszCurrent_; + } + + eStatus_ = STATUS_NORMAL; + + TProcess_& process = oProcess2_; + TSequenceProcessor::jumpPfn pfn = process.process.jump_process.jumpFn; + JUT_ASSERT(556, pfn!=NULL); + + const void* pEntry = pfn(this); + if (pEntry != NULL) { + on_jump(pEntry, pControl_->getMessageText_begin()); + } + break; + } + case STATUS_BRANCH: { + JUT_ASSERT(567, pControl_!=NULL); + + u32 queryResult = on_branch_queryResult(); + if (queryResult > 0x7FFFFFFF) { + switch (queryResult) { + case 0xFFFFFFFF: + return pszCurrent_; + case 0xFFFFFFFE: + eStatus_ = STATUS_NORMAL; + break; + default: + JUT_ASSERT(579, false); + } + } else { + eStatus_ = STATUS_NORMAL; + + TProcess_& process = oProcess2_; + if (queryResult >= process.process.branch_process.uTarget) { + JGADGET_WARNMSG1(588, "unknown result : ", queryResult); + } else { + TSequenceProcessor::branchPfn pfn = process.process.branch_process.branchFn; + JUT_ASSERT(592, pfn!=NULL); + + const void* pEntry = pfn(this, queryResult); + if (pEntry != NULL) { + on_branch(pEntry, pControl_->getMessageText_begin()); + } + } + } + break; + } + default: + JUT_ASSERT(602, false); + } + + if (pszCurrent_ == pszText) { + on_end(); + return NULL; + } + + if (!on_isReady()) { + return pszCurrent_; + } + } while (process_character_()); + + return NULL; +} + +bool JMessage::TSequenceProcessor::on_isReady() { + JUT_ASSERT(629, eStatus_==STATUS_NORMAL); + return do_isReady(); +} + +void JMessage::TSequenceProcessor::on_jump_register(JMessage::TSequenceProcessor::jumpPfn pfn, u32 u32Target) { + JUT_ASSERT(638, eStatus_==STATUS_NORMAL); + eStatus_ = STATUS_JUMP; + + TProcess_& process = oProcess2_; + process.process.jump_process.jumpFn = pfn; + process.process.jump_process.u32Target = u32Target; +} + +bool JMessage::TSequenceProcessor::on_jump_isReady() { + JUT_ASSERT(649, eStatus_==STATUS_JUMP); + return do_jump_isReady(); +} + +void JMessage::TSequenceProcessor::on_jump(void const* pEntry, char const* pszText) { + on_resetStatus_(pszText); + + JUT_ASSERT(658, eStatus_==STATUS_NORMAL); + JUT_ASSERT(659, pEntry!=NULL); + JUT_ASSERT(660, pszText!=NULL); + do_jump(pEntry, pszText); +} + +void JMessage::TSequenceProcessor::on_branch_register(JMessage::TSequenceProcessor::branchPfn pfn, void const* pTarget, u32 uTarget) { + JUT_ASSERT(669, eStatus_==STATUS_NORMAL); + + TProcess_& process = oProcess2_; + process.process.branch_process.branchFn = pfn; + process.process.branch_process.pTarget = pTarget; + process.process.branch_process.uTarget = uTarget; +} + +void JMessage::TSequenceProcessor::on_branch_query(u32 uCode) { + JUT_ASSERT(680, eStatus_==STATUS_NORMAL); + eStatus_ = STATUS_BRANCH; + do_branch_query(uCode); +} + +u32 JMessage::TSequenceProcessor::on_branch_queryResult() { + JUT_ASSERT(691, eStatus_==STATUS_BRANCH); + u32 result = do_branch_queryResult(); + return result; +} + +void JMessage::TSequenceProcessor::on_branch(void const* pEntry, char const* pszText) { + on_resetStatus_(pszText); + + JUT_ASSERT(717, eStatus_==STATUS_NORMAL); + JUT_ASSERT(718, pEntry!=NULL); + JUT_ASSERT(719, pszText!=NULL); + do_branch(pEntry, pszText); +} + +bool JMessage::TSequenceProcessor::do_isReady() { + return true; +} + +bool JMessage::TSequenceProcessor::do_jump_isReady() { + return true; +} + +void JMessage::TSequenceProcessor::do_jump(void const* pEntry, char const* pszText) {} + +void JMessage::TSequenceProcessor::do_branch_query(u32 uCode) {} + +s32 JMessage::TSequenceProcessor::do_branch_queryResult() { + return -2; +} + +void JMessage::TSequenceProcessor::do_branch(void const* pEntry, char const* pszText) {} + +void JMessage::TSequenceProcessor::do_resetStatus_(char const* pszText) { + eStatus_ = STATUS_READY; + + if (pszText != NULL) { + eStatus_ = STATUS_NORMAL; + } +} + +bool JMessage::TSequenceProcessor::do_setBegin_isReady_() const { + return eStatus_ == STATUS_READY; +} + +void JMessage::TSequenceProcessor::do_begin_(void const* pEntry, char const* pszText) { + JUT_ASSERT(782, eStatus_==STATUS_NORMAL); +} + +void JMessage::TSequenceProcessor::do_end_() { + JUT_ASSERT(789, eStatus_==STATUS_NORMAL); + eStatus_ = STATUS_ONE; +} + +void JMessage::TSequenceProcessor::do_tag_(u32 uTag, void const* pData, u32 uSize) { + u8 uGroupID = data::getTagGroup(uTag); + unsigned int uCode = data::getTagCode(uTag); + + switch (uGroupID) { + case 0xFF: + switch (uCode & 0xFFFF) { + case 0: + case 1: + case 2: + case 3: + break; + case 6: { + JUT_ASSERT(807, uSize==4); + u32 u32Target = JGadget::binary::TParseValue >::parse(pData); + on_jump_register(process_onJump_, u32Target); + break; + } + case 7: + break; + default: { + TProcessor::do_tag_(uTag, pData, uSize); + break; + } + } + break; + case 0xFC: { + JUT_ASSERT(828, uSize==0); + on_jump_register(process_onJump_limited_, uCode & 0xFFFF); + break; + } + case 0xFB: { + u32 uNumber = uCode & 0xFFFF; + JUT_ASSERT(835, uSize==2*uNumber); + on_branch_register(process_onBranch_limited_, pData, uNumber); + break; + } + case 0xFA: { + u32 uNumber = uCode & 0xFFFF; + JUT_ASSERT(843, uSize==4*uNumber); + on_branch_register(process_onBranch_, pData, uNumber); + break; + } + case 0xF9: { + JUT_ASSERT(849, uSize==0); + on_branch_query(uCode & 0xFFFF); + break; + } + case 0xF8: { + u16* pu16Data = (u16*)pData; + u32 uNumber = JGadget::binary::TParseValue >::parse(pu16Data); + JUT_ASSERT(859, uSize==2+2*uNumber); + on_branch_register(process_onBranch_limited_, pu16Data + 1, uNumber); + on_branch_query(uCode & 0xFFFF); + break; + } + case 0xF7: { + u16* pu16Data = (u16*)pData; + u32 uNumber = JGadget::binary::TParseValue >::parse(pu16Data); + JUT_ASSERT(871, uSize==2+4*uNumber); + on_branch_register(process_onBranch_, pu16Data + 1, uNumber); + on_branch_query(uCode & 0xFFFF); + break; + } + default: + TProcessor::do_tag_(uTag, pData, uSize); + } +} + +void JMessage::TSequenceProcessor::process_setMessageIndex_reserved_(u16 u16Index) { + JUT_ASSERT(890, (data::MESSAGEINDEX_RESERVED_ENUM_MIN<=u16Index)&& (u16Index<=data::MESSAGEINDEX_RESERVED_ENUM_MAX)); + + switch (u16Index) { + case 0xFFFF: + JGADGET_WARNMSG1(896, "message-index reserved : ", u16Index); + return; + } +} + +void* JMessage::TSequenceProcessor::process_setMessageCode_(JMessage::TSequenceProcessor const* pProcessor, u16 u16GroupID, u16 u16Index) { + JGADGET_ASSERTWARN(904, u16GroupID<=data::MESSAGEGROUPID_USER_ENUM_MIN); + + if (u16Index >= 0xFF00) { + process_setMessageIndex_reserved_(u16Index); + return NULL; + } + + TControl* pControl = pProcessor->getControl(); + JUT_ASSERT(911, pControl!=NULL); + + if (!pControl->setMessageCode_inSequence_(pProcessor, u16GroupID, u16Index)) { + JGADGET_WARNMSG1(914, "message-code undefined : ", pControl->getMessageCode()); + return NULL; + } + + return pControl->getMessageEntry(); +} + +const void* +JMessage::TSequenceProcessor::process_onJump_limited_(JMessage::TSequenceProcessor const* pProcessor) { + const TProcess_::processData::jumpData& rData = pProcessor->oProcess2_.process.jump_process; + + JUT_ASSERT(925, rData.u32Target<=std::uint16_t(-1)); + return process_setMessageIndex_(pProcessor, rData.u32Target); +} + +const void* +JMessage::TSequenceProcessor::process_onJump_(JMessage::TSequenceProcessor const* pProcessor) { + const TProcess_::processData::jumpData& rData = pProcessor->oProcess2_.process.jump_process; + return process_setMessageCode_(pProcessor, rData.u32Target); +} + +const void* +JMessage::TSequenceProcessor::process_onBranch_limited_(JMessage::TSequenceProcessor const* pProcessor, u32 uTargetIndex) { + const TProcess_::processData::branchData& rData = pProcessor->oProcess2_.process.branch_process; + + JUT_ASSERT(942, rData.pTarget!=NULL); + JUT_ASSERT(943, uTargetIndex >::parse(rData.pTarget, uTargetIndex); + return process_setMessageIndex_(pProcessor, u16Index); +} + +const void* +JMessage::TSequenceProcessor::process_onBranch_(JMessage::TSequenceProcessor const* pProcessor, u32 uTargetIndex) { + const TProcess_::processData::branchData& rData = pProcessor->oProcess2_.process.branch_process; + + JUT_ASSERT(957, rData.pTarget!=NULL); + JUT_ASSERT(958, uTargetIndex >::parse(rData.pTarget, uTargetIndex); + return process_setMessageCode_(pProcessor, uCode); +} + +JMessage::TRenderingProcessor::TRenderingProcessor(JMessage::TReference const* pReference) + : TProcessor(pReference) {} + +JMessage::TRenderingProcessor::~TRenderingProcessor() {} + +int JMessage::TRenderingProcessor::process(char const* pszText) { + do { + if (pszCurrent_ == pszText) { + on_end(); + return 0; + } + } while (process_character_()); + + return 0; +} + +void JMessage::TRenderingProcessor::do_begin_(void const* pEntry, char const* pszText) {} + +void JMessage::TRenderingProcessor::do_end_() {} + +void JMessage::TRenderingProcessor::do_tag_(u32 uTag, void const* pData, u32 uSize) { + u8 uGroupID = data::getTagGroup(uTag); + unsigned int uCode = data::getTagCode(uTag); + + switch (uGroupID) { + case 0xFF: + switch (uCode & 0xFFFF) { + case 0: + case 1: + case 2: + case 3: { + JGADGET_WARNMSG1(1047, "system-tag-code ignored : ", uCode & 0xFFFF); + break; + } + case 6: + break; + case 7: + break; + default: + TProcessor::do_tag_(uTag, pData, uSize); + break; + } + break; + case 0xFC: + case 0xFB: + case 0xFA: + case 0xF9: + case 0xF8: + case 0xF7: + break; + default: + TProcessor::do_tag_(uTag, pData, uSize); + break; + } +} -- cgit v1.2.3