JSString*
jsd_GetIdForStackFrame(JSDContext* jsdc,
JSDThreadState* jsdthreadstate,
JSDStackFrameInfo* jsdframe)
{
JSString *rv = NULL;
JSD_LOCK_THREADSTATES(jsdc);
if( jsd_IsValidFrameInThreadState(jsdc, jsdthreadstate, jsdframe) )
{
JSFunction *fun = JS_GetFrameFunction (jsdthreadstate->context,
jsdframe->fp);
if( fun )
{
rv = JS_GetFunctionId (fun);
/*
* For compatibility we return "anonymous", not an empty string
* here.
*/
if( !rv )
rv = JS_GetAnonymousString(jsdc->jsrt);
}
}
JSD_UNLOCK_THREADSTATES(jsdc);
return rv;
}
nsresult
XPCJSStackFrame::CreateStack(JSContext* cx, JSStackFrame* fp,
XPCJSStackFrame** stack)
{
static const unsigned MAX_FRAMES = 100;
unsigned numFrames = 0;
nsRefPtr<XPCJSStackFrame> first = new XPCJSStackFrame();
nsRefPtr<XPCJSStackFrame> self = first;
while (fp && self) {
if (!JS_IsScriptFrame(cx, fp)) {
self->mLanguage = nsIProgrammingLanguage::CPLUSPLUS;
} else {
self->mLanguage = nsIProgrammingLanguage::JAVASCRIPT;
JSScript* script = JS_GetFrameScript(cx, fp);
jsbytecode* pc = JS_GetFramePC(cx, fp);
if (script && pc) {
JS::AutoEnterFrameCompartment ac;
if (ac.enter(cx, fp)) {
const char* filename = JS_GetScriptFilename(cx, script);
if (filename) {
self->mFilename = (char*)
nsMemory::Clone(filename,
sizeof(char)*(strlen(filename)+1));
}
self->mLineno = (int32_t) JS_PCToLineNumber(cx, script, pc);
JSFunction* fun = JS_GetFrameFunction(cx, fp);
if (fun) {
JSString *funid = JS_GetFunctionId(fun);
if (funid) {
size_t length = JS_GetStringEncodingLength(cx, funid);
if (length != size_t(-1)) {
self->mFunname = static_cast<char *>(nsMemory::Alloc(length + 1));
if (self->mFunname) {
JS_EncodeStringToBuffer(funid, self->mFunname, length);
self->mFunname[length] = '\0';
}
}
}
}
}
} else {
self->mLanguage = nsIProgrammingLanguage::CPLUSPLUS;
}
}
if (++numFrames > MAX_FRAMES) {
fp = NULL;
} else if (JS_FrameIterator(cx, &fp)) {
XPCJSStackFrame* frame = new XPCJSStackFrame();
self->mCaller = frame;
self = frame;
}
}
*stack = first.forget().get();
return NS_OK;
}
static JSObject* FindNamedConstructorForXray(
JSContext* aCx, JS::Handle<jsid> aId, const WebIDLNameTableEntry* aEntry) {
JSObject* interfaceObject =
GetPerInterfaceObjectHandle(aCx, aEntry->mConstructorId, aEntry->mCreate,
/* aDefineOnGlobal = */ false);
if (!interfaceObject) {
return nullptr;
}
// This is a call over Xrays, so we will actually use the return value
// (instead of just having it defined on the global now). Check for named
// constructors with this id, in case that's what the caller is asking for.
for (unsigned slot = DOM_INTERFACE_SLOTS_BASE;
slot < JSCLASS_RESERVED_SLOTS(js::GetObjectClass(interfaceObject));
++slot) {
JSObject* constructor =
&js::GetReservedSlot(interfaceObject, slot).toObject();
if (JS_GetFunctionId(JS_GetObjectFunction(constructor)) ==
JSID_TO_STRING(aId)) {
return constructor;
}
}
// None of the named constructors match, so the caller must want the
// interface object itself.
return interfaceObject;
}
static JSString *
ValueToShortSource(JSContext *cx, jsval v)
{
JSString *str;
/* Avoid toSource bloat and fallibility for object types. */
if (JSVAL_IS_PRIMITIVE(v)) {
str = js_ValueToSource(cx, v);
} else if (VALUE_IS_FUNCTION(cx, v)) {
/*
* XXX Avoid function decompilation bloat for now.
*/
str = JS_GetFunctionId(JS_ValueToFunction(cx, v));
if (!str && !(str = js_ValueToSource(cx, v))) {
/*
* Continue to soldier on if the function couldn't be
* converted into a string.
*/
JS_ClearPendingException(cx);
str = JS_NewStringCopyZ(cx, "[unknown function]");
}
} else {
/*
* XXX Avoid toString on objects, it takes too long and uses too much
* memory, for too many classes (see Mozilla bug 166743).
*/
char buf[100];
JS_snprintf(buf, sizeof buf, "[object %s]",
OBJ_GET_CLASS(cx, JSVAL_TO_OBJECT(v))->name);
str = JS_NewStringCopyZ(cx, buf);
}
return str;
}
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;
}
/* Mimick the behaviour exposed by standard Error objects
(http://mxr.mozilla.org/mozilla-central/source/js/src/jsexn.cpp#554)
*/
static char*
jsvalue_to_string(JSContext* cx, jsval val, gboolean* is_string)
{
char* value = NULL;
JSString* value_str = NULL;
if (JSVAL_IS_PRIMITIVE(val)) {
value_str = JS_ValueToSource(cx, val);
} else {
JSObject *obj = JSVAL_TO_OBJECT(val);
if (JS_ObjectIsFunction(cx, obj)) {
JSFunction *fn = JS_ValueToFunction(cx, val);
value_str = JS_GetFunctionId(fn);
if (!value_str)
value = g_strdup("[unknown function]");
} else {
value = g_strdup_printf("[object %s]", JS_GetClass(cx, obj)->name);
}
}
if (!value && value_str)
value = gjs_value_debug_string(cx, val);
if (is_string)
*is_string = JSVAL_IS_STRING(val);
return value;
}
JSString*
jsd_GetValueFunctionId(JSDContext* jsdc, JSDValue* jsdval)
{
JSContext* cx = jsdc->dumbContext;
JSFunction* fun;
JSExceptionState* exceptionState;
JSCrossCompartmentCall *call = NULL;
if(!jsdval->funName && jsd_IsValueFunction(jsdc, jsdval))
{
JS_BeginRequest(cx);
call = JS_EnterCrossCompartmentCall(jsdc->dumbContext, JSVAL_TO_OBJECT(jsdval->val));
if(!call) {
JS_EndRequest(cx);
return NULL;
}
exceptionState = JS_SaveExceptionState(cx);
fun = JSD_GetValueFunction(jsdc, jsdval);
JS_RestoreExceptionState(cx, exceptionState);
JS_LeaveCrossCompartmentCall(call);
JS_EndRequest(cx);
if(!fun)
return NULL;
jsdval->funName = JS_GetFunctionId(fun);
/* For compatibility we return "anonymous", not an empty string here. */
if (!jsdval->funName)
jsdval->funName = JS_GetAnonymousString(jsdc->jsrt);
}
return jsdval->funName;
}
bool rs::jsapi::Object::CallFunction(JSContext* cx, unsigned argc, JS::Value* vp) {
JSAutoRequest ar(cx);
char nameBuffer[256];
const char* name = nameBuffer;
auto args = JS::CallArgsFromVp(argc, vp);
auto func = JS_ValueToFunction(cx, args.calleev());
if (func != nullptr) {
auto funcName = JS_GetFunctionId(func);
if (funcName != nullptr) {
auto nameLength = JS_EncodeStringToBuffer(cx, funcName, nameBuffer, sizeof(nameBuffer));
if ((nameLength + 1) < sizeof(nameBuffer)) {
nameBuffer[nameLength] = '\0';
} else {
std::vector<char> vBuffer(nameLength + 1);
JS_EncodeStringToBuffer(cx, funcName, &vBuffer[0], nameLength);
vBuffer[nameLength] = '\0';
name = &vBuffer[0];
}
}
}
if (name == nullptr) {
// TODO: test this case
JS_ReportError(cx, "Unable to find function in libjsapi object");
return false;
} else {
auto that = args.thisv();
auto state = that.isObjectOrNull() ? Object::GetState(cx, JS::RootedObject(cx, that.toObjectOrNull())) : nullptr;
if (state == nullptr) {
// TODO: test this case
JS_ReportError(cx, "Unable to find function callback in libjsapi object");
return false;
} else {
try {
static thread_local std::vector<Value> vArgs;
VectorUtils::ScopedVectorCleaner<Value> clean(vArgs);
for (int i = 0; i < argc; ++i) {
vArgs.emplace_back(cx, args.get(i));
}
Value result(cx);
state->functions[name](vArgs, result);
args.rval().set(result);
return true;
} catch (const std::exception& ex) {
JS_ReportError(cx, ex.what());
return false;
}
}
}
}
JSString*
jsd_GetScriptFunctionId(JSDContext* jsdc, JSDScript *jsdscript)
{
JSString* str;
if( ! jsdscript->function )
return NULL;
str = JS_GetFunctionId(jsdscript->function);
/* For compatibility we return "anonymous", not an empty string here. */
return str ? str : JS_GetAnonymousString(jsdc->jsrt);
}
JSBool Engine::throwUsageError(JSContext* cx,jsval *argv)
{
JSObject *functionObject = JSVAL_TO_OBJECT(argv[-2]);
JSFunction *function = (JSFunction*)JS_GetPrivate(cx,functionObject);
JSString *str = JS_GetFunctionId(function);
char* functionName = JS_GetStringBytes(str);
JS_ReportError(cx,"Invalid usage of %s",functionName);
return JS_FALSE;
}
static void
GetMethodInfo(JSContext *cx,
jsval *vp,
const char **ifaceName,
const char **memberName)
{
JSObject *funobj = JSVAL_TO_OBJECT(JS_CALLEE(cx, vp));
NS_ASSERTION(JS_ObjectIsFunction(cx, funobj),
"JSFastNative callee should be Function object");
JSString *str = JS_GetFunctionId((JSFunction *) JS_GetPrivate(cx, funobj));
jsval methodId = str ? STRING_TO_JSVAL(str) : JSVAL_NULL;
GetMemberInfo(JSVAL_TO_OBJECT(vp[1]), methodId, ifaceName, memberName);
}
void CThreadDebugger::SaveCallstack()
{
ENSURE(GetIsInBreak());
CScopeLock lock(m->m_Mutex);
JSStackFrame *fp;
JSStackFrame *iter = 0;
std::string functionName;
jsint counter = 0;
JSObject* jsArray;
jsArray = JS_NewArrayObject(m->m_pScriptInterface->GetContext(), 0, 0);
JSString* functionID;
fp = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
while (fp)
{
JSFunction* fun = 0;
fun = JS_GetFrameFunction(m->m_pScriptInterface->GetContext(), fp);
if (NULL == fun)
functionID = JS_NewStringCopyZ(m->m_pScriptInterface->GetContext(), "null");
else
{
functionID = JS_GetFunctionId(fun);
if (NULL == functionID)
functionID = JS_NewStringCopyZ(m->m_pScriptInterface->GetContext(), "anonymous");
}
JSBool ret = JS_DefineElement(m->m_pScriptInterface->GetContext(), jsArray, counter, STRING_TO_JSVAL(functionID), NULL, NULL, 0);
ENSURE(ret);
fp = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
counter++;
}
m->m_Callstack = "";
m->m_Callstack = m->m_pScriptInterface->StringifyJSON(OBJECT_TO_JSVAL(jsArray), false).c_str();
}
static void
format_frame(JSContext* cx, JSStackFrame* fp,
GString *buf, int num)
{
JSPropertyDescArray call_props = { 0, NULL };
JSObject* call_obj = NULL;
char* funname_str = NULL;
const char* filename = NULL;
guint32 lineno = 0;
guint32 named_arg_count = 0;
JSFunction* fun = NULL;
JSScript* script;
guchar* pc;
guint32 i;
gboolean is_string;
jsval val;
(void)JS_EnterLocalRootScope(cx);
if (!JS_IsScriptFrame(cx, fp)) {
g_string_append_printf(buf, "%d [native frame]\n", num);
goto out;
}
/* get the info for this stack frame */
script = JS_GetFrameScript(cx, fp);
pc = JS_GetFramePC(cx, fp);
if (script && pc) {
filename = JS_GetScriptFilename(cx, script);
lineno = (guint32) JS_PCToLineNumber(cx, script, pc);
fun = JS_GetFrameFunction(cx, fp);
if (fun) {
JSString* funname = JS_GetFunctionId(fun);
if (funname)
funname_str = gjs_string_get_ascii(cx, STRING_TO_JSVAL(funname));
}
call_obj = JS_GetFrameCallObject(cx, fp);
if (call_obj) {
if (!JS_GetPropertyDescArray(cx, call_obj, &call_props))
call_props.array = NULL;
}
}
/* print the frame number and function name */
if (funname_str) {
g_string_append_printf(buf, "%d %s(", num, funname_str);
g_free(funname_str);
}
else if (fun)
g_string_append_printf(buf, "%d anonymous(", num);
else
g_string_append_printf(buf, "%d <TOP LEVEL>", num);
for (i = 0; i < call_props.length; i++) {
char *name = NULL;
char *value = NULL;
JSPropertyDesc* desc = &call_props.array[i];
if(desc->flags & JSPD_ARGUMENT) {
name = jsvalue_to_string(cx, desc->id, &is_string);
if(!is_string) {
g_free(name);
name = NULL;
}
value = jsvalue_to_string(cx, desc->value, &is_string);
g_string_append_printf(buf, "%s%s%s%s%s%s",
named_arg_count ? ", " : "",
name ? name :"",
name ? " = " : "",
is_string ? "\"" : "",
value ? value : "?unknown?",
is_string ? "\"" : "");
named_arg_count++;
}
g_free(name);
g_free(value);
}
/* print any unnamed trailing args (found in 'arguments' object) */
if (call_obj != NULL &&
JS_GetProperty(cx, call_obj, "arguments", &val) &&
JSVAL_IS_OBJECT(val)) {
guint32 k;
guint32 arg_count;
JSObject* args_obj = JSVAL_TO_OBJECT(val);
if (JS_GetArrayLength(cx, args_obj, &arg_count) &&
arg_count > named_arg_count) {
for (k = named_arg_count; k < arg_count; k++) {
if (JS_GetElement(cx, args_obj, k, &val)) {
char *value = jsvalue_to_string(cx, val, &is_string);
g_string_append_printf(buf, "%s%s%s%s",
k ? ", " : "",
is_string ? "\"" : "",
value ? value : "?unknown?",
is_string ? "\"" : "");
g_free(value);
}
}
}
}
/* print filename and line number */
g_string_append_printf(buf, "%s@%s:%d\n",
fun ? ")" : "",
filename ? filename : "",
lineno);
out:
if (call_props.array)
JS_PutPropertyDescArray(cx, &call_props);
JS_LeaveLocalRootScope(cx);
}
void CBinarySerializerScriptImpl::HandleScriptVal(JS::HandleValue val)
{
JSContext* cx = m_ScriptInterface.GetContext();
JSAutoRequest rq(cx);
switch (JS_TypeOfValue(cx, val))
{
case JSTYPE_VOID:
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_VOID);
break;
}
case JSTYPE_NULL: // This type is never actually returned (it's a JS2 feature)
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_NULL);
break;
}
case JSTYPE_OBJECT:
{
if (val.isNull())
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_NULL);
break;
}
JS::RootedObject obj(cx, &val.toObject());
// If we've already serialized this object, just output a reference to it
u32 tag = GetScriptBackrefTag(obj);
if (tag)
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_BACKREF);
m_Serializer.NumberU32_Unbounded("tag", tag);
break;
}
// Arrays are special cases of Object
if (JS_IsArrayObject(cx, obj))
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_ARRAY);
// TODO: probably should have a more efficient storage format
// Arrays like [1, 2, ] have an 'undefined' at the end which is part of the
// length but seemingly isn't enumerated, so store the length explicitly
uint length = 0;
if (!JS_GetArrayLength(cx, obj, &length))
throw PSERROR_Serialize_ScriptError("JS_GetArrayLength failed");
m_Serializer.NumberU32_Unbounded("array length", length);
}
else if (JS_IsTypedArrayObject(obj))
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_TYPED_ARRAY);
m_Serializer.NumberU8_Unbounded("array type", GetArrayType(JS_GetArrayBufferViewType(obj)));
m_Serializer.NumberU32_Unbounded("byte offset", JS_GetTypedArrayByteOffset(obj));
m_Serializer.NumberU32_Unbounded("length", JS_GetTypedArrayLength(obj));
// Now handle its array buffer
// this may be a backref, since ArrayBuffers can be shared by multiple views
JS::RootedValue bufferVal(cx, JS::ObjectValue(*JS_GetArrayBufferViewBuffer(cx, obj)));
HandleScriptVal(bufferVal);
break;
}
else if (JS_IsArrayBufferObject(obj))
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_ARRAY_BUFFER);
#if BYTE_ORDER != LITTLE_ENDIAN
#error TODO: need to convert JS ArrayBuffer data to little-endian
#endif
u32 length = JS_GetArrayBufferByteLength(obj);
m_Serializer.NumberU32_Unbounded("buffer length", length);
JS::AutoCheckCannotGC nogc;
m_Serializer.RawBytes("buffer data", (const u8*)JS_GetArrayBufferData(obj, nogc), length);
break;
}
else
{
// Find type of object
const JSClass* jsclass = JS_GetClass(obj);
if (!jsclass)
throw PSERROR_Serialize_ScriptError("JS_GetClass failed");
// TODO: Remove this workaround for upstream API breakage when updating SpiderMonkey
// See https://bugzilla.mozilla.org/show_bug.cgi?id=1236373
#define JSCLASS_CACHED_PROTO_WIDTH js::JSCLASS_CACHED_PROTO_WIDTH
JSProtoKey protokey = JSCLASS_CACHED_PROTO_KEY(jsclass);
#undef JSCLASS_CACHED_PROTO_WIDTH
if (protokey == JSProto_Object)
{
// Object class - check for user-defined prototype
JS::RootedObject proto(cx);
JS_GetPrototype(cx, obj, &proto);
if (!proto)
throw PSERROR_Serialize_ScriptError("JS_GetPrototype failed");
if (m_SerializablePrototypes->empty() || !IsSerializablePrototype(proto))
{
// Standard Object prototype
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_OBJECT);
// TODO: maybe we should throw an error for unrecognized non-Object prototypes?
// (requires fixing AI serialization first and excluding component scripts)
}
else
{
// User-defined custom prototype
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_OBJECT_PROTOTYPE);
const std::wstring prototypeName = GetPrototypeName(proto);
m_Serializer.String("proto name", prototypeName, 0, 256);
// Does it have custom Serialize function?
// if so, we serialize the data it returns, rather than the object's properties directly
bool hasCustomSerialize;
if (!JS_HasProperty(cx, obj, "Serialize", &hasCustomSerialize))
throw PSERROR_Serialize_ScriptError("JS_HasProperty failed");
if (hasCustomSerialize)
{
JS::RootedValue serialize(cx);
if (!JS_GetProperty(cx, obj, "Serialize", &serialize))
throw PSERROR_Serialize_ScriptError("JS_GetProperty failed");
// If serialize is null, so don't serialize anything more
if (!serialize.isNull())
{
JS::RootedValue data(cx);
if (!m_ScriptInterface.CallFunction(val, "Serialize", &data))
throw PSERROR_Serialize_ScriptError("Prototype Serialize function failed");
HandleScriptVal(data);
}
break;
}
}
}
else if (protokey == JSProto_Number)
{
// Standard Number object
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_OBJECT_NUMBER);
// Get primitive value
double d;
if (!JS::ToNumber(cx, val, &d))
throw PSERROR_Serialize_ScriptError("JS::ToNumber failed");
m_Serializer.NumberDouble_Unbounded("value", d);
break;
}
else if (protokey == JSProto_String)
{
// Standard String object
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_OBJECT_STRING);
// Get primitive value
JS::RootedString str(cx, JS::ToString(cx, val));
if (!str)
throw PSERROR_Serialize_ScriptError("JS_ValueToString failed");
ScriptString("value", str);
break;
}
else if (protokey == JSProto_Boolean)
{
// Standard Boolean object
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_OBJECT_BOOLEAN);
// Get primitive value
bool b = JS::ToBoolean(val);
m_Serializer.Bool("value", b);
break;
}
// TODO: Follow upstream progresses about a JS::IsMapObject
// https://bugzilla.mozilla.org/show_bug.cgi?id=1285909
else if (protokey == JSProto_Map)
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_OBJECT_MAP);
m_Serializer.NumberU32_Unbounded("map size", JS::MapSize(cx, obj));
JS::RootedValue keyValueIterator(cx);
if (!JS::MapEntries(cx, obj, &keyValueIterator))
throw PSERROR_Serialize_ScriptError("JS::MapEntries failed");
JS::ForOfIterator it(cx);
if (!it.init(keyValueIterator))
throw PSERROR_Serialize_ScriptError("JS::ForOfIterator::init failed");
JS::RootedValue keyValuePair(cx);
bool done;
while (true)
{
if (!it.next(&keyValuePair, &done))
throw PSERROR_Serialize_ScriptError("JS::ForOfIterator::next failed");
if (done)
break;
JS::RootedObject keyValuePairObj(cx, &keyValuePair.toObject());
JS::RootedValue key(cx);
JS::RootedValue value(cx);
ENSURE(JS_GetElement(cx, keyValuePairObj, 0, &key));
ENSURE(JS_GetElement(cx, keyValuePairObj, 1, &value));
HandleScriptVal(key);
HandleScriptVal(value);
}
break;
}
// TODO: Follow upstream progresses about a JS::IsSetObject
// https://bugzilla.mozilla.org/show_bug.cgi?id=1285909
else if (protokey == JSProto_Set)
{
// TODO: When updating SpiderMonkey to a release after 38 use the C++ API for Sets.
// https://bugzilla.mozilla.org/show_bug.cgi?id=1159469
u32 setSize;
m_ScriptInterface.GetProperty(val, "size", setSize);
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_OBJECT_SET);
m_Serializer.NumberU32_Unbounded("set size", setSize);
JS::RootedValue valueIterator(cx);
m_ScriptInterface.CallFunction(val, "values", &valueIterator);
for (u32 i=0; i<setSize; ++i)
{
JS::RootedValue currentIterator(cx);
JS::RootedValue value(cx);
ENSURE(m_ScriptInterface.CallFunction(valueIterator, "next", ¤tIterator));
m_ScriptInterface.GetProperty(currentIterator, "value", &value);
HandleScriptVal(value);
}
break;
}
else
{
// Unrecognized class
LOGERROR("Cannot serialise JS objects with unrecognized class '%s'", jsclass->name);
throw PSERROR_Serialize_InvalidScriptValue();
}
}
// Find all properties (ordered by insertion time)
JS::AutoIdArray ida (cx, JS_Enumerate(cx, obj));
if (!ida)
throw PSERROR_Serialize_ScriptError("JS_Enumerate failed");
m_Serializer.NumberU32_Unbounded("num props", (u32)ida.length());
for (size_t i = 0; i < ida.length(); ++i)
{
JS::RootedId id(cx, ida[i]);
JS::RootedValue idval(cx);
JS::RootedValue propval(cx);
// Forbid getters, which might delete values and mess things up.
JS::Rooted<JSPropertyDescriptor> desc(cx);
if (!JS_GetPropertyDescriptorById(cx, obj, id, &desc))
throw PSERROR_Serialize_ScriptError("JS_GetPropertyDescriptorById failed");
if (desc.hasGetterObject())
throw PSERROR_Serialize_ScriptError("Cannot serialize property getters");
// Get the property name as a string
if (!JS_IdToValue(cx, id, &idval))
throw PSERROR_Serialize_ScriptError("JS_IdToValue failed");
JS::RootedString idstr(cx, JS::ToString(cx, idval));
if (!idstr)
throw PSERROR_Serialize_ScriptError("JS_ValueToString failed");
ScriptString("prop name", idstr);
if (!JS_GetPropertyById(cx, obj, id, &propval))
throw PSERROR_Serialize_ScriptError("JS_GetPropertyById failed");
HandleScriptVal(propval);
}
break;
}
case JSTYPE_FUNCTION:
{
// We can't serialise functions, but we can at least name the offender (hopefully)
std::wstring funcname(L"(unnamed)");
JS::RootedFunction func(cx, JS_ValueToFunction(cx, val));
if (func)
{
JS::RootedString string(cx, JS_GetFunctionId(func));
if (string)
{
if (JS_StringHasLatin1Chars(string))
{
size_t length;
JS::AutoCheckCannotGC nogc;
const JS::Latin1Char* ch = JS_GetLatin1StringCharsAndLength(cx, nogc, string, &length);
if (ch && length > 0)
funcname.assign(ch, ch + length);
}
else
{
size_t length;
JS::AutoCheckCannotGC nogc;
const char16_t* ch = JS_GetTwoByteStringCharsAndLength(cx, nogc, string, &length);
if (ch && length > 0)
funcname.assign(ch, ch + length);
}
}
}
LOGERROR("Cannot serialise JS objects of type 'function': %s", utf8_from_wstring(funcname));
throw PSERROR_Serialize_InvalidScriptValue();
}
case JSTYPE_STRING:
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_STRING);
JS::RootedString stringVal(cx, val.toString());
ScriptString("string", stringVal);
break;
}
case JSTYPE_NUMBER:
{
// To reduce the size of the serialized data, we handle integers and doubles separately.
// We can't check for val.isInt32 and val.isDouble directly, because integer numbers are not guaranteed
// to be represented as integers. A number like 33 could be stored as integer on the computer of one player
// and as double on the other player's computer. That would cause out of sync errors in multiplayer games because
// their binary representation and thus the hash would be different.
double d;
d = val.toNumber();
i32 integer;
if (JS_DoubleIsInt32(d, &integer))
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_INT);
m_Serializer.NumberI32_Unbounded("value", integer);
}
else
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_DOUBLE);
m_Serializer.NumberDouble_Unbounded("value", d);
}
break;
}
case JSTYPE_BOOLEAN:
{
m_Serializer.NumberU8_Unbounded("type", SCRIPT_TYPE_BOOLEAN);
bool b = val.toBoolean();
m_Serializer.NumberU8_Unbounded("value", b ? 1 : 0);
break;
}
default:
{
debug_warn(L"Invalid TypeOfValue");
throw PSERROR_Serialize_InvalidScriptValue();
}
}
}
static char* FormatJSFrame(JSContext* cx, JSStackFrame* fp,
char* buf, int num,
JSBool showArgs, JSBool showLocals, JSBool showThisProps)
{
JSPropertyDescArray callProps = {0, nsnull};
JSPropertyDescArray thisProps = {0, nsnull};
JSBool gotThisVal = JS_FALSE;
jsval thisVal;
JSObject* callObj = nsnull;
JSString* funname = nsnull;
JSAutoByteString funbytes;
const char* filename = nsnull;
PRInt32 lineno = 0;
JSFunction* fun = nsnull;
uint32 namedArgCount = 0;
jsval val;
JSBool isString;
// get the info for this stack frame
JSScript* script = JS_GetFrameScript(cx, fp);
jsbytecode* pc = JS_GetFramePC(cx, fp);
JSAutoRequest ar(cx);
JSAutoEnterCompartment ac;
if(!ac.enter(cx, JS_GetFrameScopeChain(cx, fp)))
return buf;
if(script && pc)
{
filename = JS_GetScriptFilename(cx, script);
lineno = (PRInt32) JS_PCToLineNumber(cx, script, pc);
fun = JS_GetFrameFunction(cx, fp);
if(fun)
funname = JS_GetFunctionId(fun);
if(showArgs || showLocals)
{
callObj = JS_GetFrameCallObject(cx, fp);
if(callObj)
if(!JS_GetPropertyDescArray(cx, callObj, &callProps))
callProps.array = nsnull; // just to be sure
}
gotThisVal = JS_GetFrameThis(cx, fp, &thisVal);
if (!gotThisVal ||
!showThisProps ||
JSVAL_IS_PRIMITIVE(thisVal) ||
!JS_GetPropertyDescArray(cx, JSVAL_TO_OBJECT(thisVal),
&thisProps))
{
thisProps.array = nsnull; // just to be sure
}
}
// print the frame number and function name
if(funname)
buf = JS_sprintf_append(buf, "%d %s(", num, funbytes.encode(cx, funname));
else if(fun)
buf = JS_sprintf_append(buf, "%d anonymous(", num);
else
buf = JS_sprintf_append(buf, "%d <TOP LEVEL>", num);
if(!buf) goto out;
// print the function arguments
if(showArgs && callObj)
{
for(uint32 i = 0; i < callProps.length; i++)
{
JSPropertyDesc* desc = &callProps.array[i];
if(desc->flags & JSPD_ARGUMENT)
{
JSAutoByteString nameBytes;
const char* name = JSVAL2String(cx, desc->id, &isString, &nameBytes);
if(!isString)
name = nsnull;
JSAutoByteString valueBytes;
const char* value = JSVAL2String(cx, desc->value, &isString, &valueBytes);
buf = JS_sprintf_append(buf, "%s%s%s%s%s%s",
namedArgCount ? ", " : "",
name ? name :"",
name ? " = " : "",
isString ? "\"" : "",
value ? value : "?unknown?",
isString ? "\"" : "");
if(!buf) goto out;
namedArgCount++;
}
}
// print any unnamed trailing args (found in 'arguments' object)
if(JS_GetProperty(cx, callObj, "arguments", &val) &&
JSVAL_IS_OBJECT(val))
{
uint32 argCount;
JSObject* argsObj = JSVAL_TO_OBJECT(val);
if(JS_GetProperty(cx, argsObj, "length", &val) &&
JS_ValueToECMAUint32(cx, val, &argCount) &&
argCount > namedArgCount)
{
for(uint32 k = namedArgCount; k < argCount; k++)
{
char number[8];
JS_snprintf(number, 8, "%d", (int) k);
if(JS_GetProperty(cx, argsObj, number, &val))
{
JSAutoByteString valueBytes;
const char *value = JSVAL2String(cx, val, &isString, &valueBytes);
buf = JS_sprintf_append(buf, "%s%s%s%s",
k ? ", " : "",
isString ? "\"" : "",
value ? value : "?unknown?",
isString ? "\"" : "");
if(!buf) goto out;
}
}
}
}
}
// print filename and line number
buf = JS_sprintf_append(buf, "%s [\"%s\":%d]\n",
fun ? ")" : "",
filename ? filename : "<unknown>",
lineno);
if(!buf) goto out;
// print local variables
if(showLocals && callProps.array)
{
for(uint32 i = 0; i < callProps.length; i++)
{
JSPropertyDesc* desc = &callProps.array[i];
if(desc->flags & JSPD_VARIABLE)
{
JSAutoByteString nameBytes;
JSAutoByteString valueBytes;
const char *name = JSVAL2String(cx, desc->id, nsnull, &nameBytes);
const char *value = JSVAL2String(cx, desc->value, &isString, &valueBytes);
if(name && value)
{
buf = JS_sprintf_append(buf, TAB "%s = %s%s%s\n",
name,
isString ? "\"" : "",
value,
isString ? "\"" : "");
if(!buf) goto out;
}
}
}
}
// print the value of 'this'
if(showLocals)
{
if(gotThisVal)
{
JSString* thisValStr;
JSAutoByteString thisValBytes;
if(nsnull != (thisValStr = JS_ValueToString(cx, thisVal)) &&
thisValBytes.encode(cx, thisValStr))
{
buf = JS_sprintf_append(buf, TAB "this = %s\n", thisValBytes.ptr());
if(!buf) goto out;
}
}
else
buf = JS_sprintf_append(buf, TAB "<failed to get 'this' value>\n");
}
// print the properties of 'this', if it is an object
if(showThisProps && thisProps.array)
{
for(uint32 i = 0; i < thisProps.length; i++)
{
JSPropertyDesc* desc = &thisProps.array[i];
if(desc->flags & JSPD_ENUMERATE)
{
JSAutoByteString nameBytes;
JSAutoByteString valueBytes;
const char *name = JSVAL2String(cx, desc->id, nsnull, &nameBytes);
const char *value = JSVAL2String(cx, desc->value, &isString, &valueBytes);
if(name && value)
{
buf = JS_sprintf_append(buf, TAB "this.%s = %s%s%s\n",
name,
isString ? "\"" : "",
value,
isString ? "\"" : "");
if(!buf) goto out;
}
}
}
}
out:
if(callProps.array)
JS_PutPropertyDescArray(cx, &callProps);
if(thisProps.array)
JS_PutPropertyDescArray(cx, &thisProps);
return buf;
}
static JSBool
InitExceptionObject(JSContext *cx, JSObject *obj, JSString *message,
JSString *filename, uintN lineno)
{
JSCheckAccessOp checkAccess;
JSErrorReporter older;
JSExceptionState *state;
jschar *stackbuf;
size_t stacklen, stackmax;
JSStackFrame *fp;
jsval callerid, v;
JSBool ok;
JSString *argsrc, *stack;
uintN i, ulineno;
const char *cp;
char ulnbuf[11];
if (!JS_DefineProperty(cx, obj, js_message_str, STRING_TO_JSVAL(message),
NULL, NULL, JSPROP_ENUMERATE)) {
return JS_FALSE;
}
if (!JS_DefineProperty(cx, obj, js_filename_str,
STRING_TO_JSVAL(filename),
NULL, NULL, JSPROP_ENUMERATE)) {
return JS_FALSE;
}
if (!JS_DefineProperty(cx, obj, js_lineno_str,
INT_TO_JSVAL(lineno),
NULL, NULL, JSPROP_ENUMERATE)) {
return JS_FALSE;
}
/*
* Set the 'stack' property.
*
* First, set aside any error reporter for cx and save its exception state
* so we can suppress any checkAccess failures. Such failures should stop
* the backtrace procedure, not result in a failure of this constructor.
*/
checkAccess = cx->runtime->checkObjectAccess;
if (checkAccess) {
older = JS_SetErrorReporter(cx, NULL);
state = JS_SaveExceptionState(cx);
}
#ifdef __GNUC__ /* suppress bogus gcc warnings */
else {
older = NULL;
state = NULL;
}
#endif
callerid = ATOM_KEY(cx->runtime->atomState.callerAtom);
/*
* Prepare to allocate a jschar buffer at stackbuf, where stacklen indexes
* the next free jschar slot, and with room for at most stackmax non-null
* jschars. If stackbuf is non-null, it always contains an extra slot for
* the null terminator we'll store at the end, as a backstop.
*
* All early returns must goto done after this point, till the after-loop
* cleanup code has run!
*/
stackbuf = NULL;
stacklen = stackmax = 0;
ok = JS_TRUE;
#define APPEND_CHAR_TO_STACK(c) \
JS_BEGIN_MACRO \
if (stacklen == stackmax) { \
void *ptr_; \
stackmax = stackmax ? 2 * stackmax : 64; \
ptr_ = JS_realloc(cx, stackbuf, (stackmax+1) * sizeof(jschar)); \
if (!ptr_) { \
ok = JS_FALSE; \
goto done; \
} \
stackbuf = ptr_; \
} \
stackbuf[stacklen++] = (c); \
JS_END_MACRO
#define APPEND_STRING_TO_STACK(str) \
JS_BEGIN_MACRO \
JSString *str_ = str; \
size_t length_ = JSSTRING_LENGTH(str_); \
if (stacklen + length_ > stackmax) { \
void *ptr_; \
stackmax = JS_BIT(JS_CeilingLog2(stacklen + length_)); \
ptr_ = JS_realloc(cx, stackbuf, (stackmax+1) * sizeof(jschar)); \
if (!ptr_) { \
ok = JS_FALSE; \
goto done; \
} \
stackbuf = ptr_; \
} \
js_strncpy(stackbuf + stacklen, JSSTRING_CHARS(str_), length_); \
stacklen += length_; \
JS_END_MACRO
for (fp = cx->fp; fp; fp = fp->down) {
if (checkAccess) {
v = (fp->fun && fp->argv) ? fp->argv[-2] : JSVAL_NULL;
if (!JSVAL_IS_PRIMITIVE(v)) {
ok = checkAccess(cx, fp->fun->object, callerid, JSACC_READ, &v);
if (!ok) {
ok = JS_TRUE;
break;
}
}
}
if (fp->fun) {
if (fp->fun->atom)
APPEND_STRING_TO_STACK(ATOM_TO_STRING(fp->fun->atom));
APPEND_CHAR_TO_STACK('(');
for (i = 0; i < fp->argc; i++) {
/* Avoid toSource bloat and fallibility for object types. */
v = fp->argv[i];
if (JSVAL_IS_PRIMITIVE(v)) {
argsrc = js_ValueToSource(cx, v);
} else if (JSVAL_IS_FUNCTION(cx, v)) {
/* XXX Avoid function decompilation bloat for now. */
argsrc = JS_GetFunctionId(JS_ValueToFunction(cx, v));
if (!argsrc)
argsrc = js_ValueToSource(cx, v);
} else {
/* XXX Avoid toString on objects, it takes too long and
uses too much memory, for too many classes (see
Mozilla bug 166743). */
char buf[100];
JS_snprintf(buf, sizeof buf, "[object %s]",
OBJ_GET_CLASS(cx, JSVAL_TO_OBJECT(v))->name);
argsrc = JS_NewStringCopyZ(cx, buf);
}
if (!argsrc) {
ok = JS_FALSE;
goto done;
}
if (i > 0)
APPEND_CHAR_TO_STACK(',');
APPEND_STRING_TO_STACK(argsrc);
}
APPEND_CHAR_TO_STACK(')');
}
APPEND_CHAR_TO_STACK('@');
if (fp->script && fp->script->filename) {
for (cp = fp->script->filename; *cp; cp++)
APPEND_CHAR_TO_STACK(*cp);
}
APPEND_CHAR_TO_STACK(':');
if (fp->script && fp->pc) {
ulineno = js_PCToLineNumber(fp->script, fp->pc);
JS_snprintf(ulnbuf, sizeof ulnbuf, "%u", ulineno);
for (cp = ulnbuf; *cp; cp++)
APPEND_CHAR_TO_STACK(*cp);
} else {
APPEND_CHAR_TO_STACK('0');
}
APPEND_CHAR_TO_STACK('\n');
}
#undef APPEND_CHAR_TO_STACK
#undef APPEND_STRING_TO_STACK
done:
if (checkAccess) {
if (ok)
JS_RestoreExceptionState(cx, state);
else
JS_DropExceptionState(cx, state);
JS_SetErrorReporter(cx, older);
}
if (!ok) {
JS_free(cx, stackbuf);
return JS_FALSE;
}
if (!stackbuf) {
stack = cx->runtime->emptyString;
} else {
/* NB: if stackbuf was allocated, it has room for the terminator. */
JS_ASSERT(stacklen <= stackmax);
if (stacklen < stackmax) {
/*
* Realloc can fail when shrinking on some FreeBSD versions, so
* don't use JS_realloc here; simply let the oversized allocation
* be owned by the string in that rare case.
*/
void *shrunk = realloc(stackbuf, (stacklen+1) * sizeof(jschar));
if (shrunk)
stackbuf = shrunk;
}
stackbuf[stacklen] = 0;
stack = js_NewString(cx, stackbuf, stacklen, 0);
if (!stack) {
JS_free(cx, stackbuf);
return JS_FALSE;
}
}
return JS_DefineProperty(cx, obj, js_stack_str,
STRING_TO_JSVAL(stack),
NULL, NULL, JSPROP_ENUMERATE);
}
static JSDScript*
_newJSDScript(JSDContext* jsdc,
JSContext *cx,
JSScript *script_)
{
JS::RootedScript script(cx, script_);
if ( JS_GetScriptIsSelfHosted(script) )
return NULL;
JSDScript* jsdscript;
unsigned lineno;
const char* raw_filename;
JS_ASSERT(JSD_SCRIPTS_LOCKED(jsdc));
/* these are inlined javascript: urls and we can't handle them now */
lineno = (unsigned) JS_GetScriptBaseLineNumber(cx, script);
if( lineno == 0 )
return NULL;
jsdscript = (JSDScript*) calloc(1, sizeof(JSDScript));
if( ! jsdscript )
return NULL;
raw_filename = JS_GetScriptFilename(cx,script);
JS_HashTableAdd(jsdc->scriptsTable, (void *)script, (void *)jsdscript);
JS_APPEND_LINK(&jsdscript->links, &jsdc->scripts);
jsdscript->jsdc = jsdc;
jsdscript->script = script;
jsdscript->lineBase = lineno;
jsdscript->lineExtent = (unsigned)NOT_SET_YET;
jsdscript->data = NULL;
#ifndef LIVEWIRE
jsdscript->url = (char*) jsd_BuildNormalizedURL(raw_filename);
#else
jsdscript->app = LWDBG_GetCurrentApp();
if( jsdscript->app && raw_filename )
{
jsdscript->url = jsdlw_BuildAppRelativeFilename(jsdscript->app, raw_filename);
if( function )
{
JSString* funid = JS_GetFunctionId(function);
char* funbytes;
const char* funnanme;
if( fuinid )
{
funbytes = JS_EncodeString(cx, funid);
funname = funbytes ? funbytes : "";
}
else
{
funbytes = NULL;
funname = "anonymous";
}
jsdscript->lwscript =
LWDBG_GetScriptOfFunction(jsdscript->app,funname);
JS_Free(cx, funbytes);
/* also, make sure this file is added to filelist if is .js file */
if( HasFileExtention(raw_filename,"js") ||
HasFileExtention(raw_filename,"sjs") )
{
jsdlw_PreLoadSource(jsdc, jsdscript->app, raw_filename, JS_FALSE);
}
}
else
{
jsdscript->lwscript = LWDBG_GetCurrentTopLevelScript();
}
}
#endif
JS_INIT_CLIST(&jsdscript->hooks);
return jsdscript;
}
/*
* Start newborn or restart yielding generator and perform the requested
* operation inside its frame.
*/
static JSBool
SendToGenerator(JSContext *cx, JSGeneratorOp op, JSObject *obj,
JSGenerator *gen, jsval arg)
{
JSStackFrame *fp;
JSArena *arena;
JSBool ok;
if (gen->state == JSGEN_RUNNING || gen->state == JSGEN_CLOSING) {
js_ReportValueError(cx, JSMSG_NESTING_GENERATOR,
JSDVG_SEARCH_STACK, OBJECT_TO_JSVAL(obj),
JS_GetFunctionId(gen->frame.fun));
return JS_FALSE;
}
JS_ASSERT(gen->state == JSGEN_NEWBORN || gen->state == JSGEN_OPEN);
switch (op) {
case JSGENOP_NEXT:
case JSGENOP_SEND:
if (gen->state == JSGEN_OPEN) {
/*
* Store the argument to send as the result of the yield
* expression.
*/
gen->savedRegs.sp[-1] = arg;
}
gen->state = JSGEN_RUNNING;
break;
case JSGENOP_THROW:
JS_SetPendingException(cx, arg);
gen->state = JSGEN_RUNNING;
break;
default:
JS_ASSERT(op == JSGENOP_CLOSE);
JS_SetPendingException(cx, JSVAL_ARETURN);
gen->state = JSGEN_CLOSING;
break;
}
/* Extend the current stack pool with gen->arena. */
arena = cx->stackPool.current;
JS_ASSERT(!arena->next);
JS_ASSERT(!gen->arena.next);
JS_ASSERT(cx->stackPool.current != &gen->arena);
cx->stackPool.current = arena->next = &gen->arena;
/* Push gen->frame around the interpreter activation. */
fp = cx->fp;
cx->fp = &gen->frame;
gen->frame.down = fp;
ok = js_Interpret(cx);
cx->fp = fp;
gen->frame.down = NULL;
/* Retract the stack pool and sanitize gen->arena. */
JS_ASSERT(!gen->arena.next);
JS_ASSERT(arena->next == &gen->arena);
JS_ASSERT(cx->stackPool.current == &gen->arena);
cx->stackPool.current = arena;
arena->next = NULL;
if (gen->frame.flags & JSFRAME_YIELDING) {
/* Yield cannot fail, throw or be called on closing. */
JS_ASSERT(ok);
JS_ASSERT(!cx->throwing);
JS_ASSERT(gen->state == JSGEN_RUNNING);
JS_ASSERT(op != JSGENOP_CLOSE);
gen->frame.flags &= ~JSFRAME_YIELDING;
gen->state = JSGEN_OPEN;
return JS_TRUE;
}
gen->frame.rval = JSVAL_VOID;
gen->state = JSGEN_CLOSED;
if (ok) {
/* Returned, explicitly or by falling off the end. */
if (op == JSGENOP_CLOSE)
return JS_TRUE;
return js_ThrowStopIteration(cx);
}
/*
* An error, silent termination by operation callback or an exception.
* Propagate the condition to the caller.
*/
return JS_FALSE;
}
