Ykkrosh
d7ec8c47a6
Fix EncryptPassword being called with the wrong argument order, and encrypting username instead of password. (This will break all existing lobby accounts.) Fix EncryptPassword not using all of salt_base. This was SVN commit r14123.
1357 lines
36 KiB
C++
1357 lines
36 KiB
C++
/* Copyright (C) 2013 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 "DebuggingServer.h"
|
|
#include "ScriptStats.h"
|
|
#include "AutoRooters.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"
|
|
|
|
#define STACK_CHUNK_SIZE 8192
|
|
|
|
#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.
|
|
*/
|
|
|
|
////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Abstraction around a SpiderMonkey JSRuntime.
|
|
* Each ScriptRuntime can be used to initialize several ScriptInterface
|
|
* contexts which can then share data, but a single ScriptRuntime should
|
|
* only be used on a single thread.
|
|
*
|
|
* (One means to share data between threads and runtimes is to create
|
|
* a ScriptInterface::StructuredClone.)
|
|
*/
|
|
class ScriptRuntime
|
|
{
|
|
public:
|
|
ScriptRuntime(int runtimeSize) :
|
|
m_rooter(NULL), m_compartmentGlobal(NULL)
|
|
{
|
|
m_rt = JS_NewRuntime(runtimeSize);
|
|
ENSURE(m_rt); // TODO: error handling
|
|
|
|
if (g_ScriptProfilingEnabled)
|
|
{
|
|
// Profiler isn't thread-safe, so only enable this on the main thread
|
|
if (ThreadUtil::IsMainThread())
|
|
{
|
|
if (CProfileManager::IsInitialised())
|
|
{
|
|
JS_SetExecuteHook(m_rt, jshook_script, this);
|
|
JS_SetCallHook(m_rt, jshook_function, this);
|
|
}
|
|
}
|
|
}
|
|
|
|
JS_SetExtraGCRoots(m_rt, jshook_trace, this);
|
|
}
|
|
|
|
~ScriptRuntime()
|
|
{
|
|
JS_DestroyRuntime(m_rt);
|
|
}
|
|
|
|
JSRuntime* m_rt;
|
|
AutoGCRooter* m_rooter;
|
|
|
|
JSObject* m_compartmentGlobal;
|
|
|
|
private:
|
|
|
|
|
|
static void* jshook_script(JSContext* UNUSED(cx), JSStackFrame* UNUSED(fp), JSBool before, JSBool* UNUSED(ok), void* closure)
|
|
{
|
|
if (before)
|
|
g_Profiler.StartScript("script invocation");
|
|
else
|
|
g_Profiler.Stop();
|
|
|
|
return closure;
|
|
}
|
|
|
|
// To profile scripts usefully, we use a call hook that's called on every enter/exit,
|
|
// and need to find the function name. But most functions are anonymous so we make do
|
|
// with filename plus line number instead.
|
|
// Computing the names is fairly expensive, and we need to return an interned char*
|
|
// for the profiler to hold a copy of, so we use boost::flyweight to construct interned
|
|
// strings per call location.
|
|
|
|
// Identifies a location in a script
|
|
struct ScriptLocation
|
|
{
|
|
JSContext* cx;
|
|
JSScript* script;
|
|
jsbytecode* pc;
|
|
|
|
bool operator==(const ScriptLocation& b) const
|
|
{
|
|
return cx == b.cx && script == b.script && pc == b.pc;
|
|
}
|
|
|
|
friend std::size_t hash_value(const ScriptLocation& loc)
|
|
{
|
|
std::size_t seed = 0;
|
|
boost::hash_combine(seed, loc.cx);
|
|
boost::hash_combine(seed, loc.script);
|
|
boost::hash_combine(seed, loc.pc);
|
|
return seed;
|
|
}
|
|
};
|
|
|
|
// Computes and stores the name of a location in a script
|
|
struct ScriptLocationName
|
|
{
|
|
ScriptLocationName(const ScriptLocation& loc)
|
|
{
|
|
JSContext* cx = loc.cx;
|
|
JSScript* script = loc.script;
|
|
jsbytecode* pc = loc.pc;
|
|
|
|
std::string filename = JS_GetScriptFilename(cx, script);
|
|
size_t slash = filename.rfind('/');
|
|
if (slash != filename.npos)
|
|
filename = filename.substr(slash+1);
|
|
|
|
uintN line = JS_PCToLineNumber(cx, script, pc);
|
|
|
|
std::stringstream ss;
|
|
ss << "(" << filename << ":" << line << ")";
|
|
name = ss.str();
|
|
}
|
|
|
|
std::string name;
|
|
};
|
|
|
|
// Flyweight types (with no_locking because the call hooks are only used in the
|
|
// main thread, and no_tracking because we mustn't delete values the profiler is
|
|
// using and it's not going to waste much memory)
|
|
typedef boost::flyweight<
|
|
std::string,
|
|
boost::flyweights::no_tracking,
|
|
boost::flyweights::no_locking
|
|
> StringFlyweight;
|
|
typedef boost::flyweight<
|
|
boost::flyweights::key_value<ScriptLocation, ScriptLocationName>,
|
|
boost::flyweights::no_tracking,
|
|
boost::flyweights::no_locking
|
|
> LocFlyweight;
|
|
|
|
static void* jshook_function(JSContext* cx, JSStackFrame* fp, JSBool before, JSBool* UNUSED(ok), void* closure)
|
|
{
|
|
if (!before)
|
|
{
|
|
g_Profiler.Stop();
|
|
return closure;
|
|
}
|
|
|
|
JSFunction* fn = JS_GetFrameFunction(cx, fp);
|
|
if (!fn)
|
|
{
|
|
g_Profiler.StartScript("(function)");
|
|
return closure;
|
|
}
|
|
|
|
// Try to get the name of non-anonymous functions
|
|
JSString* name = JS_GetFunctionId(fn);
|
|
if (name)
|
|
{
|
|
char* chars = JS_EncodeString(cx, name);
|
|
if (chars)
|
|
{
|
|
g_Profiler.StartScript(StringFlyweight(chars).get().c_str());
|
|
JS_free(cx, chars);
|
|
return closure;
|
|
}
|
|
}
|
|
|
|
// No name - compute from the location instead
|
|
ScriptLocation loc = { cx, JS_GetFrameScript(cx, fp), JS_GetFramePC(cx, fp) };
|
|
g_Profiler.StartScript(LocFlyweight(loc).get().name.c_str());
|
|
|
|
return closure;
|
|
}
|
|
|
|
static void jshook_trace(JSTracer* trc, void* data)
|
|
{
|
|
ScriptRuntime* m = static_cast<ScriptRuntime*>(data);
|
|
|
|
if (m->m_rooter)
|
|
m->m_rooter->Trace(trc);
|
|
}
|
|
};
|
|
|
|
shared_ptr<ScriptRuntime> ScriptInterface::CreateRuntime(int runtimeSize)
|
|
{
|
|
return shared_ptr<ScriptRuntime>(new ScriptRuntime(runtimeSize));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////
|
|
|
|
struct ScriptInterface_impl
|
|
{
|
|
ScriptInterface_impl(const char* nativeScopeName, const shared_ptr<ScriptRuntime>& runtime);
|
|
~ScriptInterface_impl();
|
|
void Register(const char* name, JSNative fptr, uintN nargs);
|
|
|
|
shared_ptr<ScriptRuntime> m_runtime;
|
|
JSContext* m_cx;
|
|
JSObject* m_glob; // global scope object
|
|
JSObject* m_nativeScope; // native function scope object
|
|
JSCrossCompartmentCall* m_call;
|
|
};
|
|
|
|
namespace
|
|
{
|
|
|
|
JSClass global_class = {
|
|
"global", JSCLASS_GLOBAL_FLAGS,
|
|
JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_StrictPropertyStub,
|
|
JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, JS_FinalizeStub,
|
|
NULL, NULL, NULL, NULL,
|
|
NULL, NULL, NULL, NULL
|
|
};
|
|
|
|
void ErrorReporter(JSContext* cx, const char* message, JSErrorReport* report)
|
|
{
|
|
// XXX Ugly hack: we want to compile code with 'use strict' and with JSOPTION_STRICT,
|
|
// but the latter causes the former to be reported as a useless expression, so
|
|
// ignore that specific warning here
|
|
if (report->flags == 5 && report->lineno == 0 && report->errorNumber == 163)
|
|
return;
|
|
|
|
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
|
|
jsval excn;
|
|
if (JS_GetPendingException(cx, &excn) && JSVAL_IS_OBJECT(excn))
|
|
{
|
|
// TODO: this violates the docs ("The error reporter callback must not reenter the JSAPI.")
|
|
|
|
// Hide the exception from EvaluateScript
|
|
JSExceptionState* excnState = JS_SaveExceptionState(cx);
|
|
JS_ClearPendingException(cx);
|
|
|
|
jsval rval;
|
|
const char dumpStack[] = "this.stack.trimRight().replace(/^/mg, ' ')"; // indent each line
|
|
if (JS_EvaluateScript(cx, JSVAL_TO_OBJECT(excn), dumpStack, ARRAY_SIZE(dumpStack)-1, "(eval)", 1, &rval))
|
|
{
|
|
std::string stackTrace;
|
|
if (ScriptInterface::FromJSVal(cx, rval, stackTrace))
|
|
msg << "\n" << stackTrace;
|
|
|
|
JS_RestoreExceptionState(cx, excnState);
|
|
}
|
|
else
|
|
{
|
|
// Error got replaced by new exception from EvaluateScript
|
|
JS_DropExceptionState(cx, excnState);
|
|
}
|
|
}
|
|
|
|
if (isWarning)
|
|
LOGWARNING(L"%hs", msg.str().c_str());
|
|
else
|
|
LOGERROR(L"%hs", msg.str().c_str());
|
|
|
|
// When running under Valgrind, print more information in the error message
|
|
// VALGRIND_PRINTF_BACKTRACE("->");
|
|
}
|
|
|
|
// Functions in the global namespace:
|
|
|
|
JSBool print(JSContext* cx, uintN argc, jsval* vp)
|
|
{
|
|
for (uintN i = 0; i < argc; ++i)
|
|
{
|
|
std::string str;
|
|
if (!ScriptInterface::FromJSVal(cx, JS_ARGV(cx, vp)[i], str))
|
|
return JS_FALSE;
|
|
debug_printf(L"%hs", str.c_str());
|
|
}
|
|
fflush(stdout);
|
|
JS_SET_RVAL(cx, vp, JSVAL_VOID);
|
|
return JS_TRUE;
|
|
}
|
|
|
|
JSBool logmsg(JSContext* cx, uintN argc, jsval* vp)
|
|
{
|
|
if (argc < 1)
|
|
{
|
|
JS_SET_RVAL(cx, vp, JSVAL_VOID);
|
|
return JS_TRUE;
|
|
}
|
|
|
|
std::wstring str;
|
|
if (!ScriptInterface::FromJSVal(cx, JS_ARGV(cx, vp)[0], str))
|
|
return JS_FALSE;
|
|
LOGMESSAGE(L"%ls", str.c_str());
|
|
JS_SET_RVAL(cx, vp, JSVAL_VOID);
|
|
return JS_TRUE;
|
|
}
|
|
|
|
JSBool warn(JSContext* cx, uintN argc, jsval* vp)
|
|
{
|
|
if (argc < 1)
|
|
{
|
|
JS_SET_RVAL(cx, vp, JSVAL_VOID);
|
|
return JS_TRUE;
|
|
}
|
|
|
|
std::wstring str;
|
|
if (!ScriptInterface::FromJSVal(cx, JS_ARGV(cx, vp)[0], str))
|
|
return JS_FALSE;
|
|
LOGWARNING(L"%ls", str.c_str());
|
|
JS_SET_RVAL(cx, vp, JSVAL_VOID);
|
|
return JS_TRUE;
|
|
}
|
|
|
|
JSBool error(JSContext* cx, uintN argc, jsval* vp)
|
|
{
|
|
if (argc < 1)
|
|
{
|
|
JS_SET_RVAL(cx, vp, JSVAL_VOID);
|
|
return JS_TRUE;
|
|
}
|
|
|
|
std::wstring str;
|
|
if (!ScriptInterface::FromJSVal(cx, JS_ARGV(cx, vp)[0], str))
|
|
return JS_FALSE;
|
|
LOGERROR(L"%ls", str.c_str());
|
|
JS_SET_RVAL(cx, vp, JSVAL_VOID);
|
|
return JS_TRUE;
|
|
}
|
|
|
|
JSBool deepcopy(JSContext* cx, uintN argc, jsval* vp)
|
|
{
|
|
if (argc < 1)
|
|
{
|
|
JS_SET_RVAL(cx, vp, JSVAL_VOID);
|
|
return JS_TRUE;
|
|
}
|
|
|
|
jsval ret;
|
|
|
|
// We'd usually do:
|
|
// if (!JS_StructuredClone(cx, JS_ARGV(cx, vp)[0], &ret, NULL, NULL))
|
|
// return JS_FALSE;
|
|
// but that function is broken in the 1.8.5 release
|
|
// (https://bugzilla.mozilla.org/show_bug.cgi?id=651510)
|
|
// so do an equivalent operation with a different API:
|
|
JSAutoStructuredCloneBuffer buf;
|
|
if (!buf.write(cx, JS_ARGV(cx, vp)[0]) || !buf.read(&ret, cx))
|
|
return JS_FALSE;
|
|
|
|
JS_SET_RVAL(cx, vp, ret);
|
|
return JS_TRUE;
|
|
}
|
|
|
|
JSBool ProfileStart(JSContext* cx, uintN argc, jsval* vp)
|
|
{
|
|
const char* name = "(ProfileStart)";
|
|
|
|
if (argc >= 1)
|
|
{
|
|
std::string str;
|
|
if (!ScriptInterface::FromJSVal(cx, JS_ARGV(cx, vp)[0], str))
|
|
return JS_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);
|
|
|
|
JS_SET_RVAL(cx, vp, JSVAL_VOID);
|
|
return JS_TRUE;
|
|
}
|
|
|
|
JSBool ProfileStop(JSContext* UNUSED(cx), uintN UNUSED(argc), jsval* vp)
|
|
{
|
|
if (CProfileManager::IsInitialised() && ThreadUtil::IsMainThread())
|
|
g_Profiler.Stop();
|
|
|
|
g_Profiler2.RecordRegionLeave("(ProfileStop)");
|
|
|
|
JS_SET_RVAL(cx, vp, JSVAL_VOID);
|
|
return JS_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;
|
|
}
|
|
}
|
|
|
|
JSBool Math_random(JSContext* cx, uintN UNUSED(argc), jsval* vp)
|
|
{
|
|
// Grab the RNG that was hidden in our slot
|
|
jsval rngp;
|
|
if (!JS_GetReservedSlot(cx, JSVAL_TO_OBJECT(JS_CALLEE(cx, vp)), 0, &rngp))
|
|
return JS_FALSE;
|
|
boost::rand48* rng = static_cast<boost::rand48*>(JSVAL_TO_PRIVATE(rngp));
|
|
|
|
double r = generate_uniform_real(*rng, 0.0, 1.0);
|
|
|
|
jsval rv;
|
|
if (!JS_NewNumberValue(cx, r, &rv))
|
|
return JS_FALSE;
|
|
JS_SET_RVAL(cx, vp, rv);
|
|
return JS_TRUE;
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
ScriptInterface_impl::ScriptInterface_impl(const char* nativeScopeName, const shared_ptr<ScriptRuntime>& runtime) :
|
|
m_runtime(runtime)
|
|
{
|
|
JSBool ok;
|
|
|
|
m_cx = JS_NewContext(m_runtime->m_rt, STACK_CHUNK_SIZE);
|
|
ENSURE(m_cx);
|
|
|
|
// For GC debugging:
|
|
// JS_SetGCZeal(m_cx, 2);
|
|
|
|
JS_SetContextPrivate(m_cx, NULL);
|
|
|
|
JS_SetErrorReporter(m_cx, ErrorReporter);
|
|
|
|
uint32 options = 0;
|
|
options |= JSOPTION_STRICT; // "warn on dubious practice"
|
|
options |= JSOPTION_XML; // "ECMAScript for XML support: parse <!-- --> as a token"
|
|
options |= JSOPTION_VAROBJFIX; // "recommended" (fixes variable scoping)
|
|
|
|
// Enable method JIT, unless script profiling/debugging is enabled (since profiling/debugging
|
|
// hooks are incompatible with the JIT)
|
|
// TODO: Verify what exactly is incompatible
|
|
if (!g_ScriptProfilingEnabled && !g_JSDebuggerEnabled)
|
|
{
|
|
options |= JSOPTION_METHODJIT;
|
|
|
|
// Some other JIT flags to experiment with:
|
|
options |= JSOPTION_JIT;
|
|
options |= JSOPTION_PROFILING;
|
|
}
|
|
|
|
JS_SetOptions(m_cx, options);
|
|
|
|
JS_SetVersion(m_cx, JSVERSION_LATEST);
|
|
|
|
// Threadsafe SpiderMonkey requires that we have a request before doing anything much
|
|
JS_BeginRequest(m_cx);
|
|
|
|
// We only want a single compartment per runtime
|
|
if (m_runtime->m_compartmentGlobal)
|
|
{
|
|
m_call = JS_EnterCrossCompartmentCall(m_cx, m_runtime->m_compartmentGlobal);
|
|
m_glob = JS_NewGlobalObject(m_cx, &global_class);
|
|
}
|
|
else
|
|
{
|
|
m_call = NULL;
|
|
m_glob = JS_NewCompartmentAndGlobalObject(m_cx, &global_class, NULL);
|
|
m_runtime->m_compartmentGlobal = m_glob;
|
|
}
|
|
|
|
ok = JS_InitStandardClasses(m_cx, m_glob);
|
|
ENSURE(ok);
|
|
|
|
JS_DefineProperty(m_cx, m_glob, "global", OBJECT_TO_JSVAL(m_glob), NULL, NULL, JSPROP_ENUMERATE | JSPROP_READONLY
|
|
| JSPROP_PERMANENT);
|
|
|
|
m_nativeScope = JS_DefineObject(m_cx, m_glob, nativeScopeName, NULL, NULL, JSPROP_ENUMERATE | JSPROP_READONLY
|
|
| JSPROP_PERMANENT);
|
|
|
|
JS_DefineFunction(m_cx, m_glob, "print", ::print, 0, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
|
|
JS_DefineFunction(m_cx, m_glob, "log", ::logmsg, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
|
|
JS_DefineFunction(m_cx, m_glob, "warn", ::warn, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
|
|
JS_DefineFunction(m_cx, m_glob, "error", ::error, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
|
|
JS_DefineFunction(m_cx, m_glob, "deepcopy", ::deepcopy, 1, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
|
|
|
|
Register("ProfileStart", ::ProfileStart, 1);
|
|
Register("ProfileStop", ::ProfileStop, 0);
|
|
}
|
|
|
|
ScriptInterface_impl::~ScriptInterface_impl()
|
|
{
|
|
if (m_call)
|
|
JS_LeaveCrossCompartmentCall(m_call);
|
|
JS_EndRequest(m_cx);
|
|
JS_DestroyContext(m_cx);
|
|
}
|
|
|
|
void ScriptInterface_impl::Register(const char* name, JSNative fptr, uintN nargs)
|
|
{
|
|
JSFunction* func = JS_DefineFunction(m_cx, m_nativeScope, name, fptr, nargs, JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
|
|
|
|
if (!func)
|
|
return;
|
|
|
|
if (g_ScriptProfilingEnabled)
|
|
{
|
|
// Store the function name in a slot, so we can pass it to the profiler.
|
|
|
|
// Use a flyweight std::string because we can't assume the caller has
|
|
// a correctly-aligned string and that its lifetime is long enough
|
|
typedef boost::flyweight<
|
|
std::string,
|
|
boost::flyweights::no_tracking
|
|
// can't use no_locking; Register might be called in threads
|
|
> LockedStringFlyweight;
|
|
|
|
LockedStringFlyweight fw(name);
|
|
JS_SetReservedSlot(m_cx, JS_GetFunctionObject(func), 0, PRIVATE_TO_JSVAL((void*)fw.get().c_str()));
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
if (g_JSDebuggerEnabled && g_DebuggingServer != NULL)
|
|
{
|
|
if(!JS_SetDebugMode(GetContext(), true))
|
|
LOGERROR(L"Failed to set Spidermonkey to debug mode!");
|
|
else
|
|
g_DebuggingServer->RegisterScriptinterface(debugName, this);
|
|
}
|
|
}
|
|
|
|
ScriptInterface::~ScriptInterface()
|
|
{
|
|
if (ThreadUtil::IsMainThread())
|
|
{
|
|
if (g_ScriptStatsTable)
|
|
g_ScriptStatsTable->Remove(this);
|
|
}
|
|
|
|
// Unregister from the Debugger class
|
|
if (g_JSDebuggerEnabled && g_DebuggingServer != NULL)
|
|
g_DebuggingServer->UnRegisterScriptinterface(this);
|
|
}
|
|
|
|
void ScriptInterface::ShutDown()
|
|
{
|
|
JS_ShutDown();
|
|
}
|
|
|
|
void ScriptInterface::SetCallbackData(void* cbdata)
|
|
{
|
|
JS_SetContextPrivate(m->m_cx, cbdata);
|
|
}
|
|
|
|
void* ScriptInterface::GetCallbackData(JSContext* cx)
|
|
{
|
|
return JS_GetContextPrivate(cx);
|
|
}
|
|
|
|
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 (VfsPaths::iterator it = pathnames.begin(); it != pathnames.end(); ++it)
|
|
{
|
|
if (!LoadGlobalScriptFile(*it))
|
|
{
|
|
LOGERROR(L"LoadGlobalScripts: Failed to load script %ls", it->string().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ScriptInterface::ReplaceNondeterministicRNG(boost::rand48& rng)
|
|
{
|
|
jsval math;
|
|
if (JS_GetProperty(m->m_cx, m->m_glob, "Math", &math) && JSVAL_IS_OBJECT(math))
|
|
{
|
|
JSFunction* random = JS_DefineFunction(m->m_cx, JSVAL_TO_OBJECT(math), "random", Math_random, 0,
|
|
JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT);
|
|
if (random)
|
|
{
|
|
// Store the RNG in a slot which is sort-of-guaranteed to be unused by the JS engine
|
|
if (JS_SetReservedSlot(m->m_cx, JS_GetFunctionObject(random), 0, PRIVATE_TO_JSVAL(&rng)))
|
|
return true;
|
|
}
|
|
}
|
|
|
|
LOGERROR(L"ReplaceNondeterministicRNG: failed to replace Math.random");
|
|
return false;
|
|
}
|
|
|
|
void ScriptInterface::Register(const char* name, JSNative fptr, size_t nargs)
|
|
{
|
|
m->Register(name, fptr, (uintN)nargs);
|
|
}
|
|
|
|
JSContext* ScriptInterface::GetContext() const
|
|
{
|
|
return m->m_cx;
|
|
}
|
|
|
|
JSRuntime* ScriptInterface::GetRuntime() const
|
|
{
|
|
return m->m_runtime->m_rt;
|
|
}
|
|
|
|
AutoGCRooter* ScriptInterface::ReplaceAutoGCRooter(AutoGCRooter* rooter)
|
|
{
|
|
AutoGCRooter* ret = m->m_runtime->m_rooter;
|
|
m->m_runtime->m_rooter = rooter;
|
|
return ret;
|
|
}
|
|
|
|
|
|
jsval ScriptInterface::CallConstructor(jsval ctor, jsval arg)
|
|
{
|
|
if (!JSVAL_IS_OBJECT(ctor))
|
|
{
|
|
LOGERROR(L"CallConstructor: ctor is not an object");
|
|
return JSVAL_VOID;
|
|
}
|
|
|
|
return OBJECT_TO_JSVAL(JS_New(m->m_cx, JSVAL_TO_OBJECT(ctor), 1, &arg));
|
|
}
|
|
|
|
jsval ScriptInterface::NewObjectFromConstructor(jsval ctor)
|
|
{
|
|
// Get the constructor's prototype
|
|
// (Can't use JS_GetPrototype, since we want .prototype not .__proto__)
|
|
jsval protoVal;
|
|
if (!JS_GetProperty(m->m_cx, JSVAL_TO_OBJECT(ctor), "prototype", &protoVal))
|
|
{
|
|
LOGERROR(L"NewObjectFromConstructor: can't get prototype");
|
|
return JSVAL_VOID;
|
|
}
|
|
|
|
if (!JSVAL_IS_OBJECT(protoVal))
|
|
{
|
|
LOGERROR(L"NewObjectFromConstructor: prototype is not an object");
|
|
return JSVAL_VOID;
|
|
}
|
|
|
|
JSObject* proto = JSVAL_TO_OBJECT(protoVal);
|
|
JSObject* parent = JS_GetParent(m->m_cx, JSVAL_TO_OBJECT(ctor));
|
|
// TODO: rooting?
|
|
if (!proto || !parent)
|
|
{
|
|
LOGERROR(L"NewObjectFromConstructor: null proto/parent");
|
|
return JSVAL_VOID;
|
|
}
|
|
|
|
JSObject* obj = JS_NewObject(m->m_cx, NULL, proto, parent);
|
|
if (!obj)
|
|
{
|
|
LOGERROR(L"NewObjectFromConstructor: object creation failed");
|
|
return JSVAL_VOID;
|
|
}
|
|
|
|
return OBJECT_TO_JSVAL(obj);
|
|
}
|
|
|
|
bool ScriptInterface::CallFunctionVoid(jsval val, const char* name)
|
|
{
|
|
jsval jsRet;
|
|
return CallFunction_(val, name, 0, NULL, jsRet);
|
|
}
|
|
|
|
bool ScriptInterface::CallFunction_(jsval val, const char* name, size_t argc, jsval* argv, jsval& ret)
|
|
{
|
|
JSObject* obj;
|
|
if (!JS_ValueToObject(m->m_cx, val, &obj) || obj == NULL)
|
|
return false;
|
|
|
|
// Check that the named function actually exists, to avoid ugly JS error reports
|
|
// when calling an undefined value
|
|
JSBool found;
|
|
if (!JS_HasProperty(m->m_cx, obj, name, &found) || !found)
|
|
return false;
|
|
|
|
JSBool ok = JS_CallFunctionName(m->m_cx, obj, name, (uintN)argc, argv, &ret);
|
|
|
|
return ok ? true : false;
|
|
}
|
|
|
|
jsval ScriptInterface::GetGlobalObject()
|
|
{
|
|
return OBJECT_TO_JSVAL(JS_GetGlobalObject(m->m_cx));
|
|
}
|
|
|
|
JSClass* ScriptInterface::GetGlobalClass()
|
|
{
|
|
return &global_class;
|
|
}
|
|
|
|
bool ScriptInterface::SetGlobal_(const char* name, jsval value, bool replace)
|
|
{
|
|
if (!replace)
|
|
{
|
|
JSBool found;
|
|
if (!JS_HasProperty(m->m_cx, m->m_glob, name, &found))
|
|
return false;
|
|
if (found)
|
|
{
|
|
JS_ReportError(m->m_cx, "SetGlobal \"%s\" called multiple times", name);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
JSBool ok = JS_DefineProperty(m->m_cx, m->m_glob, name, value, NULL, NULL, JSPROP_ENUMERATE | JSPROP_READONLY
|
|
| JSPROP_PERMANENT);
|
|
return ok ? true : false;
|
|
}
|
|
|
|
bool ScriptInterface::SetProperty_(jsval obj, const char* name, jsval value, bool constant, bool enumerate)
|
|
{
|
|
uintN attrs = 0;
|
|
if (constant)
|
|
attrs |= JSPROP_READONLY | JSPROP_PERMANENT;
|
|
if (enumerate)
|
|
attrs |= JSPROP_ENUMERATE;
|
|
|
|
if (! JSVAL_IS_OBJECT(obj))
|
|
return false;
|
|
JSObject* object = JSVAL_TO_OBJECT(obj);
|
|
|
|
if (! JS_DefineProperty(m->m_cx, object, name, value, NULL, NULL, attrs))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool ScriptInterface::SetProperty_(jsval obj, const wchar_t* name, jsval value, bool constant, bool enumerate)
|
|
{
|
|
uintN attrs = 0;
|
|
if (constant)
|
|
attrs |= JSPROP_READONLY | JSPROP_PERMANENT;
|
|
if (enumerate)
|
|
attrs |= JSPROP_ENUMERATE;
|
|
|
|
if (! JSVAL_IS_OBJECT(obj))
|
|
return false;
|
|
JSObject* object = JSVAL_TO_OBJECT(obj);
|
|
|
|
utf16string name16(name, name + wcslen(name));
|
|
if (! JS_DefineUCProperty(m->m_cx, object, reinterpret_cast<const jschar*>(name16.c_str()), name16.length(), value, NULL, NULL, attrs))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool ScriptInterface::SetPropertyInt_(jsval obj, int name, jsval value, bool constant, bool enumerate)
|
|
{
|
|
uintN attrs = 0;
|
|
if (constant)
|
|
attrs |= JSPROP_READONLY | JSPROP_PERMANENT;
|
|
if (enumerate)
|
|
attrs |= JSPROP_ENUMERATE;
|
|
|
|
if (! JSVAL_IS_OBJECT(obj))
|
|
return false;
|
|
JSObject* object = JSVAL_TO_OBJECT(obj);
|
|
|
|
if (! JS_DefinePropertyById(m->m_cx, object, INT_TO_JSID(name), value, NULL, NULL, attrs))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool ScriptInterface::GetProperty_(jsval obj, const char* name, jsval& out)
|
|
{
|
|
if (! JSVAL_IS_OBJECT(obj))
|
|
return false;
|
|
JSObject* object = JSVAL_TO_OBJECT(obj);
|
|
|
|
if (!JS_GetProperty(m->m_cx, object, name, &out))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool ScriptInterface::GetPropertyInt_(jsval obj, int name, jsval& out)
|
|
{
|
|
if (! JSVAL_IS_OBJECT(obj))
|
|
return false;
|
|
JSObject* object = JSVAL_TO_OBJECT(obj);
|
|
|
|
if (!JS_GetPropertyById(m->m_cx, object, INT_TO_JSID(name), &out))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool ScriptInterface::HasProperty(jsval obj, const char* name)
|
|
{
|
|
if (! JSVAL_IS_OBJECT(obj))
|
|
return false;
|
|
JSObject* object = JSVAL_TO_OBJECT(obj);
|
|
|
|
JSBool found;
|
|
if (!JS_HasProperty(m->m_cx, object, name, &found))
|
|
return false;
|
|
return (found != JS_FALSE);
|
|
}
|
|
|
|
bool ScriptInterface::EnumeratePropertyNamesWithPrefix(jsval obj, const char* prefix, std::vector<std::string>& out)
|
|
{
|
|
utf16string prefix16 (prefix, prefix+strlen(prefix));
|
|
|
|
if (! JSVAL_IS_OBJECT(obj))
|
|
return false; // TODO: log error messages
|
|
|
|
JSObject* it = JS_NewPropertyIterator(m->m_cx, JSVAL_TO_OBJECT(obj));
|
|
if (!it)
|
|
return false;
|
|
|
|
while (true)
|
|
{
|
|
jsid idp;
|
|
jsval val;
|
|
if (! JS_NextProperty(m->m_cx, it, &idp) || ! JS_IdToValue(m->m_cx, idp, &val))
|
|
return false;
|
|
if (val == JSVAL_VOID)
|
|
break; // end of iteration
|
|
if (! JSVAL_IS_STRING(val))
|
|
continue; // ignore integer properties
|
|
|
|
JSString* name = JSVAL_TO_STRING(val);
|
|
size_t len;
|
|
const jschar* chars = JS_GetStringCharsAndLength(m->m_cx, name, &len);
|
|
if (chars && len >= prefix16.size() && memcmp(chars, prefix16.c_str(), prefix16.size()*2) == 0)
|
|
out.push_back(std::string(chars, chars+len)); // handles Unicode poorly
|
|
}
|
|
|
|
// Recurse up the prototype chain
|
|
JSObject* prototype = JS_GetPrototype(m->m_cx, JSVAL_TO_OBJECT(obj));
|
|
if (prototype)
|
|
{
|
|
if (! EnumeratePropertyNamesWithPrefix(OBJECT_TO_JSVAL(prototype), prefix, out))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ScriptInterface::SetPrototype(jsval obj, jsval proto)
|
|
{
|
|
if (!JSVAL_IS_OBJECT(obj) || !JSVAL_IS_OBJECT(proto))
|
|
return false;
|
|
return JS_SetPrototype(m->m_cx, JSVAL_TO_OBJECT(obj), JSVAL_TO_OBJECT(proto)) ? true : false;
|
|
}
|
|
|
|
bool ScriptInterface::FreezeObject(jsval obj, bool deep)
|
|
{
|
|
if (!JSVAL_IS_OBJECT(obj))
|
|
return false;
|
|
|
|
if (deep)
|
|
return JS_DeepFreezeObject(m->m_cx, JSVAL_TO_OBJECT(obj)) ? true : false;
|
|
else
|
|
return JS_FreezeObject(m->m_cx, JSVAL_TO_OBJECT(obj)) ? true : false;
|
|
}
|
|
|
|
bool ScriptInterface::LoadScript(const VfsPath& filename, const std::string& code)
|
|
{
|
|
// Compile the code in strict mode, to encourage better coding practices and
|
|
// to possibly help SpiderMonkey with optimisations
|
|
std::wstring codeStrict = L"\"use strict\";\n" + wstring_from_utf8(code);
|
|
utf16string codeUtf16(codeStrict.begin(), codeStrict.end());
|
|
uintN lineNo = 0; // put the automatic 'use strict' on line 0, so the real code starts at line 1
|
|
|
|
JSFunction* func = JS_CompileUCFunction(m->m_cx, NULL, NULL, 0, NULL,
|
|
reinterpret_cast<const jschar*> (codeUtf16.c_str()), (uintN)(codeUtf16.length()),
|
|
utf8_from_wstring(filename.string()).c_str(), lineNo);
|
|
|
|
if (!func)
|
|
return false;
|
|
|
|
jsval scriptRval;
|
|
JSBool ok = JS_CallFunction(m->m_cx, NULL, func, 0, NULL, &scriptRval);
|
|
|
|
return ok ? true : false;
|
|
}
|
|
|
|
bool ScriptInterface::LoadGlobalScript(const VfsPath& filename, const std::string& code)
|
|
{
|
|
// Compile the code in strict mode, to encourage better coding practices and
|
|
// to possibly help SpiderMonkey with optimisations
|
|
std::wstring codeStrict = L"\"use strict\";\n" + wstring_from_utf8(code);
|
|
utf16string codeUtf16(codeStrict.begin(), codeStrict.end());
|
|
uintN lineNo = 0; // put the automatic 'use strict' on line 0, so the real code starts at line 1
|
|
|
|
jsval rval;
|
|
JSBool ok = JS_EvaluateUCScript(m->m_cx, m->m_glob,
|
|
reinterpret_cast<const jschar*> (codeUtf16.c_str()), (uintN)(codeUtf16.length()),
|
|
utf8_from_wstring(filename.string()).c_str(), lineNo, &rval);
|
|
|
|
return ok ? true : false;
|
|
}
|
|
|
|
bool ScriptInterface::LoadGlobalScriptFile(const VfsPath& path)
|
|
{
|
|
if (!VfsFileExists(path))
|
|
{
|
|
LOGERROR(L"File '%ls' does not exist", path.string().c_str());
|
|
return false;
|
|
}
|
|
|
|
CVFSFile file;
|
|
|
|
PSRETURN ret = file.Load(g_VFS, path);
|
|
|
|
if (ret != PSRETURN_OK)
|
|
{
|
|
LOGERROR(L"Failed to load file '%ls': %hs", path.string().c_str(), GetErrorString(ret));
|
|
return false;
|
|
}
|
|
|
|
std::wstring code = wstring_from_utf8(file.DecodeUTF8()); // assume it's UTF-8
|
|
|
|
// Compile the code in strict mode, to encourage better coding practices and
|
|
// to possibly help SpiderMonkey with optimisations
|
|
std::wstring codeStrict = L"\"use strict\";\n" + code;
|
|
utf16string codeUtf16(codeStrict.begin(), codeStrict.end());
|
|
uintN lineNo = 0; // put the automatic 'use strict' on line 0, so the real code starts at line 1
|
|
|
|
jsval rval;
|
|
JSBool ok = JS_EvaluateUCScript(m->m_cx, m->m_glob,
|
|
reinterpret_cast<const jschar*> (codeUtf16.c_str()), (uintN)(codeUtf16.length()),
|
|
utf8_from_wstring(path.string()).c_str(), lineNo, &rval);
|
|
|
|
return ok ? true : false;
|
|
}
|
|
|
|
|
|
bool ScriptInterface::Eval(const char* code)
|
|
{
|
|
jsval rval;
|
|
return Eval_(code, rval);
|
|
}
|
|
|
|
bool ScriptInterface::Eval_(const char* code, jsval& rval)
|
|
{
|
|
utf16string codeUtf16(code, code+strlen(code));
|
|
|
|
JSBool ok = JS_EvaluateUCScript(m->m_cx, m->m_glob, (const jschar*)codeUtf16.c_str(), (uintN)codeUtf16.length(), "(eval)", 1, &rval);
|
|
return ok ? true : false;
|
|
}
|
|
|
|
bool ScriptInterface::Eval_(const wchar_t* code, jsval& rval)
|
|
{
|
|
utf16string codeUtf16(code, code+wcslen(code));
|
|
|
|
JSBool ok = JS_EvaluateUCScript(m->m_cx, m->m_glob, (const jschar*)codeUtf16.c_str(), (uintN)codeUtf16.length(), "(eval)", 1, &rval);
|
|
return ok ? true : false;
|
|
}
|
|
|
|
CScriptValRooted ScriptInterface::ParseJSON(const std::string& string_utf8)
|
|
{
|
|
std::wstring attrsW = wstring_from_utf8(string_utf8);
|
|
utf16string string(attrsW.begin(), attrsW.end());
|
|
|
|
jsval vp;
|
|
JSONParser* parser = JS_BeginJSONParse(m->m_cx, &vp);
|
|
if (!parser)
|
|
{
|
|
LOGERROR(L"ParseJSON failed to begin");
|
|
return CScriptValRooted();
|
|
}
|
|
|
|
if (!JS_ConsumeJSONText(m->m_cx, parser, reinterpret_cast<const jschar*>(string.c_str()), (uint32)string.size()))
|
|
{
|
|
LOGERROR(L"ParseJSON failed to consume");
|
|
return CScriptValRooted();
|
|
}
|
|
|
|
if (!JS_FinishJSONParse(m->m_cx, parser, JSVAL_NULL))
|
|
{
|
|
LOGERROR(L"ParseJSON failed to finish");
|
|
return CScriptValRooted();
|
|
}
|
|
|
|
return CScriptValRooted(m->m_cx, vp);
|
|
}
|
|
|
|
CScriptValRooted ScriptInterface::ReadJSONFile(const VfsPath& path)
|
|
{
|
|
if (!VfsFileExists(path))
|
|
{
|
|
LOGERROR(L"File '%ls' does not exist", path.string().c_str());
|
|
return CScriptValRooted();
|
|
}
|
|
|
|
CVFSFile file;
|
|
|
|
PSRETURN ret = file.Load(g_VFS, path);
|
|
|
|
if (ret != PSRETURN_OK)
|
|
{
|
|
LOGERROR(L"Failed to load file '%ls': %hs", path.string().c_str(), GetErrorString(ret));
|
|
return CScriptValRooted();
|
|
}
|
|
|
|
std::string content(file.DecodeUTF8()); // assume it's UTF-8
|
|
|
|
return ParseJSON(content);
|
|
}
|
|
|
|
struct Stringifier
|
|
{
|
|
static JSBool callback(const jschar* buf, uint32 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 JS_TRUE;
|
|
}
|
|
|
|
std::stringstream stream;
|
|
};
|
|
|
|
struct StringifierW
|
|
{
|
|
static JSBool callback(const jschar* buf, uint32 len, void* data)
|
|
{
|
|
utf16string str(buf, buf+len);
|
|
static_cast<StringifierW*>(data)->stream << std::wstring(str.begin(), str.end());
|
|
return JS_TRUE;
|
|
}
|
|
|
|
std::wstringstream stream;
|
|
};
|
|
|
|
std::string ScriptInterface::StringifyJSON(jsval obj, bool indent)
|
|
{
|
|
Stringifier str;
|
|
if (!JS_Stringify(m->m_cx, &obj, NULL, indent ? INT_TO_JSVAL(2) : JSVAL_VOID, &Stringifier::callback, &str))
|
|
{
|
|
JS_ClearPendingException(m->m_cx);
|
|
LOGERROR(L"StringifyJSON failed");
|
|
JS_ClearPendingException(m->m_cx);
|
|
return std::string();
|
|
}
|
|
|
|
return str.stream.str();
|
|
}
|
|
|
|
|
|
std::wstring ScriptInterface::ToString(jsval obj, bool pretty)
|
|
{
|
|
if (JSVAL_IS_VOID(obj))
|
|
return L"(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)
|
|
{
|
|
StringifierW str;
|
|
|
|
// Temporary disable the error reporter, so we don't print complaints about cyclic values
|
|
JSErrorReporter er = JS_SetErrorReporter(m->m_cx, NULL);
|
|
|
|
bool ok = JS_Stringify(m->m_cx, &obj, NULL, INT_TO_JSVAL(2), &StringifierW::callback, &str) == JS_TRUE;
|
|
|
|
// Restore error reporter
|
|
JS_SetErrorReporter(m->m_cx, 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 source;
|
|
}
|
|
|
|
void ScriptInterface::ReportError(const char* msg)
|
|
{
|
|
// 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, JSVAL_VOID);
|
|
// 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)
|
|
{
|
|
return JS_IsExceptionPending(cx) ? true : false;
|
|
}
|
|
|
|
JSClass* ScriptInterface::GetClass(JSContext* cx, JSObject* obj)
|
|
{
|
|
UNUSED2(cx); // unused if not JS_THREADSAFE
|
|
|
|
return JS_GET_CLASS(cx, obj);
|
|
}
|
|
|
|
void* ScriptInterface::GetPrivate(JSContext* cx, JSObject* obj)
|
|
{
|
|
// TODO: use JS_GetInstancePrivate
|
|
return JS_GetPrivate(cx, obj);
|
|
}
|
|
|
|
void ScriptInterface::DumpHeap()
|
|
{
|
|
#if MOZJS_DEBUG_ABI
|
|
JS_DumpHeap(m->m_cx, stderr, NULL, 0, NULL, (size_t)-1, NULL);
|
|
#endif
|
|
fprintf(stderr, "# Bytes allocated: %u\n", JS_GetGCParameter(GetRuntime(), JSGC_BYTES));
|
|
JS_GC(m->m_cx);
|
|
fprintf(stderr, "# Bytes allocated after GC: %u\n", JS_GetGCParameter(GetRuntime(), JSGC_BYTES));
|
|
}
|
|
|
|
void ScriptInterface::MaybeGC()
|
|
{
|
|
JS_MaybeGC(m->m_cx);
|
|
}
|
|
|
|
class ValueCloner
|
|
{
|
|
public:
|
|
ValueCloner(ScriptInterface& from, ScriptInterface& to) :
|
|
scriptInterfaceFrom(from), cxFrom(from.GetContext()), cxTo(to.GetContext()), m_RooterFrom(from), m_RooterTo(to)
|
|
{
|
|
}
|
|
|
|
// Return the cloned object (or an already-computed object if we've cloned val before)
|
|
jsval GetOrClone(jsval val)
|
|
{
|
|
if (!JSVAL_IS_GCTHING(val) || JSVAL_IS_NULL(val))
|
|
return val;
|
|
|
|
std::map<void*, jsval>::iterator it = m_Mapping.find(JSVAL_TO_GCTHING(val));
|
|
if (it != m_Mapping.end())
|
|
return it->second;
|
|
|
|
m_RooterFrom.Push(val); // root it so our mapping doesn't get invalidated
|
|
|
|
return Clone(val);
|
|
}
|
|
|
|
private:
|
|
|
|
#define CLONE_REQUIRE(expr, msg) if (!(expr)) { debug_warn(L"Internal error in CloneValueFromOtherContext: " msg); return JSVAL_VOID; }
|
|
|
|
// Clone a new value (and root it and add it to the mapping)
|
|
jsval Clone(jsval val)
|
|
{
|
|
if (JSVAL_IS_DOUBLE(val))
|
|
{
|
|
jsval rval;
|
|
CLONE_REQUIRE(JS_NewNumberValue(cxTo, JSVAL_TO_DOUBLE(val), &rval), L"JS_NewNumberValue");
|
|
m_RooterTo.Push(rval);
|
|
return rval;
|
|
}
|
|
|
|
if (JSVAL_IS_STRING(val))
|
|
{
|
|
size_t len;
|
|
const jschar* chars = JS_GetStringCharsAndLength(cxFrom, JSVAL_TO_STRING(val), &len);
|
|
CLONE_REQUIRE(chars, L"JS_GetStringCharsAndLength");
|
|
JSString* str = JS_NewUCStringCopyN(cxTo, chars, len);
|
|
CLONE_REQUIRE(str, L"JS_NewUCStringCopyN");
|
|
jsval rval = STRING_TO_JSVAL(str);
|
|
m_Mapping[JSVAL_TO_GCTHING(val)] = rval;
|
|
m_RooterTo.Push(rval);
|
|
return rval;
|
|
}
|
|
|
|
ENSURE(JSVAL_IS_OBJECT(val));
|
|
|
|
JSObject* newObj;
|
|
if (JS_IsArrayObject(cxFrom, JSVAL_TO_OBJECT(val)))
|
|
{
|
|
jsuint length;
|
|
CLONE_REQUIRE(JS_GetArrayLength(cxFrom, JSVAL_TO_OBJECT(val), &length), L"JS_GetArrayLength");
|
|
newObj = JS_NewArrayObject(cxTo, length, NULL);
|
|
CLONE_REQUIRE(newObj, L"JS_NewArrayObject");
|
|
}
|
|
else
|
|
{
|
|
newObj = JS_NewObject(cxTo, NULL, NULL, NULL);
|
|
CLONE_REQUIRE(newObj, L"JS_NewObject");
|
|
}
|
|
|
|
m_Mapping[JSVAL_TO_GCTHING(val)] = OBJECT_TO_JSVAL(newObj);
|
|
m_RooterTo.Push(newObj);
|
|
|
|
AutoJSIdArray ida (cxFrom, JS_Enumerate(cxFrom, JSVAL_TO_OBJECT(val)));
|
|
CLONE_REQUIRE(ida.get(), L"JS_Enumerate");
|
|
|
|
AutoGCRooter idaRooter(scriptInterfaceFrom);
|
|
idaRooter.Push(ida.get());
|
|
|
|
for (size_t i = 0; i < ida.length(); ++i)
|
|
{
|
|
jsid id = ida[i];
|
|
jsval idval, propval;
|
|
CLONE_REQUIRE(JS_IdToValue(cxFrom, id, &idval), L"JS_IdToValue");
|
|
CLONE_REQUIRE(JS_GetPropertyById(cxFrom, JSVAL_TO_OBJECT(val), id, &propval), L"JS_GetPropertyById");
|
|
jsval newPropval = GetOrClone(propval);
|
|
|
|
if (JSVAL_IS_INT(idval))
|
|
{
|
|
// int jsids are portable across runtimes
|
|
CLONE_REQUIRE(JS_SetPropertyById(cxTo, newObj, id, &newPropval), L"JS_SetPropertyById");
|
|
}
|
|
else if (JSVAL_IS_STRING(idval))
|
|
{
|
|
// string jsids are runtime-specific, so we need to copy the string content
|
|
JSString* idstr = JS_ValueToString(cxFrom, idval);
|
|
CLONE_REQUIRE(idstr, L"JS_ValueToString (id)");
|
|
size_t len;
|
|
const jschar* chars = JS_GetStringCharsAndLength(cxFrom, idstr, &len);
|
|
CLONE_REQUIRE(idstr, L"JS_GetStringCharsAndLength (id)");
|
|
CLONE_REQUIRE(JS_SetUCProperty(cxTo, newObj, chars, len, &newPropval), L"JS_SetUCProperty");
|
|
}
|
|
else
|
|
{
|
|
// this apparently could be an XML object; ignore it
|
|
}
|
|
}
|
|
|
|
return OBJECT_TO_JSVAL(newObj);
|
|
}
|
|
|
|
ScriptInterface& scriptInterfaceFrom;
|
|
JSContext* cxFrom;
|
|
JSContext* cxTo;
|
|
std::map<void*, jsval> m_Mapping;
|
|
AutoGCRooter m_RooterFrom;
|
|
AutoGCRooter m_RooterTo;
|
|
};
|
|
|
|
jsval ScriptInterface::CloneValueFromOtherContext(ScriptInterface& otherContext, jsval val)
|
|
{
|
|
PROFILE("CloneValueFromOtherContext");
|
|
|
|
ValueCloner cloner(otherContext, *this);
|
|
return cloner.GetOrClone(val);
|
|
}
|
|
|
|
ScriptInterface::StructuredClone::StructuredClone() :
|
|
m_Context(NULL), m_Data(NULL), m_Size(0)
|
|
{
|
|
}
|
|
|
|
ScriptInterface::StructuredClone::~StructuredClone()
|
|
{
|
|
if (m_Data)
|
|
JS_free(m_Context, m_Data);
|
|
}
|
|
|
|
shared_ptr<ScriptInterface::StructuredClone> ScriptInterface::WriteStructuredClone(jsval v)
|
|
{
|
|
uint64* data = NULL;
|
|
size_t nbytes = 0;
|
|
if (!JS_WriteStructuredClone(m->m_cx, v, &data, &nbytes, NULL, NULL))
|
|
return shared_ptr<StructuredClone>();
|
|
// TODO: should we have better error handling?
|
|
// Currently we'll probably continue and then crash in ReadStructuredClone
|
|
|
|
shared_ptr<StructuredClone> ret (new StructuredClone);
|
|
ret->m_Context = m->m_cx;
|
|
ret->m_Data = data;
|
|
ret->m_Size = nbytes;
|
|
return ret;
|
|
}
|
|
|
|
jsval ScriptInterface::ReadStructuredClone(const shared_ptr<ScriptInterface::StructuredClone>& ptr)
|
|
{
|
|
jsval ret = JSVAL_VOID;
|
|
JS_ReadStructuredClone(m->m_cx, ptr->m_Data, ptr->m_Size, JS_STRUCTURED_CLONE_VERSION, &ret, NULL, NULL);
|
|
return ret;
|
|
}
|