summaryrefslogtreecommitdiffstats
path: root/src/corelib/global
diff options
context:
space:
mode:
Diffstat (limited to 'src/corelib/global')
-rw-r--r--src/corelib/global/qflags.h4
-rw-r--r--src/corelib/global/qglobal.cpp28
-rw-r--r--src/corelib/global/qhooks.cpp2
-rw-r--r--src/corelib/global/qnumeric.cpp4
-rw-r--r--src/corelib/global/qnumeric_p.h8
-rw-r--r--src/corelib/global/qrandom.cpp6
-rw-r--r--src/corelib/global/qrandom.h2
7 files changed, 27 insertions, 27 deletions
diff --git a/src/corelib/global/qflags.h b/src/corelib/global/qflags.h
index 4f46de5eaa..3cb46e3a01 100644
--- a/src/corelib/global/qflags.h
+++ b/src/corelib/global/qflags.h
@@ -88,10 +88,10 @@ Q_DECL_CONSTEXPR inline QIncompatibleFlag::QIncompatibleFlag(int value) noexcept
template<typename Enum>
class QFlags
{
- Q_STATIC_ASSERT_X((sizeof(Enum) <= sizeof(int)),
+ static_assert((sizeof(Enum) <= sizeof(int)),
"QFlags uses an int as storage, so an enum with underlying "
"long long will overflow.");
- Q_STATIC_ASSERT_X((std::is_enum<Enum>::value), "QFlags is only usable on enumeration types.");
+ static_assert((std::is_enum<Enum>::value), "QFlags is only usable on enumeration types.");
#if QT_DEPRECATED_SINCE(5,15)
struct Private;
diff --git a/src/corelib/global/qglobal.cpp b/src/corelib/global/qglobal.cpp
index 4d990f5bb5..460a36e2bc 100644
--- a/src/corelib/global/qglobal.cpp
+++ b/src/corelib/global/qglobal.cpp
@@ -133,15 +133,15 @@ Q_CORE_EXPORT void *qMemSet(void *dest, int c, size_t n);
// in. The idea here is to error or warn if otherwise implicit Qt
// assumptions are not fulfilled on new hardware or compilers
// (if this list becomes too long, consider factoring into a separate file)
-Q_STATIC_ASSERT_X(UCHAR_MAX == 255, "Qt assumes that char is 8 bits");
-Q_STATIC_ASSERT_X(sizeof(int) == 4, "Qt assumes that int is 32 bits");
-Q_STATIC_ASSERT_X(QT_POINTER_SIZE == sizeof(void *), "QT_POINTER_SIZE defined incorrectly");
-Q_STATIC_ASSERT_X(sizeof(float) == 4, "Qt assumes that float is 32 bits");
-Q_STATIC_ASSERT_X(sizeof(char16_t) == 2, "Qt assumes that char16_t is 16 bits");
-Q_STATIC_ASSERT_X(sizeof(char32_t) == 4, "Qt assumes that char32_t is 32 bits");
-Q_STATIC_ASSERT_X(std::numeric_limits<int>::radix == 2,
+static_assert(UCHAR_MAX == 255, "Qt assumes that char is 8 bits");
+static_assert(sizeof(int) == 4, "Qt assumes that int is 32 bits");
+static_assert(QT_POINTER_SIZE == sizeof(void *), "QT_POINTER_SIZE defined incorrectly");
+static_assert(sizeof(float) == 4, "Qt assumes that float is 32 bits");
+static_assert(sizeof(char16_t) == 2, "Qt assumes that char16_t is 16 bits");
+static_assert(sizeof(char32_t) == 4, "Qt assumes that char32_t is 32 bits");
+static_assert(std::numeric_limits<int>::radix == 2,
"Qt assumes binary integers");
-Q_STATIC_ASSERT_X((std::numeric_limits<int>::max() + std::numeric_limits<int>::lowest()) == -1,
+static_assert((std::numeric_limits<int>::max() + std::numeric_limits<int>::lowest()) == -1,
"Qt assumes two's complement integers");
// While we'd like to check for __STDC_IEC_559__, as per ISO/IEC 9899:2011
@@ -152,13 +152,13 @@ Q_STATIC_ASSERT_X((std::numeric_limits<int>::max() + std::numeric_limits<int>::l
// On GHC the compiler reports std::numeric_limits<float>::is_iec559 as false.
// This is all right according to our needs.
#if !defined(Q_CC_GHS)
-Q_STATIC_ASSERT_X(std::numeric_limits<float>::is_iec559,
+static_assert(std::numeric_limits<float>::is_iec559,
"Qt assumes IEEE 754 floating point");
#endif
// Technically, presence of NaN and infinities are implied from the above check,
// but double checking our environment doesn't hurt...
-Q_STATIC_ASSERT_X(std::numeric_limits<float>::has_infinity &&
+static_assert(std::numeric_limits<float>::has_infinity &&
std::numeric_limits<float>::has_quiet_NaN &&
std::numeric_limits<float>::has_signaling_NaN,
"Qt assumes IEEE 754 floating point");
@@ -167,13 +167,13 @@ Q_STATIC_ASSERT_X(std::numeric_limits<float>::has_infinity &&
// but that allows for a non-binary radix. We need to recheck that.
// Note how __STDC_IEC_559__ would instead check for IEC 60559:1989, aka
// ANSI/IEEE 754−1985, which specifically implies binary floating point numbers.
-Q_STATIC_ASSERT_X(std::numeric_limits<float>::radix == 2,
+static_assert(std::numeric_limits<float>::radix == 2,
"Qt assumes binary IEEE 754 floating point");
// not required by the definition of size_t, but we depend on this
-Q_STATIC_ASSERT_X(sizeof(size_t) == sizeof(void *), "size_t and a pointer don't have the same size");
-Q_STATIC_ASSERT(sizeof(size_t) == sizeof(qsizetype)); // implied by the definition
-Q_STATIC_ASSERT((std::is_same<qsizetype, qptrdiff>::value));
+static_assert(sizeof(size_t) == sizeof(void *), "size_t and a pointer don't have the same size");
+static_assert(sizeof(size_t) == sizeof(qsizetype)); // implied by the definition
+static_assert((std::is_same<qsizetype, qptrdiff>::value));
/*!
\class QFlag
diff --git a/src/corelib/global/qhooks.cpp b/src/corelib/global/qhooks.cpp
index 79f9b7d6c2..22f01853b7 100644
--- a/src/corelib/global/qhooks.cpp
+++ b/src/corelib/global/qhooks.cpp
@@ -70,7 +70,7 @@ quintptr Q_CORE_EXPORT qtHookData[] = {
18
};
-Q_STATIC_ASSERT(QHooks::LastHookIndex == sizeof(qtHookData) / sizeof(qtHookData[0]));
+static_assert(QHooks::LastHookIndex == sizeof(qtHookData) / sizeof(qtHookData[0]));
QT_END_NAMESPACE
diff --git a/src/corelib/global/qnumeric.cpp b/src/corelib/global/qnumeric.cpp
index 9cb9c1283a..b754155b30 100644
--- a/src/corelib/global/qnumeric.cpp
+++ b/src/corelib/global/qnumeric.cpp
@@ -169,7 +169,7 @@ Q_CORE_EXPORT quint32 qFloatDistance(float a, float b)
* IEE754 format.
* Integers and floats have the same endian
*/
- Q_STATIC_ASSERT(sizeof(quint32) == sizeof(float));
+ static_assert(sizeof(quint32) == sizeof(float));
Q_ASSERT(qIsFinite(a) && qIsFinite(b));
if (a == b)
return 0;
@@ -227,7 +227,7 @@ Q_CORE_EXPORT quint64 qFloatDistance(double a, double b)
* IEE754 format double precision
* Integers and floats have the same endian
*/
- Q_STATIC_ASSERT(sizeof(quint64) == sizeof(double));
+ static_assert(sizeof(quint64) == sizeof(double));
Q_ASSERT(qIsFinite(a) && qIsFinite(b));
if (a == b)
return 0;
diff --git a/src/corelib/global/qnumeric_p.h b/src/corelib/global/qnumeric_p.h
index 27490bce97..790a00bdb5 100644
--- a/src/corelib/global/qnumeric_p.h
+++ b/src/corelib/global/qnumeric_p.h
@@ -128,7 +128,7 @@ Q_DECL_CONST_FUNCTION static inline int fpclassify(float f) { return std::fpclas
Q_DECL_CONSTEXPR Q_DECL_CONST_FUNCTION static inline double qt_inf() noexcept
{
- Q_STATIC_ASSERT_X(std::numeric_limits<double>::has_infinity,
+ static_assert(std::numeric_limits<double>::has_infinity,
"platform has no definition for infinity for type double");
return std::numeric_limits<double>::infinity();
}
@@ -136,7 +136,7 @@ Q_DECL_CONSTEXPR Q_DECL_CONST_FUNCTION static inline double qt_inf() noexcept
#if QT_CONFIG(signaling_nan)
Q_DECL_CONSTEXPR Q_DECL_CONST_FUNCTION static inline double qt_snan() noexcept
{
- Q_STATIC_ASSERT_X(std::numeric_limits<double>::has_signaling_NaN,
+ static_assert(std::numeric_limits<double>::has_signaling_NaN,
"platform has no definition for signaling NaN for type double");
return std::numeric_limits<double>::signaling_NaN();
}
@@ -145,7 +145,7 @@ Q_DECL_CONSTEXPR Q_DECL_CONST_FUNCTION static inline double qt_snan() noexcept
// Quiet NaN
Q_DECL_CONSTEXPR Q_DECL_CONST_FUNCTION static inline double qt_qnan() noexcept
{
- Q_STATIC_ASSERT_X(std::numeric_limits<double>::has_quiet_NaN,
+ static_assert(std::numeric_limits<double>::has_quiet_NaN,
"platform has no definition for quiet NaN for type double");
return std::numeric_limits<double>::quiet_NaN();
}
@@ -204,7 +204,7 @@ namespace {
*/
template <typename T> static inline bool convertDoubleTo(double v, T *value, bool allow_precision_upgrade = true)
{
- Q_STATIC_ASSERT(std::numeric_limits<T>::is_integer);
+ static_assert(std::numeric_limits<T>::is_integer);
// The [conv.fpint] (7.10 Floating-integral conversions) section of the C++
// standard says only exact conversions are guaranteed. Converting
diff --git a/src/corelib/global/qrandom.cpp b/src/corelib/global/qrandom.cpp
index e35fc21d98..c18ee6acbb 100644
--- a/src/corelib/global/qrandom.cpp
+++ b/src/corelib/global/qrandom.cpp
@@ -183,7 +183,7 @@ struct QRandomGenerator::SystemGenerator
// other than quint32 (unsigned int) to fill their buffers.
template <typename T> void generate(T *begin, T *end)
{
- Q_STATIC_ASSERT(sizeof(T) >= sizeof(quint32));
+ static_assert(sizeof(T) >= sizeof(quint32));
if (sizeof(T) == sizeof(quint32)) {
// Microsoft Visual Studio uses unsigned long, but that's still 32-bit
generate(reinterpret_cast<quint32 *>(begin), reinterpret_cast<quint32 *>(end));
@@ -377,14 +377,14 @@ struct QRandomGenerator::SystemAndGlobalGenerators
constexpr SystemAndGlobalGenerators g = {};
Q_UNUSED(g);
- Q_STATIC_ASSERT(std::is_literal_type<SystemAndGlobalGenerators>::value);
+ static_assert(std::is_literal_type<SystemAndGlobalGenerators>::value);
#endif
}
static SystemAndGlobalGenerators *self()
{
static SystemAndGlobalGenerators g;
- Q_STATIC_ASSERT(sizeof(g) > sizeof(QRandomGenerator64));
+ static_assert(sizeof(g) > sizeof(QRandomGenerator64));
return &g;
}
diff --git a/src/corelib/global/qrandom.h b/src/corelib/global/qrandom.h
index e1494ab523..4e27ef1edc 100644
--- a/src/corelib/global/qrandom.h
+++ b/src/corelib/global/qrandom.h
@@ -201,7 +201,7 @@ private:
const RandomEngine &engine() const { return reinterpret_cast<const RandomEngine &>(buffer); }
#endif
- Q_STATIC_ASSERT_X(std::is_trivially_destructible<RandomEngine>::value,
+ static_assert(std::is_trivially_destructible<RandomEngine>::value,
"std::mersenne_twister not trivially destructible as expected");
Q_DECL_CONSTEXPR Storage();
};
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-01 00:34:02 +0000