SCI: Improved the Table template a bit by taking advantage of C++ features

svn-id: r40190

8 files changed, 71 insertions, 143 deletions

diff --git a/engines/sci/engine/kernel.cpp b/engines/sci/engine/kernel.cpp
index 5927e328c5..b33ce60f18 100644
--- a/engines/sci/engine/kernel.cpp
+++ b/engines/sci/engine/kernel.cpp
@@ -247,7 +247,7 @@ byte *kmem(EngineState *s, reg_t handle) {
 		return NULL;
 	}
 
-	return (byte *) ht->table[handle.offset].entry.mem;
+	return (byte *)ht->table[handle.offset].mem;
 }
 
 // Frees the specified handle. Returns 0 on success, 1 otherwise.
diff --git a/engines/sci/engine/klists.cpp b/engines/sci/engine/klists.cpp
index d655472ba4..bf9e0a4858 100644
--- a/engines/sci/engine/klists.cpp
+++ b/engines/sci/engine/klists.cpp
@@ -53,7 +53,7 @@ Node *lookup_node(EngineState *s, reg_t addr, const char *file, int line) {
 		return NULL;
 	}
 
-	return &(nt->table[addr.offset].entry);
+	return &(nt->table[addr.offset]);
 }
 
 List *lookup_list(EngineState *s, reg_t addr, const char *file, int line) {
@@ -73,7 +73,7 @@ List *lookup_list(EngineState *s, reg_t addr, const char *file, int line) {
 		return NULL;
 	}
 
-	return &(lt->table[addr.offset].entry);
+	return &(lt->table[addr.offset]);
 }
 
 #ifdef DISABLE_VALIDATIONS
diff --git a/engines/sci/engine/savegame.cpp b/engines/sci/engine/savegame.cpp
index 042590b33b..74ef6c9ccc 100644
--- a/engines/sci/engine/savegame.cpp
+++ b/engines/sci/engine/savegame.cpp
@@ -288,16 +288,7 @@ static void sync_Object(Common::Serializer &s, Object &obj) {
 }
 
 static void sync_Clone(Common::Serializer &s, Clone &obj) {
-	s.syncAsSint32LE(obj.flags);
-	sync_reg_t(s, obj.pos);
-	s.syncAsSint32LE(obj.variables_nr);
-	s.syncAsSint32LE(obj.variable_names_nr);
-	s.syncAsSint32LE(obj.methods_nr);
-
-	if (!obj.variables && obj.variables_nr)
-		obj.variables = (reg_t *)sci_calloc(obj.variables_nr, sizeof(reg_t));
-	for (int i = 0; i < obj.variables_nr; ++i)
-		sync_reg_t(s, obj.variables[i]);
+	sync_Object(s, obj);
 }
 
 static void sync_List(Common::Serializer &s, List &obj) {
@@ -312,9 +303,9 @@ static void sync_Node(Common::Serializer &s, Node &obj) {
 	sync_reg_t(s, obj.value);
 }
 
-static void sync_CloneEntry(Common::Serializer &s, CloneEntry &obj) {
+static void sync_CloneEntry(Common::Serializer &s, CloneTable::Entry &obj) {
 	s.syncAsSint32LE(obj.next_free);
-	sync_Clone(s, obj.entry);
+	sync_Clone(s, obj);
 }
 
 static void sync_CloneTable(Common::Serializer &s, CloneTable &obj) {
@@ -324,14 +315,14 @@ static void sync_CloneTable(Common::Serializer &s, CloneTable &obj) {
 	s.syncAsSint32LE(obj.max_entry);
 
 	if (!obj.table && obj.entries_nr)
-		obj.table = (CloneEntry *)sci_calloc(obj.entries_nr, sizeof(CloneEntry));
+		obj.table = (CloneTable::Entry *)sci_calloc(obj.entries_nr, sizeof(CloneTable::Entry));
 	for (int i = 0; i < obj.entries_nr; ++i)
 		sync_CloneEntry(s, obj.table[i]);
 }
 
-static void sync_ListEntry(Common::Serializer &s, ListEntry &obj) {
+static void sync_ListEntry(Common::Serializer &s, ListTable::Entry &obj) {
 	s.syncAsSint32LE(obj.next_free);
-	sync_List(s, obj.entry);
+	sync_List(s, obj);
 }
 
 static void sync_ListTable(Common::Serializer &s, ListTable &obj) {
@@ -341,14 +332,14 @@ static void sync_ListTable(Common::Serializer &s, ListTable &obj) {
 	s.syncAsSint32LE(obj.max_entry);
 
 	if (!obj.table && obj.entries_nr)
-		obj.table = (ListEntry *)sci_calloc(obj.entries_nr, sizeof(ListEntry));
+		obj.table = (ListTable::Entry *)sci_calloc(obj.entries_nr, sizeof(ListTable::Entry));
 	for (int i = 0; i < obj.entries_nr; ++i)
 		sync_ListEntry(s, obj.table[i]);
 }
 
-static void sync_NodeEntry(Common::Serializer &s, NodeEntry &obj) {
+static void sync_NodeEntry(Common::Serializer &s, NodeTable::Entry &obj) {
 	s.syncAsSint32LE(obj.next_free);
-	sync_Node(s, obj.entry);
+	sync_Node(s, obj);
 }
 
 static void sync_NodeTable(Common::Serializer &s, NodeTable &obj) {
@@ -358,7 +349,7 @@ static void sync_NodeTable(Common::Serializer &s, NodeTable &obj) {
 	s.syncAsSint32LE(obj.max_entry);
 
 	if (!obj.table && obj.entries_nr)
-		obj.table = (NodeEntry *)sci_calloc(obj.entries_nr, sizeof(NodeEntry));
+		obj.table = (NodeTable::Entry *)sci_calloc(obj.entries_nr, sizeof(NodeTable::Entry));
 	for (int i = 0; i < obj.entries_nr; ++i)
 		sync_NodeEntry(s, obj.table[i]);
 }
@@ -486,7 +477,7 @@ static void sync_MemObjPtr(Common::Serializer &s, MemObject *&obj) {
 		break;
 	case MEM_OBJ_HUNK:
 		if (s.isLoading()) {
-			init_Hunk_table(&obj->data.hunks);
+			obj->data.hunks.initTable();
 		}
 		break;
 	case MEM_OBJ_STRING_FRAG:
@@ -501,7 +492,7 @@ static void sync_MemObjPtr(Common::Serializer &s, MemObject *&obj) {
 		sync_DynMem(s, obj->data.dynmem);
 		break;
 	default:
-		error("Unknown MemObject type %d\n", obj->type);
+		error("Unknown MemObject type %d", obj->type);
 		break;
 	}
 }
@@ -590,7 +581,7 @@ static void reconstruct_stack(EngineState *retval) {
 static int clone_entry_used(CloneTable *table, int n) {
 	int backup;
 	int seeker = table->first_free;
-	CloneEntry *entries = table->table;
+	CloneTable::Entry *entries = table->table;
 
 	if (seeker == HEAPENTRY_INVALID) return 1;
 
@@ -715,7 +706,7 @@ static void reconstruct_clones(EngineState *s, SegManager *self) {
 			switch (mobj->type) {
 			case MEM_OBJ_CLONES: {
 				int j;
-				CloneEntry *seeker = mobj->data.clones.table;
+				CloneTable::Entry *seeker = mobj->data.clones.table;
 
 				/*
 				sciprintf("Free list: ");
@@ -726,7 +717,7 @@ static void reconstruct_clones(EngineState *s, SegManager *self) {
 
 				sciprintf("Entries w/zero vars: ");
 				for (j = 0; j < mobj->data.clones.max_entry; j++) {
-					if (mobj->data.clones.table[j].entry.variables == NULL)
+					if (mobj->data.clones.table[j].variables == NULL)
 						sciprintf("%d ", j);
 				}
 				sciprintf("\n");
@@ -739,17 +730,17 @@ static void reconstruct_clones(EngineState *s, SegManager *self) {
 						seeker++;
 						continue;
 					}
-					base_obj = obj_get(s, seeker->entry.variables[SCRIPT_SPECIES_SELECTOR]);
+					base_obj = obj_get(s, seeker->variables[SCRIPT_SPECIES_SELECTOR]);
 					if (!base_obj) {
 						sciprintf("Clone entry without a base class: %d\n", j);
-						seeker->entry.base = seeker->entry.base_obj = NULL;
-						seeker->entry.base_vars = seeker->entry.base_method = NULL;
+						seeker->base = seeker->base_obj = NULL;
+						seeker->base_vars = seeker->base_method = NULL;
 						continue;
 					}
-					seeker->entry.base = base_obj->base;
-					seeker->entry.base_obj = base_obj->base_obj;
-					seeker->entry.base_vars = base_obj->base_vars;
-					seeker->entry.base_method = base_obj->base_method;
+					seeker->base = base_obj->base;
+					seeker->base_obj = base_obj->base_obj;
+					seeker->base_vars = base_obj->base_vars;
+					seeker->base_method = base_obj->base_method;
 
 					seeker++;
 				}
diff --git a/engines/sci/engine/scriptconsole.cpp b/engines/sci/engine/scriptconsole.cpp
index decfd167dc..935f3e7418 100644
--- a/engines/sci/engine/scriptconsole.cpp
+++ b/engines/sci/engine/scriptconsole.cpp
@@ -328,7 +328,7 @@ int parse_reg_t(EngineState *s, const char *str, reg_t *dest) { // Returns 0 on
 					obj = mobj->data.script.objects + idx;
 					objpos.offset = obj->pos.offset;
 				} else if (mobj->type == MEM_OBJ_CLONES) {
-					obj = &(mobj->data.clones.table[idx].entry);
+					obj = &(mobj->data.clones.table[idx]);
 					objpos.offset = idx;
 					valid = clone_is_used(&mobj->data.clones, idx);
 				}
diff --git a/engines/sci/engine/scriptdebug.cpp b/engines/sci/engine/scriptdebug.cpp
index 76ac53ec81..66d5377bef 100644
--- a/engines/sci/engine/scriptdebug.cpp
+++ b/engines/sci/engine/scriptdebug.cpp
@@ -366,7 +366,7 @@ static void print_list(EngineState *s, List *l) {
 			return;
 		}
 
-		node = &(mobj->data.nodes.table[pos.offset].entry);
+		node = &(mobj->data.nodes.table[pos.offset]);
 
 		sciprintf("\t"PREG"  : "PREG" -> "PREG"\n", PRINT_REG(pos), PRINT_REG(node->key), PRINT_REG(node->value));
 
@@ -446,7 +446,7 @@ static void _c_single_seg_info(EngineState *s, MemObject *mobj) {
 		for (i = 0; i < ct->max_entry; i++)
 			if (ENTRY_IS_VALID(ct, i)) {
 				sciprintf("  [%04x] ", i);
-				print_obj_head(s, &(ct->table[i].entry));
+				print_obj_head(s, &(ct->table[i]));
 			}
 	}
 	break;
@@ -459,7 +459,7 @@ static void _c_single_seg_info(EngineState *s, MemObject *mobj) {
 		for (i = 0; i < lt->max_entry; i++)
 			if (ENTRY_IS_VALID(lt, i)) {
 				sciprintf("  [%04x]: ", i);
-				print_list(s, &(lt->table[i].entry));
+				print_list(s, &(lt->table[i]));
 			}
 	}
 	break;
@@ -477,7 +477,7 @@ static void _c_single_seg_info(EngineState *s, MemObject *mobj) {
 		for (i = 0; i < ht->max_entry; i++)
 			if (ENTRY_IS_VALID(ht, i)) {
 				sciprintf("    [%04x] %d bytes at %p, type=%s\n",
-				          i, ht->table[i].entry.size, ht->table[i].entry.mem, ht->table[i].entry.type);
+				          i, ht->table[i].size, ht->table[i].mem, ht->table[i].type);
 			}
 	}
 
@@ -512,7 +512,7 @@ static int show_node(EngineState *s, reg_t addr) {
 			return 1;
 		}
 
-		list = &(lt->table[addr.offset].entry);
+		list = &(lt->table[addr.offset]);
 
 		sciprintf(PREG" : first x last = ("PREG", "PREG")\n", PRINT_REG(addr), PRINT_REG(list->first), PRINT_REG(list->last));
 	} else {
@@ -531,7 +531,7 @@ static int show_node(EngineState *s, reg_t addr) {
 			sciprintf("Address does not contain a node\n");
 			return 1;
 		}
-		node = &(nt->table[addr.offset].entry);
+		node = &(nt->table[addr.offset]);
 
 		sciprintf(PREG" : prev x next = ("PREG", "PREG"); maps "PREG" -> "PREG"\n",
 		          PRINT_REG(addr), PRINT_REG(node->pred), PRINT_REG(node->succ), PRINT_REG(node->key), PRINT_REG(node->value));
diff --git a/engines/sci/engine/seg_manager.cpp b/engines/sci/engine/seg_manager.cpp
index 84f670091b..7173cd61d6 100644
--- a/engines/sci/engine/seg_manager.cpp
+++ b/engines/sci/engine/seg_manager.cpp
@@ -363,7 +363,7 @@ int SegManager::deallocateScript(int script_nr) {
 }
 
 MemObject *SegManager::memObjAllocate(SegmentId segid, int hash_id, memObjType type) {
-	MemObject *mem = (MemObject *)sci_calloc(sizeof(MemObject), 1);
+	MemObject *mem = (MemObject *)sci_calloc(1, sizeof(MemObject));
 	if (!mem) {
 		sciprintf("SegManager: invalid mem_obj ");
 		return NULL;
@@ -1283,96 +1283,46 @@ Hunk *SegManager::alloc_hunk_entry(const char *hunk_type, int size, reg_t *reg)
 }
 
 
-void init_List_table(ListTable *table) {
-	table->entries_nr = 8;
-	table->max_entry = 0;
-	table->entries_used = 0;
-	table->first_free = HEAPENTRY_INVALID;
-	table->table = (ListEntry *)sci_malloc(sizeof(ListEntry) * 8);
-	memset(table->table, 0, sizeof(ListEntry) * 8);
-}
-
 void free_List_entry(ListTable *table, int index) {
-	ListEntry *e = table->table + index;
-
 	if (index < 0 || index >= table->max_entry) {
 		error("heapmgr: Attempt to release invalid table index %d", index);
 	}
 
-	e->next_free = table->first_free;
+	table->table[index].next_free = table->first_free;
 	table->first_free = index;
 	table->entries_used--;
 }
 
-
-
-void init_Node_table(NodeTable *table) {
-	table->entries_nr = 32;
-	table->max_entry = 0;
-	table->entries_used = 0;
-	table->first_free = HEAPENTRY_INVALID;
-	table->table = (NodeEntry *)sci_malloc(sizeof(NodeEntry) * 32);
-	memset(table->table, 0, sizeof(NodeEntry) * 32);
-}
-
 void free_Node_entry(NodeTable *table, int index) {
-	NodeEntry *e = table->table + index;
-
 	if (index < 0 || index >= table->max_entry) {
 		error("heapmgr: Attempt to release invalid table index %d", index);
 	}
 
-	e->next_free = table->first_free;
+	table->table[index].next_free = table->first_free;
 	table->first_free = index;
 	table->entries_used--;
 }
 
-
-
-void init_Clone_table(CloneTable *table) {
-	table->entries_nr = 16;
-	table->max_entry = 0;
-	table->entries_used = 0;
-	table->first_free = HEAPENTRY_INVALID;
-	table->table = (CloneEntry *)sci_malloc(sizeof(CloneEntry) * 16);
-	memset(table->table, 0, sizeof(CloneEntry) * 16);
-}
-
 void free_Clone_entry(CloneTable *table, int index) {
-	CloneEntry *e = table->table + index;
-
 	if (index < 0 || index >= table->max_entry) {
 		error("heapmgr: Attempt to release invalid table index %d", index);
 	}
 
-	free(e->entry.variables); // Free the dynamically allocated memory part
+	free(table->table[index].variables); // Free the dynamically allocated memory part
 
-	e->next_free = table->first_free;
+	table->table[index].next_free = table->first_free;
 	table->first_free = index;
 	table->entries_used--;
 }
 
-
-
-void init_Hunk_table(HunkTable *table) {
-	table->entries_nr = 4;
-	table->max_entry = 0;
-	table->entries_used = 0;
-	table->first_free = HEAPENTRY_INVALID;
-	table->table = (HunkEntry *)sci_malloc(sizeof(HunkEntry) * 4);
-	memset(table->table, 0, sizeof(HunkEntry) * 4);
-}
-
 void free_Hunk_entry(HunkTable *table, int index) {
-	HunkEntry *e = table->table + index;
-
 	if (index < 0 || index >= table->max_entry) {
 		error("heapmgr: Attempt to release invalid table index %d", index);
 	}
 
-	free(e->entry.mem);
+	free(table->table[index].mem);
 
-	e->next_free = table->first_free;
+	table->table[index].next_free = table->first_free;
 	table->first_free = index;
 	table->entries_used--;
 }
@@ -1386,7 +1336,7 @@ Clone *SegManager::alloc_Clone(reg_t *addr) {
 
 	if (!Clones_seg_id) {
 		mobj = allocNonscriptSegment(MEM_OBJ_CLONES, &(Clones_seg_id));
-		init_Clone_table(&(mobj->data.clones));
+		mobj->data.clones.initTable();
 	} else
 		mobj = heap[Clones_seg_id];
 
@@ -1394,7 +1344,7 @@ Clone *SegManager::alloc_Clone(reg_t *addr) {
 	offset = table->allocEntry();
 
 	*addr = make_reg(Clones_seg_id, offset);
-	return &(mobj->data.clones.table[offset].entry);
+	return &(mobj->data.clones.table[offset]);
 }
 
 List *SegManager::alloc_List(reg_t *addr) {
@@ -1404,7 +1354,7 @@ List *SegManager::alloc_List(reg_t *addr) {
 
 	if (!Lists_seg_id) {
 		mobj = allocNonscriptSegment(MEM_OBJ_LISTS, &(Lists_seg_id));
-		init_List_table(&(mobj->data.lists));
+		mobj->data.lists.initTable();
 	} else
 		mobj = heap[Lists_seg_id];
 
@@ -1412,7 +1362,7 @@ List *SegManager::alloc_List(reg_t *addr) {
 	offset = table->allocEntry();
 
 	*addr = make_reg(Lists_seg_id, offset);
-	return &(mobj->data.lists.table[offset].entry);
+	return &(mobj->data.lists.table[offset]);
 }
 
 Node *SegManager::alloc_Node(reg_t *addr) {
@@ -1422,7 +1372,7 @@ Node *SegManager::alloc_Node(reg_t *addr) {
 
 	if (!Nodes_seg_id) {
 		mobj = allocNonscriptSegment(MEM_OBJ_NODES, &(Nodes_seg_id));
-		init_Node_table(&(mobj->data.nodes));
+		mobj->data.nodes.initTable();
 	} else
 		mobj = heap[Nodes_seg_id];
 
@@ -1430,7 +1380,7 @@ Node *SegManager::alloc_Node(reg_t *addr) {
 	offset = table->allocEntry();
 
 	*addr = make_reg(Nodes_seg_id, offset);
-	return &(mobj->data.nodes.table[offset].entry);
+	return &(mobj->data.nodes.table[offset]);
 }
 
 Hunk *SegManager::alloc_Hunk(reg_t *addr) {
@@ -1440,7 +1390,7 @@ Hunk *SegManager::alloc_Hunk(reg_t *addr) {
 
 	if (!Hunks_seg_id) {
 		mobj = allocNonscriptSegment(MEM_OBJ_HUNK, &(Hunks_seg_id));
-		init_Hunk_table(&(mobj->data.hunks));
+		mobj->data.hunks.initTable();
 	} else
 		mobj = heap[Hunks_seg_id];
 
@@ -1448,7 +1398,7 @@ Hunk *SegManager::alloc_Hunk(reg_t *addr) {
 	offset = table->allocEntry();
 
 	*addr = make_reg(Hunks_seg_id, offset);
-	return &(mobj->data.hunks.table[offset].entry);
+	return &(mobj->data.hunks.table[offset]);
 }
 
 
@@ -1696,7 +1646,7 @@ void SegInterfaceClones::listAllOutgoingReferences(EngineState *s, reg_t addr, v
 		return;
 	}
 
-	clone = &(clone_table->table[addr.offset].entry);
+	clone = &(clone_table->table[addr.offset]);
 
 	// Emit all member variables (including references to the 'super' delegate)
 	for (i = 0; i < clone->variables_nr; i++)
@@ -1712,7 +1662,7 @@ void SegInterfaceClones::freeAtAddress(reg_t addr) {
 
 	assert(addr.segment == _segId);
 
-	victim_obj = &(_mobj->data.clones.table[addr.offset].entry);
+	victim_obj = &(_mobj->data.clones.table[addr.offset]);
 
 #ifdef GC_DEBUG
 	if (!(victim_obj->flags & OBJECT_FLAG_FREED))
@@ -1826,7 +1776,7 @@ void SegInterfaceLists::listAllDeallocatable(void *param, NoteCallback note) {
 
 void SegInterfaceLists::listAllOutgoingReferences(EngineState *s, reg_t addr, void *param, NoteCallback note) {
 	ListTable *table = &(_mobj->data.lists);
-	List *list = &(table->table[addr.offset].entry);
+	List *list = &(table->table[addr.offset]);
 
 	if (!ENTRY_IS_VALID(table, addr.offset)) {
 		fprintf(stderr, "Invalid list referenced for outgoing references: "PREG"\n", PRINT_REG(addr));
@@ -1860,7 +1810,7 @@ void SegInterfaceNodes::listAllDeallocatable(void *param, NoteCallback note) {
 
 void SegInterfaceNodes::listAllOutgoingReferences(EngineState *s, reg_t addr, void *param, NoteCallback note) {
 	NodeTable *table = &(_mobj->data.nodes);
-	Node *node = &(table->table[addr.offset].entry);
+	Node *node = &(table->table[addr.offset]);
 
 	if (!ENTRY_IS_VALID(table, addr.offset)) {
 		fprintf(stderr, "Invalid node referenced for outgoing references: "PREG"\n", PRINT_REG(addr));
diff --git a/engines/sci/engine/vm.cpp b/engines/sci/engine/vm.cpp
index e776b9e598..8a49efb906 100644
--- a/engines/sci/engine/vm.cpp
+++ b/engines/sci/engine/vm.cpp
@@ -2089,7 +2089,7 @@ Object *obj_get(EngineState *s, reg_t offset) {
 
 	if (memobj != NULL) {
 		if (memobj->type == MEM_OBJ_CLONES && ENTRY_IS_VALID(&memobj->data.clones, offset.offset))
-			obj = &(memobj->data.clones.table[offset.offset].entry);
+			obj = &(memobj->data.clones.table[offset.offset]);
 		else if (memobj->type == MEM_OBJ_SCRIPT) {
 			if (offset.offset <= memobj->data.script.buf_size && offset.offset >= -SCRIPT_OBJECT_MAGIC_OFFSET
 			        && RAW_IS_OBJECT(memobj->data.script.buf + offset.offset)) {
diff --git a/engines/sci/engine/vm.h b/engines/sci/engine/vm.h
index 614ffe56ec..2dd2873ed6 100644
--- a/engines/sci/engine/vm.h
+++ b/engines/sci/engine/vm.h
@@ -259,12 +259,24 @@ struct Hunk {
 
 template<typename T, int INITIAL, int INCREMENT>
 struct Table {
+	struct Entry : public T {
+		int next_free; /* Only used for free entries */
+	};
+
 	int entries_nr; /* Number of entries allocated */
 	int first_free; /* Beginning of a singly linked list for entries */
 	int entries_used; /* Statistical information */
 	int max_entry; /* Highest entry used */
 
-	T *table;
+	Entry *table;
+
+	void initTable() {
+		entries_nr = INITIAL;
+		max_entry = 0;
+		entries_used = 0;
+		first_free = HEAPENTRY_INVALID;
+		table = (Entry *)calloc(INITIAL, sizeof(Entry));
+	}
 
 	int	allocEntry() {
 		entries_used++;
@@ -278,9 +290,8 @@ struct Table {
 			if (max_entry == entries_nr) {
 				entries_nr += INCREMENT;
 
-				table = (T *)sci_realloc(table,
-							   sizeof(T) * entries_nr);
-				memset(&table[entries_nr-INCREMENT], 0, INCREMENT * sizeof(T));
+				table = (Entry *)sci_realloc(table,  sizeof(Entry) * entries_nr);
+				memset(&table[entries_nr-INCREMENT], 0, INCREMENT * sizeof(Entry));
 			}
 			table[max_entry].next_free = max_entry; /* Tag as 'valid' */
 			return max_entry++;
@@ -289,46 +300,22 @@ struct Table {
 };
 
 /* CloneTable */
-struct CloneEntry {
-	int next_free; /* Only used for free entries */
-	Clone entry;
-};
-typedef Table<CloneEntry, 16, 4> CloneTable;
-void init_Clone_table(CloneTable *table);
-int alloc_Clone_entry(CloneTable *table);
+typedef Table<Clone, 16, 4> CloneTable;
 void free_Clone_entry(CloneTable *table, int index);
 
 
 /* NodeTable */
-struct NodeEntry {
-	int next_free; /* Only used for free entries */
-	Node entry;
-};
-typedef Table<NodeEntry, 32, 16> NodeTable;
-void init_Node_table(NodeTable *table);
-int alloc_Node_entry(NodeTable *table);
+typedef Table<Node, 32, 16> NodeTable;
 void free_Node_entry(NodeTable *table, int index);
 
 
 /* ListTable */
-struct ListEntry {
-	int next_free; /* Only used for free entries */
-	List entry;
-};
-typedef Table<ListEntry, 8, 4> ListTable;
-void init_List_table(ListTable *table);
-int alloc_List_entry(ListTable *table);
+typedef Table<List, 8, 4> ListTable;
 void free_List_entry(ListTable *table, int index);
 
 
 /* HunkTable */
-struct HunkEntry {
-	int next_free; /* Only used for free entries */
-	Hunk entry;
-};
-typedef Table<HunkEntry, 4, 4> HunkTable;
-void init_Hunk_table(HunkTable *table);
-int alloc_Hunk_entry(HunkTable *table);
+typedef Table<Hunk, 4, 4> HunkTable;
 void free_Hunk_entry(HunkTable *table, int index);