Revision control
Copy as Markdown
// 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
#ifndef QJSENGINE_H
#define QJSENGINE_H
#include <QtCore/qmetatype.h>
#include <QtCore/qvariant.h>
#include <QtCore/qsharedpointer.h>
#include <QtCore/qobject.h>
#include <QtCore/qtimezone.h>
#include <QtQml/qjsvalue.h>
#include <QtQml/qjsmanagedvalue.h>
#include <QtQml/qqmldebug.h>
QT_BEGIN_NAMESPACE
template <typename T>
inline T qjsvalue_cast(const QJSValue &);
class QJSEnginePrivate;
class Q_QML_EXPORT QJSEngine
: public QObject
{
Q_OBJECT
Q_PROPERTY(QString uiLanguage READ uiLanguage WRITE setUiLanguage NOTIFY uiLanguageChanged)
public:
QJSEngine();
explicit QJSEngine(QObject *parent);
~QJSEngine() override;
QJSValue globalObject() const;
QJSValue evaluate(const QString &program, const QString &fileName = QString(), int lineNumber = 1, QStringList *exceptionStackTrace = nullptr);
QJSValue importModule(const QString &fileName);
bool registerModule(const QString &moduleName, const QJSValue &value);
QJSValue newObject();
QJSValue newSymbol(const QString &name);
QJSValue newArray(uint length = 0);
QJSValue newQObject(QObject *object);
QJSValue newQMetaObject(const QMetaObject* metaObject);
template <typename T>
QJSValue newQMetaObject()
{
return newQMetaObject(&T::staticMetaObject);
}
QJSValue newErrorObject(QJSValue::ErrorType errorType, const QString &message = QString());
template <typename T>
inline QJSValue toScriptValue(const T &value)
{
return create(QMetaType::fromType<T>(), &value);
}
template <typename T>
inline QJSManagedValue toManagedValue(const T &value)
{
return createManaged(QMetaType::fromType<T>(), &value);
}
template <typename T>
inline QJSPrimitiveValue toPrimitiveValue(const T &value)
{
// In the common case that the argument fits into QJSPrimitiveValue, use it.
if constexpr (std::disjunction_v<
std::is_same<T, int>,
std::is_same<T, bool>,
std::is_same<T, double>,
std::is_same<T, QString>>) {
return QJSPrimitiveValue(value);
} else {
return createPrimitive(QMetaType::fromType<T>(), &value);
}
}
template <typename T>
inline T fromScriptValue(const QJSValue &value)
{
return qjsvalue_cast<T>(value);
}
template <typename T>
inline T fromManagedValue(const QJSManagedValue &value)
{
return qjsvalue_cast<T>(value);
}
template <typename T>
inline T fromPrimitiveValue(const QJSPrimitiveValue &value)
{
if constexpr (std::is_same_v<T, int>)
return value.toInteger();
if constexpr (std::is_same_v<T, bool>)
return value.toBoolean();
if constexpr (std::is_same_v<T, double>)
return value.toDouble();
if constexpr (std::is_same_v<T, QString>)
return value.toString();
if constexpr (std::is_same_v<T, QVariant>)
return value.toVariant();
if constexpr (std::is_pointer_v<T>)
return nullptr;
return qjsvalue_cast<T>(value);
}
template <typename T>
inline T fromVariant(const QVariant &value)
{
// MSVC doesn't like the constexpr chains and complains about "unreachable code"
QT_WARNING_PUSH
QT_WARNING_DISABLE_MSVC(4702)
if constexpr (std::is_same_v<T, QVariant>)
return value;
const QMetaType sourceType = value.metaType();
const QMetaType targetType = QMetaType::fromType<T>();
if (sourceType == targetType)
return *reinterpret_cast<const T *>(value.constData());
if constexpr (std::is_same_v<T,std::remove_const_t<std::remove_pointer_t<T>> const *>) {
using nonConstT = std::remove_const_t<std::remove_pointer_t<T>> *;
const QMetaType nonConstTargetType = QMetaType::fromType<nonConstT>();
if (value.metaType() == nonConstTargetType)
return *reinterpret_cast<const nonConstT *>(value.constData());
}
if constexpr (std::is_same_v<T, QJSValue>)
return toScriptValue(value);
if constexpr (std::is_same_v<T, QJSManagedValue>)
return toManagedValue(value);
if constexpr (std::is_same_v<T, QJSPrimitiveValue>)
return toPrimitiveValue(value);
if constexpr (std::is_same_v<T, QString>) {
if (sourceType.flags() & QMetaType::PointerToQObject) {
return convertQObjectToString(
*reinterpret_cast<QObject *const *>(value.constData()));
}
}
if constexpr (std::is_same_v<T, double>) {
if (sourceType == QMetaType::fromType<int>())
return double(*static_cast<const int *>(value.constData()));
}
if constexpr (std::is_same_v<T, int>) {
if (sourceType == QMetaType::fromType<double>()) {
return QJSNumberCoercion::toInteger(
*static_cast<const double *>(value.constData()));
}
}
if constexpr (std::is_same_v<QObject, std::remove_const_t<std::remove_pointer_t<T>>>) {
if (sourceType.flags() & QMetaType::PointerToQObject) {
return *static_cast<QObject *const *>(value.constData());
// We should not access source->metaObject() here since that may trigger some
// rather involved code. convertVariant() can do this using property caches.
}
}
if (sourceType == QMetaType::fromType<QJSValue>())
return fromScriptValue<T>(*reinterpret_cast<const QJSValue *>(value.constData()));
if (sourceType == QMetaType::fromType<QJSManagedValue>()) {
return fromManagedValue<T>(
*reinterpret_cast<const QJSManagedValue *>(value.constData()));
}
if (sourceType == QMetaType::fromType<QJSPrimitiveValue>()) {
return fromPrimitiveValue<T>(
*reinterpret_cast<const QJSPrimitiveValue *>(value.constData()));
}
return [&] {
T t{};
if (value.metaType() == QMetaType::fromType<QString>()) {
if (convertString(value.toString(), targetType, &t))
return t;
} else if (convertVariant(value, targetType, &t)) {
return t;
}
QMetaType::convert(value.metaType(), value.constData(), targetType, &t);
return t;
}();
QT_WARNING_POP
}
template<typename From, typename To>
inline To coerceValue(const From &from)
{
if constexpr (std::is_base_of_v<To, From>)
return from;
if constexpr (std::is_same_v<To, QJSValue>)
return toScriptValue(from);
if constexpr (std::is_same_v<From, QJSValue>)
return fromScriptValue<To>(from);
if constexpr (std::is_same_v<To, QJSManagedValue>)
return toManagedValue(from);
if constexpr (std::is_same_v<From, QJSManagedValue>)
return fromManagedValue<To>(from);
if constexpr (std::is_same_v<To, QJSPrimitiveValue>)
return toPrimitiveValue(from);
if constexpr (std::is_same_v<From, QJSPrimitiveValue>)
return fromPrimitiveValue<To>(from);
if constexpr (std::is_same_v<From, QVariant>)
return fromVariant<To>(from);
if constexpr (std::is_same_v<To, QVariant>)
return QVariant::fromValue(from);
if constexpr (std::is_same_v<To, QString>) {
if constexpr (std::is_base_of_v<QObject, std::remove_const_t<std::remove_pointer_t<From>>>)
return convertQObjectToString(from);
}
if constexpr (std::is_same_v<From, QDateTime>) {
if constexpr (std::is_same_v<To, QDate>)
return convertDateTimeToDate(from.toLocalTime());
if constexpr (std::is_same_v<To, QTime>)
return from.toLocalTime().time();
if constexpr (std::is_same_v<To, QString>)
return convertDateTimeToString(from.toLocalTime());
if constexpr (std::is_same_v<To, double>)
return convertDateTimeToNumber(from.toLocalTime());
}
if constexpr (std::is_same_v<From, QDate>) {
if constexpr (std::is_same_v<To, QDateTime>)
return from.startOfDay(QTimeZone::UTC);
if constexpr (std::is_same_v<To, QTime>) {
// This is the current time zone offset, for better or worse
return coerceValue<QDateTime, QTime>(coerceValue<QDate, QDateTime>(from));
}
if constexpr (std::is_same_v<To, QString>)
return convertDateTimeToString(coerceValue<QDate, QDateTime>(from));
if constexpr (std::is_same_v<To, double>)
return convertDateTimeToNumber(coerceValue<QDate, QDateTime>(from));
}
if constexpr (std::is_same_v<From, QTime>) {
if constexpr (std::is_same_v<To, QDate>) {
// Yes. April Fools' 1971. See qv4dateobject.cpp.
return from.isValid() ? QDate(1971, 4, 1) : QDate();
}
if constexpr (std::is_same_v<To, QDateTime>)
return QDateTime(coerceValue<QTime, QDate>(from), from, QTimeZone::LocalTime);
if constexpr (std::is_same_v<To, QString>)
return convertDateTimeToString(coerceValue<QTime, QDateTime>(from));
if constexpr (std::is_same_v<To, double>)
return convertDateTimeToNumber(coerceValue<QTime, QDateTime>(from));
}
if constexpr (std::is_same_v<To, std::remove_const_t<std::remove_pointer_t<To>> const *>) {
using nonConstTo = std::remove_const_t<std::remove_pointer_t<To>> *;
if constexpr (std::is_same_v<From, nonConstTo>)
return from;
}
if constexpr (std::is_same_v<To, double>) {
if constexpr (std::is_same_v<From, int>)
return double(from);
}
if constexpr (std::is_same_v<To, int>) {
if constexpr (std::is_same_v<From, double>)
return QJSNumberCoercion::toInteger(from);
}
return [&] {
const QMetaType sourceType = QMetaType::fromType<From>();
const QMetaType targetType = QMetaType::fromType<To>();
To to{};
if constexpr (std::is_same_v<From, QString>) {
if (convertString(from, targetType, &to))
return to;
} else if (convertMetaType(sourceType, &from, targetType, &to)) {
return to;
}
QMetaType::convert(sourceType, &from, targetType, &to);
return to;
}();
}
void collectGarbage();
enum ObjectOwnership { CppOwnership, JavaScriptOwnership };
static void setObjectOwnership(QObject *, ObjectOwnership);
static ObjectOwnership objectOwnership(QObject *);
enum Extension {
TranslationExtension = 0x1,
ConsoleExtension = 0x2,
GarbageCollectionExtension = 0x4,
AllExtensions = 0xffffffff
};
Q_DECLARE_FLAGS(Extensions, Extension)
void installExtensions(Extensions extensions, const QJSValue &object = QJSValue());
void setInterrupted(bool interrupted);
bool isInterrupted() const;
QV4::ExecutionEngine *handle() const { return m_v4Engine; }
void throwError(const QString &message);
void throwError(QJSValue::ErrorType errorType, const QString &message = QString());
void throwError(const QJSValue &error);
bool hasError() const;
QJSValue catchError();
QString uiLanguage() const;
void setUiLanguage(const QString &language);
Q_SIGNALS:
void uiLanguageChanged();
private:
QJSPrimitiveValue createPrimitive(QMetaType type, const void *ptr);
QJSManagedValue createManaged(QMetaType type, const void *ptr);
QJSValue create(QMetaType type, const void *ptr);
#if QT_QML_REMOVED_SINCE(6, 5)
QJSValue create(int id, const void *ptr); // only there for BC reasons
#endif
static bool convertPrimitive(const QJSPrimitiveValue &value, QMetaType type, void *ptr);
static bool convertManaged(const QJSManagedValue &value, int type, void *ptr);
static bool convertManaged(const QJSManagedValue &value, QMetaType type, void *ptr);
#if QT_QML_REMOVED_SINCE(6, 5)
static bool convertV2(const QJSValue &value, int type, void *ptr); // only there for BC reasons
#endif
static bool convertV2(const QJSValue &value, QMetaType metaType, void *ptr);
static bool convertString(const QString &string, QMetaType metaType, void *ptr);
bool convertVariant(const QVariant &value, QMetaType metaType, void *ptr);
bool convertMetaType(QMetaType fromType, const void *from, QMetaType toType, void *to);
QString convertQObjectToString(QObject *object);
QString convertDateTimeToString(const QDateTime &dateTime);
double convertDateTimeToNumber(const QDateTime &dateTime);
static QDate convertDateTimeToDate(const QDateTime &dateTime);
template<typename T>
friend inline T qjsvalue_cast(const QJSValue &);
template<typename T>
friend inline T qjsvalue_cast(const QJSManagedValue &);
template<typename T>
friend inline T qjsvalue_cast(const QJSPrimitiveValue &);
protected:
QJSEngine(QJSEnginePrivate &dd, QObject *parent = nullptr);
private:
QV4::ExecutionEngine *m_v4Engine;
Q_DISABLE_COPY(QJSEngine)
Q_DECLARE_PRIVATE(QJSEngine)
};
Q_DECLARE_OPERATORS_FOR_FLAGS(QJSEngine::Extensions)
template<typename T>
T qjsvalue_cast(const QJSValue &value)
{
if (T t; QJSEngine::convertV2(value, QMetaType::fromType<T>(), &t))
return t;
return qvariant_cast<T>(value.toVariant());
}
template<typename T>
T qjsvalue_cast(const QJSManagedValue &value)
{
if (T t; QJSEngine::convertManaged(value, QMetaType::fromType<T>(), &t))
return t;
return qvariant_cast<T>(value.toVariant());
}
template<typename T>
T qjsvalue_cast(const QJSPrimitiveValue &value)
{
if (T t; QJSEngine::convertPrimitive(value, QMetaType::fromType<T>(), &t))
return t;
return qvariant_cast<T>(value.toVariant());
}
template <>
inline QVariant qjsvalue_cast<QVariant>(const QJSValue &value)
{
return value.toVariant();
}
template <>
inline QVariant qjsvalue_cast<QVariant>(const QJSManagedValue &value)
{
return value.toVariant();
}
template <>
inline QVariant qjsvalue_cast<QVariant>(const QJSPrimitiveValue &value)
{
return value.toVariant();
}
Q_QML_EXPORT QJSEngine *qjsEngine(const QObject *);
QT_END_NAMESPACE
#endif // QJSENGINE_H