[Scummvm-cvs-logs] SF.net SVN: scummvm:[40190] scummvm/trunk/engines/sci/engine
fingolfin at users.sourceforge.net
fingolfin at users.sourceforge.net
Wed Apr 29 00:56:44 CEST 2009
Revision: 40190
http://scummvm.svn.sourceforge.net/scummvm/?rev=40190&view=rev
Author: fingolfin
Date: 2009-04-28 22:56:44 +0000 (Tue, 28 Apr 2009)
Log Message:
-----------
SCI: Improved the Table template a bit by taking advantage of C++ features
Modified Paths:
--------------
scummvm/trunk/engines/sci/engine/kernel.cpp
scummvm/trunk/engines/sci/engine/klists.cpp
scummvm/trunk/engines/sci/engine/savegame.cpp
scummvm/trunk/engines/sci/engine/scriptconsole.cpp
scummvm/trunk/engines/sci/engine/scriptdebug.cpp
scummvm/trunk/engines/sci/engine/seg_manager.cpp
scummvm/trunk/engines/sci/engine/vm.cpp
scummvm/trunk/engines/sci/engine/vm.h
Modified: scummvm/trunk/engines/sci/engine/kernel.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/kernel.cpp 2009-04-28 22:04:03 UTC (rev 40189)
+++ scummvm/trunk/engines/sci/engine/kernel.cpp 2009-04-28 22:56:44 UTC (rev 40190)
@@ -247,7 +247,7 @@
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.
Modified: scummvm/trunk/engines/sci/engine/klists.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/klists.cpp 2009-04-28 22:04:03 UTC (rev 40189)
+++ scummvm/trunk/engines/sci/engine/klists.cpp 2009-04-28 22:56:44 UTC (rev 40190)
@@ -53,7 +53,7 @@
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 @@
return NULL;
}
- return &(lt->table[addr.offset].entry);
+ return &(lt->table[addr.offset]);
}
#ifdef DISABLE_VALIDATIONS
Modified: scummvm/trunk/engines/sci/engine/savegame.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/savegame.cpp 2009-04-28 22:04:03 UTC (rev 40189)
+++ scummvm/trunk/engines/sci/engine/savegame.cpp 2009-04-28 22:56:44 UTC (rev 40190)
@@ -288,16 +288,7 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 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 @@
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 @@
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 @@
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++;
}
Modified: scummvm/trunk/engines/sci/engine/scriptconsole.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/scriptconsole.cpp 2009-04-28 22:04:03 UTC (rev 40189)
+++ scummvm/trunk/engines/sci/engine/scriptconsole.cpp 2009-04-28 22:56:44 UTC (rev 40190)
@@ -328,7 +328,7 @@
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);
}
Modified: scummvm/trunk/engines/sci/engine/scriptdebug.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/scriptdebug.cpp 2009-04-28 22:04:03 UTC (rev 40189)
+++ scummvm/trunk/engines/sci/engine/scriptdebug.cpp 2009-04-28 22:56:44 UTC (rev 40190)
@@ -366,7 +366,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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));
Modified: scummvm/trunk/engines/sci/engine/seg_manager.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/seg_manager.cpp 2009-04-28 22:04:03 UTC (rev 40189)
+++ scummvm/trunk/engines/sci/engine/seg_manager.cpp 2009-04-28 22:56:44 UTC (rev 40190)
@@ -363,7 +363,7 @@
}
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 @@
}
-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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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::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::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));
Modified: scummvm/trunk/engines/sci/engine/vm.cpp
===================================================================
--- scummvm/trunk/engines/sci/engine/vm.cpp 2009-04-28 22:04:03 UTC (rev 40189)
+++ scummvm/trunk/engines/sci/engine/vm.cpp 2009-04-28 22:56:44 UTC (rev 40190)
@@ -2089,7 +2089,7 @@
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)) {
Modified: scummvm/trunk/engines/sci/engine/vm.h
===================================================================
--- scummvm/trunk/engines/sci/engine/vm.h 2009-04-28 22:04:03 UTC (rev 40189)
+++ scummvm/trunk/engines/sci/engine/vm.h 2009-04-28 22:56:44 UTC (rev 40190)
@@ -259,13 +259,25 @@
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++;
if (first_free != HEAPENTRY_INVALID) {
@@ -278,9 +290,8 @@
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 @@
};
/* 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);
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
More information about the Scummvm-git-logs
mailing list