qqmlbuiltinfunctions.cpp

Go to the documentation of this file.

// Copyright (C) 2021 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 "qqmlbuiltinfunctions_p.h"
 
#include <private/qqmlcomponent_p.h>
#include <private/qqmldebugconnector_p.h>
#include <private/qqmldebugserviceinterfaces_p.h>
#include <private/qqmldelayedcallqueue_p.h>
#include <private/qqmlengine_p.h>
#include <private/qqmlloggingcategorybase_p.h>
#include <private/qqmlplatform_p.h>
#include <private/qqmlstringconverters_p.h>
 
#include <private/qv4dateobject_p.h>
#include <private/qv4engine_p.h>
#include <private/qv4functionobject_p.h>
#include <private/qv4include_p.h>
#include <private/qv4mm_p.h>
#include <private/qv4qobjectwrapper_p.h>
#include <private/qv4stackframe_p.h>
 
#include <QtQml/qqmlfile.h>
 
#include <QtCore/qcoreapplication.h>
#include <QtCore/qcryptographichash.h>
#include <QtCore/qdatetime.h>
#include <QtCore/qfileinfo.h>
#include <QtCore/qloggingcategory.h>
#include <QtCore/qpoint.h>
#include <QtCore/qrect.h>
#include <QtCore/qsize.h>
#include <QtCore/qstring.h>
#include <QtCore/qurl.h>
 
QT_BEGIN_NAMESPACE
 
Q_STATIC_LOGGING_CATEGORY(lcRootProperties, "qt.qml.rootObjectProperties");
Q_LOGGING_CATEGORY(lcQml, "qml");
Q_LOGGING_CATEGORY(lcJs, "js");
 
using namespace QV4;
 
#define THROW_TYPE_ERROR_WITH_MESSAGE(msg) \
    do { \
        return scope.engine->throwTypeError(QString::fromUtf8(msg)); \
    } while (false)
 
 
// Qt.include() is implemented in qv4include.cpp
 
QtObject::QtObject(ExecutionEngine *engine)
    : m_engine(engine)
{
}
 
QtObject::Contexts QtObject::getContexts() const
{
    QQmlEngine *engine = qmlEngine();
    if (!engine)
        return {};
 
    QQmlRefPointer<QQmlContextData> context = v4Engine()->callingQmlContext();
    if (!context)
        context = QQmlContextData::get(QQmlEnginePrivate::get(engine)->rootContext);
 
    Q_ASSERT(context);
    QQmlRefPointer<QQmlContextData> effectiveContext
            = context->isPragmaLibraryContext() ? nullptr : context;
    return {context, effectiveContext};
}
 
QtObject *QtObject::create(QQmlEngine *, QJSEngine *jsEngine)
{
    QV4::ExecutionEngine *v4 = jsEngine->handle();
    QV4::Scope scope(v4);
    ScopedObject globalObject(scope, v4->globalObject);
    ScopedString qtName(scope, v4->newString(QStringLiteral("Qt")));
    QV4::ScopedValue result(scope, globalObject->get(qtName->toPropertyKey()));
    return qobject_cast<QtObject *>(result->as<QV4::QObjectWrapper>()->object());
}
 
QJSValue QtObject::include(const QString &url, const QJSValue &callback) const
{
    return QV4Include::method_include(v4Engine(), v4Engine()->resolvedUrl(url), callback);
}
 
 
bool QtObject::isQtObject(const QJSValue &value) const
{
    return qjsvalue_cast<QObject *>(value) != nullptr;
}
 
QVariant QtObject::color(const QString &name) const
{
    bool ok = false;
    const QVariant v = QQmlStringConverters::colorFromString(name, &ok);
    if (ok)
        return v;
 
    v4Engine()->throwError(QStringLiteral("\"%1\" is not a valid color name").arg(name));
    return QVariant::fromValue(nullptr);
}
 
QVariant QtObject::rgba(double r, double g, double b, double a) const
{
    if (r < 0.0) r=0.0;
    if (r > 1.0) r=1.0;
    if (g < 0.0) g=0.0;
    if (g > 1.0) g=1.0;
    if (b < 0.0) b=0.0;
    if (b > 1.0) b=1.0;
    if (a < 0.0) a=0.0;
    if (a > 1.0) a=1.0;
 
    return QQml_colorProvider()->fromRgbF(r, g, b, a);
}
 
QVariant QtObject::hsla(double h, double s, double l, double a) const
{
    if (h < 0.0) h=0.0;
    if (h > 1.0) h=1.0;
    if (s < 0.0) s=0.0;
    if (s > 1.0) s=1.0;
    if (l < 0.0) l=0.0;
    if (l > 1.0) l=1.0;
    if (a < 0.0) a=0.0;
    if (a > 1.0) a=1.0;
 
    return QQml_colorProvider()->fromHslF(h, s, l, a);
}
 
QVariant QtObject::hsva(double h, double s, double v, double a) const
{
    h = qBound(0.0, h, 1.0);
    s = qBound(0.0, s, 1.0);
    v = qBound(0.0, v, 1.0);
    a = qBound(0.0, a, 1.0);
 
    return QQml_colorProvider()->fromHsvF(h, s, v, a);
}
 
bool QtObject::colorEqual(const QVariant &lhs, const QVariant &rhs) const
{
    bool ok = false;
 
    QVariant color1 = lhs;
    if (color1.userType() == QMetaType::QString) {
        color1 = QQmlStringConverters::colorFromString(color1.toString(), &ok);
        if (!ok) {
            v4Engine()->throwError(QStringLiteral("Qt.colorEqual(): Invalid color name"));
            return false;
        }
    } else if (color1.userType() != QMetaType::QColor) {
        v4Engine()->throwError(QStringLiteral("Qt.colorEqual(): Invalid arguments"));
        return false;
    }
 
    QVariant color2 = rhs;
    if (color2.userType() == QMetaType::QString) {
        color2 = QQmlStringConverters::colorFromString(color2.toString(), &ok);
        if (!ok) {
            v4Engine()->throwError(QStringLiteral("Qt.colorEqual(): Invalid color name"));
            return false;
        }
    } else if (color2.userType() != QMetaType::QColor) {
        v4Engine()->throwError(QStringLiteral("Qt.colorEqual(): Invalid arguments"));
        return false;
    }
 
    return color1 == color2;
}
 
QRectF QtObject::rect(double x, double y, double width, double height) const
{
    return QRectF(x, y, width, height);
}
 
QPointF QtObject::point(double x, double y) const
{
    return QPointF(x, y);
}
 
QSizeF QtObject::size(double w, double h) const
{
    return QSizeF(w, h);
}
 
QVariant QtObject::font(const QJSValue &fontSpecifier) const
{
    if (!fontSpecifier.isObject()) {
        v4Engine()->throwError(QStringLiteral("Qt.font(): Invalid arguments"));
        return QVariant();
    }
 
    {
        const QVariant v = QQmlValueTypeProvider::createValueType(
                    fontSpecifier, QMetaType(QMetaType::QFont));
        if (v.isValid())
            return v;
    }
 
    v4Engine()->throwError(QStringLiteral("Qt.font(): Invalid argument: "
                                          "no valid font subproperties specified"));
    return QVariant();
}
 
template<typename T>
void addParameters(QJSEngine *e, QJSValue &result, int i, T parameter)
{
    result.setProperty(i, e->toScriptValue(parameter));
}
 
template<>
void addParameters<double>(QJSEngine *, QJSValue &result, int i, double parameter)
{
    result.setProperty(i, QJSValue(parameter));
}
 
template<typename T, typename ...Others>
void addParameters(QJSEngine *e, QJSValue &result, int i, T parameter, Others... others)
{
    addParameters<T>(e, result, i, parameter);
    addParameters<Others...>(e, result, ++i, others...);
}
 
template<typename ...T>
static QVariant constructFromJSValue(QJSEngine *e, QMetaType type, T... parameters)
{
    if (!e)
        return QVariant();
    QJSValue params = e->newArray(sizeof...(parameters));
    addParameters(e, params, 0, parameters...);
    const QVariant variant = QQmlValueTypeProvider::createValueType(params, type);
    return variant.isValid() ? variant : QVariant(type);
}
 
QVariant QtObject::vector2d(double x, double y) const
{
    return constructFromJSValue(jsEngine(), QMetaType(QMetaType::QVector2D), x, y);
}
 
QVariant QtObject::vector3d(double x, double y, double z) const
{
    return constructFromJSValue(jsEngine(), QMetaType(QMetaType::QVector3D), x, y, z);
}
 
QVariant QtObject::vector4d(double x, double y, double z, double w) const
{
    return constructFromJSValue(jsEngine(), QMetaType(QMetaType::QVector4D), x, y, z, w);
}
 
QVariant QtObject::quaternion(double scalar, double x, double y, double z) const
{
    return constructFromJSValue(jsEngine(), QMetaType(QMetaType::QQuaternion), scalar, x, y, z);
}
 
QVariant QtObject::matrix4x4() const
{
    const QMetaType metaType(QMetaType::QMatrix4x4);
    const QVariant variant = QQmlValueTypeProvider::createValueType(QJSValue(), metaType);
    return variant.isValid() ? variant : QVariant(metaType);
}
 
QVariant QtObject::matrix4x4(const QJSValue &value) const
{
    if (value.isObject()) {
        QVariant v = QQmlValueTypeProvider::createValueType(
                    value, QMetaType(QMetaType::QMatrix4x4));
        if (v.isValid())
            return v;
    }
 
    v4Engine()->throwError(QStringLiteral("Qt.matrix4x4(): Invalid argument: "
                                          "not a valid matrix4x4 values array"));
    return QVariant();
}
 
QVariant QtObject::matrix4x4(double m11, double m12, double m13, double m14,
                             double m21, double m22, double m23, double m24,
                             double m31, double m32, double m33, double m34,
                             double m41, double m42, double m43, double m44) const
{
    return constructFromJSValue(jsEngine(), QMetaType(QMetaType::QMatrix4x4),
                           m11, m12, m13, m14, m21, m22, m23, m24,
                           m31, m32, m33, m34, m41, m42, m43, m44);
}
 
static QVariant colorVariantFromJSValue(const QJSValue &color, bool *ok)
{
    QVariant v;
    if (color.isString()) {
        v = QQmlStringConverters::colorFromString(color.toString(), ok);
        if (!(*ok))
            return QVariant::fromValue(nullptr);
    } else {
        v = color.toVariant();
        if (v.userType() != QMetaType::QColor) {
            *ok = false;
            return QVariant::fromValue(nullptr);
        }
    }
 
    *ok = true;
    return v;
}
 
QVariant QtObject::lighter(const QJSValue &color, double factor) const
{
    bool ok;
    const QVariant v = colorVariantFromJSValue(color, &ok);
    return ok ? QQml_colorProvider()->lighter(v, factor) : v;
}
 
QVariant QtObject::darker(const QJSValue &color, double factor) const
{
    bool ok;
    const QVariant v = colorVariantFromJSValue(color, &ok);
    return ok ? QQml_colorProvider()->darker(v, factor) : v;
}
 
QVariant QtObject::alpha(const QJSValue &baseColor, double value) const
{
    bool ok;
    const QVariant v = colorVariantFromJSValue(baseColor, &ok);
    return ok ? QQml_colorProvider()->alpha(v, value) : v;
}
 
QVariant QtObject::tint(const QJSValue &baseColor, const QJSValue &tintColor) const
{
    bool ok;
 
    // base color
    const QVariant v1 = colorVariantFromJSValue(baseColor, &ok);
    if (!ok)
        return v1;
 
    // tint color
    const QVariant v2 = colorVariantFromJSValue(tintColor, &ok);
 
    return ok ? QQml_colorProvider()->tint(v1, v2) : v2;
}
 
namespace {
template <typename T>
QString formatDateTimeObjectUsingDateFormat(T formatThis, Qt::DateFormat format) {
    switch (format) {
    case Qt::TextDate:
    case Qt::ISODate:
    case Qt::RFC2822Date:
    case Qt::ISODateWithMs:
        return formatThis.toString(format);
    default: // ### Qt 6: remove once qtbase has removed the rest of the enum !
        break;
    }
    // Q_UNREACHABLE(); // ### Qt 6: restore once the default is gone
    return QString();
}
}
 
static QTime dateTimeToTime(const QDateTime &dateTime)
{
    return dateTime.toLocalTime().time();
}
 
static std::optional<QDate> dateFromString(const QString &string, QV4::ExecutionEngine *engine)
{
    {
        const QDate date = QDate::fromString(string, Qt::ISODate);
        if (date.isValid())
            return date;
    }
 
    {
        // For historical reasons, the string argument is parsed as datetime, not as only date
        const QDateTime dateTime = QDateTime::fromString(string, Qt::ISODate);
        if (dateTime.isValid()) {
            qCWarning(lcRootProperties())
                    << string << "is a date/time string being passed to formatDate()."
                    << "You should only pass date strings to formatDate().";
            return dateTime.date();
        }
    }
 
    {
        // Since we can coerce QDate to QString, allow the resulting string format here.
        const QDateTime dateTime = DateObject::stringToDateTime(string, engine);
        if (dateTime.isValid())
            return DateObject::dateTimeToDate(dateTime);
    }
 
    engine->throwError(QStringLiteral("Invalid argument passed to formatDate(): %1").arg(string));
    return std::nullopt;
}
 
QString QtObject::formatDate(QDate date, const QString &format) const
{
    return date.toString(format);
}
 
QString QtObject::formatDate(QDate date, Qt::DateFormat format) const
{
    return formatDateTimeObjectUsingDateFormat(date, format);
}
 
QString QtObject::formatDate(const QDateTime &dateTime, const QString &format) const
{
    return DateObject::dateTimeToDate(dateTime).toString(format);
}
 
QString QtObject::formatDate(const QString &string, const QString &format) const
{
    if (const auto qDate = dateFromString(string, v4Engine()))
        return formatDate(qDate.value(), format);
 
    return QString();
}
 
QString QtObject::formatDate(const QDateTime &dateTime, Qt::DateFormat format) const
{
    return formatDateTimeObjectUsingDateFormat(DateObject::dateTimeToDate(dateTime), format);
}
 
QString QtObject::formatDate(const QString &string, Qt::DateFormat format) const
{
    if (const auto qDate = dateFromString(string, v4Engine()))
        return formatDate(qDate.value(), format);
 
    return QString();
}
 
#if QT_CONFIG(qml_locale)
QString QtObject::formatDate(QDate date, const QLocale &locale,
                             QLocale::FormatType formatType) const
{
    return locale.toString(date, formatType);
}
 
QString QtObject::formatDate(const QDateTime &dateTime, const QLocale &locale,
                             QLocale::FormatType formatType) const
{
    return locale.toString(DateObject::dateTimeToDate(dateTime), formatType);
}
 
QString QtObject::formatDate(const QString &string, const QLocale &locale,
                             QLocale::FormatType formatType) const
{
    if (const auto qDate = dateFromString(string, v4Engine()))
        return locale.toString(qDate.value(), formatType);
 
    return QString();
}
#endif
 
static std::optional<QTime> timeFromString(const QString &string, QV4::ExecutionEngine *engine)
{
    {
        const QTime time = QTime::fromString(string, Qt::ISODate);
        if (time.isValid())
            return time;
    }
 
    {
        // For historical reasons, the string argument is parsed as datetime, not as only time
        const QDateTime dateTime = QDateTime::fromString(string, Qt::ISODate);
        if (dateTime.isValid()) {
            qCWarning(lcRootProperties())
                    << string << "is a date/time string being passed to formatTime()."
                    << "You should only pass time strings to formatTime().";
            return dateTime.time();
        }
    }
 
    {
        // Since we can coerce QTime to QString, allow the resulting string format here.
        const QDateTime dateTime = DateObject::stringToDateTime(string, engine);
        if (dateTime.isValid())
            return dateTimeToTime(dateTime);
    }
 
    engine->throwError(QStringLiteral("Invalid argument passed to formatTime(): %1").arg(string));
    return std::nullopt;
}
 
QString QtObject::formatTime(QTime time, const QString &format) const
{
    return time.toString(format);
}
 
QString QtObject::formatTime(const QDateTime &dateTime, const QString &format) const
{
    return dateTimeToTime(dateTime).toString(format);
}
 
QString QtObject::formatTime(const QString &time, const QString &format) const
{
 
    if (auto qTime = timeFromString(time, v4Engine()))
        return formatTime(qTime.value(), format);
 
    return QString();
}
 
QString QtObject::formatTime(QTime time, Qt::DateFormat format) const
{
    return formatDateTimeObjectUsingDateFormat(time, format);
}
 
QString QtObject::formatTime(const QDateTime &dateTime, Qt::DateFormat format) const
{
    return formatDateTimeObjectUsingDateFormat(dateTimeToTime(dateTime), format);
}
 
QString QtObject::formatTime(const QString &time, Qt::DateFormat format) const
{
    if (auto qTime = timeFromString(time, v4Engine()))
        return formatTime(qTime.value(), format);
 
    return QString();
}
 
#if QT_CONFIG(qml_locale)
QString QtObject::formatTime(QTime time, const QLocale &locale,
                             QLocale::FormatType formatType) const
{
    return locale.toString(time, formatType);
}
 
QString QtObject::formatTime(const QDateTime &dateTime, const QLocale &locale,
                             QLocale::FormatType formatType) const
{
    return locale.toString(dateTimeToTime(dateTime), formatType);
}
 
QString QtObject::formatTime(const QString &time, const QLocale &locale,
                             QLocale::FormatType formatType) const
{
    if (auto qTime = timeFromString(time, v4Engine()))
        return locale.toString(qTime.value(), formatType);
 
    return QString();
}
#endif
 
static std::optional<QDateTime> dateTimeFromString(const QString &string, QV4::ExecutionEngine *engine)
{
    {
        const QDateTime dateTime = QDateTime::fromString(string, Qt::ISODate);
        if (dateTime.isValid())
            return dateTime;
    }
 
    {
        // Since we can coerce QDateTime to QString, allow the resulting string format here.
        const QDateTime dateTime = DateObject::stringToDateTime(string, engine);
        if (dateTime.isValid())
            return dateTime;
    }
 
    engine->throwError(QStringLiteral("Invalid argument passed to formatDateTime(): %1").arg(string));
    return std::nullopt;
}
 
QString QtObject::formatDateTime(const QDateTime &dateTime, const QString &format) const
{
    return dateTime.toString(format);
}
 
QString QtObject::formatDateTime(const QString &string, const QString &format) const
{
 
    if (const auto qDateTime = dateTimeFromString(string, v4Engine()))
        return formatDateTime(qDateTime.value(), format);
 
    return QString();
}
 
QString QtObject::formatDateTime(const QDateTime &dateTime, Qt::DateFormat format) const
{
    return formatDateTimeObjectUsingDateFormat(dateTime, format);
}
 
QString QtObject::formatDateTime(const QString &string, Qt::DateFormat format) const
{
 
    if (const auto qDateTime = dateTimeFromString(string, v4Engine()))
        return formatDateTime(qDateTime.value(), format);
 
    return QString();
}
 
#if QT_CONFIG(qml_locale)
QString QtObject::formatDateTime(const QDateTime &dateTime, const QLocale &locale,
                                 QLocale::FormatType formatType) const
{
    return locale.toString(dateTime, formatType);
}
 
QString QtObject::formatDateTime(const QString &string, const QLocale &locale,
                                 QLocale::FormatType formatType) const
{
 
    if (const auto qDateTime = dateTimeFromString(string, v4Engine()))
        return formatDateTime(qDateTime.value(), locale, formatType);
 
    return QString();
}
#endif
 
bool QtObject::openUrlExternally(const QUrl &url) const
{
    return QQml_guiProvider()->openUrlExternally(resolvedUrl(url));
}
 
QUrl QtObject::url(const QUrl &url) const
{
    return url;
}
 
QUrl QtObject::resolvedUrl(const QUrl &url) const
{
    if (QQmlRefPointer<QQmlContextData> ctxt = v4Engine()->callingQmlContext())
        return ctxt->resolvedUrl(url);
    if (QQmlEngine *engine = qmlEngine())
        return engine->baseUrl().resolved(url);
    return url;
}
 
QUrl QtObject::resolvedUrl(const QUrl &url, QObject *context) const
{
    if (context) {
        QQmlData *data = QQmlData::get(context);
        if (data && data->outerContext)
            return data->outerContext->resolvedUrl(url);
    }
 
    if (QQmlEngine *engine = qmlEngine())
        return engine->baseUrl().resolved(url);
    return url;
}
 
QStringList QtObject::fontFamilies() const
{
    return QQml_guiProvider()->fontFamilies();
}
 
QString QtObject::md5(const QString &data) const
{
    return QLatin1String(QCryptographicHash::hash(data.toUtf8(), QCryptographicHash::Md5).toHex());
}
 
QString QtObject::btoa(const QString &data) const
{
    return QLatin1String(data.toUtf8().toBase64());
}
 
QString QtObject::atob(const QString &data) const
{
    return QString::fromUtf8(QByteArray::fromBase64(data.toLatin1()));
}
 
void QtObject::quit() const
{
    if (QQmlEngine *engine = qmlEngine())
        QQmlEnginePrivate::get(engine)->sendQuit();
}
 
void QtObject::exit(int retCode) const
{
    if (QQmlEngine *engine = qmlEngine())
        QQmlEnginePrivate::get(engine)->sendExit(retCode);
}
 
QObject *QtObject::createQmlObject(const QString &qml, QObject *parent, const QUrl &url) const
{
    QQmlEngine *engine = qmlEngine();
    if (!engine) {
        v4Engine()->throwError(QStringLiteral("Qt.createQmlObject(): "
                                              "Can only be called on a QML engine."));
        return nullptr;
    }
 
    struct Error {
        static ReturnedValue create(QV4::ExecutionEngine *v4, const QList<QQmlError> &errors) {
            Scope scope(v4);
            QString errorstr;
            // '+=' reserves extra capacity. Follow-up appending will be probably free.
            errorstr += QLatin1String("Qt.createQmlObject(): failed to create object: ");
 
            QV4::ScopedArrayObject qmlerrors(scope, v4->newArrayObject());
            QV4::ScopedObject qmlerror(scope);
            QV4::ScopedString s(scope);
            QV4::ScopedValue v(scope);
            for (int ii = 0; ii < errors.size(); ++ii) {
                const QQmlError &error = errors.at(ii);
                errorstr += QLatin1String("\n    ") + error.toString();
                qmlerror = v4->newObject();
                qmlerror->put((s = v4->newString(QStringLiteral("lineNumber"))), (v = QV4::Value::fromInt32(error.line())));
                qmlerror->put((s = v4->newString(QStringLiteral("columnNumber"))), (v = QV4::Value::fromInt32(error.column())));
                qmlerror->put((s = v4->newString(QStringLiteral("fileName"))), (v = v4->newString(error.url().toString())));
                qmlerror->put((s = v4->newString(QStringLiteral("message"))), (v = v4->newString(error.description())));
                qmlerrors->put(ii, qmlerror);
            }
 
            v = v4->newString(errorstr);
            ScopedObject errorObject(scope, v4->newErrorObject(v));
            errorObject->put((s = v4->newString(QStringLiteral("qmlErrors"))), qmlerrors);
            return errorObject.asReturnedValue();
        }
    };
 
    QQmlRefPointer<QQmlContextData> context = v4Engine()->callingQmlContext();
    if (!context)
        context = QQmlContextData::get(QQmlEnginePrivate::get(engine)->rootContext);
 
    Q_ASSERT(context);
    QQmlContext *effectiveContext = nullptr;
    if (context->isPragmaLibraryContext())
        effectiveContext = engine->rootContext();
    else
        effectiveContext = context->asQQmlContext();
    Q_ASSERT(effectiveContext);
 
    if (qml.isEmpty())
        return nullptr;
 
    QUrl resolvedUrl = url;
    if (url.isValid() && url.isRelative())
        resolvedUrl = context->resolvedUrl(url);
 
    if (!parent) {
        v4Engine()->throwError(QStringLiteral("Qt.createQmlObject(): Missing parent object"));
        return nullptr;
    }
 
    QQmlRefPointer<QQmlTypeData> typeData = QQmlEnginePrivate::get(engine)->typeLoader.getType(
                qml.toUtf8(), resolvedUrl, QQmlTypeLoader::Synchronous);
    Q_ASSERT(typeData->isCompleteOrError());
    QQmlComponent component(engine);
    QQmlComponentPrivate *componentPrivate = QQmlComponentPrivate::get(&component);
    componentPrivate->fromTypeData(typeData);
    componentPrivate->progress = 1.0;
 
    Scope scope(v4Engine());
    if (component.isError()) {
        ScopedValue v(scope, Error::create(scope.engine, component.errors()));
        scope.engine->throwError(v);
        return nullptr;
    }
 
    if (!component.isReady()) {
        v4Engine()->throwError(QStringLiteral("Qt.createQmlObject(): Component is not ready"));
        return nullptr;
    }
 
    if (!effectiveContext->isValid()) {
        v4Engine()->throwError(QStringLiteral("Qt.createQmlObject(): Cannot create a component "
                                              "in an invalid context"));
        return nullptr;
    }
 
    QObject *obj = component.beginCreate(effectiveContext);
    if (obj) {
        QQmlData::get(obj, true)->explicitIndestructibleSet = false;
        QQmlData::get(obj)->indestructible = false;
 
        obj->setParent(parent);
 
        QList<QQmlPrivate::AutoParentFunction> functions = QQmlMetaType::parentFunctions();
        for (int ii = 0; ii < functions.size(); ++ii) {
            if (QQmlPrivate::Parented == functions.at(ii)(obj, parent))
                break;
        }
    }
    component.completeCreate();
 
    if (component.isError()) {
        ScopedValue v(scope, Error::create(scope.engine, component.errors()));
        scope.engine->throwError(v);
        return nullptr;
    }
 
    Q_ASSERT(obj);
    return obj;
}
 
QQmlComponent *QtObject::createComponent(const QUrl &url, QObject *parent) const
{
    return createComponent(url, QQmlComponent::PreferSynchronous, parent);
}
 
QQmlComponent *QtObject::createComponent(const QUrl &url, QQmlComponent::CompilationMode mode,
                                         QObject *parent) const
{
    if (mode != QQmlComponent::Asynchronous && mode != QQmlComponent::PreferSynchronous) {
        v4Engine()->throwError(QStringLiteral("Invalid compilation mode %1").arg(mode));
        return nullptr;
    }
 
    if (url.isEmpty())
        return nullptr;
 
    QQmlEngine *engine = qmlEngine();
    if (!engine)
        return nullptr;
 
    auto [context, effectiveContext] = getContexts();
    if (!context)
        return nullptr;
 
    QQmlComponent *c = new QQmlComponent(engine, context->resolvedUrl(url), mode, parent);
    QQmlComponentPrivate::get(c)->creationContext = effectiveContext;
    QQmlData::get(c, true)->explicitIndestructibleSet = false;
    QQmlData::get(c)->indestructible = false;
    return c;
}
 
QQmlComponent *QtObject::createComponent(const QString &moduleUri, const QString &typeName,
                                         QObject *parent) const
{
    return createComponent(moduleUri, typeName, QQmlComponent::PreferSynchronous, parent);
}
 
QQmlComponent *QtObject::createComponent(const QString &moduleUri, const QString &typeName, QQmlComponent::CompilationMode mode, QObject *parent) const
{
    if (mode != QQmlComponent::Asynchronous && mode != QQmlComponent::PreferSynchronous) {
        v4Engine()->throwError(QStringLiteral("Invalid compilation mode %1").arg(mode));
        return nullptr;
    }
 
    QQmlEngine *engine = qmlEngine();
    if (!engine)
        return nullptr;
 
    if (moduleUri.isEmpty() || typeName.isEmpty())
        return nullptr;
 
    auto [context, effectiveContext] = getContexts();
    if (!context)
        return nullptr;
 
    QQmlComponent *c = new QQmlComponent(engine, moduleUri, typeName, mode, parent);
    if (c->isError() && !parent && moduleUri.endsWith(u".qml")) {
        v4Engine()->throwTypeError(
                    QStringLiteral("Invalid arguments; did you swap mode and parent"));
    }
    QQmlComponentPrivate::get(c)->creationContext = effectiveContext;
    QQmlData::get(c, true)->explicitIndestructibleSet = false;
    QQmlData::get(c)->indestructible = false;
    return c;
}
 
#if QT_CONFIG(translation)
QString QtObject::uiLanguage() const
{
    if (const QJSEngine *e = jsEngine())
        return e->uiLanguage();
    return QString();
}
 
void QtObject::setUiLanguage(const QString &uiLanguage)
{
    if (QJSEngine *e = jsEngine())
        e->setUiLanguage(uiLanguage);
}
 
QBindable<QString> QtObject::uiLanguageBindable()
{
    if (QJSEngine *e = jsEngine())
        return QBindable<QString>(&QJSEnginePrivate::get(e)->uiLanguage);
    return QBindable<QString>();
}
#endif
 
#if QT_CONFIG(qml_locale)
QLocale QtObject::locale() const
{
    return QLocale();
}
 
QLocale QtObject::locale(const QString &name) const
{
    return QLocale(name);
}
#endif
 
void Heap::QQmlBindingFunction::init(const QV4::JavaScriptFunctionObject *bindingFunction)
{
    Scope scope(bindingFunction->engine());
    ScopedContext context(scope, bindingFunction->scope());
    JavaScriptFunctionObject::init(context, bindingFunction->function());
    this->bindingFunction.set(internalClass->engine, bindingFunction->d());
}
 
ReturnedValue QQmlBindingFunction::virtualCall(
        const FunctionObject *f, const Value *, const Value *, int)
{
    // Mark this as a callable object, so that we can perform the binding magic on it.
    return f->engine()->throwTypeError(QStringLiteral("Bindings must not be called directly."));
}
 
QQmlSourceLocation QQmlBindingFunction::currentLocation() const
{
    QV4::CppStackFrame *frame = engine()->currentStackFrame;
    if (frame->v4Function) // synchronous loading:
        return QQmlSourceLocation(frame->source(), frame->lineNumber(), 0);
    else // async loading:
        return bindingFunction()->function->sourceLocation();
}
 
DEFINE_OBJECT_VTABLE(QQmlBindingFunction);
 
QJSValue QtObject::binding(const QJSValue &function) const
{
    const QV4::JavaScriptFunctionObject *f
            = QJSValuePrivate::asManagedType<JavaScriptFunctionObject>(&function);
    QV4::ExecutionEngine *e = v4Engine();
    if (!f) {
        return QJSValuePrivate::fromReturnedValue(
                    e->throwError(
                        QStringLiteral(
                            "binding(): argument (binding expression) must be a function")));
    }
 
    return QJSValuePrivate::fromReturnedValue(
                Encode(e->memoryManager->allocate<QQmlBindingFunction>(f)));
}
 
void QtObject::callLater(QQmlV4FunctionPtr args)
{
    m_engine->delayedCallQueue()->addUniquelyAndExecuteLater(m_engine, args);
}
 
 
QQmlPlatform *QtObject::platform()
{
    if (!m_platform)
        m_platform = new QQmlPlatform(this);
    return m_platform;
}
 
QQmlApplication *QtObject::application()
{
    if (!m_application)
        // Only allocate an application object once
        m_application = QQml_guiProvider()->application(this);
 
    return m_application;
}
 
QObject *QtObject::inputMethod() const
{
    return QQml_guiProvider()->inputMethod();
}
 
QObject *QtObject::styleHints() const
{
    return QQml_guiProvider()->styleHints();
}
 
void QV4::Heap::ConsoleObject::init()
{
    Object::init();
    QV4::Scope scope(internalClass->engine);
    QV4::ScopedObject o(scope, this);
 
    o->defineDefaultProperty(QStringLiteral("debug"), QV4::ConsoleObject::method_log);
    o->defineDefaultProperty(QStringLiteral("log"), QV4::ConsoleObject::method_log);
    o->defineDefaultProperty(QStringLiteral("info"), QV4::ConsoleObject::method_info);
    o->defineDefaultProperty(QStringLiteral("warn"), QV4::ConsoleObject::method_warn);
    o->defineDefaultProperty(QStringLiteral("error"), QV4::ConsoleObject::method_error);
    o->defineDefaultProperty(QStringLiteral("assert"), QV4::ConsoleObject::method_assert);
 
    o->defineDefaultProperty(QStringLiteral("count"), QV4::ConsoleObject::method_count);
    o->defineDefaultProperty(QStringLiteral("profile"), QV4::ConsoleObject::method_profile);
    o->defineDefaultProperty(QStringLiteral("profileEnd"), QV4::ConsoleObject::method_profileEnd);
    o->defineDefaultProperty(QStringLiteral("time"), QV4::ConsoleObject::method_time);
    o->defineDefaultProperty(QStringLiteral("timeEnd"), QV4::ConsoleObject::method_timeEnd);
    o->defineDefaultProperty(QStringLiteral("trace"), QV4::ConsoleObject::method_trace);
    o->defineDefaultProperty(QStringLiteral("exception"), QV4::ConsoleObject::method_exception);
}
 
 
enum ConsoleLogTypes {
    Log,
    Info,
    Warn,
    Error
};
 
static QString jsStack(QV4::ExecutionEngine *engine) {
    QString stack;
 
    int i = 0;
    for (CppStackFrame *f = engine->currentStackFrame; f && i < 10; f = f->parentFrame(), ++i) {
        QString stackFrame;
 
        if (f->isJSTypesFrame() && static_cast<JSTypesStackFrame *>(f)->isTailCalling()) {
            stackFrame = QStringLiteral("[elided tail calls]");
        } else {
            const int line = f->lineNumber();
            if (line != f->missingLineNumber()) {
                stackFrame = QStringLiteral("%1 (%2:%3)").arg(
                        f->function(), f->source(), QString::number(qAbs(line)));
            } else {
                stackFrame = QStringLiteral("%1 (%2)").arg(
                        f->function(), f->source());
            }
        }
 
        if (i)
            stack += QLatin1Char('\n');
        stack += stackFrame;
    }
    return stack;
}
 
static QString serializeArray(Object *array, ExecutionEngine *v4, QSet<QV4::Heap::Object *> &alreadySeen) {
    Scope scope(v4);
    ScopedValue val(scope);
    QString result;
 
    alreadySeen.insert(array->d());
    result += QLatin1Char('[');
    const uint length = array->getLength();
    for (uint i = 0; i < length; ++i) {
        if (i != 0)
            result += QLatin1Char(',');
        val = array->get(i);
        if (val->isManaged() && val->managed()->isArrayLike())
            if (!alreadySeen.contains(val->objectValue()->d()))
                result += serializeArray(val->objectValue(), v4, alreadySeen);
            else
                result += QLatin1String("[Circular]");
        else
            result += val->toQStringNoThrow();
    }
    result += QLatin1Char(']');
    alreadySeen.remove(array->d());
    return result;
};
 
static ReturnedValue writeToConsole(const FunctionObject *b, const Value *argv, int argc,
                                    ConsoleLogTypes logType, bool printStack = false)
{
    const QLoggingCategory *loggingCategory = nullptr;
    QString result;
    QV4::Scope scope(b);
    QV4::ExecutionEngine *v4 = scope.engine;
 
    int start = 0;
    if (argc > 0) {
        if (const QObjectWrapper* wrapper = argv[0].as<QObjectWrapper>()) {
            if (QQmlLoggingCategoryBase *category
                    = qobject_cast<QQmlLoggingCategoryBase *>(wrapper->object())) {
                if (category->category())
                    loggingCategory = category->category();
                else
                    THROW_GENERIC_ERROR("A QmlLoggingCatgory was provided without a valid name");
                start = 1;
            }
        }
    }
 
 
    for (int i = start, ei = argc; i < ei; ++i) {
        if (i != start)
            result.append(QLatin1Char(' '));
 
        QSet<QV4::Heap::Object *> alreadySeenElements;
        if (argv[i].isManaged() && argv[i].managed()->isArrayLike())
            result.append(serializeArray(argv[i].objectValue(), v4, alreadySeenElements));
        else
            result.append(argv[i].toQStringNoThrow());
    }
 
    if (printStack)
        result += QLatin1Char('\n') + jsStack(v4);
 
    if (!loggingCategory)
        loggingCategory = v4->qmlEngine() ? &lcQml() : &lcJs();
    QV4::CppStackFrame *frame = v4->currentStackFrame;
    const QByteArray baSource = frame ? frame->source().toUtf8() : QByteArray();
    const QByteArray baFunction = frame ? frame->function().toUtf8() : QByteArray();
    QMessageLogger logger(baSource.constData(), frame ? frame->lineNumber() : 0,
                          baFunction.constData(), loggingCategory->categoryName());
 
    switch (logType) {
    case Log:
        if (loggingCategory->isDebugEnabled())
            logger.debug("%s", result.toUtf8().constData());
        break;
    case Info:
        if (loggingCategory->isInfoEnabled())
            logger.info("%s", result.toUtf8().constData());
        break;
    case Warn:
        if (loggingCategory->isWarningEnabled())
            logger.warning("%s", result.toUtf8().constData());
        break;
    case Error:
        if (loggingCategory->isCriticalEnabled())
            logger.critical("%s", result.toUtf8().constData());
        break;
    default:
        break;
    }
 
    return Encode::undefined();
}
 
DEFINE_OBJECT_VTABLE(ConsoleObject);
 
ReturnedValue ConsoleObject::method_error(const FunctionObject *b, const Value *, const Value *argv, int argc)
{
    return writeToConsole(b, argv, argc, Error);
}
 
ReturnedValue ConsoleObject::method_log(const FunctionObject *b, const Value *, const Value *argv, int argc)
{
    //console.log
    //console.debug
    //print
    return writeToConsole(b, argv, argc, Log);
}
 
ReturnedValue ConsoleObject::method_info(const FunctionObject *b, const Value *, const Value *argv, int argc)
{
    return writeToConsole(b, argv, argc, Info);
}
 
ReturnedValue ConsoleObject::method_profile(const FunctionObject *b, const Value *, const Value *, int)
{
    QV4::Scope scope(b);
    QV4::ExecutionEngine *v4 = scope.engine;
 
    QV4::CppStackFrame *frame = v4->currentStackFrame;
    const QByteArray baSource = frame->source().toUtf8();
    const QByteArray baFunction = frame->function().toUtf8();
    QMessageLogger logger(baSource.constData(), frame->lineNumber(), baFunction.constData());
    QQmlProfilerService *service = QQmlDebugConnector::service<QQmlProfilerService>();
    if (!service) {
        logger.warning("Cannot start profiling because debug service is disabled. Start with -qmljsdebugger=port:XXXXX.");
    } else {
        service->startProfiling(v4->jsEngine());
        logger.debug("Profiling started.");
    }
 
    return QV4::Encode::undefined();
}
 
ReturnedValue ConsoleObject::method_profileEnd(const FunctionObject *b, const Value *, const Value *, int)
{
    QV4::Scope scope(b);
    QV4::ExecutionEngine *v4 = scope.engine;
 
    QV4::CppStackFrame *frame = v4->currentStackFrame;
    const QByteArray baSource = frame->source().toUtf8();
    const QByteArray baFunction = frame->function().toUtf8();
    QMessageLogger logger(baSource.constData(), frame->lineNumber(), baFunction.constData());
 
    QQmlProfilerService *service = QQmlDebugConnector::service<QQmlProfilerService>();
    if (!service) {
        logger.warning("Ignoring console.profileEnd(): the debug service is disabled.");
    } else {
        service->stopProfiling(v4->jsEngine());
        logger.debug("Profiling ended.");
    }
 
    return QV4::Encode::undefined();
}
 
ReturnedValue ConsoleObject::method_time(const FunctionObject *b, const Value *, const Value *argv, int argc)
{
    QV4::Scope scope(b);
    if (argc != 1)
        THROW_GENERIC_ERROR("console.time(): Invalid arguments");
 
    QString name = argv[0].toQStringNoThrow();
    scope.engine->startTimer(name);
    return QV4::Encode::undefined();
}
 
ReturnedValue ConsoleObject::method_timeEnd(const FunctionObject *b, const Value *, const Value *argv, int argc)
{
    QV4::Scope scope(b);
    if (argc != 1)
        THROW_GENERIC_ERROR("console.timeEnd(): Invalid arguments");
 
    QString name = argv[0].toQStringNoThrow();
    bool wasRunning;
    qint64 elapsed = scope.engine->stopTimer(name, &wasRunning);
    if (wasRunning) {
        qDebug("%s: %llims", qPrintable(name), elapsed);
    }
    return QV4::Encode::undefined();
}
 
ReturnedValue ConsoleObject::method_count(const FunctionObject *b, const Value *, const Value *argv, int argc)
{
    // first argument: name to print. Ignore any additional arguments
    QString name;
    if (argc > 0)
        name = argv[0].toQStringNoThrow();
 
    Scope scope(b);
    QV4::ExecutionEngine *v4 = scope.engine;
 
    QV4::CppStackFrame *frame = v4->currentStackFrame;
 
    QString scriptName = frame->source();
 
    int value = v4->consoleCountHelper(scriptName, frame->lineNumber(), 0);
    QString message = name + QLatin1String(": ") + QString::number(value);
 
    QMessageLogger(qPrintable(scriptName), frame->lineNumber(),
                   qPrintable(frame->function()))
        .debug("%s", qPrintable(message));
 
    return QV4::Encode::undefined();
}
 
ReturnedValue ConsoleObject::method_trace(const FunctionObject *b, const Value *, const Value *, int argc)
{
    QV4::Scope scope(b);
    if (argc != 0)
        THROW_GENERIC_ERROR("console.trace(): Invalid arguments");
 
    QV4::ExecutionEngine *v4 = scope.engine;
 
    QString stack = jsStack(v4);
 
    QV4::CppStackFrame *frame = v4->currentStackFrame;
    QMessageLogger(frame->source().toUtf8().constData(), frame->lineNumber(),
                   frame->function().toUtf8().constData())
            .debug(v4->qmlEngine() ? lcQml() : lcJs(), "%s", qPrintable(stack));
 
    return QV4::Encode::undefined();
}
 
ReturnedValue ConsoleObject::method_warn(const FunctionObject *b, const Value *, const Value *argv, int argc)
{
    return writeToConsole(b, argv, argc, Warn);
}
 
ReturnedValue ConsoleObject::method_assert(const FunctionObject *b, const Value *, const Value *argv, int argc)
{
    QV4::Scope scope(b);
    if (argc == 0)
        THROW_GENERIC_ERROR("console.assert(): Missing argument");
 
    QV4::ExecutionEngine *v4 = scope.engine;
 
    if (!argv[0].toBoolean()) {
        QString message;
        for (int i = 1, ei = argc; i < ei; ++i) {
            if (i != 1)
                message.append(QLatin1Char(' '));
 
            message.append(argv[i].toQStringNoThrow());
        }
 
        QString stack = jsStack(v4);
 
        QV4::CppStackFrame *frame = v4->currentStackFrame;
        QMessageLogger(frame->source().toUtf8().constData(), frame->lineNumber(),
                       frame->function().toUtf8().constData())
            .critical("%s\n%s",qPrintable(message), qPrintable(stack));
 
    }
    return QV4::Encode::undefined();
}
 
ReturnedValue ConsoleObject::method_exception(const FunctionObject *b, const Value *, const Value *argv, int argc)
{
    QV4::Scope scope(b);
    if (argc == 0)
        THROW_GENERIC_ERROR("console.exception(): Missing argument");
 
    return writeToConsole(b, argv, argc, Error, true);
}
 
void QV4::GlobalExtensions::init(Object *globalObject, QJSEngine::Extensions extensions)
{
    ExecutionEngine *v4 = globalObject->engine();
    Scope scope(v4);
 
    if (extensions.testFlag(QJSEngine::TranslationExtension)) {
    #if QT_CONFIG(translation)
        globalObject->defineDefaultProperty(QStringLiteral("qsTranslate"), QV4::GlobalExtensions::method_qsTranslate);
        globalObject->defineDefaultProperty(QStringLiteral("QT_TRANSLATE_NOOP"), QV4::GlobalExtensions::method_qsTranslateNoOp);
        globalObject->defineDefaultProperty(QStringLiteral("qsTr"), QV4::GlobalExtensions::method_qsTr);
        globalObject->defineDefaultProperty(QStringLiteral("QT_TR_NOOP"), QV4::GlobalExtensions::method_qsTrNoOp);
        globalObject->defineDefaultProperty(QStringLiteral("qsTrId"), QV4::GlobalExtensions::method_qsTrId);
        globalObject->defineDefaultProperty(QStringLiteral("QT_TRID_NOOP"), QV4::GlobalExtensions::method_qsTrIdNoOp);
 
        // Initialize the Qt global object for the uiLanguage property
        ScopedString qtName(scope, v4->newString(QStringLiteral("Qt")));
        ScopedObject qt(scope, globalObject->get(qtName));
        if (!qt)
            v4->createQtObject();
 
        // string prototype extension
        scope.engine->stringPrototype()->defineDefaultProperty(QStringLiteral("arg"), QV4::GlobalExtensions::method_string_arg);
    #endif
    }
 
    if (extensions.testFlag(QJSEngine::ConsoleExtension)) {
        globalObject->defineDefaultProperty(QStringLiteral("print"), QV4::ConsoleObject::method_log);
 
 
        QV4::ScopedObject console(scope, globalObject->engine()->memoryManager->allocate<QV4::ConsoleObject>());
        globalObject->defineDefaultProperty(QStringLiteral("console"), console);
    }
 
    if (extensions.testFlag(QJSEngine::GarbageCollectionExtension)) {
        globalObject->defineDefaultProperty(QStringLiteral("gc"), QV4::GlobalExtensions::method_gc);
    }
}
 
 
#if QT_CONFIG(translation)
ReturnedValue GlobalExtensions::method_qsTranslate(const FunctionObject *b, const Value *, const Value *argv, int argc)
{
    QV4::Scope scope(b);
    if (argc < 2)
        THROW_GENERIC_ERROR("qsTranslate() requires at least two arguments");
    if (!argv[0].isString())
        THROW_GENERIC_ERROR("qsTranslate(): first argument (context) must be a string");
    if (!argv[1].isString())
        THROW_GENERIC_ERROR("qsTranslate(): second argument (sourceText) must be a string");
    if ((argc > 2) && !argv[2].isString())
        THROW_GENERIC_ERROR("qsTranslate(): third argument (disambiguation) must be a string");
 
    QString context = argv[0].toQStringNoThrow();
    QString text = argv[1].toQStringNoThrow();
    QString comment;
    if (argc > 2) comment = argv[2].toQStringNoThrow();
 
    int i = 3;
    if (argc > i && argv[i].isString()) {
        qWarning("qsTranslate(): specifying the encoding as fourth argument is deprecated");
        ++i;
    }
 
    int n = -1;
    if (argc > i)
        n = argv[i].toInt32();
 
    if (QQmlEnginePrivate *ep = (scope.engine->qmlEngine() ? QQmlEnginePrivate::get(scope.engine->qmlEngine()) : nullptr))
        if (ep->propertyCapture)
            ep->propertyCapture->captureTranslation();
 
    QString result = QCoreApplication::translate(context.toUtf8().constData(),
                                                 text.toUtf8().constData(),
                                                 comment.toUtf8().constData(),
                                                 n);
 
    return Encode(scope.engine->newString(result));
}
 
ReturnedValue GlobalExtensions::method_qsTranslateNoOp(const FunctionObject *b, const Value *, const Value *argv, int argc)
{
    QV4::Scope scope(b);
    if (argc < 2)
        return QV4::Encode::undefined();
    else
        return argv[1].asReturnedValue();
}
 
QString GlobalExtensions::currentTranslationContext(ExecutionEngine *engine)
{
    QString context;
    CppStackFrame *frame = engine->currentStackFrame;
 
    // The first non-empty source URL in the call stack determines the translation context.
    while (frame && context.isEmpty()) {
        if (ExecutableCompilationUnit *unit = frame->v4Function->executableCompilationUnit()) {
            auto translationContextIndex = unit->unitData()->translationContextIndex();
            if (translationContextIndex)
                context = unit->stringAt(*translationContextIndex);
            if (!context.isEmpty())
                break;
            QString fileName = unit->fileName();
            QUrl url(unit->fileName());
            if (url.isValid() && url.isRelative()) {
                context = url.fileName();
            } else {
                context = QQmlFile::urlToLocalFileOrQrc(fileName);
                if (context.isEmpty() && fileName.startsWith(QLatin1String(":/")))
                    context = fileName;
            }
            context = QFileInfo(context).completeBaseName();
        }
        frame = frame->parentFrame();
    }
 
    if (context.isEmpty()) {
        if (QQmlRefPointer<QQmlContextData> ctxt = engine->callingQmlContext()) {
            QString path = ctxt->urlString();
            int lastSlash = path.lastIndexOf(QLatin1Char('/'));
            int lastDot = path.lastIndexOf(QLatin1Char('.'));
            int length = lastDot - (lastSlash + 1);
            context = (lastSlash > -1) ? path.mid(lastSlash + 1, (length > -1) ? length : -1) : QString();
        }
    }
 
    return context;
}
 
ReturnedValue GlobalExtensions::method_qsTr(const FunctionObject *b, const Value *, const Value *argv, int argc)
{
    QV4::Scope scope(b);
    if (argc < 1)
        THROW_GENERIC_ERROR("qsTr() requires at least one argument");
    if (!argv[0].isString())
        THROW_GENERIC_ERROR("qsTr(): first argument (sourceText) must be a string");
    if ((argc > 1) && !argv[1].isString())
        THROW_GENERIC_ERROR("qsTr(): second argument (disambiguation) must be a string");
    if ((argc > 2) && !argv[2].isNumber())
        THROW_GENERIC_ERROR("qsTr(): third argument (n) must be a number");
 
    const QString context = currentTranslationContext(scope.engine);
    const QString text = argv[0].toQStringNoThrow();
    const QString comment = argc > 1 ? argv[1].toQStringNoThrow() : QString();
    const int n = argc > 2 ? argv[2].toInt32() : -1;
 
    if (QQmlEnginePrivate *ep = (scope.engine->qmlEngine() ? QQmlEnginePrivate::get(scope.engine->qmlEngine()) : nullptr))
        if (ep->propertyCapture)
            ep->propertyCapture->captureTranslation();
 
    QString result = QCoreApplication::translate(context.toUtf8().constData(), text.toUtf8().constData(),
                                                 comment.toUtf8().constData(), n);
 
    return Encode(scope.engine->newString(result));
}
 
ReturnedValue GlobalExtensions::method_qsTrNoOp(const FunctionObject *, const Value *, const Value *argv, int argc)
{
    if (argc < 1)
        return QV4::Encode::undefined();
    else
        return argv[0].asReturnedValue();
}
 
ReturnedValue GlobalExtensions::method_qsTrId(const FunctionObject *b, const Value *, const Value *argv, int argc)
{
    QV4::Scope scope(b);
    if (argc < 1)
        THROW_GENERIC_ERROR("qsTrId() requires at least one argument");
    if (!argv[0].isString())
        THROW_TYPE_ERROR_WITH_MESSAGE("qsTrId(): first argument (id) must be a string");
    if (argc > 1 && !argv[1].isNumber())
        THROW_TYPE_ERROR_WITH_MESSAGE("qsTrId(): second argument (n) must be a number");
 
    int n = -1;
    if (argc > 1)
        n = argv[1].toInt32();
 
    if (QQmlEnginePrivate *ep = (scope.engine->qmlEngine() ? QQmlEnginePrivate::get(scope.engine->qmlEngine()) : nullptr))
        if (ep->propertyCapture)
            ep->propertyCapture->captureTranslation();
 
    return Encode(scope.engine->newString(qtTrId(argv[0].toQStringNoThrow().toUtf8().constData(), n)));
}
 
ReturnedValue GlobalExtensions::method_qsTrIdNoOp(const FunctionObject *, const Value *, const Value *argv, int argc)
{
    if (argc < 1)
        return QV4::Encode::undefined();
    else
        return argv[0].asReturnedValue();
}
#endif // translation
 
ReturnedValue GlobalExtensions::method_gc(const FunctionObject *b, const Value *, const Value *, int)
{
    auto mm = b->engine()->memoryManager;
    mm->runFullGC();
 
    return QV4::Encode::undefined();
}
 
ReturnedValue GlobalExtensions::method_string_arg(const FunctionObject *b, const Value *thisObject, const Value *argv, int argc)
{
    QV4::Scope scope(b);
    if (argc != 1)
        THROW_GENERIC_ERROR("String.arg(): Invalid arguments");
 
    QString value = thisObject->toQString();
 
    QV4::ScopedValue arg(scope, argv[0]);
    if (arg->isInteger())
        RETURN_RESULT(scope.engine->newString(value.arg(arg->integerValue())));
    else if (arg->isDouble())
        RETURN_RESULT(scope.engine->newString(value.arg(arg->doubleValue())));
    else if (arg->isBoolean())
        RETURN_RESULT(scope.engine->newString(value.arg(arg->booleanValue())));
 
    RETURN_RESULT(scope.engine->newString(value.arg(arg->toQString())));
}
 
QT_END_NAMESPACE
 
#include "moc_qqmlbuiltinfunctions_p.cpp"