256 lines
12 KiB
C++
256 lines
12 KiB
C++
/*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* Copyright 2010-2019 Danny Robson <danny@nerdcruft.net>
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "./common.hpp"
|
|
#include "./debugger.hpp"
|
|
|
|
#include "../platform.hpp"
|
|
#include "../maths.hpp"
|
|
|
|
#include <utility>
|
|
|
|
#include <cassert>
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define assert_message(MSG) __assert_fail(MSG, __FILE__, __LINE__, __PRETTY_FUNCTION__);
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#ifdef COMPILER_GCC
|
|
#define CHECK(C) do { \
|
|
_Pragma("GCC diagnostic push") \
|
|
_Pragma("GCC diagnostic ignored \"-Wnonnull-compare\"") \
|
|
DEBUG_ONLY ( \
|
|
if (!(C)) \
|
|
assert_message (#C); \
|
|
); \
|
|
_Pragma("GCC diagnostic pop") \
|
|
} while (0)
|
|
#elif defined(COMPILER_CLANG)
|
|
#define CHECK(C) do { \
|
|
DEBUG_ONLY ( \
|
|
if (!(C)) \
|
|
assert_message (#C); \
|
|
); \
|
|
} while (0)
|
|
#else
|
|
#error Unhandled compiler
|
|
#endif
|
|
|
|
|
|
constexpr void constexpr_assert (auto const &expr)
|
|
{
|
|
if (std::is_constant_evaluated ())
|
|
static_cast<bool> (expr) ? void (0) : [] () { throw nullptr; } ();
|
|
else
|
|
assert (expr);
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define SCOPED_SANITY(A) \
|
|
::cruft::debug::scoped_sanity PASTE(__scoped_sanity_checker,__LINE__) ((A)); \
|
|
(void)PASTE(__scoped_sanity_checker,__LINE__);
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define CHECK_SANITY(A,...) CHECK(::cruft::debug::is_valid ((A) __VA_OPT__(,) __VA_ARGS__))
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define CHECK_EQ(A,B) do { \
|
|
DEBUG_ONLY ( \
|
|
const auto &__a = (A); \
|
|
const auto &__b = (B); \
|
|
\
|
|
if (!::cruft::almost_equal (__a, __b)) { \
|
|
assert_message ("expected: " #A " == " #B); \
|
|
breakpoint (); \
|
|
} \
|
|
); \
|
|
} while (0)
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define CHECK_LT(A,B) do { \
|
|
DEBUG_ONLY ( \
|
|
const auto &__a = (A); \
|
|
const auto &__b = (B); \
|
|
\
|
|
if (__a >= __b) { \
|
|
assert_message ("expected: " #A " < " #B); \
|
|
breakpoint (); \
|
|
}; \
|
|
); \
|
|
} while (0)
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define CHECK_LE(A,B) do { \
|
|
DEBUG_ONLY ( \
|
|
const auto &__a = (A); \
|
|
const auto &__b = (B); \
|
|
\
|
|
if (!(__a <= __b)) { \
|
|
assert_message ("expected: " #A " <= " #B); \
|
|
breakpoint (); \
|
|
} \
|
|
); \
|
|
} while (0)
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define CHECK_GT(A,B) do { \
|
|
DEBUG_ONLY ( \
|
|
const auto &__a = (A); \
|
|
const auto &__b = (B); \
|
|
\
|
|
if (__a <= __b) { \
|
|
assert_message ("expected: " #A " > " #B); \
|
|
breakpoint (); \
|
|
} \
|
|
); \
|
|
} while (0)
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define CHECK_GE(A,B) do { \
|
|
DEBUG_ONLY ( \
|
|
const auto &__a = (A); \
|
|
const auto &__b = (B); \
|
|
\
|
|
if (__a < __b) { \
|
|
assert_message ("expected: " #A " >= " #B); \
|
|
breakpoint (); \
|
|
}; \
|
|
); \
|
|
} while (0)
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define CHECK_INCLUSIVE(V,L,H) do { \
|
|
DEBUG_ONLY ( \
|
|
const auto &__v = (V); \
|
|
const auto &__l = (L); \
|
|
const auto &__h = (H); \
|
|
\
|
|
if (__v < __l || __v > __h) { \
|
|
assert_message ("expected: " #L " <= " #V " <= " #H); \
|
|
breakpoint (); \
|
|
}; \
|
|
); \
|
|
} while (0)
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define CHECK_INDEX(V,H) do { \
|
|
DEBUG_ONLY ( \
|
|
const auto &__v = (V); \
|
|
const auto &__h = (H); \
|
|
\
|
|
_Pragma("GCC diagnostic push") \
|
|
_Pragma("GCC diagnostic ignored \"-Wtype-limits\"") \
|
|
\
|
|
if (intmax_t (__v) < 0 || __v >= __h) { \
|
|
assert_message ("expected: 0 <= " #V " <= " #H); \
|
|
breakpoint (); \
|
|
}; \
|
|
\
|
|
_Pragma("GCC diagnostic pop") \
|
|
); \
|
|
} while (0)
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define CHECK_NEQ(A,B) do { \
|
|
DEBUG_ONLY( \
|
|
const auto &__a = (A); \
|
|
const auto &__b = (B); \
|
|
\
|
|
if (::cruft::almost_equal (__a, __b)) { \
|
|
assert_message ("expected: " #A " != " #B); \
|
|
breakpoint (); \
|
|
}; \
|
|
); \
|
|
} while (0)
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define CHECK_ZERO(A) do { \
|
|
DEBUG_ONLY ( \
|
|
const auto &__a = (A); \
|
|
\
|
|
if (!::cruft::almost_zero (__a)) { \
|
|
assert_message ("expected: " #A " == 0"); \
|
|
breakpoint (); \
|
|
}; \
|
|
); \
|
|
} while (0)
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define CHECK_NEZ(A) do { \
|
|
DEBUG_ONLY ( \
|
|
const auto &__a = (A); \
|
|
\
|
|
if (::cruft::exactly_zero (__a)) { \
|
|
assert_message ("expected: " #A " != 0"); \
|
|
breakpoint (); \
|
|
} \
|
|
); \
|
|
} while (0)
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#define CHECK_MOD(V,M) do { \
|
|
DEBUG_ONLY ( \
|
|
const auto &__check_mod_v = (V); \
|
|
const auto &__check_mod_m = (M); \
|
|
\
|
|
if (!::cruft::exactly_zero (__check_mod_v % __check_mod_m)) { \
|
|
assert_message ("expected: " #V " % " #M " == 0"); \
|
|
breakpoint (); \
|
|
} \
|
|
); \
|
|
} while (0)
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#if defined(ENABLE_DEBUGGING)
|
|
#define CHECK_ENUM(C, ...) do { \
|
|
const auto &__c = (C); \
|
|
const auto &__e = { __VA_ARGS__ }; \
|
|
\
|
|
if (std::find (std::cbegin (__e), \
|
|
std::cend (__e), \
|
|
__c) == std::end (__e)) { \
|
|
assert_message ("expected: " #C " in " #__VA_ARGS__); \
|
|
breakpoint (); \
|
|
} \
|
|
} while (0)
|
|
#else
|
|
#define CHECK_ENUM(C,...)
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
#if !defined(NDEBUG)
|
|
#define CHECK_FINITE(V) do { \
|
|
const auto &__v = (V); \
|
|
if (!std::isfinite (__v)) { \
|
|
assert_message ("expected: " #V " is finite"); \
|
|
breakpoint (); \
|
|
} \
|
|
} while (0)
|
|
#else
|
|
#define CHECK_FINITE(V,...)
|
|
#endif
|