Index: ps/trunk/source/gui/IGUIObject.cpp
===================================================================
--- ps/trunk/source/gui/IGUIObject.cpp	(revision 22628)
+++ ps/trunk/source/gui/IGUIObject.cpp	(revision 22629)
@@ -1,492 +1,492 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "GUI.h"
 
 #include "gui/scripting/JSInterface_GUITypes.h"
 #include "gui/scripting/JSInterface_IGUIObject.h"
 
 #include "ps/GameSetup/Config.h"
 #include "ps/CLogger.h"
 #include "ps/Profile.h"
 #include "scriptinterface/ScriptInterface.h"
 
 IGUIObject::IGUIObject(CGUI* pGUI)
 	: m_pGUI(pGUI), m_pParent(NULL), m_MouseHovering(false), m_LastClickTime()
 {
 	AddSetting<bool>("enabled");
 	AddSetting<bool>("hidden");
 	AddSetting<CClientArea>("size");
 	AddSetting<CStr>("style");
 	AddSetting<CStr>("hotkey");
 	AddSetting<float>("z");
 	AddSetting<bool>("absolute");
 	AddSetting<bool>("ghost");
 	AddSetting<float>("aspectratio");
 	AddSetting<CStrW>("tooltip");
 	AddSetting<CStr>("tooltip_style");
 
 	// Setup important defaults
 	GUI<bool>::SetSetting(this, "hidden", false);
 	GUI<bool>::SetSetting(this, "ghost", false);
 	GUI<bool>::SetSetting(this, "enabled", true);
 	GUI<bool>::SetSetting(this, "absolute", true);
 }
 
 IGUIObject::~IGUIObject()
 {
 	for (const std::pair<CStr, IGUISetting*>& p : m_Settings)
 		delete p.second;
 
 	if (!m_ScriptHandlers.empty())
 		JS_RemoveExtraGCRootsTracer(m_pGUI->GetScriptInterface()->GetJSRuntime(), Trace, this);
 }
 
 //-------------------------------------------------------------------
 //  Functions
 //-------------------------------------------------------------------
 
 void IGUIObject::AddChild(IGUIObject* pChild)
 {
 //	ENSURE(pChild);
 
 	pChild->SetParent(this);
 
 	m_Children.push_back(pChild);
 
 	// If this (not the child) object is already attached
 	//  to a CGUI, it pGUI pointer will be non-null.
 	//  This will mean we'll have to check if we're using
 	//  names already used.
 	if (pChild->GetGUI())
 	{
 		try
 		{
 			// Atomic function, if it fails it won't
 			//  have changed anything
 			//UpdateObjects();
 			pChild->GetGUI()->UpdateObjects();
 		}
 		catch (PSERROR_GUI&)
 		{
 			// If anything went wrong, reverse what we did and throw
 			//  an exception telling it never added a child
 			m_Children.erase(m_Children.end()-1);
 
 			throw;
 		}
 	}
 	// else do nothing
 }
 
 void IGUIObject::AddToPointersMap(map_pObjects& ObjectMap)
 {
 	// Just don't do anything about the top node
 	if (m_pParent == NULL)
 		return;
 
 	// Now actually add this one
 	//  notice we won't add it if it's doesn't have any parent
 	//  (i.e. being the base object)
 	if (m_Name.empty())
 	{
 		throw PSERROR_GUI_ObjectNeedsName();
 	}
 	if (ObjectMap.count(m_Name) > 0)
 	{
 		throw PSERROR_GUI_NameAmbiguity(m_Name.c_str());
 	}
 	else
 	{
 		ObjectMap[m_Name] = this;
 	}
 }
 
 void IGUIObject::Destroy()
 {
 	// Is there anything besides the children to destroy?
 }
 
 template<typename T>
 void IGUIObject::AddSetting(const CStr& Name)
 {
 	// This can happen due to inheritance
 	if (SettingExists(Name))
 		return;
 
 	m_Settings[Name] = new CGUISetting<T>(*this, Name);
 }
 
 bool IGUIObject::MouseOver()
 {
 	if (!GetGUI())
 		throw PSERROR_GUI_OperationNeedsGUIObject();
 
 	return m_CachedActualSize.PointInside(GetMousePos());
 }
 
 bool IGUIObject::MouseOverIcon()
 {
 	return false;
 }
 
 CPos IGUIObject::GetMousePos() const
 {
 	if (GetGUI())
 		return GetGUI()->m_MousePos;
 
 	return CPos();
 }
 
 void IGUIObject::UpdateMouseOver(IGUIObject* const& pMouseOver)
 {
 	if (pMouseOver == this)
 	{
 		if (!m_MouseHovering)
 			SendEvent(GUIM_MOUSE_ENTER, "mouseenter");
 
 		m_MouseHovering = true;
 
 		SendEvent(GUIM_MOUSE_OVER, "mousemove");
 	}
 	else
 	{
 		if (m_MouseHovering)
 		{
 			m_MouseHovering = false;
 			SendEvent(GUIM_MOUSE_LEAVE, "mouseleave");
 		}
 	}
 }
 
 bool IGUIObject::SettingExists(const CStr& Setting) const
 {
 	return m_Settings.count(Setting) == 1;
 }
 
 PSRETURN IGUIObject::SetSetting(const CStr& Setting, const CStrW& Value, const bool& SkipMessage)
 {
 	if (!SettingExists(Setting))
 		return PSRETURN_GUI_InvalidSetting;
 
 	if (!m_Settings[Setting]->FromString(Value, SkipMessage))
 		return PSRETURN_GUI_UnableToParse;
 
 	return PSRETURN_OK;
 }
 
 void IGUIObject::ChooseMouseOverAndClosest(IGUIObject*& pObject)
 {
 	if (!MouseOver())
 		return;
 
 	// Check if we've got competition at all
 	if (pObject == NULL)
 	{
 		pObject = this;
 		return;
 	}
 
 	// Or if it's closer
 	if (GetBufferedZ() >= pObject->GetBufferedZ())
 	{
 		pObject = this;
 		return;
 	}
 }
 
 IGUIObject* IGUIObject::GetParent() const
 {
 	// Important, we're not using GetParent() for these
 	//  checks, that could screw it up
 	if (m_pParent)
 	{
 		if (m_pParent->m_pParent == NULL)
 			return NULL;
 	}
 
 	return m_pParent;
 }
 
 void IGUIObject::ResetStates()
 {
 	// Notify the gui that we aren't hovered anymore
 	UpdateMouseOver(nullptr);
 }
 
 void IGUIObject::UpdateCachedSize()
 {
 	bool absolute;
 	GUI<bool>::GetSetting(this, "absolute", absolute);
 
 	float aspectratio = 0.f;
 	GUI<float>::GetSetting(this, "aspectratio", aspectratio);
 
 	CClientArea ca;
 	GUI<CClientArea>::GetSetting(this, "size", ca);
 
 	// If absolute="false" and the object has got a parent,
 	//  use its cached size instead of the screen. Notice
 	//  it must have just been cached for it to work.
 	if (absolute == false && m_pParent && !IsRootObject())
 		m_CachedActualSize = ca.GetClientArea(m_pParent->m_CachedActualSize);
 	else
 		m_CachedActualSize = ca.GetClientArea(CRect(0.f, 0.f, g_xres / g_GuiScale, g_yres / g_GuiScale));
 
 	// In a few cases, GUI objects have to resize to fill the screen
 	// but maintain a constant aspect ratio.
 	// Adjust the size to be the max possible, centered in the original size:
 	if (aspectratio)
 	{
 		if (m_CachedActualSize.GetWidth() > m_CachedActualSize.GetHeight()*aspectratio)
 		{
 			float delta = m_CachedActualSize.GetWidth() - m_CachedActualSize.GetHeight()*aspectratio;
 			m_CachedActualSize.left += delta/2.f;
 			m_CachedActualSize.right -= delta/2.f;
 		}
 		else
 		{
 			float delta = m_CachedActualSize.GetHeight() - m_CachedActualSize.GetWidth()/aspectratio;
 			m_CachedActualSize.bottom -= delta/2.f;
 			m_CachedActualSize.top += delta/2.f;
 		}
 	}
 }
 
 void IGUIObject::LoadStyle(CGUI& GUIinstance, const CStr& StyleName)
 {
 	// Fetch style
 	if (GUIinstance.m_Styles.count(StyleName) == 1)
 	{
 		LoadStyle(GUIinstance.m_Styles[StyleName]);
 	}
 	else
 	{
 		debug_warn(L"IGUIObject::LoadStyle failed");
 	}
 }
 
 void IGUIObject::LoadStyle(const SGUIStyle& Style)
 {
 	// Iterate settings, it won't be able to set them all probably, but that doesn't matter
 	for (const std::pair<CStr, CStrW>& p : Style.m_SettingsDefaults)
 	{
 		// Try set setting in object
 		SetSetting(p.first, p.second);
 
 		// It doesn't matter if it fail, it's not suppose to be able to set every setting.
 		//  since it's generic.
 
 		// The beauty with styles is that it can contain more settings
 		//  than exists for the objects using it. So if the SetSetting
 		//  fails, don't care.
 	}
 }
 
 float IGUIObject::GetBufferedZ() const
 {
 	bool absolute;
 	GUI<bool>::GetSetting(this, "absolute", absolute);
 
 	float Z;
 	GUI<float>::GetSetting(this, "z", Z);
 
 	if (absolute)
 		return Z;
 	else
 	{
 		if (GetParent())
 			return GetParent()->GetBufferedZ() + Z;
 		else
 		{
 			// In philosophy, a parentless object shouldn't be able to have a relative sizing,
 			//  but we'll accept it so that absolute can be used as default without a complaint.
 			//  Also, you could consider those objects children to the screen resolution.
 			return Z;
 		}
 	}
 }
 
 void IGUIObject::RegisterScriptHandler(const CStr& Action, const CStr& Code, CGUI* pGUI)
 {
 	if(!GetGUI())
 		throw PSERROR_GUI_OperationNeedsGUIObject();
 
 	JSContext* cx = pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue globalVal(cx, pGUI->GetGlobalObject());
 	JS::RootedObject globalObj(cx, &globalVal.toObject());
 
 	const int paramCount = 1;
 	const char* paramNames[paramCount] = { "mouse" };
 
 	// Location to report errors from
 	CStr CodeName = GetName()+" "+Action;
 
 	// Generate a unique name
 	static int x = 0;
 	char buf[64];
 	sprintf_s(buf, ARRAY_SIZE(buf), "__eventhandler%d (%s)", x++, Action.c_str());
 
 	JS::CompileOptions options(cx);
 	options.setFileAndLine(CodeName.c_str(), 0);
-	options.setIsRunOnce(true);
+	options.setIsRunOnce(false);
 
 	JS::RootedFunction func(cx);
 	JS::AutoObjectVector emptyScopeChain(cx);
 	if (!JS::CompileFunction(cx, emptyScopeChain, options, buf, paramCount, paramNames, Code.c_str(), Code.length(), &func))
 	{
 		LOGERROR("RegisterScriptHandler: Failed to compile the script for %s", Action.c_str());
 		return;
 	}
 
 	JS::RootedObject funcObj(cx, JS_GetFunctionObject(func));
 	SetScriptHandler(Action, funcObj);
 }
 
 void IGUIObject::SetScriptHandler(const CStr& Action, JS::HandleObject Function)
 {
 	ENSURE(m_pGUI && "A GUI must be associated with the GUIObject before adding ScriptHandlers!");
 
 	if (m_ScriptHandlers.empty())
 		JS_AddExtraGCRootsTracer(m_pGUI->GetScriptInterface()->GetJSRuntime(), Trace, this);
 
 	m_ScriptHandlers[Action] = JS::Heap<JSObject*>(Function);
 }
 
 InReaction IGUIObject::SendEvent(EGUIMessageType type, const CStr& EventName)
 {
 	PROFILE2_EVENT("gui event");
 	PROFILE2_ATTR("type: %s", EventName.c_str());
 	PROFILE2_ATTR("object: %s", m_Name.c_str());
 
 	SGUIMessage msg(type);
 	HandleMessage(msg);
 
 	ScriptEvent(EventName);
 
 	return (msg.skipped ? IN_PASS : IN_HANDLED);
 }
 
 void IGUIObject::ScriptEvent(const CStr& Action)
 {
 	std::map<CStr, JS::Heap<JSObject*> >::iterator it = m_ScriptHandlers.find(Action);
 	if (it == m_ScriptHandlers.end())
 		return;
 
 	JSContext* cx = m_pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 
 	// Set up the 'mouse' parameter
 	JS::RootedValue mouse(cx);
 
 	m_pGUI->GetScriptInterface()->CreateObject(
 		&mouse,
 		"x", m_pGUI->m_MousePos.x,
 		"y", m_pGUI->m_MousePos.y,
 		"buttons", m_pGUI->m_MouseButtons);
 
 	JS::AutoValueVector paramData(cx);
 	paramData.append(mouse);
 	JS::RootedObject obj(cx, GetJSObject());
 	JS::RootedValue handlerVal(cx, JS::ObjectValue(*it->second));
 	JS::RootedValue result(cx);
 	bool ok = JS_CallFunctionValue(cx, obj, handlerVal, paramData, &result);
 	if (!ok)
 	{
 		// We have no way to propagate the script exception, so just ignore it
 		// and hope the caller checks JS_IsExceptionPending
 	}
 }
 
 void IGUIObject::ScriptEvent(const CStr& Action, JS::HandleValueArray paramData)
 {
 	std::map<CStr, JS::Heap<JSObject*> >::iterator it = m_ScriptHandlers.find(Action);
 	if (it == m_ScriptHandlers.end())
 		return;
 
 	JSContext* cx = m_pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedObject obj(cx, GetJSObject());
 	JS::RootedValue handlerVal(cx, JS::ObjectValue(*it->second));
 	JS::RootedValue result(cx);
 
 	if (!JS_CallFunctionValue(cx, obj, handlerVal, paramData, &result))
 		JS_ReportError(cx, "Errors executing script action \"%s\"", Action.c_str());
 }
 
 void IGUIObject::CreateJSObject()
 {
 	JSContext* cx = m_pGUI->GetScriptInterface()->GetContext();
 	JSAutoRequest rq(cx);
 
 	m_JSObject.init(cx, m_pGUI->GetScriptInterface()->CreateCustomObject("GUIObject"));
 	JS_SetPrivate(m_JSObject.get(), this);
 }
 
 JSObject* IGUIObject::GetJSObject()
 {
 	// Cache the object when somebody first asks for it, because otherwise
 	// we end up doing far too much object allocation.
 	if (!m_JSObject.initialized())
 		CreateJSObject();
 
 	return m_JSObject.get();
 }
 
 CStr IGUIObject::GetPresentableName() const
 {
 	// __internal(), must be at least 13 letters to be able to be
 	//  an internal name
 	if (m_Name.length() <= 12)
 		return m_Name;
 
 	if (m_Name.substr(0, 10) == "__internal")
 		return CStr("[unnamed object]");
 	else
 		return m_Name;
 }
 
 void IGUIObject::SetFocus()
 {
 	GetGUI()->m_FocusedObject = this;
 }
 
 bool IGUIObject::IsFocused() const
 {
 	return GetGUI()->m_FocusedObject == this;
 }
 
 bool IGUIObject::IsRootObject() const
 {
 	return GetGUI() != 0 && m_pParent == GetGUI()->m_BaseObject;
 }
 
 void IGUIObject::TraceMember(JSTracer* trc)
 {
 	// Please ensure to adapt the Tracer enabling and disabling in accordance with the GC things traced!
 
 	for (std::pair<const CStr, JS::Heap<JSObject*>>& handler : m_ScriptHandlers)
 		JS_CallObjectTracer(trc, &handler.second, "IGUIObject::m_ScriptHandlers");
 }
 
 // Instantiate templated functions:
 #define TYPE(T) template void IGUIObject::AddSetting<T>(const CStr& Name);
 #include "GUItypes.h"
 #undef TYPE
Index: ps/trunk/source/scriptinterface/ScriptInterface.cpp
===================================================================
--- ps/trunk/source/scriptinterface/ScriptInterface.cpp	(revision 22628)
+++ ps/trunk/source/scriptinterface/ScriptInterface.cpp	(revision 22629)
@@ -1,1160 +1,1160 @@
 /* Copyright (C) 2019 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. 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.
  *
  * 0 A.D. 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 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "ScriptInterface.h"
 #include "ScriptRuntime.h"
 #include "ScriptStats.h"
 
 #include "lib/debug.h"
 #include "lib/utf8.h"
 #include "ps/CLogger.h"
 #include "ps/Filesystem.h"
 #include "ps/Profile.h"
 #include "ps/utf16string.h"
 
 #include <cassert>
 #include <map>
 
 #define BOOST_MULTI_INDEX_DISABLE_SERIALIZATION
 #include <boost/preprocessor/punctuation/comma_if.hpp>
 #include <boost/preprocessor/repetition/repeat.hpp>
 #include <boost/random/linear_congruential.hpp>
 #include <boost/flyweight.hpp>
 #include <boost/flyweight/key_value.hpp>
 #include <boost/flyweight/no_locking.hpp>
 #include <boost/flyweight/no_tracking.hpp>
 
 #include "valgrind.h"
 
 #include "scriptinterface/ScriptExtraHeaders.h"
 
 /**
  * @file
  * Abstractions of various SpiderMonkey features.
  * Engine code should be using functions of these interfaces rather than
  * directly accessing the underlying JS api.
  */
 
 
 struct ScriptInterface_impl
 {
 	ScriptInterface_impl(const char* nativeScopeName, const shared_ptr<ScriptRuntime>& runtime);
 	~ScriptInterface_impl();
 	void Register(const char* name, JSNative fptr, uint nargs) const;
 
 	// Take care to keep this declaration before heap rooted members. Destructors of heap rooted
 	// members have to be called before the runtime destructor.
 	shared_ptr<ScriptRuntime> m_runtime;
 
 	JSContext* m_cx;
 	JS::PersistentRootedObject m_glob; // global scope object
 	JSCompartment* m_comp;
 	boost::rand48* m_rng;
 	JS::PersistentRootedObject m_nativeScope; // native function scope object
 };
 
 namespace
 {
 
 JSClass global_class = {
 	"global", JSCLASS_GLOBAL_FLAGS,
 	nullptr, nullptr,
 	nullptr, nullptr,
 	nullptr, nullptr, nullptr,
 	nullptr, nullptr, nullptr, nullptr,
 	JS_GlobalObjectTraceHook
 };
 
 void ErrorReporter(JSContext* cx, const char* message, JSErrorReport* report)
 {
 	JSAutoRequest rq(cx);
 
 	std::stringstream msg;
 	bool isWarning = JSREPORT_IS_WARNING(report->flags);
 	msg << (isWarning ? "JavaScript warning: " : "JavaScript error: ");
 	if (report->filename)
 	{
 		msg << report->filename;
 		msg << " line " << report->lineno << "\n";
 	}
 
 	msg << message;
 
 	// If there is an exception, then print its stack trace
 	JS::RootedValue excn(cx);
 	if (JS_GetPendingException(cx, &excn) && excn.isObject())
 	{
 		JS::RootedValue stackVal(cx);
 		JS::RootedObject excnObj(cx, &excn.toObject());
 		JS_GetProperty(cx, excnObj, "stack", &stackVal);
 
 		std::string stackText;
 		ScriptInterface::FromJSVal(cx, stackVal, stackText);
 
 		std::istringstream stream(stackText);
 		for (std::string line; std::getline(stream, line);)
 			msg << "\n  " << line;
 	}
 
 	if (isWarning)
 		LOGWARNING("%s", msg.str().c_str());
 	else
 		LOGERROR("%s", msg.str().c_str());
 
 	// When running under Valgrind, print more information in the error message
 //	VALGRIND_PRINTF_BACKTRACE("->");
 }
 
 // Functions in the global namespace:
 
 bool print(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	for (uint i = 0; i < args.length(); ++i)
 	{
 		std::wstring str;
 		if (!ScriptInterface::FromJSVal(cx, args[i], str))
 			return false;
 		debug_printf("%s", utf8_from_wstring(str).c_str());
 	}
 	fflush(stdout);
 	args.rval().setUndefined();
 	return true;
 }
 
 bool logmsg(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	if (args.length() < 1)
 	{
 		args.rval().setUndefined();
 		return true;
 	}
 
 	std::wstring str;
 	if (!ScriptInterface::FromJSVal(cx, args[0], str))
 		return false;
 	LOGMESSAGE("%s", utf8_from_wstring(str));
 	args.rval().setUndefined();
 	return true;
 }
 
 bool warn(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	if (args.length() < 1)
 	{
 		args.rval().setUndefined();
 		return true;
 	}
 
 	std::wstring str;
 	if (!ScriptInterface::FromJSVal(cx, args[0], str))
 		return false;
 	LOGWARNING("%s", utf8_from_wstring(str));
 	args.rval().setUndefined();
 	return true;
 }
 
 bool error(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	if (args.length() < 1)
 	{
 		args.rval().setUndefined();
 		return true;
 	}
 
 	std::wstring str;
 	if (!ScriptInterface::FromJSVal(cx, args[0], str))
 		return false;
 	LOGERROR("%s", utf8_from_wstring(str));
 	args.rval().setUndefined();
 	return true;
 }
 
 bool deepcopy(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JSAutoRequest rq(cx);
 
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	if (args.length() < 1)
 	{
 		args.rval().setUndefined();
 		return true;
 	}
 
 	JS::RootedValue ret(cx);
 	if (!JS_StructuredClone(cx, args[0], &ret, NULL, NULL))
 		return false;
 
 	args.rval().set(ret);
 	return true;
 }
 
 bool deepfreeze(JSContext* cx, uint argc, JS::Value* vp)
 {
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 
 	if (args.length() != 1 || !args.get(0).isObject())
 	{
 		JS_ReportError(cx, "deepfreeze requires exactly one object as an argument.");
 		return false;
 	}
 
 	ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface->FreezeObject(args.get(0), true);
 	args.rval().set(args.get(0));
 	return true;
 }
 
 bool ProfileStart(JSContext* cx, uint argc, JS::Value* vp)
 {
 	const char* name = "(ProfileStart)";
 
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	if (args.length() >= 1)
 	{
 		std::string str;
 		if (!ScriptInterface::FromJSVal(cx, args[0], str))
 			return false;
 
 		typedef boost::flyweight<
 			std::string,
 			boost::flyweights::no_tracking,
 			boost::flyweights::no_locking
 		> StringFlyweight;
 
 		name = StringFlyweight(str).get().c_str();
 	}
 
 	if (CProfileManager::IsInitialised() && ThreadUtil::IsMainThread())
 		g_Profiler.StartScript(name);
 
 	g_Profiler2.RecordRegionEnter(name);
 
 	args.rval().setUndefined();
 	return true;
 }
 
 bool ProfileStop(JSContext* UNUSED(cx), uint UNUSED(argc), JS::Value* vp)
 {
 	JS::CallReceiver rec = JS::CallReceiverFromVp(vp);
 	if (CProfileManager::IsInitialised() && ThreadUtil::IsMainThread())
 		g_Profiler.Stop();
 
 	g_Profiler2.RecordRegionLeave();
 
 	rec.rval().setUndefined();
 	return true;
 }
 
 bool ProfileAttribute(JSContext* cx, uint argc, JS::Value* vp)
 {
 	const char* name = "(ProfileAttribute)";
 
 	JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
 	if (args.length() >= 1)
 	{
 		std::string str;
 		if (!ScriptInterface::FromJSVal(cx, args[0], str))
 			return false;
 
 		typedef boost::flyweight<
 			std::string,
 			boost::flyweights::no_tracking,
 			boost::flyweights::no_locking
 		> StringFlyweight;
 
 		name = StringFlyweight(str).get().c_str();
 	}
 
 	g_Profiler2.RecordAttribute("%s", name);
 
 	args.rval().setUndefined();
 	return true;
 }
 
 // Math override functions:
 
 // boost::uniform_real is apparently buggy in Boost pre-1.47 - for integer generators
 // it returns [min,max], not [min,max). The bug was fixed in 1.47.
 // We need consistent behaviour, so manually implement the correct version:
 static double generate_uniform_real(boost::rand48& rng, double min, double max)
 {
 	while (true)
 	{
 		double n = (double)(rng() - rng.min());
 		double d = (double)(rng.max() - rng.min()) + 1.0;
 		ENSURE(d > 0 && n >= 0 && n <= d);
 		double r = n / d * (max - min) + min;
 		if (r < max)
 			return r;
 	}
 }
 
 bool Math_random(JSContext* cx, uint UNUSED(argc), JS::Value* vp)
 {
 	JS::CallReceiver rec = JS::CallReceiverFromVp(vp);
 	double r;
 	if (!ScriptInterface::GetScriptInterfaceAndCBData(cx)->pScriptInterface->MathRandom(r))
 		return false;
 
 	rec.rval().setNumber(r);
 	return true;
 }
 
 } // anonymous namespace
 
 bool ScriptInterface::MathRandom(double& nbr)
 {
 	if (m->m_rng == NULL)
 		return false;
 	nbr = generate_uniform_real(*(m->m_rng), 0.0, 1.0);
 	return true;
 }
 
 ScriptInterface_impl::ScriptInterface_impl(const char* nativeScopeName, const shared_ptr<ScriptRuntime>& runtime) :
 	m_runtime(runtime), m_glob(runtime->m_rt), m_nativeScope(runtime->m_rt)
 {
 	bool ok;
 
 	m_cx = JS_NewContext(m_runtime->m_rt, STACK_CHUNK_SIZE);
 	ENSURE(m_cx);
 
 	JS_SetOffthreadIonCompilationEnabled(m_runtime->m_rt, true);
 
 	// For GC debugging:
 	// JS_SetGCZeal(m_cx, 2, JS_DEFAULT_ZEAL_FREQ);
 
 	JS_SetContextPrivate(m_cx, NULL);
 
 	JS_SetErrorReporter(m_runtime->m_rt, ErrorReporter);
 
 	JS_SetGlobalJitCompilerOption(m_runtime->m_rt, JSJITCOMPILER_ION_ENABLE, 1);
 	JS_SetGlobalJitCompilerOption(m_runtime->m_rt, JSJITCOMPILER_BASELINE_ENABLE, 1);
 
 	JS::RuntimeOptionsRef(m_cx)
 		.setExtraWarnings(true)
 		.setWerror(false)
 		.setStrictMode(true);
 
 	JS::CompartmentOptions opt;
 	opt.setVersion(JSVERSION_LATEST);
 	// Keep JIT code during non-shrinking GCs. This brings a quite big performance improvement.
 	opt.setPreserveJitCode(true);
 
 	JSAutoRequest rq(m_cx);
 	JS::RootedObject globalRootedVal(m_cx, JS_NewGlobalObject(m_cx, &global_class, NULL, JS::OnNewGlobalHookOption::FireOnNewGlobalHook, opt));
 	m_comp = JS_EnterCompartment(m_cx, globalRootedVal);
 	ok = JS_InitStandardClasses(m_cx, globalRootedVal);
 	ENSURE(ok);
 	m_glob = globalRootedVal.get();
 
 	JS_DefineProperty(m_cx, m_glob, "global", globalRootedVal, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 
 	m_nativeScope = JS_DefineObject(m_cx, m_glob, nativeScopeName, nullptr, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 
 	JS_DefineFunction(m_cx, globalRootedVal, "print", ::print,        0, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 	JS_DefineFunction(m_cx, globalRootedVal, "log",   ::logmsg,       1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 	JS_DefineFunction(m_cx, globalRootedVal, "warn",  ::warn,         1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 	JS_DefineFunction(m_cx, globalRootedVal, "error", ::error,        1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 	JS_DefineFunction(m_cx, globalRootedVal, "clone", ::deepcopy,        1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 	JS_DefineFunction(m_cx, globalRootedVal, "deepfreeze", ::deepfreeze, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
 
 	Register("ProfileStart", ::ProfileStart, 1);
 	Register("ProfileStop", ::ProfileStop, 0);
 	Register("ProfileAttribute", ::ProfileAttribute, 1);
 
 	runtime->RegisterContext(m_cx);
 }
 
 ScriptInterface_impl::~ScriptInterface_impl()
 {
 	m_runtime->UnRegisterContext(m_cx);
 	{
 		JSAutoRequest rq(m_cx);
 		JS_LeaveCompartment(m_cx, m_comp);
 	}
 	JS_DestroyContext(m_cx);
 }
 
 void ScriptInterface_impl::Register(const char* name, JSNative fptr, uint nargs) const
 {
 	JSAutoRequest rq(m_cx);
 	JS::RootedObject nativeScope(m_cx, m_nativeScope);
 	JS::RootedFunction func(m_cx, JS_DefineFunction(m_cx, nativeScope, name, fptr, nargs, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT));
 }
 
 ScriptInterface::ScriptInterface(const char* nativeScopeName, const char* debugName, const shared_ptr<ScriptRuntime>& runtime) :
 	m(new ScriptInterface_impl(nativeScopeName, runtime))
 {
 	// Profiler stats table isn't thread-safe, so only enable this on the main thread
 	if (ThreadUtil::IsMainThread())
 	{
 		if (g_ScriptStatsTable)
 			g_ScriptStatsTable->Add(this, debugName);
 	}
 
 	m_CxPrivate.pScriptInterface = this;
 	JS_SetContextPrivate(m->m_cx, (void*)&m_CxPrivate);
 }
 
 ScriptInterface::~ScriptInterface()
 {
 	if (ThreadUtil::IsMainThread())
 	{
 		if (g_ScriptStatsTable)
 			g_ScriptStatsTable->Remove(this);
 	}
 }
 
 void ScriptInterface::SetCallbackData(void* pCBData)
 {
 	m_CxPrivate.pCBData = pCBData;
 }
 
 ScriptInterface::CxPrivate* ScriptInterface::GetScriptInterfaceAndCBData(JSContext* cx)
 {
 	CxPrivate* pCxPrivate = (CxPrivate*)JS_GetContextPrivate(cx);
 	return pCxPrivate;
 }
 
 
 bool ScriptInterface::LoadGlobalScripts()
 {
 	// Ignore this failure in tests
 	if (!g_VFS)
 		return false;
 
 	// Load and execute *.js in the global scripts directory
 	VfsPaths pathnames;
 	vfs::GetPathnames(g_VFS, L"globalscripts/", L"*.js", pathnames);
 	for (const VfsPath& path : pathnames)
 		if (!LoadGlobalScriptFile(path))
 		{
 			LOGERROR("LoadGlobalScripts: Failed to load script %s", path.string8());
 			return false;
 		}
 
 	return true;
 }
 
 bool ScriptInterface::ReplaceNondeterministicRNG(boost::rand48& rng)
 {
 	JSAutoRequest rq(m->m_cx);
 	JS::RootedValue math(m->m_cx);
 	JS::RootedObject global(m->m_cx, m->m_glob);
 	if (JS_GetProperty(m->m_cx, global, "Math", &math) && math.isObject())
 	{
 		JS::RootedObject mathObj(m->m_cx, &math.toObject());
 		JS::RootedFunction random(m->m_cx, JS_DefineFunction(m->m_cx, mathObj, "random", Math_random, 0,
 			JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT));
 		if (random)
 		{
 			m->m_rng = &rng;
 			return true;
 		}
 	}
 
 	LOGERROR("ReplaceNondeterministicRNG: failed to replace Math.random");
 	return false;
 }
 
 void ScriptInterface::Register(const char* name, JSNative fptr, size_t nargs) const
 {
 	m->Register(name, fptr, (uint)nargs);
 }
 
 JSContext* ScriptInterface::GetContext() const
 {
 	return m->m_cx;
 }
 
 JSRuntime* ScriptInterface::GetJSRuntime() const
 {
 	return m->m_runtime->m_rt;
 }
 
 shared_ptr<ScriptRuntime> ScriptInterface::GetRuntime() const
 {
 	return m->m_runtime;
 }
 
 void ScriptInterface::CallConstructor(JS::HandleValue ctor, JS::HandleValueArray argv, JS::MutableHandleValue out) const
 {
 	JSAutoRequest rq(m->m_cx);
 	if (!ctor.isObject())
 	{
 		LOGERROR("CallConstructor: ctor is not an object");
 		out.setNull();
 		return;
 	}
 
 	JS::RootedObject ctorObj(m->m_cx, &ctor.toObject());
 	out.setObjectOrNull(JS_New(m->m_cx, ctorObj, argv));
 }
 
 void ScriptInterface::DefineCustomObjectType(JSClass *clasp, JSNative constructor, uint minArgs, JSPropertySpec *ps, JSFunctionSpec *fs, JSPropertySpec *static_ps, JSFunctionSpec *static_fs)
 {
 	JSAutoRequest rq(m->m_cx);
 	std::string typeName = clasp->name;
 
 	if (m_CustomObjectTypes.find(typeName) != m_CustomObjectTypes.end())
 	{
 		// This type already exists
 		throw PSERROR_Scripting_DefineType_AlreadyExists();
 	}
 
 	JS::RootedObject global(m->m_cx, m->m_glob);
 	JS::RootedObject obj(m->m_cx, JS_InitClass(m->m_cx, global, nullptr,
 	                                           clasp,
 	                                           constructor, minArgs,     // Constructor, min args
 	                                           ps, fs,                   // Properties, methods
 	                                           static_ps, static_fs));   // Constructor properties, methods
 
 	if (obj == NULL)
 		throw PSERROR_Scripting_DefineType_CreationFailed();
 
 	CustomType& type = m_CustomObjectTypes[typeName];
 
 	type.m_Prototype.init(m->m_cx, obj);
 	type.m_Class = clasp;
 	type.m_Constructor = constructor;
 }
 
 JSObject* ScriptInterface::CreateCustomObject(const std::string& typeName) const
 {
 	std::map<std::string, CustomType>::const_iterator it = m_CustomObjectTypes.find(typeName);
 
 	if (it == m_CustomObjectTypes.end())
 		throw PSERROR_Scripting_TypeDoesNotExist();
 
 	JS::RootedObject prototype(m->m_cx, it->second.m_Prototype.get());
 	return JS_NewObjectWithGivenProto(m->m_cx, it->second.m_Class, prototype);
 }
 
 bool ScriptInterface::CallFunction_(JS::HandleValue val, const char* name, JS::HandleValueArray argv, JS::MutableHandleValue ret) const
 {
 	JSAutoRequest rq(m->m_cx);
 	JS::RootedObject obj(m->m_cx);
 	if (!JS_ValueToObject(m->m_cx, val, &obj) || !obj)
 		return false;
 
 	// Check that the named function actually exists, to avoid ugly JS error reports
 	// when calling an undefined value
 	bool found;
 	if (!JS_HasProperty(m->m_cx, obj, name, &found) || !found)
 		return false;
 
 	bool ok = JS_CallFunctionName(m->m_cx, obj, name, argv, ret);
 
 	return ok;
 }
 
 bool ScriptInterface::CreateObject(JS::MutableHandleValue objectValue) const
 {
 	JSContext* cx = GetContext();
 	JSAutoRequest rq(cx);
 
 	objectValue.setObjectOrNull(JS_NewPlainObject(cx));
 	if (!objectValue.isObject())
 		throw PSERROR_Scripting_CreateObjectFailed();
 
 	return true;
 }
 
 void ScriptInterface::CreateArray(JS::MutableHandleValue objectValue, size_t length) const
 {
 	JSContext* cx = GetContext();
 	JSAutoRequest rq(cx);
 
 	objectValue.setObjectOrNull(JS_NewArrayObject(cx, length));
 	if (!objectValue.isObject())
 		throw PSERROR_Scripting_CreateObjectFailed();
 }
 
 JS::Value ScriptInterface::GetGlobalObject() const
 {
 	JSAutoRequest rq(m->m_cx);
 	return JS::ObjectValue(*JS::CurrentGlobalOrNull(m->m_cx));
 }
 
 bool ScriptInterface::SetGlobal_(const char* name, JS::HandleValue value, bool replace, bool constant, bool enumerate)
 {
 	JSAutoRequest rq(m->m_cx);
 	JS::RootedObject global(m->m_cx, m->m_glob);
 
 	bool found;
 	if (!JS_HasProperty(m->m_cx, global, name, &found))
 		return false;
 	if (found)
 	{
 		JS::Rooted<JSPropertyDescriptor> desc(m->m_cx);
 		if (!JS_GetOwnPropertyDescriptor(m->m_cx, global, name, &desc))
 			return false;
 
 		if (!desc.writable())
 		{
 			if (!replace)
 			{
 				JS_ReportError(m->m_cx, "SetGlobal \"%s\" called multiple times", name);
 				return false;
 			}
 
 			// This is not supposed to happen, unless the user has called SetProperty with constant = true on the global object
 			// instead of using SetGlobal.
 			if (!desc.configurable())
 			{
 				JS_ReportError(m->m_cx, "The global \"%s\" is permanent and cannot be hotloaded", name);
 				return false;
 			}
 
 			LOGMESSAGE("Hotloading new value for global \"%s\".", name);
 			ENSURE(JS_DeleteProperty(m->m_cx, global, name));
 		}
 	}
 
 	uint attrs = 0;
 	if (constant)
 		attrs |= JSPROP_READONLY;
 	if (enumerate)
 		attrs |= JSPROP_ENUMERATE;
 
 	return JS_DefineProperty(m->m_cx, global, name, value, attrs);
 }
 
 bool ScriptInterface::SetProperty_(JS::HandleValue obj, const char* name, JS::HandleValue value, bool constant, bool enumerate) const
 {
 	JSAutoRequest rq(m->m_cx);
 	uint attrs = 0;
 	if (constant)
 		attrs |= JSPROP_READONLY | JSPROP_PERMANENT;
 	if (enumerate)
 		attrs |= JSPROP_ENUMERATE;
 
 	if (!obj.isObject())
 		return false;
 	JS::RootedObject object(m->m_cx, &obj.toObject());
 
 	if (!JS_DefineProperty(m->m_cx, object, name, value, attrs))
 		return false;
 	return true;
 }
 
 bool ScriptInterface::SetProperty_(JS::HandleValue obj, const wchar_t* name, JS::HandleValue value, bool constant, bool enumerate) const
 {
 	JSAutoRequest rq(m->m_cx);
 	uint attrs = 0;
 	if (constant)
 		attrs |= JSPROP_READONLY | JSPROP_PERMANENT;
 	if (enumerate)
 		attrs |= JSPROP_ENUMERATE;
 
 	if (!obj.isObject())
 		return false;
 	JS::RootedObject object(m->m_cx, &obj.toObject());
 
 	utf16string name16(name, name + wcslen(name));
 	if (!JS_DefineUCProperty(m->m_cx, object, reinterpret_cast<const char16_t*>(name16.c_str()), name16.length(), value, attrs))
 		return false;
 	return true;
 }
 
 bool ScriptInterface::SetPropertyInt_(JS::HandleValue obj, int name, JS::HandleValue value, bool constant, bool enumerate) const
 {
 	JSAutoRequest rq(m->m_cx);
 	uint attrs = 0;
 	if (constant)
 		attrs |= JSPROP_READONLY | JSPROP_PERMANENT;
 	if (enumerate)
 		attrs |= JSPROP_ENUMERATE;
 
 	if (!obj.isObject())
 		return false;
 	JS::RootedObject object(m->m_cx, &obj.toObject());
 
 	JS::RootedId id(m->m_cx, INT_TO_JSID(name));
 	if (!JS_DefinePropertyById(m->m_cx, object, id, value, attrs))
 		return false;
 	return true;
 }
 
 bool ScriptInterface::GetProperty(JS::HandleValue obj, const char* name, JS::MutableHandleValue out) const
 {
 	return GetProperty_(obj, name, out);
 }
 
 bool ScriptInterface::GetProperty(JS::HandleValue obj, const char* name, JS::MutableHandleObject out) const
 {
 	JSContext* cx = GetContext();
 	JSAutoRequest rq(cx);
 	JS::RootedValue val(cx);
 	if (!GetProperty_(obj, name, &val))
 		return false;
 	if (!val.isObject())
 	{
 		LOGERROR("GetProperty failed: trying to get an object, but the property is not an object!");
 		return false;
 	}
 
 	out.set(&val.toObject());
 	return true;
 }
 
 bool ScriptInterface::GetPropertyInt(JS::HandleValue obj, int name, JS::MutableHandleValue out) const
 {
 	return GetPropertyInt_(obj, name, out);
 }
 
 bool ScriptInterface::GetProperty_(JS::HandleValue obj, const char* name, JS::MutableHandleValue out) const
 {
 	JSAutoRequest rq(m->m_cx);
 	if (!obj.isObject())
 		return false;
 	JS::RootedObject object(m->m_cx, &obj.toObject());
 
 	if (!JS_GetProperty(m->m_cx, object, name, out))
 		return false;
 	return true;
 }
 
 bool ScriptInterface::GetPropertyInt_(JS::HandleValue obj, int name, JS::MutableHandleValue out) const
 {
 	JSAutoRequest rq(m->m_cx);
 	JS::RootedId nameId(m->m_cx, INT_TO_JSID(name));
 	if (!obj.isObject())
 		return false;
 	JS::RootedObject object(m->m_cx, &obj.toObject());
 
 	if (!JS_GetPropertyById(m->m_cx, object, nameId, out))
 		return false;
 	return true;
 }
 
 bool ScriptInterface::HasProperty(JS::HandleValue obj, const char* name) const
 {
 	// TODO: proper errorhandling
 	JSAutoRequest rq(m->m_cx);
 	if (!obj.isObject())
 		return false;
 	JS::RootedObject object(m->m_cx, &obj.toObject());
 
 	bool found;
 	if (!JS_HasProperty(m->m_cx, object, name, &found))
 		return false;
 	return found;
 }
 
 bool ScriptInterface::EnumeratePropertyNamesWithPrefix(JS::HandleValue objVal, const char* prefix, std::vector<std::string>& out) const
 {
 	JSAutoRequest rq(m->m_cx);
 
 	if (!objVal.isObjectOrNull())
 	{
 		LOGERROR("EnumeratePropertyNamesWithPrefix expected object type!");
 		return false;
 	}
 
 	if (objVal.isNull())
 		return true; // reached the end of the prototype chain
 
 	JS::RootedObject obj(m->m_cx, &objVal.toObject());
 	JS::Rooted<JS::IdVector> props(m->m_cx, JS::IdVector(m->m_cx));
 	if (!JS_Enumerate(m->m_cx, obj, &props))
 		return false;
 
 	for (size_t i = 0; i < props.length(); ++i)
 	{
 		JS::RootedId id(m->m_cx, props[i]);
 		JS::RootedValue val(m->m_cx);
 		if (!JS_IdToValue(m->m_cx, id, &val))
 			return false;
 
 		if (!val.isString())
 			continue; // ignore integer properties
 
 		JS::RootedString name(m->m_cx, val.toString());
 		size_t len = strlen(prefix)+1;
 		std::vector<char> buf(len);
 		size_t prefixLen = strlen(prefix) * sizeof(char);
 		JS_EncodeStringToBuffer(m->m_cx, name, &buf[0], prefixLen);
 		buf[len-1]= '\0';
 		if (0 == strcmp(&buf[0], prefix))
 		{
 			if (JS_StringHasLatin1Chars(name))
 			{
 				size_t length;
 				JS::AutoCheckCannotGC nogc;
 				const JS::Latin1Char* chars = JS_GetLatin1StringCharsAndLength(m->m_cx, nogc, name, &length);
 				if (chars)
 					out.push_back(std::string(chars, chars+length));
 			}
 			else
 			{
 				size_t length;
 				JS::AutoCheckCannotGC nogc;
 				const char16_t* chars = JS_GetTwoByteStringCharsAndLength(m->m_cx, nogc, name, &length);
 				if (chars)
 					out.push_back(std::string(chars, chars+length));
 			}
 		}
 	}
 
 	// Recurse up the prototype chain
 	JS::RootedObject prototype(m->m_cx);
 	if (JS_GetPrototype(m->m_cx, obj, &prototype))
 	{
 		JS::RootedValue prototypeVal(m->m_cx, JS::ObjectOrNullValue(prototype));
 		if (!EnumeratePropertyNamesWithPrefix(prototypeVal, prefix, out))
 			return false;
 	}
 
 	return true;
 }
 
 bool ScriptInterface::SetPrototype(JS::HandleValue objVal, JS::HandleValue protoVal)
 {
 	JSAutoRequest rq(m->m_cx);
 	if (!objVal.isObject() || !protoVal.isObject())
 		return false;
 	JS::RootedObject obj(m->m_cx, &objVal.toObject());
 	JS::RootedObject proto(m->m_cx, &protoVal.toObject());
 	return JS_SetPrototype(m->m_cx, obj, proto);
 }
 
 bool ScriptInterface::FreezeObject(JS::HandleValue objVal, bool deep) const
 {
 	JSAutoRequest rq(m->m_cx);
 	if (!objVal.isObject())
 		return false;
 
 	JS::RootedObject obj(m->m_cx, &objVal.toObject());
 
 	if (deep)
 		return JS_DeepFreezeObject(m->m_cx, obj);
 	else
 		return JS_FreezeObject(m->m_cx, obj);
 }
 
 bool ScriptInterface::LoadScript(const VfsPath& filename, const std::string& code) const
 {
 	JSAutoRequest rq(m->m_cx);
 	JS::RootedObject global(m->m_cx, m->m_glob);
 	utf16string codeUtf16(code.begin(), code.end());
 	uint lineNo = 1;
 	// CompileOptions does not copy the contents of the filename string pointer.
 	// Passing a temporary string there will cause undefined behaviour, so we create a separate string to avoid the temporary.
 	std::string filenameStr = filename.string8();
 
 	JS::CompileOptions options(m->m_cx);
 	options.setFileAndLine(filenameStr.c_str(), lineNo);
-	options.setIsRunOnce(true);
+	options.setIsRunOnce(false);
 
 	JS::RootedFunction func(m->m_cx);
 	JS::AutoObjectVector emptyScopeChain(m->m_cx);
 	if (!JS::CompileFunction(m->m_cx, emptyScopeChain, options, NULL, 0, NULL,
 	                         reinterpret_cast<const char16_t*>(codeUtf16.c_str()), (uint)(codeUtf16.length()), &func))
 		return false;
 
 	JS::RootedValue rval(m->m_cx);
 	return JS_CallFunction(m->m_cx, nullptr, func, JS::HandleValueArray::empty(), &rval);
 }
 
 shared_ptr<ScriptRuntime> ScriptInterface::CreateRuntime(shared_ptr<ScriptRuntime> parentRuntime, int runtimeSize, int heapGrowthBytesGCTrigger)
 {
 	return shared_ptr<ScriptRuntime>(new ScriptRuntime(parentRuntime, runtimeSize, heapGrowthBytesGCTrigger));
 }
 
 bool ScriptInterface::LoadGlobalScript(const VfsPath& filename, const std::wstring& code) const
 {
 	JSAutoRequest rq(m->m_cx);
 	utf16string codeUtf16(code.begin(), code.end());
 	uint lineNo = 1;
 	// CompileOptions does not copy the contents of the filename string pointer.
 	// Passing a temporary string there will cause undefined behaviour, so we create a separate string to avoid the temporary.
 	std::string filenameStr = filename.string8();
 
 	JS::RootedValue rval(m->m_cx);
 	JS::CompileOptions opts(m->m_cx);
 	opts.setFileAndLine(filenameStr.c_str(), lineNo);
 	return JS::Evaluate(m->m_cx, opts,
 			reinterpret_cast<const char16_t*>(codeUtf16.c_str()), (uint)(codeUtf16.length()), &rval);
 }
 
 bool ScriptInterface::LoadGlobalScriptFile(const VfsPath& path) const
 {
 	JSAutoRequest rq(m->m_cx);
 	if (!VfsFileExists(path))
 	{
 		LOGERROR("File '%s' does not exist", path.string8());
 		return false;
 	}
 
 	CVFSFile file;
 
 	PSRETURN ret = file.Load(g_VFS, path);
 
 	if (ret != PSRETURN_OK)
 	{
 		LOGERROR("Failed to load file '%s': %s", path.string8(), GetErrorString(ret));
 		return false;
 	}
 
 	std::wstring code = wstring_from_utf8(file.DecodeUTF8()); // assume it's UTF-8
 
 	utf16string codeUtf16(code.begin(), code.end());
 	uint lineNo = 1;
 	// CompileOptions does not copy the contents of the filename string pointer.
 	// Passing a temporary string there will cause undefined behaviour, so we create a separate string to avoid the temporary.
 	std::string filenameStr = path.string8();
 
 	JS::RootedValue rval(m->m_cx);
 	JS::CompileOptions opts(m->m_cx);
 	opts.setFileAndLine(filenameStr.c_str(), lineNo);
 	return JS::Evaluate(m->m_cx, opts,
 			reinterpret_cast<const char16_t*>(codeUtf16.c_str()), (uint)(codeUtf16.length()), &rval);
 }
 
 bool ScriptInterface::Eval(const char* code) const
 {
 	JSAutoRequest rq(m->m_cx);
 	JS::RootedValue rval(m->m_cx);
 	return Eval_(code, &rval);
 }
 
 bool ScriptInterface::Eval_(const char* code, JS::MutableHandleValue rval) const
 {
 	JSAutoRequest rq(m->m_cx);
 	utf16string codeUtf16(code, code+strlen(code));
 
 	JS::CompileOptions opts(m->m_cx);
 	opts.setFileAndLine("(eval)", 1);
 	return JS::Evaluate(m->m_cx, opts, reinterpret_cast<const char16_t*>(codeUtf16.c_str()), (uint)codeUtf16.length(), rval);
 }
 
 bool ScriptInterface::Eval_(const wchar_t* code, JS::MutableHandleValue rval) const
 {
 	JSAutoRequest rq(m->m_cx);
 	utf16string codeUtf16(code, code+wcslen(code));
 
 	JS::CompileOptions opts(m->m_cx);
 	opts.setFileAndLine("(eval)", 1);
 	return JS::Evaluate(m->m_cx, opts, reinterpret_cast<const char16_t*>(codeUtf16.c_str()), (uint)codeUtf16.length(), rval);
 }
 
 bool ScriptInterface::ParseJSON(const std::string& string_utf8, JS::MutableHandleValue out) const
 {
 	JSAutoRequest rq(m->m_cx);
 	std::wstring attrsW = wstring_from_utf8(string_utf8);
  	utf16string string(attrsW.begin(), attrsW.end());
 	if (JS_ParseJSON(m->m_cx, reinterpret_cast<const char16_t*>(string.c_str()), (u32)string.size(), out))
 		return true;
 
 	LOGERROR("JS_ParseJSON failed!");
 	if (!JS_IsExceptionPending(m->m_cx))
 		return false;
 
 	JS::RootedValue exc(m->m_cx);
 	if (!JS_GetPendingException(m->m_cx, &exc))
 		return false;
 
 	JS_ClearPendingException(m->m_cx);
 	// We expect an object of type SyntaxError
 	if (!exc.isObject())
 		return false;
 
 	JS::RootedValue rval(m->m_cx);
 	JS::RootedObject excObj(m->m_cx, &exc.toObject());
 	if (!JS_CallFunctionName(m->m_cx, excObj, "toString", JS::HandleValueArray::empty(), &rval))
 		return false;
 
 	std::wstring error;
 	ScriptInterface::FromJSVal(m->m_cx, rval, error);
 	LOGERROR("%s", utf8_from_wstring(error));
 	return false;
 }
 
 void ScriptInterface::ReadJSONFile(const VfsPath& path, JS::MutableHandleValue out) const
 {
 	if (!VfsFileExists(path))
 	{
 		LOGERROR("File '%s' does not exist", path.string8());
 		return;
 	}
 
 	CVFSFile file;
 
 	PSRETURN ret = file.Load(g_VFS, path);
 
 	if (ret != PSRETURN_OK)
 	{
 		LOGERROR("Failed to load file '%s': %s", path.string8(), GetErrorString(ret));
 		return;
 	}
 
 	std::string content(file.DecodeUTF8()); // assume it's UTF-8
 
 	if (!ParseJSON(content, out))
 		LOGERROR("Failed to parse '%s'", path.string8());
 }
 
 struct Stringifier
 {
 	static bool callback(const char16_t* buf, u32 len, void* data)
 	{
 		utf16string str(buf, buf+len);
 		std::wstring strw(str.begin(), str.end());
 
 		Status err; // ignore Unicode errors
 		static_cast<Stringifier*>(data)->stream << utf8_from_wstring(strw, &err);
 		return true;
 	}
 
 	std::stringstream stream;
 };
 
 // TODO: It's not quite clear why JS_Stringify needs JS::MutableHandleValue. |obj| should not get modified.
 // It probably has historical reasons and could be changed by SpiderMonkey in the future.
 std::string ScriptInterface::StringifyJSON(JS::MutableHandleValue obj, bool indent) const
 {
 	JSAutoRequest rq(m->m_cx);
 	Stringifier str;
 	JS::RootedValue indentVal(m->m_cx, indent ? JS::Int32Value(2) : JS::UndefinedValue());
 	if (!JS_Stringify(m->m_cx, obj, nullptr, indentVal, &Stringifier::callback, &str))
 	{
 		JS_ClearPendingException(m->m_cx);
 		LOGERROR("StringifyJSON failed");
 		return std::string();
 	}
 
 	return str.stream.str();
 }
 
 
 std::string ScriptInterface::ToString(JS::MutableHandleValue obj, bool pretty) const
 {
 	JSAutoRequest rq(m->m_cx);
 
 	if (obj.isUndefined())
 		return "(void 0)";
 
 	// Try to stringify as JSON if possible
 	// (TODO: this is maybe a bad idea since it'll drop 'undefined' values silently)
 	if (pretty)
 	{
 		Stringifier str;
 		JS::RootedValue indentVal(m->m_cx, JS::Int32Value(2));
 
 		// Temporary disable the error reporter, so we don't print complaints about cyclic values
 		JSErrorReporter er = JS_SetErrorReporter(m->m_runtime->m_rt, NULL);
 
 		bool ok = JS_Stringify(m->m_cx, obj, nullptr, indentVal, &Stringifier::callback, &str);
 
 		// Restore error reporter
 		JS_SetErrorReporter(m->m_runtime->m_rt, er);
 
 		if (ok)
 			return str.stream.str();
 
 		// Clear the exception set when Stringify failed
 		JS_ClearPendingException(m->m_cx);
 	}
 
 	// Caller didn't want pretty output, or JSON conversion failed (e.g. due to cycles),
 	// so fall back to obj.toSource()
 
 	std::wstring source = L"(error)";
 	CallFunction(obj, "toSource", source);
 	return utf8_from_wstring(source);
 }
 
 void ScriptInterface::ReportError(const char* msg) const
 {
 	JSAutoRequest rq(m->m_cx);
 	// JS_ReportError by itself doesn't seem to set a JS-style exception, and so
 	// script callers will be unable to catch anything. So use JS_SetPendingException
 	// to make sure there really is a script-level exception. But just set it to undefined
 	// because there's not much value yet in throwing a real exception object.
 	JS_SetPendingException(m->m_cx, JS::UndefinedHandleValue);
 	// And report the actual error
 	JS_ReportError(m->m_cx, "%s", msg);
 
 	// TODO: Why doesn't JS_ReportPendingException(m->m_cx); work?
 }
 
 bool ScriptInterface::IsExceptionPending(JSContext* cx)
 {
 	JSAutoRequest rq(cx);
 	return JS_IsExceptionPending(cx) ? true : false;
 }
 
 const JSClass* ScriptInterface::GetClass(JS::HandleObject obj)
 {
 	return JS_GetClass(obj);
 }
 
 void* ScriptInterface::GetPrivate(JS::HandleObject obj)
 {
 	// TODO: use JS_GetInstancePrivate
 	return JS_GetPrivate(obj);
 }
 
 JS::Value ScriptInterface::CloneValueFromOtherContext(const ScriptInterface& otherContext, JS::HandleValue val) const
 {
 	PROFILE("CloneValueFromOtherContext");
 	JSAutoRequest rq(m->m_cx);
 	JS::RootedValue out(m->m_cx);
 	shared_ptr<StructuredClone> structuredClone = otherContext.WriteStructuredClone(val);
 	ReadStructuredClone(structuredClone, &out);
 	return out.get();
 }
 
 ScriptInterface::StructuredClone::StructuredClone() :
 	m_Data(NULL), m_Size(0)
 {
 }
 
 ScriptInterface::StructuredClone::~StructuredClone()
 {
 	if (m_Data)
 		JS_ClearStructuredClone(m_Data, m_Size, NULL, NULL);
 }
 
 shared_ptr<ScriptInterface::StructuredClone> ScriptInterface::WriteStructuredClone(JS::HandleValue v) const
 {
 	JSAutoRequest rq(m->m_cx);
 	u64* data = NULL;
 	size_t nbytes = 0;
 	if (!JS_WriteStructuredClone(m->m_cx, v, &data, &nbytes, NULL, NULL, JS::UndefinedHandleValue))
 	{
 		debug_warn(L"Writing a structured clone with JS_WriteStructuredClone failed!");
 		return shared_ptr<StructuredClone>();
 	}
 
 	shared_ptr<StructuredClone> ret(new StructuredClone);
 	ret->m_Data = data;
 	ret->m_Size = nbytes;
 	return ret;
 }
 
 void ScriptInterface::ReadStructuredClone(const shared_ptr<ScriptInterface::StructuredClone>& ptr, JS::MutableHandleValue ret) const
 {
 	JSAutoRequest rq(m->m_cx);
 	JS_ReadStructuredClone(m->m_cx, ptr->m_Data, ptr->m_Size, JS_STRUCTURED_CLONE_VERSION, ret, NULL, NULL);
 }