implement JScript;

include "common.m";
include "ecmascript.m";

ES: Ecmascript;
	Exec, Obj, Call, Prop, Val, Ref, RefVal, Builtin, ReadOnly: import ES;
me: ESHostobj;

# local copies from CU
sys: Sys;
CU: CharonUtils;

D: Draw;
S: String;
T: StringIntTab;
C: Ctype;
B: Build;
	Item: import B;
CH: Charon;
L: Layout;
	Frame: import L;
U: Url;
	ParsedUrl: import U;
E: Events;
	Event, ScriptEvent: import E;

JScript: module
{
	# First, conform to Script interface
	defaultStatus: string;
	jevchan: chan of ref ScriptEvent;

	init: fn(cu: CharonUtils);
	frametreechanged: fn(top: ref Layout->Frame);
	havenewdoc: fn(f: ref Layout->Frame);
	evalscript: fn(f: ref Layout->Frame, s: string, donebuild: int) : (string, string);

	#
	# implement the host object interface, too
	#
	get:		fn(ex: ref Exec, o: ref Obj, property: string): ref Val;
	put:		fn(ex: ref Exec, o: ref Obj, property: string, val: ref Val);
	canput:	fn(ex: ref Exec, o: ref Obj, property: string): ref Val;
	hasproperty:	fn(ex: ref Exec, o: ref Obj, property: string): ref Val;
	delete:		fn(ex: ref Exec, o: ref Obj, property: string);
	defaultval:	fn(ex: ref Exec, o: ref Obj, tyhint: int): ref Val;
	call:		fn(ex: ref Exec, func, this: ref Obj, args: array of ref Val): ref Ref;
	construct:	fn(ex: ref Exec, func: ref Obj, args: array of ref Val): ref Obj;
};

# Call init() before calling anything else.
# It makes a global object (a Window) for the browser's top level frame,
# and also puts a navaigator object in it.  The document can't be filled
# in until the first document gets loaded.
#
# This module keeps track of the correspondence between the Script Window
# objects and the corresponding Layout Frames, using the ScriptWin adt to
# build a tree mirroring the structure.  The root of the tree never changes
# after first being set (but changing its document essentially resets all of the
# other data structures).  After charon has built its top-level window, it
# should call frametreechanged(top).
#
# When a frame gets reset or gets some frame children added, call frametreechanged(f),
# where f is the changed frame.  This module will update its ScriptWin tree as needed.
#
# Whenever the document in a (Layout) Frame f changes, call havenewdoc(f)
# after the frame's doc field is set. This causes this module to initialize the document
# object in the corresponding window object.
#
# From within the build process, call evalscript(containing frame, script) to evaluate
# global code fragments as needed.  The return value is two strings: a possible error
# description, and HTML that is the result of a document.write (so it should be spliced
# in at the point where the <SCRIPT> element occurred).  evalscript() also handles
# the job of synching up the Docinfo data (on the Build side) with the document object
# (on the Script side).
#
# For use by other external routines, the xfertoscriptobjs() and xferfromscriptobjs()
# functions that do the just-described synch-up are available for external callers.

# Adt for keeping track of correspondence between Image objects
# and their corresponding Build items.
ScriptImg: adt
{
	item: ref Build->Item.Iimage;
	obj: ref Obj;
};

# Adt for keeping track of correspondence between Window
# objects and their corresponding Frames.

ScriptWin: adt
{
	frame: ref Layout->Frame;
	ex: ref Exec;		# ex.global is frame's Window obj
	locobj: ref Obj;	# Location object for window
	val : ref Val;		# val of ex.global - used to side-effect entry in parent.frames[]

	parent: ref ScriptWin;
	kids: cyclic list of ref ScriptWin;
	imgs: list of ref ScriptImg;
	newloc: string;		# url to go to after script finishes executing
	newloctarg: string;	# target frame for newloc
	inbuild: int;

	new: fn(f: ref Layout->Frame, ex: ref Exec, loc: ref Obj, par: ref ScriptWin) : ref ScriptWin;
	addkid: fn(sw: self ref ScriptWin, f: ref Layout->Frame);
	findbyframe: fn(sw: self ref ScriptWin, f: ref Layout->Frame) : ref ScriptWin;
	findbyframeid: fn(sw: self ref ScriptWin, fid: int) : ref ScriptWin;
	findbydoc: fn(sw: self ref ScriptWin, d: ref Build->Docinfo) : ref ScriptWin;
	findbyobj: fn(sw : self ref ScriptWin, obj : ref Obj) : ref ScriptWin;
};


# Helper adts for initializing objects.
# Methods go in prototype, properties go in objects

MethSpec: adt
{
	name: string;
	args: array of string;
};


IVundef, IVnull, IVtrue, IVfalse, IVnullstr, IVzero, IVzerostr, IVarray: con iota;

PropSpec: adt
{
	name: string;
	attr: int;
	initval: int;	# one of IVnull, etc.
};

ObjSpec: adt
{
	name: string;
	methods: array of MethSpec;
	props: array of PropSpec;
};

MimeSpec: adt
{
	description: string;
	suffixes: string;
	ty: string;
};

# Javascript 1.1 (Netscape 3) client objects

objspecs := array[] of {
    ObjSpec("Anchor", 
	nil,
	nil
	),
    ObjSpec("Applet",
	nil,
	nil
	),
    ObjSpec("document",
	array[] of {MethSpec
		("close", nil),
		("open", array[] of { "mimetype", "replace" }),
		("write", array[] of { "string" }),
		("writeln", array[] of { "string" }) },
	array[] of {PropSpec
		("alinkColor", 0, IVnullstr),
		("anchors", ReadOnly, IVarray),
		("applets", ReadOnly, IVarray),
		("bgColor", 0, IVnullstr),
		("cookie", 0, IVnullstr),
		("domain", 0, IVnullstr),
		("embeds", ReadOnly, IVarray),
		("fgColor", 0, IVnullstr),
		("forms", ReadOnly, IVarray),
		("images", ReadOnly, IVarray),
		("lastModified", ReadOnly, IVnullstr),
		("linkColor", 0, IVnullstr),
		("links", ReadOnly, IVarray),
		("plugins", ReadOnly, IVarray),
		("referrer", ReadOnly, IVnullstr),
		("title", ReadOnly, IVnullstr),
		("URL", ReadOnly, IVnullstr),
		("vlinkColor", 0, IVnullstr) }
	),
    ObjSpec("Form",
	array[] of {MethSpec
		("reset", nil),
		("submit", nil) },
	array[] of {PropSpec
		("action", 0, IVnullstr),
		("elements", ReadOnly, IVarray),
		("encoding", 0, IVnullstr),
		("length", ReadOnly, IVzero),
		("method", 0, IVnullstr),
		("name", 0, IVnullstr),
		("target", 0, IVnullstr) }
	),
   # This is merge of Netscape objects (to save code & data space):
   # Button, Checkbox, Hidden, Radio, Reset, Select, Text, and Textarea
    ObjSpec("FormField",
	array[] of {MethSpec
		("blur", nil),
		("click", nil),
		("focus", nil),
		("select", nil) },
	array[] of {PropSpec
		("checked", 0, IVundef),
		("defaultChecked", 0, IVundef),
		("defaultValue", 0, IVundef),
		("form", ReadOnly, IVundef),
		("length", 0, IVundef),
		("name", 0, IVnullstr),
		("options", 0, IVundef),
		("type", ReadOnly, IVundef),
		("selectedIndex", 0, IVundef),
		("value", 0, IVnullstr) }
	),
    ObjSpec("History",
	array[] of {MethSpec
		("back", nil),
		("forward", nil),
		("go", array[] of { "location-or-delta" }) },
	array[] of {PropSpec
		("current", ReadOnly, IVnullstr),
		("length", ReadOnly, IVzero),
		("next", ReadOnly, IVnullstr),
		("previous", ReadOnly, IVnullstr) }
	),
    ObjSpec("Image",
	nil,
	array[] of {PropSpec
		("border", ReadOnly, IVzerostr),
		("complete", ReadOnly, IVfalse),
		("height", ReadOnly, IVzerostr),
		("hspace", ReadOnly, IVzerostr),
		("lowsrc", 0, IVnullstr),
		("name", ReadOnly, IVnullstr),
		("src", 0, IVnullstr),
		("vspace", ReadOnly, IVzerostr),
		("width", ReadOnly, IVzerostr) }
	),
    ObjSpec("Link",
	nil,
	array[] of {PropSpec
		("hash", 0, IVnullstr),
		("host", 0, IVnullstr),
		("hostname", 0, IVnullstr),
		("href", 0, IVnullstr),
		("pathname", 0, IVnullstr),
		("port", 0, IVnullstr),
		("protocol", 0, IVnullstr),
		("search", 0, IVnullstr),
		("target", 0, IVnullstr) }
	),
    ObjSpec("Location",
	array[] of {MethSpec
		("reload", array[] of { "forceGet" }),
		("replace", array[] of { "URL" }) },
	array[] of {PropSpec
		("hash", 0, IVnullstr),
		("host", 0, IVnullstr),
		("hostname", 0, IVnullstr),
		("href", 0, IVnullstr),
		("pathname", 0, IVnullstr),
		("port", 0, IVnullstr),
		("protocol", 0, IVnullstr),
		("search", 0, IVnullstr) }
	),
    ObjSpec("MimeType",
	nil,
	array[] of {PropSpec
		("description", ReadOnly, IVnullstr),
		("enabledPlugin", ReadOnly, IVnull),
		("suffixes", ReadOnly, IVnullstr),
		("type", ReadOnly, IVnullstr) }
	),
    ObjSpec("Option",
	nil,
	array[] of {PropSpec
		("defaultSelected", 0, IVfalse),
		("index", 0, IVundef),
		("selected", 0, IVfalse),
		("text", 0, IVnullstr),
		("value", 0, IVnullstr) }
	),
    ObjSpec("navigator",
	array[] of {MethSpec
		("javaEnabled", nil),
		("plugins.refresh", nil),
		("taintEnabled", nil) },
	array[] of {PropSpec
		("appCodeName", ReadOnly, IVnullstr),
		("appName", ReadOnly, IVnullstr),
		("appVersion", ReadOnly, IVnullstr),
		("mimeTypes", ReadOnly, IVarray),
		("platform", ReadOnly, IVnullstr),
		("plugins", ReadOnly, IVarray),
		("userAgent", ReadOnly, IVnullstr) }
	),
    ObjSpec("Plugin",
	nil,
	array[] of {PropSpec
		("description", 0, IVnullstr),
		("filename", 0, IVnullstr),
		("length", 0, IVzero),
		("name", 0, IVnullstr) }
	),
     ObjSpec("Window",
	array[] of {MethSpec
		("alert", array[] of { "msg" }),
		("blur", nil),
		("clearTimeout", array[] of { "timeoutid" }),
		("close", nil),
		("confirm", array[] of  { "msg" }),
		("focus", nil),
		("open", array[] of { "url", "winname", "winfeatures" }),
		("prompt", array[] of { "msg", "inputdflt" }),
		("scroll", array[] of { "x", "y"  }),
		("setTimeout", array[] of { "expr", "msec" }) },
	array[] of {PropSpec
		("closed", ReadOnly, IVfalse),
		("defaultStatus", 0, IVnullstr),
		("document", 0, IVnull),
		("frames", ReadOnly, IVnull),	# array, really
		("history", 0, IVnull),	# array, really
		("length", ReadOnly, IVzero),
		("location", 0, IVnullstr),
		("name", 0, IVnullstr),
		("opener", 0, IVnull),
		("parent", ReadOnly, IVnull),
		("self", ReadOnly, IVnull),
		("status", 0, IVnullstr),
		("top", ReadOnly, IVnull),
		("window", ReadOnly, IVnull) }
	)
};

# Currently supported charon mime types
mimespecs := array[] of {
    MimeSpec("HTML", 
	"htm,html",
	"text/html"
	),
    MimeSpec("Plain text", 
	"txt,text",
	"text/plain"
	),
   MimeSpec("Gif Image", 
	"gif",
	"image/gif"
	),
    MimeSpec("Jpeg Image", 
	"jpeg,jpg,jpe",
	"image/jpeg"
	),
    MimeSpec("X Bitmap Image", 
	"",
	"image/x-xbitmap"
	)
};

dbg : int;
top: ref ScriptWin;
docwriteout := "";
createdimages : list of ref Obj;
nullstrval: ref Val;
zeroval: ref Val;
zerostrval: ref Val;

# Call this after charon's main (top) frame has been built
init(cu: CharonUtils)
{
	CU = cu;
	sys = load Sys Sys->PATH;
	D = load Draw Draw->PATH;
	S = load String String->PATH;
	T = load StringIntTab StringIntTab->PATH;
	U = load Url Url->PATH;
	C = cu->C;
	B = cu->B;
	L = cu->L;
	E = cu->E;
	CH = cu->CH;
	dbg = int (CU->config).dbg['s'];
	ES = load Ecmascript Ecmascript->PATH;
	if(ES == nil)
		cu->raise(sys->sprint("EXInternal: couldn't load Ecmascript: %r"));
	exc := ref sys->Exception;
	if(sys->rescue("ecmascript*", exc) == sys->EXCEPTION) {
		if(dbg)
			sys->print("Unexpected error initializing ecmascript:  %s", exc.name);
		return;
	}
	ES->init();

	me = load ESHostobj SELF;
	if(me == nil)
		cu->raise(sys->sprint("EXInternal: can't load self as a ESHostobj: %r"));
	if(dbg > 1) {
		ES->debug['p'] = 1;	# print parsed code
		ES->debug['e'] = 1;	# prinv ops as they are executed
		if(dbg > 2)
			ES->debug['e'] = 2;
		ES->debug['v'] = 1;	# print value of expression statements
		ES->debug['r'] = 1;	# print and abort if runtime errors
	}
	
	# some constant values, for initialization
	nullstrval = ES->strval("");
	zeroval = ES->numval(0.);
	zerostrval = ES->strval("0");
	jevchan = chan of ref ScriptEvent;
	spawn jevhandler();
}

doneevent := ScriptEvent(-1,0,0,0,0,0,0,0,0,nil);

# Used to receive and act upon ScriptEvents from main charon thread.
# Want to queue the events up, so that the main thread doesn't have
# to wait, and spawn off a do_on, one at a time, so that they don't
# interfere with each other.
# When do_on is finished, it must send a copy of doneevent
# so that jevhandler knows it can spawn another do_on.
jevhandler()
{
	q := array[10] of ref ScriptEvent;
	qhead := 0;
	qtail := 0;
	spawnok := 1;
	for(;;) {
		jev := <- jevchan;
		if(jev.kind == -1)
			spawnok = 1;
		else
			q[qtail++] = jev;
		jev = nil;

		# remove next event to process, if ok to and there is one
		if(spawnok && qhead < qtail)
			jev = q[qhead++];

		# adjust queue to make sure there is room for next event
		if(qhead == qtail) {
			qhead = 0;
			qtail = 0;
		}
		if(qtail == len q) {
			if(qhead > 0) {
				q[0:] = q[qhead:qtail];
				qtail -= qhead;
				qhead = 0;
			}
			else {
				newq := array[len q + 10] of ref ScriptEvent;
				newq[0:] = q;
				q = newq;
			}
		}

		# process next event, if any
		if(jev != nil) {
			spawnok = 0;
			spawn do_on(jev);
		}
	}
}

# Create an execution context for the frame.
# The global object of the frame is the frame's Window object.
# Return the execution context and the Location object for the window.
makeframeex(f : ref Layout->Frame) : (ref Exec, ref Obj)
{
	winobj := mkhostobj(nil, "Window");
	ex := ES->mkexec(winobj);
	winobj.prototype = ex.objproto;
	winobj.prototype = mkprototype(ex, specindex("Window"));

	navobj := mknavobj(ex);
	ES->put(ex, winobj, "navigator", ES->objval(navobj));

	histobj := mkhostobj(ex, "History");
	(length, current, next, previous) := CH->histinfo();
	reinitprop(histobj, "current", ES->strval(current));
	reinitprop(histobj, "length", ES->numval(real length));
	reinitprop(histobj, "next", ES->strval(next));
	reinitprop(histobj, "previous", ES->strval(previous));
	ES->put(ex, winobj, "history", ES->objval(histobj));

	locobj := mkhostobj(ex, "Location");
	src : ref U->ParsedUrl;
	if (f.doc != nil && f.doc.src != nil) {
		src = f.doc.src;
		reinitprop(locobj, "hash", ES->strval("#" + src.frag));
		reinitprop(locobj, "host", ES->strval(src.host + ":" + src.port));
		reinitprop(locobj, "hostname", ES->strval(src.host));
		reinitprop(locobj, "href", ES->strval(src.tostring()));
		reinitprop(locobj, "pathname", ES->strval(src.path));
		reinitprop(locobj, "port", ES->strval(src.port));
		reinitprop(locobj, "protocol", ES->strval(U->schemes[src.scheme] + ":"));
		reinitprop(locobj, "search", ES->strval("?" + src.query));
	}
	ES->put(ex, winobj, "location", ES->objval(locobj));

	# make an Image constructor object
	improto := mkprototype(ex, specindex("Image"));
	o := ES->biinst(winobj, Builtin("Image", "Image", array[] of {"width", "height"}, 2),
			ex.funcproto, me);
	o.construct = o.call;

	defaultStatus = "";
	return (ex, locobj);
}

# make a navigator object
# currently, we've decided to emulate Netscape Version 3
mknavobj(ex: ref Exec) : ref Obj
{
	navobj := mkhostobj(ex, "navigator");
	reinitprop(navobj, "appCodeName", ES->strval("Mozilla"));
	reinitprop(navobj, "appName", ES->strval("Netscape"));
	reinitprop(navobj, "appVersion", ES->strval("3.0 (Inferno, U)"));
	reinitprop(navobj, "userAgent", ES->strval("Mozilla/3.0 (Inferno; U)"));

	omty := getobj(ex, navobj, "mimeTypes");
	for(i := 0; i < len mimespecs; i++) {
		sp := mimespecs[i];
		v := mkhostobj(ex, "MimeType");
		reinitprop(v, "description", ES->strval(sp.description));
		reinitprop(v, "suffixes", ES->strval(sp.suffixes));
		reinitprop(v, "type", ES->strval(sp.ty));
		arrayput(ex, omty, i, sp.ty, ES->objval(v));
	}
	return navobj;
}

# Something changed in charon's frame tree
frametreechanged(t: ref Layout->Frame)
{
	rebuild : ref ScriptWin;

	if (top == nil) {
		(ex, loc) := makeframeex(t);
		top = ScriptWin.new(t, ex, loc, nil);
		rebuild = top;
	} else {
		rebuild = top.findbyframe(t);
		# t could be new frame - need to look for parent
		while (rebuild == nil && t.parent != nil) {
			t = t.parent;
			rebuild = top.findbyframe(t);
		}
		# if we haven't found it by now, it's not in the official Frame
		# hierarchy, so ignore it
	}
	if (rebuild != nil)
		wininstant(rebuild);
}

# Frame f has just been reset, then given a new doc field
# (with initial values for src, base, refresh, chset).
# We'll defer doing any actual building of the script objects
# until an evalscript; that way, pages that don't use scripts
# incur minimum penalties).
havenewdoc(f: ref Layout->Frame)
{
	sw := top.findbyframe(f);
	if(sw != nil) {
		(sw.ex, sw.locobj) = makeframeex(f);
		if (sw.val != nil)
			# global object is referenced via parent.frames array
			sw.val.obj = sw.ex.global;
		wininstant(sw);
	}
}

# First string in answer is error (if non-nil), second is possible
# output of document.write's.
# Currently, assume this is only called during page build.
# When page build is done, this should be called a final
# time with donebuild=1.
evalscript(f: ref Layout->Frame, s: string, donebuild: int) : (string, string)
{
	sw := top.findbyframe(f);
	if(sw == nil || sw.ex == nil)
		return ("", "");

	ex := sw.ex;
	docwriteout = "";
	createdimages = nil;
	exc := ref sys->Exception;
	if(sys->rescue("ecmascript*", exc) == sys->EXCEPTION) {
		if(dbg) {
			sys->print("error executing evalscript: %s\nscript=", ex.error);
			sa := array of byte s;
			sys->write(sys->fildes(1), sa, len sa);
			sys->print("\n");
		}
		return (ex.error, docwriteout);
	}
	xfertoscriptobjs(f, 1);
	if(s != "") {
		ES->eval(ex, s);
		xferfromscriptobjs(f, 1);
	}
	if(donebuild)
		sw.inbuild = 0;
	return("", docwriteout);
}

xfertoscriptobjs(f: ref Layout->Frame, inbuild: int)
{
	sw := top.findbyframe(f);
	if(sw == nil)
		return;
	ex := sw.ex;
	ow := ex.global;

	for(el := f.doc.events; el != nil; el = tl el) {
		e := hd el;
		hname := "";
		case e.attid {
		Lex->Aonblur =>
			hname = "onblur";
		Lex->Aonerror =>
			hname = "onerror";
		Lex->Aonfocus =>
			hname = "onfocus";
		Lex->Aonload =>
			hname = "onload";
		Lex->Aonunload =>
			hname = "onunload";
		}
		if(hname != "")
			puthandler(ex, ow, hname, e.value);
	}
	f.doc.events = nil;

	od := getobj(ex, ow, "document");
	if(od == nil) {
		reinitprop(ow, "document", docinstant(ex, f));
		od = getobj(ex, ow, "document");
		CU->assert(od != nil);
	}
	else if(inbuild)
		docfill(ex, od, f);
	for(frml := f.doc.forms; frml != nil; frml = tl frml) {
		frm := hd frml;
		for(fieldl := frm.fields; fieldl != nil; fieldl = tl fieldl) {
			fld := hd fieldl;
			# change value in control, if it is there yet
			if(fld.ctlid >= 0 && fld.ctlid < len f.controls) {
				ofield := getformfieldobj(ex, f.id, frm.formid, fld.fieldid);
				if(ofield == nil)
					continue;
				pick c := f.controls[fld.ctlid] {
				Centry =>
					reinitprop(ofield, "value", ES->strval(c.s));
				Ccheckbox =>
					cv := ES->false;
					if(c.flags&Layout->CFactive)
						cv = ES->true;
					reinitprop(ofield, "checked", cv);
				Cselect =>
					for(i := 0; i < len c.options; i++) {
						if(c.options[i].selected)
							reinitprop(ofield, "selectedIndex", ES->numval(real i));
					}
				}
			}
		}
	}
	for(sil := sw.imgs; sil != nil; sil = tl sil) {
		si := hd sil;
		if(si.item.ci.complete != 0)
			reinitprop(si.obj, "complete", ES->true);
	}
}

xferfromscriptobjs(f: ref Layout->Frame, inbuild: int)
{
	sw := top.findbyframe(f);
	if(sw == nil)
		return;
	ex := sw.ex;
	ow := ex.global;
	od := getobj(ex, ow, "document");
	if(od != nil) {
		if(inbuild) {
			di := f.doc;
			di.doctitle = strxfer(ex, od, "title", di.doctitle);
			di.background.color = colorxfer(ex, od, "bgColor", di.background.color);
			di.text = colorxfer(ex, od, "fgColor", di.text);
			di.alink = colorxfer(ex, od, "alinkColor", di.alink);
			di.link = colorxfer(ex, od, "linkColor", di.link);
			di.vlink = colorxfer(ex, od, "vlinkColor", di.vlink);
			if(createdimages != nil) {
				for(oil := createdimages; oil != nil; oil = tl oil) {
					oi := hd oil;
					vsrc := ES->get(ex, oi, "src");
					if(ES->isstr(vsrc)) {
						u := U->makeurl(vsrc.str);
						if(u.scheme != U->UNKNOWN) {
							u.makeabsolute(di.base);
							it := Item.newimage(di, u, nil, "", B->Anone,
								0, 0, 0, 0, 0, 0, nil, nil, nil);
							di.images = it :: di.images;
						}
					}
				}
			}
		}
		else {
			(oimages, n) := getarraywithlen(ex, od, "images");
			for(i := 0; i < n; i++) {
				oi := getobj(ex, oimages, string i);
				voldsrc := ES->get(ex, oi, "@PRIVsrc");
				vnewsrc := ES->get(ex, oi, "src");
				if(ES->isstr(voldsrc) && ES->isstr(vnewsrc)) {
					if(voldsrc.str != vnewsrc.str) {
						for(sil := sw.imgs; sil != nil; sil = tl sil) {
							si := hd sil;
							if(si.obj == oi) {
								ES->put(ex, oi, "@PRIVsrc", ES->strval(vnewsrc.str));
								f.swapimage(si.item, vnewsrc.str);
								break;
							}
						}
					}
				}
			}
		}
	}
}

# Check ScriptWin tree for non-empty newlocs.
# When found, generate a go event to the new place.
# If found, don't recurse into children, because those
# child frames are about to go away anyway.
# Otherwise, recurse into all kids -- this might generate
# multiple go events.
# BUG: if multiple events are generated, later ones will
# interrupt (STOP!) loading of pages specified by preceding
# events.  To fix, need to queue them up, probably in
# main charon module.
checknewlocs(sw: ref ScriptWin)
{
	if(sw.newloc != "") {
		E->evchan <-= ref Event.Ego(sw.newloc, sw.newloctarg, 0, E->EGnormal);
		sw.newloc = "";
	}
	else {
		for(l := sw.kids; l != nil; l = tl l)
			checknewlocs(hd l);
	}
}

# if e.anchorid >= 0	=> target is Link
# if e.fieldid > 0	=> target is FormField (and e.formid > 0)
# if e.formid > 0	=> target is Form (e.fieldid == -1)
# if e.imageid >= 0	=> target is Image
# otherwise		=> target is window
do_on(e: ref ScriptEvent)
{
	if(dbg)
		sys->print("do_on %d, frameid=%d, formid=%d, fieldid=%d, anchorid=%d, x=%d, y=%d, which=%d\n",
			e.kind, e.frameid, e.formid, e.fieldid, e.anchorid, e.x, e.y, e.which);
	sw := top.findbyframeid(e.frameid);
	if (sw == nil || sw.inbuild) {
		if(e.reply != nil)
			e.reply <-= 0;
		jevchan <-= ref doneevent;
		return;
	}
	f := sw.frame;
	ex := sw.ex;
	ow := ex.global;
	od := getobj(ex, ow, "document");
	exc := ref sys->Exception;
	if(sys->rescue("ecmascript*", exc) == sys->EXCEPTION) {
		if(dbg)
			sys->print("error executing 'on' handler: %s\n", ex.error);
		if(e.reply != nil)
			e.reply <-= 0;
		jevchan <-= ref doneevent;
		return;
	}
	# event target types
	TAnchor, TForm, TFormField, TImage, TWindow, Tnone: con iota;
	ttype := Tnone;
	target, oform: ref Obj;
	if(e.anchorid >= 0) {
		ttype = TAnchor;
		target = getanchorobj(ex, e.frameid, e.anchorid);
	} else if(e.formid > 0) {
		oform = getformobj(ex, e.frameid, e.formid);
		if(e.fieldid > 0) {
			ttype = TFormField;
			target = getformfieldobj(ex, e.frameid, e.formid, e.fieldid);
		} else {
			ttype = TForm;
			target = oform;
		}
	} else if(e.imageid >= 0) {
		ttype = TImage;
		target = getimageobj(ex, e.frameid, e.imageid);
	} else {
		ttype = TWindow;
		target = ow;
	}
	oscript: ref Obj;
	if(target != nil) {
		scrname := "";
		case e.kind {
		E->SEonabort =>
			scrname = "onabort";
		E->SEonblur =>
			scrname = "onblur";
		E->SEonchange =>
			scrname = "onchange";
		E->SEonclick =>
			scrname = "onclick";
		E->SEonerror =>
			scrname = "onerror";
		E->SEonfocus =>
			scrname = "onfocus";
		E->SEonload =>
			scrname = "onload";
		E->SEonmouseout =>
			scrname = "onmouseout";
		E->SEonmouseover =>
			scrname = "onmouseover";
		E->SEonreset =>
			scrname = "onreset";
		E->SEonselect =>
			scrname = "onselect";
		E->SEonsubmit =>
			scrname = "onsubmit";
		E->SEonunload =>
			scrname = "onunload";
		E->SEtimeout =>
			oscript = dotimeout(ex, target, e.which);
		}
		if(scrname != "")
			oscript = getobj(ex, target, scrname);
		if(oscript != nil) {
			xfertoscriptobjs(f, 0);
			if(dbg)
				sys->print("calling script\n");
			# establish scope chain per Rhino p. 287 (3rd edition)
			oldsc := ex.scopechain;
			sc := ow :: nil;
			if(ttype != TWindow) {
				sc = od :: sc;
				if(ttype == TFormField)
					sc = oform :: sc;
				sc = target :: sc;
			}
			ex.scopechain = sc;
			v := ES->call(ex, oscript, target, nil).val;
			v = ES->toBoolean(ex, v);
			ex.scopechain = oldsc;
			# onreset/onsubmit reply channel
			if(e.reply != nil) {
				if(v == ES->true)
					ans := 1;
				else
					ans = 0;
				e.reply <-= ans;
				e.reply = nil;
			}
			xferfromscriptobjs(f, 0);
		}
	}
	if(e.reply != nil)
		e.reply <-= 0;
	jevchan <-= ref doneevent;
}

#
# interface for host objects
#
get(ex: ref Exec, o: ref Obj, property: string): ref Val
{
	if(o.class == "document" && property == "cookie") {
		ans := "";
		target := top.findbyobj(o);
		if(target != nil) {
			url := target.frame.doc.src;
			l := CU->getcookies(url.host, "/" + url.path);
			while(l != nil) {
				if(ans != nil)
					ans += ";";
				ans += hd l;
				l = tl l;
			}
		}
		return ES->strval(ans);
	}
	return ES->get(ex, o, property);
}

put(ex: ref Exec, o: ref Obj, property: string, val: ref Val)
{
	if(dbg)
		sys->print("put property %s in cobj of class %s\n", property, o.class);

	url : ref ParsedUrl;
	target : ref ScriptWin;
	str := ES->toString(ex, val);

	case o.class {
	"Window" =>
		case property {
		"defaultStatus" or
		"status" =>
			if(ES->isstr(val)) {
				if(property == "defaultStatus")
					defaultStatus = val.str;
				CH->showstatus(val.str);
			}
		"location" =>
			target = top.findbyobj(o);
			if (target == nil)
				break;
			url = U->makeurl(str);
			# TODO: be more defensive
			url.makeabsolute(target.frame.doc.base);
		}
	"Location" =>
		target = top.findbyobj(o);
		if (target == nil)
			break;
		url = ref *target.frame.doc.src;

		case property {
		"hash" =>
			if (str != nil && str[0] == '#')
				str = str[1:];
			url.frag = str;
		"host" =>
			# host:port
			(h, p) := S->splitl(str, ":");
			if (p != nil)
				p = p[1:];
			if (h != nil)
				url.host = h;
			if (p != nil)
				url.port = p;
		"hostname" =>
			url.host = str;
		"href" or
		"pathname" =>
			url = U->makeurl(str);
			url.makeabsolute(target.frame.doc.base);
		"port" =>
			url.port = str;
		"protocol" =>
			scheme := str + "/";
			su := U->makeurl(scheme);
			url.scheme = su.scheme;
		"search" =>
			url.query = str;
		* =>
			url = nil;
		}
	"Image" =>
		# making URLs absolute matches Netscape
		if(property == "src" || property == "lowsrc") {
			target = top.findbyobj(o);
			if(target == nil)
				break;
			url = U->makeurl(str);
			url.makeabsolute(target.frame.doc.base);
			val = ES->strval(url.tostring());
			url = nil;
		}
	"document" =>
		if(property == "cookie") {
			target = top.findbyobj(o);
			if(target != nil && (CU->config).docookies > 0) {
				url = target.frame.doc.src;
				CU->setcookie(str, url.host, "/" + url.path);
			}
			return;
		}
	}
	ES->put(ex, o, property, val);

	if (url != nil && target != nil) {
		if (!CU->urlequal(url, target.frame.doc.src)) {
			target.newloc = url.tostring();
			target.newloctarg = "_top";
			if(target.frame != nil)
				target.newloctarg = target.frame.name;
		}
	}
}

canput(ex: ref Exec, o: ref Obj, property: string): ref Val
{
	return ES->canput(ex, o, property);
}

hasproperty(ex: ref Exec, o: ref Obj, property: string): ref Val
{
	return ES->hasproperty(ex, o, property);
}

delete(ex: ref Exec, o: ref Obj, property: string)
{
	ES->delete(ex, o, property);
}

defaultval(ex: ref Exec, o: ref Obj, tyhint: int): ref Val
{
	return ES->defaultval(ex, o, tyhint);
}

call(ex: ref Exec, func, this: ref Obj, args: array of ref Val): ref Ref
{
if(dbg) { sys->print("call %x (class %s), val %s\n", func, func.class, func.val.str); }
	ans := ES->valref(ES->true);
	case func.val.str{
	"document.prototype.write" =>
		docwriteout += ES->toString(ex, ES->biarg(args, 0));
	"document.prototype.writeln" =>
		docwriteout += ES->toString(ex, ES->biarg(args, 0)) + "\n";
	"navigator.prototype.javaEnabled" or
	"navigator.prototype.taintEnabled" =>
		ans = ES->valref(ES->false);
	"Form.prototype.reset" or "Form.prototype.submit"=>
		vframeid := ES->get(ex, this, "@PRIVframeid");
		vformid := ES->get(ex, this, "@PRIVformid");
		if(ES->isnum(vframeid) && ES->isnum(vformid)) {
			frameid := ES->toInt32(ex, vframeid);
			formid := ES->toInt32(ex, vformid);
			ftype : int;
			if(func.val.str == "Form.prototype.reset")
				ftype = E->EFreset;
			else
				ftype = E->EFsubmit;
			E->evchan <-= ref Event.Eform(frameid, formid, ftype);
		}
	"FormField.prototype.blur" or
	"FormField.prototype.click" or
	"FormField.prototype.focus" or
	"FormField.prototype.select" =>
		oform := getobj(ex, this, "form");
		vformid := ES->get(ex, oform, "@PRIVformid");
		vframeid := ES->get(ex, oform, "@PRIVframeid");
		vfieldid := ES->get(ex, this, "@PRIVfieldid");
		if(ES->isnum(vframeid) && ES->isnum(vformid) && ES->isnum(vfieldid)) {
			frameid := ES->toInt32(ex, vframeid);
			formid := ES->toInt32(ex, vformid);
			fieldid := ES->toInt32(ex, vfieldid);
			fftype : int;
			case func.val.str{
			"FormField.prototype.blur" =>
				fftype = E->EFFblur;
			"FormField.prototype.click" =>
				fftype = E->EFFclick;
			"FormField.prototype.focus" =>
				fftype = E->EFFfocus;
			"FormField.prototype.select" =>
				fftype = E->EFFselect;
			* =>
				fftype = E->EFFnone;
			}
			E->evchan <-= ref Event.Eformfield(frameid, formid, fieldid, fftype);
		}
	"History.prototype.back" =>
		E->evchan <-= ref Event.Ego("", "", 0, E->EGback);
	"History.prototype.forward" =>
		E->evchan <-= ref Event.Ego("", "", 0, E->EGforward);
	"History.prototype.go" =>
		ego : ref Event.Ego;
		v := ES->biarg(args, 0);
		if(ES->isstr(v))
			ego = ref Event.Ego(v.str, "", 0, E->EGlocation);
		else if(ES->isnum(v)) {
			delta := ES->toInt32(ex, v);
			case delta {
			-1 =>
				ego = ref Event.Ego("", "", 0, E->EGback);
			0 =>
				ego = ref Event.Ego("", "", 0, E->EGreload);
			1 =>
				ego = ref Event.Ego("", "", 0, E->EGforward);
			* =>
				ego = ref Event.Ego("", "", delta,  E->EGdelta);
			}
		}
		if(ego != nil)
			E->evchan <-= ego;
	"Location.prototype.reload" =>
		# ignore 'force' argument for now
		E->evchan <-= ref Event.Ego("", "", 0, E->EGreload);
	"Location.prototype.replace" =>
		v := ES->biarg(args, 0);
		if(ES->isstr(v)) {
			target := top.findbyobj(this);
			if(target == nil)
				fname := "_top";
			else
				fname = target.frame.name;
			E->evchan <-= ref Event.Ego(v.str, fname, 0, E->EGreplace);
		}
	"Window.prototype.alert" =>
		sync := chan of int;
		E->evchan <-= ref Event.Ealert(ES->toString(ex, ES->biarg(args, 0)), sync);
		<- sync;
	"Window.prototype.confirm" =>
		sync := chan of int;
		E->evchan <-= ref Event.Econfirm(ES->toString(ex, ES->biarg(args, 0)), sync);
		code := <- sync;
		if(code == 0)
			ans = ES->valref(ES->false);
	"Window.prototype.open" =>
		u := ES->toString(ex, ES->biarg(args, 0));
		if(u != "") {
			# Want to replace top window by navigation to u
			top.newloc = u;
			top.newloctarg = "_top";
			url := U->makeurl(u);
			# TODO: be more defensive
			# Perhaps make absolute relative to current frame
			url.makeabsolute(top.frame.doc.base);
			top.newloc = url.tostring();
		}
	"Window.prototype.prompt" =>
		sync := chan of (int, string);
		E->evchan <-= ref Event.Eprompt(ES->toString(ex, ES->biarg(args, 0)), ES->toString(ex, ES->biarg(args, 1)), sync);
		(code, input) := <- sync;
		if(code == 0)
			v := ES->null;
		else
			v = ES->strval(input);
		ans = ES->valref(v);

	"Window.prototype.setTimeout" =>
		(v1, v2) := (ES->biarg(args, 0), ES->biarg(args, 1));
		cmd := ES->toString(ex, v1);
		ms := ES->toInt32(ex, v2);
		id := addtimeout(ex, this, cmd, ms);
		ans = ES->valref(ES->numval(real id));

	"Window.prototype.clearTimeout" =>
		v := ES->biarg(args, 0);
		id := ES->toInt32(ex, v);
		clrtimeout(ex, this, id);

	* =>
		ES->runtime(ex, "unknown or unimplemented func "+func.val.str+" in host call");
		return nil;
	}
	return ans;
}

timeout(e : ref ScriptEvent, ms : int)
{
	sys->sleep(ms);
	jevchan <- = e;
}

# BUGS
#	cannot set a timeout for a window just created by window.open()
#	because it will not have an entry in the ScriptWin tree
#	(This is really a problem with the ScriptEvent adt only taking a frame id)
#
addtimeout(ex : ref Exec, win : ref Obj, cmd : string, ms : int) : int
{
	sw := top.findbyobj(win);
	if (sw == nil || cmd == nil || ms <= 0)
		return -1;

	# check for timeout handler array, create if doesn't exist
	(toa, n) := getarraywithlen(ex, win, "@PRIVtoa");
	if (toa == nil) {
		toa = ES->mkobj(ex.arrayproto, "Array");
		ES->varinstant(toa, ES->DontEnum|ES->DontDelete, "length", ref RefVal(ES->numval(0.)));
		ES->varinstant(win, ES->DontEnum|ES->DontDelete, "@PRIVtoa", ref RefVal(ES->objval(toa)));
	}

	# find first free handler
	for (ix := 0; ix < n; ix++) {
		hv := ES->get(ex, toa, string ix);

		if (hv == nil)
			break;
		# val == null		Timeout has been cancelled, but timer still running
		# val == undefined	Timeout has expired
		if (hv == ES->undefined)
			break;
	}

	# construct a private handler for the timeout
	# The code is always executed in the scope of the window object
	# for which the timeout is being set.
	oldsc := ex.scopechain;
	ex.scopechain = win :: nil;
	ES->eval(ex, "function PRIVhandler() {" + cmd + "}");
	hobj := getobj(ex, win, "PRIVhandler");
	ex.scopechain = oldsc;
	if(hobj == nil)
		return -1;
	ES->put(ex, toa, string ix, ES->objval(hobj));

	ev := ref ScriptEvent(E->SEtimeout, sw.frame.id, -1, -1, -1, -1, 0, 0, ix, nil);
	spawn timeout(ev, ms);
	return ix;
}

dotimeout(ex : ref Exec, win : ref Obj, id : int) : ref Ecmascript->Obj
{
	if (id < 0)
		return nil;

	(toa, n) := getarraywithlen(ex, win, "@PRIVtoa");
	if (toa == nil || id >= n)
		return nil;

	handler := getobj(ex, toa, string id);
	if (handler == nil)
		return nil;
	if (id == n-1)
		ES->put(ex, toa, "length", ES->numval(real (n-1)));
	else
		ES->put(ex, toa, string id, ES->undefined);
	return handler;
}

clrtimeout(ex : ref Exec, win : ref Obj, id : int)
{
	if (id < 0)
		return;
	(toa, n) := getarraywithlen(ex, win, "@PRIVtoa");
	if (toa == nil || id >= n)
		return;

	ES->put(ex, toa, string id, ES->null);
}

construct(ex: ref Exec, func: ref Obj, args: array of ref Val): ref Obj
{
if(dbg) { sys->print("construct %x (class %s), val %s\n", func, func.class, func.val.str); }
	case func.val.str {
	"Image" =>
		o := mkhostobj(ex, "Image");
		if(len args > 0) {
			reinitprop(o, "width", args[0]);
			if(len args > 1)
				reinitprop(o, "height", args[1]);
		}
		createdimages = o :: createdimages;
		return o;
	}
	return nil;
}


# Make a host object with given class.
# Get the prototype from the objspecs array
# (if none yet, make one up and install the methods).
# Put in required properties, with undefined values initially.
# If mainex is nil (it will be for bootstrapping the initial object),
# the prototype has to be filled in later.
mkhostobj(ex : ref Exec, class: string) : ref Obj
{
	ci := specindex(class);
	proto : ref Obj;
	if(ex != nil)
		proto = mkprototype(ex, ci);
	ans := ES->mkobj(proto, class);
	initprops(ex, ans, objspecs[ci].props);
	ans.host = me;
	return ans;
}

initprops(ex : ref Exec, o: ref Obj, props: array of PropSpec)
{
	if(props == nil)
		return;
	for(i := 0; i < len props; i++) {
		v := ES->undefined;
		case props[i].initval {
		IVundef =>
			v = ES->undefined;
		IVnull =>
			v = ES->null;
		IVtrue =>
			v = ES->true;
		IVfalse =>
			v = ES->false;
		IVnullstr =>
			v = nullstrval;
		IVzero =>
			v = zeroval;
		IVzerostr =>
			v = zerostrval;
		IVarray =>
			# need a separate one for each array,
			# since we'll update these rather than replacing
			ao := ES->mkobj(ex.arrayproto, "Array");
			ES->varinstant(ao, ES->DontEnum|ES->DontDelete, "length", ref RefVal(ES->numval(0.)));
			v = ES->objval(ao);
		* =>
			CU->assert(0);
		}
		ES->varinstant(o, props[i].attr | ES->DontDelete, props[i].name, ref RefVal(v));
	}
}

# Return index into objspecs where class is specified
specindex(class: string) : int
{
	for(i := 0; i < len objspecs; i++)
		if(objspecs[i].name == class)
			break;
	if(i == len objspecs)
		CU->raise("EXInternal: couldn't find host object class " + class);
	return i;
}

# Make a prototype for host object specified by objspecs[ci]
mkprototype(ex : ref Exec, ci : int) : ref Obj
{
	CU->assert(ex != nil);
	class := objspecs[ci].name;
	prototype := ES->mkobj(ex.objproto, class);
	meths := objspecs[ci].methods;
	for(k := 0; k < len meths; k++) {
		name := meths[k].name;
		fullname := class + ".prototype." + name;
		args := meths[k].args;
		ES->biinst(prototype, Builtin(name, fullname, args, len args),
			ex.funcproto, me);
	}
	return prototype;
}


getframeobj(frameid: int) : ref Obj
{
	sw := top.findbyframeid(frameid);
	if(sw != nil)
		return sw.ex.global;
	return nil;
}

getdocobj(ex : ref Exec, frameid: int) : ref Obj
{
	return getobj(ex, getframeobj(frameid), "document");
}

getformobj(ex : ref Exec, frameid, formid: int) : ref Obj
{
	# frameids are 1-origin, document.forms is 0-origin
	return getarrayelem(ex, getdocobj(ex, frameid), "forms", formid-1);
}

getformfieldobj(ex : ref Exec, frameid, formid, fieldid: int) : ref Obj
{
	# fieldids are 1-origin, elements are 0-origin
	return getarrayelem(ex, getformobj(ex, frameid, formid), "elements", fieldid-1);
}

getanchorobj(ex: ref Exec, frameid, anchorid: int) : ref Obj
{
	od := getdocobj(ex, frameid);
	if(od != nil) {
		(olinks, olinkslen) := getarraywithlen(ex, od, "links");
		if(olinks != nil) {
			for(i := 0; i < olinkslen; i++) {
				ol := getobj(ex, olinks, string i);
				if(ol != nil) {
					v := ES->get(ex, ol, "@PRIVanchorid");
					if(ES->isnum(v) && ES->toInt32(ex, v) == anchorid)
						return ol;
				}
			}
		}
	}
	return nil;
}

getimageobj(ex: ref Exec, frameid, imageid: int) : ref Obj
{
	od := getdocobj(ex, frameid);
	if(od != nil) {
		(oimages, oimageslen) := getarraywithlen(ex, od, "images");
		if(oimages != nil) {
			for(i := 0; i < oimageslen; i++) {
				oi := getobj(ex, oimages, string i);
				if(oi != nil) {
					v := ES->get(ex, oi, "@PRIVimageid");
					if(ES->isnum(v) && ES->toInt32(ex, v) == imageid)
						return oi;
				}
			}
		}
	}
	return nil;
}

# return nil if none such, or not an object
getobj(ex : ref Exec, o: ref Obj, prop: string) : ref Obj
{
	if(o != nil) {
		v := ES->get(ex, o, prop);
		if(ES->isobj(v))
			return ES->toObject(ex, v);
	}
	return nil;
}

# return nil if none such, or not an object
getarrayelem(ex : ref Exec, o: ref Obj, arrayname: string, index: int) : ref Obj
{
	oarr := getobj(ex, o, arrayname);
	if(oarr != nil) {
		v := ES->get(ex, oarr, string index);
		if(ES->isobj(v))
			return ES->toObject(ex, v);
	}
	return nil;
}

# return "" if none such, or not a string
getstr(ex : ref Exec, o: ref Obj, prop: string) : string
{

	if(o != nil) {
		v := ES->get(ex, o, prop);
		if(ES->isstr(v))
			return ES->toString(ex, v);
	}
	return "";
}

# Property index, -1 if doesn't exist
pind(o: ref Obj, prop: string) : int
{
	props := o.props;
	for(i := 0; i < len props; i++){
		if(props[i] != nil && props[i].name == prop)
			return i;
	}
	return -1;
}

# Reinitialize property prop of object o to value v
# (pay no attention to ReadOnly status, so can't use ES->put).
# Assume the property exists already.
reinitprop(o: ref Obj, prop: string, v: ref Val)
{
	i := pind(o, prop);
	if(i < 0) {
		# set up dummy ex for now - needs sorting out
		ex := ref Exec;
		ES->runtime(ex, "missing property " + prop); # shouldn't happen
	}
	CU->assert(i >= 0);
	o.props[i].val.val = v;
}

# Get the array object named aname from o, and also find its current
# length value.  If there is any problem, return (nil, 0).
getarraywithlen(ex : ref Exec, o: ref Obj, aname: string) : (ref Obj, int)
{
	varray := ES->get(ex, o, aname);
	if(ES->isobj(varray)) {
		oarray := ES->toObject(ex, varray);
		vlen := ES->get(ex, oarray, "length");
		if(vlen != ES->undefined)
			return (oarray, ES->toInt32(ex, vlen));
	}
	return (nil, 0);	
}

# Put val v as property "index" of object oarray.
# Also, if the name doesn't conflict with array properties, add the val as
# a "name" property too
arrayput(ex : ref Exec, oarray: ref Obj, index: int, name: string, v: ref Val)
{
	ES->put(ex, oarray, string index, v);
	if(name != "" && name != "length") {
		for(i := 0; i < len name; i++) {
			c := name[i];
			if(c < '0' || c > '9') {
				# name is not all decimal digits, so OK
				ES->put(ex, oarray, name, v);
				break;
			}
		}
	}
}

# Instantiate window object.
# mkhostobj has already put the property names and default initial values in;
# we have to fill in the proper values.
wininstant(sw: ref ScriptWin)
{
	ex := sw.ex;
	w := ex.global;
	f := sw.frame;

	# document to be init'd by xfertoscriptobjs

	# frames[ ]
	# could delete old frames from frame array by setting "length" prop to 0
	# Just make a new one, as nothing else should have a ref to it at this point
	sw.kids = nil;
	ao := ES->mkobj(ex.arrayproto, "Array");
	ES->varinstant(ao, ES->DontEnum|ES->DontDelete, "length", ref RefVal(ES->numval(0.)));
	reinitprop(w, "frames", ES->objval(ao));
	for (kl := f.kids; kl != nil; kl = tl kl) {
		sw.addkid(hd kl);
	}
	kn := 0;
	for (swkl := sw.kids; swkl != nil; swkl = tl swkl) {
		k := hd swkl;
		# not sure if frame name should be defined as property of parent
		arrayput(ex, ao, kn++, "", k.val);
	}

	reinitprop(w, "length", ES->numval(real len f.kids));

	v := ref Val;
	if (sw.parent == nil)
		v = ES->objval(w);
	else
		v = ES->objval(sw.parent.ex.global);
	reinitprop(w, "parent", v);

	reinitprop(w, "self", ES->objval(w));
	reinitprop(w, "window", ES->objval(w));
	reinitprop(w, "top", ES->objval(top.ex.global));
}

# Return initial document object value, based on d
docinstant(ex: ref Exec, f: ref Layout->Frame) : ref Val
{
	od := mkhostobj(ex, "document");
	docfill(ex, od, f);
	return ES->objval(od);
}

# Fill in properties of doc object, based on d.
# Can be called at various points during build.
docfill(ex: ref Exec, od: ref Obj, f: ref Layout->Frame)
{
	sw := top.findbyframe(f);
	if(sw == nil)
		return;
	di := f.doc;
	if(di.src != nil) {
		reinitprop(od, "URL", ES->strval(di.src.tostring()));
		reinitprop(od, "domain", ES->strval(di.src.host));
	}
	if(di.referrer != nil)
		reinitprop(od, "referrer", ES->strval(di.referrer.tostring()));
	if(di.doctitle != "")
		reinitprop(od, "title", ES->strval(di.doctitle));
	reinitprop(od, "lastModified", ES->strval(di.lastModified));
	reinitprop(od, "bgColor", colorval(di.background.color));
	reinitprop(od, "fgColor", colorval(di.text));
	reinitprop(od, "alinkColor", colorval(di.alink));
	reinitprop(od, "linkColor", colorval(di.link));
	reinitprop(od, "vlinkColor", colorval(di.vlink));

	# Forms in d.forms are in reverse order of appearance.
	# Add any that aren't already in the document.forms object,
	# assuming that the relative lengths will tell us what needs
	# to be done.
	if(di.forms != nil) {
		newformslen := len di.forms;
		(oforms, oldformslen) := getarraywithlen(ex, od, "forms");

		# oforms should be non-nil, because the object is initialized
		# to an empty array and is readonly.  The following test
		# is just defensive.
		if(oforms != nil) {
			fl := di.forms;
			for(i := newformslen-1; i >= oldformslen; i--) {
				form := hd fl;
				fl = tl fl;
				vfrm := forminstant(ex, form, di.frameid);
				arrayput(ex, oforms, i, form.name, vfrm);
				if(form.name != "")
					ES->put(ex, od, form.name, vfrm);
			}
		}
	}

	# Charon calls "DestAnchor" what Netscape calls "Anchor".
	# Use same method as for forms to discover new ones.
	if(di.dests != nil) {
		newdestslen := len di.dests;
		(oanchors, oldanchorslen) := getarraywithlen(ex, od, "anchors");
		if(oanchors != nil) {
			dl := di.dests;
			for(i := newdestslen-1; i >= oldanchorslen; i--) {
				dest := hd dl;
				dl = tl dl;
				arrayput(ex, oanchors, i, dest.name, anchorinstant(ex));
			}
		}
	}

	# Charon calls "Anchor" what Netscape calls "Link" (how confusing for us!).
	# Use same method as for forms to discover new ones.
	# BUG: Areas are supposed to be in this list too.
	if(di.anchors != nil) {
		newanchorslen := len di.anchors;
		(olinks, oldlinkslen) := getarraywithlen(ex, od, "links");
		if(olinks != nil) {
			al := di.anchors;
			for(i := newanchorslen-1; i >= oldlinkslen; i--) {
				a := hd al;
				al = tl al;
				arrayput(ex, olinks, i, a.name,  linkinstant(ex, a));
			}
		}
	}

	if(di.images != nil) {
		newimageslen := len di.images;
		(oimages, oldimageslen) := getarraywithlen(ex, od, "images");
		if(oimages != nil) {
			il := di.images;
			for(i := newimageslen-1; i >= oldimageslen; i--) {
				imit := hd il;
				il = tl il;
				pick ii := imit {
				Iimage =>
					vim := imageinstant(ex, ii);
					arrayput(ex, oimages, i, ii.name, vim);
					ES->put(ex, od, ii.name, vim);
					if(ES->isobj(vim)) {
						sw.imgs = ref ScriptImg(ii, vim.obj) :: sw.imgs;
					}
				}
			}
		}
	}

	# private variables
	ES->varinstant(od, ES->DontEnum|ES->DontDelete, "@PRIVframeid",
			ref RefVal(ES->numval(real di.frameid)));
}

forminstant(ex : ref Exec, form: ref Build->Form, frameid: int) : ref Val
{
	oform := mkhostobj(ex, "Form");
	reinitprop(oform, "action", ES->strval(form.action.tostring()));
	reinitprop(oform, "encoding", ES->strval("application/x-www-form-urlencoded"));
	reinitprop(oform, "length", ES->numval(real form.nfields));
	reinitprop(oform, "method", ES->strval(CU->hmeth[form.method]));
	reinitprop(oform, "name", ES->strval(form.name));
	reinitprop(oform, "target", ES->strval(form.target));
	ffl := form.fields;
	if(ffl != nil) {
		velements := ES->get(ex, oform, "elements");
		if(ES->isobj(velements)) {
			oelements := ES->toObject(ex, velements);
			for(i := 0; i < form.nfields; i++) {
				field := hd ffl;
				ffl = tl ffl;
				vfield := fieldinstant(ex, field, oform);
				arrayput(ex, oelements, i, field.name, vfield);
				ES->put(ex, oform, field.name, vfield);
			}
		}
	}
	for(el := form.events; el != nil; el = tl el) {
		e := hd el;
		hname := "";
		case e.attid {
		Lex->Aonreset =>
			hname = "onreset";
		Lex->Aonsubmit =>
			hname = "onsubmit";
		}
		if(hname != "")
			puthandler(ex, oform, hname, e.value);
	}
	# private variables
	ES->varinstant(oform, ES->DontEnum|ES->DontDelete, "@PRIVformid",
			ref RefVal(ES->numval(real form.formid)));
	ES->varinstant(oform, ES->DontEnum|ES->DontDelete, "@PRIVframeid",
			ref RefVal(ES->numval(real frameid)));
	return ES->objval(oform);
}

fieldinstant(ex : ref Exec, field: ref Build->Formfield, oform: ref Obj) : ref Val
{
	ofield := mkhostobj(ex, "FormField");
	reinitprop(ofield, "form", ES->objval(oform));
	reinitprop(ofield, "name", ES->strval(field.name));
	reinitprop(ofield, "value", ES->strval(field.value));
	reinitprop(ofield, "defaultValue", ES->strval(field.value));
	chkd := ES->false;
	if((field.flags & Build->FFchecked) != byte 0)
		chkd = ES->true;
	reinitprop(ofield, "checked", chkd);
	reinitprop(ofield, "defaultChecked", chkd);
	nopts := len field.options;
	reinitprop(ofield, "length", ES->numval(real nopts));
	reinitprop(ofield, "selectedIndex", ES->numval(-1.0)); # BUG: search for selected option
	ty : string;
	case field.ftype {
	Build->Ftext =>
		ty = "text";
		reinitprop(ofield, "value", ES->strval(field.value));
	Build->Fpassword =>
		ty = "password";
	Build->Fcheckbox =>
		ty = "checkbox";
	Build->Fradio =>
		ty = "radio";
	Build->Fsubmit =>
		ty = "submit";
	Build->Fhidden =>
		ty = "hidden";
	Build->Fimage =>
		ty = "image";
	Build->Freset =>
		ty = "reset";
	Build->Ffile =>
		ty = "fileupload";
	Build->Fbutton =>
		ty = "button";
	Build->Fselect =>
		ty = "select";
		options := ES->mkobj(ex.arrayproto, "Array");
		ES->varinstant(options, ES->DontEnum|ES->DontDelete, "length",
					ref RefVal(ES->numval(real nopts)));
		reinitprop(ofield, "options", ES->objval(options));
		optl := field.options;
		for(i := 0; i < nopts; i++) {
			opt := hd optl;
			optl = tl optl;
			oopt := mkhostobj(ex, "Option");
			reinitprop(oopt, "index", ES->numval(real i));
			reinitprop(oopt, "value", ES->strval(opt.value));
			reinitprop(oopt, "text", ES->strval(opt.display));
			if(opt.selected) {
				reinitprop(oopt, "selected", ES->true);
				reinitprop(oopt, "defaultSelected", ES->true);
				reinitprop(ofield, "selectedIndex", ES->numval(real i));
			}
			ES->put(ex, options, string i, ES->objval(oopt));
		}
	Build->Ftextarea =>
		ty = "textarea";
	}
	reinitprop(ofield, "type", ES->strval(ty));
	for(el := field.events; el != nil; el = tl el) {
		e := hd el;
		hname := "";
		case e.attid {
		Lex->Aonblur =>
			hname = "onblur";
		Lex->Aonchange =>
			hname = "onchange";
		Lex->Aonclick =>
			hname = "onclick";
		Lex->Aonfocus =>
			hname = "onfocus";
		Lex->Aonselect =>
			hname = "onselect";
		}
		if(hname != "")
			puthandler(ex, ofield, hname, e.value);
	}
	# private variables
	ES->varinstant(ofield, ES->DontEnum|ES->DontDelete, "@PRIVfieldid",
			ref RefVal(ES->numval(real field.fieldid)));
	return ES->objval(ofield);
}

# Make an event handler named hname in o, with given body.
puthandler(ex: ref Exec, o: ref Obj, hname: string, hbody: string)
{
	c := ES->eval(ex, "function PRIVhandler() {" + hbody + "}");
	hobj := getobj(ex, ex.global, "PRIVhandler");
	if(hobj != nil) {
		ES->put(ex, o, hname, ES->objval(hobj));
	}
}

anchorinstant(ex : ref Exec) : ref Val
{
	oanchor := mkhostobj(ex, "Anchor");
	return ES->objval(oanchor);
}

# Build ensures that the anchor href has been made absolute
linkinstant(ex: ref Exec, anchor: ref Build->Anchor) : ref Val
{
	olink := mkhostobj(ex, "Link");
	u := anchor.href;
	if(u != nil) {
		if(u.frag != "")
			reinitprop(olink, "hash", ES->strval("#" + u.frag));
		host := u.host;
		if(u.user != "" || u.passwd != "") {
			host = u.user;
			if(u.passwd != "")
				host += ":" + u.passwd;
			host += "@" + u.host;
		}
		reinitprop(olink, "host",  ES->strval(host));
		hostname := host;
		if(u.port != "")
			hostname += ":" + u.port;
		reinitprop(olink, "hostname", ES->strval(hostname));
		reinitprop(olink, "href", ES->strval(u.tostring()));
		pathname := u.pstart + u.path;
		reinitprop(olink, "pathname", ES->strval(pathname));
		if(u.port != "")
			reinitprop(olink, "port", ES->strval(u.port));
		reinitprop(olink, "protocol", ES->strval(U->schemes[u.scheme] + ":"));
		if(u.query != "")
			reinitprop(olink, "search", ES->strval("?" + u.query));
	}
	if(anchor.target != "")
		reinitprop(olink, "target", ES->strval(anchor.target));

	for(el := anchor.events; el != nil; el = tl el) {
		e := hd el;
		hname := "";
		case e.attid {
		Lex->Aonclick =>
			hname = "onclick";
		Lex->Aonmouseout =>
			hname = "onmouseout";
		Lex->Aonmouseover =>
			hname = "onmouseover";
		}
		if(hname != "")
			puthandler(ex, olink, hname, e.value);
	}
	# private variable
	ES->varinstant(olink, ES->DontEnum|ES->DontDelete, "@PRIVanchorid",
			ref RefVal(ES->numval(real anchor.index)));

	return ES->objval(olink);
}

imageinstant(ex: ref Exec, im: ref Build->Item.Iimage) : ref Val
{
	oim := mkhostobj(ex, "Image");
	src := im.ci.src.tostring();
	reinitprop(oim, "border", ES->numval(real im.border));
	reinitprop(oim, "height", ES->numval(real im.imheight));
	reinitprop(oim, "hspace", ES->numval(real im.hspace));
	reinitprop(oim, "name", ES->strval(im.name));
	reinitprop(oim, "src", ES->strval(src));
	if(im.ci.lowsrc != nil)
		reinitprop(oim, "lowsrc", ES->strval(im.ci.lowsrc.tostring()));
	reinitprop(oim, "vspace", ES->numval(real im.vspace));
	reinitprop(oim, "width", ES->numval(real im.imwidth));
	if(im.ci.complete == 0)
		done := ES->false;
	else
		done = ES->true;
	reinitprop(oim, "complete", done);

	el : list of Lex->Attr = nil;
	if(im.genattr != nil)
		el = im.genattr.events;
	for(; el != nil; el = tl el) {
		e := hd el;
		hname := "";
		case e.attid {
		Lex->Aonabort =>
			hname = "onabort";
		Lex->Aonerror =>
			hname = "onerror";
		Lex->Aonload =>
			hname = "onload";
		}
		if(hname != "")
			puthandler(ex, oim, hname, e.value);
	}

	# private variables
	ES->varinstant(oim, ES->DontEnum|ES->DontDelete, "@PRIVimageid",
			ref RefVal(ES->numval(real im.imageid)));
	# to keep track of src as currently known in item
	ES->varinstant(oim, ES->DontEnum|ES->DontDelete, "@PRIVsrc",
			ref RefVal(ES->strval(src)));
	return ES->objval(oim);
}

colorval(v: int) : ref Val
{
	return ES->strval(sys->sprint("%.6x", v));
}

# If the o.name is a recognizable color, return it, else dflt
colorxfer(ex: ref Exec, o: ref Obj, name: string, dflt: int) : int
{
	v := ES->get(ex, o, name);
	if(v == ES->undefined)
		return dflt;
	return CU->color(ES->toString(ex, v), dflt);
}

strxfer(ex : ref Exec, o: ref Obj, name: string, dflt: string) : string
{
	v := ES->get(ex, o, name);
	if(v == ES->undefined)
		return dflt;
	return ES->toString(ex, v);
}

ScriptWin.new(f: ref Layout->Frame, ex: ref Exec, loc: ref Obj, par: ref ScriptWin) : ref ScriptWin
{
	return ref ScriptWin(f, ex, loc, ES->objval(ex.global), par, nil, nil, "", "", 1);
}

# Make a new ScriptWin with f as frame and new, empty
# Window object as obj, to be a child window of sw's window.
ScriptWin.addkid(sw: self ref ScriptWin, f: ref Layout->Frame)
{
	(cex, clocobj) := makeframeex(f);
	csw := ScriptWin.new(f, cex, clocobj, sw);
	wininstant(csw);
	sw.kids = csw :: sw.kids;
}

# Find the ScriptWin in the tree with sw as root that has
# f as frame, returning nil if none.
ScriptWin.findbyframe(sw: self ref ScriptWin, f: ref Layout->Frame) : ref ScriptWin
{
	if(sw.frame == f)
		return sw;
	for(l := sw.kids; l != nil; l = tl l) {
		x := (hd l).findbyframe(f);
		if(x != nil)
			return x;
	}
	return nil;
}

# Find the ScriptWin in the tree with sw as root that has
# fid as frame id, returning nil if none.
ScriptWin.findbyframeid(sw: self ref ScriptWin, fid: int) : ref ScriptWin
{
	if(sw.frame.id == fid)
		return sw;
	for(l := sw.kids; l != nil; l = tl l) {
		x := (hd l).findbyframeid(fid);
		if(x != nil)
			return x;
	}
	return nil;
}

# Find the ScriptWin in the tree with sw as root that has
# d as doc for the frame, returning nil if none.
ScriptWin.findbydoc(sw: self ref ScriptWin, d: ref Build->Docinfo) : ref ScriptWin
{
	if(sw.frame.doc == d)
		return sw;
	for(l := sw.kids; l != nil; l = tl l) {
		x := (hd l).findbydoc(d);
		if(x != nil)
			return x;
	}
	return nil;
}

# obj can either be the frame's Window obj, Location obj, or document obj,
# or an Image object within the frame
ScriptWin.findbyobj(sw : self ref ScriptWin, obj : ref Obj) : ref ScriptWin
{
	if (sw.locobj == obj || sw.ex.global == obj || obj == getdocobj(sw.ex, sw.frame.id))
		return sw;
	for(sil := sw.imgs; sil != nil; sil = tl sil) {
		if((hd sil).obj == obj)
			return sw;
	}
	for (l := sw.kids; l != nil; l = tl l) {
		x := (hd l).findbyobj(obj);
		if (x != nil)
			return x;
	}
	return nil;
}