Revision control
++ // 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
++ // Qt-Security score:significant
++
++ #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/qqmlscriptblob_p.h>
++ #include <private/qqmlscriptdata_p.h>
++ #include <private/qv4context_p.h>
++ #include <private/qv4engine_p.h>
++ #include <private/qv4functionobject_p.h>
++ #include <private/qv4script_p.h>
++
++ QT_BEGIN_NAMESPACE
++
++ QV4::ReturnedValue QV4Include::resultValue(QV4::ExecutionEngine *v4)
++ {
++ 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)));
++ return o.asReturnedValue();
++ }
++
++ void QV4Include::populateResultValue(QV4::Object *o, Status status, const QString &statusText)
++ {
++ QV4::Scope scope(o->engine());
++ QV4::ScopedString statusKey(scope, scope.engine->newString(QStringLiteral("status")));
++ QV4::ScopedValue statusValue(scope, QV4::Value::fromInt32(status));
++ o->put(statusKey, statusValue);
++ if (statusText.isEmpty())
++ return;
++
++ QV4::ScopedString textKey(scope, scope.engine->newString(QStringLiteral("statusText")));
++ QV4::ScopedValue textValue(scope, scope.engine->newString(statusText));
++ o->put(textKey, textValue);
++ }
++
++ QV4Include::QV4Include(
++ QV4::Object *result, QV4::FunctionObject *callbackFunction, QV4::QmlContext *qmlContext)
++ {
++ Q_ASSERT(result);
++ QV4::ExecutionEngine *engine = result->engine();
++ m_resultObject.set(engine, result->asReturnedValue());
++ if (callbackFunction)
++ m_callbackFunction.set(engine, callbackFunction->asReturnedValue());
++ if (qmlContext)
++ m_qmlContext.set(engine, qmlContext->asReturnedValue());
++ }
++
++ void QV4Include::callback(QV4::FunctionObject *callback, QV4::Object *result)
++ {
++ if (!callback)
++ return;
++
++ QV4::Scope scope(callback->engine());
++ QV4::JSCallArguments jsCallData(scope, 1);
++ *jsCallData.thisObject = scope.engine->globalObject->asReturnedValue();
++ jsCallData.args[0] = result;
++ callback->call(jsCallData);
++ if (scope.hasException())
++ scope.engine->catchException();
++ }
++
++ /*
++ 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")));
++ }
++
++ // The JavaScript compilation unit inherits its context when doing Qt.include().
++ // This means we need to turn fast lookups off at compile time.
++ // Signal this through the URL fragment.
++ QUrl includeUrl = url;
++ includeUrl.setFragment(QLatin1String("include"));
++ QQmlRefPointer<QQmlScriptBlob> scriptBlob = engine->typeLoader()->getScript(includeUrl);
++
++ QV4::Scope scope(engine);
++ QV4::ScopedObject result(scope, resultValue(engine));
++ QV4::ScopedFunctionObject callback(
++ scope, QJSValuePrivate::asReturnedValue(&callbackFunction));
++ QV4::Scoped<QV4::QmlContext> qmlContext(scope, scope.engine->qmlContext());
++
++ if (scriptBlob->isCompleteOrError()) {
++ processScriptBlob(scriptBlob.data(), result, callback, qmlContext);
++ return QJSValuePrivate::fromReturnedValue(result.asReturnedValue());
++ }
++
++ scriptBlob->registerCallback(new QV4Include(result, callback, qmlContext));
++ populateResultValue(result, Loading);
++ return QJSValuePrivate::fromReturnedValue(result.asReturnedValue());
++ }
++
++ void QV4Include::ready(QQmlNotifyingBlob *notifyingBlob)
++ {
++ Q_ASSERT(notifyingBlob);
++ Q_ASSERT(notifyingBlob->type() == QQmlDataBlob::JavaScriptFile);
++
++ processScriptBlob(
++ static_cast<QQmlScriptBlob *>(notifyingBlob), m_resultObject.as<QV4::Object>(),
++ m_callbackFunction.as<QV4::FunctionObject>(), m_qmlContext.as<QV4::QmlContext>());
++
++ delete this;
++ }
++
++ void QV4Include::processScriptBlob(
++ QQmlScriptBlob *scriptBlob, QV4::Object *result, QV4::FunctionObject *callbackFunction,
++ QV4::QmlContext *qmlContext)
++ {
++ Q_ASSERT(scriptBlob);
++ Q_ASSERT(result);
++
++ QV4::Scope scope(result->engine());
++
++ if (scriptBlob->isError()) {
++ const QList<QQmlError> errors = scriptBlob->errors();
++ Q_ASSERT(!errors.isEmpty());
++ const QString errorString = QLatin1String("Error opening source file %1: %2")
++ .arg(scriptBlob->finalUrlString(), errors[0].toString());
++ populateResultValue(result, NetworkError, errorString);
++ callback(callbackFunction, result);
++ return;
++ }
++
++ Q_ASSERT(scriptBlob->isComplete());
++ const auto cu = scope.engine->executableCompilationUnit(
++ scriptBlob->scriptData()->compilationUnit());
++ if (QV4::Function *vmFunction = cu->rootFunction()) {
++ QScopedValueRollback<QV4::Function *> savedGlobal(scope.engine->globalCode, vmFunction);
++ vmFunction->call(nullptr, nullptr, 0, qmlContext ? qmlContext : scope.engine->rootContext());
++ }
++
++ if (scope.hasException()) {
++ QV4::ScopedValue ex(scope, scope.engine->catchException());
++ populateResultValue(result, Exception);
++ QV4::ScopedString exception(scope, scope.engine->newString(QStringLiteral("exception")));
++ result->put(exception, ex);
++ } else {
++ populateResultValue(result, Ok);
++ }
++
++ callback(callbackFunction, result);
++ }
++
++ QT_END_NAMESPACE
++