SCI: Making various object and script related things const

svn-id: r49246

10 files changed, 97 insertions, 90 deletions

diff --git a/engines/sci/engine/features.cpp b/engines/sci/engine/features.cpp
index e51867332a..0e521d3c73 100644
--- a/engines/sci/engine/features.cpp
+++ b/engines/sci/engine/features.cpp
@@ -266,7 +266,7 @@ SciVersion GameFeatures::detectLofsType() {
 
 		// Find a function of the game object which invokes lofsa/lofss
 		reg_t gameClass = _segMan->findObjectByName("Game");
-		Object *obj = _segMan->getObject(gameClass);
+		const Object *obj = _segMan->getObject(gameClass);
 		bool found = false;
 
 		for (uint m = 0; m < obj->getMethodCount(); m++) {
@@ -343,7 +343,7 @@ SciVersion GameFeatures::detectGfxFunctionsType() {
 				// No overlay selector found, check if any method of the Rm object
 				// is calling kDrawPic, as the overlay selector might be missing in demos
 
-				Object *obj = _segMan->getObject(_segMan->findObjectByName("Rm"));
+				const Object *obj = _segMan->getObject(_segMan->findObjectByName("Rm"));
 				for (uint m = 0; m < obj->getMethodCount(); m++) {
 					found = autoDetectGfxFunctionsType(m);
 					if (found)
diff --git a/engines/sci/engine/kparse.cpp b/engines/sci/engine/kparse.cpp
index 0254d21642..51ad6bb5c6 100644
--- a/engines/sci/engine/kparse.cpp
+++ b/engines/sci/engine/kparse.cpp
@@ -177,7 +177,7 @@ reg_t kSetSynonyms(EngineState *s, int argc, reg_t *argv) {
 			numSynonyms = s->_segMan->getScript(seg)->getSynonymsNr();
 
 		if (numSynonyms) {
-			byte *synonyms = s->_segMan->getScript(seg)->getSynonyms();
+			const byte *synonyms = s->_segMan->getScript(seg)->getSynonyms();
 
 			if (synonyms) {
 				debugC(2, kDebugLevelParser, "Setting %d synonyms for script.%d",
diff --git a/engines/sci/engine/kscripts.cpp b/engines/sci/engine/kscripts.cpp
index ba29f64966..eeaa0ceec0 100644
--- a/engines/sci/engine/kscripts.cpp
+++ b/engines/sci/engine/kscripts.cpp
@@ -111,7 +111,7 @@ reg_t kResCheck(EngineState *s, int argc, reg_t *argv) {
 
 reg_t kClone(EngineState *s, int argc, reg_t *argv) {
 	reg_t parent_addr = argv[0];
-	Object *parent_obj = s->_segMan->getObject(parent_addr);
+	const Object *parent_obj = s->_segMan->getObject(parent_addr);
 	reg_t clone_addr;
 	Clone *clone_obj; // same as Object*
 
diff --git a/engines/sci/engine/savegame.cpp b/engines/sci/engine/savegame.cpp
index 8f341895c6..c967dddf7d 100644
--- a/engines/sci/engine/savegame.cpp
+++ b/engines/sci/engine/savegame.cpp
@@ -833,7 +833,7 @@ void SegManager::reconstructScripts(EngineState *s) {
 				it->_value._baseVars = (uint16 *)(scr->_buf + READ_LE_UINT16( data + 4 ));
 			} else {
 				int funct_area = READ_LE_UINT16(data + SCRIPT_FUNCTAREAPTR_OFFSET);
-				Object *baseObj = s->_segMan->getObject(it->_value.getSpeciesSelector());
+				const Object *baseObj = s->_segMan->getObject(it->_value.getSpeciesSelector());
 
 				if (!baseObj) {
 					warning("Object without a base class: Script %d, index %d (reg address %04x:%04x",
diff --git a/engines/sci/engine/scriptdebug.cpp b/engines/sci/engine/scriptdebug.cpp
index 608260ec50..da8e4ee211 100644
--- a/engines/sci/engine/scriptdebug.cpp
+++ b/engines/sci/engine/scriptdebug.cpp
@@ -193,7 +193,7 @@ reg_t disassemble(EngineState *s, reg_t pos, int print_bw_tag, int print_bytecod
 	if (pos == scriptState.xs->addr.pc) { // Extra information if debugging the current opcode
 		if ((opcode == op_pTos) || (opcode == op_sTop) || (opcode == op_pToa) || (opcode == op_aTop) ||
 		        (opcode == op_dpToa) || (opcode == op_ipToa) || (opcode == op_dpTos) || (opcode == op_ipTos)) {
-			Object *obj = s->_segMan->getObject(scriptState.xs->objp);
+			const Object *obj = s->_segMan->getObject(scriptState.xs->objp);
 			if (!obj)
 				warning("Attempted to reference on non-object at %04x:%04x", PRINT_REG(scriptState.xs->objp));
 			else
diff --git a/engines/sci/engine/seg_manager.cpp b/engines/sci/engine/seg_manager.cpp
index b18d76e1a7..e0b6e75d70 100644
--- a/engines/sci/engine/seg_manager.cpp
+++ b/engines/sci/engine/seg_manager.cpp
@@ -156,7 +156,7 @@ int SegManager::deallocate(SegmentId seg, bool recursive) {
 }
 
 bool SegManager::isHeapObject(reg_t pos) {
-	Object *obj = getObject(pos);
+	const Object *obj = getObject(pos);
 	if (obj == NULL || (obj && obj->isFreed()))
 		return false;
 	Script *scr = getScriptIfLoaded(pos.segment);
@@ -234,7 +234,7 @@ Object *SegManager::getObject(reg_t pos) {
 }
 
 const char *SegManager::getObjectName(reg_t pos) {
-	Object *obj = getObject(pos);
+	const Object *obj = getObject(pos);
 	if (!obj)
 		return "<no such object>";
 
@@ -275,7 +275,7 @@ reg_t SegManager::findObjectByName(const Common::String &name, int index) {
 
 		// It's a script or a clone table, scan all objects in it
 		for (; idx < max_index; ++idx) {
-			Object *obj = NULL;
+			const Object *obj = NULL;
 			reg_t objpos;
 			objpos.offset = 0;
 			objpos.segment = i;
@@ -485,7 +485,7 @@ void SegManager::reconstructClones() {
 						continue;
 
 					CloneTable::Entry &seeker = ct->_table[j];
-					Object *baseObj = getObject(seeker.getSpeciesSelector());
+					const Object *baseObj = getObject(seeker.getSpeciesSelector());
 					seeker.cloneFromObject(baseObj);
 					if (!baseObj)
 						warning("Clone entry without a base class: %d", j);
diff --git a/engines/sci/engine/segment.cpp b/engines/sci/engine/segment.cpp
index b26ac4f78e..c43c195e6b 100644
--- a/engines/sci/engine/segment.cpp
+++ b/engines/sci/engine/segment.cpp
@@ -194,6 +194,13 @@ Object *Script::getObject(uint16 offset) {
 		return 0;
 }
 
+const Object *Script::getObject(uint16 offset) const {
+	if (_objects.contains(offset))
+		return &_objects[offset];
+	else
+		return 0;
+}
+
 Object *Script::scriptObjInit(reg_t obj_pos) {
 	Object *obj;
 
@@ -355,8 +362,8 @@ void Script::setLockers(int lockers) {
 
 void Script::setExportTableOffset(int offset) {
 	if (offset) {
-		_exportTable = (uint16 *)(_buf + offset + 2);
-		_numExports = READ_SCI11ENDIAN_UINT16((byte *)(_exportTable - 1));
+		_exportTable = (const uint16 *)(_buf + offset + 2);
+		_numExports = READ_SCI11ENDIAN_UINT16((const byte *)(_exportTable - 1));
 	} else {
 		_exportTable = NULL;
 		_numExports = 0;
@@ -373,7 +380,7 @@ uint16 Script::validateExportFunc(int pubfunct) {
 
 	if (exportsAreWide)
 		pubfunct *= 2;
-	uint16 offset = READ_SCI11ENDIAN_UINT16((byte *)(_exportTable + pubfunct));
+	uint16 offset = READ_SCI11ENDIAN_UINT16((const byte *)(_exportTable + pubfunct));
 	VERIFY(offset < _bufSize, "invalid export function pointer");
 
 	return offset;
@@ -383,7 +390,7 @@ void Script::setSynonymsOffset(int offset) {
 	_synonyms = _buf + offset;
 }
 
-byte *Script::getSynonyms() const {
+const byte *Script::getSynonyms() const {
 	return _synonyms;
 }
 
@@ -547,13 +554,13 @@ void Script::freeAtAddress(SegManager *segMan, reg_t addr) {
 		segMan->deallocateScript(_nr);
 }
 
-void Script::listAllDeallocatable(SegmentId segId, void *param, NoteCallback note) {
+void Script::listAllDeallocatable(SegmentId segId, void *param, NoteCallback note) const {
 	(*note)(param, make_reg(segId, 0));
 }
 
-void Script::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback note) {
+void Script::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback note) const {
 	if (addr.offset <= _bufSize && addr.offset >= -SCRIPT_OBJECT_MAGIC_OFFSET && RAW_IS_OBJECT(_buf + addr.offset)) {
-		Object *obj = getObject(addr.offset);
+		const Object *obj = getObject(addr.offset);
 		if (obj) {
 			// Note all local variables, if we have a local variable environment
 			if (_localsSegment)
@@ -573,16 +580,14 @@ void Script::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback not
 
 //-------------------- clones --------------------
 
-void CloneTable::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback note) {
-	Clone *clone;
-
+void CloneTable::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback note) const {
 //	assert(addr.segment == _segId);
 
 	if (!isValidEntry(addr.offset)) {
 		error("Unexpected request for outgoing references from clone at %04x:%04x", PRINT_REG(addr));
 	}
 
-	clone = &(_table[addr.offset]);
+	const Clone *clone = &(_table[addr.offset]);
 
 	// Emit all member variables (including references to the 'super' delegate)
 	for (uint i = 0; i < clone->getVarCount(); i++)
@@ -626,7 +631,7 @@ reg_t LocalVariables::findCanonicAddress(SegManager *segMan, reg_t addr) {
 	return make_reg(owner_seg, 0);
 }
 
-void LocalVariables::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback note) {
+void LocalVariables::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback note) const {
 //	assert(addr.segment == _segId);
 
 	for (uint i = 0; i < _locals.size(); i++)
@@ -640,7 +645,7 @@ reg_t DataStack::findCanonicAddress(SegManager *segMan, reg_t addr) {
 	return addr;
 }
 
-void DataStack::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback note) {
+void DataStack::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback note) const {
 	fprintf(stderr, "Emitting %d stack entries\n", _capacity);
 	for (int i = 0; i < _capacity; i++)
 		(*note)(param, _entries[i]);
@@ -653,13 +658,13 @@ void ListTable::freeAtAddress(SegManager *segMan, reg_t sub_addr) {
 	freeEntry(sub_addr.offset);
 }
 
-void ListTable::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback note) {
+void ListTable::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback note) const {
 	if (!isValidEntry(addr.offset)) {
 		warning("Invalid list referenced for outgoing references: %04x:%04x", PRINT_REG(addr));
 		return;
 	}
 
-	List *list = &(_table[addr.offset]);
+	const List *list = &(_table[addr.offset]);
 
 	note(param, list->first);
 	note(param, list->last);
@@ -673,12 +678,12 @@ void NodeTable::freeAtAddress(SegManager *segMan, reg_t sub_addr) {
 	freeEntry(sub_addr.offset);
 }
 
-void NodeTable::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback note) {
+void NodeTable::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback note) const {
 	if (!isValidEntry(addr.offset)) {
 		warning("Invalid node referenced for outgoing references: %04x:%04x", PRINT_REG(addr));
 		return;
 	}
-	Node *node = &(_table[addr.offset]);
+	const Node *node = &(_table[addr.offset]);
 
 	// 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
@@ -694,19 +699,19 @@ void NodeTable::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback
 //-------------------- object ----------------------------
 
 void Object::init(byte *buf, reg_t obj_pos) {
-	byte *data = (byte *)(buf + obj_pos.offset);
+	byte *data = buf + obj_pos.offset;
 	_baseObj = data;
 	_pos = obj_pos;
 
 	if (getSciVersion() < SCI_VERSION_1_1) {
 		_variables.resize(READ_LE_UINT16(data + SCRIPT_SELECTORCTR_OFFSET));
-		_baseVars = (uint16 *)(_baseObj + _variables.size() * 2);
-		_baseMethod = (uint16 *)(data + READ_LE_UINT16(data + SCRIPT_FUNCTAREAPTR_OFFSET));
+		_baseVars = (const uint16 *)(_baseObj + _variables.size() * 2);
+		_baseMethod = (const uint16 *)(data + READ_LE_UINT16(data + SCRIPT_FUNCTAREAPTR_OFFSET));
 		_methodCount = READ_LE_UINT16(_baseMethod - 1);
 	} else {
 		_variables.resize(READ_SCI11ENDIAN_UINT16(data + 2));
-		_baseVars = (uint16 *)(buf + READ_SCI11ENDIAN_UINT16(data + 4));
-		_baseMethod = (uint16 *)(buf + READ_SCI11ENDIAN_UINT16(data + 6));
+		_baseVars = (const uint16 *)(buf + READ_SCI11ENDIAN_UINT16(data + 4));
+		_baseMethod = (const uint16 *)(buf + READ_SCI11ENDIAN_UINT16(data + 6));
 		_methodCount = READ_SCI11ENDIAN_UINT16(_baseMethod);
 	}
 
@@ -714,12 +719,12 @@ void Object::init(byte *buf, reg_t obj_pos) {
 		_variables[i] = make_reg(0, READ_SCI11ENDIAN_UINT16(data + (i * 2)));
 }
 
-Object *Object::getClass(SegManager *segMan) {
+const Object *Object::getClass(SegManager *segMan) const {
 	return isClass() ? this : segMan->getObject(getSuperClassSelector());
 }
 
-int Object::locateVarSelector(SegManager *segMan, Selector slc) {
-	byte *buf;
+int Object::locateVarSelector(SegManager *segMan, Selector slc) const {
+	const byte *buf;
 	uint varnum;
 
 	if (getSciVersion() < SCI_VERSION_1_1) {
@@ -727,7 +732,7 @@ int Object::locateVarSelector(SegManager *segMan, Selector slc) {
 		int selector_name_offset = varnum * 2 + SCRIPT_SELECTOR_OFFSET;
 		buf = _baseObj + selector_name_offset;
 	} else {
-		Object *obj = getClass(segMan);
+		const Object *obj = getClass(segMan);
 		varnum = obj->getVariable(1).toUint16();
 		buf = (byte *)obj->_baseVars;
 	}
@@ -761,7 +766,7 @@ bool Object::relocate(SegmentId segment, int location, size_t scriptSize) {
 	return true;
 }
 
-int Object::propertyOffsetToId(SegManager *segMan, int propertyOffset) {
+int Object::propertyOffsetToId(SegManager *segMan, int propertyOffset) const {
 	int selectors = getVarCount();
 
 	if (propertyOffset < 0 || (propertyOffset >> 1) >= selectors) {
@@ -771,14 +776,14 @@ int Object::propertyOffsetToId(SegManager *segMan, int propertyOffset) {
 	}
 
 	if (getSciVersion() < SCI_VERSION_1_1) {
-		byte *selectoroffset = ((byte *)(_baseObj)) + SCRIPT_SELECTOR_OFFSET + selectors * 2;
+		const byte *selectoroffset = ((const byte *)(_baseObj)) + SCRIPT_SELECTOR_OFFSET + selectors * 2;
 		return READ_SCI11ENDIAN_UINT16(selectoroffset + propertyOffset);
 	} else {
-		Object *obj = this;
+		const Object *obj = this;
 		if (!(getInfoSelector().offset & SCRIPT_INFO_CLASS))
 			obj = segMan->getObject(getSuperClassSelector());
 
-		return READ_SCI11ENDIAN_UINT16((byte *)obj->_baseVars + propertyOffset);
+		return READ_SCI11ENDIAN_UINT16((const byte *)obj->_baseVars + propertyOffset);
 	}
 }
 
@@ -801,7 +806,7 @@ void Object::initSuperClass(SegManager *segMan, reg_t addr) {
 }
 
 bool Object::initBaseObject(SegManager *segMan, reg_t addr) {
-	Object *baseObj = segMan->getObject(getSpeciesSelector());
+	const Object *baseObj = segMan->getObject(getSpeciesSelector());
 
 	if (baseObj) {
 		setVarCount(baseObj->getVarCount());
@@ -821,7 +826,7 @@ reg_t DynMem::findCanonicAddress(SegManager *segMan, reg_t addr) {
 	return addr;
 }
 
-void DynMem::listAllDeallocatable(SegmentId segId, void *param, NoteCallback note) {
+void DynMem::listAllDeallocatable(SegmentId segId, void *param, NoteCallback note) const {
 	(*note)(param, make_reg(segId, 0));
 }
 
@@ -840,13 +845,13 @@ void ArrayTable::freeAtAddress(SegManager *segMan, reg_t sub_addr) {
 	freeEntry(sub_addr.offset);
 }
 
-void ArrayTable::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback note) {
+void ArrayTable::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback note) const {
 	if (!isValidEntry(addr.offset)) {
 		warning("Invalid array referenced for outgoing references: %04x:%04x", PRINT_REG(addr));
 		return;
 	}
 
-	SciArray<reg_t> *array = &(_table[addr.offset]);
+	const SciArray<reg_t> *array = &(_table[addr.offset]);
 
 	for (uint32 i = 0; i < array->getSize(); i++) {
 		reg_t value = array->getValue(i);
diff --git a/engines/sci/engine/segment.h b/engines/sci/engine/segment.h
index 2912567ff7..b3ea80f665 100644
--- a/engines/sci/engine/segment.h
+++ b/engines/sci/engine/segment.h
@@ -125,7 +125,7 @@ public:
 	 * @param note		Invoked for each address on which free_at_address() makes sense
 	 * @param param		parameter passed to 'note'
 	 */
-	virtual void listAllDeallocatable(SegmentId segId, void *param, NoteCallback note) {}
+	virtual void listAllDeallocatable(SegmentId segId, void *param, NoteCallback note) const {}
 
 	/**
 	 * Iterates over all references reachable from the specified object.
@@ -134,7 +134,7 @@ public:
 	 * @param note		Invoked for each outgoing reference within the object
 	 * Note: This function may also choose to report numbers (segment 0) as adresses
 	 */
-	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note) {}
+	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note) const {}
 };
 
 
@@ -195,7 +195,7 @@ public:
 	virtual bool isValidOffset(uint16 offset) const;
 	virtual SegmentRef dereference(reg_t pointer);
 	virtual reg_t findCanonicAddress(SegManager *segMan, reg_t sub_addr);
-	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note);
+	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note) const;
 
 	virtual void saveLoadWithSerializer(Common::Serializer &ser);
 };
@@ -214,29 +214,29 @@ public:
 
 	~Object() { }
 
-	reg_t getSpeciesSelector() { return _variables[_offset]; }
+	reg_t getSpeciesSelector() const { return _variables[_offset]; }
 	void setSpeciesSelector(reg_t value) { _variables[_offset] = value; }
 
-	reg_t getSuperClassSelector() {	return _variables[_offset + 1];	}
+	reg_t getSuperClassSelector() const {	return _variables[_offset + 1];	}
 	void setSuperClassSelector(reg_t value) { _variables[_offset + 1] = value; }
 
-	reg_t getInfoSelector() { return _variables[_offset + 2]; }
+	reg_t getInfoSelector() const { return _variables[_offset + 2]; }
 	void setInfoSelector(reg_t value) {	_variables[_offset + 2] = value; }
 
-	reg_t getNameSelector() { return _variables[_offset + 3]; }
+	reg_t getNameSelector() const { return _variables[_offset + 3]; }
 	void setNameSelector(reg_t value) {	_variables[_offset + 3] = value; }
 
-	reg_t getClassScriptSelector() { return _variables[4]; }
+	reg_t getClassScriptSelector() const { return _variables[4]; }
 	void setClassScriptSelector(reg_t value) { _variables[4] = value; }
 
-	Selector getVarSelector(uint16 i) { return READ_SCI11ENDIAN_UINT16(_baseVars + i); }
+	Selector getVarSelector(uint16 i) const { return READ_SCI11ENDIAN_UINT16(_baseVars + i); }
 
-	reg_t getFunction(uint16 i) {
+	reg_t getFunction(uint16 i) const {
 		uint16 offset = (getSciVersion() < SCI_VERSION_1_1) ? _methodCount + 1 + i : i * 2 + 2;
 		return make_reg(_pos.segment, READ_SCI11ENDIAN_UINT16((byte *) (_baseMethod + offset)));
 	}
 
-	Selector getFuncSelector(uint16 i) {
+	Selector getFuncSelector(uint16 i) const {
 		uint16 offset = (getSciVersion() < SCI_VERSION_1_1) ? i : i * 2 + 1;
 		return READ_SCI11ENDIAN_UINT16((byte *) (_baseMethod + offset));
 	}
@@ -247,7 +247,7 @@ public:
 	 * superclasses, i.e. failure may be returned even if one of the
 	 * superclasses defines the funcselector
 	 */
-	int funcSelectorPosition(Selector sel) {
+	int funcSelectorPosition(Selector sel) const {
 		for (uint i = 0; i < _methodCount; i++)
 			if (getFuncSelector(i) == sel)
 				return i;
@@ -256,30 +256,31 @@ public:
 	}
 
 	/**
-	 * Determines if the object explicitly defines slc as a varselector
-	 * Returns -1 if not found
+	 * Determines if the object explicitly defines slc as a varselector.
+	 * Returns -1 if not found.
 	 */
-	int locateVarSelector(SegManager *segMan, Selector slc);
+	int locateVarSelector(SegManager *segMan, Selector slc) const;
 
-	bool isClass() { return (getInfoSelector().offset & SCRIPT_INFO_CLASS);	}
-	Object *getClass(SegManager *segMan);
+	bool isClass() const { return (getInfoSelector().offset & SCRIPT_INFO_CLASS);	}
+	const Object *getClass(SegManager *segMan) const;
 
 	void markAsFreed() { _flags |= OBJECT_FLAG_FREED; }
-	bool isFreed() { return _flags & OBJECT_FLAG_FREED;	}
+	bool isFreed() const { return _flags & OBJECT_FLAG_FREED;	}
 
 	void setVarCount(uint size) { _variables.resize(size); }
-	uint getVarCount() { return _variables.size(); }
+	uint getVarCount() const { return _variables.size(); }
 
 	void init(byte *buf, reg_t obj_pos);
 
-	reg_t &getVariable(uint var) { return _variables[var]; }
+	reg_t getVariable(uint var) const { return _variables[var]; }
+	reg_t &getVariableRef(uint var) { return _variables[var]; }
 
-	uint16 getMethodCount() { return _methodCount; }
-	reg_t getPos() { return _pos; }
+	uint16 getMethodCount() const { return _methodCount; }
+	reg_t getPos() const { return _pos; }
 
 	void saveLoadWithSerializer(Common::Serializer &ser);
 
-	void cloneFromObject(Object *obj) {
+	void cloneFromObject(const Object *obj) {
 		_baseObj = obj ? obj->_baseObj : NULL;
 		_baseMethod = obj ? obj->_baseMethod : NULL;
 		_baseVars = obj ? obj->_baseVars : NULL;
@@ -287,7 +288,7 @@ public:
 
 	bool relocate(SegmentId segment, int location, size_t scriptSize);
 
-	int propertyOffsetToId(SegManager *segMan, int propertyOffset);
+	int propertyOffsetToId(SegManager *segMan, int propertyOffset) const;
 
 	void initSpecies(SegManager *segMan, reg_t addr);
 	void initSuperClass(SegManager *segMan, reg_t addr);
@@ -296,9 +297,9 @@ public:
 	// TODO: make private
 	// Only SegManager::reconstructScripts() is left needing direct access to these
 public:
-	byte *_baseObj; /**< base + object offset within base */
-	uint16 *_baseVars; /**< Pointer to the varselector area for this object */
-	uint16 *_baseMethod; /**< Pointer to the method selector area for this object */
+	const byte *_baseObj; /**< base + object offset within base */
+	const uint16 *_baseVars; /**< Pointer to the varselector area for this object */
+	const uint16 *_baseMethod; /**< Pointer to the method selector area for this object */
 
 private:
 	Common::Array<reg_t> _variables;
@@ -325,7 +326,7 @@ public:
 
 	byte *_heapStart; /**< Start of heap if SCI1.1, NULL otherwise */
 
-	uint16 *_exportTable; /**< Abs. offset of the export table or 0 if not present */
+	const uint16 *_exportTable; /**< Abs. offset of the export table or 0 if not present */
 	int _numExports; /**< Number of entries in the exports table */
 
 	byte *_synonyms; /**< Synonyms block or 0 if not present*/
@@ -360,13 +361,14 @@ public:
 	virtual SegmentRef dereference(reg_t pointer);
 	virtual reg_t findCanonicAddress(SegManager *segMan, reg_t sub_addr);
 	virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr);
-	virtual void listAllDeallocatable(SegmentId segId, void *param, NoteCallback note);
-	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note);
+	virtual void listAllDeallocatable(SegmentId segId, void *param, NoteCallback note) const;
+	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note) const;
 
 	virtual void saveLoadWithSerializer(Common::Serializer &ser);
 
 	Object *allocateObject(uint16 offset);
 	Object *getObject(uint16 offset);
+	const Object *getObject(uint16 offset) const;
 
 	/**
 	 * Informs the segment manager that a code block must be relocated
@@ -428,7 +430,7 @@ public:
 	 * Retrieves a pointer to the synonyms associated with this script
 	 * @return	pointer to the synonyms, in non-parsed format.
 	 */
-	byte *getSynonyms() const;
+	const byte *getSynonyms() const;
 
 	/**
 	 * Retrieves the number of synonyms associated with this script.
@@ -525,7 +527,7 @@ public:
 	virtual bool isValidOffset(uint16 offset) const;
 	virtual SegmentRef dereference(reg_t pointer);
 	virtual reg_t findCanonicAddress(SegManager *segMan, reg_t sub_addr);
-	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note);
+	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note) const;
 
 	virtual void saveLoadWithSerializer(Common::Serializer &ser);
 };
@@ -613,7 +615,7 @@ public:
 		entries_used--;
 	}
 
-	virtual void listAllDeallocatable(SegmentId segId, void *param, NoteCallback note) {
+	virtual void listAllDeallocatable(SegmentId segId, void *param, NoteCallback note) const {
 		for (uint i = 0; i < _table.size(); i++)
 			if (isValidEntry(i))
 				(*note)(param, make_reg(segId, i));
@@ -626,7 +628,7 @@ struct CloneTable : public Table<Clone> {
 	CloneTable() : Table<Clone>(SEG_TYPE_CLONES) {}
 
 	virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr);
-	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note);
+	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note) const;
 
 	virtual void saveLoadWithSerializer(Common::Serializer &ser);
 };
@@ -637,7 +639,7 @@ struct NodeTable : public Table<Node> {
 	NodeTable() : Table<Node>(SEG_TYPE_NODES) {}
 
 	virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr);
-	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note);
+	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note) const;
 
 	virtual void saveLoadWithSerializer(Common::Serializer &ser);
 };
@@ -648,7 +650,7 @@ struct ListTable : public Table<List> {
 	ListTable() : Table<List>(SEG_TYPE_LISTS) {}
 
 	virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr);
-	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note);
+	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note) const;
 
 	virtual void saveLoadWithSerializer(Common::Serializer &ser);
 };
@@ -684,7 +686,7 @@ public:
 	virtual bool isValidOffset(uint16 offset) const;
 	virtual SegmentRef dereference(reg_t pointer);
 	virtual reg_t findCanonicAddress(SegManager *segMan, reg_t sub_addr);
-	virtual void listAllDeallocatable(SegmentId segId, void *param, NoteCallback note);
+	virtual void listAllDeallocatable(SegmentId segId, void *param, NoteCallback note) const;
 
 	virtual void saveLoadWithSerializer(Common::Serializer &ser);
 };
@@ -777,7 +779,7 @@ public:
 		_size = _actualSize = size;
 	}
 
-	T getValue(uint16 index) {
+	T getValue(uint16 index) const {
 		if (index >= _size)
 			error("SciArray::getValue(): %d is out of bounds (%d)", index, _size);
 
@@ -791,8 +793,8 @@ public:
 		_data[index] = value;
 	}
 
-	byte getType() { return _type; }
-	uint32 getSize() { return _size; }
+	byte getType() const { return _type; }
+	uint32 getSize() const { return _size; }
 	T *getRawData() { return _data; }
 
 protected:
@@ -817,7 +819,7 @@ struct ArrayTable : public Table<SciArray<reg_t> > {
 	ArrayTable() : Table<SciArray<reg_t> >(SEG_TYPE_ARRAY) {}
 
 	virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr);
-	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note);
+	virtual void listAllOutgoingReferences(reg_t object, void *param, NoteCallback note) const;
 
 	void saveLoadWithSerializer(Common::Serializer &ser);
 	SegmentRef dereference(reg_t pointer);
diff --git a/engines/sci/engine/selector.cpp b/engines/sci/engine/selector.cpp
index aba134818b..cdbce5a6e4 100644
--- a/engines/sci/engine/selector.cpp
+++ b/engines/sci/engine/selector.cpp
@@ -260,7 +260,7 @@ int invoke_selector(EngineState *s, reg_t object, int selector_id, SelectorInvoc
 }
 
 SelectorType lookup_selector(SegManager *segMan, reg_t obj_location, Selector selector_id, ObjVarRef *varp, reg_t *fptr) {
-	Object *obj = segMan->getObject(obj_location);
+	const Object *obj = segMan->getObject(obj_location);
 	int index;
 	bool oldScriptHeader = (getSciVersion() == SCI_VERSION_0_EARLY);
 
diff --git a/engines/sci/engine/vm.cpp b/engines/sci/engine/vm.cpp
index 44279af1c1..903c4a9a78 100644
--- a/engines/sci/engine/vm.cpp
+++ b/engines/sci/engine/vm.cpp
@@ -120,7 +120,7 @@ static reg_t &validate_property(Object *obj, int index) {
 		return dummyReg;
 	}
 
-	return obj->getVariable(index);
+	return obj->getVariableRef(index);
 }
 
 static StackPtr validate_stack_addr(EngineState *s, StackPtr sp) {
@@ -1766,12 +1766,12 @@ void quit_vm() {
 	g_debugState.runningStep = 0;
 }
 
-reg_t* ObjVarRef::getPointer(SegManager *segMan) const {
+reg_t *ObjVarRef::getPointer(SegManager *segMan) const {
 	Object *o = segMan->getObject(obj);
-	return o ? &o->getVariable(varindex) : 0;
+	return o ? &o->getVariableRef(varindex) : 0;
 }
 
-reg_t* ExecStack::getVarPointer(SegManager *segMan) const {
+reg_t *ExecStack::getVarPointer(SegManager *segMan) const {
 	assert(type == EXEC_STACK_TYPE_VARSELECTOR);
 	return addr.varp.getPointer(segMan);
 }