qjsengine.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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 "qjsengine.h"
#include "qjsengine_p.h"
#include "qjsvalue.h"
#include "qjsvalue_p.h"
 
#include "private/qv4engine_p.h"
#include "private/qv4mm_p.h"
#include "private/qv4errorobject_p.h"
#include "private/qv4globalobject_p.h"
#include "private/qv4script_p.h"
#include "private/qv4runtime_p.h"
#include <private/qv4dateobject_p.h>
#include <private/qqmlbuiltinfunctions_p.h>
#include <private/qqmldebugconnector_p.h>
#include <private/qv4qobjectwrapper_p.h>
#include <private/qv4qmetaobjectwrapper_p.h>
#include <private/qv4stackframe_p.h>
#include <private/qv4module_p.h>
#include <private/qv4symbol_p.h>
 
#include <QtCore/qdatetime.h>
#include <QtCore/qmetaobject.h>
#include <QtCore/qstringlist.h>
#include <QtCore/qvariant.h>
#include <QtCore/qdatetime.h>
 
#include <QtCore/qcoreapplication.h>
#include <QtCore/qdir.h>
#include <QtCore/qfile.h>
#include <QtCore/qfileinfo.h>
#include <QtCore/qpluginloader.h>
#include <qthread.h>
#include <qmutex.h>
#include <qwaitcondition.h>
#include <private/qqmlglobal_p.h>
#include <qqmlengine.h>
 
Q_DECLARE_METATYPE(QList<int>)
 
 
QT_BEGIN_NAMESPACE
 
static void checkForApplicationInstance()
{
    if (!QCoreApplication::instance())
        qFatal("QJSEngine: Must construct a QCoreApplication before a QJSEngine");
}
 
QJSEngine::QJSEngine()
    : QJSEngine(nullptr)
{
}
 
QJSEngine::QJSEngine(QObject *parent)
    : QJSEngine(*new QJSEnginePrivate, parent)
{
    QJSEnginePrivate::addToDebugServer(this);
}
 
QJSEngine::QJSEngine(QJSEnginePrivate &dd, QObject *parent)
    : QObject(dd, parent)
    , m_v4Engine(new QV4::ExecutionEngine(this))
{
    checkForApplicationInstance();
}
 
QJSEngine::~QJSEngine()
{
    m_v4Engine->inShutdown = true;
    QJSEnginePrivate::removeFromDebugServer(this);
    delete m_v4Engine;
}
 
void QJSEngine::collectGarbage()
{
    m_v4Engine->memoryManager->runGC();
}
 
void QJSEngine::installExtensions(QJSEngine::Extensions extensions, const QJSValue &object)
{
    QV4::ExecutionEngine *otherEngine = QJSValuePrivate::engine(&object);
    if (otherEngine && otherEngine != m_v4Engine) {
        qWarning("QJSEngine: Trying to install extensions from a different engine");
        return;
    }
 
    QV4::Scope scope(m_v4Engine);
    QV4::ScopedObject obj(scope, QJSValuePrivate::asReturnedValue(&object));
    if (!obj)
        obj = scope.engine->globalObject;
 
    QV4::GlobalExtensions::init(obj, extensions);
}
 
void QJSEngine::setInterrupted(bool interrupted)
{
    m_v4Engine->isInterrupted.storeRelaxed(interrupted);
}
 
bool QJSEngine::isInterrupted() const
{
    return m_v4Engine->isInterrupted.loadRelaxed();
}
 
static QUrl urlForFileName(const QString &fileName)
{
    if (!fileName.startsWith(QLatin1Char(':')))
        return QUrl::fromLocalFile(fileName);
 
    QUrl url;
    url.setPath(fileName.mid(1));
    url.setScheme(QLatin1String("qrc"));
    return url;
}
 
QJSValue QJSEngine::evaluate(const QString& program, const QString& fileName, int lineNumber, QStringList *exceptionStackTrace)
{
    QV4::ExecutionEngine *v4 = m_v4Engine;
    QV4::Scope scope(v4);
    QV4::ScopedValue result(scope);
 
    QV4::Script script(v4->rootContext(), QV4::Compiler::ContextType::Global, program, urlForFileName(fileName).toString(), lineNumber);
    script.strictMode = false;
    if (v4->currentStackFrame)
        script.strictMode = v4->currentStackFrame->v4Function->isStrict();
    else if (v4->globalCode)
        script.strictMode = v4->globalCode->isStrict();
    script.inheritContext = true;
    script.parse();
    if (!scope.hasException())
        result = script.run();
    if (exceptionStackTrace)
        exceptionStackTrace->clear();
    if (scope.hasException()) {
        QV4::StackTrace trace;
        result = v4->catchException(&trace);
        if (exceptionStackTrace) {
            for (auto &&frame: trace)
                exceptionStackTrace->push_back(QLatin1StringView("%1:%2:%3:%4").arg(
                                          frame.function,
                                          QString::number(qAbs(frame.line)),
                                          QString::number(frame.column),
                                          frame.source)
                                      );
        }
    }
    if (v4->isInterrupted.loadRelaxed())
        result = v4->newErrorObject(QStringLiteral("Interrupted"));
 
    return QJSValuePrivate::fromReturnedValue(result->asReturnedValue());
}
 
QJSValue QJSEngine::importModule(const QString &fileName)
{
    const QUrl url = urlForFileName(QFileInfo(fileName).canonicalFilePath());
    const auto module = m_v4Engine->loadModule(url);
    if (m_v4Engine->hasException)
        return QJSValuePrivate::fromReturnedValue(m_v4Engine->catchException());
 
    QV4::Scope scope(m_v4Engine);
    if (const auto compiled = module.compiled) {
        QV4::Scoped<QV4::Module> moduleNamespace(scope, compiled->instantiate());
        if (m_v4Engine->hasException)
            return QJSValuePrivate::fromReturnedValue(m_v4Engine->catchException());
        compiled->evaluate();
        if (!m_v4Engine->isInterrupted.loadRelaxed())
            return QJSValuePrivate::fromReturnedValue(moduleNamespace->asReturnedValue());
        return QJSValuePrivate::fromReturnedValue(
                    m_v4Engine->newErrorObject(QStringLiteral("Interrupted"))->asReturnedValue());
    }
 
    // If there is neither a native nor a compiled module, we should have seen an exception
    Q_ASSERT(module.native);
 
    return QJSValuePrivate::fromReturnedValue(module.native->asReturnedValue());
}
 
bool QJSEngine::registerModule(const QString &moduleName, const QJSValue &value)
{
    QV4::Scope scope(m_v4Engine);
    QV4::ScopedValue v4Value(scope, QJSValuePrivate::asReturnedValue(&value));
    m_v4Engine->registerNativeModule(QUrl(moduleName), v4Value);
    if (m_v4Engine->hasException)
        return false;
    return true;
}
 
QJSValue QJSEngine::newObject()
{
    QV4::Scope scope(m_v4Engine);
    QV4::ScopedValue v(scope, m_v4Engine->newObject());
    return QJSValuePrivate::fromReturnedValue(v->asReturnedValue());
}
 
QJSValue QJSEngine::newSymbol(const QString &name)
{
    QV4::Scope scope(m_v4Engine);
    QV4::ScopedValue v(scope, QV4::Symbol::create(m_v4Engine, u'@' + name));
    return QJSValuePrivate::fromReturnedValue(v->asReturnedValue());
}
 
QJSValue QJSEngine::newErrorObject(QJSValue::ErrorType errorType, const QString &message)
{
    QV4::Scope scope(m_v4Engine);
    QV4::ScopedObject error(scope);
    switch (errorType) {
    case QJSValue::RangeError:
        error = m_v4Engine->newRangeErrorObject(message);
        break;
    case QJSValue::SyntaxError:
        error = m_v4Engine->newSyntaxErrorObject(message);
        break;
    case QJSValue::TypeError:
        error = m_v4Engine->newTypeErrorObject(message);
        break;
    case QJSValue::URIError:
        error = m_v4Engine->newURIErrorObject(message);
        break;
    case QJSValue::ReferenceError:
        error = m_v4Engine->newReferenceErrorObject(message);
        break;
    case QJSValue::EvalError:
        error = m_v4Engine->newEvalErrorObject(message);
        break;
    case QJSValue::GenericError:
        error = m_v4Engine->newErrorObject(message);
        break;
    case QJSValue::NoError:
        return QJSValue::UndefinedValue;
    }
    return QJSValuePrivate::fromReturnedValue(error->asReturnedValue());
}
 
QJSValue QJSEngine::newArray(uint length)
{
    QV4::Scope scope(m_v4Engine);
    QV4::ScopedArrayObject array(scope, m_v4Engine->newArrayObject());
    if (length < 0x1000)
        array->arrayReserve(length);
    array->setArrayLengthUnchecked(length);
    return QJSValuePrivate::fromReturnedValue(array.asReturnedValue());
}
 
QJSValue QJSEngine::newQObject(QObject *object)
{
    QV4::ExecutionEngine *v4 = m_v4Engine;
    QV4::Scope scope(v4);
    if (object) {
        QQmlData *ddata = QQmlData::get(object, true);
        if (!ddata || !ddata->explicitIndestructibleSet)
            QQmlEngine::setObjectOwnership(object, QQmlEngine::JavaScriptOwnership);
    }
    QV4::ScopedValue v(scope, QV4::QObjectWrapper::wrap(v4, object));
    return QJSValuePrivate::fromReturnedValue(v->asReturnedValue());
}
 
QJSValue QJSEngine::newQMetaObject(const QMetaObject* metaObject) {
    QV4::ExecutionEngine *v4 = m_v4Engine;
    QV4::Scope scope(v4);
    QV4::ScopedValue v(scope, QV4::QMetaObjectWrapper::create(v4, metaObject));
    return QJSValuePrivate::fromReturnedValue(v->asReturnedValue());
}
 
QJSValue QJSEngine::globalObject() const
{
    QV4::Scope scope(m_v4Engine);
    QV4::ScopedValue v(scope, m_v4Engine->globalObject);
    return QJSValuePrivate::fromReturnedValue(v->asReturnedValue());
}
 
QJSPrimitiveValue QJSEngine::createPrimitive(QMetaType type, const void *ptr)
{
    QV4::Scope scope(m_v4Engine);
    QV4::ScopedValue v(scope, m_v4Engine->metaTypeToJS(type, ptr));
    return QV4::ExecutionEngine::createPrimitive(v);
}
 
QJSManagedValue QJSEngine::createManaged(QMetaType type, const void *ptr)
{
    QJSManagedValue result(m_v4Engine);
    *result.d = m_v4Engine->metaTypeToJS(type, ptr);
    return result;
}
 
QJSValue QJSEngine::create(QMetaType type, const void *ptr)
{
    QV4::Scope scope(m_v4Engine);
    QV4::ScopedValue v(scope, scope.engine->metaTypeToJS(type, ptr));
    return QJSValuePrivate::fromReturnedValue(v->asReturnedValue());
}
 
bool QJSEngine::convertPrimitive(const QJSPrimitiveValue &value, QMetaType type, void *ptr)
{
    switch (value.type()) {
    case QJSPrimitiveValue::Undefined:
        return QV4::ExecutionEngine::metaTypeFromJS(QV4::Value::undefinedValue(), type, ptr);
    case QJSPrimitiveValue::Null:
        return QV4::ExecutionEngine::metaTypeFromJS(QV4::Value::nullValue(), type, ptr);
    case QJSPrimitiveValue::Boolean:
        return QV4::ExecutionEngine::metaTypeFromJS(QV4::Value::fromBoolean(value.toBoolean()), type, ptr);
    case QJSPrimitiveValue::Integer:
        return QV4::ExecutionEngine::metaTypeFromJS(QV4::Value::fromInt32(value.toInteger()), type, ptr);
    case QJSPrimitiveValue::Double:
        return QV4::ExecutionEngine::metaTypeFromJS(QV4::Value::fromDouble(value.toDouble()), type, ptr);
    case QJSPrimitiveValue::String:
        return convertString(value.toString(), type, ptr);
    }
 
    Q_UNREACHABLE_RETURN(false);
}
 
bool QJSEngine::convertManaged(const QJSManagedValue &value, int type, void *ptr)
{
    return convertManaged(value, QMetaType(type), ptr);
}
 
bool QJSEngine::convertManaged(const QJSManagedValue &value, QMetaType type, void *ptr)
{
    return QV4::ExecutionEngine::metaTypeFromJS(*value.d, type, ptr);
}
 
bool QJSEngine::convertString(const QString &string, QMetaType metaType, void *ptr)
{
    // have a string based value without engine. Do conversion manually
    if (metaType == QMetaType::fromType<bool>()) {
        *reinterpret_cast<bool*>(ptr) = string.size() != 0;
        return true;
    }
    if (metaType == QMetaType::fromType<QString>()) {
        *reinterpret_cast<QString*>(ptr) = string;
        return true;
    }
    if (metaType == QMetaType::fromType<QUrl>()) {
        *reinterpret_cast<QUrl *>(ptr) = QUrl(string);
        return true;
    }
 
    double d = QV4::RuntimeHelpers::stringToNumber(string);
    switch (metaType.id()) {
    case QMetaType::Int:
        *reinterpret_cast<int*>(ptr) = QV4::Value::toInt32(d);
        return true;
    case QMetaType::UInt:
        *reinterpret_cast<uint*>(ptr) = QV4::Value::toUInt32(d);
        return true;
    case QMetaType::Long:
        *reinterpret_cast<long*>(ptr) = QV4::Value::toInteger(d);
        return true;
    case QMetaType::ULong:
        *reinterpret_cast<ulong*>(ptr) = QV4::Value::toInteger(d);
        return true;
    case QMetaType::LongLong:
        *reinterpret_cast<qlonglong*>(ptr) = QV4::Value::toInteger(d);
        return true;
    case QMetaType::ULongLong:
        *reinterpret_cast<qulonglong*>(ptr) = QV4::Value::toInteger(d);
        return true;
    case QMetaType::Double:
        *reinterpret_cast<double*>(ptr) = d;
        return true;
    case QMetaType::Float:
        *reinterpret_cast<float*>(ptr) = d;
        return true;
    case QMetaType::Short:
        *reinterpret_cast<short*>(ptr) = QV4::Value::toInt32(d);
        return true;
    case QMetaType::UShort:
        *reinterpret_cast<unsigned short*>(ptr) = QV4::Value::toUInt32(d);
        return true;
    case QMetaType::Char:
        *reinterpret_cast<char*>(ptr) = QV4::Value::toInt32(d);
        return true;
    case QMetaType::UChar:
        *reinterpret_cast<unsigned char*>(ptr) = QV4::Value::toUInt32(d);
        return true;
    case QMetaType::QChar:
        *reinterpret_cast<QChar*>(ptr) = QChar(QV4::Value::toUInt32(d));
        return true;
    case QMetaType::Char16:
        *reinterpret_cast<char16_t *>(ptr) = QV4::Value::toUInt32(d);
        return true;
    default:
        return false;
    }
}
 
bool QJSEngine::convertV2(const QJSValue &value, QMetaType metaType, void *ptr)
{
    if (const QString *string = QJSValuePrivate::asQString(&value))
        return convertString(*string, metaType, ptr);
 
    // Does not need scoping since QJSValue still holds on to the value.
    return QV4::ExecutionEngine::metaTypeFromJS(QJSValuePrivate::asReturnedValue(&value), metaType, ptr);
}
 
bool QJSEngine::convertVariant(const QVariant &value, QMetaType metaType, void *ptr)
{
    // TODO: We could probably avoid creating a QV4::Value in many cases, but we'd have to
    //       duplicate much of metaTypeFromJS and some methods of QV4::Value itself here.
    QV4::Scope scope(handle());
    QV4::ScopedValue scoped(scope, scope.engine->fromVariant(value));
    return QV4::ExecutionEngine::metaTypeFromJS(scoped, metaType, ptr);
}
 
bool QJSEngine::convertMetaType(QMetaType fromType, const void *from, QMetaType toType, void *to)
{
    // TODO: We could probably avoid creating a QV4::Value in many cases, but we'd have to
    //       duplicate much of metaTypeFromJS and some methods of QV4::Value itself here.
    QV4::Scope scope(handle());
    QV4::ScopedValue scoped(scope, scope.engine->fromData(fromType, from));
    return QV4::ExecutionEngine::metaTypeFromJS(scoped, toType, to);
}
 
QString QJSEngine::convertQObjectToString(QObject *object)
{
    return QV4::QObjectWrapper::objectToString(
                handle(), object ? object->metaObject() : nullptr, object);
}
 
QString QJSEngine::convertDateTimeToString(const QDateTime &dateTime)
{
    return QV4::DateObject::dateTimeToString(dateTime, handle());
}
 
double QJSEngine::convertDateTimeToNumber(const QDateTime &dateTime)
{
    return QV4::DateObject::dateTimeToNumber(dateTime);
}
 
QDate QJSEngine::convertDateTimeToDate(const QDateTime &dateTime)
{
    return QV4::DateObject::dateTimeToDate(dateTime);
}
 
void QJSEngine::throwError(const QString &message)
{
    m_v4Engine->throwError(message);
}
 
void QJSEngine::throwError(QJSValue::ErrorType errorType, const QString &message)
{
    QV4::Scope scope(m_v4Engine);
    QJSValue error = newErrorObject(errorType, message);
    QV4::ScopedObject e(scope, QJSValuePrivate::asReturnedValue(&error));
    if (!e)
        return;
    m_v4Engine->throwError(e);
}
 
void QJSEngine::throwError(const QJSValue &error)
{
    m_v4Engine->throwError(QJSValuePrivate::asReturnedValue(&error));
}
 
bool QJSEngine::hasError() const
{
    return m_v4Engine->hasException;
}
 
QJSValue QJSEngine::catchError()
{
    if (m_v4Engine->hasException)
        return QJSValuePrivate::fromReturnedValue(m_v4Engine->catchException());
    else
        return QJSValue();
}
 
void QJSEngine::setUiLanguage(const QString &language) {
    Q_D(QJSEngine);
    d->uiLanguage = language; // property takes care of signal emission if necessary
}
 
QString QJSEngine::uiLanguage() const
{
    Q_D(const QJSEngine);
    return d->uiLanguage;
}
 
QJSEnginePrivate *QJSEnginePrivate::get(QV4::ExecutionEngine *e)
{
    return e->jsEngine()->d_func();
}
 
QJSEnginePrivate::~QJSEnginePrivate()
{
    QQmlMetaType::freeUnusedTypesAndCaches();
}
 
void QJSEnginePrivate::addToDebugServer(QJSEngine *q)
{
    if (QCoreApplication::instance()->thread() != q->thread())
        return;
 
    QQmlDebugConnector *server = QQmlDebugConnector::instance();
    if (!server || server->hasEngine(q))
        return;
 
    server->open();
    server->addEngine(q);
}
 
void QJSEnginePrivate::removeFromDebugServer(QJSEngine *q)
{
    QQmlDebugConnector *server = QQmlDebugConnector::instance();
    if (server && server->hasEngine(q))
        server->removeEngine(q);
}
 
QJSEngine *qjsEngine(const QObject *object)
{
    QQmlData *data = QQmlData::get(object);
    if (!data || data->jsWrapper.isNullOrUndefined())
        return nullptr;
    return data->jsWrapper.engine()->jsEngine();
}
 
 
void QJSEngine::setObjectOwnership(QObject *object, ObjectOwnership ownership)
{
    if (!object)
        return;
 
    QQmlData *ddata = QQmlData::get(object, true);
    if (!ddata)
        return;
 
    ddata->indestructible = (ownership == CppOwnership)?true:false;
    ddata->explicitIndestructibleSet = true;
}
 
QJSEngine::ObjectOwnership QJSEngine::objectOwnership(QObject *object)
{
    if (!object)
        return CppOwnership;
 
    QQmlData *ddata = QQmlData::get(object, false);
    if (!ddata)
        return CppOwnership;
    else
        return ddata->indestructible?CppOwnership:JavaScriptOwnership;
}
 
QT_END_NAMESPACE
 
#include "moc_qjsengine.cpp"