1 files changed, 75 insertions, 149 deletions

diff --git a/engines/sci/engine/vm.cpp b/engines/sci/engine/vm.cpp
index ae07c314d4..64ee7243fb 100644
--- a/engines/sci/engine/vm.cpp
+++ b/engines/sci/engine/vm.cpp
@@ -187,34 +187,6 @@ static void validate_write_var(reg_t *r, reg_t *stack_base, int type, int max, i
 
 #define OBJ_PROPERTY(o, p) (validate_property(o, p))
 
-reg_t get_class_address(EngineState *s, int classnr, SCRIPT_GET lock, reg_t caller) {
-
-	if (NULL == s) {
-		warning("vm.c: get_class_address(): NULL passed for \"s\"");
-		return NULL_REG;
-	}
-
-	if (classnr < 0 || (int)s->_classtable.size() <= classnr || s->_classtable[classnr].script < 0) {
-		error("[VM] Attempt to dereference class %x, which doesn't exist (max %x)", classnr, s->_classtable.size());
-		return NULL_REG;
-	} else {
-		Class *the_class = &s->_classtable[classnr];
-		if (!the_class->reg.segment) {
-			script_get_segment(s, the_class->script, lock);
-
-			if (!the_class->reg.segment) {
-				error("[VM] Trying to instantiate class %x by instantiating script 0x%x (%03d) failed;"
-				          " Entering debugger.", classnr, the_class->script, the_class->script);
-				return NULL_REG;
-			}
-		} else
-			if (caller.segment != the_class->reg.segment)
-				s->seg_manager->getScript(the_class->reg.segment)->incrementLockers();
-
-		return the_class->reg;
-	}
-}
-
 // Operating on the stack
 // 16 bit:
 #define PUSH(v) PUSH32(make_reg(0, v))
@@ -236,7 +208,7 @@ ExecStack *execute_method(EngineState *s, uint16 script, uint16 pubfunct, StackP
 	Script *scr = s->seg_manager->getScriptIfLoaded(seg);
 
 	if (!scr)  // Script not present yet?
-		seg = script_instantiate(s, script);
+		seg = script_instantiate(s->resmgr, s->seg_manager, s->_version, ((SciEngine*)g_engine)->getKernel()->hasOldScriptHeader(), script);
 	else
 		scr->unmarkDeleted();
 
@@ -313,7 +285,7 @@ ExecStack *send_selector(EngineState *s, reg_t send_obj, reg_t work_obj, StackPt
 			Breakpoint *bp;
 			char method_name [256];
 
-			sprintf(method_name, "%s::%s", obj_get_name(s, send_obj), ((SciEngine*)g_engine)->getKernel()->getSelectorName(selector).c_str());
+			sprintf(method_name, "%s::%s", obj_get_name(s->seg_manager, s->_version, send_obj), ((SciEngine*)g_engine)->getKernel()->getSelectorName(selector).c_str());
 
 			bp = s->bp_list;
 			while (bp) {
@@ -501,10 +473,6 @@ void vm_handle_fatal_error(EngineState *s, int line, const char *file) {
 	error("Fatal VM error in %s, L%d; aborting...", file, line);
 }
 
-static Script *script_locate_by_segment(EngineState *s, SegmentId seg) {
-	return s->seg_manager->getScriptIfLoaded(seg);
-}
-
 static reg_t pointer_add(EngineState *s, reg_t base, int offset) {
 	MemObject *mobj = GET_SEGMENT_ANY(*s->seg_manager, base.segment);
 
@@ -559,8 +527,8 @@ void run_vm(EngineState *s, int restoring) {
 	// Current execution data:
 	scriptState.xs = &(s->_executionStack.back());
 	ExecStack *xs_new = NULL;
-	Object *obj = obj_get(s, scriptState.xs->objp);
-	Script *local_script = script_locate_by_segment(s, scriptState.xs->local_segment);
+	Object *obj = obj_get(s->seg_manager, s->_version, scriptState.xs->objp);
+	Script *local_script = s->seg_manager->getScriptIfLoaded(scriptState.xs->local_segment);
 	int old_execution_stack_base = s->execution_stack_base;
 	// Used to detect the stack bottom, for "physical" returns
 	const byte *code_buf = NULL; // (Avoid spurious warning)
@@ -606,7 +574,7 @@ void run_vm(EngineState *s, int restoring) {
 			scriptState.xs = &(s->_executionStack.back());
 			s->_executionStackPosChanged = false;
 
-			scr = script_locate_by_segment(s, scriptState.xs->addr.pc.segment);
+			scr = s->seg_manager->getScriptIfLoaded(scriptState.xs->addr.pc.segment);
 			if (!scr) {
 				// No script? Implicit return via fake instruction buffer
 				warning("Running on non-existant script in segment %x", scriptState.xs->addr.pc.segment);
@@ -619,12 +587,12 @@ void run_vm(EngineState *s, int restoring) {
 				scr = NULL;
 				obj = NULL;
 			} else {
-				obj = obj_get(s, scriptState.xs->objp);
+				obj = obj_get(s->seg_manager, s->_version, scriptState.xs->objp);
 				code_buf = scr->buf;
 #ifndef DISABLE_VALIDATIONS
 				code_buf_size = scr->buf_size;
 #endif
-				local_script = script_locate_by_segment(s, scriptState.xs->local_segment);
+				local_script = s->seg_manager->getScriptIfLoaded(scriptState.xs->local_segment);
 				if (!local_script) {
 					warning("Could not find local script from segment %x", scriptState.xs->local_segment);
 					local_script = NULL;
@@ -1077,7 +1045,7 @@ void run_vm(EngineState *s, int restoring) {
 			break;
 
 		case 0x28: // class
-			s->r_acc = get_class_address(s, (unsigned)opparams[0], SCRIPT_GET_LOCK,
+			s->r_acc = s->seg_manager->get_class_address((unsigned)opparams[0], SCRIPT_GET_LOCK,
 											scriptState.xs->addr.pc);
 			break;
 
@@ -1097,7 +1065,7 @@ void run_vm(EngineState *s, int restoring) {
 			break;
 
 		case 0x2b: // super
-			r_temp = get_class_address(s, opparams[0], SCRIPT_GET_LOAD, scriptState.xs->addr.pc);
+			r_temp = s->seg_manager->get_class_address(opparams[0], SCRIPT_GET_LOAD, scriptState.xs->addr.pc);
 
 			if (!r_temp.segment)
 				error("[VM]: Invalid superclass in object");
@@ -1432,6 +1400,7 @@ void run_vm(EngineState *s, int restoring) {
 static int _obj_locate_varselector(EngineState *s, Object *obj, Selector slc) {
 	// Determines if obj explicitly defines slc as a varselector
 	// Returns -1 if not found
+	SciVersion version = s->_version;	// for the selector defines
 
 	if (s->_version < SCI_VERSION_1_1) {
 		int varnum = obj->variable_names_nr;
@@ -1452,7 +1421,7 @@ static int _obj_locate_varselector(EngineState *s, Object *obj, Selector slc) {
 		int varnum = obj->_variables[1].offset;
 
 		if (!(obj->_variables[SCRIPT_INFO_SELECTOR].offset & SCRIPT_INFO_CLASS))
-			buf = ((byte *) obj_get(s, obj->_variables[SCRIPT_SUPERCLASS_SELECTOR])->base_vars);
+			buf = ((byte *) obj_get(s->seg_manager, s->_version, obj->_variables[SCRIPT_SUPERCLASS_SELECTOR])->base_vars);
 
 		for (i = 0; i < varnum; i++)
 			if (READ_LE_UINT16(buf + (i << 1)) == slc) // Found it?
@@ -1478,6 +1447,7 @@ static int _class_locate_funcselector(EngineState *s, Object *obj, Selector slc)
 
 static SelectorType _lookup_selector_function(EngineState *s, int seg_id, Object *obj, Selector selector_id, reg_t *fptr) {
 	int index;
+	SciVersion version = s->_version;	// for the selector defines
 
 	// "recursive" lookup
 
@@ -1492,7 +1462,7 @@ static SelectorType _lookup_selector_function(EngineState *s, int seg_id, Object
 			return kSelectorMethod;
 		} else {
 			seg_id = obj->_variables[SCRIPT_SUPERCLASS_SELECTOR].segment;
-			obj = obj_get(s, obj->_variables[SCRIPT_SUPERCLASS_SELECTOR]);
+			obj = obj_get(s->seg_manager, s->_version, obj->_variables[SCRIPT_SUPERCLASS_SELECTOR]);
 		}
 	}
 
@@ -1500,9 +1470,10 @@ static SelectorType _lookup_selector_function(EngineState *s, int seg_id, Object
 }
 
 SelectorType lookup_selector(EngineState *s, reg_t obj_location, Selector selector_id, ObjVarRef *varp, reg_t *fptr) {
-	Object *obj = obj_get(s, obj_location);
+	Object *obj = obj_get(s->seg_manager, s->_version, obj_location);
 	Object *species;
 	int index;
+	SciVersion version = s->_version;	// for the selector defines
 
 	// Early SCI versions used the LSB in the selector ID as a read/write
 	// toggle, meaning that we must remove it for selector lookup.
@@ -1517,7 +1488,7 @@ SelectorType lookup_selector(EngineState *s, reg_t obj_location, Selector select
 	if (IS_CLASS(obj))
 		species = obj;
 	else
-		species = obj_get(s, obj->_variables[SCRIPT_SPECIES_SELECTOR]);
+		species = obj_get(s->seg_manager, s->_version, obj->_variables[SCRIPT_SPECIES_SELECTOR]);
 
 
 	if (!obj) {
@@ -1540,65 +1511,27 @@ SelectorType lookup_selector(EngineState *s, reg_t obj_location, Selector select
 	return _lookup_selector_function(s, obj_location.segment, obj, selector_id, fptr);
 }
 
-SegmentId script_get_segment(EngineState *s, int script_nr, SCRIPT_GET load) {
-	SegmentId segment;
-
-	if ((load & SCRIPT_GET_LOAD) == SCRIPT_GET_LOAD)
-		script_instantiate(s, script_nr);
-
-	segment = s->seg_manager->segGet(script_nr);
-
-	if (segment > 0) {
-		if ((load & SCRIPT_GET_LOCK) == SCRIPT_GET_LOCK)
-			s->seg_manager->getScript(segment)->incrementLockers();
-
-		return segment;
-	} else
-		return 0;
+reg_t script_lookup_export(SegManager *segManager, int script_nr, int export_index) {
+	SegmentId seg = segManager->getSegment(script_nr, SCRIPT_GET_DONT_LOAD);
+	Script *script = segManager->getScriptIfLoaded(seg);
+	return make_reg(seg, READ_LE_UINT16((byte *)(script->export_table + export_index)));
 }
 
-reg_t script_lookup_export(EngineState *s, int script_nr, int export_index) {
-	SegmentId seg = script_get_segment(s, script_nr, SCRIPT_GET_DONT_LOAD);
-	Script *script = NULL;
+#define INST_LOOKUP_CLASS(id) ((id == 0xffff)? NULL_REG : segManager->get_class_address(id, SCRIPT_GET_LOCK, reg))
 
-#ifndef DISABLE_VALIDATIONS
-	if (!seg)
-		error("script_lookup_export(): script.%03d (0x%x) is invalid or not loaded",
-				script_nr, script_nr);
-#endif
-
-	script = script_locate_by_segment(s, seg);
-
-#ifndef DISABLE_VALIDATIONS
-	if (script && export_index < script->exports_nr && export_index >= 0)
-#endif
-		return make_reg(seg, READ_LE_UINT16((byte *)(script->export_table + export_index)));
-#ifndef DISABLE_VALIDATIONS
-	else {
-		if (!script)
-			error("script_lookup_export(): script.%03d missing", script_nr);
-		else
-			error("script_lookup_export(): script.%03d: Sought invalid export %d/%d",
-			      script_nr, export_index, script->exports_nr);
-	}
-#endif
-}
-
-#define INST_LOOKUP_CLASS(id) ((id == 0xffff)? NULL_REG : get_class_address(s, id, SCRIPT_GET_LOCK, reg))
-
-int script_instantiate_common(EngineState *s, int script_nr, Resource **script, Resource **heap, int *was_new) {
+int script_instantiate_common(ResourceManager *resMgr, SegManager *segManager, SciVersion version, int script_nr, Resource **script, Resource **heap, int *was_new) {
 	int seg_id;
 	reg_t reg;
 
 	*was_new = 1;
 
-	*script = s->resmgr->findResource(ResourceId(kResourceTypeScript, script_nr), 0);
-	if (s->_version >= SCI_VERSION_1_1)
-		*heap = s->resmgr->findResource(ResourceId(kResourceTypeHeap, script_nr), 0);
+	*script = resMgr->findResource(ResourceId(kResourceTypeScript, script_nr), 0);
+	if (version >= SCI_VERSION_1_1)
+		*heap = resMgr->findResource(ResourceId(kResourceTypeHeap, script_nr), 0);
 
-	if (!*script || (s->_version >= SCI_VERSION_1_1 && !heap)) {
+	if (!*script || (version >= SCI_VERSION_1_1 && !heap)) {
 		warning("Script 0x%x requested but not found", script_nr);
-		if (s->_version >= SCI_VERSION_1_1) {
+		if (version >= SCI_VERSION_1_1) {
 			if (*heap)
 				warning("Inconsistency: heap resource WAS found");
 			else if (*script)
@@ -1607,13 +1540,8 @@ int script_instantiate_common(EngineState *s, int script_nr, Resource **script,
 		return 0;
 	}
 
-	if (NULL == s) {
-		warning("script_instantiate_common(): script_instantiate(): NULL passed for \"s\"");
-		return 0;
-	}
-
-	seg_id = s->seg_manager->segGet(script_nr);
-	Script *scr = script_locate_by_segment(s, seg_id);
+	seg_id = segManager->segGet(script_nr);
+	Script *scr = segManager->getScriptIfLoaded(seg_id);
 	if (scr) {
 		if (!scr->isMarkedAsDeleted()) {
 			scr->incrementLockers();
@@ -1622,14 +1550,14 @@ int script_instantiate_common(EngineState *s, int script_nr, Resource **script,
 			scr->freeScript();
 		}
 	} else {
-		scr = s->seg_manager->allocateScript(s, script_nr, &seg_id);
+		scr = segManager->allocateScript(script_nr, &seg_id);
 		if (!scr) {  // ALL YOUR SCRIPT BASE ARE BELONG TO US
 			error("Not enough heap space for script size 0x%x of script 0x%x (Should this happen?)", (*script)->size, script_nr);
 			return 0;
 		}
 	}
 
-	s->seg_manager->initialiseScript(*scr, s, script_nr);
+	segManager->initialiseScript(*scr, script_nr);
 
 	reg.segment = seg_id;
 	reg.offset = 0;
@@ -1645,7 +1573,7 @@ int script_instantiate_common(EngineState *s, int script_nr, Resource **script,
 	return seg_id;
 }
 
-int script_instantiate_sci0(EngineState *s, int script_nr) {
+int script_instantiate_sci0(ResourceManager *resMgr, SegManager *segManager, SciVersion version, bool oldScriptHeader, int script_nr) {
 	int objtype;
 	unsigned int objlength;
 	reg_t reg;
@@ -1655,7 +1583,7 @@ int script_instantiate_sci0(EngineState *s, int script_nr) {
 	Resource *script;
 	int was_new;
 
-	seg_id = script_instantiate_common(s, script_nr, &script, NULL, &was_new);
+	seg_id = script_instantiate_common(resMgr, segManager, version, script_nr, &script, NULL, &was_new);
 
 	if (was_new)
 		return seg_id;
@@ -1663,9 +1591,9 @@ int script_instantiate_sci0(EngineState *s, int script_nr) {
 	reg.segment = seg_id;
 	reg.offset = 0;
 
-	Script *scr = s->seg_manager->getScript(seg_id);
+	Script *scr = segManager->getScript(seg_id);
 
-	if (((SciEngine*)g_engine)->getKernel()->hasOldScriptHeader()) {
+	if (oldScriptHeader) {
 		//
 		int locals_nr = READ_LE_UINT16(script->data);
 
@@ -1678,7 +1606,7 @@ int script_instantiate_sci0(EngineState *s, int script_nr) {
 		magic_pos_adder = 2;  // Step over the funny prefix
 
 		if (locals_nr)
-			s->seg_manager->scriptInitialiseLocalsZero(reg.segment, locals_nr);
+			segManager->scriptInitialiseLocalsZero(reg.segment, locals_nr);
 
 	} else {
 		scr->mcpyInOut(0, script->data, script->size);
@@ -1717,24 +1645,24 @@ int script_instantiate_sci0(EngineState *s, int script_nr) {
 			break;
 
 		case SCI_OBJ_LOCALVARS:
-			s->seg_manager->scriptInitialiseLocals(data_base);
+			segManager->scriptInitialiseLocals(data_base);
 			break;
 
 		case SCI_OBJ_CLASS: {
 			int classpos = addr.offset - SCRIPT_OBJECT_MAGIC_OFFSET;
 			int species;
 			species = scr->getHeap(addr.offset - SCRIPT_OBJECT_MAGIC_OFFSET + SCRIPT_SPECIES_OFFSET);
-			if (species < 0 || species >= (int)s->_classtable.size()) {
+			if (species < 0 || species >= (int)segManager->_classtable.size()) {
 				error("Invalid species %d(0x%x) not in interval "
 				          "[0,%d) while instantiating script %d\n",
-				          species, species, s->_classtable.size(),
+				          species, species, segManager->_classtable.size(),
 				          script_nr);
 				return 1;
 			}
 
-			s->_classtable[species].script = script_nr;
-			s->_classtable[species].reg = addr;
-			s->_classtable[species].reg.offset = classpos;
+			segManager->_classtable[species].script = script_nr;
+			segManager->_classtable[species].reg = addr;
+			segManager->_classtable[species].reg.offset = classpos;
 			// Set technical class position-- into the block allocated for it
 		}
 		break;
@@ -1760,17 +1688,17 @@ int script_instantiate_sci0(EngineState *s, int script_nr) {
 
 		switch (objtype) {
 		case SCI_OBJ_CODE:
-			s->seg_manager->scriptAddCodeBlock(addr);
+			segManager->scriptAddCodeBlock(addr);
 			break;
 		case SCI_OBJ_OBJECT:
 		case SCI_OBJ_CLASS: { // object or class?
-			Object *obj = s->seg_manager->scriptObjInit(s, addr);
+			Object *obj = segManager->scriptObjInit(addr);
 			Object *base_obj;
 
 			// Instantiate the superclass, if neccessary
 			obj->_variables[SCRIPT_SPECIES_SELECTOR] = INST_LOOKUP_CLASS(obj->_variables[SCRIPT_SPECIES_SELECTOR].offset);
 
-			base_obj = obj_get(s, obj->_variables[SCRIPT_SPECIES_SELECTOR]);
+			base_obj = obj_get(segManager, version, obj->_variables[SCRIPT_SPECIES_SELECTOR]);
 			obj->variable_names_nr = base_obj->_variables.size();
 			obj->base_obj = base_obj->base_obj;
 			// Copy base from species class, as we need its selector IDs
@@ -1791,24 +1719,24 @@ int script_instantiate_sci0(EngineState *s, int script_nr) {
 	} while ((objtype != 0) && (((unsigned)reg.offset) < script->size - 2));
 
 	if (relocation >= 0)
-		s->seg_manager->scriptRelocate(make_reg(reg.segment, relocation));
+		segManager->scriptRelocate(make_reg(reg.segment, relocation));
 
 	return reg.segment;		// instantiation successful
 }
 
-int script_instantiate_sci11(EngineState *s, int script_nr) {
+int script_instantiate_sci11(ResourceManager *resMgr, SegManager *segManager, SciVersion version, int script_nr) {
 	Resource *script, *heap;
 	int seg_id;
 	int heap_start;
 	reg_t reg;
 	int was_new;
 
-	seg_id = script_instantiate_common(s, script_nr, &script, &heap, &was_new);
+	seg_id = script_instantiate_common(resMgr, segManager, version, script_nr, &script, &heap, &was_new);
 
 	if (was_new)
 		return seg_id;
 
-	Script *scr = s->seg_manager->getScript(seg_id);
+	Script *scr = segManager->getScript(seg_id);
 
 	heap_start = script->size;
 	if (script->size & 2)
@@ -1822,28 +1750,28 @@ int script_instantiate_sci11(EngineState *s, int script_nr) {
 
 	reg.segment = seg_id;
 	reg.offset = heap_start + 4;
-	s->seg_manager->scriptInitialiseLocals(reg);
+	segManager->scriptInitialiseLocals(reg);
 
-	s->seg_manager->scriptRelocateExportsSci11(seg_id);
-	s->seg_manager->scriptInitialiseObjectsSci11(s, seg_id);
+	segManager->scriptRelocateExportsSci11(seg_id);
+	segManager->scriptInitialiseObjectsSci11(seg_id);
 
 	reg.offset = READ_LE_UINT16(heap->data);
-	s->seg_manager->heapRelocate(reg);
+	segManager->heapRelocate(reg);
 
 	return seg_id;
 }
 
-int script_instantiate(EngineState *s, int script_nr) {
-	if (s->_version >= SCI_VERSION_1_1)
-		return script_instantiate_sci11(s, script_nr);
+int script_instantiate(ResourceManager *resMgr, SegManager *segManager, SciVersion version, bool oldScriptHeader, int script_nr) {
+	if (version >= SCI_VERSION_1_1)
+		return script_instantiate_sci11(resMgr, segManager, version, script_nr);
 	else
-		return script_instantiate_sci0(s, script_nr);
+		return script_instantiate_sci0(resMgr, segManager, version, oldScriptHeader, script_nr);
 }
 
-void script_uninstantiate_sci0(EngineState *s, int script_nr, SegmentId seg) {
+void script_uninstantiate_sci0(SegManager *segManager, SciVersion version, int script_nr, SegmentId seg) {
 	reg_t reg = make_reg(seg, ((SciEngine*)g_engine)->getKernel()->hasOldScriptHeader() ? 2 : 0);
 	int objtype, objlength;
-	Script *scr = s->seg_manager->getScript(seg);
+	Script *scr = segManager->getScript(seg);
 
 	// Make a pass over the object in order uninstantiate all superclasses
 	objlength = 0;
@@ -1866,13 +1794,13 @@ void script_uninstantiate_sci0(EngineState *s, int script_nr, SegmentId seg) {
 			superclass = scr->getHeap(reg.offset + SCRIPT_SUPERCLASS_OFFSET); // Get superclass...
 
 			if (superclass >= 0) {
-				int superclass_script = s->_classtable[superclass].script;
+				int superclass_script = segManager->_classtable[superclass].script;
 
 				if (superclass_script == script_nr) {
 					if (scr->getLockers())
 						scr->decrementLockers();  // Decrease lockers if this is us ourselves
 				} else
-					script_uninstantiate(s, superclass_script);
+					script_uninstantiate(segManager, version, superclass_script);
 				// Recurse to assure that the superclass lockers number gets decreased
 			}
 
@@ -1884,11 +1812,9 @@ void script_uninstantiate_sci0(EngineState *s, int script_nr, SegmentId seg) {
 	} while (objtype != 0);
 }
 
-void script_uninstantiate(EngineState *s, int script_nr) {
-	reg_t reg = make_reg(0, ((SciEngine*)g_engine)->getKernel()->hasOldScriptHeader() ? 2 : 0);
-
-	reg.segment = s->seg_manager->segGet(script_nr);
-	Script *scr = script_locate_by_segment(s, reg.segment);
+void script_uninstantiate(SegManager *segManager, SciVersion version, int script_nr) {
+	SegmentId segment = segManager->segGet(script_nr);
+	Script *scr = segManager->getScriptIfLoaded(segment);
 
 	if (!scr) {   // Is it already loaded?
 		//warning("unloading script 0x%x requested although not loaded", script_nr);
@@ -1902,12 +1828,12 @@ void script_uninstantiate(EngineState *s, int script_nr) {
 		return;
 
 	// Free all classtable references to this script
-	for (uint i = 0; i < s->_classtable.size(); i++)
-		if (s->_classtable[i].reg.segment == reg.segment)
-			s->_classtable[i].reg = NULL_REG;
+	for (uint i = 0; i < segManager->_classtable.size(); i++)
+		if (segManager->_classtable[i].reg.segment == segment)
+			segManager->_classtable[i].reg = NULL_REG;
 
-	if (s->_version < SCI_VERSION_1_1)
-		script_uninstantiate_sci0(s, script_nr, reg.segment);
+	if (version < SCI_VERSION_1_1)
+		script_uninstantiate_sci0(segManager, version, script_nr, segment);
 	else
 		warning("FIXME: Add proper script uninstantiation for SCI 1.1");
 
@@ -1999,8 +1925,8 @@ int game_run(EngineState **_s) {
 	return 0;
 }
 
-Object *obj_get(EngineState *s, reg_t offset) {
-	MemObject *mobj = GET_OBJECT_SEGMENT(*s->seg_manager, offset.segment);
+Object *obj_get(SegManager *segManager, SciVersion version, reg_t offset) {
+	MemObject *mobj = GET_OBJECT_SEGMENT(*segManager, offset.segment);
 	Object *obj = NULL;
 	int idx;
 
@@ -2023,8 +1949,8 @@ Object *obj_get(EngineState *s, reg_t offset) {
 	return obj;
 }
 
-const char *obj_get_name(EngineState *s, reg_t pos) {
-	Object *obj = obj_get(s, pos);
+const char *obj_get_name(SegManager *segManager, SciVersion version, reg_t pos) {
+	Object *obj = obj_get(segManager, version, pos);
 	if (!obj)
 		return "<no such object>";
 
@@ -2032,7 +1958,7 @@ const char *obj_get_name(EngineState *s, reg_t pos) {
 	if (nameReg.isNull())
 		return "<no name>";
 
-	const char *name = (const char*)s->seg_manager->dereference(obj->_variables[SCRIPT_NAME_SELECTOR], NULL);
+	const char *name = (const char*)segManager->dereference(obj->_variables[SCRIPT_NAME_SELECTOR], NULL);
 	if (!name)
 		return "<invalid name>";
 
@@ -2056,7 +1982,7 @@ void shrink_execution_stack(EngineState *s, uint size) {
 }
 
 reg_t* ObjVarRef::getPointer(EngineState *s) const {
-	Object *o = obj_get(s, obj);
+	Object *o = obj_get(s->seg_manager, s->_version, obj);
 	if (!o) return 0;
 	return &(o->_variables[varindex]);
 }