Compare commits
6 Commits
agent/w101
...
agent/fix/
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
c652da19c3 | ||
|
|
3d7e767cf7 | ||
|
|
10146c1b5f | ||
|
|
82783c6edb | ||
|
|
72e9c8d658 | ||
|
|
0062d65a27 |
@@ -42,7 +42,7 @@ AppLoaderHdr = .bss:0x810ABF40; // type:object size:0x20 align:32 data:4byte
|
||||
bi2 = .bss:0x810ABF60; // type:object size:0x2000 align:32 data:4byte
|
||||
UpdateDiskID = .bss:0x810ADF60; // type:object size:0x20 align:32 data:4byte
|
||||
TicketViewsBuf = .bss:0x810ADF80; // type:object size:0x3600 scope:local align:32
|
||||
Flags0 = .bss:0x810B1580; // type:object size:0x800 scope:local
|
||||
Flags0$1129 = .bss:0x810B1580; // type:object size:0x800 scope:local
|
||||
Flags1 = .bss:0x810B1D80; // type:object size:0x800 scope:local
|
||||
Thread = .bss:0x810B2580; // type:object size:0x318 scope:local
|
||||
UpdateHeader0 = .bss:0x810B38A0; // type:object size:0x20 scope:local
|
||||
@@ -17727,7 +17727,7 @@ __vt__Q39textinput4util9Animation = .data:0x8165D258; // type:object size:0x24
|
||||
@STRING@GetTextColor__Q34nw4r3lyt7TextBoxCFUl = .data:0x8165D28C; // type:object size:0x41 data:string
|
||||
scT_prdc_Text_00 = .data:0x8165D2D0; // type:object size:0xF data:string
|
||||
scP_prdc_scrl_Left = .data:0x8165D2E0; // type:object size:0x11 data:string
|
||||
scCandidatePaneData = .data:0x8165D2F8; // type:object size:0x680
|
||||
csPaneToAnimation__Q29textinput12candidatebox = .data:0x8165D2F8; // type:object size:0x680 scope:local
|
||||
@9934 = .data:0x8165D978; // type:object size:0x9 scope:local data:string
|
||||
@9935 = .data:0x8165D984; // type:object size:0x9 scope:local data:string
|
||||
@9936 = .data:0x8165D990; // type:object size:0xB scope:local data:string
|
||||
|
||||
@@ -658,7 +658,7 @@ config.libs = [
|
||||
Object(Matching, "system/iplChannelRsoThread.cpp"),
|
||||
Object(Matching, "system/RsoSystem.cpp"),
|
||||
Object(Matching, "system/iplCdbBackup.cpp"),
|
||||
Object(NonMatching, "system/odh.cpp"),
|
||||
Object(Matching, "system/odh.cpp"),
|
||||
Object(Matching, "system/iplSDVFWorker.cpp"),
|
||||
Object(Matching, "system/iplNandWrapper.cpp"),
|
||||
Object(Matching, "system/main.cpp"),
|
||||
@@ -719,7 +719,7 @@ config.libs = [
|
||||
Object(Matching, "BS2/BS2.c"),
|
||||
Object(Matching, "BS2/BS2Init.c"),
|
||||
Object(NonMatching, "BS2/BS2Mach.c"),
|
||||
Object(NonMatching, "BS2/BS2Update.c"),
|
||||
Object(Matching, "BS2/BS2Update.c"),
|
||||
Object(Matching, "BS2/BS2ParentalControl.c"),
|
||||
Object(Matching, "BS2/BS2BringUp.c"),
|
||||
Object(Matching, "BS2/BS2Reset.c"),
|
||||
@@ -912,7 +912,7 @@ config.libs = [
|
||||
Object(Matching, "keyboard/tiPcKeyboard.cpp", extra_cflags=["-O4,p"]),
|
||||
Object(Matching, "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(Matching, "keyboard/tiCandidateBox.cpp", extra_cflags=["-O4,p"]),
|
||||
Object(Matching, "keyboard/tiToolBar.cpp", extra_cflags=["-O4,p"]),
|
||||
Object(Matching, "keyboard/tiPredictLang.cpp", extra_cflags=["-O4,p"]),
|
||||
Object(Matching, "keyboard/tiSignWindow.cpp", extra_cflags=["-O4,p"]),
|
||||
@@ -1886,7 +1886,7 @@ config.libs = [
|
||||
]
|
||||
),
|
||||
RVLSDKLib("kbd", [
|
||||
Object(NonMatching, "kbd/kbd_lib.c"),
|
||||
Object(Matching, "kbd/kbd_lib.c"),
|
||||
Object(NonMatching, "kbd/kbd_lib_map_jp.c"),
|
||||
Object(Matching, "kbd/kbd_lib_map_us.c"),
|
||||
Object(NonMatching, "kbd/kbd_lib_map_eu.c"),
|
||||
|
||||
@@ -77,7 +77,7 @@ namespace textinput {
|
||||
|
||||
class Base : public CommandSender {
|
||||
public:
|
||||
#ifdef TIMANAGER_IMPLEMENTATION
|
||||
#if defined(TIMANAGER_IMPLEMENTATION) || defined(TI_CANDIDATEBOX_SAMPLE_CLASS)
|
||||
Base(Manager* manager) : mpCandidates(NULL), mpAllocator(NULL), mbOn(false), mbInvalid(true), meLanguage(USA), mpManager(manager) {}
|
||||
#endif
|
||||
virtual ~Base();
|
||||
@@ -114,7 +114,7 @@ namespace textinput {
|
||||
|
||||
class EventHandler : public nw4rmanager::TiEventHandler {
|
||||
public:
|
||||
#ifdef TIMANAGER_IMPLEMENTATION
|
||||
#if defined(TIMANAGER_IMPLEMENTATION) || defined(TI_CANDIDATEBOX_SAMPLE_CLASS)
|
||||
EventHandler(LayoutByNW4R* layout) : mpLayoutByNW4R(layout) {}
|
||||
#endif
|
||||
virtual void onTiEvent(gui::PaneComponent* paneComponent, u32 event, Input* input) override; // 0x18
|
||||
@@ -302,7 +302,7 @@ namespace textinput {
|
||||
// TODO
|
||||
class LayoutByNW4R : public Base, public nw4rmanager::Layout, public UIObj::Listener {
|
||||
public:
|
||||
#ifdef TIMANAGER_IMPLEMENTATION
|
||||
#if defined(TIMANAGER_IMPLEMENTATION) || defined(TI_CANDIDATEBOX_SAMPLE_CLASS)
|
||||
LayoutByNW4R(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
|
||||
: Base(manager), nw4rmanager::Layout(accessor, layoutName, observer), mEventHandler(this), mpTiString(NULL),
|
||||
mTextArea(0, this, this), mLeftScroll(1, this, this), mRightScroll(2, this, this), mOnOffButton(3, this, this),
|
||||
@@ -371,6 +371,15 @@ namespace textinput {
|
||||
bool mbActive;
|
||||
};
|
||||
|
||||
#ifdef TI_CANDIDATEBOX_SAMPLE_CLASS
|
||||
class Sample : public LayoutByNW4R {
|
||||
public:
|
||||
Sample(Manager* manager, nw4r::lyt::MultiArcResourceAccessor* accessor, EventObserver* observer, const char* layoutName)
|
||||
: LayoutByNW4R(manager, accessor, observer, layoutName) {}
|
||||
virtual ~Sample() {}
|
||||
};
|
||||
#endif
|
||||
|
||||
class CandidateTextAnmPane : public nw4rmanager::AnmPane {
|
||||
public:
|
||||
CandidateTextAnmPane(nw4r::lyt::Pane* pane, nw4rmanager::AnmObserver* observer)
|
||||
|
||||
@@ -396,6 +396,8 @@ static void kbdProcKey(u32 key, u32 pressed, u32 channel) {
|
||||
kbdSendKey(&event);
|
||||
}
|
||||
|
||||
#pragma push
|
||||
#pragma opt_propagation off
|
||||
static void kbdProcMod(u32 key, u32 pressed, u32 channel) {
|
||||
KBDChannel* data;
|
||||
u32 modState;
|
||||
@@ -524,6 +526,7 @@ static void kbdProcMod(u32 key, u32 pressed, u32 channel) {
|
||||
finalState = modState | 0x1000;
|
||||
KBDSetModState(channel, finalState);
|
||||
}
|
||||
#pragma pop
|
||||
|
||||
static void kbdSendKey(KBDKeyEventData* event) {
|
||||
KBDChannel* data;
|
||||
|
||||
@@ -9,12 +9,11 @@
|
||||
|
||||
#include <string.h>
|
||||
|
||||
static u32 Flags0[BS2_UPDATE_ENTRY_COUNT] = {0};
|
||||
static u32 Flags1[BS2_UPDATE_ENTRY_COUNT] = {0};
|
||||
static OSThread Thread = {0};
|
||||
static u8 ThreadStack[4096] = {0};
|
||||
static BS2UpdateHeader UpdateHeader0 ALIGN32 = {0};
|
||||
static BS2UpdateHeader UpdateHeader1 ALIGN32 = {0};
|
||||
static u32 Flags1[BS2_UPDATE_ENTRY_COUNT];
|
||||
static OSThread Thread;
|
||||
static u8 ThreadStack[4096];
|
||||
static BS2UpdateHeader UpdateHeader0 ALIGN32;
|
||||
static BS2UpdateHeader UpdateHeader1 ALIGN32;
|
||||
|
||||
BS2UpdateEntry DiscEntries[BS2_UPDATE_ENTRY_COUNT] ADDRESS(0x80480000);
|
||||
|
||||
@@ -50,32 +49,8 @@ char* getSuffix(const char* path) {
|
||||
return suffix;
|
||||
}
|
||||
|
||||
static void* UpdateThread(void* argument);
|
||||
|
||||
void BS2UpdateInit(void* allocator) {
|
||||
BS2Report("initialize BS2Update\n");
|
||||
ConsoleType = OSGetConsoleType();
|
||||
VersionES = __OSGetHollywoodRev();
|
||||
VersionMEM2 = OSGetPhysicalMem2Size();
|
||||
__OSGetIOSRev((OSIOSRev*)&VersionIOS);
|
||||
BS2Report("Console Type : %08X\n", ConsoleType);
|
||||
BS2Report("Hollywood Rev : %08X\n", VersionES);
|
||||
BS2Report("MEM2 Size : %08X\n", VersionMEM2);
|
||||
MemAllocator = allocator;
|
||||
State = 0;
|
||||
CurrentEntry = NULL;
|
||||
pEntries = NULL;
|
||||
EntriesCount = 0;
|
||||
memset(DiscEntries, 0, 0x40000);
|
||||
memset(EntriesToImport, 0, 0x40000);
|
||||
memset(Flags1, 0, sizeof(Flags1));
|
||||
BS2Report("Create update thread\n");
|
||||
OSCreateThread(&Thread, UpdateThread, NULL, ThreadStack + sizeof(ThreadStack),
|
||||
sizeof(ThreadStack), 31, OS_THREAD_ATTR_DETACH);
|
||||
OSResumeThread(&Thread);
|
||||
}
|
||||
|
||||
static inline u32 BS2SelectUpdateEntries(void) {
|
||||
static u32 Flags0[BS2_UPDATE_ENTRY_COUNT];
|
||||
BOOL missingFile;
|
||||
u32 index;
|
||||
u32 selectedCount;
|
||||
@@ -418,6 +393,31 @@ selection_complete:
|
||||
return selectedCount;
|
||||
}
|
||||
|
||||
static void* UpdateThread(void* argument);
|
||||
|
||||
void BS2UpdateInit(void* allocator) {
|
||||
BS2Report("initialize BS2Update\n");
|
||||
ConsoleType = OSGetConsoleType();
|
||||
VersionES = __OSGetHollywoodRev();
|
||||
VersionMEM2 = OSGetPhysicalMem2Size();
|
||||
__OSGetIOSRev((OSIOSRev*)&VersionIOS);
|
||||
BS2Report("Console Type : %08X\n", ConsoleType);
|
||||
BS2Report("Hollywood Rev : %08X\n", VersionES);
|
||||
BS2Report("MEM2 Size : %08X\n", VersionMEM2);
|
||||
MemAllocator = allocator;
|
||||
State = 0;
|
||||
CurrentEntry = NULL;
|
||||
pEntries = NULL;
|
||||
EntriesCount = 0;
|
||||
memset(DiscEntries, 0, 0x40000);
|
||||
memset(EntriesToImport, 0, 0x40000);
|
||||
memset(Flags1, 0, sizeof(Flags1));
|
||||
BS2Report("Create update thread\n");
|
||||
OSCreateThread(&Thread, UpdateThread, NULL, ThreadStack + sizeof(ThreadStack),
|
||||
sizeof(ThreadStack), 31, OS_THREAD_ATTR_DETACH);
|
||||
OSResumeThread(&Thread);
|
||||
}
|
||||
|
||||
static void* UpdateThread(void* argument) {
|
||||
u32 index;
|
||||
s32 importResult;
|
||||
|
||||
@@ -4994,30 +4994,47 @@ static inline void VmBlobCopyPadded(BlobHeader* parentBlob, const BlobHeader* sr
|
||||
|
||||
static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, CHANSVmObjHdr* VmReturnObj, vmU32 flag) {
|
||||
u32 packBuf[2];
|
||||
s32 writeHexBufSize;
|
||||
CHANSVmObjHdr* argArr;
|
||||
CHANSVmObjHdr* measureStringObj;
|
||||
s32 measureBlobCount;
|
||||
u32 writeFmtPos;
|
||||
u32 writeHexI;
|
||||
BlobHeader* parentBlob;
|
||||
CHANSVmObjHdr* argStr;
|
||||
CHANSVmObjHdr* measureHexObj;
|
||||
CHANSVmObjHdr* writeStringStrObj;
|
||||
u32 writeIntegerValHigh;
|
||||
CHANSVmObjHdr* writeHexStrObj;
|
||||
u32 writeIntegerValLow;
|
||||
u8* writeStringDest;
|
||||
const wchar_t* fmtStr;
|
||||
u8* writeHexSrcData;
|
||||
u32 writeStringStrLen;
|
||||
u32 fmtLen;
|
||||
CHANSVmObjHdr* argArr;
|
||||
u32 fmtPos;
|
||||
u32 writeArgCount;
|
||||
u8* writeHexDest;
|
||||
s32 measureHexCount;
|
||||
s32 writeIntegerCount;
|
||||
BlobHeader* measureBlobSrcBlob;
|
||||
u32 writeIntegerI;
|
||||
s32 writeStringCount;
|
||||
CHANSVmObjHdr* writeBlobObj;
|
||||
u32 argCount;
|
||||
CHANSVmObjHdr* measureBlobObj;
|
||||
s32 writeBlobCopySize;
|
||||
s32 measureIntegerCount;
|
||||
CHANSVmObjHdr* writeIntegerIntObj;
|
||||
BlobHeader* writeBlobSrcBlob;
|
||||
u8* writeStringSrcData;
|
||||
u32 writeStringCharCount;
|
||||
u32 fmtPos;
|
||||
u32 totalSize;
|
||||
s32 count;
|
||||
u32 i;
|
||||
CHANSVmObjHdr* obj;
|
||||
BlobHeader* srcBlob;
|
||||
s32 copySize;
|
||||
CHANSVmObjHdr* strObj;
|
||||
u8* srcData;
|
||||
u32 charCount;
|
||||
u32 strLen;
|
||||
CHANSVmObjHdr* intObj;
|
||||
u32 valLow;
|
||||
u32 valHigh;
|
||||
s32 bufSize;
|
||||
u8* dest;
|
||||
u32 ch;
|
||||
CHANSVmExecutionCtx* execCtx;
|
||||
u32 writeHexCh;
|
||||
s32 measureStringCount;
|
||||
s32 writeHexCount;
|
||||
CHANSVmExecutionCtx* measureIntegerExecCtx;
|
||||
CHANSVmExecutionCtx* writeIntegerExecCtx;
|
||||
|
||||
parentBlob = (BlobHeader*)VmGetStrFromObjHdr(VmParentObj);
|
||||
argStr = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, CHANSVmGetArg(VmInst, 0));
|
||||
@@ -5057,26 +5074,26 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
|
||||
case 4: {
|
||||
if (paramValue < 0) {
|
||||
if (argArr != vmNull) {
|
||||
obj = CHANSVmGetArrayElement(VmInst, argArr, argCount);
|
||||
measureBlobObj = CHANSVmGetArrayElement(VmInst, argArr, argCount);
|
||||
} else {
|
||||
obj = CHANSVmGetArg(VmInst, argCount + 1);
|
||||
measureBlobObj = CHANSVmGetArg(VmInst, argCount + 1);
|
||||
}
|
||||
if (CHANSVmCheckNativeInstance(obj, VmBlobClassName)) {
|
||||
srcBlob = (BlobHeader*)VmGetStrFromObjHdr(obj);
|
||||
if (CHANSVmCheckNativeInstance(measureBlobObj, VmBlobClassName)) {
|
||||
measureBlobSrcBlob = (BlobHeader*)VmGetStrFromObjHdr(measureBlobObj);
|
||||
} else {
|
||||
srcBlob = vmNull;
|
||||
measureBlobSrcBlob = vmNull;
|
||||
}
|
||||
if (srcBlob == vmNull) {
|
||||
if (measureBlobSrcBlob == vmNull) {
|
||||
goto error;
|
||||
}
|
||||
count = srcBlob->size - srcBlob->offset;
|
||||
measureBlobCount = measureBlobSrcBlob->size - measureBlobSrcBlob->offset;
|
||||
} else {
|
||||
count = paramValue;
|
||||
measureBlobCount = paramValue;
|
||||
}
|
||||
if (count < 0) {
|
||||
if (measureBlobCount < 0) {
|
||||
goto error;
|
||||
}
|
||||
totalSize += count;
|
||||
totalSize += measureBlobCount;
|
||||
argCount++;
|
||||
break;
|
||||
}
|
||||
@@ -5093,20 +5110,20 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
|
||||
case 9: {
|
||||
if (paramValue < 0) {
|
||||
if (argArr != vmNull) {
|
||||
count = CHANSVmGetArrayLength(VmInst, argArr);
|
||||
count = count - argCount;
|
||||
measureIntegerCount = CHANSVmGetArrayLength(VmInst, argArr);
|
||||
measureIntegerCount = measureIntegerCount - argCount;
|
||||
} else {
|
||||
execCtx = ((CHANSVmPrivate*)VmInst)->pActiveCtx;
|
||||
count = execCtx->argc - argCount - 1;
|
||||
measureIntegerExecCtx = ((CHANSVmPrivate*)VmInst)->pActiveCtx;
|
||||
measureIntegerCount = measureIntegerExecCtx->argc - argCount - 1;
|
||||
}
|
||||
} else {
|
||||
count = paramValue;
|
||||
measureIntegerCount = paramValue;
|
||||
}
|
||||
if (count < 0) {
|
||||
if (measureIntegerCount < 0) {
|
||||
goto error;
|
||||
}
|
||||
argCount += count;
|
||||
totalSize += elemSize * count;
|
||||
argCount += measureIntegerCount;
|
||||
totalSize += elemSize * measureIntegerCount;
|
||||
break;
|
||||
}
|
||||
case 10:
|
||||
@@ -5115,47 +5132,47 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
|
||||
case 13: {
|
||||
if (paramValue < 0) {
|
||||
if (argArr != vmNull) {
|
||||
obj = CHANSVmGetArrayElement(VmInst, argArr, argCount);
|
||||
obj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, obj);
|
||||
measureStringObj = CHANSVmGetArrayElement(VmInst, argArr, argCount);
|
||||
measureStringObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, measureStringObj);
|
||||
} else {
|
||||
obj = CHANSVmGetArg(VmInst, argCount + 1);
|
||||
obj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, obj);
|
||||
measureStringObj = CHANSVmGetArg(VmInst, argCount + 1);
|
||||
measureStringObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, measureStringObj);
|
||||
}
|
||||
if (obj == vmNull) {
|
||||
if (measureStringObj == vmNull) {
|
||||
goto error;
|
||||
}
|
||||
count = (u32)obj->value.int32_v->val >> 1;
|
||||
measureStringCount = (u32)measureStringObj->value.int32_v->val >> 1;
|
||||
} else {
|
||||
count = paramValue;
|
||||
measureStringCount = paramValue;
|
||||
}
|
||||
if (count < 0) {
|
||||
if (measureStringCount < 0) {
|
||||
goto error;
|
||||
}
|
||||
argCount++;
|
||||
totalSize += elemSize * count;
|
||||
totalSize += elemSize * measureStringCount;
|
||||
break;
|
||||
}
|
||||
case 14: {
|
||||
if (paramValue < 0) {
|
||||
if (argArr != vmNull) {
|
||||
obj = CHANSVmGetArrayElement(VmInst, argArr, argCount);
|
||||
obj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, obj);
|
||||
measureHexObj = CHANSVmGetArrayElement(VmInst, argArr, argCount);
|
||||
measureHexObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, measureHexObj);
|
||||
} else {
|
||||
obj = CHANSVmGetArg(VmInst, argCount + 1);
|
||||
obj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, obj);
|
||||
measureHexObj = CHANSVmGetArg(VmInst, argCount + 1);
|
||||
measureHexObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, measureHexObj);
|
||||
}
|
||||
if (obj == vmNull) {
|
||||
if (measureHexObj == vmNull) {
|
||||
goto error;
|
||||
}
|
||||
count = (u32)obj->value.int32_v->val >> 1;
|
||||
measureHexCount = (u32)measureHexObj->value.int32_v->val >> 1;
|
||||
} else {
|
||||
count = paramValue;
|
||||
measureHexCount = paramValue;
|
||||
}
|
||||
if (count < 0) {
|
||||
if (measureHexCount < 0) {
|
||||
goto error;
|
||||
}
|
||||
argCount++;
|
||||
totalSize += (s32)((u32)count + 1U) / 2;
|
||||
totalSize += (s32)((u32)measureHexCount + 1U) / 2;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -5180,8 +5197,8 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
|
||||
}
|
||||
}
|
||||
|
||||
argCount = 0;
|
||||
fmtPos = 0;
|
||||
writeArgCount = 0;
|
||||
writeFmtPos = 0;
|
||||
|
||||
while (vmTrue) {
|
||||
u32 nextPos = 0;
|
||||
@@ -5189,7 +5206,7 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
|
||||
u32 elemSize = 1;
|
||||
s32 paramValue = 1;
|
||||
|
||||
fmtPos = vmBlobParsePackFormatString(&nextPos, &elemType, &elemSize, (void*)¶mValue, fmtStr, fmtLen, fmtPos);
|
||||
writeFmtPos = vmBlobParsePackFormatString(&nextPos, &elemType, &elemSize, (void*)¶mValue, fmtStr, fmtLen, writeFmtPos);
|
||||
|
||||
if (elemType == 1) {
|
||||
break;
|
||||
@@ -5202,33 +5219,33 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
|
||||
switch (elemType) {
|
||||
case 4: {
|
||||
if (argArr != vmNull) {
|
||||
obj = CHANSVmGetArrayElement(VmInst, argArr, argCount);
|
||||
writeBlobObj = CHANSVmGetArrayElement(VmInst, argArr, writeArgCount);
|
||||
} else {
|
||||
obj = CHANSVmGetArg(VmInst, argCount + 1);
|
||||
writeBlobObj = CHANSVmGetArg(VmInst, writeArgCount + 1);
|
||||
}
|
||||
|
||||
if (CHANSVmCheckNativeInstance(obj, VmBlobClassName)) {
|
||||
srcBlob = (BlobHeader*)VmGetStrFromObjHdr(obj);
|
||||
if (CHANSVmCheckNativeInstance(writeBlobObj, VmBlobClassName)) {
|
||||
writeBlobSrcBlob = (BlobHeader*)VmGetStrFromObjHdr(writeBlobObj);
|
||||
} else {
|
||||
srcBlob = vmNull;
|
||||
writeBlobSrcBlob = vmNull;
|
||||
}
|
||||
argCount++;
|
||||
writeArgCount++;
|
||||
|
||||
if (srcBlob == vmNull) {
|
||||
if (writeBlobSrcBlob == vmNull) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
if (paramValue < 0) {
|
||||
copySize = srcBlob->size - srcBlob->offset;
|
||||
writeBlobCopySize = writeBlobSrcBlob->size - writeBlobSrcBlob->offset;
|
||||
} else {
|
||||
copySize = paramValue;
|
||||
writeBlobCopySize = paramValue;
|
||||
}
|
||||
|
||||
if (copySize < 0 || !CHANSVmBlobHasSpace(parentBlob, copySize)) {
|
||||
if (writeBlobCopySize < 0 || !CHANSVmBlobHasSpace(parentBlob, writeBlobCopySize)) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
VmBlobCopyPadded(parentBlob, srcBlob, copySize);
|
||||
VmBlobCopyPadded(parentBlob, writeBlobSrcBlob, writeBlobCopySize);
|
||||
break;
|
||||
}
|
||||
case 5: {
|
||||
@@ -5247,38 +5264,38 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
|
||||
case 9: {
|
||||
if (paramValue < 0) {
|
||||
if (argArr != vmNull) {
|
||||
count = CHANSVmGetArrayLength(VmInst, argArr) - argCount;
|
||||
writeIntegerCount = CHANSVmGetArrayLength(VmInst, argArr) - writeArgCount;
|
||||
} else {
|
||||
execCtx = ((CHANSVmPrivate*)VmInst)->pActiveCtx;
|
||||
count = execCtx->argc - argCount - 1;
|
||||
writeIntegerExecCtx = ((CHANSVmPrivate*)VmInst)->pActiveCtx;
|
||||
writeIntegerCount = writeIntegerExecCtx->argc - writeArgCount - 1;
|
||||
}
|
||||
} else {
|
||||
count = paramValue;
|
||||
writeIntegerCount = paramValue;
|
||||
}
|
||||
if (count < 0) {
|
||||
if (writeIntegerCount < 0) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
if (!CHANSVmBlobHasSpace(parentBlob, elemSize * count)) {
|
||||
if (!CHANSVmBlobHasSpace(parentBlob, elemSize * writeIntegerCount)) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
for (writeIntegerI = 0; writeIntegerI < writeIntegerCount; writeIntegerI++) {
|
||||
packBuf[1] = 0;
|
||||
packBuf[0] = 0;
|
||||
if (argArr != vmNull) {
|
||||
intObj = CHANSVmGetArrayElement(VmInst, argArr, argCount);
|
||||
intObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_INTEGER, intObj);
|
||||
writeIntegerIntObj = CHANSVmGetArrayElement(VmInst, argArr, writeArgCount);
|
||||
writeIntegerIntObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_INTEGER, writeIntegerIntObj);
|
||||
} else {
|
||||
intObj = CHANSVmGetArg(VmInst, argCount + 1);
|
||||
intObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_INTEGER, intObj);
|
||||
writeIntegerIntObj = CHANSVmGetArg(VmInst, writeArgCount + 1);
|
||||
writeIntegerIntObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_INTEGER, writeIntegerIntObj);
|
||||
}
|
||||
argCount++;
|
||||
if (intObj == vmNull) {
|
||||
writeArgCount++;
|
||||
if (writeIntegerIntObj == vmNull) {
|
||||
goto error;
|
||||
}
|
||||
valLow = (u32)intObj->value.int_v;
|
||||
valHigh = (u32)((u64)intObj->value.int_v >> 32);
|
||||
writeIntegerValLow = (u32)writeIntegerIntObj->value.int_v;
|
||||
writeIntegerValHigh = (u32)((u64)writeIntegerIntObj->value.int_v >> 32);
|
||||
|
||||
switch ((s32)elemType) {
|
||||
case 6:
|
||||
@@ -5286,20 +5303,20 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
|
||||
// signed
|
||||
switch (elemSize) {
|
||||
case 1: {
|
||||
*(s8*)packBuf = (s8)valLow;
|
||||
*(s8*)packBuf = (s8)writeIntegerValLow;
|
||||
break;
|
||||
}
|
||||
case 2: {
|
||||
*(s16*)packBuf = (s16)valLow;
|
||||
*(s16*)packBuf = (s16)writeIntegerValLow;
|
||||
break;
|
||||
}
|
||||
case 4: {
|
||||
packBuf[0] = valLow;
|
||||
*(s32*)packBuf = writeIntegerValLow;
|
||||
break;
|
||||
}
|
||||
case 8: {
|
||||
packBuf[1] = valLow;
|
||||
packBuf[0] = valHigh;
|
||||
((s32*)packBuf)[1] = writeIntegerValLow;
|
||||
*(s32*)packBuf = writeIntegerValHigh;
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
@@ -5313,15 +5330,15 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
|
||||
// unsigned
|
||||
switch (elemSize) {
|
||||
case 1: {
|
||||
*(u8*)packBuf = (u8)valLow;
|
||||
*(u8*)packBuf = (u8)writeIntegerValLow;
|
||||
break;
|
||||
}
|
||||
case 2: {
|
||||
*(u16*)packBuf = (u16)valLow;
|
||||
*(u16*)packBuf = (u16)writeIntegerValLow;
|
||||
break;
|
||||
}
|
||||
case 4: {
|
||||
packBuf[0] = valLow;
|
||||
*(u32*)packBuf = writeIntegerValLow;
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
@@ -5350,7 +5367,7 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
|
||||
break;
|
||||
}
|
||||
case 4: {
|
||||
__stwbrx(packBuf[0], packBuf, 0);
|
||||
__stwbrx(*(u32*)packBuf, packBuf, 0);
|
||||
break;
|
||||
}
|
||||
case 8: {
|
||||
@@ -5371,100 +5388,100 @@ static vmBoolInt VmBlobPackCommon(CHANSVm* VmInst, CHANSVmObjHdr* VmParentObj, C
|
||||
case 12:
|
||||
case 13: {
|
||||
if (argArr != vmNull) {
|
||||
strObj = CHANSVmGetArrayElement(VmInst, argArr, argCount);
|
||||
strObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, strObj);
|
||||
writeStringStrObj = CHANSVmGetArrayElement(VmInst, argArr, writeArgCount);
|
||||
writeStringStrObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, writeStringStrObj);
|
||||
} else {
|
||||
strObj = CHANSVmGetArg(VmInst, argCount + 1);
|
||||
strObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, strObj);
|
||||
writeStringStrObj = CHANSVmGetArg(VmInst, writeArgCount + 1);
|
||||
writeStringStrObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, writeStringStrObj);
|
||||
}
|
||||
argCount++;
|
||||
if (strObj == vmNull) {
|
||||
writeArgCount++;
|
||||
if (writeStringStrObj == vmNull) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
if (paramValue < 0) {
|
||||
count = (u32)strObj->value.int32_v->val >> 1;
|
||||
writeStringCount = (u32)writeStringStrObj->value.int32_v->val >> 1;
|
||||
} else {
|
||||
count = paramValue;
|
||||
writeStringCount = paramValue;
|
||||
}
|
||||
if (count < 0) {
|
||||
if (writeStringCount < 0) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
if (!CHANSVmBlobHasSpace(parentBlob, elemSize * count)) {
|
||||
if (!CHANSVmBlobHasSpace(parentBlob, elemSize * writeStringCount)) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
srcData = (u8*)VmGetStrFromObjHdr(strObj);
|
||||
strLen = (u32)VmGetIntFromObjHdr(strObj) >> 1;
|
||||
charCount = strLen;
|
||||
dest = parentBlob->pData + parentBlob->offset;
|
||||
writeStringSrcData = (u8*)VmGetStrFromObjHdr(writeStringStrObj);
|
||||
writeStringStrLen = (u32)VmGetIntFromObjHdr(writeStringStrObj) >> 1;
|
||||
writeStringCharCount = writeStringStrLen;
|
||||
writeStringDest = parentBlob->pData + parentBlob->offset;
|
||||
|
||||
if (charCount > count) {
|
||||
charCount = count;
|
||||
if (writeStringCharCount > writeStringCount) {
|
||||
writeStringCharCount = writeStringCount;
|
||||
}
|
||||
|
||||
memset(dest, 0, elemSize * count);
|
||||
memset(writeStringDest, 0, elemSize * writeStringCount);
|
||||
if (elemSize == 1) {
|
||||
CHANSVmStrCpyToU8FromU16(dest, srcData, charCount);
|
||||
CHANSVmStrCpyToU8FromU16(writeStringDest, writeStringSrcData, writeStringCharCount);
|
||||
} else {
|
||||
memcpy(dest, srcData, elemSize * charCount);
|
||||
memcpy(writeStringDest, writeStringSrcData, elemSize * writeStringCharCount);
|
||||
}
|
||||
parentBlob->offset += elemSize * count;
|
||||
parentBlob->offset += elemSize * writeStringCount;
|
||||
break;
|
||||
}
|
||||
case 14: {
|
||||
if (argArr != vmNull) {
|
||||
strObj = CHANSVmGetArrayElement(VmInst, argArr, argCount);
|
||||
strObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, strObj);
|
||||
writeHexStrObj = CHANSVmGetArrayElement(VmInst, argArr, writeArgCount);
|
||||
writeHexStrObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, writeHexStrObj);
|
||||
} else {
|
||||
strObj = CHANSVmGetArg(VmInst, argCount + 1);
|
||||
strObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, strObj);
|
||||
writeHexStrObj = CHANSVmGetArg(VmInst, writeArgCount + 1);
|
||||
writeHexStrObj = CHANSVmConvertObjectType(VmInst, CHANS_VM_OBJ_TYPE_STRING, writeHexStrObj);
|
||||
}
|
||||
argCount++;
|
||||
if (strObj == vmNull) {
|
||||
writeArgCount++;
|
||||
if (writeHexStrObj == vmNull) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
if (paramValue < 0) {
|
||||
count = (u32)strObj->value.int32_v->val >> 1;
|
||||
writeHexCount = (u32)writeHexStrObj->value.int32_v->val >> 1;
|
||||
} else {
|
||||
count = paramValue;
|
||||
writeHexCount = paramValue;
|
||||
}
|
||||
if (count < 0) {
|
||||
if (writeHexCount < 0) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
bufSize = (s32)((u32)count + 1U) / 2;
|
||||
if (!CHANSVmBlobHasSpace(parentBlob, bufSize)) {
|
||||
writeHexBufSize = (s32)((u32)writeHexCount + 1U) / 2;
|
||||
if (!CHANSVmBlobHasSpace(parentBlob, writeHexBufSize)) {
|
||||
goto error;
|
||||
}
|
||||
|
||||
srcData = (u8*)VmGetStrFromObjHdr(strObj);
|
||||
strLen = (u32)VmGetIntFromObjHdr(strObj) >> 1;
|
||||
dest = parentBlob->pData + parentBlob->offset;
|
||||
memset(dest, 0, bufSize);
|
||||
writeHexSrcData = (u8*)VmGetStrFromObjHdr(writeHexStrObj);
|
||||
VmGetIntFromObjHdr(writeHexStrObj);
|
||||
writeHexDest = parentBlob->pData + parentBlob->offset;
|
||||
memset(writeHexDest, 0, writeHexBufSize);
|
||||
|
||||
for (i = 0; (s32)i < count; i++) {
|
||||
ch = ((const u16*)srcData)[i];
|
||||
if (ch >= 0x30 && ch <= 0x39) {
|
||||
ch -= 0x30;
|
||||
} else if (ch >= 0x61 && ch <= 0x66) {
|
||||
ch -= 0x57;
|
||||
} else if (ch >= 0x41 && ch <= 0x46) {
|
||||
ch -= 0x37;
|
||||
for (writeHexI = 0; (s32)writeHexI < writeHexCount; writeHexI++) {
|
||||
writeHexCh = ((const u16*)writeHexSrcData)[writeHexI];
|
||||
if (writeHexCh >= 0x30 && writeHexCh <= 0x39) {
|
||||
writeHexCh -= 0x30;
|
||||
} else if (writeHexCh >= 0x61 && writeHexCh <= 0x66) {
|
||||
writeHexCh -= 0x57;
|
||||
} else if (writeHexCh >= 0x41 && writeHexCh <= 0x46) {
|
||||
writeHexCh -= 0x37;
|
||||
} else {
|
||||
ch = 0;
|
||||
writeHexCh = 0;
|
||||
}
|
||||
if ((i & 1) == 0) {
|
||||
ch *= 16;
|
||||
if ((writeHexI & 1) == 0) {
|
||||
writeHexCh *= 16;
|
||||
}
|
||||
*dest |= ch & 0xFF;
|
||||
if (i & 1) {
|
||||
dest++;
|
||||
*writeHexDest |= writeHexCh & 0xFF;
|
||||
if (writeHexI & 1) {
|
||||
writeHexDest++;
|
||||
}
|
||||
}
|
||||
parentBlob->offset += bufSize;
|
||||
parentBlob->offset += writeHexBufSize;
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
#define TI_CANDIDATEBOX_IMPLEMENTATION
|
||||
#define TI_CANDIDATEBOX_SAMPLE_CLASS
|
||||
#include "keyboard/tiCandidateBox.h"
|
||||
#undef TI_CANDIDATEBOX_SAMPLE_CLASS
|
||||
|
||||
#include "keyboard/tiManager.h"
|
||||
|
||||
@@ -60,11 +62,7 @@ namespace textinput {
|
||||
{ANM_InvalidOff, "fs_VK_predictInput_a_invalidMode_OFF.brlan"},
|
||||
};
|
||||
|
||||
struct CandidatePaneData {
|
||||
PaneToAnimation panes[26];
|
||||
};
|
||||
|
||||
extern "C" const CandidatePaneData scCandidatePaneData __attribute__((aligned(8))) = {{
|
||||
static const PaneToAnimation csPaneToAnimation[] = {
|
||||
{KT_CandidateText, "N_predictInput", 1, NULL, {&csAninationFile[0]}},
|
||||
{KT_ScrollButton,
|
||||
"P_prdc_scrl_Left",
|
||||
@@ -195,7 +193,7 @@ namespace textinput {
|
||||
6,
|
||||
NULL,
|
||||
{&csAninationFile[0], &csAninationFile[8], &csAninationFile[9], &csAninationFile[10], &csAninationFile[11], &csAninationFile[12]}},
|
||||
}};
|
||||
};
|
||||
|
||||
void CandidateBoxCaller::Candidates::addCandidate(const wchar_t* wcString) {
|
||||
wcsncpy(szwcPredicted[mNumCandidate], wcString, ARRAY_LENGTH(szwcPredicted[0]));
|
||||
@@ -376,50 +374,44 @@ namespace textinput {
|
||||
}
|
||||
|
||||
void LayoutByNW4R::createAnmPane_(MEMAllocator* allocator) {
|
||||
u32 animationCount;
|
||||
const char* forceAddName;
|
||||
u16 i;
|
||||
for (i = 0; i < ARRAY_LENGTH(scCandidatePaneData.panes); i++) {
|
||||
const PaneToAnimation& p = scCandidatePaneData.panes[i];
|
||||
for (u16 i = 0; i < ARRAY_LENGTH(csPaneToAnimation); i++) {
|
||||
const PaneToAnimation& paneAnimations = csPaneToAnimation[i];
|
||||
CandidateTextAnmPane* pane = NULL;
|
||||
switch (p.type) {
|
||||
switch (paneAnimations.type) {
|
||||
case KT_ScrollButton: {
|
||||
void* pBtnBuf = MEMAllocFromAllocator(allocator, sizeof(CandidateScrollAnmPane));
|
||||
pane = new (pBtnBuf) CandidateScrollAnmPane(getPane(p.paneName), NULL);
|
||||
pane = new (pBtnBuf) CandidateScrollAnmPane(getPane(paneAnimations.paneName), NULL);
|
||||
break;
|
||||
}
|
||||
case KT_CandidateText: {
|
||||
void* pBtnBuf = MEMAllocFromAllocator(allocator, sizeof(CandidateTextAnmPane));
|
||||
pane = new (pBtnBuf) CandidateTextAnmPane(getPane(p.paneName), NULL);
|
||||
pane = new (pBtnBuf) CandidateTextAnmPane(getPane(paneAnimations.paneName), NULL);
|
||||
break;
|
||||
}
|
||||
case KT_OnOffButton: {
|
||||
void* pBtnBuf = MEMAllocFromAllocator(allocator, sizeof(OnOffAnmPane));
|
||||
pane = new (pBtnBuf) OnOffAnmPane(getPane(p.paneName), &mOnOffButton);
|
||||
pane = new (pBtnBuf) OnOffAnmPane(getPane(paneAnimations.paneName), &mOnOffButton);
|
||||
break;
|
||||
}
|
||||
|
||||
case KT_Window: {
|
||||
void* pBtnBuf = MEMAllocFromAllocator(allocator, sizeof(PredictWindow));
|
||||
pane = new (pBtnBuf) PredictWindow(getPane(p.paneName), &mTextWindow);
|
||||
pane = new (pBtnBuf) PredictWindow(getPane(paneAnimations.paneName), &mTextWindow);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
nw4r::ut::List_Append(&mAnmPanes, pane);
|
||||
|
||||
forceAddName = p.forceAddName;
|
||||
animationCount = p.count;
|
||||
for (u16 j = 0; j < animationCount; j++) {
|
||||
const AnimationFile* const& animation = p.pAnims[j];
|
||||
void* pResource = mpMultiArcResourceAccessor->GetResource(0, animation->fileName);
|
||||
for (u16 j = 0; j < paneAnimations.count; j++) {
|
||||
void* pResource = mpMultiArcResourceAccessor->GetResource(0, paneAnimations.pAnims[j]->fileName);
|
||||
AnimTransformPane* transform =
|
||||
static_cast<AnimTransformPane*>(getLayout()->CreateAnimTransform(pResource, mpMultiArcResourceAccessor));
|
||||
|
||||
if (forceAddName == NULL) {
|
||||
pane->addAnimation(allocator, animation->id, transform, false, true);
|
||||
if (paneAnimations.forceAddName == NULL) {
|
||||
pane->addAnimation(allocator, paneAnimations.pAnims[j]->id, transform, false, true);
|
||||
} else {
|
||||
pane->forceAddAnimation(allocator, animation->id, transform, forceAddName, false, true);
|
||||
pane->forceAddAnimation(allocator, paneAnimations.pAnims[j]->id, transform, paneAnimations.forceAddName, false, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -678,8 +670,8 @@ namespace textinput {
|
||||
}
|
||||
|
||||
void LayoutByNW4R::cancelStateFocusIn() {
|
||||
const PaneToAnimation* pane = scCandidatePaneData.panes;
|
||||
for (int i = 0; i < ARRAY_LENGTH(scCandidatePaneData.panes); i++) {
|
||||
const PaneToAnimation* pane = csPaneToAnimation;
|
||||
for (int i = 0; i < ARRAY_LENGTH(csPaneToAnimation); i++) {
|
||||
CandidateTextAnmPane* p = static_cast<CandidateTextAnmPane*>(searchAnmPane(pane->paneName));
|
||||
if (p != NULL) {
|
||||
switch (p->getKeyType()) {
|
||||
@@ -1766,3 +1758,48 @@ namespace textinput {
|
||||
|
||||
} // namespace candidatebox
|
||||
} // namespace textinput
|
||||
|
||||
inline void textinput::util::Animation::startAnm(AnimObserver* observer, f32 start, f32 end, f32 duration, void* data) {
|
||||
mfStartPoint = start;
|
||||
mfEndPoint = end;
|
||||
mfAnimationTime = duration;
|
||||
mfCurrentFrame = 0.0f;
|
||||
mbInAnimation = true;
|
||||
mpAnimObserver = observer;
|
||||
mpData = data;
|
||||
mbSE = false;
|
||||
if (observer) observer->onAnmEvent(AnimObserver::AE_0, data);
|
||||
}
|
||||
|
||||
inline void textinput::util::Animation::calc() {
|
||||
if (mbInAnimation) {
|
||||
if (mfCurrentFrame < mfAnimationTime) {
|
||||
mfCurrentFrame = 1.0f + mfCurrentFrame;
|
||||
} else {
|
||||
if (mbInAnimation && mpAnimObserver) {
|
||||
mpAnimObserver->onAnmEvent(AnimObserver::AE_1, mpData);
|
||||
}
|
||||
mbInAnimation = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline f32 textinput::util::Animation::getValue() {
|
||||
return hermiteInterporation(mfCurrentFrame, 0.0f, mfStartPoint, 0.0f, mfAnimationTime, mfEndPoint, 0.0f);
|
||||
}
|
||||
|
||||
inline bool textinput::util::Animation::isActive() {
|
||||
return mbInAnimation;
|
||||
}
|
||||
|
||||
inline void textinput::util::Animation::setSEFlag(bool flag) {
|
||||
mbSE = flag;
|
||||
}
|
||||
|
||||
inline bool textinput::util::Animation::isSEFlag() {
|
||||
return mbSE;
|
||||
}
|
||||
|
||||
inline void textinput::util::Animation::stop() {
|
||||
mbInAnimation = false;
|
||||
}
|
||||
|
||||
@@ -892,68 +892,62 @@ s32 CArGBAOdh::cdj_c_colorConv(SArCDJ_OdhMaster* master, u8* sourceData, int for
|
||||
void CArGBAOdh::LineConv11(u8* source, u8* lumaOutput, u8* cbOutput, u8* crOutput, u16 width, u16 height,
|
||||
const long* conversionTable, int format) {
|
||||
u32 planeSize = (u32)width * (u32)height;
|
||||
const s32* table = conversionTable;
|
||||
u32 pixelIndex = 0;
|
||||
|
||||
for (int i = 0; i < width; i++) {
|
||||
s32 red;
|
||||
s32 green;
|
||||
s32 blue;
|
||||
s32 red;
|
||||
s32 green;
|
||||
s32 blue;
|
||||
s32 cbValue;
|
||||
s32 crValue;
|
||||
|
||||
if (format == ODH_FORMAT_RGB565) {
|
||||
u8* pixelSource = source + (pixelIndex & 0x1FFFFFFC) * 8 + (pixelIndex & 3) * 2;
|
||||
u16 pixel = pixelSource[1];
|
||||
pixel |= (u16)pixelSource[0] << 8;
|
||||
red = (pixel >> 11) & 0x1F;
|
||||
green = (pixel >> 6) & 0x1F;
|
||||
blue = pixel & 0x1F;
|
||||
} else if (format == ODH_FORMAT_RGBA8) {
|
||||
int blueOrPixelOffset = (pixelIndex & 0xFFFFFFFC) * 0x10 + (pixelIndex & 3) * 2;
|
||||
u8* pixel = source + blueOrPixelOffset;
|
||||
red = pixel[1] >> 3;
|
||||
green = pixel[0x20] >> 3;
|
||||
blue = pixel[0x21] >> 3;
|
||||
} else {
|
||||
int sourceOffset = (pixelIndex & 7) + (pixelIndex & 0x3FFFFFF8) * 4;
|
||||
float y = (float)source[sourceOffset] - colorConvert16;
|
||||
float cb = (float)source[planeSize + sourceOffset] - colorConvert128;
|
||||
float cr = (float)source[planeSize * 2 + sourceOffset] - colorConvert128;
|
||||
red = (int)(colorConvertY * y + colorConvertR * cr);
|
||||
green = (int)(colorConvertY * y - colorConvertG1 * cb - colorConvertG2 * cr);
|
||||
blue = (int)(colorConvertY * y + colorConvertB * cb);
|
||||
|
||||
if (red < 0) {
|
||||
red = 0;
|
||||
}
|
||||
if (0xFF < red) {
|
||||
red = 0xFF;
|
||||
}
|
||||
if (green < 0) {
|
||||
green = 0;
|
||||
}
|
||||
if (0xFF < green) {
|
||||
green = 0xFF;
|
||||
}
|
||||
if (blue < 0) {
|
||||
blue = 0;
|
||||
}
|
||||
if (0xFF < blue) {
|
||||
blue = 0xFF;
|
||||
}
|
||||
|
||||
red >>= 3;
|
||||
green >>= 3;
|
||||
blue >>= 3;
|
||||
if (format == ODH_FORMAT_RGB565) {
|
||||
int offset = (i & ~3) * 8 + (i & 3) * 2;
|
||||
u16 pixel = source[offset];
|
||||
pixel <<= 8;
|
||||
pixel |= source[offset + 1];
|
||||
red = (pixel >> 11) & 0x1F;
|
||||
green = (pixel >> 6) & 0x1F;
|
||||
blue = pixel & 0x1F;
|
||||
} else if (format == ODH_FORMAT_RGBA8) {
|
||||
int offset = (i & ~3) * 16 + (i & 3) * 2;
|
||||
red = source[offset + 1] >> 3;
|
||||
green = source[offset + 0x20] >> 3;
|
||||
blue = source[offset + 0x21] >> 3;
|
||||
} else {
|
||||
int offset = (i & 7) + (i & ~7) * 4;
|
||||
float y = source[offset] - colorConvert16;
|
||||
float cb = source[planeSize + offset] - colorConvert128;
|
||||
float cr = source[planeSize * 2 + offset] - colorConvert128;
|
||||
red = colorConvertY * y + colorConvertR * cr;
|
||||
green = colorConvertY * y - colorConvertG1 * cb - colorConvertG2 * cr;
|
||||
blue = colorConvertY * y + colorConvertB * cb;
|
||||
if (red < 0) {
|
||||
red = 0;
|
||||
}
|
||||
if (red > 0xFF) {
|
||||
red = 0xFF;
|
||||
}
|
||||
if (green < 0) {
|
||||
green = 0;
|
||||
}
|
||||
if (green > 0xFF) {
|
||||
green = 0xFF;
|
||||
}
|
||||
if (blue < 0) {
|
||||
blue = 0;
|
||||
}
|
||||
if (blue > 0xFF) {
|
||||
blue = 0xFF;
|
||||
}
|
||||
red >>= 3;
|
||||
green >>= 3;
|
||||
blue >>= 3;
|
||||
}
|
||||
|
||||
int cbValue = (table[red + 0x60] + table[green + 0x80] + table[blue + 0xA0]) >> 16;
|
||||
int crValue = (table[red + 0xC0] + table[green + 0xE0] + table[blue + 0x100]) >> 16;
|
||||
int luma = (table[red + 0] + table[green + 0x20] + table[blue + 0x40]) >> 16;
|
||||
|
||||
*lumaOutput++ = (u8)luma;
|
||||
*cbOutput++ = (u8)cbValue;
|
||||
*crOutput++ = (u8)crValue;
|
||||
pixelIndex++;
|
||||
cbValue = (conversionTable[red + 0x60] + conversionTable[green + 0x80] + conversionTable[blue + 0xA0]) >> 16;
|
||||
crValue = (conversionTable[red + 0xC0] + conversionTable[green + 0xE0] + conversionTable[blue + 0x100]) >> 16;
|
||||
*lumaOutput++ = (conversionTable[red] + conversionTable[green + 0x20] + conversionTable[blue + 0x40]) >> 16;
|
||||
*cbOutput++ = cbValue;
|
||||
*crOutput++ = crValue;
|
||||
}
|
||||
}
|
||||
void CArGBAOdh::fdct_fast(u32* coefficients, u8* samples, u32 stride, u32* quantizationTable) {
|
||||
@@ -2007,208 +2001,206 @@ void CArGBAOdh::LineDeconv22(u8* dest, u8* y, u8* cb, u8* cr, u16 width, u16 hei
|
||||
}
|
||||
|
||||
s32 CArGBAOdh::huffmanDecoder(u32* coefficientOutput, SArCDJ_HuffmanRequest* request, u16** huffmanTables, int component, u32 sourceLimit) {
|
||||
u32 bitBuffer;
|
||||
u32 tableCount;
|
||||
s32 decodeResult;
|
||||
int bitIndex;
|
||||
s32 maximumBitLength;
|
||||
int maxHuffmanBits;
|
||||
u16 tableEntry;
|
||||
s32 valueCategory;
|
||||
u32 tableIndex;
|
||||
u32 magnitudeMask;
|
||||
int bytesConsumed;
|
||||
u8* sourceCursor;
|
||||
u32 decodedSymbol;
|
||||
u32 bitCountAndMask;
|
||||
u32 bitOffset;
|
||||
int coefficient;
|
||||
s32 category;
|
||||
int bytesConsumed;
|
||||
u32 bitBuffer;
|
||||
int length;
|
||||
u32 tableIndex;
|
||||
int maxLength;
|
||||
u32 value;
|
||||
u32 mask;
|
||||
u32 leafIndex;
|
||||
u32 run;
|
||||
u32 i;
|
||||
|
||||
bytesConsumed = request->bytesConsumed;
|
||||
sourceCursor = request->bitstream;
|
||||
u32 bitOffset = *request->bitCount;
|
||||
bitOffset = *request->bitCount;
|
||||
|
||||
if ((u32)(bytesConsumed + 4) > sourceLimit) {
|
||||
decodeResult = ODH_ERROR_INVALID_BITSTREAM;
|
||||
} else {
|
||||
maximumBitLength = 0xB;
|
||||
bitBuffer = ((u32)*sourceCursor << 0x18) | ((u32)sourceCursor[1] << 0x10) | ((u32)sourceCursor[2] << 8) | sourceCursor[3];
|
||||
bitBuffer <<= bitOffset;
|
||||
if (component == 0) {
|
||||
maximumBitLength = 9;
|
||||
}
|
||||
bitIndex = 1;
|
||||
tableIndex = 0;
|
||||
maxHuffmanBits = (int)maximumBitLength;
|
||||
for (; bitIndex <= maxHuffmanBits; bitIndex++) {
|
||||
tableEntry = huffmanTables[0][tableIndex];
|
||||
decodedSymbol = (u32)tableEntry & 0x3FFF;
|
||||
if (((bitBuffer >> (0x20U - bitIndex)) & 1) == 0) {
|
||||
if ((tableEntry & 0x8000) != 0) {
|
||||
valueCategory = huffmanTables[0][tableIndex + decodedSymbol];
|
||||
break;
|
||||
}
|
||||
tableIndex = tableIndex + decodedSymbol;
|
||||
} else {
|
||||
if ((tableEntry & 0x4000) != 0) {
|
||||
u32 leafIndex = tableIndex + decodedSymbol + 1;
|
||||
valueCategory = huffmanTables[0][leafIndex];
|
||||
break;
|
||||
}
|
||||
tableIndex = tableIndex + decodedSymbol + 1;
|
||||
}
|
||||
}
|
||||
if (bitIndex > maxHuffmanBits) {
|
||||
decodeResult = ODH_ERROR_INVALID_BITSTREAM;
|
||||
return ODH_ERROR_INVALID_BITSTREAM;
|
||||
}
|
||||
|
||||
bitBuffer = ((u32)sourceCursor[0] << 24 | (u32)sourceCursor[1] << 16 | (u32)sourceCursor[2] << 8 | sourceCursor[3]) << bitOffset;
|
||||
maxLength = component == 0 ? 9 : 11;
|
||||
|
||||
length = 1;
|
||||
tableIndex = 0;
|
||||
for (; length <= maxLength; length++) {
|
||||
u32 branch;
|
||||
u16 node;
|
||||
|
||||
node = huffmanTables[0][tableIndex];
|
||||
branch = node & 0x3FFF;
|
||||
if (((bitBuffer >> (32 - length)) & 1) == 0) {
|
||||
if (node & 0x8000) {
|
||||
category = huffmanTables[0][tableIndex + branch];
|
||||
break;
|
||||
}
|
||||
tableIndex += branch;
|
||||
} else {
|
||||
if (valueCategory > 0) {
|
||||
bitCountAndMask = (1 << (valueCategory)) - 1;
|
||||
bitBuffer = bitCountAndMask & (bitBuffer >> ((0x20 - bitIndex) - valueCategory));
|
||||
if ((bitBuffer & (1 << (valueCategory - 1))) == 0) {
|
||||
bitBuffer = bitBuffer + 1 | ~bitCountAndMask;
|
||||
}
|
||||
} else {
|
||||
bitBuffer = 0;
|
||||
if (node & 0x4000) {
|
||||
leafIndex = tableIndex + branch + 1;
|
||||
category = huffmanTables[0][leafIndex];
|
||||
break;
|
||||
}
|
||||
u32** predictors = request->predictors;
|
||||
u32* predictor = predictors[component >> 1];
|
||||
bitCountAndMask = bitOffset + bitIndex + valueCategory;
|
||||
tableIndex = (bitCountAndMask >> 3);
|
||||
decodedSymbol = 1;
|
||||
bitIndex = (int)bitBuffer + *predictor;
|
||||
*coefficientOutput = bitIndex;
|
||||
*predictors[component >> 1] = bitIndex;
|
||||
while (bitCountAndMask >= 8) {
|
||||
sourceCursor++;
|
||||
bytesConsumed++;
|
||||
bitCountAndMask -= 8;
|
||||
}
|
||||
do {
|
||||
if ((u32)(bytesConsumed + 4) > sourceLimit) {
|
||||
decodeResult = ODH_ERROR_INVALID_BITSTREAM;
|
||||
goto finishDecode;
|
||||
}
|
||||
bitIndex = 1;
|
||||
tableIndex = 0;
|
||||
bitBuffer = ((u32)*sourceCursor << 0x18) | ((u32)sourceCursor[1] << 0x10) | ((u32)sourceCursor[2] << 8) | sourceCursor[3];
|
||||
bitBuffer <<= bitCountAndMask;
|
||||
maximumBitLength = 6;
|
||||
for (; maximumBitLength != 0; maximumBitLength--) {
|
||||
tableEntry = huffmanTables[1][tableIndex];
|
||||
tableCount = (u32)tableEntry & 0x3FFF;
|
||||
if (((bitBuffer >> (0x20U - bitIndex)) & 1) == 0) {
|
||||
if ((tableEntry & 0x8000) != 0) {
|
||||
valueCategory = huffmanTables[1][tableIndex + tableCount];
|
||||
break;
|
||||
}
|
||||
tableIndex = tableIndex + tableCount;
|
||||
} else {
|
||||
if ((tableEntry & 0x4000) != 0) {
|
||||
valueCategory = huffmanTables[1][tableIndex + tableCount + 1];
|
||||
break;
|
||||
}
|
||||
tableIndex = tableIndex + tableCount + 1;
|
||||
}
|
||||
bitIndex++;
|
||||
}
|
||||
if (bitIndex > 6) {
|
||||
decodeResult = ODH_ERROR_INVALID_BITSTREAM;
|
||||
goto finishDecode;
|
||||
}
|
||||
if (valueCategory == 7) {
|
||||
bitCountAndMask += bitIndex;
|
||||
tableIndex = (bitCountAndMask >> 3);
|
||||
while (bitCountAndMask >= 8) {
|
||||
sourceCursor++;
|
||||
bytesConsumed++;
|
||||
bitCountAndMask -= 8;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (valueCategory > 0) {
|
||||
tableIndex = (u32)(1 << (valueCategory)) - 1 &
|
||||
(bitBuffer >> ((0x20 - bitIndex) - valueCategory));
|
||||
if ((tableIndex & (u32)(1 << (valueCategory - 1))) == 0) {
|
||||
decodeResult = ODH_ERROR_INVALID_BITSTREAM;
|
||||
goto finishDecode;
|
||||
}
|
||||
} else {
|
||||
tableIndex = 0;
|
||||
}
|
||||
for (u32 zeroIndex = 0; zeroIndex < tableIndex; zeroIndex++) {
|
||||
coefficientOutput[decodedSymbol] = 0;
|
||||
decodedSymbol++;
|
||||
}
|
||||
bitCountAndMask = bitCountAndMask + bitIndex + valueCategory;
|
||||
tableIndex = (bitCountAndMask >> 3);
|
||||
while (bitCountAndMask >= 8) {
|
||||
sourceCursor++;
|
||||
bytesConsumed++;
|
||||
bitCountAndMask -= 8;
|
||||
}
|
||||
if ((u32)(bytesConsumed + 4) > sourceLimit) {
|
||||
decodeResult = ODH_ERROR_INVALID_BITSTREAM;
|
||||
goto finishDecode;
|
||||
}
|
||||
maximumBitLength = 0xB;
|
||||
bitBuffer = ((u32)*sourceCursor << 0x18) | ((u32)sourceCursor[1] << 0x10) | ((u32)sourceCursor[2] << 8) | sourceCursor[3];
|
||||
bitBuffer <<= bitCountAndMask;
|
||||
if (component == 0) {
|
||||
maximumBitLength = 9;
|
||||
}
|
||||
bitIndex = 1;
|
||||
tableIndex = 0;
|
||||
maxHuffmanBits = (int)maximumBitLength;
|
||||
for (; bitIndex <= maxHuffmanBits; bitIndex++) {
|
||||
tableEntry = huffmanTables[0][tableIndex];
|
||||
tableCount = (u32)tableEntry & 0x3FFF;
|
||||
if (((bitBuffer >> (0x20U - bitIndex)) & 1) == 0) {
|
||||
if ((tableEntry & 0x8000) != 0) {
|
||||
valueCategory = huffmanTables[0][tableIndex + tableCount];
|
||||
break;
|
||||
}
|
||||
tableIndex = tableIndex + tableCount;
|
||||
} else {
|
||||
if ((tableEntry & 0x4000) != 0) {
|
||||
valueCategory = huffmanTables[0][tableIndex + tableCount + 1];
|
||||
break;
|
||||
}
|
||||
tableIndex = tableIndex + tableCount + 1;
|
||||
}
|
||||
}
|
||||
if (bitIndex > maxHuffmanBits) {
|
||||
decodeResult = ODH_ERROR_INVALID_BITSTREAM;
|
||||
goto finishDecode;
|
||||
}
|
||||
if (valueCategory > 0) {
|
||||
magnitudeMask = (1 << (valueCategory)) - 1;
|
||||
bitBuffer = magnitudeMask & (bitBuffer >> ((0x20 - bitIndex) - valueCategory));
|
||||
if ((bitBuffer & (1 << (valueCategory - 1))) == 0) {
|
||||
bitBuffer = bitBuffer + 1 | ~magnitudeMask;
|
||||
}
|
||||
} else {
|
||||
bitBuffer = 0;
|
||||
}
|
||||
bitCountAndMask = bitCountAndMask + bitIndex + valueCategory;
|
||||
coefficientOutput[decodedSymbol] = bitBuffer;
|
||||
tableIndex = (bitCountAndMask >> 3);
|
||||
decodedSymbol = decodedSymbol + 1;
|
||||
while (bitCountAndMask >= 8) {
|
||||
sourceCursor++;
|
||||
bytesConsumed++;
|
||||
bitCountAndMask -= 8;
|
||||
}
|
||||
} while ((int)decodedSymbol < 0x40);
|
||||
for (; (int)decodedSymbol < 0x40; decodedSymbol++) {
|
||||
coefficientOutput[decodedSymbol] = 0;
|
||||
}
|
||||
request->bytesConsumed = bytesConsumed;
|
||||
decodeResult = 0;
|
||||
request->bitstream = sourceCursor;
|
||||
*request->bitCount = bitCountAndMask;
|
||||
tableIndex += branch + 1;
|
||||
}
|
||||
}
|
||||
finishDecode:
|
||||
return decodeResult;
|
||||
}
|
||||
|
||||
if (length > maxLength) {
|
||||
return ODH_ERROR_INVALID_BITSTREAM;
|
||||
}
|
||||
|
||||
if (category > 0) {
|
||||
mask = (1 << category) - 1;
|
||||
value = mask & (bitBuffer >> (32 - length - category));
|
||||
if ((value & (1 << (category - 1))) == 0) {
|
||||
value = (value + 1) | ~mask;
|
||||
}
|
||||
} else {
|
||||
value = 0;
|
||||
}
|
||||
|
||||
bitOffset += length + category;
|
||||
coefficient = 1;
|
||||
coefficientOutput[0] = value + *request->predictors[component >> 1];
|
||||
*request->predictors[component >> 1] = coefficientOutput[0];
|
||||
while (bitOffset >= 8) {
|
||||
sourceCursor++;
|
||||
bytesConsumed++;
|
||||
bitOffset -= 8;
|
||||
}
|
||||
|
||||
do {
|
||||
if ((u32)(bytesConsumed + 4) > sourceLimit) {
|
||||
return ODH_ERROR_INVALID_BITSTREAM;
|
||||
}
|
||||
|
||||
bitBuffer = ((u32)sourceCursor[0] << 24 | (u32)sourceCursor[1] << 16 | (u32)sourceCursor[2] << 8 | sourceCursor[3]) << bitOffset;
|
||||
length = 1;
|
||||
tableIndex = 0;
|
||||
for (; length <= 6; length++) {
|
||||
u32 branch;
|
||||
u16 node;
|
||||
|
||||
node = huffmanTables[1][tableIndex];
|
||||
branch = node & 0x3FFF;
|
||||
if (((bitBuffer >> (32 - length)) & 1) == 0) {
|
||||
if (node & 0x8000) {
|
||||
category = huffmanTables[1][tableIndex + branch];
|
||||
break;
|
||||
}
|
||||
tableIndex += branch;
|
||||
} else {
|
||||
if (node & 0x4000) {
|
||||
category = huffmanTables[1][tableIndex + branch + 1];
|
||||
break;
|
||||
}
|
||||
tableIndex += branch + 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (length > 6) {
|
||||
return ODH_ERROR_INVALID_BITSTREAM;
|
||||
}
|
||||
|
||||
if (category == 7) {
|
||||
bitOffset += length;
|
||||
while (bitOffset >= 8) {
|
||||
sourceCursor++;
|
||||
bytesConsumed++;
|
||||
bitOffset -= 8;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
if (category > 0) {
|
||||
run = ((1 << category) - 1) & (bitBuffer >> (32 - length - category));
|
||||
if ((run & (1 << (category - 1))) == 0) {
|
||||
return ODH_ERROR_INVALID_BITSTREAM;
|
||||
}
|
||||
} else {
|
||||
run = 0;
|
||||
}
|
||||
|
||||
for (i = 0; i < run; i++) {
|
||||
coefficientOutput[coefficient] = 0;
|
||||
coefficient++;
|
||||
}
|
||||
|
||||
bitOffset += length + category;
|
||||
while (bitOffset >= 8) {
|
||||
sourceCursor++;
|
||||
bytesConsumed++;
|
||||
bitOffset -= 8;
|
||||
}
|
||||
|
||||
if ((u32)(bytesConsumed + 4) > sourceLimit) {
|
||||
return ODH_ERROR_INVALID_BITSTREAM;
|
||||
}
|
||||
|
||||
bitBuffer = ((u32)sourceCursor[0] << 24 | (u32)sourceCursor[1] << 16 | (u32)sourceCursor[2] << 8 | sourceCursor[3]) << bitOffset;
|
||||
maxLength = component == 0 ? 9 : 11;
|
||||
|
||||
length = 1;
|
||||
tableIndex = 0;
|
||||
for (; length <= maxLength; length++) {
|
||||
u32 branch;
|
||||
u16 node;
|
||||
|
||||
node = huffmanTables[0][tableIndex];
|
||||
branch = node & 0x3FFF;
|
||||
if (((bitBuffer >> (32 - length)) & 1) == 0) {
|
||||
if (node & 0x8000) {
|
||||
category = huffmanTables[0][tableIndex + branch];
|
||||
break;
|
||||
}
|
||||
tableIndex += branch;
|
||||
} else {
|
||||
if (node & 0x4000) {
|
||||
category = huffmanTables[0][tableIndex + branch + 1];
|
||||
break;
|
||||
}
|
||||
tableIndex += branch + 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (length > maxLength) {
|
||||
return ODH_ERROR_INVALID_BITSTREAM;
|
||||
}
|
||||
|
||||
if (category > 0) {
|
||||
mask = (1 << category) - 1;
|
||||
value = mask & (bitBuffer >> (32 - length - category));
|
||||
if ((value & (1 << (category - 1))) == 0) {
|
||||
value = (value + 1) | ~mask;
|
||||
}
|
||||
} else {
|
||||
value = 0;
|
||||
}
|
||||
|
||||
coefficientOutput[coefficient++] = value;
|
||||
bitOffset += length + category;
|
||||
while (bitOffset >= 8) {
|
||||
sourceCursor++;
|
||||
bytesConsumed++;
|
||||
bitOffset -= 8;
|
||||
}
|
||||
} while (coefficient < 64);
|
||||
|
||||
for (; coefficient < 64; coefficient++) {
|
||||
coefficientOutput[coefficient] = 0;
|
||||
}
|
||||
|
||||
request->bytesConsumed = bytesConsumed;
|
||||
request->bitstream = sourceCursor;
|
||||
*request->bitCount = bitOffset;
|
||||
return 0;
|
||||
}
|
||||
void CArGBAOdh::idct_fast(const u8* rangeLimitTable, u32* coefficients, u32* quantizationTable, u8* destination, u32 stride) {
|
||||
int evenPart0, evenPart1, evenPart2, evenPart3, oddPart3, oddPart2, oddPart1, oddPart0;
|
||||
int butterflyTerm0, butterflyTerm1, butterflyTerm2, evenInnerSum;
|
||||
|
||||
47
tools/decomp-assist/odh-source-integrity.attempts.md
Normal file
47
tools/decomp-assist/odh-source-integrity.attempts.md
Normal file
@@ -0,0 +1,47 @@
|
||||
# ODH source-integrity checks
|
||||
|
||||
Base: 3d7e767cf729de96ac1cd88ddbf5c18eaa08187d (43U only).
|
||||
|
||||
- Restored unsigned arithmetic in all three huffmanDecoder word refills by
|
||||
casting the shifted bytes to u32. The combined word and its bitOffset shift
|
||||
now remain unsigned, including input words with the high bit set.
|
||||
- Restored unsigned planeSize indexing in LineConv11. Chroma source pointers
|
||||
are only formed by accesses in the planar-format branch. The RGB565 caller
|
||||
passes a row-offset pointer into Capture's GXGetTexBufferSize allocation;
|
||||
for tile-aligned dimensions that allocation is exactly width*height*2 bytes.
|
||||
Unconditionally adding two planes to a nonzero row pointer could therefore
|
||||
form an out-of-bounds pointer even though RGB565 never dereferences it.
|
||||
- Reviewed the full huffmanDecoder rewrite against its preceding source.
|
||||
Other category shifts and caller/table preconditions were already present;
|
||||
no additional newly introduced arithmetic issue was identified in this pass.
|
||||
|
||||
One candidate, no compiler flags or other source changes. No debugger, compiler
|
||||
memory access, forced registers, assembly, uninitialized values, or online source
|
||||
references were used. Retail objects and disassembly remained local.
|
||||
|
||||
Validation:
|
||||
|
||||
- All allocated source-object sections, function spans, and resolved relocations
|
||||
are identical to the unmodified base object (debug metadata differs).
|
||||
- All 28 retail function spans are raw-byte exact: 14,684 bytes, with all 203
|
||||
relocations identical after resolving local symbols to actual section offsets
|
||||
and code symbols to function-relative targets.
|
||||
- Data matches: .rodata 5,856, .data 464, .sdata2 40 bytes. The source .data is
|
||||
459 bytes plus five zero alignment bytes in the split/link target.
|
||||
- Pool identical, 10/10 strings. huffmanDecoder ctxdiff: 306/306, zero diffs.
|
||||
LineConv11: 146/146; the strict-name local helper prints eight pre-existing
|
||||
label-name differences. Exact bytes, resolved relocation destinations, and
|
||||
referenced data independently match; none were ignored without resolution.
|
||||
- Official objdiff: ODH 28/28 functions; code, data, fuzzy and link all 100%.
|
||||
- Every measure, function and section in all 1,028 report units, plus all global
|
||||
measures, is unchanged from the base report.
|
||||
- Full 43U build and build/43U/ok pass. DOL SHA1:
|
||||
26116613f624061ba99c8d1a299aaa6efa85670d.
|
||||
- All 22 workflow-guard tests pass. A host UBSan refill test passes 524,288
|
||||
cases against a 64-bit oracle (every high byte, offsets 0..7).
|
||||
- The global completion checker still fails on pre-existing incomplete units;
|
||||
this change does not claim repository-wide completion.
|
||||
|
||||
Local reproducible evidence: ../odh-unsigned-refills-evidence/verify.py,
|
||||
verification.log, full-build.log, pool.log, guards.log, refill-test.cpp/log,
|
||||
completion.log, status.json and dol.sha1. No publication or merge performed.
|
||||
44
tools/decomp-assist/opus-bs2update.attempts.md
Normal file
44
tools/decomp-assist/opus-bs2update.attempts.md
Normal file
@@ -0,0 +1,44 @@
|
||||
# opus-bs2update UpdateThread attempts
|
||||
|
||||
Worktree data-d10, branch agent/w1009/o-bs2update, base 72e9c8d6 (origin/main). Owned `src/BS2/BS2Update.c`; the fix also needs a one-line rename in `config/43U/symbols.txt` and the Matching flip in `configure.py`. Read opus-common, levers, the effort-policy entries, sol-x8, sol-y3 (`git show 4925fde2`) and sol-z1.
|
||||
|
||||
Start: UpdateThread 6/913 differing, equal size 0xe44. The other nine functions are exact. The remaining diffs are the three seat-loop scheduling swaps described by sol-x8, sol-y3 and sol-z1.
|
||||
|
||||
combosweep (single and pairwise allowed pragmas): `BEST src/BS2/BS2Update UpdateThread base 6 -> 6 []`. No pragma moves it.
|
||||
|
||||
## Diagnosis
|
||||
|
||||
The decompiled 1.2.5 scheduler (rayanht/mwcc `src/backend/Scheduler.c`, inspiredrobot/mwcc `docs/SCHEDULER.md`) adds a store-to-later-load edge for every memory pair the alias test cannot separate, with the store's latency. sol-y3's capture already showed that the seat loads carry a worst-case alias set that contains Flags0's bit, so `Flags0[index] = 0` wins the height race against the seat address `add`. The target schedules the `add` first. That is the order you get when no such edge exists.
|
||||
|
||||
I tested small probe functions with the unit's exact compiler flags: a loop that stores `FlagsX[i] = 0` and then tests `p[i].attr & 1`. The results:
|
||||
|
||||
| Seat entries come from | Flag array | Edge (store first)? |
|
||||
| --- | --- | --- |
|
||||
| absolute `T a[] : addr` (array, struct, single entry, const, static) | file-scope static | yes |
|
||||
| integer cast `(T*)0x80480000 + n` (folds to `addis`, wrong form anyway) | file-scope static | yes |
|
||||
| pointer parameter | file-scope static | yes |
|
||||
| normal relocated global array | file-scope static | no, but needs `lis/addi` with relocs (wrong form) |
|
||||
| absolute array (target's `lis r0,0x8048; add` form) | file-scope static, initialized or tentative, extern | yes |
|
||||
| absolute array | **function-local static** | **no** |
|
||||
| absolute array | global scalar / local stack array | no |
|
||||
|
||||
An unknown pointer (absolute storage counts as unknown) may alias every file-scope object, but not a function-local static whose address is never taken. The target keeps the absolute `lis r0, 0x8048; add` form and has no edge. So Flags0 was a function-local static of the selection code.
|
||||
|
||||
## .bss order
|
||||
|
||||
The target order is Flags0, Flags1, Thread, ThreadStack, UpdateHeader0, UpdateHeader1. Probes on the same compiler show the emission rules:
|
||||
- initialized objects are emitted where they are defined;
|
||||
- tentative definitions are emitted at their first use;
|
||||
- a function static is emitted when its function is parsed.
|
||||
|
||||
So the static has to come from a function parsed before BS2UpdateInit, and the other five arrays have to be tentative definitions. Init first uses Flags1, Thread and ThreadStack, and the inlined selection code first uses UpdateHeader0 and UpdateHeader1. That gives exactly the target order.
|
||||
|
||||
## Trials
|
||||
|
||||
1. `seatEntries = (BS2UpdateEntry*)0x80480000 + wadCount`: 549/912 (address folds into `addis`; the swaps stay). Rejected.
|
||||
2. `static u32 Flags0[...] = {0};` inside BS2SelectUpdateEntries, everything else unchanged: 18/913. All three swaps gone; the 18 left are .bss offsets because Flags0 lands after UpdateHeader1. Init 4 diffs from the same shift.
|
||||
3. As 2, but the Flags1/Thread/ThreadStack/UpdateHeader0/UpdateHeader1 definitions are tentative (the `= {0}` initializers dropped) and BS2SelectUpdateEntries is defined before BS2UpdateInit: **UpdateThread 0/913, all 10 functions exact**. .bss layout identical to the target, pool 55/55 identical.
|
||||
4. Rename the target symbol `Flags0` to the compiler's local-static name `Flags0$1129` in config/43U/symbols.txt. This is the project convention for function statics (144 `name$N` entries). Report: code 4052/4052, data 10488/10488, every section 100%, functions 10/10.
|
||||
5. Flip BS2Update to Matching and run the full build: DOL SHA1 26116613f624061ba99c8d1a299aaa6efa85670d. build.ninja links build/43U/src/src/BS2/BS2Update.o.
|
||||
|
||||
No pragma, asm, volatile change, carrier, padding or dummy is added. The source change is: the selection helper moves above BS2UpdateInit, Flags0 becomes its function static, and five `= {0}` initializers are removed.
|
||||
61
tools/decomp-assist/opus-candbox.attempts.md
Normal file
61
tools/decomp-assist/opus-candbox.attempts.md
Normal file
@@ -0,0 +1,61 @@
|
||||
# opus-candbox attempts
|
||||
|
||||
Worktree `sol-high`, branch `agent/w1009/o-candbox`, base `72e9c8d6`. Unit `src/keyboard/tiCandidateBox`, last open function `LayoutByNW4R::createAnmPane_` (6/216, count r23 and slot r31 swapped). Read opus-common.md, levers.md, effort-policy entries, sol-x9 log, sol-m4 log (branch `agent/w1009/candbox-max`), saved sol-r12/sol-y11 diffs.
|
||||
|
||||
Baseline: full build OK, DOL `26116613...`, odiff 6/216, pool identical 57/57. combosweep (single and pairwise pragmas): `base 6 -> 6`, no hit.
|
||||
|
||||
## Root cause
|
||||
|
||||
`tiPredictLang::create` is already exact and has the same inner loop with the same struct (`char paneName[20]`, `count`, `forceAddName`, `pAnims[8]`). Its target has count r31 and slot r23, which is what createAnmPane_ needs.
|
||||
|
||||
A private mwdbg trace of `tiPredictLang::create` (port 19931 copy of the launcher, shared tool unchanged) shows why. The slot base `p + j*4` is IRO CSE temp `@7026` (vreg r45) and forceAddName is IRO temp `@7028` (r44). Both are numbered after the named locals and before the hoisted constructor constants, so they simplify before the constants and color after them (slot r23). Count is a late anonymous load hoisted out of the loop condition (r131), so it colors first (r31).
|
||||
|
||||
The same natural loop inside tiCandidateBox (`j < paneAnimations.count`, `paneAnimations.pAnims[j]->` three times) gives 220 insns. No IRO temps are created, the slot is recomputed in each branch, and constant `2` survives pass-1 spilling.
|
||||
|
||||
Table declaration trials with that loop:
|
||||
|
||||
| trial | table | result |
|
||||
| --- | --- | --- |
|
||||
| 01 | `extern "C" const CandidatePaneData scCandidatePaneData` (struct wrapper, aligned(8)) | 158/220 |
|
||||
| 02 | `static const CandidatePaneData` (struct wrapper) | 158/220 |
|
||||
| 03 | `extern "C" const PaneToAnimation[]` (plain array) | 158/220 |
|
||||
| 04 | `static const PaneToAnimation[]` (plain array, no aligned) | **0/216** |
|
||||
|
||||
IRO only CSEs the table loads and addresses when the table is a static plain array, which is how every sibling unit declares it (`csPaneToAnimation`). The `CandidatePaneData` wrapper and `extern "C"` were decomp scaffolding. Without `aligned(8)` the table still lands at .data 0x28, size 0x680.
|
||||
|
||||
## Source changes
|
||||
|
||||
- Table: `static const PaneToAnimation csPaneToAnimation[]`, same name as tiToolBar/tiPredictLang/pctype. Removed the unused `CandidatePaneData` struct.
|
||||
- `createAnmPane_`: the tiPredictLang/tiToolBar loop form, with no count/forceAddName/animation locals.
|
||||
- symbols.txt: `scCandidatePaneData` -> `csPaneToAnimation__Q29textinput12candidatebox` (scope:local). Same address and size. Only tiCandidateBox referenced the old name.
|
||||
|
||||
Unit after this: 112/112 functions, code 100%, data 100%, all sections 100%, pool identical.
|
||||
|
||||
## Link (Matching flip)
|
||||
|
||||
First flip: DOL `8d444a7b...`. Two causes, both checked against the original objects:
|
||||
|
||||
1. Thunk order. Target `@36@__dt__` comes before `@36@setRootPaneScaleFor4x3..init`; ours put it last (already true on the old baseline). This is the "move to end on touch" thunk list (eggAudioExpMgr, lever 12). tiPredictLang/tiToolBar/tiCellPhone fix it with a header `Sample : public LayoutByNW4R` behind a `*_SAMPLE_CLASS` macro, and `__vt__Q39textinput12candidatebox6Sample` exists in the DOL. A Sample with only `virtual ~Sample() {}` does not move the thunks. It needs the inline constructor, so the Base/EventHandler/LayoutByNW4R constructor guards also accept `TI_CANDIDATEBOX_SAMPLE_CLASS`, as tiPredictLang.h does. After that, all 112 common functions are in target order. Proof it is required: removing it leaves the wrong thunk order and DOL `5507fb9e...`.
|
||||
2. Weak vtable hole. The target has 0x40 zero bytes between `__vt__...AnmObserver` (0xd48) and `__vt__Q39textinput4util12AnimObserver` (0xd94). Ours left only the deduplicated gui::EventHandler copy (0x18), so everything after shifted by -0x20/-0x24. util::Animation methods were inline in the original: they sit as scattered weak functions in tiInputForm's .text, and MyTiManager.cpp already defines them `inline`. UITextArea has a `util::Animation` member, so the original object also emitted a weak `__vt__Q39textinput4util9Animation` (0x24, kept from tiInputForm). EventHandler 0x18 at 0xd58 + Animation 0x24 at 0xd70 ends at 0xd94. I added the same inline definitions as MyTiManager.cpp at the end of tiCandidateBox.cpp, with startAnm in this TU's declared parameter order. Only virtual calls exist, so no code changes. .data is now 0xda0, the target size.
|
||||
|
||||
Flip with both: full build OK, `build/43U/main.dol` SHA1 `26116613f624061ba99c8d1a299aaa6efa85670d`.
|
||||
|
||||
Trial snapshots: `/tmp/opus-candbox/trials/`. Captures: `/tmp/opus-candbox-cap-predictlang`, `/tmp/opus-candbox-cap-f01`.
|
||||
|
||||
## Gate
|
||||
|
||||
```text
|
||||
full build: ok
|
||||
main.dol sha1: 26116613f624061ba99c8d1a299aaa6efa85670d
|
||||
[src/keyboard/tiCandidateBox] pool: IDENTICAL
|
||||
[src/keyboard/tiCandidateBox] objdiff: code 24000/24000 data 4652/4652 functions 112/112 fuzzy 100.0000 linked code 24000
|
||||
[src/keyboard/tiCandidateBox] instruction-exact functions: 112/112
|
||||
regressions vs baseline: 0
|
||||
global matched_code_percent: 98.14728 -> 98.17613
|
||||
global complete_code_percent: 91.22256 -> 92.02384
|
||||
forbidden patterns added (net, per file): 0
|
||||
readability warnings (net, per file; must be 0 in the final result): 0
|
||||
GATE PASS
|
||||
```
|
||||
|
||||
origin/main moved to `82783c6e` during the run (BS2Update lines in configure.py/symbols.txt only, no overlap). Not rebased.
|
||||
68
tools/decomp-assist/opus-odh.attempts.md
Normal file
68
tools/decomp-assist/opus-odh.attempts.md
Normal file
@@ -0,0 +1,68 @@
|
||||
# opus-odh attempts (src/system/odh)
|
||||
|
||||
Worktree data-d6, branch agent/w1009/o-odh from origin/main 72e9c8d6. Read opus-common.md, sol-r4 and
|
||||
sol-m2 logs, effort-policy entries, levers.md, the mwdbg README and the allocator reference.
|
||||
|
||||
Baseline: LineConv11 12/146, huffmanDecoder 171/306, unit 26/28 exact, pool identical.
|
||||
|
||||
## combosweep (run first)
|
||||
|
||||
- main source: LineConv11 12 -> 12, huffmanDecoder 171 -> 166 (opt_propagation off). No exact.
|
||||
- sol-m2 seed: LineConv11 6 -> 6, huffmanDecoder 114 -> 114. No exact.
|
||||
|
||||
## LineConv11: EXACT
|
||||
|
||||
mwdbg capture of the seed: inside the loop r8 is the only free volatile GPR, so every other temp takes a
|
||||
saved register and the lowest claimed one wins. The packed RGB565 word (v68) was colored before the
|
||||
high byte (v66) and took r8. The target needs the high byte on r8, the pointer on r29, and the packed word
|
||||
colored after cbValue claims r25. So the packed word has to be a named local numbered below cbValue.
|
||||
|
||||
Petari's matching SMG source (SMGCommunity/Petari src/Game/Screen/odh.cpp, read-only) does exactly that:
|
||||
cbValue/crValue are declared with red/green/blue before the format chain, and `pixel` is built high byte
|
||||
first (`pixel = src[o]; pixel <<= 8; pixel |= src[o + 1];`) inside the RGB565 block. Ported as-is with
|
||||
this file's names: LineConv11 0/146, ctxdiff diffs 0, pool identical, no other function changes.
|
||||
|
||||
Lever isolation (each from the exact version):
|
||||
- cbValue/crValue declared at their assignment instead: 5 diffs.
|
||||
- pixel low byte first (`pixel = src[o + 1]; pixel |= src[o] << 8`): 6 diffs.
|
||||
- pixel as one expression `(src[o] << 8) | src[o + 1]`: 6 diffs.
|
||||
- planeSize indexing instead of cbSource/crSource pointers: 0 (either form works).
|
||||
|
||||
## huffmanDecoder: EXACT
|
||||
|
||||
Started from a fresh natural rewrite (early returns, `length`/`tableIndex`/`category` names, Petari-style
|
||||
tree walks) instead of the Ghidra-shaped seed: 170 diffs, same 306 instructions. Structural fixes first:
|
||||
- `coefficient = 1` before the first refill loop (the target sets it in the DC block): 163.
|
||||
- DC leaf through a named `leafIndex` (target keeps `(idx + off + 1) * 2` + lhzx only in the DC walk).
|
||||
- `length = 1;` before `tableIndex = 0;` in every walk (li order): 139, 0 structural left.
|
||||
|
||||
Then allocator work with mwdbg + a per-vreg want list built by aligning backend-04 PCode with the target
|
||||
object (/tmp/opus-odh-want.py), and an annealer over the numbering (/tmp/opus-odh-anneal.py):
|
||||
- A full renumbering (temps included) reached 1 miss and showed both maxLength values must be colored
|
||||
after their walk temps, i.e. behave as codegen temps. `maxLength = component == 0 ? 9 : 11;` gets
|
||||
copy-propagated into the ternary temp: 139 -> 80.
|
||||
- `dc` must be colored before the predictor-index temp, so no named `dc`:
|
||||
`coefficientOutput[0] = value + *pred; *pred = coefficientOutput[0];` (store forwarded, no reload): 68.
|
||||
- AC tail: target creates the store address before `length + category`:
|
||||
`coefficientOutput[coefficient++] = value; bitOffset += length + category;`: 66.
|
||||
- Remaining misses were named-local order only. Simulator: declare sourceCursor, bitOffset, coefficient,
|
||||
category before bytesConsumed (sourceCursor colors first and takes r12, bitOffset claims r31, then
|
||||
coefficient r30, category r29, bytesConsumed r28). C89 declarations at the top of the function: 9.
|
||||
- Last 9: the run walk needs `branch` numbered above `node` (declared first). Per-walk C89 blocks
|
||||
`u32 branch; u16 node;` then assignments: 0. Only the run walk needs it; using it in all three walks
|
||||
is also exact, so the final source is uniform.
|
||||
|
||||
Checked and rejected along the way: function-scope shared node/branch (always 9, any position);
|
||||
`value += *pred` (80); chained assignment for the predictor works (68) but the two-statement form reads
|
||||
better. maxLength/value/mask/leafIndex/run/i can sit anywhere in the top declaration list.
|
||||
|
||||
Final: huffmanDecoder 0/306, ctxdiff diffs 0, pool identical, unit 28/28, code 14684/14684, data 6360/6360.
|
||||
|
||||
## Link
|
||||
|
||||
Flipped system/odh.cpp to Matching. ODHEncodeRGBA8/ODHEncodeY8U8V8/ODHDecodeY8U8V8 are in the source but
|
||||
not in the split target (unreferenced, dead-stripped); the link output is unchanged.
|
||||
Full build: main.dol SHA1 26116613f624061ba99c8d1a299aaa6efa85670d, "system/odh.cpp: linked True".
|
||||
|
||||
Gate (`gate.py src/system/odh --quick`): GATE PASS, 28/28 instruction-exact, linked code 14684,
|
||||
0 regressions, 0 forbidden patterns, 0 readability warnings. Global matched code 98.14728 -> 98.20765.
|
||||
144
tools/decomp-assist/sol-m12.attempts.md
Normal file
144
tools/decomp-assist/sol-m12.attempts.md
Normal file
@@ -0,0 +1,144 @@
|
||||
# sol-m12 CHANSVm big functions, MAX
|
||||
|
||||
Worktree data-d2, branch agent/w1009/chansvm-big, initial HEAD bbd98e1e. Requested full Ninja build passed before edits, required DOL SHA1 verified by the build. Source initially clean. Read sol-common, brief-v2, all levers, AGENTS.md, unslop, writing-for-agents, graphify query instructions, 11b01025:sol-m8, 50eb9be2:sol-c1, ef500621:sol-y4, archived and repository histories, and every CHANSVm effort-policy entry. History inventory and prior trial labels are /tmp/sol-m12-history.json and /tmp/sol-m12-prior-rows.json. Graph query resolved its ambiguous name to src/channelScript/CHANSVm.c::VmBlobPackCommon.
|
||||
|
||||
## Excluded repetitions
|
||||
|
||||
- No unchanged-graph declaration permutations. Prior 218-node Pack models prove the array/counter swap needs a changed interference graph.
|
||||
- No whole Pack measure/write wrappers, complete packing helper, element-size/format-specific writers, typed argument-selection wrappers, named remaining-count/format-length/blob-length getters, sequential generic argument reuse, or shared pass counters/format positions already tried.
|
||||
- No Step scratch carrier, out-parameters hoisting locals, dead locals, duplicated control flags, redundant conditions, raw offset casts, table-identity getters, previously tested late-table getters, readonly-view cleanup helpers, named immediate getters, instruction-union variants, or countdown normalization variants.
|
||||
- No compiler-version/unit-flag sweep or standalone scoped-setting repeat. No small-function work outside Pack and Step.
|
||||
|
||||
## Acceptance and method
|
||||
|
||||
Replay the saved Pack-only best, remove any unused local, and check equivalent behavior and all existing exact functions before retaining it. The task explicitly authorizes committing clean improvements below exactness; record them as partial results. Align opcode plus resolved-relocation streams with difflib, locate count differences first, then scheduling and allocation. For Step, map the switch table and inspect the least-different cases first. Preserve the pool, all data sections and existing exact functions. Run the requested final quick gate once. Keep all source experiments in this worktree and temporary files under /tmp/sol-m12-. No push, PR, merge, rebase, subagent or Matching flip without a fully exact unit.
|
||||
|
||||
## Measurements
|
||||
- {"label": "pack-clean-replay", "counts": {"VmBlobPackCommon": {"diff": 151, "insns": [666, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "c18451afb381"} Removed unused hexadecimal length local and pure getter from historical best. All separated locals carry genuine pass-specific values.
|
||||
- {"label": "pack-clean-unused-result-call", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "705ffdaec24d"} Target instruction 604 prepares writeHexStrObj and 605 calls VmGetIntFromObjHdr. Return is unused in the remaining hex block. Preserve that original call without a dead local.
|
||||
|
||||
Pack clean replay is 47/668 versus 230/668 at HEAD. All 47 aligned differences are the r18/r23 array-counter exchange. Target hex block explicitly calls VmGetIntFromObjHdr and discards its result, so the required source call is retained without declaring a dead local. The rest of the function keeps identical call order, branches, instruction count, all allocated data, and every other function. Unit report after replay: {"fuzzy_match_percent": 99.66164, "total_code": "53564", "matched_code": "44588", "matched_code_percent": 83.24248, "total_data": "6904", "matched_data": "6904", "matched_data_percent": 100.0, "total_functions": 233, "matched_functions": 227, "matched_functions_percent": 97.4249, "total_units": 1}. Task authorizes this partial checkpoint. No exact match claimed.
|
||||
- {"label": "pack-integer-store-words", "counts": {"VmBlobPackCommon": {"diff": 325, "insns": [677, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "34b5f067b570"} Actual integer serialization or byte-swap helper writes the real packing buffer; no scratch carrier or hoisted local out-parameter.
|
||||
- {"label": "pack-integer-store-integer", "counts": {"VmBlobPackCommon": {"diff": 325, "insns": [677, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "c75536b1e87b"} Actual integer serialization or byte-swap helper writes the real packing buffer; no scratch carrier or hoisted local out-parameter.
|
||||
- {"label": "pack-integer-store-integer-case-scope", "build": "FAIL"} Same new serialization boundary, with integer-loop values declared in their owning case.
|
||||
- {"label": "pack-integer-store-object", "counts": {"VmBlobPackCommon": {"diff": 321, "insns": [677, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "b0afd352444d"} Actual integer serialization or byte-swap helper writes the real packing buffer; no scratch carrier or hoisted local out-parameter.
|
||||
- {"label": "pack-integer-store-object-case-scope", "build": "FAIL"} Same new serialization boundary, with integer-loop values declared in their owning case.
|
||||
- {"label": "pack-integer-swap-words", "counts": {"VmBlobPackCommon": {"diff": 56, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "434ff2985dbf"} Actual integer serialization or byte-swap helper writes the real packing buffer; no scratch carrier or hoisted local out-parameter.
|
||||
- {"label": "pack-integer-encode-words", "counts": {"VmBlobPackCommon": {"diff": 333, "insns": [675, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "46cb1062b4df"} Actual integer serialization or byte-swap helper writes the real packing buffer; no scratch carrier or hoisted local out-parameter.
|
||||
- {"label": "pack-integer-encode-integer", "counts": {"VmBlobPackCommon": {"diff": 333, "insns": [675, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "37020ec61736"} Actual integer serialization or byte-swap helper writes the real packing buffer; no scratch carrier or hoisted local out-parameter.
|
||||
- {"label": "pack-integer-encode-integer-case-scope", "counts": {"VmBlobPackCommon": {"diff": 334, "insns": [675, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "1e8a9605e258"} Same new serialization boundary, with integer-loop values declared in their owning case.
|
||||
- {"label": "pack-integer-encode-object", "counts": {"VmBlobPackCommon": {"diff": 329, "insns": [675, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "389b97208b09"} Actual integer serialization or byte-swap helper writes the real packing buffer; no scratch carrier or hoisted local out-parameter.
|
||||
- {"label": "pack-integer-encode-object-case-scope", "counts": {"VmBlobPackCommon": {"diff": 330, "insns": [675, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "73d7c8ffa5e6"} Same new serialization boundary, with integer-loop values declared in their owning case.
|
||||
- {"label": "pack-restore-after-integer-helpers", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "705ffdaec24d"} Restore the best reviewed packing shape after serialized helper trials.
|
||||
- {"label": "step-case-float-local", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 266, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "5a5c1246d7a2"} Move only this case actual operand/index/literal into its owning scope, following the least-different case ordering. Independent objects, unchanged calls and operand sizes.
|
||||
- {"label": "step-case-string-index-local", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "19ecec628150"} Move only this case actual operand/index/literal into its owning scope, following the least-different case ordering. Independent objects, unchanged calls and operand sizes.
|
||||
- {"label": "step-case-new-array-index-local", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "c16b93768a1c"} Move only this case actual operand/index/literal into its owning scope, following the least-different case ordering. Independent objects, unchanged calls and operand sizes.
|
||||
- {"label": "step-case-call-operand-local", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "52188babcf52"} Move only this case actual operand/index/literal into its owning scope, following the least-different case ordering. Independent objects, unchanged calls and operand sizes.
|
||||
- {"label": "step-single-function-scope-opSize", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "0bcda653f75c"} One real cross-case interpreter local lives at function scope. Carrier-free baseline; this is not a declaration permutation of the previous carrier graph.
|
||||
- {"label": "step-single-function-scope-operandBuf", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "70349864ce40"} One real cross-case interpreter local lives at function scope. Carrier-free baseline; this is not a declaration permutation of the previous carrier graph.
|
||||
- {"label": "step-single-function-scope-copyResult", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "e302683194b4"} One real cross-case interpreter local lives at function scope. Carrier-free baseline; this is not a declaration permutation of the previous carrier graph.
|
||||
- {"label": "step-single-function-scope-foundObj", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "c0c7872f13d2"} One real cross-case interpreter local lives at function scope. Carrier-free baseline; this is not a declaration permutation of the previous carrier graph.
|
||||
- {"label": "step-single-function-scope-result", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "621e11cb0158"} One real cross-case interpreter local lives at function scope. Carrier-free baseline; this is not a declaration permutation of the previous carrier graph.
|
||||
- {"label": "step-single-function-scope-newPos", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "72977265684a"} One real cross-case interpreter local lives at function scope. Carrier-free baseline; this is not a declaration permutation of the previous carrier graph.
|
||||
- {"label": "step-case-helper-VmLoadIndirect", "build": "FAIL"} Real opcode operation helper preserves its complete copy/delete/store or boolean operation and error propagation. Buffer parameter is the actual operation storage, not an allocator carrier.
|
||||
- {"label": "step-case-helper-VmDeleteIndirect", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "a78209fb7d99"} Real opcode operation helper preserves its complete copy/delete/store or boolean operation and error propagation. Buffer parameter is the actual operation storage, not an allocator carrier.
|
||||
- {"label": "step-case-helper-VmLogicalNot", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "78a1e07de24a"} Real opcode operation helper preserves its complete copy/delete/store or boolean operation and error propagation. Buffer parameter is the actual operation storage, not an allocator carrier.
|
||||
- {"label": "step-internal-readonly-VmResultTypeTbl", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "d7acb65b18d2"} Diagnostic internal linkage on real TU-private readonly globals. Target shares the rodata base; retain only if every symbol user and relocation remain valid.
|
||||
- {"label": "step-internal-readonly-CHANSVmConstStringObjectUndefined_", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "29f94ee37b0f"} Diagnostic internal linkage on real TU-private readonly globals. Target shares the rodata base; retain only if every symbol user and relocation remain valid.
|
||||
- {"label": "step-internal-readonly-both", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "9ffa6e38abd1"} Diagnostic internal linkage on real TU-private readonly globals. Target shares the rodata base; retain only if every symbol user and relocation remain valid.
|
||||
- {"label": "step-restore-after-case-trials", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "705ffdaec24d"} Restore best reviewed source after opcode and scope trials.
|
||||
- {"label": "pack-real-serialization-buffer-signed-words", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "953ba41006c9"} Actual eight-byte serialization buffer has its natural byte, signed-word or integer representation; typed accesses preserve exactly the stored byte ranges and order.
|
||||
- {"label": "pack-real-serialization-buffer-bytes", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "68bdeb48da60"} Actual eight-byte serialization buffer has its natural byte, signed-word or integer representation; typed accesses preserve exactly the stored byte ranges and order.
|
||||
- {"label": "pack-real-serialization-buffer-integer", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "c817b37a562e"} Actual eight-byte serialization buffer has its natural byte, signed-word or integer representation; typed accesses preserve exactly the stored byte ranges and order.
|
||||
- {"label": "pack-hex-real-phase-indexed-vmBoolInt", "counts": {"VmBlobPackCommon": {"diff": 125, "insns": [669, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "8037667d9caf"} Named consumed high/low nibble phase and a real index, remaining-count or input cursor. Ghidra shows alternating phase and two-byte source traversal; no artificial lifetime or extra VM call.
|
||||
- {"label": "pack-hex-real-phase-indexed-vmBool", "counts": {"VmBlobPackCommon": {"diff": 125, "insns": [669, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "d10098e4f2c2"} Named consumed high/low nibble phase and a real index, remaining-count or input cursor. Ghidra shows alternating phase and two-byte source traversal; no artificial lifetime or extra VM call.
|
||||
- {"label": "pack-hex-real-phase-remaining-vmBoolInt", "counts": {"VmBlobPackCommon": {"diff": 235, "insns": [669, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "51a8b18b0da5"} Named consumed high/low nibble phase and a real index, remaining-count or input cursor. Ghidra shows alternating phase and two-byte source traversal; no artificial lifetime or extra VM call.
|
||||
- {"label": "pack-hex-real-phase-remaining-vmBool", "counts": {"VmBlobPackCommon": {"diff": 235, "insns": [669, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "25983a62b93c"} Named consumed high/low nibble phase and a real index, remaining-count or input cursor. Ghidra shows alternating phase and two-byte source traversal; no artificial lifetime or extra VM call.
|
||||
- {"label": "pack-hex-real-phase-pointer-end-vmBoolInt", "counts": {"VmBlobPackCommon": {"diff": 255, "insns": [673, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "73d1cf266113"} Named consumed high/low nibble phase and a real index, remaining-count or input cursor. Ghidra shows alternating phase and two-byte source traversal; no artificial lifetime or extra VM call.
|
||||
- {"label": "pack-hex-real-phase-pointer-end-vmBool", "counts": {"VmBlobPackCommon": {"diff": 255, "insns": [673, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "d1915f38ce30"} Named consumed high/low nibble phase and a real index, remaining-count or input cursor. Ghidra shows alternating phase and two-byte source traversal; no artificial lifetime or extra VM call.
|
||||
- {"label": "pack-restore-after-buffer-and-phase", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "705ffdaec24d"} Restore best reviewed source after actual buffer and nibble traversal shapes.
|
||||
- {"label": "step-property-found-init-before-lookup", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 1105, "insns": [1249, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "554f8359dc13"} Initialize the real found flag on entry and remove unused arrayIdx assignments and the redundant non-array flag store. Same success, failure and branch conditions.
|
||||
- {"label": "step-property-found-init-after-lookup", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 1105, "insns": [1249, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "1f0ce1b9b7c3"} Initialize the real found flag on entry and remove unused arrayIdx assignments and the redundant non-array flag store. Same success, failure and branch conditions.
|
||||
- {"label": "step-property-found-init-guard", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 649, "insns": [1250, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "48ba164a012a"} Initialize the real found flag on entry and remove unused arrayIdx assignments and the redundant non-array flag store. Same success, failure and branch conditions.
|
||||
- {"label": "step-property-operation-output-last", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 640, "insns": [1249, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "49695948b8e6"} Real property lookup operation returns CHANSVmErr and an actual found result, like CHANSVmGetBoolean. The output controls the bytecode branch and does not hoist helper temporaries.
|
||||
- {"label": "step-property-operation-output-last-format-scope", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 640, "insns": [1249, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "b23ec141e9bc"} Same property operation, with formatting temporaries in their actual owning scope. Original 64-bit snprintf argument is preserved.
|
||||
- {"label": "step-property-operation-output-first", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 640, "insns": [1249, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "0d4424248f8e"} Real property lookup operation returns CHANSVmErr and an actual found result, like CHANSVmGetBoolean. The output controls the bytecode branch and does not hoist helper temporaries.
|
||||
- {"label": "step-property-operation-output-first-format-scope", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 640, "insns": [1249, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "b94e4670e35e"} Same property operation, with formatting temporaries in their actual owning scope. Original 64-bit snprintf argument is preserved.
|
||||
- {"label": "step-operation-helper-VmLoadStringConstant", "build": "FAIL"} Complete actual opcode operation behind a normal helper. Operand buffers are genuine input and storage used for VM object operations; no scratch carrier or artificial dependency.
|
||||
- {"label": "step-operation-helper-VmCreateArrayOpcode", "build": "FAIL"} Complete actual opcode operation behind a normal helper. Operand buffers are genuine input and storage used for VM object operations; no scratch carrier or artificial dependency.
|
||||
- {"label": "step-operation-helper-VmStoreIndirect", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "1eb11d802892"} Complete actual opcode operation behind a normal helper. Operand buffers are genuine input and storage used for VM object operations; no scratch carrier or artificial dependency.
|
||||
- {"label": "step-operation-helper-VmLoadIndirect", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "bd99a82f2c25"} Complete actual opcode operation behind a normal helper. Operand buffers are genuine input and storage used for VM object operations; no scratch carrier or artificial dependency.
|
||||
- {"label": "step-restore-after-property-operation", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "705ffdaec24d"} Restore best source after new property and object-operation boundaries.
|
||||
- {"label": "pack-consume-argument-advance-call-Blob", "counts": {"VmBlobPackCommon": {"diff": 450, "insns": [670, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "b559537f4f93"} A real next-argument expression advances the cursor at its lookup. Argument indexes and call order stay unchanged, and no counter address escapes. Nested conversion keeps the same two calls.
|
||||
- {"label": "pack-consume-argument-advance-call-Integer", "counts": {"VmBlobPackCommon": {"diff": 354, "insns": [670, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "f660f73ecb6a"} A real next-argument expression advances the cursor at its lookup. Argument indexes and call order stay unchanged, and no counter address escapes. Nested conversion keeps the same two calls.
|
||||
- {"label": "pack-consume-argument-advance-call-String", "counts": {"VmBlobPackCommon": {"diff": 253, "insns": [670, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "08ba492b44e7"} A real next-argument expression advances the cursor at its lookup. Argument indexes and call order stay unchanged, and no counter address escapes. Nested conversion keeps the same two calls.
|
||||
- {"label": "pack-consume-argument-advance-call-Hex", "counts": {"VmBlobPackCommon": {"diff": 187, "insns": [670, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "390460abe825"} A real next-argument expression advances the cursor at its lookup. Argument indexes and call order stay unchanged, and no counter address escapes. Nested conversion keeps the same two calls.
|
||||
- {"label": "pack-consume-argument-advance-call-Integer-String", "counts": {"VmBlobPackCommon": {"diff": 350, "insns": [672, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "ca6636c2679e"} A real next-argument expression advances the cursor at its lookup. Argument indexes and call order stay unchanged, and no counter address escapes. Nested conversion keeps the same two calls.
|
||||
- {"label": "pack-consume-argument-advance-call-String-Hex", "counts": {"VmBlobPackCommon": {"diff": 253, "insns": [672, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "83e444dc541f"} A real next-argument expression advances the cursor at its lookup. Argument indexes and call order stay unchanged, and no counter address escapes. Nested conversion keeps the same two calls.
|
||||
- {"label": "pack-consume-argument-advance-call-Blob-Integer-String-Hex", "counts": {"VmBlobPackCommon": {"diff": 450, "insns": [676, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "365e81430a1d"} A real next-argument expression advances the cursor at its lookup. Argument indexes and call order stay unchanged, and no counter address escapes. Nested conversion keeps the same two calls.
|
||||
- {"label": "pack-consume-argument-nested-conversion-Blob", "counts": {"VmBlobPackCommon": {"diff": 450, "insns": [670, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "b559537f4f93"} A real next-argument expression advances the cursor at its lookup. Argument indexes and call order stay unchanged, and no counter address escapes. Nested conversion keeps the same two calls.
|
||||
- {"label": "pack-consume-argument-nested-conversion-Integer", "counts": {"VmBlobPackCommon": {"diff": 354, "insns": [670, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "75618b2bc41c"} A real next-argument expression advances the cursor at its lookup. Argument indexes and call order stay unchanged, and no counter address escapes. Nested conversion keeps the same two calls.
|
||||
- {"label": "pack-consume-argument-nested-conversion-String", "counts": {"VmBlobPackCommon": {"diff": 251, "insns": [669, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "49deaae31879"} A real next-argument expression advances the cursor at its lookup. Argument indexes and call order stay unchanged, and no counter address escapes. Nested conversion keeps the same two calls.
|
||||
- {"label": "pack-consume-argument-nested-conversion-Hex", "counts": {"VmBlobPackCommon": {"diff": 250, "insns": [669, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "04cbe5619579"} A real next-argument expression advances the cursor at its lookup. Argument indexes and call order stay unchanged, and no counter address escapes. Nested conversion keeps the same two calls.
|
||||
- {"label": "pack-consume-argument-nested-conversion-Integer-String", "counts": {"VmBlobPackCommon": {"diff": 350, "insns": [671, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "67e5b3e35451"} A real next-argument expression advances the cursor at its lookup. Argument indexes and call order stay unchanged, and no counter address escapes. Nested conversion keeps the same two calls.
|
||||
- {"label": "pack-consume-argument-nested-conversion-String-Hex", "counts": {"VmBlobPackCommon": {"diff": 303, "insns": [670, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "f4f5cef096fa"} A real next-argument expression advances the cursor at its lookup. Argument indexes and call order stay unchanged, and no counter address escapes. Nested conversion keeps the same two calls.
|
||||
- {"label": "pack-consume-argument-nested-conversion-Blob-Integer-String-Hex", "counts": {"VmBlobPackCommon": {"diff": 463, "insns": [674, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "3cce13c8aeff"} A real next-argument expression advances the cursor at its lookup. Argument indexes and call order stay unchanged, and no counter address escapes. Nested conversion keeps the same two calls.
|
||||
- {"label": "pack-measure-count-after-size-Integer", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "c92bdc893fbe"} Accumulate the format element byte size before advancing its argument cursor. These local updates commute and retain all overflow/conversion rules.
|
||||
- {"label": "pack-measure-count-after-size-String", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "0055b2fe1791"} Accumulate the format element byte size before advancing its argument cursor. These local updates commute and retain all overflow/conversion rules.
|
||||
- {"label": "pack-measure-count-after-size-Hex", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "a7e4638108c1"} Accumulate the format element byte size before advancing its argument cursor. These local updates commute and retain all overflow/conversion rules.
|
||||
- {"label": "pack-measure-count-after-size-all", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "30d118739d6f"} Accumulate the format element byte size before advancing its argument cursor. These local updates commute and retain all overflow/conversion rules.
|
||||
- {"label": "pack-restore-after-argument-shapes", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "705ffdaec24d"} Restore best source after actual cursor lifetime changes.
|
||||
|
||||
## Fresh backend evidence
|
||||
|
||||
Pack capture /tmp/sol-m12-pack-capture has executable bytes, resolved text relocations and every allocated data section identical to the ordinary Ninja object. Simulator reproduces 218/218, and the manually checked array/counter want-list reaches only 2/3. All 47 baseline differences are the r18/r23 exchange. Step capture /tmp/sol-m12-step-capture likewise equals normal compilation in all allocated sections and resolved relocations and reproduces 491/491. The 10-name diagnostic reaches 8/10, but the stock search can reorder compiler @ aliases and parameters, so it is not a writable source order and no proposed ordering is applied. Maps are /tmp/sol-m12-pack-vmap.txt and /tmp/sol-m12-step-vmap.txt.
|
||||
|
||||
Opcode/relocation alignment includes HA/LO relocations stored at instruction offset +2. It identifies Step target shared rodata base 0, source separate bases 352 and 96; early count normalization and pretest branch; stack object locations; enum indexing; property flag/output stack stores; and later branch cleanup. The source jump tables currently match all 121 relocation destinations. Case priority is /tmp/sol-m12-step-case-priority.json. POP, IS_CLASS, DELETE_INDIRECT, LOG_NOT and BIT_NOT bodies already match; the first positive-difference cases differ by the shared instruction-size register. Property lookup has 92 differing positions in its 134-instruction block. Internal linkage on the real readonly globals changes no instructions. No fake common-base aggregate or cross-object pointer arithmetic is introduced.
|
||||
- {"label": "step-operation-helper-VmLoadStringConstant-fixed", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "6282fff9aa19"} Corrected helper generator retains original case declarations. Same opcode operation boundary and original call order, without hoisted local outputs.
|
||||
- {"label": "step-operation-helper-VmLoadStringConstant-decoded-input", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 695, "insns": [1252, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "550e55657ba8"} Actual decoded string index or array extent is the operation input; keep decoding at the caller and object creation inside the helper.
|
||||
- {"label": "step-operation-helper-VmCreateArrayOpcode-fixed", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "f3e3f9a42c40"} Corrected helper generator retains original case declarations. Same opcode operation boundary and original call order, without hoisted local outputs.
|
||||
- {"label": "step-operation-helper-VmCreateArrayOpcode-decoded-input", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "6b1fff6c9d84"} Actual decoded string index or array extent is the operation input; keep decoding at the caller and object creation inside the helper.
|
||||
- {"label": "step-property-output-last-pretest", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 1227, "insns": [1251, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "7d34bf2d9d62"} Combine new real property operation with assembly-proven pretest countdown or indexed operand-type output. Old standalone controls are not counted as new ideas.
|
||||
- {"label": "step-property-output-last-indexed-types", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 1099, "insns": [1250, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "2cb470409b7e"} Combine new real property operation with assembly-proven pretest countdown or indexed operand-type output. Old standalone controls are not counted as new ideas.
|
||||
- {"label": "step-property-output-last-pretest-indexed-types", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 1222, "insns": [1252, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "59a1cb761b4e"} Combine new real property operation with assembly-proven pretest countdown or indexed operand-type output. Old standalone controls are not counted as new ideas.
|
||||
- {"label": "step-property-output-first-pretest", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 1227, "insns": [1251, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "23cf3deee40e"} Combine new real property operation with assembly-proven pretest countdown or indexed operand-type output. Old standalone controls are not counted as new ideas.
|
||||
- {"label": "step-property-output-first-indexed-types", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 1099, "insns": [1250, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "bff9685e9c39"} Combine new real property operation with assembly-proven pretest countdown or indexed operand-type output. Old standalone controls are not counted as new ideas.
|
||||
- {"label": "step-property-output-first-pretest-indexed-types", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 1222, "insns": [1252, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "11b5acc54f47"} Combine new real property operation with assembly-proven pretest countdown or indexed operand-type output. Old standalone controls are not counted as new ideas.
|
||||
- {"label": "step-case-property-object-values", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "06ad45705671"} The large opcode case owns its actual object handles or decoded operands. Separate per-case values remove cross-case source reuse without a carrier or any added operation.
|
||||
- {"label": "step-case-property-operand-values", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 614, "insns": [1251, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "17f609f5347f"} The large opcode case owns its actual object handles or decoded operands. Separate per-case values remove cross-case source reuse without a carrier or any added operation.
|
||||
- {"label": "step-case-index-object-values", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "d5a261278a30"} The large opcode case owns its actual object handles or decoded operands. Separate per-case values remove cross-case source reuse without a carrier or any added operation.
|
||||
- {"label": "step-case-index-operand-values", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 703, "insns": [1251, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "bdd38f3134bd"} The large opcode case owns its actual object handles or decoded operands. Separate per-case values remove cross-case source reuse without a carrier or any added operation.
|
||||
- {"label": "step-restore-final-best", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "705ffdaec24d"} Restore best source after combined operation and indexed-operand shapes.
|
||||
- {"label": "pack-integer-store-integer-case-scope-fixed", "counts": {"VmBlobPackCommon": {"diff": 326, "insns": [677, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "0b8f526b806a"} Corrected generator identifies the outer format case with an anchored pattern. Real loop index and converted argument are owned by that case.
|
||||
- {"label": "pack-integer-store-object-case-scope-fixed", "counts": {"VmBlobPackCommon": {"diff": 322, "insns": [677, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "4278fbf87ee4"} Corrected generator identifies the outer format case with an anchored pattern. Real loop index and converted argument are owned by that case.
|
||||
- {"label": "step-case-property-real-operands", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 614, "insns": [1251, 1253]}}, "drops": [], "others": [], "data_changes": [".rela.data"], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "9bdcba724a96"} Remove the generated unused per-case array-index local. Keep only real operand buffer and decoded index values; reject if target count or table offsets differ.
|
||||
- {"label": "final-retained-checkpoint", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "705ffdaec24d"} Retain only the committed clean Pack replay; all new non-exact experiments are rejected.
|
||||
- {"label": "pack-typed-buffer-index", "counts": {"VmBlobPackCommon": {"diff": 47, "insns": [668, 668]}, "CHANSVmStep": {"diff": 262, "insns": [1253, 1253]}}, "drops": [], "others": [], "data_changes": [], "pool": "POOL IDENTICAL up to 125 (mine=125 base=125)", "sha": "a0f7d087c354"} The source scan flags cast-plus-offset spelling in the replay. Use actual typed array indexing for the known eight-byte serialization buffer; store width and order remain identical. The measurement completed successfully; an unquoted separator in its trailing shell note then attempted an unrelated command and returned 127. The later independent final checks below pass.
|
||||
|
||||
## Final result and handoff
|
||||
|
||||
The log contains 92 measurement rows: 87 successful compilations/checkpoints and five generator failures. After the cleaned replay, there are 38 compiled Pack variants (37 distinct source hashes) and 39 Step variants. These are measured variations, not 77 independent ideas: parameter orders, unchanged-code controls and the composed pretest/indexing controls are labeled above. The failed generators were corrected. The generated property-operand trial with an unused array-index local was rejected and corrected to use only real operands. Every follow-up source experiment was restored.
|
||||
|
||||
Retain the inherited Pack replay from sol-c1, with the unused hexadecimal length local removed and the signed word store written as typed array indexing. The target's explicit unused-result getter call remains. Pack improves from 230 to 47 differences, 668/668 instructions, fuzzy 98.0988 to 99.588326. There is no new exact function. The remaining 47 differences exchange the argument-array and argument-counter registers r18/r23; their opcode and resolved-relocation streams align without insertions or deletions. Fresh backend evidence reproduces the allocator, but does not supply an honest source change that fixes the exchange.
|
||||
|
||||
Step remains 262 differences, 1253/1253 instructions, fuzzy 97.23225. Its function text equals the initial bbd98e1e function exactly. The smallest differing opcode bodies mostly inherit the shared opSize register. Full property-operation boundaries, genuine case-owned inputs and object handles, readonly linkage, and operand-type/pretest compositions either preserve the original differences or change instruction counts and jump-table relocations. The target common readonly base, operand storage, property flag and loop control remain unresolved; none justifies a scratch carrier or fabricated object layout. All 121 data-table relocation destinations and every previously exact sibling are preserved in the retained object.
|
||||
|
||||
Final source SHA256: a0f7d087c354b113fcdbc456fa90f651a739af74353db4673aadac3cfc9f395c. Changed repository paths are src/channelScript/CHANSVm.c and this log. Source checkpoint ae3810af contains the clean replay; the final checkpoint also contains the typed-index spelling and this audit. The focused source diff is saved as /mnt/drive2/projects/wii-ipl-workers/_luna-runs/best/sol-m12.CHANSVm.diff.
|
||||
|
||||
Ran the requested final gate exactly once:
|
||||
|
||||
```
|
||||
python3 /mnt/drive2/projects/wii-ipl-workers/_restore0928-tools/gate.py src/channelScript/CHANSVm --quick
|
||||
full build: ok
|
||||
main.dol sha1: 26116613f624061ba99c8d1a299aaa6efa85670d
|
||||
pool: IDENTICAL
|
||||
objdiff: code 44588/53564 data 6904/6904 functions 227/233 fuzzy 99.66164 linked code 0
|
||||
instruction-exact functions: 227/233
|
||||
all five allocated data sections: 100.0
|
||||
regressions vs baseline: 0
|
||||
forbidden patterns added: 0
|
||||
readability warnings: 0
|
||||
GATE PASS
|
||||
```
|
||||
|
||||
The gate baseline is bbd98e1e, unit fuzzy 99.58733. Final live report was regenerated with Ninja progress and build/43U/report.json. Independent final ctxdiff reports Pack 47 and Step 262; pool_diff reports 125/125 identical; git diff --check passes. Direct executable-byte and resolved-relocation comparison against the initial object finds no changed sibling, exact-function drop or allocated-data change. Final evidence is /tmp/sol-m12-gate.txt, /tmp/sol-m12-final-VmBlobPackCommon.ctxdiff.txt, /tmp/sol-m12-final-CHANSVmStep.ctxdiff.txt and /tmp/sol-m12-final-pool.txt. This is a validated partial replay, with the unit still NonMatching and unlinked.
|
||||
Reference in New Issue
Block a user