Replaced "typedef struct _seg_manager_t seg_manager_t" with "struct SegManager"

svn-id: r38679

7 files changed, 355 insertions, 355 deletions

diff --git a/engines/sci/engine/gc.cpp b/engines/sci/engine/gc.cpp
index c1ce2bb8dc..cfa0235767 100644
--- a/engines/sci/engine/gc.cpp
+++ b/engines/sci/engine/gc.cpp
@@ -130,7 +130,7 @@ void add_outgoing_refs(void *pre_wm, reg_t addr) {
 }
 
 reg_t_hash_map *find_all_used_references(EngineState *s) {
-	seg_manager_t *sm = &(s->seg_manager);
+	SegManager *sm = &(s->seg_manager);
 	seg_interface_t **interfaces = (seg_interface_t**)sci_calloc(sizeof(seg_interface_t *), sm->heap_size);
 	reg_t_hash_map *nonnormal_map = new reg_t_hash_map();
 	reg_t_hash_map *normal_map = NULL;
@@ -256,7 +256,7 @@ void free_unless_used(void *pre_use_map, reg_t addr) {
 void run_gc(EngineState *s) {
 	int seg_nr;
 	deallocator_t deallocator;
-	seg_manager_t *sm = &(s->seg_manager);
+	SegManager *sm = &(s->seg_manager);
 
 #ifdef DEBUG_GC
 	c_segtable(s);
diff --git a/engines/sci/engine/savegame.cfsml b/engines/sci/engine/savegame.cfsml
index eca85edab8..2902efbb94 100644
--- a/engines/sci/engine/savegame.cfsml
+++ b/engines/sci/engine/savegame.cfsml
@@ -284,7 +284,7 @@ RECORD menubar_t "menubar_t" {
 	menu_t menus[DYNAMIC menus_nr];
 }
 
-RECORD seg_manager_t "seg_manager_t" {
+RECORD SegManager "SegManager" {
 	int_hash_map_tp id_seg_map;
 	mem_obj_ptr heap[DYNAMIC heap_size];
 	int heap_size;
@@ -324,7 +324,7 @@ RECORD EngineState "EngineState" {
 	menubar_tp menubar;
 	int status_bar_foreground;
 	int status_bar_background;
-	seg_manager_t seg_manager;
+	SegManager seg_manager;
 	int classtable_size;
 	class_t classtable[DYNAMIC classtable_size];
 	sfx_state_t sound;
@@ -757,7 +757,7 @@ int gamestate_save(EngineState *s, Common::WriteStream *fh, const char* savename
 	return 0;
 }
 
-static seg_id_t find_unique_seg_by_type(seg_manager_t *self, int type) {
+static seg_id_t find_unique_seg_by_type(SegManager *self, int type) {
 	int i;
 
 	for (i = 0; i < self->heap_size; i++)
@@ -831,7 +831,7 @@ static void load_script(EngineState *s, seg_id_t seg) {
 	}
 }
 
-static void reconstruct_scripts(EngineState *s, seg_manager_t *self) {
+static void reconstruct_scripts(EngineState *s, SegManager *self) {
 	int i;
 	mem_obj_t *mobj;
 	for (i = 0; i < self->heap_size; i++) {
@@ -905,7 +905,7 @@ static void reconstruct_scripts(EngineState *s, seg_manager_t *self) {
 	}
 }
 
-void reconstruct_clones(EngineState *s, seg_manager_t *self) {
+void reconstruct_clones(EngineState *s, SegManager *self) {
 	int i;
 	mem_obj_t *mobj;
 
diff --git a/engines/sci/engine/savegame.cpp b/engines/sci/engine/savegame.cpp
index a516c8ba79..4d42154e4e 100644
--- a/engines/sci/engine/savegame.cpp
+++ b/engines/sci/engine/savegame.cpp
@@ -480,6 +480,10 @@ static void _cfsml_write_int_hash_map_t(Common::WriteStream *fh, int_hash_map_t*
 static int _cfsml_read_int_hash_map_t(Common::SeekableReadStream *fh, int_hash_map_t* save_struc, const char *lastval, int *line, int *hiteof);
 
 #line 383 "engines/sci/engine/savegame.cfsml"
+static void _cfsml_write_SegManager(Common::WriteStream *fh, SegManager* save_struc);
+static int _cfsml_read_SegManager(Common::SeekableReadStream *fh, SegManager* save_struc, const char *lastval, int *line, int *hiteof);
+
+#line 383 "engines/sci/engine/savegame.cfsml"
 static void _cfsml_write_song_t(Common::WriteStream *fh, song_t* save_struc);
 static int _cfsml_read_song_t(Common::SeekableReadStream *fh, song_t* save_struc, const char *lastval, int *line, int *hiteof);
 
@@ -567,10 +571,6 @@ static int _cfsml_read_sys_string_t(Common::SeekableReadStream *fh, sys_string_t
 static void _cfsml_write_script_t(Common::WriteStream *fh, script_t* save_struc);
 static int _cfsml_read_script_t(Common::SeekableReadStream *fh, script_t* save_struc, const char *lastval, int *line, int *hiteof);
 
-#line 383 "engines/sci/engine/savegame.cfsml"
-static void _cfsml_write_seg_manager_t(Common::WriteStream *fh, seg_manager_t* save_struc);
-static int _cfsml_read_seg_manager_t(Common::SeekableReadStream *fh, seg_manager_t* save_struc, const char *lastval, int *line, int *hiteof);
-
 #line 395 "engines/sci/engine/savegame.cfsml"
 static void
 _cfsml_write_sfx_state_t(Common::WriteStream *fh, sfx_state_t* save_struc)
@@ -1239,6 +1239,219 @@ _cfsml_read_int_hash_map_t(Common::SeekableReadStream *fh, int_hash_map_t* save_
 
 #line 395 "engines/sci/engine/savegame.cfsml"
 static void
+_cfsml_write_SegManager(Common::WriteStream *fh, SegManager* save_struc)
+{
+#line 412 "engines/sci/engine/savegame.cfsml"
+	WSprintf(fh, "{\n");
+	WSprintf(fh, "id_seg_map = ");
+	write_int_hash_map_tp(fh, (int_hash_map_t **) &(save_struc->id_seg_map));
+	WSprintf(fh, "\n");
+	WSprintf(fh, "heap = ");
+	int min, max;
+	min = max = save_struc->heap_size;
+	if (!save_struc->heap)
+		min = max = 0; /* Don't write if it points to NULL */
+#line 439 "engines/sci/engine/savegame.cfsml"
+	WSprintf(fh, "[%d][\n", max);
+	for (int i = 0; i < min; i++) {
+		write_mem_obj_tp(fh, &(save_struc->heap[i]));
+		WSprintf(fh, "\n");
+	}
+	WSprintf(fh, "]");
+	WSprintf(fh, "\n");
+	WSprintf(fh, "heap_size = ");
+	_cfsml_write_int(fh, (int*) &(save_struc->heap_size));
+	WSprintf(fh, "\n");
+	WSprintf(fh, "reserved_id = ");
+	_cfsml_write_int(fh, (int*) &(save_struc->reserved_id));
+	WSprintf(fh, "\n");
+	WSprintf(fh, "exports_wide = ");
+	_cfsml_write_int(fh, (int*) &(save_struc->exports_wide));
+	WSprintf(fh, "\n");
+	WSprintf(fh, "sci1_1 = ");
+	_cfsml_write_int(fh, (int*) &(save_struc->sci1_1));
+	WSprintf(fh, "\n");
+	WSprintf(fh, "gc_mark_bits = ");
+	_cfsml_write_int(fh, (int*) &(save_struc->gc_mark_bits));
+	WSprintf(fh, "\n");
+	WSprintf(fh, "mem_allocated = ");
+	_cfsml_write_size_t(fh, (size_t*) &(save_struc->mem_allocated));
+	WSprintf(fh, "\n");
+	WSprintf(fh, "clones_seg_id = ");
+	_cfsml_write_seg_id_t(fh, (seg_id_t*) &(save_struc->clones_seg_id));
+	WSprintf(fh, "\n");
+	WSprintf(fh, "lists_seg_id = ");
+	_cfsml_write_seg_id_t(fh, (seg_id_t*) &(save_struc->lists_seg_id));
+	WSprintf(fh, "\n");
+	WSprintf(fh, "nodes_seg_id = ");
+	_cfsml_write_seg_id_t(fh, (seg_id_t*) &(save_struc->nodes_seg_id));
+	WSprintf(fh, "\n");
+	WSprintf(fh, "}");
+}
+
+#line 486 "engines/sci/engine/savegame.cfsml"
+static int
+_cfsml_read_SegManager(Common::SeekableReadStream *fh, SegManager* save_struc, const char *lastval, int *line, int *hiteof)
+{
+#line 541 "engines/sci/engine/savegame.cfsml"
+	char *token;
+	int assignment, closed;
+
+	if (strcmp(lastval, "{")) {
+		_cfsml_error("Reading record SegManager; expected opening braces in line %d, got \"%s\"\n", *line, lastval);
+		return CFSML_FAILURE;
+	};
+	closed = 0;
+	do {
+		const char *value;
+		token = _cfsml_get_identifier(fh, line, hiteof, &assignment);
+
+		if (!token) {
+			_cfsml_error("Expected token at line %d\n", *line);
+			return CFSML_FAILURE;
+		}
+		if (!assignment) {
+			if (!strcmp(token, "}")) 
+				closed = 1;
+			else {
+				_cfsml_error("Expected assignment or closing braces in line %d\n", *line);
+				return CFSML_FAILURE;
+			}
+		} else {
+			value = "";
+			while (!value || !strcmp(value, ""))
+				value = _cfsml_get_value(fh, line, hiteof);
+			if (!value) {
+				_cfsml_error("Expected token at line %d\n", *line);
+				return CFSML_FAILURE;
+			}
+				if (!strcmp(token, "id_seg_map")) {
+#line 690 "engines/sci/engine/savegame.cfsml"
+				if (read_int_hash_map_tp(fh, (int_hash_map_t **) &(save_struc->id_seg_map), value, line, hiteof)) {
+					_cfsml_error("Token expected by read_int_hash_map_tp() for id_seg_map at line %d\n", *line);
+					return CFSML_FAILURE;
+				}
+			} else
+				if (!strcmp(token, "heap")) {
+#line 604 "engines/sci/engine/savegame.cfsml"
+			if ((value[0] != '[') || (value[strlen(value) - 1] != '[')) {
+				_cfsml_error("Opening brackets expected at line %d\n", *line);
+				return CFSML_FAILURE;
+			}
+			int max,done,i;
+#line 615 "engines/sci/engine/savegame.cfsml"
+			// Prepare to restore dynamic array
+			max = strtol(value + 1, NULL, 0);
+			if (max < 0) {
+				_cfsml_error("Invalid number of elements to allocate for dynamic array '%s' at line %d\n", token, *line);
+				return CFSML_FAILURE;
+			}
+
+			if (max) {
+				save_struc->heap = (mem_obj_ptr *)sci_malloc(max * sizeof(mem_obj_ptr));
+#ifdef SATISFY_PURIFY
+				memset(save_struc->heap, 0, max * sizeof(mem_obj_ptr));
+#endif
+				_cfsml_register_pointer(save_struc->heap);
+			} else
+				save_struc->heap = NULL;
+#line 639 "engines/sci/engine/savegame.cfsml"
+			done = i = 0;
+			do {
+			if (!(value = _cfsml_get_identifier(fh, line, hiteof, NULL))) {
+#line 647 "engines/sci/engine/savegame.cfsml"
+				_cfsml_error("Token expected at line %d\n", *line);
+				return 1;
+			}
+			if (strcmp(value, "]")) {
+				if (i == max) {
+					_cfsml_error("More elements than space available (%d) in '%s' at line %d\n", max, token, *line);
+					return CFSML_FAILURE;
+				}
+				if (read_mem_obj_tp(fh, &(save_struc->heap[i++]), value, line, hiteof)) {
+					_cfsml_error("Token expected by read_mem_obj_tp() for heap[i++] at line %d\n", *line);
+					return CFSML_FAILURE;
+				}
+			} else 
+				done = 1;
+			} while (!done);
+		 	save_struc->heap_size = max ; // Set array size accordingly
+			} else
+				if (!strcmp(token, "heap_size")) {
+#line 690 "engines/sci/engine/savegame.cfsml"
+				if (_cfsml_read_int(fh, (int*) &(save_struc->heap_size), value, line, hiteof)) {
+					_cfsml_error("Token expected by _cfsml_read_int() for heap_size at line %d\n", *line);
+					return CFSML_FAILURE;
+				}
+			} else
+				if (!strcmp(token, "reserved_id")) {
+#line 690 "engines/sci/engine/savegame.cfsml"
+				if (_cfsml_read_int(fh, (int*) &(save_struc->reserved_id), value, line, hiteof)) {
+					_cfsml_error("Token expected by _cfsml_read_int() for reserved_id at line %d\n", *line);
+					return CFSML_FAILURE;
+				}
+			} else
+				if (!strcmp(token, "exports_wide")) {
+#line 690 "engines/sci/engine/savegame.cfsml"
+				if (_cfsml_read_int(fh, (int*) &(save_struc->exports_wide), value, line, hiteof)) {
+					_cfsml_error("Token expected by _cfsml_read_int() for exports_wide at line %d\n", *line);
+					return CFSML_FAILURE;
+				}
+			} else
+				if (!strcmp(token, "sci1_1")) {
+#line 690 "engines/sci/engine/savegame.cfsml"
+				if (_cfsml_read_int(fh, (int*) &(save_struc->sci1_1), value, line, hiteof)) {
+					_cfsml_error("Token expected by _cfsml_read_int() for sci1_1 at line %d\n", *line);
+					return CFSML_FAILURE;
+				}
+			} else
+				if (!strcmp(token, "gc_mark_bits")) {
+#line 690 "engines/sci/engine/savegame.cfsml"
+				if (_cfsml_read_int(fh, (int*) &(save_struc->gc_mark_bits), value, line, hiteof)) {
+					_cfsml_error("Token expected by _cfsml_read_int() for gc_mark_bits at line %d\n", *line);
+					return CFSML_FAILURE;
+				}
+			} else
+				if (!strcmp(token, "mem_allocated")) {
+#line 690 "engines/sci/engine/savegame.cfsml"
+				if (_cfsml_read_size_t(fh, (size_t*) &(save_struc->mem_allocated), value, line, hiteof)) {
+					_cfsml_error("Token expected by _cfsml_read_size_t() for mem_allocated at line %d\n", *line);
+					return CFSML_FAILURE;
+				}
+			} else
+				if (!strcmp(token, "clones_seg_id")) {
+#line 690 "engines/sci/engine/savegame.cfsml"
+				if (_cfsml_read_seg_id_t(fh, (seg_id_t*) &(save_struc->clones_seg_id), value, line, hiteof)) {
+					_cfsml_error("Token expected by _cfsml_read_seg_id_t() for clones_seg_id at line %d\n", *line);
+					return CFSML_FAILURE;
+				}
+			} else
+				if (!strcmp(token, "lists_seg_id")) {
+#line 690 "engines/sci/engine/savegame.cfsml"
+				if (_cfsml_read_seg_id_t(fh, (seg_id_t*) &(save_struc->lists_seg_id), value, line, hiteof)) {
+					_cfsml_error("Token expected by _cfsml_read_seg_id_t() for lists_seg_id at line %d\n", *line);
+					return CFSML_FAILURE;
+				}
+			} else
+				if (!strcmp(token, "nodes_seg_id")) {
+#line 690 "engines/sci/engine/savegame.cfsml"
+				if (_cfsml_read_seg_id_t(fh, (seg_id_t*) &(save_struc->nodes_seg_id), value, line, hiteof)) {
+					_cfsml_error("Token expected by _cfsml_read_seg_id_t() for nodes_seg_id at line %d\n", *line);
+					return CFSML_FAILURE;
+				}
+			} else
+#line 699 "engines/sci/engine/savegame.cfsml"
+			{
+				_cfsml_error("SegManager: Assignment to invalid identifier '%s' in line %d\n", token, *line);
+				return CFSML_FAILURE;
+			}
+		}
+	} while (!closed); // Until closing braces are hit
+	return CFSML_SUCCESS;
+}
+
+#line 395 "engines/sci/engine/savegame.cfsml"
+static void
 _cfsml_write_song_t(Common::WriteStream *fh, song_t* save_struc)
 {
 #line 412 "engines/sci/engine/savegame.cfsml"
@@ -2620,7 +2833,7 @@ _cfsml_write_EngineState(Common::WriteStream *fh, EngineState* save_struc)
 	_cfsml_write_int(fh, (int*) &(save_struc->status_bar_background));
 	WSprintf(fh, "\n");
 	WSprintf(fh, "seg_manager = ");
-	_cfsml_write_seg_manager_t(fh, (seg_manager_t*) &(save_struc->seg_manager));
+	_cfsml_write_SegManager(fh, (SegManager*) &(save_struc->seg_manager));
 	WSprintf(fh, "\n");
 	WSprintf(fh, "classtable_size = ");
 	_cfsml_write_int(fh, (int*) &(save_struc->classtable_size));
@@ -2724,8 +2937,8 @@ _cfsml_read_EngineState(Common::SeekableReadStream *fh, EngineState* save_struc,
 			} else
 				if (!strcmp(token, "seg_manager")) {
 #line 690 "engines/sci/engine/savegame.cfsml"
-				if (_cfsml_read_seg_manager_t(fh, (seg_manager_t*) &(save_struc->seg_manager), value, line, hiteof)) {
-					_cfsml_error("Token expected by _cfsml_read_seg_manager_t() for seg_manager at line %d\n", *line);
+				if (_cfsml_read_SegManager(fh, (SegManager*) &(save_struc->seg_manager), value, line, hiteof)) {
+					_cfsml_error("Token expected by _cfsml_read_SegManager() for seg_manager at line %d\n", *line);
 					return CFSML_FAILURE;
 				}
 			} else
@@ -3775,219 +3988,6 @@ _cfsml_read_script_t(Common::SeekableReadStream *fh, script_t* save_struc, const
 	return CFSML_SUCCESS;
 }
 
-#line 395 "engines/sci/engine/savegame.cfsml"
-static void
-_cfsml_write_seg_manager_t(Common::WriteStream *fh, seg_manager_t* save_struc)
-{
-#line 412 "engines/sci/engine/savegame.cfsml"
-	WSprintf(fh, "{\n");
-	WSprintf(fh, "id_seg_map = ");
-	write_int_hash_map_tp(fh, (int_hash_map_t **) &(save_struc->id_seg_map));
-	WSprintf(fh, "\n");
-	WSprintf(fh, "heap = ");
-	int min, max;
-	min = max = save_struc->heap_size;
-	if (!save_struc->heap)
-		min = max = 0; /* Don't write if it points to NULL */
-#line 439 "engines/sci/engine/savegame.cfsml"
-	WSprintf(fh, "[%d][\n", max);
-	for (int i = 0; i < min; i++) {
-		write_mem_obj_tp(fh, &(save_struc->heap[i]));
-		WSprintf(fh, "\n");
-	}
-	WSprintf(fh, "]");
-	WSprintf(fh, "\n");
-	WSprintf(fh, "heap_size = ");
-	_cfsml_write_int(fh, (int*) &(save_struc->heap_size));
-	WSprintf(fh, "\n");
-	WSprintf(fh, "reserved_id = ");
-	_cfsml_write_int(fh, (int*) &(save_struc->reserved_id));
-	WSprintf(fh, "\n");
-	WSprintf(fh, "exports_wide = ");
-	_cfsml_write_int(fh, (int*) &(save_struc->exports_wide));
-	WSprintf(fh, "\n");
-	WSprintf(fh, "sci1_1 = ");
-	_cfsml_write_int(fh, (int*) &(save_struc->sci1_1));
-	WSprintf(fh, "\n");
-	WSprintf(fh, "gc_mark_bits = ");
-	_cfsml_write_int(fh, (int*) &(save_struc->gc_mark_bits));
-	WSprintf(fh, "\n");
-	WSprintf(fh, "mem_allocated = ");
-	_cfsml_write_size_t(fh, (size_t*) &(save_struc->mem_allocated));
-	WSprintf(fh, "\n");
-	WSprintf(fh, "clones_seg_id = ");
-	_cfsml_write_seg_id_t(fh, (seg_id_t*) &(save_struc->clones_seg_id));
-	WSprintf(fh, "\n");
-	WSprintf(fh, "lists_seg_id = ");
-	_cfsml_write_seg_id_t(fh, (seg_id_t*) &(save_struc->lists_seg_id));
-	WSprintf(fh, "\n");
-	WSprintf(fh, "nodes_seg_id = ");
-	_cfsml_write_seg_id_t(fh, (seg_id_t*) &(save_struc->nodes_seg_id));
-	WSprintf(fh, "\n");
-	WSprintf(fh, "}");
-}
-
-#line 486 "engines/sci/engine/savegame.cfsml"
-static int
-_cfsml_read_seg_manager_t(Common::SeekableReadStream *fh, seg_manager_t* save_struc, const char *lastval, int *line, int *hiteof)
-{
-#line 541 "engines/sci/engine/savegame.cfsml"
-	char *token;
-	int assignment, closed;
-
-	if (strcmp(lastval, "{")) {
-		_cfsml_error("Reading record seg_manager_t; expected opening braces in line %d, got \"%s\"\n", *line, lastval);
-		return CFSML_FAILURE;
-	};
-	closed = 0;
-	do {
-		const char *value;
-		token = _cfsml_get_identifier(fh, line, hiteof, &assignment);
-
-		if (!token) {
-			_cfsml_error("Expected token at line %d\n", *line);
-			return CFSML_FAILURE;
-		}
-		if (!assignment) {
-			if (!strcmp(token, "}")) 
-				closed = 1;
-			else {
-				_cfsml_error("Expected assignment or closing braces in line %d\n", *line);
-				return CFSML_FAILURE;
-			}
-		} else {
-			value = "";
-			while (!value || !strcmp(value, ""))
-				value = _cfsml_get_value(fh, line, hiteof);
-			if (!value) {
-				_cfsml_error("Expected token at line %d\n", *line);
-				return CFSML_FAILURE;
-			}
-				if (!strcmp(token, "id_seg_map")) {
-#line 690 "engines/sci/engine/savegame.cfsml"
-				if (read_int_hash_map_tp(fh, (int_hash_map_t **) &(save_struc->id_seg_map), value, line, hiteof)) {
-					_cfsml_error("Token expected by read_int_hash_map_tp() for id_seg_map at line %d\n", *line);
-					return CFSML_FAILURE;
-				}
-			} else
-				if (!strcmp(token, "heap")) {
-#line 604 "engines/sci/engine/savegame.cfsml"
-			if ((value[0] != '[') || (value[strlen(value) - 1] != '[')) {
-				_cfsml_error("Opening brackets expected at line %d\n", *line);
-				return CFSML_FAILURE;
-			}
-			int max,done,i;
-#line 615 "engines/sci/engine/savegame.cfsml"
-			// Prepare to restore dynamic array
-			max = strtol(value + 1, NULL, 0);
-			if (max < 0) {
-				_cfsml_error("Invalid number of elements to allocate for dynamic array '%s' at line %d\n", token, *line);
-				return CFSML_FAILURE;
-			}
-
-			if (max) {
-				save_struc->heap = (mem_obj_ptr *)sci_malloc(max * sizeof(mem_obj_ptr));
-#ifdef SATISFY_PURIFY
-				memset(save_struc->heap, 0, max * sizeof(mem_obj_ptr));
-#endif
-				_cfsml_register_pointer(save_struc->heap);
-			} else
-				save_struc->heap = NULL;
-#line 639 "engines/sci/engine/savegame.cfsml"
-			done = i = 0;
-			do {
-			if (!(value = _cfsml_get_identifier(fh, line, hiteof, NULL))) {
-#line 647 "engines/sci/engine/savegame.cfsml"
-				_cfsml_error("Token expected at line %d\n", *line);
-				return 1;
-			}
-			if (strcmp(value, "]")) {
-				if (i == max) {
-					_cfsml_error("More elements than space available (%d) in '%s' at line %d\n", max, token, *line);
-					return CFSML_FAILURE;
-				}
-				if (read_mem_obj_tp(fh, &(save_struc->heap[i++]), value, line, hiteof)) {
-					_cfsml_error("Token expected by read_mem_obj_tp() for heap[i++] at line %d\n", *line);
-					return CFSML_FAILURE;
-				}
-			} else 
-				done = 1;
-			} while (!done);
-		 	save_struc->heap_size = max ; // Set array size accordingly
-			} else
-				if (!strcmp(token, "heap_size")) {
-#line 690 "engines/sci/engine/savegame.cfsml"
-				if (_cfsml_read_int(fh, (int*) &(save_struc->heap_size), value, line, hiteof)) {
-					_cfsml_error("Token expected by _cfsml_read_int() for heap_size at line %d\n", *line);
-					return CFSML_FAILURE;
-				}
-			} else
-				if (!strcmp(token, "reserved_id")) {
-#line 690 "engines/sci/engine/savegame.cfsml"
-				if (_cfsml_read_int(fh, (int*) &(save_struc->reserved_id), value, line, hiteof)) {
-					_cfsml_error("Token expected by _cfsml_read_int() for reserved_id at line %d\n", *line);
-					return CFSML_FAILURE;
-				}
-			} else
-				if (!strcmp(token, "exports_wide")) {
-#line 690 "engines/sci/engine/savegame.cfsml"
-				if (_cfsml_read_int(fh, (int*) &(save_struc->exports_wide), value, line, hiteof)) {
-					_cfsml_error("Token expected by _cfsml_read_int() for exports_wide at line %d\n", *line);
-					return CFSML_FAILURE;
-				}
-			} else
-				if (!strcmp(token, "sci1_1")) {
-#line 690 "engines/sci/engine/savegame.cfsml"
-				if (_cfsml_read_int(fh, (int*) &(save_struc->sci1_1), value, line, hiteof)) {
-					_cfsml_error("Token expected by _cfsml_read_int() for sci1_1 at line %d\n", *line);
-					return CFSML_FAILURE;
-				}
-			} else
-				if (!strcmp(token, "gc_mark_bits")) {
-#line 690 "engines/sci/engine/savegame.cfsml"
-				if (_cfsml_read_int(fh, (int*) &(save_struc->gc_mark_bits), value, line, hiteof)) {
-					_cfsml_error("Token expected by _cfsml_read_int() for gc_mark_bits at line %d\n", *line);
-					return CFSML_FAILURE;
-				}
-			} else
-				if (!strcmp(token, "mem_allocated")) {
-#line 690 "engines/sci/engine/savegame.cfsml"
-				if (_cfsml_read_size_t(fh, (size_t*) &(save_struc->mem_allocated), value, line, hiteof)) {
-					_cfsml_error("Token expected by _cfsml_read_size_t() for mem_allocated at line %d\n", *line);
-					return CFSML_FAILURE;
-				}
-			} else
-				if (!strcmp(token, "clones_seg_id")) {
-#line 690 "engines/sci/engine/savegame.cfsml"
-				if (_cfsml_read_seg_id_t(fh, (seg_id_t*) &(save_struc->clones_seg_id), value, line, hiteof)) {
-					_cfsml_error("Token expected by _cfsml_read_seg_id_t() for clones_seg_id at line %d\n", *line);
-					return CFSML_FAILURE;
-				}
-			} else
-				if (!strcmp(token, "lists_seg_id")) {
-#line 690 "engines/sci/engine/savegame.cfsml"
-				if (_cfsml_read_seg_id_t(fh, (seg_id_t*) &(save_struc->lists_seg_id), value, line, hiteof)) {
-					_cfsml_error("Token expected by _cfsml_read_seg_id_t() for lists_seg_id at line %d\n", *line);
-					return CFSML_FAILURE;
-				}
-			} else
-				if (!strcmp(token, "nodes_seg_id")) {
-#line 690 "engines/sci/engine/savegame.cfsml"
-				if (_cfsml_read_seg_id_t(fh, (seg_id_t*) &(save_struc->nodes_seg_id), value, line, hiteof)) {
-					_cfsml_error("Token expected by _cfsml_read_seg_id_t() for nodes_seg_id at line %d\n", *line);
-					return CFSML_FAILURE;
-				}
-			} else
-#line 699 "engines/sci/engine/savegame.cfsml"
-			{
-				_cfsml_error("seg_manager_t: Assignment to invalid identifier '%s' in line %d\n", token, *line);
-				return CFSML_FAILURE;
-			}
-		}
-	} while (!closed); // Until closing braces are hit
-	return CFSML_SUCCESS;
-}
-
 
 // Auto-generated CFSML declaration and function block ends here
 // Auto-generation performed by cfsml.pl 0.8.2 
@@ -4708,7 +4708,7 @@ int gamestate_save(EngineState *s, Common::WriteStream *fh, const char* savename
 	return 0;
 }
 
-static seg_id_t find_unique_seg_by_type(seg_manager_t *self, int type) {
+static seg_id_t find_unique_seg_by_type(SegManager *self, int type) {
 	int i;
 
 	for (i = 0; i < self->heap_size; i++)
@@ -4782,7 +4782,7 @@ static void load_script(EngineState *s, seg_id_t seg) {
 	}
 }
 
-static void reconstruct_scripts(EngineState *s, seg_manager_t *self) {
+static void reconstruct_scripts(EngineState *s, SegManager *self) {
 	int i;
 	mem_obj_t *mobj;
 	for (i = 0; i < self->heap_size; i++) {
@@ -4856,7 +4856,7 @@ static void reconstruct_scripts(EngineState *s, seg_manager_t *self) {
 	}
 }
 
-void reconstruct_clones(EngineState *s, seg_manager_t *self) {
+void reconstruct_clones(EngineState *s, SegManager *self) {
 	int i;
 	mem_obj_t *mobj;
 
diff --git a/engines/sci/engine/seg_manager.cpp b/engines/sci/engine/seg_manager.cpp
index 5956b4d701..c2fd99c514 100644
--- a/engines/sci/engine/seg_manager.cpp
+++ b/engines/sci/engine/seg_manager.cpp
@@ -35,7 +35,7 @@ namespace Sci {
 
 #define SM_MEMORY_POISON	// Poison memory upon deallocation
 
-mem_obj_t* mem_obj_allocate(seg_manager_t *self, seg_id_t segid, int hash_id, mem_obj_enum type);
+mem_obj_t* mem_obj_allocate(SegManager *self, seg_id_t segid, int hash_id, mem_obj_enum type);
 
 #undef DEBUG_SEG_MANAGER // Define to turn on debugging
 
@@ -62,12 +62,12 @@ void dbg_print(const char* msg, void *i) {
 
 //-- forward declarations --
 
-void sm_script_initialise_locals_zero(seg_manager_t *self, seg_id_t seg, int count);
-void sm_script_initialise_locals(seg_manager_t *self, reg_t location);
-static int _sm_deallocate(seg_manager_t* self, int seg, int recursive);
-static hunk_t *sm_alloc_hunk(seg_manager_t *self, reg_t *);
-static void sm_free_hunk(seg_manager_t *self, reg_t addr);
-static int sm_check(seg_manager_t* self, int seg);
+void sm_script_initialise_locals_zero(SegManager *self, seg_id_t seg, int count);
+void sm_script_initialise_locals(SegManager *self, reg_t location);
+static int _sm_deallocate(SegManager* self, int seg, int recursive);
+static hunk_t *sm_alloc_hunk(SegManager *self, reg_t *);
+static void sm_free_hunk(SegManager *self, reg_t addr);
+static int sm_check(SegManager* self, int seg);
 /* Check segment validity
 ** Parameters: (int) seg: The segment to validate
 ** Returns   : (int)	0 if 'seg' is an invalid segment
@@ -76,7 +76,7 @@ static int sm_check(seg_manager_t* self, int seg);
 
 // End of Memory Management
 
-static inline int find_free_id(seg_manager_t *self, int *id) {
+static inline int find_free_id(SegManager *self, int *id) {
 	char was_added = 0;
 	int retval = 0;
 
@@ -91,7 +91,7 @@ static inline int find_free_id(seg_manager_t *self, int *id) {
 	return retval;
 }
 
-static mem_obj_t * alloc_nonscript_segment(seg_manager_t *self, mem_obj_enum type, seg_id_t *segid) {
+static mem_obj_t * alloc_nonscript_segment(SegManager *self, mem_obj_enum type, seg_id_t *segid) {
 	// Allocates a non-script segment
 	int id;
 
@@ -99,7 +99,7 @@ static mem_obj_t * alloc_nonscript_segment(seg_manager_t *self, mem_obj_enum typ
 	return mem_obj_allocate(self, *segid, id, type);
 }
 
-void sm_init(seg_manager_t* self, int sci1_1) {
+void sm_init(SegManager* self, int sci1_1) {
 	int i;
 
 	self->mem_allocated = 0; // Initialise memory count
@@ -130,7 +130,7 @@ void sm_init(seg_manager_t* self, int sci1_1) {
 }
 
 // destroy the object, free the memorys if allocated before
-void sm_destroy(seg_manager_t* self) {
+void sm_destroy(SegManager* self) {
 	int i;
 
 	// free memory
@@ -151,7 +151,7 @@ void sm_destroy(seg_manager_t* self) {
 // Returns   : 0 - allocation failure
 //             1 - allocated successfully
 //             seg_id - allocated segment id
-mem_obj_t* sm_allocate_script(seg_manager_t* self, EngineState *s, int script_nr, int* seg_id) {
+mem_obj_t *sm_allocate_script(SegManager* self, EngineState *s, int script_nr, int* seg_id) {
 	int seg;
 	char was_added;
 	mem_obj_t* mem;
@@ -251,7 +251,7 @@ int sm_initialise_script(mem_obj_t *mem, EngineState *s, int script_nr) {
 	return 1;
 }
 
-int _sm_deallocate(seg_manager_t* self, int seg, int recursive) {
+int _sm_deallocate(SegManager *self, int seg, int recursive) {
 	mem_obj_t *mobj;
 	VERIFY(sm_check(self, seg), "invalid seg id");
 
@@ -318,7 +318,7 @@ int _sm_deallocate(seg_manager_t* self, int seg, int recursive) {
 	return 1;
 }
 
-int sm_script_marked_deleted(seg_manager_t* self, int script_nr) {
+int sm_script_marked_deleted(SegManager *self, int script_nr) {
 	script_t *scr;
 	int seg = sm_seg_get(self, script_nr);
 	VERIFY(sm_check(self, seg), "invalid seg id");
@@ -327,7 +327,7 @@ int sm_script_marked_deleted(seg_manager_t* self, int script_nr) {
 	return scr->marked_as_deleted;
 }
 
-void sm_mark_script_deleted(seg_manager_t* self, int script_nr) {
+void sm_mark_script_deleted(SegManager *self, int script_nr) {
 	script_t *scr;
 	int seg = sm_seg_get(self, script_nr);
 	VERIFY(sm_check(self, seg), "invalid seg id");
@@ -336,7 +336,7 @@ void sm_mark_script_deleted(seg_manager_t* self, int script_nr) {
 	scr->marked_as_deleted = 1;
 }
 
-void sm_unmark_script_deleted(seg_manager_t* self, int script_nr) {
+void sm_unmark_script_deleted(SegManager* self, int script_nr) {
 	script_t *scr;
 	int seg = sm_seg_get(self, script_nr);
 	VERIFY(sm_check(self, seg), "invalid seg id");
@@ -345,7 +345,7 @@ void sm_unmark_script_deleted(seg_manager_t* self, int script_nr) {
 	scr->marked_as_deleted = 0;
 }
 
-int sm_script_is_marked_as_deleted(seg_manager_t* self, seg_id_t seg) {
+int sm_script_is_marked_as_deleted(SegManager* self, seg_id_t seg) {
 	script_t *scr;
 
 	if (!sm_check(self, seg))
@@ -360,7 +360,7 @@ int sm_script_is_marked_as_deleted(seg_manager_t* self, seg_id_t seg) {
 }
 
 
-int sm_deallocate_script(seg_manager_t* self, int script_nr) {
+int sm_deallocate_script(SegManager* self, int script_nr) {
 	int seg = sm_seg_get(self, script_nr);
 
 	_sm_deallocate(self, seg, 1);
@@ -368,7 +368,7 @@ int sm_deallocate_script(seg_manager_t* self, int script_nr) {
 	return 1;
 }
 
-mem_obj_t* mem_obj_allocate(seg_manager_t *self, seg_id_t segid, int hash_id, mem_obj_enum type) {
+mem_obj_t* mem_obj_allocate(SegManager *self, seg_id_t segid, int hash_id, mem_obj_enum type) {
 	mem_obj_t* mem = (mem_obj_t*) sci_calloc(sizeof(mem_obj_t), 1);
 	if (!mem) {
 		sciprintf("seg_manager.c: invalid mem_obj ");
@@ -444,7 +444,7 @@ void sm_free_script(mem_obj_t *mem) {
 // memory operations
 #if 0
 // Unreferenced - removed
-static void sm_mset(seg_manager_t *self, int offset, int c, size_t n, int id, int flag) {
+static void sm_mset(SegManager *self, int offset, int c, size_t n, int id, int flag) {
 	mem_obj_t *mem_obj;
 	GET_SEGID();
 	mem_obj = self->heap[id];
@@ -466,7 +466,7 @@ static void sm_mset(seg_manager_t *self, int offset, int c, size_t n, int id, in
 
 #if 0
 // Unreferenced - removed
-static void sm_mcpy_in_in(seg_manager_t *self, int dst, const int src, size_t n, int id, int flag) {
+static void sm_mcpy_in_in(SegManager *self, int dst, const int src, size_t n, int id, int flag) {
 	mem_obj_t *mem_obj;
 	GET_SEGID();
 	mem_obj = self->heap[id];
@@ -486,7 +486,7 @@ static void sm_mcpy_in_in(seg_manager_t *self, int dst, const int src, size_t n,
 }
 #endif
 
-void sm_mcpy_in_out(seg_manager_t *self, int dst, const void *src, size_t n, int id, int flag) {
+void sm_mcpy_in_out(SegManager *self, int dst, const void *src, size_t n, int id, int flag) {
 	mem_obj_t *mem_obj;
 	GET_SEGID();
 	mem_obj = self->heap[id];
@@ -507,7 +507,7 @@ void sm_mcpy_in_out(seg_manager_t *self, int dst, const void *src, size_t n, int
 
 #if 0
 // Unreferenced - removed
-static void sm_mcpy_out_in(seg_manager_t *self, void *dst, const int src, size_t n, int id, int flag) {
+static void sm_mcpy_out_in(SegManager *self, void *dst, const int src, size_t n, int id, int flag) {
 	mem_obj_t *mem_obj;
 	GET_SEGID();
 	mem_obj = self->heap[id];
@@ -527,7 +527,7 @@ static void sm_mcpy_out_in(seg_manager_t *self, void *dst, const int src, size_t
 }
 #endif
 
-gint16 sm_get_heap(seg_manager_t *self, reg_t reg) {
+gint16 sm_get_heap(SegManager *self, reg_t reg) {
 	mem_obj_t *mem_obj;
 	mem_obj_enum mem_type;
 
@@ -549,7 +549,7 @@ gint16 sm_get_heap(seg_manager_t *self, reg_t reg) {
 	return 0; // never get here
 }
 
-void sm_put_heap(seg_manager_t *self, reg_t reg, gint16 value) {
+void sm_put_heap(SegManager *self, reg_t reg, gint16 value) {
 	mem_obj_t *mem_obj;
 	mem_obj_enum mem_type;
 
@@ -573,7 +573,7 @@ void sm_put_heap(seg_manager_t *self, reg_t reg, gint16 value) {
 }
 
 // return the seg if script_id is valid and in the map, else -1
-int sm_seg_get(seg_manager_t *self, int script_id) {
+int sm_seg_get(SegManager *self, int script_id) {
 	return self->id_seg_map->check_value(script_id, false);
 }
 
@@ -581,7 +581,7 @@ int sm_seg_get(seg_manager_t *self, int script_id) {
 // return:
 //	0 - invalid seg
 //	1 - valid seg
-static int sm_check(seg_manager_t *self, int seg) {
+static int sm_check(SegManager *self, int seg) {
 	if (seg < 0 || seg >= self->heap_size) {
 		return 0;
 	}
@@ -592,21 +592,21 @@ static int sm_check(seg_manager_t *self, int seg) {
 	return 1;
 }
 
-int sm_script_is_loaded(seg_manager_t *self, int id, id_flag flag) {
+int sm_script_is_loaded(SegManager *self, int id, id_flag flag) {
 	if (flag == SCRIPT_ID)
 		id = sm_seg_get(self, id);
 
 	return sm_check(self, id);
 }
 
-void sm_increment_lockers(seg_manager_t *self, int id, id_flag flag) {
+void sm_increment_lockers(SegManager *self, int id, id_flag flag) {
 	if (flag == SCRIPT_ID)
 		id = sm_seg_get(self, id);
 	VERIFY(sm_check(self, id), "invalid seg id");
 	self->heap[id]->data.script.lockers++;
 }
 
-void sm_decrement_lockers(seg_manager_t *self, int id, id_flag flag) {
+void sm_decrement_lockers(SegManager *self, int id, id_flag flag) {
 	if (flag == SCRIPT_ID)
 		id = sm_seg_get(self, id);
 	VERIFY(sm_check(self, id), "invalid seg id");
@@ -615,7 +615,7 @@ void sm_decrement_lockers(seg_manager_t *self, int id, id_flag flag) {
 		self->heap[id]->data.script.lockers--;
 }
 
-int sm_get_lockers(seg_manager_t *self, int id, id_flag flag) {
+int sm_get_lockers(SegManager *self, int id, id_flag flag) {
 	if (flag == SCRIPT_ID)
 		id = sm_seg_get(self, id);
 	VERIFY(sm_check(self, id), "invalid seg id");
@@ -623,14 +623,14 @@ int sm_get_lockers(seg_manager_t *self, int id, id_flag flag) {
 	return self->heap[id]->data.script.lockers;
 }
 
-void sm_set_lockers(seg_manager_t *self, int lockers, int id, id_flag flag) {
+void sm_set_lockers(SegManager *self, int lockers, int id, id_flag flag) {
 	if (flag == SCRIPT_ID)
 		id = sm_seg_get(self, id);
 	VERIFY(sm_check(self, id), "invalid seg id");
 	self->heap[id]->data.script.lockers = lockers;
 }
 
-void sm_set_export_table_offset(struct _seg_manager_t *self, int offset, int id, id_flag flag) {
+void sm_set_export_table_offset(SegManager *self, int offset, int id, id_flag flag) {
 	script_t *scr = &(self->heap[id]->data.script);
 
 	GET_SEGID();
@@ -643,7 +643,7 @@ void sm_set_export_table_offset(struct _seg_manager_t *self, int offset, int id,
 	}
 }
 
-int sm_hash_segment_data(struct _seg_manager_t *self, int id) {
+int sm_hash_segment_data(SegManager *self, int id) {
 	int i, len, hash_code = 0x55555555;
 	char *buf;
 
@@ -661,13 +661,13 @@ int sm_hash_segment_data(struct _seg_manager_t *self, int id) {
 	return hash_code;
 }
 
-void sm_set_export_width(struct _seg_manager_t *self, int flag) {
+void sm_set_export_width(SegManager *self, int flag) {
 	self->exports_wide = flag;
 }
 
 #if 0
 // Unreferenced - removed
-static guint16 *sm_get_export_table_offset(struct _seg_manager_t *self, int id, int flag, int *max) {
+static guint16 *sm_get_export_table_offset(SegManager *self, int id, int flag, int *max) {
 	GET_SEGID();
 	if (max)
 		*max = self->heap[id]->data.script.exports_nr;
@@ -676,29 +676,29 @@ static guint16 *sm_get_export_table_offset(struct _seg_manager_t *self, int id,
 }
 #endif
 
-void sm_set_synonyms_offset(struct _seg_manager_t *self, int offset, int id, id_flag flag) {
+void sm_set_synonyms_offset(SegManager *self, int offset, int id, id_flag flag) {
 	GET_SEGID();
 	self->heap[id]->data.script.synonyms = self->heap[id]->data.script.buf + offset;
 }
 
-byte *sm_get_synonyms(seg_manager_t *self, int id, id_flag flag) {
+byte *sm_get_synonyms(SegManager *self, int id, id_flag flag) {
 	GET_SEGID();
 	return self->heap[id]->data.script.synonyms;
 }
 
-void sm_set_synonyms_nr(struct _seg_manager_t *self, int nr, int id, id_flag flag) {
+void sm_set_synonyms_nr(SegManager *self, int nr, int id, id_flag flag) {
 	GET_SEGID();
 	self->heap[id]->data.script.synonyms_nr = nr;
 }
 
-int sm_get_synonyms_nr(struct _seg_manager_t *self, int id, id_flag flag) {
+int sm_get_synonyms_nr(SegManager *self, int id, id_flag flag) {
 	GET_SEGID();
 	return self->heap[id]->data.script.synonyms_nr;
 }
 
 #if 0
 // Unreferenced - removed
-static int sm_get_heappos(struct _seg_manager_t *self, int id, int flag) {
+static int sm_get_heappos(SegManager *self, int id, int flag) {
 	GET_SEGID();
 	return 0;
 }
@@ -706,7 +706,7 @@ static int sm_get_heappos(struct _seg_manager_t *self, int id, int flag) {
 
 #if 0
 // Unreferenced - removed
-static void sm_set_variables(struct _seg_manager_t *self, reg_t reg, int obj_index, reg_t variable_reg, int variable_index) {
+static void sm_set_variables(SegManager *self, reg_t reg, int obj_index, reg_t variable_reg, int variable_index) {
 	script_t *script;
 	VERIFY(sm_check(self, reg.segment), "invalid seg id");
 	VERIFY(self->heap[reg.segment], "invalid mem");
@@ -721,7 +721,7 @@ static void sm_set_variables(struct _seg_manager_t *self, reg_t reg, int obj_ind
 }
 #endif
 
-static inline int _relocate_block(seg_manager_t *self, reg_t *block, int block_location, int block_items, seg_id_t segment, int location) {
+static inline int _relocate_block(SegManager *self, reg_t *block, int block_location, int block_items, seg_id_t segment, int location) {
 	int rel = location - block_location;
 	int index;
 
@@ -744,18 +744,18 @@ static inline int _relocate_block(seg_manager_t *self, reg_t *block, int block_l
 	return 1;
 }
 
-static inline int _relocate_local(seg_manager_t *self, script_t *scr, seg_id_t segment, int location) {
+static inline int _relocate_local(SegManager *self, script_t *scr, seg_id_t segment, int location) {
 	if (scr->locals_block)
 		return _relocate_block(self, scr->locals_block->locals, scr->locals_offset, scr->locals_block->nr, segment, location);
 	else
 		return 0; // No hands, no cookies
 }
 
-static inline int _relocate_object(seg_manager_t *self, object_t *obj, seg_id_t segment, int location) {
+static inline int _relocate_object(SegManager *self, object_t *obj, seg_id_t segment, int location) {
 	return _relocate_block(self, obj->variables, obj->pos.offset, obj->variables_nr, segment, location);
 }
 
-void sm_script_add_code_block(seg_manager_t *self, reg_t location) {
+void sm_script_add_code_block(SegManager *self, reg_t location) {
 	mem_obj_t *mobj = self->heap[location.segment];
 	script_t *scr;
 	int index;
@@ -774,7 +774,7 @@ void sm_script_add_code_block(seg_manager_t *self, reg_t location) {
 	scr->code[index].size = getUInt16(scr->buf + location.offset - 2);
 }
 
-void sm_script_relocate(seg_manager_t *self, reg_t block) {
+void sm_script_relocate(SegManager *self, reg_t block) {
 	mem_obj_t *mobj = self->heap[block.segment];
 	script_t *scr;
 	int count;
@@ -826,7 +826,7 @@ void sm_script_relocate(seg_manager_t *self, reg_t block) {
 	}
 }
 
-void sm_heap_relocate(seg_manager_t *self, EngineState *s, reg_t block) {
+void sm_heap_relocate(SegManager *self, EngineState *s, reg_t block) {
 	mem_obj_t *mobj = self->heap[block.segment];
 	script_t *scr;
 	int count;
@@ -875,7 +875,7 @@ void sm_heap_relocate(seg_manager_t *self, EngineState *s, reg_t block) {
 
 reg_t get_class_address(EngineState *s, int classnr, int lock, reg_t caller);
 
-static object_t *sm_script_obj_init0(seg_manager_t *self, EngineState *s, reg_t obj_pos) {
+static object_t *sm_script_obj_init0(SegManager *self, EngineState *s, reg_t obj_pos) {
 	mem_obj_t *mobj = self->heap[obj_pos.segment];
 	script_t *scr;
 	object_t *obj;
@@ -943,7 +943,7 @@ static object_t *sm_script_obj_init0(seg_manager_t *self, EngineState *s, reg_t
 	return obj;
 }
 
-static object_t *sm_script_obj_init11(seg_manager_t *self, EngineState *s, reg_t obj_pos) {
+static object_t *sm_script_obj_init11(SegManager *self, EngineState *s, reg_t obj_pos) {
 	mem_obj_t *mobj = self->heap[obj_pos.segment];
 	script_t *scr;
 	object_t *obj;
@@ -1010,14 +1010,14 @@ static object_t *sm_script_obj_init11(seg_manager_t *self, EngineState *s, reg_t
 	return obj;
 }
 
-object_t *sm_script_obj_init(seg_manager_t *self, EngineState *s, reg_t obj_pos) {
+object_t *sm_script_obj_init(SegManager *self, EngineState *s, reg_t obj_pos) {
 	if (!self->sci1_1)
 		return sm_script_obj_init0(self, s, obj_pos);
 	else
 		return sm_script_obj_init11(self, s, obj_pos);
 }
 
-static local_variables_t *_sm_alloc_locals_segment(seg_manager_t *self, script_t *scr, int count) {
+static local_variables_t *_sm_alloc_locals_segment(SegManager *self, script_t *scr, int count) {
 	if (!count) { // No locals
 		scr->locals_segment = 0;
 		scr->locals_block = NULL;
@@ -1043,7 +1043,7 @@ static local_variables_t *_sm_alloc_locals_segment(seg_manager_t *self, script_t
 	}
 }
 
-void sm_script_initialise_locals_zero(seg_manager_t *self, seg_id_t seg, int count) {
+void sm_script_initialise_locals_zero(SegManager *self, seg_id_t seg, int count) {
 	mem_obj_t *mobj = self->heap[seg];
 	script_t *scr;
 
@@ -1056,7 +1056,7 @@ void sm_script_initialise_locals_zero(seg_manager_t *self, seg_id_t seg, int cou
 	_sm_alloc_locals_segment(self, scr, count);
 }
 
-void sm_script_initialise_locals(seg_manager_t *self, reg_t location) {
+void sm_script_initialise_locals(SegManager *self, reg_t location) {
 	mem_obj_t *mobj = self->heap[location.segment];
 	unsigned int count;
 	script_t *scr;
@@ -1091,7 +1091,7 @@ void sm_script_initialise_locals(seg_manager_t *self, reg_t location) {
 	}
 }
 
-void sm_script_relocate_exports_sci11(seg_manager_t *self, int seg) {
+void sm_script_relocate_exports_sci11(SegManager *self, int seg) {
 	mem_obj_t *mobj = self->heap[seg];
 	script_t *scr;
 	int i;
@@ -1114,7 +1114,7 @@ void sm_script_relocate_exports_sci11(seg_manager_t *self, int seg) {
 	}
 }
 
-void sm_script_initialise_objects_sci11(seg_manager_t *self, EngineState *s, int seg) {
+void sm_script_initialise_objects_sci11(SegManager *self, EngineState *s, int seg) {
 	mem_obj_t *mobj = self->heap[seg];
 	script_t *scr;
 	byte *seeker;
@@ -1168,7 +1168,7 @@ void sm_script_initialise_objects_sci11(seg_manager_t *self, EngineState *s, int
 	}
 }
 
-void sm_script_free_unused_objects(seg_manager_t *self, seg_id_t seg) {
+void sm_script_free_unused_objects(SegManager *self, seg_id_t seg) {
 	mem_obj_t *mobj = self->heap[seg];
 	script_t *scr;
 
@@ -1198,7 +1198,7 @@ static inline char *dynprintf(char *msg, ...) {
 	return buf;
 }
 
-dstack_t *sm_allocate_stack(seg_manager_t *self, int size, seg_id_t *segid) {
+dstack_t *sm_allocate_stack(SegManager *self, int size, seg_id_t *segid) {
 	mem_obj_t *memobj = alloc_nonscript_segment(self, MEM_OBJ_STACK, segid);
 	dstack_t *retval = &(memobj->data.stack);
 
@@ -1208,7 +1208,7 @@ dstack_t *sm_allocate_stack(seg_manager_t *self, int size, seg_id_t *segid) {
 	return retval;
 }
 
-sys_strings_t *sm_allocate_sys_strings(seg_manager_t *self, seg_id_t *segid) {
+sys_strings_t *sm_allocate_sys_strings(SegManager *self, seg_id_t *segid) {
 	mem_obj_t *memobj = alloc_nonscript_segment(self, MEM_OBJ_SYS_STRINGS, segid);
 	sys_strings_t *retval = &(memobj->data.sys_strings);
 
@@ -1217,7 +1217,7 @@ sys_strings_t *sm_allocate_sys_strings(seg_manager_t *self, seg_id_t *segid) {
 	return retval;
 }
 
-seg_id_t sm_allocate_reserved_segment(seg_manager_t *self, char *src_name) {
+seg_id_t sm_allocate_reserved_segment(SegManager *self, char *src_name) {
 	seg_id_t segid;
 	mem_obj_t *memobj = alloc_nonscript_segment(self, MEM_OBJ_RESERVED, &segid);
 	char *name = sci_strdup(src_name);
@@ -1227,7 +1227,7 @@ seg_id_t sm_allocate_reserved_segment(seg_manager_t *self, char *src_name) {
 	return segid;
 }
 
-guint16 sm_validate_export_func(struct _seg_manager_t* self, int pubfunct, int seg) {
+guint16 sm_validate_export_func(SegManager* self, int pubfunct, int seg) {
 	script_t* script;
 	guint16 offset;
 	VERIFY(sm_check(self, seg), "invalid seg id");
@@ -1247,11 +1247,11 @@ guint16 sm_validate_export_func(struct _seg_manager_t* self, int pubfunct, int s
 	return offset;
 }
 
-void sm_free_hunk_entry(seg_manager_t *self, reg_t addr) {
+void sm_free_hunk_entry(SegManager *self, reg_t addr) {
 	sm_free_hunk(self, addr);
 }
 
-hunk_t *sm_alloc_hunk_entry(seg_manager_t *self, const char *hunk_type, int size, reg_t *reg) {
+hunk_t *sm_alloc_hunk_entry(SegManager *self, const char *hunk_type, int size, reg_t *reg) {
 	hunk_t *h = sm_alloc_hunk(self, reg);
 
 	if (!h)
@@ -1280,7 +1280,7 @@ DEFINE_HEAPENTRY_WITH_CLEANUP(clone, 16, 4, _clone_cleanup)
 DEFINE_HEAPENTRY_WITH_CLEANUP(hunk, 4, 4, _hunk_cleanup)
 
 #define DEFINE_ALLOC_DEALLOC(STATIC, TYPE, SEGTYPE, PLURAL) \
-STATIC TYPE##_t *sm_alloc_##TYPE(seg_manager_t *self, reg_t *addr) {												  \
+STATIC TYPE##_t *sm_alloc_##TYPE(SegManager *self, reg_t *addr) {												  \
 	mem_obj_t *mobj;									  \
 	TYPE##_table_t *table;									  \
 	int offset;										  \
@@ -1298,7 +1298,7 @@ STATIC TYPE##_t *sm_alloc_##TYPE(seg_manager_t *self, reg_t *addr) {
 	return &(mobj->data.PLURAL.table[offset].entry);					  \
 }												  \
 												  \
-STATIC void	sm_free_##TYPE(seg_manager_t *self, reg_t addr) {												  \
+STATIC void	sm_free_##TYPE(SegManager *self, reg_t addr) {												  \
 	mem_obj_t *mobj = GET_SEGMENT(*self, addr.segment, SEGTYPE);				  \
 												  \
 	if (!mobj) {										  \
@@ -1314,7 +1314,7 @@ DEFINE_ALLOC_DEALLOC(, list, MEM_OBJ_LISTS, lists)
 DEFINE_ALLOC_DEALLOC(, node, MEM_OBJ_NODES, nodes)
 DEFINE_ALLOC_DEALLOC(static, hunk, MEM_OBJ_HUNK, hunks)
 
-byte *sm_dereference(seg_manager_t *self, reg_t pointer, int *size) {
+byte *sm_dereference(SegManager *self, reg_t pointer, int *size) {
 	mem_obj_t *mobj;
 	byte *base = NULL;
 	int count;
@@ -1380,7 +1380,7 @@ byte *sm_dereference(seg_manager_t *self, reg_t pointer, int *size) {
 	    base + pointer.offset;
 }
 
-unsigned char *sm_alloc_dynmem(seg_manager_t *self, int size, const char *descr, reg_t *addr) {
+unsigned char *sm_alloc_dynmem(SegManager *self, int size, const char *descr, reg_t *addr) {
 	seg_id_t seg;
 	mem_obj_t *mobj = alloc_nonscript_segment(self, MEM_OBJ_DYNMEM, &seg);
 	*addr = make_reg(seg, 0);
@@ -1397,7 +1397,7 @@ unsigned char *sm_alloc_dynmem(seg_manager_t *self, int size, const char *descr,
 	return (unsigned char *)(mobj->data.dynmem.buf);
 }
 
-const char *sm_get_description(seg_manager_t *self, reg_t addr) {
+const char *sm_get_description(SegManager *self, reg_t addr) {
 	mem_obj_t *mobj = self->heap[addr.segment];
 
 	if (addr.segment >= self->heap_size)
@@ -1411,7 +1411,7 @@ const char *sm_get_description(seg_manager_t *self, reg_t addr) {
 	}
 }
 
-int sm_free_dynmem(seg_manager_t *self, reg_t addr) {
+int sm_free_dynmem(SegManager *self, reg_t addr) {
 	if (addr.segment <= 0 || addr.segment >= self->heap_size || !self->heap[addr.segment] || self->heap[addr.segment]->type != MEM_OBJ_DYNMEM)
 		return 1; // error
 
@@ -1791,7 +1791,7 @@ static seg_interface_t* seg_interfaces[MEM_OBJ_MAX] = {
 	&seg_interface_reserved
 };
 
-seg_interface_t *get_seg_interface(seg_manager_t *self, seg_id_t segid) {
+seg_interface_t *get_seg_interface(SegManager *self, seg_id_t segid) {
 	mem_obj_t *mobj;
 	seg_interface_t *retval;
 
diff --git a/engines/sci/engine/seg_manager.h b/engines/sci/engine/seg_manager.h
index 88e6f42dd6..457f74f356 100644
--- a/engines/sci/engine/seg_manager.h
+++ b/engines/sci/engine/seg_manager.h
@@ -83,7 +83,7 @@ struct _mem_obj;
 		(((mgr).heap[index]	&& ((mgr).heap[index]->type == MEM_OBJ_SCRIPT || (mgr).heap[index]->type == MEM_OBJ_CLONES))? (mgr).heap[index]	\
 		: NULL): NULL
 
-typedef struct _seg_manager_t {
+struct SegManager {
 	int_hash_map_t *id_seg_map; // id - script id; seg - index of heap
 	struct _mem_obj **heap;
 	int heap_size;		// size of the heap
@@ -101,17 +101,17 @@ typedef struct _seg_manager_t {
 	seg_id_t lists_seg_id; // ID of the (a) list segment
 	seg_id_t nodes_seg_id; // ID of the (a) node segment
 	seg_id_t hunks_seg_id; // ID of the (a) hunk segment
-} seg_manager_t;
+};
 
 // Toplevel functionality
 
-void sm_init(seg_manager_t *self, int sci1_1);
+void sm_init(SegManager *self, int sci1_1);
 // Initialize the segment manager
 
-void sm_destroy(seg_manager_t *self);
+void sm_destroy(SegManager *self);
 // Deallocate all memory associated with the segment manager
 
-void sm_gc(seg_manager_t *self, EngineState *s);
+void sm_gc(SegManager *self, EngineState *s);
 // Perform garbage collection
 // Parameters: (state_t *) s: The state to operate on
 // Effects   : Unreachable objects in 's' are deallocated
@@ -120,7 +120,7 @@ void sm_gc(seg_manager_t *self, EngineState *s);
 
 void sm_free_script(mem_obj_t* mem);
 
-mem_obj_t *sm_allocate_script(struct _seg_manager_t* self, EngineState *s, int script_nr, int* seg_id);
+mem_obj_t *sm_allocate_script(SegManager* self, EngineState *s, int script_nr, int* seg_id);
 // Allocate a script into the segment manager
 // Parameters: (int) script_nr: number of the script to load
 //	       (state_t *) s: The state containing resource manager handlers to load the
@@ -130,26 +130,26 @@ mem_obj_t *sm_allocate_script(struct _seg_manager_t* self, EngineState *s, int s
 
 // The script must then be initialised; see section (1b.), below.
 
-int sm_deallocate_script(struct _seg_manager_t* self, int script_nr);
+int sm_deallocate_script(SegManager* self, int script_nr);
 // Forcefully deallocate a previously allocated script
 // Parameters: (int) script_nr: number of the script to deallocate
 // Returns   : (int) 1 on success, 0 on failure
 
-int sm_script_is_loaded(struct _seg_manager_t* self, int id, id_flag flag);
+int sm_script_is_loaded(SegManager* self, int id, id_flag flag);
 // Determines whether a script has been loaded yet
 // Parameters: (int) id: number of the script or ID of the script segment to check for
 //             (id_flag) flag: Whether to address the script by script number (SCRIPT_ID) or
 //				by its segment (SEG_ID). SEG_ID is faster than SCRIPT_ID,
 //				but less convenient.
 
-guint16 sm_validate_export_func(struct _seg_manager_t* self, int pubfunct, int seg);
+guint16 sm_validate_export_func(SegManager* self, int pubfunct, int seg);
 // Validate whether the specified public function is exported by the script in the specified segment
 // Parameters:	(int) pubfunct: Index of the function to validate
 //		(int) seg: Segment ID of the script the check is to be performed for
 // Returns   :  (guint16) 0 if the public function is invalid, its offset into the script's segment
 //			  otherwise
 
-int sm_seg_get(seg_manager_t* self, int script_nr);
+int sm_seg_get(SegManager* self, int script_nr);
 // Get the segment ID associated with a script number
 // Parameters: (int) script_nr: Number of the script to look up
 // Returns   : (int) The associated segment ID, or -1 if no matching segment exists
@@ -159,7 +159,7 @@ int sm_seg_get(seg_manager_t* self, int script_nr);
 
 // script lock operations
 
-void sm_increment_lockers(struct _seg_manager_t *self, int id, id_flag flag);
+void sm_increment_lockers(SegManager *self, int id, id_flag flag);
 // Increments the number of lockers of the script in question by one
 // Parameters: (int) id: ID of the script or script segment to modify
 //             (id_flag) flag: Whether to address the script by script number (SCRIPT_ID) or
@@ -167,14 +167,14 @@ void sm_increment_lockers(struct _seg_manager_t *self, int id, id_flag flag);
 //				but less convenient.
 
 
-void sm_decrement_lockers(struct _seg_manager_t *self, int id, id_flag flag);
+void sm_decrement_lockers(SegManager *self, int id, id_flag flag);
 // Decrements the number of lockers of the script in question by one
 // Parameters: (int) id: ID of the script or script segment to modify
 //             (id_flag) flag: Whether to address the script by script number (SCRIPT_ID) or
 //				by its segment (SEG_ID). SEG_ID is faster than SCRIPT_ID,
 //				but less convenient.
 
-int sm_get_lockers(struct _seg_manager_t *self, int id, id_flag flag);
+int sm_get_lockers(SegManager *self, int id, id_flag flag);
 // Retrieves the number of locks held on this script
 // Parameters: (int) id: ID of the script or script segment to read from
 //             (id_flag) flag: Whether to address the script by script number (SCRIPT_ID) or
@@ -183,7 +183,7 @@ int sm_get_lockers(struct _seg_manager_t *self, int id, id_flag flag);
 // Returns   : (int) The number of locks held on the previously identified script
 
 
-void sm_set_lockers(struct _seg_manager_t *self, int lockers, int id, id_flag flag);
+void sm_set_lockers(SegManager *self, int lockers, int id, id_flag flag);
 // Sets the number of locks held on the specified script
 // Parameters: (int) id: ID of the script or script segment to modify
 //             (id_flag) flag: Whether to address the script by script number (SCRIPT_ID) or
@@ -191,7 +191,7 @@ void sm_set_lockers(struct _seg_manager_t *self, int lockers, int id, id_flag fl
 //				but less convenient.
 
 
-byte *sm_get_synonyms(struct _seg_manager_t *self, int id, id_flag flag);
+byte *sm_get_synonyms(SegManager *self, int id, id_flag flag);
 // Retrieves a pointer to the synonyms associated with the specified script
 // Parameters: (int) id: ID of the script or script segment to read from
 //             (id_flag) flag: Whether to address the script by script number (SCRIPT_ID) or
@@ -201,7 +201,7 @@ byte *sm_get_synonyms(struct _seg_manager_t *self, int id, id_flag flag);
 // A dynamic failure is issued if the specified ID does not reference a proper script.
 
 
-int sm_get_synonyms_nr(struct _seg_manager_t *self, int id, id_flag flag);
+int sm_get_synonyms_nr(SegManager *self, int id, id_flag flag);
 // Retrieves the number of synonyms associated with the specified script
 // Parameters: (int) id: ID of the script or script segment to read from
 //             (id_flag) flag: Whether to address the script by script number (SCRIPT_ID) or
@@ -218,19 +218,19 @@ int sm_get_synonyms_nr(struct _seg_manager_t *self, int id, id_flag flag);
 // to be used during script instantiation, 
 // i.e. loading and linking.		   
 
-void sm_script_initialise_locals_zero(struct _seg_manager_t *self, seg_id_t seg, int nr);
+void sm_script_initialise_locals_zero(SegManager *self, seg_id_t seg, int nr);
 // Initializes a script's local variable block
 // Parameters: (seg_id_t) seg: Segment containing the script to initialize
 //             (int) nr: Number of local variables to allocate
 // All variables are initialized to zero.
 
 
-void sm_script_initialise_locals(struct _seg_manager_t *self, reg_t location);
+void sm_script_initialise_locals(SegManager *self, reg_t location);
 // Initializes a script's local variable block according to a prototype
 // Parameters: (reg_t) location: Location to initialize from
 
 
-object_t *sm_script_obj_init(seg_manager_t *self, EngineState *s, reg_t obj_pos);
+object_t *sm_script_obj_init(SegManager *self, EngineState *s, reg_t obj_pos);
 // Initializes an object within the segment manager
 // Parameters: (reg_t) obj_pos: Location (segment, offset) of the object
 // Returns   : (object_t *) A newly created object_t describing the object
@@ -239,16 +239,16 @@ object_t *sm_script_obj_init(seg_manager_t *self, EngineState *s, reg_t obj_pos)
 // The corresponding object_t is stored within the relevant script.
 
 
-void sm_script_add_code_block(struct _seg_manager_t *self, reg_t location);
+void sm_script_add_code_block(SegManager *self, reg_t location);
 // Informs the segment manager that a code block must be relocated
 // Parameters: (reg_t) location: Start of block to relocate
 
 
-void sm_set_export_width(struct _seg_manager_t *self, int flag);
+void sm_set_export_width(SegManager *self, int flag);
 // Tells the segment manager whether exports are wide (32-bit) or not.
 // Parameters: (int) flag: 1 if exports are wide, 0 otherwise 
 
-void sm_script_relocate(struct _seg_manager_t *self, reg_t block);
+void sm_script_relocate(SegManager *self, reg_t block);
 // Processes a relocation block witin a script
 // Parameters: (reg_t) obj_pos: Location (segment, offset) of the block
 // Returns   : (object_t *) Location of the relocation block
@@ -256,14 +256,14 @@ void sm_script_relocate(struct _seg_manager_t *self, reg_t block);
 // objects have been instantiated, or a run-time error will occur.
 
 
-void sm_script_free_unused_objects(struct _seg_manager_t *self, seg_id_t segid);
+void sm_script_free_unused_objects(SegManager *self, seg_id_t segid);
 // Deallocates all unused but allocated entries for objects
 // Parameters: (seg_id_t) segid: segment of the script to prune in this way
 // These entries are created during script instantiation; deallocating them
 // frees up some additional memory.
 
 
-void sm_set_export_table_offset(struct _seg_manager_t *self, int offset, int id, id_flag flag);
+void sm_set_export_table_offset(SegManager *self, int offset, int id, id_flag flag);
 // Sets the script-relative offset of the exports table
 // Parameters: (int) offset: The script-relative exports table offset
 //	       (int) id: ID of the script or script segment to write to
@@ -273,7 +273,7 @@ void sm_set_export_table_offset(struct _seg_manager_t *self, int offset, int id,
 // A dynamic failure is issued if the specified ID does not reference a proper script.
 
 
-void sm_set_synonyms_offset(struct _seg_manager_t *self, int offset, int id, id_flag flag);
+void sm_set_synonyms_offset(SegManager *self, int offset, int id, id_flag flag);
 // Sets the script-relative offset of the synonyms associated with the specified script
 // Parameters: (int) offset: The script-relative offset of the synonyms block
 //	       (int) id: ID of the script or script segment to write to
@@ -283,7 +283,7 @@ void sm_set_synonyms_offset(struct _seg_manager_t *self, int offset, int id, id_
 // A dynamic failure is issued if the specified ID does not reference a proper script.
 
 
-void sm_set_synonyms_nr(struct _seg_manager_t *self, int nr, int id, id_flag flag);
+void sm_set_synonyms_nr(SegManager *self, int nr, int id, id_flag flag);
 // Sets the number of synonyms associated with the specified script
 // Parameters: (int) nr: The number of synonyms, as to be stored within the script
 //	       (int) id: ID of the script or script segment to write to
@@ -293,7 +293,7 @@ void sm_set_synonyms_nr(struct _seg_manager_t *self, int nr, int id, id_flag fla
 // A dynamic failure is issued if the specified ID does not reference a proper script.
 
 
-void sm_mark_script_deleted(seg_manager_t *self, int script_nr);
+void sm_mark_script_deleted(SegManager *self, int script_nr);
 // Marks the script identified by its script number as deleted
 // Parameters: (int) script_nr: Script number to mark as deleted
 // This will not actually delete the script.  If references remain present on the
@@ -302,12 +302,12 @@ void sm_mark_script_deleted(seg_manager_t *self, int script_nr);
 // in its data being updated).
 
 
-void sm_unmark_script_deleted(seg_manager_t *self, int script_nr);
+void sm_unmark_script_deleted(SegManager *self, int script_nr);
 // Marks the script identified by its script number as not deleted
 // Parameters: (int) script_nr: Script number to mark as not deleted
 
 
-int sm_script_is_marked_as_deleted(seg_manager_t *self, seg_id_t seg);
+int sm_script_is_marked_as_deleted(SegManager *self, seg_id_t seg);
 // Determines whether the script referenced by the indicated segment is marked as being deleted.
 // Parameters: (seg_id_t) Segment ID of the script to investigate
 // Returns   : (int) 1 iff seg points to a script and the segment is deleted, 0 otherwise
@@ -316,13 +316,13 @@ int sm_script_is_marked_as_deleted(seg_manager_t *self, seg_id_t seg);
 
 // 2. Clones							
 
-clone_t *sm_alloc_clone(struct _seg_manager_t *self, reg_t *addr);
+clone_t *sm_alloc_clone(SegManager *self, reg_t *addr);
 // Allocate a fresh clone
 // Returns : (clone_t*): Reference to the memory allocated for the clone
 //           (reg_t) *addr: The offset of the freshly allocated clone
 
 
-void sm_free_clone(struct _seg_manager_t *self, reg_t addr);
+void sm_free_clone(SegManager *self, reg_t addr);
 // Deallocates a clone
 // Parameters: (reg_t) addr: Offset of the clone scheduled for termination
 
@@ -331,19 +331,19 @@ void sm_free_clone(struct _seg_manager_t *self, reg_t addr);
 
 // Not all of these functions are fully operational for clones ATM 
 
-gint16 sm_get_heap(struct _seg_manager_t* self, reg_t reg);
+gint16 sm_get_heap(SegManager* self, reg_t reg);
 // Retrieves a 16 bit value from within a script's heap representation
 // Parameters: (reg_t) reg: The address to read from
 // Returns   : (gint16) The value read from the specified location
 
 
-void sm_put_heap(struct _seg_manager_t *self, reg_t reg, gint16 value);
+void sm_put_heap(SegManager *self, reg_t reg, gint16 value);
 // Writes a 16 bit value into a script's heap representation
 // Parameters: (reg_t) reg: The address to write to
 //	       (gint16) value: The value to write
 
 
-void sm_mcpy_in_out(seg_manager_t* self, int dst, const void *src, size_t n, int id, int flag);
+void sm_mcpy_in_out(SegManager* self, int dst, const void *src, size_t n, int id, int flag);
 // Copies a byte string into a script's heap representation
 // Parameters: (int) dst: The script-relative offset of the destination area
 //	       (const void *) src: Pointer to the data source location
@@ -357,7 +357,7 @@ void sm_mcpy_in_out(seg_manager_t* self, int dst, const void *src, size_t n, int
 
 // 4. Stack							
 
-dstack_t *sm_allocate_stack(struct _seg_manager_t *self, int size, seg_id_t *segid);
+dstack_t *sm_allocate_stack(SegManager *self, int size, seg_id_t *segid);
 // Allocates a data stack
 // Parameters: (int) size: Number of stack entries to reserve
 // Returns   : (dstack_t *): The physical stack
@@ -366,7 +366,7 @@ dstack_t *sm_allocate_stack(struct _seg_manager_t *self, int size, seg_id_t *seg
 
 // 5. System Strings						
 
-sys_strings_t *sm_allocate_sys_strings(struct _seg_manager_t *self, seg_id_t *segid);
+sys_strings_t *sm_allocate_sys_strings(SegManager *self, seg_id_t *segid);
 // Allocates a system string table
 // Returns   : (dstack_t *): The physical stack
 //             (seg_id_t) segid: Segment ID of the stack
@@ -375,30 +375,30 @@ sys_strings_t *sm_allocate_sys_strings(struct _seg_manager_t *self, seg_id_t *se
 
 // 6, 7. Lists and Nodes					
 
-list_t *sm_alloc_list(struct _seg_manager_t *self, reg_t *addr);
+list_t *sm_alloc_list(SegManager *self, reg_t *addr);
 // Allocate a fresh list
 // Returns : (listY_t*): Reference to the memory allocated for the list
 //           (reg_t) *addr: The offset of the freshly allocated list
 
 
-void sm_free_list(struct _seg_manager_t *self, reg_t addr);
+void sm_free_list(SegManager *self, reg_t addr);
 // Deallocates a list
 // Parameters: (reg_t) addr: Offset of the list scheduled for termination
 
 
-node_t *sm_alloc_node(struct _seg_manager_t *self, reg_t *addr);
+node_t *sm_alloc_node(SegManager *self, reg_t *addr);
 // Allocate a fresh node
 // Returns : (node_t*): Reference to the memory allocated for the node
 //           (reg_t) *addr: The offset of the freshly allocated node
 
-void sm_free_node(struct _seg_manager_t *self, reg_t addr);
+void sm_free_node(SegManager *self, reg_t addr);
 // Deallocates a list node
 // Parameters: (reg_t) addr: Offset of the node scheduled for termination
 
 
 // 8. Hunk Memory						
 
-hunk_t *sm_alloc_hunk_entry(struct _seg_manager_t *self, const char *hunk_type, int size, reg_t *addr);
+hunk_t *sm_alloc_hunk_entry(SegManager *self, const char *hunk_type, int size, reg_t *addr);
 // Allocate a fresh chunk of the hunk
 // Parameters: (int) size: Number of bytes to allocate for the hunk entry
 //             (const char *) hunk_type: A descriptive string for the hunk entry,
@@ -407,14 +407,14 @@ hunk_t *sm_alloc_hunk_entry(struct _seg_manager_t *self, const char *hunk_type,
 //             (reg_t) *addr: The offset of the freshly allocated hunk entry
 
 
-void sm_free_hunk_entry(struct _seg_manager_t *self, reg_t addr);
+void sm_free_hunk_entry(SegManager *self, reg_t addr);
 // Deallocates a hunk eentry
 // Parameters: (reg_t) addr: Offset of the hunk entry to delete
 
 
 // 9. Dynamic Memory						
 
-unsigned char *sm_alloc_dynmem(struct _seg_manager_t *self, int size, const char *description, reg_t *addr);
+unsigned char *sm_alloc_dynmem(SegManager *self, int size, const char *description, reg_t *addr);
 // Allocate some dynamic memory
 // Parameters: (int) size: Number of bytes to allocate
 //             (const char_ *) description: A descriptive string,
@@ -422,12 +422,12 @@ unsigned char *sm_alloc_dynmem(struct _seg_manager_t *self, int size, const char
 // Returns   : (unsigned char*): Raw pointer into the allocated dynamic memory
 //             (reg_t) *addr: The offset of the freshly allocated X
 
-int sm_free_dynmem(struct _seg_manager_t *self, reg_t addr);
+int sm_free_dynmem(SegManager *self, reg_t addr);
 // Deallocates a piece of dynamic memory
 // Parameters: (reg_t) addr: Offset of the dynmem chunk to free
 
 
-const char *sm_get_description(struct _seg_manager_t *self, reg_t addr);
+const char *sm_get_description(SegManager *self, reg_t addr);
 // Gets the description of a dynmem segment
 // Parameters: (reg_t) addr: Segment to describe
 // Returns   : (const char *): Pointer to the descriptive string set in
@@ -436,7 +436,7 @@ const char *sm_get_description(struct _seg_manager_t *self, reg_t addr);
 
 // 10. Reserved segments					
 
-seg_id_t sm_allocate_reserved_segment(struct _seg_manager_t *self, char *name);
+seg_id_t sm_allocate_reserved_segment(SegManager *self, char *name);
 // Reserves a special-purpose segment
 // Parameters: (char *) name: A string name identifying the segment (the string is cloned and retained)
 // Returns   : A fresh segment ID for the segment in question
@@ -446,7 +446,7 @@ seg_id_t sm_allocate_reserved_segment(struct _seg_manager_t *self, char *name);
 
 // Generic Operations on Segments and Addresses			
 
-byte *sm_dereference(struct _seg_manager_t *self, reg_t reg, int *size);
+byte *sm_dereference(SegManager *self, reg_t reg, int *size);
 // Dereferences a raw memory pointer
 // Parameters: (reg_t) reg: The reference to dereference
 // Returns   : (byte *) The data block referenced
@@ -455,7 +455,7 @@ byte *sm_dereference(struct _seg_manager_t *self, reg_t reg, int *size);
 // 11. Segment interface, primarily for GC			
 
 typedef struct _seg_interface {
-	seg_manager_t *segmgr;
+	SegManager *segmgr;
 	mem_obj_t *mobj;
 	seg_id_t seg_id;
 	mem_obj_enum type_id;	// Segment type 
@@ -488,7 +488,7 @@ typedef struct _seg_interface {
 	// Deallocates the segment interface
 } seg_interface_t;
 
-seg_interface_t *get_seg_interface(seg_manager_t *self, seg_id_t segid);
+seg_interface_t *get_seg_interface(SegManager *self, seg_id_t segid);
 // Retrieves the segment interface to the specified segment
 // Parameters: (seg_id_t) segid: ID of the segment to look up
 // Returns   : (seg_interface_t *): An interface to the specified segment ID, or NULL on error
diff --git a/engines/sci/engine/vm.cpp b/engines/sci/engine/vm.cpp
index b720df63b3..e2a949d99c 100644
--- a/engines/sci/engine/vm.cpp
+++ b/engines/sci/engine/vm.cpp
@@ -1682,7 +1682,7 @@ reg_t script_lookup_export(EngineState *s, int script_nr, int export_index) {
 
 #define INST_LOOKUP_CLASS(id) ((id == 0xffff)? NULL_REG : get_class_address(s, id, SCRIPT_GET_LOCK, reg))
 
-int sm_script_marked_deleted(seg_manager_t* self, int script_nr);
+int sm_script_marked_deleted(SegManager* self, int script_nr);
 int sm_initialise_script(mem_obj_t *mem, EngineState *s, int script_nr);
 int script_instantiate_common(EngineState *s, int script_nr, resource_t **script, resource_t **heap, int *was_new) {
 	int seg;
@@ -1901,9 +1901,9 @@ int script_instantiate_sci0(EngineState *s, int script_nr) {
 	return reg.segment;		// instantiation successful 
 }
 
-void sm_script_relocate_exports_sci11(seg_manager_t *self, int seg);
-void sm_script_initialise_objects_sci11(seg_manager_t *self, EngineState *s, int seg);
-void sm_heap_relocate(seg_manager_t *self, EngineState *s, reg_t block);
+void sm_script_relocate_exports_sci11(SegManager *self, int seg);
+void sm_script_initialise_objects_sci11(SegManager *self, EngineState *s, int seg);
+void sm_heap_relocate(SegManager *self, EngineState *s, reg_t block);
 
 int script_instantiate_sci11(EngineState *s, int script_nr) {
 	resource_t *script, *heap;
@@ -1947,7 +1947,7 @@ int script_instantiate(EngineState *s, int script_nr) {
 		return script_instantiate_sci0(s, script_nr);
 }
 
-void sm_mark_script_deleted(seg_manager_t* self, int script_nr);
+void sm_mark_script_deleted(SegManager* self, int script_nr);
 
 void script_uninstantiate_sci0(EngineState *s, int script_nr, seg_id_t seg) {
 	reg_t reg = make_reg(seg, (s->version < SCI_VERSION_FTU_NEW_SCRIPT_HEADER) ? 2 : 0);
diff --git a/engines/sci/include/engine.h b/engines/sci/include/engine.h
index b79cb7498d..7cfc423e85 100644
--- a/engines/sci/include/engine.h
+++ b/engines/sci/include/engine.h
@@ -256,7 +256,7 @@ struct EngineState {
 	int classtable_size; /* Number of classes in the table- for debugging */
 	class_t *classtable; /* Table of all classes */
 
-	seg_manager_t seg_manager;
+	SegManager seg_manager;
 	int gc_countdown; /* Number of kernel calls until next gc */
 
 	int selector_names_nr; /* Number of selector names */