template<> bool ScriptInterface::FromJSVal<std::wstring>(JSContext* cx, JS::HandleValue v, std::wstring& out)
{
JSAutoRequest rq(cx);
WARN_IF_NOT(v.isString() || v.isNumber(), v); // allow implicit number conversions
JS::RootedString str(cx, JS::ToString(cx, v));
if (!str)
FAIL("Argument must be convertible to a string");
if (JS_StringHasLatin1Chars(str))
{
size_t length;
JS::AutoCheckCannotGC nogc;
const JS::Latin1Char* ch = JS_GetLatin1StringCharsAndLength(cx, nogc, str, &length);
if (!ch)
FAIL("JS_GetLatin1StringCharsAndLength failed");
out.assign(ch, ch + length);
}
else
{
size_t length;
JS::AutoCheckCannotGC nogc;
const char16_t* ch = JS_GetTwoByteStringCharsAndLength(cx, nogc, str, &length);
if (!ch)
FAIL("JS_GetTwoByteStringsCharsAndLength failed"); // out of memory
out.assign(ch, ch + length);
}
return true;
}
/**
* gjs_string_get_char16_data:
* @context: js context
* @str: a rooted JSString
* @data_p: address to return allocated data buffer
* @len_p: address to return length of data (number of 16-bit characters)
*
* Get the binary data (as a sequence of 16-bit characters) in @str.
*
* Returns: false if exception thrown
**/
bool
gjs_string_get_char16_data(JSContext *context,
JS::HandleString str,
char16_t **data_p,
size_t *len_p)
{
JSAutoRequest ar(context);
if (JS_StringHasLatin1Chars(str))
return from_latin1(context, str, data_p, len_p);
/* From this point on, crash if a GC is triggered while we are using
* the string's chars */
JS::AutoCheckCannotGC nogc;
const char16_t *js_data =
JS_GetTwoByteStringCharsAndLength(context, nogc, str, len_p);
if (js_data == NULL)
return false;
*data_p = (char16_t *) g_memdup(js_data, sizeof(*js_data) * (*len_p));
return true;
}
void CBinarySerializerScriptImpl::ScriptString(const char* name, JS::HandleString string)
{
JSContext* cx = m_ScriptInterface.GetContext();
JSAutoRequest rq(cx);
#if BYTE_ORDER != LITTLE_ENDIAN
#error TODO: probably need to convert JS strings to little-endian
#endif
size_t length;
JS::AutoCheckCannotGC nogc;
// Serialize strings directly as UTF-16 or Latin1, to avoid expensive encoding conversions
bool isLatin1 = JS_StringHasLatin1Chars(string);
m_Serializer.Bool("isLatin1", isLatin1);
if (isLatin1)
{
const JS::Latin1Char* chars = JS_GetLatin1StringCharsAndLength(cx, nogc, string, &length);
if (!chars)
throw PSERROR_Serialize_ScriptError("JS_GetLatin1StringCharsAndLength failed");
m_Serializer.NumberU32_Unbounded("string length", (u32)length);
m_Serializer.RawBytes(name, (const u8*)chars, length);
}
else
{
const char16_t* chars = JS_GetTwoByteStringCharsAndLength(cx, nogc, string, &length);
if (!chars)
throw PSERROR_Serialize_ScriptError("JS_GetTwoByteStringCharsAndLength failed");
m_Serializer.NumberU32_Unbounded("string length", (u32)length);
m_Serializer.RawBytes(name, (const u8*)chars, length*2);
}
}
/**
* gjs_string_to_ucs4:
* @cx: a #JSContext
* @str: rooted JSString
* @ucs4_string_p: return location for a #gunichar array
* @len_p: return location for @ucs4_string_p length
*
* Returns: true on success, false otherwise in which case a JS error is thrown
*/
bool
gjs_string_to_ucs4(JSContext *cx,
JS::HandleString str,
gunichar **ucs4_string_p,
size_t *len_p)
{
if (ucs4_string_p == NULL)
return true;
JSAutoRequest ar(cx);
size_t len;
GError *error = NULL;
if (JS_StringHasLatin1Chars(str))
return from_latin1(cx, str, ucs4_string_p, len_p);
/* From this point on, crash if a GC is triggered while we are using
* the string's chars */
JS::AutoCheckCannotGC nogc;
const char16_t *utf16 =
JS_GetTwoByteStringCharsAndLength(cx, nogc, str, &len);
if (utf16 == NULL) {
gjs_throw(cx, "Failed to get UTF-16 string data");
return false;
}
if (ucs4_string_p != NULL) {
long length;
*ucs4_string_p = g_utf16_to_ucs4(reinterpret_cast<const gunichar2 *>(utf16),
len, NULL, &length, &error);
if (*ucs4_string_p == NULL) {
gjs_throw(cx, "Failed to convert UTF-16 string to UCS-4: %s",
error->message);
g_clear_error(&error);
return false;
}
if (len_p != NULL)
*len_p = (size_t) length;
}
return true;
}
bool ScriptInterface::EnumeratePropertyNamesWithPrefix(JS::HandleValue objVal, const char* prefix, std::vector<std::string>& out)
{
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::AutoIdArray props(m->m_cx, JS_Enumerate(m->m_cx, obj));
if (!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;
}
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();
}
}
}