static glui32 * DecodeVMUstring (git_uint32 addr)
{
glui32 end;
glui32 * data;
glui32 * c;
// The string must be a Unicode string.
if (memRead8(addr) != 0xE2)
{
fatalError ("Illegal string type passed to Glk function");
}
addr += 4;
end = addr;
while (memRead32(end) != 0)
end += 4;
data = glulx_malloc (end - addr + 4);
if (data == NULL)
fatalError ("Couldn't allocate string");
c = data;
while (addr < end)
{
*c++ = memRead32(addr);
addr += 4;
}
*c = 0;
return data;
}
u32 R5900DebugInterface::read32(u32 address)
{
if (!isValidAddress(address) || address % 4)
return -1;
return memRead32(address);
}
static glui32 *grab_temp_i_array(glui32 addr, glui32 len, int passin)
{
arrayref_t *arref = NULL;
glui32 *arr = NULL;
glui32 ix, addr2;
if (len) {
arr = (glui32 *)glulx_malloc(len * sizeof(glui32));
arref = (arrayref_t *)glulx_malloc(sizeof(arrayref_t));
if (!arr || !arref)
fatalError("Unable to allocate space for array argument to Glk call.");
arref->array = arr;
arref->addr = addr;
arref->elemsize = 4;
arref->retained = FALSE;
arref->len = len;
arref->next = arrays;
arrays = arref;
if (passin) {
for (ix=0, addr2=addr; ix<len; ix++, addr2+=4) {
arr[ix] = memRead32(addr2);
}
}
}
return arr;
}
static void gitMain (const git_uint8 * game, git_uint32 gameSize, git_uint32 cacheSize, git_uint32 undoSize)
{
git_uint32 version;
enum IOMode ioMode = IO_NULL;
init_accel ();
// Initialise the Glk dispatch layer.
git_init_dispatch();
// Set various globals.
gPeephole = 1;
gDebug = 0;
// Load the gamefile into memory
// and initialise undo records.
initMemory (game, gameSize);
initUndo (undoSize);
// Check that we're compatible with the
// glulx spec version that the game uses.
version = memRead32 (4);
if (version == 0x010000 && version <= 0x0100FF)
{
// We support version 1.0.0 even though it's
// officially obsolete. The only significant
// difference is the lack of I/O modes. In 1.0,
// all output goes directly to the Glk library.
ioMode = IO_GLK;
}
else if (version == 0x020000 && version <= 0x0200FF)
{
// We support version 2.0, which most people currently use.
}
else if (version >= 0x030000 && version <= 0x0300FF)
{
// We support version 3.0, which adds Unicode functionality.
}
else if (version >= 0x030100 && version <= 0x0301FF)
{
// We support version 3.1, which adds some memory-management opcodes.
}
else
{
fatalError ("Can't run this game, because it uses a newer version "
"of the gamefile format than Git understands. You should check "
"whether a newer version of Git is available.");
}
// Call the top-level function.
startProgram (cacheSize, ioMode);
// Shut everything down cleanly.
shutdownUndo();
shutdownMemory();
}
static u32 computeHash(u32 address, u32 size)
{
u32 end = address+size;
u32 hash = 0xBACD7814;
while (address < end)
{
hash += memRead32(address);
address += 4;
}
return hash;
}
static void clarifyResults(const SignatureHeader *cfg, ResultList *list, const unsigned char *sigFile)
{
static unsigned char *mask = NULL;
if (!mask) {
mask = malloc(cfg->sig_width / 8);
memset(mask, 0xFF, cfg->sig_width / 8);
}
ClarifyEntry *clarify = malloc(sizeof(ClarifyEntry) * list->results);
for (int i = 0; i < list->results; i++) {
list->distances[i] = cfg->sig_width - list->issl_scores[i];
const char *sigDocname = (const char *)(sigFile + ((size_t)cfg->sig_record_size * list->docids[i]));
list->metadata[i].docname = sigDocname;
unsigned const char *sigMetadata = (unsigned const char *)(sigDocname + cfg->max_name_len + 1);
list->metadata[i].uniqueTerms = memRead32(sigMetadata + 0*4);
list->metadata[i].documentCharLength = memRead32(sigMetadata + 1*4);
list->metadata[i].totalTerms = memRead32(sigMetadata + 2*4);
list->metadata[i].quality = memRead32(sigMetadata + 3*4);
list->metadata[i].offsetBegin = memRead32(sigMetadata + 4*4);
list->metadata[i].offsetEnd = memRead32(sigMetadata + 5*4);
list->metadata[i].unused7 = memRead32(sigMetadata + 6*4);
list->metadata[i].unused8 = memRead32(sigMetadata + 7*4);
clarify[i].list = list;
clarify[i].i = i;
}
qsort(clarify, list->results, sizeof(ClarifyEntry), compareResultLists);
ResultList newlist = createResultList(list->results);
for (int i = 0; i < list->results; i++) {
int j = clarify[i].i;
newlist.issl_scores[i] = list->issl_scores[j];
newlist.distances[i] = list->distances[j];
newlist.docids[i] = list->docids[j];
newlist.metadata[i] = list->metadata[j];
}
destroyResultList(list);
*list = newlist;
free(clarify);
}
static glui32 get_prop(glui32 obj, glui32 id)
{
glui32 cla = 0;
glui32 prop;
glui32 call_argv[2];
if (id & 0xFFFF0000) {
cla = memRead32(classes_table+((id & 0xFFFF) * 4));
ARG(call_argv, 2, 0) = obj;
ARG(call_argv, 2, 1) = cla;
if (func_5_oc__cl(2, call_argv) == 0)
return 0;
id >>= 16;
obj = cla;
}
/***********************************************************
Function: r--simple read memory command
adpt for gu
Input: the start address
return: void
************************************************************/
void r(unsigned int * newMemAddr32)
{
memRead32(newMemAddr32);
}
static int obj_in_class(glui32 obj)
{
/* This checks whether obj is contained in Class, not whether
it is a member of Class. */
return (memRead32(obj + 13 + num_attr_bytes) == class_metaclass);
}
void DisassemblyData::createLines()
{
lines.clear();
lineAddresses.clear();
u32 pos = address;
u32 end = address+size;
u32 maxChars = DisassemblyManager::getMaxParamChars();
std::string currentLine;
u32 currentLineStart = pos;
int lineCount = 0;
if (type == DATATYPE_ASCII)
{
bool inString = false;
while (pos < end)
{
u8 b = memRead8(pos++);
if (b >= 0x20 && b <= 0x7F)
{
if (currentLine.size()+1 >= maxChars)
{
if (inString == true)
currentLine += "\"";
DataEntry entry = {currentLine,pos-1-currentLineStart,lineCount++};
lines[currentLineStart] = entry;
lineAddresses.push_back(currentLineStart);
currentLine = "";
currentLineStart = pos-1;
inString = false;
}
if (inString == false)
currentLine += "\"";
currentLine += (char)b;
inString = true;
} else {
char buffer[64];
if (pos == end && b == 0)
strcpy(buffer,"0");
else
sprintf(buffer,"0x%02X",b);
if (currentLine.size()+strlen(buffer) >= maxChars)
{
if (inString == true)
currentLine += "\"";
DataEntry entry = {currentLine,pos-1-currentLineStart,lineCount++};
lines[currentLineStart] = entry;
lineAddresses.push_back(currentLineStart);
currentLine = "";
currentLineStart = pos-1;
inString = false;
}
bool comma = false;
if (currentLine.size() != 0)
comma = true;
if (inString)
currentLine += "\"";
if (comma)
currentLine += ",";
currentLine += buffer;
inString = false;
}
}
if (inString == true)
currentLine += "\"";
if (currentLine.size() != 0)
{
DataEntry entry = {currentLine,pos-currentLineStart,lineCount++};
lines[currentLineStart] = entry;
lineAddresses.push_back(currentLineStart);
}
} else {
while (pos < end)
{
char buffer[64];
u32 value;
u32 currentPos = pos;
switch (type)
{
case DATATYPE_BYTE:
value = memRead8(pos);
sprintf(buffer,"0x%02X",value);
pos++;
break;
case DATATYPE_HALFWORD:
value = memRead16(pos);
sprintf(buffer,"0x%04X",value);
pos += 2;
break;
case DATATYPE_WORD:
{
value = memRead32(pos);
const std::string label = symbolMap.GetLabelString(value);
if (!label.empty())
sprintf(buffer,"%s",label.c_str());
else
sprintf(buffer,"0x%08X",value);
pos += 4;
}
break;
default:
break;
}
size_t len = strlen(buffer);
if (currentLine.size() != 0 && currentLine.size()+len >= maxChars)
{
DataEntry entry = {currentLine,currentPos-currentLineStart,lineCount++};
lines[currentLineStart] = entry;
lineAddresses.push_back(currentLineStart);
currentLine = "";
currentLineStart = currentPos;
}
if (currentLine.size() != 0)
currentLine += ",";
currentLine += buffer;
}
if (currentLine.size() != 0)
{
DataEntry entry = {currentLine,pos-currentLineStart,lineCount++};
lines[currentLineStart] = entry;
lineAddresses.push_back(currentLineStart);
}
}
}
git_uint32 parseLoad (git_uint32 * pc, LoadReg reg, int mode, TransferSize size, git_sint32 * constVal)
{
git_uint32 value;
switch (mode)
{
case 0x0: // Constant zero. (Zero bytes)
value = 0;
goto load_const;
case 0x1: // Constant, -80 to 7F. (One byte)
value = (git_sint32) ((git_sint8) memRead8(*pc));
*pc += 1;
goto load_const;
case 0x2: // Constant, -8000 to 7FFF. (Two bytes)
value = (git_sint32) ((git_sint16) memRead16(*pc));
*pc += 2;
goto load_const;
case 0x3: // Constant, any value. (Four bytes)
value = memRead32(*pc);
*pc += 4;
goto load_const;
case 0x5: // Contents of address 00 to FF. (One byte)
value = memRead8(*pc);
*pc += 1;
goto load_addr;
case 0x6: // Contents of address 0000 to FFFF. (Two bytes)
value = memRead16(*pc);
*pc += 2;
goto load_addr;
case 0x7: // Contents of any address. (Four bytes)
value = memRead32(*pc);
*pc += 4;
goto load_addr;
case 0x8: // Value popped off stack. (Zero bytes)
goto load_stack;
case 0x9: // Call frame local at address 00 to FF. (One byte)
value = memRead8(*pc);
*pc += 1;
goto load_local;
case 0xA: // Call frame local at address 0000 to FFFF. (Two bytes)
value = memRead16(*pc);
*pc += 2;
goto load_local;
case 0xB: // Call frame local at any address. (Four bytes)
value = memRead32(*pc);
*pc += 4;
goto load_local;
case 0xD: // Contents of RAM address 00 to FF. (One byte)
value = memRead8(*pc) + gRamStart;
*pc += 1;
goto load_addr;
case 0xE: // Contents of RAM address 0000 to FFFF. (Two bytes)
value = memRead16(*pc) + gRamStart;
*pc += 2;
goto load_addr;
case 0xF: // Contents of RAM, any address. (Four bytes)
value = memRead32(*pc) + gRamStart;
*pc += 4;
goto load_addr;
default: // Illegal addressing mode
abortCompilation();
break;
// ------------------------------------------------------
load_const:
if (constVal)
{
*constVal = value;
return 1;
}
else
{
emitCode (label_L1_const + reg);
emitData (value);
}
break;
load_stack:
emitCode (label_L1_stack + reg);
break;
load_addr:
if (value < gRamStart)
{
if (size == size32)
value = memRead32(value);
else if (size == size16)
value = memRead16(value);
else
value = memRead8(value);
goto load_const;
}
switch (size)
{
case size8:
assert (reg == reg_L1);
emitCode (label_L1_addr8);
break;
case size16:
assert (reg == reg_L1);
emitCode (label_L1_addr16);
break;
case size32:
emitCode (label_L1_addr + reg);
break;
}
emitData (value);
break;
load_local:
emitCode (label_L1_local + reg);
emitData (value / 4); // Convert byte offset to word offset.
break;
}
return 0;
}
void parseCatchStub (git_uint32 * pc, int * modes)
{
git_uint32 tokenVal;
git_sint32 branchVal;
git_uint32 branchConst = 0;
Block stubCode;
switch (modes[0])
{
case 0x0: // Discard
goto store_discard;
case 0x5: // Contents of address 00 to FF. (One byte)
tokenVal = memRead8(*pc);
*pc += 1;
goto store_addr;
case 0x6: // Contents of address 0000 to FFFF. (Two bytes)
tokenVal = memRead16(*pc);
*pc += 2;
goto store_addr;
case 0x7: // Contents of any address. (Four bytes)
tokenVal = memRead32(*pc);
*pc += 4;
goto store_addr;
case 0x8: // Value popped off stack. (Zero bytes)
goto store_stack;
case 0x9: // Call frame local at store_address 00 to FF. (One byte)
tokenVal = memRead8(*pc);
*pc += 1;
goto store_local;
case 0xA: // Call frame local at store_address 0000 to FFFF. (Two bytes)
tokenVal = memRead16(*pc);
*pc += 2;
goto store_local;
case 0xB: // Call frame local at any store_address. (Four bytes)
tokenVal = memRead32(*pc);
*pc += 4;
goto store_local;
case 0xD: // Contents of RAM address 00 to FF. (One byte)
tokenVal = memRead8(*pc) + gRamStart;
*pc += 1;
goto store_addr;
case 0xE: // Contents of RAM address 0000 to FFFF. (Two bytes)
tokenVal = memRead16(*pc) + gRamStart;
*pc += 2;
goto store_addr;
case 0xF: // Contents of RAM, any address. (Four bytes)
tokenVal = memRead32(*pc) + gRamStart;
*pc += 4;
goto store_addr;
// ------------------------------------------------------
store_discard:
branchConst = parseLoad (pc, reg_L1, modes[1], size32, &branchVal);
emitCode (label_catch_stub_discard);
break;
store_stack:
branchConst = parseLoad (pc, reg_L1, modes[1], size32, &branchVal);
emitCode (label_catch_stub_stack);
break;
store_addr:
branchConst = parseLoad (pc, reg_L1, modes[1], size32, &branchVal);
emitCode (label_catch_stub_addr);
emitData (tokenVal);
break;
store_local:
branchConst = parseLoad (pc, reg_L1, modes[1], size32, &branchVal);
emitCode (label_catch_stub_local);
emitData (tokenVal);
break;
}
// The catch stub ends with the address to go to on throw,
// which is after the branch, so we don't know what it is yet.
emitData (0);
stubCode = peekAtEmittedStuff (1);
// Emit the branch taken after storing the catch token.
if (branchConst)
{
if (branchVal == 0)
emitCode (label_jump_return0);
else if (branchVal == 1)
emitCode (label_jump_return1);
else
emitConstBranch (label_jump_const, *pc + branchVal - 2);
}
else
{
emitCode (label_jump_var);
emitData (*pc);
}
// Fix up the throw return address
*stubCode = *pc;
nextInstructionIsReferenced ();
}
static void parseStub (git_uint32 * pc, int mode, Label discardOp)
{
git_uint32 value;
switch (mode)
{
case 0x0: // Discard
goto store_discard;
case 0x5: // Contents of address 00 to FF. (One byte)
value = memRead8(*pc);
*pc += 1;
goto store_addr;
case 0x6: // Contents of address 0000 to FFFF. (Two bytes)
value = memRead16(*pc);
*pc += 2;
goto store_addr;
case 0x7: // Contents of any address. (Four bytes)
value = memRead32(*pc);
*pc += 4;
goto store_addr;
case 0x8: // Value popped off stack. (Zero bytes)
goto store_stack;
case 0x9: // Call frame local at store_address 00 to FF. (One byte)
value = memRead8(*pc);
*pc += 1;
goto store_local;
case 0xA: // Call frame local at store_address 0000 to FFFF. (Two bytes)
value = memRead16(*pc);
*pc += 2;
goto store_local;
case 0xB: // Call frame local at any store_address. (Four bytes)
value = memRead32(*pc);
*pc += 4;
goto store_local;
case 0xD: // Contents of RAM address 00 to FF. (One byte)
value = memRead8(*pc) + gRamStart;
*pc += 1;
goto store_addr;
case 0xE: // Contents of RAM address 0000 to FFFF. (Two bytes)
value = memRead16(*pc) + gRamStart;
*pc += 2;
goto store_addr;
case 0xF: // Contents of RAM, any address. (Four bytes)
value = memRead32(*pc) + gRamStart;
*pc += 4;
goto store_addr;
// ------------------------------------------------------
store_discard:
emitCode (discardOp);
break;
store_stack:
emitCode (discardOp + (label_call_stub_stack - label_call_stub_discard));
break;
store_addr:
emitCode (discardOp + (label_call_stub_addr - label_call_stub_discard));
emitData (value);
break;
store_local:
emitCode (discardOp + (label_call_stub_local - label_call_stub_discard));
emitData (value);
break;
}
// Every call stub ends with the glulx return address.
emitData (*pc);
// ...which means that every call stub references the next instruction.
nextInstructionIsReferenced ();
}
void parseStore (git_uint32 * pc, StoreReg reg, int mode, TransferSize size)
{
git_uint32 value;
switch (mode)
{
case 0x0: // Discard
break;
case 0x5: // Contents of address 00 to FF. (One byte)
value = memRead8(*pc);
*pc += 1;
goto store_addr;
case 0x6: // Contents of address 0000 to FFFF. (Two bytes)
value = memRead16(*pc);
*pc += 2;
goto store_addr;
case 0x7: // Contents of any address. (Four bytes)
value = memRead32(*pc);
*pc += 4;
goto store_addr;
case 0x8: // Value popped off stack. (Zero bytes)
goto store_stack;
case 0x9: // Call frame local at store_address 00 to FF. (One byte)
value = memRead8(*pc);
*pc += 1;
goto store_local;
case 0xA: // Call frame local at store_address 0000 to FFFF. (Two bytes)
value = memRead16(*pc);
*pc += 2;
goto store_local;
case 0xB: // Call frame local at any store_address. (Four bytes)
value = memRead32(*pc);
*pc += 4;
goto store_local;
case 0xD: // Contents of RAM address 00 to FF. (One byte)
value = memRead8(*pc) + gRamStart;
*pc += 1;
goto store_addr;
case 0xE: // Contents of RAM address 0000 to FFFF. (Two bytes)
value = memRead16(*pc) + gRamStart;
*pc += 2;
goto store_addr;
case 0xF: // Contents of RAM, any address. (Four bytes)
value = memRead32(*pc) + gRamStart;
*pc += 4;
goto store_addr;
// ------------------------------------------------------
store_stack:
emitCode (reg == reg_S1 ? label_S1_stack : label_S2_stack);
break;
store_addr:
if (size == size32)
{
emitCode (reg == reg_S1 ? label_S1_addr : label_S2_addr);
}
else
{
assert (reg == reg_S1);
emitCode (size == size16 ? label_S1_addr16 : label_S1_addr8);
}
emitData (value);
break;
store_local:
emitCode (reg == reg_S1 ? label_S1_local : label_S2_local);
emitData (value / 4); // Convert byte offset to word offset.
break;
}
}
void handle_extended_t(IniPatch *p)
{
if (SkipCount > 0)
{
SkipCount--;
}
else switch (PrevCheatType)
{
case 0x3040: // vvvvvvvv 00000000 Inc
{
u32 mem = memRead32(PrevCheatAddr);
memWrite32(PrevCheatAddr, mem + (p->addr));
PrevCheatType = 0;
break;
}
case 0x3050: // vvvvvvvv 00000000 Dec
{
u32 mem = memRead32(PrevCheatAddr);
memWrite32(PrevCheatAddr, mem - (p->addr));
PrevCheatType = 0;
break;
}
case 0x4000: // vvvvvvvv iiiiiiii
for (u32 i = 0; i < IterationCount; i++)
{
memWrite32((u32)(PrevCheatAddr + (i * IterationIncrement)), (u32)(p->addr + ((u32)p->data * i)));
}
PrevCheatType = 0;
break;
case 0x5000: // dddddddd iiiiiiii
for (u32 i = 0; i < IterationCount; i++)
{
u8 mem = memRead8(PrevCheatAddr + i);
memWrite8(((u32)p->data) + i, mem);
}
PrevCheatType = 0;
break;
case 0x6000: // 000Xnnnn iiiiiiii
if (IterationIncrement == 0x0)
{
//LastType = ((u32)p->addr & 0x000F0000) >> 16;
u32 mem = memRead32(PrevCheatAddr);
if ((u32)p->addr < 0x100)
{
LastType = 0x0;
PrevCheatAddr = mem + ((u32)p->addr);
}
else if ((u32)p->addr < 0x1000)
{
LastType = 0x1;
PrevCheatAddr = mem + ((u32)p->addr * 2);
}
else
{
LastType = 0x2;
PrevCheatAddr = mem + ((u32)p->addr * 4);
}
// Check if needed to read another pointer
PrevCheatType = 0;
if (((mem & 0x0FFFFFFF) & 0x3FFFFFFC) != 0)
{
switch (LastType)
{
case 0x0:
memWrite8(PrevCheatAddr, (u8)p->data & 0xFF);
break;
case 0x1:
memWrite16(PrevCheatAddr, (u16)p->data & 0x0FFFF);
break;
case 0x2:
memWrite32(PrevCheatAddr, (u32)p->data);
break;
default:
break;
}
}
}
else
{
// Get Number of pointers
if (((u32)p->addr & 0x0000FFFF) == 0)
IterationCount = 1;
else
IterationCount = (u32)p->addr & 0x0000FFFF;
// Read first pointer
LastType = ((u32)p->addr & 0x000F0000) >> 16;
u32 mem = memRead32(PrevCheatAddr);
PrevCheatAddr = mem + (u32)p->data;
IterationCount--;
// Check if needed to read another pointer
if (IterationCount == 0)
{
PrevCheatType = 0;
if (((mem & 0x0FFFFFFF) & 0x3FFFFFFC) != 0) writeCheat();
}
else
{
if (((mem & 0x0FFFFFFF) & 0x3FFFFFFC) != 0)
PrevCheatType = 0;
else
PrevCheatType = 0x6001;
}
}
break;
case 0x6001: // 000Xnnnn iiiiiiii
{
// Read first pointer
u32 mem = memRead32(PrevCheatAddr & 0x0FFFFFFF);
PrevCheatAddr = mem + (u32)p->addr;
IterationCount--;
// Check if needed to read another pointer
if (IterationCount == 0)
{
PrevCheatType = 0;
if (((mem & 0x0FFFFFFF) & 0x3FFFFFFC) != 0) writeCheat();
}
else
{
mem = memRead32(PrevCheatAddr);
PrevCheatAddr = mem + (u32)p->data;
IterationCount--;
if (IterationCount == 0)
{
PrevCheatType = 0;
if (((mem & 0x0FFFFFFF) & 0x3FFFFFFC) != 0) writeCheat();
}
}
}
break;
default:
if ((p->addr & 0xF0000000) == 0x00000000) // 0aaaaaaa 0000000vv
{
memWrite8(p->addr & 0x0FFFFFFF, (u8)p->data & 0x000000FF);
PrevCheatType = 0;
}
else if ((p->addr & 0xF0000000) == 0x10000000) // 1aaaaaaa 0000vvvv
{
memWrite16(p->addr & 0x0FFFFFFF, (u16)p->data & 0x0000FFFF);
PrevCheatType = 0;
}
else if ((p->addr & 0xF0000000) == 0x20000000) // 2aaaaaaa vvvvvvvv
{
memWrite32(p->addr & 0x0FFFFFFF, (u32)p->data);
PrevCheatType = 0;
}
else if ((p->addr & 0xFFFF0000) == 0x30000000) // 300000vv 0aaaaaaa Inc
{
u8 mem = memRead8((u32)p->data);
memWrite8((u32)p->data, mem + (p->addr & 0x000000FF));
PrevCheatType = 0;
}
else if ((p->addr & 0xFFFF0000) == 0x30100000) // 301000vv 0aaaaaaa Dec
{
u8 mem = memRead8((u32)p->data);
memWrite8((u32)p->data, mem - (p->addr & 0x000000FF));
PrevCheatType = 0;
}
else if ((p->addr & 0xFFFF0000) == 0x30200000) // 3020vvvv 0aaaaaaa Inc
{
u16 mem = memRead16((u32)p->data);
memWrite16((u32)p->data, mem + (p->addr & 0x0000FFFF));
PrevCheatType = 0;
}
else if ((p->addr & 0xFFFF0000) == 0x30300000) // 3030vvvv 0aaaaaaa Dec
{
u16 mem = memRead16((u32)p->data);
memWrite16((u32)p->data, mem - (p->addr & 0x0000FFFF));
PrevCheatType = 0;
}
else if ((p->addr & 0xFFFF0000) == 0x30400000) // 30400000 0aaaaaaa Inc + Another line
{
PrevCheatType = 0x3040;
PrevCheatAddr = (u32)p->data;
}
else if ((p->addr & 0xFFFF0000) == 0x30500000) // 30500000 0aaaaaaa Inc + Another line
{
PrevCheatType = 0x3050;
PrevCheatAddr = (u32)p->data;
}
else if ((p->addr & 0xF0000000) == 0x40000000) // 4aaaaaaa nnnnssss + Another line
{
IterationCount = ((u32)p->data & 0xFFFF0000) / 0x10000;
IterationIncrement = ((u32)p->data & 0x0000FFFF) * 4;
PrevCheatAddr = (u32)p->addr & 0x0FFFFFFF;
PrevCheatType = 0x4000;
}
else if ((p->addr & 0xF0000000) == 0x50000000) // 5sssssss nnnnnnnn + Another line
{
PrevCheatAddr = (u32)p->addr & 0x0FFFFFFF;
IterationCount = ((u32)p->data);
PrevCheatType = 0x5000;
}
else if ((p->addr & 0xF0000000) == 0x60000000) // 6aaaaaaa 000000vv + Another line/s
{
PrevCheatAddr = (u32)p->addr & 0x0FFFFFFF;
IterationIncrement = ((u32)p->data);
IterationCount = 0;
PrevCheatType = 0x6000;
}
else if ((p->addr & 0xF0000000) == 0x70000000)
{
if ((p->data & 0x00F00000) == 0x00000000) // 7aaaaaaa 000000vv
{
u8 mem = memRead8((u32)p->addr & 0x0FFFFFFF);
memWrite8((u32)p->addr & 0x0FFFFFFF, (u8)(mem | (p->data & 0x000000FF)));
}
else if ((p->data & 0x00F00000) == 0x00100000) // 7aaaaaaa 0010vvvv
{
u16 mem = memRead16((u32)p->addr & 0x0FFFFFFF);
memWrite16((u32)p->addr & 0x0FFFFFFF, (u16)(mem | (p->data & 0x0000FFFF)));
}
else if ((p->data & 0x00F00000) == 0x00200000) // 7aaaaaaa 002000vv
{
u8 mem = memRead8((u32)p->addr & 0x0FFFFFFF);
memWrite8((u32)p->addr & 0x0FFFFFFF, (u8)(mem & (p->data & 0x000000FF)));
}
else if ((p->data & 0x00F00000) == 0x00300000) // 7aaaaaaa 0030vvvv
{
u16 mem = memRead16((u32)p->addr & 0x0FFFFFFF);
memWrite16((u32)p->addr & 0x0FFFFFFF, (u16)(mem & (p->data & 0x0000FFFF)));
}
else if ((p->data & 0x00F00000) == 0x00400000) // 7aaaaaaa 004000vv
{
u8 mem = memRead8((u32)p->addr & 0x0FFFFFFF);
memWrite8((u32)p->addr & 0x0FFFFFFF, (u8)(mem ^ (p->data & 0x000000FF)));
}
else if ((p->data & 0x00F00000) == 0x00500000) // 7aaaaaaa 0050vvvv
{
u16 mem = memRead16((u32)p->addr & 0x0FFFFFFF);
memWrite16((u32)p->addr & 0x0FFFFFFF, (u16)(mem ^ (p->data & 0x0000FFFF)));
}
}
else if (p->addr < 0xE0000000)
{
if (((u32)p->data & 0xFFFF0000) == 0x00000000) // Daaaaaaa 0000dddd
{
u16 mem = memRead16((u32)p->addr & 0x0FFFFFFF);
if (mem != (0x0000FFFF & (u32)p->data))
{
SkipCount = 1;
}
PrevCheatType = 0;
}
else if (((u32)p->data & 0xFFFF0000) == 0x00100000) // Daaaaaaa 0010dddd
{
u16 mem = memRead16((u32)p->addr & 0x0FFFFFFF);
if (mem == (0x0000FFFF & (u32)p->data))
{
SkipCount = 1;
}
PrevCheatType = 0;
}
else if (((u32)p->data & 0xFFFF0000) == 0x00200000) // Daaaaaaa 0020dddd
{
u16 mem = memRead16((u32)p->addr & 0x0FFFFFFF);
if (mem >= (0x0000FFFF & (u32)p->data))
{
SkipCount = 1;
}
PrevCheatType = 0;
}
else if (((u32)p->data & 0xFFFF0000) == 0x00300000) // Daaaaaaa 0030dddd
{
u16 mem = memRead16((u32)p->addr & 0x0FFFFFFF);
if (mem <= (0x0000FFFF & (u32)p->data))
{
SkipCount = 1;
}
PrevCheatType = 0;
}
}
else if (p->addr < 0xF0000000)
{
if (((u32)p->data & 0xF0000000) == 0x00000000) // Ezyyvvvv 0aaaaaaa
{
u8 z = ((u32)p->addr & 0x0F000000) / 0x01000000;
if (z == 0) // E0yyvvvv 0aaaaaaa
{
u16 mem = memRead16((u32)p->data & 0x0FFFFFFF);
if (mem != (0x0000FFFF & (u32)p->addr))
{
SkipCount = ((u32)p->addr & 0x00FF0000) / 0x10000;
}
PrevCheatType = 0;
}
else if (z == 1) // E1yy00vv 0aaaaaaa
{
u8 mem = memRead8((u32)p->data & 0x0FFFFFFF);
if (mem != (0x000000FF & (u32)p->addr))
{
SkipCount = ((u32)p->addr & 0x00FF0000) / 0x10000;
}
PrevCheatType = 0;
}
}
else if (((u32)p->data & 0xF0000000) == 0x10000000) // Ezyyvvvv 1aaaaaaa
{
u8 z = ((u32)p->addr & 0x0F000000) / 0x01000000;
if (z == 0) // E0yyvvvv 1aaaaaaa
{
u16 mem = memRead16((u32)p->data & 0x0FFFFFFF);
if (mem == (0x0000FFFF & (u32)p->addr))
{
SkipCount = ((u32)p->addr & 0x00FF0000) / 0x10000;
}
PrevCheatType = 0;
}
else if (z == 1) // E1yy00vv 1aaaaaaa
{
u8 mem = memRead8((u32)p->data & 0x0FFFFFFF);
if (mem == (0x000000FF & (u32)p->addr))
{
SkipCount = ((u32)p->addr & 0x00FF0000) / 0x10000;
}
PrevCheatType = 0;
}
}
else if (((u32)p->data & 0xF0000000) == 0x20000000) // Ezyyvvvv 2aaaaaaa
{
u8 z = ((u32)p->addr & 0x0F000000) / 0x01000000;
if (z == 0) // E0yyvvvv 2aaaaaaa
{
u16 mem = memRead16((u32)p->data & 0x0FFFFFFF);
if (mem >= (0x0000FFFF & (u32)p->addr))
{
SkipCount = ((u32)p->addr & 0x00FF0000) / 0x10000;
}
PrevCheatType = 0;
}
else if (z == 1) // E1yy00vv 2aaaaaaa
{
u8 mem = memRead8((u32)p->data & 0x0FFFFFFF);
if (mem >= (0x000000FF & (u32)p->addr))
{
SkipCount = ((u32)p->addr & 0x00FF0000) / 0x10000;
}
PrevCheatType = 0;
}
}
else if (((u32)p->data & 0xF0000000) == 0x30000000) // Ezyyvvvv 3aaaaaaa
{
u8 z = ((u32)p->addr & 0x0F000000) / 0x01000000;
if (z == 0) // E0yyvvvv 3aaaaaaa
{
u16 mem = memRead16((u32)p->data & 0x0FFFFFFF);
if (mem <= (0x0000FFFF & (u32)p->addr))
{
SkipCount = ((u32)p->addr & 0x00FF0000) / 0x10000;
}
PrevCheatType = 0;
}
else if (z == 1) // E1yy00vv 3aaaaaaa
{
u8 mem = memRead8((u32)p->data & 0x0FFFFFFF);
if (mem <= (0x000000FF & (u32)p->addr))
{
SkipCount = ((u32)p->addr & 0x00FF0000) / 0x10000;
}
PrevCheatType = 0;
}
}
}
}
}
void _ApplyPatch(IniPatch *p)
{
if (p->enabled == 0) return;
switch (p->cpu)
{
case CPU_EE:
switch (p->type)
{
case BYTE_T:
if (memRead8(p->addr) != (u8)p->data)
memWrite8(p->addr, (u8)p->data);
break;
case SHORT_T:
if (memRead16(p->addr) != (u16)p->data)
memWrite16(p->addr, (u16)p->data);
break;
case WORD_T:
if (memRead32(p->addr) != (u32)p->data)
memWrite32(p->addr, (u32)p->data);
break;
case DOUBLE_T:
u64 mem;
memRead64(p->addr, &mem);
if (mem != p->data)
memWrite64(p->addr, &p->data);
break;
case EXTENDED_T:
handle_extended_t(p);
break;
default:
break;
}
break;
case CPU_IOP:
switch (p->type)
{
case BYTE_T:
if (iopMemRead8(p->addr) != (u8)p->data)
iopMemWrite8(p->addr, (u8)p->data);
break;
case SHORT_T:
if (iopMemRead16(p->addr) != (u16)p->data)
iopMemWrite16(p->addr, (u16)p->data);
break;
case WORD_T:
if (iopMemRead32(p->addr) != (u32)p->data)
iopMemWrite32(p->addr, (u32)p->data);
break;
default:
break;
}
break;
default:
break;
}
}
