1/****************************************************************************
2**
3** Copyright (C) 2016 The Qt Company Ltd.
4** Copyright (C) 2016 Intel Corporation.
5** Contact: https://www.qt.io/licensing/
6**
7** This file is part of the QtCore module of the Qt Toolkit.
8**
9** $QT_BEGIN_LICENSE:LGPL$
10** Commercial License Usage
11** Licensees holding valid commercial Qt licenses may use this file in
12** accordance with the commercial license agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and The Qt Company. For licensing terms
15** and conditions see https://www.qt.io/terms-conditions. For further
16** information use the contact form at https://www.qt.io/contact-us.
17**
18** GNU Lesser General Public License Usage
19** Alternatively, this file may be used under the terms of the GNU Lesser
20** General Public License version 3 as published by the Free Software
21** Foundation and appearing in the file LICENSE.LGPL3 included in the
22** packaging of this file. Please review the following information to
23** ensure the GNU Lesser General Public License version 3 requirements
24** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
25**
26** GNU General Public License Usage
27** Alternatively, this file may be used under the terms of the GNU
28** General Public License version 2.0 or (at your option) the GNU General
29** Public license version 3 or any later version approved by the KDE Free
30** Qt Foundation. The licenses are as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
32** included in the packaging of this file. Please review the following
33** information to ensure the GNU General Public License requirements will
34** be met: https://www.gnu.org/licenses/gpl-2.0.html and
35** https://www.gnu.org/licenses/gpl-3.0.html.
36**
37** $QT_END_LICENSE$
38**
39****************************************************************************/
40
41#ifndef QGLOBAL_H
42#define QGLOBAL_H
43
44#ifdef __cplusplus
45# include <type_traits>
46# include <cstddef>
47# include <utility>
48#endif
49#ifndef __ASSEMBLER__
50# include <stddef.h>
51#endif
52
53/*
54 QT_VERSION is (major << 16) + (minor << 8) + patch.
55*/
56#define QT_VERSION QT_VERSION_CHECK(QT_VERSION_MAJOR, QT_VERSION_MINOR, QT_VERSION_PATCH)
57/*
58 can be used like #if (QT_VERSION >= QT_VERSION_CHECK(4, 4, 0))
59*/
60#define QT_VERSION_CHECK(major, minor, patch) ((major<<16)|(minor<<8)|(patch))
61
62#ifdef QT_BOOTSTRAPPED
63#include <QtCore/qconfig-bootstrapped.h>
64#else
65#include <QtCore/qconfig.h>
66#include <QtCore/qtcore-config.h>
67#endif
68
69// The QT_SUPPORTS macro is deprecated. Don't use it in new code.
70// Instead, use QT_CONFIG(feature)
71// ### Qt6: remove macro
72#ifdef _MSC_VER
73# define QT_SUPPORTS(FEATURE) (!defined QT_NO_##FEATURE)
74#else
75# define QT_SUPPORTS(FEATURE) (!defined(QT_NO_##FEATURE))
76#endif
77
78/*
79 The QT_CONFIG macro implements a safe compile time check for features of Qt.
80 Features can be in three states:
81 0 or undefined: This will lead to a compile error when testing for it
82 -1: The feature is not available
83 1: The feature is available
84*/
85#define QT_CONFIG(feature) (1/QT_FEATURE_##feature == 1)
86#define QT_REQUIRE_CONFIG(feature) Q_STATIC_ASSERT_X(QT_FEATURE_##feature == 1, "Required feature " #feature " for file " __FILE__ " not available.")
87
88#if QT_VERSION >= QT_VERSION_CHECK(6,0,0)
89# define QT_NO_UNSHARABLE_CONTAINERS
90#endif
91
92/* These two macros makes it possible to turn the builtin line expander into a
93 * string literal. */
94#define QT_STRINGIFY2(x) #x
95#define QT_STRINGIFY(x) QT_STRINGIFY2(x)
96
97#include <QtCore/qsystemdetection.h>
98#include <QtCore/qprocessordetection.h>
99#include <QtCore/qcompilerdetection.h>
100
101#if defined (__ELF__)
102# define Q_OF_ELF
103#endif
104#if defined (__MACH__) && defined (__APPLE__)
105# define Q_OF_MACH_O
106#endif
107
108#ifdef __cplusplus
109
110#include <algorithm>
111
112#if !defined(QT_NAMESPACE) || defined(Q_MOC_RUN) /* user namespace */
113
114# define QT_PREPEND_NAMESPACE(name) ::name
115# define QT_USE_NAMESPACE
116# define QT_BEGIN_NAMESPACE
117# define QT_END_NAMESPACE
118# define QT_BEGIN_INCLUDE_NAMESPACE
119# define QT_END_INCLUDE_NAMESPACE
120#ifndef QT_BEGIN_MOC_NAMESPACE
121# define QT_BEGIN_MOC_NAMESPACE
122#endif
123#ifndef QT_END_MOC_NAMESPACE
124# define QT_END_MOC_NAMESPACE
125#endif
126# define QT_FORWARD_DECLARE_CLASS(name) class name;
127# define QT_FORWARD_DECLARE_STRUCT(name) struct name;
128# define QT_MANGLE_NAMESPACE(name) name
129
130#else /* user namespace */
131
132# define QT_PREPEND_NAMESPACE(name) ::QT_NAMESPACE::name
133# define QT_USE_NAMESPACE using namespace ::QT_NAMESPACE;
134# define QT_BEGIN_NAMESPACE namespace QT_NAMESPACE {
135# define QT_END_NAMESPACE }
136# define QT_BEGIN_INCLUDE_NAMESPACE }
137# define QT_END_INCLUDE_NAMESPACE namespace QT_NAMESPACE {
138#ifndef QT_BEGIN_MOC_NAMESPACE
139# define QT_BEGIN_MOC_NAMESPACE QT_USE_NAMESPACE
140#endif
141#ifndef QT_END_MOC_NAMESPACE
142# define QT_END_MOC_NAMESPACE
143#endif
144# define QT_FORWARD_DECLARE_CLASS(name) \
145 QT_BEGIN_NAMESPACE class name; QT_END_NAMESPACE \
146 using QT_PREPEND_NAMESPACE(name);
147
148# define QT_FORWARD_DECLARE_STRUCT(name) \
149 QT_BEGIN_NAMESPACE struct name; QT_END_NAMESPACE \
150 using QT_PREPEND_NAMESPACE(name);
151
152# define QT_MANGLE_NAMESPACE0(x) x
153# define QT_MANGLE_NAMESPACE1(a, b) a##_##b
154# define QT_MANGLE_NAMESPACE2(a, b) QT_MANGLE_NAMESPACE1(a,b)
155# define QT_MANGLE_NAMESPACE(name) QT_MANGLE_NAMESPACE2( \
156 QT_MANGLE_NAMESPACE0(name), QT_MANGLE_NAMESPACE0(QT_NAMESPACE))
157
158namespace QT_NAMESPACE {}
159
160# ifndef QT_BOOTSTRAPPED
161# ifndef QT_NO_USING_NAMESPACE
162 /*
163 This expands to a "using QT_NAMESPACE" also in _header files_.
164 It is the only way the feature can be used without too much
165 pain, but if people _really_ do not want it they can add
166 DEFINES += QT_NO_USING_NAMESPACE to their .pro files.
167 */
168 QT_USE_NAMESPACE
169# endif
170# endif
171
172#endif /* user namespace */
173
174#else /* __cplusplus */
175
176# define QT_BEGIN_NAMESPACE
177# define QT_END_NAMESPACE
178# define QT_USE_NAMESPACE
179# define QT_BEGIN_INCLUDE_NAMESPACE
180# define QT_END_INCLUDE_NAMESPACE
181
182#endif /* __cplusplus */
183
184// ### Qt6: remove me.
185#define QT_BEGIN_HEADER
186#define QT_END_HEADER
187
188#if defined(Q_OS_DARWIN) && !defined(QT_LARGEFILE_SUPPORT)
189# define QT_LARGEFILE_SUPPORT 64
190#endif
191
192#ifndef __ASSEMBLER__
193QT_BEGIN_NAMESPACE
194
195/*
196 Size-dependent types (architechture-dependent byte order)
197
198 Make sure to update QMetaType when changing these typedefs
199*/
200
201typedef signed char qint8; /* 8 bit signed */
202typedef unsigned char quint8; /* 8 bit unsigned */
203typedef short qint16; /* 16 bit signed */
204typedef unsigned short quint16; /* 16 bit unsigned */
205typedef int qint32; /* 32 bit signed */
206typedef unsigned int quint32; /* 32 bit unsigned */
207#if defined(Q_OS_WIN) && !defined(Q_CC_GNU)
208# define Q_INT64_C(c) c ## i64 /* signed 64 bit constant */
209# define Q_UINT64_C(c) c ## ui64 /* unsigned 64 bit constant */
210typedef __int64 qint64; /* 64 bit signed */
211typedef unsigned __int64 quint64; /* 64 bit unsigned */
212#else
213# define Q_INT64_C(c) static_cast<long long>(c ## LL) /* signed 64 bit constant */
214# define Q_UINT64_C(c) static_cast<unsigned long long>(c ## ULL) /* unsigned 64 bit constant */
215typedef long long qint64; /* 64 bit signed */
216typedef unsigned long long quint64; /* 64 bit unsigned */
217#endif
218
219typedef qint64 qlonglong;
220typedef quint64 qulonglong;
221
222/*
223 Useful type definitions for Qt
224*/
225
226QT_BEGIN_INCLUDE_NAMESPACE
227typedef unsigned char uchar;
228typedef unsigned short ushort;
229typedef unsigned int uint;
230typedef unsigned long ulong;
231QT_END_INCLUDE_NAMESPACE
232
233#if defined(QT_COORD_TYPE)
234typedef QT_COORD_TYPE qreal;
235#else
236typedef double qreal;
237#endif
238
239#if defined(QT_NO_DEPRECATED)
240# undef QT_DEPRECATED
241# undef QT_DEPRECATED_X
242# undef QT_DEPRECATED_VARIABLE
243# undef QT_DEPRECATED_CONSTRUCTOR
244#elif defined(QT_DEPRECATED_WARNINGS)
245# undef QT_DEPRECATED
246# define QT_DEPRECATED Q_DECL_DEPRECATED
247# undef QT_DEPRECATED_X
248# define QT_DEPRECATED_X(text) Q_DECL_DEPRECATED_X(text)
249# undef QT_DEPRECATED_VARIABLE
250# define QT_DEPRECATED_VARIABLE Q_DECL_VARIABLE_DEPRECATED
251# undef QT_DEPRECATED_CONSTRUCTOR
252# define QT_DEPRECATED_CONSTRUCTOR explicit Q_DECL_CONSTRUCTOR_DEPRECATED
253#else
254# undef QT_DEPRECATED
255# define QT_DEPRECATED
256# undef QT_DEPRECATED_X
257# define QT_DEPRECATED_X(text)
258# undef QT_DEPRECATED_VARIABLE
259# define QT_DEPRECATED_VARIABLE
260# undef QT_DEPRECATED_CONSTRUCTOR
261# define QT_DEPRECATED_CONSTRUCTOR
262#endif
263
264#ifndef QT_DISABLE_DEPRECATED_BEFORE
265#define QT_DISABLE_DEPRECATED_BEFORE QT_VERSION_CHECK(5, 0, 0)
266#endif
267
268/*
269 QT_DEPRECATED_SINCE(major, minor) evaluates as true if the Qt version is greater than
270 the deprecation point specified.
271
272 Use it to specify from which version of Qt a function or class has been deprecated
273
274 Example:
275 #if QT_DEPRECATED_SINCE(5,1)
276 QT_DEPRECATED void deprecatedFunction(); //function deprecated since Qt 5.1
277 #endif
278
279*/
280#ifdef QT_DEPRECATED
281#define QT_DEPRECATED_SINCE(major, minor) (QT_VERSION_CHECK(major, minor, 0) > QT_DISABLE_DEPRECATED_BEFORE)
282#else
283#define QT_DEPRECATED_SINCE(major, minor) 0
284#endif
285
286/*
287 The Qt modules' export macros.
288 The options are:
289 - defined(QT_STATIC): Qt was built or is being built in static mode
290 - defined(QT_SHARED): Qt was built or is being built in shared/dynamic mode
291 If neither was defined, then QT_SHARED is implied. If Qt was compiled in static
292 mode, QT_STATIC is defined in qconfig.h. In shared mode, QT_STATIC is implied
293 for the bootstrapped tools.
294*/
295
296#ifdef QT_BOOTSTRAPPED
297# ifdef QT_SHARED
298# error "QT_SHARED and QT_BOOTSTRAPPED together don't make sense. Please fix the build"
299# elif !defined(QT_STATIC)
300# define QT_STATIC
301# endif
302#endif
303
304#if defined(QT_SHARED) || !defined(QT_STATIC)
305# ifdef QT_STATIC
306# error "Both QT_SHARED and QT_STATIC defined, please make up your mind"
307# endif
308# ifndef QT_SHARED
309# define QT_SHARED
310# endif
311# if defined(QT_BUILD_CORE_LIB)
312# define Q_CORE_EXPORT Q_DECL_EXPORT
313# else
314# define Q_CORE_EXPORT Q_DECL_IMPORT
315# endif
316#else
317# define Q_CORE_EXPORT
318#endif
319
320/*
321 Some classes do not permit copies to be made of an object. These
322 classes contains a private copy constructor and assignment
323 operator to disable copying (the compiler gives an error message).
324*/
325#define Q_DISABLE_COPY(Class) \
326 Class(const Class &) Q_DECL_EQ_DELETE;\
327 Class &operator=(const Class &) Q_DECL_EQ_DELETE;
328
329/*
330 No, this is not an evil backdoor. QT_BUILD_INTERNAL just exports more symbols
331 for Qt's internal unit tests. If you want slower loading times and more
332 symbols that can vanish from version to version, feel free to define QT_BUILD_INTERNAL.
333*/
334#if defined(QT_BUILD_INTERNAL) && defined(QT_BUILDING_QT) && defined(QT_SHARED)
335# define Q_AUTOTEST_EXPORT Q_DECL_EXPORT
336#elif defined(QT_BUILD_INTERNAL) && defined(QT_SHARED)
337# define Q_AUTOTEST_EXPORT Q_DECL_IMPORT
338#else
339# define Q_AUTOTEST_EXPORT
340#endif
341
342#define Q_INIT_RESOURCE(name) \
343 do { extern int QT_MANGLE_NAMESPACE(qInitResources_ ## name) (); \
344 QT_MANGLE_NAMESPACE(qInitResources_ ## name) (); } while (false)
345#define Q_CLEANUP_RESOURCE(name) \
346 do { extern int QT_MANGLE_NAMESPACE(qCleanupResources_ ## name) (); \
347 QT_MANGLE_NAMESPACE(qCleanupResources_ ## name) (); } while (false)
348
349/*
350 * If we're compiling C++ code:
351 * - and this is a non-namespace build, declare qVersion as extern "C"
352 * - and this is a namespace build, declare it as a regular function
353 * (we're already inside QT_BEGIN_NAMESPACE / QT_END_NAMESPACE)
354 * If we're compiling C code, simply declare the function. If Qt was compiled
355 * in a namespace, qVersion isn't callable anyway.
356 */
357#if !defined(QT_NAMESPACE) && defined(__cplusplus) && !defined(Q_QDOC)
358extern "C"
359#endif
360Q_CORE_EXPORT Q_DECL_CONST_FUNCTION const char *qVersion(void) Q_DECL_NOTHROW;
361
362#if defined(__cplusplus)
363
364#ifndef Q_CONSTRUCTOR_FUNCTION
365# define Q_CONSTRUCTOR_FUNCTION0(AFUNC) \
366 namespace { \
367 static const struct AFUNC ## _ctor_class_ { \
368 inline AFUNC ## _ctor_class_() { AFUNC(); } \
369 } AFUNC ## _ctor_instance_; \
370 }
371
372# define Q_CONSTRUCTOR_FUNCTION(AFUNC) Q_CONSTRUCTOR_FUNCTION0(AFUNC)
373#endif
374
375#ifndef Q_DESTRUCTOR_FUNCTION
376# define Q_DESTRUCTOR_FUNCTION0(AFUNC) \
377 namespace { \
378 static const struct AFUNC ## _dtor_class_ { \
379 inline AFUNC ## _dtor_class_() { } \
380 inline ~ AFUNC ## _dtor_class_() { AFUNC(); } \
381 } AFUNC ## _dtor_instance_; \
382 }
383# define Q_DESTRUCTOR_FUNCTION(AFUNC) Q_DESTRUCTOR_FUNCTION0(AFUNC)
384#endif
385
386namespace QtPrivate {
387 template <class T>
388 struct AlignOfHelper
389 {
390 char c;
391 T type;
392
393 AlignOfHelper();
394 ~AlignOfHelper();
395 };
396
397 template <class T>
398 struct AlignOf_Default
399 {
400 enum { Value = sizeof(AlignOfHelper<T>) - sizeof(T) };
401 };
402
403 template <class T> struct AlignOf : AlignOf_Default<T> { };
404 template <class T> struct AlignOf<T &> : AlignOf<T> {};
405 template <size_t N, class T> struct AlignOf<T[N]> : AlignOf<T> {};
406
407#ifdef Q_COMPILER_RVALUE_REFS
408 template <class T> struct AlignOf<T &&> : AlignOf<T> {};
409#endif
410
411#if defined(Q_PROCESSOR_X86_32) && !defined(Q_OS_WIN)
412 template <class T> struct AlignOf_WorkaroundForI386Abi { enum { Value = sizeof(T) }; };
413
414 // x86 ABI weirdness
415 // Alignment of naked type is 8, but inside struct has alignment 4.
416 template <> struct AlignOf<double> : AlignOf_WorkaroundForI386Abi<double> {};
417 template <> struct AlignOf<qint64> : AlignOf_WorkaroundForI386Abi<qint64> {};
418 template <> struct AlignOf<quint64> : AlignOf_WorkaroundForI386Abi<quint64> {};
419#ifdef Q_CC_CLANG
420 // GCC and Clang seem to disagree wrt to alignment of arrays
421 template <size_t N> struct AlignOf<double[N]> : AlignOf_Default<double> {};
422 template <size_t N> struct AlignOf<qint64[N]> : AlignOf_Default<qint64> {};
423 template <size_t N> struct AlignOf<quint64[N]> : AlignOf_Default<quint64> {};
424#endif
425#endif
426} // namespace QtPrivate
427
428#define QT_EMULATED_ALIGNOF(T) \
429 (size_t(QT_PREPEND_NAMESPACE(QtPrivate)::AlignOf<T>::Value))
430
431#ifndef Q_ALIGNOF
432#define Q_ALIGNOF(T) QT_EMULATED_ALIGNOF(T)
433#endif
434
435
436/*
437 quintptr and qptrdiff is guaranteed to be the same size as a pointer, i.e.
438
439 sizeof(void *) == sizeof(quintptr)
440 && sizeof(void *) == sizeof(qptrdiff)
441
442 size_t and qsizetype are not guaranteed to be the same size as a pointer, but
443 they usually are.
444*/
445template <int> struct QIntegerForSize;
446template <> struct QIntegerForSize<1> { typedef quint8 Unsigned; typedef qint8 Signed; };
447template <> struct QIntegerForSize<2> { typedef quint16 Unsigned; typedef qint16 Signed; };
448template <> struct QIntegerForSize<4> { typedef quint32 Unsigned; typedef qint32 Signed; };
449template <> struct QIntegerForSize<8> { typedef quint64 Unsigned; typedef qint64 Signed; };
450#if defined(Q_CC_GNU) && defined(__SIZEOF_INT128__)
451template <> struct QIntegerForSize<16> { __extension__ typedef unsigned __int128 Unsigned; __extension__ typedef __int128 Signed; };
452#endif
453template <class T> struct QIntegerForSizeof: QIntegerForSize<sizeof(T)> { };
454typedef QIntegerForSize<Q_PROCESSOR_WORDSIZE>::Signed qregisterint;
455typedef QIntegerForSize<Q_PROCESSOR_WORDSIZE>::Unsigned qregisteruint;
456typedef QIntegerForSizeof<void*>::Unsigned quintptr;
457typedef QIntegerForSizeof<void*>::Signed qptrdiff;
458typedef qptrdiff qintptr;
459using qsizetype = QIntegerForSizeof<std::size_t>::Signed;
460
461/* moc compats (signals/slots) */
462#ifndef QT_MOC_COMPAT
463# define QT_MOC_COMPAT
464#else
465# undef QT_MOC_COMPAT
466# define QT_MOC_COMPAT
467#endif
468
469#ifdef QT_ASCII_CAST_WARNINGS
470# define QT_ASCII_CAST_WARN Q_DECL_DEPRECATED_X("Use fromUtf8, QStringLiteral, or QLatin1String")
471#else
472# define QT_ASCII_CAST_WARN
473#endif
474
475#ifdef Q_PROCESSOR_X86_32
476# if defined(Q_CC_GNU)
477# define QT_FASTCALL __attribute__((regparm(3)))
478# elif defined(Q_CC_MSVC)
479# define QT_FASTCALL __fastcall
480# else
481# define QT_FASTCALL
482# endif
483#else
484# define QT_FASTCALL
485#endif
486
487// enable gcc warnings for printf-style functions
488#if defined(Q_CC_GNU) && !defined(__INSURE__)
489# if defined(Q_CC_MINGW) && !defined(Q_CC_CLANG)
490# define Q_ATTRIBUTE_FORMAT_PRINTF(A, B) \
491 __attribute__((format(gnu_printf, (A), (B))))
492# else
493# define Q_ATTRIBUTE_FORMAT_PRINTF(A, B) \
494 __attribute__((format(printf, (A), (B))))
495# endif
496#else
497# define Q_ATTRIBUTE_FORMAT_PRINTF(A, B)
498#endif
499
500#ifdef Q_CC_MSVC
501# define Q_NEVER_INLINE __declspec(noinline)
502# define Q_ALWAYS_INLINE __forceinline
503#elif defined(Q_CC_GNU)
504# define Q_NEVER_INLINE __attribute__((noinline))
505# define Q_ALWAYS_INLINE inline __attribute__((always_inline))
506#else
507# define Q_NEVER_INLINE
508# define Q_ALWAYS_INLINE inline
509#endif
510
511#ifdef Q_CC_GNU
512# define QT_INIT_METAOBJECT __attribute__((init_priority(101)))
513#else
514# define QT_INIT_METAOBJECT
515#endif
516
517//defines the type for the WNDPROC on windows
518//the alignment needs to be forced for sse2 to not crash with mingw
519#if defined(Q_OS_WIN)
520# if defined(Q_CC_MINGW) && !defined(Q_OS_WIN64)
521# define QT_ENSURE_STACK_ALIGNED_FOR_SSE __attribute__ ((force_align_arg_pointer))
522# else
523# define QT_ENSURE_STACK_ALIGNED_FOR_SSE
524# endif
525# define QT_WIN_CALLBACK CALLBACK QT_ENSURE_STACK_ALIGNED_FOR_SSE
526#endif
527
528typedef int QNoImplicitBoolCast;
529
530/*
531 Utility macros and inline functions
532*/
533
534template <typename T>
535Q_DECL_CONSTEXPR inline T qAbs(const T &t) { return t >= 0 ? t : -t; }
536
537Q_DECL_CONSTEXPR inline int qRound(double d)
538{ return d >= 0.0 ? int(d + 0.5) : int(d - double(int(d-1)) + 0.5) + int(d-1); }
539Q_DECL_CONSTEXPR inline int qRound(float d)
540{ return d >= 0.0f ? int(d + 0.5f) : int(d - float(int(d-1)) + 0.5f) + int(d-1); }
541
542Q_DECL_CONSTEXPR inline qint64 qRound64(double d)
543{ return d >= 0.0 ? qint64(d + 0.5) : qint64(d - double(qint64(d-1)) + 0.5) + qint64(d-1); }
544Q_DECL_CONSTEXPR inline qint64 qRound64(float d)
545{ return d >= 0.0f ? qint64(d + 0.5f) : qint64(d - float(qint64(d-1)) + 0.5f) + qint64(d-1); }
546
547template <typename T>
548Q_DECL_CONSTEXPR inline const T &qMin(const T &a, const T &b) { return (a < b) ? a : b; }
549template <typename T>
550Q_DECL_CONSTEXPR inline const T &qMax(const T &a, const T &b) { return (a < b) ? b : a; }
551template <typename T>
552Q_DECL_CONSTEXPR inline const T &qBound(const T &min, const T &val, const T &max)
553{ return qMax(min, qMin(max, val)); }
554
555#ifndef Q_FORWARD_DECLARE_OBJC_CLASS
556# ifdef __OBJC__
557# define Q_FORWARD_DECLARE_OBJC_CLASS(classname) @class classname
558# else
559# define Q_FORWARD_DECLARE_OBJC_CLASS(classname) typedef struct objc_object classname
560# endif
561#endif
562#ifndef Q_FORWARD_DECLARE_CF_TYPE
563# define Q_FORWARD_DECLARE_CF_TYPE(type) typedef const struct __ ## type * type ## Ref
564#endif
565#ifndef Q_FORWARD_DECLARE_MUTABLE_CF_TYPE
566# define Q_FORWARD_DECLARE_MUTABLE_CF_TYPE(type) typedef struct __ ## type * type ## Ref
567#endif
568#ifndef Q_FORWARD_DECLARE_CG_TYPE
569#define Q_FORWARD_DECLARE_CG_TYPE(type) typedef const struct type *type ## Ref;
570#endif
571#ifndef Q_FORWARD_DECLARE_MUTABLE_CG_TYPE
572#define Q_FORWARD_DECLARE_MUTABLE_CG_TYPE(type) typedef struct type *type ## Ref;
573#endif
574
575#ifdef Q_OS_DARWIN
576# define QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(macos, ios, tvos, watchos) \
577 ((defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && macos != __MAC_NA && __MAC_OS_X_VERSION_MAX_ALLOWED >= macos) || \
578 (defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && ios != __IPHONE_NA && __IPHONE_OS_VERSION_MAX_ALLOWED >= ios) || \
579 (defined(__TV_OS_VERSION_MAX_ALLOWED) && tvos != __TVOS_NA && __TV_OS_VERSION_MAX_ALLOWED >= tvos) || \
580 (defined(__WATCH_OS_VERSION_MAX_ALLOWED) && watchos != __WATCHOS_NA && __WATCH_OS_VERSION_MAX_ALLOWED >= watchos))
581
582# define QT_DARWIN_DEPLOYMENT_TARGET_BELOW(macos, ios, tvos, watchos) \
583 ((defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && macos != __MAC_NA && __MAC_OS_X_VERSION_MIN_REQUIRED < macos) || \
584 (defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && ios != __IPHONE_NA && __IPHONE_OS_VERSION_MIN_REQUIRED < ios) || \
585 (defined(__TV_OS_VERSION_MIN_REQUIRED) && tvos != __TVOS_NA && __TV_OS_VERSION_MIN_REQUIRED < tvos) || \
586 (defined(__WATCH_OS_VERSION_MIN_REQUIRED) && watchos != __WATCHOS_NA && __WATCH_OS_VERSION_MIN_REQUIRED < watchos))
587
588# define QT_MACOS_IOS_PLATFORM_SDK_EQUAL_OR_ABOVE(macos, ios) \
589 QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(macos, ios, __TVOS_NA, __WATCHOS_NA)
590# define QT_MACOS_PLATFORM_SDK_EQUAL_OR_ABOVE(macos) \
591 QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(macos, __IPHONE_NA, __TVOS_NA, __WATCHOS_NA)
592# define QT_IOS_PLATFORM_SDK_EQUAL_OR_ABOVE(ios) \
593 QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(__MAC_NA, ios, __TVOS_NA, __WATCHOS_NA)
594# define QT_TVOS_PLATFORM_SDK_EQUAL_OR_ABOVE(tvos) \
595 QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(__MAC_NA, __IPHONE_NA, tvos, __WATCHOS_NA)
596# define QT_WATCHOS_PLATFORM_SDK_EQUAL_OR_ABOVE(watchos) \
597 QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(__MAC_NA, __IPHONE_NA, __TVOS_NA, watchos)
598
599# define QT_MACOS_IOS_DEPLOYMENT_TARGET_BELOW(macos, ios) \
600 QT_DARWIN_DEPLOYMENT_TARGET_BELOW(macos, ios, __TVOS_NA, __WATCHOS_NA)
601# define QT_MACOS_DEPLOYMENT_TARGET_BELOW(macos) \
602 QT_DARWIN_DEPLOYMENT_TARGET_BELOW(macos, __IPHONE_NA, __TVOS_NA, __WATCHOS_NA)
603# define QT_IOS_DEPLOYMENT_TARGET_BELOW(ios) \
604 QT_DARWIN_DEPLOYMENT_TARGET_BELOW(__MAC_NA, ios, __TVOS_NA, __WATCHOS_NA)
605# define QT_TVOS_DEPLOYMENT_TARGET_BELOW(tvos) \
606 QT_DARWIN_DEPLOYMENT_TARGET_BELOW(__MAC_NA, __IPHONE_NA, tvos, __WATCHOS_NA)
607# define QT_WATCHOS_DEPLOYMENT_TARGET_BELOW(watchos) \
608 QT_DARWIN_DEPLOYMENT_TARGET_BELOW(__MAC_NA, __IPHONE_NA, __TVOS_NA, watchos)
609
610// Compatibility synonyms, do not use
611# define QT_MAC_PLATFORM_SDK_EQUAL_OR_ABOVE(osx, ios) QT_MACOS_IOS_PLATFORM_SDK_EQUAL_OR_ABOVE(osx, ios)
612# define QT_MAC_DEPLOYMENT_TARGET_BELOW(osx, ios) QT_MACOS_IOS_DEPLOYMENT_TARGET_BELOW(osx, ios)
613# define QT_OSX_PLATFORM_SDK_EQUAL_OR_ABOVE(osx) QT_MACOS_PLATFORM_SDK_EQUAL_OR_ABOVE(osx)
614# define QT_OSX_DEPLOYMENT_TARGET_BELOW(osx) QT_MACOS_DEPLOYMENT_TARGET_BELOW(osx)
615
616// Implemented in qcore_mac_objc.mm
617class Q_CORE_EXPORT QMacAutoReleasePool
618{
619public:
620 QMacAutoReleasePool();
621 ~QMacAutoReleasePool();
622private:
623 Q_DISABLE_COPY(QMacAutoReleasePool)
624 void *pool;
625};
626
627#else
628
629#define QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(macos, ios, tvos, watchos) (0)
630#define QT_MACOS_IOS_PLATFORM_SDK_EQUAL_OR_ABOVE(macos, ios) (0)
631#define QT_MACOS_PLATFORM_SDK_EQUAL_OR_ABOVE(macos) (0)
632#define QT_IOS_PLATFORM_SDK_EQUAL_OR_ABOVE(ios) (0)
633#define QT_TVOS_PLATFORM_SDK_EQUAL_OR_ABOVE(tvos) (0)
634#define QT_WATCHOS_PLATFORM_SDK_EQUAL_OR_ABOVE(watchos) (0)
635
636#define QT_MAC_PLATFORM_SDK_EQUAL_OR_ABOVE(osx, ios) (0)
637#define QT_OSX_PLATFORM_SDK_EQUAL_OR_ABOVE(osx) (0)
638
639#endif // Q_OS_DARWIN
640
641/*
642 Data stream functions are provided by many classes (defined in qdatastream.h)
643*/
644
645class QDataStream;
646
647inline void qt_noop(void) {}
648
649/* These wrap try/catch so we can switch off exceptions later.
650
651 Beware - do not use more than one QT_CATCH per QT_TRY, and do not use
652 the exception instance in the catch block.
653 If you can't live with those constraints, don't use these macros.
654 Use the QT_NO_EXCEPTIONS macro to protect your code instead.
655*/
656
657#if !defined(QT_NO_EXCEPTIONS)
658# if !defined(Q_MOC_RUN)
659# if (defined(Q_CC_CLANG) && !defined(Q_CC_INTEL) && !QT_HAS_FEATURE(cxx_exceptions)) || \
660 (defined(Q_CC_GNU) && !defined(__EXCEPTIONS))
661# define QT_NO_EXCEPTIONS
662# endif
663# elif defined(QT_BOOTSTRAPPED)
664# define QT_NO_EXCEPTIONS
665# endif
666#endif
667
668#ifdef QT_NO_EXCEPTIONS
669# define QT_TRY if (true)
670# define QT_CATCH(A) else
671# define QT_THROW(A) qt_noop()
672# define QT_RETHROW qt_noop()
673# define QT_TERMINATE_ON_EXCEPTION(expr) do { expr; } while (false)
674#else
675# define QT_TRY try
676# define QT_CATCH(A) catch (A)
677# define QT_THROW(A) throw A
678# define QT_RETHROW throw
679Q_NORETURN Q_CORE_EXPORT void qTerminate() Q_DECL_NOTHROW;
680# ifdef Q_COMPILER_NOEXCEPT
681# define QT_TERMINATE_ON_EXCEPTION(expr) do { expr; } while (false)
682# else
683# define QT_TERMINATE_ON_EXCEPTION(expr) do { try { expr; } catch (...) { qTerminate(); } } while (false)
684# endif
685#endif
686
687Q_CORE_EXPORT Q_DECL_CONST_FUNCTION bool qSharedBuild() Q_DECL_NOTHROW;
688
689#ifndef Q_OUTOFLINE_TEMPLATE
690# define Q_OUTOFLINE_TEMPLATE
691#endif
692#ifndef Q_INLINE_TEMPLATE
693# define Q_INLINE_TEMPLATE inline
694#endif
695
696/*
697 Avoid "unused parameter" warnings
698*/
699#define Q_UNUSED(x) (void)x;
700
701/*
702 Debugging and error handling
703*/
704
705#if !defined(QT_NO_DEBUG) && !defined(QT_DEBUG)
706# define QT_DEBUG
707#endif
708
709#ifndef qPrintable
710# define qPrintable(string) QString(string).toLocal8Bit().constData()
711#endif
712
713#ifndef qUtf8Printable
714# define qUtf8Printable(string) QString(string).toUtf8().constData()
715#endif
716
717/*
718 Wrap QString::utf16() with enough casts to allow passing it
719 to QString::asprintf("%ls") without warnings.
720*/
721#ifndef qUtf16Printable
722# define qUtf16Printable(string) \
723 static_cast<const wchar_t*>(static_cast<const void*>(QString(string).utf16()))
724#endif
725
726class QString;
727Q_CORE_EXPORT QString qt_error_string(int errorCode = -1);
728
729#ifndef Q_CC_MSVC
730Q_NORETURN
731#endif
732Q_CORE_EXPORT void qt_assert(const char *assertion, const char *file, int line) Q_DECL_NOTHROW;
733
734#if !defined(Q_ASSERT)
735# if defined(QT_NO_DEBUG) && !defined(QT_FORCE_ASSERTS)
736# define Q_ASSERT(cond) static_cast<void>(false && (cond))
737# else
738# define Q_ASSERT(cond) ((cond) ? static_cast<void>(0) : qt_assert(#cond, __FILE__, __LINE__))
739# endif
740#endif
741
742#if defined(QT_NO_DEBUG) && !defined(QT_PAINT_DEBUG)
743#define QT_NO_PAINT_DEBUG
744#endif
745
746#ifndef Q_CC_MSVC
747Q_NORETURN
748#endif
749Q_CORE_EXPORT void qt_assert_x(const char *where, const char *what, const char *file, int line) Q_DECL_NOTHROW;
750
751#if !defined(Q_ASSERT_X)
752# if defined(QT_NO_DEBUG) && !defined(QT_FORCE_ASSERTS)
753# define Q_ASSERT_X(cond, where, what) static_cast<void>(false && (cond))
754# else
755# define Q_ASSERT_X(cond, where, what) ((cond) ? static_cast<void>(0) : qt_assert_x(where, what, __FILE__, __LINE__))
756# endif
757#endif
758
759
760#ifdef Q_COMPILER_STATIC_ASSERT
761#define Q_STATIC_ASSERT(Condition) static_assert(bool(Condition), #Condition)
762#define Q_STATIC_ASSERT_X(Condition, Message) static_assert(bool(Condition), Message)
763#else
764// Intentionally undefined
765template <bool Test> class QStaticAssertFailure;
766template <> class QStaticAssertFailure<true> {};
767
768#define Q_STATIC_ASSERT_PRIVATE_JOIN(A, B) Q_STATIC_ASSERT_PRIVATE_JOIN_IMPL(A, B)
769#define Q_STATIC_ASSERT_PRIVATE_JOIN_IMPL(A, B) A ## B
770#ifdef __COUNTER__
771#define Q_STATIC_ASSERT(Condition) \
772 enum {Q_STATIC_ASSERT_PRIVATE_JOIN(q_static_assert_result, __COUNTER__) = sizeof(QStaticAssertFailure<!!(Condition)>)}
773#else
774#define Q_STATIC_ASSERT(Condition) \
775 enum {Q_STATIC_ASSERT_PRIVATE_JOIN(q_static_assert_result, __LINE__) = sizeof(QStaticAssertFailure<!!(Condition)>)}
776#endif /* __COUNTER__ */
777#define Q_STATIC_ASSERT_X(Condition, Message) Q_STATIC_ASSERT(Condition)
778#endif
779
780Q_NORETURN Q_CORE_EXPORT void qt_check_pointer(const char *, int) Q_DECL_NOTHROW;
781Q_CORE_EXPORT void qBadAlloc();
782
783#ifdef QT_NO_EXCEPTIONS
784# if defined(QT_NO_DEBUG) && !defined(QT_FORCE_ASSERTS)
785# define Q_CHECK_PTR(p) qt_noop()
786# else
787# define Q_CHECK_PTR(p) do {if (!(p)) qt_check_pointer(__FILE__,__LINE__);} while (false)
788# endif
789#else
790# define Q_CHECK_PTR(p) do { if (!(p)) qBadAlloc(); } while (false)
791#endif
792
793template <typename T>
794inline T *q_check_ptr(T *p) { Q_CHECK_PTR(p); return p; }
795
796typedef void (*QFunctionPointer)();
797
798#if !defined(Q_UNIMPLEMENTED)
799# define Q_UNIMPLEMENTED() qWarning("Unimplemented code.")
800#endif
801
802Q_REQUIRED_RESULT Q_DECL_CONSTEXPR static inline Q_DECL_UNUSED bool qFuzzyCompare(double p1, double p2)
803{
804 return (qAbs(p1 - p2) * 1000000000000. <= qMin(qAbs(p1), qAbs(p2)));
805}
806
807Q_REQUIRED_RESULT Q_DECL_CONSTEXPR static inline Q_DECL_UNUSED bool qFuzzyCompare(float p1, float p2)
808{
809 return (qAbs(p1 - p2) * 100000.f <= qMin(qAbs(p1), qAbs(p2)));
810}
811
812Q_REQUIRED_RESULT Q_DECL_CONSTEXPR static inline Q_DECL_UNUSED bool qFuzzyIsNull(double d)
813{
814 return qAbs(d) <= 0.000000000001;
815}
816
817Q_REQUIRED_RESULT Q_DECL_CONSTEXPR static inline Q_DECL_UNUSED bool qFuzzyIsNull(float f)
818{
819 return qAbs(f) <= 0.00001f;
820}
821
822/*
823 This function tests a double for a null value. It doesn't
824 check whether the actual value is 0 or close to 0, but whether
825 it is binary 0, disregarding sign.
826*/
827Q_REQUIRED_RESULT static inline Q_DECL_UNUSED bool qIsNull(double d)
828{
829 union U {
830 double d;
831 quint64 u;
832 };
833 U val;
834 val.d = d;
835 return (val.u & Q_UINT64_C(0x7fffffffffffffff)) == 0;
836}
837
838/*
839 This function tests a float for a null value. It doesn't
840 check whether the actual value is 0 or close to 0, but whether
841 it is binary 0, disregarding sign.
842*/
843Q_REQUIRED_RESULT static inline Q_DECL_UNUSED bool qIsNull(float f)
844{
845 union U {
846 float f;
847 quint32 u;
848 };
849 U val;
850 val.f = f;
851 return (val.u & 0x7fffffff) == 0;
852}
853
854/*
855 Compilers which follow outdated template instantiation rules
856 require a class to have a comparison operator to exist when
857 a QList of this type is instantiated. It's not actually
858 used in the list, though. Hence the dummy implementation.
859 Just in case other code relies on it we better trigger a warning
860 mandating a real implementation.
861*/
862
863#ifdef Q_FULL_TEMPLATE_INSTANTIATION
864# define Q_DUMMY_COMPARISON_OPERATOR(C) \
865 bool operator==(const C&) const { \
866 qWarning(#C"::operator==(const "#C"&) was called"); \
867 return false; \
868 }
869#else
870
871# define Q_DUMMY_COMPARISON_OPERATOR(C)
872#endif
873
874namespace QtPrivate
875{
876namespace SwapExceptionTester { // insulate users from the "using std::swap" below
877 using std::swap; // import std::swap
878 template <typename T>
879 void checkSwap(T &t)
880 Q_DECL_NOEXCEPT_EXPR(noexcept(swap(t, t)));
881 // declared, but not implemented (only to be used in unevaluated contexts (noexcept operator))
882}
883} // namespace QtPrivate
884
885template <typename T>
886inline void qSwap(T &value1, T &value2)
887 Q_DECL_NOEXCEPT_EXPR(noexcept(QtPrivate::SwapExceptionTester::checkSwap(value1)))
888{
889 using std::swap;
890 swap(value1, value2);
891}
892
893#if QT_DEPRECATED_SINCE(5, 0)
894Q_CORE_EXPORT QT_DEPRECATED void *qMalloc(size_t size) Q_ALLOC_SIZE(1);
895Q_CORE_EXPORT QT_DEPRECATED void qFree(void *ptr);
896Q_CORE_EXPORT QT_DEPRECATED void *qRealloc(void *ptr, size_t size) Q_ALLOC_SIZE(2);
897Q_CORE_EXPORT QT_DEPRECATED void *qMemCopy(void *dest, const void *src, size_t n);
898Q_CORE_EXPORT QT_DEPRECATED void *qMemSet(void *dest, int c, size_t n);
899#endif
900Q_CORE_EXPORT void *qMallocAligned(size_t size, size_t alignment) Q_ALLOC_SIZE(1);
901Q_CORE_EXPORT void *qReallocAligned(void *ptr, size_t size, size_t oldsize, size_t alignment) Q_ALLOC_SIZE(2);
902Q_CORE_EXPORT void qFreeAligned(void *ptr);
903
904
905/*
906 Avoid some particularly useless warnings from some stupid compilers.
907 To get ALL C++ compiler warnings, define QT_CC_WARNINGS or comment out
908 the line "#define QT_NO_WARNINGS".
909*/
910#if !defined(QT_CC_WARNINGS)
911# define QT_NO_WARNINGS
912#endif
913#if defined(QT_NO_WARNINGS)
914# if defined(Q_CC_MSVC)
915QT_WARNING_DISABLE_MSVC(4251) /* class 'type' needs to have dll-interface to be used by clients of class 'type2' */
916QT_WARNING_DISABLE_MSVC(4244) /* conversion from 'type1' to 'type2', possible loss of data */
917QT_WARNING_DISABLE_MSVC(4275) /* non - DLL-interface classkey 'identifier' used as base for DLL-interface classkey 'identifier' */
918QT_WARNING_DISABLE_MSVC(4514) /* unreferenced inline function has been removed */
919QT_WARNING_DISABLE_MSVC(4800) /* 'type' : forcing value to bool 'true' or 'false' (performance warning) */
920QT_WARNING_DISABLE_MSVC(4097) /* typedef-name 'identifier1' used as synonym for class-name 'identifier2' */
921QT_WARNING_DISABLE_MSVC(4706) /* assignment within conditional expression */
922# if _MSC_VER <= 1310 // MSVC 2003
923QT_WARNING_DISABLE_MSVC(4786) /* 'identifier' : identifier was truncated to 'number' characters in the debug information */
924# endif
925QT_WARNING_DISABLE_MSVC(4355) /* 'this' : used in base member initializer list */
926# if _MSC_VER < 1800 // MSVC 2013
927QT_WARNING_DISABLE_MSVC(4231) /* nonstandard extension used : 'identifier' before template explicit instantiation */
928# endif
929QT_WARNING_DISABLE_MSVC(4710) /* function not inlined */
930QT_WARNING_DISABLE_MSVC(4530) /* C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc */
931# elif defined(Q_CC_BOR)
932# pragma option -w-inl
933# pragma option -w-aus
934# pragma warn -inl
935# pragma warn -pia
936# pragma warn -ccc
937# pragma warn -rch
938# pragma warn -sig
939# endif
940#endif
941
942// this adds const to non-const objects (like std::as_const)
943template <typename T>
944Q_DECL_CONSTEXPR typename std::add_const<T>::type &qAsConst(T &t) Q_DECL_NOTHROW { return t; }
945// prevent rvalue arguments:
946template <typename T>
947void qAsConst(const T &&) Q_DECL_EQ_DELETE;
948
949#ifndef QT_NO_FOREACH
950
951namespace QtPrivate {
952
953template <typename T>
954class QForeachContainer {
955 Q_DISABLE_COPY(QForeachContainer)
956public:
957 QForeachContainer(const T &t) : c(t), i(qAsConst(c).begin()), e(qAsConst(c).end()) {}
958 QForeachContainer(T &&t) : c(std::move(t)), i(qAsConst(c).begin()), e(qAsConst(c).end()) {}
959
960 QForeachContainer(QForeachContainer &&other)
961 : c(std::move(other.c)),
962 i(qAsConst(c).begin()),
963 e(qAsConst(c).end()),
964 control(std::move(other.control))
965 {
966 }
967
968 QForeachContainer &operator=(QForeachContainer &&other)
969 {
970 c = std::move(other.c);
971 i = qAsConst(c).begin();
972 e = qAsConst(c).end();
973 control = std::move(other.control);
974 return *this;
975 }
976
977 T c;
978 typename T::const_iterator i, e;
979 int control = 1;
980};
981
982template<typename T>
983QForeachContainer<typename std::decay<T>::type> qMakeForeachContainer(T &&t)
984{
985 return QForeachContainer<typename std::decay<T>::type>(std::forward<T>(t));
986}
987
988}
989// Explanation of the control word:
990// - it's initialized to 1
991// - that means both the inner and outer loops start
992// - if there were no breaks, at the end of the inner loop, it's set to 0, which
993// causes it to exit (the inner loop is run exactly once)
994// - at the end of the outer loop, it's inverted, so it becomes 1 again, allowing
995// the outer loop to continue executing
996// - if there was a break inside the inner loop, it will exit with control still
997// set to 1; in that case, the outer loop will invert it to 0 and will exit too
998#define Q_FOREACH(variable, container) \
999for (auto _container_ = QtPrivate::qMakeForeachContainer(container); \
1000 _container_.control && _container_.i != _container_.e; \
1001 ++_container_.i, _container_.control ^= 1) \
1002 for (variable = *_container_.i; _container_.control; _container_.control = 0)
1003
1004#endif // QT_NO_FOREACH
1005
1006#define Q_FOREVER for(;;)
1007#ifndef QT_NO_KEYWORDS
1008# ifndef QT_NO_FOREACH
1009# ifndef foreach
1010# define foreach Q_FOREACH
1011# endif
1012# endif // QT_NO_FOREACH
1013# ifndef forever
1014# define forever Q_FOREVER
1015# endif
1016#endif
1017
1018template <typename T> static inline T *qGetPtrHelper(T *ptr) { return ptr; }
1019template <typename Wrapper> static inline typename Wrapper::pointer qGetPtrHelper(const Wrapper &p) { return p.data(); }
1020
1021#define Q_DECLARE_PRIVATE(Class) \
1022 inline Class##Private* d_func() { return reinterpret_cast<Class##Private *>(qGetPtrHelper(d_ptr)); } \
1023 inline const Class##Private* d_func() const { return reinterpret_cast<const Class##Private *>(qGetPtrHelper(d_ptr)); } \
1024 friend class Class##Private;
1025
1026#define Q_DECLARE_PRIVATE_D(Dptr, Class) \
1027 inline Class##Private* d_func() { return reinterpret_cast<Class##Private *>(qGetPtrHelper(Dptr)); } \
1028 inline const Class##Private* d_func() const { return reinterpret_cast<const Class##Private *>(qGetPtrHelper(Dptr)); } \
1029 friend class Class##Private;
1030
1031#define Q_DECLARE_PUBLIC(Class) \
1032 inline Class* q_func() { return static_cast<Class *>(q_ptr); } \
1033 inline const Class* q_func() const { return static_cast<const Class *>(q_ptr); } \
1034 friend class Class;
1035
1036#define Q_D(Class) Class##Private * const d = d_func()
1037#define Q_Q(Class) Class * const q = q_func()
1038
1039#define QT_TR_NOOP(x) x
1040#define QT_TR_NOOP_UTF8(x) x
1041#define QT_TRANSLATE_NOOP(scope, x) x
1042#define QT_TRANSLATE_NOOP_UTF8(scope, x) x
1043#define QT_TRANSLATE_NOOP3(scope, x, comment) {x, comment}
1044#define QT_TRANSLATE_NOOP3_UTF8(scope, x, comment) {x, comment}
1045
1046#ifndef QT_NO_TRANSLATION // ### This should enclose the NOOPs above
1047
1048// Defined in qcoreapplication.cpp
1049// The better name qTrId() is reserved for an upcoming function which would
1050// return a much more powerful QStringFormatter instead of a QString.
1051Q_CORE_EXPORT QString qtTrId(const char *id, int n = -1);
1052
1053#define QT_TRID_NOOP(id) id
1054
1055#endif // QT_NO_TRANSLATION
1056
1057/*
1058 When RTTI is not available, define this macro to force any uses of
1059 dynamic_cast to cause a compile failure.
1060*/
1061
1062#if defined(QT_NO_DYNAMIC_CAST) && !defined(dynamic_cast)
1063# define dynamic_cast QT_PREPEND_NAMESPACE(qt_dynamic_cast_check)
1064
1065 template<typename T, typename X>
1066 T qt_dynamic_cast_check(X, T* = 0)
1067 { return T::dynamic_cast_will_always_fail_because_rtti_is_disabled; }
1068#endif
1069
1070
1071#ifdef Q_QDOC
1072
1073// Just for documentation generation
1074template<typename T>
1075auto qOverload(T functionPointer);
1076template<typename T>
1077auto qConstOverload(T memberFunctionPointer);
1078template<typename T>
1079auto qNonConstOverload(T memberFunctionPointer);
1080
1081#elif defined(Q_COMPILER_VARIADIC_TEMPLATES)
1082
1083template <typename... Args>
1084struct QNonConstOverload
1085{
1086 template <typename R, typename T>
1087 Q_DECL_CONSTEXPR auto operator()(R (T::*ptr)(Args...)) const Q_DECL_NOTHROW -> decltype(ptr)
1088 { return ptr; }
1089
1090 template <typename R, typename T>
1091 static Q_DECL_CONSTEXPR auto of(R (T::*ptr)(Args...)) Q_DECL_NOTHROW -> decltype(ptr)
1092 { return ptr; }
1093};
1094
1095template <typename... Args>
1096struct QConstOverload
1097{
1098 template <typename R, typename T>
1099 Q_DECL_CONSTEXPR auto operator()(R (T::*ptr)(Args...) const) const Q_DECL_NOTHROW -> decltype(ptr)
1100 { return ptr; }
1101
1102 template <typename R, typename T>
1103 static Q_DECL_CONSTEXPR auto of(R (T::*ptr)(Args...) const) Q_DECL_NOTHROW -> decltype(ptr)
1104 { return ptr; }
1105};
1106
1107template <typename... Args>
1108struct QOverload : QConstOverload<Args...>, QNonConstOverload<Args...>
1109{
1110 using QConstOverload<Args...>::of;
1111 using QConstOverload<Args...>::operator();
1112 using QNonConstOverload<Args...>::of;
1113 using QNonConstOverload<Args...>::operator();
1114
1115 template <typename R>
1116 Q_DECL_CONSTEXPR auto operator()(R (*ptr)(Args...)) const Q_DECL_NOTHROW -> decltype(ptr)
1117 { return ptr; }
1118
1119 template <typename R>
1120 static Q_DECL_CONSTEXPR auto of(R (*ptr)(Args...)) Q_DECL_NOTHROW -> decltype(ptr)
1121 { return ptr; }
1122};
1123
1124#if defined(__cpp_variable_templates) && __cpp_variable_templates >= 201304 // C++14
1125template <typename... Args> Q_CONSTEXPR Q_DECL_UNUSED QOverload<Args...> qOverload = {};
1126template <typename... Args> Q_CONSTEXPR Q_DECL_UNUSED QConstOverload<Args...> qConstOverload = {};
1127template <typename... Args> Q_CONSTEXPR Q_DECL_UNUSED QNonConstOverload<Args...> qNonConstOverload = {};
1128#endif
1129
1130#endif
1131
1132
1133class QByteArray;
1134Q_CORE_EXPORT QByteArray qgetenv(const char *varName);
1135#ifdef Q_QDOC
1136Q_CORE_EXPORT QString qEnvironmentVariable(const char *varName,
1137 const QString &defaultValue = QString());
1138#else // need it as two functions because QString is only forward-declared here
1139Q_CORE_EXPORT QString qEnvironmentVariable(const char *varName);
1140Q_CORE_EXPORT QString qEnvironmentVariable(const char *varName, const QString &defaultValue);
1141#endif
1142Q_CORE_EXPORT bool qputenv(const char *varName, const QByteArray& value);
1143Q_CORE_EXPORT bool qunsetenv(const char *varName);
1144
1145Q_CORE_EXPORT bool qEnvironmentVariableIsEmpty(const char *varName) Q_DECL_NOEXCEPT;
1146Q_CORE_EXPORT bool qEnvironmentVariableIsSet(const char *varName) Q_DECL_NOEXCEPT;
1147Q_CORE_EXPORT int qEnvironmentVariableIntValue(const char *varName, bool *ok=Q_NULLPTR) Q_DECL_NOEXCEPT;
1148
1149inline int qIntCast(double f) { return int(f); }
1150inline int qIntCast(float f) { return int(f); }
1151
1152/*
1153 Reentrant versions of basic rand() functions for random number generation
1154*/
1155Q_CORE_EXPORT void qsrand(uint seed);
1156Q_CORE_EXPORT int qrand();
1157
1158#define QT_MODULE(x)
1159
1160#if !defined(QT_BOOTSTRAPPED) && defined(QT_REDUCE_RELOCATIONS) && defined(__ELF__) && \
1161 (!defined(__PIC__) || (defined(__PIE__) && defined(Q_CC_GNU) && Q_CC_GNU >= 500))
1162# error "You must build your code with position independent code if Qt was built with -reduce-relocations. "\
1163 "Compile your code with -fPIC (-fPIE is not enough)."
1164#endif
1165
1166namespace QtPrivate {
1167//like std::enable_if
1168template <bool B, typename T = void> struct QEnableIf;
1169template <typename T> struct QEnableIf<true, T> { typedef T Type; };
1170
1171template <bool B, typename T, typename F> struct QConditional { typedef T Type; };
1172template <typename T, typename F> struct QConditional<false, T, F> { typedef F Type; };
1173}
1174
1175QT_END_NAMESPACE
1176
1177// We need to keep QTypeInfo, QSysInfo, QFlags, qDebug & family in qglobal.h for compatibility with Qt 4.
1178// Be careful when changing the order of these files.
1179#include <QtCore/qtypeinfo.h>
1180#include <QtCore/qsysinfo.h>
1181#include <QtCore/qlogging.h>
1182
1183#include <QtCore/qflags.h>
1184
1185#include <QtCore/qatomic.h>
1186#include <QtCore/qglobalstatic.h>
1187#include <QtCore/qnumeric.h>
1188#include <QtCore/qversiontagging.h>
1189
1190#endif /* __cplusplus */
1191#endif /* !__ASSEMBLER__ */
1192
1193#endif /* QGLOBAL_H */
1194