qv4include.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 "qv4include_p.h"
#include "qv4scopedvalue_p.h"
#include "qv4jscall_p.h"
 
#include <QtQml/qjsengine.h>
#if QT_CONFIG(qml_network)
#include <QtNetwork/qnetworkrequest.h>
#include <QtNetwork/qnetworkreply.h>
#endif
#include <QtCore/qfile.h>
#include <QtQml/qqmlfile.h>
 
#include <private/qqmlengine_p.h>
#include <private/qv4engine_p.h>
#include <private/qv4functionobject_p.h>
#include <private/qv4script_p.h>
#include <private/qv4context_p.h>
 
QT_BEGIN_NAMESPACE
 
QV4Include::QV4Include(const QUrl &url, QV4::ExecutionEngine *engine,
                       QV4::QmlContext *qmlContext, const QV4::Value &callback)
    : QObject(engine->jsEngine())
    , v4(engine), m_url(url)
#if QT_CONFIG(qml_network)
    , m_network(nullptr) , m_reply(nullptr)
#endif
{
    if (qmlContext)
        m_qmlContext.set(v4, *qmlContext);
    if (callback.as<QV4::FunctionObject>())
        m_callbackFunction.set(v4, callback);
 
    m_resultObject.set(v4, resultValue(v4));
 
#if QT_CONFIG(qml_network)
    if (QQmlEngine *qmlEngine = v4->qmlEngine()) {
        m_network = qmlEngine->networkAccessManager();
 
        QNetworkRequest request;
        request.setUrl(url);
 
        m_reply = m_network->get(request);
        QObject::connect(m_reply, SIGNAL(finished()), this, SLOT(finished()));
    } else {
        finished();
    }
#else
    finished();
#endif
}
 
QV4Include::~QV4Include()
{
#if QT_CONFIG(qml_network)
    delete m_reply;
    m_reply = nullptr;
#endif
}
 
QV4::ReturnedValue QV4Include::resultValue(QV4::ExecutionEngine *v4, Status status,
                                           const QString &statusText)
{
    QV4::Scope scope(v4);
 
    // XXX It seems inefficient to create this object from scratch each time.
    QV4::ScopedObject o(scope, v4->newObject());
    QV4::ScopedString s(scope);
    QV4::ScopedValue v(scope);
    o->put((s = v4->newString(QStringLiteral("OK"))), (v = QV4::Value::fromInt32(Ok)));
    o->put((s = v4->newString(QStringLiteral("LOADING"))), (v = QV4::Value::fromInt32(Loading)));
    o->put((s = v4->newString(QStringLiteral("NETWORK_ERROR"))), (v = QV4::Value::fromInt32(NetworkError)));
    o->put((s = v4->newString(QStringLiteral("EXCEPTION"))), (v = QV4::Value::fromInt32(Exception)));
    o->put((s = v4->newString(QStringLiteral("status"))), (v = QV4::Value::fromInt32(status)));
    if (!statusText.isEmpty())
        o->put((s = v4->newString(QStringLiteral("statusText"))), (v = v4->newString(statusText)));
 
    return o.asReturnedValue();
}
 
void QV4Include::callback(const QV4::Value &callback, const QV4::Value &status)
{
    if (!callback.isObject())
        return;
    QV4::ExecutionEngine *v4 = callback.as<QV4::Object>()->engine();
    QV4::Scope scope(v4);
    QV4::ScopedFunctionObject f(scope, callback);
    if (!f)
        return;
 
    QV4::JSCallArguments jsCallData(scope, 1);
    *jsCallData.thisObject = v4->globalObject->asReturnedValue();
    jsCallData.args[0] = status;
    f->call(jsCallData);
    if (scope.hasException())
        scope.engine->catchException();
}
 
QV4::ReturnedValue QV4Include::result()
{
    return m_resultObject.value();
}
 
void QV4Include::finished()
{
#if QT_CONFIG(qml_network)
    QV4::Scope scope(v4);
    QV4::ScopedObject resultObj(scope, m_resultObject.value());
    QV4::ScopedString status(scope, v4->newString(QStringLiteral("status")));
    if (m_reply->error() == QNetworkReply::NoError) {
        QByteArray data = m_reply->readAll();
 
        QString code = QString::fromUtf8(data);
 
        QV4::Scoped<QV4::QmlContext> qml(scope, m_qmlContext.value());
        QV4::Script script(v4, qml, /*parse as QML binding*/false, code, m_url.toString());
 
        script.parse();
        if (!scope.hasException())
            script.run();
        if (scope.hasException()) {
            QV4::ScopedValue ex(scope, scope.engine->catchException());
            resultObj->put(status, QV4::ScopedValue(scope, QV4::Value::fromInt32(Exception)));
            QV4::ScopedString exception(scope, v4->newString(QStringLiteral("exception")));
            resultObj->put(exception, ex);
        } else {
            resultObj->put(status, QV4::ScopedValue(scope, QV4::Value::fromInt32(Ok)));
        }
    } else {
        resultObj->put(status, QV4::ScopedValue(scope, QV4::Value::fromInt32(NetworkError)));
    }
#else
    QV4::Scope scope(v4);
    QV4::ScopedObject resultObj(scope, m_resultObject.value());
    QV4::ScopedString status(scope, v4->newString(QStringLiteral("status")));
    resultObj->put(status, QV4::ScopedValue(scope, QV4::Value::fromInt32(NetworkError)));
#endif // qml_network
 
    QV4::ScopedValue cb(scope, m_callbackFunction.value());
    callback(cb, resultObj);
 
    disconnect();
    deleteLater();
}
 
/*
    Documented in qv4engine.cpp
*/
QJSValue QV4Include::method_include(QV4::ExecutionEngine *engine, const QUrl &url,
                                    const QJSValue &callbackFunction)
{
    QQmlRefPointer<QQmlContextData> context = engine->callingQmlContext();
 
    if ((!context || !context->isJSContext()) && engine->qmlEngine()) {
        return QJSValuePrivate::fromReturnedValue(
                    engine->throwError(
                        QString::fromUtf8(
                            "Qt.include(): Can only be called from JavaScript files")));
    }
 
 
    QV4::Scope scope(engine);
    QV4::ScopedValue scopedCallbackFunction(scope, QV4::Value::undefinedValue());
    if (auto function = QJSValuePrivate::asManagedType<QV4::FunctionObject>(&callbackFunction))
        scopedCallbackFunction = *function;
 
    const QQmlEngine *qmlEngine = engine->qmlEngine();
    const QUrl intercepted = qmlEngine
            ? qmlEngine->interceptUrl(url, QQmlAbstractUrlInterceptor::JavaScriptFile)
            : url;
    QString localFile = QQmlFile::urlToLocalFileOrQrc(intercepted);
 
    QV4::ScopedValue result(scope);
    QV4::Scoped<QV4::QmlContext> qmlcontext(scope, scope.engine->qmlContext());
 
    if (localFile.isEmpty()) {
#if QT_CONFIG(qml_network)
        QV4Include *i = new QV4Include(url, engine, qmlcontext, scopedCallbackFunction);
        result = i->result();
#else
        result = resultValue(scope.engine, NetworkError);
        callback(scopedCallbackFunction, result);
#endif
    } else {
        QScopedPointer<QV4::Script> script;
        QString error;
        script.reset(QV4::Script::createFromFileOrCache(scope.engine, qmlcontext, localFile, url, &error));
 
        if (!script.isNull()) {
            script->parse();
            if (!scope.hasException())
                script->run();
            if (scope.hasException()) {
                QV4::ScopedValue ex(scope, scope.engine->catchException());
                result = resultValue(scope.engine, Exception);
                QV4::ScopedString exception(scope, scope.engine->newString(QStringLiteral("exception")));
                result->as<QV4::Object>()->put(exception, ex);
            } else {
                result = resultValue(scope.engine, Ok);
            }
        } else {
            result = resultValue(scope.engine, NetworkError, error);
        }
 
        callback(scopedCallbackFunction, result);
    }
 
    return QJSValuePrivate::fromReturnedValue(result->asReturnedValue());
}
 
QT_END_NAMESPACE
 
#include "moc_qv4include_p.cpp"