qjsmanagedvalue.cpp

Go to the documentation of this file.

// Copyright (C) 2020 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include <QtQml/qjsmanagedvalue.h>
#include <QtQml/qjsengine.h>
#include <QtQml/private/qv4persistent_p.h>
#include <QtQml/private/qv4engine_p.h>
#include <QtQml/private/qv4mm_p.h>
#include <QtQml/private/qjsvalue_p.h>
#include <QtQml/private/qv4runtime_p.h>
#include <QtQml/private/qv4functionobject_p.h>
#include <QtQml/private/qv4jscall_p.h>
#include <QtQml/private/qv4urlobject_p.h>
#include <QtQml/private/qv4variantobject_p.h>
#include <QtQml/private/qv4qobjectwrapper_p.h>
#include <QtQml/private/qv4qmetaobjectwrapper_p.h>
#include <QtQml/private/qv4regexpobject_p.h>
#include <QtQml/private/qv4dateobject_p.h>
#include <QtQml/private/qv4errorobject_p.h>
#include <QtQml/private/qv4identifiertable_p.h>
 
#include <QtCore/qregularexpression.h>
#include <QtCore/qurl.h>
#include <QtCore/qdatetime.h>
 
QT_BEGIN_NAMESPACE
 
static QV4::ExecutionEngine *v4Engine(QV4::Value *d)
{
    if (!d)
        return nullptr;
 
    QV4::ExecutionEngine *v4 = QV4::PersistentValueStorage::getEngine(d);
    Q_ASSERT(v4);
    return v4;
}
 
QJSManagedValue::QJSManagedValue(QJSValue value, QJSEngine *engine)
{
    QV4::ExecutionEngine *v4 = engine->handle();
 
    if (QV4::Value *m = QJSValuePrivate::takeManagedValue(&value)) {
        if (Q_UNLIKELY(v4Engine(m) != v4)) {
            qWarning("QJSManagedValue(QJSValue, QJSEngine *) failed: "
                     "Value was created in different engine.");
            QV4::PersistentValueStorage::free(m);
            return;
        }
 
        d = m;
        return;
    }
 
    d = v4->memoryManager->m_persistentValues->allocate();
 
    if (const QString *string = QJSValuePrivate::asQString(&value))
        *d = v4->newString(*string);
    else
        *d = QJSValuePrivate::asReturnedValue(&value);
}
 
QJSManagedValue::QJSManagedValue(const QJSPrimitiveValue &value, QJSEngine *engine) :
    QJSManagedValue(engine->handle())
{
    switch (value.type()) {
    case QJSPrimitiveValue::Undefined:
        *d = QV4::Encode::undefined();
        return;
    case QJSPrimitiveValue::Null:
        *d = QV4::Encode::null();
        return;
    case QJSPrimitiveValue::Boolean:
        *d = QV4::Encode(value.asBoolean());
        return;
    case QJSPrimitiveValue::Integer:
        *d = QV4::Encode(value.asInteger());
        return;
    case QJSPrimitiveValue::Double:
        *d = QV4::Encode(value.asDouble());
        return;
    case QJSPrimitiveValue::String:
        *d = engine->handle()->newString(value.asString());
        return;
    }
 
    Q_UNREACHABLE();
}
 
QJSManagedValue::QJSManagedValue(const QVariant &variant, QJSEngine *engine) :
    QJSManagedValue(engine->handle())
{
    *d = engine->handle()->fromVariant(variant);
}
 
QJSManagedValue::QJSManagedValue(const QString &string, QJSEngine *engine) :
    QJSManagedValue(engine->handle())
{
    *d = engine->handle()->newString(string);
}
 
QJSManagedValue::~QJSManagedValue()
{
    QV4::PersistentValueStorage::free(d);
}
 
QJSManagedValue::QJSManagedValue(QJSManagedValue &&other)
{
    qSwap(d, other.d);
}
 
QJSManagedValue &QJSManagedValue::operator=(QJSManagedValue &&other)
{
    if (this != &other) {
        QV4::PersistentValueStorage::free(d);
        d = nullptr;
        qSwap(d, other.d);
    }
    return *this;
}
 
bool QJSManagedValue::equals(const QJSManagedValue &other) const
{
    if (!d)
        return !other.d || other.d->isNullOrUndefined();
    if (!other.d)
        return d->isNullOrUndefined();
 
    return QV4::Runtime::CompareEqual::call(*d, *other.d);
}
 
bool QJSManagedValue::strictlyEquals(const QJSManagedValue &other) const
{
    if (!d)
        return !other.d || other.d->isUndefined();
    if (!other.d)
        return d->isUndefined();
 
    return QV4::RuntimeHelpers::strictEqual(*d, *other.d);
}
 
QJSEngine *QJSManagedValue::engine() const
{
    if (!d)
        return nullptr;
    if (QV4::ExecutionEngine *v4 = QV4::PersistentValueStorage::getEngine(d))
        return v4->jsEngine();
    return nullptr;
}
 
QJSManagedValue QJSManagedValue::prototype() const
{
    if (!d)
        return QJSManagedValue();
 
    QV4::ExecutionEngine *v4 = v4Engine(d);
    QJSManagedValue result(v4);
 
    if (auto object = d->as<QV4::Object>())
        *result.d = object->getPrototypeOf();
    else if (auto managed = d->as<QV4::Managed>())
        *result.d = managed->internalClass()->prototype;
    else if (d->isBoolean())
        *result.d = v4->booleanPrototype();
    else if (d->isNumber())
        *result.d = v4->numberPrototype();
 
    // If the prototype appears to be undefined, then it's actually null in JS terms.
    if (result.d->isUndefined())
        *result.d = QV4::Encode::null();
 
    return result;
}
 
void QJSManagedValue::setPrototype(const QJSManagedValue &prototype)
{
    auto object = d ? d->as<QV4::Object>() : nullptr;
    if (!object) {
        qWarning("QJSManagedValue::setPrototype() failed: "
                 "Can only set a prototype on an object (excluding null).");
        return;
    }
 
    // Object includes null ...
    if (prototype.type() != QJSManagedValue::Object) {
        qWarning("QJSManagedValue::setPrototype() failed: "
                 "Can only set objects (including null) as prototypes.");
        return;
    }
 
    if (Q_UNLIKELY(object->engine() != v4Engine(prototype.d))) {
        qWarning("QJSManagedValue::setPrototype() failed: "
                 "Prototype was created in differen engine.");
        return;
    }
 
    // ... Null becomes nullptr here. That is why it appears as undefined later.
    if (!object->setPrototypeOf(prototype.d->as<QV4::Object>())) {
        qWarning("QJSManagedValue::setPrototype() failed: "
                 "Prototype cycle detected.");
    }
}
 
QJSManagedValue::Type QJSManagedValue::type() const
{
    if (!d || d->isUndefined())
        return Undefined;
    if (d->isBoolean())
        return Boolean;
    if (d->isNumber())
        return Number;
    if (d->isString())
        return String;
    if (d->isSymbol())
        return Symbol;
    if (d->isFunctionObject())
        return Function;
    return Object;
}
 
bool QJSManagedValue::isNull() const
{
    return d && d->isNull();
}
 
bool QJSManagedValue::isInteger() const
{
    return d && d->isInteger();
}
 
bool QJSManagedValue::isRegularExpression() const
{
    return d && d->as<QV4::RegExpObject>();
}
 
bool QJSManagedValue::isArray() const
{
    return d && d->as<QV4::ArrayObject>();
}
 
bool QJSManagedValue::isUrl() const
{
    return d && d->as<QV4::UrlObject>();
}
 
bool QJSManagedValue::isVariant() const
{
    return d && d->as<QV4::VariantObject>();
}
 
bool QJSManagedValue::isQObject() const
{
    return d && d->as<QV4::QObjectWrapper>();
}
 
bool QJSManagedValue::isQMetaObject() const
{
    return d && d->as<QV4::QMetaObjectWrapper>();
}
 
bool QJSManagedValue::isDate() const
{
    return d && d->as<QV4::DateObject>();
}
 
bool QJSManagedValue::isError() const
{
    return d && d->as<QV4::ErrorObject>();
}
 
bool QJSManagedValue::isJsMetaType() const
{
    return d && d->as<QV4::InternalClass>();
}
 
QString QJSManagedValue::toString() const
{
    return d ? d->toQString() : QStringLiteral("undefined");
}
 
double QJSManagedValue::toNumber() const
{
    return d ? d->toNumber() : 0;
}
 
bool QJSManagedValue::toBoolean() const
{
    return d ? d->toBoolean() : false;
}
 
int QJSManagedValue::toInteger() const
{
    return d ? d->toInt32() : 0;
}
 
QJSPrimitiveValue QJSManagedValue::toPrimitive() const
{
    if (!d || d->isUndefined())
        return QJSPrimitiveUndefined();
    if (d->isNull())
        return QJSPrimitiveNull();
    if (d->isBoolean())
        return d->booleanValue();
    if (d->isInteger())
        return d->integerValue();
    if (d->isNumber())
        return d->doubleValue();
 
    bool ok;
    const QString result = d->toQString(&ok);
    return ok ? QJSPrimitiveValue(result) : QJSPrimitiveValue(QJSPrimitiveUndefined());
}
 
QJSValue QJSManagedValue::toJSValue() const
{
    return d ? QJSValuePrivate::fromReturnedValue(d->asReturnedValue()) : QJSValue();
}
 
QVariant QJSManagedValue::toVariant() const
{
    if (!d || d->isUndefined())
        return QVariant();
    if (d->isNull())
        return QVariant(QMetaType::fromType<std::nullptr_t>(), nullptr);
    if (d->isBoolean())
        return QVariant(d->booleanValue());
    if (d->isInteger())
        return QVariant(d->integerValue());
    if (d->isNumber())
        return QVariant(d->doubleValue());
    if (d->isString())
        return QVariant(d->toQString());
    if (d->as<QV4::Managed>())
        return QV4::ExecutionEngine::toVariant(*d, QMetaType{}, true);
 
    Q_UNREACHABLE_RETURN(QVariant());
}
 
QRegularExpression QJSManagedValue::toRegularExpression() const
{
    if (const auto *r = d ? d->as<QV4::RegExpObject>() : nullptr)
        return r->toQRegularExpression();
    return {};
}
 
QUrl QJSManagedValue::toUrl() const
{
    if (const auto *u = d ? d->as<QV4::UrlObject>() : nullptr)
        return u->toQUrl();
    return {};
}
 
QObject *QJSManagedValue::toQObject() const
{
    if (const auto *o = d ? d->as<QV4::QObjectWrapper>() : nullptr)
        return o->object();
    return {};
}
 
const QMetaObject *QJSManagedValue::toQMetaObject() const
{
    if (const auto *m = d ? d->as<QV4::QMetaObjectWrapper>() : nullptr)
        return m->metaObject();
    return {};
}
 
QDateTime QJSManagedValue::toDateTime() const
{
    if (const auto *t = d ? d->as<QV4::DateObject>() : nullptr)
        return t->toQDateTime();
    return {};
}
 
bool QJSManagedValue::hasProperty(const QString &name) const
{
    if (!d || d->isNullOrUndefined())
        return false;
 
    if (d->isString() && name == QStringLiteral("length"))
        return true;
 
    if (QV4::Object *obj = d->as<QV4::Object>()) {
        QV4::Scope scope(obj->engine());
        QV4::ScopedPropertyKey key(scope, scope.engine->identifierTable->asPropertyKey(name));
        return obj->hasProperty(key);
    }
 
    return prototype().hasProperty(name);
}
 
bool QJSManagedValue::hasOwnProperty(const QString &name) const
{
    if (!d || d->isNullOrUndefined())
        return false;
 
    if (d->isString() && name == QStringLiteral("length"))
        return true;
 
    if (QV4::Object *obj = d->as<QV4::Object>()) {
        QV4::Scope scope(obj->engine());
        QV4::ScopedPropertyKey key(scope, scope.engine->identifierTable->asPropertyKey(name));
        return obj->getOwnProperty(key) != QV4::Attr_Invalid;
    }
 
    return false;
}
 
QJSValue QJSManagedValue::property(const QString &name) const
{
    if (!d)
        return QJSValue();
 
    if (d->isNullOrUndefined()) {
        QV4::ExecutionEngine *e = v4Engine(d);
        e->throwTypeError(QStringLiteral("Cannot read property '%1' of null").arg(name));
        return QJSValue();
    }
 
    if (QV4::String *string = d->as<QV4::String>()) {
        if (name == QStringLiteral("length"))
            return QJSValue(string->d()->length());
    }
 
    if (QV4::Object *obj = d->as<QV4::Object>()) {
        QV4::Scope scope(obj->engine());
        QV4::ScopedPropertyKey key(scope, scope.engine->identifierTable->asPropertyKey(name));
        return QJSValuePrivate::fromReturnedValue(obj->get(key));
    }
 
    return prototype().property(name);
}
 
void QJSManagedValue::setProperty(const QString &name, const QJSValue &value)
{
    if (!d)
        return;
 
    if (d->isNullOrUndefined()) {
        v4Engine(d)->throwTypeError(
                    QStringLiteral("Value is null and could not be converted to an object"));
    }
 
    if (QV4::Object *obj = d->as<QV4::Object>()) {
        QV4::Scope scope(obj->engine());
        QV4::ExecutionEngine *v4 = QJSValuePrivate::engine(&value);
        if (Q_UNLIKELY(v4 && v4 != scope.engine)) {
            qWarning("QJSManagedValue::setProperty() failed: "
                     "Value was created in different engine.");
            return;
        }
        QV4::ScopedPropertyKey key(scope, scope.engine->identifierTable->asPropertyKey(name));
        obj->put(key, QJSValuePrivate::convertToReturnedValue(scope.engine, value));
    }
}
 
bool QJSManagedValue::deleteProperty(const QString &name)
{
    if (!d)
        return false;
 
    if (QV4::Object *obj = d->as<QV4::Object>()) {
        QV4::Scope scope(obj->engine());
        QV4::ScopedPropertyKey key(scope, scope.engine->identifierTable->asPropertyKey(name));
        return obj->deleteProperty(key);
    }
 
    return false;
}
 
bool QJSManagedValue::hasProperty(quint32 arrayIndex) const
{
    if (!d || d->isNullOrUndefined())
        return false;
 
    if (QV4::String *string = d->as<QV4::String>())
        return arrayIndex < quint32(string->d()->length());
 
    if (QV4::Object *obj = d->as<QV4::Object>()) {
        bool hasProperty = false;
        if (arrayIndex == std::numeric_limits<quint32>::max())
            obj->get(obj->engine()->id_uintMax(), &hasProperty);
        else
            obj->get(arrayIndex, &hasProperty);
        return hasProperty;
    }
 
    return prototype().hasProperty(arrayIndex);
}
 
bool QJSManagedValue::hasOwnProperty(quint32 arrayIndex) const
{
    if (!d || d->isNullOrUndefined())
        return false;
 
    if (QV4::String *string = d->as<QV4::String>())
        return arrayIndex < quint32(string->d()->length());
 
    if (QV4::Object *obj = d->as<QV4::Object>()) {
        if (arrayIndex == std::numeric_limits<quint32>::max()) {
            return obj->getOwnProperty(obj->engine()->id_uintMax()->toPropertyKey())
                    != QV4::Attr_Invalid;
        } else {
            return obj->getOwnProperty(QV4::PropertyKey::fromArrayIndex(arrayIndex))
                    != QV4::Attr_Invalid;
        }
    }
 
    return false;
}
 
QJSValue QJSManagedValue::property(quint32 arrayIndex) const
{
    if (!d || d->isNullOrUndefined())
        return QJSValue();
 
    if (QV4::String *string = d->as<QV4::String>()) {
        const QString qString = string->toQString();
        if (arrayIndex < quint32(qString.size()))
            return qString.sliced(arrayIndex, 1);
        return QJSValue();
    }
 
    if (QV4::Object *obj = d->as<QV4::Object>()) {
        if (arrayIndex == std::numeric_limits<quint32>::max())
            return QJSValuePrivate::fromReturnedValue(obj->get(obj->engine()->id_uintMax()));
        else
            return QJSValuePrivate::fromReturnedValue(obj->get(arrayIndex));
    }
 
    return prototype().property(arrayIndex);
}
 
void QJSManagedValue::setProperty(quint32 arrayIndex, const QJSValue &value)
{
    if (!d)
        return;
 
    if (QV4::Object *obj = d->as<QV4::Object>()) {
        QV4::ExecutionEngine *v4 = QJSValuePrivate::engine(&value);
        if (Q_UNLIKELY(v4 && v4 != obj->engine())) {
            qWarning("QJSManagedValue::setProperty() failed: "
                     "Value was created in different engine.");
            return;
        }
        obj->put(arrayIndex, QJSValuePrivate::convertToReturnedValue(v4, value));
    }
}
 
bool QJSManagedValue::deleteProperty(quint32 arrayIndex)
{
    if (!d)
        return false;
 
    if (QV4::Object *obj = d->as<QV4::Object>())
        return obj->deleteProperty(QV4::PropertyKey::fromArrayIndex(arrayIndex));
 
    return false;
}
 
static const QV4::FunctionObject *functionObjectForCall(QV4::Value *d)
{
    if (Q_UNLIKELY(!d)) {
        qWarning("QJSManagedValue: Calling a default-constructed or moved-from managed value"
                 "should throw an exception, but there is no engine to receive it.");
        return nullptr;
    }
 
    if (const QV4::FunctionObject *f = d->as<QV4::FunctionObject>())
        return f;
 
    v4Engine(d)->throwTypeError(QStringLiteral("Value is not a function"));
    return nullptr;
}
 
QJSValue QJSManagedValue::call(const QJSValueList &arguments) const
{
    const QV4::FunctionObject *f = functionObjectForCall(d);
    if (!f)
        return QJSValue();
 
    QV4::ExecutionEngine *engine = f->engine();
 
    QV4::Scope scope(engine);
    QV4::JSCallArguments jsCallData(scope, arguments.size());
    *jsCallData.thisObject = engine->globalObject;
    int i = 0;
    for (const QJSValue &arg : arguments) {
        if (Q_UNLIKELY(!QJSValuePrivate::checkEngine(engine, arg))) {
            qWarning("QJSManagedValue::call() failed: Argument was created in different engine.");
            return QJSValue();
        }
        jsCallData.args[i++] = QJSValuePrivate::convertToReturnedValue(engine, arg);
    }
 
    return QJSValuePrivate::fromReturnedValue(f->call(jsCallData));
}
 
QJSValue QJSManagedValue::callWithInstance(const QJSValue &instance,
                                           const QJSValueList &arguments) const
{
    const QV4::FunctionObject *f = functionObjectForCall(d);
    if (!f)
        return QJSValue();
 
    QV4::ExecutionEngine *engine = f->engine();
 
    if (Q_UNLIKELY(!QJSValuePrivate::checkEngine(engine, instance))) {
        qWarning("QJSManagedValue::callWithInstance() failed: "
                 "Instance was created in different engine.");
        return QJSValue();
    }
 
    QV4::Scope scope(engine);
    QV4::JSCallArguments jsCallData(scope, arguments.size());
    *jsCallData.thisObject = QJSValuePrivate::convertToReturnedValue(engine, instance);
    int i = 0;
    for (const QJSValue &arg : arguments) {
        if (Q_UNLIKELY(!QJSValuePrivate::checkEngine(engine, arg))) {
            qWarning("QJSManagedValue::callWithInstance() failed: "
                     "Argument was created in different engine.");
            return QJSValue();
        }
        jsCallData.args[i++] = QJSValuePrivate::convertToReturnedValue(engine, arg);
    }
 
    return QJSValuePrivate::fromReturnedValue(f->call(jsCallData));
}
 
QJSValue QJSManagedValue::callAsConstructor(const QJSValueList &arguments) const
{
    const QV4::FunctionObject *f = functionObjectForCall(d);
    if (!f)
        return QJSValue();
 
    QV4::ExecutionEngine *engine = f->engine();
 
    QV4::Scope scope(engine);
    QV4::JSCallArguments jsCallData(scope, arguments.size());
    int i = 0;
    for (const QJSValue &arg : arguments) {
        if (Q_UNLIKELY(!QJSValuePrivate::checkEngine(engine, arg))) {
            qWarning("QJSManagedValue::callAsConstructor() failed: "
                     "Argument was created in different engine.");
            return QJSValue();
        }
        jsCallData.args[i++] = QJSValuePrivate::convertToReturnedValue(engine, arg);
    }
 
    return QJSValuePrivate::fromReturnedValue(f->callAsConstructor(jsCallData));
}
 
QJSManagedValue QJSManagedValue::jsMetaType() const
{
    if (!d)
        return QJSManagedValue();
 
    QJSManagedValue result(v4Engine(d));
    if (QV4::Managed *m = d->as<QV4::Managed>())
        *result.d = m->internalClass();
 
    return result;
}
 
QStringList QJSManagedValue::jsMetaMembers() const
{
    if (!d)
        return {};
 
    if (QV4::InternalClass *c = d->as<QV4::InternalClass>()) {
        const auto heapClass = c->d();
        const int size = heapClass->size;
        QStringList result;
        result.reserve(size);
        QV4::Scope scope(c->engine());
        for (int i = 0; i < size; ++i) {
            QV4::ScopedValue key(scope, heapClass->keyAt(i));
            result.append(key->toQString());
        }
        return result;
    }
 
    return {};
}
 
QJSManagedValue QJSManagedValue::jsMetaInstantiate(const QJSValueList &values) const
{
    if (!d)
        return {};
 
    if (QV4::InternalClass *c = d->as<QV4::InternalClass>()) {
        QV4::ExecutionEngine *engine = c->engine();
        QJSManagedValue result(engine);
        *result.d = c->engine()->newObject(c->d());
        QV4::Object *o = result.d->as<QV4::Object>();
 
        for (uint i = 0, end = qMin(qsizetype(c->d()->size), values.size()); i < end; ++i) {
            const QJSValue &arg = values[i];
            if (Q_UNLIKELY(!QJSValuePrivate::checkEngine(engine, arg))) {
                qWarning("QJSManagedValue::instantiate() failed: "
                         "Argument was created in different engine.");
                return QJSManagedValue();
            }
            o->setProperty(i, QJSValuePrivate::convertToReturnedValue(engine, arg));
        }
 
        return result;
    }
 
    return {};
}
 
QJSManagedValue::QJSManagedValue(QV4::ExecutionEngine *engine) :
    d(engine->memoryManager->m_persistentValues->allocate())
{
}
 
QT_END_NAMESPACE