Assert.hpp

Go to the documentation of this file.

#pragma once
 
#include "PixelBullet/Application/Log.hpp"
 
#include <fmt/format.h>
 
#include <cstdlib>
#include <filesystem>
 
#if defined(_WIN32)
#define DEBUG_BREAK() __debugbreak()
#elif defined(__linux__)
#include <signal.h>
#define DEBUG_BREAK() raise(SIGTRAP)
#else
#define DEBUG_BREAK() std::abort()
#endif
 
namespace PixelBullet
{
    inline void Fail(const char* file, int line, const char* conditionStr)
    {
        Log::Error("Assertion '{}' failed at {}:{}", conditionStr, file, line);
        DEBUG_BREAK();
        std::abort();
    }
 
    template <typename... Args>
    void Fail(const char* file, int line, const char* conditionStr, fmt::format_string<Args...> msg, Args&&... args)
    {
        Log::Error(msg, std::forward<Args>(args)...);
        DEBUG_BREAK();
        std::abort();
    }
 
    inline void Panic(const char* file, int line)
    {
        Log::Error("Panic triggered at {}:{}", file, line);
        DEBUG_BREAK();
        std::abort();
    }
 
    template <typename... Args>
    void Panic(const char* file, int line, fmt::format_string<Args...> msg, Args&&... args)
    {
        Log::Error(msg, std::forward<Args>(args)...);
        DEBUG_BREAK();
        std::abort();
    }
 
    inline void Unreachable(const char* file, int line)
    {
        Log::Error("Reached unreachable code at {}:{}", file, line);
        DEBUG_BREAK();
        std::abort();
    }
 
    template <typename... Args>
    void Unreachable(const char* file, int line, fmt::format_string<Args...> msg, Args&&... args)
    {
        Log::Error(msg, std::forward<Args>(args)...);
        DEBUG_BREAK();
        std::abort();
    }
 
} // namespace PixelBullet
 
// -----------------------------------------------------------------------------
// === Conditional Assertions ================================================
// -----------------------------------------------------------------------------
 
#define ASSERT(condition, ...)                                                \
    do                                                                        \
    {                                                                         \
        if (!(condition))                                                     \
        {                                                                     \
            PixelBullet::Fail(__FILE__, __LINE__, #condition, ##__VA_ARGS__); \
        }                                                                     \
    } while (0)
 
#ifdef PB_DEBUG
#define DEBUG_ASSERT(condition, ...) ASSERT(condition, ##__VA_ARGS__)
#else
#define DEBUG_ASSERT(condition, ...) ((void)0)
#endif
 
#ifdef PB_DEBUG
#define ASSUME(condition, ...) ASSERT(condition, ##__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::Panic(__FILE__, __LINE__, ##__VA_ARGS__); \
    } while (0)
 
#ifdef PB_DEBUG
#define UNREACHABLE(...)                                             \
    do                                                               \
    {                                                                \
        PixelBullet::Unreachable(__FILE__, __LINE__, ##__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