enum Type { Database, Query, Rows };
struct Data : Object::Data {
Data(ExecutionEngine *e)
- : Object::Data(e)
+ : QV4::Heap::Object(e)
{
setVTable(staticVTable());
type = Database;
{
struct Data : QV4::Object::Data {
Data(QV4::ExecutionEngine *engine, QQuickParticleData *datum)
- : Object::Data(engine)
+ : QV4::Heap::Object(engine)
, datum(datum)
{
setVTable(QV4ParticleData::staticVTable());
DEFINE_OBJECT_VTABLE(ArgumentsObject);
ArgumentsObject::Data::Data(CallContext *context)
- : Object::Data(context->d()->strictMode ? context->d()->engine->strictArgumentsObjectClass : context->d()->engine->argumentsObjectClass)
+ : Heap::Object(context->d()->strictMode ? context->d()->engine->strictArgumentsObjectClass : context->d()->engine->argumentsObjectClass)
, context(context)
, fullyCreated(false)
{
struct ArgumentsObject: Object {
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(CallContext *context);
CallContext *context;
bool fullyCreated;
ArrayBuffer::Data::Data(ExecutionEngine *e, int length)
- : Object::Data(e->arrayBufferClass)
+ : Heap::Object(e->arrayBufferClass)
{
data = QTypedArrayData<char>::allocate(length + 1);
if (!data) {
struct ArrayBuffer : Object
{
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *e, int length);
QTypedArrayData<char> *data;
};
global = eng->globalObject;
}
-Heap::WithContext::WithContext(ExecutionEngine *engine, Object *with)
+Heap::WithContext::WithContext(ExecutionEngine *engine, QV4::Object *with)
: Heap::ExecutionContext(engine, Heap::ExecutionContext::Type_WithContext)
{
callData = parent->d()->callData;
this->exceptionValue = exceptionValue;
}
-Heap::CallContext::CallContext(ExecutionEngine *engine, Object *qml, FunctionObject *function)
+Heap::CallContext::CallContext(ExecutionEngine *engine, QV4::Object *qml, FunctionObject *function)
: Heap::ExecutionContext(engine, Heap::ExecutionContext::Type_QmlContext)
{
this->function = function;
};
struct WithContext : ExecutionContext {
- WithContext(ExecutionEngine *engine, Object *with);
+ WithContext(ExecutionEngine *engine, QV4::Object *with);
Object *withObject;
};
DataView::Data::Data(ExecutionEngine *e)
- : Object::Data(e->dataViewClass),
+ : Heap::Object(e->dataViewClass),
buffer(0),
byteLength(0),
byteOffset(0)
struct DataView : Object
{
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *e);
ArrayBuffer *buffer;
uint byteLength;
DEFINE_OBJECT_VTABLE(DateObject);
DateObject::Data::Data(ExecutionEngine *engine, const QDateTime &date)
- : Object::Data(engine->dateClass)
+ : Heap::Object(engine->dateClass)
{
setVTable(staticVTable());
value.setDouble(date.isValid() ? date.toMSecsSinceEpoch() : qSNaN());
namespace QV4 {
struct DateObject: Object {
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *engine, const ValueRef date)
- : Object::Data(engine->dateClass)
+ : Heap::Object(engine->dateClass)
{
value = date;
}
Data(ExecutionEngine *engine, const QDateTime &date);
Data(InternalClass *ic)
- : Object::Data(ic)
+ : Heap::Object(ic)
{
Q_ASSERT(internalClass->vtable == staticVTable());
value = Primitive::fromDouble(qSNaN());
using namespace QV4;
ErrorObject::Data::Data(InternalClass *ic)
- : Object::Data(ic)
+ : Heap::Object(ic)
{
Scope scope(ic->engine);
Scoped<ErrorObject> e(scope, this);
}
ErrorObject::Data::Data(InternalClass *ic, const ValueRef message, ErrorType t)
- : Object::Data(ic)
+ : Heap::Object(ic)
{
subtype = t;
}
ErrorObject::Data::Data(InternalClass *ic, const QString &message, ErrorObject::ErrorType t)
- : Object::Data(ic)
+ : Heap::Object(ic)
{
subtype = t;
}
ErrorObject::Data::Data(InternalClass *ic, const QString &message, const QString &fileName, int line, int column, ErrorObject::ErrorType t)
- : Object::Data(ic)
+ : Heap::Object(ic)
{
subtype = t;
TypeError,
URIError
};
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(InternalClass *ic);
Data(InternalClass *ic, const ValueRef message, ErrorType t = Error);
Data(InternalClass *ic, const QString &message, ErrorType t = Error);
DEFINE_OBJECT_VTABLE(FunctionObject);
FunctionObject::Data::Data(ExecutionContext *scope, String *name, bool createProto)
- : Object::Data(scope->d()->engine->functionClass)
+ : Heap::Object(scope->d()->engine->functionClass)
, scope(scope)
{
Scope s(scope);
FunctionObject::Data::Data(ExecutionContext *scope, const QString &name, bool createProto)
- : Object::Data(scope->d()->engine->functionClass)
+ : Heap::Object(scope->d()->engine->functionClass)
, scope(scope)
{
Scope s(scope);
}
FunctionObject::Data::Data(ExecutionContext *scope, const ReturnedValue name)
- : Object::Data(scope->d()->engine->functionClass)
+ : Heap::Object(scope->d()->engine->functionClass)
, scope(scope)
{
Scope s(scope);
}
FunctionObject::Data::Data(InternalClass *ic)
- : Object::Data(ic)
+ : Heap::Object(ic)
, scope(ic->engine->rootContext)
{
Scope scope(ic->engine);
namespace QV4 {
struct Q_QML_EXPORT FunctionObject: Object {
- struct Q_QML_PRIVATE_EXPORT Data : Object::Data {
+ struct Q_QML_PRIVATE_EXPORT Data : Heap::Object {
Data(ExecutionContext *scope, String *name, bool createProto = false);
Data(ExecutionContext *scope, const QString &name = QString(), bool createProto = false);
Data(ExecutionContext *scope, const ReturnedValue name);
JsonObject::Data::Data(InternalClass *ic)
- : Object::Data(ic)
+ : Heap::Object(ic)
{
Scope scope(ic->engine);
ScopedObject o(scope, this);
namespace QV4 {
struct JsonObject : Object {
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(InternalClass *ic);
};
Q_MANAGED_TYPE(JsonObject)
const Data *d() const { return &static_cast<const Data &>(Managed::data); } \
Data *d() { return &static_cast<Data &>(Managed::data); }
+#define V4_OBJECT2(DataClass, superClass) \
+ public: \
+ Q_MANAGED_CHECK \
+ typedef QV4::Heap::DataClass Data; \
+ typedef superClass SuperClass; \
+ static const QV4::ObjectVTable static_vtbl; \
+ static inline const QV4::ManagedVTable *staticVTable() { return &static_vtbl.managedVTable; } \
+ template <typename _T> \
+ QV4::Returned<_T> *asReturned() { return QV4::Returned<_T>::create(this); } \
+ V4_MANAGED_SIZE_TEST \
+ const QV4::Heap::DataClass *d() const { return &static_cast<const QV4::Heap::DataClass &>(Managed::data); } \
+ QV4::Heap::DataClass *d() { return &static_cast<QV4::Heap::DataClass &>(Managed::data); }
+
#define Q_MANAGED_TYPE(type) \
public: \
enum { MyType = Type_##type };
static const double qt_PI = 2.0 * ::asin(1.0);
MathObject::Data::Data(InternalClass *ic)
- : Object::Data(ic)
+ : Heap::Object(ic)
{
Scope scope(ic->engine);
ScopedObject m(scope, this);
struct MathObject: Object
{
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(InternalClass *ic);
};
DEFINE_OBJECT_VTABLE(Object);
-Object::Data::Data(InternalClass *internalClass)
+Heap::Object::Object(InternalClass *internalClass)
: Heap::Base(internalClass)
{
if (internalClass->size) {
void Object::markObjects(Heap::Base *that, ExecutionEngine *e)
{
- Object::Data *o = static_cast<Object::Data *>(that);
+ Heap::Object *o = static_cast<Heap::Object *>(that);
if (o->memberData)
o->memberData->mark(e);
DEFINE_OBJECT_VTABLE(ArrayObject);
ArrayObject::Data::Data(ExecutionEngine *engine, const QStringList &list)
- : Object::Data(engine->arrayClass)
+ : Heap::Object(engine->arrayClass)
{
init();
Scope scope(engine);
namespace QV4 {
-struct Q_QML_EXPORT Object: Managed {
- struct Data : Heap::Base {
- Data(ExecutionEngine *engine)
- : Heap::Base(engine->objectClass)
- {
- }
- Data(InternalClass *internal = 0);
+namespace Heap {
- Heap::MemberData *memberData;
- Heap::ArrayData *arrayData;
- };
- V4_OBJECT(Object)
+struct Object : Base {
+ Object(ExecutionEngine *engine)
+ : Base(engine->objectClass)
+ {
+ }
+ Object(InternalClass *internal = 0);
+
+ MemberData *memberData;
+ ArrayData *arrayData;
+};
+
+}
+
+struct Q_QML_EXPORT Object: Managed {
+ V4_OBJECT2(Object, Object)
Q_MANAGED_TYPE(Object)
enum {
};
struct BooleanObject: Object {
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *engine, const ValueRef val)
- : Object::Data(engine->booleanClass)
+ : Heap::Object(engine->booleanClass)
{
value = val;
}
Data(InternalClass *ic)
- : Object::Data(ic)
+ : Heap::Object(ic)
{
Q_ASSERT(internalClass->vtable == staticVTable());
value = Encode(false);
};
struct NumberObject: Object {
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *engine, const ValueRef val)
- : Object::Data(engine->numberClass) {
+ : Heap::Object(engine->numberClass) {
value = val;
}
Data(InternalClass *ic)
- : Object::Data(ic) {
+ : Heap::Object(ic) {
Q_ASSERT(internalClass->vtable == staticVTable());
value = Encode((int)0);
}
};
struct ArrayObject: Object {
- struct Data : Object::Data {
- Data(ExecutionEngine *engine) : Object::Data(engine->arrayClass) { init(); }
+ struct Data : Heap::Object {
+ Data(ExecutionEngine *engine) : Heap::Object(engine->arrayClass) { init(); }
Data(ExecutionEngine *engine, const QStringList &list);
- Data(InternalClass *ic) : Object::Data(ic) { init(); }
+ Data(InternalClass *ic) : Heap::Object(ic) { init(); }
void init()
{ memberData->data[LengthPropertyIndex] = Primitive::fromInt32(0); }
};
};
struct ForEachIteratorObject: Object {
- struct Data : Object::Data {
- Data(ExecutionEngine *engine, Object *o)
- : Object::Data(engine)
+ struct Data : Heap::Object {
+ Data(ExecutionEngine *engine, QV4::Object *o)
+ : Heap::Object(engine)
, it(workArea, workArea + 1, o, ObjectIterator::EnumerableOnly|ObjectIterator::WithProtoChain) {
setVTable(staticVTable());
}
}
QObjectWrapper::Data::Data(ExecutionEngine *engine, QObject *object)
- : Object::Data(engine)
+ : Heap::Object(engine)
, object(object)
{
setVTable(staticVTable());
DEFINE_OBJECT_VTABLE(QObjectMethod);
QmlSignalHandler::Data::Data(ExecutionEngine *engine, QObject *object, int signalIndex)
- : Object::Data(engine)
+ : Heap::Object(engine)
, object(object)
, signalIndex(signalIndex)
{
struct Q_QML_EXPORT QObjectWrapper : public QV4::Object
{
- struct Data : QV4::Object::Data {
+ struct Data : QV4::Heap::Object {
Data(ExecutionEngine *engine, QObject *object);
QPointer<QObject> object;
};
struct QmlSignalHandler : public QV4::Object
{
- struct Data : QV4::Object::Data {
+ struct Data : QV4::Heap::Object {
Data(ExecutionEngine *engine, QObject *object, int signalIndex);
QPointer<QObject> object;
int signalIndex;
DEFINE_OBJECT_VTABLE(RegExpPrototype);
RegExpObject::Data::Data(InternalClass *ic)
- : Object::Data(ic)
+ : Heap::Object(ic)
{
setVTable(staticVTable());
}
RegExpObject::Data::Data(ExecutionEngine *engine, RegExp *value, bool global)
- : Object::Data(engine->regExpClass)
+ : Heap::Object(engine->regExpClass)
, value(value)
, global(global)
{
// The conversion is not 100% exact since ECMA regexp and QRegExp
// have different semantics/flags, but we try to do our best.
RegExpObject::Data::Data(ExecutionEngine *engine, const QRegExp &re)
- : Object::Data(engine->regExpClass)
+ : Heap::Object(engine->regExpClass)
{
setVTable(staticVTable());
namespace QV4 {
struct RegExpObject: Object {
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *engine, RegExp *value, bool global);
Data(ExecutionEngine *engine, const QRegExp &re);
Data(InternalClass *ic);
using namespace QV4;
-QmlBindingWrapper::Data::Data(ExecutionContext *scope, Function *f, Object *qml)
+QmlBindingWrapper::Data::Data(ExecutionContext *scope, Function *f, QV4::Object *qml)
: FunctionObject::Data(scope, scope->d()->engine->id_eval, /*createProto = */ false)
, qml(qml)
{
s.engine->popContext();
}
-QmlBindingWrapper::Data::Data(ExecutionContext *scope, Object *qml)
+QmlBindingWrapper::Data::Data(ExecutionContext *scope, QV4::Object *qml)
: FunctionObject::Data(scope, scope->d()->engine->id_eval, /*createProto = */ false)
, qml(qml)
{
struct CompilationUnitHolder : public Object
{
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *engine, CompiledData::CompilationUnit *unit)
- : Object::Data(engine)
+ : Heap::Object(engine)
, unit(unit)
{
setVTable(staticVTable());
struct Q_QML_EXPORT QmlBindingWrapper : FunctionObject {
struct Data : FunctionObject::Data {
- Data(ExecutionContext *scope, Function *f, Object *qml);
+ Data(ExecutionContext *scope, Function *f, QV4::Object *qml);
// Constructor for QML functions and signal handlers, resulting binding wrapper is not callable!
- Data(ExecutionContext *scope, Object *qml);
- Object *qml;
+ Data(ExecutionContext *scope, QV4::Object *qml);
+ QV4::Object *qml;
CallContext *qmlContext;
};
V4_OBJECT(FunctionObject)
template <typename Container>
struct QQmlSequence : public QV4::Object
{
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(QV4::ExecutionEngine *engine, const Container &container)
- : Object::Data(InternalClass::create(engine, staticVTable(), engine->sequencePrototype.asObject()))
+ : Heap::Object(InternalClass::create(engine, staticVTable(), engine->sequencePrototype.asObject()))
, container(container)
, propertyIndex(-1)
, isReference(false)
}
Data(QV4::ExecutionEngine *engine, QObject *object, int propertyIndex)
- : Object::Data(InternalClass::create(engine, staticVTable(), engine->sequencePrototype.asObject()))
+ : Heap::Object(InternalClass::create(engine, staticVTable(), engine->sequencePrototype.asObject()))
, object(object)
, propertyIndex(propertyIndex)
, isReference(true)
DEFINE_OBJECT_VTABLE(StringObject);
StringObject::Data::Data(InternalClass *ic)
- : Object::Data(ic)
+ : Heap::Object(ic)
{
Q_ASSERT(internalClass->vtable == staticVTable());
value = ic->engine->newString(QStringLiteral(""))->asReturnedValue();
}
StringObject::Data::Data(ExecutionEngine *engine, const ValueRef val)
- : Object::Data(engine->stringObjectClass)
+ : Heap::Object(engine->stringObjectClass)
{
value = val;
Q_ASSERT(value.isString());
namespace QV4 {
struct StringObject: Object {
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *engine, const ValueRef value);
Data(InternalClass *ic);
Value value;
}
TypedArray::Data::Data(ExecutionEngine *e, Type t)
- : Object::Data(e->typedArrayClasses[t]),
+ : Heap::Object(e->typedArrayClasses[t]),
type(operations + t)
{
}
NTypes
};
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *e, Type t);
const TypedArrayOperations *type;
struct TypedArrayPrototype : Object
{
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *e, TypedArray::Type t)
- : Object::Data(e)
+ : Heap::Object(e)
, type(t)
{
setVTable(staticVTable());
DEFINE_OBJECT_VTABLE(VariantObject);
VariantObject::Data::Data(InternalClass *ic)
- : Object::Data(ic)
+ : Heap::Object(ic)
{
}
VariantObject::Data::Data(ExecutionEngine *engine, const QVariant &value)
- : Object::Data(engine->variantClass)
+ : Heap::Object(engine->variantClass)
{
data = value;
if (isScarce())
struct VariantObject : Object
{
- struct Data : Object::Data, public ExecutionEngine::ScarceResourceData
+ struct Data : Heap::Object, public ExecutionEngine::ScarceResourceData
{
Data(InternalClass *ic);
Data(ExecutionEngine *engine, const QVariant &value);
struct QmlIncubatorObject : public QV4::Object
{
- struct Data : QV4::Object::Data {
+ struct Data : QV4::Heap::Object {
Data(QV8Engine *engine, QQmlIncubator::IncubationMode = QQmlIncubator::Asynchronous);
QScopedPointer<QQmlComponentIncubator> incubator;
QV8Engine *v8;
}
QmlIncubatorObject::Data::Data(QV8Engine *engine, QQmlIncubator::IncubationMode m)
- : Object::Data(QV8Engine::getV4(engine))
+ : QV4::Heap::Object(QV8Engine::getV4(engine))
, v8(engine)
, valuemap(QV4::Primitive::undefinedValue())
, qmlGlobal(QV4::Primitive::undefinedValue())
DEFINE_OBJECT_VTABLE(QmlContextWrapper);
QmlContextWrapper::Data::Data(QV8Engine *engine, QQmlContextData *context, QObject *scopeObject, bool ownsContext)
- : Object::Data(QV8Engine::getV4(engine))
+ : Heap::Object(QV8Engine::getV4(engine))
, readOnly(true)
, ownsContext(ownsContext)
, isNullWrapper(false)
DEFINE_OBJECT_VTABLE(QQmlIdObjectsArray);
QQmlIdObjectsArray::Data::Data(ExecutionEngine *engine, QmlContextWrapper *contextWrapper)
- : Object::Data(engine)
+ : Heap::Object(engine)
, contextWrapper(contextWrapper)
{
setVTable(staticVTable());
struct Q_QML_EXPORT QmlContextWrapper : Object
{
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(QV8Engine *engine, QQmlContextData *context, QObject *scopeObject, bool ownsContext = false);
~Data();
bool readOnly;
struct QQmlIdObjectsArray : public Object
{
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *engine, QmlContextWrapper *contextWrapper);
QmlContextWrapper *contextWrapper;
};
DEFINE_OBJECT_VTABLE(QmlListWrapper);
QmlListWrapper::Data::Data(QV8Engine *engine)
- : Object::Data(QV8Engine::getV4(engine))
+ : Heap::Object(QV8Engine::getV4(engine))
, v8(engine)
{
setVTable(staticVTable());
struct Q_QML_EXPORT QmlListWrapper : Object
{
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(QV8Engine *engine);
~Data();
QV8Engine *v8;
struct QQmlLocaleData : public QV4::Object
{
- struct Data : Object::Data {
+ struct Data : QV4::Heap::Object {
Data(QV4::ExecutionEngine *engine)
- : Object::Data(engine)
+ : QV4::Heap::Object(engine)
{
setVTable(staticVTable());
}
DEFINE_OBJECT_VTABLE(QmlTypeWrapper);
QmlTypeWrapper::Data::Data(QV8Engine *engine)
- : Object::Data(QV8Engine::getV4(engine))
+ : Heap::Object(QV8Engine::getV4(engine))
, v8(engine)
, mode(IncludeEnums)
{
{
enum TypeNameMode { IncludeEnums, ExcludeEnums };
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(QV8Engine *engine);
~Data();
QV8Engine *v8;
DEFINE_OBJECT_VTABLE(QmlValueTypeCopy);
QmlValueTypeWrapper::Data::Data(QV8Engine *engine, ObjectType objectType)
- : Object::Data(QV8Engine::getV4(engine))
+ : Heap::Object(QV8Engine::getV4(engine))
, v8(engine)
, objectType(objectType)
{
struct Q_QML_EXPORT QmlValueTypeWrapper : Object
{
enum ObjectType { Reference, Copy };
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(QV8Engine *engine, ObjectType type);
QV8Engine *v8;
ObjectType objectType;
class NamedNodeMap : public Object
{
public:
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *engine, NodeImpl *data, const QList<NodeImpl *> &list)
- : Object::Data(engine)
+ : Heap::Object(engine)
, list(list)
, d(data)
{
class NodeList : public Object
{
public:
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *engine, NodeImpl *data)
- : Object::Data(engine)
+ : Heap::Object(engine)
, d(data)
{
setVTable(staticVTable());
class NodePrototype : public Object
{
public:
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *engine)
- : Object::Data(engine)
+ : Heap::Object(engine)
{
setVTable(staticVTable());
struct Node : public Object
{
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *engine, NodeImpl *data)
- : Object::Data(engine)
+ : Heap::Object(engine)
, d(data)
{
setVTable(staticVTable());
struct QQmlXMLHttpRequestWrapper : public Object
{
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *engine, QQmlXMLHttpRequest *request)
- : Object::Data(engine)
+ : Heap::Object(engine)
, request(request)
{
setVTable(staticVTable());
ScopedString s(scope, engine->id_prototype);
ctor->defineDefaultProperty(s.getPointer(), ScopedObject(scope, ctor->d()->proto));
}
- Object *proto;
+ QV4::Object *proto;
};
V4_OBJECT(FunctionObject)
static void markObjects(Heap::Base *that, ExecutionEngine *e) {
};
QV4::QtObject::Data::Data(ExecutionEngine *v4, QQmlEngine *qmlEngine)
- : Object::Data(v4)
+ : Heap::Object(v4)
{
setVTable(staticVTable());
QV4::ConsoleObject::Data::Data(ExecutionEngine *v4)
- : Object::Data(v4)
+ : Heap::Object(v4)
{
QV4::Scope scope(v4);
QV4::ScopedObject o(scope, this);
struct QtObject : Object
{
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *v4, QQmlEngine *qmlEngine);
QObject *platform;
QObject *application;
struct ConsoleObject : Object
{
- struct Data : Object::Data {
+ struct Data : Heap::Object {
Data(ExecutionEngine *engine);
};
struct QQmlDelegateModelGroupChange : QV4::Object
{
- struct Data : QV4::Object::Data {
+ struct Data : QV4::Heap::Object {
Data(QV4::ExecutionEngine *engine)
- : Object::Data(engine)
+ : QV4::Heap::Object(engine)
{
setVTable(staticVTable());
}
struct QQmlDelegateModelGroupChangeArray : public QV4::Object
{
- struct Data : QV4::Object::Data {
+ struct Data : QV4::Heap::Object {
Data(QV4::ExecutionEngine *engine, const QVector<QQmlChangeSet::Change> &changes)
- : Object::Data(engine)
+ : QV4::Heap::Object(engine)
, changes(changes)
{
setVTable(staticVTable());
struct QQmlDelegateModelItemObject : QV4::Object
{
- struct Data : QV4::Object::Data {
+ struct Data : QV4::Heap::Object {
Data(QV4::ExecutionEngine *engine, QQmlDelegateModelItem *item)
- : Object::Data(engine)
+ : QV4::Heap::Object(engine)
, item(item)
{
setVTable(staticVTable());
struct QQuickJSContext2D : public QV4::Object
{
- struct Data : Object::Data {
+ struct Data : QV4::Heap::Object {
Data(QV4::ExecutionEngine *engine)
- : Object::Data(engine)
+ : QV4::Heap::Object(engine)
{
setVTable(staticVTable());
}
struct QQuickContext2DStyle : public QV4::Object
{
- struct Data : Object::Data {
+ struct Data : QV4::Heap::Object {
Data(QV4::ExecutionEngine *e)
- : Object::Data(e)
+ : QV4::Heap::Object(e)
{
patternRepeatX = false;
patternRepeatY = false;
struct QQuickJSContext2DPixelData : public QV4::Object
{
- struct Data : Object::Data {
+ struct Data : QV4::Heap::Object {
Data(QV4::ExecutionEngine *engine)
- : Object::Data(engine)
+ : QV4::Heap::Object(engine)
{
setVTable(staticVTable());
QV4::Scope scope(engine);
struct QQuickJSContext2DImageData : public QV4::Object
{
- struct Data : Object::Data {
+ struct Data : QV4::Heap::Object {
Data(QV4::ExecutionEngine *engine)
- : Object::Data(engine)
+ : QV4::Heap::Object(engine)
{
setVTable(staticVTable());
pixelData = QV4::Primitive::undefinedValue();
struct QQuickRootItemMarker : public QV4::Object
{
- struct Data : QV4::Object::Data {
+ struct Data : QV4::Heap::Object {
Data(QV4::ExecutionEngine *engine, QQuickWindow *window)
- : Object::Data(engine)
+ : QV4::Heap::Object(engine)
, window(window)
{
setVTable(staticVTable());