SCI: Introduce accessors for SegmentObjTable entries.

This makes code not use _table directly whenever possible. An exception is the
save game code which is not easy to adapt due to design deficiencies.

4 files changed, 55 insertions, 48 deletions

diff --git a/engines/sci/engine/scriptdebug.cpp b/engines/sci/engine/scriptdebug.cpp
index 7d70f30d55..b017e62df7 100644
--- a/engines/sci/engine/scriptdebug.cpp
+++ b/engines/sci/engine/scriptdebug.cpp
@@ -741,13 +741,13 @@ void logKernelCall(const KernelFunction *kernelCall, const KernelSubFunction *ke
 					switch (mobj->getType()) {
 					case SEG_TYPE_HUNK:
 					{
-						HunkTable *ht = (HunkTable *)mobj;
+						HunkTable &ht = *(HunkTable *)mobj;
 						int index = argv[parmNr].getOffset();
-						if (ht->isValidEntry(index)) {
+						if (ht.isValidEntry(index)) {
 							// NOTE: This ", deleted" isn't as useful as it could
 							// be because it prints the status _after_ the kernel
 							// call.
-							debugN(" ('%s' hunk%s)", ht->_table[index].type, ht->_table[index].mem ? "" : ", deleted");
+							debugN(" ('%s' hunk%s)", ht[index].type, ht[index].mem ? "" : ", deleted");
 						} else
 							debugN(" (INVALID hunk ref)");
 						break;
diff --git a/engines/sci/engine/seg_manager.cpp b/engines/sci/engine/seg_manager.cpp
index 8090b1861d..95e3cd15f9 100644
--- a/engines/sci/engine/seg_manager.cpp
+++ b/engines/sci/engine/seg_manager.cpp
@@ -247,9 +247,9 @@ Object *SegManager::getObject(reg_t pos) const {
 
 	if (mobj != NULL) {
 		if (mobj->getType() == SEG_TYPE_CLONES) {
-			CloneTable *ct = (CloneTable *)mobj;
-			if (ct->isValidEntry(pos.getOffset()))
-				obj = &(ct->_table[pos.getOffset()]);
+			CloneTable &ct = *(CloneTable *)mobj;
+			if (ct.isValidEntry(pos.getOffset()))
+				obj = &(ct[pos.getOffset()]);
 			else
 				warning("getObject(): Trying to get an invalid object");
 		} else if (mobj->getType() == SEG_TYPE_SCRIPT) {
@@ -313,7 +313,7 @@ reg_t SegManager::findObjectByName(const Common::String &name, int index) {
 		} else if (mobj->getType() == SEG_TYPE_CLONES) {
 			// It's clone table, scan all objects in it
 			const CloneTable *ct = (const CloneTable *)mobj;
-			for (uint idx = 0; idx < ct->_table.size(); ++idx) {
+			for (uint idx = 0; idx < ct->size(); ++idx) {
 				if (!ct->isValidEntry(idx))
 					continue;
 
@@ -404,7 +404,7 @@ reg_t SegManager::allocateHunkEntry(const char *hunk_type, int size) {
 	offset = table->allocEntry();
 
 	reg_t addr = make_reg(_hunksSegId, offset);
-	Hunk *h = &(table->_table[offset]);
+	Hunk *h = &table->at(offset);
 
 	if (!h)
 		return NULL_REG;
@@ -424,7 +424,7 @@ byte *SegManager::getHunkPointer(reg_t addr) {
 		return NULL;
 	}
 
-	return (byte *)ht->_table[addr.getOffset()].mem;
+	return (byte *)ht->at(addr.getOffset()).mem;
 }
 
 Clone *SegManager::allocateClone(reg_t *addr) {
@@ -439,7 +439,7 @@ Clone *SegManager::allocateClone(reg_t *addr) {
 	offset = table->allocEntry();
 
 	*addr = make_reg(_clonesSegId, offset);
-	return &(table->_table[offset]);
+	return &table->at(offset);
 }
 
 List *SegManager::allocateList(reg_t *addr) {
@@ -453,7 +453,7 @@ List *SegManager::allocateList(reg_t *addr) {
 	offset = table->allocEntry();
 
 	*addr = make_reg(_listsSegId, offset);
-	return &(table->_table[offset]);
+	return &table->at(offset);
 }
 
 Node *SegManager::allocateNode(reg_t *addr) {
@@ -467,7 +467,7 @@ Node *SegManager::allocateNode(reg_t *addr) {
 	offset = table->allocEntry();
 
 	*addr = make_reg(_nodesSegId, offset);
-	return &(table->_table[offset]);
+	return &table->at(offset);
 }
 
 reg_t SegManager::newNode(reg_t value, reg_t key) {
@@ -486,14 +486,14 @@ List *SegManager::lookupList(reg_t addr) {
 		return NULL;
 	}
 
-	ListTable *lt = (ListTable *)_heap[addr.getSegment()];
+	ListTable &lt = *(ListTable *)_heap[addr.getSegment()];
 
-	if (!lt->isValidEntry(addr.getOffset())) {
+	if (!lt.isValidEntry(addr.getOffset())) {
 		error("Attempt to use non-list %04x:%04x as list", PRINT_REG(addr));
 		return NULL;
 	}
 
-	return &(lt->_table[addr.getOffset()]);
+	return &(lt[addr.getOffset()]);
 }
 
 Node *SegManager::lookupNode(reg_t addr, bool stopOnDiscarded) {
@@ -507,9 +507,9 @@ Node *SegManager::lookupNode(reg_t addr, bool stopOnDiscarded) {
 		return NULL;
 	}
 
-	NodeTable *nt = (NodeTable *)_heap[addr.getSegment()];
+	NodeTable &nt = *(NodeTable *)_heap[addr.getSegment()];
 
-	if (!nt->isValidEntry(addr.getOffset())) {
+	if (!nt.isValidEntry(addr.getOffset())) {
 		if (!stopOnDiscarded)
 			return NULL;
 
@@ -517,7 +517,7 @@ Node *SegManager::lookupNode(reg_t addr, bool stopOnDiscarded) {
 		return NULL;
 	}
 
-	return &(nt->_table[addr.getOffset()]);
+	return &(nt[addr.getOffset()]);
 }
 
 SegmentRef SegManager::dereference(reg_t pointer) {
@@ -873,32 +873,32 @@ SciArray<reg_t> *SegManager::allocateArray(reg_t *addr) {
 	offset = table->allocEntry();
 
 	*addr = make_reg(_arraysSegId, offset);
-	return &(table->_table[offset]);
+	return &table->at(offset);
 }
 
 SciArray<reg_t> *SegManager::lookupArray(reg_t addr) {
 	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.getSegment()];
+	ArrayTable &arrayTable = *(ArrayTable *)_heap[addr.getSegment()];
 
-	if (!arrayTable->isValidEntry(addr.getOffset()))
+	if (!arrayTable.isValidEntry(addr.getOffset()))
 		error("Attempt to use non-array %04x:%04x as array", PRINT_REG(addr));
 
-	return &(arrayTable->_table[addr.getOffset()]);
+	return &(arrayTable[addr.getOffset()]);
 }
 
 void SegManager::freeArray(reg_t addr) {
 	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.getSegment()];
+	ArrayTable &arrayTable = *(ArrayTable *)_heap[addr.getSegment()];
 
-	if (!arrayTable->isValidEntry(addr.getOffset()))
+	if (!arrayTable.isValidEntry(addr.getOffset()))
 		error("Attempt to use non-array %04x:%04x as array", PRINT_REG(addr));
 
-	arrayTable->_table[addr.getOffset()].destroy();
-	arrayTable->freeEntry(addr.getOffset());
+	arrayTable[addr.getOffset()].destroy();
+	arrayTable.freeEntry(addr.getOffset());
 }
 
 SciString *SegManager::allocateString(reg_t *addr) {
@@ -913,32 +913,32 @@ SciString *SegManager::allocateString(reg_t *addr) {
 	offset = table->allocEntry();
 
 	*addr = make_reg(_stringSegId, offset);
-	return &(table->_table[offset]);
+	return &table->at(offset);
 }
 
 SciString *SegManager::lookupString(reg_t addr) {
 	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.getSegment()];
+	StringTable &stringTable = *(StringTable *)_heap[addr.getSegment()];
 
-	if (!stringTable->isValidEntry(addr.getOffset()))
+	if (!stringTable.isValidEntry(addr.getOffset()))
 		error("lookupString: Attempt to use non-string %04x:%04x as string", PRINT_REG(addr));
 
-	return &(stringTable->_table[addr.getOffset()]);
+	return &(stringTable[addr.getOffset()]);
 }
 
 void SegManager::freeString(reg_t addr) {
 	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.getSegment()];
+	StringTable &stringTable = *(StringTable *)_heap[addr.getSegment()];
 
-	if (!stringTable->isValidEntry(addr.getOffset()))
+	if (!stringTable.isValidEntry(addr.getOffset()))
 		error("freeString: Attempt to use non-string %04x:%04x as string", PRINT_REG(addr));
 
-	stringTable->_table[addr.getOffset()].destroy();
-	stringTable->freeEntry(addr.getOffset());
+	stringTable[addr.getOffset()].destroy();
+	stringTable.freeEntry(addr.getOffset());
 }
 
 #endif
diff --git a/engines/sci/engine/segment.cpp b/engines/sci/engine/segment.cpp
index bb90698e6a..2cff799f4b 100644
--- a/engines/sci/engine/segment.cpp
+++ b/engines/sci/engine/segment.cpp
@@ -97,7 +97,7 @@ Common::Array<reg_t> CloneTable::listAllOutgoingReferences(reg_t addr) const {
 		error("Unexpected request for outgoing references from clone at %04x:%04x", PRINT_REG(addr));
 	}
 
-	const Clone *clone = &(_table[addr.getOffset()]);
+	const Clone *clone = &at(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.getOffset()]);
+	Object *victim_obj = &at(addr.getOffset());
 
 	if (!(victim_obj->_flags & OBJECT_FLAG_FREED))
 		warning("[GC] Clone %04x:%04x not reachable and not freed (freeing now)", PRINT_REG(addr));
@@ -208,7 +208,7 @@ Common::Array<reg_t> ListTable::listAllOutgoingReferences(reg_t addr) const {
 		error("Invalid list referenced for outgoing references: %04x:%04x", PRINT_REG(addr));
 	}
 
-	const List *list = &(_table[addr.getOffset()]);
+	const List *list = &at(addr.getOffset());
 
 	tmp.push_back(list->first);
 	tmp.push_back(list->last);
@@ -225,7 +225,7 @@ Common::Array<reg_t> NodeTable::listAllOutgoingReferences(reg_t addr) const {
 	if (!isValidEntry(addr.getOffset())) {
 		error("Invalid node referenced for outgoing references: %04x:%04x", PRINT_REG(addr));
 	}
-	const Node *node = &(_table[addr.getOffset()]);
+	const Node *node = &at(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
@@ -252,13 +252,13 @@ SegmentRef DynMem::dereference(reg_t pointer) {
 SegmentRef ArrayTable::dereference(reg_t pointer) {
 	SegmentRef ret;
 	ret.isRaw = false;
-	ret.maxSize = _table[pointer.getOffset()].getSize() * 2;
-	ret.reg = _table[pointer.getOffset()].getRawData();
+	ret.maxSize = at(pointer.getOffset()).getSize() * 2;
+	ret.reg = at(pointer.getOffset()).getRawData();
 	return ret;
 }
 
 void ArrayTable::freeAtAddress(SegManager *segMan, reg_t sub_addr) {
-	_table[sub_addr.getOffset()].destroy();
+	at(sub_addr.getOffset()).destroy();
 	freeEntry(sub_addr.getOffset());
 }
 
@@ -268,7 +268,7 @@ Common::Array<reg_t> ArrayTable::listAllOutgoingReferences(reg_t addr) const {
 		error("Invalid array referenced for outgoing references: %04x:%04x", PRINT_REG(addr));
 	}
 
-	const SciArray<reg_t> *array = &(_table[addr.getOffset()]);
+	const SciArray<reg_t> *array = &at(addr.getOffset());
 
 	for (uint32 i = 0; i < array->getSize(); i++) {
 		reg_t value = array->getValue(i);
@@ -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.getOffset()].getSize();
-	ret.raw = (byte *)_table[pointer.getOffset()].getRawData();
+	ret.maxSize = at(pointer.getOffset()).getSize();
+	ret.raw = (byte *)at(pointer.getOffset()).getRawData();
 	return ret;
 }
 
diff --git a/engines/sci/engine/segment.h b/engines/sci/engine/segment.h
index 2699bc2e5b..529f6b7a7d 100644
--- a/engines/sci/engine/segment.h
+++ b/engines/sci/engine/segment.h
@@ -215,7 +215,6 @@ struct SegmentObjTable : public SegmentObj {
 	};
 	enum { HEAPENTRY_INVALID = -1 };
 
-
 	int first_free; /**< Beginning of a singly linked list for entries */
 	int entries_used; /**< Statistical information */
 
@@ -272,6 +271,14 @@ public:
 				tmp.push_back(make_reg(segId, i));
 		return tmp;
 	}
+
+	uint size() const { return _table.size(); }
+
+	T &at(uint index) { return _table[index]; }
+	const T &at(uint index) const { return _table[index]; }
+
+	T &operator[](uint index) { return at(index); }
+	const T &operator[](uint index) const { return at(index); }
 };
 
 
@@ -323,8 +330,8 @@ struct HunkTable : public SegmentObjTable<Hunk> {
 	}
 
 	void freeEntryContents(int idx) {
-		free(_table[idx].mem);
-		_table[idx].mem = 0;
+		free(at(idx).mem);
+		at(idx).mem = 0;
 	}
 
 	virtual void freeEntry(int idx) {
@@ -502,7 +509,7 @@ struct StringTable : public SegmentObjTable<SciString> {
 	StringTable() : SegmentObjTable<SciString>(SEG_TYPE_STRING) {}
 
 	virtual void freeAtAddress(SegManager *segMan, reg_t sub_addr) {
-		_table[sub_addr.getOffset()].destroy();
+		at(sub_addr.getOffset()).destroy();
 		freeEntry(sub_addr.getOffset());
 	}