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

SCI: Cleanup

Browse source
This commit is contained in:
md5 2011-03-08 20:13:08 +02:00
parent fe89ffe80a
commit 12e7d3078b
3 changed files with 103 additions and 136 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -328,14 +328,14 @@ void Object::saveLoadWithSerializer(Common::Serializer &s) {
} }
template <> template <>
void syncWithSerializer(Common::Serializer &s, Table<Clone>::Entry &obj) { void syncWithSerializer(Common::Serializer &s, SegmentObjTable<Clone>::Entry &obj) {
s.syncAsSint32LE(obj.next_free); s.syncAsSint32LE(obj.next_free);
syncWithSerializer<Object>(s, obj); syncWithSerializer<Object>(s, obj);
} }
template <> template <>
void syncWithSerializer(Common::Serializer &s, Table<List>::Entry &obj) { void syncWithSerializer(Common::Serializer &s, SegmentObjTable<List>::Entry &obj) {
s.syncAsSint32LE(obj.next_free); s.syncAsSint32LE(obj.next_free);
syncWithSerializer(s, obj.first); syncWithSerializer(s, obj.first);
@ -343,7 +343,7 @@ void syncWithSerializer(Common::Serializer &s, Table<List>::Entry &obj) {
} }
template <> template <>
void syncWithSerializer(Common::Serializer &s, Table<Node>::Entry &obj) { void syncWithSerializer(Common::Serializer &s, SegmentObjTable<Node>::Entry &obj) {
s.syncAsSint32LE(obj.next_free); s.syncAsSint32LE(obj.next_free);
syncWithSerializer(s, obj.pred); syncWithSerializer(s, obj.pred);
@ -354,7 +354,7 @@ void syncWithSerializer(Common::Serializer &s, Table<Node>::Entry &obj) {
#ifdef ENABLE_SCI32 #ifdef ENABLE_SCI32
template <> template <>
void syncWithSerializer(Common::Serializer &s, Table<SciArray<reg_t> >::Entry &obj) { void syncWithSerializer(Common::Serializer &s, SegmentObjTable<SciArray<reg_t> >::Entry &obj) {
s.syncAsSint32LE(obj.next_free); s.syncAsSint32LE(obj.next_free);
byte type = 0; byte type = 0;
@ -390,7 +390,7 @@ void syncWithSerializer(Common::Serializer &s, Table<SciArray<reg_t> >::Entry &o
} }
template <> template <>
void syncWithSerializer(Common::Serializer &s, Table<SciString>::Entry &obj) { void syncWithSerializer(Common::Serializer &s, SegmentObjTable<SciString>::Entry &obj) {
s.syncAsSint32LE(obj.next_free); s.syncAsSint32LE(obj.next_free);
uint32 size = 0; uint32 size = 0;

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

@ -90,69 +90,6 @@ SegmentRef SegmentObj::dereference(reg_t pointer) {
return SegmentRef(); return SegmentRef();
} }
bool LocalVariables::isValidOffset(uint16 offset) const {
return offset < _locals.size() * 2;
}
SegmentRef LocalVariables::dereference(reg_t pointer) {
SegmentRef ret;
ret.isRaw = false; // reg_t based data!
ret.maxSize = (_locals.size() - pointer.offset / 2) * 2;
if (pointer.offset & 1) {
ret.maxSize -= 1;
ret.skipByte = true;
}
if (ret.maxSize > 0) {
ret.reg = &_locals[pointer.offset / 2];
} else {
if ((g_sci->getEngineState()->currentRoomNumber() == 660 || g_sci->getEngineState()->currentRoomNumber() == 660)
&& g_sci->getGameId() == GID_LAURABOW2) {
// Happens in two places during the intro of LB2CD, both from kMemory(peek):
// - room 160: Heap 160 has 83 local variables (0-82), and the game
// asks for variables at indices 83 - 90 too.
// - room 220: Heap 220 has 114 local variables (0-113), and the
// game asks for variables at indices 114-120 too.
} else {
error("LocalVariables::dereference: Offset at end or out of bounds %04x:%04x", PRINT_REG(pointer));
}
ret.reg = 0;
}
return ret;
}
bool DataStack::isValidOffset(uint16 offset) const {
return offset < _capacity * 2;
}
SegmentRef DataStack::dereference(reg_t pointer) {
SegmentRef ret;
ret.isRaw = false; // reg_t based data!
ret.maxSize = (_capacity - pointer.offset / 2) * 2;
if (pointer.offset & 1) {
ret.maxSize -= 1;
ret.skipByte = true;
}
ret.reg = &_entries[pointer.offset / 2];
return ret;
}
bool DynMem::isValidOffset(uint16 offset) const {
return offset < _size;
}
SegmentRef DynMem::dereference(reg_t pointer) {
SegmentRef ret;
ret.isRaw = true;
ret.maxSize = _size - pointer.offset;
ret.raw = _buf + pointer.offset;
return ret;
}
//-------------------- clones -------------------- //-------------------- clones --------------------
Common::Array<reg_t> CloneTable::listAllOutgoingReferences(reg_t addr) const { Common::Array<reg_t> CloneTable::listAllOutgoingReferences(reg_t addr) const {
@ -195,18 +132,44 @@ void CloneTable::freeAtAddress(SegManager *segMan, reg_t addr) {
//-------------------- locals -------------------- //-------------------- locals --------------------
SegmentRef LocalVariables::dereference(reg_t pointer) {
SegmentRef ret;
ret.isRaw = false; // reg_t based data!
ret.maxSize = (_locals.size() - pointer.offset / 2) * 2;
if (pointer.offset & 1) {
ret.maxSize -= 1;
ret.skipByte = true;
}
if (ret.maxSize > 0) {
ret.reg = &_locals[pointer.offset / 2];
} else {
if ((g_sci->getEngineState()->currentRoomNumber() == 660 || g_sci->getEngineState()->currentRoomNumber() == 660)
&& g_sci->getGameId() == GID_LAURABOW2) {
// Happens in two places during the intro of LB2CD, both from kMemory(peek):
// - room 160: Heap 160 has 83 local variables (0-82), and the game
// asks for variables at indices 83 - 90 too.
// - room 220: Heap 220 has 114 local variables (0-113), and the
// game asks for variables at indices 114-120 too.
} else {
error("LocalVariables::dereference: Offset at end or out of bounds %04x:%04x", PRINT_REG(pointer));
}
ret.reg = 0;
}
return ret;
}
reg_t LocalVariables::findCanonicAddress(SegManager *segMan, reg_t addr) const { reg_t LocalVariables::findCanonicAddress(SegManager *segMan, reg_t addr) const {
// Reference the owning script // Reference the owning script
SegmentId owner_seg = segMan->getScriptSegment(script_id); SegmentId owner_seg = segMan->getScriptSegment(script_id);
assert(owner_seg > 0); assert(owner_seg > 0);
return make_reg(owner_seg, 0); return make_reg(owner_seg, 0);
} }
Common::Array<reg_t> LocalVariables::listAllOutgoingReferences(reg_t addr) const { Common::Array<reg_t> LocalVariables::listAllOutgoingReferences(reg_t addr) const {
Common::Array<reg_t> tmp; Common::Array<reg_t> tmp;
for (uint i = 0; i < _locals.size(); i++) for (uint i = 0; i < _locals.size(); i++)
tmp.push_back(_locals[i]); tmp.push_back(_locals[i]);
@ -215,8 +178,19 @@ Common::Array<reg_t> LocalVariables::listAllOutgoingReferences(reg_t addr) const
//-------------------- stack -------------------- //-------------------- stack --------------------
reg_t DataStack::findCanonicAddress(SegManager *segMan, reg_t addr) const {
return make_reg(addr.segment, 0); SegmentRef DataStack::dereference(reg_t pointer) {
SegmentRef ret;
ret.isRaw = false; // reg_t based data!
ret.maxSize = (_capacity - pointer.offset / 2) * 2;
if (pointer.offset & 1) {
ret.maxSize -= 1;
ret.skipByte = true;
}
ret.reg = &_entries[pointer.offset / 2];
return ret;
} }
Common::Array<reg_t> DataStack::listAllOutgoingReferences(reg_t object) const { Common::Array<reg_t> DataStack::listAllOutgoingReferences(reg_t object) const {
@ -227,16 +201,7 @@ Common::Array<reg_t> DataStack::listAllOutgoingReferences(reg_t object) const {
return tmp; return tmp;
} }
//-------------------- hunk ---------------------
void HunkTable::freeAtAddress(SegManager *segMan, reg_t sub_addr) {
freeEntry(sub_addr.offset);
}
//-------------------- lists -------------------- //-------------------- lists --------------------
void ListTable::freeAtAddress(SegManager *segMan, reg_t sub_addr) {
freeEntry(sub_addr.offset);
}
Common::Array<reg_t> ListTable::listAllOutgoingReferences(reg_t addr) const { Common::Array<reg_t> ListTable::listAllOutgoingReferences(reg_t addr) const {
Common::Array<reg_t> tmp; Common::Array<reg_t> tmp;
@ -254,11 +219,7 @@ Common::Array<reg_t> ListTable::listAllOutgoingReferences(reg_t addr) const {
return tmp; return tmp;
} }
//-------------------- nodes -------------------- //-------------------- nodes --------------------
void NodeTable::freeAtAddress(SegManager *segMan, reg_t sub_addr) {
freeEntry(sub_addr.offset);
}
Common::Array<reg_t> NodeTable::listAllOutgoingReferences(reg_t addr) const { Common::Array<reg_t> NodeTable::listAllOutgoingReferences(reg_t addr) const {
Common::Array<reg_t> tmp; Common::Array<reg_t> tmp;
@ -279,13 +240,12 @@ Common::Array<reg_t> NodeTable::listAllOutgoingReferences(reg_t addr) const {
//-------------------- dynamic memory -------------------- //-------------------- dynamic memory --------------------
reg_t DynMem::findCanonicAddress(SegManager *segMan, reg_t addr) const { SegmentRef DynMem::dereference(reg_t pointer) {
return make_reg(addr.segment, 0); SegmentRef ret;
} ret.isRaw = true;
ret.maxSize = _size - pointer.offset;
Common::Array<reg_t> DynMem::listAllDeallocatable(SegmentId segId) const { ret.raw = _buf + pointer.offset;
const reg_t r = make_reg(segId, 0); return ret;
return Common::Array<reg_t>(&r, 1);
} }
#ifdef ENABLE_SCI32 #ifdef ENABLE_SCI32
@ -350,11 +310,6 @@ SegmentRef StringTable::dereference(reg_t pointer) {
return ret; return ret;
} }
void StringTable::freeAtAddress(SegManager *segMan, reg_t sub_addr) {
_table[sub_addr.offset].destroy();
freeEntry(sub_addr.offset);
}
#endif #endif
} // End of namespace Sci } // End of namespace Sci

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

@ -149,11 +149,11 @@ struct LocalVariables : public SegmentObj {
Common::Array<reg_t> _locals; Common::Array<reg_t> _locals;
public: public:
LocalVariables(): SegmentObj(SEG_TYPE_LOCALS) { LocalVariables(): SegmentObj(SEG_TYPE_LOCALS), script_id(0) { }
script_id = 0;
}
virtual bool isValidOffset(uint16 offset) const; virtual bool isValidOffset(uint16 offset) const {
return offset < _locals.size() * 2;
}
virtual SegmentRef dereference(reg_t pointer); virtual SegmentRef dereference(reg_t pointer);
virtual reg_t findCanonicAddress(SegManager *segMan, reg_t sub_addr) const; virtual reg_t findCanonicAddress(SegManager *segMan, reg_t sub_addr) const;
virtual Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const; virtual Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const;
@ -167,18 +167,19 @@ struct DataStack : SegmentObj {
reg_t *_entries; reg_t *_entries;
public: public:
DataStack() : SegmentObj(SEG_TYPE_STACK) { DataStack() : SegmentObj(SEG_TYPE_STACK), _capacity(0), _entries(NULL) { }
_capacity = 0;
_entries = NULL;
}
~DataStack() { ~DataStack() {
free(_entries); free(_entries);
_entries = NULL; _entries = NULL;
} }
virtual bool isValidOffset(uint16 offset) const; virtual bool isValidOffset(uint16 offset) const {
return offset < _capacity * 2;
}
virtual SegmentRef dereference(reg_t pointer); virtual SegmentRef dereference(reg_t pointer);
virtual reg_t findCanonicAddress(SegManager *segMan, reg_t sub_addr) const; virtual reg_t findCanonicAddress(SegManager *segMan, reg_t addr) const {
return make_reg(addr.segment, 0);
}
virtual Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const; virtual Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const;
virtual void saveLoadWithSerializer(Common::Serializer &ser); virtual void saveLoadWithSerializer(Common::Serializer &ser);
@ -210,7 +211,7 @@ struct Hunk {
}; };
template<typename T> template<typename T>
struct Table : public SegmentObj { struct SegmentObjTable : public SegmentObj {
typedef T value_type; typedef T value_type;
struct Entry : public T { struct Entry : public T {
int next_free; /* Only used for free entries */ int next_free; /* Only used for free entries */
@ -224,7 +225,7 @@ struct Table : public SegmentObj {
Common::Array<Entry> _table; Common::Array<Entry> _table;
public: public:
Table(SegmentType type) : SegmentObj(type) { SegmentObjTable(SegmentType type) : SegmentObj(type) {
initTable(); initTable();
} }
@ -278,8 +279,8 @@ public:
/* CloneTable */ /* CloneTable */
struct CloneTable : public Table<Clone> { struct CloneTable : public SegmentObjTable<Clone> {
CloneTable() : Table<Clone>(SEG_TYPE_CLONES) {} CloneTable() : SegmentObjTable<Clone>(SEG_TYPE_CLONES) {}
virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr); virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr);
virtual Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const; virtual Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const;
@ -289,10 +290,12 @@ struct CloneTable : public Table<Clone> {
/* NodeTable */ /* NodeTable */
struct NodeTable : public Table<Node> { struct NodeTable : public SegmentObjTable<Node> {
NodeTable() : Table<Node>(SEG_TYPE_NODES) {} NodeTable() : SegmentObjTable<Node>(SEG_TYPE_NODES) {}
virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr); virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr) {
freeEntry(sub_addr.offset);
}
virtual Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const; virtual Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const;
virtual void saveLoadWithSerializer(Common::Serializer &ser); virtual void saveLoadWithSerializer(Common::Serializer &ser);
@ -300,10 +303,12 @@ struct NodeTable : public Table<Node> {
/* ListTable */ /* ListTable */
struct ListTable : public Table<List> { struct ListTable : public SegmentObjTable<List> {
ListTable() : Table<List>(SEG_TYPE_LISTS) {} ListTable() : SegmentObjTable<List>(SEG_TYPE_LISTS) {}
virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr); virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr) {
freeEntry(sub_addr.offset);
}
virtual Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const; virtual Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const;
virtual void saveLoadWithSerializer(Common::Serializer &ser); virtual void saveLoadWithSerializer(Common::Serializer &ser);
@ -311,8 +316,8 @@ struct ListTable : public Table<List> {
/* HunkTable */ /* HunkTable */
struct HunkTable : public Table<Hunk> { struct HunkTable : public SegmentObjTable<Hunk> {
HunkTable() : Table<Hunk>(SEG_TYPE_HUNK) {} HunkTable() : SegmentObjTable<Hunk>(SEG_TYPE_HUNK) {}
void freeEntryContents(int idx) { void freeEntryContents(int idx) {
free(_table[idx].mem); free(_table[idx].mem);
@ -320,11 +325,13 @@ struct HunkTable : public Table<Hunk> {
} }
virtual void freeEntry(int idx) { virtual void freeEntry(int idx) {
Table<Hunk>::freeEntry(idx); SegmentObjTable<Hunk>::freeEntry(idx);
freeEntryContents(idx); freeEntryContents(idx);
} }
virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr); virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr) {
freeEntry(sub_addr.offset);
}
virtual void saveLoadWithSerializer(Common::Serializer &ser); virtual void saveLoadWithSerializer(Common::Serializer &ser);
}; };
@ -343,10 +350,17 @@ public:
_buf = NULL; _buf = NULL;
} }
virtual bool isValidOffset(uint16 offset) const; virtual bool isValidOffset(uint16 offset) const {
return offset < _size;
}
virtual SegmentRef dereference(reg_t pointer); virtual SegmentRef dereference(reg_t pointer);
virtual reg_t findCanonicAddress(SegManager *segMan, reg_t sub_addr) const; virtual reg_t findCanonicAddress(SegManager *segMan, reg_t addr) const {
virtual Common::Array<reg_t> listAllDeallocatable(SegmentId segId) const; return make_reg(addr.segment, 0);
}
virtual Common::Array<reg_t> listAllDeallocatable(SegmentId segId) const {
const reg_t r = make_reg(segId, 0);
return Common::Array<reg_t>(&r, 1);
}
virtual void saveLoadWithSerializer(Common::Serializer &ser); virtual void saveLoadWithSerializer(Common::Serializer &ser);
}; };
@ -356,12 +370,7 @@ public:
template <typename T> template <typename T>
class SciArray { class SciArray {
public: public:
SciArray() { SciArray() : _type(-1), _data(NULL), _size(0), _actualSize(0) { }
_type = -1;
_data = NULL;
_size = 0;
_actualSize = 0;
}
SciArray(const SciArray<T> &array) { SciArray(const SciArray<T> &array) {
_type = array._type; _type = array._type;
@ -476,8 +485,8 @@ public:
void fromString(const Common::String &string); void fromString(const Common::String &string);
}; };
struct ArrayTable : public Table<SciArray<reg_t> > { struct ArrayTable : public SegmentObjTable<SciArray<reg_t> > {
ArrayTable() : Table<SciArray<reg_t> >(SEG_TYPE_ARRAY) {} ArrayTable() : SegmentObjTable<SciArray<reg_t> >(SEG_TYPE_ARRAY) {}
virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr); virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr);
virtual Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const; virtual Common::Array<reg_t> listAllOutgoingReferences(reg_t object) const;
@ -486,10 +495,13 @@ struct ArrayTable : public Table<SciArray<reg_t> > {
SegmentRef dereference(reg_t pointer); SegmentRef dereference(reg_t pointer);
}; };
struct StringTable : public Table<SciString> { struct StringTable : public SegmentObjTable<SciString> {
StringTable() : Table<SciString>(SEG_TYPE_STRING) {} StringTable() : SegmentObjTable<SciString>(SEG_TYPE_STRING) {}
virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr); virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr) {
_table[sub_addr.offset].destroy();
freeEntry(sub_addr.offset);
}
void saveLoadWithSerializer(Common::Serializer &ser); void saveLoadWithSerializer(Common::Serializer &ser);
SegmentRef dereference(reg_t pointer); SegmentRef dereference(reg_t pointer);