dmcallis
65a0592776
Source code drop for the Actionscript virtual machine in the Adobe Flash Player for December 2013
1512 lines
48 KiB
C++
1512 lines
48 KiB
C++
/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
|
|
/* vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "avmplus.h"
|
|
|
|
namespace avmplus
|
|
{
|
|
|
|
#define BUILTIN_TRAITS_(class_id) toplevel->core()->builtinPool->getClassTraits(avmplus::NativeID::abcclass_##class_id)->itraits
|
|
|
|
static const char kTransient[] = "Transient";
|
|
static const char kWriteExternal[] = "writeExternal";
|
|
static const char kReadExternal[] = "readExternal";
|
|
|
|
//---------------------------------------------------------------------
|
|
// class ObjectOutput is the base class for classes ClassicObjectOutput
|
|
// and AvmPlusObjectOutput
|
|
//
|
|
|
|
ObjectOutput::ObjectOutput(Toplevel *tl)
|
|
: m_listClassInfo(tl->core()->GetGC(), 64)
|
|
, m_htString(HeapHashtable::create(tl->core()->GetGC()))
|
|
, m_htTraits(HeapHashtable::create(tl->core()->GetGC()))
|
|
, m_htObject(HeapHashtable::create(tl->core()->GetGC()))
|
|
{
|
|
}
|
|
|
|
ObjectOutput::~ObjectOutput()
|
|
{
|
|
HeapHashtable* temp;
|
|
|
|
temp = m_htString;
|
|
*(HeapHashtable **)&m_htString = NULL;
|
|
delete temp;
|
|
|
|
temp = m_htTraits;
|
|
*(HeapHashtable **)&m_htTraits = NULL;
|
|
delete temp;
|
|
|
|
temp = m_htObject;
|
|
*(HeapHashtable **)&m_htObject = NULL;
|
|
delete temp;
|
|
}
|
|
|
|
void ObjectOutput::TableAdd(HeapHashtable *ht, Atom atom)
|
|
{
|
|
// this may realloc *ppHashtable
|
|
// just store the raw int value. we encapsulate access to these tables so it's
|
|
// okay that the keys are atoms and the values are raw ints.
|
|
ht->add(atom, core()->intToAtom(ht->getSize()));
|
|
}
|
|
|
|
int32_t ObjectOutput::TableFind(HeapHashtable *ht, Atom atom)
|
|
{
|
|
if(!ht->contains(atom))
|
|
return -1;
|
|
|
|
return core()->integer(ht->get(atom));
|
|
}
|
|
// end class ObjectOutput
|
|
//---------------------------------------------------------------------
|
|
|
|
//---------------------------------------------------------------------
|
|
// class ObjectInput is the base class for classes ClassicObjectInput
|
|
// and AvmPlusObjectInput
|
|
//
|
|
|
|
ObjectInput::ObjectInput(Toplevel *tl)
|
|
: m_listString(tl->core()->GetGC(), 64),
|
|
m_listObject(tl->core()->GetGC(), 64),
|
|
m_listClassInfo(tl->core()->GetGC(), 64)
|
|
{
|
|
}
|
|
|
|
|
|
void ObjectInput::SetObjectProperty(Atom objectAtom, Stringp name, Atom value)
|
|
{
|
|
TRY(core(), kCatchAction_Ignore)
|
|
{
|
|
Toplevel* toplevel = this->toplevel();
|
|
toplevel->setpropname(objectAtom, name, value);
|
|
}
|
|
CATCH(Exception *exception)
|
|
{
|
|
// http://flashqa.macromedia.com/bugapp/detail.asp?ID=144290
|
|
//
|
|
// Flex has requested read suppresses exceptions thrown while adding members
|
|
// to the object being created (for instance, if the class is sealed and
|
|
// does not contain member name).
|
|
|
|
// output the error to the console so it's not entirely lost.
|
|
core()->console << core()->string(exception->atom) << "\n";
|
|
}
|
|
END_CATCH
|
|
END_TRY
|
|
}
|
|
|
|
|
|
String *ObjectInput::StringListFind(uint32_t i)
|
|
{
|
|
if (i >= m_listString.length())
|
|
{
|
|
ThrowRangeError();
|
|
}
|
|
|
|
return m_listString.get(i);
|
|
}
|
|
|
|
GCRef<ScriptObject> ObjectInput::ObjectListFind(uint32_t i)
|
|
{
|
|
if (i >= m_listObject.length())
|
|
{
|
|
ThrowRangeError();
|
|
}
|
|
|
|
return GCREF_CASTFROMVOID(ScriptObject, m_listObject.get(i));
|
|
}
|
|
|
|
ClassInfo *ObjectInput::ClassInfoListFind(uint32_t i)
|
|
{
|
|
if (i >= m_listClassInfo.length())
|
|
{
|
|
ThrowRangeError();
|
|
}
|
|
|
|
return m_listClassInfo.get(i);
|
|
}
|
|
|
|
// end class ObjectInput
|
|
//---------------------------------------------------------------------
|
|
|
|
//---------------------------------------------------------------------
|
|
// BEGIN class AvmPlusObjectOutput
|
|
//
|
|
|
|
void AvmPlusObjectOutput::WriteUint29(uint32_t ref)
|
|
{
|
|
// Represent smaller integers with fewer bytes using the most
|
|
// significant bit of each byte. The worst case uses 32-bits
|
|
// to represent a 29-bit number, which is what we would have
|
|
// done with no compression.
|
|
|
|
// 0x00000000 - 0x0000007F : 0xxxxxxx
|
|
// 0x00000080 - 0x00003FFF : 1xxxxxxx 0xxxxxxx
|
|
// 0x00004000 - 0x001FFFFF : 1xxxxxxx 1xxxxxxx 0xxxxxxx
|
|
// 0x00200000 - 0x3FFFFFFF : 1xxxxxxx 1xxxxxxx 1xxxxxxx xxxxxxxx
|
|
// 0x40000000 - 0xFFFFFFFF : throw range exception
|
|
|
|
if (ref < 0x80) {
|
|
// 0x00000000 - 0x0000007F : 0xxxxxxx
|
|
WriteU8((uint8_t)ref);
|
|
} else if (ref < 0x4000) {
|
|
// 0x00000080 - 0x00003FFF : 1xxxxxxx 0xxxxxxx
|
|
WriteU8((uint8_t)(((ref >> 7) & 0x7F) | 0x80));
|
|
WriteU8((uint8_t)(ref & 0x7F));
|
|
} else if (ref < 0x200000) {
|
|
// 0x00004000 - 0x001FFFFF : 1xxxxxxx 1xxxxxxx 0xxxxxxx
|
|
WriteU8((uint8_t)(((ref >> 14) & 0x7F) | 0x80));
|
|
WriteU8((uint8_t)(((ref >> 7) & 0x7F) | 0x80));
|
|
WriteU8((uint8_t)(ref & 0x7F));
|
|
} else if (ref < 0x40000000) {
|
|
// 0x00200000 - 0x3FFFFFFF : 1xxxxxxx 1xxxxxxx 1xxxxxxx xxxxxxxx
|
|
WriteU8((uint8_t)(((ref >> 22) & 0x7F) | 0x80));
|
|
WriteU8((uint8_t)(((ref >> 15) & 0x7F) | 0x80));
|
|
WriteU8((uint8_t)(((ref >> 8) & 0x7F) | 0x80));
|
|
WriteU8((uint8_t)(ref & 0xFF));
|
|
} else {
|
|
// 0x40000000 - 0xFFFFFFFF : throw range exception
|
|
ThrowRangeError();
|
|
}
|
|
}
|
|
|
|
void AvmPlusObjectOutput::WriteString(String *str) {
|
|
|
|
if (str->length() == 0)
|
|
{
|
|
// don't create a reference for the empty string,
|
|
// as it's represented by the one byte value 1
|
|
// len = 0, ((len << 1) | 1).
|
|
WriteReference(1);
|
|
return;
|
|
}
|
|
|
|
// intern so (str1 == str2) is true if the strings are the same.
|
|
str = core()->internString(str);
|
|
|
|
int32_t ref = StringTableFind(str);
|
|
|
|
if (ref >= 0)
|
|
{
|
|
// this is a duplicate of a previous String, so write a reference.
|
|
WriteReference(ref << 1);
|
|
}
|
|
else
|
|
{
|
|
StringTableAdd(str);
|
|
|
|
StUTF8String utf8(str);
|
|
uint32_t len = utf8.length();
|
|
|
|
WriteReference((len << 1) | 1);
|
|
Write(utf8.c_str(), len);
|
|
}
|
|
}
|
|
|
|
|
|
void AvmPlusObjectOutput::WriteAtom(Atom value)
|
|
{
|
|
if (handleAdditionalAtom(value))
|
|
return; //Handled by a sub-class implementation. Nothing to be done here
|
|
|
|
GCRef<Toplevel> toplevel = this->toplevel();
|
|
GCRef<AvmCore> core = toplevel->core();
|
|
GCRef<builtinClassManifest> builtinClasses = toplevel->builtinClasses();
|
|
|
|
if (AvmCore::isUndefined(value))
|
|
{
|
|
WriteType(kUndefinedAtomType);
|
|
}
|
|
else if (AvmCore::isNull(value))
|
|
{
|
|
WriteType(kNullAtomType);
|
|
}
|
|
else if (AvmCore::isBoolean(value))
|
|
{
|
|
if (value == trueAtom)
|
|
{
|
|
WriteType(kTrueAtomType);
|
|
}
|
|
else
|
|
{
|
|
WriteType(kFalseAtomType);
|
|
}
|
|
|
|
}
|
|
else if (atomIsIntptr(value))
|
|
{
|
|
intptr_t const val = atomGetIntptr(value);
|
|
// Does our integer fit into 29 bits?
|
|
if (atomCanBeInt32(value) && ((int32_t(val)<<3)>>3) == val)
|
|
{
|
|
// 32-bit: AVM+ integers are int29, so use reference
|
|
// 64-bit: Our check above protects large integers
|
|
WriteType(kIntegerAtomType);
|
|
WriteUint29(val & 0x1fffffff);
|
|
}
|
|
else
|
|
{
|
|
WriteType(kDoubleAtomType);
|
|
WriteDouble((double)val);
|
|
}
|
|
}
|
|
else if (AvmCore::isDouble(value))
|
|
{
|
|
WriteType(kDoubleAtomType);
|
|
WriteDouble(AvmCore::number(value));
|
|
}
|
|
#ifdef VMCFG_FLOAT
|
|
else if(AvmCore::isFloat(value))
|
|
{
|
|
WriteType(kFloatAtomType);
|
|
WriteFloat(AvmCore::atomToFloat(value));
|
|
}
|
|
else if(AvmCore::isFloat4(value))
|
|
{
|
|
float4_t floatVal = AvmCore::atomToFloat4(value);
|
|
WriteType(kFloat4AtomType);
|
|
WriteFloat4(floatVal);
|
|
}
|
|
#endif// VMCFG_FLOAT
|
|
else if (AvmCore::isString(value))
|
|
{
|
|
WriteType(kStringAtomType);
|
|
WriteString(core->string(value));
|
|
}
|
|
else if (core->isFunction(value))
|
|
{
|
|
// don't serialize functions
|
|
WriteType(kUndefinedAtomType);
|
|
}
|
|
else if (!AvmCore::isObject(value))
|
|
{
|
|
// We've enumerated everything we know but object,
|
|
// so if it isn't an object, it's something we cannot serialize.
|
|
ThrowArgumentError();
|
|
}
|
|
else
|
|
{
|
|
GCRef<ScriptObject> obj = AvmCore::atomToScriptObject(value);
|
|
|
|
// cn: Note we ignore XMLList type here, which is actually different from the XML type.
|
|
// AMF is a published format, however, so we can't add a new datatype to correctly
|
|
// handle XMLList. We'll write a generic Object type in that case (see default below),
|
|
// workaround is to wrap your XMLList value in an XML wrapper.
|
|
|
|
if (AvmCore::istype(value, core->traits.xml_itraits))
|
|
{
|
|
WriteType(kAvmPlusXmlAtomType);
|
|
WriteXML(obj,true);
|
|
}
|
|
else if (AvmCore::istype(value, core->traits.date_itraits))
|
|
{
|
|
WriteType(kDateAtomType);
|
|
WriteDate(obj.staticCast<DateObject>());
|
|
}
|
|
else if (AvmCore::istype(value, core->traits.array_itraits))
|
|
{
|
|
WriteType(kArrayAtomType);
|
|
WriteArray(obj.staticCast<ArrayObject>());
|
|
}
|
|
else if (builtinClasses->get_ByteArrayClass()->isType(value))
|
|
{
|
|
WriteType(kByteArrayAtomType);
|
|
WriteByteArray(obj.staticCast<ByteArrayObject>());
|
|
}
|
|
else if (builtinClasses->get_DictionaryClass()->isType(value))
|
|
{
|
|
WriteDictionary(obj.staticCast<DictionaryObject>());
|
|
}
|
|
else if (AvmCore::istype(value, VECTORINT_TYPE) ||
|
|
AvmCore::istype(value, VECTORUINT_TYPE) ||
|
|
AvmCore::istype(value, VECTORDOUBLE_TYPE) ||
|
|
#ifdef VMCFG_FLOAT
|
|
AvmCore::istype(value, VECTORFLOAT_TYPE) ||
|
|
AvmCore::istype(value, VECTORFLOAT4_TYPE) ||
|
|
#endif
|
|
AvmCore::istype(value, VECTOROBJ_TYPE))
|
|
{
|
|
// We assume vectors can only be created from within SWF10 files.
|
|
WriteTypedVector(value);
|
|
}
|
|
else
|
|
{
|
|
WriteType(kObjectAtomType);
|
|
WriteScriptObject(obj);
|
|
}
|
|
}
|
|
}
|
|
|
|
void AvmPlusObjectOutput::WriteXML(GCRef<ScriptObject> obj, bool isAS3XML)
|
|
{
|
|
int32_t ref = ObjectTableFind(obj);
|
|
|
|
if (ref >= 0)
|
|
{
|
|
// output already contains object. Save a reference to previous instance.
|
|
WriteReference(ref << 1);
|
|
return;
|
|
}
|
|
|
|
ObjectTableAdd(obj);
|
|
|
|
String* str = NULL;
|
|
// cn: XML's toString() will skip the tags if the content is simple (i.e. <f>hi</f>.toString() == "hi")
|
|
// use toXMLString instead.
|
|
if (isAS3XML)
|
|
{
|
|
XMLObject* x = obj.staticCast<XMLObject>();
|
|
str = x->toXMLString();
|
|
}
|
|
else
|
|
{
|
|
str = obj->toString();
|
|
}
|
|
|
|
StUTF8String utf8(str);
|
|
uint32_t len = utf8.length();
|
|
|
|
// Store length in the surplus bits of the invalid reference
|
|
WriteReference((len << 1) | 1);
|
|
Write(utf8.c_str(), len);
|
|
}
|
|
|
|
void AvmPlusObjectOutput::WriteDate(DateObject *obj)
|
|
{
|
|
int32_t ref = ObjectTableFind(obj);
|
|
|
|
if (ref >= 0)
|
|
{
|
|
// output already contains object. Save a reference to previous instance.
|
|
WriteReference(ref << 1);
|
|
return;
|
|
}
|
|
|
|
ObjectTableAdd(obj);
|
|
|
|
// write an invalid reference, followed by the date.
|
|
// As the date is only a double, it's hard to re-use the surplus bits of the reference.
|
|
WriteReference(1);
|
|
WriteDouble(obj->date.getTime());
|
|
}
|
|
|
|
void AvmPlusObjectOutput::WriteByteArray(GCRef<ByteArrayObject> obj)
|
|
{
|
|
int32_t ref = ObjectTableFind(obj);
|
|
|
|
if (ref >= 0)
|
|
{
|
|
// output already contains object. Save a reference to previous instance.
|
|
WriteReference(ref << 1);
|
|
return;
|
|
}
|
|
|
|
ObjectTableAdd(obj);
|
|
|
|
//
|
|
// obj might be the ByteArray we are writing to, such as
|
|
// o.ba = ba;
|
|
// ba.writeObject(o);
|
|
// so play it safe and duplicate the ByteArray before copying.
|
|
//
|
|
// ByteArray ba(obj->GetByteArray());
|
|
|
|
// actually, it's been legal for a ByteArray to write to itself for quite
|
|
// a while, so duplicating this data is unnecessary
|
|
ByteArray& ba = obj->GetByteArray();
|
|
|
|
int len = ba.GetLength();
|
|
const uint8_t* buf = ba.GetReadableBuffer();
|
|
|
|
// write an invalid reference, but re-use the surplus bits to store the length
|
|
WriteReference((len << 1) | 1);
|
|
Write(buf, len);
|
|
}
|
|
|
|
void AvmPlusObjectOutput::WriteArray(GCRef<ArrayObject> obj)
|
|
{
|
|
int32_t ref = ObjectTableFind(obj);
|
|
|
|
if (ref >= 0)
|
|
{
|
|
// output already contains object. Save a reference to previous instance.
|
|
WriteReference(ref << 1);
|
|
return;
|
|
}
|
|
|
|
ObjectTableAdd(obj);
|
|
|
|
// Arrays could be written just like Objects, as an undefined terminated
|
|
// list of {name, value} pairs, but we'd like to avoid writing the name's
|
|
// if they are all integers. So, we calculate the smallest range that has no
|
|
// holes, and emit that as a list, with any extra properties getting emitted as a map.
|
|
// (Array used to have a "getDenseLength" call that would we'd use, but that relied
|
|
// on the underlying representation, which has changed in the name of efficiency;
|
|
// therefore we calculate it manually here. Note that this could cause some arrays
|
|
// to be written in slightly different form (ie with more name/value pairs), but that's
|
|
// OK, just suboptimal.)
|
|
uint32_t denseLen = obj->getLength();
|
|
for (uint32_t i = 0, n = denseLen; i < n; ++i)
|
|
{
|
|
if (!obj->hasUintProperty(i))
|
|
{
|
|
denseLen = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
uint32_t len;
|
|
int index;
|
|
uint32_t i;
|
|
|
|
// This is a bit of a pest, but we don't write out functions,
|
|
// and we don't want any holes in the dense portion. AVM-
|
|
// wrote an undefined in this case, but we don't want read to
|
|
// create an undefined element, and so we scan this dense portion
|
|
// searching for functions, and contract the length to exclude them.
|
|
|
|
for (i = 0, index = 0, len = denseLen; (i < len); i++)
|
|
{
|
|
index = obj->nextNameIndex(index);
|
|
Atom value = obj->nextValue(index);
|
|
|
|
if (AvmCore::istype(value, core()->traits.function_itraits))
|
|
{
|
|
len = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Write an invalid reference. Repurpose the unused bits to store the number of dense elements.
|
|
WriteReference((len << 1) | 1);
|
|
|
|
// When the entire Array is dense, the server will create a List.
|
|
// When the Array has holes, or contains elements indexed with non-numeric values,
|
|
// the server will create a Map.
|
|
//
|
|
// Therefore, it's easier for the server if we write out the non-dense portion first.
|
|
while ((index = obj->nextNameIndex(index)) != 0)
|
|
{
|
|
Atom name = obj->nextName(index);
|
|
Atom value = obj->nextValue(index);
|
|
|
|
if (AvmCore::istype(value, core()->traits.function_itraits))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
WriteString(core()->string(name));
|
|
WriteAtom(value);
|
|
}
|
|
|
|
// Terminate the non-dense portion with an empty string (which is invalid as a property name)
|
|
WriteString(core()->kEmptyString);
|
|
|
|
// Write out the dense portion of the array
|
|
for (i = 0, index = 0; i < len; i++)
|
|
{
|
|
index = obj->nextNameIndex(index);
|
|
WriteAtom(obj->nextValue(index));
|
|
}
|
|
}
|
|
|
|
void AvmPlusObjectOutput::WriteDictionary(GCRef<DictionaryObject> obj)
|
|
{
|
|
int32_t ref = ObjectTableFind(obj);
|
|
|
|
WriteType(kDictionaryObject);
|
|
|
|
if (ref >= 0)
|
|
{
|
|
// output already contains object. Save a reference to previous instance.
|
|
WriteReference(ref << 1);
|
|
return;
|
|
}
|
|
|
|
ObjectTableAdd(obj);
|
|
|
|
InlineHashtable *h = obj->getTable();
|
|
|
|
WriteReference((h->getSize()<<1)|1);
|
|
|
|
WriteBoolean(obj->isUsingWeakKeys());
|
|
|
|
for (uint32_t c = h->next(0); c ; c = h->next(c))
|
|
{
|
|
Atom key = h->keyAt(c);
|
|
// The dictionary class converts keys to integers if possible
|
|
// so convert it back to a string if neccessary.
|
|
if (atomIsIntptr(key))
|
|
{
|
|
key = MathUtils::convertIntegerToStringRadix(core(), atomGetIntptr(key), 10, MathUtils::kTreatAsSigned)->atom();
|
|
}
|
|
WriteAtom(key);
|
|
WriteAtom(h->valueAt(c));
|
|
}
|
|
}
|
|
|
|
void AvmPlusObjectOutput::WriteTypedVector(Atom atom)
|
|
{
|
|
Toplevel* toplevel = this->toplevel();
|
|
AvmCore* core = toplevel->core();
|
|
|
|
GCRef<ScriptObject> obj = core->atomToScriptObject(atom);
|
|
int32_t ref = ObjectTableFind(obj);
|
|
|
|
uint8_t vec_type = 0;
|
|
// Write out the type - have to do this before we write out the reference
|
|
if (AvmCore::istype(atom, VECTORINT_TYPE))
|
|
{
|
|
vec_type = kTypedVectorInt;
|
|
}
|
|
else if (AvmCore::istype(atom, VECTORUINT_TYPE))
|
|
{
|
|
vec_type = kTypedVectorUint;
|
|
}
|
|
else if (AvmCore::istype(atom, VECTORDOUBLE_TYPE))
|
|
{
|
|
vec_type = kTypedVectorDouble;
|
|
}
|
|
#ifdef VMCFG_FLOAT
|
|
else if(AvmCore::istype(atom, VECTORFLOAT_TYPE))
|
|
{
|
|
vec_type = kTypedVectorFloat;
|
|
}
|
|
else if(AvmCore::istype(atom, VECTORFLOAT4_TYPE))
|
|
{
|
|
vec_type = kTypedVectorFloat4;
|
|
}
|
|
#endif// VMCFG_FLOAT
|
|
else
|
|
{
|
|
vec_type = kTypedVectorObject;
|
|
}
|
|
|
|
WriteType(vec_type);
|
|
|
|
if (ref >= 0)
|
|
{
|
|
// output already contains object. Save a reference to previous instance.
|
|
WriteReference(ref << 1);
|
|
return;
|
|
}
|
|
|
|
ObjectTableAdd(obj);
|
|
|
|
if (vec_type == kTypedVectorInt)
|
|
{
|
|
IntVectorObject *v = obj.staticCast<IntVectorObject>();
|
|
WriteReference((v->get_length()<<1)|1);
|
|
WriteBoolean(v->get_fixed());
|
|
|
|
IntVectorAccessor va(v);
|
|
const int32_t* data = va.addr();
|
|
uint32_t len = va.length();
|
|
for (uint32_t c=0; c<len; c++)
|
|
{
|
|
WriteU32(uint32_t(data[c]));
|
|
}
|
|
|
|
}
|
|
else if (vec_type == kTypedVectorUint)
|
|
{
|
|
UIntVectorObject *v = obj.staticCast<UIntVectorObject>();
|
|
WriteReference((v->get_length()<<1)|1);
|
|
WriteBoolean(v->get_fixed());
|
|
|
|
UIntVectorAccessor va(v);
|
|
const uint32_t* data = va.addr();
|
|
uint32_t len = va.length();
|
|
for (uint32_t c=0; c<len; c++)
|
|
{
|
|
WriteU32(data[c]);
|
|
}
|
|
|
|
}
|
|
else if (vec_type == kTypedVectorDouble)
|
|
{
|
|
DoubleVectorObject *v = obj.staticCast<DoubleVectorObject>();
|
|
WriteReference((v->get_length()<<1)|1);
|
|
WriteBoolean(v->get_fixed());
|
|
|
|
DoubleVectorAccessor va(v);
|
|
const double* data = va.addr();
|
|
uint32_t len = va.length();
|
|
for (uint32_t c=0; c<len; c++)
|
|
{
|
|
WriteDouble(data[c]);
|
|
}
|
|
}
|
|
#ifdef VMCFG_FLOAT
|
|
else if (vec_type == kTypedVectorFloat)
|
|
{
|
|
FloatVectorObject *v = obj.staticCast<FloatVectorObject>();
|
|
WriteReference((v->get_length()<<1)|1);
|
|
WriteBoolean(v->get_fixed());
|
|
|
|
FloatVectorAccessor va(v);
|
|
const float* data = va.addr();
|
|
uint32_t len = va.length();
|
|
for (uint32_t c=0; c<len; c++)
|
|
{
|
|
WriteFloat(data[c]);
|
|
}
|
|
}
|
|
else if (vec_type == kTypedVectorFloat4)
|
|
{
|
|
Float4VectorObject *v = obj.staticCast<Float4VectorObject>();
|
|
WriteReference((v->get_length()<<1)|1);
|
|
WriteBoolean(v->get_fixed());
|
|
|
|
Float4VectorAccessor va(v);
|
|
const float4_t* data = va.addr();
|
|
uint32_t len = va.length();
|
|
for (uint32_t c=0; c<len; c++)
|
|
{
|
|
WriteFloat4(data[c]);
|
|
}
|
|
}
|
|
#endif // VMCFG_FLOAT
|
|
else
|
|
{
|
|
ObjectVectorObject *v = obj.staticCast<ObjectVectorObject>();
|
|
WriteReference((v->get_length()<<1)|1);
|
|
WriteBoolean(v->get_fixed());
|
|
|
|
// Write prototype
|
|
Traits* traits = v->getTypeTraits();
|
|
Stringp classname;
|
|
if (traits)
|
|
{
|
|
classname = toplevel->getAliasFromTraits(traits);
|
|
}
|
|
else
|
|
{
|
|
classname = core->kAsterisk;
|
|
}
|
|
WriteString(classname);
|
|
|
|
// Write contents
|
|
uint32_t len = v->get_length();
|
|
for (uint32_t c=0; c<len; c++)
|
|
{
|
|
WriteAtom(v->getUintProperty(c));
|
|
}
|
|
}
|
|
}
|
|
|
|
void AvmPlusObjectOutput::WriteScriptObject(GCRef<ScriptObject> obj)
|
|
{
|
|
int32_t ref = ObjectTableFind(obj);
|
|
|
|
if (ref >= 0)
|
|
{
|
|
// output already contains object. Save a reference to previous instance.
|
|
WriteReference(ref << 1);
|
|
return;
|
|
}
|
|
|
|
ObjectTableAdd(obj);
|
|
|
|
Toplevel* toplevel = this->toplevel();
|
|
AvmCore* core = toplevel->core();
|
|
|
|
//
|
|
// Start an object with its class information
|
|
//
|
|
Traits *traits = obj->traits();
|
|
ClassInfo *info;
|
|
int i, count;
|
|
bool dynamic;
|
|
bool externalizable;
|
|
|
|
ref = TraitsTableFind(traits);
|
|
if (ref >= 0)
|
|
{
|
|
// output already contains class info. Save a reference to previous instance.
|
|
WriteReference((ref << 2) | 1);
|
|
info = ClassInfoListFind(ref);
|
|
count = info->SealedPropCount();
|
|
dynamic = info->dynamic();
|
|
externalizable = info->externalizable();
|
|
}
|
|
else
|
|
{
|
|
// Create class info
|
|
info = new (core->GetGC()) ClassInfo(toplevel, traits);
|
|
|
|
// Add class info to relate tables
|
|
ClassInfoListAdd(info);
|
|
TraitsTableAdd(traits);
|
|
AvmAssert(ClassInfoListFind(TraitsTableFind(traits)) == info);
|
|
|
|
// write out class info, using the surplas bits of the reference to
|
|
// store dynamic and the number of sealed properties
|
|
count = info->SealedPropCount();
|
|
dynamic = info->dynamic();
|
|
externalizable = info->externalizable();
|
|
|
|
WriteReference(3 | (externalizable ? 4 : 0) | (dynamic ? 8 : 0) | (count << 4));
|
|
info->Write(this);
|
|
}
|
|
|
|
if (externalizable)
|
|
{
|
|
// ClassInfo's constructor has already verified this, so we don't need to repeat the error handling here
|
|
AvmAssert(obj->traits()->containsInterface(BUILTIN_TRAITS_(flash_utils_IExternalizable)));
|
|
|
|
// !!@ Is it a worthwhile performance optimization to :
|
|
// 1. create only one ObjectOutputObject for the stream?
|
|
|
|
// invoke writeExternal()
|
|
const int argc = 1;
|
|
Atom argv[argc + 1];
|
|
argv[0] = obj->atom();
|
|
|
|
GCRef<ObjectOutputObject> output = toplevel->builtinClasses()->get_ObjectOutputClass()->constructObject();
|
|
output->m_out = this;
|
|
argv[1] = output->atom();
|
|
|
|
MethodEnv* method = obj->vtable->methods[AvmCore::bindingToMethodId(info->get_functionBinding())];
|
|
method->coerceEnter(argc, argv);
|
|
|
|
}
|
|
else
|
|
{
|
|
// for each sealed property in the class info, write out its value
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
WriteAtom(toplevel->getpropname(obj->atom(), info->SealedProp(i)));
|
|
}
|
|
|
|
if (dynamic)
|
|
{
|
|
GCRef<ScriptObject> writer = toplevel->builtinClasses()->get_ObjectEncodingClass()->m_writer;
|
|
|
|
if (!writer)
|
|
{
|
|
for (int index = 0; ((index = obj->nextNameIndex(index)) != 0);)
|
|
{
|
|
Atom name = obj->nextName(index);
|
|
Atom value = obj->nextValue(index);
|
|
|
|
if (AvmCore::istype(value, core->traits.function_itraits))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Empty string is sentinel for end-of-data, so we CANNOT serialize it.
|
|
String *nameStr = core->string(name);
|
|
if (nameStr->length() == 0)
|
|
{
|
|
continue;
|
|
}
|
|
WriteString(nameStr);
|
|
WriteAtom(value);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// invoke ObjectEncoding.dynamicPropertyWriter
|
|
GCRef<ScriptObject> func = AvmCore::atomToScriptObject(toplevel->getpropname(writer->atom(), core->internConstantStringLatin1("writeDynamicProperties")));
|
|
GCRef<DynamicPropertyOutputObject> output = toplevel->builtinClasses()->get_DynamicPropertyOutputClass()->constructObject();
|
|
output->m_out = this;
|
|
|
|
const int argc = 2;
|
|
Atom argv[argc + 1];
|
|
argv[0] = writer->atom();
|
|
argv[1] = obj->atom();
|
|
argv[2] = output->atom();
|
|
|
|
func->call(argc, argv);
|
|
}
|
|
|
|
// Write out the empty string as a terminator
|
|
WriteString(core->kEmptyString);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// END class AvmPlusObjectOutput
|
|
//---------------------------------------------------------------------
|
|
|
|
//---------------------------------------------------------------------
|
|
// BEGIN class AvmPlusObjectInput
|
|
//
|
|
uint32_t AvmPlusObjectInput::ReadUint29()
|
|
{
|
|
// Represent smaller integers with fewer bytes using the most
|
|
// significant bit of each byte. The worst case uses 32-bits
|
|
// to represent a 29-bit number, which is what we would have
|
|
// done with no compression.
|
|
|
|
// 0x00000000 - 0x0000007F : 0xxxxxxx
|
|
// 0x00000080 - 0x00003FFF : 1xxxxxxx 0xxxxxxx
|
|
// 0x00004000 - 0x001FFFFF : 1xxxxxxx 1xxxxxxx 0xxxxxxx
|
|
// 0x00200000 - 0x3FFFFFFF : 1xxxxxxx 1xxxxxxx 1xxxxxxx xxxxxxxx
|
|
// 0x40000000 - 0xFFFFFFFF : throw range exception
|
|
|
|
uint8_t byte;
|
|
uint32_t ref;
|
|
|
|
byte = ReadU8();
|
|
|
|
if (byte < 128)
|
|
{
|
|
return byte;
|
|
}
|
|
|
|
ref = (byte & 0x7F) << 7;
|
|
byte = ReadU8();
|
|
|
|
if (byte < 128)
|
|
{
|
|
return (ref | byte);
|
|
}
|
|
|
|
ref = (ref | (byte & 0x7F)) << 7;
|
|
byte = ReadU8();
|
|
|
|
if (byte < 128)
|
|
{
|
|
return (ref | byte);
|
|
}
|
|
|
|
ref = (ref | (byte & 0x7F)) << 8;
|
|
byte = ReadU8();
|
|
|
|
return (ref | byte);
|
|
}
|
|
|
|
Atom AvmPlusObjectInput::ReadAtom()
|
|
{
|
|
Toplevel* toplevel = this->toplevel();
|
|
AvmCore* core = toplevel->core();
|
|
|
|
uint8_t type = ReadType();
|
|
|
|
Atom retVal;
|
|
if (handleAdditionalType(type, retVal))
|
|
return retVal; // Handled by subclass. Nothing to be done here
|
|
|
|
switch (type)
|
|
{
|
|
case kUndefinedAtomType:
|
|
return undefinedAtom;
|
|
case kNullAtomType:
|
|
return nullObjectAtom;
|
|
case kFalseAtomType:
|
|
return falseAtom;
|
|
case kTrueAtomType:
|
|
return trueAtom;
|
|
case kIntegerAtomType:
|
|
// symmetric with writing an integer to fix sign bits for negative values
|
|
return core->intToAtom(((int)ReadUint29() << 3) >> 3);
|
|
case kDoubleAtomType:
|
|
return core->doubleToAtom(ReadDouble());
|
|
#ifdef VMCFG_FLOAT
|
|
case kFloatAtomType:
|
|
return core->floatToAtom(ReadFloat());
|
|
case kFloat4AtomType:
|
|
return core->float4ToAtom(ReadFloat4());
|
|
#endif //VMCFG_FLOAT
|
|
case kStringAtomType:
|
|
return ReadString()->atom();
|
|
case kAvmMinusXmlAtomType: //Even XML minus atoms are read back as XML objects. However handleAdditionalType can override this behavior.
|
|
case kAvmPlusXmlAtomType:
|
|
return ReadXML()->atom();
|
|
case kDateAtomType:
|
|
return ReadDate()->atom();
|
|
case kArrayAtomType:
|
|
return ReadArray()->atom();
|
|
case kByteArrayAtomType:
|
|
return ReadByteArray()->atom();
|
|
case kObjectAtomType:
|
|
return ReadScriptObject()->atom();
|
|
case kDictionaryObject:
|
|
return ReadDictionary()->atom();
|
|
case kTypedVectorInt:
|
|
case kTypedVectorUint:
|
|
case kTypedVectorDouble:
|
|
case kTypedVectorFloat:
|
|
case kTypedVectorFloat4:
|
|
case kTypedVectorObject:
|
|
return ReadTypedVector(type);
|
|
default:
|
|
this->ThrowRangeError();
|
|
return undefinedAtom;
|
|
}
|
|
}
|
|
|
|
DateObject* AvmPlusObjectInput::ReadDate()
|
|
{
|
|
uint32_t ref = ReadReference();
|
|
|
|
if ((ref & 1) == 0)
|
|
{
|
|
// This is a reference
|
|
return ObjectListFind(ref >> 1).staticCast<DateObject>();
|
|
}
|
|
|
|
Toplevel* toplevel = this->toplevel();
|
|
DateClass* dateClass = toplevel->dateClass();
|
|
DateObject* obj = DateObject::create(dateClass->ivtable()->gc(), dateClass, Date(ReadDouble()));
|
|
ObjectListAdd(obj);
|
|
|
|
return obj;
|
|
}
|
|
|
|
GCRef<ByteArrayObject> AvmPlusObjectInput::ReadByteArray()
|
|
{
|
|
Toplevel* toplevel = this->toplevel();
|
|
uint32_t ref = ReadReference();
|
|
|
|
if ((ref & 1) == 0)
|
|
{
|
|
// This is a reference
|
|
return ObjectListFind(ref >> 1).staticCast<ByteArrayObject>();
|
|
}
|
|
|
|
GCRef<ByteArrayObject> obj = toplevel->byteArrayClass()->constructObject();
|
|
ObjectListAdd(obj);
|
|
|
|
int len = ref >> 1;
|
|
|
|
ByteArray& ba = obj->GetByteArray();
|
|
ba.SetLength(len);
|
|
Read(ba.GetWritableBuffer(), len);
|
|
|
|
return obj;
|
|
}
|
|
|
|
String *AvmPlusObjectInput::ReadString()
|
|
{
|
|
uint32_t ref = ReadReference();
|
|
|
|
if ((ref & 1) == 0)
|
|
{
|
|
// This is a reference
|
|
return StringListFind(ref >> 1);
|
|
}
|
|
|
|
// Read the string in
|
|
uint32_t len = (ref >> 1);
|
|
|
|
if (len == 0)
|
|
{
|
|
// WriteString() special cases the empty string to avoid creating a reference.
|
|
return core()->kEmptyString;
|
|
}
|
|
|
|
char *buffer = mmfx_new_array_opt(char, len+1, MMgc::kCanFail);
|
|
if (!buffer)
|
|
{
|
|
ThrowMemoryError();
|
|
}
|
|
|
|
Read(buffer, len);
|
|
buffer[len] = 0;
|
|
|
|
String *str = core()->newStringUTF8(buffer, len);
|
|
mmfx_delete_array(buffer);
|
|
|
|
StringListAdd(str);
|
|
return str;
|
|
}
|
|
|
|
String* AvmPlusObjectInput::ReadXmlString(uint32_t len)
|
|
{
|
|
Toplevel* toplevel = this->toplevel();
|
|
AvmCore* core = toplevel->core();
|
|
char *buffer = mmfx_new_array_opt(char, len+1, MMgc::kCanFail);
|
|
if (!buffer)
|
|
{
|
|
ThrowMemoryError();
|
|
}
|
|
|
|
Read(buffer, len);
|
|
buffer[len] = 0;
|
|
|
|
String *str = core->newStringUTF8(buffer, len);
|
|
mmfx_delete_array(buffer);
|
|
return str;
|
|
}
|
|
|
|
GCRef<ScriptObject> AvmPlusObjectInput::ReadXML()
|
|
{
|
|
uint32_t ref = ReadReference();
|
|
|
|
if ((ref & 1) == 0)
|
|
{
|
|
// This is a reference
|
|
return ObjectListFind(ref >> 1);
|
|
}
|
|
|
|
Toplevel* toplevel = this->toplevel();
|
|
|
|
// Read the toString() version of the XML object in
|
|
uint32_t len = (ref >> 1);
|
|
|
|
String* str = ReadXmlString(len);
|
|
|
|
// construct an XML object from the string
|
|
GCRef<ScriptObject> obj;
|
|
obj = toplevel->xmlClass()->constructObject(str->atom());
|
|
|
|
ObjectListAdd(obj);
|
|
|
|
return obj;
|
|
}
|
|
|
|
GCRef<DictionaryObject> AvmPlusObjectInput::ReadDictionary()
|
|
{
|
|
uint32_t ref = ReadReference();
|
|
|
|
if ((ref & 1) == 0)
|
|
{
|
|
// This is a reference
|
|
return ObjectListFind(ref >> 1).staticCast<DictionaryObject>();
|
|
}
|
|
|
|
Toplevel* toplevel = this->toplevel();
|
|
AvmCore* core = toplevel->core();
|
|
|
|
uint32_t len = ref >> 1;
|
|
bool weakKeys = ReadBoolean();
|
|
GCRef<DictionaryObject> obj = toplevel->builtinClasses()->get_DictionaryClass()->constructObject(weakKeys);
|
|
ObjectListAdd(obj);
|
|
|
|
for (uint32_t c = 0; c<len ; c++)
|
|
{
|
|
// Key can be either an object or an interned string
|
|
Atom key = ReadAtom();
|
|
// Value can be anything
|
|
Atom value = ReadAtom();
|
|
if (AvmCore::isString(key))
|
|
{
|
|
// Intern the string if not done already
|
|
key = core->internString(key)->atom();
|
|
}
|
|
else if (!AvmCore::isObject(key))
|
|
{
|
|
// Keys can not be anything else
|
|
ThrowArgumentError();
|
|
}
|
|
obj->setAtomProperty(key, value);
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
Atom AvmPlusObjectInput::ReadTypedVector(uint8_t type)
|
|
{
|
|
uint32_t ref = ReadReference();
|
|
|
|
if ((ref & 1) == 0)
|
|
{
|
|
// This is a reference
|
|
return ObjectListFind(ref >> 1)->atom();
|
|
}
|
|
|
|
Toplevel* toplevel = this->toplevel();
|
|
AvmCore* core = toplevel->core();
|
|
|
|
uint32_t len = ref >> 1;
|
|
bool fixed = ReadBoolean();
|
|
|
|
switch (type)
|
|
{
|
|
case kTypedVectorInt:
|
|
{
|
|
GCRef<IntVectorObject> v = toplevel->intVectorClass()->newVector(len);
|
|
ObjectListAdd(v);
|
|
v->set_fixed(fixed);
|
|
IntVectorAccessor va(v);
|
|
int32_t* data = va.addr();
|
|
for (uint32_t c=0; c<len; c++)
|
|
{
|
|
data[c] = int32_t(ReadU32());
|
|
}
|
|
return v->atom();
|
|
}
|
|
case kTypedVectorUint:
|
|
{
|
|
GCRef<UIntVectorObject> v = toplevel->uintVectorClass()->newVector(len);
|
|
ObjectListAdd(v);
|
|
v->set_fixed(fixed);
|
|
UIntVectorAccessor va(v);
|
|
uint32_t* data = va.addr();
|
|
for (uint32_t c=0; c<len; c++)
|
|
{
|
|
data[c] = ReadU32();
|
|
}
|
|
return v->atom();
|
|
}
|
|
case kTypedVectorDouble:
|
|
{
|
|
GCRef<DoubleVectorObject> v = toplevel->doubleVectorClass()->newVector(len);
|
|
ObjectListAdd(v);
|
|
v->set_fixed(fixed);
|
|
DoubleVectorAccessor va(v);
|
|
double* data = va.addr();
|
|
for (uint32_t c=0; c<len; c++)
|
|
{
|
|
data[c] = ReadDouble();
|
|
}
|
|
return v->atom();
|
|
}
|
|
#ifdef VMCFG_FLOAT
|
|
case kTypedVectorFloat:
|
|
{
|
|
GCRef<FloatVectorObject> v = toplevel->floatVectorClass()->newVector(len);
|
|
ObjectListAdd(v);
|
|
v->set_fixed(fixed);
|
|
FloatVectorAccessor va(v);
|
|
float* data = va.addr();
|
|
for (uint32_t c=0; c<len; c++)
|
|
{
|
|
data[c] = ReadFloat();
|
|
}
|
|
return v->atom();
|
|
}
|
|
case kTypedVectorFloat4:
|
|
{
|
|
GCRef<Float4VectorObject> v = toplevel->float4VectorClass()->newVector(len);
|
|
ObjectListAdd(v);
|
|
v->set_fixed(fixed);
|
|
Float4VectorAccessor va(v);
|
|
float4_t* data = va.addr();
|
|
for (uint32_t c=0; c<len; c++)
|
|
{
|
|
data[c] = ReadFloat4();
|
|
}
|
|
return v->atom();
|
|
}
|
|
#endif // VMCFG_FLOAT
|
|
case kTypedVectorObject:
|
|
{
|
|
// Read prototype
|
|
Stringp classname = core->internString(ReadString());
|
|
ClassClosure* closure = NULL;
|
|
if (classname != core->kAsterisk)
|
|
closure = toplevel->getClassClosureFromAlias(classname);
|
|
GCRef<ObjectVectorObject> v = toplevel->vectorClass()->newVector(closure, len);
|
|
ObjectListAdd(v);
|
|
v->set_fixed(fixed);
|
|
|
|
// Read contents
|
|
for (uint32_t c=0; c<len; c++)
|
|
{
|
|
v->setUintProperty(c,ReadAtom());
|
|
}
|
|
return v->atom();
|
|
}
|
|
}
|
|
|
|
ThrowArgumentError();
|
|
|
|
return 0;
|
|
}
|
|
|
|
GCRef<ScriptObject> AvmPlusObjectInput::ReadScriptObject(ClassClosure** closure)
|
|
{
|
|
uint32_t ref = ReadReference();
|
|
|
|
if ((ref & 1) == 0)
|
|
{
|
|
// This object has already been in input, so (ref >> 1) is an index
|
|
return ObjectListFind(ref >> 1);
|
|
}
|
|
|
|
// The object has not previously been in input, so we must read it in.
|
|
// It begins with its class info
|
|
|
|
Toplevel* toplevel = this->toplevel();
|
|
AvmCore* core = toplevel->core();
|
|
|
|
ClassInfo *info;
|
|
|
|
if ((ref & 3) == 1)
|
|
{
|
|
// This ClassInfo has already been in input, so (ref >> 2) is an index
|
|
info = ClassInfoListFind(ref >> 2);
|
|
}
|
|
else
|
|
{
|
|
// The ClassInfo has not previously been in input, so we must read it in.
|
|
// dynamic, and the number of multinames to follow have been encoded
|
|
// in the surplus bits of ref.
|
|
bool externalizable = (ref & 4) ? true : false;
|
|
bool dynamic = (ref & 8) ? true : false;
|
|
int count = (ref >> 4);
|
|
|
|
info = ClassInfo::Read(toplevel, this, dynamic, externalizable, count);
|
|
ClassInfoListAdd(info);
|
|
}
|
|
|
|
// Create an object and add it to the list of objects already read in
|
|
GCRef<ScriptObject> obj = info->closure()->constructObject();
|
|
ObjectListAdd(obj);
|
|
|
|
if (closure)
|
|
{
|
|
*closure = info->closure();
|
|
}
|
|
|
|
if (info->externalizable())
|
|
{
|
|
// ClassInfo::Read() has already verified that the class closure registered for this
|
|
// class's alias implements IExternalizable, so there's no need to repeat the error handling here.
|
|
AvmAssert(obj->traits()->containsInterface(BUILTIN_TRAITS_(flash_utils_IExternalizable)));
|
|
|
|
// invoke readExternal()
|
|
|
|
const int argc = 1;
|
|
Atom argv[argc + 1];
|
|
argv[0] = obj->atom();
|
|
|
|
GCRef<ObjectInputObject> input = toplevel->builtinClasses()->get_ObjectInputClass()->constructObject();
|
|
input->m_in = this;
|
|
argv[1] = input->atom();
|
|
|
|
MethodEnv* method = obj->vtable->methods[AvmCore::bindingToMethodId(info->get_functionBinding())];
|
|
method->coerceEnter(argc, argv);
|
|
}
|
|
else
|
|
{
|
|
// read in the value of each sealed property, and then assign it to the object's member
|
|
for (int i = 0, len = info->SealedPropCount(); i < len; i++)
|
|
{
|
|
SetObjectProperty(obj->atom(), info->SealedProp(i), ReadAtom());
|
|
}
|
|
|
|
// if the class is dynamic, read in the remaining properties (if any)
|
|
if (info->dynamic())
|
|
{
|
|
for (;;)
|
|
{
|
|
String* name = ReadString();
|
|
if (name->length() == 0)
|
|
break;
|
|
|
|
Atom value = ReadAtom();
|
|
SetObjectProperty(obj->atom(), core->internString(name), value);
|
|
}
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
GCRef<ArrayObject> AvmPlusObjectInput::ReadArray()
|
|
{
|
|
AvmCore *core = this->core(); // this->core() is necessary when there is a local variable called core.
|
|
|
|
uint32_t ref = ReadReference();
|
|
|
|
if ((ref & 1) == 0)
|
|
{
|
|
// This is a reference
|
|
return ObjectListFind(ref >> 1).staticCast<ArrayObject>();
|
|
}
|
|
|
|
uint32_t len = (ref >> 1);
|
|
uint32_t i;
|
|
|
|
Toplevel* toplevel = this->toplevel();
|
|
GCRef<ArrayObject> obj = toplevel->arrayClass()->newArray(len);
|
|
ObjectListAdd(obj);
|
|
|
|
// read the non-dense portion first, terminated by the empty string
|
|
for (;;)
|
|
{
|
|
String* name = ReadString();
|
|
if (name->length() == 0)
|
|
break;
|
|
|
|
Atom value = ReadAtom();
|
|
SetObjectProperty(obj->atom(), core->internString(name), value);
|
|
}
|
|
|
|
// now read the dense portion.
|
|
for (i = 0; i < len; i ++)
|
|
{
|
|
obj->setUintProperty(i, ReadAtom());
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
// END class AvmPlusObjectInput
|
|
//---------------------------------------------------------------------
|
|
|
|
//---------------------------------------------------------------------
|
|
// BEGIN class ClassInfo is used by class ObjectInput and ObjectOutput
|
|
|
|
// for output, construct information from Traits
|
|
|
|
bool ClassInfo::containsTransientMetadata(PoolObject* pool, const uint8_t* meta_pos)
|
|
{
|
|
AvmCore* core = m_toplevel->core();
|
|
return meta_pos ? pool->hasMetadataName(meta_pos, core->internConstantStringLatin1(kTransient)) : false;
|
|
}
|
|
|
|
bool ClassInfo::slotContainsTransientMetadata(Traits *traits, int index)
|
|
{
|
|
PoolObject* pool = NULL;
|
|
const uint8_t* pos = traits->getTraitsMetadata()->getSlotMetadataPos(index, pool);
|
|
return containsTransientMetadata(pool, pos);
|
|
}
|
|
|
|
bool ClassInfo::methodContainsTransientMetadata(Traits *traits, int index)
|
|
{
|
|
PoolObject* pool = NULL;
|
|
const uint8_t* pos = traits->getTraitsMetadata()->getMethodMetadataPos(index, pool);
|
|
return containsTransientMetadata(pool, pos);
|
|
}
|
|
|
|
bool ClassInfo::isSerializable(Traits * t, Namespace* ns, Binding b)
|
|
{
|
|
// ignore members that are not public and not compatible with the current version
|
|
if (!ns->isPublic() || !m_toplevel->core()->isNamespaceVisibleToApiVersionFromCallStack(ns))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (AvmCore::isVarBinding(b))
|
|
{
|
|
uint32_t slot = AvmCore::bindingToSlotId(b);
|
|
if (slotContainsTransientMetadata(t, slot))
|
|
{
|
|
// exclude slots contain metadata transient
|
|
return false;
|
|
}
|
|
|
|
}
|
|
else if (AvmCore::isAccessorBinding(b))
|
|
{
|
|
if (!AvmCore::hasGetterBinding(b) || methodContainsTransientMetadata(t, AvmCore::bindingToGetterId(b)))
|
|
{
|
|
// must implement a non-transient get accessor
|
|
return false;
|
|
}
|
|
|
|
if (!AvmCore::hasSetterBinding(b) || methodContainsTransientMetadata(t, AvmCore::bindingToSetterId(b)))
|
|
{
|
|
// must implement a non-transient set accessor
|
|
return false;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
// ignore members that aren't variables or accessors
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
ClassInfo::ClassInfo(Toplevel* toplevel, Traits *t) :
|
|
m_toplevel(toplevel),
|
|
m_traits(t),
|
|
m_dynamic(t->needsHashtable()),
|
|
m_sealed(toplevel->core()->GetGC(), 64)
|
|
{
|
|
// initialize m_name
|
|
m_name = toplevel->getAliasFromTraits(t);
|
|
|
|
if (t->containsInterface(BUILTIN_TRAITS_(flash_utils_IExternalizable)))
|
|
{
|
|
if (m_name->isEmpty())
|
|
{
|
|
// readExternal() does not exist on class Object,
|
|
// so it is meaningless to writeExternal() without a class name,
|
|
// as an instance of Object will be created when we decode the data.
|
|
|
|
// !!@ FIXME : Create a new exception for this?
|
|
toplevel->argumentErrorClass()->throwError(kInvalidParamError);
|
|
}
|
|
|
|
AvmCore* core = toplevel->core();
|
|
Multiname mn(core->getPublicNamespace(t->pool), core->internConstantStringLatin1(kWriteExternal));
|
|
m_functionBinding = toplevel->getBinding(t, &mn);
|
|
return;
|
|
}
|
|
|
|
TraitsIterator iterator(t);
|
|
Stringp name;
|
|
Namespace *ns;
|
|
Binding b;
|
|
|
|
// Add the name:String of all public variables to m_sealed.
|
|
// For our purposes, a getter/setter is considered a variable too.
|
|
while (iterator.getNext(name, ns, b))
|
|
{
|
|
if (isSerializable(t, ns, b))
|
|
{
|
|
m_sealed.add(name);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ClassInfo::Write(AvmPlusObjectOutput *output)
|
|
{
|
|
int len = SealedPropCount();
|
|
|
|
output->WriteString(m_name);
|
|
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
// write the name:String for each property (SealedPropCount() was encoded in the invalid ref id
|
|
output->WriteString(SealedProp(i));
|
|
}
|
|
}
|
|
|
|
// for input, construct information from DataInput
|
|
ClassInfo *ClassInfo::Read(Toplevel *toplevel, AvmPlusObjectInput *input, bool dynamic, bool externalizable, int count)
|
|
{
|
|
AvmCore* core = toplevel->core();
|
|
ClassInfo *info = new (core->GetGC()) ClassInfo(toplevel);
|
|
int i;
|
|
|
|
info->m_dynamic = dynamic;
|
|
info->m_name = core->internString(input->ReadString());
|
|
|
|
// initialize m_closure
|
|
info->m_closure = toplevel->getClassClosureFromAlias(info->m_name);
|
|
|
|
if (externalizable)
|
|
{
|
|
if (!info->m_closure->traits()->itraits->containsInterface(BUILTIN_TRAITS_(flash_utils_IExternalizable)))
|
|
{
|
|
// object was encoded with writeExternal, but current class does not implement readExternal,
|
|
// so data is meaningless to us.
|
|
toplevel->argumentErrorClass()->throwError(kReadExternalNotImplementedError, info->m_name);
|
|
}
|
|
|
|
Multiname mn(core->findPublicNamespace(), core->internConstantStringLatin1(kReadExternal));
|
|
info->m_functionBinding = toplevel->getBinding(info->m_closure->traits()->itraits, &mn);
|
|
}
|
|
|
|
info->m_traits = NULL; // unused when reading
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
String *name = input->ReadString();
|
|
info->m_sealed.add(core->internString(name));
|
|
}
|
|
|
|
return info;
|
|
}
|
|
|
|
// end class ClassInfo
|
|
//---------------------------------------------------------------------
|
|
|
|
}
|
|
|