/***************************************************************************
 scidisasm.c Copyright (C) 1999 Christoph Reichenbach, TU Darmstadt


 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:

    Dmitry Jemerov (DJ) [yole@spb.cityline.ru]

 History:

   991213 - created (DJ)

***************************************************************************/

#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);
}