Scope scope(v4);
Scoped<ArgumentsObject> args(scope, this);
- args->setArrayType(ArrayData::Complex);
+ args->setArrayType(Heap::ArrayData::Complex);
if (context->d()->strictMode) {
Q_ASSERT(CalleePropertyIndex == args->internalClass()->find(context->d()->engine->id_callee));
uint numAccessors = qMin((int)context()->d()->function->formalParameterCount(), context()->d()->realArgumentCount);
uint argCount = qMin(context()->d()->realArgumentCount, context()->d()->callData->argc);
- ArrayData::realloc(this, ArrayData::Sparse, argCount, true);
+ ArrayData::realloc(this, Heap::ArrayData::Sparse, argCount, true);
context()->d()->engine->requireArgumentsAccessors(numAccessors);
Scope scope(engine());
return Encode::undefined();
}
-void ArgumentsObject::markObjects(HeapObject *that, ExecutionEngine *e)
+void ArgumentsObject::markObjects(Heap::Base *that, ExecutionEngine *e)
{
ArgumentsObject::Data *o = static_cast<ArgumentsObject::Data *>(that);
if (o->context)
Data(CallContext *context);
CallContext *context;
bool fullyCreated;
- MemberData::Data *mappedArguments;
+ Heap::MemberData *mappedArguments;
};
V4_OBJECT(Object)
Q_MANAGED_TYPE(ArgumentsObject)
CallContext *context() const { return d()->context; }
bool fullyCreated() const { return d()->fullyCreated; }
- MemberData::Data *mappedArguments() { return d()->mappedArguments; }
+ Heap::MemberData *mappedArguments() { return d()->mappedArguments; }
static bool isNonStrictArgumentsObject(Managed *m) {
return m->internalClass()->vtable->type == Type_ArgumentsObject &&
static void putIndexed(Managed *m, uint index, const ValueRef value);
static bool deleteIndexedProperty(Managed *m, uint index);
static PropertyAttributes queryIndexed(const Managed *m, uint index);
- static void markObjects(HeapObject *that, ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, ExecutionEngine *e);
void fullyCreate();
};
const ArrayVTable SimpleArrayData::static_vtbl =
{
DEFINE_MANAGED_VTABLE_INT(SimpleArrayData, 0),
- SimpleArrayData::Simple,
+ Heap::ArrayData::Simple,
SimpleArrayData::reallocate,
SimpleArrayData::get,
SimpleArrayData::put,
const ArrayVTable SparseArrayData::static_vtbl =
{
DEFINE_MANAGED_VTABLE_INT(SparseArrayData, 0),
- ArrayData::Sparse,
+ Heap::ArrayData::Sparse,
SparseArrayData::reallocate,
SparseArrayData::get,
SparseArrayData::put,
SparseArrayData::length
};
-Q_STATIC_ASSERT(sizeof(ArrayData::Data) == sizeof(SimpleArrayData::Data));
-Q_STATIC_ASSERT(sizeof(ArrayData::Data) == sizeof(SparseArrayData::Data));
+Q_STATIC_ASSERT(sizeof(Heap::ArrayData) == sizeof(Heap::SimpleArrayData));
+Q_STATIC_ASSERT(sizeof(Heap::ArrayData) == sizeof(Heap::SparseArrayData));
void ArrayData::realloc(Object *o, Type newType, uint requested, bool enforceAttributes)
{
if (alloc < d->alloc())
alloc = d->alloc();
- if (d->type() < Sparse) {
+ if (d->type() < Heap::ArrayData::Sparse) {
offset = static_cast<SimpleArrayData *>(d)->d()->offset;
toCopy = static_cast<SimpleArrayData *>(d)->len();
} else {
if (d->type() > newType)
newType = d->type();
}
- if (enforceAttributes && newType == Simple)
- newType = Complex;
+ if (enforceAttributes && newType == Heap::ArrayData::Simple)
+ newType = Heap::ArrayData::Complex;
while (alloc < requested)
alloc *= 2;
- size_t size = sizeof(ArrayData::Data) + (alloc - 1)*sizeof(Value);
+ size_t size = sizeof(Heap::ArrayData) + (alloc - 1)*sizeof(Value);
if (enforceAttributes)
size += alloc*sizeof(PropertyAttributes);
ArrayData *newData;
- if (newType < Sparse) {
+ if (newType < Heap::ArrayData::Sparse) {
SimpleArrayData *n = static_cast<SimpleArrayData *>(o->engine()->memoryManager->allocManaged(size));
- new (n->d()) SimpleArrayData::Data(o->engine());
+ new (n->d()) Heap::SimpleArrayData(o->engine());
n->d()->offset = 0;
n->len() = d ? static_cast<SimpleArrayData *>(d)->len() : 0;
newData = n;
} else {
SparseArrayData *n = static_cast<SparseArrayData *>(o->engine()->memoryManager->allocManaged(size));
- new (n->d()) SparseArrayData::Data(o->engine());
+ new (n->d()) Heap::SparseArrayData(o->engine());
newData = n;
}
newData->setAlloc(alloc);
memcpy(o->arrayData()->d()->arrayData, d->d()->arrayData + offset, sizeof(Value)*toCopy);
}
- if (newType != Sparse)
+ if (newType != Heap::ArrayData::Sparse)
return;
SparseArrayData *sparse = static_cast<SparseArrayData *>(o->arrayData());
uint *lastFree;
- if (d && d->type() == Sparse) {
+ if (d && d->type() == Heap::ArrayData::Sparse) {
SparseArrayData *old = static_cast<SparseArrayData *>(d);
sparse->setSparse(old->sparse());
old->setSparse(0);
ArrayData *SimpleArrayData::reallocate(Object *o, uint n, bool enforceAttributes)
{
- realloc(o, Simple, n, enforceAttributes);
+ realloc(o, Heap::ArrayData::Simple, n, enforceAttributes);
return o->arrayData();
}
if (o->arrayData() && o->arrayData()->attrs())
return;
- ArrayData::realloc(o, Simple, 0, true);
+ ArrayData::realloc(o, Heap::ArrayData::Simple, 0, true);
}
-void SimpleArrayData::markObjects(HeapObject *d, ExecutionEngine *e)
+void SimpleArrayData::markObjects(Heap::Base *d, ExecutionEngine *e)
{
- SimpleArrayData::Data *dd = static_cast<SimpleArrayData::Data *>(d);
+ Heap::SimpleArrayData *dd = static_cast<Heap::SimpleArrayData *>(d);
uint l = dd->len;
for (uint i = 0; i < l; ++i)
dd->arrayData[i].mark(e);
SimpleArrayData *dd = static_cast<SimpleArrayData *>(o->arrayData());
Q_ASSERT(!dd->attrs());
if (dd->len() + n > dd->alloc()) {
- realloc(o, Simple, dd->len() + n, false);
+ realloc(o, Heap::ArrayData::Simple, dd->len() + n, false);
dd = static_cast<SimpleArrayData *>(o->arrayData());
}
dd->d()->offset = (dd->d()->offset - n) % dd->d()->alloc;
void SparseArrayData::free(ArrayData *d, uint idx)
{
- Q_ASSERT(d && d->type() == ArrayData::Sparse);
+ Q_ASSERT(d && d->type() == Heap::ArrayData::Sparse);
SparseArrayData *dd = static_cast<SparseArrayData *>(d);
Value *v = dd->arrayData() + idx;
if (dd->attrs() && dd->attrs()[idx].isAccessor()) {
delete dd->sparse();
}
-void SparseArrayData::markObjects(HeapObject *d, ExecutionEngine *e)
+void SparseArrayData::markObjects(Heap::Base *d, ExecutionEngine *e)
{
- SparseArrayData::Data *dd = static_cast<SparseArrayData::Data *>(d);
+ Heap::SparseArrayData *dd = static_cast<Heap::SparseArrayData *>(d);
uint l = dd->alloc;
for (uint i = 0; i < l; ++i)
dd->arrayData[i].mark(e);
ArrayData *SparseArrayData::reallocate(Object *o, uint n, bool enforceAttributes)
{
- realloc(o, Sparse, n, enforceAttributes);
+ realloc(o, Heap::ArrayData::Sparse, n, enforceAttributes);
return o->arrayData();
}
// double slots are required for accessor properties
uint SparseArrayData::allocate(Object *o, bool doubleSlot)
{
- Q_ASSERT(o->arrayData()->type() == ArrayData::Sparse);
+ Q_ASSERT(o->arrayData()->type() == Heap::ArrayData::Sparse);
SparseArrayData *dd = static_cast<SparseArrayData *>(o->arrayData());
if (doubleSlot) {
uint *last = &dd->freeList();
Property *ArrayData::insert(Object *o, uint index, bool isAccessor)
{
- if (!isAccessor && o->arrayData()->type() != ArrayData::Sparse) {
+ if (!isAccessor && o->arrayData()->type() != Heap::ArrayData::Sparse) {
SimpleArrayData *d = static_cast<SimpleArrayData *>(o->arrayData());
if (index < 0x1000 || index < d->len() + (d->len() >> 2)) {
if (index >= o->arrayData()->alloc()) {
// The spec says the sorting goes through a series of get,put and delete operations.
// this implies that the attributes don't get sorted around.
- if (thisObject->arrayData()->type() == ArrayData::Sparse) {
+ if (thisObject->arrayData()->type() == Heap::ArrayData::Sparse) {
// since we sort anyway, we can simply iterate over the entries in the sparse
// array and append them one by one to a regular one.
SparseArrayData *sparse = static_cast<SparseArrayData *>(thisObject->arrayData());
return;
thisObject->setArrayData(0);
- ArrayData::realloc(thisObject, ArrayData::Simple, sparse->sparse()->nEntries(), sparse->attrs() ? true : false);
+ ArrayData::realloc(thisObject, Heap::ArrayData::Simple, sparse->sparse()->nEntries(), sparse->attrs() ? true : false);
SimpleArrayData *d = static_cast<SimpleArrayData *>(thisObject->arrayData());
SparseArrayNode *n = sparse->sparse()->begin();
namespace QV4 {
-#define V4_ARRAYDATA \
+#define V4_ARRAYDATA(Data) \
public: \
Q_MANAGED_CHECK \
static const QV4::ArrayVTable static_vtbl; \
template <typename T> \
QV4::Returned<T> *asReturned() { return QV4::Returned<T>::create(this); } \
V4_MANAGED_SIZE_TEST \
- const Data *d() const { return &static_cast<const Data &>(Managed::data); } \
- Data *d() { return &static_cast<Data &>(Managed::data); }
+ const QV4::Heap::Data *d() const { return &static_cast<const QV4::Heap::Data &>(Managed::data); } \
+ QV4::Heap::Data *d() { return &static_cast<QV4::Heap::Data &>(Managed::data); }
struct ArrayData;
uint (*length)(const ArrayData *d);
};
+namespace Heap {
-struct Q_QML_EXPORT ArrayData : public Managed
-{
+struct ArrayData : public Base {
+ ArrayData(InternalClass *ic)
+ : Base(ic)
+ {}
enum Type {
Simple = 0,
Complex = 1,
Custom = 3
};
- struct Data : public Managed::Data {
- Data(InternalClass *ic)
- : Managed::Data(ic)
- {}
- uint alloc;
- Type type;
- PropertyAttributes *attrs;
- union {
- uint len;
- uint freeList;
- };
- union {
- uint offset;
- SparseArray *sparse;
- };
- Value arrayData[1];
+ uint alloc;
+ Type type;
+ PropertyAttributes *attrs;
+ union {
+ uint len;
+ uint freeList;
+ };
+ union {
+ uint offset;
+ SparseArray *sparse;
};
- V4_MANAGED(Managed)
+ Value arrayData[1];
+};
+
+struct SimpleArrayData : public ArrayData {
+ SimpleArrayData(ExecutionEngine *engine)
+ : ArrayData(engine->simpleArrayDataClass)
+ {}
+};
+
+struct SparseArrayData : public ArrayData {
+ inline SparseArrayData(ExecutionEngine *engine);
+};
+
+}
+
+struct Q_QML_EXPORT ArrayData : public Managed
+{
+ typedef Heap::ArrayData::Type Type;
+ V4_MANAGED2(ArrayData, Managed)
uint alloc() const { return d()->alloc; }
uint &alloc() { return d()->alloc; }
Value *arrayData() { return &d()->arrayData[0]; }
const ArrayVTable *vtable() const { return reinterpret_cast<const ArrayVTable *>(internalClass()->vtable); }
- bool isSparse() const { return type() == Sparse; }
+ bool isSparse() const { return type() == Heap::ArrayData::Sparse; }
uint length() const {
return vtable()->length(this);
struct Q_QML_EXPORT SimpleArrayData : public ArrayData
{
-
- struct Data : public ArrayData::Data {
- Data(ExecutionEngine *engine)
- : ArrayData::Data(engine->simpleArrayDataClass)
- {}
- };
- V4_ARRAYDATA
+ V4_ARRAYDATA(SimpleArrayData)
uint mappedIndex(uint index) const { return (index + d()->offset) % d()->alloc; }
Value data(uint index) const { return d()->arrayData[mappedIndex(index)]; }
static ArrayData *reallocate(Object *o, uint n, bool enforceAttributes);
- static void markObjects(HeapObject *d, ExecutionEngine *e);
+ static void markObjects(Heap::Base *d, ExecutionEngine *e);
static ReturnedValue get(const ArrayData *d, uint index);
static bool put(Object *o, uint index, ValueRef value);
struct Q_QML_EXPORT SparseArrayData : public ArrayData
{
- struct Data : public ArrayData::Data {
- Data(ExecutionEngine *engine)
- : ArrayData::Data(engine->emptyClass)
- { setVTable(staticVTable()); }
- };
- V4_ARRAYDATA
+ V4_ARRAYDATA(SparseArrayData)
uint &freeList() { return d()->freeList; }
uint freeList() const { return d()->freeList; }
}
static void destroy(Managed *d);
- static void markObjects(HeapObject *d, ExecutionEngine *e);
+ static void markObjects(Heap::Base *d, ExecutionEngine *e);
static ArrayData *reallocate(Object *o, uint n, bool enforceAttributes);
static ReturnedValue get(const ArrayData *d, uint index);
static uint length(const ArrayData *d);
};
+namespace Heap {
+inline SparseArrayData::SparseArrayData(ExecutionEngine *engine)
+ : ArrayData(engine->emptyClass)
+{
+ setVTable(QV4::SparseArrayData::staticVTable());
+}
+}
inline Property *ArrayData::getProperty(uint index)
{
- if (type() != Sparse) {
+ if (type() != Heap::ArrayData::Sparse) {
SimpleArrayData *that = static_cast<SimpleArrayData *>(this);
return that->getProperty(index);
} else {
if (!ctx->d()->callData->argc) {
;
- } else if (!instance->protoHasArray() && instance->arrayData()->length() <= len && instance->arrayType() == ArrayData::Simple) {
+ } else if (!instance->protoHasArray() && instance->arrayData()->length() <= len && instance->arrayType() == Heap::ArrayData::Simple) {
instance->arrayData()->vtable()->putArray(instance.getPointer(), len, ctx->d()->callData->args, ctx->d()->callData->argc);
len = instance->arrayData()->length();
} else {
ScopedValue result(scope);
- if (!instance->protoHasArray() && !instance->arrayData()->hasAttributes() && instance->arrayData()->length() <= len && instance->arrayData()->type() != ArrayData::Custom) {
+ if (!instance->protoHasArray() && !instance->arrayData()->hasAttributes() && instance->arrayData()->length() <= len && instance->arrayData()->type() != Heap::ArrayData::Custom) {
result = instance->arrayData()->vtable()->pop_front(instance.getPointer());
} else {
result = instance->getIndexed(0);
uint len = instance->getLength();
- if (!instance->protoHasArray() && !instance->arrayData()->hasAttributes() && instance->arrayData()->length() <= len && instance->arrayData()->type() != ArrayData::Custom) {
+ if (!instance->protoHasArray() && !instance->arrayData()->hasAttributes() && instance->arrayData()->length() <= len &&
+ instance->arrayData()->type() != Heap::ArrayData::Custom) {
instance->arrayData()->vtable()->push_front(instance.getPointer(), ctx->d()->callData->args, ctx->d()->callData->argc);
} else {
ScopedValue v(scope);
ScopedValue value(scope);
- if (instance->hasAccessorProperty() || (instance->arrayType() >= ArrayData::Sparse) || instance->protoHasArray()) {
+ if (instance->hasAccessorProperty() || (instance->arrayType() >= Heap::ArrayData::Sparse) || instance->protoHasArray()) {
// lets be safe and slow
for (uint i = fromIndex; i < len; ++i) {
bool exists;
} else if (!instance->arrayData()) {
return Encode(-1);
} else {
- Q_ASSERT(instance->arrayType() == ArrayData::Simple || instance->arrayType() == ArrayData::Complex);
+ Q_ASSERT(instance->arrayType() == Heap::ArrayData::Simple || instance->arrayType() == Heap::ArrayData::Complex);
SimpleArrayData *sa = static_cast<SimpleArrayData *>(instance->arrayData());
if (len > sa->len())
len = sa->len();
return d()->function->needsActivation() || d()->callData->argc < static_cast<int>(d()->function->formalParameterCount());
}
-void ExecutionContext::markObjects(HeapObject *m, ExecutionEngine *engine)
+void ExecutionContext::markObjects(Heap::Base *m, ExecutionEngine *engine)
{
ExecutionContext::Data *ctx = static_cast<ExecutionContext::Data *>(m);
EvalCode *next;
};
- struct Data : Managed::Data {
+ struct Data : Heap::Base {
Data(ExecutionEngine *engine, ContextType t)
- : Managed::Data(engine->executionContextClass)
+ : Heap::Base(engine->executionContextClass)
, type(t)
, strictMode(false)
, engine(engine)
inline CallContext *asCallContext();
inline const CallContext *asCallContext() const;
- static void markObjects(HeapObject *m, ExecutionEngine *e);
+ static void markObjects(Heap::Base *m, ExecutionEngine *e);
};
struct CallContext : public ExecutionContext
}
-void DataView::markObjects(HeapObject *that, ExecutionEngine *e)
+void DataView::markObjects(Heap::Base *that, ExecutionEngine *e)
{
DataView::Data *v = static_cast<DataView::Data *>(that);
v->buffer->mark(e);
};
V4_OBJECT(Object)
- static void markObjects(HeapObject *that, ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, ExecutionEngine *e);
};
struct DataViewPrototype: Object
jsStackTop -= nValues;
}
- void pushForGC(HeapObject *m) {
+ void pushForGC(Heap::Base *m) {
*jsStackTop = Value::fromHeapObject(m);
++jsStackTop;
}
- HeapObject *popForGC() {
+ Heap::Base *popForGC() {
--jsStackTop;
return jsStackTop->heapObject();
}
inline
-void HeapObject::mark(QV4::ExecutionEngine *engine)
+void Heap::Base::mark(QV4::ExecutionEngine *engine)
{
Q_ASSERT(inUse);
if (markBit)
return This->d()->stack->asReturnedValue();
}
-void ErrorObject::markObjects(HeapObject *that, ExecutionEngine *e)
+void ErrorObject::markObjects(Heap::Base *that, ExecutionEngine *e)
{
ErrorObject::Data *This = static_cast<ErrorObject::Data *>(that);
if (This->stack)
SyntaxErrorObject *asSyntaxError();
static ReturnedValue method_get_stack(CallContext *ctx);
- static void markObjects(HeapObject *that, ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, ExecutionEngine *e);
static void destroy(Managed *that) { static_cast<ErrorObject *>(that)->d()->~Data(); }
};
return Encode::undefined();
}
-void FunctionObject::markObjects(HeapObject *that, ExecutionEngine *e)
+void FunctionObject::markObjects(Heap::Base *that, ExecutionEngine *e)
{
FunctionObject::Data *o = static_cast<FunctionObject::Data *>(that);
if (o->scope)
ScopedCallData callData(scope, len);
if (len) {
- if (arr->arrayType() != ArrayData::Simple || arr->protoHasArray() || arr->hasAccessorProperty()) {
+ if (arr->arrayType() != Heap::ArrayData::Simple || arr->protoHasArray() || arr->hasAccessorProperty()) {
for (quint32 i = 0; i < len; ++i)
callData->args[i] = arr->getIndexed(i);
} else {
return f->target()->construct(callData);
}
-void BoundFunction::markObjects(HeapObject *that, ExecutionEngine *e)
+void BoundFunction::markObjects(Heap::Base *that, ExecutionEngine *e)
{
BoundFunction::Data *o = static_cast<BoundFunction::Data *>(that);
o->target->mark(e);
bool strictMode() const { return d()->strictMode; }
bool bindingKeyFlag() const { return d()->bindingKeyFlag; }
- static void markObjects(HeapObject *that, ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, ExecutionEngine *e);
};
template<>
Data(ExecutionContext *scope, FunctionObject *target, const ValueRef boundThis, MemberData *boundArgs);
FunctionObject *target;
Value boundThis;
- MemberData::Data *boundArgs;
+ Heap::MemberData *boundArgs;
};
V4_OBJECT(FunctionObject)
static ReturnedValue construct(Managed *, CallData *d);
static ReturnedValue call(Managed *that, CallData *dd);
- static void markObjects(HeapObject *that, ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, ExecutionEngine *e);
};
}
namespace QV4 {
+namespace Heap {
+ struct Base;
+}
+
class MemoryManager;
struct String;
struct Object;
struct Property;
struct Value;
struct Lookup;
-struct HeapObject;
struct ArrayData;
struct ManagedVTable;
return indexedGetterGeneric(l, object, index);
Object *o = object->objectValue();
- if (o->arrayData() && o->arrayData()->type() == ArrayData::Simple) {
+ if (o->arrayData() && o->arrayData()->type() == Heap::ArrayData::Simple) {
SimpleArrayData *s = static_cast<SimpleArrayData *>(o->arrayData());
if (idx < s->len())
if (!s->data(idx).isEmpty())
{
if (object->isObject()) {
Object *o = object->objectValue();
- if (o->arrayData() && o->arrayData()->type() == ArrayData::Simple && index->asArrayIndex() < UINT_MAX) {
+ if (o->arrayData() && o->arrayData()->type() == Heap::ArrayData::Simple && index->asArrayIndex() < UINT_MAX) {
l->indexedSetter = indexedSetterObjectInt;
indexedSetterObjectInt(l, object, index, v);
return;
uint idx = index->asArrayIndex();
if (idx < UINT_MAX) {
- if (o->arrayData() && o->arrayData()->type() == ArrayData::Simple) {
+ if (o->arrayData() && o->arrayData()->type() == Heap::ArrayData::Simple) {
SimpleArrayData *s = static_cast<SimpleArrayData *>(o->arrayData());
if (idx < s->len() && !s->data(idx).isEmpty()) {
s->data(idx) = value;
}
Object *o = object->objectValue();
- if (o->arrayData() && o->arrayData()->type() == ArrayData::Simple) {
+ if (o->arrayData() && o->arrayData()->type() == Heap::ArrayData::Simple) {
SimpleArrayData *s = static_cast<SimpleArrayData *>(o->arrayData());
if (idx < s->len() && !s->data(idx).isEmpty()) {
s->data(idx) = v;
d()->internalClass = internalClass()->changeVTable(vt);
}
-void HeapObject::setVTable(const ManagedVTable *vt)
+void Heap::Base::setVTable(const ManagedVTable *vt)
{
Q_ASSERT(internalClass);
internalClass = internalClass->changeVTable(vt);
const Data *d() const { return &static_cast<const Data &>(Managed::data); } \
Data *d() { return &static_cast<Data &>(Managed::data); }
+#define V4_MANAGED2(Data, superClass) \
+ public: \
+ Q_MANAGED_CHECK \
+ typedef superClass SuperClass; \
+ static const QV4::ManagedVTable static_vtbl; \
+ static inline const QV4::ManagedVTable *staticVTable() { return &static_vtbl; } \
+ template <typename _T> \
+ QV4::Returned<_T> *asReturned() { return QV4::Returned<_T>::create(this); } \
+ V4_MANAGED_SIZE_TEST \
+ const QV4::Heap::Data *d() const { return &static_cast<const QV4::Heap::Data &>(Managed::data); } \
+ QV4::Heap::Data *d() { return &static_cast<QV4::Heap::Data &>(Managed::data); }
+
#define V4_OBJECT(superClass) \
public: \
Q_MANAGED_CHECK \
uint type : 8;
const char *className;
void (*destroy)(Managed *);
- void (*markObjects)(HeapObject *, ExecutionEngine *e);
+ void (*markObjects)(Heap::Base *, ExecutionEngine *e);
bool (*isEqualTo)(Managed *m, Managed *other);
};
struct Q_QML_PRIVATE_EXPORT Managed
{
- struct Q_QML_PRIVATE_EXPORT Data : HeapObject {
- Data() : HeapObject(0) {}
- Data(InternalClass *internal)
- : HeapObject(internal)
- {}
- };
- Data data;
- V4_MANAGED(Managed)
+ Heap::Base data;
+ V4_MANAGED2(Base, Managed)
enum {
IsExecutionContext = false,
IsString = false,
DEFINE_MANAGED_VTABLE(MemberData);
-void MemberData::markObjects(HeapObject *that, ExecutionEngine *e)
+void MemberData::markObjects(Heap::Base *that, ExecutionEngine *e)
{
- MemberData::Data *m = static_cast<MemberData::Data *>(that);
+ Heap::MemberData *m = static_cast<Heap::MemberData *>(that);
for (uint i = 0; i < m->size; ++i)
m->data[i].mark(e);
}
-MemberData::Data *MemberData::reallocate(ExecutionEngine *e, Data *old, uint idx)
+Heap::MemberData *MemberData::reallocate(ExecutionEngine *e, Heap::MemberData *old, uint idx)
{
uint s = old ? old->size : 0;
if (idx < s)
return old;
int newAlloc = qMax((uint)4, 2*idx);
- uint alloc = sizeof(Data) + (newAlloc)*sizeof(Value);
+ uint alloc = sizeof(Heap::MemberData) + (newAlloc)*sizeof(Value);
MemberData *newMemberData = static_cast<MemberData *>(e->memoryManager->allocManaged(alloc));
if (old)
- memcpy(newMemberData, old, sizeof(MemberData::Data) + s*sizeof(Value));
+ memcpy(newMemberData, old, sizeof(Heap::MemberData) + s*sizeof(Value));
else
new (newMemberData) MemberData(e->memberDataClass);
newMemberData->d()->size = newAlloc;
namespace QV4 {
+namespace Heap {
+
+struct MemberData : Base {
+ union {
+ uint size;
+ double _dummy;
+ };
+ Value data[1];
+};
+
+}
+
struct MemberData : Managed
{
- struct Data : Managed::Data {
- union {
- uint size;
- double _dummy;
- };
- Value data[1];
- };
- V4_MANAGED(Managed)
+ V4_MANAGED2(MemberData, Managed)
MemberData(QV4::InternalClass *ic) : Managed(ic) {}
Value &operator[] (uint idx) { return d()->data[idx]; }
Value *data() { return d()->data; }
inline uint size() const { return d()->size; }
- static MemberData::Data *reallocate(QV4::ExecutionEngine *e, MemberData::Data *old, uint idx);
+ static Heap::MemberData *reallocate(QV4::ExecutionEngine *e, Heap::MemberData *old, uint idx);
- static void markObjects(HeapObject *that, ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, ExecutionEngine *e);
};
}
static void drainMarkStack(QV4::ExecutionEngine *engine, Value *markBase)
{
while (engine->jsStackTop > markBase) {
- HeapObject *h = engine->popForGC();
+ Heap::Base *h = engine->popForGC();
Q_ASSERT (h->internalClass->vtable->markObjects);
h->internalClass->vtable->markObjects(h, engine);
}
char *chunkStart = reinterpret_cast<char *>(i->memory.base());
char *chunkEnd = chunkStart + i->memory.size() - i->chunkSize;
for (char *chunk = chunkStart; chunk <= chunkEnd; chunk += i->chunkSize) {
- Managed::Data *m = reinterpret_cast<Managed::Data *>(chunk);
+ Heap::Base *m = reinterpret_cast<Heap::Base *>(chunk);
Q_ASSERT((qintptr) chunk % 16 == 0);
if (m->inUse)
usedMem += i->chunkSize;
DEFINE_OBJECT_VTABLE(Object);
Object::Data::Data(InternalClass *internalClass)
- : Managed::Data(internalClass)
+ : Heap::Base(internalClass)
{
if (internalClass->size) {
Scope scope(internalClass->engine);
insertMember(name, value, Attr_ReadOnly);
}
-void Object::markObjects(HeapObject *that, ExecutionEngine *e)
+void Object::markObjects(Heap::Base *that, ExecutionEngine *e)
{
Object::Data *o = static_cast<Object::Data *>(that);
} else {
Q_ASSERT(!arrayData() && other->arrayData());
ArrayData::realloc(this, other->arrayData()->type(), other->arrayData()->alloc(), false);
- if (other->arrayType() == ArrayData::Sparse) {
+ if (other->arrayType() == Heap::ArrayData::Sparse) {
SparseArrayData *od = static_cast<SparseArrayData *>(other->arrayData());
SparseArrayData *dd = static_cast<SparseArrayData *>(arrayData());
dd->setSparse(new SparseArray(*od->sparse()));
void Object::initSparseArray()
{
- if (arrayType() == ArrayData::Sparse)
+ if (arrayType() == Heap::ArrayData::Sparse)
return;
- ArrayData::realloc(this, ArrayData::Sparse, 0, false);
+ ArrayData::realloc(this, Heap::ArrayData::Sparse, 0, false);
}
namespace QV4 {
struct Q_QML_EXPORT Object: Managed {
- struct Data : Managed::Data {
+ struct Data : Heap::Base {
Data(ExecutionEngine *engine)
- : Managed::Data(engine->objectClass)
+ : Heap::Base(engine->objectClass)
{
}
Data(InternalClass *internal = 0);
- MemberData::Data *memberData;
- ArrayData::Data *arrayData;
+ Heap::MemberData *memberData;
+ Heap::ArrayData *arrayData;
};
V4_OBJECT(Object)
Q_MANAGED_TYPE(Object)
void push_back(const ValueRef v);
ArrayData::Type arrayType() const {
- return arrayData() ? arrayData()->type() : ArrayData::Simple;
+ return arrayData() ? arrayData()->type() : Heap::ArrayData::Simple;
}
// ### remove me
void setArrayType(ArrayData::Type t) {
- Q_ASSERT(t != ArrayData::Simple && t != ArrayData::Sparse);
+ Q_ASSERT(t != Heap::ArrayData::Simple && t != Heap::ArrayData::Sparse);
arrayCreate();
arrayData()->setType(t);
}
inline void arrayReserve(uint n) {
- ArrayData::realloc(this, ArrayData::Simple, n, false);
+ ArrayData::realloc(this, Heap::ArrayData::Simple, n, false);
}
void arrayCreate() {
if (!arrayData())
- ArrayData::realloc(this, ArrayData::Simple, 0, false);
+ ArrayData::realloc(this, Heap::ArrayData::Simple, 0, false);
#ifdef CHECK_SPARSE_ARRAYS
initSparseArray();
#endif
}
void initSparseArray();
- SparseArrayNode *sparseBegin() { return arrayType() == ArrayData::Sparse ? static_cast<SparseArrayData *>(arrayData())->sparse()->begin() : 0; }
- SparseArrayNode *sparseEnd() { return arrayType() == ArrayData::Sparse ? static_cast<SparseArrayData *>(arrayData())->sparse()->end() : 0; }
+ SparseArrayNode *sparseBegin() { return arrayType() == Heap::ArrayData::Sparse ? static_cast<SparseArrayData *>(arrayData())->sparse()->begin() : 0; }
+ SparseArrayNode *sparseEnd() { return arrayType() == Heap::ArrayData::Sparse ? static_cast<SparseArrayData *>(arrayData())->sparse()->end() : 0; }
inline bool protoHasArray() {
Scope scope(engine());
inline ReturnedValue call(CallData *d)
{ return vtable()->call(this, d); }
protected:
- static void markObjects(HeapObject *that, ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, ExecutionEngine *e);
static ReturnedValue construct(Managed *m, CallData *);
static ReturnedValue call(Managed *m, CallData *);
static ReturnedValue get(Managed *m, String *name, bool *hasProperty);
Object *proto = current->objectValue()->prototype();
current->m = proto ? &proto->data : 0;
} else
- current->m = (HeapObject *)0;
+ current->m = (Heap::Base *)0;
arrayIndex = 0;
memberIndex = 0;
DEFINE_OBJECT_VTABLE(ForEachIteratorObject);
-void ForEachIteratorObject::markObjects(HeapObject *that, ExecutionEngine *e)
+void ForEachIteratorObject::markObjects(Heap::Base *that, ExecutionEngine *e)
{
ForEachIteratorObject::Data *o = static_cast<ForEachIteratorObject::Data *>(that);
o->workArea[0].mark(e);
ReturnedValue nextPropertyName() { return d()->it.nextPropertyNameAsString(); }
protected:
- static void markObjects(HeapObject *that, ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, ExecutionEngine *e);
};
}
}
-void QObjectWrapper::markObjects(HeapObject *that, QV4::ExecutionEngine *e)
+void QObjectWrapper::markObjects(Heap::Base *that, QV4::ExecutionEngine *e)
{
QObjectWrapper::Data *This = static_cast<QObjectWrapper::Data *>(that);
static void put(Managed *m, String *name, const ValueRef value);
static PropertyAttributes query(const Managed *, String *name);
static void advanceIterator(Managed *m, ObjectIterator *it, String *&name, uint *index, Property *p, PropertyAttributes *attributes);
- static void markObjects(HeapObject *that, QV4::ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, QV4::ExecutionEngine *e);
static void destroy(Managed *that);
static ReturnedValue method_connect(CallContext *ctx);
}
RegExp::Data::Data(ExecutionEngine* engine, const QString &pattern, bool ignoreCase, bool multiline)
- : Managed::Data(engine->regExpValueClass)
+ : Heap::Base(engine->regExpValueClass)
, pattern(pattern)
, ignoreCase(ignoreCase)
, multiLine(multiline)
static_cast<RegExp*>(that)->d()->~Data();
}
-void RegExp::markObjects(HeapObject *that, ExecutionEngine *e)
+void RegExp::markObjects(Heap::Base *that, ExecutionEngine *e)
{
Q_UNUSED(that);
Q_UNUSED(e);
struct RegExp : public Managed
{
- struct Data : Managed::Data {
+ struct Data : Heap::Base {
Data(ExecutionEngine* engine, const QString& pattern, bool ignoreCase, bool multiline);
~Data();
QString pattern;
int captureCount() const { return subPatternCount() + 1; }
static void destroy(Managed *that);
- static void markObjects(HeapObject *that, QV4::ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, QV4::ExecutionEngine *e);
friend class RegExpCache;
};
}
-void RegExpObject::markObjects(HeapObject *that, ExecutionEngine *e)
+void RegExpObject::markObjects(Heap::Base *that, ExecutionEngine *e)
{
RegExpObject::Data *re = static_cast<RegExpObject::Data *>(that);
if (re->value)
return construct(that, callData);
}
-void RegExpCtor::markObjects(HeapObject *that, ExecutionEngine *e)
+void RegExpCtor::markObjects(Heap::Base *that, ExecutionEngine *e)
{
RegExpCtor::Data *This = static_cast<RegExpCtor::Data *>(that);
This->lastMatch.mark(e);
uint flags() const;
protected:
- static void markObjects(HeapObject *that, ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, ExecutionEngine *e);
};
struct RegExpCtor: FunctionObject
static ReturnedValue construct(Managed *m, CallData *callData);
static ReturnedValue call(Managed *that, CallData *callData);
- static void markObjects(HeapObject *that, ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, ExecutionEngine *e);
};
struct RegExpPrototype: RegExpObject
uint idx = index->asArrayIndex();
if (idx < UINT_MAX) {
- if (o->arrayType() == ArrayData::Simple) {
+ if (o->arrayType() == Heap::ArrayData::Simple) {
SimpleArrayData *s = static_cast<SimpleArrayData *>(o->arrayData());
if (s && idx < s->len() && !s->data(idx).isEmpty()) {
s->data(idx) = value;
#endif
}
- ScopedValue(const Scope &scope, HeapObject *o)
+ ScopedValue(const Scope &scope, Heap::Base *o)
{
ptr = scope.engine->jsStackTop++;
ptr->m = o;
return *this;
}
- ScopedValue &operator=(HeapObject *o) {
+ ScopedValue &operator=(Heap::Base *o) {
ptr->m = o;
#if QT_POINTER_SIZE == 4
ptr->tag = QV4::Value::Managed_Type;
++scope.size;
#endif
}
- Scoped(const Scope &scope, HeapObject *o)
+ Scoped(const Scope &scope, Heap::Base *o)
{
Value v;
v.m = o;
#endif
}
- Scoped<T> &operator=(HeapObject *o) {
+ Scoped<T> &operator=(Heap::Base *o) {
Value v;
v.m = o;
#if QT_POINTER_SIZE == 4
return result.asReturnedValue();
}
-void QmlBindingWrapper::markObjects(HeapObject *m, ExecutionEngine *e)
+void QmlBindingWrapper::markObjects(Heap::Base *m, ExecutionEngine *e)
{
QmlBindingWrapper::Data *wrapper = static_cast<QmlBindingWrapper::Data *>(m);
if (wrapper->qml)
V4_OBJECT(FunctionObject)
static ReturnedValue call(Managed *that, CallData *);
- static void markObjects(HeapObject *m, ExecutionEngine *e);
+ static void markObjects(Heap::Base *m, ExecutionEngine *e);
CallContext *context() const { return d()->qmlContext; }
{
QV4::Scope scope(engine);
QV4::Scoped<QQmlSequence<Container> > o(scope, this);
- o->setArrayType(ArrayData::Custom);
+ o->setArrayType(Heap::ArrayData::Custom);
o->init();
}
{
QV4::Scope scope(engine);
QV4::Scoped<QQmlSequence<Container> > o(scope, this);
- o->setArrayType(ArrayData::Custom);
+ o->setArrayType(Heap::ArrayData::Custom);
o->loadReference();
o->init();
}
static_cast<String*>(that)->d()->~Data();
}
-void String::markObjects(HeapObject *that, ExecutionEngine *e)
+void String::markObjects(Heap::Base *that, ExecutionEngine *e)
{
String::Data *s = static_cast<String::Data *>(that);
if (s->largestSubLength) {
String::Data::Data(ExecutionEngine *engine, const QString &t)
- : Managed::Data(engine->stringClass)
+ : Heap::Base(engine->stringClass)
{
subtype = StringType_Unknown;
}
String::Data::Data(ExecutionEngine *engine, String *l, String *r)
- : Managed::Data(engine->stringClass)
+ : Heap::Base(engine->stringClass)
{
subtype = StringType_Unknown;
struct Q_QML_PRIVATE_EXPORT String : public Managed {
#ifndef V4_BOOTSTRAP
- struct Q_QML_PRIVATE_EXPORT Data : Managed::Data {
+ struct Q_QML_PRIVATE_EXPORT Data : Heap::Base {
Data(ExecutionEngine *engine, const QString &text);
Data(ExecutionEngine *engine, String *l, String *n);
~Data() {
protected:
static void destroy(Managed *);
- static void markObjects(HeapObject *that, ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, ExecutionEngine *e);
static ReturnedValue get(Managed *m, String *name, bool *hasProperty);
static ReturnedValue getIndexed(Managed *m, uint index, bool *hasProperty);
static void put(Managed *m, String *name, const ValueRef value);
return Object::advanceIterator(m, it, name, index, p, attrs);
}
-void StringObject::markObjects(HeapObject *that, ExecutionEngine *e)
+void StringObject::markObjects(Heap::Base *that, ExecutionEngine *e)
{
StringObject::Data *o = static_cast<StringObject::Data *>(that);
o->value.stringValue()->mark(e);
protected:
static void advanceIterator(Managed *m, ObjectIterator *it, String *&name, uint *index, Property *p, PropertyAttributes *attrs);
- static void markObjects(HeapObject *that, ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, ExecutionEngine *e);
};
struct StringCtor: FunctionObject
{
}
-void TypedArray::markObjects(HeapObject *that, ExecutionEngine *e)
+void TypedArray::markObjects(Heap::Base *that, ExecutionEngine *e)
{
static_cast<TypedArray::Data *>(that)->buffer->mark(e);
Object::markObjects(that, e);
}
- static void markObjects(HeapObject *that, ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, ExecutionEngine *e);
static ReturnedValue getIndexed(Managed *m, uint index, bool *hasProperty);
static void putIndexed(Managed *m, uint index, const ValueRef value);
};
{
if (!isManaged())
return false;
- return m && static_cast<Managed::Data *>(m)->internalClass->vtable->isString;
+ return m && static_cast<Heap::Base *>(m)->internalClass->vtable->isString;
}
inline bool Value::isObject() const
{
if (!isManaged())
return false;
- return m && static_cast<Managed::Data *>(m)->internalClass->vtable->isObject;
+ return m && static_cast<Heap::Base *>(m)->internalClass->vtable->isObject;
}
inline bool Value::isPrimitive() const
typedef uint Bool;
-struct Q_QML_EXPORT HeapObject {
- HeapObject(InternalClass *internal)
+namespace Heap {
+
+struct Q_QML_EXPORT Base {
+ Base(InternalClass *internal)
: internalClass(internal)
, markBit(0)
, inUse(1)
inline void mark(QV4::ExecutionEngine *engine);
void *operator new(size_t, Managed *m) { return m; }
- void *operator new(size_t, HeapObject *m) { return m; }
- void operator delete(void *, HeapObject *) {}
+ void *operator new(size_t, Heap::Base *m) { return m; }
+ void operator delete(void *, Heap::Base *) {}
};
+}
+
template <typename T>
-struct Returned : private HeapObject
+struct Returned : private Heap::Base
{
- static Returned<T> *create(T *t) { Q_ASSERT((void *)&t->data == (void *)t); return static_cast<Returned<T> *>(static_cast<HeapObject*>(t ? &t->data : 0)); }
- static Returned<T> *create(typename T::Data *t) { return static_cast<Returned<T> *>(static_cast<HeapObject*>(t)); }
+ static Returned<T> *create(T *t) { Q_ASSERT((void *)&t->data == (void *)t); return static_cast<Returned<T> *>(static_cast<Heap::Base*>(t ? &t->data : 0)); }
+ static Returned<T> *create(typename T::Data *t) { return static_cast<Returned<T> *>(static_cast<Heap::Base*>(t)); }
T *getPointer() { return reinterpret_cast<T *>(this); }
template<typename X>
static T *getPointer(Returned<X> *x) { return x->getPointer(); }
union {
quint64 val;
#if QT_POINTER_SIZE == 8
- HeapObject *m;
+ Heap::Base *m;
#else
double dbl;
#endif
uint uint_32;
int int_32;
#if QT_POINTER_SIZE == 4
- HeapObject *m;
+ Heap::Base *m;
#endif
};
#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
Managed *managed() const {
return m ? reinterpret_cast<Managed*>(m) : 0;
}
- HeapObject *heapObject() const {
+ Heap::Base *heapObject() const {
return m;
}
return val;
}
- static inline Value fromHeapObject(HeapObject *m)
+ static inline Value fromHeapObject(Heap::Base *m)
{
Value v;
v.m = m;
val = Value::fromManaged(t).val;
return *this;
}
- Value &operator=(HeapObject *o) {
+ Value &operator=(Heap::Base *o) {
m = o;
return *this;
}
};
inline
-ReturnedValue HeapObject::asReturnedValue() const
+ReturnedValue Heap::Base::asReturnedValue() const
{
- return Value::fromHeapObject(const_cast<HeapObject *>(this)).asReturnedValue();
+ return Value::fromHeapObject(const_cast<Heap::Base *>(this)).asReturnedValue();
}
static QV4::ReturnedValue method_forceCompletion(QV4::CallContext *ctx);
static void destroy(Managed *that);
- static void markObjects(QV4::HeapObject *that, QV4::ExecutionEngine *e);
+ static void markObjects(QV4::Heap::Base *that, QV4::ExecutionEngine *e);
void statusChanged(QQmlIncubator::Status);
void setInitialState(QObject *);
static_cast<QmlIncubatorObject *>(that)->d()->~Data();
}
-void QmlIncubatorObject::markObjects(QV4::HeapObject *that, QV4::ExecutionEngine *e)
+void QmlIncubatorObject::markObjects(QV4::Heap::Base *that, QV4::ExecutionEngine *e)
{
QmlIncubatorObject::Data *o = static_cast<QmlIncubatorObject::Data *>(that);
o->valuemap.mark(e);
static_cast<QmlContextWrapper *>(that)->d()->~Data();
}
-void QmlContextWrapper::markObjects(HeapObject *m, ExecutionEngine *engine)
+void QmlContextWrapper::markObjects(Heap::Base *m, ExecutionEngine *engine)
{
QmlContextWrapper::Data *This = static_cast<QmlContextWrapper::Data *>(m);
if (This->idObjectsWrapper)
return QObjectWrapper::wrap(This->engine(), context->idValues[index].data());
}
-void QQmlIdObjectsArray::markObjects(HeapObject *that, ExecutionEngine *engine)
+void QQmlIdObjectsArray::markObjects(Heap::Base *that, ExecutionEngine *engine)
{
QQmlIdObjectsArray::Data *This = static_cast<QQmlIdObjectsArray::Data *>(that);
This->contextWrapper->mark(engine);
static ReturnedValue get(Managed *m, String *name, bool *hasProperty);
static void put(Managed *m, String *name, const ValueRef value);
static void destroy(Managed *that);
- static void markObjects(HeapObject *m, ExecutionEngine *engine);
+ static void markObjects(Heap::Base *m, ExecutionEngine *engine);
static void registerQmlDependencies(ExecutionEngine *context, const CompiledData::Function *compiledFunction);
V4_OBJECT(Object)
static ReturnedValue getIndexed(Managed *m, uint index, bool *hasProperty);
- static void markObjects(HeapObject *that, ExecutionEngine *engine);
+ static void markObjects(Heap::Base *that, ExecutionEngine *engine);
};
QV4::Scope scope(QV8Engine::getV4(engine));
QV4::ScopedObject o(scope, this);
- o->setArrayType(ArrayData::Custom);
+ o->setArrayType(Heap::ArrayData::Custom);
}
QmlListWrapper::Data::~Data()
Object *proto;
};
V4_OBJECT(FunctionObject)
- static void markObjects(HeapObject *that, ExecutionEngine *e) {
+ static void markObjects(Heap::Base *that, ExecutionEngine *e) {
QQmlXMLHttpRequestCtor::Data *c = static_cast<QQmlXMLHttpRequestCtor::Data *>(that);
if (c->proto)
c->proto->mark(e);
return This->d()->originalFunction->call(callData);
}
-void QQmlBindingFunction::markObjects(HeapObject *that, ExecutionEngine *e)
+void QQmlBindingFunction::markObjects(Heap::Base *that, ExecutionEngine *e)
{
QQmlBindingFunction::Data *This = static_cast<QQmlBindingFunction::Data *>(that);
This->originalFunction->mark(e);
static ReturnedValue call(Managed *that, CallData *callData);
- static void markObjects(HeapObject *that, ExecutionEngine *e);
+ static void markObjects(Heap::Base *that, ExecutionEngine *e);
static void destroy(Managed *that) {
static_cast<QQmlBindingFunction *>(that)->d()->~Data();
}
setVTable(staticVTable());
QV4::Scope scope(engine);
QV4::ScopedObject o(scope, this);
- o->setArrayType(QV4::ArrayData::Custom);
+ o->setArrayType(QV4::Heap::ArrayData::Custom);
}
QVector<QQmlChangeSet::Change> changes;
};
setVTable(staticVTable());
QV4::Scope scope(engine);
QV4::ScopedObject o(scope, this);
- o->setArrayType(QV4::ArrayData::Custom);
+ o->setArrayType(QV4::Heap::ArrayData::Custom);
}
QImage image;
};
static QV4::ReturnedValue method_get_height(QV4::CallContext *ctx);
static QV4::ReturnedValue method_get_data(QV4::CallContext *ctx);
- static void markObjects(QV4::HeapObject *that, QV4::ExecutionEngine *engine) {
+ static void markObjects(QV4::Heap::Base *that, QV4::ExecutionEngine *engine) {
static_cast<QQuickJSContext2DImageData::Data *>(that)->pixelData.mark(engine);
QV4::Object::markObjects(that, engine);
}
return e->memoryManager->alloc<QQuickRootItemMarker>(e, window);
}
-void QQuickRootItemMarker::markObjects(QV4::HeapObject *that, QV4::ExecutionEngine *e)
+void QQuickRootItemMarker::markObjects(QV4::Heap::Base *that, QV4::ExecutionEngine *e)
{
QQuickItem *root = static_cast<QQuickRootItemMarker::Data *>(that)->window->contentItem();
if (root) {
static QV4::Returned<QQuickRootItemMarker> *create(QQmlEngine *engine, QQuickWindow *window);
- static void markObjects(QV4::HeapObject *that, QV4::ExecutionEngine *e);
+ static void markObjects(QV4::Heap::Base *that, QV4::ExecutionEngine *e);
};