Scoped<ArrayData> newData(scope);
if (newType < Heap::ArrayData::Sparse) {
Heap::SimpleArrayData *n = scope.engine->memoryManager->allocManaged<SimpleArrayData>(size);
- new (n) Heap::SimpleArrayData(scope.engine);
+ new (n) Heap::SimpleArrayData;
n->offset = 0;
n->len = d ? d->d()->len : 0;
newData = n;
} else {
Heap::SparseArrayData *n = scope.engine->memoryManager->allocManaged<SparseArrayData>(size);
- new (n) Heap::SparseArrayData(scope.engine);
+ new (n) Heap::SparseArrayData;
newData = n;
}
newData->setAlloc(alloc);
namespace Heap {
struct ArrayData : public Base {
- ArrayData(InternalClass *ic)
- : Base(ic)
- {}
enum Type {
Simple = 0,
Complex = 1,
};
struct SimpleArrayData : public ArrayData {
- SimpleArrayData(ExecutionEngine *engine)
- : ArrayData(engine->emptyClass)
- {}
-
uint mappedIndex(uint index) const { return (index + offset) % alloc; }
Value data(uint index) const { return arrayData[mappedIndex(index)]; }
Value &data(uint index) { return arrayData[mappedIndex(index)]; }
};
struct SparseArrayData : public ArrayData {
- inline SparseArrayData(ExecutionEngine *engine);
inline ~SparseArrayData();
uint mappedIndex(uint index) const {
};
namespace Heap {
-inline SparseArrayData::SparseArrayData(ExecutionEngine *engine)
- : ArrayData(engine->emptyClass)
-{
-}
inline SparseArrayData::~SparseArrayData()
{
Heap::String *ExecutionEngine::newString(const QString &s)
{
Scope scope(this);
- return ScopedString(scope, memoryManager->alloc<String>(this, s))->d();
+ return ScopedString(scope, memoryManager->alloc<String>(s))->d();
}
Heap::String *ExecutionEngine::newIdentifier(const QString &text)
inline
Heap::ExecutionContext::ExecutionContext(ExecutionEngine *engine, ContextType t)
- : Heap::Base(engine->emptyClass)
- , type(t)
+ : type(t)
, strictMode(false)
, engine(engine)
, parent(engine->currentContext())
break;
}
// duplicate arguments, need some trick to store them
- arg = engine->memoryManager->alloc<String>(engine, arg->d(), engine->newString(QString(0xfffe)));
+ arg = engine->memoryManager->alloc<String>(arg->d(), engine->newString(QString(0xfffe)));
}
}
ReturnedValue FunctionObject::construct(Managed *that, CallData *)
{
- that->internalClass()->engine->throwTypeError();
+ static_cast<FunctionObject *>(that)->internalClass()->engine->throwTypeError();
return Encode::undefined();
}
ReturnedValue SimpleScriptFunction::call(Managed *that, CallData *callData)
{
- ExecutionEngine *v4 = that->internalClass()->engine;
+ ExecutionEngine *v4 = static_cast<SimpleScriptFunction *>(that)->internalClass()->engine;
if (v4->hasException)
return Encode::undefined();
CHECK_STACK_LIMITS(v4);
ReturnedValue BuiltinFunction::construct(Managed *f, CallData *)
{
- return f->internalClass()->engine->throwTypeError();
+ return static_cast<BuiltinFunction *>(f)->internalClass()->engine->throwTypeError();
}
ReturnedValue BuiltinFunction::call(Managed *that, CallData *callData)
template <typename T>
T *as() {
- Q_ASSERT(internalClass());
+ Q_ASSERT(d()->vtable);
#if !defined(QT_NO_QOBJECT_CHECK)
static_cast<T *>(this)->qt_check_for_QMANAGED_macro(static_cast<T *>(this));
#endif
}
template <typename T>
const T *as() const {
- Q_ASSERT(internalClass());
+ Q_ASSERT(d()->vtable);
#if !defined(QT_NO_QOBJECT_CHECK)
static_cast<T *>(this)->qt_check_for_QMANAGED_macro(static_cast<T *>(const_cast<Managed *>(this)));
#endif
ReturnedValue asReturnedValue() { return Value::fromManaged(this).asReturnedValue(); }
- InternalClass *internalClass() const { return d()->internalClass; }
- void setInternalClass(InternalClass *ic) { d()->internalClass = ic; }
-
bool inUse() const { return d()->inUse(); }
bool markBit() const { return d()->isMarked(); }
if (old)
memcpy(newMemberData->d(), old, sizeof(Heap::MemberData) + s*sizeof(Value));
else
- new (newMemberData->d()) Heap::MemberData(e->emptyClass);
+ new (newMemberData->d()) Heap::MemberData;
newMemberData->d()->size = newAlloc;
return newMemberData->d();
}
namespace Heap {
struct MemberData : Base {
- MemberData(InternalClass *c)
- : Base(c), size(0) {}
union {
uint size;
double _dummy;
DEFINE_OBJECT_VTABLE(Object);
Heap::Object::Object(InternalClass *internalClass, QV4::Object *prototype)
- : Heap::Base(internalClass),
+ : internalClass(internalClass),
prototype(prototype ? prototype->d() : 0)
{
if (internalClass->size) {
struct Object : Base {
Object(ExecutionEngine *engine)
- : Base(engine->emptyClass),
+ : internalClass(engine->emptyClass),
prototype(static_cast<Object *>(engine->objectPrototype.m))
{
}
const Property *propertyAt(uint index) const { return reinterpret_cast<const Property *>(memberData->data + index); }
Property *propertyAt(uint index) { return reinterpret_cast<Property *>(memberData->data + index); }
+ InternalClass *internalClass;
Heap::Object *prototype;
MemberData *memberData;
ArrayData *arrayData;
IsObject = true
};
+ InternalClass *internalClass() const { return d()->internalClass; }
+ void setInternalClass(InternalClass *ic) { d()->internalClass = ic; }
+
Heap::MemberData *memberData() { return d()->memberData; }
const Heap::MemberData *memberData() const { return d()->memberData; }
Heap::ArrayData *arrayData() const { return d()->arrayData; }
}
Heap::RegExp::RegExp(ExecutionEngine* engine, const QString &pattern, bool ignoreCase, bool multiline)
- : Base(engine->emptyClass)
- , pattern(pattern)
+ : pattern(pattern)
, ignoreCase(ignoreCase)
, multiLine(multiline)
{
return pright->asReturnedValue();
if (!pright->stringValue()->d()->length())
return pleft->asReturnedValue();
- return (engine->memoryManager->alloc<String>(engine, pleft->stringValue()->d(), pright->stringValue()->d()))->asReturnedValue();
+ return (engine->memoryManager->alloc<String>(pleft->stringValue()->d(), pright->stringValue()->d()))->asReturnedValue();
}
double x = RuntimeHelpers::toNumber(pleft);
double y = RuntimeHelpers::toNumber(pright);
return right->asReturnedValue();
if (!right->stringValue()->d()->length())
return left->asReturnedValue();
- return (engine->memoryManager->alloc<String>(engine, left->stringValue()->d(), right->stringValue()->d()))->asReturnedValue();
+ return (engine->memoryManager->alloc<String>(left->stringValue()->d(), right->stringValue()->d()))->asReturnedValue();
}
Scope scope(engine);
return pright->asReturnedValue();
if (!pright->stringValue()->d()->length())
return pleft->asReturnedValue();
- return (engine->memoryManager->alloc<String>(engine, pleft->stringValue()->d(), pright->stringValue()->d()))->asReturnedValue();
+ return (engine->memoryManager->alloc<String>(pleft->stringValue()->d(), pright->stringValue()->d()))->asReturnedValue();
}
void Runtime::setProperty(ExecutionEngine *engine, const ValueRef object, int nameIndex, const ValueRef value)
}
-Heap::String::String(ExecutionEngine *engine, const QString &t)
- : Heap::Base(engine->emptyClass)
+Heap::String::String(const QString &t)
{
subtype = String::StringType_Unknown;
len = text->size;
}
-Heap::String::String(ExecutionEngine *engine, String *l, String *r)
- : Heap::Base(engine->emptyClass)
+Heap::String::String(String *l, String *r)
{
subtype = String::StringType_Unknown;
StringType_ArrayIndex
};
- String(ExecutionEngine *engine, const QString &text);
- String(ExecutionEngine *engine, String *l, String *n);
+ String(const QString &text);
+ String(String *l, String *n);
~String() {
if (!largestSubLength && !text->ref.deref())
QStringData::deallocate(text);
namespace Heap {
struct Q_QML_EXPORT Base {
- Base() {}
- Base(InternalClass *internal)
- : internalClass(internal)
- {
-// Q_ASSERT(vtable && inUse() && !isMarked());
- // ####
- // Q_ASSERT(internal && internal->vtable);
- }
union {
const ManagedVTable *vtable;
quintptr mm_data;
};
- InternalClass *internalClass;
inline ReturnedValue asReturnedValue() const;
inline void mark(QV4::ExecutionEngine *engine);