using namespace QV4;
-DEFINE_OBJECT_VTABLE(ArgumentsObject);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(ArgumentsObject);
ArgumentsObject::ArgumentsObject(CallContext *context)
: Object(context->strictMode ? context->engine->strictArgumentsObjectClass : context->engine->argumentsObjectClass)
Q_ASSERT(internalClass->vtable == staticVTable());
}
-void ArgumentsObject::destroy(Managed *that)
-{
- static_cast<ArgumentsObject *>(that)->~ArgumentsObject();
-}
-
void ArgumentsObject::fullyCreate()
{
if (fullyCreated)
return Attr_Accessor;
}
-DEFINE_OBJECT_VTABLE(ArgumentsGetterFunction);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(ArgumentsGetterFunction);
ReturnedValue ArgumentsGetterFunction::call(Managed *getter, CallData *callData)
{
return o->context->argument(g->index);
}
-DEFINE_OBJECT_VTABLE(ArgumentsSetterFunction);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(ArgumentsSetterFunction);
ReturnedValue ArgumentsSetterFunction::call(Managed *setter, CallData *callData)
{
bool fullyCreated;
Members mappedArguments;
ArgumentsObject(CallContext *context);
- ~ArgumentsObject() {}
static bool isNonStrictArgumentsObject(Managed *m) {
return m->internalClass->vtable->type == Type_ArgumentsObject &&
static bool deleteIndexedProperty(Managed *m, uint index);
static PropertyAttributes queryIndexed(const Managed *m, uint index);
static void markObjects(Managed *that, ExecutionEngine *e);
- static void destroy(Managed *);
void fullyCreate();
};
const ArrayVTable SimpleArrayData::static_vtbl =
{
- DEFINE_MANAGED_VTABLE_INT(SimpleArrayData),
+ DEFINE_MANAGED_VTABLE_NO_DESTROY_INT(SimpleArrayData),
SimpleArrayData::Simple,
SimpleArrayData::reallocate,
SimpleArrayData::get,
}
-void SimpleArrayData::destroy(Managed *)
-{
-}
-
void SimpleArrayData::markObjects(Managed *d, ExecutionEngine *e)
{
SimpleArrayData *dd = static_cast<SimpleArrayData *>(d);
static void getHeadRoom(Object *o);
static ArrayData *reallocate(Object *o, uint n, bool enforceAttributes);
- static void destroy(Managed *d);
static void markObjects(Managed *d, ExecutionEngine *e);
static ReturnedValue get(const ArrayData *d, uint index);
using namespace QV4;
-DEFINE_OBJECT_VTABLE(ArrayCtor);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(ArrayCtor);
ArrayCtor::ArrayCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("Array"))
using namespace QV4;
-DEFINE_OBJECT_VTABLE(BooleanCtor);
-DEFINE_OBJECT_VTABLE(BooleanObject);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(BooleanCtor);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(BooleanObject);
BooleanCtor::BooleanCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("Boolean"))
using namespace QV4;
-DEFINE_MANAGED_VTABLE(ExecutionContext);
+DEFINE_MANAGED_VTABLE_NO_DESTROY(ExecutionContext);
CallContext *ExecutionContext::newCallContext(FunctionObject *function, CallData *callData)
{
#endif
}
-DEFINE_OBJECT_VTABLE(DateObject);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(DateObject);
DateObject::DateObject(ExecutionEngine *engine, const QDateTime &date)
: Object(engine->dateClass)
return ToDateTime(value.asDouble(), Qt::LocalTime);
}
-DEFINE_OBJECT_VTABLE(DateCtor);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(DateCtor);
DateCtor::DateCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("Date"))
{
}
-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);
+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);
ErrorCtor::ErrorCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("Error"))
using namespace QV4;
-DEFINE_OBJECT_VTABLE(FunctionObject);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(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(FunctionCtor);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(FunctionCtor);
FunctionCtor::FunctionCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("Function"))
return ctx->engine->newBoundFunction(ctx->engine->rootContext, target, boundThis, boundArgs)->asReturnedValue();
}
-DEFINE_OBJECT_VTABLE(ScriptFunction);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(ScriptFunction);
ScriptFunction::ScriptFunction(ExecutionContext *scope, Function *function)
: SimpleScriptFunction(scope, function, true)
return result.asReturnedValue();
}
-DEFINE_OBJECT_VTABLE(SimpleScriptFunction);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(SimpleScriptFunction);
SimpleScriptFunction::SimpleScriptFunction(ExecutionContext *scope, Function *function, bool createProto)
: FunctionObject(scope, function->name(), createProto)
-DEFINE_OBJECT_VTABLE(BuiltinFunction);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(BuiltinFunction);
BuiltinFunction::BuiltinFunction(ExecutionContext *scope, const StringRef name, ReturnedValue (*code)(CallContext *))
: FunctionObject(scope, name)
return f->code(&ctx, f->index);
}
-DEFINE_OBJECT_VTABLE(IndexedBuiltinFunction);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(IndexedBuiltinFunction);
DEFINE_OBJECT_VTABLE(BoundFunction);
FunctionObject(InternalClass *ic);
static void markObjects(Managed *that, ExecutionEngine *e);
- static void destroy(Managed *that)
- { static_cast<FunctionObject*>(that)->~FunctionObject(); }
};
template<>
return QString();
}
-DEFINE_OBJECT_VTABLE(EvalFunction);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(EvalFunction);
EvalFunction::EvalFunction(ExecutionContext *scope)
: FunctionObject(scope, scope->engine->id_eval)
#endif
-DEFINE_OBJECT_VTABLE(JsonObject);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(JsonObject);
class JsonParser
{
0,
Managed::MyType,
"Managed",
- destroy,
+ 0,
0 /*markObjects*/,
isEqualTo
};
isEqualTo \
}
+#define DEFINE_MANAGED_VTABLE_NO_DESTROY_INT(classname) \
+{ \
+ classname::IsExecutionContext, \
+ classname::IsString, \
+ classname::IsObject, \
+ classname::IsFunctionObject, \
+ classname::IsErrorObject, \
+ classname::IsArrayData, \
+ 0, \
+ classname::MyType, \
+ #classname, \
+ 0, \
+ 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 = \
{ \
bool isEqualTo(Managed *other)
{ return internalClass->vtable->isEqualTo(this, other); }
- static void destroy(Managed *that) { that->_data = 0; }
static bool isEqualTo(Managed *m, Managed *other);
ReturnedValue asReturnedValue() { return Value::fromManaged(this).asReturnedValue(); }
using namespace QV4;
-DEFINE_OBJECT_VTABLE(MathObject);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(MathObject);
static const double qt_PI = 2.0 * ::asin(1.0);
using namespace QV4;
-const ManagedVTable MemberData::static_vtbl =
-{
- MemberData::IsExecutionContext,
- MemberData::IsString,
- MemberData::IsObject,
- MemberData::IsFunctionObject,
- MemberData::IsErrorObject,
- MemberData::IsArrayData,
- 0,
- MemberData::MyType,
- "MemberData",
- destroy,
- markObjects,
- isEqualTo
-};
-
-
+DEFINE_MANAGED_VTABLE_NO_DESTROY(MemberData);
void MemberData::markObjects(Managed *that, ExecutionEngine *e)
{
using namespace QV4;
-DEFINE_OBJECT_VTABLE(NumberCtor);
-DEFINE_OBJECT_VTABLE(NumberObject);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(NumberCtor);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(NumberObject);
NumberCtor::NumberCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("Number"))
using namespace QV4;
-DEFINE_OBJECT_VTABLE(Object);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(Object);
Object::Object(ExecutionEngine *engine)
: Managed(engine->objectClass)
}
}
-Object::~Object()
-{
- _data = 0;
-}
-
bool Object::setPrototype(Object *proto)
{
Object *pp = proto;
return true;
}
-void Object::destroy(Managed *that)
-{
- static_cast<Object *>(that)->~Object();
-}
-
void Object::put(ExecutionContext *ctx, const QString &name, const ValueRef value)
{
Scope scope(ctx);
}
-DEFINE_OBJECT_VTABLE(ArrayObject);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(ArrayObject);
ArrayObject::ArrayObject(ExecutionEngine *engine, const QStringList &list)
: Object(engine->arrayClass)
Object(ExecutionEngine *engine);
Object(InternalClass *internalClass);
- ~Object();
const ObjectVTable *vtable() const { return reinterpret_cast<const ObjectVTable *>(internalClass->vtable); }
Object *prototype() const { return internalClass->prototype; }
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 *);
}
-DEFINE_OBJECT_VTABLE(ForEachIteratorObject);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(ForEachIteratorObject);
void ForEachIteratorObject::markObjects(Managed *that, ExecutionEngine *e)
{
using namespace QV4;
-DEFINE_OBJECT_VTABLE(ObjectCtor);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(ObjectCtor);
ObjectCtor::ObjectCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("Object"))
using namespace QV4;
-DEFINE_OBJECT_VTABLE(RegExpObject);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(RegExpObject);
RegExpObject::RegExpObject(InternalClass *ic)
: Object(ic)
}
-void RegExpObject::destroy(Managed *that)
-{
- static_cast<RegExpObject *>(that)->~RegExpObject();
-}
-
void RegExpObject::markObjects(Managed *that, ExecutionEngine *e)
{
RegExpObject *re = static_cast<RegExpObject*>(that);
return f;
}
-DEFINE_OBJECT_VTABLE(RegExpCtor);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(RegExpCtor);
RegExpCtor::RegExpCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("RegExp"))
RegExpObject(ExecutionEngine *engine, RegExpRef value, bool global);
RegExpObject(ExecutionEngine *engine, const QRegExp &re);
- ~RegExpObject() {}
void init(ExecutionEngine *engine);
protected:
RegExpObject(InternalClass *ic);
- static void destroy(Managed *that);
static void markObjects(Managed *that, ExecutionEngine *e);
};
return function->asReturned<FunctionObject>();
}
-DEFINE_OBJECT_VTABLE(QmlBindingWrapper);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(QmlBindingWrapper);
struct CompilationUnitHolder : public QV4::Object
{
using namespace QV4;
-DEFINE_OBJECT_VTABLE(StringObject);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(StringObject);
StringObject::StringObject(InternalClass *ic)
: Object(ic)
Object::markObjects(that, e);
}
-DEFINE_OBJECT_VTABLE(StringCtor);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(StringCtor);
StringCtor::StringCtor(ExecutionContext *scope)
: FunctionObject(scope, QStringLiteral("String"))
return QJSValuePrivate::get(siinfo->scriptApi(e))->getValue(engine());
}
-DEFINE_OBJECT_VTABLE(QQmlIdObjectsArray);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(QQmlIdObjectsArray);
QQmlIdObjectsArray::QQmlIdObjectsArray(ExecutionEngine *engine, QmlContextWrapper *contextWrapper)
: Object(engine)
};
-DEFINE_OBJECT_VTABLE(NodePrototype);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(NodePrototype);
class Node : public Object
{
Object *proto;
};
-DEFINE_OBJECT_VTABLE(QQmlXMLHttpRequestCtor);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(QQmlXMLHttpRequestCtor);
void QQmlXMLHttpRequestCtor::setupProto()
{
using namespace QV4;
-DEFINE_OBJECT_VTABLE(QtObject);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(QtObject);
struct StaticQtMetaObject : public QObject
{
static ReturnedValue call(Managed *that, CallData *callData);
static void markObjects(Managed *that, ExecutionEngine *e);
+ static void destroy(Managed *that) {
+ static_cast<QQmlBindingFunction *>(that)->~QQmlBindingFunction();
+ }
QV4::FunctionObject *originalFunction;
// Set when the binding is created later
}
};
-DEFINE_OBJECT_VTABLE(DelegateModelGroupFunction);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(DelegateModelGroupFunction);
QQmlChangeSet::Change change;
};
-DEFINE_OBJECT_VTABLE(QQmlDelegateModelGroupChange);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(QQmlDelegateModelGroupChange);
class QQmlDelegateModelGroupChangeArray : public QV4::Object
{
static QV4::ReturnedValue method_set_textBaseline(QV4::CallContext *ctx);
protected:
- static void destroy(Managed *that)
- {
- static_cast<QQuickJSContext2D *>(that)->~QQuickJSContext2D();
- }
};
-DEFINE_OBJECT_VTABLE(QQuickJSContext2D);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(QQuickJSContext2D);
struct QQuickJSContext2DPrototype : public QV4::Object
};
-DEFINE_OBJECT_VTABLE(QQuickJSContext2DPrototype);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(QQuickJSContext2DPrototype);
class QQuickContext2DStyle : public QV4::Object
DEFINE_REF(QQuickJSContext2DImageData, QV4::Object);
-DEFINE_OBJECT_VTABLE(QQuickJSContext2DImageData);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(QQuickJSContext2DImageData);
static QV4::ReturnedValue qt_create_image_data(qreal w, qreal h, QV8Engine* engine, const QImage& image)
{
}
};
-DEFINE_OBJECT_VTABLE(Print);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(Print);
struct GC: public FunctionObject
{
}
};
-DEFINE_OBJECT_VTABLE(GC);
+DEFINE_OBJECT_VTABLE_NO_DESTROY(GC);
} // builtins