path: root/devtools/sci/scidisasm.cpp

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif /* HAVE_CONFIG_H */

#define MALLOC_DEBUG

#include <sciresource.h>
#include <engine.h>
#include <console.h>
#include <versions.h>

#ifdef HAVE_GETOPT_H
#include <getopt.h>
#endif /* HAVE_GETOPT_H */

static int hexdump = 0;
static int opcode_size = 0;
static int verbose = 0;

static resource_mgr_t *resmgr;

#ifdef HAVE_GETOPT_LONG
static struct option options[] = {
	{"version", no_argument, 0, 256},
	{"help", no_argument, 0, 'h'},
	{"hexdump", no_argument, &hexdump, 1},
	{"opcode-size", no_argument, &opcode_size, 1},
	{"verbose", no_argument, &verbose, 1},
	{"gamedir", required_argument, 0, 'd'},
	{0, 0, 0, 0}
};
#endif /* HAVE_GETOPT_LONG */

#define SCI_ASSUME_VERSION SCI_VERSION_FTU_NEW_SCRIPT_HEADER

typedef struct name_s {
	int offset;
	char *name;
	int class_no;
	struct name_s *next;
} name_t;

typedef struct area_s {
	int start_offset;
	int end_offset;
	void *data;
	struct area_s *next;
} area_t;

enum area_type { area_said, area_string, area_object, area_last };

typedef struct script_state_s {
	int script_no;
	name_t *names;
	area_t *areas [area_last];

	struct script_state_s *next;
} script_state_t;

typedef struct disasm_state_s {
	char **snames;
	int selector_count;
	opcode *opcodes;
	int kernel_names_nr;
	char **kernel_names;
	word_t **words;
	int word_count;

	char **class_names;
	int *class_selector_count;
	short **class_selectors;
	int class_count;
	int old_header;

	script_state_t *scripts;
} disasm_state_t;

void
disassemble_script(disasm_state_t *d, int res_no, int pass_no);

script_state_t *
find_script_state(disasm_state_t *d, int script_no);

void
script_free_names(script_state_t *s);

void
script_add_name(script_state_t *s, int aoffset, char *aname, int aclass_no);

char *
script_find_name(script_state_t *s, int offset, int *class_no);

void
script_add_area(script_state_t *s, int start_offset, int end_offset, int type, void *data);

void
script_free_areas(script_state_t *s);

int
script_get_area_type(script_state_t *s, int offset, void **pdata);

void
disasm_init(disasm_state_t *d);

void
disasm_free_state(disasm_state_t *d);

int main(int argc, char** argv) {
	int i;
	char outfilename [256];
	int optindex = 0;
	int c;
	disasm_state_t disasm_state;
	char *gamedir = NULL;
	int res_version = SCI_VERSION_AUTODETECT;

#ifdef HAVE_GETOPT_LONG
	while ((c = getopt_long(argc, argv, "vhxr:d:", options, &optindex)) > -1) {
#else /* !HAVE_GETOPT_H */
	while ((c = getopt(argc, argv, "vhxr:d:")) > -1) {
#endif /* !HAVE_GETOPT_H */

		switch (c) {
		case 256:
			printf("scidisasm ("PACKAGE") "VERSION"\n");
			printf("This program is copyright (C) 1999 Christoph Reichenbach.\n"
			       "It comes WITHOUT WARRANTY of any kind.\n"
			       "This is free software, released under the GNU General Public License.\n");
			exit(0);

		case 'h':
			printf("Usage: scidisasm\n"
			       "\nAvailable options:\n"
			       " --version               Prints the version number\n"
			       " --help        -h        Displays this help message\n"
			       " --gamedir <dir> -d<dir> Read game resources from dir\n"
			       " --hexdump     -x        Hex dump all script resources\n"
			       " --verbose               Print additional disassembly information\n"
			       " --opcode-size           Print opcode size postfixes\n");
			exit(0);

		case 'd':
			if (gamedir) sci_free(gamedir);
			gamedir = sci_strdup(optarg);
			break;

		case 'r':
			res_version = atoi(optarg);
			break;

		case 0: /* getopt_long already did this for us */
		case '?':
			/* getopt_long already printed an error message. */
			break;

		default:
			return -1;
		}
	}

	if (gamedir)
		if (chdir(gamedir)) {
			printf("Error changing to game directory '%s'\n", gamedir);
			exit(1);
		}

	printf("Loading resources...\n");
	if (!(resmgr = scir_new_resource_manager(sci_getcwd(), res_version,
	               1, 1024 * 128))) {
		fprintf(stderr, "Could not find any resources; quitting.\n");
		exit(1);
	}

	disasm_init(&disasm_state);

	script_adjust_opcode_formats(resmgr->sci_version);

	printf("Performing first pass...\n");
	for (i = 0; i < resmgr->resources_nr; i++)
		if (resmgr->resources[i].type == sci_script)
			disassemble_script(&disasm_state,
			                   resmgr->resources[i].number, 1);

	printf("Performing second pass...\n");
	for (i = 0; i < resmgr->resources_nr; i++)
		if (resmgr->resources[i].type == sci_script) {
			sprintf(outfilename, "%03d.script",
			        resmgr->resources[i].number);
			open_console_file(outfilename);
			disassemble_script(&disasm_state,
			                   resmgr->resources[i].number, 2);
		}

	close_console_file();
	disasm_free_state(&disasm_state);

	free(resmgr->resource_path);
	scir_free_resource_manager(resmgr);
	return 0;
}

/* -- General operations on disasm_state_t -------------------------------  */

void
disasm_init(disasm_state_t *d) {
	d->snames = vocabulary_get_snames(resmgr, &d->selector_count, SCI_ASSUME_VERSION);
	d->opcodes = vocabulary_get_opcodes(resmgr);
	d->kernel_names = vocabulary_get_knames(resmgr, &d->kernel_names_nr);
	d->words = vocab_get_words(resmgr, &d->word_count);
	d->scripts = NULL;
	d->old_header = 0;

	d->class_count = vocabulary_get_class_count(resmgr);
	d->class_names = (char **) sci_malloc(d->class_count * sizeof(char *));
	memset(d->class_names, 0, d->class_count * sizeof(char *));
	d->class_selector_count = (int *) sci_malloc(d->class_count * sizeof(int));
	memset(d->class_selector_count, 0, d->class_count * sizeof(int));
	d->class_selectors = (short **) sci_malloc(d->class_count * sizeof(short *));
	memset(d->class_selectors, 0, d->class_count * sizeof(short *));
}

void
disasm_free_state(disasm_state_t *d) {
	script_state_t *s, *next_script;
	int i;

	s = d->scripts;
	while (s) {
		next_script = s->next;
		script_free_names(s);
		script_free_areas(s);
		s = next_script;
	}

	for (i = 0; i < d->class_count; i++) {
		if (d->class_names [i]) sci_free(d->class_names [i]);
		if (d->class_selectors [i]) sci_free(d->class_selectors [i]);
	}

	free(d->class_names);
	free(d->class_selectors);
	free(d->class_selector_count);

	vocabulary_free_snames(d->snames);
	vocabulary_free_opcodes(d->opcodes);
	vocabulary_free_knames(d->kernel_names);
	vocab_free_words(d->words, d->word_count);
}

script_state_t *
find_script_state(disasm_state_t *d, int script_no) {
	script_state_t *s;

	for (s = d->scripts; s; s = s->next)
		if (s->script_no == script_no) return s;

	s = (script_state_t *) sci_malloc(sizeof(script_state_t));
	memset(s, 0, sizeof(script_state_t));
	s->script_no = script_no;
	s->next = d->scripts;

	d->scripts = s;
	return s;
}

/* -- Name table operations ----------------------------------------------  */

void
script_free_names(script_state_t *s) {
	name_t *p = s->names, *next_name;

	while (p) {
		next_name = p->next;
		free(p->name);
		free(p);
		p = next_name;
	}

	s->names = NULL;
}

void
script_add_name(script_state_t *s, int aoffset, char *aname, int aclass_no) {
	name_t *p;
	char *name = script_find_name(s, aoffset, NULL);
	if (name) return;

	p = (name_t *) sci_malloc(sizeof(name_t));
	p->offset = aoffset;
	p->name = sci_strdup(aname);
	p->class_no = aclass_no;
	p->next = s->names;
	s->names = p;
}

char *
script_find_name(script_state_t *s, int offset, int *aclass_no) {
	name_t *p;

	for (p = s->names; p; p = p->next)
		if (p->offset == offset) {
			if (aclass_no && p->class_no != -2) *aclass_no = p->class_no;
			return p->name;
		}

	return NULL;
}

/* -- Area table operations ----------------------------------------------  */

void
script_add_area(script_state_t *s, int start_offset, int end_offset, int type, void *data) {
	area_t *area;

	area = (area_t *) sci_malloc(sizeof(area_t));
	area->start_offset = start_offset;
	area->end_offset = end_offset;
	area->data = data;
	area->next = s->areas [type];

	s->areas [type] = area;
}

void
script_free_areas(script_state_t *s) {
	int i;

	for (i = 0; i < area_last; i++) {
		area_t *area = s->areas [i], *next_area;
		while (area) {
			next_area = area->next;
			free(area);
			area = next_area;
		}
	}
}

int
script_get_area_type(script_state_t *s, int offset, void **pdata) {
	int i;

	for (i = 0; i < area_last; i++) {
		area_t *area = s->areas [i];
		while (area) {
			if (area->start_offset <= offset && area->end_offset >= offset)     {
				if (pdata != NULL) *pdata = area->data;
				return i;
			}
			area = area->next;
		}
	}

	return -1;
}

char *
get_selector_name(disasm_state_t *d, int selector) {
	static char selector_name [256];

	if (d->snames && selector >= 0 && selector < d->selector_count)
		return d->snames [selector];
	else {
		sprintf(selector_name, "unknown_sel_%X", selector);
		return selector_name;
	}
}

const char *
get_class_name(disasm_state_t *d, int class_no) {
	static char class_name [256];

	if (class_no == -1)
		return "<none>";
	else if (class_no >= 0 && class_no < d->class_count && d->class_names [class_no])
		return d->class_names [class_no];
	else {
		sprintf(class_name, "class_%d", class_no);
		return class_name;
	}
}

/* -- Code to dump individual script block types -------------------------  */

static void
script_dump_object(disasm_state_t *d, script_state_t *s,
                   unsigned char *data, int seeker, int objsize, int pass_no) {
	int selectors, overloads, selectorsize;
	int species = getInt16(data + 8 + seeker);
	int superclass = getInt16(data + 10 + seeker);
	int namepos = getInt16(data + 14 + seeker);
	int i = 0;
	short sel;
	const char *name;
	char buf [256];
	short *sels;

	selectors = (selectorsize = getInt16(data + seeker + 6));
	name = namepos ? ((const char *)data + namepos) : "<unknown>";

	if (pass_no == 1)
		script_add_area(s, seeker, seeker + objsize - 1, area_object, strdup(name));

	if (pass_no == 2) {
		sciprintf(".object\n");
		sciprintf("Name: %s\n", name);
		sciprintf("Superclass: %s  [%x]\n", get_class_name(d, superclass), superclass);
		sciprintf("Species: %s  [%x]\n", get_class_name(d, species), species);

		sciprintf("-info-:%x\n", getInt16(data + 12 + seeker) & 0xffff);

		sciprintf("Function area offset: %x\n", getInt16(data + seeker + 4));
		sciprintf("Selectors [%x]:\n", selectors);
	}

	seeker += 8;

	if (species < d->class_count)
		sels = d->class_selectors [species];
	else
		sels = NULL;

	while (selectors--) {
		if (pass_no == 2) {
			sel = getInt16(data + seeker) & 0xffff;
			if (sels && (sels [i] >= 0) && (sels[i] < d->selector_count)) {
				sciprintf("  [#%03x] %s = 0x%x\n", i, d->snames [sels [i]], sel);
				i++;
			} else
				sciprintf("  [#%03x] <unknown> = 0x%x\n", i++, sel);
		}

		seeker += 2;
	}

	selectors = overloads = getInt16(data + seeker);

	if (pass_no == 2)
		sciprintf("Overloaded functions: %x\n", overloads);

	seeker += 2;

	while (overloads--) {
		word selector = getInt16(data + (seeker)) & 0xffff;
		if (d->old_header) selector >>= 1;

		if (pass_no == 1) {
			sprintf(buf, "%s::%s", name, get_selector_name(d, selector));
			script_add_name(s, getInt16(data + seeker + selectors*2 + 2), buf, species);
		} else {
			sciprintf("  [%03x] %s: @", selector, get_selector_name(d, selector));
			sciprintf("%04x\n", getInt16(data + seeker + selectors*2 + 2));
		}

		seeker += 2;
	}
}

static void
script_dump_class(disasm_state_t *d, script_state_t *s,
                  unsigned char *data, int seeker, int objsize, int pass_no) {
	word selectors, overloads, selectorsize;
	int species = getInt16(data + 8 + seeker);
	int superclass = getInt16(data + 10 + seeker);
	int namepos = getInt16(data + 14 + seeker);
	const char *name;
	char buf [256];
	int i;

	name = namepos ? ((const char *)data + namepos) : "<unknown>";
	selectors = (selectorsize = getInt16(data + seeker + 6));

	if (pass_no == 1) {
		if (species >= 0 && species < d->class_count) {
			if (!namepos) {
				sprintf(buf, "class_%d", species);
				d->class_names [species] = sci_strdup(buf);
			} else
				d->class_names [species] = sci_strdup(name);

			d->class_selector_count [species] = selectors;
			d->class_selectors [species] = (short *) sci_malloc(sizeof(short) * selectors);
		}
	}

	if (pass_no == 2) {
		sciprintf(".class\n");
		sciprintf("Name: %s\n", name);
		sciprintf("Superclass: %s  [%x]\n", get_class_name(d, superclass), superclass);
		sciprintf("Species: %x\n", species);
		sciprintf("-info-:%x\n", getInt16(data + 12 + seeker) & 0xffff);

		sciprintf("Function area offset: %x\n", getInt16(data + seeker + 4));
		sciprintf("Selectors [%x]:\n", selectors);
	}

	seeker += 8;
	selectorsize <<= 1;

	for (i = 0; i < selectors; i++) {
		word selector = 0xffff & getInt16(data + (seeker) + selectorsize);
		if (d->old_header) selector >>= 1;

		if (pass_no == 1) {
			if (species >= 0 && species < d->class_count)
				d->class_selectors [species][i] = selector;
		} else
			sciprintf("  [%03x] %s = 0x%x\n", selector, get_selector_name(d, selector),
			          getInt16(data + seeker) & 0xffff);

		seeker += 2;
	}

	seeker += selectorsize;

	selectors = overloads = getInt16(data + seeker);

	sciprintf("Overloaded functions: %x\n", overloads);

	seeker += 2;

	while (overloads--) {
		word selector = getInt16(data + (seeker)) & 0xffff;
		if (d->old_header) selector >>= 1;

		if (pass_no == 1) {
			sprintf(buf, "%s::%s", name, get_selector_name(d, selector));
			script_add_name(s, getInt16(data + seeker + selectors*2 + 2) & 0xffff, buf, species);
		} else {
			sciprintf("  [%03x] %s: @", selector & 0xffff, get_selector_name(d, selector));
			sciprintf("%04x\n", getInt16(data + seeker + selectors*2 + 2) & 0xffff);
		}

		seeker += 2;
	}
}

static int
script_dump_said_string(disasm_state_t *d, unsigned char *data, int seeker) {
	while (1) {
		unsigned short nextitem = (unsigned char) data [seeker++];
		if (nextitem == 0xFF) return seeker;

		if (nextitem >= 0xF0) {
			switch (nextitem) {
			case 0xf0:
				sciprintf(", ");
				break;
			case 0xf1:
				sciprintf("& ");
				break;
			case 0xf2:
				sciprintf("/ ");
				break;
			case 0xf3:
				sciprintf("( ");
				break;
			case 0xf4:
				sciprintf(") ");
				break;
			case 0xf5:
				sciprintf("[ ");
				break;
			case 0xf6:
				sciprintf("] ");
				break;
			case 0xf7:
				sciprintf("# ");
				break;
			case 0xf8:
				sciprintf("< ");
				break;
			case 0xf9:
				sciprintf("> ");
				break;
			}
		} else {
			nextitem = nextitem << 8 | (unsigned char) data [seeker++];
			sciprintf("%s ", vocab_get_any_group_word(nextitem, d->words, d->word_count));
			if (verbose)
				sciprintf("[%03x] ", nextitem);
		}
	}
}

static void
script_dump_said(disasm_state_t *d, script_state_t *s,
                 unsigned char *data, int seeker, int objsize, int pass_no) {
	int _seeker = seeker + objsize - 4;

	if (pass_no == 1) {
		script_add_area(s, seeker, seeker + objsize - 1, area_said, NULL);
		return;
	}

	sciprintf(".said\n");

	while (seeker < _seeker - 1) {
		sciprintf("%04x: ", seeker);
		seeker = script_dump_said_string(d, data, seeker);
		sciprintf("\n");
	}
}

static void
script_dump_synonyms(disasm_state_t *d, script_state_t *s,
                     unsigned char *data, int seeker, int objsize, int pass_no) {
	int _seeker = seeker + objsize - 4;

	sciprintf("Synonyms:\n");
	while (seeker < _seeker) {
		int search = getInt16(data + seeker);
		int replace = getInt16(data + seeker + 2);
		seeker += 4;
		if (search < 0) break;
		sciprintf("%s[%03x] ==> %s[%03x]\n",
		          vocab_get_any_group_word(search, d->words, d->word_count), search,
		          vocab_get_any_group_word(replace, d->words, d->word_count), replace);
	}
}

static void
script_dump_strings(disasm_state_t *d, script_state_t *s,
                    unsigned char *data, int seeker, int objsize, int pass_no) {
	int endptr = seeker + objsize - 4;

	if (pass_no == 1) {
		script_add_area(s, seeker, seeker + objsize - 1, area_string, NULL);
		return;
	}

	sciprintf(".strings\n");
	while (data [seeker] && seeker < endptr) {
		sciprintf("%04x: %s\n", seeker, data + seeker);
		seeker += strlen((char *) data + seeker) + 1;
	}
}

static void
script_dump_exports(disasm_state_t *d, script_state_t *s,
                    unsigned char *data, int seeker, int objsize, int pass_no) {
	byte *pexport = (byte *)(data + seeker);
	word export_count = getUInt16(pexport);
	int i;
	char buf [256];

	pexport += 2;

	if (pass_no == 2) sciprintf(".exports\n");

	for (i = 0; i < export_count; i++) {
		if (pass_no == 1) {
			guint16 offset = getUInt16(pexport);
			sprintf(buf, "exp_%02X", i);
			script_add_name(s, offset, buf, -1);
		} else
			sciprintf("%02X: %04X\n", i, *pexport);
		pexport += 2;
	}
}

/* -- The disassembly code -----------------------------------------------  */

static void
script_disassemble_code(disasm_state_t *d, script_state_t *s,
                        unsigned char *data, int seeker, int objsize, int pass_no) {
	int endptr = seeker + objsize - 4;
	int i = 0;
	int cur_class = -1;
	word dest;
	void *area_data;
	char buf [256];
	char *dest_name;

	if (pass_no == 2) sciprintf(".code\n");

	while (seeker < endptr - 1) {
		unsigned char opsize = data [seeker];
		unsigned char opcode = opsize >> 1;
		word param_value;
		char *name;

		opsize &= 1; /* byte if true, word if false */

		if (pass_no == 2) {
			name = script_find_name(s, seeker, &cur_class);
			if (name) sciprintf("      %s:\n", name);
			sciprintf("%04X: ", seeker);
			sciprintf("%s", d->opcodes[opcode].name);
			if (opcode_size && formats[opcode][0])
				sciprintf(".%c", opsize ? 'b' : 'w');
			sciprintf("\t");
		}

		seeker++;

		for (i = 0; formats[opcode][i]; i++)

			switch (formats[opcode][i]) {

			case Script_Invalid:
				if (pass_no == 2) sciprintf("-Invalid operation-");
				break;

			case Script_SByte:
			case Script_Byte:
				if (pass_no == 2) sciprintf(" %02x", data[seeker]);
				seeker++;
				break;

			case Script_Word:
			case Script_SWord:
				if (pass_no == 2)
					sciprintf(" %04x", 0xffff & (data[seeker] | (data[seeker+1] << 8)));
				seeker += 2;
				break;

			case Script_SVariable:
			case Script_Variable:
			case Script_Global:
			case Script_Local:
			case Script_Temp:
			case Script_Param:
			case Script_SRelative:
			case Script_Property:
			case Script_Offset:
				if (opsize)
					param_value = data [seeker++];
				else {
					param_value = 0xffff & (data[seeker] | (data[seeker+1] << 8));
					seeker += 2;
				}

				if (pass_no == 1) {
					if (opcode == op_jmp || opcode == op_bt || opcode == op_bnt)					{
						dest = seeker + (short) param_value;
						sprintf(buf, "lbl_%04X", dest);
						script_add_name(s, dest, buf, -2);
					}
				} else if (pass_no == 2)
					switch (formats[opcode][i]) {

					case Script_SVariable:
					case Script_Variable:
						if (opcode == op_callk) {
							sciprintf(" #%s", (param_value < d->kernel_names_nr)
							          ? d->kernel_names[param_value] : "<invalid>");
							if (verbose) sciprintf("[%x]", param_value);
						} else if (opcode == op_class || (opcode == op_super && i == 0))           {
							sciprintf(" %s", (d->class_names && param_value < d->class_count)
							          ? d->class_names[param_value] : "<invalid>");
							if (verbose) sciprintf("[%x]", param_value);
						} else sciprintf(opsize ? " %02x" : " %04x", param_value);

						if (opcode == op_pushi && param_value > 0 && param_value < d->selector_count)
							sciprintf("\t\t; selector <%s>", d->snames [param_value]);

						break;

					case Script_Global:
						sciprintf(" global_%d", param_value);
						break;

					case Script_Local:
						sciprintf(" local_%d", param_value);
						break;

					case Script_Temp:
						sciprintf(" temp_%d", param_value);
						break;

					case Script_Param:
						sciprintf(" param_%d", param_value);
						break;

					case Script_Offset:
						dest = (short) param_value;
						dest_name = script_find_name(s, dest, NULL);
						if (dest_name)
							sciprintf(" %s", dest_name);
						else
							sciprintf(" %04x", dest);

						if (verbose)
							sciprintf(opsize ? "   [%02x] " : "   [%04x] ", param_value);

						if (opcode == op_lofsa || opcode == op_lofss) {
							int atype = script_get_area_type(s, dest, &area_data);
							if (atype == area_string) {
								strncpy(buf, (char *) &data [dest], sizeof(buf) - 1);
								buf [sizeof(buf)-1] = 0;
								if (strlen(buf) > 40) {
									buf [40] = 0;
									strcat(buf, "...");
								}
								sciprintf("\t\t; \"%s\"", buf);
							} else if (atype == area_said) {
								sciprintf("\t\t; said \"");
								script_dump_said_string(d, data, dest);
								sciprintf("\"\n");
							} else if (atype == area_object)
								sciprintf("\t\t; object <%s>", area_data);
						}
						break;

					case Script_SRelative:
						dest = seeker + (short) param_value;
						dest_name = script_find_name(s, dest, NULL);
						if (dest_name)
							sciprintf(" %s", dest_name);
						else
							sciprintf(" %04x", dest);

						if (verbose)
							sciprintf(opsize ? "   [%02x] " : "   [%04x] ", param_value);

						if (opcode == op_lofsa || opcode == op_lofss) {
							int atype = script_get_area_type(s, dest, &area_data);
							if (atype == area_string) {
								strncpy(buf, (char *) &data [dest], sizeof(buf) - 1);
								buf [sizeof(buf)-1] = 0;
								if (strlen(buf) > 40) {
									buf [40] = 0;
									strcat(buf, "...");
								}
								sciprintf("\t\t; \"%s\"", buf);
							} else if (atype == area_said) {
								sciprintf("\t\t; said \"");
								script_dump_said_string(d, data, dest);
								sciprintf("\"\n");
							} else if (atype == area_object)
								sciprintf("\t\t; object <%s>", area_data);
						}
						break;

					case Script_Property:
						if (cur_class != -1 && param_value / 2 < d->class_selector_count [cur_class]) {
							sciprintf(" %s", get_selector_name(d, d->class_selectors [cur_class][param_value/2]));
							if (verbose) sciprintf("[%x]", param_value);
						} else
							sciprintf(opsize ? " %02x" : " %04x", param_value);

						break;

					case Script_End:
						if (pass_no == 2) sciprintf("\n");
						break;

					default:
						sciprintf("Unexpected opcode format %d\n", (formats[opcode][i]));
					}

			default:
				break;
			}
		if (pass_no == 2) sciprintf("\n");

	}

}

void
disassemble_script_pass(disasm_state_t *d, script_state_t *s,
                        resource_t *script, int pass_no) {
	int _seeker = 0;
	word id = getInt16(script->data);

	if (id > 15) {
		if (pass_no == 2) sciprintf("; Old script header detected\n");
		d->old_header = 1;
	}

	if (d->old_header) _seeker = 2;

	while (_seeker < script->size) {
		int objtype = getInt16(script->data + _seeker);
		int objsize;
		int seeker = _seeker + 4;

		if (!objtype) return;

		if (pass_no == 2)
			sciprintf("\n");

		objsize = getInt16(script->data + _seeker + 2);

		if (pass_no == 2) {
			sciprintf("; Obj type #%x, offset 0x%x, size 0x%x:\n", objtype, _seeker, objsize);
			if (hexdump) sci_hexdump(script->data + seeker, objsize - 4, seeker);
		}

		_seeker += objsize;

		switch (objtype) {
		case sci_obj_object:
			script_dump_object(d, s, script->data, seeker, objsize, pass_no);
			break;

		case sci_obj_code:
			script_disassemble_code(d, s, script->data, seeker, objsize, pass_no);
			break;

		case sci_obj_synonyms:
			script_dump_synonyms(d, s, script->data, seeker, objsize, pass_no);
			break;

		case sci_obj_said:
			script_dump_said(d, s, script->data, seeker, objsize, pass_no);
			break;

		case sci_obj_strings:
			script_dump_strings(d, s, script->data, seeker, objsize, pass_no);
			break;

		case sci_obj_class:
			script_dump_class(d, s, script->data, seeker, objsize, pass_no);
			break;

		case sci_obj_exports:
			script_dump_exports(d, s, script->data, seeker, objsize, pass_no);
			break;

		case sci_obj_pointers:
			if (pass_no == 2) {
				sciprintf("Pointers\n");
				sci_hexdump(script->data + seeker, objsize - 4, seeker);
			};
			break;

		case sci_obj_preload_text:
			if (pass_no == 2) {
				sciprintf("The script has a preloaded text resource\n");
			};
			break;

		case sci_obj_localvars:
			if (pass_no == 2) {
				sciprintf("Local vars\n");
				sci_hexdump(script->data + seeker, objsize - 4, seeker);
			};
			break;

		default:
			sciprintf("Unsupported %d!\n", objtype);
			return;
		}
	}

	sciprintf("Script ends without terminator\n");
}

void
disassemble_script(disasm_state_t *d, int res_no, int pass_no) {
	resource_t *script = scir_find_resource(resmgr, sci_script, res_no, 0);
	script_state_t *s = find_script_state(d, res_no);

	if (!script) {
		sciprintf("Script not found!\n");
		return;
	}

	disassemble_script_pass(d, s, script, pass_no);
}