mirror of
https://github.com/TwilitRealm/dusklight
synced 2026-07-28 23:15:32 -04:00
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 <dolphin/x.h>` -> `<x.h>`
* Remove `__REVOLUTION_SDK__` forwards from dolphin
* Fix dolphin/ references in revolution
* Wrap `#include <dolphin.h>` in `!__REVOLUTION_SDK__`
* Always build TRK against dolphin headers
* Resolve revolution SDK header resolution issues
This commit is contained in:
Luke Street
@@ -0,0 +1,96 @@
|
||||
/**
|
||||
* JMessage/control.cpp
|
||||
* JMessage Controller
|
||||
*/
|
||||
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JMessage/control.h"
|
||||
|
||||
JMessage::TControl::TControl()
|
||||
: pSequenceProcessor_(NULL),
|
||||
pRenderingProcessor_(NULL),
|
||||
uMessageGroupID_(0xFFFF),
|
||||
uMessageID_(0xFFFF),
|
||||
pResourceCache_(NULL),
|
||||
pEntry_(NULL),
|
||||
pMessageText_begin_(NULL),
|
||||
pszText_update_current_(NULL),
|
||||
pMessageText_current_(NULL)
|
||||
{}
|
||||
|
||||
JMessage::TControl::~TControl() {}
|
||||
|
||||
void JMessage::TControl::reset() {
|
||||
pEntry_ = NULL;
|
||||
pMessageText_begin_ = NULL;
|
||||
pszText_update_current_ = NULL;
|
||||
pMessageText_current_ = NULL;
|
||||
oStack_renderingProcessor_.clear();
|
||||
|
||||
if (pSequenceProcessor_ != NULL) {
|
||||
pSequenceProcessor_->reset();
|
||||
}
|
||||
|
||||
if (pRenderingProcessor_ != NULL) {
|
||||
pRenderingProcessor_->reset();
|
||||
}
|
||||
}
|
||||
|
||||
int JMessage::TControl::update() {
|
||||
if (!isReady_update_()) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
pszText_update_current_ = pSequenceProcessor_->process(NULL);
|
||||
if (pszText_update_current_ == NULL) {
|
||||
pMessageText_begin_ = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void JMessage::TControl::render() {
|
||||
if (isReady_render_()) {
|
||||
pRenderingProcessor_->setBegin_messageEntryText(pResourceCache_, pEntry_, pMessageText_current_);
|
||||
pRenderingProcessor_->oStack_ = oStack_renderingProcessor_;
|
||||
pRenderingProcessor_->process(pszText_update_current_);
|
||||
}
|
||||
}
|
||||
|
||||
int JMessage::TControl::setMessageCode(u16 u16GroupID, u16 u16Index) {
|
||||
TProcessor* pProcessor = getProcessor();
|
||||
JUT_ASSERT(120, pProcessor!=NULL);
|
||||
return setMessageCode_inReset_(pProcessor, u16GroupID, u16Index);
|
||||
}
|
||||
|
||||
int JMessage::TControl::setMessageID(u32 uMsgID, u32 param_1, bool* pbValid) {
|
||||
TProcessor* pProcessor = getProcessor();
|
||||
JUT_ASSERT(132, pProcessor!=NULL);
|
||||
|
||||
u32 uCode = pProcessor->toMessageCode_messageID(uMsgID, param_1, pbValid);
|
||||
if (uCode == 0xFFFFFFFF) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return setMessageCode_inReset_(pProcessor, uCode >> 16, uCode & 0xFFFF);
|
||||
}
|
||||
|
||||
bool JMessage::TControl::setMessageCode_inSequence_(JMessage::TProcessor const* pProcessor, u16 u16GroupID, u16 u16Index) {
|
||||
pEntry_ = pProcessor->getMessageEntry_messageCode(u16GroupID, u16Index);
|
||||
if (pEntry_ == NULL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
uMessageGroupID_ = u16GroupID;
|
||||
uMessageID_ = u16Index;
|
||||
|
||||
pResourceCache_ = pProcessor->getResourceCache();
|
||||
JUT_ASSERT(155, pResourceCache_!=NULL);
|
||||
|
||||
pMessageText_begin_ = pResourceCache_->getMessageText_messageEntry(pEntry_);
|
||||
pMessageText_current_ = pMessageText_begin_;
|
||||
oStack_renderingProcessor_.clear();
|
||||
return true;
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JMessage/data.h"
|
||||
|
||||
const u32 JMessage::data::ga4cSignature = 'MESG';
|
||||
|
||||
const u32 JMessage::data::ga4cSignature_color = 'MGCL';
|
||||
@@ -0,0 +1,56 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JMessage/locale.h"
|
||||
|
||||
int JMessage::locale::parseCharacter_ShiftJIS(const char** ppszText) {
|
||||
int c = *(u8*)*ppszText & 0xFF;
|
||||
(*ppszText)++;
|
||||
|
||||
if (isLeadByte_ShiftJIS(c)) {
|
||||
c <<= 8;
|
||||
c |= *(u8*)*ppszText & 0xFF;
|
||||
(*ppszText)++;
|
||||
}
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
int JMessage::locale::parseCharacter_UTF8(const char** ppszText) {
|
||||
int c = *(u8*)*ppszText & 0xFF;
|
||||
(*ppszText)++;
|
||||
|
||||
if (c & 0x80) {
|
||||
if ((c & 0xE0) == 0xC0) {
|
||||
c &= 0x1F;
|
||||
c <<= 6;
|
||||
c |= (*(u8*)*ppszText & 0xFF) & 0x3F;
|
||||
(*ppszText)++;
|
||||
} else if ((c & 0xF0) == 0xE0) {
|
||||
c &= 0xF;
|
||||
c <<= 6;
|
||||
c |= (*(u8*)*ppszText & 0xFF) & 0x3F;
|
||||
(*ppszText)++;
|
||||
|
||||
c <<= 6;
|
||||
c |= (*(u8*)*ppszText & 0xFF) & 0x3F;
|
||||
(*ppszText)++;
|
||||
} else if ((c & 0xF8) == 0xF0) {
|
||||
c &= 0x7;
|
||||
c <<= 6;
|
||||
c |= (*(u8*)*ppszText & 0xFF) & 0x3F;
|
||||
(*ppszText)++;
|
||||
|
||||
c <<= 6;
|
||||
c |= (*(u8*)*ppszText & 0xFF) & 0x3F;
|
||||
(*ppszText)++;
|
||||
|
||||
c <<= 6;
|
||||
c |= (*(u8*)*ppszText & 0xFF) & 0x3F;
|
||||
(*ppszText)++;
|
||||
} else {
|
||||
c = -1;
|
||||
}
|
||||
}
|
||||
|
||||
return c;
|
||||
}
|
||||
@@ -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 <cstdint>
|
||||
|
||||
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<JMessage::TResource, 0> 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<JGadget::binary::TParseValue_endian_big_<u32> >::parse(pData)));
|
||||
break;
|
||||
case 5:
|
||||
JUT_ASSERT(341, uSize==4);
|
||||
stack_pushCurrent(on_message(JGadget::binary::TParseValue<JGadget::binary::TParseValue_endian_big_<u32> >::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<JGadget::binary::TParseValue_endian_big_<u16> >::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<JGadget::binary::TParseValue_endian_big_<u32> >::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<JGadget::binary::TParseValue_endian_big_<u32> >::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<JGadget::binary::TParseValue_endian_big_<u16> >::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<JGadget::binary::TParseValue_endian_big_<u16> >::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<rData.uTarget);
|
||||
|
||||
u16 u16Index = JGadget::binary::TParseValue<JGadget::binary::TParseValue_endian_big_<u16> >::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<rData.uTarget);
|
||||
|
||||
u32 uCode = JGadget::binary::TParseValue<JGadget::binary::TParseValue_endian_big_<u32> >::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;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,298 @@
|
||||
#include "JSystem/JSystem.h" // IWYU pragma: keep
|
||||
|
||||
#include "JSystem/JMessage/resource.h"
|
||||
#include "JSystem/JGadget/search.h"
|
||||
#include "JSystem/JGadget/define.h"
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
|
||||
u16 JMessage::TResource::toMessageIndex_messageID(u32 uMsgID, u32 upperHalf, bool* pbValid) const {
|
||||
if (!oParse_TBlock_messageID_.getRaw()) {
|
||||
return 0xFFFF;
|
||||
}
|
||||
|
||||
JUT_ASSERT(87, oParse_TBlock_messageID_.get_form()==0);
|
||||
|
||||
u32 uMsgValue = 0xFFFFFFFF;
|
||||
bool valid = true;
|
||||
|
||||
u8 uFormSupplement = oParse_TBlock_messageID_.get_formSupplement();
|
||||
switch (uFormSupplement) {
|
||||
case 0:
|
||||
if (upperHalf != 0) {
|
||||
valid = false;
|
||||
}
|
||||
uMsgValue = uMsgID;
|
||||
break;
|
||||
case 1:
|
||||
if (uMsgID > 0xFFFFFF || upperHalf > 0xFF) {
|
||||
valid = false;
|
||||
}
|
||||
uMsgValue = ((uMsgID << 8) & 0xFFFFFF00) | (upperHalf & 0xFF);
|
||||
break;
|
||||
case 2:
|
||||
if (uMsgID > 0xFFFF || upperHalf > 0xFFFF) {
|
||||
valid = false;
|
||||
}
|
||||
uMsgValue = ((uMsgID << 16) & 0xFFFF0000) | (upperHalf & 0xFFFF);
|
||||
break;
|
||||
case 3:
|
||||
if (uMsgID > 0xFF || upperHalf > 0xFFFFFF) {
|
||||
valid = false;
|
||||
}
|
||||
uMsgValue = ((uMsgID << 24) & 0xFF000000) | (upperHalf & 0x00FFFFFF);
|
||||
break;
|
||||
case 4:
|
||||
if (uMsgID != 0) {
|
||||
valid = false;
|
||||
}
|
||||
uMsgValue = upperHalf;
|
||||
break;
|
||||
default:
|
||||
JGADGET_WARNMSG1(122, "form-supplement unknown", uFormSupplement);
|
||||
return 0xFFFF;
|
||||
}
|
||||
|
||||
if (pbValid) {
|
||||
*pbValid = valid;
|
||||
}
|
||||
|
||||
if (uMsgValue == 0xFFFFFFFF) {
|
||||
return 0xFFFF;
|
||||
}
|
||||
|
||||
int nMsgNumber = oParse_TBlock_messageID_.get_number();
|
||||
|
||||
const u32* pContent = oParse_TBlock_messageID_.getContent();
|
||||
JUT_ASSERT(131, pContent!=NULL);
|
||||
|
||||
const u32* pFirst = pContent;
|
||||
const u32* pLast = pFirst + nMsgNumber;
|
||||
const u32* pEntry;
|
||||
|
||||
if (oParse_TBlock_messageID_.get_isOrdered()) {
|
||||
pEntry = std::lower_bound(pFirst, pLast, uMsgValue);
|
||||
if (pEntry == pLast || *pEntry != uMsgValue) {
|
||||
return 0xFFFF;
|
||||
}
|
||||
} else {
|
||||
pEntry = std::find(pFirst, pLast, uMsgValue);
|
||||
if (pEntry == pLast) {
|
||||
return 0xFFFF;
|
||||
}
|
||||
}
|
||||
|
||||
int nIndex = pEntry - pFirst;
|
||||
JUT_ASSERT(154, (data::MESSAGEINDEX_USER_ENUM_MIN<=nIndex)&& (nIndex<=data::MESSAGEINDEX_USER_ENUM_MAX));
|
||||
return nIndex;
|
||||
}
|
||||
|
||||
JMessage::locale::parseCharacter_function JMessage::TResourceContainer::sapfnParseCharacter_[5] = {
|
||||
NULL,
|
||||
JMessage::locale::parseCharacter_1Byte,
|
||||
JMessage::locale::parseCharacter_2Byte,
|
||||
JMessage::locale::parseCharacter_ShiftJIS,
|
||||
JMessage::locale::parseCharacter_UTF8,
|
||||
};
|
||||
|
||||
JMessage::TResourceContainer::TCResource::TCResource() {}
|
||||
|
||||
JMessage::TResourceContainer::TCResource::~TCResource() {
|
||||
JGADGET_ASSERTWARN(173, empty());
|
||||
}
|
||||
JMessage::TResource* JMessage::TResourceContainer::TCResource::Get_groupID(u16 u16GroupID) {
|
||||
JGadget::TContainerEnumerator<TResourceContainer::TCResource> enumerator(*this);
|
||||
while (enumerator) {
|
||||
const TResource* res = &(*enumerator);
|
||||
if (res->getGroupID() == u16GroupID)
|
||||
return (TResource*)res;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
JMessage::TResource* JMessage::TResourceContainer::TCResource::Do_create() {
|
||||
return new TResource();
|
||||
}
|
||||
|
||||
void JMessage::TResourceContainer::TCResource::Do_destroy(JMessage::TResource* pResource) {
|
||||
#if DEBUG
|
||||
delete pResource;
|
||||
#else
|
||||
operator delete(pResource);
|
||||
#endif
|
||||
}
|
||||
|
||||
JMessage::TResourceContainer::TResourceContainer() : encodingType_(0), pfnParseCharacter_(NULL) {}
|
||||
|
||||
void JMessage::TResourceContainer::setEncoding(u8 e) {
|
||||
if (e == 0) {
|
||||
encodingType_ = e;
|
||||
pfnParseCharacter_ = NULL;
|
||||
} else {
|
||||
JGADGET_ASSERTWARN(285, isEncodingSettable(e));
|
||||
setEncoding_(e);
|
||||
}
|
||||
}
|
||||
|
||||
void JMessage::TResourceContainer::setEncoding_(u8 e) {
|
||||
encodingType_ = e;
|
||||
pfnParseCharacter_ = JGadget::toValueFromIndex<JMessage::locale::parseCharacter_function>(e, sapfnParseCharacter_, 5, NULL);
|
||||
JUT_ASSERT(299, pfnParseCharacter_!=NULL);
|
||||
}
|
||||
|
||||
JMessage::TParse::TParse(JMessage::TResourceContainer* pContainer) {
|
||||
u8 sp8[5];
|
||||
JMessage::TResourceContainer* cont;
|
||||
JUT_ASSERT(324, pContainer!=NULL);
|
||||
cont = pContainer;
|
||||
pContainer_ = cont;
|
||||
pResource_ = NULL;
|
||||
sp8[0] = 0;
|
||||
}
|
||||
|
||||
JMessage::TParse::~TParse() {}
|
||||
|
||||
bool JMessage::TParse::parseHeader_next(const void** ppData_inout, u32* puBlock_out, u32 param_2) {
|
||||
JUT_ASSERT(343, ppData_inout!=NULL);
|
||||
JUT_ASSERT(344, puBlock_out!=NULL);
|
||||
|
||||
const void* pData = *ppData_inout;
|
||||
JUT_ASSERT(346, pData!=NULL);
|
||||
|
||||
data::TParse_THeader oHeader(pData);
|
||||
*ppData_inout = oHeader.getContent();
|
||||
*puBlock_out = oHeader.get_blockNumber();
|
||||
|
||||
JUT_ASSERT(350, pContainer_!=NULL);
|
||||
|
||||
if (memcmp(oHeader.get_signature(), &data::ga4cSignature, sizeof(data::ga4cSignature)) != 0) {
|
||||
JGADGET_WARNMSG(355, "unknown signature");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (oHeader.get_type() != 'bmg1') {
|
||||
JGADGET_WARNMSG(360, "unknown type");
|
||||
return false;
|
||||
}
|
||||
|
||||
const u8 uEncoding = oHeader.get_encoding();
|
||||
if (uEncoding != 0) {
|
||||
if (!pContainer_->isEncodingSettable(uEncoding)) {
|
||||
JGADGET_WARNMSG(369, "encoding not acceptable");
|
||||
return false;
|
||||
}
|
||||
|
||||
pContainer_->setEncoding(uEncoding);
|
||||
}
|
||||
|
||||
if (param_2 & 0x10) {
|
||||
return true;
|
||||
}
|
||||
|
||||
TResourceContainer::TCResource* pResContainer = &pContainer_->resContainer_;
|
||||
pResource_ = pResContainer->Do_create();
|
||||
|
||||
if (pResource_ == NULL) {
|
||||
JGADGET_WARNMSG(384, "can't create resource");
|
||||
if (param_2 & 0x20) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
pResContainer->Push_back(pResource_);
|
||||
pResource_->setData_header(oHeader.getRaw());
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
bool JMessage::TParse::parseBlock_next(const void** ppData_inout, u32* puData_out, u32 param_2) {
|
||||
JUT_ASSERT(401, ppData_inout!=NULL);
|
||||
JUT_ASSERT(402, puData_out!=NULL);
|
||||
|
||||
const void* pData = *ppData_inout;
|
||||
JUT_ASSERT(404, pData!=NULL);
|
||||
|
||||
data::TParse_TBlock oBlock(pData);
|
||||
|
||||
*ppData_inout = oBlock.getNext();
|
||||
*puData_out = oBlock.get_size();
|
||||
|
||||
TResourceContainer::TCResource& rcResource = pContainer_->resContainer_;
|
||||
JUT_ASSERT(412, pResource_==&*--(rcResource.end()));
|
||||
|
||||
u32 uType = oBlock.get_type();
|
||||
switch (uType) {
|
||||
case 'INF1': {
|
||||
pResource_->setData_block_info(pData);
|
||||
break;
|
||||
}
|
||||
case 'FLI1':
|
||||
break;
|
||||
case 'FLW1':
|
||||
break;
|
||||
case 'DAT1': {
|
||||
pResource_->setData_block_messageText(pData);
|
||||
u16 u16GroupID = pResource_->getGroupID();
|
||||
|
||||
if (param_2 & 0x80) {
|
||||
JGadget::TLinkList<JMessage::TResource, 0>::iterator iResource(rcResource.begin());
|
||||
JMessage::TResource* pResource;
|
||||
while ((pResource = &*iResource) != pResource_) {
|
||||
if ((u16)u16GroupID != pResource->getGroupID()) {
|
||||
++iResource;
|
||||
} else {
|
||||
iResource = rcResource.Erase_destroy(pResource);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
#if DEBUG
|
||||
JMessage::TResource* pResource = rcResource.Get_groupID(u16GroupID);
|
||||
if (pResource != pResource_) {
|
||||
JGADGET_WARNMSG1(444, "group-ID already exist : ", u16GroupID);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'STR1': {
|
||||
pResource_->setData_block_stringAttribute(pData);
|
||||
break;
|
||||
}
|
||||
case 'MID1': {
|
||||
pResource_->setData_block_messageID(pData);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
JGADGET_WARNMSG1(463, "unknown block : ", uType);
|
||||
if (!(param_2 & 0x40)) {
|
||||
return 0;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int JMessage::locale::parseCharacter_1Byte(char const** ppszText) {
|
||||
u8** ppuText = (u8**)ppszText;
|
||||
int parse_char = **ppuText & 0xFF;
|
||||
|
||||
(*ppuText)++;
|
||||
return parse_char;
|
||||
}
|
||||
|
||||
int JMessage::locale::parseCharacter_2Byte(char const** ppszText) {
|
||||
u8** ppuText = (u8**)ppszText;
|
||||
|
||||
int parse_char = **ppuText & 0xFF;
|
||||
(*ppuText)++;
|
||||
|
||||
parse_char <<= 8;
|
||||
|
||||
parse_char |= **ppuText & 0xFF;
|
||||
(*ppuText)++;
|
||||
|
||||
return parse_char;
|
||||
}
|
||||
Reference in New Issue
Block a user