SCI: Committed stuff I forgot in my last commit; changed int_hash_map_t to a C++ class

svn-id: r38360

4 files changed, 3 insertions, 827 deletions

diff --git a/engines/sci/include/hashmap.h b/engines/sci/include/hashmap.h
deleted file mode 100644
index 51a945c9d9..0000000000
--- a/engines/sci/include/hashmap.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/***************************************************************************
- hashmap.h Copyright (C) 2001 Christoph Reichenbach
-
-
- This program may be modified and copied freely according to the terms of
- the GNU general public license (GPL), as long as the above copyright
- notice and the licensing information contained herein are preserved.
-
- Please refer to www.gnu.org for licensing details.
-
- This work is provided AS IS, without warranty of any kind, expressed or
- implied, including but not limited to the warranties of merchantibility,
- noninfringement, and fitness for a specific purpose. The author will not
- be held liable for any damage caused by this work or derivatives of it.
-
- By using this source code, you agree to the licensing terms as stated
- above.
-
-
- Please contact the maintainer for bug reports or inquiries.
-
- Current Maintainer:
-
-    Christoph Reichenbach (CR) <jameson@linuxgames.com>
-
-***************************************************************************/
-/* Defines a hash map that maps values to small integers.
-** Preprocessor parameters:
-** TYPE: The type to hash
-** HASH_MAX: Maximum hash value
-** HASH(x): Hashes a value of type TYPE to an int from 0 to HASH_MAX
-** COMP(x, y): Compares x, y, returns zero(!) iff they are equal
-** MUST_FREE: Define if 'lost' values are simple pointers and should be freed
-** DUPLICATOR: Usually needed when MUST_FREE is being used, means that
-**             new values must be dup'd before being added.
-**             Define it to the name of the function to use for duplication
-**             (e.g. '#define DUPLICATOR strdup').
-*/
-
-/**-- WARNING!!! --**/
-
-/* This file uses a lot of dark magic (aka preprocessor macros) to define
-** its semantics. It is not to be taken lightly. It is not to be taken
-** as an example for good programming. Most importantly, it is not to
-** be read by mere mortals, except for the author and other people who
-** have undergone appropriate psychological preparation. Keep out of
-** reach of small children. Do not shake. Do not put in a microwave. Do
-** not feed to animals.
-*/
-
-/* OK, it's not that bad. */
-
-
-#ifndef HASH_MAX
-#  error "Must define the maximum hash value (HASH_MAX) before including hashmap.h!"
-#endif
-
-#ifndef HASH
-#  error "Must define the hash function (HASH) before including hashmap.h!"
-#endif
-
-#ifndef COMP
-#  error "Must define a comparison function (COMP) before including hashmap.h!"
-#endif
-
-
-#define DECLARE_STRUCTS(TYPE) \
-typedef struct _##TYPE##_hash_map_node {                                    \
-	TYPE name;                                                          \
-	int value;                                                          \
-	struct _##TYPE##_hash_map_node *next;                               \
-} TYPE##_hash_map_node_t;                                                   \
-                                                                            \
-                                                                            \
-typedef struct {                                                            \
-	int base_value;  /* Starts at zero, counts upwards */               \
-	TYPE##_hash_map_node_t *nodes[HASH_MAX+1];                          \
-	TYPE##_hash_map_node_t *holes; /* List of freed entries to minimize \
-				     ** memory operations and modifications \
-				     ** to base_value  */                   \
-} TYPE##_hash_map_t, *TYPE##_hash_map_ptr;
-
-
-#define DECLARE_FUNCTIONS(TYPE) \
-                                                                            \
-TYPE##_hash_map_t *                                                         \
-new_##TYPE##_hash_map(void);                                                \
-/* Creates a new hash map for the specified TYPE                            \
-** Parameters: (void)                                                       \
-** Returns   : (TYPE##_hash_map_t *) The newly allocated hash map           \
-*/                                                                          \
-                                                                            \
-void                                                                        \
-free_##TYPE##_hash_map(TYPE##_hash_map_ptr map);                            \
-/* Frees the specified hash map                                             \
-** Parameters: (TYPE##_hash_map_t *) map: The map to free                   \
-** Returns   : (void)                                                       \
-*/                                                                          \
-														    \
-void														    \
-apply_to_##TYPE##_hash_map(TYPE##_hash_map_ptr map, void *param, void (*note) (void *param, TYPE name, int value)); \
-/* Iterates over all entries in the hash map and invokes 'note'							    \
-** Parameters: (TYPE##_hash_map_t *) map: The map to iterate over						    \
-**             (void *) param: Some parameter to pass to 'note'							    \
-**             ((voidptr * TYPE * value) -> void) note: The callback to invoke for each entry			    \
-*/                                                                            					    \
-                                                                            \
-int                                                                         \
-TYPE##_hash_map_check_value(TYPE##_hash_map_ptr map, TYPE value, char add, char *was_added);  \
-/* Checks whether a value is in the map, adds it if neccessary              \
-** Parameters: (TYPE##_hash_map_t *) map: The map to look in/modify         \
-**             (TYPE) value: The value to check for/add                     \
-**             (char) add: Whether to add the value if it's not in there    \
-**             (char *) was_added: Set to non-zero iff the value is new     \
-**                                 Ignored if NULL.                         \
-** Returns   : (int) The new (or old) index, or -1 if add was zero and      \
-**                   the value couldn't be found                            \
-** If MUST_FREE is defined and add is set but the value was already in      \
-** there, the value is freed.                                               \
-*/                                                                          \
-                                                                            \
-int                                                                         \
-TYPE##_hash_map_remove_value(TYPE##_hash_map_ptr map, TYPE value);          \
-/* Removes a value from the hash map                                        \
-** Parameters: (TYPE##_hash_map_t *) map: The map to remove from            \
-**             (TYPE) value: The value to remove                            \
-** Returns   : (int) The ID of the value, or -1 if it wasn't presen         \
-*/
-
-
-
-
diff --git a/engines/sci/include/int_hashmap.h b/engines/sci/include/int_hashmap.h
deleted file mode 100644
index b10140b4bf..0000000000
--- a/engines/sci/include/int_hashmap.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/***************************************************************************
- int_hashmap.h Copyright (C) 2001 Christoph Reichenbach
-
-
- This program may be modified and copied freely according to the terms of
- the GNU general public license (GPL), as long as the above copyright
- notice and the licensing information contained herein are preserved.
-
- Please refer to www.gnu.org for licensing details.
-
- This work is provided AS IS, without warranty of any kind, expressed or
- implied, including but not limited to the warranties of merchantibility,
- noninfringement, and fitness for a specific purpose. The author will not
- be held liable for any damage caused by this work or derivatives of it.
-
- By using this source code, you agree to the licensing terms as stated
- above.
-
-
- Please contact the maintainer for bug reports or inquiries.
-
- Current Maintainer:
-
-    Christoph Reichenbach (CR) <jameson@linuxgames.com>
-
-***************************************************************************/
-
-#ifndef _INT_HASHMAP_H_
-#define _INT_HASHMAP_H_
-
-#include "common/scummsys.h"
-
-/* Assumes that the ints are relatively evenly distributed */
-
-#define DCS_INT_HASH_MAX 255
-
-#define HASH_MAX DCS_INT_HASH_MAX
-#define COMP(x, y) ((x)-(y))
-#define HASH(x) (x & 0xff)
-#undef MUST_FREE
-
-#include "hashmap.h"
-DECLARE_STRUCTS(int)
-DECLARE_FUNCTIONS(int)
-
-#ifndef BUILD_MAP_FUNCTIONS
-#  undef HASH_MAX
-#  undef COMP
-#  undef HASH
-#endif
-
-/* see hashmap.h for descriptions of these functions */
-int_hash_map_ptr
-new_int_hash_map(void);
-
-void
-free_int_hash_map(int_hash_map_ptr);
-
-int
-int_hash_map_check_value(int_hash_map_ptr, int value, char add_p, char *added);
-
-int
-int_hash_map_remove_value(int_hash_map_ptr, int value);
-
-#endif /* _INT_HASHMAP_H_ */
diff --git a/engines/sci/include/seg_manager.h b/engines/sci/include/seg_manager.h
deleted file mode 100644
index fd5d8a6d4f..0000000000
--- a/engines/sci/include/seg_manager.h
+++ /dev/null
@@ -1,627 +0,0 @@
-/***************************************************************************
- seg_manager.h Copyright (C) 2002 Xiaojun Chen, Christoph Reichenbach
-
-
- This program may be modified and copied freely according to the terms of
- the GNU general public license (GPL), as long as the above copyright
- notice and the licensing information contained herein are preserved.
-
- Please refer to www.gnu.org for licensing details.
-
- This work is provided AS IS, without warranty of any kind, expressed or
- implied, including but not limited to the warranties of merchantibility,
- noninfringement, and fitness for a specific purpose. The author will not
- be held liable for any damage caused by this work or derivatives of it.
-
- By using this source code, you agree to the licensing terms as stated
- above.
-
-
- Please contact the maintainer for bug reports or inquiries.
-
- Current Maintainer:
-
-    Christoph Reichenbach (CR) <jameson@linuxgames.com>
-
-***************************************************************************/
-
-
-#ifndef _SCI_SEG_MANAGER_H
-#define _SCI_SEG_MANAGER_H
-
-#include "sci/include/int_hashmap.h"
-#include "sci/include/sys_strings.h"
-#include "sci/include/vm.h"
-
-#define DEFAULT_SCRIPTS 32
-#define DEFAULT_OBJECTS 8	    /* default # of objects per script */
-#define DEFAULT_OBJECTS_INCREMENT 4 /* Number of additional objects to
-** instantiate if we're running out of them  */
-
-/* SCRIPT_ID must be 0 */
-typedef enum {
-SCRIPT_ID,
-SEG_ID
-} id_flag;
-
-//void dbg_print( const char* msg, void *i );	/* for debug only */
-
-/* verify the the given condition is true, output the message if condition is false, and exit
-** Parameters:
-**   cond - condition to be verified
-**   msg  - the message to be printed if condition fails
-** return:
-**   none, terminate the program if fails
-*/
-#define VERIFY( cond, msg ) if (! ( cond ) ) {\
-	sciprintf( "%s, line, %d, %s\n", __FILE__, __LINE__, msg ); \
-	BREAKPOINT(); \
-	}
-
-
-#define MEM_OBJ_INVALID		0
-#define MEM_OBJ_SCRIPT		1
-#define MEM_OBJ_CLONES		2
-#define MEM_OBJ_LOCALS		3
-#define MEM_OBJ_STACK		4
-#define MEM_OBJ_SYS_STRINGS	5
-#define MEM_OBJ_LISTS		6
-#define MEM_OBJ_NODES		7
-#define MEM_OBJ_HUNK		8
-#define MEM_OBJ_DYNMEM		9
-#define MEM_OBJ_RESERVED	10
-#define MEM_OBJ_MAX		MEM_OBJ_RESERVED /* For sanity checking */
-typedef int mem_obj_enum;
-
-struct _mem_obj;
-
-#define GET_SEGMENT(mgr, index, rtype) ((index) > 0 && (mgr).heap_size > index)?		\
-		(((mgr).heap[index] && (mgr).heap[index]->type == rtype)? (mgr).heap[index]	\
-		: NULL) /* Type does not match */						\
-	: NULL /* Invalid index */
-
-#define GET_SEGMENT_ANY(mgr, index) ((index) > 0 && (mgr).heap_size > index)?			\
-		(((mgr).heap[index])? (mgr).heap[index]						\
-		: NULL) /* Type does not match */						\
-	: NULL /* Invalid index */
-
-#define GET_OBJECT_SEGMENT(mgr, index) ((index) > 0 && (mgr).heap_size > index)?		\
-		(((mgr).heap[index]								\
-                    && ((mgr).heap[index]->type == MEM_OBJ_SCRIPT				\
-		        || (mgr).heap[index]->type == MEM_OBJ_CLONES))? (mgr).heap[index]	\
-		: NULL) /* Type does not match */						\
-	: NULL /* Invalid index */
-
-
-typedef struct _seg_manager_t {
-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 */
-int reserved_id;
-int exports_wide;
-int sci1_1;
-
-int gc_mark_bits; /* For standard Mark&Sweep:
-** 1 or 0, depending on what unreachable/freshly allocated
-** memory is tagged as  */
-size_t mem_allocated; /* Total amount of memory allocated */
-
-seg_id_t clones_seg_id; /* ID of the (a) clones segment */
-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);
-/* Initialize the segment manager
-*/
-
-void
-sm_destroy(seg_manager_t* self);
-/* Deallocate all memory associated with the segment manager
-*/
-
-void
-sm_gc(seg_manager_t *self, struct _state *s);
-/* Perform garbage collection
-** Parameters: (state_t *) s: The state to operate on
-** Effects   : Unreachable objects in 's' are deallocated
-*/
-
-
-
-/*==============================================================*/
-/* 1. Scripts							*/
-/*==============================================================*/
-
-
-void
-sm_free_script(mem_obj_t* mem);
-
-mem_obj_t*
-sm_allocate_script(struct _seg_manager_t* self, struct _state *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
-**			      script data
-** Returns   : (int) 0 on failure, 1 on success
-**	       (int) *seg_id: The segment ID of the newly allocated segment, on success
-
-** The script must then be initialised; see section (1b.), below.
-*/
-
-int
-sm_deallocate_script(struct _seg_manager_t* 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);
-/* 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);
-/* 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);
-/* 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
-** This function is "pure" (i.e, it doesn't modify anything).
-*/
-
-
-/**************************/
-/* script lock operations */
-/**************************/
-
-void
-sm_increment_lockers(struct _seg_manager_t* 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
-**				by its segment (SEG_ID). SEG_ID is faster than SCRIPT_ID,
-**				but less convenient.
-*/
-
-void
-sm_decrement_lockers(struct _seg_manager_t* 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);
-/* 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
-**				by its segment (SEG_ID). SEG_ID is faster than SCRIPT_ID,
-**				but less convenient.
-** 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);
-/* 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
-**				by its segment (SEG_ID). SEG_ID is faster than SCRIPT_ID,
-**				but less convenient.
-*/
-
-byte *
-sm_get_synonyms(struct _seg_manager_t* 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
-**				by its segment (SEG_ID). SEG_ID is faster than SCRIPT_ID,
-**				but less convenient.
-** Returns   : (byte *) Pointer to the synonyms, in non-parsed format.
-** 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);
-/* 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
-**				by its segment (SEG_ID). SEG_ID is faster than SCRIPT_ID,
-**				but less convenient.
-** Returns   : (int) The number of synonyms associated with the specified script
-** A dynamic failure is issued if the specified ID does not reference a proper script.
-*/
-
-
-/*==============================================================*/
-/* 1b. Script Initialisation					*/
-/*==============================================================*/
-
-/*******************************************/
-/* The set of functions below are intended */
-/* 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);
-/* 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);
-/* 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, struct _state *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
-** obj_pos must point to the beginning of the script/class block (as opposed
-** to what the VM considers to be the object location)
-** The corresponding object_t is stored within the relevant script.
-*/
-
-void
-sm_script_add_code_block(struct _seg_manager_t* 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);
-/* 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);
-/* 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
-** This function is idempotent, but it must only be called after all
-** 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);
-/* 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);
-/* 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
-**             (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.
-** 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);
-/* 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
-**             (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.
-** 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);
-/* 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
-**             (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.
-** 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);
-/* 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
-** heap or the stack, the script will stay in memory in a quasi-deleted state until
-** either unreachable (resulting in its eventual deletion) or reloaded (resulting
-** in its data being updated).
-*/
-
-void
-sm_unmark_script_deleted(seg_manager_t* 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);
-/* 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
-** Will return 0 when applied to an invalid or non-script seg.
-*/
-
-
-
-/*==============================================================*/
-/* 2. Clones							*/
-/*==============================================================*/
-
-clone_t*
-sm_alloc_clone(struct _seg_manager_t *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);
-/* Deallocates a clone
-** Parameters: (reg_t) addr: Offset of the clone scheduled for termination
-*/
-
-
-
-/*==============================================================*/
-/* Objects (static, from Scripts, and dynmic, from Clones)	*/
-/*==============================================================*/
-
-/* Not all of these functions are fully operational for clones ATM */
-
-gint16
-sm_get_heap(struct _seg_manager_t* 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);
-/* 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);
-/* 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
-**	       (size_t) n: Number of bytes to copy
-**	       (int) id: ID of the script or script segment to write to
-**             (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.
-** A dynamic failure is issued if the specified ID does not reference a proper script.
-*/
-
-
-/*==============================================================*/
-/* 4. Stack							*/
-/*==============================================================*/
-
-dstack_t *
-sm_allocate_stack(struct _seg_manager_t *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
-**             (seg_id_t) segid: Segment ID of the stack
-*/
-
-
-
-/*==============================================================*/
-/* 5. System Strings						*/
-/*==============================================================*/
-
-sys_strings_t *
-sm_allocate_sys_strings(struct _seg_manager_t *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
-** See also sys_string_acquire();
-*/
-
-
-
-/*==============================================================*/
-/* 6, 7. Lists and Nodes					*/
-/*==============================================================*/
-
-list_t*
-sm_alloc_list(struct _seg_manager_t *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);
-/* 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);
-/* 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);
-/* 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);
-/* 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,
-**				for debugging purposes
-** Returns   : (hunk_t*): Reference to the memory allocated for the hunk piece
-**             (reg_t) *addr: The offset of the freshly allocated hunk entry
-*/
-
-void
-sm_free_hunk_entry(struct _seg_manager_t *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);
-/* Allocate some dynamic memory
-** Parameters: (int) size: Number of bytes to allocate
-**             (const char_ *) description: A descriptive string,
-**				for debugging purposes
-** 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);
-/* 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);
-/* Gets the description of a dynmem segment
-** Parameters: (reg_t) addr: Segment to describe
-** Returns   : (const char *): Pointer to the descriptive string set in
-** sm_alloc_dynmem
-*/
-
-/*==============================================================*/
-/* 10. Reserved segments					*/
-/*==============================================================*/
-
-seg_id_t
-sm_allocate_reserved_segment(struct _seg_manager_t *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
-** Reserved segments are never used by the segment manager.  They can be used to tag special-purpose addresses.
-** Segment 0 is implicitly reserved for numbers.
-*/
-
-/*==============================================================*/
-/* Generic Operations on Segments and Addresses			*/
-/*==============================================================*/
-
-byte *
-sm_dereference(struct _seg_manager_t *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
-**             (int) size: (optionally) the theoretical maximum size of it
-*/
-
-
-/*==============================================================*/
-/* 11. Segment interface, primarily for GC			*/
-/*==============================================================*/
-
-typedef struct _seg_interface {
-	seg_manager_t *segmgr;
-	mem_obj_t *mobj;
-	seg_id_t seg_id;
-	mem_obj_enum type_id;	/* Segment type */
-	const char *type;	/* String description of the segment type */
-
-	reg_t
-	(*find_canonic_address)(struct _seg_interface *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.
-	*/
-
-	void
-	(*free_at_address)(struct _seg_interface *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)(struct _seg_interface *self, void *param, void (*note)(void *param, reg_t 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'
-	*/
-
-	void
-	(*list_all_outgoing_references)(struct _seg_interface *self, struct _state *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)(struct _seg_interface *self);
-	/* Deallocates the segment interface
-	 */
-
-} seg_interface_t;
-
-seg_interface_t *
-get_seg_interface(seg_manager_t *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
-** The returned interface 'si' must be freed after use by calling 'si->dealloc_self(si)';
-*/
-
-
-
-#endif
diff --git a/engines/sci/include/vm.h b/engines/sci/include/vm.h
index 69c6bcafb4..ab1cb7e976 100644
--- a/engines/sci/include/vm.h
+++ b/engines/sci/include/vm.h
@@ -31,7 +31,7 @@
 #include "sci/include/script.h"
 #include "sci/include/vocabulary.h"
 #include "sci/include/versions.h"
-#include "sci/include/seg_manager.h"
+#include "sci/engine/seg_manager.h"
 #include "sci/include/vm_types.h"
 #include "sci/include/sys_strings.h"
 #include "sci/include/heapmgr.h"
@@ -113,7 +113,7 @@ typedef struct {
 	reg_t reg; /* offset; script-relative offset, segment: 0 if not instantiated */
 } class_t;
 
-#define RAW_GET_CLASS_INDEX(scr, reg) (int_hash_map_check_value((scr)->obj_indices, reg.offset, 0, NULL))
+#define RAW_GET_CLASS_INDEX(scr, reg) ((scr)->obj_indices->check_value(reg.offset, false))
 #define RAW_IS_OBJECT(datablock) (getUInt16(((byte *) datablock) + SCRIPT_OBJECT_MAGIC_OFFSET) == SCRIPT_OBJECT_MAGIC_NUMBER)
 
 #define IS_CLASS(obj) (obj->variables[SCRIPT_INFO_SELECTOR].offset & SCRIPT_INFO_CLASS)
@@ -180,7 +180,7 @@ typedef struct {
 
 
 //#define VM_OBJECT_SET_INDEX(ptr, index) { ((byte *) (ptr))[0] = (index) & 0xff; ((byte *) (ptr))[1] = ((index) >> 8) & 0xff; }
-#define VM_OBJECT_GET_INDEX(scr, reg) (int_hash_map_check_value(scr->obj_indices, reg.offset, 0, NULL))
+//#define VM_OBJECT_GET_INDEX(scr, reg) (int_hash_map_check_value(scr->obj_indices, reg.offset, 0, NULL))
 
 typedef struct {
 	int nr; /* Script number */