[Scummvm-cvs-logs] SF.net SVN: scummvm:[44130] scummvm/trunk/engines/sci
fingolfin at users.sourceforge.net
fingolfin at users.sourceforge.net
Thu Sep 17 02:45:12 CEST 2009
Revision: 44130
http://scummvm.svn.sourceforge.net/scummvm/?rev=44130&view=rev
Author: fingolfin
Date: 2009-09-17 00:45:12 +0000 (Thu, 17 Sep 2009)
Log Message:
-----------
SCI: Rename MemObject -> SegmentObj
Modified Paths:
--------------
scummvm/trunk/engines/sci/console.cpp
scummvm/trunk/engines/sci/engine/gc.cpp
scummvm/trunk/engines/sci/engine/kernel.cpp
scummvm/trunk/engines/sci/engine/klists.cpp
scummvm/trunk/engines/sci/engine/kmisc.cpp
scummvm/trunk/engines/sci/engine/kstring.cpp
scummvm/trunk/engines/sci/engine/memobj.cpp
scummvm/trunk/engines/sci/engine/memobj.h
scummvm/trunk/engines/sci/engine/savegame.cpp
scummvm/trunk/engines/sci/engine/scriptdebug.cpp
scummvm/trunk/engines/sci/engine/seg_manager.cpp
scummvm/trunk/engines/sci/engine/seg_manager.h
scummvm/trunk/engines/sci/engine/vm.cpp
Modified: scummvm/trunk/engines/sci/console.cpp
===================================================================
--- scummvm/trunk/engines/sci/console.cpp 2009-09-17 00:44:22 UTC (rev 44129)
+++ scummvm/trunk/engines/sci/console.cpp 2009-09-17 00:45:12 UTC (rev 44130)
@@ -1314,48 +1314,48 @@
DebugPrintf("Segment table:\n");
for (uint i = 0; i < _vm->_gamestate->segMan->_heap.size(); i++) {
- MemObject *mobj = _vm->_gamestate->segMan->_heap[i];
+ SegmentObj *mobj = _vm->_gamestate->segMan->_heap[i];
if (mobj && mobj->getType()) {
DebugPrintf(" [%04x] ", i);
switch (mobj->getType()) {
- case MEM_OBJ_SCRIPT:
+ case SEG_TYPE_SCRIPT:
DebugPrintf("S script.%03d l:%d ", (*(Script *)mobj)._nr, (*(Script *)mobj).getLockers());
break;
- case MEM_OBJ_CLONES:
+ case SEG_TYPE_CLONES:
DebugPrintf("C clones (%d allocd)", (*(CloneTable *)mobj).entries_used);
break;
- case MEM_OBJ_LOCALS:
+ case SEG_TYPE_LOCALS:
DebugPrintf("V locals %03d", (*(LocalVariables *)mobj).script_id);
break;
- case MEM_OBJ_STACK:
+ case SEG_TYPE_STACK:
DebugPrintf("D data stack (%d)", (*(DataStack *)mobj).nr);
break;
- case MEM_OBJ_SYS_STRINGS:
+ case SEG_TYPE_SYS_STRINGS:
DebugPrintf("Y system string table");
break;
- case MEM_OBJ_LISTS:
+ case SEG_TYPE_LISTS:
DebugPrintf("L lists (%d)", (*(ListTable *)mobj).entries_used);
break;
- case MEM_OBJ_NODES:
+ case SEG_TYPE_NODES:
DebugPrintf("N nodes (%d)", (*(NodeTable *)mobj).entries_used);
break;
- case MEM_OBJ_HUNK:
+ case SEG_TYPE_HUNK:
DebugPrintf("H hunk (%d)", (*(HunkTable *)mobj).entries_used);
break;
- case MEM_OBJ_DYNMEM:
+ case SEG_TYPE_DYNMEM:
DebugPrintf("M dynmem: %d bytes", (*(DynMem *)mobj)._size);
break;
- case MEM_OBJ_STRING_FRAG:
+ case SEG_TYPE_STRING_FRAG:
DebugPrintf("F string fragments");
break;
@@ -1378,11 +1378,11 @@
if ((nr < 0) || ((uint)nr >= _vm->_gamestate->segMan->_heap.size()) || !_vm->_gamestate->segMan->_heap[nr])
return false;
- MemObject *mobj = _vm->_gamestate->segMan->_heap[nr];
+ SegmentObj *mobj = _vm->_gamestate->segMan->_heap[nr];
switch (mobj->getType()) {
- case MEM_OBJ_SCRIPT: {
+ case SEG_TYPE_SCRIPT: {
Script *scr = (Script *)mobj;
DebugPrintf("script.%03d locked by %d, bufsize=%d (%x)\n", scr->_nr, scr->getLockers(), (uint)scr->_bufSize, (uint)scr->_bufSize);
if (scr->_exportTable)
@@ -1410,21 +1410,21 @@
}
break;
- case MEM_OBJ_LOCALS: {
+ case SEG_TYPE_LOCALS: {
LocalVariables *locals = (LocalVariables *)mobj;
DebugPrintf("locals for script.%03d\n", locals->script_id);
DebugPrintf(" %d (0x%x) locals\n", locals->_locals.size(), locals->_locals.size());
}
break;
- case MEM_OBJ_STACK: {
+ case SEG_TYPE_STACK: {
DataStack *stack = (DataStack *)mobj;
DebugPrintf("stack\n");
DebugPrintf(" %d (0x%x) entries\n", stack->nr, stack->nr);
}
break;
- case MEM_OBJ_SYS_STRINGS: {
+ case SEG_TYPE_SYS_STRINGS: {
DebugPrintf("system string table - viewing currently disabled\n");
#if 0
SystemStrings *strings = &(mobj->data.sys_strings);
@@ -1436,7 +1436,7 @@
}
break;
- case MEM_OBJ_CLONES: {
+ case SEG_TYPE_CLONES: {
CloneTable *ct = (CloneTable *)mobj;
DebugPrintf("clones\n");
@@ -1457,7 +1457,7 @@
}
break;
- case MEM_OBJ_LISTS: {
+ case SEG_TYPE_LISTS: {
ListTable *lt = (ListTable *)mobj;
DebugPrintf("lists\n");
@@ -1469,12 +1469,12 @@
}
break;
- case MEM_OBJ_NODES: {
+ case SEG_TYPE_NODES: {
DebugPrintf("nodes (total %d)\n", (*(NodeTable *)mobj).entries_used);
break;
}
- case MEM_OBJ_HUNK: {
+ case SEG_TYPE_HUNK: {
HunkTable *ht = (HunkTable *)mobj;
DebugPrintf("hunk (total %d)\n", ht->entries_used);
@@ -1486,7 +1486,7 @@
}
break;
- case MEM_OBJ_DYNMEM: {
+ case SEG_TYPE_DYNMEM: {
DebugPrintf("dynmem (%s): %d bytes\n",
(*(DynMem *)mobj)._description.c_str(), (*(DynMem *)mobj)._size);
@@ -1494,7 +1494,7 @@
}
break;
- case MEM_OBJ_STRING_FRAG: {
+ case SEG_TYPE_STRING_FRAG: {
DebugPrintf("string frags\n");
break;
}
@@ -1642,7 +1642,7 @@
return true;
}
- MemObject *mobj = _vm->_gamestate->segMan->getMemObject(addr.segment);
+ SegmentObj *mobj = _vm->_gamestate->segMan->getSegmentObj(addr.segment);
if (!mobj) {
DebugPrintf("Unknown segment : %x\n", addr.segment);
return 1;
@@ -1671,7 +1671,7 @@
return true;
}
- MemObject *mobj = _vm->_gamestate->segMan->getMemObject(addr.segment);
+ SegmentObj *mobj = _vm->_gamestate->segMan->getSegmentObj(addr.segment);
if (!mobj) {
DebugPrintf("Unknown segment : %x\n", addr.segment);
return true;
@@ -1701,7 +1701,7 @@
return true;
}
- MemObject *mobj = _vm->_gamestate->segMan->getMemObject(addr.segment);
+ SegmentObj *mobj = _vm->_gamestate->segMan->getSegmentObj(addr.segment);
if (!mobj) {
DebugPrintf("Unknown segment : %x\n", addr.segment);
return true;
@@ -2881,14 +2881,14 @@
// Now all values are available; iterate over all objects.
for (i = 0; i < s->segMan->_heap.size(); i++) {
- MemObject *mobj = s->segMan->_heap[i];
+ SegmentObj *mobj = s->segMan->_heap[i];
int idx = 0;
int max_index = 0;
if (mobj) {
- if (mobj->getType() == MEM_OBJ_SCRIPT)
+ if (mobj->getType() == SEG_TYPE_SCRIPT)
max_index = (*(Script *)mobj)._objects.size();
- else if (mobj->getType() == MEM_OBJ_CLONES)
+ else if (mobj->getType() == SEG_TYPE_CLONES)
max_index = (*(CloneTable *)mobj)._table.size();
}
@@ -2899,10 +2899,10 @@
objpos.offset = 0;
objpos.segment = i;
- if (mobj->getType() == MEM_OBJ_SCRIPT) {
+ if (mobj->getType() == SEG_TYPE_SCRIPT) {
obj = &(*(Script *)mobj)._objects[idx];
objpos.offset = obj->pos.offset;
- } else if (mobj->getType() == MEM_OBJ_CLONES) {
+ } else if (mobj->getType() == SEG_TYPE_CLONES) {
obj = &((*(CloneTable *)mobj)._table[idx]);
objpos.offset = idx;
valid = ((CloneTable *)mobj)->isValidEntry(idx);
@@ -2983,7 +2983,7 @@
while (!pos.isNull()) {
Node *node;
- NodeTable *nt = (NodeTable *)GET_SEGMENT(*_vm->_gamestate->segMan, pos.segment, MEM_OBJ_NODES);
+ NodeTable *nt = (NodeTable *)GET_SEGMENT(*_vm->_gamestate->segMan, pos.segment, SEG_TYPE_NODES);
if (!nt || !nt->isValidEntry(pos.offset)) {
DebugPrintf(" WARNING: %04x:%04x: Doesn't contain list node!\n",
@@ -3010,7 +3010,7 @@
}
int Console::printNode(reg_t addr) {
- MemObject *mobj = GET_SEGMENT(*_vm->_gamestate->segMan, addr.segment, MEM_OBJ_LISTS);
+ SegmentObj *mobj = GET_SEGMENT(*_vm->_gamestate->segMan, addr.segment, SEG_TYPE_LISTS);
if (mobj) {
ListTable *lt = (ListTable *)mobj;
@@ -3027,7 +3027,7 @@
} else {
NodeTable *nt;
Node *node;
- mobj = GET_SEGMENT(*_vm->_gamestate->segMan, addr.segment, MEM_OBJ_NODES);
+ mobj = GET_SEGMENT(*_vm->_gamestate->segMan, addr.segment, SEG_TYPE_NODES);
if (!mobj) {
DebugPrintf("Segment #%04x is not a list or node segment\n", addr.segment);
@@ -3089,7 +3089,7 @@
reg_t fptr = VM_OBJECT_READ_FUNCTION(obj, i);
DebugPrintf(" [%03x] %s = %04x:%04x\n", VM_OBJECT_GET_FUNCSELECTOR(obj, i), selector_name(s, VM_OBJECT_GET_FUNCSELECTOR(obj, i)), PRINT_REG(fptr));
}
- if (s->segMan->_heap[pos.segment]->getType() == MEM_OBJ_SCRIPT)
+ if (s->segMan->_heap[pos.segment]->getType() == SEG_TYPE_SCRIPT)
DebugPrintf("\nOwner script:\t%d\n", s->segMan->getScript(pos.segment)->_nr);
return 0;
Modified: scummvm/trunk/engines/sci/engine/gc.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/gc.cpp 2009-09-17 00:44:22 UTC (rev 44129)
+++ scummvm/trunk/engines/sci/engine/gc.cpp 2009-09-17 00:45:12 UTC (rev 44130)
@@ -53,7 +53,7 @@
for (reg_t_hash_map::iterator i = nonnormal_map.begin(); i != nonnormal_map.end(); ++i) {
reg_t reg = i->_key;
- MemObject *mobj = (reg.segment < segMan->_heap.size()) ? segMan->_heap[reg.segment] : NULL;
+ SegmentObj *mobj = (reg.segment < segMan->_heap.size()) ? segMan->_heap[reg.segment] : NULL;
if (mobj) {
reg = mobj->findCanonicAddress(segMan, reg);
@@ -111,7 +111,7 @@
// Init: Explicitly loaded scripts
for (i = 1; i < segMan->_heap.size(); i++)
if (segMan->_heap[i]
- && segMan->_heap[i]->getType() == MEM_OBJ_SCRIPT) {
+ && segMan->_heap[i]->getType() == SEG_TYPE_SCRIPT) {
Script *script = (Script *)segMan->_heap[i];
if (script->getLockers()) { // Explicitly loaded?
@@ -146,10 +146,10 @@
struct deallocator_t {
SegManager *segMan;
- MemObject *mobj;
+ SegmentObj *mobj;
#ifdef DEBUG_GC
- char *segnames[MEM_OBJ_MAX + 1];
- int segcount[MEM_OBJ_MAX + 1];
+ char *segnames[SEG_TYPE_MAX + 1];
+ int segcount[SEG_TYPE_MAX + 1];
#endif
reg_t_hash_map *use_map;
};
@@ -176,7 +176,7 @@
#ifdef DEBUG_GC
debugC(2, kDebugLevelGC, "[GC] Running...\n");
- memset(&(deallocator.segcount), 0, sizeof(int) * (MEM_OBJ_MAX + 1));
+ memset(&(deallocator.segcount), 0, sizeof(int) * (SEG_TYPE_MAX + 1));
#endif
deallocator.segMan = segMan;
@@ -198,7 +198,7 @@
{
int i;
debugC(2, kDebugLevelGC, "[GC] Summary:\n");
- for (i = 0; i <= MEM_OBJ_MAX; i++)
+ for (i = 0; i <= SEG_TYPE_MAX; i++)
if (deallocator.segcount[i])
debugC(2, kDebugLevelGC, "\t%d\t* %s\n", deallocator.segcount[i], deallocator.segnames[i]);
}
Modified: scummvm/trunk/engines/sci/engine/kernel.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/kernel.cpp 2009-09-17 00:44:22 UTC (rev 44129)
+++ scummvm/trunk/engines/sci/engine/kernel.cpp 2009-09-17 00:45:12 UTC (rev 44130)
@@ -467,7 +467,7 @@
// Returns a pointer to the memory indicated by the specified handle
byte *kmem(SegManager *segMan, reg_t handle) {
- HunkTable *ht = (HunkTable *)GET_SEGMENT(*segMan, handle.segment, MEM_OBJ_HUNK);
+ HunkTable *ht = (HunkTable *)GET_SEGMENT(*segMan, handle.segment, SEG_TYPE_HUNK);
if (!ht || !ht->isValidEntry(handle.offset)) {
warning("Error: kmem() with invalid handle");
@@ -621,7 +621,7 @@
}
int determine_reg_type(SegManager *segMan, reg_t reg, bool allow_invalid) {
- MemObject *mobj;
+ SegmentObj *mobj;
int type = 0;
if (!reg.segment) {
@@ -632,14 +632,14 @@
return type;
}
- mobj = segMan->getMemObject(reg.segment);
+ mobj = segMan->getSegmentObj(reg.segment);
if (!mobj)
return 0; // Invalid
SciVersion version = segMan->sciVersion(); // for the offset defines
switch (mobj->getType()) {
- case MEM_OBJ_SCRIPT:
+ case SEG_TYPE_SCRIPT:
if (reg.offset <= (*(Script *)mobj)._bufSize && reg.offset >= -SCRIPT_OBJECT_MAGIC_OFFSET
&& RAW_IS_OBJECT((*(Script *)mobj)._buf + reg.offset)) {
Object *obj = ((Script *)mobj)->getObject(reg.offset);
@@ -650,22 +650,22 @@
} else
return KSIG_REF;
- case MEM_OBJ_CLONES:
+ case SEG_TYPE_CLONES:
type = KSIG_OBJECT;
break;
- case MEM_OBJ_LOCALS:
- case MEM_OBJ_STACK:
- case MEM_OBJ_SYS_STRINGS:
- case MEM_OBJ_DYNMEM:
+ case SEG_TYPE_LOCALS:
+ case SEG_TYPE_STACK:
+ case SEG_TYPE_SYS_STRINGS:
+ case SEG_TYPE_DYNMEM:
type = KSIG_REF;
break;
- case MEM_OBJ_LISTS:
+ case SEG_TYPE_LISTS:
type = KSIG_LIST;
break;
- case MEM_OBJ_NODES:
+ case SEG_TYPE_NODES:
type = KSIG_NODE;
break;
Modified: scummvm/trunk/engines/sci/engine/klists.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/klists.cpp 2009-09-17 00:44:22 UTC (rev 44129)
+++ scummvm/trunk/engines/sci/engine/klists.cpp 2009-09-17 00:45:12 UTC (rev 44130)
@@ -32,7 +32,7 @@
if (!addr.offset && !addr.segment)
return NULL; // Non-error null
- MemObject *mobj = GET_SEGMENT(*s->segMan, addr.segment, MEM_OBJ_NODES);
+ SegmentObj *mobj = GET_SEGMENT(*s->segMan, addr.segment, SEG_TYPE_NODES);
if (!mobj) {
// FIXME: This occurs right at the beginning of SQ4, when walking north from the first screen. It doesn't
// seem to have any apparent ill-effects, though, so it's been changed to non-fatal, for now
@@ -52,7 +52,7 @@
}
List *lookup_list(EngineState *s, reg_t addr) {
- MemObject *mobj = GET_SEGMENT(*s->segMan, addr.segment, MEM_OBJ_LISTS);
+ SegmentObj *mobj = GET_SEGMENT(*s->segMan, addr.segment, SEG_TYPE_LISTS);
if (!mobj) {
error("Attempt to use non-list %04x:%04x as list", PRINT_REG(addr));
Modified: scummvm/trunk/engines/sci/engine/kmisc.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/kmisc.cpp 2009-09-17 00:44:22 UTC (rev 44129)
+++ scummvm/trunk/engines/sci/engine/kmisc.cpp 2009-09-17 00:45:12 UTC (rev 44130)
@@ -204,7 +204,7 @@
warning("Attempt to peek invalid memory at %04x:%04x", PRINT_REG(argv[1]));
return s->r_acc;
}
- if (s->segMan->getMemObjectType(argv[1].segment) == MEM_OBJ_LOCALS)
+ if (s->segMan->getSegmentType(argv[1].segment) == SEG_TYPE_LOCALS)
return *((reg_t *) ref);
else
return make_reg(0, (int16)READ_LE_UINT16(ref));
@@ -218,7 +218,7 @@
return s->r_acc;
}
- if (s->segMan->getMemObjectType(argv[1].segment) == MEM_OBJ_LOCALS)
+ if (s->segMan->getSegmentType(argv[1].segment) == SEG_TYPE_LOCALS)
*((reg_t *) ref) = argv[2];
else {
if (argv[2].segment) {
Modified: scummvm/trunk/engines/sci/engine/kstring.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/kstring.cpp 2009-09-17 00:44:22 UTC (rev 44129)
+++ scummvm/trunk/engines/sci/engine/kstring.cpp 2009-09-17 00:45:12 UTC (rev 44130)
@@ -308,7 +308,7 @@
if (length >= 0)
strncpy(dest, src, length);
else {
- if (s->segMan->_heap[argv[0].segment]->getType() == MEM_OBJ_DYNMEM) {
+ if (s->segMan->_heap[argv[0].segment]->getType() == SEG_TYPE_DYNMEM) {
reg_t *srcp = (reg_t *) src;
int i;
Modified: scummvm/trunk/engines/sci/engine/memobj.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/memobj.cpp 2009-09-17 00:44:22 UTC (rev 44129)
+++ scummvm/trunk/engines/sci/engine/memobj.cpp 2009-09-17 00:45:12 UTC (rev 44130)
@@ -38,41 +38,41 @@
//#define GC_DEBUG_VERBOSE // Debug garbage verbosely
-MemObject *MemObject::createMemObject(MemObjectType type) {
- MemObject *mem = 0;
+SegmentObj *SegmentObj::createSegmentObj(SegmentType type) {
+ SegmentObj *mem = 0;
switch (type) {
- case MEM_OBJ_SCRIPT:
+ case SEG_TYPE_SCRIPT:
mem = new Script();
break;
- case MEM_OBJ_CLONES:
+ case SEG_TYPE_CLONES:
mem = new CloneTable();
break;
- case MEM_OBJ_LOCALS:
+ case SEG_TYPE_LOCALS:
mem = new LocalVariables();
break;
- case MEM_OBJ_SYS_STRINGS:
+ case SEG_TYPE_SYS_STRINGS:
mem = new SystemStrings();
break;
- case MEM_OBJ_STACK:
+ case SEG_TYPE_STACK:
mem = new DataStack();
break;
- case MEM_OBJ_HUNK:
+ case SEG_TYPE_HUNK:
mem = new HunkTable();
break;
- case MEM_OBJ_STRING_FRAG:
+ case SEG_TYPE_STRING_FRAG:
mem = new StringFrag();
break;
- case MEM_OBJ_LISTS:
+ case SEG_TYPE_LISTS:
mem = new ListTable();
break;
- case MEM_OBJ_NODES:
+ case SEG_TYPE_NODES:
mem = new NodeTable();
break;
- case MEM_OBJ_DYNMEM:
+ case SEG_TYPE_DYNMEM:
mem = new DynMem();
break;
default:
- error("Unknown MemObject type %d", type);
+ error("Unknown SegmentObj type %d", type);
break;
}
@@ -229,7 +229,7 @@
// return (_buf[offset] | (_buf[offset+1]) << 8);
}
-byte *MemObject::dereference(reg_t pointer, int *size) {
+byte *SegmentObj::dereference(reg_t pointer, int *size) {
error("Error: Trying to dereference pointer %04x:%04x to inappropriate segment",
PRINT_REG(pointer));
return NULL;
Modified: scummvm/trunk/engines/sci/engine/memobj.h
===================================================================
--- scummvm/trunk/engines/sci/engine/memobj.h 2009-09-17 00:44:22 UTC (rev 44129)
+++ scummvm/trunk/engines/sci/engine/memobj.h 2009-09-17 00:45:12 UTC (rev 44130)
@@ -34,34 +34,34 @@
namespace Sci {
-enum MemObjectType {
- MEM_OBJ_INVALID = 0,
- MEM_OBJ_SCRIPT = 1,
- MEM_OBJ_CLONES = 2,
- MEM_OBJ_LOCALS = 3,
- MEM_OBJ_STACK = 4,
- MEM_OBJ_SYS_STRINGS = 5,
- MEM_OBJ_LISTS = 6,
- MEM_OBJ_NODES = 7,
- MEM_OBJ_HUNK = 8,
- MEM_OBJ_DYNMEM = 9,
- MEM_OBJ_STRING_FRAG = 10,
+enum SegmentType {
+ SEG_TYPE_INVALID = 0,
+ SEG_TYPE_SCRIPT = 1,
+ SEG_TYPE_CLONES = 2,
+ SEG_TYPE_LOCALS = 3,
+ SEG_TYPE_STACK = 4,
+ SEG_TYPE_SYS_STRINGS = 5,
+ SEG_TYPE_LISTS = 6,
+ SEG_TYPE_NODES = 7,
+ SEG_TYPE_HUNK = 8,
+ SEG_TYPE_DYNMEM = 9,
+ SEG_TYPE_STRING_FRAG = 10,
- MEM_OBJ_MAX // For sanity checking
+ SEG_TYPE_MAX // For sanity checking
};
-struct MemObject : public Common::Serializable {
- MemObjectType _type;
+struct SegmentObj : public Common::Serializable {
+ SegmentType _type;
typedef void (*NoteCallback)(void *param, reg_t addr); // FIXME: Bad choice of name
public:
- static MemObject *createMemObject(MemObjectType type);
+ static SegmentObj *createSegmentObj(SegmentType type);
public:
- virtual ~MemObject() {}
+ virtual ~SegmentObj() {}
- inline MemObjectType getType() const { return _type; }
+ inline SegmentType getType() const { return _type; }
/**
* Check whether the given offset into this memory object is valid,
@@ -112,7 +112,7 @@
// TODO: Implement the following class
-struct StringFrag : public MemObject {
+struct StringFrag : public SegmentObj {
virtual bool isValidOffset(uint16 offset) const { return false; }
virtual void saveLoadWithSerializer(Common::Serializer &ser);
@@ -135,7 +135,7 @@
reg_t *value;
};
-struct SystemStrings : public MemObject {
+struct SystemStrings : public SegmentObj {
SystemString strings[SYS_STRINGS_MAX];
public:
@@ -178,7 +178,7 @@
int type; /**< Same as ExecStack.type */
};
-struct LocalVariables : public MemObject {
+struct LocalVariables : public SegmentObj {
int script_id; /**< Script ID this local variable block belongs to */
Common::Array<reg_t> _locals;
@@ -237,7 +237,7 @@
-class Script : public MemObject {
+class Script : public SegmentObj {
public:
int _nr; /**< Script number */
byte *_buf; /**< Static data buffer, or NULL if not used */
@@ -427,7 +427,7 @@
};
/** Data stack */
-struct DataStack : MemObject {
+struct DataStack : SegmentObj {
int nr; /**< Number of stack entries */
reg_t *entries;
@@ -473,7 +473,7 @@
};
template<typename T>
-struct Table : public MemObject {
+struct Table : public SegmentObj {
typedef T value_type;
struct Entry : public T {
int next_free; /* Only used for free entries */
@@ -578,7 +578,7 @@
// Free-style memory
-struct DynMem : public MemObject {
+struct DynMem : public SegmentObj {
int _size;
Common::String _description;
byte *_buf;
Modified: scummvm/trunk/engines/sci/engine/savegame.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/savegame.cpp 2009-09-17 00:44:22 UTC (rev 44129)
+++ scummvm/trunk/engines/sci/engine/savegame.cpp 2009-09-17 00:45:12 UTC (rev 44130)
@@ -217,21 +217,21 @@
s.syncAsUint32LE(sync_heap_size);
_heap.resize(sync_heap_size);
for (uint i = 0; i < sync_heap_size; ++i) {
- MemObject *&mobj = _heap[i];
+ SegmentObj *&mobj = _heap[i];
// Sync the memobj type
- MemObjectType type = (s.isSaving() && mobj) ? mobj->getType() : MEM_OBJ_INVALID;
+ SegmentType type = (s.isSaving() && mobj) ? mobj->getType() : SEG_TYPE_INVALID;
s.syncAsUint32LE(type);
// If we were saving and mobj == 0, or if we are loading and this is an
// entry marked as empty -> skip to next
- if (type == MEM_OBJ_INVALID) {
+ if (type == SEG_TYPE_INVALID) {
mobj = 0;
continue;
}
if (s.isLoading()) {
- mobj = MemObject::createMemObject(type);
+ mobj = SegmentObj::createSegmentObj(type);
}
assert(mobj);
@@ -241,7 +241,7 @@
mobj->saveLoadWithSerializer(s);
// If we are loading a script, hook it up in the script->segment map.
- if (s.isLoading() && type == MEM_OBJ_SCRIPT) {
+ if (s.isLoading() && type == SEG_TYPE_SCRIPT) {
_scriptSegMap[((Script *)mobj)->_nr] = i;
}
}
@@ -525,7 +525,7 @@
// FIXME: This should probably be turned into an EngineState method
static void reconstruct_stack(EngineState *retval) {
- SegmentId stack_seg = retval->segMan->findSegmentByType(MEM_OBJ_STACK);
+ SegmentId stack_seg = retval->segMan->findSegmentByType(SEG_TYPE_STACK);
DataStack *stack = (DataStack *)(retval->segMan->_heap[stack_seg]);
retval->stack_segment = stack_seg;
@@ -553,14 +553,14 @@
// FIXME: The following should likely become a SegManager method
static void reconstruct_scripts(EngineState *s, SegManager *self) {
uint i, j;
- MemObject *mobj;
+ SegmentObj *mobj;
SciVersion version = self->sciVersion(); // for the selector defines
for (i = 0; i < self->_heap.size(); i++) {
if (self->_heap[i]) {
mobj = self->_heap[i];
switch (mobj->getType()) {
- case MEM_OBJ_SCRIPT: {
+ case SEG_TYPE_SCRIPT: {
Script *scr = (Script *)mobj;
// FIXME: Unify this code with script_instantiate_*
@@ -597,7 +597,7 @@
if (self->_heap[i]) {
mobj = self->_heap[i];
switch (mobj->getType()) {
- case MEM_OBJ_SCRIPT: {
+ case SEG_TYPE_SCRIPT: {
Script *scr = (Script *)mobj;
for (j = 0; j < scr->_objects.size(); j++) {
@@ -738,8 +738,8 @@
retval->game_obj = s->game_obj;
retval->script_000 = retval->segMan->getScript(retval->segMan->getScriptSegment(0, SCRIPT_GET_DONT_LOAD));
retval->gc_countdown = GC_INTERVAL - 1;
- retval->sys_strings_segment = retval->segMan->findSegmentByType(MEM_OBJ_SYS_STRINGS);
- retval->sys_strings = (SystemStrings *)GET_SEGMENT(*retval->segMan, retval->sys_strings_segment, MEM_OBJ_SYS_STRINGS);
+ retval->sys_strings_segment = retval->segMan->findSegmentByType(SEG_TYPE_SYS_STRINGS);
+ retval->sys_strings = (SystemStrings *)GET_SEGMENT(*retval->segMan, retval->sys_strings_segment, SEG_TYPE_SYS_STRINGS);
// Restore system strings
SystemString *str;
Modified: scummvm/trunk/engines/sci/engine/scriptdebug.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/scriptdebug.cpp 2009-09-17 00:44:22 UTC (rev 44129)
+++ scummvm/trunk/engines/sci/engine/scriptdebug.cpp 2009-09-17 00:45:12 UTC (rev 44130)
@@ -99,7 +99,7 @@
// 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, int print_bw_tag, int print_bytecode) {
- MemObject *mobj = GET_SEGMENT(*s->segMan, pos.segment, MEM_OBJ_SCRIPT);
+ SegmentObj *mobj = GET_SEGMENT(*s->segMan, pos.segment, SEG_TYPE_SCRIPT);
Script *script_entity = NULL;
byte *scr;
int scr_size;
@@ -360,7 +360,7 @@
#endif
if (scriptState.seeking && !bp) { // Are we looking for something special?
- MemObject *mobj = GET_SEGMENT(*s->segMan, scriptState.xs->addr.pc.segment, MEM_OBJ_SCRIPT);
+ SegmentObj *mobj = GET_SEGMENT(*s->segMan, scriptState.xs->addr.pc.segment, SEG_TYPE_SCRIPT);
if (mobj) {
Script *scr = (Script *)mobj;
Modified: scummvm/trunk/engines/sci/engine/seg_manager.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/seg_manager.cpp 2009-09-17 00:44:22 UTC (rev 44129)
+++ scummvm/trunk/engines/sci/engine/seg_manager.cpp 2009-09-17 00:45:12 UTC (rev 44130)
@@ -94,12 +94,12 @@
return seg;
}
-MemObject *SegManager::allocSegment(MemObjectType type, SegmentId *segid) {
+SegmentObj *SegManager::allocSegment(SegmentType type, SegmentId *segid) {
// Find a free segment
*segid = findFreeSegment();
// Now allocate an object of the appropriate type...
- MemObject *mem = MemObject::createMemObject(type);
+ SegmentObj *mem = SegmentObj::createSegmentObj(type);
if (!mem)
error("SegManager: invalid mobj");
@@ -121,8 +121,8 @@
return (Script *)_heap[*seg_id];
}
- // allocate the MemObject
- MemObject *mem = allocSegment(MEM_OBJ_SCRIPT, seg_id);
+ // allocate the SegmentObj
+ SegmentObj *mem = allocSegment(SEG_TYPE_SCRIPT, seg_id);
// Add the script to the "script id -> segment id" hashmap
_scriptSegMap[script_nr] = *seg_id;
@@ -167,12 +167,12 @@
}
int SegManager::deallocate(SegmentId seg, bool recursive) {
- MemObject *mobj;
+ SegmentObj *mobj;
VERIFY(check(seg), "invalid seg id");
mobj = _heap[seg];
- if (mobj->getType() == MEM_OBJ_SCRIPT) {
+ if (mobj->getType() == SEG_TYPE_SCRIPT) {
Script *scr = (Script *)mobj;
_scriptSegMap.erase(scr->_nr);
if (recursive && scr->_localsSegment)
@@ -207,14 +207,14 @@
if (!_heap[seg]) {
error("SegManager::getScript(): seg id %x is not in memory", seg);
}
- if (_heap[seg]->getType() != MEM_OBJ_SCRIPT) {
- error("SegManager::getScript(): seg id %x refers to type %d != MEM_OBJ_SCRIPT", seg, _heap[seg]->getType());
+ if (_heap[seg]->getType() != SEG_TYPE_SCRIPT) {
+ error("SegManager::getScript(): seg id %x refers to type %d != SEG_TYPE_SCRIPT", seg, _heap[seg]->getType());
}
return (Script *)_heap[seg];
}
Script *SegManager::getScriptIfLoaded(const SegmentId seg) {
- if (seg < 1 || (uint)seg >= _heap.size() || !_heap[seg] || _heap[seg]->getType() != MEM_OBJ_SCRIPT)
+ if (seg < 1 || (uint)seg >= _heap.size() || !_heap[seg] || _heap[seg]->getType() != SEG_TYPE_SCRIPT)
return 0;
return (Script *)_heap[seg];
}
@@ -226,29 +226,29 @@
return -1;
}
-MemObject *SegManager::getMemObject(SegmentId seg) {
+SegmentObj *SegManager::getSegmentObj(SegmentId seg) {
if (seg < 1 || (uint)seg >= _heap.size() || !_heap[seg])
return 0;
return _heap[seg];
}
-MemObjectType SegManager::getMemObjectType(SegmentId seg) {
+SegmentType SegManager::getSegmentType(SegmentId seg) {
if (seg < 1 || (uint)seg >= _heap.size() || !_heap[seg])
- return MEM_OBJ_INVALID;
+ return SEG_TYPE_INVALID;
return _heap[seg]->getType();
}
Object *SegManager::getObject(reg_t pos) {
- MemObject *mobj = getMemObject(pos.segment);
+ SegmentObj *mobj = getSegmentObj(pos.segment);
SciVersion version = _resMan->sciVersion();
Object *obj = NULL;
if (mobj != NULL) {
- if (mobj->getType() == MEM_OBJ_CLONES) {
+ if (mobj->getType() == SEG_TYPE_CLONES) {
CloneTable *ct = (CloneTable *)mobj;
if (ct->isValidEntry(pos.offset))
obj = &(ct->_table[pos.offset]);
- } else if (mobj->getType() == MEM_OBJ_SCRIPT) {
+ } else if (mobj->getType() == SEG_TYPE_SCRIPT) {
Script *scr = (Script *)mobj;
if (pos.offset <= scr->_bufSize && pos.offset >= -SCRIPT_OBJECT_MAGIC_OFFSET
&& RAW_IS_OBJECT(scr->_buf + pos.offset)) {
@@ -573,10 +573,10 @@
if (scr->_localsSegment) {
locals = (LocalVariables *)_heap[scr->_localsSegment];
VERIFY(locals != NULL, "Re-used locals segment was NULL'd out");
- VERIFY(locals->getType() == MEM_OBJ_LOCALS, "Re-used locals segment did not consist of local variables");
+ VERIFY(locals->getType() == SEG_TYPE_LOCALS, "Re-used locals segment did not consist of local variables");
VERIFY(locals->script_id == scr->_nr, "Re-used locals segment belonged to other script");
} else
- locals = (LocalVariables *)allocSegment(MEM_OBJ_LOCALS, &scr->_localsSegment);
+ locals = (LocalVariables *)allocSegment(SEG_TYPE_LOCALS, &scr->_localsSegment);
scr->_localsBlock = locals;
locals->script_id = scr->_nr;
@@ -709,7 +709,7 @@
*/
DataStack *SegManager::allocateStack(int size, SegmentId *segid) {
- MemObject *mobj = allocSegment(MEM_OBJ_STACK, segid);
+ SegmentObj *mobj = allocSegment(SEG_TYPE_STACK, segid);
DataStack *retval = (DataStack *)mobj;
retval->entries = (reg_t *)calloc(size, sizeof(reg_t));
@@ -719,13 +719,13 @@
}
SystemStrings *SegManager::allocateSysStrings(SegmentId *segid) {
- return (SystemStrings *)allocSegment(MEM_OBJ_SYS_STRINGS, segid);
+ return (SystemStrings *)allocSegment(SEG_TYPE_SYS_STRINGS, segid);
}
SegmentId SegManager::allocateStringFrags() {
SegmentId segid;
- allocSegment(MEM_OBJ_STRING_FRAG, &segid);
+ allocSegment(SEG_TYPE_STRING_FRAG, &segid);
return segid;
}
@@ -746,7 +746,7 @@
}
void SegManager::freeHunkEntry(reg_t addr) {
- HunkTable *ht = (HunkTable *)GET_SEGMENT(*this, addr.segment, MEM_OBJ_HUNK);
+ HunkTable *ht = (HunkTable *)GET_SEGMENT(*this, addr.segment, SEG_TYPE_HUNK);
if (!ht) {
warning("Attempt to free Hunk from address %04x:%04x: Invalid segment type", PRINT_REG(addr));
@@ -774,7 +774,7 @@
int offset;
if (!Clones_seg_id) {
- table = (CloneTable *)allocSegment(MEM_OBJ_CLONES, &(Clones_seg_id));
+ table = (CloneTable *)allocSegment(SEG_TYPE_CLONES, &(Clones_seg_id));
} else
table = (CloneTable *)_heap[Clones_seg_id];
@@ -789,8 +789,8 @@
for (uint i = 0; i < _heap.size(); i++) {
if (_heap[i]) {
- MemObject *mobj = _heap[i];
- if (mobj->getType() == MEM_OBJ_CLONES) {
+ SegmentObj *mobj = _heap[i];
+ if (mobj->getType() == SEG_TYPE_CLONES) {
CloneTable *ct = (CloneTable *)mobj;
for (uint j = 0; j < ct->_table.size(); j++) {
@@ -835,7 +835,7 @@
int offset;
if (!Lists_seg_id)
- allocSegment(MEM_OBJ_LISTS, &(Lists_seg_id));
+ allocSegment(SEG_TYPE_LISTS, &(Lists_seg_id));
table = (ListTable *)_heap[Lists_seg_id];
offset = table->allocEntry();
@@ -849,7 +849,7 @@
int offset;
if (!Nodes_seg_id)
- allocSegment(MEM_OBJ_NODES, &(Nodes_seg_id));
+ allocSegment(SEG_TYPE_NODES, &(Nodes_seg_id));
table = (NodeTable *)_heap[Nodes_seg_id];
offset = table->allocEntry();
@@ -863,7 +863,7 @@
int offset;
if (!Hunks_seg_id)
- allocSegment(MEM_OBJ_HUNK, &(Hunks_seg_id));
+ allocSegment(SEG_TYPE_HUNK, &(Hunks_seg_id));
table = (HunkTable *)_heap[Hunks_seg_id];
offset = table->allocEntry();
@@ -879,7 +879,7 @@
return NULL; /* Invalid */
}
- MemObject *mobj = _heap[pointer.segment];
+ SegmentObj *mobj = _heap[pointer.segment];
return mobj->dereference(pointer, size);
}
@@ -919,7 +919,7 @@
byte *SegManager::allocDynmem(int size, const char *descr, reg_t *addr) {
SegmentId seg;
- MemObject *mobj = allocSegment(MEM_OBJ_DYNMEM, &seg);
+ SegmentObj *mobj = allocSegment(SEG_TYPE_DYNMEM, &seg);
*addr = make_reg(seg, 0);
DynMem &d = *(DynMem *)mobj;
@@ -940,10 +940,10 @@
if (addr.segment < 1 || addr.segment >= _heap.size())
return "";
- MemObject *mobj = _heap[addr.segment];
+ SegmentObj *mobj = _heap[addr.segment];
switch (mobj->getType()) {
- case MEM_OBJ_DYNMEM:
+ case SEG_TYPE_DYNMEM:
return (*(DynMem *)mobj)._description.c_str();
default:
return "";
@@ -951,7 +951,7 @@
}
int SegManager::freeDynmem(reg_t addr) {
- if (addr.segment < 1 || addr.segment >= _heap.size() || !_heap[addr.segment] || _heap[addr.segment]->getType() != MEM_OBJ_DYNMEM)
+ if (addr.segment < 1 || addr.segment >= _heap.size() || !_heap[addr.segment] || _heap[addr.segment]->getType() != SEG_TYPE_DYNMEM)
return 1; // error
deallocate(addr.segment, true);
Modified: scummvm/trunk/engines/sci/engine/seg_manager.h
===================================================================
--- scummvm/trunk/engines/sci/engine/seg_manager.h 2009-09-17 00:44:22 UTC (rev 44129)
+++ scummvm/trunk/engines/sci/engine/seg_manager.h 2009-09-17 00:45:12 UTC (rev 44130)
@@ -33,7 +33,7 @@
namespace Sci {
-#define GET_SEGMENT(mgr, index, rtype) (((mgr).getMemObjectType(index) == (rtype))? (mgr)._heap[index] : NULL)
+#define GET_SEGMENT(mgr, index, rtype) (((mgr).getSegmentType(index) == (rtype))? (mgr)._heap[index] : NULL)
/**
* Parameters for getScriptSegment().
@@ -315,10 +315,10 @@
SegmentId findSegmentByType(int type);
// TODO: document this
- MemObject *getMemObject(SegmentId seg);
+ SegmentObj *getSegmentObj(SegmentId seg);
// TODO: document this
- MemObjectType getMemObjectType(SegmentId seg);
+ SegmentType getSegmentType(SegmentId seg);
/**
* Retrieves an object from the specified location
@@ -353,7 +353,7 @@
SciVersion sciVersion() { return _resMan->sciVersion(); }
public: // TODO: make private
- Common::Array<MemObject *> _heap;
+ Common::Array<SegmentObj *> _heap;
Common::Array<Class> _classtable; /**< Table of all classes */
private:
@@ -370,7 +370,7 @@
SegmentId Hunks_seg_id; ///< ID of the (a) hunk segment
private:
- MemObject *allocSegment(MemObjectType type, SegmentId *segid);
+ SegmentObj *allocSegment(SegmentType type, SegmentId *segid);
LocalVariables *allocLocalsSegment(Script *scr, int count);
int deallocate(SegmentId seg, bool recursive);
int createClassTable();
Modified: scummvm/trunk/engines/sci/engine/vm.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/vm.cpp 2009-09-17 00:44:22 UTC (rev 44129)
+++ scummvm/trunk/engines/sci/engine/vm.cpp 2009-09-17 00:45:12 UTC (rev 44130)
@@ -463,7 +463,7 @@
#endif
static reg_t pointer_add(EngineState *s, reg_t base, int offset) {
- MemObject *mobj = s->segMan->getMemObject(base.segment);
+ SegmentObj *mobj = s->segMan->getSegmentObj(base.segment);
if (!mobj) {
error("[VM] Error: Attempt to add %d to invalid pointer %04x:%04x", offset, PRINT_REG(base));
@@ -472,13 +472,13 @@
switch (mobj->getType()) {
- case MEM_OBJ_LOCALS:
+ case SEG_TYPE_LOCALS:
base.offset += 2 * offset;
return base;
- case MEM_OBJ_SCRIPT:
- case MEM_OBJ_STACK:
- case MEM_OBJ_DYNMEM:
+ case SEG_TYPE_SCRIPT:
+ case SEG_TYPE_STACK:
+ case SEG_TYPE_DYNMEM:
base.offset += offset;
return base;
break;
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
More information about the Scummvm-git-logs
mailing list