Scoped<Object> p(scope, o->prototype());
if (!p)
return QJSValue(NullValue);
- return new QJSValuePrivate(o->internalClass->engine, p);
+ return new QJSValuePrivate(o->internalClass()->engine, p);
}
/*!
setArrayType(ArrayData::Complex);
if (context->strictMode) {
- Q_ASSERT(CalleePropertyIndex == internalClass->find(context->engine->id_callee));
- Q_ASSERT(CallerPropertyIndex == internalClass->find(context->engine->id_caller));
+ Q_ASSERT(CalleePropertyIndex == internalClass()->find(context->engine->id_callee));
+ Q_ASSERT(CallerPropertyIndex == internalClass()->find(context->engine->id_caller));
propertyAt(CalleePropertyIndex)->value = v4->thrower;
propertyAt(CalleePropertyIndex)->set = v4->thrower;
propertyAt(CallerPropertyIndex)->value = v4->thrower;
arrayPut(0, context->callData->args, context->callData->argc);
fullyCreated = true;
} else {
- hasAccessorProperty = 1;
- Q_ASSERT(CalleePropertyIndex == internalClass->find(context->engine->id_callee));
+ setHasAccessorProperty();
+ Q_ASSERT(CalleePropertyIndex == internalClass()->find(context->engine->id_callee));
memberData[CalleePropertyIndex] = context->function->asReturnedValue();
}
- Q_ASSERT(LengthPropertyIndex == internalClass->find(context->engine->id_length));
+ Q_ASSERT(LengthPropertyIndex == internalClass()->find(context->engine->id_length));
memberData[LengthPropertyIndex] = Primitive::fromInt32(context->realArgumentCount);
- Q_ASSERT(internalClass->vtable == staticVTable());
+ Q_ASSERT(internalClass()->vtable == staticVTable());
}
void ArgumentsObject::fullyCreate()
ArgumentsObject(CallContext *context);
static bool isNonStrictArgumentsObject(Managed *m) {
- return m->internalClass->vtable->type == Type_ArgumentsObject &&
+ return m->internalClass()->vtable->type == Type_ArgumentsObject &&
!static_cast<ArgumentsObject *>(m)->context->strictMode;
}
uint oldSize = obj->getLength();
if (other->isSparse()) {
- if (otherObj->hasAccessorProperty && other->hasAttributes()) {
+ if (otherObj->hasAccessorProperty() && other->hasAttributes()) {
Scope scope(obj->engine());
ScopedValue v(scope);
for (const SparseArrayNode *it = static_cast<const SparseArrayData *>(other)->sparse->begin();
PropertyAttributes *attrs;
Value *data;
- const ArrayVTable *vtable() const { return reinterpret_cast<const ArrayVTable *>(internalClass->vtable); }
+ const ArrayVTable *vtable() const { return reinterpret_cast<const ArrayVTable *>(internalClass()->vtable); }
bool isSparse() const { return this && type == Sparse; }
uint length() const {
ScopedValue value(scope);
- if (instance->hasAccessorProperty || (instance->arrayType() >= ArrayData::Sparse) || instance->protoHasArray()) {
+ if (instance->hasAccessorProperty() || (instance->arrayType() >= ArrayData::Sparse) || instance->protoHasArray()) {
// lets be safe and slow
for (uint i = fromIndex; i < len; ++i) {
bool exists;
c->function = function;
c->realArgumentCount = callData->argc;
- c->strictMode = function->strictMode;
+ c->strictMode = function->strictMode();
c->outer = function->scope;
c->activation = 0;
} else if (ctx->type >= Type_CallContext) {
CallContext *c = static_cast<CallContext *>(ctx);
FunctionObject *f = c->function;
- if (f->needsActivation || hasWith) {
+ if (f->needsActivation() || hasWith) {
uint index = f->function->internalClass->find(name);
if (index < UINT_MAX)
// ### throw in strict mode?
bool CallContext::needsOwnArguments() const
{
- return function->needsActivation || callData->argc < static_cast<int>(function->formalParameterCount());
+ return function->needsActivation() || callData->argc < static_cast<int>(function->formalParameterCount());
}
void ExecutionContext::markObjects(Managed *m, ExecutionEngine *engine)
activation->put(name, value);
return;
} else {
- uint member = activation->internalClass->find(name);
+ uint member = activation->internalClass()->find(name);
if (member < UINT_MAX) {
- activation->putValue(activation->propertyAt(member), activation->internalClass->propertyData[member], value);
+ activation->putValue(activation->propertyAt(member), activation->internalClass()->propertyData[member], value);
return;
}
}
else if (ctx->type >= Type_CallContext) {
QV4::CallContext *c = static_cast<CallContext *>(ctx);
ScopedFunctionObject f(scope, c->function);
- if (f->function && (f->needsActivation || hasWith || hasCatchScope)) {
+ if (f->function && (f->needsActivation() || hasWith || hasCatchScope)) {
uint index = f->function->internalClass->find(name);
if (index < UINT_MAX) {
if (index < c->function->formalParameterCount())
else if (ctx->type >= Type_CallContext) {
QV4::CallContext *c = static_cast<CallContext *>(ctx);
FunctionObject *f = c->function;
- if (f->function && (f->needsActivation || hasWith || hasCatchScope)) {
+ if (f->function && (f->needsActivation() || hasWith || hasCatchScope)) {
uint index = f->function->internalClass->find(name);
if (index < UINT_MAX) {
if (index < c->function->formalParameterCount())
protected:
DateObject(InternalClass *ic): Object(ic) {
- Q_ASSERT(internalClass->vtable == staticVTable());
+ Q_ASSERT(internalClass()->vtable == staticVTable());
value = Primitive::fromDouble(qSNaN());
}
};
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);
+ Q_ASSERT(variantPrototype->internalClass()->prototype == objectPrototype);
sequencePrototype = new (memoryManager) SequencePrototype(arrayClass);
globalObject = newObject()->getPointer();
rootContext->global = globalObject;
rootContext->callData->thisObject = globalObject;
- Q_ASSERT(globalObject->internalClass->vtable);
+ Q_ASSERT(globalObject->internalClass()->vtable);
globalObject->defineDefaultProperty(QStringLiteral("Object"), objectCtor);
globalObject->defineDefaultProperty(QStringLiteral("String"), stringCtor);
inline
void Managed::mark(QV4::ExecutionEngine *engine)
{
- Q_ASSERT(inUse);
- if (markBit)
+ Q_ASSERT(inUse());
+ if (markBit())
return;
- markBit = 1;
+ managedData()->markBit = 1;
engine->pushForGC(this);
}
: Object(ic)
, stack(0)
{
- subtype = t;
+ setSubtype(t);
Scope scope(engine());
ScopedValue protectThis(scope, this);
: Object(ic)
, stack(0)
{
- subtype = t;
+ setSubtype(t);
Scope scope(engine());
ScopedValue protectThis(scope, this);
: Object(ic)
, stack(0)
{
- subtype = t;
+ setSubtype(t);
Scope scope(engine());
ScopedValue protectThis(scope, this);
inline SyntaxErrorObject *ErrorObject::asSyntaxError()
{
- return subtype == SyntaxError ? static_cast<SyntaxErrorObject *>(this) : 0;
+ return subtype() == SyntaxError ? static_cast<SyntaxErrorObject *>(this) : 0;
}
}
, scope(ic->engine->rootContext)
, function(0)
{
- needsActivation = false;
- strictMode = false;
+ managedData()->needsActivation = false;
+ managedData()->strictMode = false;
memberData[Index_Prototype] = Encode::undefined();
}
void FunctionObject::init(const StringRef n, bool createProto)
{
- Scope s(internalClass->engine);
+ Scope s(internalClass()->engine);
ScopedValue protectThis(s, this);
- needsActivation = true;
- strictMode = false;
+ managedData()->needsActivation = true;
+ managedData()->strictMode = false;
if (createProto) {
Scoped<Object> proto(s, scope->engine->newObject(scope->engine->protoClass));
ReturnedValue FunctionObject::newInstance()
{
- Scope scope(internalClass->engine);
+ Scope scope(internalClass()->engine);
ScopedCallData callData(scope, 0);
return construct(callData);
}
ReturnedValue FunctionObject::construct(Managed *that, CallData *)
{
- that->internalClass->engine->currentContext()->throwTypeError();
+ that->internalClass()->engine->currentContext()->throwTypeError();
return Encode::undefined();
}
ReturnedValue FunctionCtor::construct(Managed *that, CallData *callData)
{
FunctionCtor *f = static_cast<FunctionCtor *>(that);
- ExecutionEngine *v4 = f->internalClass->engine;
+ ExecutionEngine *v4 = f->internalClass()->engine;
ExecutionContext *ctx = v4->currentContext();
QString arguments;
QString body;
IR::Module module(v4->debugger != 0);
- QQmlJS::RuntimeCodegen cg(v4->currentContext(), f->strictMode);
+ QQmlJS::RuntimeCodegen cg(v4->currentContext(), f->strictMode());
cg.generateFromFunctionExpression(QString(), function, fe, &module);
QV4::Compiler::JSUnitGenerator jsGenerator(&module);
ScopedCallData callData(scope, len);
if (len) {
- if (arr->arrayType() != ArrayData::Simple || arr->protoHasArray() || arr->hasAccessorProperty) {
+ if (arr->arrayType() != ArrayData::Simple || arr->protoHasArray() || arr->hasAccessorProperty()) {
for (quint32 i = 0; i < len; ++i)
callData->args[i] = arr->getIndexed(i);
} else {
Scope s(scope);
ScopedValue protectThis(s, this);
- needsActivation = function->needsActivation();
- strictMode = function->isStrict();
+ managedData()->needsActivation = function->needsActivation();
+ managedData()->strictMode = function->isStrict();
defineReadonlyProperty(scope->engine->id_length, Primitive::fromInt32(formalParameterCount()));
ReturnedValue ScriptFunction::construct(Managed *that, CallData *callData)
{
- ExecutionEngine *v4 = that->internalClass->engine;
+ ExecutionEngine *v4 = that->engine();
if (v4->hasException)
return Encode::undefined();
CHECK_STACK_LIMITS(v4);
ReturnedValue ScriptFunction::call(Managed *that, CallData *callData)
{
ScriptFunction *f = static_cast<ScriptFunction *>(that);
- ExecutionEngine *v4 = f->internalClass->engine;
+ ExecutionEngine *v4 = f->engine();
if (v4->hasException)
return Encode::undefined();
CHECK_STACK_LIMITS(v4);
ExecutionEngine *v4 = scope->engine;
- needsActivation = function->needsActivation();
- strictMode = function->isStrict();
+ managedData()->needsActivation = function->needsActivation();
+ managedData()->strictMode = function->isStrict();
defineReadonlyProperty(scope->engine->id_length, Primitive::fromInt32(formalParameterCount()));
ReturnedValue SimpleScriptFunction::construct(Managed *that, CallData *callData)
{
- ExecutionEngine *v4 = that->internalClass->engine;
+ ExecutionEngine *v4 = that->engine();
if (v4->hasException)
return Encode::undefined();
CHECK_STACK_LIMITS(v4);
ExecutionContextSaver ctxSaver(context);
CallContext ctx(v4);
- ctx.strictMode = f->strictMode;
+ ctx.strictMode = f->strictMode();
ctx.callData = callData;
ctx.function = f.getPointer();
ctx.compilationUnit = f->function->compilationUnit;
ReturnedValue SimpleScriptFunction::call(Managed *that, CallData *callData)
{
- ExecutionEngine *v4 = that->internalClass->engine;
+ ExecutionEngine *v4 = that->internalClass()->engine;
if (v4->hasException)
return Encode::undefined();
CHECK_STACK_LIMITS(v4);
ExecutionContextSaver ctxSaver(context);
CallContext ctx(v4);
- ctx.strictMode = f->strictMode;
+ ctx.strictMode = f->strictMode();
ctx.callData = callData;
ctx.function = f;
ctx.compilationUnit = f->function->compilationUnit;
{
ReturnedValue proto = protoProperty();
InternalClass *classForConstructor;
- Scope scope(internalClass->engine);
+ Scope scope(internalClass()->engine);
ScopedObject p(scope, proto);
if (p)
- classForConstructor = internalClass->engine->constructClass->changePrototype(p.getPointer());
+ classForConstructor = internalClass()->engine->constructClass->changePrototype(p.getPointer());
else
classForConstructor = scope.engine->objectClass;
ReturnedValue BuiltinFunction::construct(Managed *f, CallData *)
{
- return f->internalClass->engine->currentContext()->throwTypeError();
+ return f->internalClass()->engine->currentContext()->throwTypeError();
}
ReturnedValue BuiltinFunction::call(Managed *that, CallData *callData)
{
BuiltinFunction *f = static_cast<BuiltinFunction *>(that);
- ExecutionEngine *v4 = f->internalClass->engine;
+ ExecutionEngine *v4 = f->internalClass()->engine;
if (v4->hasException)
return Encode::undefined();
CHECK_STACK_LIMITS(v4);
ReturnedValue IndexedBuiltinFunction::call(Managed *that, CallData *callData)
{
IndexedBuiltinFunction *f = static_cast<IndexedBuiltinFunction *>(that);
- ExecutionEngine *v4 = f->internalClass->engine;
+ ExecutionEngine *v4 = f->internalClass()->engine;
if (v4->hasException)
return Encode::undefined();
CHECK_STACK_LIMITS(v4);
, boundArgs(boundArgs)
{
setVTable(staticVTable());
- subtype = FunctionObject::BoundFunction;
+ setSubtype(FunctionObject::BoundFunction);
this->boundThis = boundThis;
Scope s(scope);
ReturnedValue protoProperty() { return memberData[Index_Prototype].asReturnedValue(); }
+ bool needsActivation() const { return managedData()->needsActivation; }
+ bool strictMode() const { return managedData()->strictMode; }
+ bool bindingKeyFlag() const { return managedData()->bindingKeyFlag; }
+
protected:
FunctionObject(InternalClass *ic);
if (!function)
return Encode::undefined();
- strictMode = function->isStrict() || (ctx->strictMode);
+ managedData()->strictMode = function->isStrict() || (ctx->strictMode);
- needsActivation = function->needsActivation();
+ managedData()->needsActivation = function->needsActivation();
- if (strictMode) {
+ if (strictMode()) {
ScopedFunctionObject e(scope, FunctionObject::createScriptFunction(ctx, function));
ScopedCallData callData(scope, 0);
callData->thisObject = ctx->callData->thisObject;
ctx->currentEvalCode = &evalCode;
// set the correct strict mode flag on the context
- ctx->strictMode = strictMode;
+ ctx->strictMode = strictMode();
ctx->compilationUnit = function->compilationUnit;
return function->code(ctx, function->codeData);
{
uint hash = str->hashValue();
- if (str->subtype == String::StringType_ArrayIndex)
+ if (str->subtype() == String::StringType_ArrayIndex)
return;
str->identifier = new Identifier;
if (str->identifier)
return str->identifier;
uint hash = str->hashValue();
- if (str->subtype == String::StringType_ArrayIndex)
+ if (str->subtype() == String::StringType_ArrayIndex)
return 0;
uint idx = hash % alloc;
void mark(ExecutionEngine *e) {
for (int i = 0; i < alloc; ++i) {
String *entry = entries[i];
- if (!entry || entry->markBit)
+ if (!entry || entry->data.markBit)
continue;
- entry->markBit = 1;
- Q_ASSERT(entry->internalClass->vtable->markObjects);
- entry->internalClass->vtable->markObjects(entry, e);
+ entry->data.markBit = 1;
+ Q_ASSERT(entry->data.internalClass->vtable->markObjects);
+ entry->data.internalClass->vtable->markObjects(entry, e);
}
}
};
void InternalClass::changeMember(Object *object, String *string, PropertyAttributes data, uint *index)
{
uint idx;
- InternalClass *newClass = object->internalClass->changeMember(string, data, &idx);
+ InternalClass *newClass = object->internalClass()->changeMember(string, data, &idx);
if (index)
*index = idx;
- if (newClass->size > object->internalClass->size) {
- Q_ASSERT(newClass->size == object->internalClass->size + 1);
- memmove(object->memberData.data() + idx + 2, object->memberData.data() + idx + 1, (object->internalClass->size - idx - 1)*sizeof(Value));
- } else if (newClass->size < object->internalClass->size) {
- Q_ASSERT(newClass->size == object->internalClass->size - 1);
- memmove(object->memberData.data() + idx + 1, object->memberData.data() + idx + 2, (object->internalClass->size - idx - 2)*sizeof(Value));
+ if (newClass->size > object->internalClass()->size) {
+ Q_ASSERT(newClass->size == object->internalClass()->size + 1);
+ memmove(object->memberData.data() + idx + 2, object->memberData.data() + idx + 1, (object->internalClass()->size - idx - 1)*sizeof(Value));
+ } else if (newClass->size < object->internalClass()->size) {
+ Q_ASSERT(newClass->size == object->internalClass()->size - 1);
+ memmove(object->memberData.data() + idx + 1, object->memberData.data() + idx + 2, (object->internalClass()->size - idx - 2)*sizeof(Value));
}
- object->internalClass = newClass;
+ object->setInternalClass(newClass);
}
InternalClass *InternalClass::changeMember(String *string, PropertyAttributes data, uint *index)
void InternalClass::addMember(Object *object, String *string, PropertyAttributes data, uint *index)
{
data.resolve();
- object->internalClass->engine->identifierTable->identifier(string);
- if (object->internalClass->propertyTable.lookup(string->identifier) < object->internalClass->size) {
+ object->internalClass()->engine->identifierTable->identifier(string);
+ if (object->internalClass()->propertyTable.lookup(string->identifier) < object->internalClass()->size) {
changeMember(object, string, data, index);
return;
}
uint idx;
- InternalClass *newClass = object->internalClass->addMemberImpl(string, data, &idx);
+ InternalClass *newClass = object->internalClass()->addMemberImpl(string, data, &idx);
if (index)
*index = idx;
- object->internalClass = newClass;
+ object->setInternalClass(newClass);
}
void InternalClass::removeMember(Object *object, Identifier *id)
{
- InternalClass *oldClass = object->internalClass;
+ InternalClass *oldClass = object->internalClass();
uint propIdx = oldClass->propertyTable.lookup(id);
Q_ASSERT(propIdx < oldClass->size);
Transition t = { { id } , -1 };
- QHash<Transition, InternalClass *>::const_iterator tit = object->internalClass->transitions.constFind(t);
+ QHash<Transition, InternalClass *>::const_iterator tit = object->internalClass()->transitions.constFind(t);
- if (tit != object->internalClass->transitions.constEnd()) {
- object->internalClass = tit.value();
+ if (tit != object->internalClass()->transitions.constEnd()) {
+ object->setInternalClass(tit.value());
} else {
// create a new class and add it to the tree
InternalClass *newClass = oldClass->engine->emptyClass->changeVTable(oldClass->vtable);
if (!oldClass->propertyData.at(i).isEmpty())
newClass = newClass->addMember(oldClass->nameMap.at(i), oldClass->propertyData.at(i));
}
- object->internalClass = newClass;
+ object->setInternalClass(newClass);
}
// remove the entry in memberdata
- memmove(object->memberData.data() + propIdx, object->memberData.data() + propIdx + 1, (object->internalClass->size - propIdx)*sizeof(Value));
+ memmove(object->memberData.data() + propIdx, object->memberData.data() + propIdx + 1, (object->internalClass()->size - propIdx)*sizeof(Value));
- oldClass->transitions.insert(t, object->internalClass);
+ oldClass->transitions.insert(t, object->internalClass());
}
uint InternalClass::find(const StringRef string)
{
int i = 0;
while (i < Size && obj) {
- classList[i] = obj->internalClass;
+ classList[i] = obj->internalClass();
- index = obj->internalClass->find(name);
+ index = obj->internalClass()->find(name);
if (index != UINT_MAX) {
level = i;
- *attrs = obj->internalClass->propertyData.at(index);
+ *attrs = obj->internalClass()->propertyData.at(index);
return !attrs->isAccessor() ? obj->memberData[index].asReturnedValue() : obj->getValue(thisObject, obj->propertyAt(index), *attrs);
}
level = Size;
while (obj) {
- index = obj->internalClass->find(name);
+ index = obj->internalClass()->find(name);
if (index != UINT_MAX) {
- *attrs = obj->internalClass->propertyData.at(index);
+ *attrs = obj->internalClass()->propertyData.at(index);
return !attrs->isAccessor() ? obj->memberData[index].asReturnedValue() : obj->getValue(thisObject, obj->propertyAt(index), *attrs);
}
Object *thisObject = obj;
int i = 0;
while (i < Size && obj) {
- classList[i] = obj->internalClass;
+ classList[i] = obj->internalClass();
- index = obj->internalClass->find(name);
+ index = obj->internalClass()->find(name);
if (index != UINT_MAX) {
level = i;
- *attrs = obj->internalClass->propertyData.at(index);
+ *attrs = obj->internalClass()->propertyData.at(index);
return !attrs->isAccessor() ? obj->memberData[index].asReturnedValue() : thisObject->getValue(obj->propertyAt(index), *attrs);
}
level = Size;
while (obj) {
- index = obj->internalClass->find(name);
+ index = obj->internalClass()->find(name);
if (index != UINT_MAX) {
- *attrs = obj->internalClass->propertyData.at(index);
+ *attrs = obj->internalClass()->propertyData.at(index);
return !attrs->isAccessor() ? obj->memberData[index].asReturnedValue() : thisObject->getValue(obj->propertyAt(index), *attrs);
}
// we can safely cast to a QV4::Object here. If object is actually a string,
// the internal class won't match
Object *o = object->objectValue();
- if (l->classList[0] == o->internalClass)
+ if (l->classList[0] == o->internalClass())
return o->memberData[l->index].asReturnedValue();
}
return getterTwoClasses(l, object);
// we can safely cast to a QV4::Object here. If object is actually a string,
// the internal class won't match
Object *o = object->objectValue();
- if (l->classList[0] == o->internalClass &&
- l->classList[1] == o->prototype()->internalClass)
+ if (l->classList[0] == o->internalClass() &&
+ l->classList[1] == o->prototype()->internalClass())
return o->prototype()->memberData[l->index].asReturnedValue();
}
return getterTwoClasses(l, object);
// we can safely cast to a QV4::Object here. If object is actually a string,
// the internal class won't match
Object *o = object->objectValue();
- if (l->classList[0] == o->internalClass) {
+ if (l->classList[0] == o->internalClass()) {
o = o->prototype();
- if (l->classList[1] == o->internalClass) {
+ if (l->classList[1] == o->internalClass()) {
o = o->prototype();
- if (l->classList[2] == o->internalClass)
+ if (l->classList[2] == o->internalClass())
return o->memberData[l->index].asReturnedValue();
}
}
// we can safely cast to a QV4::Object here. If object is actually a string,
// the internal class won't match
Object *o = object->objectValue();
- if (l->classList[0] == o->internalClass)
+ if (l->classList[0] == o->internalClass())
return o->memberData[l->index].asReturnedValue();
- if (l->classList[2] == o->internalClass)
+ if (l->classList[2] == o->internalClass())
return o->memberData[l->index2].asReturnedValue();
}
l->getter = getterFallback;
// we can safely cast to a QV4::Object here. If object is actually a string,
// the internal class won't match
Object *o = object->objectValue();
- if (l->classList[0] == o->internalClass)
+ if (l->classList[0] == o->internalClass())
return o->memberData[l->index].asReturnedValue();
- if (l->classList[2] == o->internalClass &&
- l->classList[3] == o->prototype()->internalClass)
+ if (l->classList[2] == o->internalClass() &&
+ l->classList[3] == o->prototype()->internalClass())
return o->prototype()->memberData[l->index2].asReturnedValue();
}
l->getter = getterFallback;
// we can safely cast to a QV4::Object here. If object is actually a string,
// the internal class won't match
Object *o = object->objectValue();
- if (l->classList[0] == o->internalClass &&
- l->classList[1] == o->prototype()->internalClass)
+ if (l->classList[0] == o->internalClass() &&
+ l->classList[1] == o->prototype()->internalClass())
return o->prototype()->memberData[l->index].asReturnedValue();
- if (l->classList[2] == o->internalClass &&
- l->classList[3] == o->prototype()->internalClass)
+ if (l->classList[2] == o->internalClass() &&
+ l->classList[3] == o->prototype()->internalClass())
return o->prototype()->memberData[l->index2].asReturnedValue();
return getterFallback(l, object);
}
// we can safely cast to a QV4::Object here. If object is actually a string,
// the internal class won't match
Object *o = object->objectValue();
- if (l->classList[0] == o->internalClass) {
+ if (l->classList[0] == o->internalClass()) {
Scope scope(o->engine());
FunctionObject *getter = o->propertyAt(l->index)->getter();
if (!getter)
// we can safely cast to a QV4::Object here. If object is actually a string,
// the internal class won't match
Object *o = object->objectValue();
- if (l->classList[0] == o->internalClass &&
- l->classList[1] == o->prototype()->internalClass) {
+ if (l->classList[0] == o->internalClass() &&
+ l->classList[1] == o->prototype()->internalClass()) {
Scope scope(o->engine());
FunctionObject *getter = o->prototype()->propertyAt(l->index)->getter();
if (!getter)
// we can safely cast to a QV4::Object here. If object is actually a string,
// the internal class won't match
Object *o = object->objectValue();
- if (l->classList[0] == o->internalClass) {
+ if (l->classList[0] == o->internalClass()) {
o = o->prototype();
- if (l->classList[1] == o->internalClass) {
+ if (l->classList[1] == o->internalClass()) {
o = o->prototype();
- if (l->classList[2] == o->internalClass) {
+ if (l->classList[2] == o->internalClass()) {
Scope scope(o->engine());
FunctionObject *getter = o->propertyAt(l->index)->getter();
if (!getter)
{
if (object->type() == l->type) {
Object *o = l->proto;
- if (l->classList[0] == o->internalClass)
+ if (l->classList[0] == o->internalClass())
return o->memberData[l->index].asReturnedValue();
}
l->getter = getterGeneric;
{
if (object->type() == l->type) {
Object *o = l->proto;
- if (l->classList[0] == o->internalClass &&
- l->classList[1] == o->prototype()->internalClass)
+ if (l->classList[0] == o->internalClass() &&
+ l->classList[1] == o->prototype()->internalClass())
return o->prototype()->memberData[l->index].asReturnedValue();
}
l->getter = getterGeneric;
{
if (object->type() == l->type) {
Object *o = l->proto;
- if (l->classList[0] == o->internalClass) {
+ if (l->classList[0] == o->internalClass()) {
Scope scope(o->engine());
FunctionObject *getter = o->propertyAt(l->index)->getter();
if (!getter)
{
if (object->type() == l->type) {
Object *o = l->proto;
- if (l->classList[0] == o->internalClass &&
- l->classList[1] == o->prototype()->internalClass) {
+ if (l->classList[0] == o->internalClass() &&
+ l->classList[1] == o->prototype()->internalClass()) {
Scope scope(o->engine());
FunctionObject *getter = o->prototype()->propertyAt(l->index)->getter();
if (!getter)
ReturnedValue Lookup::globalGetter0(Lookup *l, ExecutionContext *ctx)
{
Object *o = ctx->engine->globalObject;
- if (l->classList[0] == o->internalClass)
+ if (l->classList[0] == o->internalClass())
return o->memberData[l->index].asReturnedValue();
l->globalGetter = globalGetterGeneric;
ReturnedValue Lookup::globalGetter1(Lookup *l, ExecutionContext *ctx)
{
Object *o = ctx->engine->globalObject;
- if (l->classList[0] == o->internalClass &&
- l->classList[1] == o->prototype()->internalClass)
+ if (l->classList[0] == o->internalClass() &&
+ l->classList[1] == o->prototype()->internalClass())
return o->prototype()->memberData[l->index].asReturnedValue();
l->globalGetter = globalGetterGeneric;
ReturnedValue Lookup::globalGetter2(Lookup *l, ExecutionContext *ctx)
{
Object *o = ctx->engine->globalObject;
- if (l->classList[0] == o->internalClass) {
+ if (l->classList[0] == o->internalClass()) {
o = o->prototype();
- if (l->classList[1] == o->internalClass) {
+ if (l->classList[1] == o->internalClass()) {
o = o->prototype();
- if (l->classList[2] == o->internalClass) {
+ if (l->classList[2] == o->internalClass()) {
return o->prototype()->memberData[l->index].asReturnedValue();
}
}
ReturnedValue Lookup::globalGetterAccessor0(Lookup *l, ExecutionContext *ctx)
{
Object *o = ctx->engine->globalObject;
- if (l->classList[0] == o->internalClass) {
+ if (l->classList[0] == o->internalClass()) {
Scope scope(o->engine());
FunctionObject *getter = o->propertyAt(l->index)->getter();
if (!getter)
ReturnedValue Lookup::globalGetterAccessor1(Lookup *l, ExecutionContext *ctx)
{
Object *o = ctx->engine->globalObject;
- if (l->classList[0] == o->internalClass &&
- l->classList[1] == o->prototype()->internalClass) {
+ if (l->classList[0] == o->internalClass() &&
+ l->classList[1] == o->prototype()->internalClass()) {
Scope scope(o->engine());
FunctionObject *getter = o->prototype()->propertyAt(l->index)->getter();
if (!getter)
ReturnedValue Lookup::globalGetterAccessor2(Lookup *l, ExecutionContext *ctx)
{
Object *o = ctx->engine->globalObject;
- if (l->classList[0] == o->internalClass) {
+ if (l->classList[0] == o->internalClass()) {
o = o->prototype();
- if (l->classList[1] == o->internalClass) {
+ if (l->classList[1] == o->internalClass()) {
o = o->prototype();
- if (l->classList[2] == o->internalClass) {
+ if (l->classList[2] == o->internalClass()) {
Scope scope(o->engine());
FunctionObject *getter = o->propertyAt(l->index)->getter();
if (!getter)
void Lookup::setter0(Lookup *l, const ValueRef object, const ValueRef value)
{
Object *o = static_cast<Object *>(object->asManaged());
- if (o && o->internalClass == l->classList[0]) {
+ if (o && o->internalClass() == l->classList[0]) {
o->memberData[l->index] = *value;
return;
}
void Lookup::setterInsert0(Lookup *l, const ValueRef object, const ValueRef value)
{
Object *o = static_cast<Object *>(object->asManaged());
- if (o && o->internalClass == l->classList[0]) {
+ if (o && o->internalClass() == l->classList[0]) {
if (!o->prototype()) {
if (l->index >= o->memberData.size())
o->ensureMemberIndex(l->index);
o->memberData[l->index] = *value;
- o->internalClass = l->classList[3];
+ o->setInternalClass(l->classList[3]);
return;
}
}
void Lookup::setterInsert1(Lookup *l, const ValueRef object, const ValueRef value)
{
Object *o = static_cast<Object *>(object->asManaged());
- if (o && o->internalClass == l->classList[0]) {
+ if (o && o->internalClass() == l->classList[0]) {
Object *p = o->prototype();
- if (p && p->internalClass == l->classList[1]) {
+ if (p && p->internalClass() == l->classList[1]) {
if (l->index >= o->memberData.size())
o->ensureMemberIndex(l->index);
o->memberData[l->index] = *value;
- o->internalClass = l->classList[3];
+ o->setInternalClass(l->classList[3]);
return;
}
}
void Lookup::setterInsert2(Lookup *l, const ValueRef object, const ValueRef value)
{
Object *o = static_cast<Object *>(object->asManaged());
- if (o && o->internalClass == l->classList[0]) {
+ if (o && o->internalClass() == l->classList[0]) {
Object *p = o->prototype();
- if (p && p->internalClass == l->classList[1]) {
+ if (p && p->internalClass() == l->classList[1]) {
p = p->prototype();
- if (p && p->internalClass == l->classList[2]) {
+ if (p && p->internalClass() == l->classList[2]) {
if (l->index >= o->memberData.size())
o->ensureMemberIndex(l->index);
o->memberData[l->index] = *value;
- o->internalClass = l->classList[3];
+ o->setInternalClass(l->classList[3]);
return;
}
}
{
Object *o = static_cast<Object *>(object->asManaged());
if (o) {
- if (o->internalClass == l->classList[0]) {
+ if (o->internalClass() == l->classList[0]) {
o->memberData[l->index] = *value;
return;
}
- if (o->internalClass == l->classList[1]) {
+ if (o->internalClass() == l->classList[1]) {
o->memberData[l->index2] = *value;
return;
}
return mm->allocManaged(size);
}
-void Managed::operator delete(void *ptr)
-{
- if (!ptr)
- return;
-
- Managed *m = static_cast<Managed *>(ptr);
- m->_data = 0;
- m->markBit = 0;
- m->~Managed();
-}
-
-void Managed::operator delete(void *ptr, MemoryManager *mm)
-{
- Q_UNUSED(mm);
-
- operator delete(ptr);
-}
-
ExecutionEngine *Managed::engine() const
{
- return internalClass ? internalClass->engine : 0;
+ return internalClass()->engine;
}
QString Managed::className() const
{
const char *s = 0;
- switch (Type(internalClass->vtable->type)) {
+ switch (Type(internalClass()->vtable->type)) {
case Type_Invalid:
case Type_String:
return QString();
s = "RegExp";
break;
case Type_ErrorObject:
- switch (ErrorObject::ErrorType(subtype)) {
+ switch (ErrorObject::ErrorType(subtype())) {
case ErrorObject::Error:
s = "Error";
break;
void Managed::setVTable(const ManagedVTable *vt)
{
- Q_ASSERT(internalClass);
- internalClass = internalClass->changeVTable(vt);
+ Q_ASSERT(internalClass());
+ managedData()->internalClass = internalClass()->changeVTable(vt);
}
bool Managed::isEqualTo(Managed *, Managed *)
protected:
Managed(InternalClass *internal)
- : internalClass(internal), _data(0)
{
- Q_ASSERT(internalClass && internalClass->vtable);
- inUse = 1; extensible = 1;
+ Q_ASSERT(internal && internal->vtable);
+ managedData()->internalClass = internal;
+ managedData()->_data = 0;
+ managedData()->inUse = 1;
+ managedData()->extensible = 1;
}
public:
void *operator new(size_t size, MemoryManager *mm);
void *operator new(size_t, Managed *m) { return m; }
- void operator delete(void *ptr);
- void operator delete(void *ptr, MemoryManager *mm);
inline void mark(QV4::ExecutionEngine *engine);
template <typename T>
T *as() {
// ### FIXME:
- if (!this || !internalClass)
+ if (!this || !internalClass())
return 0;
#if !defined(QT_NO_QOBJECT_CHECK)
static_cast<T *>(this)->qt_check_for_QMANAGED_macro(static_cast<T *>(this));
#endif
- return internalClass->vtable == T::staticVTable() ? static_cast<T *>(this) : 0;
+ return internalClass()->vtable == T::staticVTable() ? static_cast<T *>(this) : 0;
}
template <typename T>
const T *as() const {
#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::staticVTable() ? 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; }
- Object *asObject() { return internalClass->vtable->isObject ? reinterpret_cast<Object *>(this) : 0; }
- ArrayObject *asArrayObject() { return internalClass->vtable->type == Type_ArrayObject ? reinterpret_cast<ArrayObject *>(this) : 0; }
- FunctionObject *asFunctionObject() { return internalClass->vtable->isFunctionObject ? reinterpret_cast<FunctionObject *>(this) : 0; }
- BooleanObject *asBooleanObject() { return internalClass->vtable->type == Type_BooleanObject ? reinterpret_cast<BooleanObject *>(this) : 0; }
- NumberObject *asNumberObject() { return internalClass->vtable->type == Type_NumberObject ? reinterpret_cast<NumberObject *>(this) : 0; }
- StringObject *asStringObject() { return internalClass->vtable->type == Type_StringObject ? reinterpret_cast<StringObject *>(this) : 0; }
- DateObject *asDateObject() { return internalClass->vtable->type == Type_DateObject ? reinterpret_cast<DateObject *>(this) : 0; }
- ErrorObject *asErrorObject() { return internalClass->vtable->isErrorObject ? reinterpret_cast<ErrorObject *>(this) : 0; }
- ArgumentsObject *asArgumentsObject() { return internalClass->vtable->type == Type_ArgumentsObject ? reinterpret_cast<ArgumentsObject *>(this) : 0; }
+ String *asString() { return internalClass()->vtable->isString ? reinterpret_cast<String *>(this) : 0; }
+ Object *asObject() { return internalClass()->vtable->isObject ? reinterpret_cast<Object *>(this) : 0; }
+ ArrayObject *asArrayObject() { return internalClass
()->vtable->type == Type_ArrayObject ? reinterpret_cast<ArrayObject *>(this) : 0; }
+ FunctionObject *asFunctionObject() { return internalClass()->vtable->isFunctionObject ? reinterpret_cast<FunctionObject *>(this) : 0; }
+ BooleanObject *asBooleanObject() { return internalClass()->vtable->type == Type_BooleanObject ? reinterpret_cast<BooleanObject *>(this) : 0; }
+ NumberObject *asNumberObject() { return internalClass()->vtable->type == Type_NumberObject ? reinterpret_cast<NumberObject *>(this) : 0; }
+ StringObject *asStringObject() { return internalClass()->vtable->type == Type_StringObject ? reinterpret_cast<StringObject *>(this) : 0; }
+ DateObject *asDateObject() { return internalClass()->vtable->type == Type_DateObject ? reinterpret_cast<DateObject *>(this) : 0; }
+ ErrorObject *asErrorObject() { return internalClass()->vtable->isErrorObject ? reinterpret_cast<ErrorObject *>(this) : 0; }
+ ArgumentsObject *asArgumentsObject() { return internalClass
()->vtable->type == Type_ArgumentsObject ? reinterpret_cast<ArgumentsObject *>(this) : 0; }
- bool isListType() const { return internalClass->vtable->type == Type_QmlSequence; }
+ bool isListType() const { return internalClass()->vtable->type == Type_QmlSequence; }
- bool isArrayObject() const { return internalClass->vtable->type == Type_ArrayObject; }
- bool isStringObject() const { return internalClass->vtable->type == Type_StringObject; }
+ bool isArrayObject() const { return internalClass()->vtable->type == Type_ArrayObject; }
+ bool isStringObject() const { return internalClass()->vtable->type == Type_StringObject; }
QString className() const;
void setVTable(const ManagedVTable *vt);
bool isEqualTo(Managed *other)
- { return internalClass->vtable->isEqualTo(this, other); }
+ { return internalClass()->vtable->isEqualTo(this, other); }
static bool isEqualTo(Managed *m, Managed *other);
ReturnedValue asReturnedValue() { return Value::fromManaged(this).asReturnedValue(); }
-
- InternalClass *internalClass;
-
- union {
- uint _data;
- struct {
- uchar markBit : 1;
- uchar inUse : 1;
- uchar extensible : 1; // used by Object
- uchar _unused : 1;
- uchar needsActivation : 1; // used by FunctionObject
- uchar strictMode : 1; // used by FunctionObject
- uchar bindingKeyFlag : 1;
- uchar hasAccessorProperty : 1;
- uchar _type;
- mutable uchar subtype;
- uchar _flags;
+ struct Data {
+ InternalClass *internalClass;
+ union {
+ uint _data;
+ struct {
+ uchar markBit : 1;
+ uchar inUse : 1;
+ uchar extensible : 1; // used by Object
+ uchar _unused : 1;
+ uchar needsActivation : 1; // used by FunctionObject
+ uchar strictMode : 1; // used by FunctionObject
+ uchar bindingKeyFlag : 1;
+ uchar hasAccessorProperty : 1;
+ uchar _type;
+ mutable uchar subtype;
+ uchar _flags;
+ };
};
};
- static void destroy(Managed *) {}
+ Data data;
+
+ Data *managedData() { return &data; }
+ const Data *managedData() const { return &data; }
+
+ InternalClass *internalClass() const { return managedData()->internalClass; }
+ void setInternalClass(InternalClass *ic) { managedData()->internalClass = ic; }
+ uchar subtype() const { return managedData()->subtype; }
+ void setSubtype(uchar subtype) const { managedData()->subtype = subtype; }
+
+ bool inUse() const { return managedData()->inUse; }
+ bool markBit() const { return managedData()->markBit; }
+
+ static void destroy(Managed *) {}
private:
friend class MemoryManager;
friend struct Identifiers;
Managed **last = &m_d->smallItems[pos];
while (chunk <= end) {
Managed *o = reinterpret_cast<Managed *>(chunk);
- o->_data = 0;
*last = o;
last = o->nextFreeRef();
chunk += size;
// now that we marked all roots, start marking recursively and popping from the mark stack
while (m_d->engine->jsStackTop > markBase) {
Managed *m = m_d->engine->popForGC();
- Q_ASSERT (m->internalClass->vtable->markObjects);
- m->internalClass->vtable->markObjects(m, m_d->engine);
+ Q_ASSERT (m->internalClass()->vtable->markObjects);
+ m->internalClass()->vtable->markObjects(m, m_d->engine);
}
}
continue;
}
if (Managed *m = weak->value.asManaged()) {
- if (!m->markBit) {
+ if (!m->markBit()) {
weak->value = Primitive::undefinedValue();
PersistentValuePrivate *n = weak->next;
weak->removeFromList();
if (MultiplyWrappedQObjectMap *multiplyWrappedQObjects = m_d->engine->m_multiplyWrappedQObjects) {
for (MultiplyWrappedQObjectMap::Iterator it = multiplyWrappedQObjects->begin(); it != multiplyWrappedQObjects->end();) {
- if (!it.value()->markBit)
+ if (!it.value()->markBit())
it = multiplyWrappedQObjects->erase(it);
else
++it;
Data::LargeItem **last = &m_d->largeItems;
while (i) {
Managed *m = i->managed();
- Q_ASSERT(m->inUse);
- if (m->markBit) {
- m->markBit = 0;
+ Q_ASSERT(m->inUse());
+ if (m->markBit()) {
+ m->managedData()->markBit = 0;
last = &i->next;
i = i->next;
continue;
}
- if (m->internalClass->vtable->destroy)
- m->internalClass->vtable->destroy(m);
+ if (m->internalClass()->vtable->destroy)
+ m->internalClass()->vtable->destroy(m);
*last = i->next;
free(Q_V4_PROFILE_DEALLOC(m_d->engine, i, i->size + sizeof(Data::LargeItem),
Q_ASSERT((qintptr) chunk % 16 == 0);
- if (m->inUse) {
- if (m->markBit) {
- m->markBit = 0;
+ if (m->inUse()) {
+ if (m->markBit()) {
+ m->managedData()->markBit = 0;
} else {
// qDebug() << "-- collecting it." << m << *f << m->nextFree();
#ifdef V4_USE_VALGRIND
VALGRIND_ENABLE_ERROR_REPORTING;
#endif
- if (m->internalClass->vtable->destroy)
- m->internalClass->vtable->destroy(m);
+ if (m->internalClass()->vtable->destroy)
+ m->internalClass()->vtable->destroy(m);
memset(m, 0, size);
m->setNextFree(*f);
for (char *chunk = chunkStart; chunk <= chunkEnd; chunk += i->chunkSize) {
Managed *m = reinterpret_cast<Managed *>(chunk);
Q_ASSERT((qintptr) chunk % 16 == 0);
- if (m->inUse)
+ if (m->inUse())
usedMem += i->chunkSize;
}
}
Value *top = m_d->engine->jsStackTop;
while (v < top) {
Managed *m = v->asManaged();
- if (m && m->inUse)
+ if (m && m->inUse())
// Skip pointers to already freed objects, they are bogus as well
m->mark(m_d->engine);
++v;
Object::Object(InternalClass *ic)
: Managed(ic)
{
- Q_ASSERT(internalClass->vtable && internalClass->vtable != &Managed::static_vtbl);
+ Q_ASSERT(internalClass()->vtable != &Managed::static_vtbl);
Q_ASSERT(!memberData.d());
- if (internalClass->size) {
+ if (internalClass()->size) {
Scope scope(engine());
ScopedObject protectThis(scope, this);
- memberData.ensureIndex(engine(), internalClass->size);
+ memberData.ensureIndex(engine(), internalClass()->size);
}
}
return false;
pp = pp->prototype();
}
- internalClass = internalClass->changePrototype(proto);
+ setInternalClass(internalClass()->changePrototype(proto));
return true;
}
void Object::putValue(Property *pd, PropertyAttributes attrs, const ValueRef value)
{
- if (internalClass->engine->hasException)
+ if (internalClass()->engine->hasException)
return;
if (attrs.isAccessor()) {
InternalClass::addMember(this, s.getPointer(), attributes, &idx);
- ensureMemberIndex(internalClass->size);
+ ensureMemberIndex(internalClass()->size);
if (attributes.isAccessor()) {
- hasAccessorProperty = 1;
+ setHasAccessorProperty();
Property *pp = propertyAt(idx);
pp->value = p.value;
pp->set = p.set;
if (idx != UINT_MAX)
return __getOwnProperty__(idx, attrs);
- uint member = internalClass->find(name);
+ uint member = internalClass()->find(name);
if (member < UINT_MAX) {
if (attrs)
- *attrs = internalClass->propertyData[member];
+ *attrs = internalClass()->propertyData[member];
return propertyAt(member);
}
const Object *o = this;
while (o) {
- uint idx = o->internalClass->find(name.getPointer());
+ uint idx = o->internalClass()->find(name.getPointer());
if (idx < UINT_MAX) {
if (attrs)
- *attrs = o->internalClass->propertyData[idx];
+ *attrs = o->internalClass()->propertyData[idx];
return o->propertyAt(idx);
}
if (idx != UINT_MAX)
return hasOwnProperty(idx);
- if (internalClass->find(name) < UINT_MAX)
+ if (internalClass()->find(name) < UINT_MAX)
return true;
if (!query(name).isEmpty())
return true;
return queryIndexed(m, idx);
const Object *o = static_cast<const Object *>(m);
- idx = o->internalClass->find(name.getPointer());
+ idx = o->internalClass()->find(name.getPointer());
if (idx < UINT_MAX)
- return o->internalClass->propertyData[idx];
+ return o->internalClass()->propertyData[idx];
return Attr_Invalid;
}
Scope scope(m->engine());
ScopedObject o(scope, static_cast<Object *>(m));
- InternalClass *c = o->internalClass;
+ InternalClass *c = o->internalClass();
uint idx = c->find(l->name);
if (!o->isArrayObject() || idx != ArrayObject::LengthPropertyIndex) {
- if (idx != UINT_MAX && o->internalClass->propertyData[idx].isData() && o->internalClass->propertyData[idx].isWritable()) {
- l->classList[0] = o->internalClass;
+ if (idx != UINT_MAX && o->internalClass()->propertyData[idx].isData() && o->internalClass()->propertyData[idx].isWritable()) {
+ l->classList[0] = o->internalClass();
l->index = idx;
l->setter = Lookup::setter0;
o->memberData[idx] = *value;
}
if (idx != UINT_MAX) {
- o->putValue(o->propertyAt(idx), o->internalClass->propertyData[idx], value);
+ o->putValue(o->propertyAt(idx), o->internalClass()->propertyData[idx], value);
return;
}
}
ScopedString s(scope, l->name);
o->put(s, value);
- if (o->internalClass == c)
+ if (o->internalClass() == c)
return;
- idx = o->internalClass->find(l->name);
+ idx = o->internalClass()->find(l->name);
if (idx == UINT_MAX)
return;
l->classList[0] = c;
- l->classList[3] = o->internalClass;
+ l->classList[3] = o->internalClass();
l->index = idx;
if (!o->prototype()) {
l->setter = Lookup::setterInsert0;
return;
}
o = o->prototype();
- l->classList[1] = o->internalClass;
+ l->classList[1] = o->internalClass();
if (!o->prototype()) {
l->setter = Lookup::setterInsert1;
return;
}
o = o->prototype();
- l->classList[2] = o->internalClass;
+ l->classList[2] = o->internalClass();
if (!o->prototype()) {
l->setter = Lookup::setterInsert2;
return;
}
}
- while (it->memberIndex < o->internalClass->size) {
- String *n = o->internalClass->nameMap.at(it->memberIndex);
+ while (it->memberIndex < o->internalClass()->size) {
+ String *n = o->internalClass()->nameMap.at(it->memberIndex);
if (!n) {
// accessor properties have a dummy entry with n == 0
++it->memberIndex;
}
Property *p = o->propertyAt(it->memberIndex);
- PropertyAttributes a = o->internalClass->propertyData[it->memberIndex];
+ PropertyAttributes a = o->internalClass()->propertyData[it->memberIndex];
++it->memberIndex;
if (!(it->flags & ObjectIterator::EnumerableOnly) || a.isEnumerable()) {
name = n;
Object *o = this;
while (o) {
- uint idx = o->internalClass->find(name.getPointer());
+ uint idx = o->internalClass()->find(name.getPointer());
if (idx < UINT_MAX) {
if (hasProperty)
*hasProperty = true;
- return getValue(o->propertyAt(idx), o->internalClass->propertyData.at(idx));
+ return getValue(o->propertyAt(idx), o->internalClass()->propertyData.at(idx));
}
o = o->prototype();
// Section 8.12.5
void Object::internalPut(const StringRef name, const ValueRef value)
{
- if (internalClass->engine->hasException)
+ if (internalClass()->engine->hasException)
return;
uint idx = name->asArrayIndex();
name->makeIdentifier();
- uint member = internalClass->find(name.getPointer());
+ uint member = internalClass()->find(name.getPointer());
Property *pd = 0;
PropertyAttributes attrs;
if (member < UINT_MAX) {
pd = propertyAt(member);
- attrs = internalClass->propertyData[member];
+ attrs = internalClass()->propertyData[member];
}
// clause 1
}
return;
} else if (!prototype()) {
- if (!extensible)
+ if (!isExtensible())
goto reject;
} else {
// clause 4
if (attrs.isAccessor()) {
if (!pd->setter())
goto reject;
- } else if (!extensible || !attrs.isWritable()) {
+ } else if (!isExtensible() || !attrs.isWritable()) {
goto reject;
}
- } else if (!extensible) {
+ } else if (!isExtensible()) {
goto reject;
}
}
void Object::internalPutIndexed(uint index, const ValueRef value)
{
- if (internalClass->engine->hasException)
+ if (internalClass()->engine->hasException)
return;
PropertyAttributes attrs;
pd->value = *value;
return;
} else if (!prototype()) {
- if (!extensible)
+ if (!isExtensible())
goto reject;
} else {
// clause 4
if (attrs.isAccessor()) {
if (!pd->setter())
goto reject;
- } else if (!extensible || !attrs.isWritable()) {
+ } else if (!isExtensible() || !attrs.isWritable()) {
goto reject;
}
- } else if (!extensible) {
+ } else if (!isExtensible()) {
goto reject;
}
}
// Section 8.12.7
bool Object::internalDeleteProperty(const StringRef name)
{
- if (internalClass->engine->hasException)
+ if (internalClass()->engine->hasException)
return false;
uint idx = name->asArrayIndex();
name->makeIdentifier();
- uint memberIdx = internalClass->find(name);
+ uint memberIdx = internalClass()->find(name);
if (memberIdx != UINT_MAX) {
- if (internalClass->propertyData[memberIdx].isConfigurable()) {
+ if (internalClass()->propertyData[memberIdx].isConfigurable()) {
InternalClass::removeMember(this, name->identifier);
return true;
}
bool Object::internalDeleteIndexedProperty(uint index)
{
- if (internalClass->engine->hasException)
+ if (internalClass()->engine->hasException)
return false;
if (!arrayData || arrayData->vtable()->del(this, index))
uint memberIndex;
if (isArrayObject() && name->equals(ctx->engine->id_length)) {
- assert(ArrayObject::LengthPropertyIndex == internalClass->find(ctx->engine->id_length));
+ assert(ArrayObject::LengthPropertyIndex == internalClass()->find(ctx->engine->id_length));
Property *lp = propertyAt(ArrayObject::LengthPropertyIndex);
- cattrs = internalClass->propertyData.constData() + ArrayObject::LengthPropertyIndex;
+ cattrs = internalClass()->propertyData.constData() + ArrayObject::LengthPropertyIndex;
if (attrs.isEmpty() || p.isSubset(attrs, *lp, *cattrs))
return true;
if (!cattrs->isWritable() || attrs.type() == PropertyAttributes::Accessor || attrs.isConfigurable() || attrs.isEnumerable())
if (!succeeded)
goto reject;
if (attrs.isAccessor())
- hasAccessorProperty = 1;
+ setHasAccessorProperty();
return true;
}
// Clause 1
- memberIndex = internalClass->find(name.getPointer());
+ memberIndex = internalClass()->find(name.getPointer());
current = (memberIndex < UINT_MAX) ? propertyAt(memberIndex) : 0;
- cattrs = internalClass->propertyData.constData() + memberIndex;
+ cattrs = internalClass()->propertyData.constData() + memberIndex;
if (!current) {
// clause 3
- if (!extensible)
+ if (!isExtensible())
goto reject;
// clause 4
Property pd;
bool Object::__defineOwnProperty__(ExecutionContext *ctx, uint index, const Property &p, PropertyAttributes attrs)
{
// 15.4.5.1, 4b
- if (isArrayObject() && index >= getLength() && !internalClass->propertyData[ArrayObject::LengthPropertyIndex].isWritable())
+ if (isArrayObject() && index >= getLength() && !internalClass()->propertyData[ArrayObject::LengthPropertyIndex].isWritable())
goto reject;
if (ArgumentsObject::isNonStrictArgumentsObject(this))
if (!current) {
// clause 3
- if (!extensible)
+ if (!isExtensible())
goto reject;
// clause 4
Property pp;
PropertyAttributes cattrs;
if (!member.isNull()) {
current = propertyAt(index);
- cattrs = internalClass->propertyData[index];
+ cattrs = internalClass()->propertyData[index];
} else {
current = arrayData->getProperty(index);
cattrs = arrayData->attributes(index);
setArrayAttributes(index, cattrs);
}
if (cattrs.isAccessor())
- hasAccessorProperty = 1;
+ setHasAccessorProperty();
return true;
reject:
if (ctx->strictMode)
Q_ASSERT(isArrayObject());
Scope scope(engine());
- if (other->protoHasArray() || other->hasAccessorProperty) {
+ if (other->protoHasArray() || other->hasAccessorProperty()) {
uint len = other->getLength();
Q_ASSERT(len);
}
} else if (!other->arrayData) {
;
- } else if (other->hasAccessorProperty && other->arrayData->attrs && other->arrayData->isSparse()){
+ } else if (other->hasAccessorProperty() && other->arrayData->attrs && other->arrayData->isSparse()){
// do it the slow way
ScopedValue v(scope);
for (const SparseArrayNode *it = static_cast<const SparseArrayData *>(other->arrayData)->sparse->begin();
bool Object::setArrayLength(uint newLen)
{
Q_ASSERT(isArrayObject());
- if (!internalClass->propertyData[ArrayObject::LengthPropertyIndex].isWritable())
+ if (!internalClass()->propertyData[ArrayObject::LengthPropertyIndex].isWritable())
return false;
uint oldLen = getLength();
bool ok = true;
{
QStringList result;
- QV4::ExecutionEngine *engine = internalClass->engine;
+ QV4::ExecutionEngine *engine = internalClass()->engine;
Scope scope(engine);
ScopedValue v(scope);
Object(ExecutionEngine *engine);
Object(InternalClass *internalClass);
- const ObjectVTable *vtable() const { return reinterpret_cast<const ObjectVTable *>(internalClass->vtable); }
- Object *prototype() const { return internalClass->prototype; }
+ const ObjectVTable *vtable() const { return reinterpret_cast<const ObjectVTable *>(internalClass()->vtable); }
+ Object *prototype() const { return internalClass()->prototype; }
bool setPrototype(Object *proto);
Property *__getOwnProperty__(const StringRef name, PropertyAttributes *attrs = 0);
}
void insertMember(const StringRef s, const Property &p, PropertyAttributes attributes);
- inline ExecutionEngine *engine() const { return internalClass->engine; }
+ inline ExecutionEngine *engine() const { return internalClass()->engine; }
+
+ inline bool hasAccessorProperty() const { return managedData()->hasAccessorProperty; }
+ inline void setHasAccessorProperty() { managedData()->hasAccessorProperty = true; }
+
+ bool isExtensible() const { return managedData()->extensible; }
+ void setExtensible(bool b) { managedData()->extensible = b; }
// Array handling
protected:
BooleanObject(InternalClass *ic)
: Object(ic) {
- Q_ASSERT(internalClass->vtable == staticVTable());
+ Q_ASSERT(internalClass()->vtable == staticVTable());
value = Encode(false);
}
};
protected:
NumberObject(InternalClass *ic)
: Object(ic) {
- Q_ASSERT(internalClass->vtable == staticVTable());
+ Q_ASSERT(internalClass()->vtable == staticVTable());
value = Encode((int)0);
}
};
// ### Clean up
arrayCreate();
if (attributes.isAccessor()) {
- hasAccessorProperty = 1;
+ setHasAccessorProperty();
initSparseArray();
} else if (index > 0x1000 && index > 2*arrayData->alloc) {
initSparseArray();
if (!o)
return ctx->throwTypeError();
- o->extensible = false;
+ o->setExtensible(false);
- o->internalClass = o->internalClass->sealed();
+ o->setInternalClass(o->internalClass()->sealed());
if (o->arrayData) {
ArrayData::ensureAttributes(o.getPointer());
if (ArgumentsObject::isNonStrictArgumentsObject(o.getPointer()))
Scoped<ArgumentsObject>(scope, o)->fullyCreate();
- o->extensible = false;
+ o->setExtensible(false);
- o->internalClass = o->internalClass->frozen();
+ o->setInternalClass(o->internalClass()->frozen());
if (o->arrayData) {
ArrayData::ensureAttributes(o.getPointer());
if (!o)
return ctx->throwTypeError();
- o->extensible = false;
+ o->setExtensible(false);
return o.asReturnedValue();
}
if (!o)
return ctx->throwTypeError();
- if (o->extensible)
+ if (o->isExtensible())
return Encode(false);
- if (o->internalClass != o->internalClass->sealed())
+ if (o->internalClass() != o->internalClass()->sealed())
return Encode(false);
if (!o->arrayData || !o->arrayData->length())
if (!o)
return ctx->throwTypeError();
- if (o->extensible)
+ if (o->isExtensible())
return Encode(false);
- if (o->internalClass != o->internalClass->frozen())
+ if (o->internalClass() != o->internalClass()->frozen())
return Encode(false);
if (!o->arrayData->length())
if (!o)
return ctx->throwTypeError();
- return Encode((bool)o->extensible);
+ return Encode((bool)o->isExtensible());
}
ReturnedValue ObjectPrototype::method_keys(CallContext *ctx)
if (!!p) {
if (o->prototype() == p.getPointer()) {
ok = true;
- } else if (o->extensible) {
+ } else if (o->isExtensible()) {
ok = o->setPrototype(p.getPointer());
}
}
QV4::Scope scope(ctx);
QV4::ScopedFunctionObject f(scope, value);
if (f) {
- if (!f->bindingKeyFlag) {
+ if (!f->bindingKeyFlag()) {
if (!property->isVarProperty() && property->propType != qMetaTypeId<QJSValue>()) {
// assigning a JS function to a non var or QJSValue property or is not allowed.
QString error = QLatin1String("Cannot assign JavaScript function to ");
, m_index(index)
{
setVTable(staticVTable());
- subtype = WrappedQtMethod;
+ setSubtype(WrappedQtMethod);
m_qmlGlobal = qmlGlobal;
}
RegExpCacheKey key(this);
m_cache->remove(key);
}
- _data = 0;
}
void RegExp::destroy(Managed *that)
, value(RegExp::create(ic->engine, QString(), false, false))
, global(false)
{
- Q_ASSERT(internalClass->vtable == staticVTable());
+ Q_ASSERT(internalClass()->vtable == staticVTable());
init(ic->engine);
}
Property *RegExpObject::lastIndexProperty(ExecutionContext *ctx)
{
Q_UNUSED(ctx);
- Q_ASSERT(0 == internalClass->find(ctx->engine->newIdentifier(QStringLiteral("lastIndex"))));
+ Q_ASSERT(0 == internalClass()->find(ctx->engine->newIdentifier(QStringLiteral("lastIndex"))));
return propertyAt(0);
}
if (!f)
return ctx->throwTypeError();
- if (f->subtype == FunctionObject::BoundFunction)
+ if (f->subtype() == FunctionObject::BoundFunction)
f = static_cast<BoundFunction *>(f)->target;
Object *v = left->asObject();
typeHint = NUMBER_HINT;
}
- ExecutionEngine *engine = object->internalClass->engine;
+ ExecutionEngine *engine = object->internalClass()->engine;
if (engine->hasException)
return Encode::undefined();
, qml(qml)
, qmlContext(0)
{
- Q_ASSERT(scope->inUse);
+ Q_ASSERT(scope->inUse());
setVTable(staticVTable());
function = f;
if (function)
function->compilationUnit->ref();
- needsActivation = function ? function->needsActivation() : false;
+ managedData()->needsActivation = function ? function->needsActivation() : false;
Scope s(scope);
ScopedValue protectThis(s, this);
, qml(qml)
, qmlContext(0)
{
- Q_ASSERT(scope->inUse);
+ Q_ASSERT(scope->inUse());
setVTable(staticVTable());
function = 0;
- needsActivation = false;
+ managedData()->needsActivation = false;
Scope s(scope);
ScopedValue protectThis(s, this);
void containerPutIndexed(uint index, const QV4::ValueRef value)
{
- if (internalClass->engine->hasException)
+ if (internalClass()->engine->hasException)
return;
/* Qt containers have int (rather than uint) allowable indexes. */
if (t == o)
return true;
- if (!o->internalClass->vtable->isString)
+ if (!o->internalClass()->vtable->isString)
return false;
String *that = static_cast<String *>(t);
return false;
if (that->identifier && that->identifier == other->identifier)
return true;
- if (that->subtype >= StringType_UInt && that->subtype == other->subtype)
+ if (that->subtype() >= StringType_UInt && that->subtype() == other->subtype())
return true;
return that->toQString() == other->toQString();
{
_text->ref.ref();
len = _text->size;
- subtype = StringType_Unknown;
+ setSubtype(StringType_Unknown);
}
String::String(ExecutionEngine *engine, String *l, String *r)
, stringHash(UINT_MAX), largestSubLength(qMax(l->largestSubLength, r->largestSubLength))
, len(l->len + r->len)
{
- subtype = StringType_Unknown;
+ setSubtype(StringType_Unknown);
if (!l->largestSubLength && l->len > largestSubLength)
largestSubLength = l->len;
{
*ok = true;
- if (subtype == StringType_Unknown)
+ if (subtype() == StringType_Unknown)
createHashValue();
- if (subtype >= StringType_UInt)
+ if (subtype() >= StringType_UInt)
return stringHash;
// ### this conversion shouldn't be required
return false;
if (identifier && identifier == other->identifier)
return true;
- if (subtype >= StringType_UInt && subtype == other->subtype)
+ if (subtype() >= StringType_UInt && subtype() == other->subtype())
return true;
return toQString() == other->toQString();
bool ok;
stringHash = ::toArrayIndex(ch, end, &ok);
if (ok) {
- subtype = (stringHash == UINT_MAX) ? StringType_UInt : StringType_ArrayIndex;
+ setSubtype((stringHash == UINT_MAX) ? StringType_UInt : StringType_ArrayIndex);
return;
}
}
stringHash = h;
- subtype = StringType_Regular;
+ setSubtype(StringType_Regular);
}
uint String::createHashValue(const QChar *ch, int length)
~String() {
if (!largestSubLength && !_text->ref.deref())
QStringData::deallocate(_text);
- _data = 0;
}
bool equals(const StringRef other) const;
Q_ASSERT(!largestSubLength);
if (identifier && identifier == other->identifier)
return true;
- if (subtype >= StringType_UInt && subtype == other->subtype)
+ if (subtype() >= StringType_UInt && subtype() == other->subtype())
return true;
return toQString() == other->toQString();
void simplifyString() const;
inline unsigned hashValue() const {
- if (subtype == StringType_Unknown)
+ if (subtype() == StringType_Unknown)
createHashValue();
Q_ASSERT(!largestSubLength);
return stringHash;
}
uint asArrayIndex() const {
- if (subtype == StringType_Unknown)
+ if (subtype() == StringType_Unknown)
createHashValue();
Q_ASSERT(!largestSubLength);
- if (subtype == StringType_ArrayIndex)
+ if (subtype() == StringType_ArrayIndex)
return stringHash;
return UINT_MAX;
}
StringObject::StringObject(InternalClass *ic)
: Object(ic)
{
- Q_ASSERT(internalClass->vtable == staticVTable());
+ Q_ASSERT(internalClass()->vtable == staticVTable());
Scope scope(engine());
ScopedObject protectThis(scope, this);
QString str = value.stringValue()->toQString();
if (index >= (uint)str.length())
return 0;
- tmpProperty.value = Encode(internalClass->engine->newString(str.mid(index, 1)));
+ tmpProperty.value = Encode(internalClass()->engine->newString(str.mid(index, 1)));
return &tmpProperty;
}
if (isString())
return RuntimeHelpers::stringToNumber(stringValue()->toQString());
{
- ExecutionContext *ctx = objectValue()->internalClass->engine->currentContext();
+ ExecutionContext *ctx = objectValue()->internalClass()->engine->currentContext();
Scope scope(ctx);
ScopedValue prim(scope, RuntimeHelpers::toPrimitive(ValueRef::fromRawValue(this), NUMBER_HINT));
return prim->toNumber();
if (isString())
return stringValue()->toQString();
{
- ExecutionContext *ctx = objectValue()->internalClass->engine->currentContext();
+ ExecutionContext *ctx = objectValue()->internalClass()->engine->currentContext();
Scope scope(ctx);
ScopedValue ex(scope);
bool caughtException = false;
if (isString())
return stringValue()->toQString();
{
- ExecutionContext *ctx = objectValue()->internalClass->engine->currentContext();
+ ExecutionContext *ctx = objectValue()->internalClass()->engine->currentContext();
Scope scope(ctx);
ScopedValue prim(scope, RuntimeHelpers::toPrimitive(ValueRef::fromRawValue(this), STRING_HINT));
return prim->toQString();
{
if (!isManaged())
return false;
- return managed() && managed()->internalClass->vtable->isString;
+ return managed() && managed()->internalClass()->vtable->isString;
}
inline bool Value::isObject() const
{
if (!isManaged())
return false;
- return managed() && managed()->internalClass->vtable->isObject;
+ return managed() && managed()->internalClass()->vtable->isObject;
}
inline bool Value::isPrimitive() const
bool VariantObject::isScarce() const
{
- QVariant::Type t = data.type();
+ QVariant::Type t = ExecutionEngine::ScarceResourceData::data.type();
return t == QVariant::Pixmap || t == QVariant::Image;
}
assert(lv);
if (QV4::VariantObject *rv = other->as<QV4::VariantObject>())
- return lv->data == rv->data;
+ return lv->ExecutionEngine::ScarceResourceData::data == rv->ExecutionEngine::ScarceResourceData::data;
if (QV4::QmlValueTypeWrapper *v = other->as<QmlValueTypeWrapper>())
- return v->isEqual(lv->data);
+ return v->isEqual(lv->ExecutionEngine::ScarceResourceData::data);
return false;
}
// and add to the ep->scarceResources list
// since it is now eligible to be released
// automatically by the engine.
- internalClass->engine->scarceResources.insert(this);
+ internalClass()->engine->scarceResources.insert(this);
}
}
if (o) {
if (o->isScarce())
o->node.remove();
- o->data = QVariant();
+ o->ExecutionEngine::ScarceResourceData::data = QVariant();
}
return Encode::undefined();
}
Scoped<VariantObject> o(scope, ctx->callData->thisObject.as<QV4::VariantObject>());
if (!o)
return Encode::undefined();
- QString result = o->data.toString();
- if (result.isEmpty() && !o->data.canConvert(QVariant::String))
- result = QString::fromLatin1("QVariant(%0)").arg(QString::fromLatin1(o->data.typeName()));
+ QString result = o->ExecutionEngine::ScarceResourceData::data.toString();
+ if (result.isEmpty() && !o->ExecutionEngine::ScarceResourceData::data.canConvert(QVariant::String))
+ result = QString::fromLatin1("QVariant(%0)").arg(QString::fromLatin1(o->ExecutionEngine::ScarceResourceData::data.typeName()));
return Encode(ctx->engine->newString(result));
}
Scope scope(ctx);
Scoped<VariantObject> o(scope, ctx->callData->thisObject.as<QV4::VariantObject>());
if (o) {
- QVariant v = o->data;
+ QVariant v = o->ExecutionEngine::ScarceResourceData::data;
switch (v.type()) {
case QVariant::Invalid:
return Encode::undefined();
QV4::Scope scope(ep->v4engine());
QV4::ScopedFunctionObject f(scope, v4function.value());
Q_ASSERT(f);
- if (f->bindingKeyFlag) {
+ if (f->bindingKeyFlag()) {
QQmlSourceLocation loc = f->as<QV4::QQmlBindingFunction>()->bindingLocation;
url = loc.sourceFile;
lineNumber = loc.line;
return false;
} else if (isVarProperty) {
QV4::FunctionObject *f = result->asFunctionObject();
- if (f && f->bindingKeyFlag) {
+ if (f && f->bindingKeyFlag()) {
// we explicitly disallow this case to avoid confusion. Users can still store one
// in an array in a var property if they need to, but the common case is user error.
expression->delayedError()->setErrorDescription(QLatin1String("Invalid use of Qt.binding() in a binding declaration."));
writeValueProperty(object, core, QVariant(), context, flags);
} else if (type == qMetaTypeId<QJSValue>()) {
QV4::FunctionObject *f = result->asFunctionObject();
- if (f && f->bindingKeyFlag) {
+ if (f && f->bindingKeyFlag()) {
expression->delayedError()->setErrorDescription(QLatin1String("Invalid use of Qt.binding() in a binding declaration."));
expression->delayedError()->setErrorObject(object);
return false;
expression->delayedError()->setErrorObject(object);
return false;
} else if (QV4::FunctionObject *f = result->asFunctionObject()) {
- if (f->bindingKeyFlag)
+ if (f->bindingKeyFlag())
expression->delayedError()->setErrorDescription(QLatin1String("Invalid use of Qt.binding() in a binding declaration."));
else
expression->delayedError()->setErrorDescription(QLatin1String("Unable to assign a function to a property of any type other than var."));
assert(lv);
if (QV4::VariantObject *rv = other->as<VariantObject>())
- return lv->isEqual(rv->data);
+ return lv->isEqual(rv->ExecutionEngine::ScarceResourceData::data);
if (QV4::QmlValueTypeWrapper *v = other->as<QmlValueTypeWrapper>())
return lv->isEqual(v->toVariant());
QV4::ScopedFunctionObject f(scope, value);
if (f) {
- if (!f->bindingKeyFlag) {
+ if (!f->bindingKeyFlag()) {
// assigning a JS function to a non-var-property is not allowed.
QString error = QLatin1String("Cannot assign JavaScript function to value-type property");
Scoped<String> e(scope, r->v8->toString(error));
, originalFunction(originalFunction)
{
setVTable(staticVTable());
- bindingKeyFlag = true;
+ managedData()->bindingKeyFlag = true;
}
void QQmlBindingFunction::initBindingLocation()
QV4::Scope scope(m_v4Engine);
if (QV4::VariantObject *v = value->as<QV4::VariantObject>())
- return v->data;
+ return v->QV4::ExecutionEngine::ScarceResourceData::data;
if (typeHint == QVariant::Bool)
return QVariant(value->toBoolean());
qt_add_sqlexceptions(m_v4Engine);
{
- for (uint i = 0; i < m_v4Engine->globalObject->internalClass->size; ++i) {
- if (m_v4Engine->globalObject->internalClass->nameMap.at(i))
- m_illegalNames.insert(m_v4Engine->globalObject->internalClass->nameMap.at(i)->toQString());
+ for (uint i = 0; i < m_v4Engine->globalObject->internalClass()->size; ++i) {
+ if (m_v4Engine->globalObject->internalClass()->nameMap.at(i))
+ m_illegalNames.insert(m_v4Engine->globalObject->internalClass()->nameMap.at(i)->toQString());
}
}
return true;
if (value->as<QV4::VariantObject>() && name.endsWith('*')) {
int valueType = QMetaType::type(name.left(name.size()-1));
- QVariant &var = value->as<QV4::VariantObject>()->data;
+ QVariant &var = value->as<QV4::VariantObject>()->QV4::ExecutionEngine::ScarceResourceData::data;
if (valueType == var.userType()) {
// We have T t, T* is requested, so return &t.
*reinterpret_cast<void* *>(data) = var.data();
while (proto) {
bool canCast = false;
if (QV4::VariantObject *vo = proto->as<QV4::VariantObject>()) {
- const QVariant &v = vo->data;
+ const QVariant &v = vo->QV4::ExecutionEngine::ScarceResourceData::data;
canCast = (type == v.userType()) || (valueType && (valueType == v.userType()));
}
else if (proto->as<QV4::QObjectWrapper>()) {
if (QV4::RegExpObject *re = value->as<QV4::RegExpObject>())
return re->toQRegExp();
if (QV4::VariantObject *v = value->as<QV4::VariantObject>())
- return v->data;
+ return v->QV4::ExecutionEngine::ScarceResourceData::data;
if (value->as<QV4::QObjectWrapper>())
return qVariantFromValue(qtObjectFromJS(value));
if (QV4::QmlValueTypeWrapper *v = value->as<QV4::QmlValueTypeWrapper>())
QV4::Scoped<QV4::VariantObject> v(scope, value);
if (v) {
- QVariant variant = v->data;
+ QVariant variant = v->QV4::ExecutionEngine::ScarceResourceData::data;
int type = variant.userType();
if (type == QMetaType::QObjectStar)
return *reinterpret_cast<QObject* const *>(variant.constData());
projects / platform / upstream / qtdeclarative.git / commitdiff