aboutsummaryrefslogtreecommitdiff
path: root/engines
diff options
context:
space:
mode:
Diffstat (limited to 'engines')
-rw-r--r--engines/sci/engine/gc.cpp18
-rw-r--r--engines/sci/engine/scriptdebug.cpp12
-rw-r--r--engines/sci/engine/seg_manager.cpp398
-rw-r--r--engines/sci/engine/seg_manager.h45
4 files changed, 238 insertions, 235 deletions
diff --git a/engines/sci/engine/gc.cpp b/engines/sci/engine/gc.cpp
index 94632a6b7c..531ecf8d19 100644
--- a/engines/sci/engine/gc.cpp
+++ b/engines/sci/engine/gc.cpp
@@ -100,7 +100,7 @@ static void free_worklist(worklist_t *wl) {
}
}
-static reg_t_hash_map * normalise_hashmap_ptrs(reg_t_hash_map *nonnormal_map, SegInterface **interfaces, int interfaces_nr) {
+static reg_t_hash_map *normalise_hashmap_ptrs(reg_t_hash_map *nonnormal_map, SegInterface **interfaces, int interfaces_nr) {
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) {
@@ -109,7 +109,7 @@ static reg_t_hash_map * normalise_hashmap_ptrs(reg_t_hash_map *nonnormal_map, Se
interfce = (reg.segment < interfaces_nr) ? interfaces[reg.segment] : NULL;
if (interfce) {
- reg = interfce->find_canonic_address(interfce, reg);
+ reg = interfce->findCanonicAddress(reg);
normal_map->setVal(reg, true);
}
}
@@ -181,8 +181,8 @@ reg_t_hash_map *find_all_used_references(EngineState *s) {
// Init: Explicitly loaded scripts
for (i = 1; i < sm->heap_size; i++)
if (interfaces[i]
- && interfaces[i]->type_id == MEM_OBJ_SCRIPT) {
- script_t *script = &(interfaces[i]->mobj->data.script);
+ && interfaces[i]->getType() == MEM_OBJ_SCRIPT) {
+ script_t *script = &(interfaces[i]->getMobj()->data.script);
if (script->lockers) { // Explicitly loaded?
int obj_nr;
@@ -209,7 +209,7 @@ reg_t_hash_map *find_all_used_references(EngineState *s) {
sciprintf("[GC] Checking "PREG"\n", PRINT_REG(reg));
#endif
if (reg.segment < sm->heap_size && interfaces[reg.segment])
- interfaces[reg.segment]->list_all_outgoing_references(interfaces[reg.segment], s, reg,
+ interfaces[reg.segment]->listAllOutgoingReferences(s, reg,
&worklist_manager, add_outgoing_refs);
}
}
@@ -220,7 +220,7 @@ reg_t_hash_map *find_all_used_references(EngineState *s) {
// Cleanup
for (i = 1; i < sm->heap_size; i++)
if (interfaces[i])
- interfaces[i]->deallocate_self(interfaces[i]);
+ delete interfaces[i];
free(interfaces);
delete nonnormal_map;
@@ -243,7 +243,7 @@ void free_unless_used(void *pre_use_map, reg_t addr) {
if (!use_map->contains(addr)) {
// Not found -> we can free it
- deallocator->interfce->free_at_address(deallocator->interfce, addr);
+ deallocator->interfce->freeAtAddress(addr);
#ifdef DEBUG_GC
sciprintf("[GC] Deallocating "PREG"\n", PRINT_REG(addr));
deallocator->segcount[deallocator->interfce->type_id]++;
@@ -271,8 +271,8 @@ void run_gc(EngineState *s) {
#ifdef DEBUG_GC
deallocator.segnames[deallocator.interfce->type_id] = deallocator.interfce->type;
#endif
- deallocator.interfce->list_all_deallocatable(deallocator.interfce, &deallocator, free_unless_used);
- deallocator.interfce->deallocate_self(deallocator.interfce);
+ deallocator.interfce->listAllDeallocatable(&deallocator, free_unless_used);
+ delete deallocator.interfce;
}
}
diff --git a/engines/sci/engine/scriptdebug.cpp b/engines/sci/engine/scriptdebug.cpp
index 4fd1dffc9a..b5b8da4c0b 100644
--- a/engines/sci/engine/scriptdebug.cpp
+++ b/engines/sci/engine/scriptdebug.cpp
@@ -2807,9 +2807,9 @@ static int c_gc_show_reachable(EngineState *s) {
GET_SEG_INTERFACE(addr.segment);
sciprintf("Reachable from "PREG":\n", PRINT_REG(addr));
- seg_interface->list_all_outgoing_references(seg_interface, s, addr, NULL, _print_address);
+ seg_interface->listAllOutgoingReferences(s, addr, NULL, _print_address);
- seg_interface->deallocate_self(seg_interface);
+ delete seg_interface;
return 0;
}
@@ -2820,9 +2820,9 @@ static int c_gc_show_freeable(EngineState *s) {
GET_SEG_INTERFACE(addr.segment);
sciprintf("Freeable in segment %04x:\n", addr.segment);
- seg_interface->list_all_deallocatable(seg_interface, NULL, _print_address);
+ seg_interface->listAllDeallocatable(NULL, _print_address);
- seg_interface->deallocate_self(seg_interface);
+ delete seg_interface;
return 0;
}
@@ -2832,10 +2832,10 @@ static int c_gc_normalise(EngineState *s) {
GET_SEG_INTERFACE(addr.segment);
- addr = seg_interface->find_canonic_address(seg_interface, addr);
+ addr = seg_interface->findCanonicAddress(addr);
sciprintf(" "PREG"\n", PRINT_REG(addr));
- seg_interface->deallocate_self(seg_interface);
+ delete seg_interface;
return 0;
}
diff --git a/engines/sci/engine/seg_manager.cpp b/engines/sci/engine/seg_manager.cpp
index bbcc310d74..ebdfc61b28 100644
--- a/engines/sci/engine/seg_manager.cpp
+++ b/engines/sci/engine/seg_manager.cpp
@@ -1423,44 +1423,58 @@ void SegManager::dbgPrint(const char* msg, void *i) {
#endif
}
-// ------------------- Segment interface ------------------
-static void free_at_address_stub(SegInterface *self, reg_t sub_addr) {
- //sciprintf(" Request to free "PREG"\n", PRINT_REG(sub_addr));
- // STUB
+// ------------------- Segment interface ------------------
+SegInterface::SegInterface(SegManager *segmgr, mem_obj_t *mobj, seg_id_t segId, memObjType typeId) :
+ _segmgr(segmgr), _mobj(mobj), _segId(segId), _typeId(typeId) {
+ VERIFY(_mobj->type == _typeId, "Invalid mem_obj_t type");
}
-static reg_t find_canonic_address_base(SegInterface *self, reg_t addr) {
- addr.offset = 0;
-
+reg_t SegInterface::findCanonicAddress(reg_t addr) {
return addr;
}
-static reg_t find_canonic_address_id(SegInterface *self, reg_t addr) {
- return addr;
+void SegInterface::freeAtAddress(reg_t sub_addr) {
}
-static void free_at_address_nop(SegInterface *self, reg_t sub_addr) {
+void SegInterface::listAllDeallocatable(void *param, void (*note)(void *param, reg_t addr)) {
}
-static void list_all_deallocatable_nop(SegInterface *self, void *param, void (*note)(void*param, reg_t addr)) {
+void SegInterface::listAllOutgoingReferences(EngineState *s, reg_t object, void *param, void (*note)(void *param, reg_t addr)) {
}
-static void list_all_deallocatable_base(SegInterface *self, void *param, void (*note)(void*param, reg_t addr)) {
- (*note)(param, make_reg(self->seg_id, 0));
-}
-static void list_all_outgoing_references_nop(SegInterface *self, EngineState *s, reg_t addr, void *param, void (*note)(void*param, reg_t addr)) {
+//-------------------- base --------------------
+class SegInterfaceBase : public SegInterface {
+protected:
+ SegInterfaceBase(SegManager *segmgr, mem_obj_t *mobj, seg_id_t segId, memObjType typeId) :
+ SegInterface(segmgr, mobj, segId, typeId) {}
+public:
+ reg_t findCanonicAddress(reg_t addr);
+ void listAllDeallocatable(void *param, void (*note)(void *param, reg_t addr));
+};
+
+reg_t SegInterfaceBase::findCanonicAddress(reg_t addr) {
+ addr.offset = 0;
+ return addr;
}
-static void deallocate_self(SegInterface *self) {
- free(self);
+void SegInterfaceBase::listAllDeallocatable(void *param, void (*note)(void *param, reg_t addr)) {
+ (*note)(param, make_reg(_segId, 0));
}
-static void free_at_address_script(SegInterface *self, reg_t addr) {
- script_t *script;
- VERIFY(self->mobj->type == MEM_OBJ_SCRIPT, "Trying to free a non-script!");
- script = &(self->mobj->data.script);
+
+//-------------------- script --------------------
+class SegInterfaceScript : public SegInterfaceBase {
+public:
+ SegInterfaceScript(SegManager *segmgr, mem_obj_t *mobj, seg_id_t segId) :
+ SegInterfaceBase(segmgr, mobj, segId, MEM_OBJ_SCRIPT) {}
+ void freeAtAddress(reg_t addr);
+ void listAllOutgoingReferences(EngineState *s, reg_t addr, void *param, void (*note)(void *param, reg_t addr));
+};
+
+void SegInterfaceScript::freeAtAddress(reg_t addr) {
+ script_t *script = &(_mobj->data.script);
/*
sciprintf("[GC] Freeing script "PREG"\n", PRINT_REG(addr));
if (script->locals_segment)
@@ -1468,11 +1482,11 @@ static void free_at_address_script(SegInterface *self, reg_t addr) {
*/
if (script->marked_as_deleted)
- self->segmgr->deallocateScript(script->nr);
+ _segmgr->deallocateScript(script->nr);
}
-static void list_all_outgoing_references_script(SegInterface *self, EngineState *s, reg_t addr, void *param, void (*note)(void*param, reg_t addr)) {
- script_t *script = &(self->mobj->data.script);
+void SegInterfaceScript::listAllOutgoingReferences(EngineState *s, reg_t addr, void *param, void (*note)(void *param, reg_t addr)) {
+ script_t *script = &(_mobj->data.script);
if (addr.offset <= script->buf_size && addr.offset >= -SCRIPT_OBJECT_MAGIC_OFFSET && RAW_IS_OBJECT(script->buf + addr.offset)) {
int idx = RAW_GET_CLASS_INDEX(script, addr);
@@ -1495,41 +1509,36 @@ static void list_all_outgoing_references_script(SegInterface *self, EngineState
}
}
-//-------------------- script --------------------
-static SegInterface seg_interface_script = {
- /* segmgr = */ NULL,
- /* mobj = */ NULL,
- /* seg_id = */ 0,
- /* type_id = */ MEM_OBJ_SCRIPT,
- /* type = */ "script",
- /* find_canonic_address = */ find_canonic_address_base,
- /* free_at_address = */ free_at_address_script,
- /* list_all_deallocatable = */ list_all_deallocatable_base,
- /* list_all_outgoing_references = */ list_all_outgoing_references_script,
- /* deallocate_self = */ deallocate_self
-};
-
#define LIST_ALL_DEALLOCATABLE(kind, kind_field) \
- mem_obj_t *mobj = self->mobj; \
- kind##_table_t * table = &(mobj->data.kind_field); \
+ kind##_table_t * table = &(_mobj->data.kind_field); \
int i; \
\
for (i = 0; i < table->max_entry; i++) \
if (ENTRY_IS_VALID(table, i)) \
- (*note) (param, make_reg(self->seg_id, i));
+ (*note) (param, make_reg(_segId, i));
+
+
+//-------------------- clones --------------------
+class SegInterfaceClones : public SegInterface {
+public:
+ SegInterfaceClones(SegManager *segmgr, mem_obj_t *mobj, seg_id_t segId) :
+ SegInterface(segmgr, mobj, segId, MEM_OBJ_CLONES) {}
+ void freeAtAddress(reg_t addr);
+ void listAllDeallocatable(void *param, void (*note)(void *param, reg_t addr));
+ void listAllOutgoingReferences(EngineState *s, reg_t addr, void *param, void (*note)(void *param, reg_t addr));
+};
-static void list_all_deallocatable_clones(SegInterface *self, void *param, void (*note)(void*param, reg_t addr)) {
+void SegInterfaceClones::listAllDeallocatable(void *param, void (*note)(void *param, reg_t addr)) {
LIST_ALL_DEALLOCATABLE(clone, clones);
}
-static void list_all_outgoing_references_clones(SegInterface *self, EngineState *s, reg_t addr, void *param, void (*note)(void*param, reg_t addr)) {
- mem_obj_t *mobj = self->mobj;
- clone_table_t *clone_table = &(mobj->data.clones);
+void SegInterfaceClones::listAllOutgoingReferences(EngineState *s, reg_t addr, void *param, void (*note)(void *param, reg_t addr)) {
+ clone_table_t *clone_table = &(_mobj->data.clones);
clone_t *clone;
int i;
- assert(addr.segment == self->seg_id);
+ assert(addr.segment == _segId);
if (!(ENTRY_IS_VALID(clone_table, addr.offset))) {
fprintf(stderr, "Unexpected request for outgoing references from clone at "PREG"\n", PRINT_REG(addr));
@@ -1548,12 +1557,12 @@ static void list_all_outgoing_references_clones(SegInterface *self, EngineState
//sciprintf("[GC] Reporting clone-pos "PREG"\n", PRINT_REG(clone->pos));
}
-void free_at_address_clones(SegInterface *self, reg_t addr) {
+void SegInterfaceClones::freeAtAddress(reg_t addr) {
object_t *victim_obj;
- assert(addr.segment == self->seg_id);
+ assert(addr.segment == _segId);
- victim_obj = &(self->mobj->data.clones.table[addr.offset].entry);
+ victim_obj = &(_mobj->data.clones.table[addr.offset].entry);
#ifdef GC_DEBUG
if (!(victim_obj->flags & OBJECT_FLAG_FREED))
@@ -1569,100 +1578,97 @@ void free_at_address_clones(SegInterface *self, reg_t addr) {
*/
free(victim_obj->variables);
victim_obj->variables = NULL;
- self->segmgr->free_clone(addr);
+ _segmgr->free_clone(addr);
}
-//-------------------- clones --------------------
-static SegInterface seg_interface_clones = {
- /* segmgr = */ NULL,
- /* mobj = */ NULL,
- /* seg_id = */ 0,
- /* type_id = */ MEM_OBJ_CLONES,
- /* type = */ "clones",
- /* find_canonic_address = */ find_canonic_address_id,
- /* free_at_address = */ free_at_address_clones,
- /* list_all_deallocatable = */ list_all_deallocatable_clones,
- /* list_all_outgoing_references = */ list_all_outgoing_references_clones,
- /* deallocate_self = */ deallocate_self
+
+//-------------------- locals --------------------
+class SegInterfaceLocals : public SegInterface {
+public:
+ SegInterfaceLocals(SegManager *segmgr, mem_obj_t *mobj, seg_id_t segId) :
+ SegInterface(segmgr, mobj, segId, MEM_OBJ_LOCALS) {}
+ reg_t findCanonicAddress(reg_t addr);
+ void freeAtAddress(reg_t addr);
+ void listAllOutgoingReferences(EngineState *s, reg_t addr, void *param, void (*note)(void *param, reg_t addr));
};
-static reg_t find_canonic_address_locals(SegInterface *self, reg_t addr) {
- local_variables_t *locals = &(self->mobj->data.locals);
+reg_t SegInterfaceLocals::findCanonicAddress(reg_t addr) {
+ local_variables_t *locals = &(_mobj->data.locals);
// Reference the owning script
- seg_id_t owner_seg = self->segmgr->segGet(locals->script_id);
+ seg_id_t owner_seg = _segmgr->segGet(locals->script_id);
assert(owner_seg >= 0);
return make_reg(owner_seg, 0);
}
-static void list_all_outgoing_references_locals(SegInterface *self, EngineState *s, reg_t addr, void *param, void (*note)(void*param, reg_t addr)) {
- local_variables_t *locals = &(self->mobj->data.locals);
+void SegInterfaceLocals::freeAtAddress(reg_t sub_addr) {
+ //sciprintf(" Request to free "PREG"\n", PRINT_REG(sub_addr));
+ // STUB
+}
+
+void SegInterfaceLocals::listAllOutgoingReferences(EngineState *s, reg_t addr, void *param, void (*note)(void*param, reg_t addr)) {
+ local_variables_t *locals = &(_mobj->data.locals);
int i;
- assert(addr.segment == self->seg_id);
+ assert(addr.segment == _segId);
for (i = 0; i < locals->nr; i++)
(*note)(param, locals->locals[i]);
}
-//-------------------- locals --------------------
-static SegInterface seg_interface_locals = {
- /* segmgr = */ NULL,
- /* mobj = */ NULL,
- /* seg_id = */ 0,
- /* type_id = */ MEM_OBJ_LOCALS,
- /* type = */ "locals",
- /* find_canonic_address = */ find_canonic_address_locals,
- /* free_at_address = */ free_at_address_stub,
- /* list_all_deallocatable = */ list_all_deallocatable_nop,
- /* list_all_outgoing_references = */ list_all_outgoing_references_locals,
- /* deallocate_self = */ deallocate_self
+
+//-------------------- stack --------------------
+class SegInterfaceStack : public SegInterface {
+public:
+ SegInterfaceStack(SegManager *segmgr, mem_obj_t *mobj, seg_id_t segId) :
+ SegInterface(segmgr, mobj, segId, MEM_OBJ_STACK) {}
+ reg_t findCanonicAddress(reg_t addr);
+ void listAllOutgoingReferences(EngineState *s, reg_t addr, void *param, void (*note)(void *param, reg_t addr));
};
-static void list_all_outgoing_references_stack(SegInterface *self, EngineState *s, reg_t addr, void *param, void (*note)(void*param, reg_t addr)) {
+reg_t SegInterfaceStack::findCanonicAddress(reg_t addr) {
+ addr.offset = 0;
+ return addr;
+}
+
+void SegInterfaceStack::listAllOutgoingReferences(EngineState *s, reg_t addr, void *param, void (*note)(void*param, reg_t addr)) {
int i;
- fprintf(stderr, "Emitting %d stack entries\n", self->mobj->data.stack.nr);
- for (i = 0; i < self->mobj->data.stack.nr; i++)
- (*note)(param, self->mobj->data.stack.entries[i]);
+ fprintf(stderr, "Emitting %d stack entries\n", _mobj->data.stack.nr);
+ for (i = 0; i < _mobj->data.stack.nr; i++)
+ (*note)(param, _mobj->data.stack.entries[i]);
fprintf(stderr, "DONE");
}
-//-------------------- stack --------------------
-static SegInterface seg_interface_stack = {
- /* segmgr = */ NULL,
- /* mobj = */ NULL,
- /* seg_id = */ 0,
- /* type_id = */ MEM_OBJ_STACK,
- /* type = */ "stack",
- /* find_canonic_address = */ find_canonic_address_base,
- /* free_at_address = */ free_at_address_nop,
- /* list_all_deallocatable = */ list_all_deallocatable_nop,
- /* list_all_outgoing_references = */ list_all_outgoing_references_stack,
- /* deallocate_self = */ deallocate_self
+//-------------------- system strings --------------------
+class SegInterfaceSysStrings : public SegInterface {
+public:
+ SegInterfaceSysStrings(SegManager *segmgr, mem_obj_t *mobj, seg_id_t segId) :
+ SegInterface(segmgr, mobj, segId, MEM_OBJ_SYS_STRINGS) {}
};
-//-------------------- system strings --------------------
-static SegInterface seg_interface_sys_strings = {
- /* segmgr = */ NULL,
- /* mobj = */ NULL,
- /* seg_id = */ 0,
- /* type_id = */ MEM_OBJ_SYS_STRINGS,
- /* type = */ "system strings",
- /* find_canonic_address = */ find_canonic_address_id,
- /* free_at_address = */ free_at_address_nop,
- /* list_all_deallocatable = */ list_all_deallocatable_nop,
- /* list_all_outgoing_references = */ list_all_outgoing_references_nop,
- /* deallocate_self = */ deallocate_self
+
+//-------------------- lists --------------------
+class SegInterfaceLists : public SegInterface {
+public:
+ SegInterfaceLists(SegManager *segmgr, mem_obj_t *mobj, seg_id_t segId) :
+ SegInterface(segmgr, mobj, segId, MEM_OBJ_LISTS) {}
+ void freeAtAddress(reg_t addr);
+ void listAllDeallocatable(void *param, void (*note)(void *param, reg_t addr));
+ void listAllOutgoingReferences(EngineState *s, reg_t addr, void *param, void (*note)(void *param, reg_t addr));
};
-static void list_all_deallocatable_list(SegInterface *self, void *param, void (*note)(void*param, reg_t addr)) {
+void SegInterfaceLists::freeAtAddress(reg_t sub_addr) {
+ _segmgr->free_list(sub_addr);
+}
+
+void SegInterfaceLists::listAllDeallocatable(void *param, void (*note)(void*param, reg_t addr)) {
LIST_ALL_DEALLOCATABLE(list, lists);
}
-static void list_all_outgoing_references_list(SegInterface *self, EngineState *s, reg_t addr, void *param, void (*note)(void*param, reg_t addr)) {
- list_table_t *table = &(self->mobj->data.lists);
+void SegInterfaceLists::listAllOutgoingReferences(EngineState *s, reg_t addr, void *param, void (*note)(void*param, reg_t addr)) {
+ list_table_t *table = &(_mobj->data.lists);
list_t *list = &(table->table[addr.offset].entry);
if (!ENTRY_IS_VALID(table, addr.offset)) {
@@ -1676,30 +1682,27 @@ static void list_all_outgoing_references_list(SegInterface *self, EngineState *s
// let's be conservative here.
}
-static void free_at_address_lists(SegInterface *self, reg_t sub_addr) {
- self->segmgr->free_list(sub_addr);
-}
-//-------------------- lists --------------------
-static SegInterface seg_interface_lists = {
- /* segmgr = */ NULL,
- /* mobj = */ NULL,
- /* seg_id = */ 0,
- /* type_id = */ MEM_OBJ_LISTS,
- /* type = */ "lists",
- /* find_canonic_address = */ find_canonic_address_id,
- /* free_at_address = */ free_at_address_lists,
- /* list_all_deallocatable = */ list_all_deallocatable_list,
- /* list_all_outgoing_references = */ list_all_outgoing_references_list,
- /* deallocate_self = */ deallocate_self
+//-------------------- nodes --------------------
+class SegInterfaceNodes : public SegInterface {
+public:
+ SegInterfaceNodes(SegManager *segmgr, mem_obj_t *mobj, seg_id_t segId) :
+ SegInterface(segmgr, mobj, segId, MEM_OBJ_NODES) {}
+ void freeAtAddress(reg_t addr);
+ void listAllDeallocatable(void *param, void (*note)(void *param, reg_t addr));
+ void listAllOutgoingReferences(EngineState *s, reg_t addr, void *param, void (*note)(void *param, reg_t addr));
};
-static void list_all_deallocatable_nodes(SegInterface *self, void *param, void (*note)(void*param, reg_t addr)) {
+void SegInterfaceNodes::freeAtAddress(reg_t sub_addr) {
+ _segmgr->free_node(sub_addr);
+}
+
+void SegInterfaceNodes::listAllDeallocatable(void *param, void (*note)(void*param, reg_t addr)) {
LIST_ALL_DEALLOCATABLE(node, nodes);
}
-static void list_all_outgoing_references_nodes(SegInterface *self, EngineState *s, reg_t addr, void *param, void (*note)(void*param, reg_t addr)) {
- node_table_t *table = &(self->mobj->data.nodes);
+void SegInterfaceNodes::listAllOutgoingReferences(EngineState *s, reg_t addr, void *param, void (*note)(void*param, reg_t addr)) {
+ node_table_t *table = &(_mobj->data.nodes);
node_t *node = &(table->table[addr.offset].entry);
if (!ENTRY_IS_VALID(table, addr.offset)) {
@@ -1715,102 +1718,89 @@ static void list_all_outgoing_references_nodes(SegInterface *self, EngineState *
note(param, node->value);
}
-static void free_at_address_nodes(SegInterface *self, reg_t sub_addr) {
- self->segmgr->free_node(sub_addr);
-}
-//-------------------- nodes --------------------
-static SegInterface seg_interface_nodes = {
- /* segmgr = */ NULL,
- /* mobj = */ NULL,
- /* seg_id = */ 0,
- /* type_id = */ MEM_OBJ_NODES,
- /* type = */ "nodes",
- /* find_canonic_address = */ find_canonic_address_id,
- /* free_at_address = */ free_at_address_nodes,
- /* list_all_deallocatable = */ list_all_deallocatable_nodes,
- /* list_all_outgoing_references = */ list_all_outgoing_references_nodes,
- /* deallocate_self = */ deallocate_self
+//-------------------- hunk --------------------
+class SegInterfaceHunk : public SegInterface {
+public:
+ SegInterfaceHunk(SegManager *segmgr, mem_obj_t *mobj, seg_id_t segId) :
+ SegInterface(segmgr, mobj, segId, MEM_OBJ_HUNK) {}
+ void freeAtAddress(reg_t addr);
+ void listAllDeallocatable(void *param, void (*note)(void *param, reg_t addr));
};
-static void list_all_deallocatable_hunk(SegInterface *self, void *param, void (*note)(void*param, reg_t addr)) {
+void SegInterfaceHunk::freeAtAddress(reg_t sub_addr) {
+ //sciprintf(" Request to free "PREG"\n", PRINT_REG(sub_addr));
+ // STUB
+}
+
+void SegInterfaceHunk::listAllDeallocatable(void *param, void (*note)(void*param, reg_t addr)) {
LIST_ALL_DEALLOCATABLE(hunk, hunks);
}
-//-------------------- hunk --------------------
-static SegInterface seg_interface_hunk = {
- /* segmgr = */ NULL,
- /* mobj = */ NULL,
- /* seg_id = */ 0,
- /* type_id = */ MEM_OBJ_HUNK,
- /* type = */ "hunk",
- /* find_canonic_address = */ find_canonic_address_id,
- /* free_at_address = */ free_at_address_stub,
- /* list_all_deallocatable = */ list_all_deallocatable_hunk,
- /* list_all_outgoing_references = */ list_all_outgoing_references_nop,
- /* deallocate_self = */ deallocate_self
-};
//-------------------- dynamic memory --------------------
-static SegInterface seg_interface_dynmem = {
- /* segmgr = */ NULL,
- /* mobj = */ NULL,
- /* seg_id = */ 0,
- /* type_id = */ MEM_OBJ_DYNMEM,
- /* type = */ "dynamic memory",
- /* find_canonic_address = */ find_canonic_address_base,
- /* free_at_address = */ free_at_address_stub,
- /* list_all_deallocatable = */ list_all_deallocatable_base,
- /* list_all_outgoing_references = */ list_all_outgoing_references_nop,
- /* deallocate_self = */ deallocate_self
+class SegInterfaceDynMem : public SegInterfaceBase {
+public:
+ SegInterfaceDynMem(SegManager *segmgr, mem_obj_t *mobj, seg_id_t segId) :
+ SegInterfaceBase(segmgr, mobj, segId, MEM_OBJ_DYNMEM) {}
+ void freeAtAddress(reg_t addr);
};
+void SegInterfaceDynMem::freeAtAddress(reg_t sub_addr) {
+ //sciprintf(" Request to free "PREG"\n", PRINT_REG(sub_addr));
+ // STUB
+}
+
+
//-------------------- reserved --------------------
-static SegInterface seg_interface_reserved = {
- /* segmgr = */ NULL,
- /* mobj = */ NULL,
- /* seg_id = */ 0,
- /* type_id = */ MEM_OBJ_RESERVED,
- /* type = */ "reserved",
- /* find_canonic_address = */ find_canonic_address_id,
- /* free_at_address = */ free_at_address_nop,
- /* list_all_deallocatable = */ list_all_deallocatable_nop,
- /* list_all_outgoing_references = */ list_all_outgoing_references_nop,
- /* deallocate_self = */ deallocate_self
+class SegInterfaceReserved : public SegInterface {
+public:
+ SegInterfaceReserved(SegManager *segmgr, mem_obj_t *mobj, seg_id_t segId) :
+ SegInterface(segmgr, mobj, segId, MEM_OBJ_RESERVED) {}
};
-static SegInterface* seg_interfaces[MEM_OBJ_MAX] = {
- &seg_interface_script,
- &seg_interface_clones,
- &seg_interface_locals,
- &seg_interface_stack,
- &seg_interface_sys_strings,
- &seg_interface_lists,
- &seg_interface_nodes,
- &seg_interface_hunk,
- &seg_interface_dynmem,
- &seg_interface_reserved
-};
SegInterface *SegManager::getSegInterface(seg_id_t segid) {
- mem_obj_t *mobj;
- SegInterface *retval;
-
if (!check(segid))
return NULL; // Invalid segment
- mobj = heap[segid];
- retval = (SegInterface *)sci_malloc(sizeof(SegInterface));
- memcpy(retval, seg_interfaces[mobj->type - 1], sizeof(SegInterface));
-
- if (mobj->type != retval->type_id) {
+ SegInterface *retval = NULL;
+ mem_obj_t *mobj = heap[segid];
+ switch (mobj->type) {
+ case MEM_OBJ_SCRIPT:
+ retval = new SegInterfaceScript(this, mobj, segid);
+ break;
+ case MEM_OBJ_CLONES:
+ retval = new SegInterfaceClones(this, mobj, segid);
+ break;
+ case MEM_OBJ_LOCALS:
+ retval = new SegInterfaceLocals(this, mobj, segid);
+ break;
+ case MEM_OBJ_STACK:
+ retval = new SegInterfaceStack(this, mobj, segid);
+ break;
+ case MEM_OBJ_SYS_STRINGS:
+ retval = new SegInterfaceSysStrings(this, mobj, segid);
+ break;
+ case MEM_OBJ_LISTS:
+ retval = new SegInterfaceLists(this, mobj, segid);
+ break;
+ case MEM_OBJ_NODES:
+ retval = new SegInterfaceNodes(this, mobj, segid);
+ break;
+ case MEM_OBJ_HUNK:
+ retval = new SegInterfaceHunk(this, mobj, segid);
+ break;
+ case MEM_OBJ_DYNMEM:
+ retval = new SegInterfaceDynMem(this, mobj, segid);
+ break;
+ case MEM_OBJ_RESERVED:
+ retval = new SegInterfaceReserved(this, mobj, segid);
+ break;
+ default:
error("Improper segment interface for %d", mobj->type);
}
- retval->segmgr = this;
- retval->mobj = mobj;
- retval->seg_id = segid;
-
return retval;
}
diff --git a/engines/sci/engine/seg_manager.h b/engines/sci/engine/seg_manager.h
index 9adf332ea4..1671619368 100644
--- a/engines/sci/engine/seg_manager.h
+++ b/engines/sci/engine/seg_manager.h
@@ -58,7 +58,7 @@ enum idFlag {
(((mgr).heap[index] && ((mgr).heap[index]->type == MEM_OBJ_SCRIPT || (mgr).heap[index]->type == MEM_OBJ_CLONES))? (mgr).heap[index] \
: NULL): NULL
-struct SegInterface;
+class SegInterface;
class SegManager {
public:
@@ -340,6 +340,7 @@ public:
// Parameters: (reg_t) addr: Offset of the hunk entry to delete
void free_hunk_entry(reg_t addr);
+
// 9. Dynamic Memory
// Allocate some dynamic memory
@@ -385,7 +386,7 @@ public:
// Retrieves the segment interface to the specified segment
// Parameters: (seg_id_t) segid: ID of the segment to look up
// Returns : (SegInterface *): An interface to the specified segment ID, or NULL on error
- // The returned interface 'si' must be freed after use by calling 'si->dealloc_self(si)';
+ // The returned interface must be deleted after use
SegInterface *getSegInterface(seg_id_t segid);
@@ -450,38 +451,50 @@ private:
// 11. Segment interface, primarily for GC
-struct SegInterface {
- SegManager *segmgr;
- mem_obj_t *mobj;
- seg_id_t seg_id;
- memObjType type_id; // Segment type
- const char *type; // String description of the segment type
+class SegInterface {
+protected:
+ SegInterface(SegManager *segmgr, mem_obj_t *mobj, seg_id_t segId, memObjType typeId);
+
+public:
+ // Deallocates the segment interface
+ virtual ~SegInterface() {}
- reg_t (*find_canonic_address)(SegInterface *self, reg_t sub_addr);
// Finds the canonic address associated with sub_reg
// Parameters: (reg_t) sub_addr: The base address whose canonic address is to be found
// For each valid address a, there exists a canonic address c(a) such that c(a) = c(c(a)).
// This address "governs" a in the sense that deallocating c(a) will deallocate a.
+ virtual reg_t findCanonicAddress(reg_t sub_addr);
- void (*free_at_address)(SegInterface *self, reg_t sub_addr);
// Deallocates all memory associated with the specified address
// Parameters: (reg_t) sub_addr: The address (within the given segment) to deallocate
-
- void (*list_all_deallocatable)(SegInterface *self, void *param, void (*note)(void *param, reg_t addr));
+ virtual void freeAtAddress(reg_t sub_addr);
+
// Iterates over and reports all addresses within the current segment
// Parameters: note : (voidptr * addr) -> (): Invoked for each address on which free_at_address()
// makes sense
// (void *) param: Parameter passed to 'note'
+ virtual void listAllDeallocatable(void *param, void (*note)(void *param, reg_t addr));
- void (*list_all_outgoing_references)(SegInterface *self, EngineState *s, reg_t object, void *param, void (*note)(void *param, reg_t addr));
// Iterates over all references reachable from the specified object
// Parameters: (reg_t) object: The object (within the current segment) to analyse
// (void *) param: Parameter passed to 'note'
// note : (voidptr * addr) -> (): Invoked for each outgoing reference within the object
// Note: This function may also choose to report numbers (segment 0) as adresses
-
- void (*deallocate_self)(SegInterface *self);
- // Deallocates the segment interface
+ virtual void listAllOutgoingReferences(EngineState *s, reg_t object, void *param, void (*note)(void *param, reg_t addr));
+
+ // Get the memory object
+ mem_obj_t *getMobj() { return _mobj; }
+
+ // Get the segment type
+ memObjType getType() { return _typeId; }
+
+protected:
+ SegManager *_segmgr;
+ mem_obj_t *_mobj;
+ seg_id_t _segId;
+
+private:
+ memObjType _typeId; // Segment type
};
} // End of namespace Sci
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-25 18:19:04 +0000