From 8bb376798e6f2d7582472c5d3650c59973713398 Mon Sep 17 00:00:00 2001 From: John Preston Date: Tue, 14 Jul 2015 16:18:37 +0300 Subject: [PATCH] removed old warning disable for clang --- Telegram/_qt_5_5_0_patch.diff | 13 + .../qtbase/src/corelib/kernel/qobjectdefs.h | 509 ++++++++++++++++++ 2 files changed, 522 insertions(+) create mode 100644 Telegram/_qt_5_5_0_patch/qtbase/src/corelib/kernel/qobjectdefs.h diff --git a/Telegram/_qt_5_5_0_patch.diff b/Telegram/_qt_5_5_0_patch.diff index 9911188f6..edce3fe02 100644 --- a/Telegram/_qt_5_5_0_patch.diff +++ b/Telegram/_qt_5_5_0_patch.diff @@ -64,6 +64,19 @@ index 0907653..96f6e19 100644 { /* High surrogate. Must be a followed by a low surrogate. */ if (length == 0) +diff --git a/qtbase/src/corelib/kernel/qobjectdefs.h b/qtbase/src/corelib/kernel/qobjectdefs.h +index 4d01264..fd3854f 100644 +--- a/qtbase/src/corelib/kernel/qobjectdefs.h ++++ b/qtbase/src/corelib/kernel/qobjectdefs.h +@@ -142,7 +142,7 @@ inline void qYouForgotTheQ_OBJECT_Macro(T1, T2) {} + # define Q_DECL_HIDDEN_STATIC_METACALL Q_DECL_HIDDEN + #endif + +-#if defined(Q_CC_CLANG) && Q_CC_CLANG >= 306 ++#if defined(Q_CC_CLANG) && Q_CC_CLANG >= 306 && false + # define Q_OBJECT_NO_OVERRIDE_WARNING QT_WARNING_DISABLE_CLANG("-Winconsistent-missing-override") + #else + # define Q_OBJECT_NO_OVERRIDE_WARNING diff --git a/qtbase/src/corelib/tools/qunicodetables.cpp b/qtbase/src/corelib/tools/qunicodetables.cpp index 73dce81..76c6933 100644 --- a/qtbase/src/corelib/tools/qunicodetables.cpp diff --git a/Telegram/_qt_5_5_0_patch/qtbase/src/corelib/kernel/qobjectdefs.h b/Telegram/_qt_5_5_0_patch/qtbase/src/corelib/kernel/qobjectdefs.h new file mode 100644 index 000000000..fd3854fd5 --- /dev/null +++ b/Telegram/_qt_5_5_0_patch/qtbase/src/corelib/kernel/qobjectdefs.h @@ -0,0 +1,509 @@ +/**************************************************************************** +** +** Copyright (C) 2015 The Qt Company Ltd. +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL21$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see http://www.qt.io/terms-conditions. For further +** information use the contact form at http://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 or version 3 as published by the Free +** Software Foundation and appearing in the file LICENSE.LGPLv21 and +** LICENSE.LGPLv3 included in the packaging of this file. Please review the +** following information to ensure the GNU Lesser General Public License +** requirements will be met: https://www.gnu.org/licenses/lgpl.html and +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** As a special exception, The Qt Company gives you certain additional +** rights. These rights are described in The Qt Company LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QOBJECTDEFS_H +#define QOBJECTDEFS_H + +#if defined(__OBJC__) && !defined(__cplusplus) +# warning "File built in Objective-C mode (.m), but using Qt requires Objective-C++ (.mm)" +#endif + +#include + +#include + +QT_BEGIN_NAMESPACE + + +class QByteArray; +struct QArrayData; +typedef QArrayData QByteArrayData; + +class QString; + +#ifndef Q_MOC_OUTPUT_REVISION +#define Q_MOC_OUTPUT_REVISION 67 +#endif + +// The following macros are our "extensions" to C++ +// They are used, strictly speaking, only by the moc. + +#ifndef Q_MOC_RUN +#ifndef QT_NO_META_MACROS +# if defined(QT_NO_KEYWORDS) +# define QT_NO_EMIT +# else +# ifndef QT_NO_SIGNALS_SLOTS_KEYWORDS +# define slots +# define signals public +# endif +# endif +# define Q_SLOTS +# define Q_SIGNALS public +# define Q_PRIVATE_SLOT(d, signature) +# define Q_EMIT +#ifndef QT_NO_EMIT +# define emit +#endif +#define Q_CLASSINFO(name, value) +#define Q_PLUGIN_METADATA(x) +#define Q_INTERFACES(x) +#define Q_PROPERTY(text) +#define Q_PRIVATE_PROPERTY(d, text) +#define Q_REVISION(v) +#define Q_OVERRIDE(text) +#define Q_ENUMS(x) +#define Q_FLAGS(x) +#define Q_ENUM(ENUM) \ + friend Q_DECL_CONSTEXPR const QMetaObject *qt_getEnumMetaObject(ENUM) Q_DECL_NOEXCEPT { return &staticMetaObject; } \ + friend Q_DECL_CONSTEXPR const char *qt_getEnumName(ENUM) Q_DECL_NOEXCEPT { return #ENUM; } +#define Q_FLAG(ENUM) Q_ENUM(ENUM) +#define Q_SCRIPTABLE +#define Q_INVOKABLE +#define Q_SIGNAL +#define Q_SLOT +#endif // QT_NO_META_MACROS + +#ifndef QT_NO_TRANSLATION +// full set of tr functions +# define QT_TR_FUNCTIONS \ + static inline QString tr(const char *s, const char *c = Q_NULLPTR, int n = -1) \ + { return staticMetaObject.tr(s, c, n); } \ + QT_DEPRECATED static inline QString trUtf8(const char *s, const char *c = Q_NULLPTR, int n = -1) \ + { return staticMetaObject.tr(s, c, n); } +#else +// inherit the ones from QObject +# define QT_TR_FUNCTIONS +#endif + +#if defined(QT_NO_QOBJECT_CHECK) +/* qmake ignore Q_OBJECT */ +#define Q_OBJECT_CHECK +#else + +/* This is a compile time check that ensures that any class cast with qobject_cast + actually contains a Q_OBJECT macro. Note: qobject_cast will fail if a QObject + subclass doesn't contain Q_OBJECT. + + In qt_check_for_QOBJECT_macro, we call a dummy templated function with two + parameters, the first being "this" and the other the target of the qobject + cast. If the types are not identical, we know that a Q_OBJECT macro is missing. + + If you get a compiler error here, make sure that the class you are casting + to contains a Q_OBJECT macro. +*/ + +/* qmake ignore Q_OBJECT */ +#define Q_OBJECT_CHECK \ + template inline void qt_check_for_QOBJECT_macro(const ThisObject &_q_argument) const \ + { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i + 1; } + +template +inline int qYouForgotTheQ_OBJECT_Macro(T, T) { return 0; } + +template +inline void qYouForgotTheQ_OBJECT_Macro(T1, T2) {} +#endif // QT_NO_QOBJECT_CHECK + +#if defined(Q_CC_INTEL) +// Cannot redefine the visibility of a method in an exported class +# define Q_DECL_HIDDEN_STATIC_METACALL +#else +# define Q_DECL_HIDDEN_STATIC_METACALL Q_DECL_HIDDEN +#endif + +#if defined(Q_CC_CLANG) && Q_CC_CLANG >= 306 && false +# define Q_OBJECT_NO_OVERRIDE_WARNING QT_WARNING_DISABLE_CLANG("-Winconsistent-missing-override") +#else +# define Q_OBJECT_NO_OVERRIDE_WARNING +#endif + +/* qmake ignore Q_OBJECT */ +#define Q_OBJECT \ +public: \ + Q_OBJECT_CHECK \ + QT_WARNING_PUSH \ + Q_OBJECT_NO_OVERRIDE_WARNING \ + static const QMetaObject staticMetaObject; \ + virtual const QMetaObject *metaObject() const; \ + virtual void *qt_metacast(const char *); \ + virtual int qt_metacall(QMetaObject::Call, int, void **); \ + QT_WARNING_POP \ + QT_TR_FUNCTIONS \ +private: \ + Q_DECL_HIDDEN_STATIC_METACALL static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); \ + struct QPrivateSignal {}; + +/* qmake ignore Q_OBJECT */ +#define Q_OBJECT_FAKE Q_OBJECT + +#ifndef QT_NO_META_MACROS +/* qmake ignore Q_GADGET */ +#define Q_GADGET \ +public: \ + static const QMetaObject staticMetaObject; \ + void qt_check_for_QGADGET_macro(); \ + typedef void QtGadgetHelper; \ +private: \ + Q_DECL_HIDDEN_STATIC_METACALL static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); +#endif // QT_NO_META_MACROS + +#else // Q_MOC_RUN +#define slots slots +#define signals signals +#define Q_SLOTS Q_SLOTS +#define Q_SIGNALS Q_SIGNALS +#define Q_CLASSINFO(name, value) Q_CLASSINFO(name, value) +#define Q_INTERFACES(x) Q_INTERFACES(x) +#define Q_PROPERTY(text) Q_PROPERTY(text) +#define Q_PRIVATE_PROPERTY(d, text) Q_PRIVATE_PROPERTY(d, text) +#define Q_REVISION(v) Q_REVISION(v) +#define Q_OVERRIDE(text) Q_OVERRIDE(text) +#define Q_ENUMS(x) Q_ENUMS(x) +#define Q_FLAGS(x) Q_FLAGS(x) +#define Q_ENUM(x) Q_ENUM(x) +#define Q_FLAGS(x) Q_FLAGS(x) + /* qmake ignore Q_OBJECT */ +#define Q_OBJECT Q_OBJECT + /* qmake ignore Q_OBJECT */ +#define Q_OBJECT_FAKE Q_OBJECT_FAKE + /* qmake ignore Q_GADGET */ +#define Q_GADGET Q_GADGET +#define Q_SCRIPTABLE Q_SCRIPTABLE +#define Q_INVOKABLE Q_INVOKABLE +#define Q_SIGNAL Q_SIGNAL +#define Q_SLOT Q_SLOT +#endif //Q_MOC_RUN + +#ifndef QT_NO_META_MACROS +// macro for onaming members +#ifdef METHOD +#undef METHOD +#endif +#ifdef SLOT +#undef SLOT +#endif +#ifdef SIGNAL +#undef SIGNAL +#endif +#endif // QT_NO_META_MACROS + +Q_CORE_EXPORT const char *qFlagLocation(const char *method); + +#ifndef QT_NO_META_MACROS +#ifndef QT_NO_DEBUG +# define QLOCATION "\0" __FILE__ ":" QT_STRINGIFY(__LINE__) +# ifndef QT_NO_KEYWORDS +# define METHOD(a) qFlagLocation("0"#a QLOCATION) +# endif +# define SLOT(a) qFlagLocation("1"#a QLOCATION) +# define SIGNAL(a) qFlagLocation("2"#a QLOCATION) +#else +# ifndef QT_NO_KEYWORDS +# define METHOD(a) "0"#a +# endif +# define SLOT(a) "1"#a +# define SIGNAL(a) "2"#a +#endif + +#define QMETHOD_CODE 0 // member type codes +#define QSLOT_CODE 1 +#define QSIGNAL_CODE 2 +#endif // QT_NO_META_MACROS + +#define Q_ARG(type, data) QArgument(#type, data) +#define Q_RETURN_ARG(type, data) QReturnArgument(#type, data) + +class QObject; +class QMetaMethod; +class QMetaEnum; +class QMetaProperty; +class QMetaClassInfo; + + +class Q_CORE_EXPORT QGenericArgument +{ +public: + inline QGenericArgument(const char *aName = 0, const void *aData = 0) + : _data(aData), _name(aName) {} + inline void *data() const { return const_cast(_data); } + inline const char *name() const { return _name; } + +private: + const void *_data; + const char *_name; +}; + +class Q_CORE_EXPORT QGenericReturnArgument: public QGenericArgument +{ +public: + inline QGenericReturnArgument(const char *aName = 0, void *aData = 0) + : QGenericArgument(aName, aData) + {} +}; + +template +class QArgument: public QGenericArgument +{ +public: + inline QArgument(const char *aName, const T &aData) + : QGenericArgument(aName, static_cast(&aData)) + {} +}; +template +class QArgument: public QGenericArgument +{ +public: + inline QArgument(const char *aName, T &aData) + : QGenericArgument(aName, static_cast(&aData)) + {} +}; + + +template +class QReturnArgument: public QGenericReturnArgument +{ +public: + inline QReturnArgument(const char *aName, T &aData) + : QGenericReturnArgument(aName, static_cast(&aData)) + {} +}; + +struct Q_CORE_EXPORT QMetaObject +{ + class Connection; + const char *className() const; + const QMetaObject *superClass() const; + + QObject *cast(QObject *obj) const; + const QObject *cast(const QObject *obj) const; + +#ifndef QT_NO_TRANSLATION + QString tr(const char *s, const char *c, int n = -1) const; +#endif // QT_NO_TRANSLATION + + int methodOffset() const; + int enumeratorOffset() const; + int propertyOffset() const; + int classInfoOffset() const; + + int constructorCount() const; + int methodCount() const; + int enumeratorCount() const; + int propertyCount() const; + int classInfoCount() const; + + int indexOfConstructor(const char *constructor) const; + int indexOfMethod(const char *method) const; + int indexOfSignal(const char *signal) const; + int indexOfSlot(const char *slot) const; + int indexOfEnumerator(const char *name) const; + int indexOfProperty(const char *name) const; + int indexOfClassInfo(const char *name) const; + + QMetaMethod constructor(int index) const; + QMetaMethod method(int index) const; + QMetaEnum enumerator(int index) const; + QMetaProperty property(int index) const; + QMetaClassInfo classInfo(int index) const; + QMetaProperty userProperty() const; + + static bool checkConnectArgs(const char *signal, const char *method); + static bool checkConnectArgs(const QMetaMethod &signal, + const QMetaMethod &method); + static QByteArray normalizedSignature(const char *method); + static QByteArray normalizedType(const char *type); + + // internal index-based connect + static Connection connect(const QObject *sender, int signal_index, + const QObject *receiver, int method_index, + int type = 0, int *types = 0); + // internal index-based disconnect + static bool disconnect(const QObject *sender, int signal_index, + const QObject *receiver, int method_index); + static bool disconnectOne(const QObject *sender, int signal_index, + const QObject *receiver, int method_index); + // internal slot-name based connect + static void connectSlotsByName(QObject *o); + + // internal index-based signal activation + static void activate(QObject *sender, int signal_index, void **argv); + static void activate(QObject *sender, const QMetaObject *, int local_signal_index, void **argv); + static void activate(QObject *sender, int signal_offset, int local_signal_index, void **argv); + + static bool invokeMethod(QObject *obj, const char *member, + Qt::ConnectionType, + QGenericReturnArgument ret, + QGenericArgument val0 = QGenericArgument(0), + QGenericArgument val1 = QGenericArgument(), + QGenericArgument val2 = QGenericArgument(), + QGenericArgument val3 = QGenericArgument(), + QGenericArgument val4 = QGenericArgument(), + QGenericArgument val5 = QGenericArgument(), + QGenericArgument val6 = QGenericArgument(), + QGenericArgument val7 = QGenericArgument(), + QGenericArgument val8 = QGenericArgument(), + QGenericArgument val9 = QGenericArgument()); + + static inline bool invokeMethod(QObject *obj, const char *member, + QGenericReturnArgument ret, + QGenericArgument val0 = QGenericArgument(0), + QGenericArgument val1 = QGenericArgument(), + QGenericArgument val2 = QGenericArgument(), + QGenericArgument val3 = QGenericArgument(), + QGenericArgument val4 = QGenericArgument(), + QGenericArgument val5 = QGenericArgument(), + QGenericArgument val6 = QGenericArgument(), + QGenericArgument val7 = QGenericArgument(), + QGenericArgument val8 = QGenericArgument(), + QGenericArgument val9 = QGenericArgument()) + { + return invokeMethod(obj, member, Qt::AutoConnection, ret, val0, val1, val2, val3, + val4, val5, val6, val7, val8, val9); + } + + static inline bool invokeMethod(QObject *obj, const char *member, + Qt::ConnectionType type, + QGenericArgument val0 = QGenericArgument(0), + QGenericArgument val1 = QGenericArgument(), + QGenericArgument val2 = QGenericArgument(), + QGenericArgument val3 = QGenericArgument(), + QGenericArgument val4 = QGenericArgument(), + QGenericArgument val5 = QGenericArgument(), + QGenericArgument val6 = QGenericArgument(), + QGenericArgument val7 = QGenericArgument(), + QGenericArgument val8 = QGenericArgument(), + QGenericArgument val9 = QGenericArgument()) + { + return invokeMethod(obj, member, type, QGenericReturnArgument(), val0, val1, val2, + val3, val4, val5, val6, val7, val8, val9); + } + + static inline bool invokeMethod(QObject *obj, const char *member, + QGenericArgument val0 = QGenericArgument(0), + QGenericArgument val1 = QGenericArgument(), + QGenericArgument val2 = QGenericArgument(), + QGenericArgument val3 = QGenericArgument(), + QGenericArgument val4 = QGenericArgument(), + QGenericArgument val5 = QGenericArgument(), + QGenericArgument val6 = QGenericArgument(), + QGenericArgument val7 = QGenericArgument(), + QGenericArgument val8 = QGenericArgument(), + QGenericArgument val9 = QGenericArgument()) + { + return invokeMethod(obj, member, Qt::AutoConnection, QGenericReturnArgument(), val0, + val1, val2, val3, val4, val5, val6, val7, val8, val9); + } + + QObject *newInstance(QGenericArgument val0 = QGenericArgument(0), + QGenericArgument val1 = QGenericArgument(), + QGenericArgument val2 = QGenericArgument(), + QGenericArgument val3 = QGenericArgument(), + QGenericArgument val4 = QGenericArgument(), + QGenericArgument val5 = QGenericArgument(), + QGenericArgument val6 = QGenericArgument(), + QGenericArgument val7 = QGenericArgument(), + QGenericArgument val8 = QGenericArgument(), + QGenericArgument val9 = QGenericArgument()) const; + + enum Call { + InvokeMetaMethod, + ReadProperty, + WriteProperty, + ResetProperty, + QueryPropertyDesignable, + QueryPropertyScriptable, + QueryPropertyStored, + QueryPropertyEditable, + QueryPropertyUser, + CreateInstance, + IndexOfMethod, + RegisterPropertyMetaType, + RegisterMethodArgumentMetaType + }; + + int static_metacall(Call, int, void **) const; + static int metacall(QObject *, Call, int, void **); + + struct { // private data + const QMetaObject *superdata; + const QByteArrayData *stringdata; + const uint *data; + typedef void (*StaticMetacallFunction)(QObject *, QMetaObject::Call, int, void **); + StaticMetacallFunction static_metacall; + const QMetaObject * const *relatedMetaObjects; + void *extradata; //reserved for future use + } d; +}; + +class Q_CORE_EXPORT QMetaObject::Connection { + void *d_ptr; //QObjectPrivate::Connection* + explicit Connection(void *data) : d_ptr(data) { } + friend class QObject; + friend class QObjectPrivate; + friend struct QMetaObject; +public: + ~Connection(); + Connection(); + Connection(const Connection &other); + Connection &operator=(const Connection &other); +#ifdef Q_QDOC + operator bool() const; +#else + typedef void *Connection::*RestrictedBool; + operator RestrictedBool() const { return d_ptr ? &Connection::d_ptr : 0; } +#endif + +#ifdef Q_COMPILER_RVALUE_REFS + inline Connection(Connection &&o) : d_ptr(o.d_ptr) { o.d_ptr = 0; } + inline Connection &operator=(Connection &&other) + { qSwap(d_ptr, other.d_ptr); return *this; } +#endif +}; + +inline const QMetaObject *QMetaObject::superClass() const +{ return d.superdata; } + +namespace QtPrivate { + /* Trait that tells is a the Object has a Q_OBJECT macro */ + template struct HasQ_OBJECT_Macro { + template + static char test(int (T::*)(QMetaObject::Call, int, void **)); + static int test(int (Object::*)(QMetaObject::Call, int, void **)); + enum { Value = sizeof(test(&Object::qt_metacall)) == sizeof(int) }; + }; +} + +QT_END_NAMESPACE + +#endif // QOBJECTDEFS_H