Detect existence of a a vtable entry at compile time.
Change-Id: Ieed5d34b063184bc4435b22c6685ac0e3fabf493
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>
using namespace QV4;
-DEFINE_OBJECT_VTABLE_NO_DESTROY(ArgumentsObject);
+DEFINE_OBJECT_VTABLE(ArgumentsObject);
ArgumentsObject::ArgumentsObject(CallContext *context)
: Object(context->strictMode ? context->engine->strictArgumentsObjectClass : context->engine->argumentsObjectClass)
return Attr_Accessor;
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(ArgumentsGetterFunction);
+DEFINE_OBJECT_VTABLE(ArgumentsGetterFunction);
ReturnedValue ArgumentsGetterFunction::call(Managed *getter, CallData *callData)
{
return o->context->argument(g->index);
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(ArgumentsSetterFunction);
+DEFINE_OBJECT_VTABLE(ArgumentsSetterFunction);
ReturnedValue ArgumentsSetterFunction::call(Managed *setter, CallData *callData)
{
const ArrayVTable SimpleArrayData::static_vtbl =
{
- DEFINE_MANAGED_VTABLE_NO_DESTROY_INT(SimpleArrayData),
+ DEFINE_MANAGED_VTABLE_INT(SimpleArrayData),
SimpleArrayData::Simple,
SimpleArrayData::reallocate,
SimpleArrayData::get,
using namespace QV4;
-DEFINE_OBJECT_VTABLE_NO_DESTROY(ArrayCtor);
+DEFINE_OBJECT_VTABLE(ArrayCtor);
ArrayCtor::ArrayCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("Array"))
using namespace QV4;
-DEFINE_OBJECT_VTABLE_NO_DESTROY(BooleanCtor);
-DEFINE_OBJECT_VTABLE_NO_DESTROY(BooleanObject);
+DEFINE_OBJECT_VTABLE(BooleanCtor);
+DEFINE_OBJECT_VTABLE(BooleanObject);
BooleanCtor::BooleanCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("Boolean"))
using namespace QV4;
-DEFINE_MANAGED_VTABLE_NO_DESTROY(ExecutionContext);
+DEFINE_MANAGED_VTABLE(ExecutionContext);
CallContext *ExecutionContext::newCallContext(FunctionObject *function, CallData *callData)
{
#endif
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(DateObject);
+DEFINE_OBJECT_VTABLE(DateObject);
DateObject::DateObject(ExecutionEngine *engine, const QDateTime &date)
: Object(engine->dateClass)
return ToDateTime(value.asDouble(), Qt::LocalTime);
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(DateCtor);
+DEFINE_OBJECT_VTABLE(DateCtor);
DateCtor::DateCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("Date"))
{
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(ErrorCtor);
-DEFINE_OBJECT_VTABLE_NO_DESTROY(EvalErrorCtor);
-DEFINE_OBJECT_VTABLE_NO_DESTROY(RangeErrorCtor);
-DEFINE_OBJECT_VTABLE_NO_DESTROY(ReferenceErrorCtor);
-DEFINE_OBJECT_VTABLE_NO_DESTROY(SyntaxErrorCtor);
-DEFINE_OBJECT_VTABLE_NO_DESTROY(TypeErrorCtor);
-DEFINE_OBJECT_VTABLE_NO_DESTROY(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"))
using namespace QV4;
-DEFINE_OBJECT_VTABLE_NO_DESTROY(FunctionObject);
+DEFINE_OBJECT_VTABLE(FunctionObject);
FunctionObject::FunctionObject(ExecutionContext *scope, const StringRef name, bool createProto)
: Object(scope->engine->functionClass)
return new (scope->engine->memoryManager) SimpleScriptFunction(scope, function, createProto);
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(FunctionCtor);
+DEFINE_OBJECT_VTABLE(FunctionCtor);
FunctionCtor::FunctionCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("Function"))
return ctx->engine->newBoundFunction(ctx->engine->rootContext, target, boundThis, boundArgs)->asReturnedValue();
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(ScriptFunction);
+DEFINE_OBJECT_VTABLE(ScriptFunction);
ScriptFunction::ScriptFunction(ExecutionContext *scope, Function *function)
: SimpleScriptFunction(scope, function, true)
return result.asReturnedValue();
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(SimpleScriptFunction);
+DEFINE_OBJECT_VTABLE(SimpleScriptFunction);
SimpleScriptFunction::SimpleScriptFunction(ExecutionContext *scope, Function *function, bool createProto)
: FunctionObject(scope, function->name(), createProto)
-DEFINE_OBJECT_VTABLE_NO_DESTROY(BuiltinFunction);
+DEFINE_OBJECT_VTABLE(BuiltinFunction);
BuiltinFunction::BuiltinFunction(ExecutionContext *scope, const StringRef name, ReturnedValue (*code)(CallContext *))
: FunctionObject(scope, name)
return f->code(&ctx, f->index);
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(IndexedBuiltinFunction);
+DEFINE_OBJECT_VTABLE(IndexedBuiltinFunction);
DEFINE_OBJECT_VTABLE(BoundFunction);
return QString();
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(EvalFunction);
+DEFINE_OBJECT_VTABLE(EvalFunction);
EvalFunction::EvalFunction(ExecutionContext *scope)
: FunctionObject(scope, scope->engine->id_eval)
#endif
-DEFINE_OBJECT_VTABLE_NO_DESTROY(JsonObject);
+DEFINE_OBJECT_VTABLE(JsonObject);
class JsonParser
{
using namespace QV4;
+
const ManagedVTable Managed::static_vtbl =
{
Managed::IsExecutionContext,
public: \
enum { MyType = Type_##type };
+#define Q_VTABLE_FUNCTION(classname, func) \
+ (classname::func == QV4::Managed::func ? 0 : classname::func)
+
+
struct GCDeletable
{
GCDeletable() : next(0), lastCall(false) {}
void (*advanceIterator)(Managed *m, ObjectIterator *it, StringRef name, uint *index, Property *p, PropertyAttributes *attributes);
};
-#define DEFINE_MANAGED_VTABLE_INT(classname) \
-{ \
- classname::IsExecutionContext, \
- classname::IsString, \
- classname::IsObject, \
- classname::IsFunctionObject, \
- classname::IsErrorObject, \
- classname::IsArrayData, \
- 0, \
- classname::MyType, \
- #classname, \
- destroy, \
- markObjects, \
- isEqualTo \
-}
-#define DEFINE_MANAGED_VTABLE_NO_DESTROY_INT(classname) \
+#define DEFINE_MANAGED_VTABLE_INT(classname) \
{ \
classname::IsExecutionContext, \
classname::IsString, \
0, \
classname::MyType, \
#classname, \
- 0, \
+ Q_VTABLE_FUNCTION(classname, destroy), \
markObjects, \
isEqualTo \
}
#define DEFINE_MANAGED_VTABLE(classname) \
const QV4::ManagedVTable classname::static_vtbl = DEFINE_MANAGED_VTABLE_INT(classname)
-#define DEFINE_MANAGED_VTABLE_NO_DESTROY(classname) \
-const QV4::ManagedVTable classname::static_vtbl = DEFINE_MANAGED_VTABLE_NO_DESTROY_INT(classname)
#define DEFINE_OBJECT_VTABLE(classname) \
advanceIterator \
}
-#define DEFINE_OBJECT_VTABLE_NO_DESTROY(classname) \
-const QV4::ObjectVTable classname::static_vtbl = \
-{ \
- DEFINE_MANAGED_VTABLE_NO_DESTROY_INT(classname), \
- call, \
- construct, \
- get, \
- getIndexed, \
- put, \
- putIndexed, \
- query, \
- queryIndexed, \
- deleteProperty, \
- deleteIndexedProperty, \
- getLookup, \
- setLookup, \
- getLength, \
- advanceIterator \
-}
-
-#define DEFINE_MANAGED_VTABLE_WITH_NAME(classname, name) \
-const QV4::ObjectVTable classname::static_vtbl = \
-{ \
- DEFINE_MANAGED_VTABLE_INT(name), \
- call, \
- construct, \
- get, \
- getIndexed, \
- put, \
- putIndexed, \
- query, \
- queryIndexed, \
- deleteProperty, \
- deleteIndexedProperty, \
- getLookup, \
- setLookup, \
- getLength, \
- advanceIterator \
-}
-
-
struct Q_QML_PRIVATE_EXPORT Managed
{
V4_MANAGED
uchar _flags;
};
};
+ static void destroy(Managed *) {}
private:
friend class MemoryManager;
using namespace QV4;
-DEFINE_OBJECT_VTABLE_NO_DESTROY(MathObject);
+DEFINE_OBJECT_VTABLE(MathObject);
static const double qt_PI = 2.0 * ::asin(1.0);
using namespace QV4;
-DEFINE_MANAGED_VTABLE_NO_DESTROY(MemberData);
+DEFINE_MANAGED_VTABLE(MemberData);
void MemberData::markObjects(Managed *that, ExecutionEngine *e)
{
using namespace QV4;
-DEFINE_OBJECT_VTABLE_NO_DESTROY(NumberCtor);
-DEFINE_OBJECT_VTABLE_NO_DESTROY(NumberObject);
+DEFINE_OBJECT_VTABLE(NumberCtor);
+DEFINE_OBJECT_VTABLE(NumberObject);
NumberCtor::NumberCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("Number"))
using namespace QV4;
-DEFINE_OBJECT_VTABLE_NO_DESTROY(Object);
+DEFINE_OBJECT_VTABLE(Object);
Object::Object(ExecutionEngine *engine)
: Managed(engine->objectClass)
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(ArrayObject);
+DEFINE_OBJECT_VTABLE(ArrayObject);
ArrayObject::ArrayObject(ExecutionEngine *engine, const QStringList &list)
: Object(engine->arrayClass)
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(ForEachIteratorObject);
+DEFINE_OBJECT_VTABLE(ForEachIteratorObject);
void ForEachIteratorObject::markObjects(Managed *that, ExecutionEngine *e)
{
using namespace QV4;
-DEFINE_OBJECT_VTABLE_NO_DESTROY(ObjectCtor);
+DEFINE_OBJECT_VTABLE(ObjectCtor);
ObjectCtor::ObjectCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("Object"))
bool multiLine() const { return m_multiLine; }
int captureCount() const { return m_subPatternCount + 1; }
-protected:
static void destroy(Managed *that);
static void markObjects(Managed *that, QV4::ExecutionEngine *e);
using namespace QV4;
-DEFINE_OBJECT_VTABLE_NO_DESTROY(RegExpObject);
+DEFINE_OBJECT_VTABLE(RegExpObject);
RegExpObject::RegExpObject(InternalClass *ic)
: Object(ic)
return f;
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(RegExpCtor);
+DEFINE_OBJECT_VTABLE(RegExpCtor);
RegExpCtor::RegExpCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("RegExp"))
return function->asReturned<FunctionObject>();
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(QmlBindingWrapper);
+DEFINE_OBJECT_VTABLE(QmlBindingWrapper);
struct CompilationUnitHolder : public QV4::Object
{
using namespace QV4;
-DEFINE_OBJECT_VTABLE_NO_DESTROY(StringObject);
+DEFINE_OBJECT_VTABLE(StringObject);
StringObject::StringObject(InternalClass *ic)
: Object(ic)
Object::markObjects(that, e);
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(StringCtor);
+DEFINE_OBJECT_VTABLE(StringCtor);
StringCtor::StringCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("String"))
return QJSValuePrivate::get(siinfo->scriptApi(e))->getValue(engine());
}
-DEFINE_OBJECT_VTABLE_NO_DESTROY(QQmlIdObjectsArray);
+DEFINE_OBJECT_VTABLE(QQmlIdObjectsArray);
QQmlIdObjectsArray::QQmlIdObjectsArray(ExecutionEngine *engine, QmlContextWrapper *contextWrapper)
: Object(engine)
};
-DEFINE_OBJECT_VTABLE_NO_DESTROY(NodePrototype);
+DEFINE_OBJECT_VTABLE(NodePrototype);
class Node : public Object
{
Object *proto;
};
-DEFINE_OBJECT_VTABLE_NO_DESTROY(QQmlXMLHttpRequestCtor);
+DEFINE_OBJECT_VTABLE(QQmlXMLHttpRequestCtor);
void QQmlXMLHttpRequestCtor::setupProto()
{
using namespace QV4;
-DEFINE_OBJECT_VTABLE_NO_DESTROY(QtObject);
+DEFINE_OBJECT_VTABLE(QtObject);
struct StaticQtMetaObject : public QObject
{
}
};
-DEFINE_OBJECT_VTABLE_NO_DESTROY(DelegateModelGroupFunction);
+DEFINE_OBJECT_VTABLE(DelegateModelGroupFunction);
QQmlChangeSet::Change change;
};
-DEFINE_OBJECT_VTABLE_NO_DESTROY(QQmlDelegateModelGroupChange);
+DEFINE_OBJECT_VTABLE(QQmlDelegateModelGroupChange);
class QQmlDelegateModelGroupChangeArray : public QV4::Object
{
protected:
};
-DEFINE_OBJECT_VTABLE_NO_DESTROY(QQuickJSContext2D);
+DEFINE_OBJECT_VTABLE(QQuickJSContext2D);
struct QQuickJSContext2DPrototype : public QV4::Object
};
-DEFINE_OBJECT_VTABLE_NO_DESTROY(QQuickJSContext2DPrototype);
+DEFINE_OBJECT_VTABLE(QQuickJSContext2DPrototype);
class QQuickContext2DStyle : public QV4::Object
DEFINE_REF(QQuickJSContext2DImageData, QV4::Object);
-DEFINE_OBJECT_VTABLE_NO_DESTROY(QQuickJSContext2DImageData);
+DEFINE_OBJECT_VTABLE(QQuickJSContext2DImageData);
static QV4::ReturnedValue qt_create_image_data(qreal w, qreal h, QV8Engine* engine, const QImage& image)
{
}
};
-DEFINE_OBJECT_VTABLE_NO_DESTROY(Print);
+DEFINE_OBJECT_VTABLE(Print);
struct GC: public FunctionObject
{
}
};
-DEFINE_OBJECT_VTABLE_NO_DESTROY(GC);
+DEFINE_OBJECT_VTABLE(GC);
} // builtins