struct CompareFunctor
{
- CompareFunctor(QV4::ExecutionContext *ctx, const QV4::Value &compareFn)
+ CompareFunctor(QV4::ExecutionContext *ctx, const QV4::ValueRef compareFn)
: m_ctx(ctx), m_compareFn(compareFn)
{}
bool operator()(typename Container::value_type lhs, typename Container::value_type rhs)
{
- QV4::Managed *fun = this->m_compareFn.asManaged();
- Scope scope(fun->engine());
+ QV4::Scope scope(m_ctx);
+ ScopedObject compare(scope, m_compareFn);
ScopedCallData callData(scope, 2);
callData->args[0] = convertElementToValue(this->m_ctx->engine, lhs);
callData->args[1] = convertElementToValue(this->m_ctx->engine, rhs);
- callData->thisObject = QV4::Value::fromObject(this->m_ctx->engine->globalObject);
- QV4::ScopedValue result(scope, fun->call(callData));
+ callData->thisObject = this->m_ctx->engine->globalObject;
+ QV4::ScopedValue result(scope, compare->call(callData));
return result->toNumber() < 0;
}
private:
QV4::ExecutionContext *m_ctx;
- QV4::Value m_compareFn;
+ QV4::ValueRef m_compareFn;
};
void sort(QV4::SimpleCallContext *ctx)
loadReference();
}
+ QV4::Scope scope(ctx);
if (ctx->callData->argc == 1 && ctx->callData->args[0].asFunctionObject()) {
- QV4::Value compareFn = ctx->callData->args[0];
- CompareFunctor cf(ctx, compareFn);
+ CompareFunctor cf(ctx, ctx->callData->args[0]);
std::sort(m_container.begin(), m_container.end(), cf);
} else {
DefaultCompareFunctor cf;
return qMetaTypeId<SequenceType>(); \
} else
-int SequencePrototype::metaTypeForSequence(QV4::Object *object)
+int SequencePrototype::metaTypeForSequence(QV4::ObjectRef object)
{
FOREACH_QML_SEQUENCE_TYPE(MAP_META_TYPE)
/*else*/ {
// serialization/deserialization failures
#define ALIGN(size) (((size) + 3) & ~3)
-void Serialize::serialize(QByteArray &data, const QV4::Value &v, QV8Engine *engine)
+void Serialize::serialize(QByteArray &data, const QV4::ValueRef v, QV8Engine *engine)
{
QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine);
QV4::Scope scope(v4);
- if (v.isEmpty()) {
+ if (v->isEmpty()) {
Q_ASSERT(!"Serialize: got empty value");
- } else if (v.isUndefined()) {
+ } else if (v->isUndefined()) {
push(data, valueheader(WorkerUndefined));
- } else if (v.isNull()) {
+ } else if (v->isNull()) {
push(data, valueheader(WorkerNull));
- } else if (v.isBoolean()) {
- push(data, valueheader(v.booleanValue() == true ? WorkerTrue : WorkerFalse));
- } else if (QV4::String *s = v.asString()) {
- const QString &qstr = s->toQString();
+ } else if (v->isBoolean()) {
+ push(data, valueheader(v->booleanValue() == true ? WorkerTrue : WorkerFalse));
+ } else if (v->isString()) {
+ const QString &qstr = v->toQString();
int length = qstr.length();
if (length > 0xFFFFFF) {
push(data, valueheader(WorkerUndefined));
char *buffer = data.data() + offset;
memcpy(buffer, qstr.constData(), length*sizeof(QChar));
- } else if (v.asFunctionObject()) {
+ } else if (v->asFunctionObject()) {
// XXX TODO: Implement passing function objects between the main and
// worker scripts
push(data, valueheader(WorkerUndefined));
- } else if (QV4::ArrayObject *array = v.asArrayObject()) {
+ } else if (v->asArrayObject()) {
+ QV4::ScopedArrayObject array(scope, v);
uint32_t length = array->arrayLength();
if (length > 0xFFFFFF) {
push(data, valueheader(WorkerUndefined));
}
reserve(data, sizeof(quint32) + length * sizeof(quint32));
push(data, valueheader(WorkerArray, length));
+ ScopedValue val(scope);
for (uint32_t ii = 0; ii < length; ++ii)
- serialize(data, QV4::Value::fromReturnedValue(array->getIndexed(ii)), engine);
- } else if (v.isInteger()) {
+ serialize(data, (val = array->getIndexed(ii)), engine);
+ } else if (v->isInteger()) {
reserve(data, 2 * sizeof(quint32));
push(data, valueheader(WorkerInt32));
- push(data, (quint32)v.integerValue());
+ push(data, (quint32)v->integerValue());
// } else if (v->IsUint32()) {
// reserve(data, 2 * sizeof(quint32));
// push(data, valueheader(WorkerUint32));
// push(data, v->Uint32Value());
- } else if (v.isNumber()) {
+ } else if (v->isNumber()) {
reserve(data, sizeof(quint32) + sizeof(double));
push(data, valueheader(WorkerNumber));
- push(data, v.asDouble());
- } else if (QV4::DateObject *d = v.asDateObject()) {
+ push(data, v->asDouble());
+ } else if (QV4::DateObject *d = v->asDateObject()) {
reserve(data, sizeof(quint32) + sizeof(double));
push(data, valueheader(WorkerDate));
push(data, d->value.asDouble());
- } else if (QV4::RegExpObject *re = v.as<RegExpObject>()) {
+ } else if (v->as<RegExpObject>()) {
+ Scoped<RegExpObject> re(scope, v);
quint32 flags = re->flags();
QString pattern = re->source();
int length = pattern.length() + 1;
char *buffer = data.data() + offset;
memcpy(buffer, pattern.constData(), length*sizeof(QChar));
- } else if (QV4::QObjectWrapper *qobjectWrapper = v.as<QV4::QObjectWrapper>()) {
+ } else if (v->as<QV4::QObjectWrapper>()) {
+ Scoped<QObjectWrapper> qobjectWrapper(scope, v);
// XXX TODO: Generalize passing objects between the main thread and worker scripts so
// that others can trivially plug in their elements.
QQmlListModel *lm = qobject_cast<QQmlListModel *>(qobjectWrapper->object());
}
// No other QObject's are allowed to be sent
push(data, valueheader(WorkerUndefined));
- } else if (QV4::Object *o = v.asObject()) {
-
+ } else if (v->asObject()) {
+ ScopedObject o(scope, v);
if (o->isListType()) {
// valid sequence. we generate a length (sequence length + 1 for the sequence type)
uint32_t seqLength = ScopedValue(scope, o->get(v4->id_length))->toUInt32();
reserve(data, sizeof(quint32) + length * sizeof(quint32));
push(data, valueheader(WorkerSequence, length));
serialize(data, QV4::Primitive::fromInt32(QV4::SequencePrototype::metaTypeForSequence(o)), engine); // sequence type
+ ScopedValue val(scope);
for (uint32_t ii = 0; ii < seqLength; ++ii)
- serialize(data, QV4::Value::fromReturnedValue(o->getIndexed(ii)), engine); // sequence elements
+ serialize(data, (val = o->getIndexed(ii)), engine); // sequence elements
return;
}
// regular object
- QV4::ScopedValue val(scope, v);
+ QV4::ScopedValue val(scope, *v);
QV4::ScopedArrayObject properties(scope, QV4::ObjectPrototype::getOwnPropertyNames(v4, val));
quint32 length = properties->arrayLength();
if (length > 0xFFFFFF) {
return QV4::Encode::undefined();
}
-QByteArray Serialize::serialize(const QV4::Value &value, QV8Engine *engine)
+QByteArray Serialize::serialize(const QV4::ValueRef value, QV8Engine *engine)
{
QByteArray rv;
serialize(rv, value, engine);