assert.h

Go to the documentation of this file.

#pragma once
 
#include "pixelbullet/core/debug_break.h"
#include "pixelbullet/logging/log.h"
 
#include <fmt/format.h>
 
#include <cstdlib>
#include <utility>

 
namespace pixelbullet::assert_internal
{
[[noreturn]] inline void fail_assertion(const char* file, int line, const char* condition_str)
{
    log::error("Assertion '{}' failed at {}:{}", condition_str, file, line);
    platform::debug_break();
    std::abort();
}

template <typename... Args>
[[noreturn]] void fail_assertion(const char* file, int line, const char* condition_str, fmt::format_string<Args...> msg, Args&&... args)
{
    log::error("Assertion '{}' failed at {}:{}: {}", condition_str, file, line, fmt::format(msg, std::forward<Args>(args)...));
    platform::debug_break();
    std::abort();
}

[[noreturn]] inline void panic(const char* file, int line)
{
    log::error("Panic triggered at {}:{}", file, line);
    platform::debug_break();
    std::abort();
}

template <typename... Args>
[[noreturn]] void panic(const char* file, int line, fmt::format_string<Args...> msg, Args&&... args)
{
    log::error("Panic triggered at {}:{}: {}", file, line, fmt::format(msg, std::forward<Args>(args)...));
    platform::debug_break();
    std::abort();
}

[[noreturn]] inline void unreachable(const char* file, int line)
{
    log::error("Reached unreachable code at {}:{}", file, line);
    platform::debug_break();
    std::abort();
}

template <typename... Args>
[[noreturn]] void unreachable(const char* file, int line, fmt::format_string<Args...> msg, Args&&... args)
{
    log::error("Reached unreachable code at {}:{}: {}", file, line, fmt::format(msg, std::forward<Args>(args)...));
    platform::debug_break();
    std::abort();
}
 
} // namespace pixelbullet::assert_internal
 
// -----------------------------------------------------------------------------
// === Conditional Assertions ================================================
// -----------------------------------------------------------------------------

#define ASSERT(condition, ...)                                                                                       \
    do                                                                                                               \
    {                                                                                                                \
        if (!(condition))                                                                                            \
        {                                                                                                            \
            pixelbullet::assert_internal::fail_assertion(__FILE__, __LINE__, #condition __VA_OPT__(, ) __VA_ARGS__); \
        }                                                                                                            \
    } while (0)

#ifdef PB_DEBUG
#define DEBUG_ASSERT(condition, ...) ASSERT(condition __VA_OPT__(, ) __VA_ARGS__)
#else
#define DEBUG_ASSERT(condition, ...) ((void)0)
#endif

#ifdef PB_DEBUG
#define ASSUME(condition, ...) ASSERT(condition __VA_OPT__(, ) __VA_ARGS__)
#else
#if defined(_MSC_VER)
#define ASSUME(condition, ...) __assume(condition)
#elif defined(__clang__) || defined(__GNUC__)
#define ASSUME(condition, ...)       \
    do                               \
    {                                \
        if (!(condition))            \
            __builtin_unreachable(); \
    } while (0)
#else
#define ASSUME(condition, ...) ((void)0)
#endif
#endif
 
// -----------------------------------------------------------------------------
// === Unconditional Assertions ================================================
// -----------------------------------------------------------------------------

#define PANIC(...)                                                                          \
    do                                                                                      \
    {                                                                                       \
        pixelbullet::assert_internal::panic(__FILE__, __LINE__ __VA_OPT__(, ) __VA_ARGS__); \
    } while (0)

#ifdef PB_DEBUG
#define UNREACHABLE(...)                                                                          \
    do                                                                                            \
    {                                                                                             \
        pixelbullet::assert_internal::unreachable(__FILE__, __LINE__ __VA_OPT__(, ) __VA_ARGS__); \
    } while (0)
#else
#if defined(_MSC_VER)
#define UNREACHABLE(...) __assume(0)
#elif defined(__clang__) || defined(__GNUC__)
#define UNREACHABLE(...) __builtin_unreachable()
#else
#define UNREACHABLE(...) ((void)0)
#endif
#endif