2020-11-11 09:43:13 +01:00
|
|
|
/* Copyright (C) 2020 Wildfire Games.
|
2010-01-09 20:20:14 +01:00
|
|
|
* 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 "StdDeserializer.h"
|
|
|
|
|
|
|
|
#include "SerializedScriptTypes.h"
|
2011-10-27 22:10:53 +02:00
|
|
|
#include "StdSerializer.h" // for DEBUG_SERIALIZER_ANNOTATE
|
2010-01-09 20:20:14 +01:00
|
|
|
|
|
|
|
#include "scriptinterface/ScriptInterface.h"
|
2013-05-26 23:57:24 +02:00
|
|
|
#include "scriptinterface/ScriptExtraHeaders.h" // for typed arrays
|
2010-05-25 21:24:14 +02:00
|
|
|
|
2010-12-09 12:16:21 +01:00
|
|
|
#include "lib/byte_order.h"
|
|
|
|
|
2017-08-24 02:32:42 +02:00
|
|
|
CStdDeserializer::CStdDeserializer(const ScriptInterface& scriptInterface, std::istream& stream) :
|
Use Symbols to store JS object references when serialising and delete ObjectIDCache
When serialising JS objects, we keep track of any encountered object,
and serialize it only once. Any further serialisation instead stores an
ID referring to the original object (essentially an opaque pointer).
The trouble of course is to have a unique, persistent identifier for
such an object.
svn uses an ObjectIDCache, essentially a "JS Object -> ID" map (which
internally is essentially a "JS heap pointer -> ID" map).
JS, since ES15, includes a "Symbol" primitive type, which is a unique,
immutable identifier. They are also not iterable by for..in or
GetOwnPropertyName or related.
This means they can be used to store the tag directly on the object
(since it's impossible overwrite a user property).
Thanks to this, we can forgo ObjectIDCache in the serializers, and since
following D2897 it becomes unused, we can delete it, along with the
Finalization code it used.
Part of SM52 migration, stage: SM45-compatible changes.
Patch by: Itms
Tested By: Freagarach
Refs #4893
Differential Revision: https://code.wildfiregames.com/D3085
This was SVN commit r24167.
2020-11-12 07:40:19 +01:00
|
|
|
m_ScriptInterface(scriptInterface), m_Stream(stream)
|
2010-01-09 20:20:14 +01:00
|
|
|
{
|
2020-11-18 15:39:04 +01:00
|
|
|
JS_AddExtraGCRootsTracer(m_ScriptInterface.GetGeneralJSContext(), CStdDeserializer::Trace, this);
|
2010-01-09 20:20:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
CStdDeserializer::~CStdDeserializer()
|
|
|
|
{
|
2020-11-18 15:39:04 +01:00
|
|
|
JS_RemoveExtraGCRootsTracer(m_ScriptInterface.GetGeneralJSContext(), CStdDeserializer::Trace, this);
|
2015-01-24 15:46:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void CStdDeserializer::Trace(JSTracer *trc, void *data)
|
|
|
|
{
|
|
|
|
reinterpret_cast<CStdDeserializer*>(data)->TraceMember(trc);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CStdDeserializer::TraceMember(JSTracer *trc)
|
|
|
|
{
|
2020-11-12 09:04:24 +01:00
|
|
|
for (JS::Heap<JSObject*>& backref : m_ScriptBackrefs)
|
|
|
|
JS::TraceEdge(trc, &backref, "StdDeserializer::m_ScriptBackrefs");
|
2010-01-09 20:20:14 +01:00
|
|
|
}
|
|
|
|
|
2011-10-27 22:10:53 +02:00
|
|
|
void CStdDeserializer::Get(const char* name, u8* data, size_t len)
|
2010-01-09 20:20:14 +01:00
|
|
|
{
|
2011-10-27 22:10:53 +02:00
|
|
|
#if DEBUG_SERIALIZER_ANNOTATE
|
|
|
|
std::string strName;
|
|
|
|
char c = m_Stream.get();
|
|
|
|
ENSURE(c == '<');
|
|
|
|
while (1)
|
|
|
|
{
|
|
|
|
c = m_Stream.get();
|
|
|
|
if (c == '>')
|
|
|
|
break;
|
|
|
|
else
|
|
|
|
strName += c;
|
|
|
|
}
|
|
|
|
ENSURE(strName == name);
|
2011-10-28 15:16:53 +02:00
|
|
|
#else
|
|
|
|
UNUSED2(name);
|
2011-10-27 22:10:53 +02:00
|
|
|
#endif
|
2010-09-05 11:38:30 +02:00
|
|
|
m_Stream.read((char*)data, (std::streamsize)len);
|
2015-06-04 07:11:47 +02:00
|
|
|
if (!m_Stream.good())
|
|
|
|
{
|
|
|
|
// hit eof before len, or other errors
|
2015-10-15 05:31:30 +02:00
|
|
|
// NOTE: older libc++ versions incorrectly set eofbit on the last char; test gcount as a workaround
|
2015-06-04 07:11:47 +02:00
|
|
|
// see https://llvm.org/bugs/show_bug.cgi?id=9335
|
|
|
|
if (m_Stream.bad() || m_Stream.fail() || (m_Stream.eof() && m_Stream.gcount() != (std::streamsize)len))
|
|
|
|
throw PSERROR_Deserialize_ReadFailed();
|
|
|
|
}
|
2010-01-09 20:20:14 +01:00
|
|
|
}
|
|
|
|
|
2011-01-12 13:29:00 +01:00
|
|
|
std::istream& CStdDeserializer::GetStream()
|
|
|
|
{
|
|
|
|
return m_Stream;
|
|
|
|
}
|
|
|
|
|
2011-12-22 15:04:32 +01:00
|
|
|
void CStdDeserializer::RequireBytesInStream(size_t numBytes)
|
|
|
|
{
|
2011-12-23 14:37:11 +01:00
|
|
|
// It would be nice to do:
|
|
|
|
// if (numBytes > (size_t)m_Stream.rdbuf()->in_avail())
|
|
|
|
// throw PSERROR_Deserialize_OutOfBounds("RequireBytesInStream");
|
|
|
|
// but that doesn't work (at least on MSVC) since in_avail isn't
|
|
|
|
// guaranteed to return the actual number of bytes available; see e.g.
|
|
|
|
// http://social.msdn.microsoft.com/Forums/en/vclanguage/thread/13009a88-933f-4be7-bf3d-150e425e66a6#70ea562d-8605-4742-8851-1bae431ce6ce
|
2016-11-23 15:09:58 +01:00
|
|
|
|
2011-12-23 14:37:11 +01:00
|
|
|
// Instead we'll just verify that it's not an extremely large number:
|
|
|
|
if (numBytes > 64*MiB)
|
2011-12-22 15:04:32 +01:00
|
|
|
throw PSERROR_Deserialize_OutOfBounds("RequireBytesInStream");
|
|
|
|
}
|
|
|
|
|
2015-01-24 15:46:52 +01:00
|
|
|
void CStdDeserializer::AddScriptBackref(JS::HandleObject obj)
|
2010-01-09 20:20:14 +01:00
|
|
|
{
|
2015-01-24 15:46:52 +01:00
|
|
|
m_ScriptBackrefs.push_back(JS::Heap<JSObject*>(obj));
|
2010-01-09 20:20:14 +01:00
|
|
|
}
|
|
|
|
|
Use Symbols to store JS object references when serialising and delete ObjectIDCache
When serialising JS objects, we keep track of any encountered object,
and serialize it only once. Any further serialisation instead stores an
ID referring to the original object (essentially an opaque pointer).
The trouble of course is to have a unique, persistent identifier for
such an object.
svn uses an ObjectIDCache, essentially a "JS Object -> ID" map (which
internally is essentially a "JS heap pointer -> ID" map).
JS, since ES15, includes a "Symbol" primitive type, which is a unique,
immutable identifier. They are also not iterable by for..in or
GetOwnPropertyName or related.
This means they can be used to store the tag directly on the object
(since it's impossible overwrite a user property).
Thanks to this, we can forgo ObjectIDCache in the serializers, and since
following D2897 it becomes unused, we can delete it, along with the
Finalization code it used.
Part of SM52 migration, stage: SM45-compatible changes.
Patch by: Itms
Tested By: Freagarach
Refs #4893
Differential Revision: https://code.wildfiregames.com/D3085
This was SVN commit r24167.
2020-11-12 07:40:19 +01:00
|
|
|
void CStdDeserializer::GetScriptBackref(size_t tag, JS::MutableHandleObject ret)
|
2010-01-09 20:20:14 +01:00
|
|
|
{
|
2015-01-24 15:46:52 +01:00
|
|
|
ENSURE(m_ScriptBackrefs.size() > tag);
|
|
|
|
ret.set(m_ScriptBackrefs[tag]);
|
2010-01-09 20:20:14 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////
|
|
|
|
|
2017-08-28 12:27:36 +02:00
|
|
|
JS::Value CStdDeserializer::ReadScriptVal(const char* UNUSED(name), JS::HandleObject appendParent)
|
2010-01-09 20:20:14 +01:00
|
|
|
{
|
Improve JS Exception handling.
- Check for pending exceptions after function calls and script
executions.
- Call LOGERROR instead of JS_ReportError when there is a conversion
error in FromJSVal, since that can only be called from C++ (where JS
errors don't really make sense). Instead, C++ callers of FromJSVal
should handle the failure and, themselves, either report an error or
simply do something else.
- Wrap JS_ReportError since that makes updating it later easier.
This isn't a systematical fix since ToJSVal also ought return a boolean
for failures, and we probably should trigger errors instead of warnings
on 'implicit' conversions, rather a preparation diff.
Part of the SM52 migration, stage: SM45 compatible (actually SM52
incompatible, too).
Based on a patch by: Itms
Comments by: Vladislavbelov, Stan`
Refs #742, #4893
Differential Revision: https://code.wildfiregames.com/D3093
This was SVN commit r24187.
2020-11-15 19:29:17 +01:00
|
|
|
ScriptRequest rq(m_ScriptInterface);
|
2014-03-28 21:26:32 +01:00
|
|
|
|
2010-01-09 20:20:14 +01:00
|
|
|
uint8_t type;
|
2010-09-17 19:53:26 +02:00
|
|
|
NumberU8_Unbounded("type", type);
|
2010-01-09 20:20:14 +01:00
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case SCRIPT_TYPE_VOID:
|
2015-01-24 15:46:52 +01:00
|
|
|
return JS::UndefinedValue();
|
2010-01-09 20:20:14 +01:00
|
|
|
|
|
|
|
case SCRIPT_TYPE_NULL:
|
2015-01-24 15:46:52 +01:00
|
|
|
return JS::NullValue();
|
2010-01-09 20:20:14 +01:00
|
|
|
|
|
|
|
case SCRIPT_TYPE_ARRAY:
|
|
|
|
case SCRIPT_TYPE_OBJECT:
|
|
|
|
{
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedObject obj(rq.cx);
|
2010-01-09 20:20:14 +01:00
|
|
|
if (appendParent)
|
2011-10-27 22:56:32 +02:00
|
|
|
{
|
2014-07-31 21:18:40 +02:00
|
|
|
obj.set(appendParent);
|
2011-10-27 22:56:32 +02:00
|
|
|
}
|
2010-01-09 20:20:14 +01:00
|
|
|
else if (type == SCRIPT_TYPE_ARRAY)
|
2011-10-27 22:56:32 +02:00
|
|
|
{
|
|
|
|
u32 length;
|
|
|
|
NumberU32_Unbounded("array length", length);
|
2020-11-13 14:18:22 +01:00
|
|
|
obj.set(JS_NewArrayObject(rq.cx, length));
|
2011-10-27 22:56:32 +02:00
|
|
|
}
|
2020-11-11 09:43:13 +01:00
|
|
|
else // SCRIPT_TYPE_OBJECT
|
2011-10-27 22:56:32 +02:00
|
|
|
{
|
2020-11-13 14:18:22 +01:00
|
|
|
obj.set(JS_NewPlainObject(rq.cx));
|
2011-10-27 22:56:32 +02:00
|
|
|
}
|
2010-01-09 20:20:14 +01:00
|
|
|
|
|
|
|
if (!obj)
|
2013-05-26 23:57:24 +02:00
|
|
|
throw PSERROR_Deserialize_ScriptError("Deserializer failed to create new object");
|
2010-01-09 20:20:14 +01:00
|
|
|
|
|
|
|
AddScriptBackref(obj);
|
|
|
|
|
|
|
|
uint32_t numProps;
|
2010-09-17 19:53:26 +02:00
|
|
|
NumberU32_Unbounded("num props", numProps);
|
2016-09-02 18:51:09 +02:00
|
|
|
bool isLatin1;
|
2010-01-09 20:20:14 +01:00
|
|
|
for (uint32_t i = 0; i < numProps; ++i)
|
|
|
|
{
|
2016-09-02 18:51:09 +02:00
|
|
|
Bool("isLatin1", isLatin1);
|
|
|
|
if (isLatin1)
|
|
|
|
{
|
|
|
|
std::vector<JS::Latin1Char> propname;
|
|
|
|
ReadStringLatin1("prop name", propname);
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedValue propval(rq.cx, ReadScriptVal("prop value", nullptr));
|
2010-01-09 20:20:14 +01:00
|
|
|
|
2016-09-02 18:51:09 +02:00
|
|
|
utf16string prp(propname.begin(), propname.end());;
|
2016-09-02 18:55:13 +02:00
|
|
|
// TODO: Should ask upstream about getting a variant of JS_SetProperty with a length param.
|
2020-11-13 14:18:22 +01:00
|
|
|
if (!JS_SetUCProperty(rq.cx, obj, (const char16_t*)prp.data(), prp.length(), propval))
|
2016-09-02 18:51:09 +02:00
|
|
|
throw PSERROR_Deserialize_ScriptError();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
utf16string propname;
|
|
|
|
ReadStringUTF16("prop name", propname);
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedValue propval(rq.cx, ReadScriptVal("prop value", nullptr));
|
2016-09-02 18:51:09 +02:00
|
|
|
|
2020-11-13 14:18:22 +01:00
|
|
|
if (!JS_SetUCProperty(rq.cx, obj, (const char16_t*)propname.data(), propname.length(), propval))
|
2016-09-02 18:51:09 +02:00
|
|
|
throw PSERROR_Deserialize_ScriptError();
|
|
|
|
}
|
2010-01-09 20:20:14 +01:00
|
|
|
}
|
|
|
|
|
2014-03-28 21:26:32 +01:00
|
|
|
return JS::ObjectValue(*obj);
|
2010-01-09 20:20:14 +01:00
|
|
|
}
|
|
|
|
case SCRIPT_TYPE_STRING:
|
|
|
|
{
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedString str(rq.cx);
|
2015-01-24 15:46:52 +01:00
|
|
|
ScriptString("string", &str);
|
2014-03-28 21:26:32 +01:00
|
|
|
return JS::StringValue(str);
|
2010-01-09 20:20:14 +01:00
|
|
|
}
|
|
|
|
case SCRIPT_TYPE_INT:
|
|
|
|
{
|
|
|
|
int32_t value;
|
2010-09-17 19:53:26 +02:00
|
|
|
NumberI32("value", value, JSVAL_INT_MIN, JSVAL_INT_MAX);
|
2014-03-28 21:26:32 +01:00
|
|
|
return JS::NumberValue(value);
|
2010-01-09 20:20:14 +01:00
|
|
|
}
|
|
|
|
case SCRIPT_TYPE_DOUBLE:
|
|
|
|
{
|
|
|
|
double value;
|
2010-09-17 19:53:26 +02:00
|
|
|
NumberDouble_Unbounded("value", value);
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedValue rval(rq.cx, JS::NumberValue(value));
|
2015-01-24 15:46:52 +01:00
|
|
|
if (rval.isNull())
|
2010-01-09 20:20:14 +01:00
|
|
|
throw PSERROR_Deserialize_ScriptError("JS_NewNumberValue failed");
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
case SCRIPT_TYPE_BOOLEAN:
|
|
|
|
{
|
|
|
|
uint8_t value;
|
2010-09-17 19:53:26 +02:00
|
|
|
NumberU8("value", value, 0, 1);
|
2014-03-28 21:26:32 +01:00
|
|
|
return JS::BooleanValue(value ? true : false);
|
2010-01-09 20:20:14 +01:00
|
|
|
}
|
|
|
|
case SCRIPT_TYPE_BACKREF:
|
|
|
|
{
|
Use Symbols to store JS object references when serialising and delete ObjectIDCache
When serialising JS objects, we keep track of any encountered object,
and serialize it only once. Any further serialisation instead stores an
ID referring to the original object (essentially an opaque pointer).
The trouble of course is to have a unique, persistent identifier for
such an object.
svn uses an ObjectIDCache, essentially a "JS Object -> ID" map (which
internally is essentially a "JS heap pointer -> ID" map).
JS, since ES15, includes a "Symbol" primitive type, which is a unique,
immutable identifier. They are also not iterable by for..in or
GetOwnPropertyName or related.
This means they can be used to store the tag directly on the object
(since it's impossible overwrite a user property).
Thanks to this, we can forgo ObjectIDCache in the serializers, and since
following D2897 it becomes unused, we can delete it, along with the
Finalization code it used.
Part of SM52 migration, stage: SM45-compatible changes.
Patch by: Itms
Tested By: Freagarach
Refs #4893
Differential Revision: https://code.wildfiregames.com/D3085
This was SVN commit r24167.
2020-11-12 07:40:19 +01:00
|
|
|
i32 tag;
|
|
|
|
NumberI32("tag", tag, 0, JSVAL_INT_MAX);
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedObject obj(rq.cx);
|
2015-01-24 15:46:52 +01:00
|
|
|
GetScriptBackref(tag, &obj);
|
2010-01-09 20:20:14 +01:00
|
|
|
if (!obj)
|
|
|
|
throw PSERROR_Deserialize_ScriptError("Invalid backref tag");
|
2014-03-28 21:26:32 +01:00
|
|
|
return JS::ObjectValue(*obj);
|
2010-01-09 20:20:14 +01:00
|
|
|
}
|
2013-05-26 23:57:24 +02:00
|
|
|
case SCRIPT_TYPE_OBJECT_NUMBER:
|
|
|
|
{
|
|
|
|
double value;
|
|
|
|
NumberDouble_Unbounded("value", value);
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedValue val(rq.cx, JS::NumberValue(value));
|
2013-05-26 23:57:24 +02:00
|
|
|
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedObject ctorobj(rq.cx);
|
|
|
|
if (!JS_GetClassObject(rq.cx, JSProto_Number, &ctorobj))
|
2013-05-26 23:57:24 +02:00
|
|
|
throw PSERROR_Deserialize_ScriptError("JS_GetClassObject failed");
|
|
|
|
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedObject obj(rq.cx, JS_New(rq.cx, ctorobj, JS::HandleValueArray(val)));
|
2013-05-26 23:57:24 +02:00
|
|
|
if (!obj)
|
|
|
|
throw PSERROR_Deserialize_ScriptError("JS_New failed");
|
|
|
|
AddScriptBackref(obj);
|
2014-03-28 21:26:32 +01:00
|
|
|
return JS::ObjectValue(*obj);
|
2013-05-26 23:57:24 +02:00
|
|
|
}
|
|
|
|
case SCRIPT_TYPE_OBJECT_STRING:
|
|
|
|
{
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedString str(rq.cx);
|
2015-01-24 15:46:52 +01:00
|
|
|
ScriptString("value", &str);
|
2013-05-26 23:57:24 +02:00
|
|
|
if (!str)
|
|
|
|
throw PSERROR_Deserialize_ScriptError();
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedValue val(rq.cx, JS::StringValue(str));
|
2013-05-26 23:57:24 +02:00
|
|
|
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedObject ctorobj(rq.cx);
|
|
|
|
if (!JS_GetClassObject(rq.cx, JSProto_String, &ctorobj))
|
2013-05-26 23:57:24 +02:00
|
|
|
throw PSERROR_Deserialize_ScriptError("JS_GetClassObject failed");
|
|
|
|
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedObject obj(rq.cx, JS_New(rq.cx, ctorobj, JS::HandleValueArray(val)));
|
2013-05-26 23:57:24 +02:00
|
|
|
if (!obj)
|
|
|
|
throw PSERROR_Deserialize_ScriptError("JS_New failed");
|
|
|
|
AddScriptBackref(obj);
|
2014-03-28 21:26:32 +01:00
|
|
|
return JS::ObjectValue(*obj);
|
2013-05-26 23:57:24 +02:00
|
|
|
}
|
|
|
|
case SCRIPT_TYPE_OBJECT_BOOLEAN:
|
|
|
|
{
|
|
|
|
bool value;
|
|
|
|
Bool("value", value);
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedValue val(rq.cx, JS::BooleanValue(value));
|
2013-05-26 23:57:24 +02:00
|
|
|
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedObject ctorobj(rq.cx);
|
|
|
|
if (!JS_GetClassObject(rq.cx, JSProto_Boolean, &ctorobj))
|
2013-05-26 23:57:24 +02:00
|
|
|
throw PSERROR_Deserialize_ScriptError("JS_GetClassObject failed");
|
|
|
|
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedObject obj(rq.cx, JS_New(rq.cx, ctorobj, JS::HandleValueArray(val)));
|
2013-05-26 23:57:24 +02:00
|
|
|
if (!obj)
|
|
|
|
throw PSERROR_Deserialize_ScriptError("JS_New failed");
|
|
|
|
AddScriptBackref(obj);
|
2014-03-28 21:26:32 +01:00
|
|
|
return JS::ObjectValue(*obj);
|
2013-05-26 23:57:24 +02:00
|
|
|
}
|
|
|
|
case SCRIPT_TYPE_TYPED_ARRAY:
|
|
|
|
{
|
|
|
|
u8 arrayType;
|
|
|
|
u32 byteOffset, length;
|
|
|
|
NumberU8_Unbounded("array type", arrayType);
|
|
|
|
NumberU32_Unbounded("byte offset", byteOffset);
|
|
|
|
NumberU32_Unbounded("length", length);
|
|
|
|
|
|
|
|
// To match the serializer order, we reserve the typed array's backref tag here
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedObject arrayObj(rq.cx);
|
2016-11-24 15:47:49 +01:00
|
|
|
AddScriptBackref(arrayObj);
|
2013-05-26 23:57:24 +02:00
|
|
|
|
|
|
|
// Get buffer object
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedValue bufferVal(rq.cx, ReadScriptVal("buffer", nullptr));
|
2013-05-26 23:57:24 +02:00
|
|
|
|
2014-03-28 21:26:32 +01:00
|
|
|
if (!bufferVal.isObject())
|
2013-05-26 23:57:24 +02:00
|
|
|
throw PSERROR_Deserialize_ScriptError();
|
|
|
|
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedObject bufferObj(rq.cx, &bufferVal.toObject());
|
2014-03-28 21:26:32 +01:00
|
|
|
if (!JS_IsArrayBufferObject(bufferObj))
|
2013-05-26 23:57:24 +02:00
|
|
|
throw PSERROR_Deserialize_ScriptError("js_IsArrayBuffer failed");
|
|
|
|
|
2014-03-28 21:26:32 +01:00
|
|
|
switch(arrayType)
|
|
|
|
{
|
|
|
|
case SCRIPT_TYPED_ARRAY_INT8:
|
2020-11-13 14:18:22 +01:00
|
|
|
arrayObj = JS_NewInt8ArrayWithBuffer(rq.cx, bufferObj, byteOffset, length);
|
2014-03-28 21:26:32 +01:00
|
|
|
break;
|
|
|
|
case SCRIPT_TYPED_ARRAY_UINT8:
|
2020-11-13 14:18:22 +01:00
|
|
|
arrayObj = JS_NewUint8ArrayWithBuffer(rq.cx, bufferObj, byteOffset, length);
|
2014-03-28 21:26:32 +01:00
|
|
|
break;
|
|
|
|
case SCRIPT_TYPED_ARRAY_INT16:
|
2020-11-13 14:18:22 +01:00
|
|
|
arrayObj = JS_NewInt16ArrayWithBuffer(rq.cx, bufferObj, byteOffset, length);
|
2014-03-28 21:26:32 +01:00
|
|
|
break;
|
|
|
|
case SCRIPT_TYPED_ARRAY_UINT16:
|
2020-11-13 14:18:22 +01:00
|
|
|
arrayObj = JS_NewUint16ArrayWithBuffer(rq.cx, bufferObj, byteOffset, length);
|
2014-03-28 21:26:32 +01:00
|
|
|
break;
|
|
|
|
case SCRIPT_TYPED_ARRAY_INT32:
|
2020-11-13 14:18:22 +01:00
|
|
|
arrayObj = JS_NewInt32ArrayWithBuffer(rq.cx, bufferObj, byteOffset, length);
|
2014-03-28 21:26:32 +01:00
|
|
|
break;
|
|
|
|
case SCRIPT_TYPED_ARRAY_UINT32:
|
2020-11-13 14:18:22 +01:00
|
|
|
arrayObj = JS_NewUint32ArrayWithBuffer(rq.cx, bufferObj, byteOffset, length);
|
2014-03-28 21:26:32 +01:00
|
|
|
break;
|
|
|
|
case SCRIPT_TYPED_ARRAY_FLOAT32:
|
2020-11-13 14:18:22 +01:00
|
|
|
arrayObj = JS_NewFloat32ArrayWithBuffer(rq.cx, bufferObj, byteOffset, length);
|
2014-03-28 21:26:32 +01:00
|
|
|
break;
|
|
|
|
case SCRIPT_TYPED_ARRAY_FLOAT64:
|
2020-11-13 14:18:22 +01:00
|
|
|
arrayObj = JS_NewFloat64ArrayWithBuffer(rq.cx, bufferObj, byteOffset, length);
|
2014-03-28 21:26:32 +01:00
|
|
|
break;
|
|
|
|
case SCRIPT_TYPED_ARRAY_UINT8_CLAMPED:
|
2020-11-13 14:18:22 +01:00
|
|
|
arrayObj = JS_NewUint8ClampedArrayWithBuffer(rq.cx, bufferObj, byteOffset, length);
|
2014-03-28 21:26:32 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
throw PSERROR_Deserialize_ScriptError("Failed to deserialize unrecognized typed array view");
|
|
|
|
}
|
2013-05-26 23:57:24 +02:00
|
|
|
if (!arrayObj)
|
|
|
|
throw PSERROR_Deserialize_ScriptError("js_CreateTypedArrayWithBuffer failed");
|
|
|
|
|
2014-03-28 21:26:32 +01:00
|
|
|
return JS::ObjectValue(*arrayObj);
|
2013-05-26 23:57:24 +02:00
|
|
|
}
|
|
|
|
case SCRIPT_TYPE_ARRAY_BUFFER:
|
|
|
|
{
|
|
|
|
u32 length;
|
|
|
|
NumberU32_Unbounded("buffer length", length);
|
|
|
|
|
|
|
|
#if BYTE_ORDER != LITTLE_ENDIAN
|
|
|
|
#error TODO: need to convert JS ArrayBuffer data from little-endian
|
|
|
|
#endif
|
2015-12-19 03:49:46 +01:00
|
|
|
void* contents = malloc(length);
|
|
|
|
ENSURE(contents);
|
2015-01-24 15:46:52 +01:00
|
|
|
RawBytes("buffer data", (u8*)contents, length);
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedObject bufferObj(rq.cx, JS_NewArrayBufferWithContents(rq.cx, length, contents));
|
2013-05-26 23:57:24 +02:00
|
|
|
AddScriptBackref(bufferObj);
|
|
|
|
|
2014-03-28 21:26:32 +01:00
|
|
|
return JS::ObjectValue(*bufferObj);
|
2013-05-26 23:57:24 +02:00
|
|
|
}
|
2014-09-20 19:14:53 +02:00
|
|
|
case SCRIPT_TYPE_OBJECT_MAP:
|
|
|
|
{
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedObject obj(rq.cx, JS::NewMapObject(rq.cx));
|
2016-11-24 15:47:49 +01:00
|
|
|
AddScriptBackref(obj);
|
|
|
|
|
2014-09-20 19:14:53 +02:00
|
|
|
u32 mapSize;
|
|
|
|
NumberU32_Unbounded("map size", mapSize);
|
2015-08-30 06:51:16 +02:00
|
|
|
|
2014-09-20 19:14:53 +02:00
|
|
|
for (u32 i=0; i<mapSize; ++i)
|
|
|
|
{
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedValue key(rq.cx, ReadScriptVal("map key", nullptr));
|
|
|
|
JS::RootedValue value(rq.cx, ReadScriptVal("map value", nullptr));
|
|
|
|
JS::MapSet(rq.cx, obj, key, value);
|
2014-09-20 19:14:53 +02:00
|
|
|
}
|
2016-11-24 15:47:49 +01:00
|
|
|
|
2016-09-02 18:54:00 +02:00
|
|
|
return JS::ObjectValue(*obj);
|
2014-09-20 19:14:53 +02:00
|
|
|
}
|
2015-05-02 01:04:28 +02:00
|
|
|
case SCRIPT_TYPE_OBJECT_SET:
|
|
|
|
{
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedValue setVal(rq.cx);
|
2015-05-02 01:04:28 +02:00
|
|
|
m_ScriptInterface.Eval("(new Set())", &setVal);
|
|
|
|
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedObject setObj(rq.cx, &setVal.toObject());
|
2016-11-24 15:47:49 +01:00
|
|
|
AddScriptBackref(setObj);
|
|
|
|
|
|
|
|
u32 setSize;
|
|
|
|
NumberU32_Unbounded("set size", setSize);
|
2015-08-30 06:51:16 +02:00
|
|
|
|
2015-05-02 01:04:28 +02:00
|
|
|
for (u32 i=0; i<setSize; ++i)
|
|
|
|
{
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedValue value(rq.cx, ReadScriptVal("set value", nullptr));
|
2015-05-02 01:04:28 +02:00
|
|
|
m_ScriptInterface.CallFunctionVoid(setVal, "add", value);
|
|
|
|
}
|
2016-11-24 15:47:49 +01:00
|
|
|
|
2015-05-02 01:04:28 +02:00
|
|
|
return setVal;
|
|
|
|
}
|
2010-01-09 20:20:14 +01:00
|
|
|
default:
|
|
|
|
throw PSERROR_Deserialize_OutOfBounds();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-02 18:51:09 +02:00
|
|
|
void CStdDeserializer::ReadStringLatin1(const char* name, std::vector<JS::Latin1Char>& str)
|
|
|
|
{
|
|
|
|
uint32_t len;
|
|
|
|
NumberU32_Unbounded("string length", len);
|
|
|
|
RequireBytesInStream(len);
|
|
|
|
str.resize(len);
|
|
|
|
Get(name, (u8*)str.data(), len);
|
|
|
|
}
|
|
|
|
|
2011-10-27 22:10:53 +02:00
|
|
|
void CStdDeserializer::ReadStringUTF16(const char* name, utf16string& str)
|
2010-05-25 20:07:41 +02:00
|
|
|
{
|
|
|
|
uint32_t len;
|
2010-09-17 19:53:26 +02:00
|
|
|
NumberU32_Unbounded("string length", len);
|
2011-12-22 15:04:32 +01:00
|
|
|
RequireBytesInStream(len*2);
|
|
|
|
str.resize(len);
|
2011-10-27 22:10:53 +02:00
|
|
|
Get(name, (u8*)str.data(), len*2);
|
2010-05-25 20:07:41 +02:00
|
|
|
}
|
|
|
|
|
2015-01-24 15:46:52 +01:00
|
|
|
void CStdDeserializer::ScriptString(const char* name, JS::MutableHandleString out)
|
2010-01-09 20:20:14 +01:00
|
|
|
{
|
2010-05-25 20:07:41 +02:00
|
|
|
#if BYTE_ORDER != LITTLE_ENDIAN
|
|
|
|
#error TODO: probably need to convert JS strings from little-endian
|
|
|
|
#endif
|
2010-01-09 20:20:14 +01:00
|
|
|
|
Improve JS Exception handling.
- Check for pending exceptions after function calls and script
executions.
- Call LOGERROR instead of JS_ReportError when there is a conversion
error in FromJSVal, since that can only be called from C++ (where JS
errors don't really make sense). Instead, C++ callers of FromJSVal
should handle the failure and, themselves, either report an error or
simply do something else.
- Wrap JS_ReportError since that makes updating it later easier.
This isn't a systematical fix since ToJSVal also ought return a boolean
for failures, and we probably should trigger errors instead of warnings
on 'implicit' conversions, rather a preparation diff.
Part of the SM52 migration, stage: SM45 compatible (actually SM52
incompatible, too).
Based on a patch by: Itms
Comments by: Vladislavbelov, Stan`
Refs #742, #4893
Differential Revision: https://code.wildfiregames.com/D3093
This was SVN commit r24187.
2020-11-15 19:29:17 +01:00
|
|
|
ScriptRequest rq(m_ScriptInterface);
|
2016-09-18 11:34:45 +02:00
|
|
|
|
2016-09-02 18:51:09 +02:00
|
|
|
bool isLatin1;
|
|
|
|
Bool("isLatin1", isLatin1);
|
|
|
|
if (isLatin1)
|
|
|
|
{
|
|
|
|
std::vector<JS::Latin1Char> str;
|
|
|
|
ReadStringLatin1(name, str);
|
|
|
|
|
2020-11-13 14:18:22 +01:00
|
|
|
out.set(JS_NewStringCopyN(rq.cx, (const char*)str.data(), str.size()));
|
2016-09-02 18:51:09 +02:00
|
|
|
if (!out)
|
|
|
|
throw PSERROR_Deserialize_ScriptError("JS_NewStringCopyN failed");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
utf16string str;
|
|
|
|
ReadStringUTF16(name, str);
|
|
|
|
|
2020-11-13 14:18:22 +01:00
|
|
|
out.set(JS_NewUCStringCopyN(rq.cx, (const char16_t*)str.data(), str.length()));
|
2016-09-02 18:51:09 +02:00
|
|
|
if (!out)
|
|
|
|
throw PSERROR_Deserialize_ScriptError("JS_NewUCStringCopyN failed");
|
|
|
|
}
|
2010-01-09 20:20:14 +01:00
|
|
|
}
|
|
|
|
|
2014-07-31 21:18:40 +02:00
|
|
|
void CStdDeserializer::ScriptVal(const char* name, JS::MutableHandleValue out)
|
2010-01-09 20:20:14 +01:00
|
|
|
{
|
Upgrade SpiderMonkey to version 45.0.2, refs #4893.
- Various build changes, in particular NSPR is not needed on Unix
anymore
- Add js/Initialization.h to source/scriptinterface/ScriptEngine.h
- Use nullptr instead of JS::NullPtr(), see
https://bugzilla.mozilla.org/show_bug.cgi?id=1164602
- Remove `JS::RuntimeOptionsRef.varObjFix`, see
https://bugzilla.mozilla.org/show_bug.cgi?id=1171177
- Remove uses of `AutoIdArray`, see
https://bugzilla.mozilla.org/show_bug.cgi?id=1191529
- `JS_InternUCStringN` has been renamed, see
https://bugzilla.mozilla.org/show_bug.cgi?id=1178581
- `JS::Evaluate` now takes scope chains explicitly, see
https://bugzilla.mozilla.org/show_bug.cgi?id=1097987
- Array functions (such as `JS_IsArrayObject`) are fallible and output
to params, see https://bugzilla.mozilla.org/show_bug.cgi?id=f3d35d8
- Remove `JSCLASS_CACHED_PROTO_WIDTH` workaround in our code, see
https://bugzilla.mozilla.org/show_bug.cgi?id=1236373
- Remove compile'n go (`setCompileAndGo`) and replace it by
`setIsRunOnce` which will become the default in the future, see
https://bugzilla.mozilla.org/show_bug.cgi?id=679939
- Mark shared memory in direct access operations
(`JS_GetUint16ArrayData` and `JS_GetUint8ArrayData`), see
https://bugzilla.mozilla.org/show_bug.cgi?id=1176214
- Use new `JS::ObjectOpResult`, see
https://bugzilla.mozilla.org/show_bug.cgi?id=1113369
Thanks to wraitii, elexis, Krinkle and historic_bruno for contributions
and comments, and to gentz, madpilot, s0600204 and Stan for testing and
indirect contributions.
Differential Revision: https://code.wildfiregames.com/D1510
This was SVN commit r22627.
2019-08-08 00:37:43 +02:00
|
|
|
out.set(ReadScriptVal(name, nullptr));
|
2010-01-09 20:20:14 +01:00
|
|
|
}
|
|
|
|
|
2014-07-31 21:18:40 +02:00
|
|
|
void CStdDeserializer::ScriptObjectAppend(const char* name, JS::HandleValue objVal)
|
2010-05-20 02:59:01 +02:00
|
|
|
{
|
Improve JS Exception handling.
- Check for pending exceptions after function calls and script
executions.
- Call LOGERROR instead of JS_ReportError when there is a conversion
error in FromJSVal, since that can only be called from C++ (where JS
errors don't really make sense). Instead, C++ callers of FromJSVal
should handle the failure and, themselves, either report an error or
simply do something else.
- Wrap JS_ReportError since that makes updating it later easier.
This isn't a systematical fix since ToJSVal also ought return a boolean
for failures, and we probably should trigger errors instead of warnings
on 'implicit' conversions, rather a preparation diff.
Part of the SM52 migration, stage: SM45 compatible (actually SM52
incompatible, too).
Based on a patch by: Itms
Comments by: Vladislavbelov, Stan`
Refs #742, #4893
Differential Revision: https://code.wildfiregames.com/D3093
This was SVN commit r24187.
2020-11-15 19:29:17 +01:00
|
|
|
ScriptRequest rq(m_ScriptInterface);
|
2016-11-23 15:09:58 +01:00
|
|
|
|
2014-07-31 21:18:40 +02:00
|
|
|
if (!objVal.isObject())
|
2010-01-09 20:20:14 +01:00
|
|
|
throw PSERROR_Deserialize_ScriptError();
|
|
|
|
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedObject obj(rq.cx, &objVal.toObject());
|
2014-07-31 21:18:40 +02:00
|
|
|
ReadScriptVal(name, obj);
|
2010-01-09 20:20:14 +01:00
|
|
|
}
|