diff options
70 files changed, 403 insertions, 545 deletions
diff --git a/src/imports/localstorage/plugin.cpp b/src/imports/localstorage/plugin.cpp index 7e0de1cd4b..6b2242d00b 100644 --- a/src/imports/localstorage/plugin.cpp +++ b/src/imports/localstorage/plugin.cpp @@ -101,14 +101,14 @@ V8_DEFINE_EXTENSION(QQmlSqlDatabaseData, databaseData) class QQmlSqlDatabaseWrapper : public Object { - Q_MANAGED + V4_OBJECT public: enum Type { Database, Query, Rows }; QQmlSqlDatabaseWrapper(QV8Engine *e) : Object(QV8Engine::getV4(e)), type(Database), inTransaction(false), readonly(false), forwardOnly(false) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ~QQmlSqlDatabaseWrapper() { @@ -131,7 +131,7 @@ public: bool forwardOnly; // type == Rows }; -DEFINE_MANAGED_VTABLE(QQmlSqlDatabaseWrapper); +DEFINE_OBJECT_VTABLE(QQmlSqlDatabaseWrapper); static ReturnedValue qmlsqldatabase_version(CallContext *ctx) { diff --git a/src/particles/qquickv4particledata.cpp b/src/particles/qquickv4particledata.cpp index d0e9a392d4..1d7b7abd9c 100644 --- a/src/particles/qquickv4particledata.cpp +++ b/src/particles/qquickv4particledata.cpp @@ -273,11 +273,11 @@ QT_BEGIN_NAMESPACE //### Particle data handles are not locked to within certain scopes like QQuickContext2D, but there's no way to reload either... struct QV4ParticleData : public QV4::Object { - Q_MANAGED + V4_OBJECT QV4ParticleData(QV4::ExecutionEngine *engine, QQuickParticleData *datum) : Object(engine) { - setVTable(&static_vtbl); + setVTable(staticVTable()); this->datum = datum; } @@ -287,7 +287,7 @@ struct QV4ParticleData : public QV4::Object { that->as<QV4ParticleData>()->~QV4ParticleData(); } }; -DEFINE_MANAGED_VTABLE(QV4ParticleData); +DEFINE_OBJECT_VTABLE(QV4ParticleData); class QV8ParticleDataDeletable : public QV8Engine::Deletable { diff --git a/src/qml/jsruntime/qv4argumentsobject.cpp b/src/qml/jsruntime/qv4argumentsobject.cpp index e23972d5a5..5e4debdd4a 100644 --- a/src/qml/jsruntime/qv4argumentsobject.cpp +++ b/src/qml/jsruntime/qv4argumentsobject.cpp @@ -44,7 +44,7 @@ using namespace QV4; -DEFINE_MANAGED_VTABLE(ArgumentsObject); +DEFINE_OBJECT_VTABLE(ArgumentsObject); ArgumentsObject::ArgumentsObject(CallContext *context) : Object(context->strictMode ? context->engine->strictArgumentsObjectClass : context->engine->argumentsObjectClass) @@ -76,7 +76,7 @@ ArgumentsObject::ArgumentsObject(CallContext *context) Property *lp = memberData + ArrayObject::LengthPropertyIndex; lp->value = Primitive::fromInt32(context->realArgumentCount); - Q_ASSERT(internalClass->vtable == &static_vtbl); + Q_ASSERT(internalClass->vtable == staticVTable()); } void ArgumentsObject::destroy(Managed *that) @@ -200,7 +200,7 @@ PropertyAttributes ArgumentsObject::queryIndexed(const Managed *m, uint index) return Attr_Accessor; } -DEFINE_MANAGED_VTABLE(ArgumentsGetterFunction); +DEFINE_OBJECT_VTABLE(ArgumentsGetterFunction); ReturnedValue ArgumentsGetterFunction::call(Managed *getter, CallData *callData) { @@ -215,7 +215,7 @@ ReturnedValue ArgumentsGetterFunction::call(Managed *getter, CallData *callData) return o->context->argument(g->index); } -DEFINE_MANAGED_VTABLE(ArgumentsSetterFunction); +DEFINE_OBJECT_VTABLE(ArgumentsSetterFunction); ReturnedValue ArgumentsSetterFunction::call(Managed *setter, CallData *callData) { diff --git a/src/qml/jsruntime/qv4argumentsobject_p.h b/src/qml/jsruntime/qv4argumentsobject_p.h index 42b749cbb5..20354272f2 100644 --- a/src/qml/jsruntime/qv4argumentsobject_p.h +++ b/src/qml/jsruntime/qv4argumentsobject_p.h @@ -50,12 +50,12 @@ namespace QV4 { struct ArgumentsGetterFunction: FunctionObject { - Q_MANAGED + V4_OBJECT uint index; ArgumentsGetterFunction(ExecutionContext *scope, uint index) : FunctionObject(scope), index(index) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } static ReturnedValue call(Managed *that, CallData *d); @@ -63,12 +63,12 @@ struct ArgumentsGetterFunction: FunctionObject struct ArgumentsSetterFunction: FunctionObject { - Q_MANAGED + V4_OBJECT uint index; ArgumentsSetterFunction(ExecutionContext *scope, uint index) : FunctionObject(scope), index(index) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } static ReturnedValue call(Managed *that, CallData *callData); @@ -76,7 +76,7 @@ struct ArgumentsSetterFunction: FunctionObject struct ArgumentsObject: Object { - Q_MANAGED + V4_OBJECT Q_MANAGED_TYPE(ArgumentsObject) CallContext *context; bool fullyCreated; diff --git a/src/qml/jsruntime/qv4arrayobject.cpp b/src/qml/jsruntime/qv4arrayobject.cpp index b79e4b13fe..8069952d43 100644 --- a/src/qml/jsruntime/qv4arrayobject.cpp +++ b/src/qml/jsruntime/qv4arrayobject.cpp @@ -46,12 +46,12 @@ using namespace QV4; -DEFINE_MANAGED_VTABLE(ArrayCtor); +DEFINE_OBJECT_VTABLE(ArrayCtor); ArrayCtor::ArrayCtor(ExecutionContext *scope) : FunctionObject(scope, QStringLiteral("Array")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue ArrayCtor::construct(Managed *m, CallData *callData) diff --git a/src/qml/jsruntime/qv4arrayobject_p.h b/src/qml/jsruntime/qv4arrayobject_p.h index 641be86e2c..e7f8ba711f 100644 --- a/src/qml/jsruntime/qv4arrayobject_p.h +++ b/src/qml/jsruntime/qv4arrayobject_p.h @@ -51,7 +51,7 @@ namespace QV4 { struct ArrayCtor: FunctionObject { - Q_MANAGED + V4_OBJECT ArrayCtor(ExecutionContext *scope); static ReturnedValue construct(Managed *m, CallData *callData); diff --git a/src/qml/jsruntime/qv4booleanobject.cpp b/src/qml/jsruntime/qv4booleanobject.cpp index f8edfb7850..662ec64efb 100644 --- a/src/qml/jsruntime/qv4booleanobject.cpp +++ b/src/qml/jsruntime/qv4booleanobject.cpp @@ -43,13 +43,13 @@ using namespace QV4; -DEFINE_MANAGED_VTABLE(BooleanCtor); -DEFINE_MANAGED_VTABLE(BooleanObject); +DEFINE_OBJECT_VTABLE(BooleanCtor); +DEFINE_OBJECT_VTABLE(BooleanObject); BooleanCtor::BooleanCtor(ExecutionContext *scope) : FunctionObject(scope, QStringLiteral("Boolean")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue BooleanCtor::construct(Managed *m, CallData *callData) diff --git a/src/qml/jsruntime/qv4booleanobject_p.h b/src/qml/jsruntime/qv4booleanobject_p.h index 8d6adc0fb2..617f7f6b01 100644 --- a/src/qml/jsruntime/qv4booleanobject_p.h +++ b/src/qml/jsruntime/qv4booleanobject_p.h @@ -51,7 +51,7 @@ namespace QV4 { struct BooleanCtor: FunctionObject { - Q_MANAGED + V4_OBJECT BooleanCtor(ExecutionContext *scope); static ReturnedValue construct(Managed *, CallData *callData); diff --git a/src/qml/jsruntime/qv4context.cpp b/src/qml/jsruntime/qv4context.cpp index c2369daf83..d17a6cc09c 100644 --- a/src/qml/jsruntime/qv4context.cpp +++ b/src/qml/jsruntime/qv4context.cpp @@ -63,22 +63,7 @@ const ManagedVTable ExecutionContext::static_vtbl = "ExecutionContext", destroy, markObjects, - call, - construct, - 0 /*collectDeletables*/, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - isEqualTo, - 0, - 0 + isEqualTo }; CallContext *ExecutionContext::newCallContext(FunctionObject *function, CallData *callData) diff --git a/src/qml/jsruntime/qv4context_p.h b/src/qml/jsruntime/qv4context_p.h index a0930a577e..b794c28582 100644 --- a/src/qml/jsruntime/qv4context_p.h +++ b/src/qml/jsruntime/qv4context_p.h @@ -69,7 +69,7 @@ struct WithContext; struct Q_QML_EXPORT ExecutionContext : public Managed { - Q_MANAGED + V4_MANAGED Q_MANAGED_TYPE(ExecutionContext) enum { IsExecutionContext = true diff --git a/src/qml/jsruntime/qv4dateobject.cpp b/src/qml/jsruntime/qv4dateobject.cpp index 2b6aa21ac2..a9ef29618c 100644 --- a/src/qml/jsruntime/qv4dateobject.cpp +++ b/src/qml/jsruntime/qv4dateobject.cpp @@ -641,12 +641,12 @@ static double getLocalTZA() #endif } -DEFINE_MANAGED_VTABLE(DateObject); +DEFINE_OBJECT_VTABLE(DateObject); DateObject::DateObject(ExecutionEngine *engine, const QDateTime &date) : Object(engine->dateClass) { - setVTable(&static_vtbl); + setVTable(staticVTable()); value.setDouble(date.isValid() ? date.toMSecsSinceEpoch() : qSNaN()); } @@ -655,12 +655,12 @@ QDateTime DateObject::toQDateTime() const return ToDateTime(value.asDouble(), Qt::LocalTime); } -DEFINE_MANAGED_VTABLE(DateCtor); +DEFINE_OBJECT_VTABLE(DateCtor); DateCtor::DateCtor(ExecutionContext *scope) : FunctionObject(scope, QStringLiteral("Date")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue DateCtor::construct(Managed *m, CallData *callData) diff --git a/src/qml/jsruntime/qv4dateobject_p.h b/src/qml/jsruntime/qv4dateobject_p.h index 244553b1d4..ad8dec87c9 100644 --- a/src/qml/jsruntime/qv4dateobject_p.h +++ b/src/qml/jsruntime/qv4dateobject_p.h @@ -52,7 +52,7 @@ class QDateTime; namespace QV4 { struct DateObject: Object { - Q_MANAGED + V4_OBJECT Q_MANAGED_TYPE(DateObject) SafeValue value; DateObject(ExecutionEngine *engine, const ValueRef date): Object(engine->dateClass) { @@ -64,14 +64,14 @@ struct DateObject: Object { protected: DateObject(InternalClass *ic): Object(ic) { - Q_ASSERT(internalClass->vtable == &static_vtbl); + Q_ASSERT(internalClass->vtable == staticVTable()); value = Primitive::fromDouble(qSNaN()); } }; struct DateCtor: FunctionObject { - Q_MANAGED + V4_OBJECT DateCtor(ExecutionContext *scope); static ReturnedValue construct(Managed *, CallData *callData); diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp index 5de8e0de44..995c711a02 100644 --- a/src/qml/jsruntime/qv4engine.cpp +++ b/src/qml/jsruntime/qv4engine.cpp @@ -202,9 +202,9 @@ ExecutionEngine::ExecutionEngine(QQmlJS::EvalISelFactory *factory) identifierTable = new IdentifierTable(this); emptyClass = new (classPool.allocate(sizeof(InternalClass))) InternalClass(this); - executionContextClass = InternalClass::create(this, &ExecutionContext::static_vtbl, 0); - stringClass = InternalClass::create(this, &String::static_vtbl, 0); - regExpValueClass = InternalClass::create(this, &RegExp::static_vtbl, 0); + executionContextClass = InternalClass::create(this, ExecutionContext::staticVTable(), 0); + stringClass = InternalClass::create(this, String::staticVTable(), 0); + regExpValueClass = InternalClass::create(this, RegExp::staticVTable(), 0); id_undefined = newIdentifier(QStringLiteral("undefined")); id_null = newIdentifier(QStringLiteral("null")); @@ -237,69 +237,69 @@ ExecutionEngine::ExecutionEngine(QQmlJS::EvalISelFactory *factory) id_toString = newIdentifier(QStringLiteral("toString")); id_valueOf = newIdentifier(QStringLiteral("valueOf")); - ObjectPrototype *objectPrototype = new (memoryManager) ObjectPrototype(InternalClass::create(this, &ObjectPrototype::static_vtbl, 0)); - objectClass = InternalClass::create(this, &Object::static_vtbl, objectPrototype); - Q_ASSERT(objectClass->vtable == &Object::static_vtbl); + ObjectPrototype *objectPrototype = new (memoryManager) ObjectPrototype(InternalClass::create(this, ObjectPrototype::staticVTable(), 0)); + objectClass = InternalClass::create(this, Object::staticVTable(), objectPrototype); + Q_ASSERT(objectClass->vtable == Object::staticVTable()); - arrayClass = InternalClass::create(this, &ArrayObject::static_vtbl, objectPrototype); + arrayClass = InternalClass::create(this, ArrayObject::staticVTable(), objectPrototype); arrayClass = arrayClass->addMember(id_length, Attr_NotConfigurable|Attr_NotEnumerable); ArrayPrototype *arrayPrototype = new (memoryManager) ArrayPrototype(arrayClass); arrayClass = arrayClass->changePrototype(arrayPrototype); - InternalClass *argsClass = InternalClass::create(this, &ArgumentsObject::static_vtbl, objectPrototype); + InternalClass *argsClass = InternalClass::create(this, ArgumentsObject::staticVTable(), objectPrototype); argsClass = argsClass->addMember(id_length, Attr_NotEnumerable); argumentsObjectClass = argsClass->addMember(id_callee, Attr_Data|Attr_NotEnumerable); strictArgumentsObjectClass = argsClass->addMember(id_callee, Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable); strictArgumentsObjectClass = strictArgumentsObjectClass->addMember(id_caller, Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable); - Q_ASSERT(argumentsObjectClass->vtable == &ArgumentsObject::static_vtbl); - Q_ASSERT(strictArgumentsObjectClass->vtable == &ArgumentsObject::static_vtbl); + Q_ASSERT(argumentsObjectClass->vtable == ArgumentsObject::staticVTable()); + Q_ASSERT(strictArgumentsObjectClass->vtable == ArgumentsObject::staticVTable()); initRootContext(); - StringPrototype *stringPrototype = new (memoryManager) StringPrototype(InternalClass::create(this, &StringPrototype::static_vtbl, objectPrototype)); - stringObjectClass = InternalClass::create(this, &String::static_vtbl, stringPrototype); + StringPrototype *stringPrototype = new (memoryManager) StringPrototype(InternalClass::create(this, StringPrototype::staticVTable(), objectPrototype)); + stringObjectClass = InternalClass::create(this, String::staticVTable(), stringPrototype); - NumberPrototype *numberPrototype = new (memoryManager) NumberPrototype(InternalClass::create(this, &NumberPrototype::static_vtbl, objectPrototype)); - numberClass = InternalClass::create(this, &NumberObject::static_vtbl, numberPrototype); + NumberPrototype *numberPrototype = new (memoryManager) NumberPrototype(InternalClass::create(this, NumberPrototype::staticVTable(), objectPrototype)); + numberClass = InternalClass::create(this, NumberObject::staticVTable(), numberPrototype); - BooleanPrototype *booleanPrototype = new (memoryManager) BooleanPrototype(InternalClass::create(this, &BooleanPrototype::static_vtbl, objectPrototype)); - booleanClass = InternalClass::create(this, &BooleanObject::static_vtbl, booleanPrototype); + BooleanPrototype *booleanPrototype = new (memoryManager) BooleanPrototype(InternalClass::create(this, BooleanPrototype::staticVTable(), objectPrototype)); + booleanClass = InternalClass::create(this, BooleanObject::staticVTable(), booleanPrototype); - DatePrototype *datePrototype = new (memoryManager) DatePrototype(InternalClass::create(this, &DatePrototype::static_vtbl, objectPrototype)); - dateClass = InternalClass::create(this, &DateObject::static_vtbl, datePrototype); + DatePrototype *datePrototype = new (memoryManager) DatePrototype(InternalClass::create(this, DatePrototype::staticVTable(), objectPrototype)); + dateClass = InternalClass::create(this, DateObject::staticVTable(), datePrototype); - FunctionPrototype *functionPrototype = new (memoryManager) FunctionPrototype(InternalClass::create(this, &FunctionPrototype::static_vtbl, objectPrototype)); - functionClass = InternalClass::create(this, &FunctionObject::static_vtbl, functionPrototype); + FunctionPrototype *functionPrototype = new (memoryManager) FunctionPrototype(InternalClass::create(this, FunctionPrototype::staticVTable(), objectPrototype)); + functionClass = InternalClass::create(this, FunctionObject::staticVTable(), functionPrototype); uint index; functionWithProtoClass = functionClass->addMember(id_prototype, Attr_NotEnumerable|Attr_NotConfigurable, &index); Q_ASSERT(index == FunctionObject::Index_Prototype); protoClass = objectClass->addMember(id_constructor, Attr_NotEnumerable, &index); Q_ASSERT(index == FunctionObject::Index_ProtoConstructor); - RegExpPrototype *regExpPrototype = new (memoryManager) RegExpPrototype(InternalClass::create(this, &RegExpPrototype::static_vtbl, objectPrototype)); - regExpClass = InternalClass::create(this, &RegExpObject::static_vtbl, regExpPrototype); + RegExpPrototype *regExpPrototype = new (memoryManager) RegExpPrototype(InternalClass::create(this, RegExpPrototype::staticVTable(), objectPrototype)); + regExpClass = InternalClass::create(this, RegExpObject::staticVTable(), regExpPrototype); regExpExecArrayClass = arrayClass->addMember(id_index, Attr_Data, &index); Q_ASSERT(index == RegExpObject::Index_ArrayIndex); regExpExecArrayClass = regExpExecArrayClass->addMember(id_input, Attr_Data, &index); Q_ASSERT(index == RegExpObject::Index_ArrayInput); - ErrorPrototype *errorPrototype = new (memoryManager) ErrorPrototype(InternalClass::create(this, &ErrorObject::static_vtbl, objectPrototype)); - errorClass = InternalClass::create(this, &ErrorObject::static_vtbl, errorPrototype); + ErrorPrototype *errorPrototype = new (memoryManager) ErrorPrototype(InternalClass::create(this, ErrorObject::staticVTable(), objectPrototype)); + errorClass = InternalClass::create(this, ErrorObject::staticVTable(), errorPrototype); EvalErrorPrototype *evalErrorPrototype = new (memoryManager) EvalErrorPrototype(errorClass); - evalErrorClass = InternalClass::create(this, &EvalErrorObject::static_vtbl, evalErrorPrototype); + evalErrorClass = InternalClass::create(this, EvalErrorObject::staticVTable(), evalErrorPrototype); RangeErrorPrototype *rangeErrorPrototype = new (memoryManager) RangeErrorPrototype(errorClass); - rangeErrorClass = InternalClass::create(this, &RangeErrorObject::static_vtbl, rangeErrorPrototype); + rangeErrorClass = InternalClass::create(this, RangeErrorObject::staticVTable(), rangeErrorPrototype); ReferenceErrorPrototype *referenceErrorPrototype = new (memoryManager) ReferenceErrorPrototype(errorClass); - referenceErrorClass = InternalClass::create(this, &ReferenceErrorObject::static_vtbl, referenceErrorPrototype); + referenceErrorClass = InternalClass::create(this, ReferenceErrorObject::staticVTable(), referenceErrorPrototype); SyntaxErrorPrototype *syntaxErrorPrototype = new (memoryManager) SyntaxErrorPrototype(errorClass); - syntaxErrorClass = InternalClass::create(this, &SyntaxErrorObject::static_vtbl, syntaxErrorPrototype); + syntaxErrorClass = InternalClass::create(this, SyntaxErrorObject::staticVTable(), syntaxErrorPrototype); TypeErrorPrototype *typeErrorPrototype = new (memoryManager) TypeErrorPrototype(errorClass); - typeErrorClass = InternalClass::create(this, &TypeErrorObject::static_vtbl, typeErrorPrototype); + typeErrorClass = InternalClass::create(this, TypeErrorObject::staticVTable(), typeErrorPrototype); URIErrorPrototype *uRIErrorPrototype = new (memoryManager) URIErrorPrototype(errorClass); - uriErrorClass = InternalClass::create(this, &URIErrorObject::static_vtbl, uRIErrorPrototype); + uriErrorClass = InternalClass::create(this, URIErrorObject::staticVTable(), uRIErrorPrototype); - VariantPrototype *variantPrototype = new (memoryManager) VariantPrototype(InternalClass::create(this, &VariantPrototype::static_vtbl, objectPrototype)); - variantClass = InternalClass::create(this, &VariantObject::static_vtbl, variantPrototype); + VariantPrototype *variantPrototype = new (memoryManager) VariantPrototype(InternalClass::create(this, VariantPrototype::staticVTable(), objectPrototype)); + variantClass = InternalClass::create(this, VariantObject::staticVTable(), variantPrototype); Q_ASSERT(variantClass->prototype == variantPrototype); Q_ASSERT(variantPrototype->internalClass->prototype == objectPrototype); @@ -364,8 +364,8 @@ ExecutionEngine::ExecutionEngine(QQmlJS::EvalISelFactory *factory) globalObject->defineDefaultProperty(QStringLiteral("TypeError"), typeErrorCtor); globalObject->defineDefaultProperty(QStringLiteral("URIError"), uRIErrorCtor); ScopedObject o(scope); - globalObject->defineDefaultProperty(QStringLiteral("Math"), (o = new (memoryManager) MathObject(QV4::InternalClass::create(this, &MathObject::static_vtbl, objectPrototype)))); - globalObject->defineDefaultProperty(QStringLiteral("JSON"), (o = new (memoryManager) JsonObject(QV4::InternalClass::create(this, &JsonObject::static_vtbl, objectPrototype)))); + globalObject->defineDefaultProperty(QStringLiteral("Math"), (o = new (memoryManager) MathObject(QV4::InternalClass::create(this, MathObject::staticVTable(), objectPrototype)))); + globalObject->defineDefaultProperty(QStringLiteral("JSON"), (o = new (memoryManager) JsonObject(QV4::InternalClass::create(this, JsonObject::staticVTable(), objectPrototype)))); globalObject->defineReadonlyProperty(QStringLiteral("undefined"), Primitive::undefinedValue()); globalObject->defineReadonlyProperty(QStringLiteral("NaN"), Primitive::fromDouble(std::numeric_limits<double>::quiet_NaN())); diff --git a/src/qml/jsruntime/qv4errorobject.cpp b/src/qml/jsruntime/qv4errorobject.cpp index f5d21b2f30..29615e8ec2 100644 --- a/src/qml/jsruntime/qv4errorobject.cpp +++ b/src/qml/jsruntime/qv4errorobject.cpp @@ -191,9 +191,9 @@ void ErrorObject::markObjects(Managed *that, ExecutionEngine *e) Object::markObjects(that, e); } -DEFINE_MANAGED_VTABLE(ErrorObject); +DEFINE_OBJECT_VTABLE(ErrorObject); -DEFINE_MANAGED_VTABLE(SyntaxErrorObject); +DEFINE_OBJECT_VTABLE(SyntaxErrorObject); SyntaxErrorObject::SyntaxErrorObject(ExecutionEngine *engine, const ValueRef msg) : ErrorObject(engine->syntaxErrorClass, msg, SyntaxError) @@ -250,24 +250,24 @@ URIErrorObject::URIErrorObject(ExecutionEngine *engine, const ValueRef message) { } -DEFINE_MANAGED_VTABLE(ErrorCtor); -DEFINE_MANAGED_VTABLE(EvalErrorCtor); -DEFINE_MANAGED_VTABLE(RangeErrorCtor); -DEFINE_MANAGED_VTABLE(ReferenceErrorCtor); -DEFINE_MANAGED_VTABLE(SyntaxErrorCtor); -DEFINE_MANAGED_VTABLE(TypeErrorCtor); -DEFINE_MANAGED_VTABLE(URIErrorCtor); +DEFINE_OBJECT_VTABLE(ErrorCtor); +DEFINE_OBJECT_VTABLE(EvalErrorCtor); +DEFINE_OBJECT_VTABLE(RangeErrorCtor); +DEFINE_OBJECT_VTABLE(ReferenceErrorCtor); +DEFINE_OBJECT_VTABLE(SyntaxErrorCtor); +DEFINE_OBJECT_VTABLE(TypeErrorCtor); +DEFINE_OBJECT_VTABLE(URIErrorCtor); ErrorCtor::ErrorCtor(ExecutionContext *scope) : FunctionObject(scope, QStringLiteral("Error")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ErrorCtor::ErrorCtor(ExecutionContext *scope, const QString &name) : FunctionObject(scope, name) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue ErrorCtor::construct(Managed *m, CallData *callData) @@ -279,13 +279,13 @@ ReturnedValue ErrorCtor::construct(Managed *m, CallData *callData) ReturnedValue ErrorCtor::call(Managed *that, CallData *callData) { - return that->construct(callData); + return static_cast<Object *>(that)->construct(callData); } EvalErrorCtor::EvalErrorCtor(ExecutionContext *scope) : ErrorCtor(scope, QStringLiteral("EvalError")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue EvalErrorCtor::construct(Managed *m, CallData *callData) @@ -298,7 +298,7 @@ ReturnedValue EvalErrorCtor::construct(Managed *m, CallData *callData) RangeErrorCtor::RangeErrorCtor(ExecutionContext *scope) : ErrorCtor(scope, QStringLiteral("RangeError")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue RangeErrorCtor::construct(Managed *m, CallData *callData) @@ -311,7 +311,7 @@ ReturnedValue RangeErrorCtor::construct(Managed *m, CallData *callData) ReferenceErrorCtor::ReferenceErrorCtor(ExecutionContext *scope) : ErrorCtor(scope, QStringLiteral("ReferenceError")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue ReferenceErrorCtor::construct(Managed *m, CallData *callData) @@ -324,7 +324,7 @@ ReturnedValue ReferenceErrorCtor::construct(Managed *m, CallData *callData) SyntaxErrorCtor::SyntaxErrorCtor(ExecutionContext *scope) : ErrorCtor(scope, QStringLiteral("SyntaxError")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue SyntaxErrorCtor::construct(Managed *m, CallData *callData) @@ -337,7 +337,7 @@ ReturnedValue SyntaxErrorCtor::construct(Managed *m, CallData *callData) TypeErrorCtor::TypeErrorCtor(ExecutionContext *scope) : ErrorCtor(scope, QStringLiteral("TypeError")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue TypeErrorCtor::construct(Managed *m, CallData *callData) @@ -350,7 +350,7 @@ ReturnedValue TypeErrorCtor::construct(Managed *m, CallData *callData) URIErrorCtor::URIErrorCtor(ExecutionContext *scope) : ErrorCtor(scope, QStringLiteral("URIError")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue URIErrorCtor::construct(Managed *m, CallData *callData) diff --git a/src/qml/jsruntime/qv4errorobject_p.h b/src/qml/jsruntime/qv4errorobject_p.h index 560b003062..c44cc5cdb2 100644 --- a/src/qml/jsruntime/qv4errorobject_p.h +++ b/src/qml/jsruntime/qv4errorobject_p.h @@ -51,7 +51,7 @@ namespace QV4 { struct SyntaxErrorObject; struct ErrorObject: Object { - Q_MANAGED + V4_OBJECT Q_MANAGED_TYPE(ErrorObject) enum { IsErrorObject = true @@ -103,7 +103,7 @@ struct ReferenceErrorObject: ErrorObject { }; struct SyntaxErrorObject: ErrorObject { - Q_MANAGED + V4_OBJECT SyntaxErrorObject(ExecutionEngine *engine, const ValueRef msg); SyntaxErrorObject(ExecutionEngine *engine, const QString &msg, const QString &fileName, int lineNumber, int columnNumber); }; @@ -119,7 +119,7 @@ struct URIErrorObject: ErrorObject { struct ErrorCtor: FunctionObject { - Q_MANAGED + V4_OBJECT ErrorCtor(ExecutionContext *scope); ErrorCtor(ExecutionContext *scope, const QString &name); @@ -129,7 +129,7 @@ struct ErrorCtor: FunctionObject struct EvalErrorCtor: ErrorCtor { - Q_MANAGED + V4_OBJECT EvalErrorCtor(ExecutionContext *scope); static ReturnedValue construct(Managed *m, CallData *callData); @@ -137,7 +137,7 @@ struct EvalErrorCtor: ErrorCtor struct RangeErrorCtor: ErrorCtor { - Q_MANAGED + V4_OBJECT RangeErrorCtor(ExecutionContext *scope); static ReturnedValue construct(Managed *m, CallData *callData); @@ -145,7 +145,7 @@ struct RangeErrorCtor: ErrorCtor struct ReferenceErrorCtor: ErrorCtor { - Q_MANAGED + V4_OBJECT ReferenceErrorCtor(ExecutionContext *scope); static ReturnedValue construct(Managed *m, CallData *callData); @@ -153,7 +153,7 @@ struct ReferenceErrorCtor: ErrorCtor struct SyntaxErrorCtor: ErrorCtor { - Q_MANAGED + V4_OBJECT SyntaxErrorCtor(ExecutionContext *scope); static ReturnedValue construct(Managed *m, CallData *callData); @@ -161,7 +161,7 @@ struct SyntaxErrorCtor: ErrorCtor struct TypeErrorCtor: ErrorCtor { - Q_MANAGED + V4_OBJECT TypeErrorCtor(ExecutionContext *scope); static ReturnedValue construct(Managed *m, CallData *callData); @@ -169,7 +169,7 @@ struct TypeErrorCtor: ErrorCtor struct URIErrorCtor: ErrorCtor { - Q_MANAGED + V4_OBJECT URIErrorCtor(ExecutionContext *scope); static ReturnedValue construct(Managed *m, CallData *callData); @@ -188,37 +188,37 @@ struct ErrorPrototype: ErrorObject struct EvalErrorPrototype: ErrorObject { - EvalErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(&static_vtbl); } + EvalErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(staticVTable()); } void init(ExecutionEngine *engine, ObjectRef ctor) { ErrorPrototype::init(engine, ctor, this); } }; struct RangeErrorPrototype: ErrorObject { - RangeErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(&static_vtbl); } + RangeErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(staticVTable()); } void init(ExecutionEngine *engine, ObjectRef ctor) { ErrorPrototype::init(engine, ctor, this); } }; struct ReferenceErrorPrototype: ErrorObject { - ReferenceErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(&static_vtbl); } + ReferenceErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(staticVTable()); } void init(ExecutionEngine *engine, ObjectRef ctor) { ErrorPrototype::init(engine, ctor, this); } }; struct SyntaxErrorPrototype: ErrorObject { - SyntaxErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(&static_vtbl); } + SyntaxErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(staticVTable()); } void init(ExecutionEngine *engine, ObjectRef ctor) { ErrorPrototype::init(engine, ctor, this); } }; struct TypeErrorPrototype: ErrorObject { - TypeErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(&static_vtbl); } + TypeErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(staticVTable()); } void init(ExecutionEngine *engine, ObjectRef ctor) { ErrorPrototype::init(engine, ctor, this); } }; struct URIErrorPrototype: ErrorObject { - URIErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(&static_vtbl); } + URIErrorPrototype(InternalClass *ic): ErrorObject(ic) { setVTable(staticVTable()); } void init(ExecutionEngine *engine, ObjectRef ctor) { ErrorPrototype::init(engine, ctor, this); } }; diff --git a/src/qml/jsruntime/qv4functionobject.cpp b/src/qml/jsruntime/qv4functionobject.cpp index 858d625725..a6ed03cea8 100644 --- a/src/qml/jsruntime/qv4functionobject.cpp +++ b/src/qml/jsruntime/qv4functionobject.cpp @@ -71,7 +71,7 @@ using namespace QV4; -DEFINE_MANAGED_VTABLE(FunctionObject); +DEFINE_OBJECT_VTABLE(FunctionObject); FunctionObject::FunctionObject(ExecutionContext *scope, const StringRef name, bool createProto) : Object(createProto ? scope->engine->functionWithProtoClass : scope->engine->functionClass) @@ -222,19 +222,19 @@ InternalClass *FunctionObject::internalClassForConstructor() Scope scope(internalClass->engine); ScopedObject p(scope, proto); if (p) - classForConstructor = InternalClass::create(scope.engine, &Object::static_vtbl, p.getPointer()); + classForConstructor = InternalClass::create(scope.engine, Object::staticVTable(), p.getPointer()); else classForConstructor = scope.engine->objectClass; return classForConstructor; } -DEFINE_MANAGED_VTABLE(FunctionCtor); +DEFINE_OBJECT_VTABLE(FunctionCtor); FunctionCtor::FunctionCtor(ExecutionContext *scope) : FunctionObject(scope, QStringLiteral("Function")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } // 15.3.2 @@ -394,12 +394,12 @@ ReturnedValue FunctionPrototype::method_bind(CallContext *ctx) return ctx->engine->newBoundFunction(ctx->engine->rootContext, target, boundThis, boundArgs)->asReturnedValue(); } -DEFINE_MANAGED_VTABLE(ScriptFunction); +DEFINE_OBJECT_VTABLE(ScriptFunction); ScriptFunction::ScriptFunction(ExecutionContext *scope, Function *function) : FunctionObject(scope, function->name, true) { - setVTable(&static_vtbl); + setVTable(staticVTable()); Scope s(scope); ScopedValue protectThis(s, this); @@ -476,12 +476,12 @@ ReturnedValue ScriptFunction::call(Managed *that, CallData *callData) return f->function->code(ctx, f->function->codeData); } -DEFINE_MANAGED_VTABLE(SimpleScriptFunction); +DEFINE_OBJECT_VTABLE(SimpleScriptFunction); SimpleScriptFunction::SimpleScriptFunction(ExecutionContext *scope, Function *function) : FunctionObject(scope, function->name, true) { - setVTable(&static_vtbl); + setVTable(staticVTable()); Scope s(scope); ScopedValue protectThis(s, this); @@ -587,13 +587,13 @@ ReturnedValue SimpleScriptFunction::call(Managed *that, CallData *callData) -DEFINE_MANAGED_VTABLE(BuiltinFunction); +DEFINE_OBJECT_VTABLE(BuiltinFunction); BuiltinFunction::BuiltinFunction(ExecutionContext *scope, const StringRef name, ReturnedValue (*code)(CallContext *)) : FunctionObject(scope, name) , code(code) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue BuiltinFunction::construct(Managed *f, CallData *) @@ -639,16 +639,16 @@ ReturnedValue IndexedBuiltinFunction::call(Managed *that, CallData *callData) return f->code(&ctx, f->index); } -DEFINE_MANAGED_VTABLE(IndexedBuiltinFunction); +DEFINE_OBJECT_VTABLE(IndexedBuiltinFunction); -DEFINE_MANAGED_VTABLE(BoundFunction); +DEFINE_OBJECT_VTABLE(BoundFunction); BoundFunction::BoundFunction(ExecutionContext *scope, FunctionObjectRef target, const ValueRef boundThis, const QVector<SafeValue> &boundArgs) : FunctionObject(scope, QStringLiteral("__bound function__")) , target(target) , boundArgs(boundArgs) { - setVTable(&static_vtbl); + setVTable(staticVTable()); subtype = FunctionObject::BoundFunction; this->boundThis = boundThis; diff --git a/src/qml/jsruntime/qv4functionobject_p.h b/src/qml/jsruntime/qv4functionobject_p.h index 0168e13a6f..64a1dc92d2 100644 --- a/src/qml/jsruntime/qv4functionobject_p.h +++ b/src/qml/jsruntime/qv4functionobject_p.h @@ -93,7 +93,7 @@ struct InternalClass; struct Lookup; struct Q_QML_EXPORT FunctionObject: Object { - Q_MANAGED + V4_OBJECT Q_MANAGED_TYPE(FunctionObject) enum { IsFunctionObject = true @@ -128,14 +128,10 @@ struct Q_QML_EXPORT FunctionObject: Object { ReturnedValue newInstance(); + using Object::construct; + using Object::call; static ReturnedValue construct(Managed *that, CallData *); static ReturnedValue call(Managed *that, CallData *d); - inline ReturnedValue construct(CallData *callData) { - return internalClass->vtable->construct(this, callData); - } - inline ReturnedValue call(CallData *callData) { - return internalClass->vtable->call(this, callData); - } static FunctionObject *cast(const Value &v) { return v.asFunctionObject(); @@ -161,7 +157,7 @@ inline FunctionObject *value_cast(const Value &v) { struct FunctionCtor: FunctionObject { - Q_MANAGED + V4_OBJECT FunctionCtor(ExecutionContext *scope); static ReturnedValue construct(Managed *that, CallData *callData); @@ -180,7 +176,7 @@ struct FunctionPrototype: FunctionObject }; struct BuiltinFunction: FunctionObject { - Q_MANAGED + V4_OBJECT ReturnedValue (*code)(CallContext *); BuiltinFunction(ExecutionContext *scope, const StringRef name, ReturnedValue (*code)(CallContext *)); @@ -191,7 +187,7 @@ struct BuiltinFunction: FunctionObject { struct IndexedBuiltinFunction: FunctionObject { - Q_MANAGED + V4_OBJECT ReturnedValue (*code)(CallContext *ctx, uint index); uint index; @@ -201,7 +197,7 @@ struct IndexedBuiltinFunction: FunctionObject , code(code) , index(index) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } static ReturnedValue construct(Managed *m, CallData *) @@ -214,7 +210,7 @@ struct IndexedBuiltinFunction: FunctionObject struct ScriptFunction: FunctionObject { - Q_MANAGED + V4_OBJECT ScriptFunction(ExecutionContext *scope, Function *function); static ReturnedValue construct(Managed *, CallData *callData); @@ -222,7 +218,7 @@ struct ScriptFunction: FunctionObject { }; struct SimpleScriptFunction: FunctionObject { - Q_MANAGED + V4_OBJECT SimpleScriptFunction(ExecutionContext *scope, Function *function); static ReturnedValue construct(Managed *, CallData *callData); @@ -230,7 +226,7 @@ struct SimpleScriptFunction: FunctionObject { }; struct BoundFunction: FunctionObject { - Q_MANAGED + V4_OBJECT FunctionObject *target; SafeValue boundThis; QVector<SafeValue> boundArgs; diff --git a/src/qml/jsruntime/qv4globalobject.cpp b/src/qml/jsruntime/qv4globalobject.cpp index fa8af8ed5d..224d383614 100644 --- a/src/qml/jsruntime/qv4globalobject.cpp +++ b/src/qml/jsruntime/qv4globalobject.cpp @@ -344,12 +344,12 @@ static QString decode(const QString &input, DecodeMode decodeMode, bool *ok) return QString(); } -DEFINE_MANAGED_VTABLE(EvalFunction); +DEFINE_OBJECT_VTABLE(EvalFunction); EvalFunction::EvalFunction(ExecutionContext *scope) : FunctionObject(scope, scope->engine->id_eval) { - setVTable(&static_vtbl); + setVTable(staticVTable()); defineReadonlyProperty(scope->engine->id_length, Primitive::fromInt32(1)); } diff --git a/src/qml/jsruntime/qv4globalobject_p.h b/src/qml/jsruntime/qv4globalobject_p.h index bf529a465d..63823acc19 100644 --- a/src/qml/jsruntime/qv4globalobject_p.h +++ b/src/qml/jsruntime/qv4globalobject_p.h @@ -50,12 +50,12 @@ namespace QV4 { struct Q_QML_EXPORT EvalFunction : FunctionObject { - Q_MANAGED + V4_OBJECT EvalFunction(ExecutionContext *scope); ReturnedValue evalCall(CallData *callData, bool directCall); - using Managed::construct; + using Object::construct; static ReturnedValue call(Managed *that, CallData *callData); }; diff --git a/src/qml/jsruntime/qv4jsonobject.cpp b/src/qml/jsruntime/qv4jsonobject.cpp index facc2da781..0614346cff 100644 --- a/src/qml/jsruntime/qv4jsonobject.cpp +++ b/src/qml/jsruntime/qv4jsonobject.cpp @@ -66,7 +66,7 @@ static int indent = 0; #endif -DEFINE_MANAGED_VTABLE(JsonObject); +DEFINE_OBJECT_VTABLE(JsonObject); class JsonParser { diff --git a/src/qml/jsruntime/qv4jsonobject_p.h b/src/qml/jsruntime/qv4jsonobject_p.h index b37b28b078..34a4f4dd4b 100644 --- a/src/qml/jsruntime/qv4jsonobject_p.h +++ b/src/qml/jsruntime/qv4jsonobject_p.h @@ -52,7 +52,7 @@ namespace QV4 { struct JsonObject : Object { Q_MANAGED_TYPE(JsonObject) - Q_MANAGED + V4_OBJECT private: typedef QSet<QV4::Object *> V4ObjectSet; public: diff --git a/src/qml/jsruntime/qv4managed.cpp b/src/qml/jsruntime/qv4managed.cpp index ec349702d6..671ac5d362 100644 --- a/src/qml/jsruntime/qv4managed.cpp +++ b/src/qml/jsruntime/qv4managed.cpp @@ -57,22 +57,7 @@ const ManagedVTable Managed::static_vtbl = "Managed", destroy, 0 /*markObjects*/, - call, - construct, - 0 /*collectDeletables*/, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - isEqualTo, - 0, - 0 + isEqualTo }; @@ -195,67 +180,7 @@ void Managed::setVTable(const ManagedVTable *vt) internalClass = internalClass->changeVTable(vt); } -ReturnedValue Managed::construct(Managed *m, CallData *) -{ - return m->engine()->currentContext()->throwTypeError(); -} - -ReturnedValue Managed::call(Managed *m, CallData *) -{ - return m->engine()->currentContext()->throwTypeError(); -} - -ReturnedValue Managed::getLookup(Managed *m, Lookup *) -{ - return m->engine()->currentContext()->throwTypeError(); -} - -void Managed::setLookup(Managed *m, Lookup *, const ValueRef) -{ - m->engine()->currentContext()->throwTypeError(); -} - bool Managed::isEqualTo(Managed *, Managed *) { return false; } - -ReturnedValue Managed::get(const StringRef name, bool *hasProperty) -{ - return internalClass->vtable->get(this, name, hasProperty); -} - -ReturnedValue Managed::getIndexed(uint index, bool *hasProperty) -{ - return internalClass->vtable->getIndexed(this, index, hasProperty); -} - -void Managed::put(const StringRef name, const ValueRef value) -{ - internalClass->vtable->put(this, name, value); -} - -void Managed::setLookup(Lookup *l, const ValueRef v) -{ - internalClass->vtable->setLookup(this, l, v); -} - -void Managed::putIndexed(uint index, const ValueRef value) -{ - internalClass->vtable->putIndexed(this, index, value); -} - -PropertyAttributes Managed::query(StringRef name) const -{ - return internalClass->vtable->query(this, name); -} - -bool Managed::deleteProperty(const StringRef name) -{ - return internalClass->vtable->deleteProperty(this, name); -} - -void Managed::advanceIterator(ObjectIterator *it, StringRef name, uint *index, Property *p, PropertyAttributes *attributes) -{ - internalClass->vtable->advanceIterator(this, it, name, index, p, attributes); -} diff --git a/src/qml/jsruntime/qv4managed_p.h b/src/qml/jsruntime/qv4managed_p.h index 6c154c80b5..e97217b02a 100644 --- a/src/qml/jsruntime/qv4managed_p.h +++ b/src/qml/jsruntime/qv4managed_p.h @@ -62,10 +62,19 @@ inline int qYouForgotTheQ_MANAGED_Macro(T, T) { return 0; } template <typename T1, typename T2> inline void qYouForgotTheQ_MANAGED_Macro(T1, T2) {} -#define Q_MANAGED \ +#define V4_MANAGED \ public: \ Q_MANAGED_CHECK \ 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); } \ + +#define V4_OBJECT \ + public: \ + Q_MANAGED_CHECK \ + 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); } \ @@ -93,6 +102,12 @@ struct ManagedVTable const char *className; void (*destroy)(Managed *); void (*markObjects)(Managed *, ExecutionEngine *e); + bool (*isEqualTo)(Managed *m, Managed *other); +}; + +struct ObjectVTable +{ + ManagedVTable managedVTable; ReturnedValue (*call)(Managed *, CallData *data); ReturnedValue (*construct)(Managed *, CallData *data); void (*collectDeletables)(Managed *, GCDeletable **deletable); @@ -106,14 +121,13 @@ struct ManagedVTable bool (*deleteIndexedProperty)(Managed *m, uint index); ReturnedValue (*getLookup)(Managed *m, Lookup *l); void (*setLookup)(Managed *m, Lookup *l, const ValueRef v); - bool (*isEqualTo)(Managed *m, Managed *other); uint (*getLength)(const Managed *m); void (*advanceIterator)(Managed *m, ObjectIterator *it, StringRef name, uint *index, Property *p, PropertyAttributes *attributes); }; #define DEFINE_MANAGED_VTABLE(classname) \ const QV4::ManagedVTable classname::static_vtbl = \ -{ \ +{ \ classname::IsExecutionContext, \ classname::IsString, \ classname::IsObject, \ @@ -124,6 +138,26 @@ const QV4::ManagedVTable classname::static_vtbl = \ #classname, \ destroy, \ markObjects, \ + isEqualTo, \ +} + + +#define DEFINE_OBJECT_VTABLE(classname) \ +const QV4::ObjectVTable classname::static_vtbl = \ +{ \ + { \ + classname::IsExecutionContext, \ + classname::IsString, \ + classname::IsObject, \ + classname::IsFunctionObject, \ + classname::IsErrorObject, \ + 0, \ + classname::MyType, \ + #classname, \ + destroy, \ + markObjects, \ + isEqualTo, \ + }, \ call, \ construct, \ 0, \ @@ -137,24 +171,26 @@ const QV4::ManagedVTable classname::static_vtbl = \ deleteIndexedProperty, \ getLookup, \ setLookup, \ - isEqualTo, \ getLength, \ advanceIterator \ } #define DEFINE_MANAGED_VTABLE_WITH_NAME(classname, name) \ -const QV4::ManagedVTable classname::static_vtbl = \ +const QV4::ObjectVTable classname::static_vtbl = \ { \ - classname::IsExecutionContext, \ - classname::IsString, \ - classname::IsObject, \ - classname::IsFunctionObject, \ - classname::IsErrorObject, \ - 0, \ - classname::MyType, \ - #name, \ - destroy, \ - markObjects, \ + { \ + classname::IsExecutionContext, \ + classname::IsString, \ + classname::IsObject, \ + classname::IsFunctionObject, \ + classname::IsErrorObject, \ + 0, \ + classname::MyType, \ + #name, \ + destroy, \ + markObjects, \ + isEqualTo, \ + }, \ call, \ construct, \ 0, \ @@ -168,24 +204,26 @@ const QV4::ManagedVTable classname::static_vtbl = \ deleteIndexedProperty, \ getLookup, \ setLookup, \ - isEqualTo, \ getLength, \ advanceIterator \ } #define DEFINE_MANAGED_VTABLE_WITH_DELETABLES(classname) \ -const QV4::ManagedVTable classname::static_vtbl = \ +const QV4::ObjectVTable classname::static_vtbl = \ { \ - classname::IsExecutionContext, \ - classname::IsString, \ - classname::IsObject, \ - classname::IsFunctionObject, \ - classname::IsErrorObject, \ - 0, \ - classname::MyType, \ - #classname, \ - destroy, \ - markObjects, \ + { \ + classname::IsExecutionContext, \ + classname::IsString, \ + classname::IsObject, \ + classname::IsFunctionObject, \ + classname::IsErrorObject, \ + 0, \ + classname::MyType, \ + #classname, \ + destroy, \ + markObjects, \ + isEqualTo, \ + }, \ call, \ construct, \ collectDeletables, \ @@ -199,14 +237,13 @@ const QV4::ManagedVTable classname::static_vtbl = \ deleteIndexedProperty, \ getLookup, \ setLookup, \ - isEqualTo, \ getLength, \ advanceIterator \ } struct Q_QML_EXPORT Managed { - Q_MANAGED + V4_MANAGED enum { IsExecutionContext = false, IsString = false, @@ -269,7 +306,7 @@ public: #if !defined(QT_NO_QOBJECT_CHECK) static_cast<T *>(this)->qt_check_for_QMANAGED_macro(static_cast<T *>(this)); #endif - return internalClass->vtable == &T::static_vtbl ? static_cast<T *>(this) : 0; + return internalClass->vtable == T::staticVTable() ? static_cast<T *>(this) : 0; } template <typename T> const T *as() const { @@ -279,7 +316,7 @@ public: #if !defined(QT_NO_QOBJECT_CHECK) static_cast<T *>(this)->qt_check_for_QMANAGED_macro(static_cast<T *>(const_cast<Managed *>(this))); #endif - return internalClass->vtable == &T::static_vtbl ? static_cast<const T *>(this) : 0; + return internalClass->vtable == T::staticVTable() ? static_cast<const T *>(this) : 0; } String *asString() { return internalClass->vtable->isString ? reinterpret_cast<String *>(this) : 0; } @@ -312,35 +349,11 @@ public: void setVTable(const ManagedVTable *vt); - ReturnedValue construct(CallData *d); - ReturnedValue call(CallData *d); - ReturnedValue get(const StringRef name, bool *hasProperty = 0); - ReturnedValue getIndexed(uint index, bool *hasProperty = 0); - void put(const StringRef name, const ValueRef value); - void putIndexed(uint index, const ValueRef value); - PropertyAttributes query(StringRef name) const; - PropertyAttributes queryIndexed(uint index) const - { return internalClass->vtable->queryIndexed(this, index); } - - bool deleteProperty(const StringRef name); - bool deleteIndexedProperty(uint index) - { return internalClass->vtable->deleteIndexedProperty(this, index); } - ReturnedValue getLookup(Lookup *l) - { return internalClass->vtable->getLookup(this, l); } - void setLookup(Lookup *l, const ValueRef v); - bool isEqualTo(Managed *other) { return internalClass->vtable->isEqualTo(this, other); } - uint getLength() const { return internalClass->vtable->getLength(this); } - void advanceIterator(ObjectIterator *it, StringRef name, uint *index, Property *p, PropertyAttributes *attributes); static void destroy(Managed *that) { that->_data = 0; } - static ReturnedValue construct(Managed *m, CallData *d); - static ReturnedValue call(Managed *m, CallData *); - static ReturnedValue getLookup(Managed *m, Lookup *); - static void setLookup(Managed *m, Lookup *l, const ValueRef v); static bool isEqualTo(Managed *m, Managed *other); - static uint getLength(const Managed *) { return 0; } ReturnedValue asReturnedValue() { return Value::fromManaged(this).asReturnedValue(); } @@ -398,13 +411,6 @@ inline FunctionObject *managed_cast(Managed *m) } -inline ReturnedValue Managed::construct(CallData *d) { - return internalClass->vtable->construct(this, d); -} -inline ReturnedValue Managed::call(CallData *d) { - return internalClass->vtable->call(this, d); -} - } diff --git a/src/qml/jsruntime/qv4mathobject.cpp b/src/qml/jsruntime/qv4mathobject.cpp index 6225d6b4ae..16d76e6914 100644 --- a/src/qml/jsruntime/qv4mathobject.cpp +++ b/src/qml/jsruntime/qv4mathobject.cpp @@ -51,7 +51,7 @@ using namespace QV4; -DEFINE_MANAGED_VTABLE(MathObject); +DEFINE_OBJECT_VTABLE(MathObject); static const double qt_PI = 2.0 * ::asin(1.0); diff --git a/src/qml/jsruntime/qv4mathobject_p.h b/src/qml/jsruntime/qv4mathobject_p.h index 45f8e7cd2e..18a80c2ba0 100644 --- a/src/qml/jsruntime/qv4mathobject_p.h +++ b/src/qml/jsruntime/qv4mathobject_p.h @@ -49,7 +49,7 @@ namespace QV4 { struct MathObject: Object { - Q_MANAGED + V4_OBJECT Q_MANAGED_TYPE(MathObject) MathObject(InternalClass *ic); diff --git a/src/qml/jsruntime/qv4mm.cpp b/src/qml/jsruntime/qv4mm.cpp index d55ddead89..0af0fea49a 100644 --- a/src/qml/jsruntime/qv4mm.cpp +++ b/src/qml/jsruntime/qv4mm.cpp @@ -522,8 +522,9 @@ void MemoryManager::sweep(char *chunkStart, std::size_t chunkSize, size_t size, #ifdef V4_USE_VALGRIND VALGRIND_ENABLE_ERROR_REPORTING; #endif - if (m->internalClass->vtable->collectDeletables) - m->internalClass->vtable->collectDeletables(m, deletable); + Object *o = m->asObject(); + if (o && o->vtable()->collectDeletables) + o->vtable()->collectDeletables(m, deletable); m->internalClass->vtable->destroy(m); memset(m, 0, size); diff --git a/src/qml/jsruntime/qv4numberobject.cpp b/src/qml/jsruntime/qv4numberobject.cpp index a363a06242..decbcab7a0 100644 --- a/src/qml/jsruntime/qv4numberobject.cpp +++ b/src/qml/jsruntime/qv4numberobject.cpp @@ -48,13 +48,13 @@ using namespace QV4; -DEFINE_MANAGED_VTABLE(NumberCtor); -DEFINE_MANAGED_VTABLE(NumberObject); +DEFINE_OBJECT_VTABLE(NumberCtor); +DEFINE_OBJECT_VTABLE(NumberObject); NumberCtor::NumberCtor(ExecutionContext *scope) : FunctionObject(scope, QStringLiteral("Number")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue NumberCtor::construct(Managed *m, CallData *callData) diff --git a/src/qml/jsruntime/qv4numberobject_p.h b/src/qml/jsruntime/qv4numberobject_p.h index 1ca3a71249..ccabcf6727 100644 --- a/src/qml/jsruntime/qv4numberobject_p.h +++ b/src/qml/jsruntime/qv4numberobject_p.h @@ -51,7 +51,7 @@ namespace QV4 { struct NumberCtor: FunctionObject { - Q_MANAGED + V4_OBJECT NumberCtor(ExecutionContext *scope); static ReturnedValue construct(Managed *that, CallData *callData); diff --git a/src/qml/jsruntime/qv4object.cpp b/src/qml/jsruntime/qv4object.cpp index 43e0808a24..f45c40e469 100644 --- a/src/qml/jsruntime/qv4object.cpp +++ b/src/qml/jsruntime/qv4object.cpp @@ -67,7 +67,7 @@ using namespace QV4; -DEFINE_MANAGED_VTABLE(Object); +DEFINE_OBJECT_VTABLE(Object); Object::Object(ExecutionEngine *engine) : Managed(engine->objectClass) @@ -408,6 +408,16 @@ bool Object::hasOwnProperty(uint index) const return false; } +ReturnedValue Object::construct(Managed *m, CallData *) +{ + return m->engine()->currentContext()->throwTypeError(); +} + +ReturnedValue Object::call(Managed *m, CallData *) +{ + return m->engine()->currentContext()->throwTypeError(); +} + ReturnedValue Object::get(Managed *m, const StringRef name, bool *hasProperty) { return static_cast<Object *>(m)->internalGet(name, hasProperty); @@ -1122,7 +1132,7 @@ void Object::copyArrayData(Object *other) uint Object::getLength(const Managed *m) { Scope scope(m->engine()); - ScopedValue v(scope, const_cast<Managed *>(m)->get(scope.engine->id_length)); + ScopedValue v(scope, static_cast<Object *>(const_cast<Managed *>(m))->get(scope.engine->id_length)); return v->toUInt32(); } @@ -1196,7 +1206,7 @@ void Object::initSparseArray() } -DEFINE_MANAGED_VTABLE(ArrayObject); +DEFINE_OBJECT_VTABLE(ArrayObject); ArrayObject::ArrayObject(ExecutionEngine *engine, const QStringList &list) : Object(engine->arrayClass) diff --git a/src/qml/jsruntime/qv4object_p.h b/src/qml/jsruntime/qv4object_p.h index 7a2b3bb38e..2f2b7cff49 100644 --- a/src/qml/jsruntime/qv4object_p.h +++ b/src/qml/jsruntime/qv4object_p.h @@ -102,7 +102,7 @@ struct URIErrorPrototype; struct Q_QML_EXPORT Object: Managed { - Q_MANAGED + V4_OBJECT Q_MANAGED_TYPE(Object) enum { IsObject = true @@ -121,6 +121,7 @@ struct Q_QML_EXPORT Object: Managed { Object(InternalClass *internalClass); ~Object(); + const ObjectVTable *vtable() const { return reinterpret_cast<const ObjectVTable *>(internalClass->vtable); } Object *prototype() const { return internalClass->prototype; } bool setPrototype(Object *proto); @@ -231,28 +232,38 @@ public: void ensureMemberIndex(uint idx); inline ReturnedValue get(const StringRef name, bool *hasProperty = 0) - { return internalClass->vtable->get(this, name, hasProperty); } + { return vtable()->get(this, name, hasProperty); } inline ReturnedValue getIndexed(uint idx, bool *hasProperty = 0) - { return internalClass->vtable->getIndexed(this, idx, hasProperty); } + { return vtable()->getIndexed(this, idx, hasProperty); } inline void put(const StringRef name, const ValueRef v) - { internalClass->vtable->put(this, name, v); } + { vtable()->put(this, name, v); } inline void putIndexed(uint idx, const ValueRef v) - { internalClass->vtable->putIndexed(this, idx, v); } - using Managed::get; - using Managed::getIndexed; - using Managed::put; - using Managed::putIndexed; - using Managed::query; - using Managed::queryIndexed; - using Managed::deleteProperty; - using Managed::deleteIndexedProperty; - using Managed::getLookup; - using Managed::setLookup; - using Managed::advanceIterator; - using Managed::getLength; + { vtable()->putIndexed(this, idx, v); } + PropertyAttributes query(StringRef name) const + { return vtable()->query(this, name); } + PropertyAttributes queryIndexed(uint index) const + { return vtable()->queryIndexed(this, index); } + bool deleteProperty(const StringRef name) + { return vtable()->deleteProperty(this, name); } + bool deleteIndexedProperty(uint index) + { return vtable()->deleteIndexedProperty(this, index); } + ReturnedValue getLookup(Lookup *l) + { return vtable()->getLookup(this, l); } + void setLookup(Lookup *l, const ValueRef v) + { vtable()->setLookup(this, l, v); } + void advanceIterator(ObjectIterator *it, StringRef name, uint *index, Property *p, PropertyAttributes *attributes) + { vtable()->advanceIterator(this, it, name, index, p, attributes); } + uint getLength() const { return vtable()->getLength(this); } + + inline ReturnedValue construct(CallData *d) + { return vtable()->construct(this, d); } + inline ReturnedValue call(CallData *d) + { return vtable()->call(this, d); } protected: static void destroy(Managed *that); static void markObjects(Managed *that, ExecutionEngine *e); + static ReturnedValue construct(Managed *m, CallData *); + static ReturnedValue call(Managed *m, CallData *); static ReturnedValue get(Managed *m, const StringRef name, bool *hasProperty); static ReturnedValue getIndexed(Managed *m, uint index, bool *hasProperty); static void put(Managed *m, const StringRef name, const ValueRef value); @@ -279,7 +290,7 @@ private: }; struct BooleanObject: Object { - Q_MANAGED + V4_OBJECT Q_MANAGED_TYPE(BooleanObject) SafeValue value; BooleanObject(ExecutionEngine *engine, const ValueRef val) @@ -289,13 +300,13 @@ struct BooleanObject: Object { protected: BooleanObject(InternalClass *ic) : Object(ic) { - Q_ASSERT(internalClass->vtable == &static_vtbl); + Q_ASSERT(internalClass->vtable == staticVTable()); value = Encode(false); } }; struct NumberObject: Object { - Q_MANAGED + V4_OBJECT Q_MANAGED_TYPE(NumberObject) SafeValue value; NumberObject(ExecutionEngine *engine, const ValueRef val) @@ -305,13 +316,13 @@ struct NumberObject: Object { protected: NumberObject(InternalClass *ic) : Object(ic) { - Q_ASSERT(internalClass->vtable == &static_vtbl); + Q_ASSERT(internalClass->vtable == staticVTable()); value = Encode((int)0); } }; struct ArrayObject: Object { - Q_MANAGED + V4_OBJECT Q_MANAGED_TYPE(ArrayObject) enum { LengthPropertyIndex = 0 @@ -324,7 +335,7 @@ struct ArrayObject: Object { void init(ExecutionEngine *engine); static ReturnedValue getLookup(Managed *m, Lookup *l); - using Managed::getLength; + using Object::getLength; static uint getLength(const Managed *m); QStringList toQStringList() const; diff --git a/src/qml/jsruntime/qv4objectiterator.cpp b/src/qml/jsruntime/qv4objectiterator.cpp index 3efda3f9cb..0e35996710 100644 --- a/src/qml/jsruntime/qv4objectiterator.cpp +++ b/src/qml/jsruntime/qv4objectiterator.cpp @@ -192,7 +192,7 @@ ReturnedValue ObjectIterator::nextPropertyNameAsString() } -DEFINE_MANAGED_VTABLE(ForEachIteratorObject); +DEFINE_OBJECT_VTABLE(ForEachIteratorObject); void ForEachIteratorObject::markObjects(Managed *that, ExecutionEngine *e) { diff --git a/src/qml/jsruntime/qv4objectiterator_p.h b/src/qml/jsruntime/qv4objectiterator_p.h index e95f59e247..08a740fc37 100644 --- a/src/qml/jsruntime/qv4objectiterator_p.h +++ b/src/qml/jsruntime/qv4objectiterator_p.h @@ -83,12 +83,12 @@ struct Q_QML_EXPORT ObjectIterator }; struct ForEachIteratorObject: Object { - Q_MANAGED + V4_OBJECT Q_MANAGED_TYPE(ForeachIteratorObject) ObjectIterator it; ForEachIteratorObject(ExecutionContext *ctx, const ObjectRef o) : Object(ctx->engine), it(workArea, workArea + 1, o, ObjectIterator::EnumerableOnly|ObjectIterator::WithProtoChain) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue nextPropertyName() { return it.nextPropertyNameAsString(); } diff --git a/src/qml/jsruntime/qv4objectproto.cpp b/src/qml/jsruntime/qv4objectproto.cpp index 2eec96ec95..e8623d131d 100644 --- a/src/qml/jsruntime/qv4objectproto.cpp +++ b/src/qml/jsruntime/qv4objectproto.cpp @@ -72,12 +72,12 @@ using namespace QV4; -DEFINE_MANAGED_VTABLE(ObjectCtor); +DEFINE_OBJECT_VTABLE(ObjectCtor); ObjectCtor::ObjectCtor(ExecutionContext *scope) : FunctionObject(scope, QStringLiteral("Object")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue ObjectCtor::construct(Managed *that, CallData *callData) diff --git a/src/qml/jsruntime/qv4objectproto_p.h b/src/qml/jsruntime/qv4objectproto_p.h index 0bd8072db8..2b9974be06 100644 --- a/src/qml/jsruntime/qv4objectproto_p.h +++ b/src/qml/jsruntime/qv4objectproto_p.h @@ -51,7 +51,7 @@ namespace QV4 { struct ObjectCtor: FunctionObject { - Q_MANAGED + V4_OBJECT ObjectCtor(ExecutionContext *scope); static ReturnedValue construct(Managed *that, CallData *callData); diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp index d68a699b1d..c27cea9cb6 100644 --- a/src/qml/jsruntime/qv4qobjectwrapper.cpp +++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp @@ -241,7 +241,7 @@ QObjectWrapper::QObjectWrapper(ExecutionEngine *engine, QObject *object) : Object(engine) , m_object(object) { - setVTable(&static_vtbl); + setVTable(staticVTable()); Scope scope(engine); ScopedObject protectThis(scope, this); @@ -1722,7 +1722,7 @@ QObjectMethod::QObjectMethod(ExecutionContext *scope, QObject *object, int index , m_object(object) , m_index(index) { - setVTable(&static_vtbl); + setVTable(staticVTable()); subtype = WrappedQtMethod; m_qmlGlobal = qmlGlobal; } @@ -1836,17 +1836,17 @@ ReturnedValue QObjectMethod::callInternal(CallData *callData) } } -DEFINE_MANAGED_VTABLE(QObjectMethod); +DEFINE_OBJECT_VTABLE(QObjectMethod); QmlSignalHandler::QmlSignalHandler(ExecutionEngine *engine, QObject *object, int signalIndex) : Object(engine) , m_object(object) , m_signalIndex(signalIndex) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } -DEFINE_MANAGED_VTABLE(QmlSignalHandler); +DEFINE_OBJECT_VTABLE(QmlSignalHandler); void MultiplyWrappedQObjectMap::insert(QObject *key, Object *value) { diff --git a/src/qml/jsruntime/qv4qobjectwrapper_p.h b/src/qml/jsruntime/qv4qobjectwrapper_p.h index 748a782b4e..f6d1ac0790 100644 --- a/src/qml/jsruntime/qv4qobjectwrapper_p.h +++ b/src/qml/jsruntime/qv4qobjectwrapper_p.h @@ -77,7 +77,7 @@ struct QObjectSlotDispatcher; struct Q_QML_EXPORT QObjectWrapper : public QV4::Object { - Q_MANAGED + V4_OBJECT enum RevisionMode { IgnoreRevision, CheckRevision }; @@ -130,7 +130,7 @@ private: struct QObjectMethod : public QV4::FunctionObject { - Q_MANAGED + V4_OBJECT enum { DestroyMethod = -1, ToStringMethod = -2 }; @@ -161,7 +161,7 @@ private: struct QmlSignalHandler : public QV4::Object { - Q_MANAGED + V4_OBJECT QmlSignalHandler(ExecutionEngine *engine, QObject *object, int signalIndex); diff --git a/src/qml/jsruntime/qv4regexp.cpp b/src/qml/jsruntime/qv4regexp.cpp index 5be637d327..e5490cffd1 100644 --- a/src/qml/jsruntime/qv4regexp.cpp +++ b/src/qml/jsruntime/qv4regexp.cpp @@ -134,71 +134,3 @@ void RegExp::markObjects(Managed *that, ExecutionEngine *e) Q_UNUSED(that); Q_UNUSED(e); } - -ReturnedValue RegExp::get(Managed *, const StringRef, bool *) -{ - return Encode::undefined(); -} - -ReturnedValue RegExp::getIndexed(Managed *m, uint index, bool *hasProperty) -{ - Q_UNUSED(m); - Q_UNUSED(index); - Q_UNUSED(hasProperty); - - return Encode::undefined(); -} - -void RegExp::put(Managed *m, const StringRef name, const ValueRef value) -{ - Q_UNUSED(m); - Q_UNUSED(name); - Q_UNUSED(value); -} - -void RegExp::putIndexed(Managed *m, uint index, const ValueRef value) -{ - Q_UNUSED(m); - Q_UNUSED(index); - Q_UNUSED(value); -} - -PropertyAttributes RegExp::query(const Managed *m, StringRef name) -{ - Q_UNUSED(m); - Q_UNUSED(name); - - return Attr_Invalid; -} - -PropertyAttributes RegExp::queryIndexed(const Managed *m, uint index) -{ - Q_UNUSED(m); - Q_UNUSED(index); - - return Attr_Invalid; -} - -bool RegExp::deleteProperty(Managed *, const StringRef) -{ - return false; -} - -bool RegExp::deleteIndexedProperty(Managed *m, uint index) -{ - Q_UNUSED(m); - Q_UNUSED(index); - - return false; -} - -void RegExp::advanceIterator(Managed *m, ObjectIterator *it, StringRef name, uint *index, Property *, PropertyAttributes *attributes) -{ - Q_UNUSED(m); - Q_UNUSED(it); - Q_UNUSED(name); - Q_UNUSED(index); - Q_UNUSED(attributes); - - return; -} diff --git a/src/qml/jsruntime/qv4regexp_p.h b/src/qml/jsruntime/qv4regexp_p.h index 3ec34bae19..1bcc2c6f5a 100644 --- a/src/qml/jsruntime/qv4regexp_p.h +++ b/src/qml/jsruntime/qv4regexp_p.h @@ -93,7 +93,7 @@ public: class RegExp : public Managed { - Q_MANAGED + V4_MANAGED Q_MANAGED_TYPE(RegExp) public: static RegExp* create(ExecutionEngine* engine, const QString& pattern, bool ignoreCase = false, bool multiline = false); @@ -112,15 +112,6 @@ public: protected: static void destroy(Managed *that); static void markObjects(Managed *that, QV4::ExecutionEngine *e); - static ReturnedValue get(Managed *, const StringRef, bool *); - static ReturnedValue getIndexed(Managed *m, uint index, bool *hasProperty); - static void put(Managed *m, const StringRef name, const ValueRef value); - static void putIndexed(Managed *m, uint index, const ValueRef value); - static PropertyAttributes query(const Managed *m, StringRef name); - static PropertyAttributes queryIndexed(const Managed *m, uint index); - static bool deleteProperty(Managed *, const StringRef); - static bool deleteIndexedProperty(Managed *m, uint index); - static void advanceIterator(Managed *m, ObjectIterator *it, StringRef name, uint *index, Property *, PropertyAttributes *attributes); private: friend class RegExpCache; diff --git a/src/qml/jsruntime/qv4regexpobject.cpp b/src/qml/jsruntime/qv4regexpobject.cpp index 2d92f12199..aafecb5ad8 100644 --- a/src/qml/jsruntime/qv4regexpobject.cpp +++ b/src/qml/jsruntime/qv4regexpobject.cpp @@ -69,14 +69,14 @@ Q_CORE_EXPORT QString qt_regexp_toCanonical(const QString &, QRegExp::PatternSyn using namespace QV4; -DEFINE_MANAGED_VTABLE(RegExpObject); +DEFINE_OBJECT_VTABLE(RegExpObject); RegExpObject::RegExpObject(InternalClass *ic) : Object(ic) , value(RegExp::create(ic->engine, QString(), false, false)) , global(false) { - Q_ASSERT(internalClass->vtable == &static_vtbl); + Q_ASSERT(internalClass->vtable == staticVTable()); init(ic->engine); } @@ -143,7 +143,7 @@ RegExpObject::RegExpObject(ExecutionEngine *engine, const QRegExp &re) void RegExpObject::init(ExecutionEngine *engine) { - setVTable(&static_vtbl); + setVTable(staticVTable()); Scope scope(engine); ScopedObject protectThis(scope, this); @@ -231,12 +231,12 @@ uint RegExpObject::flags() const return f; } -DEFINE_MANAGED_VTABLE(RegExpCtor); +DEFINE_OBJECT_VTABLE(RegExpCtor); RegExpCtor::RegExpCtor(ExecutionContext *scope) : FunctionObject(scope, QStringLiteral("RegExp")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue RegExpCtor::construct(Managed *m, CallData *callData) diff --git a/src/qml/jsruntime/qv4regexpobject_p.h b/src/qml/jsruntime/qv4regexpobject_p.h index bd91e8f693..d306efb218 100644 --- a/src/qml/jsruntime/qv4regexpobject_p.h +++ b/src/qml/jsruntime/qv4regexpobject_p.h @@ -66,7 +66,7 @@ namespace QV4 { class RegExp; struct RegExpObject: Object { - Q_MANAGED + V4_OBJECT Q_MANAGED_TYPE(RegExpObject) // needs to be compatible with the flags in qv4jsir_p.h enum Flags { @@ -104,7 +104,7 @@ protected: struct RegExpCtor: FunctionObject { - Q_MANAGED + V4_OBJECT RegExpCtor(ExecutionContext *scope); static ReturnedValue construct(Managed *m, CallData *callData); diff --git a/src/qml/jsruntime/qv4runtime.cpp b/src/qml/jsruntime/qv4runtime.cpp index 2f1b8a0bd3..77b00122ef 100644 --- a/src/qml/jsruntime/qv4runtime.cpp +++ b/src/qml/jsruntime/qv4runtime.cpp @@ -892,10 +892,10 @@ ReturnedValue __qmljs_call_property_lookup(ExecutionContext *context, uint index Lookup *l = context->lookups + index; SafeValue v; v = l->getter(l, callData->thisObject); - if (!v.isManaged()) + if (!v.isObject()) return context->throwTypeError(); - return v.managed()->call(callData); + return v.objectValue()->call(callData); } ReturnedValue __qmljs_call_element(ExecutionContext *context, const ValueRef index, CallDataRef callData) @@ -917,10 +917,10 @@ ReturnedValue __qmljs_call_element(ExecutionContext *context, const ValueRef ind ReturnedValue __qmljs_call_value(ExecutionContext *context, const ValueRef func, CallDataRef callData) { - if (!func->isManaged()) + if (!func->isObject()) return context->throwTypeError(); - return func->managed()->call(callData); + return func->objectValue()->call(callData); } @@ -980,10 +980,10 @@ ReturnedValue __qmljs_construct_property_lookup(ExecutionContext *context, uint Lookup *l = context->lookups + index; SafeValue v; v = l->getter(l, callData->thisObject); - if (!v.isManaged()) + if (!v.isObject()) return context->throwTypeError(); - return v.managed()->construct(callData); + return v.objectValue()->construct(callData); } diff --git a/src/qml/jsruntime/qv4script.cpp b/src/qml/jsruntime/qv4script.cpp index 4fd0569627..c50b025bc9 100644 --- a/src/qml/jsruntime/qv4script.cpp +++ b/src/qml/jsruntime/qv4script.cpp @@ -67,7 +67,7 @@ QmlBindingWrapper::QmlBindingWrapper(ExecutionContext *scope, Function *f, Objec { Q_ASSERT(scope->inUse); - setVTable(&static_vtbl); + setVTable(staticVTable()); function = f; function->compilationUnit->ref(); needsActivation = function->needsActivation(); @@ -88,7 +88,7 @@ QmlBindingWrapper::QmlBindingWrapper(ExecutionContext *scope, ObjectRef qml) { Q_ASSERT(scope->inUse); - setVTable(&static_vtbl); + setVTable(staticVTable()); function = 0; needsActivation = false; @@ -129,18 +129,18 @@ void QmlBindingWrapper::markObjects(Managed *m, ExecutionEngine *e) wrapper->qmlContext->mark(e); } -DEFINE_MANAGED_VTABLE(QmlBindingWrapper); +DEFINE_OBJECT_VTABLE(QmlBindingWrapper); struct CompilationUnitHolder : public QV4::Object { - Q_MANAGED + V4_OBJECT CompilationUnitHolder(ExecutionEngine *engine, CompiledData::CompilationUnit *unit) : Object(engine) , unit(unit) { unit->ref(); - setVTable(&static_vtbl); + setVTable(staticVTable()); } ~CompilationUnitHolder() { @@ -155,7 +155,7 @@ struct CompilationUnitHolder : public QV4::Object QV4::CompiledData::CompilationUnit *unit; }; -DEFINE_MANAGED_VTABLE(CompilationUnitHolder); +DEFINE_OBJECT_VTABLE(CompilationUnitHolder); Script::Script(ExecutionEngine *v4, ObjectRef qml, CompiledData::CompilationUnit *compilationUnit) : line(0), column(0), scope(v4->rootContext), strictMode(false), inheritContext(true), parsed(false) diff --git a/src/qml/jsruntime/qv4script_p.h b/src/qml/jsruntime/qv4script_p.h index 8e11eddb8f..8afdb6126f 100644 --- a/src/qml/jsruntime/qv4script_p.h +++ b/src/qml/jsruntime/qv4script_p.h @@ -54,7 +54,7 @@ namespace QV4 { struct ExecutionContext; struct QmlBindingWrapper : FunctionObject { - Q_MANAGED + V4_OBJECT QmlBindingWrapper(ExecutionContext *scope, Function *f, ObjectRef qml); // Constructor for QML functions and signal handlers, resulting binding wrapper is not callable! diff --git a/src/qml/jsruntime/qv4sequenceobject.cpp b/src/qml/jsruntime/qv4sequenceobject.cpp index 52a6244890..4039f81896 100644 --- a/src/qml/jsruntime/qv4sequenceobject.cpp +++ b/src/qml/jsruntime/qv4sequenceobject.cpp @@ -165,11 +165,11 @@ template <> bool convertValueToElement(const ValueRef value) template <typename Container> class QQmlSequence : public QV4::Object { - Q_MANAGED + V4_OBJECT Q_MANAGED_TYPE(QmlSequence) public: QQmlSequence(QV4::ExecutionEngine *engine, const Container &container) - : QV4::Object(InternalClass::create(engine, &static_vtbl, engine->sequencePrototype.asObject())) + : QV4::Object(InternalClass::create(engine, staticVTable(), engine->sequencePrototype.asObject())) , m_container(container) , m_object(0) , m_propertyIndex(-1) @@ -183,7 +183,7 @@ public: } QQmlSequence(QV4::ExecutionEngine *engine, QObject *object, int propertyIndex) - : QV4::Object(InternalClass::create(engine, &static_vtbl, engine->sequencePrototype.asObject())) + : QV4::Object(InternalClass::create(engine, staticVTable(), engine->sequencePrototype.asObject())) , m_object(object) , m_propertyIndex(propertyIndex) , m_isReference(true) @@ -521,22 +521,22 @@ private: typedef QQmlSequence<QStringList> QQmlQStringList; template<> -DEFINE_MANAGED_VTABLE(QQmlQStringList); +DEFINE_OBJECT_VTABLE(QQmlQStringList); typedef QQmlSequence<QList<QString> > QQmlStringList; template<> -DEFINE_MANAGED_VTABLE(QQmlStringList); +DEFINE_OBJECT_VTABLE(QQmlStringList); typedef QQmlSequence<QList<int> > QQmlIntList; template<> -DEFINE_MANAGED_VTABLE(QQmlIntList); +DEFINE_OBJECT_VTABLE(QQmlIntList); typedef QQmlSequence<QList<QUrl> > QQmlUrlList; template<> -DEFINE_MANAGED_VTABLE(QQmlUrlList); +DEFINE_OBJECT_VTABLE(QQmlUrlList); typedef QQmlSequence<QList<bool> > QQmlBoolList; template<> -DEFINE_MANAGED_VTABLE(QQmlBoolList); +DEFINE_OBJECT_VTABLE(QQmlBoolList); typedef QQmlSequence<QList<qreal> > QQmlRealList; template<> -DEFINE_MANAGED_VTABLE(QQmlRealList); +DEFINE_OBJECT_VTABLE(QQmlRealList); #define REGISTER_QML_SEQUENCE_METATYPE(unused, unused2, SequenceType, unused3) qRegisterMetaType<SequenceType>(#SequenceType); SequencePrototype::SequencePrototype(InternalClass *ic) diff --git a/src/qml/jsruntime/qv4string.cpp b/src/qml/jsruntime/qv4string.cpp index ead818c8bd..15d27b3f49 100644 --- a/src/qml/jsruntime/qv4string.cpp +++ b/src/qml/jsruntime/qv4string.cpp @@ -101,20 +101,23 @@ static uint toArrayIndex(const char *ch, const char *end, bool *ok) } -const ManagedVTable String::static_vtbl = +const ObjectVTable String::static_vtbl = { - String::IsExecutionContext, - String::IsString, - String::IsObject, - String::IsFunctionObject, - String::IsErrorObject, + { + String::IsExecutionContext, + String::IsString, + String::IsObject, + String::IsFunctionObject, + String::IsErrorObject, + 0, + String::MyType, + "String", + destroy, + markObjects, + isEqualTo + }, + 0, 0, - String::MyType, - "String", - destroy, - markObjects, - call, - construct, 0 /*collectDeletables*/, get, getIndexed, @@ -126,7 +129,6 @@ const ManagedVTable String::static_vtbl = deleteIndexedProperty, 0 /*getLookup*/, 0 /*setLookup*/, - isEqualTo, 0, 0 /*advanceIterator*/, }; diff --git a/src/qml/jsruntime/qv4string_p.h b/src/qml/jsruntime/qv4string_p.h index bc5b30518e..e3d8326d84 100644 --- a/src/qml/jsruntime/qv4string_p.h +++ b/src/qml/jsruntime/qv4string_p.h @@ -52,7 +52,8 @@ struct ExecutionEngine; struct Identifier; struct Q_QML_EXPORT String : public Managed { - Q_MANAGED + // ### FIXME: Should this be a V4_OBJECT + V4_OBJECT Q_MANAGED_TYPE(String) enum { IsString = true diff --git a/src/qml/jsruntime/qv4stringobject.cpp b/src/qml/jsruntime/qv4stringobject.cpp index b9ec4202eb..07cdf31a03 100644 --- a/src/qml/jsruntime/qv4stringobject.cpp +++ b/src/qml/jsruntime/qv4stringobject.cpp @@ -75,12 +75,12 @@ using namespace QV4; -DEFINE_MANAGED_VTABLE(StringObject); +DEFINE_OBJECT_VTABLE(StringObject); StringObject::StringObject(InternalClass *ic) : Object(ic) { - Q_ASSERT(internalClass->vtable == &static_vtbl); + Q_ASSERT(internalClass->vtable == staticVTable()); Scope scope(engine()); ScopedObject protectThis(scope, this); @@ -95,7 +95,7 @@ StringObject::StringObject(InternalClass *ic) StringObject::StringObject(ExecutionEngine *engine, const ValueRef val) : Object(engine->stringObjectClass) { - setVTable(&static_vtbl); + setVTable(staticVTable()); Scope scope(engine); ScopedObject protectThis(scope, this); @@ -171,12 +171,12 @@ void StringObject::markObjects(Managed *that, ExecutionEngine *e) Object::markObjects(that, e); } -DEFINE_MANAGED_VTABLE(StringCtor); +DEFINE_OBJECT_VTABLE(StringCtor); StringCtor::StringCtor(ExecutionContext *scope) : FunctionObject(scope, QStringLiteral("String")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue StringCtor::construct(Managed *m, CallData *callData) diff --git a/src/qml/jsruntime/qv4stringobject_p.h b/src/qml/jsruntime/qv4stringobject_p.h index e7e8d5a2b9..9b26343c63 100644 --- a/src/qml/jsruntime/qv4stringobject_p.h +++ b/src/qml/jsruntime/qv4stringobject_p.h @@ -50,7 +50,7 @@ QT_BEGIN_NAMESPACE namespace QV4 { struct StringObject: Object { - Q_MANAGED + V4_OBJECT Q_MANAGED_TYPE(StringObject) SafeValue value; @@ -69,7 +69,7 @@ protected: struct StringCtor: FunctionObject { - Q_MANAGED + V4_OBJECT StringCtor(ExecutionContext *scope); static ReturnedValue construct(Managed *m, CallData *callData); diff --git a/src/qml/jsruntime/qv4variantobject.cpp b/src/qml/jsruntime/qv4variantobject.cpp index dfa4ac5775..5bfd7786e9 100644 --- a/src/qml/jsruntime/qv4variantobject.cpp +++ b/src/qml/jsruntime/qv4variantobject.cpp @@ -49,7 +49,7 @@ QT_BEGIN_NAMESPACE using namespace QV4; -DEFINE_MANAGED_VTABLE(VariantObject); +DEFINE_OBJECT_VTABLE(VariantObject); VariantObject::VariantObject(InternalClass *ic) : Object(ic) diff --git a/src/qml/jsruntime/qv4variantobject_p.h b/src/qml/jsruntime/qv4variantobject_p.h index 4e14839184..3715dbc8c4 100644 --- a/src/qml/jsruntime/qv4variantobject_p.h +++ b/src/qml/jsruntime/qv4variantobject_p.h @@ -66,7 +66,7 @@ namespace QV4 { struct VariantObject : Object, public ExecutionEngine::ScarceResourceData { - Q_MANAGED + V4_OBJECT public: VariantObject(InternalClass *ic); VariantObject(ExecutionEngine *engine, const QVariant &value); diff --git a/src/qml/qml/qqmlcomponent.cpp b/src/qml/qml/qqmlcomponent.cpp index 5813415347..a36150ee42 100644 --- a/src/qml/qml/qqmlcomponent.cpp +++ b/src/qml/qml/qqmlcomponent.cpp @@ -1069,7 +1069,7 @@ class QQmlComponentIncubator; class QmlIncubatorObject : public QV4::Object { - Q_MANAGED + V4_OBJECT public: QmlIncubatorObject(QV8Engine *engine, QQmlIncubator::IncubationMode = QQmlIncubator::Asynchronous); @@ -1093,7 +1093,7 @@ public: void setInitialState(QObject *); }; -DEFINE_MANAGED_VTABLE(QmlIncubatorObject); +DEFINE_OBJECT_VTABLE(QmlIncubatorObject); class QQmlComponentIncubator : public QQmlIncubator { @@ -1467,7 +1467,7 @@ QmlIncubatorObject::QmlIncubatorObject(QV8Engine *engine, QQmlIncubator::Incubat { incubator.reset(new QQmlComponentIncubator(this, m)); v8 = engine; - setVTable(&static_vtbl); + setVTable(staticVTable()); valuemap = QV4::Primitive::undefinedValue(); qmlGlobal = QV4::Primitive::undefinedValue(); diff --git a/src/qml/qml/qqmlcontextwrapper.cpp b/src/qml/qml/qqmlcontextwrapper.cpp index b3c2105e68..d3ef02a9ad 100644 --- a/src/qml/qml/qqmlcontextwrapper.cpp +++ b/src/qml/qml/qqmlcontextwrapper.cpp @@ -59,14 +59,14 @@ QT_BEGIN_NAMESPACE using namespace QV4; -DEFINE_MANAGED_VTABLE(QmlContextWrapper); +DEFINE_OBJECT_VTABLE(QmlContextWrapper); QmlContextWrapper::QmlContextWrapper(QV8Engine *engine, QQmlContextData *context, QObject *scopeObject, bool ownsContext) : Object(QV8Engine::getV4(engine)), v8(engine), readOnly(true), ownsContext(ownsContext), isNullWrapper(false), context(context), scopeObject(scopeObject), idObjectsWrapper(0) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } QmlContextWrapper::~QmlContextWrapper() @@ -433,13 +433,13 @@ ReturnedValue QmlContextWrapper::qmlSingletonWrapper(const StringRef &name) return QJSValuePrivate::get(siinfo->scriptApi(e))->getValue(engine()); } -DEFINE_MANAGED_VTABLE(QQmlIdObjectsArray); +DEFINE_OBJECT_VTABLE(QQmlIdObjectsArray); QQmlIdObjectsArray::QQmlIdObjectsArray(ExecutionEngine *engine, QmlContextWrapper *contextWrapper) : Object(engine) , contextWrapper(contextWrapper) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ReturnedValue QQmlIdObjectsArray::getIndexed(Managed *m, uint index, bool *hasProperty) diff --git a/src/qml/qml/qqmlcontextwrapper_p.h b/src/qml/qml/qqmlcontextwrapper_p.h index 89ace7090c..bd56d4bcec 100644 --- a/src/qml/qml/qqmlcontextwrapper_p.h +++ b/src/qml/qml/qqmlcontextwrapper_p.h @@ -73,7 +73,7 @@ struct QQmlIdObjectsArray; struct Q_QML_EXPORT QmlContextWrapper : Object { - Q_MANAGED + V4_OBJECT QmlContextWrapper(QV8Engine *engine, QQmlContextData *context, QObject *scopeObject, bool ownsContext = false); ~QmlContextWrapper(); @@ -112,7 +112,7 @@ private: struct QQmlIdObjectsArray : public Object { - Q_MANAGED + V4_OBJECT QQmlIdObjectsArray(ExecutionEngine *engine, QmlContextWrapper *contextWrapper); static ReturnedValue getIndexed(Managed *m, uint index, bool *hasProperty); diff --git a/src/qml/qml/qqmllistwrapper.cpp b/src/qml/qml/qqmllistwrapper.cpp index 2272beec4a..2c35e12227 100644 --- a/src/qml/qml/qqmllistwrapper.cpp +++ b/src/qml/qml/qqmllistwrapper.cpp @@ -50,13 +50,13 @@ QT_BEGIN_NAMESPACE using namespace QV4; -DEFINE_MANAGED_VTABLE(QmlListWrapper); +DEFINE_OBJECT_VTABLE(QmlListWrapper); QmlListWrapper::QmlListWrapper(QV8Engine *engine) : Object(QV8Engine::getV4(engine)), v8(engine) { - setVTable(&static_vtbl); + setVTable(staticVTable()); setArrayType(ArrayData::Custom); } diff --git a/src/qml/qml/qqmllistwrapper_p.h b/src/qml/qml/qqmllistwrapper_p.h index 11916a4f91..a8105d256e 100644 --- a/src/qml/qml/qqmllistwrapper_p.h +++ b/src/qml/qml/qqmllistwrapper_p.h @@ -69,7 +69,7 @@ namespace QV4 { struct Q_QML_EXPORT QmlListWrapper : Object { - Q_MANAGED + V4_OBJECT protected: QmlListWrapper(QV8Engine *engine); ~QmlListWrapper(); diff --git a/src/qml/qml/qqmllocale.cpp b/src/qml/qml/qqmllocale.cpp index 29fa587b0e..8cea66c99e 100644 --- a/src/qml/qml/qqmllocale.cpp +++ b/src/qml/qml/qqmllocale.cpp @@ -54,7 +54,7 @@ QT_BEGIN_NAMESPACE -DEFINE_MANAGED_VTABLE(QQmlLocaleData); +DEFINE_OBJECT_VTABLE(QQmlLocaleData); #define GET_LOCALE_DATA_RESOURCE(OBJECT) \ QV4::Scoped<QQmlLocaleData> r(scope, OBJECT.as<QQmlLocaleData>()); \ diff --git a/src/qml/qml/qqmllocale_p.h b/src/qml/qml/qqmllocale_p.h index 1f26f1834f..cafe448313 100644 --- a/src/qml/qml/qqmllocale_p.h +++ b/src/qml/qml/qqmllocale_p.h @@ -131,12 +131,12 @@ private: class QQmlLocaleData : public QV4::Object { - Q_MANAGED + V4_OBJECT public: QQmlLocaleData(QV4::ExecutionEngine *engine) : QV4::Object(engine) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } QLocale locale; diff --git a/src/qml/qml/qqmltypewrapper.cpp b/src/qml/qml/qqmltypewrapper.cpp index 9c350a54a5..93ad8dc6fe 100644 --- a/src/qml/qml/qqmltypewrapper.cpp +++ b/src/qml/qml/qqmltypewrapper.cpp @@ -54,13 +54,13 @@ QT_BEGIN_NAMESPACE using namespace QV4; -DEFINE_MANAGED_VTABLE(QmlTypeWrapper); +DEFINE_OBJECT_VTABLE(QmlTypeWrapper); QmlTypeWrapper::QmlTypeWrapper(QV8Engine *engine) : Object(QV8Engine::getV4(engine)), v8(engine), mode(IncludeEnums), type(0), typeNamespace(0), importNamespace(0) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } QmlTypeWrapper::~QmlTypeWrapper() @@ -277,7 +277,7 @@ PropertyAttributes QmlTypeWrapper::query(const Managed *m, StringRef name) Scope scope(m->engine()); ScopedString n(scope, name); bool hasProperty = false; - const_cast<Managed*>(m)->get(n, &hasProperty); + static_cast<Object *>(const_cast<Managed*>(m))->get(n, &hasProperty); return hasProperty ? Attr_Data : Attr_Invalid; } diff --git a/src/qml/qml/qqmltypewrapper_p.h b/src/qml/qml/qqmltypewrapper_p.h index ee462d6479..eb1eee5096 100644 --- a/src/qml/qml/qqmltypewrapper_p.h +++ b/src/qml/qml/qqmltypewrapper_p.h @@ -68,7 +68,7 @@ namespace QV4 { struct Q_QML_EXPORT QmlTypeWrapper : Object { - Q_MANAGED + V4_OBJECT private: QmlTypeWrapper(QV8Engine *engine); ~QmlTypeWrapper(); diff --git a/src/qml/qml/qqmlvaluetypewrapper.cpp b/src/qml/qml/qqmlvaluetypewrapper.cpp index 50d7cbcc5e..56da6819fe 100644 --- a/src/qml/qml/qqmlvaluetypewrapper.cpp +++ b/src/qml/qml/qqmlvaluetypewrapper.cpp @@ -56,7 +56,7 @@ QT_BEGIN_NAMESPACE using namespace QV4; -DEFINE_MANAGED_VTABLE(QmlValueTypeWrapper); +DEFINE_OBJECT_VTABLE(QmlValueTypeWrapper); class QmlValueTypeReference : public QmlValueTypeWrapper { @@ -79,7 +79,7 @@ QmlValueTypeWrapper::QmlValueTypeWrapper(QV8Engine *engine, ObjectType objectTyp : Object(QV8Engine::getV4(engine)), objectType(objectType) { v8 = engine; - setVTable(&static_vtbl); + setVTable(staticVTable()); } QmlValueTypeWrapper::~QmlValueTypeWrapper() diff --git a/src/qml/qml/qqmlvaluetypewrapper_p.h b/src/qml/qml/qqmlvaluetypewrapper_p.h index 9dd3e8dcbe..256573966a 100644 --- a/src/qml/qml/qqmlvaluetypewrapper_p.h +++ b/src/qml/qml/qqmlvaluetypewrapper_p.h @@ -68,7 +68,7 @@ namespace QV4 { struct Q_QML_EXPORT QmlValueTypeWrapper : Object { - Q_MANAGED + V4_OBJECT protected: enum ObjectType { Reference, Copy }; QmlValueTypeWrapper(QV8Engine *engine, ObjectType type); diff --git a/src/qml/qml/qqmlxmlhttprequest.cpp b/src/qml/qml/qqmlxmlhttprequest.cpp index ad231d0769..79428ca4a8 100644 --- a/src/qml/qml/qqmlxmlhttprequest.cpp +++ b/src/qml/qml/qqmlxmlhttprequest.cpp @@ -185,14 +185,14 @@ public: class NamedNodeMap : public Object { - Q_MANAGED + V4_OBJECT public: NamedNodeMap(ExecutionEngine *engine, NodeImpl *data, const QList<NodeImpl *> &list) : Object(engine) , list(list) , d(data) { - setVTable(&static_vtbl); + setVTable(staticVTable()); if (d) d->addref(); @@ -216,17 +216,17 @@ public: NodeImpl *d; }; -DEFINE_MANAGED_VTABLE(NamedNodeMap); +DEFINE_OBJECT_VTABLE(NamedNodeMap); class NodeList : public Object { - Q_MANAGED + V4_OBJECT public: NodeList(ExecutionEngine *engine, NodeImpl *data) : Object(engine) , d(data) { - setVTable(&static_vtbl); + setVTable(staticVTable()); if (d) d->addref(); @@ -249,16 +249,16 @@ public: NodeImpl *d; }; -DEFINE_MANAGED_VTABLE(NodeList); +DEFINE_OBJECT_VTABLE(NodeList); class NodePrototype : public Object { - Q_MANAGED + V4_OBJECT public: NodePrototype(ExecutionEngine *engine) : Object(engine) { - setVTable(&static_vtbl); + setVTable(staticVTable()); Scope scope(engine); ScopedObject protectThis(scope, this); @@ -302,17 +302,17 @@ public: }; -DEFINE_MANAGED_VTABLE(NodePrototype); +DEFINE_OBJECT_VTABLE(NodePrototype); class Node : public Object { - Q_MANAGED + V4_OBJECT Node(ExecutionEngine *engine, NodeImpl *data) : Object(engine) , d(data) { - setVTable(&static_vtbl); + setVTable(staticVTable()); if (d) d->addref(); @@ -339,7 +339,7 @@ private: Node &operator=(const Node &); }; -DEFINE_MANAGED_VTABLE(Node); +DEFINE_OBJECT_VTABLE(Node); class Element : public Node { @@ -1600,12 +1600,12 @@ void QQmlXMLHttpRequest::destroyNetwork() struct QQmlXMLHttpRequestWrapper : public Object { - Q_MANAGED + V4_OBJECT QQmlXMLHttpRequestWrapper(ExecutionEngine *engine, QQmlXMLHttpRequest *request) : Object(engine) , request(request) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } ~QQmlXMLHttpRequestWrapper() { delete request; @@ -1618,15 +1618,15 @@ struct QQmlXMLHttpRequestWrapper : public Object QQmlXMLHttpRequest *request; }; -DEFINE_MANAGED_VTABLE(QQmlXMLHttpRequestWrapper); +DEFINE_OBJECT_VTABLE(QQmlXMLHttpRequestWrapper); struct QQmlXMLHttpRequestCtor : public FunctionObject { - Q_MANAGED + V4_OBJECT QQmlXMLHttpRequestCtor(ExecutionEngine *engine) : FunctionObject(engine->rootContext, QStringLiteral("XMLHttpRequest")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); Scope scope(engine); ScopedValue protectThis(scope, this); @@ -1688,7 +1688,7 @@ struct QQmlXMLHttpRequestCtor : public FunctionObject Object *proto; }; -DEFINE_MANAGED_VTABLE(QQmlXMLHttpRequestCtor); +DEFINE_OBJECT_VTABLE(QQmlXMLHttpRequestCtor); void QQmlXMLHttpRequestCtor::setupProto() { diff --git a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp index 67b7e789bd..972e8cf2e3 100644 --- a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp +++ b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp @@ -77,7 +77,7 @@ QT_BEGIN_NAMESPACE using namespace QV4; -DEFINE_MANAGED_VTABLE(QtObject); +DEFINE_OBJECT_VTABLE(QtObject); struct StaticQtMetaObject : public QObject { @@ -90,7 +90,7 @@ QV4::QtObject::QtObject(ExecutionEngine *v4, QQmlEngine *qmlEngine) , m_platform(0) , m_application(0) { - setVTable(&static_vtbl); + setVTable(staticVTable()); Scope scope(v4); ScopedObject protectThis(scope, this); @@ -1178,12 +1178,12 @@ namespace { struct BindingFunction : public QV4::FunctionObject { - Q_MANAGED + V4_OBJECT BindingFunction(FunctionObject *originalFunction) : QV4::FunctionObject(originalFunction->scope, originalFunction->name) , originalFunction(originalFunction) { - setVTable(&static_vtbl); + setVTable(staticVTable()); bindingKeyFlag = true; } @@ -1203,7 +1203,7 @@ struct BindingFunction : public QV4::FunctionObject QV4::FunctionObject *originalFunction; }; -DEFINE_MANAGED_VTABLE(BindingFunction); +DEFINE_OBJECT_VTABLE(BindingFunction); } diff --git a/src/qml/qml/v8/qqmlbuiltinfunctions_p.h b/src/qml/qml/v8/qqmlbuiltinfunctions_p.h index 90536c09dd..b0c63f1ad4 100644 --- a/src/qml/qml/v8/qqmlbuiltinfunctions_p.h +++ b/src/qml/qml/v8/qqmlbuiltinfunctions_p.h @@ -65,7 +65,7 @@ namespace QV4 { struct QtObject : Object { - Q_MANAGED + V4_OBJECT QtObject(ExecutionEngine *v4, QQmlEngine *qmlEngine); static ReturnedValue method_isQtObject(CallContext *ctx); diff --git a/src/qml/types/qqmldelegatemodel.cpp b/src/qml/types/qqmldelegatemodel.cpp index 4c8635b29c..f10f54038d 100644 --- a/src/qml/types/qqmldelegatemodel.cpp +++ b/src/qml/types/qqmldelegatemodel.cpp @@ -61,7 +61,7 @@ class QQmlDelegateModelItem; struct DelegateModelGroupFunction: QV4::FunctionObject { - Q_MANAGED + V4_OBJECT QV4::ReturnedValue (*code)(QQmlDelegateModelItem *item, uint flag, const QV4::ValueRef arg); uint flag; @@ -71,7 +71,7 @@ struct DelegateModelGroupFunction: QV4::FunctionObject , code(code) , flag(flag) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } static QV4::ReturnedValue construct(QV4::Managed *m, QV4::CallData *) @@ -93,7 +93,7 @@ struct DelegateModelGroupFunction: QV4::FunctionObject } }; -DEFINE_MANAGED_VTABLE(DelegateModelGroupFunction); +DEFINE_OBJECT_VTABLE(DelegateModelGroupFunction); @@ -1795,7 +1795,7 @@ QV4::ReturnedValue QQmlDelegateModelItem::get_index(QQmlDelegateModelItem *thisI //--------------------------------------------------------------------------- -DEFINE_MANAGED_VTABLE(QQmlDelegateModelItemObject); +DEFINE_OBJECT_VTABLE(QQmlDelegateModelItemObject); QQmlDelegateModelItemObject::~QQmlDelegateModelItemObject() { @@ -3154,11 +3154,11 @@ void QQmlPartsModel::emitModelUpdated(const QQmlChangeSet &changeSet, bool reset struct QQmlDelegateModelGroupChange : QV4::Object { - Q_MANAGED + V4_OBJECT QQmlDelegateModelGroupChange(QV4::ExecutionEngine *engine) : Object(engine) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } static QV4::ReturnedValue method_get_index(QV4::CallContext *ctx) { @@ -3188,16 +3188,16 @@ struct QQmlDelegateModelGroupChange : QV4::Object QQmlChangeSet::Change change; }; -DEFINE_MANAGED_VTABLE(QQmlDelegateModelGroupChange); +DEFINE_OBJECT_VTABLE(QQmlDelegateModelGroupChange); class QQmlDelegateModelGroupChangeArray : public QV4::Object { - Q_MANAGED + V4_OBJECT public: QQmlDelegateModelGroupChangeArray(QV4::ExecutionEngine *engine) : Object(engine) { - setVTable(&static_vtbl); + setVTable(staticVTable()); setArrayType(QV4::ArrayData::Custom); } virtual ~QQmlDelegateModelGroupChangeArray() {} @@ -3253,7 +3253,7 @@ public: }; -DEFINE_MANAGED_VTABLE(QQmlDelegateModelGroupChangeArray); +DEFINE_OBJECT_VTABLE(QQmlDelegateModelGroupChangeArray); class QQmlDelegateModelGroupRemoveArray : public QQmlDelegateModelGroupChangeArray { diff --git a/src/qml/types/qqmldelegatemodel_p_p.h b/src/qml/types/qqmldelegatemodel_p_p.h index f78cf38535..32b1154d30 100644 --- a/src/qml/types/qqmldelegatemodel_p_p.h +++ b/src/qml/types/qqmldelegatemodel_p_p.h @@ -161,11 +161,11 @@ protected: struct QQmlDelegateModelItemObject : QV4::Object { - Q_MANAGED; + V4_OBJECT; QQmlDelegateModelItemObject(QV4::ExecutionEngine *engine, QQmlDelegateModelItem *item) : Object(engine) , item(item) - { setVTable(&static_vtbl); } + { setVTable(staticVTable()); } ~QQmlDelegateModelItemObject(); static void destroy(Managed *that); diff --git a/src/quick/items/context2d/qquickcontext2d.cpp b/src/quick/items/context2d/qquickcontext2d.cpp index c8741335dd..f636d5a619 100644 --- a/src/quick/items/context2d/qquickcontext2d.cpp +++ b/src/quick/items/context2d/qquickcontext2d.cpp @@ -479,12 +479,12 @@ V8_DEFINE_EXTENSION(QQuickContext2DEngineData, engineData) class QQuickJSContext2D : public QV4::Object { - Q_MANAGED + V4_OBJECT public: QQuickJSContext2D(QV4::ExecutionEngine *engine) : QV4::Object(engine) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } QQuickContext2D* context; @@ -535,12 +535,12 @@ protected: } }; -DEFINE_MANAGED_VTABLE(QQuickJSContext2D); +DEFINE_OBJECT_VTABLE(QQuickJSContext2D); struct QQuickJSContext2DPrototype : public QV4::Object { - Q_MANAGED + V4_OBJECT public: QQuickJSContext2DPrototype(QV4::ExecutionEngine *engine) : QV4::Object(engine) @@ -641,19 +641,19 @@ public: }; -DEFINE_MANAGED_VTABLE(QQuickJSContext2DPrototype); +DEFINE_OBJECT_VTABLE(QQuickJSContext2DPrototype); class QQuickContext2DStyle : public QV4::Object { - Q_MANAGED + V4_OBJECT public: QQuickContext2DStyle(QV4::ExecutionEngine *e) : QV4::Object(e) , patternRepeatX(false) , patternRepeatY(false) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } QBrush brush; bool patternRepeatX:1; @@ -667,7 +667,7 @@ protected: } }; -DEFINE_MANAGED_VTABLE(QQuickContext2DStyle); +DEFINE_OBJECT_VTABLE(QQuickContext2DStyle); QImage qt_image_convolute_filter(const QImage& src, const QVector<qreal>& weights, int radius = 0) { @@ -866,11 +866,11 @@ static QString qt_composite_mode_to_string(QPainter::CompositionMode op) struct QQuickJSContext2DPixelData : public QV4::Object { - Q_MANAGED + V4_OBJECT QQuickJSContext2DPixelData(QV4::ExecutionEngine *engine) : QV4::Object(engine) { - setVTable(&static_vtbl); + setVTable(staticVTable()); setArrayType(QV4::ArrayData::Custom); } @@ -885,15 +885,15 @@ struct QQuickJSContext2DPixelData : public QV4::Object QImage image; }; -DEFINE_MANAGED_VTABLE(QQuickJSContext2DPixelData); +DEFINE_OBJECT_VTABLE(QQuickJSContext2DPixelData); struct QQuickJSContext2DImageData : public QV4::Object { - Q_MANAGED + V4_OBJECT QQuickJSContext2DImageData(QV4::ExecutionEngine *engine) : QV4::Object(engine) { - setVTable(&static_vtbl); + setVTable(staticVTable()); pixelData = QV4::Primitive::undefinedValue(); QV4::Scope scope(engine); @@ -918,7 +918,7 @@ struct QQuickJSContext2DImageData : public QV4::Object QV4::SafeValue pixelData; }; -DEFINE_MANAGED_VTABLE(QQuickJSContext2DImageData); +DEFINE_OBJECT_VTABLE(QQuickJSContext2DImageData); static QV4::ReturnedValue qt_create_image_data(qreal w, qreal h, QV8Engine* engine, const QImage& image) { diff --git a/src/quick/items/qquickview.cpp b/src/quick/items/qquickview.cpp index 61f0f9bec2..96146ec552 100644 --- a/src/quick/items/qquickview.cpp +++ b/src/quick/items/qquickview.cpp @@ -56,13 +56,13 @@ QT_BEGIN_NAMESPACE -DEFINE_MANAGED_VTABLE(QQuickRootItemMarker); +DEFINE_OBJECT_VTABLE(QQuickRootItemMarker); QQuickRootItemMarker::QQuickRootItemMarker(QQuickViewPrivate *view) : QV4::Object(QQmlEnginePrivate::getV4Engine(view->engine.data())) , view(view) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } void QQuickRootItemMarker::markObjects(QV4::Managed *that, QV4::ExecutionEngine *e) diff --git a/src/quick/items/qquickview_p.h b/src/quick/items/qquickview_p.h index e18b45dfbe..74e40081e9 100644 --- a/src/quick/items/qquickview_p.h +++ b/src/quick/items/qquickview_p.h @@ -104,7 +104,7 @@ public: struct QQuickRootItemMarker : public QV4::Object { - Q_MANAGED + V4_OBJECT QQuickRootItemMarker(QQuickViewPrivate *view); diff --git a/tools/qmljs/main.cpp b/tools/qmljs/main.cpp index 9c10851b21..c5c94773b9 100644 --- a/tools/qmljs/main.cpp +++ b/tools/qmljs/main.cpp @@ -71,8 +71,9 @@ using namespace QV4; struct Print: FunctionObject { + V4_OBJECT Print(ExecutionContext *scope): FunctionObject(scope, QStringLiteral("print")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } static ReturnedValue call(Managed *, CallData *callData) @@ -86,29 +87,26 @@ struct Print: FunctionObject std::cout << std::endl; return Encode::undefined(); } - - static const ManagedVTable static_vtbl; }; -DEFINE_MANAGED_VTABLE(Print); +DEFINE_OBJECT_VTABLE(Print); struct GC: public FunctionObject { + V4_OBJECT GC(ExecutionContext* scope) : FunctionObject(scope, QStringLiteral("gc")) { - setVTable(&static_vtbl); + setVTable(staticVTable()); } static ReturnedValue call(Managed *m, CallData *) { m->engine()->memoryManager->runGC(); return Encode::undefined(); } - - static const ManagedVTable static_vtbl; }; -DEFINE_MANAGED_VTABLE(GC); +DEFINE_OBJECT_VTABLE(GC); } // builtins |