SCI: Rename Script class members, change Script from struct to class

svn-id: r44126

13 files changed, 291 insertions, 289 deletions

diff --git a/engines/sci/console.cpp b/engines/sci/console.cpp
index 8cdad3f6e1..0740062624 100644
--- a/engines/sci/console.cpp
+++ b/engines/sci/console.cpp
@@ -1320,7 +1320,7 @@ bool Console::cmdPrintSegmentTable(int argc, const char **argv) {
 
 			switch (mobj->getType()) {
 			case MEM_OBJ_SCRIPT:
-				DebugPrintf("S  script.%03d l:%d ", (*(Script *)mobj).nr, (*(Script *)mobj).lockers);
+				DebugPrintf("S  script.%03d l:%d ", (*(Script *)mobj)._nr, (*(Script *)mobj).getLockers());
 				break;
 
 			case MEM_OBJ_CLONES:
@@ -1384,16 +1384,16 @@ bool Console::segmentInfo(int nr) {
 
 	case MEM_OBJ_SCRIPT: {
 		Script *scr = (Script *)mobj;
-		DebugPrintf("script.%03d locked by %d, bufsize=%d (%x)\n", scr->nr, scr->lockers, (uint)scr->buf_size, (uint)scr->buf_size);
-		if (scr->export_table)
-			DebugPrintf("  Exports: %4d at %d\n", scr->exports_nr, (int)(((byte *)scr->export_table) - ((byte *)scr->buf)));
+		DebugPrintf("script.%03d locked by %d, bufsize=%d (%x)\n", scr->_nr, scr->getLockers(), (uint)scr->_bufSize, (uint)scr->_bufSize);
+		if (scr->_exportTable)
+			DebugPrintf("  Exports: %4d at %d\n", scr->_numExports, (int)(((byte *)scr->_exportTable) - ((byte *)scr->_buf)));
 		else
 			DebugPrintf("  Exports: none\n");
 
-		DebugPrintf("  Synonyms: %4d\n", scr->synonyms_nr);
+		DebugPrintf("  Synonyms: %4d\n", scr->_numSynonyms);
 
-		if (scr->locals_block)
-			DebugPrintf("  Locals : %4d in segment 0x%x\n", scr->locals_block->_locals.size(), scr->locals_segment);
+		if (scr->_localsBlock)
+			DebugPrintf("  Locals : %4d in segment 0x%x\n", scr->_localsBlock->_locals.size(), scr->_localsSegment);
 		else
 			DebugPrintf("  Locals : none\n");
 
@@ -2104,7 +2104,7 @@ bool Console::cmdBacktrace(int argc, const char **argv) {
 
 		printf(" argp:ST:%04x", (unsigned)(call.variables_argp - _vm->_gamestate->stack_base));
 		if (call.type == EXEC_STACK_TYPE_CALL)
-			printf(" script: %d", (*(Script *)_vm->_gamestate->segMan->_heap[call.addr.pc.segment]).nr);
+			printf(" script: %d", (*(Script *)_vm->_gamestate->segMan->_heap[call.addr.pc.segment])._nr);
 		printf("\n");
 	}
 
@@ -3090,7 +3090,7 @@ int Console::printObject(reg_t pos) {
 		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)
-		DebugPrintf("\nOwner script:\t%d\n", s->segMan->getScript(pos.segment)->nr);
+		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 94413a3c50..d6f9bab2af 100644
--- a/engines/sci/engine/gc.cpp
+++ b/engines/sci/engine/gc.cpp
@@ -48,15 +48,15 @@ struct WorklistManager {
 	}
 };
 
-static reg_t_hash_map *normalise_hashmap_ptrs(SegManager *sm, reg_t_hash_map &nonnormal_map) {
+static reg_t_hash_map *normalise_hashmap_ptrs(SegManager *segMan, reg_t_hash_map &nonnormal_map) {
 	reg_t_hash_map *normal_map = new 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 < sm->_heap.size()) ? sm->_heap[reg.segment] : NULL;
+		MemObject *mobj = (reg.segment < segMan->_heap.size()) ? segMan->_heap[reg.segment] : NULL;
 
 		if (mobj) {
-			reg = mobj->findCanonicAddress(sm, reg);
+			reg = mobj->findCanonicAddress(segMan, reg);
 			normal_map->setVal(reg, true);
 		}
 	}
@@ -71,7 +71,7 @@ void add_outgoing_refs(void *refcon, reg_t addr) {
 }
 
 reg_t_hash_map *find_all_used_references(EngineState *s) {
-	SegManager *sm = s->segMan;
+	SegManager *segMan = s->segMan;
 	reg_t_hash_map *normal_map = NULL;
 	WorklistManager wm;
 	uint i;
@@ -109,14 +109,14 @@ reg_t_hash_map *find_all_used_references(EngineState *s) {
 	debugC(2, kDebugLevelGC, "[GC] -- Finished adding execution stack");
 
 	// Init: Explicitly loaded scripts
-	for (i = 1; i < sm->_heap.size(); i++)
-		if (sm->_heap[i]
-		        && sm->_heap[i]->getType() == MEM_OBJ_SCRIPT) {
-			Script *script = (Script *)sm->_heap[i];
+	for (i = 1; i < segMan->_heap.size(); i++)
+		if (segMan->_heap[i]
+		        && segMan->_heap[i]->getType() == MEM_OBJ_SCRIPT) {
+			Script *script = (Script *)segMan->_heap[i];
 
-			if (script->lockers) { // Explicitly loaded?
+			if (script->getLockers()) { // Explicitly loaded?
 				// Locals, if present
-				wm.push(make_reg(script->locals_segment, 0));
+				wm.push(make_reg(script->_localsSegment, 0));
 
 				// All objects (may be classes, may be indirectly reachable)
 				for (uint obj_nr = 0; obj_nr < script->_objects.size(); obj_nr++) {
@@ -133,13 +133,13 @@ reg_t_hash_map *find_all_used_references(EngineState *s) {
 		wm._worklist.pop_back();
 		if (reg.segment != s->stack_segment) { // No need to repeat this one
 			debugC(2, kDebugLevelGC, "[GC] Checking %04x:%04x\n", PRINT_REG(reg));
-			if (reg.segment < sm->_heap.size() && sm->_heap[reg.segment])
-				sm->_heap[reg.segment]->listAllOutgoingReferences(reg, &wm, add_outgoing_refs, s->resMan->sciVersion());
+			if (reg.segment < segMan->_heap.size() && segMan->_heap[reg.segment])
+				segMan->_heap[reg.segment]->listAllOutgoingReferences(reg, &wm, add_outgoing_refs, s->resMan->sciVersion());
 		}
 	}
 
 	// Normalise
-	normal_map = normalise_hashmap_ptrs(sm, wm._map);
+	normal_map = normalise_hashmap_ptrs(segMan, wm._map);
 
 	return normal_map;
 }
@@ -172,19 +172,19 @@ void free_unless_used(void *refcon, reg_t addr) {
 void run_gc(EngineState *s) {
 	uint seg_nr;
 	deallocator_t deallocator;
-	SegManager *sm = s->segMan;
+	SegManager *segMan = s->segMan;
 
 #ifdef DEBUG_GC
 	debugC(2, kDebugLevelGC, "[GC] Running...\n");
 	memset(&(deallocator.segcount), 0, sizeof(int) * (MEM_OBJ_MAX + 1));
 #endif
 
-	deallocator.segMan = sm;
+	deallocator.segMan = segMan;
 	deallocator.use_map = find_all_used_references(s);
 
-	for (seg_nr = 1; seg_nr < sm->_heap.size(); seg_nr++) {
-		if (sm->_heap[seg_nr] != NULL) {
-			deallocator.mobj = sm->_heap[seg_nr];
+	for (seg_nr = 1; seg_nr < segMan->_heap.size(); seg_nr++) {
+		if (segMan->_heap[seg_nr] != NULL) {
+			deallocator.mobj = segMan->_heap[seg_nr];
 #ifdef DEBUG_GC
 			deallocator.segnames[deallocator.mobj->getType()] = deallocator.mobj->type;	// FIXME: add a segment "name"
 #endif
diff --git a/engines/sci/engine/kernel.cpp b/engines/sci/engine/kernel.cpp
index 6d749b36ee..3bec6359d1 100644
--- a/engines/sci/engine/kernel.cpp
+++ b/engines/sci/engine/kernel.cpp
@@ -641,8 +641,8 @@ int determine_reg_type(SegManager *segMan, reg_t reg, bool allow_invalid) {
 
 	switch (mobj->getType()) {
 	case MEM_OBJ_SCRIPT:
-		if (reg.offset <= (*(Script *)mobj).buf_size && reg.offset >= -SCRIPT_OBJECT_MAGIC_OFFSET
-		        && RAW_IS_OBJECT((*(Script *)mobj).buf + reg.offset)) {
+		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);
 			if (obj)
 				return KSIG_OBJECT;
diff --git a/engines/sci/engine/kmovement.cpp b/engines/sci/engine/kmovement.cpp
index fd115257c9..19de6a99cb 100644
--- a/engines/sci/engine/kmovement.cpp
+++ b/engines/sci/engine/kmovement.cpp
@@ -275,7 +275,7 @@ static void bresenham_autodetect(EngineState *s) {
 			return;
 		}
 
-		buf = s->segMan->getScript(fptr.segment)->buf + fptr.offset;
+		buf = s->segMan->getScript(fptr.segment)->_buf + fptr.offset;
 		handle_movecnt = (s->segMan->sciVersion() <= SCI_VERSION_01 || checksum_bytes(buf, 8) == 0x216) ? INCREMENT_MOVECNT : IGNORE_MOVECNT;
 		printf("b-moveCnt action based on checksum: %s\n", handle_movecnt == IGNORE_MOVECNT ? "ignore" : "increment");
 	} else {
diff --git a/engines/sci/engine/kscripts.cpp b/engines/sci/engine/kscripts.cpp
index d0d34caf03..f3689a6025 100644
--- a/engines/sci/engine/kscripts.cpp
+++ b/engines/sci/engine/kscripts.cpp
@@ -272,14 +272,14 @@ reg_t kScriptID(EngineState *s, int, int argc, reg_t *argv) {
 
 	scr = s->segMan->getScript(scriptSeg);
 
-	if (!scr->exports_nr) {
+	if (!scr->_numExports) {
 		// FIXME: Is this fatal? This occurs in SQ4CD
 		warning("Script 0x%x does not have a dispatch table", script);
 		return NULL_REG;
 	}
 
-	if (index > scr->exports_nr) {
-		error("Dispatch index too big: %d > %d", index, scr->exports_nr);
+	if (index > scr->_numExports) {
+		error("Dispatch index too big: %d > %d", index, scr->_numExports);
 		return NULL_REG;
 	}
 
diff --git a/engines/sci/engine/kstring.cpp b/engines/sci/engine/kstring.cpp
index 97742a0db7..49976ebae8 100644
--- a/engines/sci/engine/kstring.cpp
+++ b/engines/sci/engine/kstring.cpp
@@ -143,29 +143,29 @@ reg_t kSetSynonyms(EngineState *s, int, int argc, reg_t *argv) {
 	while (node) {
 		reg_t objpos = node->value;
 		int seg;
-		int synonyms_nr = 0;
+		int _numSynonyms = 0;
 
 		script = GET_SEL32V(objpos, number);
 		seg = s->segMan->getScriptSegment(script);
 
 		if (seg >= 0)
-			synonyms_nr = s->segMan->getScript(seg)->getSynonymsNr();
+			_numSynonyms = s->segMan->getScript(seg)->getSynonymsNr();
 
-		if (synonyms_nr) {
+		if (_numSynonyms) {
 			byte *synonyms;
 
 			synonyms = s->segMan->getScript(seg)->getSynonyms();
 			if (synonyms) {
 				debugC(2, kDebugLevelParser, "Setting %d synonyms for script.%d\n",
-				          synonyms_nr, script);
+				          _numSynonyms, script);
 
-				if (synonyms_nr > 16384) {
+				if (_numSynonyms > 16384) {
 					error("Segtable corruption: script.%03d has %d synonyms",
-					         script, synonyms_nr);
+					         script, _numSynonyms);
 					/* We used to reset the corrupted value here. I really don't think it's appropriate.
 					 * Lars */
 				} else
-					for (int i = 0; i < synonyms_nr; i++) {
+					for (int i = 0; i < _numSynonyms; i++) {
 						synonym_t tmp;
 						tmp.replaceant = (int16)READ_LE_UINT16(synonyms + i * 4);
 						tmp.replacement = (int16)READ_LE_UINT16(synonyms + i * 4 + 2);
diff --git a/engines/sci/engine/memobj.cpp b/engines/sci/engine/memobj.cpp
index 37f9a3659c..9ed5eb8758 100644
--- a/engines/sci/engine/memobj.cpp
+++ b/engines/sci/engine/memobj.cpp
@@ -77,32 +77,57 @@ MemObject *MemObject::createMemObject(MemObjectType type) {
 	return mem;
 }
 
+Script::Script() {
+	_nr = 0;
+	_buf = NULL;
+	_bufSize = 0;
+	_scriptSize = 0;
+	_heapSize = 0;
+
+	_synonyms = NULL;
+	_heapStart = NULL;
+	_exportTable = NULL;
+
+	_objIndices = NULL;
+
+	_localsOffset = 0;
+	_localsSegment = 0;
+	_localsBlock = NULL;
+
+	_relocated = false;
+	_markedAsDeleted = 0;
+}
+
+Script::~Script() {
+	freeScript();
+}
+
 void Script::freeScript() {
-	free(buf);
-	buf = NULL;
-	buf_size = 0;
+	free(_buf);
+	_buf = NULL;
+	_bufSize = 0;
 
 	_objects.clear();
 
-	delete obj_indices;
-	obj_indices = 0;
+	delete _objIndices;
+	_objIndices = 0;
 	_codeBlocks.clear();
 }
 
 void Script::init() {
-	locals_offset = 0;
-	locals_block = NULL;
+	_localsOffset = 0;
+	_localsBlock = NULL;
 
 	_codeBlocks.clear();
 
+	_relocated = false;
 	_markedAsDeleted = false;
-	relocated = 0;
 
-	obj_indices = new IntMapper();
+	_objIndices = new IntMapper();
 }
 
 Object *Script::allocateObject(uint16 offset) {
-	int idx = obj_indices->checkKey(offset, true);
+	int idx = _objIndices->checkKey(offset, true);
 	if ((uint)idx == _objects.size())
 		_objects.push_back(Object());
 
@@ -110,7 +135,7 @@ Object *Script::allocateObject(uint16 offset) {
 }
 
 Object *Script::getObject(uint16 offset) {
-	int idx = obj_indices->checkKey(offset, false);
+	int idx = _objIndices->checkKey(offset, false);
 	if (idx >= 0 && (uint)idx < _objects.size())
 		return &_objects[idx];
 	else
@@ -118,61 +143,61 @@ Object *Script::getObject(uint16 offset) {
 }
 
 void Script::incrementLockers() {
-	lockers++;
+	_lockers++;
 }
 
 void Script::decrementLockers() {
-	if (lockers > 0)
-		lockers--;
+	if (_lockers > 0)
+		_lockers--;
 }
 
 int Script::getLockers() const {
-	return lockers;
+	return _lockers;
 }
 
-void Script::setLockers(int lockers_) {
-	lockers = lockers_;
+void Script::setLockers(int lockers) {
+	_lockers = lockers;
 }
 
 void Script::setExportTableOffset(int offset) {
 	if (offset) {
-		export_table = (uint16 *)(buf + offset + 2);
-		exports_nr = READ_LE_UINT16((byte *)(export_table - 1));
+		_exportTable = (uint16 *)(_buf + offset + 2);
+		_numExports = READ_LE_UINT16((byte *)(_exportTable - 1));
 	} else {
-		export_table = NULL;
-		exports_nr = 0;
+		_exportTable = NULL;
+		_numExports = 0;
 	}
 }
 
 void Script::setSynonymsOffset(int offset) {
-	synonyms = buf + offset;
+	_synonyms = _buf + offset;
 }
 
 byte *Script::getSynonyms() const {
-	return synonyms;
+	return _synonyms;
 }
 
 void Script::setSynonymsNr(int n) {
-	synonyms_nr = n;
+	_numSynonyms = n;
 }
 
 int Script::getSynonymsNr() const {
-	return synonyms_nr;
+	return _numSynonyms;
 }
 
 // memory operations
 
 void Script::mcpyInOut(int dst, const void *src, size_t n) {
-	if (buf) {
-		assert(dst + n <= buf_size);
-		memcpy(buf + dst, src, n);
+	if (_buf) {
+		assert(dst + n <= _bufSize);
+		memcpy(_buf + dst, src, n);
 	}
 }
 
 int16 Script::getHeap(uint16 offset) const {
-	assert(offset + 1 < (int)buf_size);
-	return READ_LE_UINT16(buf + offset);
-//	return (buf[offset] | (buf[offset+1]) << 8);
+	assert(offset + 1 < (int)_bufSize);
+	return READ_LE_UINT16(_buf + offset);
+//	return (_buf[offset] | (_buf[offset+1]) << 8);
 }
 
 byte *MemObject::dereference(reg_t pointer, int *size) {
@@ -182,18 +207,18 @@ byte *MemObject::dereference(reg_t pointer, int *size) {
 }
 
 bool Script::isValidOffset(uint16 offset) const {
-	return offset < buf_size;
+	return offset < _bufSize;
 }
 
 byte *Script::dereference(reg_t pointer, int *size) {
-	if (pointer.offset > buf_size) {
+	if (pointer.offset > _bufSize) {
 		warning("Attempt to dereference invalid pointer %04x:%04x into script segment (script size=%d)\n",
-				  PRINT_REG(pointer), (uint)buf_size);
+				  PRINT_REG(pointer), (uint)_bufSize);
 		return NULL;
 	}
 	if (size)
-		*size = buf_size - pointer.offset;
-	return buf + pointer.offset;
+		*size = _bufSize - pointer.offset;
+	return _buf + pointer.offset;
 }
 
 bool LocalVariables::isValidOffset(uint16 offset) const {
@@ -260,12 +285,12 @@ reg_t Script::findCanonicAddress(SegManager *segMan, reg_t addr) {
 void Script::freeAtAddress(SegManager *segMan, reg_t addr) {
 	/*
 		debugC(2, kDebugLevelGC, "[GC] Freeing script %04x:%04x\n", PRINT_REG(addr));
-		if (locals_segment)
-			debugC(2, kDebugLevelGC, "[GC] Freeing locals %04x:0000\n", locals_segment);
+		if (_localsSegment)
+			debugC(2, kDebugLevelGC, "[GC] Freeing locals %04x:0000\n", _localsSegment);
 	*/
 
 	if (_markedAsDeleted)
-		segMan->deallocateScript(nr);
+		segMan->deallocateScript(_nr);
 }
 
 void Script::listAllDeallocatable(SegmentId segId, void *param, NoteCallback note) {
@@ -275,12 +300,12 @@ void Script::listAllDeallocatable(SegmentId segId, void *param, NoteCallback not
 void Script::listAllOutgoingReferences(reg_t addr, void *param, NoteCallback note, SciVersion version) {
 	Script *script = this;
 
-	if (addr.offset <= script->buf_size && addr.offset >= -SCRIPT_OBJECT_MAGIC_OFFSET && RAW_IS_OBJECT(script->buf + addr.offset)) {
+	if (addr.offset <= script->_bufSize && addr.offset >= -SCRIPT_OBJECT_MAGIC_OFFSET && RAW_IS_OBJECT(script->_buf + addr.offset)) {
 		Object *obj = getObject(addr.offset);
 		if (obj) {
 			// Note all local variables, if we have a local variable environment
-			if (script->locals_segment)
-				(*note)(param, make_reg(script->locals_segment, 0));
+			if (script->_localsSegment)
+				(*note)(param, make_reg(script->_localsSegment, 0));
 
 			for (uint i = 0; i < obj->_variables.size(); i++)
 				(*note)(param, obj->_variables[i]);
diff --git a/engines/sci/engine/memobj.h b/engines/sci/engine/memobj.h
index 707773add2..500d268bc5 100644
--- a/engines/sci/engine/memobj.h
+++ b/engines/sci/engine/memobj.h
@@ -237,25 +237,28 @@ struct CodeBlock {
 
 
 
-struct Script : public MemObject {
-	int nr; /**< Script number */
-	byte *buf; /**< Static data buffer, or NULL if not used */
-	size_t buf_size;
-	size_t script_size;
-	size_t heap_size;
+class Script : public MemObject {
+public:
+	int _nr; /**< Script number */
+	byte *_buf; /**< Static data buffer, or NULL if not used */
+	size_t _bufSize;
+	size_t _scriptSize;
+	size_t _heapSize;
+
+	byte *_heapStart; /**< Start of heap if SCI1.1, NULL otherwise */
 
-	byte *synonyms; /**< Synonyms block or 0 if not present*/
-	byte *heap_start; /**< Start of heap if SCI1.1, NULL otherwise */
-	uint16 *export_table; /**< Abs. offset of the export table or 0 if not present */
+	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*/
+	int _numSynonyms; /**< Number of entries in the synonyms block */
 
 protected:
-	IntMapper *obj_indices;
+	int _lockers; /**< Number of classes and objects that require this script */
 
-public:
-	int exports_nr; /**< Number of entries in the exports table */
-	int synonyms_nr; /**< Number of entries in the synonyms block */
-	int lockers; /**< Number of classes and objects that require this script */
+	IntMapper *_objIndices;
 
+public:
 	/**
 	 * Table for objects, contains property variables.
 	 * Indexed by the value stored at SCRIPT_LOCALVARPTR_OFFSET,
@@ -263,39 +266,17 @@ public:
 	 */
 	Common::Array<Object> _objects;
 
-	int locals_offset;
-	int locals_segment; /**< The local variable segment */
-	LocalVariables *locals_block;
+	int _localsOffset;
+	int _localsSegment; /**< The local variable segment */
+	LocalVariables *_localsBlock;
 
 	Common::Array<CodeBlock> _codeBlocks;
-	int relocated;
+	bool _relocated;
 	bool _markedAsDeleted;
 
 public:
-	Script() {
-		nr = 0;
-		buf = NULL;
-		buf_size = 0;
-		script_size = 0;
-		heap_size = 0;
-
-		synonyms = NULL;
-		heap_start = NULL;
-		export_table = NULL;
-
-		obj_indices = NULL;
-
-		locals_offset = 0;
-		locals_segment = 0;
-		locals_block = NULL;
-
-		relocated = 0;
-		_markedAsDeleted = 0;
-	}
-
-	~Script() {
-		freeScript();
-	}
+	Script();
+	~Script();
 
 	void freeScript();
 	void init();
diff --git a/engines/sci/engine/savegame.cpp b/engines/sci/engine/savegame.cpp
index 03adf6518e..3b222f26d3 100644
--- a/engines/sci/engine/savegame.cpp
+++ b/engines/sci/engine/savegame.cpp
@@ -242,7 +242,7 @@ void SegManager::saveLoadWithSerializer(Common::Serializer &s) {
 
 		// If we are loading a script, hook it up in the script->segment map.
 		if (s.isLoading() && type == MEM_OBJ_SCRIPT) {
-			_scriptSegMap[((Script *)mobj)->nr] = i;
+			_scriptSegMap[((Script *)mobj)->_nr] = i;
 		}
 	}
 
@@ -379,27 +379,27 @@ void HunkTable::saveLoadWithSerializer(Common::Serializer &s) {
 }
 
 void Script::saveLoadWithSerializer(Common::Serializer &s) {
-	s.syncAsSint32LE(nr);
-	s.syncAsUint32LE(buf_size);
-	s.syncAsUint32LE(script_size);
-	s.syncAsUint32LE(heap_size);
+	s.syncAsSint32LE(_nr);
+	s.syncAsUint32LE(_bufSize);
+	s.syncAsUint32LE(_scriptSize);
+	s.syncAsUint32LE(_heapSize);
 
-	// FIXME: revamp obj_indices handling
-	if (!obj_indices) {
+	// FIXME: revamp _objIndices handling
+	if (!_objIndices) {
 		assert(s.isLoading());
-		obj_indices = new IntMapper();
+		_objIndices = new IntMapper();
 	}
 
-	obj_indices->saveLoadWithSerializer(s);
+	_objIndices->saveLoadWithSerializer(s);
 
-	s.syncAsSint32LE(exports_nr);
-	s.syncAsSint32LE(synonyms_nr);
-	s.syncAsSint32LE(lockers);
+	s.syncAsSint32LE(_numExports);
+	s.syncAsSint32LE(_numSynonyms);
+	s.syncAsSint32LE(_lockers);
 
 	syncArray<Object>(s, _objects);
 
-	s.syncAsSint32LE(locals_offset);
-	s.syncAsSint32LE(locals_segment);
+	s.syncAsSint32LE(_localsOffset);
+	s.syncAsSint32LE(_localsSegment);
 
 	s.syncAsSint32LE(_markedAsDeleted);
 }
@@ -536,17 +536,17 @@ static void reconstruct_stack(EngineState *retval) {
 static void load_script(EngineState *s, Script *scr) {
 	Resource *script, *heap = NULL;
 
-	scr->buf = (byte *)malloc(scr->buf_size);
-	assert(scr->buf);
+	scr->_buf = (byte *)malloc(scr->_bufSize);
+	assert(scr->_buf);
 
-	script = s->resMan->findResource(ResourceId(kResourceTypeScript, scr->nr), 0);
+	script = s->resMan->findResource(ResourceId(kResourceTypeScript, scr->_nr), 0);
 	if (s->resMan->sciVersion() >= SCI_VERSION_1_1)
-		heap = s->resMan->findResource(ResourceId(kResourceTypeHeap, scr->nr), 0);
+		heap = s->resMan->findResource(ResourceId(kResourceTypeHeap, scr->_nr), 0);
 
-	memcpy(scr->buf, script->data, script->size);
+	memcpy(scr->_buf, script->data, script->size);
 	if (s->resMan->sciVersion() >= SCI_VERSION_1_1) {
-		scr->heap_start = scr->buf + scr->script_size;
-		memcpy(scr->heap_start, heap->data, heap->size);
+		scr->_heapStart = scr->_buf + scr->_scriptSize;
+		memcpy(scr->_heapStart, heap->data, heap->size);
 	}
 }
 
@@ -565,24 +565,24 @@ static void reconstruct_scripts(EngineState *s, SegManager *self) {
 
 				// FIXME: Unify this code with script_instantiate_*
 				load_script(s, scr);
-				scr->locals_block = (scr->locals_segment == 0) ? NULL : (LocalVariables *)(s->segMan->_heap[scr->locals_segment]);
+				scr->_localsBlock = (scr->_localsSegment == 0) ? NULL : (LocalVariables *)(s->segMan->_heap[scr->_localsSegment]);
 				if (s->resMan->sciVersion() >= SCI_VERSION_1_1) {
-					scr->export_table = 0;
-					scr->synonyms = 0;
-					if (READ_LE_UINT16(scr->buf + 6) > 0) {
+					scr->_exportTable = 0;
+					scr->_synonyms = 0;
+					if (READ_LE_UINT16(scr->_buf + 6) > 0) {
 						scr->setExportTableOffset(6);
 						s->segMan->scriptRelocateExportsSci11(i);
 					}
 				} else {
-					scr->export_table = (uint16 *) find_unique_script_block(s, scr->buf, SCI_OBJ_EXPORTS);
-					scr->synonyms = find_unique_script_block(s, scr->buf, SCI_OBJ_SYNONYMS);
-					scr->export_table += 3;
+					scr->_exportTable = (uint16 *) find_unique_script_block(s, scr->_buf, SCI_OBJ_EXPORTS);
+					scr->_synonyms = find_unique_script_block(s, scr->_buf, SCI_OBJ_SYNONYMS);
+					scr->_exportTable += 3;
 				}
 				scr->_codeBlocks.clear();
 
 				for (j = 0; j < scr->_objects.size(); j++) {
-					byte *data = scr->buf + scr->_objects[j].pos.offset;
-					scr->_objects[j].base = scr->buf;
+					byte *data = scr->_buf + scr->_objects[j].pos.offset;
+					scr->_objects[j].base = scr->_buf;
 					scr->_objects[j].base_obj = data;
 				}
 				break;
@@ -601,11 +601,11 @@ static void reconstruct_scripts(EngineState *s, SegManager *self) {
 				Script *scr = (Script *)mobj;
 
 				for (j = 0; j < scr->_objects.size(); j++) {
-					byte *data = scr->buf + scr->_objects[j].pos.offset;
+					byte *data = scr->_buf + scr->_objects[j].pos.offset;
 
 					if (s->resMan->sciVersion() >= SCI_VERSION_1_1) {
-						uint16 *funct_area = (uint16 *) (scr->buf + READ_LE_UINT16( data + 6 ));
-						uint16 *prop_area = (uint16 *) (scr->buf + READ_LE_UINT16( data + 4 ));
+						uint16 *funct_area = (uint16 *) (scr->_buf + READ_LE_UINT16( data + 6 ));
+						uint16 *prop_area = (uint16 *) (scr->_buf + READ_LE_UINT16( data + 4 ));
 
 						scr->_objects[j].base_method = funct_area;
 						scr->_objects[j].base_vars = prop_area;
@@ -617,7 +617,7 @@ static void reconstruct_scripts(EngineState *s, SegManager *self) {
 
 						if (!base_obj) {
 							warning("Object without a base class: Script %d, index %d (reg address %04x:%04x",
-								  scr->nr, j, PRINT_REG(scr->_objects[j]._variables[SCRIPT_SPECIES_SELECTOR]));
+								  scr->_nr, j, PRINT_REG(scr->_objects[j]._variables[SCRIPT_SPECIES_SELECTOR]));
 							continue;
 						}
 						scr->_objects[j].variable_names_nr = base_obj->_variables.size();
diff --git a/engines/sci/engine/scriptdebug.cpp b/engines/sci/engine/scriptdebug.cpp
index 92a8f36fc5..4f4f23f1fc 100644
--- a/engines/sci/engine/scriptdebug.cpp
+++ b/engines/sci/engine/scriptdebug.cpp
@@ -117,8 +117,8 @@ reg_t disassemble(EngineState *s, reg_t pos, int print_bw_tag, int print_bytecod
 	} else
 		script_entity = (Script *)mobj;
 
-	scr = script_entity->buf;
-	scr_size = script_entity->buf_size;
+	scr = script_entity->_buf;
+	scr_size = script_entity->_bufSize;
 
 	if (pos.offset >= scr_size) {
 		warning("Trying to disassemble beyond end of script");
@@ -350,7 +350,7 @@ void script_debug(EngineState *s, bool bp) {
 		disassemble(s, scriptState.xs->addr.pc, 0, 1);
 		if (scriptState.seeking == kDebugSeekGlobal)
 			printf("Global %d (0x%x) = %04x:%04x\n", scriptState.seekSpecial,
-			          scriptState.seekSpecial, PRINT_REG(s->script_000->locals_block->_locals[scriptState.seekSpecial]));
+			          scriptState.seekSpecial, PRINT_REG(s->script_000->_localsBlock->_locals[scriptState.seekSpecial]));
 	}
 #endif
 
@@ -364,8 +364,8 @@ void script_debug(EngineState *s, bool bp) {
 
 		if (mobj) {
 			Script *scr = (Script *)mobj;
-			byte *code_buf = scr->buf;
-			int code_buf_size = scr->buf_size;
+			byte *code_buf = scr->_buf;
+			int code_buf_size = scr->_bufSize;
 			int opcode = scriptState.xs->addr.pc.offset >= code_buf_size ? 0 : code_buf[scriptState.xs->addr.pc.offset];
 			int op = opcode >> 1;
 			int paramb1 = scriptState.xs->addr.pc.offset + 1 >= code_buf_size ? 0 : code_buf[scriptState.xs->addr.pc.offset + 1];
diff --git a/engines/sci/engine/seg_manager.cpp b/engines/sci/engine/seg_manager.cpp
index cc43de2603..5e6d15a1d4 100644
--- a/engines/sci/engine/seg_manager.cpp
+++ b/engines/sci/engine/seg_manager.cpp
@@ -138,28 +138,28 @@ void SegManager::setScriptSize(Script &scr, int script_nr) {
 	Resource *heap = _resMan->findResource(ResourceId(kResourceTypeHeap, script_nr), 0);
 	bool oldScriptHeader = (_resMan->sciVersion() == SCI_VERSION_0_EARLY);
 
-	scr.script_size = script->size;
-	scr.heap_size = 0; // Set later
+	scr._scriptSize = script->size;
+	scr._heapSize = 0; // Set later
 
 	if (!script || (_resMan->sciVersion() >= SCI_VERSION_1_1 && !heap)) {
 		error("SegManager::setScriptSize: failed to load %s", !script ? "script" : "heap");
 	}
 	if (oldScriptHeader) {
-		scr.buf_size = script->size + READ_LE_UINT16(script->data) * 2;
+		scr._bufSize = script->size + READ_LE_UINT16(script->data) * 2;
 		//locals_size = READ_LE_UINT16(script->data) * 2;
 	} else if (_resMan->sciVersion() < SCI_VERSION_1_1) {
-		scr.buf_size = script->size;
+		scr._bufSize = script->size;
 	} else {
-		scr.buf_size = script->size + heap->size;
-		scr.heap_size = heap->size;
+		scr._bufSize = script->size + heap->size;
+		scr._heapSize = heap->size;
 
 		// Ensure that the start of the heap resource can be word-aligned.
 		if (script->size & 2) {
-			scr.buf_size++;
-			scr.script_size++;
+			scr._bufSize++;
+			scr._scriptSize++;
 		}
 
-		if (scr.buf_size > 65535) {
+		if (scr._bufSize > 65535) {
 			error("Script and heap sizes combined exceed 64K."
 			          "This means a fundamental design bug was made in SCI\n"
 			          "regarding SCI1.1 games.\nPlease report this so it can be"
@@ -170,29 +170,29 @@ void SegManager::setScriptSize(Script &scr, int script_nr) {
 }
 
 int SegManager::initialiseScript(Script &scr, int script_nr) {
-	// allocate the script.buf
+	// allocate the script._buf
 
 	setScriptSize(scr, script_nr);
-	scr.buf = (byte *)malloc(scr.buf_size);
+	scr._buf = (byte *)malloc(scr._bufSize);
 
 #ifdef DEBUG_segMan
-	printf("scr.buf = %p ", scr.buf);
+	printf("scr._buf = %p ", scr._buf);
 #endif
-	if (!scr.buf) {
+	if (!scr._buf) {
 		scr.freeScript();
 		warning("SegManager: Not enough memory space for script size");
-		scr.buf_size = 0;
+		scr._bufSize = 0;
 		return 0;
 	}
 
 	// Initialize objects
 	scr.init();
-	scr.nr = script_nr;
+	scr._nr = script_nr;
 
 	if (_resMan->sciVersion() >= SCI_VERSION_1_1)
-		scr.heap_start = scr.buf + scr.script_size;
+		scr._heapStart = scr._buf + scr._scriptSize;
 	else
-		scr.heap_start = scr.buf;
+		scr._heapStart = scr._buf;
 
 	return 1;
 }
@@ -205,9 +205,9 @@ int SegManager::deallocate(SegmentId seg, bool recursive) {
 
 	if (mobj->getType() == MEM_OBJ_SCRIPT) {
 		Script *scr = (Script *)mobj;
-		_scriptSegMap.erase(scr->nr);
-		if (recursive && scr->locals_segment)
-			deallocate(scr->locals_segment, recursive);
+		_scriptSegMap.erase(scr->_nr);
+		if (recursive && scr->_localsSegment)
+			deallocate(scr->_localsSegment, recursive);
 	}
 
 	delete mobj;
@@ -282,8 +282,8 @@ Object *SegManager::getObject(reg_t pos) {
 				obj = &(ct->_table[pos.offset]);
 		} else if (mobj->getType() == MEM_OBJ_SCRIPT) {
 			Script *scr = (Script *)mobj;
-			if (pos.offset <= scr->buf_size && pos.offset >= -SCRIPT_OBJECT_MAGIC_OFFSET
-			        && RAW_IS_OBJECT(scr->buf + pos.offset)) {
+			if (pos.offset <= scr->_bufSize && pos.offset >= -SCRIPT_OBJECT_MAGIC_OFFSET
+			        && RAW_IS_OBJECT(scr->_buf + pos.offset)) {
 				obj = scr->getObject(pos.offset);
 			}
 		}
@@ -349,14 +349,14 @@ int SegManager::relocateBlock(Common::Array<reg_t> &block, int block_location, S
 	}
 	block[idx].segment = segment; // Perform relocation
 	if (_resMan->sciVersion() >= SCI_VERSION_1_1)
-		block[idx].offset += getScript(segment)->script_size;
+		block[idx].offset += getScript(segment)->_scriptSize;
 
 	return 1;
 }
 
 int SegManager::relocateLocal(Script *scr, SegmentId segment, int location) {
-	if (scr->locals_block)
-		return relocateBlock(scr->locals_block->_locals, scr->locals_offset, segment, location);
+	if (scr->_localsBlock)
+		return relocateBlock(scr->_localsBlock->_locals, scr->_localsOffset, segment, location);
 	else
 		return 0; // No hands, no cookies
 }
@@ -370,20 +370,20 @@ void SegManager::scriptAddCodeBlock(reg_t location) {
 
 	CodeBlock cb;
 	cb.pos = location;
-	cb.size = READ_LE_UINT16(scr->buf + location.offset - 2);
+	cb.size = READ_LE_UINT16(scr->_buf + location.offset - 2);
 	scr->_codeBlocks.push_back(cb);
 }
 
 void SegManager::scriptRelocate(reg_t block) {
 	Script *scr = getScript(block.segment);
 
-	VERIFY(block.offset < (uint16)scr->buf_size && READ_LE_UINT16(scr->buf + block.offset) * 2 + block.offset < (uint16)scr->buf_size,
+	VERIFY(block.offset < (uint16)scr->_bufSize && READ_LE_UINT16(scr->_buf + block.offset) * 2 + block.offset < (uint16)scr->_bufSize,
 	       "Relocation block outside of script\n");
 
-	int count = READ_LE_UINT16(scr->buf + block.offset);
+	int count = READ_LE_UINT16(scr->_buf + block.offset);
 
 	for (int i = 0; i <= count; i++) {
-		int pos = READ_LE_UINT16(scr->buf + block.offset + 2 + (i * 2));
+		int pos = READ_LE_UINT16(scr->_buf + block.offset + 2 + (i * 2));
 		if (!pos)
 			continue; // FIXME: A hack pending investigation
 
@@ -405,8 +405,8 @@ void SegManager::scriptRelocate(reg_t block) {
 			if (!done) {
 				printf("While processing relocation block %04x:%04x:\n", PRINT_REG(block));
 				printf("Relocation failed for index %04x (%d/%d)\n", pos, i + 1, count);
-				if (scr->locals_block)
-					printf("- locals: %d at %04x\n", scr->locals_block->_locals.size(), scr->locals_offset);
+				if (scr->_localsBlock)
+					printf("- locals: %d at %04x\n", scr->_localsBlock->_locals.size(), scr->_localsOffset);
 				else
 					printf("- No locals\n");
 				for (k = 0; k < scr->_objects.size(); k++)
@@ -421,16 +421,16 @@ void SegManager::scriptRelocate(reg_t block) {
 void SegManager::heapRelocate(reg_t block) {
 	Script *scr = getScript(block.segment);
 
-	VERIFY(block.offset < (uint16)scr->heap_size && READ_LE_UINT16(scr->heap_start + block.offset) * 2 + block.offset < (uint16)scr->buf_size,
+	VERIFY(block.offset < (uint16)scr->_heapSize && READ_LE_UINT16(scr->_heapStart + block.offset) * 2 + block.offset < (uint16)scr->_bufSize,
 	       "Relocation block outside of script\n");
 
-	if (scr->relocated)
+	if (scr->_relocated)
 		return;
-	scr->relocated = 1;
-	int count = READ_LE_UINT16(scr->heap_start + block.offset);
+	scr->_relocated = true;
+	int count = READ_LE_UINT16(scr->_heapStart + block.offset);
 
 	for (int i = 0; i < count; i++) {
-		int pos = READ_LE_UINT16(scr->heap_start + block.offset + 2 + (i * 2)) + scr->script_size;
+		int pos = READ_LE_UINT16(scr->_heapStart + block.offset + 2 + (i * 2)) + scr->_scriptSize;
 
 		if (!relocateLocal(scr, block.segment, pos)) {
 			bool done = false;
@@ -444,8 +444,8 @@ void SegManager::heapRelocate(reg_t block) {
 			if (!done) {
 				printf("While processing relocation block %04x:%04x:\n", PRINT_REG(block));
 				printf("Relocation failed for index %04x (%d/%d)\n", pos, i + 1, count);
-				if (scr->locals_block)
-					printf("- locals: %d at %04x\n", scr->locals_block->_locals.size(), scr->locals_offset);
+				if (scr->_localsBlock)
+					printf("- locals: %d at %04x\n", scr->_localsBlock->_locals.size(), scr->_localsOffset);
 				else
 					printf("- No locals\n");
 				for (k = 0; k < scr->_objects.size(); k++)
@@ -511,14 +511,14 @@ Object *SegManager::scriptObjInit0(reg_t obj_pos) {
 
 	Script *scr = getScript(obj_pos.segment);
 
-	VERIFY(base < scr->buf_size, "Attempt to initialize object beyond end of script\n");
+	VERIFY(base < scr->_bufSize, "Attempt to initialize object beyond end of script\n");
 
 	obj = scr->allocateObject(base);
 
-	VERIFY(base + SCRIPT_FUNCTAREAPTR_OFFSET  < scr->buf_size, "Function area pointer stored beyond end of script\n");
+	VERIFY(base + SCRIPT_FUNCTAREAPTR_OFFSET  < scr->_bufSize, "Function area pointer stored beyond end of script\n");
 
 	{
-		byte *data = (byte *)(scr->buf + base);
+		byte *data = (byte *)(scr->_buf + base);
 		int funct_area = READ_LE_UINT16(data + SCRIPT_FUNCTAREAPTR_OFFSET);
 		int variables_nr;
 		int functions_nr;
@@ -528,7 +528,7 @@ Object *SegManager::scriptObjInit0(reg_t obj_pos) {
 		obj->flags = 0;
 		obj->pos = make_reg(obj_pos.segment, base);
 
-		VERIFY(base + funct_area < scr->buf_size, "Function area pointer references beyond end of script");
+		VERIFY(base + funct_area < scr->_bufSize, "Function area pointer references beyond end of script");
 
 		variables_nr = READ_LE_UINT16(data + SCRIPT_SELECTORCTR_OFFSET);
 		functions_nr = READ_LE_UINT16(data + funct_area - 2);
@@ -536,12 +536,12 @@ Object *SegManager::scriptObjInit0(reg_t obj_pos) {
 
 		VERIFY(base + funct_area + functions_nr * 2
 		       // add again for classes, since those also store selectors
-		       + (is_class ? functions_nr * 2 : 0) < scr->buf_size, "Function area extends beyond end of script");
+		       + (is_class ? functions_nr * 2 : 0) < scr->_bufSize, "Function area extends beyond end of script");
 
 		obj->_variables.resize(variables_nr);
 
 		obj->methods_nr = functions_nr;
-		obj->base = scr->buf;
+		obj->base = scr->_buf;
 		obj->base_obj = data;
 		obj->base_method = (uint16 *)(data + funct_area);
 		obj->base_vars = NULL;
@@ -559,16 +559,16 @@ Object *SegManager::scriptObjInit11(reg_t obj_pos) {
 
 	Script *scr = getScript(obj_pos.segment);
 
-	VERIFY(base < scr->buf_size, "Attempt to initialize object beyond end of script\n");
+	VERIFY(base < scr->_bufSize, "Attempt to initialize object beyond end of script\n");
 
 	obj = scr->allocateObject(base);
 
-	VERIFY(base + SCRIPT_FUNCTAREAPTR_OFFSET < scr->buf_size, "Function area pointer stored beyond end of script\n");
+	VERIFY(base + SCRIPT_FUNCTAREAPTR_OFFSET < scr->_bufSize, "Function area pointer stored beyond end of script\n");
 
 	{
-		byte *data = (byte *)(scr->buf + base);
-		uint16 *funct_area = (uint16 *)(scr->buf + READ_LE_UINT16(data + 6));
-		uint16 *prop_area = (uint16 *)(scr->buf + READ_LE_UINT16(data + 4));
+		byte *data = (byte *)(scr->_buf + base);
+		uint16 *funct_area = (uint16 *)(scr->_buf + READ_LE_UINT16(data + 6));
+		uint16 *prop_area = (uint16 *)(scr->_buf + READ_LE_UINT16(data + 4));
 		int variables_nr;
 		int functions_nr;
 		int is_class;
@@ -577,7 +577,7 @@ Object *SegManager::scriptObjInit11(reg_t obj_pos) {
 		obj->flags = 0;
 		obj->pos = obj_pos;
 
-		VERIFY((byte *) funct_area < scr->buf + scr->buf_size, "Function area pointer references beyond end of script");
+		VERIFY((byte *) funct_area < scr->_buf + scr->_bufSize, "Function area pointer references beyond end of script");
 
 		variables_nr = READ_LE_UINT16(data + 2);
 		functions_nr = READ_LE_UINT16(funct_area);
@@ -586,13 +586,13 @@ Object *SegManager::scriptObjInit11(reg_t obj_pos) {
 		obj->base_method = funct_area;
 		obj->base_vars = prop_area;
 
-		VERIFY(((byte *) funct_area + functions_nr) < scr->buf + scr->buf_size, "Function area extends beyond end of script");
+		VERIFY(((byte *) funct_area + functions_nr) < scr->_buf + scr->_bufSize, "Function area extends beyond end of script");
 
 		obj->variable_names_nr = variables_nr;
 		obj->_variables.resize(variables_nr);
 
 		obj->methods_nr = functions_nr;
-		obj->base = scr->buf;
+		obj->base = scr->_buf;
 		obj->base_obj = data;
 
 		for (i = 0; i < variables_nr; i++)
@@ -611,22 +611,22 @@ Object *SegManager::scriptObjInit(reg_t obj_pos) {
 
 LocalVariables *SegManager::allocLocalsSegment(Script *scr, int count) {
 	if (!count) { // No locals
-		scr->locals_segment = 0;
-		scr->locals_block = NULL;
+		scr->_localsSegment = 0;
+		scr->_localsBlock = NULL;
 		return NULL;
 	} else {
 		LocalVariables *locals;
 
-		if (scr->locals_segment) {
-			locals = (LocalVariables *)_heap[scr->locals_segment];
+		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->script_id == scr->nr, "Re-used locals segment belonged to other script");
+			VERIFY(locals->script_id == scr->_nr, "Re-used locals segment belonged to other script");
 		} else
-			locals = (LocalVariables *)allocSegment(MEM_OBJ_LOCALS, &scr->locals_segment);
+			locals = (LocalVariables *)allocSegment(MEM_OBJ_LOCALS, &scr->_localsSegment);
 
-		scr->locals_block = locals;
-		locals->script_id = scr->nr;
+		scr->_localsBlock = locals;
+		locals->script_id = scr->_nr;
 		locals->_locals.resize(count);
 
 		return locals;
@@ -636,7 +636,7 @@ LocalVariables *SegManager::allocLocalsSegment(Script *scr, int count) {
 void SegManager::scriptInitialiseLocalsZero(SegmentId seg, int count) {
 	Script *scr = getScript(seg);
 
-	scr->locals_offset = -count * 2; // Make sure it's invalid
+	scr->_localsOffset = -count * 2; // Make sure it's invalid
 
 	allocLocalsSegment(scr, count);
 }
@@ -645,25 +645,25 @@ void SegManager::scriptInitialiseLocals(reg_t location) {
 	Script *scr = getScript(location.segment);
 	unsigned int count;
 
-	VERIFY(location.offset + 1 < (uint16)scr->buf_size, "Locals beyond end of script\n");
+	VERIFY(location.offset + 1 < (uint16)scr->_bufSize, "Locals beyond end of script\n");
 
 	if (_resMan->sciVersion() >= SCI_VERSION_1_1)
-		count = READ_LE_UINT16(scr->buf + location.offset - 2);
+		count = READ_LE_UINT16(scr->_buf + location.offset - 2);
 	else
-		count = (READ_LE_UINT16(scr->buf + location.offset - 2) - 4) >> 1;
+		count = (READ_LE_UINT16(scr->_buf + location.offset - 2) - 4) >> 1;
 	// half block size
 
-	scr->locals_offset = location.offset;
+	scr->_localsOffset = location.offset;
 
-	if (!(location.offset + count * 2 + 1 < scr->buf_size)) {
-		warning("Locals extend beyond end of script: offset %04x, count %x vs size %x", location.offset, count, (uint)scr->buf_size);
-		count = (scr->buf_size - location.offset) >> 1;
+	if (!(location.offset + count * 2 + 1 < scr->_bufSize)) {
+		warning("Locals extend beyond end of script: offset %04x, count %x vs size %x", location.offset, count, (uint)scr->_bufSize);
+		count = (scr->_bufSize - location.offset) >> 1;
 	}
 
 	LocalVariables *locals = allocLocalsSegment(scr, count);
 	if (locals) {
 		uint i;
-		byte *base = (byte *)(scr->buf + location.offset);
+		byte *base = (byte *)(scr->_buf + location.offset);
 
 		for (i = 0; i < count; i++)
 			locals->_locals[i].offset = READ_LE_UINT16(base + i * 2);
@@ -672,13 +672,13 @@ void SegManager::scriptInitialiseLocals(reg_t location) {
 
 void SegManager::scriptRelocateExportsSci11(SegmentId seg) {
 	Script *scr = getScript(seg);
-	for (int i = 0; i < scr->exports_nr; i++) {
+	for (int i = 0; i < scr->_numExports; i++) {
 		/* We are forced to use an ugly heuristic here to distinguish function
 		   exports from object/class exports. The former kind points into the
 		   script resource, the latter into the heap resource.  */
-		uint16 location = READ_LE_UINT16((byte *)(scr->export_table + i));
-		if ((location < scr->heap_size - 1) && (READ_LE_UINT16(scr->heap_start + location) == SCRIPT_OBJECT_MAGIC_NUMBER)) {
-			WRITE_LE_UINT16((byte *)(scr->export_table + i), location + scr->heap_start - scr->buf);
+		uint16 location = READ_LE_UINT16((byte *)(scr->_exportTable + i));
+		if ((location < scr->_heapSize - 1) && (READ_LE_UINT16(scr->_heapStart + location) == SCRIPT_OBJECT_MAGIC_NUMBER)) {
+			WRITE_LE_UINT16((byte *)(scr->_exportTable + i), location + scr->_heapStart - scr->_buf);
 		} else {
 			// Otherwise it's probably a function export,
 			// and we don't need to do anything.
@@ -688,17 +688,17 @@ void SegManager::scriptRelocateExportsSci11(SegmentId seg) {
 
 void SegManager::scriptInitialiseObjectsSci11(SegmentId seg) {
 	Script *scr = getScript(seg);
-	byte *seeker = scr->heap_start + 4 + READ_LE_UINT16(scr->heap_start + 2) * 2;
+	byte *seeker = scr->_heapStart + 4 + READ_LE_UINT16(scr->_heapStart + 2) * 2;
 	SciVersion version = _resMan->sciVersion();	// for the selector defines
 
 	while (READ_LE_UINT16(seeker) == SCRIPT_OBJECT_MAGIC_NUMBER) {
 		if (READ_LE_UINT16(seeker + 14) & SCRIPT_INFO_CLASS) {
-			int classpos = seeker - scr->buf;
+			int classpos = seeker - scr->_buf;
 			int species = READ_LE_UINT16(seeker + 10);
 
 			if (species < 0 || species >= (int)_classtable.size()) {
 				error("Invalid species %d(0x%x) not in interval [0,%d) while instantiating script %d",
-				          species, species, _classtable.size(), scr->nr);
+				          species, species, _classtable.size(), scr->_nr);
 				return;
 			}
 
@@ -708,13 +708,13 @@ void SegManager::scriptInitialiseObjectsSci11(SegmentId seg) {
 		seeker += READ_LE_UINT16(seeker + 2) * 2;
 	}
 
-	seeker = scr->heap_start + 4 + READ_LE_UINT16(scr->heap_start + 2) * 2;
+	seeker = scr->_heapStart + 4 + READ_LE_UINT16(scr->_heapStart + 2) * 2;
 	while (READ_LE_UINT16(seeker) == SCRIPT_OBJECT_MAGIC_NUMBER) {
 		reg_t reg;
 		Object *obj;
 
 		reg.segment = seg;
-		reg.offset = seeker - scr->buf;
+		reg.offset = seeker - scr->_buf;
 		obj = scriptObjInit(reg);
 
 #if 0
@@ -736,7 +736,7 @@ void SegManager::scriptInitialiseObjectsSci11(SegmentId seg) {
 		// uses this selector together with -propDict- to compare classes.
 		// For the purpose of Obj::isKindOf, using the script number appears
 		// to be sufficient.
-		obj->_variables[SCRIPT_CLASSSCRIPT_SELECTOR] = make_reg(0, scr->nr);
+		obj->_variables[SCRIPT_CLASSSCRIPT_SELECTOR] = make_reg(0, scr->_nr);
 
 		seeker += READ_LE_UINT16(seeker + 2) * 2;
 	}
@@ -779,15 +779,15 @@ SegmentId SegManager::allocateStringFrags() {
 
 uint16 SegManager::validateExportFunc(int pubfunct, SegmentId seg) {
 	Script *scr = getScript(seg);
-	if (scr->exports_nr <= pubfunct) {
+	if (scr->_numExports <= pubfunct) {
 		warning("validateExportFunc(): pubfunct is invalid");
 		return 0;
 	}
 
 	if (_exportsAreWide)
 		pubfunct *= 2;
-	uint16 offset = READ_LE_UINT16((byte *)(scr->export_table + pubfunct));
-	VERIFY(offset < scr->buf_size, "invalid export function pointer");
+	uint16 offset = READ_LE_UINT16((byte *)(scr->_exportTable + pubfunct));
+	VERIFY(offset < scr->_bufSize, "invalid export function pointer");
 
 	return offset;
 }
diff --git a/engines/sci/engine/state.cpp b/engines/sci/engine/state.cpp
index 09ec5a1f25..4c60b26fa4 100644
--- a/engines/sci/engine/state.cpp
+++ b/engines/sci/engine/state.cpp
@@ -125,7 +125,7 @@ EngineState::~EngineState() {
 }
 
 uint16 EngineState::currentRoomNumber() const {
-	return script_000->locals_block->_locals[13].toUint16();
+	return script_000->_localsBlock->_locals[13].toUint16();
 }
 
 kLanguage EngineState::charToLanguage(const char c) const {
@@ -251,15 +251,15 @@ int EngineState::methodChecksum(reg_t objAddress, Selector sel, int offset, uint
 
 	Script *script = segMan->getScript(fptr.segment);
 
-	if (!script->buf || (fptr.offset + offset < 0))
+	if (!script->_buf || (fptr.offset + offset < 0))
 		return -1;
 
 	fptr.offset += offset;
 
-	if (fptr.offset + size > script->buf_size)
+	if (fptr.offset + size > script->_bufSize)
 		return -1;
 
-	byte *buf = script->buf + fptr.offset;
+	byte *buf = script->_buf + fptr.offset;
 
 	uint sum = 0;
 	for (uint i = 0; i < size; i++)
@@ -359,7 +359,7 @@ SciVersion EngineState::detectLofsType() {
 
 				Script *script = segMan->getScript(fptr.segment);
 
-				if ((script == NULL) || (script->buf == NULL))
+				if ((script == NULL) || (script->_buf == NULL))
 					continue;
 
 				uint offset = fptr.offset;
@@ -367,10 +367,10 @@ SciVersion EngineState::detectLofsType() {
 
 				while (!done) {
 					// Read opcode
-					if (offset >= script->buf_size)
+					if (offset >= script->_bufSize)
 						break;
 
-					byte opcode = script->buf[offset++];
+					byte opcode = script->_buf[offset++];
 					byte opnumber = opcode >> 1;
 
 					if ((opnumber == 0x39) || (opnumber == 0x3a)) {
@@ -378,24 +378,24 @@ SciVersion EngineState::detectLofsType() {
 
 						// Load lofs operand
 						if (opcode & 1) {
-							if (offset >= script->buf_size)
+							if (offset >= script->_bufSize)
 								break;
-							lofs = script->buf[offset++];
+							lofs = script->_buf[offset++];
 						} else {
-							if (offset + 1 >= script->buf_size)
+							if (offset + 1 >= script->_bufSize)
 								break;
-							lofs = READ_LE_UINT16(script->buf + offset);
+							lofs = READ_LE_UINT16(script->_buf + offset);
 							offset += 2;
 						}
 
 						// Check for going out of bounds when interpreting as abs/rel
-						if (lofs >= script->buf_size)
+						if (lofs >= script->_bufSize)
 							couldBeAbs = false;
 
 						if ((signed)offset + (int16)lofs < 0)
 							couldBeRel = false;
 
-						if ((signed)offset + (int16)lofs >= (signed)script->buf_size)
+						if ((signed)offset + (int16)lofs >= (signed)script->_bufSize)
 							couldBeRel = false;
 
 						continue;
diff --git a/engines/sci/engine/vm.cpp b/engines/sci/engine/vm.cpp
index 6d190ccf41..69366758ea 100644
--- a/engines/sci/engine/vm.cpp
+++ b/engines/sci/engine/vm.cpp
@@ -425,17 +425,17 @@ ExecStack *add_exec_stack_varselector(EngineState *s, reg_t objp, int argc, Stac
 }
 
 ExecStack *add_exec_stack_entry(EngineState *s, reg_t pc, StackPtr sp, reg_t objp, int argc,
-								   StackPtr argp, Selector selector, reg_t sendp, int origin, SegmentId locals_segment) {
+								   StackPtr argp, Selector selector, reg_t sendp, int origin, SegmentId _localsSegment) {
 	// Returns new TOS element for the execution stack
-	// locals_segment may be -1 if derived from the called object
+	// _localsSegment may be -1 if derived from the called object
 
 	//printf("Exec stack: [%d/%d], origin %d, at %p\n", s->execution_stack_pos, s->_executionStack.size(), origin, s->execution_stack);
 
 	ExecStack xstack;
 
 	xstack.objp = objp;
-	if (locals_segment != SCI_XS_CALLEE_LOCALS)
-		xstack.local_segment = locals_segment;
+	if (_localsSegment != SCI_XS_CALLEE_LOCALS)
+		xstack.local_segment = _localsSegment;
 	else
 		xstack.local_segment = pc.segment;
 
@@ -531,19 +531,19 @@ void run_vm(EngineState *s, int restoring) {
 
 #ifndef DISABLE_VALIDATIONS
 	// Initialize maximum variable count
-	if (s->script_000->locals_block)
-		scriptState.variables_max[VAR_GLOBAL] = s->script_000->locals_block->_locals.size();
+	if (s->script_000->_localsBlock)
+		scriptState.variables_max[VAR_GLOBAL] = s->script_000->_localsBlock->_locals.size();
 	else
 		scriptState.variables_max[VAR_GLOBAL] = 0;
 #endif
 
-	scriptState.variables_seg[VAR_GLOBAL] = s->script_000->locals_segment;
+	scriptState.variables_seg[VAR_GLOBAL] = s->script_000->_localsSegment;
 	scriptState.variables_seg[VAR_TEMP] = scriptState.variables_seg[VAR_PARAM] = s->stack_segment;
 	scriptState.variables_base[VAR_TEMP] = scriptState.variables_base[VAR_PARAM] = s->stack_base;
 
 	// SCI code reads the zeroeth argument to determine argc
-	if (s->script_000->locals_block)
-		scriptState.variables_base[VAR_GLOBAL] = scriptState.variables[VAR_GLOBAL] = s->script_000->locals_block->_locals.begin();
+	if (s->script_000->_localsBlock)
+		scriptState.variables_base[VAR_GLOBAL] = scriptState.variables[VAR_GLOBAL] = s->script_000->_localsBlock->_locals.begin();
 	else
 		scriptState.variables_base[VAR_GLOBAL] = scriptState.variables[VAR_GLOBAL] = NULL;
 
@@ -577,9 +577,9 @@ void run_vm(EngineState *s, int restoring) {
 				obj = NULL;
 			} else {
 				obj = s->segMan->getObject(scriptState.xs->objp);
-				code_buf = scr->buf;
+				code_buf = scr->_buf;
 #ifndef DISABLE_VALIDATIONS
-				code_buf_size = scr->buf_size;
+				code_buf_size = scr->_bufSize;
 #endif
 				local_script = s->segMan->getScriptIfLoaded(scriptState.xs->local_segment);
 				if (!local_script) {
@@ -591,14 +591,14 @@ void run_vm(EngineState *s, int restoring) {
 #endif
 				} else {
 
-					scriptState.variables_seg[VAR_LOCAL] = local_script->locals_segment;
-					if (local_script->locals_block)
-						scriptState.variables_base[VAR_LOCAL] = scriptState.variables[VAR_LOCAL] = local_script->locals_block->_locals.begin();
+					scriptState.variables_seg[VAR_LOCAL] = local_script->_localsSegment;
+					if (local_script->_localsBlock)
+						scriptState.variables_base[VAR_LOCAL] = scriptState.variables[VAR_LOCAL] = local_script->_localsBlock->_locals.begin();
 					else
 						scriptState.variables_base[VAR_LOCAL] = scriptState.variables[VAR_LOCAL] = NULL;
 #ifndef DISABLE_VALIDATIONS
-					if (local_script->locals_block)
-						scriptState.variables_max[VAR_LOCAL] = local_script->locals_block->_locals.size();
+					if (local_script->_localsBlock)
+						scriptState.variables_max[VAR_LOCAL] = local_script->_localsBlock->_locals.size();
 					else
 						scriptState.variables_max[VAR_LOCAL] = 0;
 					scriptState.variables_max[VAR_TEMP] = scriptState.xs->sp - scriptState.xs->fp;
@@ -1158,7 +1158,7 @@ void run_vm(EngineState *s, int restoring) {
 
 			switch (s->detectLofsType()) {
 			case SCI_VERSION_1_1:
-				s->r_acc.offset = opparams[0] + local_script->script_size;
+				s->r_acc.offset = opparams[0] + local_script->_scriptSize;
 				break;
 			case SCI_VERSION_1_MIDDLE:
 				s->r_acc.offset = opparams[0];
@@ -1180,7 +1180,7 @@ void run_vm(EngineState *s, int restoring) {
 
 			switch (s->detectLofsType()) {
 			case SCI_VERSION_1_1:
-				r_temp.offset = opparams[0] + local_script->script_size;
+				r_temp.offset = opparams[0] + local_script->_scriptSize;
 				break;
 			case SCI_VERSION_1_MIDDLE:
 				r_temp.offset = opparams[0];
@@ -1565,7 +1565,6 @@ int script_instantiate_common(ResourceManager *resMan, SegManager *segMan, int s
 int script_instantiate_sci0(ResourceManager *resMan, SegManager *segMan, int script_nr) {
 	int objtype;
 	unsigned int objlength;
-	int seg_id;
 	int relocation = -1;
 	int magic_pos_adder; // Usually 0; 2 for older SCI versions
 	Resource *script;
@@ -1573,7 +1572,7 @@ int script_instantiate_sci0(ResourceManager *resMan, SegManager *segMan, int scr
 	SciVersion version = resMan->sciVersion();
 	bool oldScriptHeader = (version == SCI_VERSION_0_EARLY);
 
-	seg_id = script_instantiate_common(resMan, segMan, script_nr, &script, NULL, &was_new);
+	const int seg_id = script_instantiate_common(resMan, segMan, script_nr, &script, NULL, &was_new);
 
 	if (was_new)
 		return seg_id;
@@ -1683,9 +1682,9 @@ int script_instantiate_sci0(ResourceManager *resMan, SegManager *segMan, int scr
 			break;
 
 		objlength = scr->getHeap(reg.offset + 2);
-		reg.offset += 4; // Step over header
 
 		addr = reg;
+		addr.offset += 4; // Step over header
 
 		switch (objtype) {
 		case SCI_OBJ_CODE:
@@ -1715,42 +1714,39 @@ int script_instantiate_sci0(ResourceManager *resMan, SegManager *segMan, int scr
 			break;
 		}
 
-		reg.offset -= 4; // Step back on header
-
 	} while (objtype != 0 && reg.offset < script->size - 2);
 
 	if (relocation >= 0)
-		segMan->scriptRelocate(make_reg(reg.segment, relocation));
+		segMan->scriptRelocate(make_reg(seg_id, relocation));
 
 	return reg.segment;		// instantiation successful
 }
 
 int script_instantiate_sci11(ResourceManager *resMan, SegManager *segMan, int script_nr) {
 	Resource *script, *heap;
-	int seg_id;
-	int heap_start;
+	int _heapStart;
 	reg_t reg;
 	int was_new;
 
-	seg_id = script_instantiate_common(resMan, segMan, script_nr, &script, &heap, &was_new);
+	const int seg_id = script_instantiate_common(resMan, segMan, script_nr, &script, &heap, &was_new);
 
 	if (was_new)
 		return seg_id;
 
 	Script *scr = segMan->getScript(seg_id);
 
-	heap_start = script->size;
+	_heapStart = script->size;
 	if (script->size & 2)
-		heap_start ++;
+		_heapStart ++;
 
 	scr->mcpyInOut(0, script->data, script->size);
-	scr->mcpyInOut(heap_start, heap->data, heap->size);
+	scr->mcpyInOut(_heapStart, heap->data, heap->size);
 
 	if (READ_LE_UINT16(script->data + 6) > 0)
 		scr->setExportTableOffset(6);
 
 	reg.segment = seg_id;
-	reg.offset = heap_start + 4;
+	reg.offset = _heapStart + 4;
 	segMan->scriptInitialiseLocals(reg);
 
 	segMan->scriptRelocateExportsSci11(seg_id);