- Remove some unneeded files

- Mass rename .c to .cpp

svn-id: r38227

1 files changed, 2410 insertions, 0 deletions

diff --git a/engines/sci/engine/vm.cpp b/engines/sci/engine/vm.cpp
new file mode 100644
index 0000000000..d2831fbd69
--- /dev/null
+++ b/engines/sci/engine/vm.cpp
@@ -0,0 +1,2410 @@
+/***************************************************************************
+ vm.c Copyright (C) 1999 -- 2002 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 (CJR) [jameson@linuxgames.com]
+
+***************************************************************************/
+
+
+#include "sci/include/sciresource.h"
+#include "sci/include/engine.h"
+#include "sci/include/versions.h"
+#include "sci/include/kdebug.h"
+#include "sci/engine/kernel_types.h"
+#include "sci/include/seg_manager.h"
+#include "sci/engine/gc.h"
+#include "sci/include/sfx_player.h"
+
+#ifdef HAVE_SETJMP_H
+#include <setjmp.h>
+#endif
+
+reg_t NULL_REG = NULL_REG_INITIALIZER;
+
+/*#define VM_DEBUG_SEND*/
+#undef STRICT_SEND /* Disallows variable sends with more than one parameter */
+#undef STRICT_READ /* Disallows reading from out-of-bounds parameters and locals */
+
+
+int script_abort_flag = 0; /* Set to 1 to abort execution */
+int script_error_flag = 0; /* Set to 1 if an error occured, reset each round by the VM */
+int script_checkloads_flag = 0; /* Print info when scripts get (un)loaded */
+int script_step_counter = 0; /* Counts the number of steps executed */
+int script_gc_interval = GC_INTERVAL; /* Number of steps in between gcs */
+
+extern int _debug_step_running; /* scriptdebug.c */
+extern int _debug_seeking; /* scriptdebug.c */
+extern int _weak_validations; /* scriptdebug.c */
+
+
+calls_struct_t *send_calls = NULL;
+int send_calls_allocated = 0;
+int bp_flag = 0;
+static reg_t _dummy_register = NULL_REG_INITIALIZER;
+
+
+static int jump_initialized = 0;
+#ifdef HAVE_SETJMP_H
+static jmp_buf vm_error_address;
+#endif
+
+/*-- validation functionality --*/
+
+#ifndef DISABLE_VALIDATIONS
+
+static inline reg_t *
+validate_property(object_t *obj, int index)
+{
+	if (!obj)
+	{
+		if (sci_debug_flags & 4)
+			sciprintf("[VM] Sending to disposed object!\n");
+		_dummy_register = NULL_REG;
+		return &_dummy_register;
+	}
+
+	if (index < 0 || index >= obj->variables_nr) {
+		if (sci_debug_flags & 4)
+			sciprintf("[VM] Invalid property #%d (out of [0..%d]) requested!\n", index,
+				  obj->variables_nr);
+
+		_dummy_register = NULL_REG;
+		return &_dummy_register;
+	}
+
+	return obj->variables + index;
+}
+
+static inline stack_ptr_t
+validate_stack_addr(state_t *s, stack_ptr_t sp)
+{
+	if (sp >= s->stack_base && sp < s->stack_top)
+		return sp;
+
+	script_debug_flag = script_error_flag = 1;
+	if (sci_debug_flags & 4)
+		sciprintf("[VM] Stack index %d out of valid range [%d..%d]\n",
+			  sp - s->stack_base, 0, s->stack_top - s->stack_base -1);
+	return 0;
+}
+
+
+static inline int
+validate_arithmetic(reg_t reg)
+{
+	if (reg.segment) {
+		if (!_weak_validations)
+			script_debug_flag = script_error_flag = 1;
+		if (sci_debug_flags & 4)
+			sciprintf("[VM] Attempt to read arithmetic value from non-zero segment [%04x]\n", reg.segment);
+		return 0;
+	}
+
+	return reg.offset;
+}
+
+static inline int
+signed_validate_arithmetic(reg_t reg)
+{
+	if (reg.segment) {
+		if (!_weak_validations)
+			script_debug_flag = script_error_flag = 1;
+		if (sci_debug_flags & 4)
+			sciprintf("[VM] Attempt to read arithmetic value from non-zero segment [%04x]\n", reg.segment);
+		return 0;
+	}
+	
+	if (reg.offset&0x8000)
+		return (signed) (reg.offset)-65536;
+	else
+		return reg.offset;
+}
+
+static inline int
+validate_variable(reg_t *r, reg_t *stack_base, int type, int max, int index, int line)
+{
+	const char *names[4] = {"global", "local", "temp", "param"};
+
+	if (index < 0 || index >= max) {
+		sciprintf("[VM] Attempt to use invalid %s variable %04x ", names[type], index);
+		if (max == 0)
+			sciprintf("(variable type invalid)");
+		else
+			sciprintf("(out of range [%d..%d])", 0, max-1);
+		sciprintf(" in %s, line %d\n", __FILE__, line);
+		if (!_weak_validations)
+			script_debug_flag = script_error_flag = 1;
+
+#ifdef STRICT_READ
+		return 1;
+#else /* !STRICT_READ */
+		if (type == VAR_PARAM || type == VAR_TEMP) {
+			int total_offset = r - stack_base;
+			if (total_offset < 0 || total_offset >= VM_STACK_SIZE) {
+				sciprintf("[VM] Access would be outside even of the stack (%d); access denied\n",
+					  total_offset);
+				return 1;
+			} else {
+				sciprintf("[VM] Access within stack boundaries; access granted.\n");
+				return 0;
+			}
+		};
+#endif
+	}
+
+	return 0;
+}
+
+static inline reg_t
+validate_read_var(reg_t *r, reg_t *stack_base, int type, int max, int index, int line, reg_t default_value)
+{
+	if (!validate_variable(r, stack_base, type, max, index, line))
+		return r[index];
+	else
+		return default_value;
+}
+
+static inline void
+validate_write_var(reg_t *r, reg_t *stack_base, int type, int max, int index, int line, reg_t value)
+{
+	if (!validate_variable(r, stack_base, type, max, index, line))
+		r[index] = value;
+}
+
+#  define ASSERT_ARITHMETIC(v) validate_arithmetic(v)
+
+#else
+/*-- Non-validating alternatives -- */
+
+#  define validate_stack_addr(s, sp) sp
+#  define validate_arithmetic(r) ((r).offset)
+#  define signed_validate_arithmetic(r) ((int) ((r).offset)&0x8000 ? (signed) ((r).offset)-65536 : ((r).offset))
+#  define validate_variable(r, sb, t, m, i, l)
+#  define validate_read_var(r, sb, t, m, i, l) ((r)[i])
+#  define validate_write_var(r, sb, t, m, i, l, v) ((r)[i] = (v))
+#  define validate_property(o, p) (&((o)->variables[p]))
+#  define ASSERT_ARITHMETIC(v) (v).offset
+
+#endif
+
+#define READ_VAR(type, index, def) validate_read_var(variables[type], s->stack_base, type, variables_max[type], index, __LINE__, def)
+#define WRITE_VAR(type, index, value) validate_write_var(variables[type], s->stack_base, type, variables_max[type], index, __LINE__, value)
+#define WRITE_VAR16(type, index, value) WRITE_VAR(type, index, make_reg(0, value));
+
+#define ACC_ARITHMETIC_L(op) make_reg(0, (op validate_arithmetic(s->r_acc)))
+#define ACC_AUX_LOAD() aux_acc = signed_validate_arithmetic(s->r_acc)
+#define ACC_AUX_STORE() s->r_acc = make_reg(0, aux_acc)
+
+#define OBJ_PROPERTY(o, p) (*validate_property(o, p))
+
+/*==--------------------------==*/
+
+int
+script_error(state_t *s, const char *file, int line, const char *reason)
+{
+	sciprintf("Script error in file %s, line %d: %s\n", file, line, reason);
+	script_debug_flag = script_error_flag = 1;
+	return 0;
+}
+#define CORE_ERROR(area, msg) script_error(s, "[" area "] " __FILE__, __LINE__, msg)
+
+reg_t
+get_class_address(state_t *s, int classnr, int lock, reg_t caller)
+{
+	class_t *class = s->classtable + classnr;
+
+	if (NULL == s) {
+		sciprintf("vm.c: get_class_address(): NULL passed for \"s\"\n");
+		return NULL_REG;
+	}
+
+	if (classnr < 0
+	    || s->classtable_size <= classnr
+	    || class->script < 0) {
+		sciprintf("[VM] Attempt to dereference class %x, which doesn't exist (max %x)\n",
+			  classnr, s->classtable_size);
+		script_error_flag = script_debug_flag = 1;
+		return NULL_REG;
+	} else {
+		if (!class->reg.segment) {
+			script_get_segment(s, class->script, lock);
+
+			if (!class->reg.segment) {
+				sciprintf("[VM] Trying to instantiate class %x by instantiating script 0x%x (%03d) failed;"
+					  " Entering debugger.\n", classnr, class->script);
+				script_error_flag = script_debug_flag = 1;
+				return NULL_REG;
+			}
+		} else
+			if (caller.segment != class->reg.segment)
+				sm_increment_lockers(&s->seg_manager, class->reg.segment, SEG_ID);
+
+		return class->reg;
+	}
+}
+
+/* Operating on the stack */
+/* 16 bit: */
+#define PUSH(v) PUSH32(make_reg(0, v))
+#define POP() (validate_arithmetic(POP32()))
+/* 32 bit: */
+#define PUSH32(a) (*(validate_stack_addr(s, (xs->sp)++)) = (a))
+#define POP32() (*(validate_stack_addr(s, --(xs->sp))))
+
+/* Getting instruction parameters */
+#define GET_OP_BYTE() ((guint8) code_buf[(xs->addr.pc.offset)++])
+#define GET_OP_WORD() (getUInt16(code_buf + ((xs->addr.pc.offset) += 2) - 2))
+#define GET_OP_FLEX() ((opcode & 1)? GET_OP_BYTE() : GET_OP_WORD())
+#define GET_OP_SIGNED_BYTE() ((gint8)(code_buf[(xs->addr.pc.offset)++]))
+#define GET_OP_SIGNED_WORD() ((getInt16(code_buf + ((xs->addr.pc.offset) += 2) - 2)))
+#define GET_OP_SIGNED_FLEX() ((opcode & 1)? GET_OP_SIGNED_BYTE() : GET_OP_SIGNED_WORD())
+
+#define SEG_GET_HEAP( s, reg ) sm_get_heap( &s->seg_manager, reg )
+#define OBJ_SPECIES(s, reg) SEG_GET_HEAP(s, make_reg(reg.segment, reg.offset + SCRIPT_SPECIES_OFFSET))
+/* Returns an object's species */
+
+#define OBJ_SUPERCLASS(s, reg) SEG_GET_HEAP(s, make_reg(reg.segment, reg.offset + SCRIPT_SUPERCLASS_OFFSET))
+/* Returns an object's superclass */
+
+inline exec_stack_t *
+execute_method(state_t *s, word script, word pubfunct, stack_ptr_t sp,
+	       reg_t calling_obj, word argc, stack_ptr_t argp)
+{
+	int seg;
+	guint16 temp;
+
+	if (!sm_script_is_loaded (&s->seg_manager, script, SCRIPT_ID)) /* Script not present yet? */
+		script_instantiate(s, script);
+	else
+		sm_unmark_script_deleted(&s->seg_manager, script);
+
+	seg = sm_seg_get( &s->seg_manager, script );
+
+	temp = sm_validate_export_func( &s->seg_manager, pubfunct, seg );
+	VERIFY( temp, "Invalid pubfunct in export table" );
+	if( !temp ) {
+		sciprintf("Request for invalid exported function 0x%x of script 0x%x\n", pubfunct, script);
+		script_error_flag = script_debug_flag = 1;
+		return NULL;
+	}
+
+  /* Check if a breakpoint is set on this method */
+  if (s->have_bp & BREAK_EXPORT)
+  {
+    breakpoint_t *bp;
+    guint32 bpaddress;
+
+    bpaddress = (script << 16 | pubfunct);
+
+    bp = s->bp_list;
+    while (bp)
+    {
+      if (bp->type == BREAK_EXPORT && bp->data.address == bpaddress)
+      {
+        sciprintf ("Break on script %d, export %d\n", script, pubfunct);
+        script_debug_flag = 1;
+        bp_flag = 1;
+        break;
+      }
+      bp = bp->next;
+    }
+  }
+
+	return add_exec_stack_entry(s, make_reg( seg, temp ),
+				 sp, calling_obj, argc, argp, -1, calling_obj,
+				 s->execution_stack_pos, seg);
+}
+
+
+static void
+_exec_varselectors(state_t *s)
+{ /* Executes all varselector read/write ops on the TOS */
+	/* Now check the TOS to execute all varselector entries */
+	if (s->execution_stack_pos >= 0)
+		while (s->execution_stack[s->execution_stack_pos].type == EXEC_STACK_TYPE_VARSELECTOR) {
+		/* varselector access? */
+			if (s->execution_stack[s->execution_stack_pos].argc) { /* write? */
+				reg_t temp = s->execution_stack[s->execution_stack_pos].variables_argp[1];
+				*(s->execution_stack[s->execution_stack_pos].addr.varp) = temp;
+
+			} else /* No, read */
+				s->r_acc = *(s->execution_stack[s->execution_stack_pos].addr.varp);
+
+			--(s->execution_stack_pos);
+		}
+}
+
+exec_stack_t *
+send_selector(state_t *s, reg_t send_obj, reg_t work_obj,
+	      stack_ptr_t sp, int framesize, stack_ptr_t argp)
+     /* send_obj and work_obj are equal for anything but 'super' */
+     /* Returns a pointer to the TOS exec_stack element */
+{
+#ifdef VM_DEBUG_SEND
+	int i;
+#endif
+	reg_t *varp;
+	reg_t funcp;
+	int selector;
+	int argc;
+	int origin = s->execution_stack_pos; /* Origin: Used for debugging */
+	exec_stack_t *retval = s->execution_stack + s->execution_stack_pos;
+	int print_send_action = 0;
+	/* We return a pointer to the new active exec_stack_t */
+
+	/* The selector calls we catch are stored below: */
+	int send_calls_nr = -1;
+
+        if (NULL == s) {
+                sciprintf("vm.c: exec_stack_t(): NULL passed for \"s\"\n");
+                return NULL;
+        }
+
+	while (framesize > 0) {
+
+		selector = validate_arithmetic(*argp++);
+		argc = validate_arithmetic(*argp);
+
+		if (argc > 0x800){ /* More arguments than the stack could possibly accomodate for */
+			CORE_ERROR("SEND", "More than 0x800 arguments to function call\n");
+			return NULL;
+		}
+
+		/* Check if a breakpoint is set on this method */
+		if (s->have_bp & BREAK_SELECTOR) {
+			breakpoint_t *bp;
+			char method_name [256];
+
+			sprintf (method_name, "%s::%s",
+				 obj_get_name(s, send_obj),
+				 s->selector_names [selector]);
+
+			bp = s->bp_list;
+			while (bp) {
+				int cmplen = strlen(bp->data.name);
+				if (bp->data.name[cmplen - 1] != ':')
+					cmplen = 256;
+
+				if (bp->type == BREAK_SELECTOR && !strncmp (bp->data.name, method_name, cmplen)) {
+					sciprintf ("Break on %s (in ["PREG"])\n", method_name,
+						   PRINT_REG(send_obj));
+					script_debug_flag = print_send_action = 1;
+					bp_flag = 1;
+					break;
+				}
+				bp = bp->next;
+			}
+		}
+
+#ifdef VM_DEBUG_SEND
+		sciprintf("Send to "PREG", selector %04x (%s):",
+			  PRINT_REG(send_obj), selector, s->selector_names[selector]);
+#endif /* VM_DEBUG_SEND */
+
+		if (++send_calls_nr == (send_calls_allocated - 1))
+			send_calls = (calls_struct_t*)sci_realloc(send_calls, sizeof(calls_struct_t)
+						 * (send_calls_allocated *= 2));
+
+
+		switch (lookup_selector(s, send_obj, selector, &varp, &funcp)) {
+
+		case SELECTOR_NONE:
+			sciprintf("Send to invalid selector 0x%x of object at "PREG"\n",
+				  0xffff & selector, PRINT_REG(send_obj));
+			script_error_flag = script_debug_flag = 1;
+			--send_calls_nr;
+			break;
+
+		case SELECTOR_VARIABLE:
+
+#ifdef VM_DEBUG_SEND
+			sciprintf("Varselector: ");
+			if (argc)
+				sciprintf("Write "PREG"\n", PRINT_REG(argp[1]));
+			else
+				sciprintf("Read\n");
+#endif /* VM_DEBUG_SEND */
+
+			switch (argc) {
+			case 0:   /* Read selector */
+				if (print_send_action) {
+					sciprintf("[read selector]\n");
+					print_send_action = 0;
+				}
+				/* fallthrough */
+			case 1:
+#ifndef STRICT_SEND
+			default:
+#endif
+				{ /* Argument is supplied -> Selector should be set */
+
+				if (print_send_action) {
+					reg_t val = *varp;
+					reg_t new = argp[1];
+
+					sciprintf("[write to selector: change "PREG" to "PREG"]\n",
+						  PRINT_REG(val), PRINT_REG(new));
+					print_send_action = 0;
+				}
+				send_calls[send_calls_nr].address.var = varp; /* register the call */
+				send_calls[send_calls_nr].argp = argp;
+				send_calls[send_calls_nr].argc = argc;
+				send_calls[send_calls_nr].selector = selector;
+				send_calls[send_calls_nr].type = EXEC_STACK_TYPE_VARSELECTOR; /* Register as a varselector */
+
+			} break;
+#ifdef STRICT_SEND
+			default:
+				--send_calls_nr;
+				sciprintf("Send error: Variable selector %04x in "PREG" called with %04x params\n",
+					  selector, PRINT_REG(send_obj), argc);
+				script_debug_flag = 1; /* Enter debug mode */
+				_debug_seeking = _debug_step_running = 0;
+
+#endif
+			}
+			break;
+
+		case SELECTOR_METHOD:
+
+#ifdef VM_DEBUG_SEND
+			sciprintf("Funcselector(");
+			for (i = 0; i < argc; i++) {
+				sciprintf(PREG, PRINT_REG(argp[i+1]));
+				if (i + 1 < argc)
+					sciprintf(", ");
+			}
+			sciprintf(") at "PREG"\n", PRINT_REG(funcp));
+#endif /* VM_DEBUG_SEND */
+			if (print_send_action) {
+				sciprintf("[invoke selector]\n");
+				print_send_action = 0;
+			}
+
+			send_calls[send_calls_nr].address.func = funcp; /* register call */
+			send_calls[send_calls_nr].argp = argp;
+			send_calls[send_calls_nr].argc = argc;
+			send_calls[send_calls_nr].selector = selector;
+			send_calls[send_calls_nr].type = EXEC_STACK_TYPE_CALL;
+			send_calls[send_calls_nr].sp = sp;
+			sp = CALL_SP_CARRY; /* Destroy sp, as it will be carried over */
+
+			break;
+		} /* switch(lookup_selector()) */
+
+
+		framesize -= (2 + argc);
+		argp += argc + 1;
+	}
+
+	/* Iterate over all registered calls in the reverse order. This way, the first call is
+	** placed on the TOS; as soon as it returns, it will cause the second call to be executed.
+	*/
+	for (; send_calls_nr >= 0; send_calls_nr--)
+		if (send_calls[send_calls_nr].type == EXEC_STACK_TYPE_VARSELECTOR) /* Write/read variable? */
+			retval = add_exec_stack_varselector(s, work_obj, send_calls[send_calls_nr].argc,
+							    send_calls[send_calls_nr].argp,
+							    send_calls[send_calls_nr].selector,
+							    send_calls[send_calls_nr].address.var, origin);
+
+		else
+			retval =
+				add_exec_stack_entry(s, send_calls[send_calls_nr].address.func,
+						     send_calls[send_calls_nr].sp, work_obj,
+						     send_calls[send_calls_nr].argc,
+						     send_calls[send_calls_nr].argp,
+						     send_calls[send_calls_nr].selector,
+						     send_obj, origin,
+						     SCI_XS_CALLEE_LOCALS);
+
+	_exec_varselectors(s);
+
+	retval = s->execution_stack + s->execution_stack_pos;
+	return retval;
+}
+
+
+exec_stack_t *
+add_exec_stack_varselector(state_t *s, reg_t objp, int argc, stack_ptr_t argp,
+			   selector_t selector, reg_t *address, int origin)
+{
+	exec_stack_t *xstack = add_exec_stack_entry(s, NULL_REG, address, objp, argc, argp,
+						    selector, objp, origin, SCI_XS_CALLEE_LOCALS);
+	/* Store selector address in sp */
+
+	xstack->addr.varp = address;
+	xstack->type = EXEC_STACK_TYPE_VARSELECTOR;
+
+	return xstack;
+}
+
+
+exec_stack_t *
+add_exec_stack_entry(state_t *s, reg_t pc, stack_ptr_t sp, reg_t objp, int argc,
+		     stack_ptr_t argp, selector_t selector, reg_t sendp, int origin,
+		     seg_id_t locals_segment)
+/* Returns new TOS element for the execution stack*/
+/* locals_segment may be -1 if derived from the called object */
+{
+	exec_stack_t *xstack = NULL;
+
+	if (!s->execution_stack)
+		s->execution_stack =
+			(exec_stack_t*)sci_malloc(sizeof(exec_stack_t) * (s->execution_stack_size = 16));
+
+	if (++(s->execution_stack_pos) == s->execution_stack_size) /* Out of stack space? */
+		s->execution_stack = (exec_stack_t*)sci_realloc(s->execution_stack,
+				     sizeof(exec_stack_t) * (s->execution_stack_size += 8));
+
+  /*  sciprintf("Exec stack: [%d/%d], origin %d, at %p\n", s->execution_stack_pos,
+      s->execution_stack_size, origin, s->execution_stack); */
+
+	xstack = s->execution_stack + s->execution_stack_pos;
+
+	xstack->objp = objp;
+	if (locals_segment != SCI_XS_CALLEE_LOCALS)
+		xstack->local_segment = locals_segment;
+	else
+		xstack->local_segment = pc.segment;
+
+	xstack->sendp = sendp;
+	xstack->addr.pc = pc;
+	xstack->fp = xstack->sp = sp;
+	xstack->argc = argc;
+
+	xstack->variables_argp = argp; /* Parameters */
+
+	*argp = make_reg(0, argc);  /* SCI code relies on the zeroeth argument to equal argc */
+
+	/* Additional debug information */
+	xstack->selector = selector;
+	xstack->origin = origin;
+
+	xstack->type = EXEC_STACK_TYPE_CALL; /* Normal call */
+
+	return xstack;
+}
+
+
+#ifdef DISABLE_VALIDATONS
+#  define kernel_matches_signature(a, b, c, d) 1
+#endif
+
+
+void
+vm_handle_fatal_error(state_t *s, int line, const char *file)
+{
+	fprintf(stderr, "Fatal VM error in %s, L%d; aborting...\n", file, line);
+#ifdef HAVE_SETJMP_H
+	if (jump_initialized)
+		longjmp(vm_error_address, 0);
+#endif
+	fprintf(stderr, "Could not recover, exitting...\n");
+	exit(1);
+}
+
+static inline script_t *
+script_locate_by_segment(state_t *s, seg_id_t seg)
+{
+	mem_obj_t *memobj = GET_SEGMENT(s->seg_manager, seg, MEM_OBJ_SCRIPT);
+	if (memobj)
+		return &(memobj->data.script);
+
+	return NULL;
+}
+
+
+static reg_t
+pointer_add(state_t *s, reg_t base, int offset)
+{
+	mem_obj_t *mobj = GET_SEGMENT_ANY(s->seg_manager, base.segment);
+
+	if (!mobj) {
+		script_debug_flag = script_error_flag = 1;
+		sciprintf("[VM] Error: Attempt to add %d to invalid pointer "PREG"!", offset, PRINT_REG(base));
+		return NULL_REG;
+	}
+
+	switch (mobj->type) {
+
+	case MEM_OBJ_LOCALS:
+		base.offset += 2*offset;
+		return base;
+
+	case MEM_OBJ_SCRIPT:
+	case MEM_OBJ_STACK:
+	case MEM_OBJ_DYNMEM:
+		base.offset += offset;
+		return base;
+		break;
+
+	default:
+		sciprintf("[VM] Error: Attempt to add %d to pointer "PREG": Pointer arithmetics of this type unsupported!", offset, PRINT_REG(base));
+		return NULL_REG;
+
+	}
+}
+
+static inline void
+gc_countdown(state_t *s)
+{
+	if (s->gc_countdown-- <= 0) {
+		s->gc_countdown = script_gc_interval;
+		run_gc(s);
+	}
+}
+
+static byte _fake_return_buffer[2] = {op_ret << 1, op_ret << 1};
+
+void
+run_vm(state_t *s, int restoring)
+{
+	reg_t *variables[4]; /* global, local, temp, param, as immediate pointers */
+	reg_t *variables_base[4]; /* Used for referencing VM ops */
+	seg_id_t variables_seg[4]; /* Same as above, contains segment IDs */
+#ifndef DISABLE_VALIDATIONS
+	int variables_max[4]; /* Max. values for all variables */
+	int code_buf_size = 0 /* (Avoid spurious warning) */;
+#endif
+	int temp;
+	gint16 aux_acc; /* Auxiliary 16 bit accumulator */
+	reg_t r_temp; /* Temporary register */
+	stack_ptr_t s_temp; /* Temporary stack pointer */
+	gint16 opparams[4]; /* opcode parameters */
+
+	int restadjust = s->r_amp_rest; /* &rest adjusts the parameter count
+					** by this value  */
+	/* Current execution data: */
+	exec_stack_t *xs = s->execution_stack + s->execution_stack_pos;
+	exec_stack_t *xs_new = NULL /* (Avoid spurious warning) */; /* Used during some operations */
+	object_t *obj = obj_get(s, xs->objp);
+	script_t *local_script = script_locate_by_segment(s, xs->local_segment);
+	int old_execution_stack_base = s->execution_stack_base; /* Used to detect the
+								** stack bottom, for "physical"
+								** returns  */
+	byte *code_buf = NULL /* (Avoid spurious warning) */;
+
+	if (!local_script) {
+		script_error(s, __FILE__, __LINE__, "Program Counter gone astray");
+		return;
+	}
+	
+	if (NULL == s) {
+		sciprintf("vm.c: run_vm(): NULL passed for \"s\"\n");
+		return;
+	}
+
+#ifdef HAVE_SETJMP_H
+	setjmp(vm_error_address);
+	jump_initialized = 1;
+#endif
+
+	if (!restoring)
+		s->execution_stack_base = s->execution_stack_pos;
+
+#ifndef DISABLE_VALIDATIONS
+	/* Initialize maximum variable count */
+	if (s->script_000->locals_block)
+		variables_max[VAR_GLOBAL] = s->script_000->locals_block->nr;
+	else
+		variables_max[VAR_GLOBAL] = 0;
+#endif
+
+	variables_seg[VAR_GLOBAL] = s->script_000->locals_segment;
+	variables_seg[VAR_TEMP] = variables_seg[VAR_PARAM] = s->stack_segment;
+	variables_base[VAR_TEMP] = variables_base[VAR_PARAM] = s->stack_base;
+
+	/* SCI code reads the zeroeth argument to determine argc */
+	if (s->script_000->locals_block)
+		variables_base[VAR_GLOBAL] = variables[VAR_GLOBAL]
+			= s->script_000->locals_block->locals;
+	else
+		variables_base[VAR_GLOBAL] = variables[VAR_GLOBAL] = NULL;
+
+
+
+	s->execution_stack_pos_changed = 1; /* Force initialization */
+
+	while (1) {
+		byte opcode;
+		int old_pc_offset;
+		stack_ptr_t old_sp = xs->sp;
+		byte opnumber;
+		int var_type; /* See description below */
+		int var_number;
+
+		old_pc_offset = xs->addr.pc.offset;
+
+		if (s->execution_stack_pos_changed) {
+			script_t *scr;
+			xs = s->execution_stack + s->execution_stack_pos;
+			s->execution_stack_pos_changed = 0;
+
+			scr = script_locate_by_segment(s, xs->addr.pc.segment);
+			if (!scr) {
+				/* No script? Implicit return via fake instruction buffer */
+				SCIkdebug(SCIkWARNING, "Running on non-existant script in segment %x!\n", xs->addr.pc.segment);
+				code_buf = _fake_return_buffer;
+#ifndef DISABLE_VALIDATIONS
+				code_buf_size = 2;
+#endif
+				xs->addr.pc.offset = 1;
+
+				scr = NULL;
+				obj = NULL;
+			} else {
+				obj = obj_get(s, xs->objp);
+				code_buf = scr->buf;
+#ifndef DISABLE_VALIDATIONS
+				code_buf_size = scr->buf_size;
+#endif
+				/*				if (!obj) {
+					SCIkdebug(SCIkWARNING, "Running with non-existant self= "PREG"\n", PRINT_REG(xs->objp));
+					}*/
+
+				local_script = script_locate_by_segment(s, xs->local_segment);
+				if (!local_script) {
+					SCIkdebug(SCIkWARNING, "Could not find local script from segment %x!\n", xs->local_segment);
+					local_script = NULL;
+					variables_base[VAR_LOCAL] = variables[VAR_LOCAL] = NULL;
+#ifndef DISABLE_VALIDATIONS
+					variables_max[VAR_LOCAL] = 0;
+#endif
+				} else {
+
+					variables_seg[VAR_LOCAL] = local_script->locals_segment;
+					if (local_script->locals_block)
+						variables_base[VAR_LOCAL] = variables[VAR_LOCAL]
+							= local_script->locals_block->locals;
+					else
+						variables_base[VAR_LOCAL] = variables[VAR_LOCAL]
+							= NULL;
+#ifndef DISABLE_VALIDATIONS
+					if (local_script->locals_block)
+						variables_max[VAR_LOCAL] = local_script->locals_block->nr;
+					else
+						variables_max[VAR_LOCAL] = 0;
+					variables_max[VAR_TEMP] = xs->sp - xs->fp;
+					variables_max[VAR_PARAM] = xs->argc + 1;
+#endif
+				}
+				variables[VAR_TEMP] = xs->fp;
+				variables[VAR_PARAM] = xs->variables_argp;
+			}
+
+		}
+
+		script_error_flag = 0; /* Set error condition to false */
+
+		if (script_abort_flag)
+			return; /* Emergency */
+
+		/* Debug if this has been requested: */
+		if (script_debug_flag || sci_debug_flags) {
+			script_debug(s, &(xs->addr.pc), &(xs->sp), &(xs->fp),
+				     &(xs->objp), &restadjust,
+				     variables_seg, variables, variables_base,
+#ifdef DISABLE_VALIDATIONS
+				     NULL,
+#else
+				     variables_max,
+#endif
+				     bp_flag);
+			bp_flag = 0;
+		}
+
+#ifndef DISABLE_VALIDATIONS
+		if (xs->sp < xs->fp)
+			script_error(s, "[VM] "__FILE__, __LINE__, "Stack underflow");
+
+		variables_max[VAR_TEMP] = xs->sp - xs->fp;
+
+		if (xs->addr.pc.offset >= code_buf_size)
+			script_error(s, "[VM] "__FILE__, __LINE__, "Program Counter gone astray");
+#endif
+
+		opcode = GET_OP_BYTE(); /* Get opcode */
+
+		opnumber = opcode >> 1;
+
+		for (temp = 0; formats[opnumber][temp]; temp++) /* formats comes from script.c */
+			switch(formats[opnumber][temp]) {
+
+			case Script_Byte: opparams[temp] = GET_OP_BYTE(); break;
+			case Script_SByte: opparams[temp] = GET_OP_SIGNED_BYTE(); break;
+
+			case Script_Word: opparams[temp] = GET_OP_WORD(); break;
+			case Script_SWord: opparams[temp] = GET_OP_SIGNED_WORD(); break;
+
+			case Script_Variable:
+			case Script_Property:
+
+			case Script_Local:
+			case Script_Temp:
+			case Script_Global:
+			case Script_Param:
+				opparams[temp] = GET_OP_FLEX(); break;
+
+			case Script_SVariable:
+			case Script_SRelative:
+				opparams[temp] = GET_OP_SIGNED_FLEX(); break;
+
+			case Script_Offset:
+				opparams[temp] = GET_OP_FLEX(); break;
+				
+			case Script_None:
+			case Script_End:
+				break;
+
+			case Script_Invalid:
+			default:
+				sciprintf("opcode %02x: Invalid!", opcode);
+				script_debug_flag = script_error_flag = 1;
+
+			}
+
+
+		switch (opnumber) {
+
+		case 0x00: /* bnot */
+			s->r_acc = ACC_ARITHMETIC_L (0xffff ^ /*acc*/);
+			break;
+
+		case 0x01: /* add */
+			r_temp = POP32();
+			if (r_temp.segment || s->r_acc.segment) {
+				reg_t r_ptr;
+				int offset;
+				/* Pointer arithmetics! */
+				if (s->r_acc.segment) {
+					if (r_temp.segment) {
+						sciprintf("Error: Attempt to add two pointers, stack="PREG" and acc="PREG"!\n",
+							  PRINT_REG(r_temp), PRINT_REG(s->r_acc));
+						script_debug_flag = script_error_flag = 1;
+						offset = 0;
+					} else {
+						r_ptr = s->r_acc; 
+						offset = r_temp.offset;
+					}
+				} else {
+					r_ptr = r_temp;
+					offset = s->r_acc.offset;
+				}
+
+				s->r_acc = pointer_add(s, r_ptr, offset);
+
+			} else
+				s->r_acc = make_reg(0, r_temp.offset + s->r_acc.offset);
+			break;
+
+		case 0x02: /* sub */
+			r_temp = POP32();
+			if (r_temp.segment || s->r_acc.segment) {
+				reg_t r_ptr;
+				int offset;
+				/* Pointer arithmetics! */
+				if (s->r_acc.segment) {
+					if (r_temp.segment) {
+						sciprintf("Error: Attempt to subtract two pointers, stack="PREG" and acc="PREG"!\n",
+							  PRINT_REG(r_temp), PRINT_REG(s->r_acc));
+						script_debug_flag = script_error_flag = 1;
+						offset = 0;
+					} else {
+						r_ptr = s->r_acc; 
+						offset = r_temp.offset;
+					}
+				} else {
+					r_ptr = r_temp;
+					offset = s->r_acc.offset;
+				}
+
+				s->r_acc = pointer_add(s, r_ptr, -offset);
+
+			} else
+				s->r_acc = make_reg(0, r_temp.offset - s->r_acc.offset);
+			break;
+
+		case 0x03: /* mul */
+			s->r_acc = ACC_ARITHMETIC_L (((gint16)POP()) * (gint16)/*acc*/);
+			break;
+
+		case 0x04: /* div */
+			ACC_AUX_LOAD();
+			aux_acc = aux_acc != 0 ? ((gint16)POP()) / aux_acc : 0;
+			ACC_AUX_STORE();
+			break;
+
+		case 0x05: /* mod */
+			ACC_AUX_LOAD();
+			aux_acc = aux_acc != 0 ? ((gint16)POP()) % aux_acc : 0;
+			ACC_AUX_STORE();
+			break;
+
+		case 0x06: /* shr */
+			s->r_acc = ACC_ARITHMETIC_L(((guint16) POP()) >> /*acc*/);
+			break;
+
+		case 0x07: /* shl */
+			s->r_acc = ACC_ARITHMETIC_L(((guint16) POP()) << /*acc*/);
+			break;
+
+		case 0x08: /* xor */
+			s->r_acc = ACC_ARITHMETIC_L(POP() ^ /*acc*/);
+			break;
+
+		case 0x09: /* and */
+			s->r_acc = ACC_ARITHMETIC_L(POP() & /*acc*/);
+			break;
+
+		case 0x0a: /* or */
+			s->r_acc = ACC_ARITHMETIC_L(POP() | /*acc*/);
+			break;
+
+		case 0x0b: /* neg */
+			s->r_acc = ACC_ARITHMETIC_L(-/*acc*/);
+			break;
+
+		case 0x0c: /* not */
+			s->r_acc = make_reg(0, !(s->r_acc.offset || s->r_acc.segment));
+			/* Must allow pointers to be negated, as this is used for
+			** checking whether objects exist  */
+			break;
+
+		case 0x0d: /* eq? */
+			s->r_prev = s->r_acc;
+			r_temp = POP32();
+			s->r_acc = make_reg(0, REG_EQ(r_temp, s->r_acc));
+			/* Explicitly allow pointers to be compared */
+			break;
+
+		case 0x0e: /* ne? */
+			s->r_prev = s->r_acc;
+			r_temp = POP32();
+			s->r_acc = make_reg(0, !REG_EQ(r_temp, s->r_acc));
+			/* Explicitly allow pointers to be compared */
+			break;
+
+		case 0x0f: /* gt? */
+			s->r_prev = s->r_acc;
+			s->r_acc = ACC_ARITHMETIC_L((gint16)POP() > (gint16)/*acc*/);
+			break;
+
+		case 0x10: /* ge? */
+			s->r_prev = s->r_acc;
+			s->r_acc = ACC_ARITHMETIC_L((gint16)POP() >= (gint16)/*acc*/);
+			break;
+
+		case 0x11: /* lt? */
+			s->r_prev = s->r_acc;
+			s->r_acc = ACC_ARITHMETIC_L((gint16)POP() < (gint16)/*acc*/);
+			break;
+
+		case 0x12: /* le? */
+			s->r_prev = s->r_acc;
+			s->r_acc = ACC_ARITHMETIC_L((gint16)POP() <= (gint16)/*acc*/);
+			break;
+
+		case 0x13: /* ugt? */
+			s->r_prev = s->r_acc;
+			r_temp = POP32();
+			s->r_acc = make_reg(0, (r_temp.segment == s->r_acc.segment) && r_temp.offset > s->r_acc.offset);
+			break;
+
+		case 0x14: /* uge? */
+			s->r_prev = s->r_acc;
+			r_temp = POP32();
+			s->r_acc = make_reg(0, (r_temp.segment == s->r_acc.segment) && r_temp.offset >= s->r_acc.offset);
+			break;
+
+		case 0x15: /* ult? */
+			s->r_prev = s->r_acc;
+			r_temp = POP32();
+			s->r_acc = make_reg(0, (r_temp.segment == s->r_acc.segment) && r_temp.offset < s->r_acc.offset);
+			break;
+
+		case 0x16: /* ule? */
+			s->r_prev = s->r_acc;
+			r_temp = POP32();
+			s->r_acc = make_reg(0, (r_temp.segment == s->r_acc.segment) && r_temp.offset <= s->r_acc.offset);
+			break;
+
+		case 0x17: /* bt */
+			if (s->r_acc.offset || s->r_acc.segment)
+				xs->addr.pc.offset += opparams[0];
+			break;
+
+		case 0x18: /* bnt */
+			if (!(s->r_acc.offset || s->r_acc.segment))
+				xs->addr.pc.offset += opparams[0];
+			break;
+
+		case 0x19: /* jmp */
+			xs->addr.pc.offset += opparams[0];
+			break;
+
+		case 0x1a: /* ldi */
+			s->r_acc = make_reg(0, opparams[0]);
+			break;
+
+		case 0x1b: /* push */
+			PUSH32(s->r_acc);
+			break;
+
+		case 0x1c: /* pushi */
+			PUSH(opparams[0]);
+			break;
+
+		case 0x1d: /* toss */
+			xs->sp--;
+			break;
+
+		case 0x1e: /* dup */
+			r_temp = xs->sp[-1];
+			PUSH32(r_temp);
+			break;
+
+		case 0x1f: { /* link */
+			int i;
+			for (i = 0; i < opparams[0]; i++)
+				xs->sp[i] = NULL_REG;
+			xs->sp += opparams[0];
+			break;
+		}
+
+		case 0x20: { /* call */
+			int argc = (opparams[1] >> 1) /* Given as offset, but we need count */
+				+ 1 + restadjust;
+			stack_ptr_t call_base = xs->sp - argc;
+
+			xs->sp[1].offset += restadjust;
+			xs_new = add_exec_stack_entry(s, make_reg(xs->addr.pc.segment,
+								  xs->addr.pc.offset
+								  + opparams[0]),
+						      xs->sp, xs->objp,
+						      (validate_arithmetic(*call_base))
+						        + restadjust,
+						      call_base, NULL_SELECTOR, xs->objp,
+						      s->execution_stack_pos, xs->local_segment);
+			restadjust = 0; /* Used up the &rest adjustment */
+			xs->sp = call_base;
+
+			s->execution_stack_pos_changed = 1;
+			break;
+		}
+
+		case 0x21: /* callk */
+			gc_countdown(s);
+
+			xs->sp -= (opparams[1] >> 1)+1;
+			if (s->version >= SCI_VERSION_FTU_NEW_SCRIPT_HEADER) {
+				xs->sp -= restadjust;
+				s->r_amp_rest = 0; /* We just used up the restadjust, remember? */
+			}
+
+			if (opparams[0] >= s->kfunct_nr) {
+
+				sciprintf("Invalid kernel function 0x%x requested\n", opparams[0]);
+				script_debug_flag = script_error_flag = 1;
+
+			} else {
+				int argc = ASSERT_ARITHMETIC(xs->sp[0]);
+
+				if (s->version >= SCI_VERSION_FTU_NEW_SCRIPT_HEADER)
+					argc += restadjust;
+
+				if (s->kfunct_table[opparams[0]].signature
+				    && !kernel_matches_signature(s,
+								 s->kfunct_table[opparams[0]]
+								 .signature,
+								 argc, xs->sp + 1)) {
+					sciprintf("[VM] Invalid arguments to kernel call %x\n",
+						  opparams[0]);
+					script_debug_flag = script_error_flag = 1;
+				} else {
+					s->r_acc = s->kfunct_table[opparams[0]]
+						.fun(s, opparams[0], argc, xs->sp + 1);
+				}
+				/* Call kernel function */
+
+				/* Calculate xs again: The kernel function might
+				** have spawned a new VM  */
+
+				xs_new = s->execution_stack + s->execution_stack_pos;
+				s->execution_stack_pos_changed = 1;
+
+				if (s->version>=SCI_VERSION_FTU_NEW_SCRIPT_HEADER)
+					restadjust = s->r_amp_rest;
+
+			}
+			break;
+
+		case 0x22: /* callb */
+			temp = ((opparams[1] >> 1) + restadjust + 1);
+			s_temp = xs->sp;
+			xs->sp -= temp;
+
+
+			xs->sp[0].offset += restadjust;
+			xs_new = execute_method(s, 0, opparams[0], s_temp, xs->objp,
+				xs->sp[0].offset, xs->sp);
+			restadjust = 0; /* Used up the &rest adjustment */
+			if (xs_new)    /* in case of error, keep old stack */
+				s->execution_stack_pos_changed = 1;
+			break;
+			
+		case 0x23: /* calle */
+			temp = ((opparams[2] >> 1) + restadjust + 1);
+			s_temp = xs->sp;
+			xs->sp -= temp;
+
+			xs->sp[0].offset += restadjust;
+			xs_new = execute_method(s, opparams[0], opparams[1], s_temp, xs->objp,
+				xs->sp[0].offset, xs->sp);
+			restadjust = 0; /* Used up the &rest adjustment */
+			
+			if (xs_new)  /* in case of error, keep old stack */
+				s->execution_stack_pos_changed = 1;
+			break;
+
+		case 0x24: /* ret */
+			do {
+				stack_ptr_t old_sp = xs->sp;
+				stack_ptr_t old_fp = xs->fp;
+				exec_stack_t *old_xs = s->execution_stack + s->execution_stack_pos;
+
+				if (s->execution_stack_pos == s->execution_stack_base) { /* Have we reached the base? */
+					s->execution_stack_base = old_execution_stack_base; /* Restore stack base */
+
+					--(s->execution_stack_pos);
+
+					s->execution_stack_pos_changed = 1;
+					s->r_amp_rest = restadjust; /* Update &rest */
+					return; /* "Hard" return */
+				}
+
+				if (old_xs->type == EXEC_STACK_TYPE_VARSELECTOR) {
+					/* varselector access? */
+					if (old_xs->argc) /* write? */
+						*(old_xs->addr.varp) = old_xs->variables_argp[1];
+					else /* No, read */
+						s->r_acc = *(old_xs->addr.varp);
+				}
+
+				/* Not reached the base, so let's do a soft return */
+				--(s->execution_stack_pos);
+				xs = old_xs - 1;
+				s->execution_stack_pos_changed = 1;
+				xs = s->execution_stack + s->execution_stack_pos;
+
+				if (xs->sp == CALL_SP_CARRY /* Used in sends to 'carry' the stack pointer */
+				    || xs->type != EXEC_STACK_TYPE_CALL) {
+					xs->sp = old_sp;
+					xs->fp = old_fp;
+				}
+
+			} while (xs->type == EXEC_STACK_TYPE_VARSELECTOR);
+			/* Iterate over all varselector accesses */
+			s->execution_stack_pos_changed = 1;
+			xs_new = xs;
+
+			break;
+
+		case 0x25: /* send */
+			s_temp = xs->sp;
+			xs->sp -= ((opparams[0] >> 1) + restadjust); /* Adjust stack */
+
+			xs->sp[1].offset += restadjust;
+			xs_new = send_selector(s, s->r_acc, s->r_acc, s_temp,
+					       (int)(opparams[0]>>1) + (word)restadjust,
+					       xs->sp);
+
+			if (xs_new && xs_new != xs)
+				s->execution_stack_pos_changed = 1;
+
+			restadjust = 0;
+
+			break;
+
+		case 0x28: /* class */
+			s->r_acc = get_class_address(s, (unsigned) opparams[0], SCRIPT_GET_LOCK, xs->addr.pc);
+			break;
+
+		case 0x2a: /* self */
+			s_temp = xs->sp;
+			xs->sp -= ((opparams[0] >> 1) + restadjust); /* Adjust stack */
+
+			xs->sp[1].offset += restadjust;
+			xs_new = send_selector(s, xs->objp, xs->objp, s_temp,
+					       (int)(opparams[0]>>1) + (word)restadjust,
+					       xs->sp);
+
+			if (xs_new && xs_new != xs)
+				s->execution_stack_pos_changed = 1;
+
+			restadjust = 0;
+			break;
+
+		case 0x2b: /* super */
+			r_temp = get_class_address(s, opparams[0], SCRIPT_GET_LOAD, xs->addr.pc);
+
+			if (!r_temp.segment)
+				CORE_ERROR("VM", "Invalid superclass in object");
+			else {
+				s_temp = xs->sp;
+				xs->sp -= ((opparams[1] >> 1) + restadjust); /* Adjust stack */
+
+				xs->sp[1].offset += restadjust;
+				xs_new = send_selector(s, r_temp, xs->objp, s_temp,
+						       (int)(opparams[1]>>1) + (word)restadjust,
+						       xs->sp);
+
+				if (xs_new && xs_new != xs)
+					s->execution_stack_pos_changed = 1;
+
+				restadjust = 0;
+			}
+
+			break;
+
+		case 0x2c: /* &rest */
+			temp = (guint16) opparams[0]; /* First argument */
+			restadjust = xs->argc - temp + 1; /* +1 because temp counts the paramcount while argc doesn't */
+			if (restadjust < 0)
+				restadjust = 0;
+
+			for (; temp <= xs->argc; temp++)
+				PUSH32(xs->variables_argp[temp]);
+
+			break;
+
+		case 0x2d: /* lea */
+			temp = (guint16) opparams[0] >> 1;
+			var_number = temp & 0x03; /* Get variable type */
+
+			/* Get variable block offset */
+			r_temp.segment = variables_seg[var_number];
+			r_temp.offset = variables[var_number] - variables_base[var_number];
+
+			if (temp & 0x08)  /* Add accumulator offset if requested */
+				r_temp.offset += signed_validate_arithmetic(s->r_acc);
+
+			r_temp.offset += opparams[1];  /* Add index */
+			r_temp.offset *= sizeof(reg_t);
+			/* That's the immediate address now */
+			s->r_acc = r_temp;
+			break;
+
+
+		case 0x2e: /* selfID */
+			s->r_acc = xs->objp;
+			break;
+
+		case 0x30: /* pprev */
+			PUSH32(s->r_prev);
+			break;
+
+		case 0x31: /* pToa */
+			s->r_acc = OBJ_PROPERTY(obj, (opparams[0] >> 1));
+			break;
+
+		case 0x32: /* aTop */
+			OBJ_PROPERTY(obj, (opparams[0] >> 1)) = s->r_acc;
+			break;
+
+		case 0x33: /* pTos */
+			PUSH32(OBJ_PROPERTY(obj, opparams[0] >> 1));
+			break;
+
+		case 0x34: /* sTop */
+			OBJ_PROPERTY(obj, (opparams[0] >> 1)) = POP32();
+			break;
+
+		case 0x35: /* ipToa */
+			s->r_acc = OBJ_PROPERTY(obj, (opparams[0] >> 1));
+			s->r_acc = OBJ_PROPERTY(obj, (opparams[0] >> 1)) =
+				ACC_ARITHMETIC_L( 1 + /*acc*/);
+			break;
+
+		case 0x36: /* dpToa */
+			s->r_acc = OBJ_PROPERTY(obj, (opparams[0] >> 1));
+			s->r_acc = OBJ_PROPERTY(obj, (opparams[0] >> 1)) =
+				ACC_ARITHMETIC_L(-1 + /*acc*/);
+			break;
+
+		case 0x37: /* ipTos */
+			ASSERT_ARITHMETIC(OBJ_PROPERTY(obj, (opparams[0] >> 1)));
+			temp = ++OBJ_PROPERTY(obj, (opparams[0] >> 1)).offset;
+			PUSH(temp);
+			break;
+
+		case 0x38: /* dpTos */
+			ASSERT_ARITHMETIC(OBJ_PROPERTY(obj, (opparams[0] >> 1)));
+			temp = --OBJ_PROPERTY(obj, (opparams[0] >> 1)).offset;
+			PUSH(temp);
+			break;
+
+
+		case 0x39: /* lofsa */
+			s->r_acc.segment = xs->addr.pc.segment;
+
+			if (s->version >= SCI_VERSION(1,001,000))
+				s->r_acc.offset = opparams[0]+local_script->script_size;
+			else
+			if (s->version >= SCI_VERSION_FTU_LOFS_ABSOLUTE)
+				s->r_acc.offset = opparams[0]; 
+			else
+				s->r_acc.offset = xs->addr.pc.offset + opparams[0];
+#ifndef DISABLE_VALIDATIONS
+			if (s->r_acc.offset >= code_buf_size) {
+				sciprintf("VM: lofsa operation overflowed: "PREG" beyond end"
+					  " of script (at %04x)\n", PRINT_REG(s->r_acc),
+					  code_buf_size);
+				script_error_flag = script_debug_flag = 1;
+			}
+#endif
+			break;
+
+
+		case 0x3a: /* lofss */
+			r_temp.segment = xs->addr.pc.segment;
+
+			if (s->version >= SCI_VERSION_FTU_LOFS_ABSOLUTE)
+			        r_temp.offset = opparams[0]; else
+				r_temp.offset = xs->addr.pc.offset + opparams[0];
+#ifndef DISABLE_VALIDATIONS
+			if (r_temp.offset >= code_buf_size) {
+				sciprintf("VM: lofss operation overflowed: "PREG" beyond end"
+					  " of script (at %04x)\n", PRINT_REG(r_temp),
+					  code_buf_size);
+				script_error_flag = script_debug_flag = 1;
+			}
+#endif
+			PUSH32(r_temp);
+			break;
+
+		case 0x3b: /* push0 */
+			PUSH(0);
+			break;
+
+		case 0x3c: /* push1 */
+			PUSH(1);
+			break;
+
+		case 0x3d: /* push2 */
+			PUSH(2);
+			break;
+
+		case 0x3e: /* pushSelf */
+			PUSH32(xs->objp);
+			break;
+
+		case 0x40: /* lag */
+		case 0x41: /* lal */
+		case 0x42: /* lat */
+		case 0x43: /* lap */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0];
+			s->r_acc = READ_VAR(var_type, var_number, s->r_acc);
+			break;
+
+		case 0x44: /* lsg */
+		case 0x45: /* lsl */
+		case 0x46: /* lst */
+		case 0x47: /* lsp */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0];
+			PUSH32(READ_VAR(var_type, var_number, s->r_acc));
+			break;
+
+		case 0x48: /* lagi */
+		case 0x49: /* lali */
+		case 0x4a: /* lati */
+		case 0x4b: /* lapi */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0] + signed_validate_arithmetic(s->r_acc);
+			s->r_acc = READ_VAR(var_type, var_number, s->r_acc);
+			break;
+
+		case 0x4c: /* lsgi */
+		case 0x4d: /* lsli */
+		case 0x4e: /* lsti */
+		case 0x4f: /* lspi */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0] + signed_validate_arithmetic(s->r_acc);
+			PUSH32(READ_VAR(var_type, var_number, s->r_acc));
+			break;
+
+		case 0x50: /* sag */
+		case 0x51: /* sal */
+		case 0x52: /* sat */
+		case 0x53: /* sap */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0];
+			WRITE_VAR(var_type, var_number, s->r_acc);
+			break;
+
+		case 0x54: /* ssg */
+		case 0x55: /* ssl */
+		case 0x56: /* sst */
+		case 0x57: /* ssp */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0];
+			WRITE_VAR(var_type, var_number, POP32());
+			break;
+
+		case 0x58: /* sagi */
+		case 0x59: /* sali */
+		case 0x5a: /* sati */
+		case 0x5b: /* sapi */
+			/* Special semantics because it wouldn't really make a whole lot
+			** of sense otherwise, with acc being used for two things
+			** simultaneously... */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0] + signed_validate_arithmetic(s->r_acc);
+			WRITE_VAR(var_type, var_number, s->r_acc = POP32());
+			break;
+
+		case 0x5c: /* ssgi */
+		case 0x5d: /* ssli */
+		case 0x5e: /* ssti */
+		case 0x5f: /* sspi */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0] + signed_validate_arithmetic(s->r_acc);
+			WRITE_VAR(var_type, var_number, POP32());
+			break;
+
+		case 0x60: /* +ag */
+		case 0x61: /* +al */
+		case 0x62: /* +at */
+		case 0x63: /* +ap */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0];
+			s->r_acc = make_reg(0,
+					    1 + validate_arithmetic(READ_VAR(var_type,
+									     var_number,
+									     s->r_acc)));
+			WRITE_VAR(var_type, var_number, s->r_acc);
+			break;
+
+		case 0x64: /* +sg */
+		case 0x65: /* +sl */
+		case 0x66: /* +st */
+		case 0x67: /* +sp */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0];
+			r_temp = make_reg(0,
+					  1 + validate_arithmetic(READ_VAR(var_type,
+									   var_number,
+									   s->r_acc)));
+			PUSH32(r_temp);
+			WRITE_VAR(var_type, var_number, r_temp);
+			break;
+
+		case 0x68: /* +agi */
+		case 0x69: /* +ali */
+		case 0x6a: /* +ati */
+		case 0x6b: /* +api */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0] + signed_validate_arithmetic(s->r_acc);
+			s->r_acc = make_reg(0,
+					    1 + validate_arithmetic(READ_VAR(var_type,
+									     var_number,
+									     s->r_acc)));
+			WRITE_VAR(var_type, var_number, s->r_acc);
+			break;
+
+		case 0x6c: /* +sgi */
+		case 0x6d: /* +sli */
+		case 0x6e: /* +sti */
+		case 0x6f: /* +spi */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0] + signed_validate_arithmetic(s->r_acc);
+			r_temp = make_reg(0,
+					  1 + validate_arithmetic(READ_VAR(var_type,
+									   var_number,
+									   s->r_acc)));
+			PUSH32(r_temp);
+			WRITE_VAR(var_type, var_number, r_temp);
+			break;
+
+		case 0x70: /* -ag */
+		case 0x71: /* -al */
+		case 0x72: /* -at */
+		case 0x73: /* -ap */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0];
+			s->r_acc = make_reg(0,
+					    -1 + validate_arithmetic(READ_VAR(var_type,
+									      var_number, s->r_acc)));
+			WRITE_VAR(var_type, var_number, s->r_acc);
+			break;
+
+		case 0x74: /* -sg */
+		case 0x75: /* -sl */
+		case 0x76: /* -st */
+		case 0x77: /* -sp */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0];
+			r_temp = make_reg(0,
+					  -1 + validate_arithmetic(READ_VAR(var_type,
+									    var_number, s->r_acc)));
+			PUSH32(r_temp);
+			WRITE_VAR(var_type, var_number, r_temp);
+			break;
+
+		case 0x78: /* -agi */
+		case 0x79: /* -ali */
+		case 0x7a: /* -ati */
+		case 0x7b: /* -api */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0] + signed_validate_arithmetic(s->r_acc);
+			s->r_acc = make_reg(0,
+					    -1 + validate_arithmetic(READ_VAR(var_type,
+									      var_number,
+									      s->r_acc)));
+			WRITE_VAR(var_type, var_number, s->r_acc);
+			break;
+
+		case 0x7c: /* -sgi */
+		case 0x7d: /* -sli */
+		case 0x7e: /* -sti */
+		case 0x7f: /* -spi */
+			var_type = (opcode >> 1) & 0x3; /* Gets the variable type: g, l, t or p */
+			var_number = opparams[0] + signed_validate_arithmetic(s->r_acc);
+			r_temp = make_reg(0,
+					  -1 + validate_arithmetic(READ_VAR(var_type,
+									    var_number,
+									    s->r_acc)));
+			PUSH32(r_temp);
+			WRITE_VAR(var_type, var_number, r_temp);
+			break;
+
+		default:
+			script_error(s, __FILE__, __LINE__, "Illegal opcode");
+
+		} /* switch(opcode >> 1) */
+
+
+		if (s->execution_stack_pos_changed) /* Force initialization */
+			xs = xs_new;
+
+#ifndef DISABLE_VALIDATIONS
+		if (xs != s->execution_stack + s->execution_stack_pos) {
+			sciprintf("Error: xs is stale (%d vs %d); last command was %02x\n",
+				  xs-s->execution_stack, s->execution_stack_pos, opnumber);
+		}
+#endif
+
+		if (script_error_flag) {
+			_debug_step_running = 0; /* Stop multiple execution */
+			_debug_seeking = 0; /* Stop special seeks */
+			xs->addr.pc.offset = old_pc_offset;
+			xs->sp = old_sp;
+		} else
+			++script_step_counter;
+	}
+}
+
+
+
+static inline int
+_obj_locate_varselector(state_t *s, object_t *obj, selector_t slc)
+{	/* Determines if obj explicitly defines slc as a varselector */
+	/* Returns -1 if not found */
+	
+	if (s->version < SCI_VERSION(1,001,000))
+	{
+		int varnum = obj->variable_names_nr;
+		int selector_name_offset = varnum * 2 + SCRIPT_SELECTOR_OFFSET;
+		int i;
+		byte *buf = obj->base_obj + selector_name_offset;
+
+		obj->base_vars = (guint16 *) buf;
+		
+		for (i = 0; i < varnum; i++)
+			if (getUInt16(buf + (i << 1)) == slc) /* Found it? */
+				return i; /* report success */
+		
+		return -1; /* Failed */
+	}
+	else
+	{
+		byte *buf = (byte *) obj->base_vars;
+		int i;
+		int varnum = obj->variables[1].offset;
+
+		if (!(obj->variables[SCRIPT_INFO_SELECTOR].offset & SCRIPT_INFO_CLASS))
+			buf = ((byte *) obj_get(s, obj->variables[SCRIPT_SUPERCLASS_SELECTOR])->base_vars);
+
+		for (i = 0; i < varnum; i++)
+			if (getUInt16(buf + (i << 1)) == slc) /* Found it? */
+				return i; /* report success */
+		
+		return -1; /* Failed */
+	}		
+}
+
+
+static inline int
+_class_locate_funcselector(state_t *s, object_t *obj, selector_t slc)
+{	/* Determines if obj is a class and explicitly defines slc as a funcselector */
+	/* Does NOT say anything about obj's superclasses, i.e. failure may be
+	** returned even if one of the superclasses defines the funcselector. */
+	int funcnum = obj->methods_nr;
+	int i;
+
+	for (i = 0; i < funcnum; i++)
+		if (VM_OBJECT_GET_FUNCSELECTOR(obj, i) == slc) /* Found it? */
+			return i; /* report success */
+
+	return -1; /* Failed */
+}
+
+
+static inline int
+_lookup_selector_function(state_t *s, int seg_id, object_t *obj, selector_t selector_id, reg_t *fptr)
+{
+	int index;
+
+	/* "recursive" lookup */
+
+	while (obj) {
+		index = _class_locate_funcselector(s, obj, selector_id);
+
+		if (index >= 0) {
+			if (fptr)
+			{
+				if (s->version < SCI_VERSION(1,001,000))
+					*fptr = make_reg(obj->pos.segment,
+							 getUInt16((byte *)
+								   (obj->base_method + index
+								    + obj->methods_nr + 1)));
+				else
+					*fptr = make_reg(obj->pos.segment,
+							 getUInt16((byte *)
+								   (obj->base_method + index * 2 + 2)));
+			}
+
+			return SELECTOR_METHOD;
+		} else {
+			seg_id = obj->variables[SCRIPT_SUPERCLASS_SELECTOR].segment;
+			obj = obj_get(s, obj->variables[SCRIPT_SUPERCLASS_SELECTOR]);
+		}
+	}
+
+	return SELECTOR_NONE;
+}
+
+int
+lookup_selector(state_t *s, reg_t obj_location, selector_t selector_id, reg_t **vptr, reg_t *fptr)
+{
+	object_t *obj = obj_get(s, obj_location);
+	object_t *species;
+	int index;
+
+	/* Early SCI versions used the LSB in the selector ID as a read/write
+	** toggle, meaning that we must remove it for selector lookup.  */
+	if (s->version < SCI_VERSION_FTU_NEW_SCRIPT_HEADER)
+		selector_id &= ~1;
+
+	if (!obj) {
+		CORE_ERROR("SLC-LU", "Attempt to send to non-object or invalid script");
+		sciprintf("Address was "PREG"\n", PRINT_REG(obj_location));
+		return SELECTOR_NONE;
+	}
+
+	if (IS_CLASS(obj))
+		species = obj;
+	else
+		species = obj_get(s, obj->variables[SCRIPT_SPECIES_SELECTOR]);
+
+
+	if (!obj) {
+		CORE_ERROR("SLC-LU", "Error while looking up Species class");
+		sciprintf("Original address was "PREG"\n", PRINT_REG(obj_location));
+		sciprintf("Species address was "PREG"\n", PRINT_REG(obj->variables[SCRIPT_SPECIES_SELECTOR]));
+		return SELECTOR_NONE;
+	}
+
+	index = _obj_locate_varselector(s, obj, selector_id);
+
+	if (index >= 0) {
+		/* Found it as a variable */
+		if (vptr)
+			*vptr = obj->variables + index;
+		return SELECTOR_VARIABLE;
+	} return
+		_lookup_selector_function(s, obj_location.segment, obj, selector_id, fptr);
+
+}
+
+
+/* Detects SCI versions by their different script header */
+void script_detect_versions(state_t *s)
+{
+	int c;
+	resource_t *script = {0};
+
+	
+	if (scir_find_resource(s->resmgr, sci_heap, 0, 0))
+	{
+		version_require_later_than(s, SCI_VERSION(1,001,000));
+		return;
+	}
+
+	for (c = 0; c < 1000; c++) {
+		if ((script = scir_find_resource(s->resmgr, sci_script, c, 0))) {
+
+			int id = getInt16(script->data);
+
+			if (id > 15) {
+				version_require_earlier_than(s, SCI_VERSION_FTU_NEW_SCRIPT_HEADER);
+				return;
+			}
+		}
+	}
+}
+
+
+seg_id_t
+script_get_segment(state_t *s, int script_nr, int load)
+{
+	seg_id_t segment;
+
+	if ((load & SCRIPT_GET_LOAD) == SCRIPT_GET_LOAD)
+		script_instantiate(s, script_nr);
+
+	segment = sm_seg_get(&s->seg_manager, script_nr);
+
+	if (segment > 0) {
+		if ((load & SCRIPT_GET_LOCK) == SCRIPT_GET_LOCK)
+			sm_increment_lockers(&s->seg_manager, segment, SEG_ID);
+
+		return segment;
+	} else
+		return 0;
+}
+
+reg_t
+script_lookup_export(state_t *s, int script_nr, int export_index)
+{
+	seg_id_t seg = script_get_segment(s, script_nr, SCRIPT_GET_DONT_LOAD);
+	mem_obj_t *memobj;
+	script_t *script = NULL;
+
+#ifndef DISABLE_VALIDATIONS
+	if (!seg) {
+		CORE_ERROR("EXPORTS", "Script invalid or not loaded");
+		sciprintf("Script was script.03d (0x%x)\n",
+			  script_nr, script_nr);
+		return NULL_REG;
+	}
+#endif
+
+	memobj = GET_SEGMENT(s->seg_manager, seg, MEM_OBJ_SCRIPT);
+
+	if (memobj)
+		script = &(memobj->data.script);
+
+#ifndef DISABLE_VALIDATIONS
+	if (script
+	    && export_index < script->exports_nr
+	    && export_index >= 0)
+#endif
+		return make_reg(seg, getUInt16((byte *)(script->export_table + export_index)));
+#ifndef DISABLE_VALIDATIONS
+	else {
+		CORE_ERROR("EXPORTS", "Export invalid or script missing ");
+		if (!script)
+			sciprintf("(script.%03d missing)\n", script_nr);
+		else
+			sciprintf("(script.%03d: Sought export %d/%d)\n",
+				  script_nr, export_index, script->exports_nr);
+		return NULL_REG;
+	}
+#endif
+}
+
+#define INST_LOOKUP_CLASS(id) ((id == 0xffff)? NULL_REG : get_class_address(s, id, SCRIPT_GET_LOCK, reg))
+
+int sm_script_marked_deleted(seg_manager_t* self, int script_nr);
+int sm_initialise_script(mem_obj_t *mem, struct _state *s, int script_nr);
+
+int
+script_instantiate_common(state_t *s, int script_nr, resource_t **script, resource_t **heap, int *was_new)
+{
+	int seg;
+	int seg_id;
+	int marked_for_deletion; 
+	mem_obj_t *mem;
+	reg_t reg;
+
+	*was_new = 1;
+
+	*script = scir_find_resource(s->resmgr, sci_script, script_nr, 0);
+	if (s->version >= SCI_VERSION(1,001,000))
+		*heap = scir_find_resource(s->resmgr, sci_heap, script_nr, 0);
+
+	if (!*script || (s->version >= SCI_VERSION(1,001,000) && !heap)) {
+		sciprintf("Script 0x%x requested but not found\n", script_nr);
+		/*    script_debug_flag = script_error_flag = 1; */
+		if (s->version >= SCI_VERSION(1,001,000))
+		{
+			if (*heap)
+				sciprintf("Inconsistency: heap resource WAS found\n");
+			else if (*script)
+				sciprintf("Inconsistency: script resource WAS found\n");
+		}
+		return 0;
+	}
+
+        if (NULL == s) {
+                sciprintf("vm.c: script_instantiate(): NULL passed for \"s\"\n");
+		return 0;
+	}
+
+	seg = sm_seg_get ( &s->seg_manager, script_nr );
+	if (sm_script_is_loaded (&s->seg_manager, script_nr, SCRIPT_ID)) {
+		marked_for_deletion = sm_script_marked_deleted(&s->seg_manager, script_nr);
+
+		if (!marked_for_deletion) {  
+		sm_increment_lockers( &s->seg_manager, seg, SEG_ID );
+		return seg;
+	}
+		else
+		{
+			seg_id = seg;
+			mem = s->seg_manager.heap[seg];
+			sm_free_script(mem);
+		}
+	}
+	else if (!(mem = sm_allocate_script( &s->seg_manager, s, script_nr, &seg_id ))) { /* ALL YOUR SCRIPT BASE ARE BELONG TO US */
+		sciprintf("Not enough heap space for script size 0x%x of script 0x%x,"
+			  " should this happen?`\n",
+			  (*script)->size, script_nr);
+		script_debug_flag = script_error_flag = 1;
+		return 0;
+	}
+
+	sm_initialise_script(mem, s, script_nr);
+
+	reg.segment = seg_id;
+	reg.offset = 0;
+
+	/* Set heap position (beyond the size word) */
+	sm_set_lockers( &s->seg_manager, 1, reg.segment, SEG_ID );
+	sm_set_export_table_offset( &s->seg_manager, 0, reg.segment, SEG_ID );
+	sm_set_synonyms_offset( &s->seg_manager, 0, reg.segment, SEG_ID );
+	sm_set_synonyms_nr( &s->seg_manager, 0, reg.segment, SEG_ID );
+
+	*was_new = 0;
+
+	return seg_id;
+}
+
+int
+script_instantiate_sci0(state_t *s, int script_nr)
+{
+	int objtype;
+	unsigned int objlength;
+	reg_t reg, reg_tmp;
+	int seg_id;
+	int relocation = -1;
+	int magic_pos_adder; /* Usually 0; 2 for older SCI versions */
+	resource_t *script;
+	int was_new;
+
+	seg_id = script_instantiate_common(s, script_nr, &script, NULL, &was_new);
+
+	if (was_new) return seg_id;
+
+	reg.segment = seg_id;
+	reg.offset = 0;
+
+	if (s->version < SCI_VERSION_FTU_NEW_SCRIPT_HEADER) {
+		/*
+		int locals_size = getUInt16(script->data)*2;
+		int locals = (locals_size)? script->size : 0;
+		*/
+		int locals_nr = getUInt16(script->data);
+
+		/* Old script block */
+		/* There won't be a localvar block in this case */
+		/* Instead, the script starts with a 16 bit int specifying the
+		** number of locals we need; these are then allocated and zeroed.  */
+
+		sm_mcpy_in_out( &s->seg_manager, 0, script->data, script->size, reg.segment, SEG_ID);
+		magic_pos_adder = 2;  /* Step over the funny prefix */
+
+		if (locals_nr)
+			sm_script_initialise_locals_zero( &s->seg_manager,
+							  reg.segment, locals_nr);
+
+	} else {
+		sm_mcpy_in_out( &s->seg_manager, 0, script->data, script->size, reg.segment, SEG_ID);
+		magic_pos_adder = 0;
+	}
+
+	/* Now do a first pass through the script objects to find the
+	** export table and local variable block
+	*/
+
+	objlength = 0;
+	reg_tmp = reg;
+	reg.offset = magic_pos_adder;
+
+	do {
+		reg_t data_base;
+		reg_t addr;
+		reg.offset += objlength; /* Step over the last checked object */
+		objtype = SEG_GET_HEAP(s, reg);
+		if( !objtype ) break;
+
+		objlength = SEG_GET_HEAP(s, make_reg(reg.segment, reg.offset + 2));
+
+		data_base = reg;
+		data_base.offset += 4;
+
+		addr = data_base;
+
+		switch( objtype ) {
+		case sci_obj_exports: {
+			sm_set_export_table_offset( &s->seg_manager, data_base.offset,
+								reg.segment, SEG_ID );
+		}
+			break;
+
+		case sci_obj_synonyms:
+			sm_set_synonyms_offset( &s->seg_manager, addr.offset, reg.segment, SEG_ID ); /* +4 is to step over the header */
+			sm_set_synonyms_nr( &s->seg_manager, (objlength) / 4, reg.segment, SEG_ID );
+			break;
+
+		case sci_obj_localvars:
+			sm_script_initialise_locals( &s->seg_manager, data_base);
+			break;
+
+		case sci_obj_class: {
+			int classpos = addr.offset - SCRIPT_OBJECT_MAGIC_OFFSET;
+			int species;
+			reg_tmp.offset = addr.offset - SCRIPT_OBJECT_MAGIC_OFFSET;
+			species = OBJ_SPECIES(s, reg_tmp);
+			if (species < 0 || species >= s->classtable_size) {
+				sciprintf("Invalid species %d(0x%x) not in interval "
+					  "[0,%d) while instantiating script %d\n",
+					  species, species, s->classtable_size,
+					  script_nr);
+				script_debug_flag = script_error_flag = 1;
+				return 1;
+			}
+
+			s->classtable[species].script = script_nr;
+			s->classtable[species].reg = addr;
+			s->classtable[species].reg.offset = classpos;
+			/* Set technical class position-- into the block allocated for it */
+
+			}
+			break;
+
+		default:
+			break;
+		}
+	} while (objtype != 0);
+	/* And now a second pass to adjust objects and class pointers, and the general pointers */
+
+	objlength = 0;
+	reg.offset = magic_pos_adder; /* Reset counter */
+
+	do {
+		reg_t addr;
+		reg.offset += objlength; /* Step over the last checked object */
+		objtype = SEG_GET_HEAP(s, reg);
+		if( !objtype ) break;
+		objlength = SEG_GET_HEAP(s, make_reg(reg.segment, reg.offset + 2));
+		reg.offset += 4; /* Step over header */
+
+		addr = reg;
+
+		switch (objtype) {
+		case sci_obj_code:
+			sm_script_add_code_block(&s->seg_manager, addr);
+			break;
+		case sci_obj_object:
+		case sci_obj_class:
+		{ /* object or class? */
+			object_t *obj = sm_script_obj_init(&s->seg_manager, s, addr);
+			object_t *base_obj;
+
+			/* Instantiate the superclass, if neccessary */
+			obj->variables[SCRIPT_SPECIES_SELECTOR] =
+				INST_LOOKUP_CLASS(obj->variables[SCRIPT_SPECIES_SELECTOR].offset);
+
+			base_obj = obj_get(s, obj->variables[SCRIPT_SPECIES_SELECTOR]);
+			obj->variable_names_nr = base_obj->variables_nr;
+			obj->base_obj = base_obj->base_obj;
+			/* Copy base from species class, as we need its selector IDs */ 
+
+			obj->variables[SCRIPT_SUPERCLASS_SELECTOR] =
+				INST_LOOKUP_CLASS(obj->variables[SCRIPT_SUPERCLASS_SELECTOR].offset);
+
+		} /* if object or class */
+			break;
+		case sci_obj_pointers: /* A relocation table */
+			relocation = addr.offset;
+			break;
+
+		default:
+			break;
+		}
+
+		reg.offset -= 4; /* Step back on header */
+
+	} while ((objtype != 0) && (((unsigned)reg.offset) < script->size - 2));
+
+	if (relocation >= 0)
+		sm_script_relocate(&s->seg_manager, make_reg(reg.segment, relocation));
+
+	sm_script_free_unused_objects(&s->seg_manager, reg.segment);
+
+	return reg.segment;		/* instantiation successful */
+}
+
+void
+sm_script_relocate_exports_sci11(seg_manager_t *self, int seg);
+void
+sm_script_initialise_objects_sci11(seg_manager_t *self, state_t *s, int seg);
+void
+sm_heap_relocate(seg_manager_t *self, state_t *s, reg_t block);
+
+int
+script_instantiate_sci11(state_t *s, int script_nr)
+{
+	resource_t *script, *heap;
+	int seg_id;
+	int heap_start;
+	reg_t reg;
+	int was_new;
+
+	seg_id = script_instantiate_common(s, script_nr, &script, &heap, &was_new);
+
+	if (was_new) return seg_id;
+
+	heap_start = script->size;
+	if (script->size & 2)
+		heap_start ++;
+
+	sm_mcpy_in_out( &s->seg_manager, 0, script->data, script->size, seg_id, SEG_ID);
+	sm_mcpy_in_out( &s->seg_manager, heap_start, heap->data, heap->size, seg_id, SEG_ID);
+
+	if (getUInt16(script->data+6) > 0)
+		sm_set_export_table_offset(&s->seg_manager, 6,
+					   seg_id, SEG_ID);
+
+	reg.segment = seg_id;
+	reg.offset = heap_start+4;
+	sm_script_initialise_locals(&s->seg_manager, reg);
+
+	sm_script_relocate_exports_sci11(&s->seg_manager, seg_id);
+	sm_script_initialise_objects_sci11(&s->seg_manager, s, seg_id);
+
+	reg.offset = getUInt16(heap->data);
+	sm_heap_relocate(&s->seg_manager, s, reg); 
+
+	return seg_id;
+}
+
+int
+script_instantiate(state_t *s, int script_nr)
+{
+	if (s->version >= SCI_VERSION(1,001,000))
+		return script_instantiate_sci11(s, script_nr);
+	else
+		return script_instantiate_sci0(s, script_nr);
+}
+
+void sm_mark_script_deleted(seg_manager_t* self, int script_nr);
+
+void
+script_uninstantiate_sci0(state_t *s, int script_nr, seg_id_t seg)
+{
+	reg_t reg = make_reg( seg, (s->version < SCI_VERSION_FTU_NEW_SCRIPT_HEADER)? 2 : 0 );
+	int objtype, objlength;
+
+	/* Make a pass over the object in order uninstantiate all superclasses */
+	objlength = 0;
+
+	do {
+		reg.offset += objlength; /* Step over the last checked object */
+		
+		objtype = SEG_GET_HEAP(s, reg);
+		if( !objtype ) break;
+		objlength = SEG_GET_HEAP(s, make_reg(reg.segment, reg.offset + 2));  /* use SEG_UGET_HEAP ?? */
+
+		reg.offset += 4; /* Step over header */
+
+		if ((objtype == sci_obj_object) || (objtype == sci_obj_class)) { /* object or class? */
+			int superclass;
+
+			reg.offset -= SCRIPT_OBJECT_MAGIC_OFFSET;
+
+			superclass = OBJ_SUPERCLASS(s, reg); /* Get superclass... */
+
+			if (superclass >= 0) {
+				int superclass_script = s->classtable[superclass].script;
+
+				if (superclass_script == script_nr) {
+					if( sm_get_lockers( &s->seg_manager, reg.segment, SEG_ID) )
+						sm_decrement_lockers( &s->seg_manager, reg.segment, SEG_ID); /* Decrease lockers if this is us ourselves */
+				} else
+					script_uninstantiate(s, superclass_script);
+				/* Recurse to assure that the superclass lockers number gets decreased */
+			}
+
+			reg.offset += SCRIPT_OBJECT_MAGIC_OFFSET;
+		} /* if object or class */
+
+		reg.offset -= 4; /* Step back on header */
+
+	} while (objtype != 0);
+}
+
+void
+script_uninstantiate(state_t *s, int script_nr)
+{
+	reg_t reg = make_reg( 0, (s->version < SCI_VERSION_FTU_NEW_SCRIPT_HEADER)? 2 : 0 );
+	int i;
+
+	reg.segment = sm_seg_get( &s->seg_manager, script_nr);
+
+	if (!sm_script_is_loaded (&s->seg_manager, script_nr, SCRIPT_ID) || reg.segment <= 0 ) { /* Is it already loaded? */
+		/*    sciprintf("Warning: unloading script 0x%x requested although not loaded\n", script_nr); */
+		/* This is perfectly valid SCI behaviour */
+		return;
+	}
+
+	sm_decrement_lockers( &s->seg_manager, reg.segment, SEG_ID);  /* One less locker */
+
+	if( sm_get_lockers( &s->seg_manager, reg.segment, SEG_ID) > 0 )
+		return;
+
+	/* Free all classtable references to this script */
+	for (i = 0; i < s->classtable_size; i++)
+		if (s->classtable[i].reg.segment == reg.segment)
+			s->classtable[i].reg = NULL_REG;
+
+	if (s->version < SCI_VERSION(1,001,000))
+		script_uninstantiate_sci0(s, script_nr, reg.segment);
+	else
+		sciprintf("FIXME: Add proper script uninstantiation for SCI 1.1\n");
+
+	if( sm_get_lockers( &s->seg_manager, reg.segment, SEG_ID) )
+		return; /* if xxx.lockers > 0 */
+
+  /* Otherwise unload it completely */
+  /* Explanation: I'm starting to believe that this work is done by SCI itself. */
+	sm_mark_script_deleted( &s->seg_manager, script_nr );
+
+	if (script_checkloads_flag)
+		sciprintf("Unloaded script 0x%x.\n", script_nr);
+
+	return;
+}
+
+
+static void
+_init_stack_base_with_selector(state_t *s, selector_t selector)
+{
+	s->stack_base[0] = make_reg(0, (word) selector);
+	s->stack_base[1] = NULL_REG;
+}
+
+static state_t *
+_game_run(state_t *s, int restoring)
+{
+	state_t *successor = NULL;
+	int game_is_finished = 0;
+	do {
+		s->execution_stack_pos_changed = 0;
+		run_vm(s, (successor || restoring)? 1 : 0);
+		if (s->restarting_flags & SCI_GAME_IS_RESTARTING_NOW) { /* Restart was requested? */
+
+			sci_free(s->execution_stack);
+			s->execution_stack = NULL;
+			s->execution_stack_pos = -1;
+			s->execution_stack_pos_changed = 0;
+
+			game_exit(s);
+			script_free_engine(s);
+			script_init_engine(s, s->version);
+			game_init(s);
+			sfx_reset_player();
+			_init_stack_base_with_selector(s, s->selector_map.play);
+			/* Call the play selector */
+
+			send_selector(s, s->game_obj, s->game_obj,
+				      s->stack_base, 2, s->stack_base);
+
+			script_abort_flag = 0;
+			s->restarting_flags = SCI_GAME_WAS_RESTARTED |
+				SCI_GAME_WAS_RESTARTED_AT_LEAST_ONCE;
+
+		}
+		else {
+			successor = s->successor;
+			if (successor) {
+				game_exit(s);
+				script_free_vm_memory(s);
+				sci_free(s);
+				s = successor;
+
+				if (!send_calls_allocated)
+					send_calls = (calls_struct_t*)sci_calloc(sizeof(calls_struct_t),
+								send_calls_allocated = 16);
+
+				if (script_abort_flag == SCRIPT_ABORT_WITH_REPLAY) {
+					sciprintf("Restarting with replay()\n");
+					s->execution_stack_pos = -1; /* Resatart with replay */
+					
+					_init_stack_base_with_selector(s, s->selector_map.replay);
+					/* Call the replay selector */
+
+					send_selector(s, s->game_obj, s->game_obj,
+						      s->stack_base, 2,
+						      s->stack_base);
+				}
+
+				script_abort_flag = 0;
+
+			} else
+				game_is_finished = 1;
+		}
+	} while (!game_is_finished);
+
+	return s;
+}
+
+int objinfo(state_t *s, reg_t pos);
+
+int
+game_run(state_t **_s)
+{
+	state_t *s = *_s;
+
+	sciprintf(" Calling %s::play()\n", s->game_name);
+	_init_stack_base_with_selector(s, s->selector_map.play); /* Call the play selector */
+	
+
+	/* Now: Register the first element on the execution stack- */
+	if (!send_selector(s, s->game_obj, s->game_obj,
+			   s->stack_base, 2,
+			   s->stack_base) || script_error_flag) {
+		objinfo(s, s->game_obj);
+		sciprintf("Failed to run the game! Aborting...\n");
+		return 1;
+	}
+	/* and ENGAGE! */
+	*_s = s = _game_run(s, 0);
+
+	sciprintf(" Game::play() finished.\n");
+	return 0;
+}
+
+int
+game_restore(state_t **_s, char *game_name)
+{
+	state_t *s;
+	int debug_state = _debugstate_valid;
+
+	sciprintf("Restoring savegame '%s'...\n", game_name);
+	s = gamestate_restore(*_s, game_name);
+
+	if (!s) {
+		sciprintf("Restoring gamestate '%s' failed.\n", game_name);
+		return 1;
+	}
+	_debugstate_valid = debug_state;
+	script_abort_flag = 0;
+	s->restarting_flags = 0;
+
+	s->execution_stack_pos = -1; /* Resatart with replay */
+					
+	_init_stack_base_with_selector(s, s->selector_map.replay);
+	/* Call the replay selector */
+
+	send_selector(s, s->game_obj, s->game_obj,
+		      s->stack_base, 2,
+		      s->stack_base);
+
+	*_s = s = _game_run(s, 1);
+
+	sciprintf(" Game::play() finished.\n");
+	return 0;
+}
+
+
+object_t *
+obj_get(state_t *s, reg_t offset)
+{
+	mem_obj_t *memobj = GET_OBJECT_SEGMENT(s->seg_manager, offset.segment);
+	object_t *obj = NULL;
+	int idx;
+
+	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);
+		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)) {
+				idx = RAW_GET_CLASS_INDEX(&(memobj->data.script), offset);
+				if (idx >= 0 && idx < memobj->data.script.objects_nr)
+					obj = memobj->data.script.objects + idx;
+			}
+		}
+	}
+
+	return obj;
+}
+
+const char *
+obj_get_name(struct _state *s, reg_t pos)
+{
+	object_t *obj = obj_get(s, pos);
+
+	if (!obj)
+		return "<no such object>";
+
+	return
+		(const char*)(obj->base + obj->variables[SCRIPT_NAME_SELECTOR].offset);
+}
+
+
+void
+quit_vm()
+{
+	script_abort_flag = 1; /* Terminate VM */
+	_debugstate_valid = 0;
+	_debug_seeking = 0;
+	_debug_step_running = 0;
+}
+
+