SCI: Rename MemObject -> SegmentObj

svn-id: r44130

13 files changed, 152 insertions, 152 deletions

diff --git a/engines/sci/console.cpp b/engines/sci/console.cpp
index 0740062624..9f75b14d99 100644
--- a/engines/sci/console.cpp
+++ b/engines/sci/console.cpp
@@ -1314,48 +1314,48 @@ bool Console::cmdPrintSegmentTable(int argc, const char **argv) {
 	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 @@ bool Console::segmentInfo(int nr) {
 	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 @@ bool Console::segmentInfo(int nr) {
 	}
 	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 @@ bool Console::segmentInfo(int nr) {
 	}
 	break;
 
-	case MEM_OBJ_CLONES: {
+	case SEG_TYPE_CLONES: {
 		CloneTable *ct = (CloneTable *)mobj;
 
 		DebugPrintf("clones\n");
@@ -1457,7 +1457,7 @@ bool Console::segmentInfo(int nr) {
 	}
 	break;
 
-	case MEM_OBJ_LISTS: {
+	case SEG_TYPE_LISTS: {
 		ListTable *lt = (ListTable *)mobj;
 
 		DebugPrintf("lists\n");
@@ -1469,12 +1469,12 @@ bool Console::segmentInfo(int nr) {
 	}
 	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 @@ bool Console::segmentInfo(int nr) {
 	}
 	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 @@ bool Console::segmentInfo(int nr) {
 	}
 	break;
 
-	case MEM_OBJ_STRING_FRAG: {
+	case SEG_TYPE_STRING_FRAG: {
 		DebugPrintf("string frags\n");
 		break;
 	}
@@ -1642,7 +1642,7 @@ bool Console::cmdGCShowReachable(int argc, const char **argv) {
 		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 @@ bool Console::cmdGCShowFreeable(int argc, const char **argv) {
 		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 @@ bool Console::cmdGCNormalize(int argc, const char **argv) {
 		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 @@ int parse_reg_t(EngineState *s, const char *str, reg_t *dest) { // Returns 0 on
 
 		// 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 @@ int parse_reg_t(EngineState *s, const char *str, reg_t *dest) { // Returns 0 on
 				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 @@ void Console::printList(List *l) {
 
 	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 @@ void Console::printList(List *l) {
 }
 
 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 @@ int Console::printNode(reg_t addr) {
 	} 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 @@ int Console::printObject(reg_t pos) {
 		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;
diff --git a/engines/sci/engine/gc.cpp b/engines/sci/engine/gc.cpp
index d6f9bab2af..5e5db1f8a4 100644
--- a/engines/sci/engine/gc.cpp
+++ b/engines/sci/engine/gc.cpp
@@ -53,7 +53,7 @@ static reg_t_hash_map *normalise_hashmap_ptrs(SegManager *segMan, reg_t_hash_map
 
 	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 @@ reg_t_hash_map *find_all_used_references(EngineState *s) {
 	// 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 @@ reg_t_hash_map *find_all_used_references(EngineState *s) {
 
 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 @@ void run_gc(EngineState *s) {
 
 #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 @@ void run_gc(EngineState *s) {
 	{
 		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]);
 	}
diff --git a/engines/sci/engine/kernel.cpp b/engines/sci/engine/kernel.cpp
index 3cdeec1866..850827aa28 100644
--- a/engines/sci/engine/kernel.cpp
+++ b/engines/sci/engine/kernel.cpp
@@ -467,7 +467,7 @@ reg_t kalloc(SegManager *segMan, const char *type, int space) {
 
 // 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 @@ void Kernel::mapFunctions() {
 }
 
 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 @@ int determine_reg_type(SegManager *segMan, reg_t reg, bool allow_invalid) {
 		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 @@ int determine_reg_type(SegManager *segMan, reg_t reg, bool allow_invalid) {
 		} 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;
 
diff --git a/engines/sci/engine/klists.cpp b/engines/sci/engine/klists.cpp
index 556bb32712..91842ffad2 100644
--- a/engines/sci/engine/klists.cpp
+++ b/engines/sci/engine/klists.cpp
@@ -32,7 +32,7 @@ Node *lookup_node(EngineState *s, reg_t addr) {
 	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 @@ Node *lookup_node(EngineState *s, reg_t addr) {
 }
 
 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));
diff --git a/engines/sci/engine/kmisc.cpp b/engines/sci/engine/kmisc.cpp
index 7f16e7196d..5bb4737fb2 100644
--- a/engines/sci/engine/kmisc.cpp
+++ b/engines/sci/engine/kmisc.cpp
@@ -204,7 +204,7 @@ reg_t kMemory(EngineState *s, int, int argc, reg_t *argv) {
 			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 @@ reg_t kMemory(EngineState *s, int, int argc, reg_t *argv) {
 			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) {
diff --git a/engines/sci/engine/kstring.cpp b/engines/sci/engine/kstring.cpp
index 49976ebae8..cbe5dfca7a 100644
--- a/engines/sci/engine/kstring.cpp
+++ b/engines/sci/engine/kstring.cpp
@@ -308,7 +308,7 @@ reg_t kStrCpy(EngineState *s, int, int argc, reg_t *argv) {
 		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;
diff --git a/engines/sci/engine/memobj.cpp b/engines/sci/engine/memobj.cpp
index c8be76576b..e59e41f24a 100644
--- a/engines/sci/engine/memobj.cpp
+++ b/engines/sci/engine/memobj.cpp
@@ -38,41 +38,41 @@ namespace Sci {
 //#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 @@ int16 Script::getHeap(uint16 offset) const {
 //	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;
diff --git a/engines/sci/engine/memobj.h b/engines/sci/engine/memobj.h
index 0294fb01c9..7889f529f8 100644
--- a/engines/sci/engine/memobj.h
+++ b/engines/sci/engine/memobj.h
@@ -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,
-
-	MEM_OBJ_MAX // For sanity checking
+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,
+
+	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 @@ public:
 
 
 // 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 @@ struct SystemString {
 	reg_t *value;
 };
 
-struct SystemStrings : public MemObject {
+struct SystemStrings : public SegmentObj {
 	SystemString strings[SYS_STRINGS_MAX];
 
 public:
@@ -178,7 +178,7 @@ struct CallsStruct {
 	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 @@ struct CodeBlock {
 
 
 
-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 @@ private:
 };
 
 /** Data stack */
-struct DataStack : MemObject {
+struct DataStack : SegmentObj {
 	int nr; /**< Number of stack entries */
 	reg_t *entries;
 
@@ -473,7 +473,7 @@ struct Hunk {
 };
 
 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 @@ struct HunkTable : public Table<Hunk> {
 
 
 // Free-style memory
-struct DynMem : public MemObject {
+struct DynMem : public SegmentObj {
 	int _size;
 	Common::String _description;
 	byte *_buf;
diff --git a/engines/sci/engine/savegame.cpp b/engines/sci/engine/savegame.cpp
index 3b222f26d3..11599797e2 100644
--- a/engines/sci/engine/savegame.cpp
+++ b/engines/sci/engine/savegame.cpp
@@ -217,21 +217,21 @@ void SegManager::saveLoadWithSerializer(Common::Serializer &s) {
 	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 @@ void SegManager::saveLoadWithSerializer(Common::Serializer &s) {
 		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 @@ static byte *find_unique_script_block(EngineState *s, byte *buf, int type) {
 
 // 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 @@ static void load_script(EngineState *s, Script *scr) {
 // 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 @@ static void reconstruct_scripts(EngineState *s, SegManager *self) {
 		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 @@ EngineState *gamestate_restore(EngineState *s, Common::SeekableReadStream *fh) {
 	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;
diff --git a/engines/sci/engine/scriptdebug.cpp b/engines/sci/engine/scriptdebug.cpp
index 4f4f23f1fc..38879a48ae 100644
--- a/engines/sci/engine/scriptdebug.cpp
+++ b/engines/sci/engine/scriptdebug.cpp
@@ -99,7 +99,7 @@ int propertyOffsetToId(SegManager *segMan, int prop_ofs, reg_t objp) {
 
 // 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 @@ void script_debug(EngineState *s, bool bp) {
 #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;
diff --git a/engines/sci/engine/seg_manager.cpp b/engines/sci/engine/seg_manager.cpp
index ed95e22e78..402a690e62 100644
--- a/engines/sci/engine/seg_manager.cpp
+++ b/engines/sci/engine/seg_manager.cpp
@@ -94,12 +94,12 @@ SegmentId SegManager::findFreeSegment() const {
 	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 @@ Script *SegManager::allocateScript(int script_nr, SegmentId *seg_id) {
 		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 @@ void Script::setScriptSize(int script_nr, ResourceManager *resMan) {
 }
 
 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 @@ Script *SegManager::getScript(const SegmentId seg) {
 	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 @@ SegmentId SegManager::findSegmentByType(int type) {
 	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 @@ LocalVariables *SegManager::allocLocalsSegment(Script *scr, int count) {
 		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 @@ static char *SegManager::dynprintf(char *msg, ...) {
 */
 
 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 @@ DataStack *SegManager::allocateStack(int size, SegmentId *segid) {
 }
 
 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 @@ uint16 SegManager::validateExportFunc(int pubfunct, SegmentId seg) {
 }
 
 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 @@ Clone *SegManager::allocateClone(reg_t *addr) {
 	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 @@ void SegManager::reconstructClones() {
 
 	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 @@ List *SegManager::allocateList(reg_t *addr) {
 	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 @@ Node *SegManager::allocateNode(reg_t *addr) {
 	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 @@ Hunk *SegManager::alloc_Hunk(reg_t *addr) {
 	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 @@ byte *SegManager::dereference(reg_t pointer, int *size) {
 		return NULL; /* Invalid */
 	}
 
-	MemObject *mobj = _heap[pointer.segment];
+	SegmentObj *mobj = _heap[pointer.segment];
 	return mobj->dereference(pointer, size);
 }
 
@@ -919,7 +919,7 @@ char *SegManager::derefString(reg_t pointer, int entries) {
 
 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 @@ const char *SegManager::getDescription(reg_t addr) {
 	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 @@ const char *SegManager::getDescription(reg_t addr) {
 }
 
 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);
diff --git a/engines/sci/engine/seg_manager.h b/engines/sci/engine/seg_manager.h
index 277b734f60..4b1f0aaf99 100644
--- a/engines/sci/engine/seg_manager.h
+++ b/engines/sci/engine/seg_manager.h
@@ -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 @@ public:
 	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 @@ public:
 	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 @@ private:
 	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();
diff --git a/engines/sci/engine/vm.cpp b/engines/sci/engine/vm.cpp
index dc22666188..7d45f2153b 100644
--- a/engines/sci/engine/vm.cpp
+++ b/engines/sci/engine/vm.cpp
@@ -463,7 +463,7 @@ ExecStack *add_exec_stack_entry(EngineState *s, reg_t pc, StackPtr sp, reg_t obj
 #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 @@ static reg_t pointer_add(EngineState *s, reg_t base, int offset) {
 
 	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;