thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

SCI: Add setter/getter methods to reg_t's

Browse source 
No functionality change has been made with this commit. This avoids
setting and getting the reg_t members directly, and is the basis of any
future work on large SCI3 scripts (larger than 64KB)
This commit is contained in:
Filippos Karapetis 2012-06-18 05:21:59 +03:00
parent 3c04d333f2
commit 2b50824133
36 changed files with 457 additions and 425 deletions
Download patch file Download diff file Expand all files Collapse all files

105
engines/sci/console.cpp
View file

@ -1243,7 +1243,7 @@ bool Console::cmdClassTable(int argc, const char **argv) {
for (uint i = 0; i < _engine->_gamestate->_segMan->classTableSize(); i++) {
Class temp = _engine->_gamestate->_segMan->_classTable[i];
if (temp.reg.segment) {
if (temp.reg.getSegment()) {
const char *className = _engine->_gamestate->_segMan->getObjectName(temp.reg);
if (argc == 1 || (argc == 2 && !strcmp(className, argv[1]))) {
DebugPrintf(" Class 0x%x (%s) at %04x:%04x (script %d)\n", i,
@ -1688,7 +1688,7 @@ bool Console::cmdSavedBits(int argc, const char **argv) {
Common::Array<reg_t> entries = hunks->listAllDeallocatable(id);
for (uint i = 0; i < entries.size(); ++i) {
uint16 offset = entries[i].offset;
uint16 offset = entries[i].getOffset();
const Hunk& h = hunks->_table[offset];
if (strcmp(h.type, "SaveBits()") == 0) {
byte* memoryPtr = (byte *)h.mem;
@ -1751,12 +1751,12 @@ bool Console::cmdShowSavedBits(int argc, const char **argv) {
return true;
}
if (memoryHandle.segment != id || !hunks->isValidOffset(memoryHandle.offset)) {
if (memoryHandle.getSegment() != id || !hunks->isValidOffset(memoryHandle.getOffset())) {
DebugPrintf("Invalid address.\n");
return true;
}
const Hunk& h = hunks->_table[memoryHandle.offset];
const Hunk& h = hunks->_table[memoryHandle.getOffset()];
if (strcmp(h.type, "SaveBits()") != 0) {
DebugPrintf("Invalid address.\n");
@ -2266,16 +2266,16 @@ bool Console::cmdGCShowReachable(int argc, const char **argv) {
return true;
}
SegmentObj *mobj = _engine->_gamestate->_segMan->getSegmentObj(addr.segment);
SegmentObj *mobj = _engine->_gamestate->_segMan->getSegmentObj(addr.getSegment());
if (!mobj) {
DebugPrintf("Unknown segment : %x\n", addr.segment);
DebugPrintf("Unknown segment : %x\n", addr.getSegment());
return 1;
}
DebugPrintf("Reachable from %04x:%04x:\n", PRINT_REG(addr));
const Common::Array<reg_t> tmp = mobj->listAllOutgoingReferences(addr);
for (Common::Array<reg_t>::const_iterator it = tmp.begin(); it != tmp.end(); ++it)
if (it->segment)
if (it->getSegment())
g_sci->getSciDebugger()->DebugPrintf(" %04x:%04x\n", PRINT_REG(*it));
return true;
@ -2298,16 +2298,16 @@ bool Console::cmdGCShowFreeable(int argc, const char **argv) {
return true;
}
SegmentObj *mobj = _engine->_gamestate->_segMan->getSegmentObj(addr.segment);
SegmentObj *mobj = _engine->_gamestate->_segMan->getSegmentObj(addr.getSegment());
if (!mobj) {
DebugPrintf("Unknown segment : %x\n", addr.segment);
DebugPrintf("Unknown segment : %x\n", addr.getSegment());
return true;
}
DebugPrintf("Freeable in segment %04x:\n", addr.segment);
const Common::Array<reg_t> tmp = mobj->listAllDeallocatable(addr.segment);
DebugPrintf("Freeable in segment %04x:\n", addr.getSegment());
const Common::Array<reg_t> tmp = mobj->listAllDeallocatable(addr.getSegment());
for (Common::Array<reg_t>::const_iterator it = tmp.begin(); it != tmp.end(); ++it)
if (it->segment)
if (it->getSegment())
g_sci->getSciDebugger()->DebugPrintf(" %04x:%04x\n", PRINT_REG(*it));
return true;
@ -2331,9 +2331,9 @@ bool Console::cmdGCNormalize(int argc, const char **argv) {
return true;
}
SegmentObj *mobj = _engine->_gamestate->_segMan->getSegmentObj(addr.segment);
SegmentObj *mobj = _engine->_gamestate->_segMan->getSegmentObj(addr.getSegment());
if (!mobj) {
DebugPrintf("Unknown segment : %x\n", addr.segment);
DebugPrintf("Unknown segment : %x\n", addr.getSegment());
return true;
}
@ -2572,12 +2572,12 @@ bool Console::cmdViewReference(int argc, const char **argv) {
DebugPrintf("%04x:%04x is of type 0x%x: ", PRINT_REG(reg), type_mask);
if (reg.segment == 0 && reg.offset == 0) {
if (reg.getSegment() == 0 && reg.getOffset() == 0) {
DebugPrintf("Null.\n");
return true;
}
if (reg_end.segment != reg.segment && reg_end != NULL_REG) {
if (reg_end.getSegment() != reg.getSegment() && reg_end != NULL_REG) {
DebugPrintf("Ending segment different from starting segment. Assuming no bound on dump.\n");
reg_end = NULL_REG;
}
@ -2613,7 +2613,7 @@ bool Console::cmdViewReference(int argc, const char **argv) {
printObject(reg);
break;
case SIG_TYPE_REFERENCE: {
switch (_engine->_gamestate->_segMan->getSegmentType(reg.segment)) {
switch (_engine->_gamestate->_segMan->getSegmentType(reg.getSegment())) {
#ifdef ENABLE_SCI32
case SEG_TYPE_STRING: {
DebugPrintf("SCI32 string\n");
@ -2629,21 +2629,20 @@ bool Console::cmdViewReference(int argc, const char **argv) {
}
#endif
default: {
int size;
const SegmentRef block = _engine->_gamestate->_segMan->dereference(reg);
size = block.maxSize;
uint16 size = block.maxSize;
DebugPrintf("raw data\n");
if (reg_end.segment != 0 && size < reg_end.offset - reg.offset) {
if (reg_end.getSegment() != 0 && size < reg_end.getOffset() - reg.getOffset()) {
DebugPrintf("Block end out of bounds (size %d). Resetting.\n", size);
reg_end = NULL_REG;
}
if (reg_end.segment != 0 && (size >= reg_end.offset - reg.offset))
size = reg_end.offset - reg.offset;
if (reg_end.getSegment() != 0 && (size >= reg_end.getOffset() - reg.getOffset()))
size = reg_end.getOffset() - reg.getOffset();
if (reg_end.segment != 0)
if (reg_end.getSegment() != 0)
DebugPrintf("Block size less than or equal to %d\n", size);
if (block.isRaw)
@ -2655,7 +2654,7 @@ bool Console::cmdViewReference(int argc, const char **argv) {
break;
}
case SIG_TYPE_INTEGER:
DebugPrintf("arithmetic value\n %d (%04x)\n", (int16) reg.offset, reg.offset);
DebugPrintf("arithmetic value\n %d (%04x)\n", (int16) reg.getOffset(), reg.getOffset());
break;
default:
DebugPrintf("unknown type %d.\n", type);
@ -2725,7 +2724,7 @@ bool Console::cmdBacktrace(int argc, const char **argv) {
switch (call.type) {
case EXEC_STACK_TYPE_CALL: // Normal function
if (call.type == EXEC_STACK_TYPE_CALL)
DebugPrintf(" %x: script %d - ", i, (*(Script *)_engine->_gamestate->_segMan->_heap[call.addr.pc.segment]).getScriptNumber());
DebugPrintf(" %x: script %d - ", i, (*(Script *)_engine->_gamestate->_segMan->_heap[call.addr.pc.getSegment()]).getScriptNumber());
if (call.debugSelector != -1) {
DebugPrintf("%s::%s(", objname, _engine->getKernel()->getSelectorName(call.debugSelector).c_str());
} else if (call.debugExportId != -1) {
@ -2917,7 +2916,7 @@ bool Console::cmdDisassemble(int argc, const char **argv) {
addr = disassemble(_engine->_gamestate, addr, printBWTag, printBytecode);
if (addr.isNull() && prevAddr < farthestTarget)
addr = prevAddr + 1; // skip past the ret
} while (addr.offset > 0);
} while (addr.getOffset() > 0);
return true;
}
@ -2934,10 +2933,10 @@ bool Console::cmdDisassembleAddress(int argc, const char **argv) {
}
reg_t vpc = NULL_REG;
int opCount = 1;
uint opCount = 1;
bool printBWTag = false;
bool printBytes = false;
int size;
uint16 size;
if (parse_reg_t(_engine->_gamestate, argv[1], &vpc, false)) {
DebugPrintf("Invalid address passed.\n");
@ -2946,7 +2945,7 @@ bool Console::cmdDisassembleAddress(int argc, const char **argv) {
}
SegmentRef ref = _engine->_gamestate->_segMan->dereference(vpc);
size = ref.maxSize + vpc.offset; // total segment size
size = ref.maxSize + vpc.getOffset(); // total segment size
for (int i = 2; i < argc; i++) {
if (!scumm_stricmp(argv[i], "bwt"))
@ -2968,7 +2967,7 @@ bool Console::cmdDisassembleAddress(int argc, const char **argv) {
do {
vpc = disassemble(_engine->_gamestate, vpc, printBWTag, printBytes);
} while ((vpc.offset > 0) && (vpc.offset + 6 < size) && (--opCount));
} while ((vpc.getOffset() > 0) && (vpc.getOffset() + 6 < size) && (--opCount));
return true;
}
@ -3011,7 +3010,7 @@ void Console::printKernelCallsFound(int kernelFuncNum, bool showFoundScripts) {
// Now dissassemble each method of the script object
for (uint16 i = 0; i < obj->getMethodCount(); i++) {
reg_t fptr = obj->getFunction(i);
uint16 offset = fptr.offset;
uint16 offset = fptr.getOffset();
int16 opparams[4];
byte extOpcode;
byte opcode;
@ -3699,8 +3698,8 @@ static int parse_reg_t(EngineState *s, const char *str, reg_t *dest, bool mayBeV
return 1;
// Now lookup the script's segment
dest->segment = s->_segMan->getScriptSegment(script_nr);
if (!dest->segment) {
dest->setSegment(s->_segMan->getScriptSegment(script_nr));
if (!dest->getSegment()) {
return 1;
}
@ -3782,19 +3781,19 @@ static int parse_reg_t(EngineState *s, const char *str, reg_t *dest, bool mayBeV
offsetStr = colon + 1;
Common::String segmentStr(str, colon);
dest->segment = strtol(segmentStr.c_str(), &endptr, 16);
dest->setSegment(strtol(segmentStr.c_str(), &endptr, 16));
if (*endptr)
return 1;
} else {
int val = 0;
dest->segment = 0;
dest->setSegment(0);
if (charsCountNumber == charsCount) {
// Only numbers in input, assume decimal value
val = strtol(str, &endptr, 10);
if (*endptr)
return 1; // strtol failed?
dest->offset = val;
dest->setOffset(val);
return 0;
} else {
// We also got letters, check if there were only hexadecimal letters and '0x' at the start or 'h' at the end
@ -3802,7 +3801,7 @@ static int parse_reg_t(EngineState *s, const char *str, reg_t *dest, bool mayBeV
val = strtol(str, &endptr, 16);
if ((*endptr != 'h') && (*endptr != 0))
return 1;
dest->offset = val;
dest->setOffset(val);
return 0;
} else {
// Something else was in input, assume object name
@ -3851,9 +3850,9 @@ static int parse_reg_t(EngineState *s, const char *str, reg_t *dest, bool mayBeV
int val = strtol(offsetStr, &endptr, 16);
if (relativeOffset)
dest->offset += val;
dest->incOffset(val);
else
dest->offset = val;
dest->setOffset(val);
if (*endptr)
return 1;
@ -3933,15 +3932,15 @@ void Console::printList(List *list) {
while (!pos.isNull()) {
Node *node;
NodeTable *nt = (NodeTable *)_engine->_gamestate->_segMan->getSegment(pos.segment, SEG_TYPE_NODES);
NodeTable *nt = (NodeTable *)_engine->_gamestate->_segMan->getSegment(pos.getSegment(), SEG_TYPE_NODES);
if (!nt || !nt->isValidEntry(pos.offset)) {
if (!nt || !nt->isValidEntry(pos.getOffset())) {
DebugPrintf(" WARNING: %04x:%04x: Doesn't contain list node!\n",
PRINT_REG(pos));
return;
}
node = &(nt->_table[pos.offset]);
node = &(nt->_table[pos.getOffset()]);
DebugPrintf("\t%04x:%04x : %04x:%04x -> %04x:%04x\n", PRINT_REG(pos), PRINT_REG(node->key), PRINT_REG(node->value));
@ -3960,37 +3959,37 @@ void Console::printList(List *list) {
}
int Console::printNode(reg_t addr) {
SegmentObj *mobj = _engine->_gamestate->_segMan->getSegment(addr.segment, SEG_TYPE_LISTS);
SegmentObj *mobj = _engine->_gamestate->_segMan->getSegment(addr.getSegment(), SEG_TYPE_LISTS);
if (mobj) {
ListTable *lt = (ListTable *)mobj;
List *list;
if (!lt->isValidEntry(addr.offset)) {
if (!lt->isValidEntry(addr.getOffset())) {
DebugPrintf("Address does not contain a list\n");
return 1;
}
list = &(lt->_table[addr.offset]);
list = &(lt->_table[addr.getOffset()]);
DebugPrintf("%04x:%04x : first x last = (%04x:%04x, %04x:%04x)\n", PRINT_REG(addr), PRINT_REG(list->first), PRINT_REG(list->last));
} else {
NodeTable *nt;
Node *node;
mobj = _engine->_gamestate->_segMan->getSegment(addr.segment, SEG_TYPE_NODES);
mobj = _engine->_gamestate->_segMan->getSegment(addr.getSegment(), SEG_TYPE_NODES);
if (!mobj) {
DebugPrintf("Segment #%04x is not a list or node segment\n", addr.segment);
DebugPrintf("Segment #%04x is not a list or node segment\n", addr.getSegment());
return 1;
}
nt = (NodeTable *)mobj;
if (!nt->isValidEntry(addr.offset)) {
if (!nt->isValidEntry(addr.getOffset())) {
DebugPrintf("Address does not contain a node\n");
return 1;
}
node = &(nt->_table[addr.offset]);
node = &(nt->_table[addr.getOffset()]);
DebugPrintf("%04x:%04x : prev x next = (%04x:%04x, %04x:%04x); maps %04x:%04x -> %04x:%04x\n",
PRINT_REG(addr), PRINT_REG(node->pred), PRINT_REG(node->succ), PRINT_REG(node->key), PRINT_REG(node->value));
@ -4028,8 +4027,8 @@ int Console::printObject(reg_t pos) {
reg_t val = obj->getVariable(i);
DebugPrintf("%04x:%04x", PRINT_REG(val));
if (!val.segment)
DebugPrintf(" (%d)", val.offset);
if (!val.getSegment())
DebugPrintf(" (%d)", val.getOffset());
const Object *ref = s->_segMan->getObject(val);
if (ref)
@ -4042,8 +4041,8 @@ int Console::printObject(reg_t pos) {
reg_t fptr = obj->getFunction(i);
DebugPrintf(" [%03x] %s = %04x:%04x\n", obj->getFuncSelector(i), _engine->getKernel()->getSelectorName(obj->getFuncSelector(i)).c_str(), PRINT_REG(fptr));
}
if (s->_segMan->_heap[pos.segment]->getType() == SEG_TYPE_SCRIPT)
DebugPrintf("\nOwner script: %d\n", s->_segMan->getScript(pos.segment)->getScriptNumber());
if (s->_segMan->_heap[pos.getSegment()]->getType() == SEG_TYPE_SCRIPT)
DebugPrintf("\nOwner script: %d\n", s->_segMan->getScript(pos.getSegment())->getScriptNumber());
return 0;
}

36
engines/sci/engine/features.cpp
View file

@ -74,11 +74,11 @@ bool GameFeatures::autoDetectSoundType() {
// Look up the script address
reg_t addr = getDetectionAddr("Sound", SELECTOR(play));
if (!addr.segment)
if (!addr.getSegment())
return false;
uint16 offset = addr.offset;
Script *script = _segMan->getScript(addr.segment);
uint16 offset = addr.getOffset();
Script *script = _segMan->getScript(addr.getSegment());
uint16 intParam = 0xFFFF;
bool foundTarget = false;
@ -221,11 +221,11 @@ bool GameFeatures::autoDetectLofsType(Common::String gameSuperClassName, int met
// Look up the script address
reg_t addr = getDetectionAddr(gameSuperClassName.c_str(), -1, methodNum);
if (!addr.segment)
if (!addr.getSegment())
return false;
uint16 offset = addr.offset;
Script *script = _segMan->getScript(addr.segment);
uint16 offset = addr.getOffset();
Script *script = _segMan->getScript(addr.getSegment());
while (true) {
int16 opparams[4];
@ -320,11 +320,11 @@ bool GameFeatures::autoDetectGfxFunctionsType(int methodNum) {
// Look up the script address
reg_t addr = getDetectionAddr("Rm", SELECTOR(overlay), methodNum);
if (!addr.segment)
if (!addr.getSegment())
return false;
uint16 offset = addr.offset;
Script *script = _segMan->getScript(addr.segment);
uint16 offset = addr.getOffset();
Script *script = _segMan->getScript(addr.getSegment());
while (true) {
int16 opparams[4];
@ -474,11 +474,11 @@ bool GameFeatures::autoDetectSci21KernelType() {
// Look up the script address
reg_t addr = getDetectionAddr("Sound", SELECTOR(play));
if (!addr.segment)
if (!addr.getSegment())
return false;
uint16 offset = addr.offset;
Script *script = _segMan->getScript(addr.segment);
uint16 offset = addr.getOffset();
Script *script = _segMan->getScript(addr.getSegment());
while (true) {
int16 opparams[4];
@ -550,11 +550,11 @@ bool GameFeatures::autoDetectSci21StringFunctionType() {
// Look up the script address
reg_t addr = getDetectionAddr("Str", SELECTOR(size));
if (!addr.segment)
if (!addr.getSegment())
return false;
uint16 offset = addr.offset;
Script *script = _segMan->getScript(addr.segment);
uint16 offset = addr.getOffset();
Script *script = _segMan->getScript(addr.getSegment());
while (true) {
int16 opparams[4];
@ -587,11 +587,11 @@ bool GameFeatures::autoDetectMoveCountType() {
// Look up the script address
reg_t addr = getDetectionAddr("Motion", SELECTOR(doit));
if (!addr.segment)
if (!addr.getSegment())
return false;
uint16 offset = addr.offset;
Script *script = _segMan->getScript(addr.segment);
uint16 offset = addr.getOffset();
Script *script = _segMan->getScript(addr.getSegment());
bool foundTarget = false;
while (true) {

2
engines/sci/engine/file.cpp
View file

@ -269,7 +269,7 @@ Common::String DirSeeker::getVirtualFilename(uint fileNumber) {
reg_t DirSeeker::firstFile(const Common::String &mask, reg_t buffer, SegManager *segMan) {
// Verify that we are given a valid buffer
if (!buffer.segment) {
if (!buffer.getSegment()) {
error("DirSeeker::firstFile('%s') invoked with invalid buffer", mask.c_str());
return NULL_REG;
}

10
engines/sci/engine/gc.cpp
View file

@ -47,7 +47,7 @@ const char *segmentTypeNames[] = {
#endif
void WorklistManager::push(reg_t reg) {
if (!reg.segment) // No numbers
if (!reg.getSegment()) // No numbers
return;
debugC(kDebugLevelGC, "[GC] Adding %04x:%04x", PRINT_REG(reg));
@ -69,7 +69,7 @@ static AddrSet *normalizeAddresses(SegManager *segMan, const AddrSet &nonnormal_
for (AddrSet::const_iterator i = nonnormal_map.begin(); i != nonnormal_map.end(); ++i) {
reg_t reg = i->_key;
SegmentObj *mobj = segMan->getSegmentObj(reg.segment);
SegmentObj *mobj = segMan->getSegmentObj(reg.getSegment());
if (mobj) {
reg = mobj->findCanonicAddress(segMan, reg);
@ -85,11 +85,11 @@ static void processWorkList(SegManager *segMan, WorklistManager &wm, const Commo
while (!wm._worklist.empty()) {
reg_t reg = wm._worklist.back();
wm._worklist.pop_back();
if (reg.segment != stackSegment) { // No need to repeat this one
if (reg.getSegment() != stackSegment) { // No need to repeat this one
debugC(kDebugLevelGC, "[GC] Checking %04x:%04x", PRINT_REG(reg));
if (reg.segment < heap.size() && heap[reg.segment]) {
if (reg.getSegment() < heap.size() && heap[reg.getSegment()]) {
// Valid heap object? Find its outgoing references!
wm.pushArray(heap[reg.segment]->listAllOutgoingReferences(reg));
wm.pushArray(heap[reg.getSegment()]->listAllOutgoingReferences(reg));
}
}
}

2
engines/sci/engine/gc.h
View file

@ -32,7 +32,7 @@ namespace Sci {
struct reg_t_Hash {
uint operator()(const reg_t& x) const {
return (x.segment << 3) ^ x.offset ^ (x.offset << 16);
return (x.getSegment() << 3) ^ x.getOffset() ^ (x.getOffset() << 16);
}
};

28
engines/sci/engine/kernel.cpp
View file

@ -357,27 +357,27 @@ static uint16 *parseKernelSignature(const char *kernelName, const char *writtenS
uint16 Kernel::findRegType(reg_t reg) {
// No segment? Must be integer
if (!reg.segment)
return SIG_TYPE_INTEGER | (reg.offset ? 0 : SIG_TYPE_NULL);
if (!reg.getSegment())
return SIG_TYPE_INTEGER | (reg.getOffset() ? 0 : SIG_TYPE_NULL);
if (reg.segment == 0xFFFF)
if (reg.getSegment() == 0xFFFF)
return SIG_TYPE_UNINITIALIZED;
// Otherwise it's an object
SegmentObj *mobj = _segMan->getSegmentObj(reg.segment);
SegmentObj *mobj = _segMan->getSegmentObj(reg.getSegment());
if (!mobj)
return SIG_TYPE_ERROR;
uint16 result = 0;
if (!mobj->isValidOffset(reg.offset))
if (!mobj->isValidOffset(reg.getOffset()))
result |= SIG_IS_INVALID;
switch (mobj->getType()) {
case SEG_TYPE_SCRIPT:
if (reg.offset <= (*(Script *)mobj).getBufSize() &&
reg.offset >= -SCRIPT_OBJECT_MAGIC_OFFSET &&
(*(Script *)mobj).offsetIsObject(reg.offset)) {
result |= ((Script *)mobj)->getObject(reg.offset) ? SIG_TYPE_OBJECT : SIG_TYPE_REFERENCE;
if (reg.getOffset() <= (*(Script *)mobj).getBufSize() &&
reg.getOffset() >= (uint)-SCRIPT_OBJECT_MAGIC_OFFSET &&
(*(Script *)mobj).offsetIsObject(reg.getOffset())) {
result |= ((Script *)mobj)->getObject(reg.getOffset()) ? SIG_TYPE_OBJECT : SIG_TYPE_REFERENCE;
} else
result |= SIG_TYPE_REFERENCE;
break;
@ -608,7 +608,7 @@ void Kernel::mapFunctions() {
_kernelFuncs[id].workarounds = kernelMap->workarounds;
if (kernelMap->subFunctions) {
// Get version for subfunction identification
SciVersion mySubVersion = (SciVersion)kernelMap->function(NULL, 0, NULL).offset;
SciVersion mySubVersion = (SciVersion)kernelMap->function(NULL, 0, NULL).getOffset();
// Now check whats the highest subfunction-id for this version
const SciKernelMapSubEntry *kernelSubMap = kernelMap->subFunctions;
uint16 subFunctionCount = 0;
@ -885,15 +885,15 @@ Common::String Kernel::lookupText(reg_t address, int index) {
char *seeker;
Resource *textres;
if (address.segment)
if (address.getSegment())
return _segMan->getString(address);
int textlen;
int _index = index;
textres = _resMan->findResource(ResourceId(kResourceTypeText, address.offset), 0);
textres = _resMan->findResource(ResourceId(kResourceTypeText, address.getOffset()), 0);
if (!textres) {
error("text.%03d not found", address.offset);
error("text.%03d not found", address.getOffset());
return NULL; /* Will probably segfault */
}
@ -907,7 +907,7 @@ Common::String Kernel::lookupText(reg_t address, int index) {
if (textlen)
return seeker;
error("Index %d out of bounds in text.%03d", _index, address.offset);
error("Index %d out of bounds in text.%03d", _index, address.getOffset());
return NULL;
}

6
engines/sci/engine/kevent.cpp
View file

@ -157,7 +157,7 @@ reg_t kGetEvent(EngineState *s, int argc, reg_t *argv) {
s->r_acc = NULL_REG;
}
if ((s->r_acc.offset) && (g_sci->_debugState.stopOnEvent)) {
if ((s->r_acc.getOffset()) && (g_sci->_debugState.stopOnEvent)) {
g_sci->_debugState.stopOnEvent = false;
// A SCI event occurred, and we have been asked to stop, so open the debug console
@ -248,7 +248,7 @@ reg_t kGlobalToLocal(EngineState *s, int argc, reg_t *argv) {
reg_t planeObject = argc > 1 ? argv[1] : NULL_REG; // SCI32
SegManager *segMan = s->_segMan;
if (obj.segment) {
if (obj.getSegment()) {
int16 x = readSelectorValue(segMan, obj, SELECTOR(x));
int16 y = readSelectorValue(segMan, obj, SELECTOR(y));
@ -267,7 +267,7 @@ reg_t kLocalToGlobal(EngineState *s, int argc, reg_t *argv) {
reg_t planeObject = argc > 1 ? argv[1] : NULL_REG; // SCI32
SegManager *segMan = s->_segMan;
if (obj.segment) {
if (obj.getSegment()) {
int16 x = readSelectorValue(segMan, obj, SELECTOR(x));
int16 y = readSelectorValue(segMan, obj, SELECTOR(y));

4
engines/sci/engine/kfile.cpp
View file

@ -185,7 +185,7 @@ reg_t kCheckFreeSpace(EngineState *s, int argc, reg_t *argv) {
reg_t kValidPath(EngineState *s, int argc, reg_t *argv) {
Common::String path = s->_segMan->getString(argv[0]);
debug(3, "kValidPath(%s) -> %d", path.c_str(), s->r_acc.offset);
debug(3, "kValidPath(%s) -> %d", path.c_str(), s->r_acc.getOffset());
// Always return true
return make_reg(0, 1);
@ -866,7 +866,7 @@ reg_t kRestoreGame(EngineState *s, int argc, reg_t *argv) {
// saving a previously restored game.
// We set the current savedgame-id directly and remove the script
// code concerning this via script patch.
s->variables[VAR_GLOBAL][0xB3].offset = SAVEGAMEID_OFFICIALRANGE_START + savegameId;
s->variables[VAR_GLOBAL][0xB3].setOffset(SAVEGAMEID_OFFICIALRANGE_START + savegameId);
}
} else {
s->r_acc = TRUE_REG;

16
engines/sci/engine/kgraphics.cpp
View file

@ -337,7 +337,7 @@ reg_t kTextSize(EngineState *s, int argc, reg_t *argv) {
Common::String sep_str;
const char *sep = NULL;
if ((argc > 4) && (argv[4].segment)) {
if ((argc > 4) && (argv[4].getSegment())) {
sep_str = s->_segMan->getString(argv[4]);
sep = sep_str.c_str();
}
@ -789,7 +789,7 @@ void _k_GenericDrawControl(EngineState *s, reg_t controlObject, bool hilite) {
Common::Rect rect;
TextAlignment alignment;
int16 mode, maxChars, cursorPos, upperPos, listCount, i;
int16 upperOffset, cursorOffset;
uint16 upperOffset, cursorOffset;
GuiResourceId viewId;
int16 loopNo;
int16 celNo;
@ -871,7 +871,7 @@ void _k_GenericDrawControl(EngineState *s, reg_t controlObject, bool hilite) {
listCount = 0; listSeeker = textReference;
while (s->_segMan->strlen(listSeeker) > 0) {
listCount++;
listSeeker.offset += maxChars;
listSeeker.incOffset(maxChars);
}
// TODO: This is rather convoluted... It would be a lot cleaner
@ -885,11 +885,11 @@ void _k_GenericDrawControl(EngineState *s, reg_t controlObject, bool hilite) {
for (i = 0; i < listCount; i++) {
listStrings[i] = s->_segMan->getString(listSeeker);
listEntries[i] = listStrings[i].c_str();
if (listSeeker.offset == upperOffset)
if (listSeeker.getOffset() == upperOffset)
upperPos = i;
if (listSeeker.offset == cursorOffset)
if (listSeeker.getOffset() == cursorOffset)
cursorPos = i;
listSeeker.offset += maxChars;
listSeeker.incOffset(maxChars);
}
}
@ -1104,7 +1104,7 @@ reg_t kNewWindow(EngineState *s, int argc, reg_t *argv) {
rect2 = Common::Rect (argv[5].toSint16(), argv[4].toSint16(), argv[7].toSint16(), argv[6].toSint16());
Common::String title;
if (argv[4 + argextra].segment) {
if (argv[4 + argextra].getSegment()) {
title = s->_segMan->getString(argv[4 + argextra]);
title = g_sci->strSplit(title.c_str(), NULL);
}
@ -1143,7 +1143,7 @@ reg_t kDisplay(EngineState *s, int argc, reg_t *argv) {
Common::String text;
if (textp.segment) {
if (textp.getSegment()) {
argc--; argv++;
text = s->_segMan->getString(textp);
} else {

2
engines/sci/engine/kgraphics32.cpp
View file

@ -140,7 +140,7 @@ reg_t kIsOnMe(EngineState *s, int argc, reg_t *argv) {
uint16 x = argv[0].toUint16();
uint16 y = argv[1].toUint16();
reg_t targetObject = argv[2];
uint16 illegalBits = argv[3].offset;
uint16 illegalBits = argv[3].getOffset();
Common::Rect nsRect = g_sci->_gfxCompare->getNSRect(targetObject, true);
// we assume that x, y are local coordinates

18
engines/sci/engine/klists.cpp
View file

@ -409,10 +409,14 @@ int sort_temp_cmp(const void *p1, const void *p2) {
const sort_temp_t *st1 = (const sort_temp_t *)p1;
const sort_temp_t *st2 = (const sort_temp_t *)p2;
if (st1->order.segment < st2->order.segment || (st1->order.segment == st2->order.segment && st1->order.offset < st2->order.offset))
if (st1->order.getSegment() < st2->order.getSegment() ||
(st1->order.getSegment() == st2->order.getSegment() &&
st1->order.getOffset() < st2->order.getOffset()))
return -1;
if (st1->order.segment > st2->order.segment || (st1->order.segment == st2->order.segment && st1->order.offset > st2->order.offset))
if (st1->order.getSegment() > st2->order.getSegment() ||
(st1->order.getSegment() == st2->order.getSegment() &&
st1->order.getOffset() > st2->order.getOffset()))
return 1;
return 0;
@ -665,15 +669,15 @@ reg_t kArray(EngineState *s, int argc, reg_t *argv) {
if (argv[2].toUint16() == 3)
return kString(s, argc, argv);
} else {
if (s->_segMan->getSegmentType(argv[1].segment) == SEG_TYPE_STRING ||
s->_segMan->getSegmentType(argv[1].segment) == SEG_TYPE_SCRIPT) {
if (s->_segMan->getSegmentType(argv[1].getSegment()) == SEG_TYPE_STRING ||
s->_segMan->getSegmentType(argv[1].getSegment()) == SEG_TYPE_SCRIPT) {
return kString(s, argc, argv);
}
#if 0
if (op == 6) {
if (s->_segMan->getSegmentType(argv[3].segment) == SEG_TYPE_STRING ||
s->_segMan->getSegmentType(argv[3].segment) == SEG_TYPE_SCRIPT) {
if (s->_segMan->getSegmentType(argv[3].getSegment()) == SEG_TYPE_STRING ||
s->_segMan->getSegmentType(argv[3].getSegment()) == SEG_TYPE_SCRIPT) {
return kString(s, argc, argv);
}
}
@ -792,7 +796,7 @@ reg_t kArray(EngineState *s, int argc, reg_t *argv) {
#endif
return NULL_REG;
}
if (s->_segMan->getSegmentObj(argv[1].segment)->getType() != SEG_TYPE_ARRAY)
if (s->_segMan->getSegmentObj(argv[1].getSegment())->getType() != SEG_TYPE_ARRAY)
error("kArray(Dup): Request to duplicate a segment which isn't an array");
reg_t arrayHandle;

10
engines/sci/engine/kmisc.cpp
View file

@ -128,7 +128,7 @@ reg_t kMemoryInfo(EngineState *s, int argc, reg_t *argv) {
// fragmented
const uint16 size = 0x7fea;
switch (argv[0].offset) {
switch (argv[0].getOffset()) {
case K_MEMORYINFO_LARGEST_HEAP_BLOCK:
// In order to prevent "Memory fragmented" dialogs from
// popping up in some games, we must return FREE_HEAP - 2 here.
@ -140,7 +140,7 @@ reg_t kMemoryInfo(EngineState *s, int argc, reg_t *argv) {
return make_reg(0, size);
default:
error("Unknown MemoryInfo operation: %04x", argv[0].offset);
error("Unknown MemoryInfo operation: %04x", argv[0].getOffset());
}
return NULL_REG;
@ -304,7 +304,7 @@ reg_t kMemory(EngineState *s, int argc, reg_t *argv) {
break;
}
case K_MEMORY_PEEK : {
if (!argv[1].segment) {
if (!argv[1].getSegment()) {
// This occurs in KQ5CD when interacting with certain objects
warning("Attempt to peek invalid memory at %04x:%04x", PRINT_REG(argv[1]));
return s->r_acc;
@ -334,11 +334,11 @@ reg_t kMemory(EngineState *s, int argc, reg_t *argv) {
}
if (ref.isRaw) {
if (argv[2].segment) {
if (argv[2].getSegment()) {
error("Attempt to poke memory reference %04x:%04x to %04x:%04x", PRINT_REG(argv[2]), PRINT_REG(argv[1]));
return s->r_acc;
}
WRITE_SCIENDIAN_UINT16(ref.raw, argv[2].offset); // Amiga versions are BE
WRITE_SCIENDIAN_UINT16(ref.raw, argv[2].getOffset()); // Amiga versions are BE
} else {
if (ref.skipByte)
error("Attempt to poke memory at odd offset %04X:%04X", PRINT_REG(argv[1]));

2
engines/sci/engine/kparse.cpp
View file

@ -48,7 +48,7 @@ reg_t kSaid(EngineState *s, int argc, reg_t *argv) {
const int debug_parser = 0;
#endif
if (!heap_said_block.segment)
if (!heap_said_block.getSegment())
return NULL_REG;
said_block = (byte *)s->_segMan->derefBulkPtr(heap_said_block, 0);

8
engines/sci/engine/kpathing.cpp
View file

@ -367,7 +367,7 @@ static void draw_input(EngineState *s, reg_t poly_list, Common::Point start, Com
draw_point(s, start, 1, width, height);
draw_point(s, end, 0, width, height);
if (!poly_list.segment)
if (!poly_list.getSegment())
return;
list = s->_segMan->lookupList(poly_list);
@ -423,7 +423,7 @@ static void print_input(EngineState *s, reg_t poly_list, Common::Point start, Co
debug("End point: (%i, %i)", end.x, end.y);
debug("Optimization level: %i", opt);
if (!poly_list.segment)
if (!poly_list.getSegment())
return;
list = s->_segMan->lookupList(poly_list);
@ -1180,7 +1180,7 @@ static PathfindingState *convert_polygon_set(EngineState *s, reg_t poly_list, Co
PathfindingState *pf_s = new PathfindingState(width, height);
// Convert all polygons
if (poly_list.segment) {
if (poly_list.getSegment()) {
List *list = s->_segMan->lookupList(poly_list);
Node *node = s->_segMan->lookupNode(list->first);
@ -1503,7 +1503,7 @@ reg_t kAvoidPath(EngineState *s, int argc, reg_t *argv) {
draw_point(s, start, 1, width, height);
draw_point(s, end, 0, width, height);
if (poly_list.segment) {
if (poly_list.getSegment()) {
print_input(s, poly_list, start, end, opt);
draw_input(s, poly_list, start, end, opt, width, height);
}

16
engines/sci/engine/kscripts.cpp
View file

@ -140,7 +140,7 @@ reg_t kClone(EngineState *s, int argc, reg_t *argv) {
debugC(kDebugLevelMemory, "Attempting to clone from %04x:%04x", PRINT_REG(parentAddr));
uint16 infoSelector = parentObj->getInfoSelector().offset;
uint16 infoSelector = parentObj->getInfoSelector().getOffset();
cloneObj = s->_segMan->allocateClone(&cloneAddr);
if (!cloneObj) {
@ -169,8 +169,8 @@ reg_t kClone(EngineState *s, int argc, reg_t *argv) {
cloneObj->setSpeciesSelector(cloneObj->getPos());
if (parentObj->isClass())
cloneObj->setSuperClassSelector(parentObj->getPos());
s->_segMan->getScript(parentObj->getPos().segment)->incrementLockers();
s->_segMan->getScript(cloneObj->getPos().segment)->incrementLockers();
s->_segMan->getScript(parentObj->getPos().getSegment())->incrementLockers();
s->_segMan->getScript(cloneObj->getPos().getSegment())->incrementLockers();
return cloneAddr;
}
@ -191,7 +191,7 @@ reg_t kDisposeClone(EngineState *s, int argc, reg_t *argv) {
// At least kq4early relies on this behavior. The scripts clone "Sound", then set bit 1 manually
// and call kDisposeClone later. In that case we may not free it, otherwise we will run into issues
// later, because kIsObject would then return false and Sound object wouldn't get checked.
uint16 infoSelector = object->getInfoSelector().offset;
uint16 infoSelector = object->getInfoSelector().getOffset();
if ((infoSelector & 3) == kInfoFlagClone)
object->markAsFreed();
@ -203,7 +203,7 @@ reg_t kScriptID(EngineState *s, int argc, reg_t *argv) {
int script = argv[0].toUint16();
uint16 index = (argc > 1) ? argv[1].toUint16() : 0;
if (argv[0].segment)
if (argv[0].getSegment())
return argv[0];
SegmentId scriptSeg = s->_segMan->getScriptSegment(script, SCRIPT_GET_LOAD);
@ -251,12 +251,12 @@ reg_t kScriptID(EngineState *s, int argc, reg_t *argv) {
}
reg_t kDisposeScript(EngineState *s, int argc, reg_t *argv) {
int script = argv[0].offset;
int script = argv[0].getOffset();
SegmentId id = s->_segMan->getScriptSegment(script);
Script *scr = s->_segMan->getScriptIfLoaded(id);
if (scr && !scr->isMarkedAsDeleted()) {
if (s->_executionStack.back().addr.pc.segment != id)
if (s->_executionStack.back().addr.pc.getSegment() != id)
scr->setLockers(1);
}
@ -273,7 +273,7 @@ reg_t kDisposeScript(EngineState *s, int argc, reg_t *argv) {
}
reg_t kIsObject(EngineState *s, int argc, reg_t *argv) {
if (argv[0].offset == SIGNAL_OFFSET) // Treated specially
if (argv[0].getOffset() == SIGNAL_OFFSET) // Treated specially
return NULL_REG;
else
return make_reg(0, s->_segMan->isHeapObject(argv[0]));

32
engines/sci/engine/kstring.cpp
View file

@ -33,7 +33,7 @@ namespace Sci {
reg_t kStrEnd(EngineState *s, int argc, reg_t *argv) {
reg_t address = argv[0];
address.offset += s->_segMan->strlen(address);
address.incOffset(s->_segMan->strlen(address));
return address;
}
@ -123,18 +123,22 @@ reg_t kStrAt(EngineState *s, int argc, reg_t *argv) {
oddOffset = !oddOffset;
if (!oddOffset) {
value = tmp.offset & 0x00ff;
value = tmp.getOffset() & 0x00ff;
if (argc > 2) { /* Request to modify this char */
tmp.offset &= 0xff00;
tmp.offset |= newvalue;
tmp.segment = 0;
uint16 offset = tmp.toUint16();
offset &= 0xff00;
offset |= newvalue;
tmp.setOffset(offset);
tmp.setSegment(0);
}
} else {
value = tmp.offset >> 8;
value = tmp.getOffset() >> 8;
if (argc > 2) { /* Request to modify this char */
tmp.offset &= 0x00ff;
tmp.offset |= newvalue << 8;
tmp.segment = 0;
uint16 offset = tmp.toUint16();
offset &= 0x00ff;
offset |= newvalue << 8;
tmp.setOffset(offset);
tmp.setSegment(0);
}
}
}
@ -204,7 +208,7 @@ reg_t kFormat(EngineState *s, int argc, reg_t *argv) {
int strLength = 0; /* Used for stuff like "%13s" */
bool unsignedVar = false;
if (position.segment)
if (position.getSegment())
startarg = 2;
else {
// WORKAROUND: QFG1 VGA Mac calls this without the first parameter (dest). It then
@ -291,7 +295,7 @@ reg_t kFormat(EngineState *s, int argc, reg_t *argv) {
if (extralen < 0)
extralen = 0;
if (reg.segment) /* Heap address? */
if (reg.getSegment()) /* Heap address? */
paramindex++;
else
paramindex += 2; /* No, text resource address */
@ -654,7 +658,7 @@ reg_t kString(EngineState *s, int argc, reg_t *argv) {
return make_reg(0, s->_segMan->getString(argv[1]).size());
case 2: { // At (return value at an index)
// Note that values are put in bytes to avoid sign extension
if (argv[1].segment == s->_segMan->getStringSegmentId()) {
if (argv[1].getSegment() == s->_segMan->getStringSegmentId()) {
SciString *string = s->_segMan->lookupString(argv[1]);
byte val = string->getRawData()[argv[2].toUint16()];
return make_reg(0, val);
@ -705,7 +709,7 @@ reg_t kString(EngineState *s, int argc, reg_t *argv) {
uint32 string2Size = 0;
Common::String string;
if (argv[3].segment == s->_segMan->getStringSegmentId()) {
if (argv[3].getSegment() == s->_segMan->getStringSegmentId()) {
SciString *sstr;
sstr = s->_segMan->lookupString(argv[3]);
string2 = sstr->getRawData();
@ -755,7 +759,7 @@ reg_t kString(EngineState *s, int argc, reg_t *argv) {
SciString *dupString = s->_segMan->allocateString(&stringHandle);
if (argv[1].segment == s->_segMan->getStringSegmentId()) {
if (argv[1].getSegment() == s->_segMan->getStringSegmentId()) {
*dupString = *s->_segMan->lookupString(argv[1]);
} else {
dupString->fromString(s->_segMan->getString(argv[1]));

12
engines/sci/engine/kvideo.cpp
View file

@ -135,7 +135,7 @@ reg_t kShowMovie(EngineState *s, int argc, reg_t *argv) {
Video::VideoDecoder *videoDecoder = 0;
if (argv[0].segment != 0) {
if (argv[0].getSegment() != 0) {
Common::String filename = s->_segMan->getString(argv[0]);
if (g_sci->getPlatform() == Common::kPlatformMacintosh) {
@ -303,7 +303,7 @@ reg_t kPlayVMD(EngineState *s, int argc, reg_t *argv) {
// with subfx 21. The subtleness has to do with creation of temporary
// planes and positioning relative to such planes.
uint16 flags = argv[3].offset;
uint16 flags = argv[3].getOffset();
Common::String flagspec;
if (argc > 3) {
@ -331,12 +331,12 @@ reg_t kPlayVMD(EngineState *s, int argc, reg_t *argv) {
s->_videoState.flags = flags;
}
warning("x, y: %d, %d", argv[1].offset, argv[2].offset);
s->_videoState.x = argv[1].offset;
s->_videoState.y = argv[2].offset;
warning("x, y: %d, %d", argv[1].getOffset(), argv[2].getOffset());
s->_videoState.x = argv[1].getOffset();
s->_videoState.y = argv[2].getOffset();
if (argc > 4 && flags & 16)
warning("gammaBoost: %d%% between palette entries %d and %d", argv[4].offset, argv[5].offset, argv[6].offset);
warning("gammaBoost: %d%% between palette entries %d and %d", argv[4].getOffset(), argv[5].getOffset(), argv[6].getOffset());
break;
}
case 6: // Play

24
engines/sci/engine/object.cpp
View file

@ -44,15 +44,15 @@ static bool relocateBlock(Common::Array<reg_t> &block, int block_location, Segme
error("Attempt to relocate odd variable #%d.5e (relative to %04x)\n", idx, block_location);
return false;
}
block[idx].segment = segment; // Perform relocation
block[idx].setSegment(segment); // Perform relocation
if (getSciVersion() >= SCI_VERSION_1_1 && getSciVersion() <= SCI_VERSION_2_1)
block[idx].offset += scriptSize;
block[idx].incOffset(scriptSize);
return true;
}
void Object::init(byte *buf, reg_t obj_pos, bool initVariables) {
byte *data = buf + obj_pos.offset;
byte *data = buf + obj_pos.getOffset();
_baseObj = data;
_pos = obj_pos;
@ -109,7 +109,7 @@ int Object::locateVarSelector(SegManager *segMan, Selector slc) const {
}
bool Object::relocateSci0Sci21(SegmentId segment, int location, size_t scriptSize) {
return relocateBlock(_variables, getPos().offset, segment, location, scriptSize);
return relocateBlock(_variables, getPos().getOffset(), segment, location, scriptSize);
}
bool Object::relocateSci3(SegmentId segment, uint32 location, int offset, size_t scriptSize) {
@ -117,8 +117,8 @@ bool Object::relocateSci3(SegmentId segment, uint32 location, int offset, size_t
for (uint i = 0; i < _variables.size(); ++i) {
if (location == _propertyOffsetsSci3[i]) {
_variables[i].segment = segment;
_variables[i].offset += offset;
_variables[i].setSegment(segment);
_variables[i].incOffset(offset);
return true;
}
}
@ -148,21 +148,21 @@ int Object::propertyOffsetToId(SegManager *segMan, int propertyOffset) const {
}
void Object::initSpecies(SegManager *segMan, reg_t addr) {
uint16 speciesOffset = getSpeciesSelector().offset;
uint16 speciesOffset = getSpeciesSelector().getOffset();
if (speciesOffset == 0xffff) // -1
setSpeciesSelector(NULL_REG); // no species
else
setSpeciesSelector(segMan->getClassAddress(speciesOffset, SCRIPT_GET_LOCK, addr.segment));
setSpeciesSelector(segMan->getClassAddress(speciesOffset, SCRIPT_GET_LOCK, addr.getSegment()));
}
void Object::initSuperClass(SegManager *segMan, reg_t addr) {
uint16 superClassOffset = getSuperClassSelector().offset;
uint16 superClassOffset = getSuperClassSelector().getOffset();
if (superClassOffset == 0xffff) // -1
setSuperClassSelector(NULL_REG); // no superclass
else
setSuperClassSelector(segMan->getClassAddress(superClassOffset, SCRIPT_GET_LOCK, addr.segment));
setSuperClassSelector(segMan->getClassAddress(superClassOffset, SCRIPT_GET_LOCK, addr.getSegment()));
}
bool Object::initBaseObject(SegManager *segMan, reg_t addr, bool doInitSuperClass) {
@ -187,7 +187,7 @@ bool Object::initBaseObject(SegManager *segMan, reg_t addr, bool doInitSuperClas
// The effect is that a number of its method selectors may be
// treated as variable selectors, causing unpredictable effects.
int objScript = segMan->getScript(_pos.segment)->getScriptNumber();
int objScript = segMan->getScript(_pos.getSegment())->getScriptNumber();
// We have to do a little bit of work to get the name of the object
// before any relocations are done.
@ -196,7 +196,7 @@ bool Object::initBaseObject(SegManager *segMan, reg_t addr, bool doInitSuperClas
if (nameReg.isNull()) {
name = "<no name>";
} else {
nameReg.segment = _pos.segment;
nameReg.setSegment(_pos.getSegment());
name = segMan->derefString(nameReg);
if (!name)
name = "<invalid name>";

4
engines/sci/engine/object.h
View file

@ -168,7 +168,7 @@ public:
uint16 offset = (getSciVersion() < SCI_VERSION_1_1) ? _methodCount + 1 + i : i * 2 + 2;
if (getSciVersion() == SCI_VERSION_3)
offset--;
return make_reg(_pos.segment, _baseMethod[offset]);
return make_reg(_pos.getSegment(), _baseMethod[offset]);
}
Selector getFuncSelector(uint16 i) const {
@ -198,7 +198,7 @@ public:
*/
int locateVarSelector(SegManager *segMan, Selector slc) const;
bool isClass() const { return (getInfoSelector().offset & kInfoFlagClass); }
bool isClass() const { return (getInfoSelector().getOffset() & kInfoFlagClass); }
const Object *getClass(SegManager *segMan) const;
void markAsFreed() { _flags |= OBJECT_FLAG_FREED; }

13
engines/sci/engine/savegame.cpp
View file

@ -115,8 +115,9 @@ void syncArray(Common::Serializer &s, Common::Array<T> &arr) {
template<>
void syncWithSerializer(Common::Serializer &s, reg_t &obj) {
s.syncAsUint16LE(obj.segment);
s.syncAsUint16LE(obj.offset);
// Segment and offset are accessed directly here
s.syncAsUint16LE(obj._segment);
s.syncAsUint16LE(obj._offset);
}
template<>
@ -202,7 +203,7 @@ void SegManager::saveLoadWithSerializer(Common::Serializer &s) {
ObjMap objects = scr->getObjectMap();
for (ObjMap::iterator it = objects.begin(); it != objects.end(); ++it)
it->_value.syncBaseObject(scr->getBuf(it->_value.getPos().offset));
it->_value.syncBaseObject(scr->getBuf(it->_value.getPos().getOffset()));
}
@ -507,7 +508,7 @@ void Script::saveLoadWithSerializer(Common::Serializer &s) {
Object tmp;
for (uint i = 0; i < numObjs; ++i) {
syncWithSerializer(s, tmp);
_objects[tmp.getPos().offset] = tmp;
_objects[tmp.getPos().getOffset()] = tmp;
}
} else {
ObjMap::iterator it;
@ -816,7 +817,7 @@ bool gamestate_save(EngineState *s, Common::WriteStream *fh, const Common::Strin
Resource *script0 = g_sci->getResMan()->findResource(ResourceId(kResourceTypeScript, 0), false);
meta.script0Size = script0->size;
meta.gameObjectOffset = g_sci->getGameObject().offset;
meta.gameObjectOffset = g_sci->getGameObject().getOffset();
// Checking here again
if (s->executionStackBase) {
@ -867,7 +868,7 @@ void gamestate_restore(EngineState *s, Common::SeekableReadStream *fh) {
if (meta.gameObjectOffset > 0 && meta.script0Size > 0) {
Resource *script0 = g_sci->getResMan()->findResource(ResourceId(kResourceTypeScript, 0), false);
if (script0->size != meta.script0Size || g_sci->getGameObject().offset != meta.gameObjectOffset) {
if (script0->size != meta.script0Size || g_sci->getGameObject().getOffset() != meta.gameObjectOffset) {
//warning("This saved game was created with a different version of the game, unable to load it");
showScummVMDialog("This saved game was created with a different version of the game, unable to load it");

42
engines/sci/engine/script.cpp
View file

@ -239,14 +239,14 @@ const Object *Script::getObject(uint16 offset) const {
Object *Script::scriptObjInit(reg_t obj_pos, bool fullObjectInit) {
if (getSciVersion() < SCI_VERSION_1_1 && fullObjectInit)
obj_pos.offset += 8; // magic offset (SCRIPT_OBJECT_MAGIC_OFFSET)
obj_pos.incOffset(8); // magic offset (SCRIPT_OBJECT_MAGIC_OFFSET)
if (obj_pos.offset >= _bufSize)
if (obj_pos.getOffset() >= _bufSize)
error("Attempt to initialize object beyond end of script");
// Get the object at the specified position and init it. This will
// automatically "allocate" space for it in the _objects map if necessary.
Object *obj = &_objects[obj_pos.offset];
Object *obj = &_objects[obj_pos.getOffset()];
obj->init(_buf, obj_pos, fullObjectInit);
return obj;
@ -269,9 +269,9 @@ static bool relocateBlock(Common::Array<reg_t> &block, int block_location, Segme
error("Attempt to relocate odd variable #%d.5e (relative to %04x)\n", idx, block_location);
return false;
}
block[idx].segment = segment; // Perform relocation
block[idx].setSegment(segment); // Perform relocation
if (getSciVersion() >= SCI_VERSION_1_1 && getSciVersion() <= SCI_VERSION_2_1)
block[idx].offset += scriptSize;
block[idx].incOffset(scriptSize);
return true;
}
@ -310,23 +310,23 @@ void Script::relocateSci0Sci21(reg_t block) {
heapOffset = _scriptSize;
}
if (block.offset >= (uint16)heapSize ||
READ_SCI11ENDIAN_UINT16(heap + block.offset) * 2 + block.offset >= (uint16)heapSize)
if (block.getOffset() >= (uint16)heapSize ||
READ_SCI11ENDIAN_UINT16(heap + block.getOffset()) * 2 + block.getOffset() >= (uint16)heapSize)
error("Relocation block outside of script");
int count = READ_SCI11ENDIAN_UINT16(heap + block.offset);
int count = READ_SCI11ENDIAN_UINT16(heap + block.getOffset());
int exportIndex = 0;
int pos = 0;
for (int i = 0; i < count; i++) {
pos = READ_SCI11ENDIAN_UINT16(heap + block.offset + 2 + (exportIndex * 2)) + heapOffset;
pos = READ_SCI11ENDIAN_UINT16(heap + block.getOffset() + 2 + (exportIndex * 2)) + heapOffset;
// This occurs in SCI01/SCI1 games where usually one export value is
// zero. It seems that in this situation, we should skip the export and
// move to the next one, though the total count of valid exports remains
// the same
if (!pos) {
exportIndex++;
pos = READ_SCI11ENDIAN_UINT16(heap + block.offset + 2 + (exportIndex * 2)) + heapOffset;
pos = READ_SCI11ENDIAN_UINT16(heap + block.getOffset() + 2 + (exportIndex * 2)) + heapOffset;
if (!pos)
error("Script::relocate(): Consecutive zero exports found");
}
@ -335,12 +335,12 @@ void Script::relocateSci0Sci21(reg_t block) {
// We only relocate locals and objects here, and ignore relocation of
// code blocks. In SCI1.1 and newer versions, only locals and objects
// are relocated.
if (!relocateLocal(block.segment, pos)) {
if (!relocateLocal(block.getSegment(), pos)) {
// Not a local? It's probably an object or code block. If it's an
// object, relocate it.
const ObjMap::iterator end = _objects.end();
for (ObjMap::iterator it = _objects.begin(); it != end; ++it)
if (it->_value.relocateSci0Sci21(block.segment, pos, _scriptSize))
if (it->_value.relocateSci0Sci21(block.getSegment(), pos, _scriptSize))
break;
}
@ -357,7 +357,7 @@ void Script::relocateSci3(reg_t block) {
const byte *seeker = relocStart;
while (seeker < _buf + _bufSize) {
// TODO: Find out what UINT16 at (seeker + 8) means
it->_value.relocateSci3(block.segment,
it->_value.relocateSci3(block.getSegment(),
READ_SCI11ENDIAN_UINT32(seeker),
READ_SCI11ENDIAN_UINT32(seeker + 4),
_scriptSize);
@ -466,7 +466,7 @@ bool Script::isValidOffset(uint16 offset) const {
}
SegmentRef Script::dereference(reg_t pointer) {
if (pointer.offset > _bufSize) {
if (pointer.getOffset() > _bufSize) {
error("Script::dereference(): Attempt to dereference invalid pointer %04x:%04x into script segment (script size=%d)",
PRINT_REG(pointer), (uint)_bufSize);
return SegmentRef();
@ -474,8 +474,8 @@ SegmentRef Script::dereference(reg_t pointer) {
SegmentRef ret;
ret.isRaw = true;
ret.maxSize = _bufSize - pointer.offset;
ret.raw = _buf + pointer.offset;
ret.maxSize = _bufSize - pointer.getOffset();
ret.raw = _buf + pointer.getOffset();
return ret;
}
@ -653,7 +653,7 @@ void Script::initializeObjectsSci11(SegManager *segMan, SegmentId segmentId) {
// Copy base from species class, as we need its selector IDs
obj->setSuperClassSelector(
segMan->getClassAddress(obj->getSuperClassSelector().offset, SCRIPT_GET_LOCK, 0));
segMan->getClassAddress(obj->getSuperClassSelector().getOffset(), SCRIPT_GET_LOCK, 0));
// If object is instance, get -propDict- from class and set it for this
// object. This is needed for ::isMemberOf() to work.
@ -686,7 +686,7 @@ void Script::initializeObjectsSci3(SegManager *segMan, SegmentId segmentId) {
reg_t reg = make_reg(segmentId, seeker - _buf);
Object *obj = scriptObjInit(reg);
obj->setSuperClassSelector(segMan->getClassAddress(obj->getSuperClassSelector().offset, SCRIPT_GET_LOCK, 0));
obj->setSuperClassSelector(segMan->getClassAddress(obj->getSuperClassSelector().getOffset(), SCRIPT_GET_LOCK, 0));
seeker += READ_SCI11ENDIAN_UINT16(seeker + 2);
}
@ -703,7 +703,7 @@ void Script::initializeObjects(SegManager *segMan, SegmentId segmentId) {
}
reg_t Script::findCanonicAddress(SegManager *segMan, reg_t addr) const {
addr.offset = 0;
addr.setOffset(0);
return addr;
}
@ -725,8 +725,8 @@ Common::Array<reg_t> Script::listAllDeallocatable(SegmentId segId) const {
Common::Array<reg_t> Script::listAllOutgoingReferences(reg_t addr) const {
Common::Array<reg_t> tmp;
if (addr.offset <= _bufSize && addr.offset >= -SCRIPT_OBJECT_MAGIC_OFFSET && offsetIsObject(addr.offset)) {
const Object *obj = getObject(addr.offset);
if (addr.getOffset() <= _bufSize && addr.getOffset() >= (uint)-SCRIPT_OBJECT_MAGIC_OFFSET && offsetIsObject(addr.getOffset())) {
const Object *obj = getObject(addr.getOffset());
if (obj) {
// Note all local variables, if we have a local variable environment
if (_localsSegment)

101
engines/sci/engine/scriptdebug.cpp
View file

@ -69,17 +69,17 @@ const char *opcodeNames[] = {
// Disassembles one command from the heap, returns address of next command or 0 if a ret was encountered.
reg_t disassemble(EngineState *s, reg_t pos, bool printBWTag, bool printBytecode) {
SegmentObj *mobj = s->_segMan->getSegment(pos.segment, SEG_TYPE_SCRIPT);
SegmentObj *mobj = s->_segMan->getSegment(pos.getSegment(), SEG_TYPE_SCRIPT);
Script *script_entity = NULL;
const byte *scr;
int scr_size;
reg_t retval = make_reg(pos.segment, pos.offset + 1);
uint scr_size;
reg_t retval = make_reg(pos.getSegment(), pos.getOffset() + 1);
uint16 param_value = 0xffff; // Suppress GCC warning by setting default value, chose value as invalid to getKernelName etc.
int i = 0;
uint i = 0;
Kernel *kernel = g_sci->getKernel();
if (!mobj) {
warning("Disassembly failed: Segment %04x non-existant or not a script", pos.segment);
warning("Disassembly failed: Segment %04x non-existant or not a script", pos.getSegment());
return retval;
} else
script_entity = (Script *)mobj;
@ -87,14 +87,14 @@ reg_t disassemble(EngineState *s, reg_t pos, bool printBWTag, bool printBytecode
scr = script_entity->getBuf();
scr_size = script_entity->getBufSize();
if (pos.offset >= scr_size) {
if (pos.getOffset() >= scr_size) {
warning("Trying to disassemble beyond end of script");
return NULL_REG;
}
int16 opparams[4];
byte opsize;
int bytecount = readPMachineInstruction(scr + pos.offset, opsize, opparams);
uint bytecount = readPMachineInstruction(scr + pos.getOffset(), opsize, opparams);
const byte opcode = opsize >> 1;
opsize &= 1; // byte if true, word if false
@ -102,13 +102,13 @@ reg_t disassemble(EngineState *s, reg_t pos, bool printBWTag, bool printBytecode
debugN("%04x:%04x: ", PRINT_REG(pos));
if (printBytecode) {
if (pos.offset + bytecount > scr_size) {
if (pos.getOffset() + bytecount > scr_size) {
warning("Operation arguments extend beyond end of script");
return retval;
}
for (i = 0; i < bytecount; i++)
debugN("%02x ", scr[pos.offset + i]);
debugN("%02x ", scr[pos.getOffset() + i]);
for (i = bytecount; i < 5; i++)
debugN(" ");
@ -130,16 +130,16 @@ reg_t disassemble(EngineState *s, reg_t pos, bool printBWTag, bool printBytecode
case Script_SByte:
case Script_Byte:
param_value = scr[retval.offset];
debugN(" %02x", scr[retval.offset]);
retval.offset++;
param_value = scr[retval.getOffset()];
debugN(" %02x", scr[retval.getOffset()]);
retval.incOffset(1);
break;
case Script_Word:
case Script_SWord:
param_value = READ_SCI11ENDIAN_UINT16(&scr[retval.offset]);
debugN(" %04x", READ_SCI11ENDIAN_UINT16(&scr[retval.offset]));
retval.offset += 2;
param_value = READ_SCI11ENDIAN_UINT16(&scr[retval.getOffset()]);
debugN(" %04x", READ_SCI11ENDIAN_UINT16(&scr[retval.getOffset()]));
retval.incOffset(2);
break;
case Script_SVariable:
@ -149,11 +149,12 @@ reg_t disassemble(EngineState *s, reg_t pos, bool printBWTag, bool printBytecode
case Script_Local:
case Script_Temp:
case Script_Param:
if (opsize)
param_value = scr[retval.offset++];
else {
param_value = READ_SCI11ENDIAN_UINT16(&scr[retval.offset]);
retval.offset += 2;
if (opsize) {
param_value = scr[retval.getOffset()];
retval.incOffset(1);
} else {
param_value = READ_SCI11ENDIAN_UINT16(&scr[retval.getOffset()]);
retval.incOffset(2);
}
if (opcode == op_callk)
@ -166,24 +167,26 @@ reg_t disassemble(EngineState *s, reg_t pos, bool printBWTag, bool printBytecode
break;
case Script_Offset:
if (opsize)
param_value = scr[retval.offset++];
else {
param_value = READ_SCI11ENDIAN_UINT16(&scr[retval.offset]);
retval.offset += 2;
if (opsize) {
param_value = scr[retval.getOffset()];
retval.incOffset(1);
} else {
param_value = READ_SCI11ENDIAN_UINT16(&scr[retval.getOffset()]);
retval.incOffset(2);
}
debugN(opsize ? " %02x" : " %04x", param_value);
break;
case Script_SRelative:
if (opsize) {
int8 offset = (int8)scr[retval.offset++];
debugN(" %02x [%04x]", 0xff & offset, 0xffff & (retval.offset + offset));
int8 offset = (int8)scr[retval.getOffset()];
retval.incOffset(1);
debugN(" %02x [%04x]", 0xff & offset, 0xffff & (retval.getOffset() + offset));
}
else {
int16 offset = (int16)READ_SCI11ENDIAN_UINT16(&scr[retval.offset]);
retval.offset += 2;
debugN(" %04x [%04x]", 0xffff & offset, 0xffff & (retval.offset + offset));
int16 offset = (int16)READ_SCI11ENDIAN_UINT16(&scr[retval.getOffset()]);
retval.incOffset(2);
debugN(" %04x [%04x]", 0xffff & offset, 0xffff & (retval.getOffset() + offset));
}
break;
@ -216,8 +219,8 @@ reg_t disassemble(EngineState *s, reg_t pos, bool printBWTag, bool printBytecode
if (pos == s->xs->addr.pc) { // Extra information if debugging the current opcode
if (opcode == op_callk) {
int stackframe = (scr[pos.offset + 2] >> 1) + (s->r_rest);
int argc = ((s->xs->sp)[- stackframe - 1]).offset;
int stackframe = (scr[pos.getOffset() + 2] >> 1) + (s->r_rest);
int argc = ((s->xs->sp)[- stackframe - 1]).getOffset();
bool oldScriptHeader = (getSciVersion() == SCI_VERSION_0_EARLY);
if (!oldScriptHeader)
@ -233,13 +236,13 @@ reg_t disassemble(EngineState *s, reg_t pos, bool printBWTag, bool printBytecode
debugN(")\n");
} else if ((opcode == op_send) || (opcode == op_self)) {
int restmod = s->r_rest;
int stackframe = (scr[pos.offset + 1] >> 1) + restmod;
int stackframe = (scr[pos.getOffset() + 1] >> 1) + restmod;
reg_t *sb = s->xs->sp;
uint16 selector;
reg_t fun_ref;
while (stackframe > 0) {
int argc = sb[- stackframe + 1].offset;
int argc = sb[- stackframe + 1].getOffset();
const char *name = NULL;
reg_t called_obj_addr = s->xs->objp;
@ -248,7 +251,7 @@ reg_t disassemble(EngineState *s, reg_t pos, bool printBWTag, bool printBytecode
else if (opcode == op_self)
called_obj_addr = s->xs->objp;
selector = sb[- stackframe].offset;
selector = sb[- stackframe].getOffset();
name = s->_segMan->getObjectName(called_obj_addr);
@ -290,20 +293,20 @@ reg_t disassemble(EngineState *s, reg_t pos, bool printBWTag, bool printBytecode
}
bool isJumpOpcode(EngineState *s, reg_t pos, reg_t& jumpTarget) {
SegmentObj *mobj = s->_segMan->getSegment(pos.segment, SEG_TYPE_SCRIPT);
SegmentObj *mobj = s->_segMan->getSegment(pos.getSegment(), SEG_TYPE_SCRIPT);
if (!mobj)
return false;
Script *script_entity = (Script *)mobj;
const byte *scr = script_entity->getBuf();
int scr_size = script_entity->getScriptSize();
uint scr_size = script_entity->getScriptSize();
if (pos.offset >= scr_size)
if (pos.getOffset() >= scr_size)
return false;
int16 opparams[4];
byte opsize;
int bytecount = readPMachineInstruction(scr + pos.offset, opsize, opparams);
int bytecount = readPMachineInstruction(scr + pos.getOffset(), opsize, opparams);
const byte opcode = opsize >> 1;
switch (opcode) {
@ -313,7 +316,7 @@ bool isJumpOpcode(EngineState *s, reg_t pos, reg_t& jumpTarget) {
{
reg_t jmpTarget = pos + bytecount + opparams[0];
// QFG2 has invalid jumps outside the script buffer in script 260
if (jmpTarget.offset >= scr_size)
if (jmpTarget.getOffset() >= scr_size)
return false;
jumpTarget = jmpTarget;
}
@ -336,16 +339,16 @@ void SciEngine::scriptDebug() {
if (_debugState.seeking != kDebugSeekNothing) {
const reg_t pc = s->xs->addr.pc;
SegmentObj *mobj = s->_segMan->getSegment(pc.segment, SEG_TYPE_SCRIPT);
SegmentObj *mobj = s->_segMan->getSegment(pc.getSegment(), SEG_TYPE_SCRIPT);
if (mobj) {
Script *scr = (Script *)mobj;
const byte *code_buf = scr->getBuf();
int code_buf_size = scr->getBufSize();
int opcode = pc.offset >= code_buf_size ? 0 : code_buf[pc.offset];
uint16 code_buf_size = scr->getBufSize();
int opcode = pc.getOffset() >= code_buf_size ? 0 : code_buf[pc.getOffset()];
int op = opcode >> 1;
int paramb1 = pc.offset + 1 >= code_buf_size ? 0 : code_buf[pc.offset + 1];
int paramf1 = (opcode & 1) ? paramb1 : (pc.offset + 2 >= code_buf_size ? 0 : (int16)READ_SCI11ENDIAN_UINT16(code_buf + pc.offset + 1));
int paramb1 = pc.getOffset() + 1 >= code_buf_size ? 0 : code_buf[pc.getOffset() + 1];
int paramf1 = (opcode & 1) ? paramb1 : (pc.getOffset() + 2 >= code_buf_size ? 0 : (int16)READ_SCI11ENDIAN_UINT16(code_buf + pc.getOffset() + 1));
switch (_debugState.seeking) {
case kDebugSeekSpecialCallk:
@ -714,7 +717,7 @@ void logKernelCall(const KernelFunction *kernelCall, const KernelSubFunction *ke
else if (regType & SIG_IS_INVALID)
debugN("INVALID");
else if (regType & SIG_TYPE_INTEGER)
debugN("%d", argv[parmNr].offset);
debugN("%d", argv[parmNr].getOffset());
else {
debugN("%04x:%04x", PRINT_REG(argv[parmNr]));
switch (regType) {
@ -723,12 +726,12 @@ void logKernelCall(const KernelFunction *kernelCall, const KernelSubFunction *ke
break;
case SIG_TYPE_REFERENCE:
{
SegmentObj *mobj = s->_segMan->getSegmentObj(argv[parmNr].segment);
SegmentObj *mobj = s->_segMan->getSegmentObj(argv[parmNr].getSegment());
switch (mobj->getType()) {
case SEG_TYPE_HUNK:
{
HunkTable *ht = (HunkTable *)mobj;
int index = argv[parmNr].offset;
int index = argv[parmNr].getOffset();
if (ht->isValidEntry(index)) {
// NOTE: This ", deleted" isn't as useful as it could
// be because it prints the status _after_ the kernel
@ -765,7 +768,7 @@ void logKernelCall(const KernelFunction *kernelCall, const KernelSubFunction *ke
if (result.isPointer())
debugN(" = %04x:%04x\n", PRINT_REG(result));
else
debugN(" = %d\n", result.offset);
debugN(" = %d\n", result.getOffset());
}
} // End of namespace Sci

133
engines/sci/engine/seg_manager.cpp
View file

@ -81,7 +81,7 @@ void SegManager::initSysStrings() {
if (getSciVersion() <= SCI_VERSION_1_1) {
// We need to allocate system strings in one segment, for compatibility reasons
allocDynmem(512, "system strings", &_saveDirPtr);
_parserPtr = make_reg(_saveDirPtr.segment, _saveDirPtr.offset + 256);
_parserPtr = make_reg(_saveDirPtr.getSegment(), _saveDirPtr.getOffset() + 256);
#ifdef ENABLE_SCI32
} else {
SciString *saveDirString = allocateString(&_saveDirPtr);
@ -163,7 +163,7 @@ bool SegManager::isHeapObject(reg_t pos) const {
const Object *obj = getObject(pos);
if (obj == NULL || (obj && obj->isFreed()))
return false;
Script *scr = getScriptIfLoaded(pos.segment);
Script *scr = getScriptIfLoaded(pos.getSegment());
return !(scr && scr->isMarkedAsDeleted());
}
@ -214,21 +214,21 @@ SegmentObj *SegManager::getSegment(SegmentId seg, SegmentType type) const {
}
Object *SegManager::getObject(reg_t pos) const {
SegmentObj *mobj = getSegmentObj(pos.segment);
SegmentObj *mobj = getSegmentObj(pos.getSegment());
Object *obj = NULL;
if (mobj != NULL) {
if (mobj->getType() == SEG_TYPE_CLONES) {
CloneTable *ct = (CloneTable *)mobj;
if (ct->isValidEntry(pos.offset))
obj = &(ct->_table[pos.offset]);
if (ct->isValidEntry(pos.getOffset()))
obj = &(ct->_table[pos.getOffset()]);
else
warning("getObject(): Trying to get an invalid object");
} else if (mobj->getType() == SEG_TYPE_SCRIPT) {
Script *scr = (Script *)mobj;
if (pos.offset <= scr->getBufSize() && pos.offset >= -SCRIPT_OBJECT_MAGIC_OFFSET
&& scr->offsetIsObject(pos.offset)) {
obj = scr->getObject(pos.offset);
if (pos.getOffset() <= scr->getBufSize() && pos.getOffset() >= (uint)-SCRIPT_OBJECT_MAGIC_OFFSET
&& scr->offsetIsObject(pos.getOffset())) {
obj = scr->getObject(pos.getOffset());
}
}
}
@ -246,7 +246,7 @@ const char *SegManager::getObjectName(reg_t pos) {
return "<no name>";
const char *name = 0;
if (nameReg.segment)
if (nameReg.getSegment())
name = derefString(nameReg);
if (!name)
return "<invalid name>";
@ -272,7 +272,7 @@ reg_t SegManager::findObjectByName(const Common::String &name, int index) {
const Script *scr = (const Script *)mobj;
const ObjMap &objects = scr->getObjectMap();
for (ObjMap::const_iterator it = objects.begin(); it != objects.end(); ++it) {
objpos.offset = it->_value.getPos().offset;
objpos.setOffset(it->_value.getPos().getOffset());
if (name == getObjectName(objpos))
result.push_back(objpos);
}
@ -283,7 +283,7 @@ reg_t SegManager::findObjectByName(const Common::String &name, int index) {
if (!ct->isValidEntry(idx))
continue;
objpos.offset = idx;
objpos.setOffset(idx);
if (name == getObjectName(objpos))
result.push_back(objpos);
}
@ -364,14 +364,14 @@ void SegManager::freeHunkEntry(reg_t addr) {
return;
}
HunkTable *ht = (HunkTable *)getSegment(addr.segment, SEG_TYPE_HUNK);
HunkTable *ht = (HunkTable *)getSegment(addr.getSegment(), SEG_TYPE_HUNK);
if (!ht) {
warning("Attempt to free Hunk from address %04x:%04x: Invalid segment type", PRINT_REG(addr));
return;
}
ht->freeEntryContents(addr.offset);
ht->freeEntryContents(addr.getOffset());
}
reg_t SegManager::allocateHunkEntry(const char *hunk_type, int size) {
@ -398,14 +398,14 @@ reg_t SegManager::allocateHunkEntry(const char *hunk_type, int size) {
}
byte *SegManager::getHunkPointer(reg_t addr) {
HunkTable *ht = (HunkTable *)getSegment(addr.segment, SEG_TYPE_HUNK);
HunkTable *ht = (HunkTable *)getSegment(addr.getSegment(), SEG_TYPE_HUNK);
if (!ht || !ht->isValidEntry(addr.offset)) {
if (!ht || !ht->isValidEntry(addr.getOffset())) {
// Valid SCI behavior, e.g. when loading/quitting
return NULL;
}
return (byte *)ht->_table[addr.offset].mem;
return (byte *)ht->_table[addr.getOffset()].mem;
}
Clone *SegManager::allocateClone(reg_t *addr) {
@ -462,35 +462,35 @@ reg_t SegManager::newNode(reg_t value, reg_t key) {
}
List *SegManager::lookupList(reg_t addr) {
if (getSegmentType(addr.segment) != SEG_TYPE_LISTS) {
if (getSegmentType(addr.getSegment()) != SEG_TYPE_LISTS) {
error("Attempt to use non-list %04x:%04x as list", PRINT_REG(addr));
return NULL;
}
ListTable *lt = (ListTable *)_heap[addr.segment];
ListTable *lt = (ListTable *)_heap[addr.getSegment()];
if (!lt->isValidEntry(addr.offset)) {
if (!lt->isValidEntry(addr.getOffset())) {
error("Attempt to use non-list %04x:%04x as list", PRINT_REG(addr));
return NULL;
}
return &(lt->_table[addr.offset]);
return &(lt->_table[addr.getOffset()]);
}
Node *SegManager::lookupNode(reg_t addr, bool stopOnDiscarded) {
if (addr.isNull())
return NULL; // Non-error null
SegmentType type = getSegmentType(addr.segment);
SegmentType type = getSegmentType(addr.getSegment());
if (type != SEG_TYPE_NODES) {
error("Attempt to use non-node %04x:%04x (type %d) as list node", PRINT_REG(addr), type);
return NULL;
}
NodeTable *nt = (NodeTable *)_heap[addr.segment];
NodeTable *nt = (NodeTable *)_heap[addr.getSegment()];
if (!nt->isValidEntry(addr.offset)) {
if (!nt->isValidEntry(addr.getOffset())) {
if (!stopOnDiscarded)
return NULL;
@ -498,19 +498,19 @@ Node *SegManager::lookupNode(reg_t addr, bool stopOnDiscarded) {
return NULL;
}
return &(nt->_table[addr.offset]);
return &(nt->_table[addr.getOffset()]);
}
SegmentRef SegManager::dereference(reg_t pointer) {
SegmentRef ret;
if (!pointer.segment || (pointer.segment >= _heap.size()) || !_heap[pointer.segment]) {
if (!pointer.getSegment() || (pointer.getSegment() >= _heap.size()) || !_heap[pointer.getSegment()]) {
// This occurs in KQ5CD when interacting with certain objects
warning("SegManager::dereference(): Attempt to dereference invalid pointer %04x:%04x", PRINT_REG(pointer));
return ret; /* Invalid */
}
SegmentObj *mobj = _heap[pointer.segment];
SegmentObj *mobj = _heap[pointer.getSegment()];
return mobj->dereference(pointer);
}
@ -522,7 +522,7 @@ static void *derefPtr(SegManager *segMan, reg_t pointer, int entries, bool wantR
if (ret.isRaw != wantRaw) {
warning("Dereferencing pointer %04x:%04x (type %d) which is %s, but expected %s", PRINT_REG(pointer),
segMan->getSegmentType(pointer.segment),
segMan->getSegmentType(pointer.getSegment()),
ret.isRaw ? "raw" : "not raw",
wantRaw ? "raw" : "not raw");
}
@ -565,15 +565,15 @@ static inline char getChar(const SegmentRef &ref, uint offset) {
// segment 0xFFFF means that the scripts are using uninitialized temp-variable space
// we can safely ignore this, if it isn't one of the first 2 chars.
// foreign lsl3 uses kFileIO(readraw) and then immediately uses kReadNumber right at the start
if (val.segment != 0)
if (!((val.segment == 0xFFFF) && (offset > 1)))
if (val.getSegment() != 0)
if (!((val.getSegment() == 0xFFFF) && (offset > 1)))
warning("Attempt to read character from non-raw data");
bool oddOffset = offset & 1;
if (g_sci->isBE())
oddOffset = !oddOffset;
return (oddOffset ? val.offset >> 8 : val.offset & 0xff);
return (oddOffset ? val.getOffset() >> 8 : val.getOffset() & 0xff);
}
static inline void setChar(const SegmentRef &ref, uint offset, byte value) {
@ -582,16 +582,16 @@ static inline void setChar(const SegmentRef &ref, uint offset, byte value) {
reg_t *val = ref.reg + offset / 2;
val->segment = 0;
val->setSegment(0);
bool oddOffset = offset & 1;
if (g_sci->isBE())
oddOffset = !oddOffset;
if (oddOffset)
val->offset = (val->offset & 0x00ff) | (value << 8);
val->setOffset((val->getOffset() & 0x00ff) | (value << 8));
else
val->offset = (val->offset & 0xff00) | value;
val->setOffset((val->getOffset() & 0xff00) | value);
}
// TODO: memcpy, strcpy and strncpy could maybe be folded into a single function
@ -829,10 +829,11 @@ byte *SegManager::allocDynmem(int size, const char *descr, reg_t *addr) {
}
bool SegManager::freeDynmem(reg_t addr) {
if (addr.segment < 1 || addr.segment >= _heap.size() || !_heap[addr.segment] || _heap[addr.segment]->getType() != SEG_TYPE_DYNMEM)
if (addr.getSegment() < 1 || addr.getSegment() >= _heap.size() ||
!_heap[addr.getSegment()] || _heap[addr.getSegment()]->getType() != SEG_TYPE_DYNMEM)
return false; // error
deallocate(addr.segment);
deallocate(addr.getSegment());
return true; // OK
}
@ -854,28 +855,28 @@ SciArray<reg_t> *SegManager::allocateArray(reg_t *addr) {
}
SciArray<reg_t> *SegManager::lookupArray(reg_t addr) {
if (_heap[addr.segment]->getType() != SEG_TYPE_ARRAY)
if (_heap[addr.getSegment()]->getType() != SEG_TYPE_ARRAY)
error("Attempt to use non-array %04x:%04x as array", PRINT_REG(addr));
ArrayTable *arrayTable = (ArrayTable *)_heap[addr.segment];
ArrayTable *arrayTable = (ArrayTable *)_heap[addr.getSegment()];
if (!arrayTable->isValidEntry(addr.offset))
if (!arrayTable->isValidEntry(addr.getOffset()))
error("Attempt to use non-array %04x:%04x as array", PRINT_REG(addr));
return &(arrayTable->_table[addr.offset]);
return &(arrayTable->_table[addr.getOffset()]);
}
void SegManager::freeArray(reg_t addr) {
if (_heap[addr.segment]->getType() != SEG_TYPE_ARRAY)
if (_heap[addr.getSegment()]->getType() != SEG_TYPE_ARRAY)
error("Attempt to use non-array %04x:%04x as array", PRINT_REG(addr));
ArrayTable *arrayTable = (ArrayTable *)_heap[addr.segment];
ArrayTable *arrayTable = (ArrayTable *)_heap[addr.getSegment()];
if (!arrayTable->isValidEntry(addr.offset))
if (!arrayTable->isValidEntry(addr.getOffset()))
error("Attempt to use non-array %04x:%04x as array", PRINT_REG(addr));
arrayTable->_table[addr.offset].destroy();
arrayTable->freeEntry(addr.offset);
arrayTable->_table[addr.getOffset()].destroy();
arrayTable->freeEntry(addr.getOffset());
}
SciString *SegManager::allocateString(reg_t *addr) {
@ -894,28 +895,28 @@ SciString *SegManager::allocateString(reg_t *addr) {
}
SciString *SegManager::lookupString(reg_t addr) {
if (_heap[addr.segment]->getType() != SEG_TYPE_STRING)
if (_heap[addr.getSegment()]->getType() != SEG_TYPE_STRING)
error("lookupString: Attempt to use non-string %04x:%04x as string", PRINT_REG(addr));
StringTable *stringTable = (StringTable *)_heap[addr.segment];
StringTable *stringTable = (StringTable *)_heap[addr.getSegment()];
if (!stringTable->isValidEntry(addr.offset))
if (!stringTable->isValidEntry(addr.getOffset()))
error("lookupString: Attempt to use non-string %04x:%04x as string", PRINT_REG(addr));
return &(stringTable->_table[addr.offset]);
return &(stringTable->_table[addr.getOffset()]);
}
void SegManager::freeString(reg_t addr) {
if (_heap[addr.segment]->getType() != SEG_TYPE_STRING)
if (_heap[addr.getSegment()]->getType() != SEG_TYPE_STRING)
error("freeString: Attempt to use non-string %04x:%04x as string", PRINT_REG(addr));
StringTable *stringTable = (StringTable *)_heap[addr.segment];
StringTable *stringTable = (StringTable *)_heap[addr.getSegment()];
if (!stringTable->isValidEntry(addr.offset))
if (!stringTable->isValidEntry(addr.getOffset()))
error("freeString: Attempt to use non-string %04x:%04x as string", PRINT_REG(addr));
stringTable->_table[addr.offset].destroy();
stringTable->freeEntry(addr.offset);
stringTable->_table[addr.getOffset()].destroy();
stringTable->freeEntry(addr.getOffset());
}
#endif
@ -948,16 +949,16 @@ reg_t SegManager::getClassAddress(int classnr, ScriptLoadType lock, uint16 calle
return NULL_REG;
} else {
Class *the_class = &_classTable[classnr];
if (!the_class->reg.segment) {
if (!the_class->reg.getSegment()) {
getScriptSegment(the_class->script, lock);
if (!the_class->reg.segment) {
if (!the_class->reg.getSegment()) {
error("[VM] Trying to instantiate class %x by instantiating script 0x%x (%03d) failed;", classnr, the_class->script, the_class->script);
return NULL_REG;
}
} else
if (callerSegment != the_class->reg.segment)
getScript(the_class->reg.segment)->incrementLockers();
if (callerSegment != the_class->reg.getSegment())
getScript(the_class->reg.getSegment())->incrementLockers();
return the_class->reg;
}
@ -1002,7 +1003,7 @@ void SegManager::uninstantiateScript(int script_nr) {
// Free all classtable references to this script
for (uint i = 0; i < classTableSize(); i++)
if (getClass(i).reg.segment == segmentId)
if (getClass(i).reg.getSegment() == segmentId)
setClassOffset(i, NULL_REG);
if (getSciVersion() < SCI_VERSION_1_1)
@ -1026,18 +1027,18 @@ void SegManager::uninstantiateScriptSci0(int script_nr) {
// Make a pass over the object in order to uninstantiate all superclasses
do {
reg.offset += objLength; // Step over the last checked object
reg.incOffset(objLength); // Step over the last checked object
objType = READ_SCI11ENDIAN_UINT16(scr->getBuf(reg.offset));
objType = READ_SCI11ENDIAN_UINT16(scr->getBuf(reg.getOffset()));
if (!objType)
break;
objLength = READ_SCI11ENDIAN_UINT16(scr->getBuf(reg.offset + 2));
objLength = READ_SCI11ENDIAN_UINT16(scr->getBuf(reg.getOffset() + 2));
reg.offset += 4; // Step over header
reg.incOffset(4); // Step over header
if ((objType == SCI_OBJ_OBJECT) || (objType == SCI_OBJ_CLASS)) { // object or class?
reg.offset += 8; // magic offset (SCRIPT_OBJECT_MAGIC_OFFSET)
int16 superclass = READ_SCI11ENDIAN_UINT16(scr->getBuf(reg.offset + 2));
reg.incOffset(8); // magic offset (SCRIPT_OBJECT_MAGIC_OFFSET)
int16 superclass = READ_SCI11ENDIAN_UINT16(scr->getBuf(reg.getOffset() + 2));
if (superclass >= 0) {
int superclass_script = getClass(superclass).script;
@ -1051,10 +1052,10 @@ void SegManager::uninstantiateScriptSci0(int script_nr) {
// Recurse to assure that the superclass lockers number gets decreased
}
reg.offset += SCRIPT_OBJECT_MAGIC_OFFSET;
reg.incOffset(SCRIPT_OBJECT_MAGIC_OFFSET);
} // if object or class
reg.offset -= 4; // Step back on header
reg.incOffset(-4); // Step back on header
} while (objType != 0);
}

50
engines/sci/engine/segment.cpp
View file

@ -93,11 +93,11 @@ Common::Array<reg_t> CloneTable::listAllOutgoingReferences(reg_t addr) const {
Common::Array<reg_t> tmp;
// assert(addr.segment == _segId);
if (!isValidEntry(addr.offset)) {
if (!isValidEntry(addr.getOffset())) {
error("Unexpected request for outgoing references from clone at %04x:%04x", PRINT_REG(addr));
}
const Clone *clone = &(_table[addr.offset]);
const Clone *clone = &(_table[addr.getOffset()]);
// Emit all member variables (including references to the 'super' delegate)
for (uint i = 0; i < clone->getVarCount(); i++)
@ -112,7 +112,7 @@ Common::Array<reg_t> CloneTable::listAllOutgoingReferences(reg_t addr) const {
void CloneTable::freeAtAddress(SegManager *segMan, reg_t addr) {
#ifdef GC_DEBUG
Object *victim_obj = &(_table[addr.offset]);
Object *victim_obj = &(_table[addr.getOffset()]);
if (!(victim_obj->_flags & OBJECT_FLAG_FREED))
warning("[GC] Clone %04x:%04x not reachable and not freed (freeing now)", PRINT_REG(addr));
@ -124,7 +124,7 @@ void CloneTable::freeAtAddress(SegManager *segMan, reg_t addr) {
#endif
#endif
freeEntry(addr.offset);
freeEntry(addr.getOffset());
}
@ -133,15 +133,15 @@ void CloneTable::freeAtAddress(SegManager *segMan, reg_t addr) {
SegmentRef LocalVariables::dereference(reg_t pointer) {
SegmentRef ret;
ret.isRaw = false; // reg_t based data!
ret.maxSize = (_locals.size() - pointer.offset / 2) * 2;
ret.maxSize = (_locals.size() - pointer.getOffset() / 2) * 2;
if (pointer.offset & 1) {
if (pointer.getOffset() & 1) {
ret.maxSize -= 1;
ret.skipByte = true;
}
if (ret.maxSize > 0) {
ret.reg = &_locals[pointer.offset / 2];
ret.reg = &_locals[pointer.getOffset() / 2];
} else {
if ((g_sci->getEngineState()->currentRoomNumber() == 160 ||
g_sci->getEngineState()->currentRoomNumber() == 220)
@ -181,14 +181,14 @@ Common::Array<reg_t> LocalVariables::listAllOutgoingReferences(reg_t addr) const
SegmentRef DataStack::dereference(reg_t pointer) {
SegmentRef ret;
ret.isRaw = false; // reg_t based data!
ret.maxSize = (_capacity - pointer.offset / 2) * 2;
ret.maxSize = (_capacity - pointer.getOffset() / 2) * 2;
if (pointer.offset & 1) {
if (pointer.getOffset() & 1) {
ret.maxSize -= 1;
ret.skipByte = true;
}
ret.reg = &_entries[pointer.offset / 2];
ret.reg = &_entries[pointer.getOffset() / 2];
return ret;
}
@ -204,11 +204,11 @@ Common::Array<reg_t> DataStack::listAllOutgoingReferences(reg_t object) const {
Common::Array<reg_t> ListTable::listAllOutgoingReferences(reg_t addr) const {
Common::Array<reg_t> tmp;
if (!isValidEntry(addr.offset)) {
if (!isValidEntry(addr.getOffset())) {
error("Invalid list referenced for outgoing references: %04x:%04x", PRINT_REG(addr));
}
const List *list = &(_table[addr.offset]);
const List *list = &(_table[addr.getOffset()]);
tmp.push_back(list->first);
tmp.push_back(list->last);
@ -222,10 +222,10 @@ Common::Array<reg_t> ListTable::listAllOutgoingReferences(reg_t addr) const {
Common::Array<reg_t> NodeTable::listAllOutgoingReferences(reg_t addr) const {
Common::Array<reg_t> tmp;
if (!isValidEntry(addr.offset)) {
if (!isValidEntry(addr.getOffset())) {
error("Invalid node referenced for outgoing references: %04x:%04x", PRINT_REG(addr));
}
const Node *node = &(_table[addr.offset]);
const Node *node = &(_table[addr.getOffset()]);
// We need all four here. Can't just stick with 'pred' OR 'succ' because node operations allow us
// to walk around from any given node
@ -242,8 +242,8 @@ Common::Array<reg_t> NodeTable::listAllOutgoingReferences(reg_t addr) const {
SegmentRef DynMem::dereference(reg_t pointer) {
SegmentRef ret;
ret.isRaw = true;
ret.maxSize = _size - pointer.offset;
ret.raw = _buf + pointer.offset;
ret.maxSize = _size - pointer.getOffset();
ret.raw = _buf + pointer.getOffset();
return ret;
}
@ -252,27 +252,27 @@ SegmentRef DynMem::dereference(reg_t pointer) {
SegmentRef ArrayTable::dereference(reg_t pointer) {
SegmentRef ret;
ret.isRaw = false;
ret.maxSize = _table[pointer.offset].getSize() * 2;
ret.reg = _table[pointer.offset].getRawData();
ret.maxSize = _table[pointer.getOffset()].getSize() * 2;
ret.reg = _table[pointer.getOffset()].getRawData();
return ret;
}
void ArrayTable::freeAtAddress(SegManager *segMan, reg_t sub_addr) {
_table[sub_addr.offset].destroy();
freeEntry(sub_addr.offset);
_table[sub_addr.getOffset()].destroy();
freeEntry(sub_addr.getOffset());
}
Common::Array<reg_t> ArrayTable::listAllOutgoingReferences(reg_t addr) const {
Common::Array<reg_t> tmp;
if (!isValidEntry(addr.offset)) {
if (!isValidEntry(addr.getOffset())) {
error("Invalid array referenced for outgoing references: %04x:%04x", PRINT_REG(addr));
}
const SciArray<reg_t> *array = &(_table[addr.offset]);
const SciArray<reg_t> *array = &(_table[addr.getOffset()]);
for (uint32 i = 0; i < array->getSize(); i++) {
reg_t value = array->getValue(i);
if (value.segment != 0)
if (value.getSegment() != 0)
tmp.push_back(value);
}
@ -305,8 +305,8 @@ void SciString::fromString(const Common::String &string) {
SegmentRef StringTable::dereference(reg_t pointer) {
SegmentRef ret;
ret.isRaw = true;
ret.maxSize = _table[pointer.offset].getSize();
ret.raw = (byte *)_table[pointer.offset].getRawData();
ret.maxSize = _table[pointer.getOffset()].getSize();
ret.raw = (byte *)_table[pointer.getOffset()].getRawData();
return ret;
}

14
engines/sci/engine/segment.h
View file

@ -175,7 +175,7 @@ public:
}
virtual SegmentRef dereference(reg_t pointer);
virtual reg_t findCanonicAddress(SegManager *segMan, reg_t addr) const {
return make_reg(addr.segment, 0);
return make_reg(addr.getSegment(), 0);
}
virtual Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const;
@ -291,7 +291,7 @@ struct NodeTable : public SegmentObjTable<Node> {
NodeTable() : SegmentObjTable<Node>(SEG_TYPE_NODES) {}
virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr) {
freeEntry(sub_addr.offset);
freeEntry(sub_addr.getOffset());
}
virtual Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const;
@ -304,7 +304,7 @@ struct ListTable : public SegmentObjTable<List> {
ListTable() : SegmentObjTable<List>(SEG_TYPE_LISTS) {}
virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr) {
freeEntry(sub_addr.offset);
freeEntry(sub_addr.getOffset());
}
virtual Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const;
@ -333,7 +333,7 @@ struct HunkTable : public SegmentObjTable<Hunk> {
}
virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr) {
freeEntry(sub_addr.offset);
freeEntry(sub_addr.getOffset());
}
virtual void saveLoadWithSerializer(Common::Serializer &ser);
@ -358,7 +358,7 @@ public:
}
virtual SegmentRef dereference(reg_t pointer);
virtual reg_t findCanonicAddress(SegManager *segMan, reg_t addr) const {
return make_reg(addr.segment, 0);
return make_reg(addr.getSegment(), 0);
}
virtual Common::Array<reg_t> listAllDeallocatable(SegmentId segId) const {
const reg_t r = make_reg(segId, 0);
@ -502,8 +502,8 @@ struct StringTable : public SegmentObjTable<SciString> {
StringTable() : SegmentObjTable<SciString>(SEG_TYPE_STRING) {}
virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr) {
_table[sub_addr.offset].destroy();
freeEntry(sub_addr.offset);
_table[sub_addr.getOffset()].destroy();
freeEntry(sub_addr.getOffset());
}
void saveLoadWithSerializer(Common::Serializer &ser);

2
engines/sci/engine/selector.h
View file

@ -171,7 +171,7 @@ struct SelectorCache {
* SelectorCache and mapped in script.cpp.
*/
reg_t readSelector(SegManager *segMan, reg_t object, Selector selectorId);
#define readSelectorValue(segMan, _obj_, _slc_) (readSelector(segMan, _obj_, _slc_).offset)
#define readSelectorValue(segMan, _obj_, _slc_) (readSelector(segMan, _obj_, _slc_).getOffset())
/**
* Writes a selector value to an object.

89
engines/sci/engine/vm.cpp
View file

@ -119,7 +119,7 @@ extern const char *opcodeNames[]; // from scriptdebug.cpp
static reg_t read_var(EngineState *s, int type, int index) {
if (validate_variable(s->variables[type], s->stack_base, type, s->variablesMax[type], index)) {
if (s->variables[type][index].segment == 0xffff) {
if (s->variables[type][index].getSegment() == 0xffff) {
switch (type) {
case VAR_TEMP: {
// Uninitialized read on a temp
@ -195,8 +195,8 @@ static void write_var(EngineState *s, int type, int index, reg_t value) {
// this happens at least in sq1/room 44 (slot-machine), because a send is missing parameters, then
// those parameters are taken from uninitialized stack and afterwards they are copied back into temps
// if we don't remove the segment, we would get false-positive uninitialized reads later
if (type == VAR_TEMP && value.segment == 0xffff)
value.segment = 0;
if (type == VAR_TEMP && value.getSegment() == 0xffff)
value.setSegment(0);
s->variables[type][index] = value;
@ -578,16 +578,16 @@ void run_vm(EngineState *s) {
int var_type; // See description below
int var_number;
g_sci->_debugState.old_pc_offset = s->xs->addr.pc.offset;
g_sci->_debugState.old_pc_offset = s->xs->addr.pc.getOffset();
g_sci->_debugState.old_sp = s->xs->sp;
if (s->abortScriptProcessing != kAbortNone)
return; // Stop processing
if (s->_executionStackPosChanged) {
scr = s->_segMan->getScriptIfLoaded(s->xs->addr.pc.segment);
scr = s->_segMan->getScriptIfLoaded(s->xs->addr.pc.getSegment());
if (!scr)
error("No script in segment %d", s->xs->addr.pc.segment);
error("No script in segment %d", s->xs->addr.pc.getSegment());
s->xs = &(s->_executionStack.back());
s->_executionStackPosChanged = false;
@ -624,13 +624,13 @@ void run_vm(EngineState *s) {
s->variablesMax[VAR_TEMP] = s->xs->sp - s->xs->fp;
if (s->xs->addr.pc.offset >= scr->getBufSize())
if (s->xs->addr.pc.getOffset() >= scr->getBufSize())
error("run_vm(): program counter gone astray, addr: %d, code buffer size: %d",
s->xs->addr.pc.offset, scr->getBufSize());
s->xs->addr.pc.getOffset(), scr->getBufSize());
// Get opcode
byte extOpcode;
s->xs->addr.pc.offset += readPMachineInstruction(scr->getBuf() + s->xs->addr.pc.offset, extOpcode, opparams);
s->xs->addr.pc.incOffset(readPMachineInstruction(scr->getBuf(s->xs->addr.pc.getOffset()), extOpcode, opparams));
const byte opcode = extOpcode >> 1;
//debug("%s: %d, %d, %d, %d, acc = %04x:%04x, script %d, local script %d", opcodeNames[opcode], opparams[0], opparams[1], opparams[2], opparams[3], PRINT_REG(s->r_acc), scr->getScriptNumber(), local_script->getScriptNumber());
@ -705,7 +705,7 @@ void run_vm(EngineState *s) {
break;
case op_not: // 0x0c (12)
s->r_acc = make_reg(0, !(s->r_acc.offset || s->r_acc.segment));
s->r_acc = make_reg(0, !(s->r_acc.getOffset() || s->r_acc.getSegment()));
// Must allow pointers to be negated, as this is used for checking whether objects exist
break;
@ -765,30 +765,30 @@ void run_vm(EngineState *s) {
case op_bt: // 0x17 (23)
// Branch relative if true
if (s->r_acc.offset || s->r_acc.segment)
s->xs->addr.pc.offset += opparams[0];
if (s->r_acc.getOffset() || s->r_acc.getSegment())
s->xs->addr.pc.incOffset(opparams[0]);
if (s->xs->addr.pc.offset >= local_script->getScriptSize())
if (s->xs->addr.pc.getOffset() >= local_script->getScriptSize())
error("[VM] op_bt: request to jump past the end of script %d (offset %d, script is %d bytes)",
local_script->getScriptNumber(), s->xs->addr.pc.offset, local_script->getScriptSize());
local_script->getScriptNumber(), s->xs->addr.pc.getOffset(), local_script->getScriptSize());
break;
case op_bnt: // 0x18 (24)
// Branch relative if not true
if (!(s->r_acc.offset || s->r_acc.segment))
s->xs->addr.pc.offset += opparams[0];
if (!(s->r_acc.getOffset() || s->r_acc.getSegment()))
s->xs->addr.pc.incOffset(opparams[0]);
if (s->xs->addr.pc.offset >= local_script->getScriptSize())
if (s->xs->addr.pc.getOffset() >= local_script->getScriptSize())
error("[VM] op_bnt: request to jump past the end of script %d (offset %d, script is %d bytes)",
local_script->getScriptNumber(), s->xs->addr.pc.offset, local_script->getScriptSize());
local_script->getScriptNumber(), s->xs->addr.pc.getOffset(), local_script->getScriptSize());
break;
case op_jmp: // 0x19 (25)
s->xs->addr.pc.offset += opparams[0];
s->xs->addr.pc.incOffset(opparams[0]);
if (s->xs->addr.pc.offset >= local_script->getScriptSize())
if (s->xs->addr.pc.getOffset() >= local_script->getScriptSize())
error("[VM] op_jmp: request to jump past the end of script %d (offset %d, script is %d bytes)",
local_script->getScriptNumber(), s->xs->addr.pc.offset, local_script->getScriptSize());
local_script->getScriptNumber(), s->xs->addr.pc.getOffset(), local_script->getScriptSize());
break;
case op_ldi: // 0x1a (26)
@ -831,13 +831,13 @@ void run_vm(EngineState *s) {
int argc = (opparams[1] >> 1) // Given as offset, but we need count
+ 1 + s->r_rest;
StackPtr call_base = s->xs->sp - argc;
s->xs->sp[1].offset += s->r_rest;
s->xs->sp[1].incOffset(s->r_rest);
uint16 localCallOffset = s->xs->addr.pc.offset + opparams[0];
uint16 localCallOffset = s->xs->addr.pc.getOffset() + opparams[0];
ExecStack xstack(s->xs->objp, s->xs->objp, s->xs->sp,
(call_base->requireUint16()) + s->r_rest, call_base,
s->xs->local_segment, make_reg(s->xs->addr.pc.segment, localCallOffset),
s->xs->local_segment, make_reg(s->xs->addr.pc.getSegment(), localCallOffset),
NULL_SELECTOR, -1, localCallOffset, s->_executionStack.size() - 1,
EXEC_STACK_TYPE_CALL);
@ -894,9 +894,9 @@ void run_vm(EngineState *s) {
s_temp = s->xs->sp;
s->xs->sp -= temp;
s->xs->sp[0].offset += s->r_rest;
s->xs->sp[0].incOffset(s->r_rest);
xs_new = execute_method(s, 0, opparams[0], s_temp, s->xs->objp,
s->xs->sp[0].offset, s->xs->sp);
s->xs->sp[0].getOffset(), s->xs->sp);
s->r_rest = 0; // Used up the &rest adjustment
if (xs_new) // in case of error, keep old stack
s->_executionStackPosChanged = true;
@ -908,11 +908,10 @@ void run_vm(EngineState *s) {
s_temp = s->xs->sp;
s->xs->sp -= temp;
s->xs->sp[0].offset += s->r_rest;
s->xs->sp[0].incOffset(s->r_rest);
xs_new = execute_method(s, opparams[0], opparams[1], s_temp, s->xs->objp,
s->xs->sp[0].offset, s->xs->sp);
s->xs->sp[0].getOffset(), s->xs->sp);
s->r_rest = 0; // Used up the &rest adjustment
if (xs_new) // in case of error, keep old stack
s->_executionStackPosChanged = true;
break;
@ -965,7 +964,7 @@ void run_vm(EngineState *s) {
s_temp = s->xs->sp;
s->xs->sp -= ((opparams[0] >> 1) + s->r_rest); // Adjust stack
s->xs->sp[1].offset += s->r_rest;
s->xs->sp[1].incOffset(s->r_rest);
xs_new = send_selector(s, s->r_acc, s->r_acc, s_temp,
(int)(opparams[0] >> 1) + (uint16)s->r_rest, s->xs->sp);
@ -996,7 +995,7 @@ void run_vm(EngineState *s) {
case op_class: // 0x28 (40)
// Get class address
s->r_acc = s->_segMan->getClassAddress((unsigned)opparams[0], SCRIPT_GET_LOCK,
s->xs->addr.pc.segment);
s->xs->addr.pc.getSegment());
break;
case 0x29: // (41)
@ -1008,7 +1007,7 @@ void run_vm(EngineState *s) {
s_temp = s->xs->sp;
s->xs->sp -= ((opparams[0] >> 1) + s->r_rest); // Adjust stack
s->xs->sp[1].offset += s->r_rest;
s->xs->sp[1].incOffset(s->r_rest);
xs_new = send_selector(s, s->xs->objp, s->xs->objp,
s_temp, (int)(opparams[0] >> 1) + (uint16)s->r_rest,
s->xs->sp);
@ -1021,7 +1020,7 @@ void run_vm(EngineState *s) {
case op_super: // 0x2b (43)
// Send to any class
r_temp = s->_segMan->getClassAddress(opparams[0], SCRIPT_GET_LOAD, s->xs->addr.pc.segment);
r_temp = s->_segMan->getClassAddress(opparams[0], SCRIPT_GET_LOAD, s->xs->addr.pc.getSegment());
if (!r_temp.isPointer())
error("[VM]: Invalid superclass in object");
@ -1029,7 +1028,7 @@ void run_vm(EngineState *s) {
s_temp = s->xs->sp;
s->xs->sp -= ((opparams[1] >> 1) + s->r_rest); // Adjust stack
s->xs->sp[1].offset += s->r_rest;
s->xs->sp[1].incOffset(s->r_rest);
xs_new = send_selector(s, r_temp, s->xs->objp, s_temp,
(int)(opparams[1] >> 1) + (uint16)s->r_rest,
s->xs->sp);
@ -1058,14 +1057,14 @@ void run_vm(EngineState *s) {
var_number = temp & 0x03; // Get variable type
// Get variable block offset
r_temp.segment = s->variablesSegment[var_number];
r_temp.offset = s->variables[var_number] - s->variablesBase[var_number];
r_temp.setSegment(s->variablesSegment[var_number]);
r_temp.setOffset(s->variables[var_number] - s->variablesBase[var_number]);
if (temp & 0x08) // Add accumulator offset if requested
r_temp.offset += s->r_acc.requireSint16();
r_temp.incOffset(s->r_acc.requireSint16());
r_temp.offset += opparams[1]; // Add index
r_temp.offset *= 2; // variables are 16 bit
r_temp.incOffset(opparams[1]); // Add index
r_temp.setOffset(r_temp.getOffset() * 2); // variables are 16 bit
// That's the immediate address now
s->r_acc = r_temp;
break;
@ -1129,28 +1128,28 @@ void run_vm(EngineState *s) {
case op_lofsa: // 0x39 (57)
case op_lofss: // 0x3a (58)
// Load offset to accumulator or push to stack
r_temp.segment = s->xs->addr.pc.segment;
r_temp.setSegment(s->xs->addr.pc.getSegment());
switch (g_sci->_features->detectLofsType()) {
case SCI_VERSION_0_EARLY:
r_temp.offset = s->xs->addr.pc.offset + opparams[0];
r_temp.setOffset(s->xs->addr.pc.getOffset() + opparams[0]);
break;
case SCI_VERSION_1_MIDDLE:
r_temp.offset = opparams[0];
r_temp.setOffset(opparams[0]);
break;
case SCI_VERSION_1_1:
r_temp.offset = opparams[0] + local_script->getScriptSize();
r_temp.setOffset(opparams[0] + local_script->getScriptSize());
break;
case SCI_VERSION_3:
// In theory this can break if the variant with a one-byte argument is
// used. For now, assume it doesn't happen.
r_temp.offset = local_script->relocateOffsetSci3(s->xs->addr.pc.offset-2);
r_temp.setOffset(local_script->relocateOffsetSci3(s->xs->addr.pc.getOffset() - 2));
break;
default:
error("Unknown lofs type");
}
if (r_temp.offset >= scr->getBufSize())
if (r_temp.getOffset() >= scr->getBufSize())
error("VM: lofsa/lofss operation overflowed: %04x:%04x beyond end"
" of script (at %04x)", PRINT_REG(r_temp), scr->getBufSize());

2
engines/sci/engine/vm.h
View file

@ -116,7 +116,7 @@ struct ExecStack {
if (localsSegment_ != 0xFFFF)
local_segment = localsSegment_;
else
local_segment = pc_.segment;
local_segment = pc_.getSegment();
debugSelector = debugSelector_;
debugExportId = debugExportId_;
debugLocalCallOffset = debugLocalCallOffset_;

14
engines/sci/engine/vm_types.cpp
View file

@ -43,17 +43,17 @@ reg_t reg_t::lookForWorkaround(const reg_t right) const {
reg_t reg_t::operator+(const reg_t right) const {
if (isPointer() && right.isNumber()) {
// Pointer arithmetics. Only some pointer types make sense here
SegmentObj *mobj = g_sci->getEngineState()->_segMan->getSegmentObj(segment);
SegmentObj *mobj = g_sci->getEngineState()->_segMan->getSegmentObj(getSegment());
if (!mobj)
error("[VM]: Attempt to add %d to invalid pointer %04x:%04x", right.offset, PRINT_REG(*this));
error("[VM]: Attempt to add %d to invalid pointer %04x:%04x", right.getOffset(), PRINT_REG(*this));
switch (mobj->getType()) {
case SEG_TYPE_LOCALS:
case SEG_TYPE_SCRIPT:
case SEG_TYPE_STACK:
case SEG_TYPE_DYNMEM:
return make_reg(segment, offset + right.toSint16());
return make_reg(getSegment(), getOffset() + right.toSint16());
default:
return lookForWorkaround(right);
}
@ -69,12 +69,12 @@ reg_t reg_t::operator+(const reg_t right) const {
}
reg_t reg_t::operator-(const reg_t right) const {
if (segment == right.segment) {
if (getSegment() == right.getSegment()) {
// We can subtract numbers, or pointers with the same segment,
// an operation which will yield a number like in C
return make_reg(0, toSint16() - right.toSint16());
} else {
return *this + make_reg(right.segment, -right.offset);
return *this + make_reg(right.getSegment(), -right.toSint16());
}
}
@ -174,7 +174,7 @@ reg_t reg_t::operator^(const reg_t right) const {
}
int reg_t::cmp(const reg_t right, bool treatAsUnsigned) const {
if (segment == right.segment) { // can compare things in the same segment
if (getSegment() == right.getSegment()) { // can compare things in the same segment
if (treatAsUnsigned || !isNumber())
return toUint16() - right.toUint16();
else
@ -218,7 +218,7 @@ bool reg_t::pointerComparisonWithInteger(const reg_t right) const {
// SQ1, room 28, when throwing water at the Orat
// SQ1, room 58, when giving the ID card to the robot
// SQ4 CD, at the first game screen, when the narrator is about to speak
return (isPointer() && right.isNumber() && right.offset <= 2000 && getSciVersion() <= SCI_VERSION_1_1);
return (isPointer() && right.isNumber() && right.getOffset() <= 2000 && getSciVersion() <= SCI_VERSION_1_1);
}
} // End of namespace Sci

47
engines/sci/engine/vm_types.h
View file

@ -31,43 +31,64 @@ namespace Sci {
typedef uint16 SegmentId;
struct reg_t {
SegmentId segment;
uint16 offset;
// Segment and offset. These should never be accessed directly
SegmentId _segment;
uint16 _offset;
inline SegmentId getSegment() const {
return _segment;
}
inline void setSegment(SegmentId segment) {
_segment = segment;
}
inline uint16 getOffset() const {
return _offset;
}
inline void setOffset(uint16 offset) {
_offset = offset;
}
inline void incOffset(int16 offset) {
setOffset(getOffset() + offset);
}
inline bool isNull() const {
return (offset | segment) == 0;
return (_offset | getSegment()) == 0;
}
inline uint16 toUint16() const {
return offset;
return _offset;
}
inline int16 toSint16() const {
return (int16)offset;
return (int16)_offset;
}
bool isNumber() const {
return segment == 0;
return getSegment() == 0;
}
bool isPointer() const {
return segment != 0 && segment != 0xFFFF;
return getSegment() != 0 && getSegment() != 0xFFFF;
}
uint16 requireUint16() const;
int16 requireSint16() const;
inline bool isInitialized() const {
return segment != 0xFFFF;
return getSegment() != 0xFFFF;
}
// Comparison operators
bool operator==(const reg_t &x) const {
return (offset == x.offset) && (segment == x.segment);
return (getOffset() == x.getOffset()) && (getSegment() == x.getSegment());
}
bool operator!=(const reg_t &x) const {
return (offset != x.offset) || (segment != x.segment);
return (getOffset() != x.getOffset()) || (getSegment() != x.getSegment());
}
bool operator>(const reg_t right) const {
@ -141,12 +162,12 @@ private:
static inline reg_t make_reg(SegmentId segment, uint16 offset) {
reg_t r;
r.offset = offset;
r.segment = segment;
r.setSegment(segment);
r.setOffset(offset);
return r;
}
#define PRINT_REG(r) (0xffff) & (unsigned) (r).segment, (unsigned) (r).offset
#define PRINT_REG(r) (0xffff) & (unsigned) (r).getSegment(), (unsigned) (r).getOffset()
// Stack pointer type
typedef reg_t *StackPtr;

2
engines/sci/graphics/animate.cpp
View file

@ -723,7 +723,7 @@ void GfxAnimate::printAnimateList(Console *con) {
const AnimateList::iterator end = _list.end();
for (it = _list.begin(); it != end; ++it) {
Script *scr = _s->_segMan->getScriptIfLoaded(it->object.segment);
Script *scr = _s->_segMan->getScriptIfLoaded(it->object.getSegment());
int16 scriptNo = scr ? scr->getScriptNumber() : -1;
con->DebugPrintf("%04x:%04x (%s), script %d, view %d (%d, %d), pal %d, "

8
engines/sci/graphics/menu.cpp
View file

@ -219,7 +219,7 @@ void GfxMenu::kernelAddEntry(Common::String title, Common::String content, reg_t
}
}
itemEntry->textVmPtr = contentVmPtr;
itemEntry->textVmPtr.offset += beginPos;
itemEntry->textVmPtr.incOffset(beginPos);
if (rightAlignedPos) {
rightAlignedPos++;
@ -297,13 +297,13 @@ void GfxMenu::kernelSetAttribute(uint16 menuId, uint16 itemId, uint16 attributeI
// We assume here that no script ever creates a separatorLine dynamically
break;
case SCI_MENU_ATTRIBUTE_KEYPRESS:
itemEntry->keyPress = tolower(value.offset);
itemEntry->keyPress = tolower(value.getOffset());
itemEntry->keyModifier = 0;
// TODO: Find out how modifier is handled
debug("setAttr keypress %X %X", value.segment, value.offset);
debug("setAttr keypress %X %X", value.getSegment(), value.getOffset());
break;
case SCI_MENU_ATTRIBUTE_TAG:
itemEntry->tag = value.offset;
itemEntry->tag = value.getOffset();
break;
default:
// Happens when loading a game in LSL3 - attribute 1A

10
engines/sci/graphics/paint16.cpp
View file

@ -491,10 +491,10 @@ reg_t GfxPaint16::kernelDisplay(const char *text, int argc, reg_t *argv) {
// processing codes in argv
while (argc > 0) {
displayArg = argv[0];
if (displayArg.segment)
displayArg.offset = 0xFFFF;
if (displayArg.getSegment())
displayArg.setOffset(0xFFFF);
argc--; argv++;
switch (displayArg.offset) {
switch (displayArg.getOffset()) {
case SCI_DISPLAY_MOVEPEN:
_ports->moveTo(argv[0].toUint16(), argv[1].toUint16());
argc -= 2; argv += 2;
@ -547,9 +547,9 @@ reg_t GfxPaint16::kernelDisplay(const char *text, int argc, reg_t *argv) {
if (!(g_sci->getGameId() == GID_LONGBOW && g_sci->isDemo()) &&
!(g_sci->getGameId() == GID_QFG1 && g_sci->isDemo()) &&
!(g_sci->getGameId() == GID_PQ2))
error("Unknown kDisplay argument %d", displayArg.offset);
error("Unknown kDisplay argument %d", displayArg.getOffset());
if (displayArg.offset == SCI_DISPLAY_DUMMY2) {
if (displayArg.getOffset() == SCI_DISPLAY_DUMMY2) {
if (!argc)
error("No parameter left for kDisplay(115)");
argc--; argv++;

2
engines/sci/resource.cpp
View file

@ -2590,7 +2590,7 @@ Common::String ResourceManager::findSierraGameId() {
if (!heap)
return "";
int16 gameObjectOffset = findGameObject(false).offset;
int16 gameObjectOffset = findGameObject(false).getOffset();
if (!gameObjectOffset)
return "";

10
engines/sci/sci.cpp
View file

@ -453,8 +453,8 @@ static byte patchGameRestoreSaveSci21[] = {
};
static void patchGameSaveRestoreCode(SegManager *segMan, reg_t methodAddress, byte id) {
Script *script = segMan->getScript(methodAddress.segment);
byte *patchPtr = const_cast<byte *>(script->getBuf(methodAddress.offset));
Script *script = segMan->getScript(methodAddress.getSegment());
byte *patchPtr = const_cast<byte *>(script->getBuf(methodAddress.getOffset()));
if (getSciVersion() <= SCI_VERSION_1_1)
memcpy(patchPtr, patchGameRestoreSave, sizeof(patchGameRestoreSave));
else // SCI2+
@ -463,8 +463,8 @@ static void patchGameSaveRestoreCode(SegManager *segMan, reg_t methodAddress, by
}
static void patchGameSaveRestoreCodeSci21(SegManager *segMan, reg_t methodAddress, byte id, bool doRestore) {
Script *script = segMan->getScript(methodAddress.segment);
byte *patchPtr = const_cast<byte *>(script->getBuf(methodAddress.offset));
Script *script = segMan->getScript(methodAddress.getSegment());
byte *patchPtr = const_cast<byte *>(script->getBuf(methodAddress.getOffset()));
memcpy(patchPtr, patchGameRestoreSaveSci21, sizeof(patchGameRestoreSaveSci21));
if (doRestore)
patchPtr[2] = 0x78; // push1
@ -740,7 +740,7 @@ GUI::Debugger *SciEngine::getDebugger() {
if (_gamestate) {
ExecStack *xs = &(_gamestate->_executionStack.back());
if (xs) {
xs->addr.pc.offset = _debugState.old_pc_offset;
xs->addr.pc.setOffset(_debugState.old_pc_offset);
xs->sp = _debugState.old_sp;
}
}

6
engines/sci/sound/soundcmd.cpp
View file

@ -61,7 +61,7 @@ reg_t SoundCommandParser::kDoSoundInit(int argc, reg_t *argv, reg_t acc) {
}
int SoundCommandParser::getSoundResourceId(reg_t obj) {
int resourceId = obj.segment ? readSelectorValue(_segMan, obj, SELECTOR(number)) : -1;
int resourceId = obj.getSegment() ? readSelectorValue(_segMan, obj, SELECTOR(number)) : -1;
// Modify the resourceId for the Windows versions that have an alternate MIDI soundtrack, like SSCI did.
if (g_sci && g_sci->_features->useAltWinGMSound()) {
// Check if the alternate MIDI song actually exists...
@ -291,7 +291,7 @@ reg_t SoundCommandParser::kDoSoundPause(int argc, reg_t *argv, reg_t acc) {
reg_t obj = argv[0];
uint16 value = argc > 1 ? argv[1].toUint16() : 0;
if (!obj.segment) { // pause the whole playlist
if (!obj.getSegment()) { // pause the whole playlist
_music->pauseAll(value);
} else { // pause a playlist slot
MusicEntry *musicSlot = _music->getSlot(obj);
@ -369,7 +369,7 @@ reg_t SoundCommandParser::kDoSoundFade(int argc, reg_t *argv, reg_t acc) {
case 5: // SCI1+ (SCI1 late sound scheme), with fade and continue
musicSlot->fadeTo = CLIP<uint16>(argv[1].toUint16(), 0, MUSIC_VOLUME_MAX);
// sometimes we get objects in that position, fix it up (ffs. workarounds)
if (!argv[1].segment)
if (!argv[1].getSegment())
musicSlot->fadeStep = volume > musicSlot->fadeTo ? -argv[3].toUint16() : argv[3].toUint16();
else
musicSlot->fadeStep = volume > musicSlot->fadeTo ? -5 : 5;