QV4::Heap::QQmlSqlDatabaseWrapper::QQmlSqlDatabaseWrapper(ExecutionEngine *e)
: QV4::Heap::Object(e)
{
- setVTable(QV4::QQmlSqlDatabaseWrapper::staticVTable());
type = Database;
}
: QV4::Heap::Object(engine)
, datum(datum)
{
- setVTable(QV4ParticleData::staticVTable());
}
QQuickParticleData* datum;//TODO: Guard needed?
};
: Heap::FunctionObject(scope)
, index(index)
{
- setVTable(QV4::ArgumentsGetterFunction::staticVTable());
}
struct ArgumentsSetterFunction: FunctionObject
: Heap::FunctionObject(scope)
, index(index)
{
- setVTable(QV4::ArgumentsSetterFunction::staticVTable());
}
Heap::ArrayBufferCtor::ArrayBufferCtor(QV4::ExecutionContext *scope)
: Heap::FunctionObject(scope, QStringLiteral("ArrayBuffer"))
{
- setVTable(QV4::ArrayBufferCtor::staticVTable());
}
ReturnedValue ArrayBufferCtor::construct(Managed *m, CallData *callData)
inline SparseArrayData::SparseArrayData(ExecutionEngine *engine)
: ArrayData(engine->emptyClass)
{
- setVTable(QV4::SparseArrayData::staticVTable());
}
inline SparseArrayData::~SparseArrayData()
Heap::ArrayCtor::ArrayCtor(QV4::ExecutionContext *scope)
: Heap::FunctionObject(scope, QStringLiteral("Array"))
{
- setVTable(QV4::ArrayCtor::staticVTable());
}
ReturnedValue ArrayCtor::construct(Managed *m, CallData *callData)
Heap::BooleanCtor::BooleanCtor(QV4::ExecutionContext *scope)
: Heap::FunctionObject(scope, QStringLiteral("Boolean"))
{
- setVTable(QV4::BooleanCtor::staticVTable());
}
ReturnedValue BooleanCtor::construct(Managed *m, CallData *callData)
Heap::DataViewCtor::DataViewCtor(QV4::ExecutionContext *scope)
: Heap::FunctionObject(scope, QStringLiteral("DataView"))
{
- setVTable(QV4::DataViewCtor::staticVTable());
}
ReturnedValue DataViewCtor::construct(Managed *m, CallData *callData)
Heap::DateObject::DateObject(QV4::ExecutionEngine *engine, const QDateTime &date)
: Heap::Object(engine->emptyClass, engine->datePrototype.asObject())
{
- setVTable(QV4::DateObject::staticVTable());
value.setDouble(date.isValid() ? date.toMSecsSinceEpoch() : qSNaN());
}
Heap::DateCtor::DateCtor(QV4::ExecutionContext *scope)
: Heap::FunctionObject(scope, QStringLiteral("Date"))
{
- setVTable(QV4::DateCtor::staticVTable());
}
ReturnedValue DateCtor::construct(Managed *m, CallData *callData)
Heap::ErrorCtor::ErrorCtor(QV4::ExecutionContext *scope)
: Heap::FunctionObject(scope, QStringLiteral("Error"))
{
- setVTable(QV4::ErrorCtor::staticVTable());
}
Heap::ErrorCtor::ErrorCtor(QV4::ExecutionContext *scope, const QString &name)
: Heap::FunctionObject(scope, name)
{
- setVTable(QV4::ErrorCtor::staticVTable());
}
ReturnedValue ErrorCtor::construct(Managed *m, CallData *callData)
Heap::EvalErrorCtor::EvalErrorCtor(QV4::ExecutionContext *scope)
: Heap::ErrorCtor(scope, QStringLiteral("EvalError"))
{
- setVTable(QV4::EvalErrorCtor::staticVTable());
}
ReturnedValue EvalErrorCtor::construct(Managed *m, CallData *callData)
Heap::RangeErrorCtor::RangeErrorCtor(QV4::ExecutionContext *scope)
: Heap::ErrorCtor(scope, QStringLiteral("RangeError"))
{
- setVTable(QV4::RangeErrorCtor::staticVTable());
}
ReturnedValue RangeErrorCtor::construct(Managed *m, CallData *callData)
Heap::ReferenceErrorCtor::ReferenceErrorCtor(QV4::ExecutionContext *scope)
: Heap::ErrorCtor(scope, QStringLiteral("ReferenceError"))
{
- setVTable(QV4::ReferenceErrorCtor::staticVTable());
}
ReturnedValue ReferenceErrorCtor::construct(Managed *m, CallData *callData)
Heap::SyntaxErrorCtor::SyntaxErrorCtor(QV4::ExecutionContext *scope)
: Heap::ErrorCtor(scope, QStringLiteral("SyntaxError"))
{
- setVTable(QV4::SyntaxErrorCtor::staticVTable());
}
ReturnedValue SyntaxErrorCtor::construct(Managed *m, CallData *callData)
Heap::TypeErrorCtor::TypeErrorCtor(QV4::ExecutionContext *scope)
: Heap::ErrorCtor(scope, QStringLiteral("TypeError"))
{
- setVTable(QV4::TypeErrorCtor::staticVTable());
}
ReturnedValue TypeErrorCtor::construct(Managed *m, CallData *callData)
Heap::URIErrorCtor::URIErrorCtor(QV4::ExecutionContext *scope)
: Heap::ErrorCtor(scope, QStringLiteral("URIError"))
{
- setVTable(QV4::URIErrorCtor::staticVTable());
}
ReturnedValue URIErrorCtor::construct(Managed *m, CallData *callData)
Heap::FunctionCtor::FunctionCtor(QV4::ExecutionContext *scope)
: Heap::FunctionObject(scope, QStringLiteral("Function"))
{
- setVTable(QV4::FunctionCtor::staticVTable());
}
// 15.3.2
Heap::ScriptFunction::ScriptFunction(QV4::ExecutionContext *scope, Function *function)
: Heap::SimpleScriptFunction(scope, function, true)
{
- setVTable(QV4::ScriptFunction::staticVTable());
}
ReturnedValue ScriptFunction::construct(Managed *that, CallData *callData)
Heap::SimpleScriptFunction::SimpleScriptFunction(QV4::ExecutionContext *scope, Function *function, bool createProto)
: Heap::FunctionObject(scope, function, createProto)
{
- setVTable(QV4::SimpleScriptFunction::staticVTable());
-
this->function = function;
function->compilationUnit->addref();
Q_ASSERT(function);
: Heap::FunctionObject(scope, name)
, code(code)
{
- setVTable(QV4::BuiltinFunction::staticVTable());
}
ReturnedValue BuiltinFunction::construct(Managed *f, CallData *)
, boundArgs(boundArgs ? boundArgs->d() : 0)
{
this->boundThis = boundThis;
- setVTable(QV4::BoundFunction::staticVTable());
Scope s(scope);
ScopedObject f(s, this);
code(code)
, index(index)
{
- setVTable(QV4::IndexedBuiltinFunction::staticVTable());
}
Heap::EvalFunction::EvalFunction(QV4::ExecutionContext *scope)
: Heap::FunctionObject(scope, scope->d()->engine->id_eval)
{
- setVTable(QV4::EvalFunction::staticVTable());
Scope s(scope);
ScopedFunctionObject f(s, this);
f->defineReadonlyProperty(s.engine->id_length, Primitive::fromInt32(1));
return QString::fromLatin1(s);
}
-void Managed::setVTable(const ManagedVTable *vt)
-{
- d()->vtable = vt;
- Q_ASSERT(internalClass());
-}
-
-void Heap::Base::setVTable(const ManagedVTable *vt)
-{
- vtable = vt;
- Q_ASSERT(internalClass);
-}
-
-
bool Managed::isEqualTo(Managed *, Managed *)
{
return false;
QString className() const;
- void setVTable(const ManagedVTable *vt);
-
bool isEqualTo(const Managed *other) const
{ return d()->vtable->isEqualTo(const_cast<Managed *>(this), const_cast<Managed *>(other)); }
Heap::NumberCtor::NumberCtor(QV4::ExecutionContext *scope)
: Heap::FunctionObject(scope, QStringLiteral("Number"))
{
- setVTable(QV4::NumberCtor::staticVTable());
}
ReturnedValue NumberCtor::construct(Managed *m, CallData *callData)
: Heap::Object(engine)
, it(engine, workArea, workArea + 1, o, ObjectIterator::EnumerableOnly|ObjectIterator::WithProtoChain)
{
- setVTable(QV4::ForEachIteratorObject::staticVTable());
}
Heap::ObjectCtor::ObjectCtor(QV4::ExecutionContext *scope)
: Heap::FunctionObject(scope, QStringLiteral("Object"))
{
- setVTable(QV4::ObjectCtor::staticVTable());
}
ReturnedValue ObjectCtor::construct(Managed *that, CallData *callData)
: Heap::Object(engine)
, object(object)
{
- setVTable(QV4::QObjectWrapper::staticVTable());
}
void QObjectWrapper::initializeBindings(ExecutionEngine *engine)
Heap::QObjectMethod::QObjectMethod(QV4::ExecutionContext *scope)
: Heap::FunctionObject(scope)
{
- setVTable(QV4::QObjectMethod::staticVTable());
}
const QMetaObject *Heap::QObjectMethod::metaObject()
, object(object)
, signalIndex(signalIndex)
{
- setVTable(QV4::QmlSignalHandler::staticVTable());
}
DEFINE_OBJECT_VTABLE(QmlSignalHandler);
, ignoreCase(ignoreCase)
, multiLine(multiline)
{
- setVTable(QV4::RegExp::staticVTable());
const char* error = 0;
JSC::Yarr::YarrPattern yarrPattern(WTF::String(pattern), ignoreCase, multiline, &error);
if (error)
Heap::RegExpObject::RegExpObject(InternalClass *ic, QV4::Object *prototype)
: Heap::Object(ic, prototype)
{
- setVTable(QV4::RegExpObject::staticVTable());
-
Scope scope(ic->engine);
Scoped<QV4::RegExpObject> o(scope, this);
o->d()->value = QV4::RegExp::create(ic->engine, QString(), false, false);
, value(value->d())
, global(global)
{
- setVTable(QV4::RegExpObject::staticVTable());
-
Scope scope(engine);
Scoped<QV4::RegExpObject> o(scope, this);
o->init(engine);
Heap::RegExpObject::RegExpObject(QV4::ExecutionEngine *engine, const QRegExp &re)
: Heap::Object(engine->emptyClass, engine->regExpPrototype.asObject())
{
- setVTable(QV4::RegExpObject::staticVTable());
-
value = 0;
global = false;
Heap::RegExpCtor::RegExpCtor(QV4::ExecutionContext *scope)
: Heap::FunctionObject(scope, QStringLiteral("RegExp"))
{
- setVTable(QV4::RegExpCtor::staticVTable());
clearLastMatch();
}
: Heap::Object(engine)
, unit(unit)
{
- setVTable(QV4::CompilationUnitHolder::staticVTable());
}
}
{
Q_ASSERT(scope->inUse());
- setVTable(QV4::QmlBindingWrapper::staticVTable());
function = f;
if (function)
function->compilationUnit->addref();
{
Q_ASSERT(scope->inUse());
- setVTable(QV4::QmlBindingWrapper::staticVTable());
-
Scope s(scope);
Scoped<QV4::QmlBindingWrapper> o(s, this);
value = val;
Q_ASSERT(value.isString());
tmpProperty.value = Primitive::undefinedValue();
- setVTable(QV4::StringObject::staticVTable());
Scope scope(engine);
ScopedObject s(scope, this);
Heap::StringCtor::StringCtor(QV4::ExecutionContext *scope)
: Heap::FunctionObject(scope, QStringLiteral("String"))
{
- setVTable(QV4::StringCtor::staticVTable());
}
ReturnedValue StringCtor::construct(Managed *m, CallData *callData)
: Heap::FunctionObject(scope, QLatin1String(operations[t].name))
, type(t)
{
- setVTable(QV4::TypedArrayCtor::staticVTable());
}
ReturnedValue TypedArrayCtor::construct(Managed *m, CallData *callData)
: Heap::Object(e)
, type(t)
{
- setVTable(QV4::TypedArrayPrototype::staticVTable());
}
} // namespace QV4
};
InternalClass *internalClass;
- void setVTable(const ManagedVTable *vt);
inline ReturnedValue asReturnedValue() const;
inline void mark(QV4::ExecutionEngine *engine);
, qmlGlobal(QV4::Primitive::undefinedValue())
, statusChanged(QV4::Primitive::undefinedValue())
{
- setVTable(QV4::QmlIncubatorObject::staticVTable());
-
incubator.reset(new QQmlComponentIncubator(this, m));
}
, context(context)
, scopeObject(scopeObject)
{
- setVTable(QV4::QmlContextWrapper::staticVTable());
}
Heap::QmlContextWrapper::~QmlContextWrapper()
: Heap::Object(engine)
, contextWrapper(contextWrapper->d())
{
- setVTable(QV4::QQmlIdObjectsArray::staticVTable());
}
ReturnedValue QQmlIdObjectsArray::getIndexed(Managed *m, uint index, bool *hasProperty)
Heap::QmlListWrapper::QmlListWrapper(ExecutionEngine *engine)
: Heap::Object(engine)
{
- setVTable(QV4::QmlListWrapper::staticVTable());
-
QV4::Scope scope(engine);
QV4::ScopedObject o(scope, this);
o->setArrayType(Heap::ArrayData::Custom);
Heap::QQmlLocaleData::QQmlLocaleData(ExecutionEngine *engine)
: Heap::Object(engine)
{
- setVTable(QV4::QQmlLocaleData::staticVTable());
}
}
: Heap::Object(engine)
, mode(IncludeEnums)
{
- setVTable(QV4::QmlTypeWrapper::staticVTable());
}
Heap::QmlTypeWrapper::~QmlTypeWrapper()
: Heap::Object(engine)
, gadgetPtr(0)
{
- setVTable(QV4::QQmlValueTypeWrapper::staticVTable());
}
Heap::QQmlValueTypeWrapper::~QQmlValueTypeWrapper()
Heap::QQmlValueTypeReference::QQmlValueTypeReference(ExecutionEngine *engine)
: Heap::QQmlValueTypeWrapper(engine)
{
- setVTable(QV4::QQmlValueTypeReference::staticVTable());
}
bool QQmlValueTypeReference::readReferenceValue() const
, list(list)
, d(data)
{
- setVTable(QV4::NamedNodeMap::staticVTable());
-
if (d)
d->addref();
}
: Heap::Object(engine)
, d(data)
{
- setVTable(QV4::NodeList::staticVTable());
-
if (d)
d->addref();
}
Heap::NodePrototype::NodePrototype(ExecutionEngine *engine)
: Heap::Object(engine)
{
- setVTable(QV4::NodePrototype::staticVTable());
-
Scope scope(engine);
ScopedObject o(scope, this);
: Heap::Object(engine)
, d(data)
{
- setVTable(QV4::Node::staticVTable());
-
if (d)
d->addref();
}
: Heap::Object(engine)
, request(request)
{
- setVTable(QV4::QQmlXMLHttpRequestWrapper::staticVTable());
}
struct QQmlXMLHttpRequestCtor : public FunctionObject
Heap::QQmlXMLHttpRequestCtor::QQmlXMLHttpRequestCtor(ExecutionEngine *engine)
: Heap::FunctionObject(engine->rootContext(), QStringLiteral("XMLHttpRequest"))
{
- setVTable(QV4::QQmlXMLHttpRequestCtor::staticVTable());
Scope scope(engine);
Scoped<QV4::QQmlXMLHttpRequestCtor> ctor(scope, this);
Heap::QtObject::QtObject(ExecutionEngine *v4, QQmlEngine *qmlEngine)
: Heap::Object(v4)
{
- setVTable(QV4::QtObject::staticVTable());
-
Scope scope(v4);
ScopedObject o(scope, this);
: QV4::Heap::FunctionObject(originalFunction->scope(), originalFunction->name())
, originalFunction(originalFunction->d())
{
- setVTable(QV4::QQmlBindingFunction::staticVTable());
}
void QQmlBindingFunction::initBindingLocation()
, flag(flag)
, code(code)
{
- setVTable(QV4::DelegateModelGroupFunction::staticVTable());
}
}
QV4::Heap::QQmlDelegateModelGroupChange::QQmlDelegateModelGroupChange(QV4::ExecutionEngine *engine)
: QV4::Heap::Object(engine)
{
- setVTable(::QQmlDelegateModelGroupChange::staticVTable());
}
DEFINE_OBJECT_VTABLE(QQmlDelegateModelGroupChange);
: QV4::Heap::Object(engine)
, changes(changes)
{
- setVTable(::QQmlDelegateModelGroupChangeArray::staticVTable());
QV4::Scope scope(engine);
QV4::ScopedObject o(scope, this);
o->setArrayType(QV4::Heap::ArrayData::Custom);
: QV4::Heap::Object(engine)
, item(item)
{
- setVTable(::QQmlDelegateModelItemObject::staticVTable());
}
QV4::Heap::QQuickJSContext2D::QQuickJSContext2D(QV4::ExecutionEngine *engine)
: QV4::Heap::Object(engine)
{
- setVTable(::QQuickJSContext2D::staticVTable());
}
DEFINE_OBJECT_VTABLE(QQuickJSContext2D);
{
patternRepeatX = false;
patternRepeatY = false;
- setVTable(::QQuickContext2DStyle::staticVTable());
}
DEFINE_OBJECT_VTABLE(QQuickContext2DStyle);
QV4::Heap::QQuickJSContext2DPixelData::QQuickJSContext2DPixelData(QV4::ExecutionEngine *engine)
: QV4::Heap::Object(engine)
{
- setVTable(::QQuickJSContext2DPixelData::staticVTable());
QV4::Scope scope(engine);
QV4::ScopedObject o(scope, this);
o->setArrayType(QV4::Heap::ArrayData::Custom);
QV4::Heap::QQuickJSContext2DImageData::QQuickJSContext2DImageData(QV4::ExecutionEngine *engine)
: QV4::Heap::Object(engine)
{
- setVTable(::QQuickJSContext2DImageData::staticVTable());
pixelData = QV4::Primitive::undefinedValue();
QV4::Scope scope(engine);
: Heap::Object(engine)
, window(window)
{
- setVTable(QV4::QQuickRootItemMarker::staticVTable());
}
}
{
struct Data : Heap::FunctionObject {
Data(ExecutionContext *scope)
- : Heap::FunctionObject(scope, QStringLiteral("print")) {
- setVTable(staticVTable());
+ : Heap::FunctionObject(scope, QStringLiteral("print"))
+ {
}
};
V4_OBJECT(FunctionObject)
Data(ExecutionContext *scope)
: Heap::FunctionObject(scope, QStringLiteral("gc"))
{
- setVTable(staticVTable());
}
};