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