if (err)
V4THROW_SQL(SQLEXCEPTION_DATABASE_ERR,query.lastError().text());
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
struct TransactionRollback {
result = v4->catchException();
if (ctx->d() != v4->rootContext())
v4->popContext();
- return QJSValue(v4, result.asReturnedValue());
+ return QJSValue(v4, result->asReturnedValue());
}
/*!
{
QV4::Scope scope(d->m_v4Engine);
QV4::ScopedValue v(scope, d->m_v4Engine->newObject());
- return QJSValue(d->m_v4Engine, v.asReturnedValue());
+ return QJSValue(d->m_v4Engine, v->asReturnedValue());
}
/*!
QQmlEngine::setObjectOwnership(object, QQmlEngine::JavaScriptOwnership);
}
QV4::ScopedValue v(scope, QV4::QObjectWrapper::wrap(v4, object));
- return QJSValue(v4, v.asReturnedValue());
+ return QJSValue(v4, v->asReturnedValue());
}
/*!
Q_D(const QJSEngine);
QV4::Scope scope(d->m_v4Engine);
QV4::ScopedValue v(scope, d->m_v4Engine->globalObject());
- return QJSValue(d->m_v4Engine, v.asReturnedValue());
+ return QJSValue(d->m_v4Engine, v->asReturnedValue());
}
/*!
Q_D(QJSEngine);
QV4::Scope scope(d->m_v4Engine);
QV4::ScopedValue v(scope, scope.engine->metaTypeToJS(type, ptr));
- return QJSValue(d->m_v4Engine, v.asReturnedValue());
+ return QJSValue(d->m_v4Engine, v->asReturnedValue());
}
/*!
if (engine->hasException)
result = engine->catchException();
- return QJSValue(engine, result.asReturnedValue());
+ return QJSValue(engine, result->asReturnedValue());
}
/*!
if (engine->hasException)
result = engine->catchException();
- return QJSValue(engine, result.asReturnedValue());
+ return QJSValue(engine, result->asReturnedValue());
}
/*!
if (engine->hasException)
result = engine->catchException();
- return QJSValue(engine, result.asReturnedValue());
+ return QJSValue(engine, result->asReturnedValue());
}
#ifdef QT_DEPRECATED
if (engine->hasException)
result = engine->catchException();
- return QJSValue(engine, result.asReturnedValue());
+ return QJSValue(engine, result->asReturnedValue());
}
/*!
QV4::ScopedValue result(scope, arrayIndex == UINT_MAX ? o->get(engine->id_uintMax) : o->getIndexed(arrayIndex));
if (engine->hasException)
engine->catchException();
- return QJSValue(engine, result.asReturnedValue());
+ return QJSValue(engine, result->asReturnedValue());
}
/*!
engine->catchException();
return QJSValue();
}
- return QJSValue(engine, v.asReturnedValue());
+ return QJSValue(engine, v->asReturnedValue());
}
instance->setArrayLength(len - 1);
else
instance->put(ctx->d()->engine->id_length, ScopedValue(scope, Primitive::fromDouble(len - 1)));
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
ReturnedValue ArrayPrototype::method_push(CallContext *ctx)
instance->setArrayLengthUnchecked(len - 1);
else
instance->put(ctx->d()->engine->id_length, ScopedValue(scope, Primitive::fromDouble(len - 1)));
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
ReturnedValue ArrayPrototype::method_slice(CallContext *ctx)
}
++k;
}
- return acc.asReturnedValue();
+ return acc->asReturnedValue();
}
ReturnedValue ArrayPrototype::method_reduceRight(CallContext *ctx)
}
--k;
}
- return acc.asReturnedValue();
+ return acc->asReturnedValue();
}
bool hasProperty = false;
v = w->get(name, &hasProperty);
if (hasProperty) {
- return v.asReturnedValue();
+ return v->asReturnedValue();
}
continue;
}
bool hasProperty = false;
v = activation->get(name, &hasProperty);
if (hasProperty)
- return v.asReturnedValue();
+ return v->asReturnedValue();
}
if (f->function() && f->function()->isNamedExpression()
&& name->equals(ScopedString(scope, f->function()->name())))
bool hasProperty = false;
v = global->get(name, &hasProperty);
if (hasProperty)
- return v.asReturnedValue();
+ return v->asReturnedValue();
}
}
ScopedValue n(scope, name);
v = w->get(name, &hasProperty);
if (hasProperty) {
*base = w->d();
- return v.asReturnedValue();
+ return v->asReturnedValue();
}
continue;
}
if (hasProperty) {
if (ctx->d()->type == Heap::ExecutionContext::Type_QmlContext)
*base = activation->d();
- return v.asReturnedValue();
+ return v->asReturnedValue();
}
}
if (f->function() && f->function()->isNamedExpression()
bool hasProperty = false;
v = global->get(name, &hasProperty);
if (hasProperty)
- return v.asReturnedValue();
+ return v->asReturnedValue();
}
}
ScopedValue n(scope, name);
QV4::Scope scope(this);
QV4::ScopedValue retn(scope, QV4::SequencePrototype::fromVariant(this, variant, &succeeded));
if (succeeded)
- return retn.asReturnedValue();
+ return retn->asReturnedValue();
return QV4::Encode(newArrayObject(*reinterpret_cast<const QStringList *>(ptr)));
}
case QMetaType::QVariantList:
bool succeeded = false;
QV4::ScopedValue retn(scope, QV4::SequencePrototype::fromVariant(this, variant, &succeeded));
if (succeeded)
- return retn.asReturnedValue();
+ return retn->asReturnedValue();
if (const QMetaObject *vtmo = QQmlValueTypeFactory::metaObjectForMetaType(type))
return QV4::QQmlValueTypeWrapper::create(this, variant, vtmo, type);
return Encode::undefined();
if (result->isObject())
- return result.asReturnedValue();
+ return result->asReturnedValue();
return obj.asReturnedValue();
}
if (f->function()->compiledFunction->hasQmlDependencies())
QmlContextWrapper::registerQmlDependencies(ctx->d()->engine, f->function()->compiledFunction);
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
DEFINE_OBJECT_VTABLE(SimpleScriptFunction);
if (f->function()->compiledFunction->hasQmlDependencies())
QmlContextWrapper::registerQmlDependencies(v4, f->function()->compiledFunction);
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
Heap::Object *SimpleScriptFunction::protoForConstructor()
callback(callbackFunction, result);
}
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
QT_END_NAMESPACE
END;
error->offset = 0;
error->error = QJsonParseError::NoError;
- return v.asReturnedValue();
+ return v->asReturnedValue();
}
/*
value = replacerFunction->call(callData);
}
- o = value.asReturnedValue();
+ o = value->asReturnedValue();
if (o) {
if (NumberObject *n = o->asNumberObject())
value = n->value();
return std::isfinite(d) ? value->toQString() : QStringLiteral("null");
}
- o = value.asReturnedValue();
+ o = value->asReturnedValue();
if (o) {
if (!o->asFunctionObject()) {
if (o->asArrayObject()) {
return ctx->engine()->throwSyntaxError(QStringLiteral("JSON.parse: Parse error"));
}
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
ReturnedValue JsonObject::method_stringify(CallContext *ctx)
};
private:
void *operator new(size_t);
- Managed();
- Managed(const Managed &other);
- void operator = (const Managed &other);
- void *operator new(size_t size, MemoryManager *mm);
- void *operator new(size_t, Managed *m) { return m; }
+ Managed() Q_DECL_EQ_DELETE;
+ Q_DISABLE_COPY(Managed)
public:
static bool isEqualTo(Managed *m, Managed *other);
- ReturnedValue asReturnedValue() { return Value::fromManaged(this).asReturnedValue(); }
-
bool inUse() const { return d()->inUse(); }
bool markBit() const { return d()->isMarked(); }
ScopedValue v(scope, ctx->d()->callData->thisObject.toObject(scope.engine));
if (ctx->d()->engine->hasException)
return Encode::undefined();
- return v.asReturnedValue();
+ return v->asReturnedValue();
}
ReturnedValue ObjectPrototype::method_hasOwnProperty(CallContext *ctx)
bool succeeded = false;
QV4::ScopedValue retn(scope, QV4::SequencePrototype::newSequence(v4, property.propType, object, property.coreIndex, &succeeded));
if (succeeded)
- return retn.asReturnedValue();
+ return retn->asReturnedValue();
}
if (property.propType == QMetaType::UnknownType) {
QV4::ScopedValue method(scope, QV4::QObjectMethod::create(global, d()->object, index));
if (hasProperty)
*hasProperty = true;
- return method.asReturnedValue();
+ return method->asReturnedValue();
}
QQmlPropertyData local;
}
}
- return rv.asReturnedValue();
+ return rv->asReturnedValue();
}
if (captureRequired && ep && !property->isConstant())
QV4::ScopedValue rv(scope, create(engine, object));
ddata->jsWrapper.set(scope.engine, rv);
ddata->jsEngineId = engine->m_engineId;
- return rv.asReturnedValue();
+ return rv->asReturnedValue();
} else {
// If this object is tainted, we have to check to see if it is in our
QV4::ScopedValue result(scope, create(engine, object));
ddata->jsWrapper.set(scope.engine, result);
ddata->jsEngineId = engine->m_engineId;
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
if (!alternateWrapper) {
if (QObject *object = qobjectWrapper->object())
QQmlData::get(object, true)->setImplicitDestructible();
}
- return rv.asReturnedValue();
+ return rv->asReturnedValue();
} else {
return QV4::Encode::undefined();
}
void *args[] = { 0, &funcptr };
object.metacall(QMetaObject::InvokeMetaMethod, method.coreIndex, args);
- return rv.asReturnedValue();
+ return rv->asReturnedValue();
}
if (!method.isOverload()) {
}
array->setArrayLengthUnchecked(len);
array->memberData()->data[Index_ArrayIndex] = Primitive::fromInt32(result);
- array->memberData()->data[Index_ArrayInput] = arg.asReturnedValue();
+ array->memberData()->data[Index_ArrayInput] = arg;
RegExpCtor::Data *dd = regExpCtor->d();
dd->lastMatch = array;
ScopedValue result(scope, lastMatch ? lastMatch->getIndexed(index) : Encode::undefined());
if (result->isUndefined())
return ctx->d()->engine->newString()->asReturnedValue();
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
ReturnedValue RegExpPrototype::method_get_lastParen(CallContext *ctx)
ScopedValue result(scope, lastMatch ? lastMatch->getIndexed(lastMatch->getLength() - 1) : Encode::undefined());
if (result->isUndefined())
return ctx->d()->engine->newString()->asReturnedValue();
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
ReturnedValue RegExpPrototype::method_get_input(CallContext *ctx)
if (!v)
return Encode(false);
- ScopedObject o(scope, QV4::Value::fromReturnedValue(f->protoProperty()).asObject());
+ ScopedObject o(scope, f->protoProperty());
if (!o)
return engine->throwTypeError();
}
ScopedValue &operator=(Managed *m) {
- ptr->val = m->asReturnedValue();
+ *ptr = *m;
return *this;
}
operator Value *() { return ptr; }
operator const Value &() const { return *ptr; }
- ReturnedValue asReturnedValue() const { return ptr->val; }
-
Value *ptr;
};
struct Scoped
{
enum _Convert { Convert };
- enum _Cast { Cast };
inline void setPointer(Managed *p) {
-#if QT_POINTER_SIZE == 8
ptr->m = p ? p->m : 0;
-#else
- *ptr = QV4::Value::fromManaged(p);
+#if QT_POINTER_SIZE == 4
+ ptr->tag = QV4::Value::Managed_Type;
#endif
}
Scoped(const Scope &scope, Heap::Base *o)
{
Value v;
- v.m = o;
-#if QT_POINTER_SIZE == 4
- v.tag = QV4::Value::Managed_Type;
-#endif
+ v = o;
ptr = scope.engine->jsStackTop++;
setPointer(value_cast<T>(v));
#ifndef QT_NO_DEBUG
++scope.size;
#endif
}
- template<typename X>
- Scoped(const Scope &scope, X *t, _Cast)
- {
- ptr = scope.engine->jsStackTop++;
- setPointer(managed_cast<T>(t));
-#ifndef QT_NO_DEBUG
- ++scope.size;
-#endif
- }
Scoped(const Scope &scope, const ReturnedValue &v)
{
Scoped<T> &operator=(Heap::Base *o) {
Value v;
- v.m = o;
-#if QT_POINTER_SIZE == 4
- v.tag = QV4::Value::Managed_Type;
-#endif
+ v = o;
setPointer(value_cast<T>(v));
return *this;
}
}
T *getPointer() {
- return static_cast<T *>(ptr->managed());
+ return ptr->cast<T>();
}
typename T::Data **getRef() {
return reinterpret_cast<typename T::Data **>(&ptr->m);
}
ReturnedValue asReturnedValue() const {
-#if QT_POINTER_SIZE == 8
- return ptr->val ? ptr->val : Primitive::undefinedValue().asReturnedValue();
-#else
- return ptr->val;
-#endif
+ return ptr->m ? ptr->val : Encode::undefined();
}
Value *ptr;
return *this;
}
-//template<typename T>
-//inline TypedValue<T> &TypedValue<T>::operator =(const ManagedRef<T> &v)
-//{
-// val = v.asReturnedValue();
-// return *this;
-//}
-
template<typename T>
inline TypedValue<T> &TypedValue<T>::operator=(const TypedValue<T> &t)
{
ScopedValue result(scope, This->function()->code(engine, This->function()->codeData));
engine->popContext();
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
void QmlBindingWrapper::markObjects(Heap::Base *m, ExecutionEngine *e)
scope.engine->catchException();
return Encode::undefined();
}
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
for (quint32 ii = 0; ii < size; ++ii) {
name = deserialize(data, engine);
value = deserialize(data, engine);
- n = name.asReturnedValue();
+ n = name->asReturnedValue();
o->put(n, value);
}
return o.asReturnedValue();
agent->release();
agent->setEngine(engine);
- return rv.asReturnedValue();
+ return rv->asReturnedValue();
}
case WorkerSequence:
{
value = callData->args[0].toString(v4);
else
value = v4->newString();
- return value.asReturnedValue();
+ return value->asReturnedValue();
}
void StringPrototype::init(ExecutionEngine *engine, Object *ctor)
if (!rv)
args->setReturnValue(QV4::Encode::null());
else
- args->setReturnValue(object.asReturnedValue());
+ args->setReturnValue(object->asReturnedValue());
}
/*!
if (hasProp) {
if (hasProperty)
*hasProperty = hasProp;
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
if (resource->d()->isNullWrapper)
if (hasProp) {
if (hasProperty)
*hasProperty = hasProp;
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
// Its possible we could delay the calculation of the "actual" context (in the case
if (!context) {
if (hasProperty)
*hasProperty = true;
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
// Search type (attached property/enum/imported scripts) names
if (hasProp) {
if (hasProperty)
*hasProperty = true;
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
}
scopeObject = 0;
if (hasProp) {
if (hasProperty)
*hasProperty = true;
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
}
expressionContext->unresolvedNames = true;
- return Primitive::undefinedValue().asReturnedValue();
+ return Encode::undefined();
}
void QmlContextWrapper::put(Managed *m, String *name, const Value &value)
ep->propertyCapture = lastPropertyCapture;
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
void QQmlJavaScriptExpression::GuardCapture::captureProperty(QQmlNotifier *n)
}
if (qmlscope)
qmlscope->set(v4, qmlScopeObject);
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
QV4::ReturnedValue QQmlJavaScriptExpression::qmlBinding(QQmlContextData *ctxt, QObject *qmlScope,
}
if (qmlscope)
qmlscope->set(v4, qmlScopeObject);
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
{
QV4::ExecutionEngine *v4 = static_cast<DelegateModelGroupFunction *>(that)->engine();
QV4::Scope scope(v4);
- QV4::Scoped<DelegateModelGroupFunction> f(scope, that, QV4::Scoped<DelegateModelGroupFunction>::Cast);
+ QV4::Scoped<DelegateModelGroupFunction> f(scope, static_cast<DelegateModelGroupFunction *>(that));
QV4::Scoped<QQmlDelegateModelItemObject> o(scope, callData->thisObject);
if (!o)
return v4->throwTypeError(QStringLiteral("Not a valid VisualData object"));
v = f->call(callData);
if (scope.hasException())
v = scope.engine->catchException();
- return v.asReturnedValue();
+ return v->asReturnedValue();
}
QNetworkAccessManager *QQuickWorkerScriptEnginePrivate::WorkerEngine::networkAccessManager()
}
}
- return valuemap.asReturnedValue();
+ return valuemap->asReturnedValue();
}
#include <moc_qquickloader_p.cpp>
scope.engine->catchException();
return QV4::Encode::undefined();
}
- return result.asReturnedValue();
+ return result->asReturnedValue();
}
#define EVALUATE_ERROR(source) evaluate_error(engine, object, source)