Assert.h

// WARNING: Changes to this file must be contributed back to Sawyer or else they will
//          be clobbered by the next update from Sawyer.  The Sawyer repository is at
//          https://gitlab.com/charger7534/sawyer.git.
 
 
 
 
#ifndef Sawyer_Assert_H
#define Sawyer_Assert_H
 
#include <Sawyer/Sawyer.h>
 
#include <boost/config.hpp>
#include <boost/lexical_cast.hpp>
#include <string>
#ifdef __clang_analyzer__
#include <cassert>
#endif
 
// If SAWYER_NDEBUG is defined then some of the macros defined in this header become no-ops.  For interoperability with the
// more standard NDEBUG symbol, we define SAWYER_NDEBUG if NDEBUG is defined.
#ifdef NDEBUG
#undef SAWYER_NDEBUG
#define SAWYER_NDEBUG
#endif
 
namespace Sawyer {                                      // documented elsewhere
 
namespace Assert {
 
SAWYER_EXPORT
#ifndef BOOST_WINDOWS
[[noreturn]]
#endif
void fail(const char *mesg, const char *expr, const std::string &note,
          const char *filename, unsigned linenum, const char *funcname);
 
typedef void (*AssertFailureHandler)(const char *mesg, const char *expr, const std::string &note,
                                     const char *filename, unsigned linenum, const char *funcname);
 
SAWYER_EXPORT extern AssertFailureHandler assertFailureHandler;
 
} // namespace
} // namespace
 
// These "always" macros are enabled regardless of whether SAWYER_NDEBUG is defined.  Don't use them for
// expensive assertions.
 
#define ASSERT_always_require(expr) ASSERT_always_require2(expr, "")
#define ASSERT_always_forbid(expr) ASSERT_always_forbid2(expr, "")
#define ASSERT_always_not_null(expr) ASSERT_always_not_null2(expr, "")
#define ASSERT_always_not_reachable(note)                                                                                      \
    Sawyer::Assert::fail("reached impossible state", NULL, boost::lexical_cast<std::string>(note),                             \
                         __FILE__, __LINE__, SAWYER_PRETTY_FUNCTION)
#define ASSERT_always_not_implemented(note)                                                                                    \
    Sawyer::Assert::fail("not implemented yet", NULL, boost::lexical_cast<std::string>(note),                                  \
                         __FILE__, __LINE__, SAWYER_PRETTY_FUNCTION)
 
#ifdef __clang_analyzer__
    // The Clang analyzer doesn't recognize Sawyer::Assert::fail, but it does recognize C's assert
    #define ASSERT_always_require2(expr, note) assert(expr)
    #define ASSERT_always_forbid2(expr, note) assert(!(expr))
    #define ASSERT_always_not_null2(expr, note) assert((expr) != nullptr)
    #define ASSERT_always_this() assert(this != NULL)
#else
    #define ASSERT_always_require2(expr, note)                                                                                 \
        ((expr) ?                                                                                                              \
            static_cast<void>(0) :                                                                                             \
            Sawyer::Assert::fail("assertion failed", "required: " #expr, boost::lexical_cast<std::string>(note),               \
                                 __FILE__, __LINE__, SAWYER_PRETTY_FUNCTION))
 
    #define ASSERT_always_forbid2(expr, note)                                                                                  \
        (!(expr) ?                                                                                                             \
            static_cast<void>(0) :                                                                                             \
            Sawyer::Assert::fail("assertion failed",                                                                           \
                                 "forbidden: " #expr, boost::lexical_cast<std::string>(note),                                  \
                                 __FILE__, __LINE__, SAWYER_PRETTY_FUNCTION))
 
    #define ASSERT_always_not_null2(expr, note)                                                                                \
        ((expr)!=NULL ?                                                                                                        \
            static_cast<void>(0) :                                                                                             \
            Sawyer::Assert::fail("null pointer",                                                                               \
                                 #expr, boost::lexical_cast<std::string>(note), __FILE__, __LINE__, SAWYER_PRETTY_FUNCTION))
 
    #if defined(__GNUC__) && !defined(__clang__)
        #define ROSE_ASSERT_DIAG_PUSH    _Pragma("GCC diagnostic push")
        #define ROSE_ASSERT_DIAG_POP     _Pragma("GCC diagnostic pop")
        #define ROSE_ASSERT_DIAG_IGNORED _Pragma("GCC diagnostic ignored \"-Wnonnull-compare\"")
    #elif defined(__clang__)
        #define ROSE_ASSERT_DIAG_PUSH    _Pragma("GCC diagnostic push")
        #define ROSE_ASSERT_DIAG_POP     _Pragma("GCC diagnostic pop")
        #define ROSE_ASSERT_DIAG_IGNORED _Pragma("GCC diagnostic ignored \"-Wtautological-undefined-compare\"")
    #else
        #define ROSE_ASSERT_DIAG_PUSH
        #define ROSE_ASSERT_DIAG_POP
        #define ROSE_ASSERT_DIAG_IGNORED
    #endif
 
    #define ASSERT_suppress_nonnull_compare(expr)                                                                              \
        do {                                                                                                                   \
            ROSE_ASSERT_DIAG_PUSH                                                                                              \
            ROSE_ASSERT_DIAG_IGNORED                                                                                           \
            expr;                                                                                                              \
            ROSE_ASSERT_DIAG_POP                                                                                               \
        } while (false)
 
    #define ASSERT_always_this()                                                                                                     \
        ASSERT_suppress_nonnull_compare((this != NULL) ?                                                                       \
            static_cast<void>(0) :                                                                                             \
            Sawyer::Assert::fail("null pointer",                                                                               \
                                 "this != NULL", boost::lexical_cast<std::string>(""), __FILE__, __LINE__,                     \
                                                 SAWYER_PRETTY_FUNCTION))
#endif
 
// The non-"always" macros might change behavior based on whether SAWYER_NDEBUG is defined.
 
#if defined(SAWYER_NDEBUG) && !defined(__clang_analyzer__)
 
#define ASSERT_require(expr)            /*void*/
#define ASSERT_require2(expr, note)     /*void*/
#define ASSERT_forbid(expr)             /*void*/
#define ASSERT_forbid2(expr, note)      /*void*/
#define ASSERT_not_null(expr)           /*void*/
#define ASSERT_not_null2(expr, note)    /*void*/
#define ASSERT_not_reachable(note)      ASSERT_always_not_reachable(note)
#define ASSERT_not_implemented(note)    ASSERT_always_not_implemented(note)
#define ASSERT_this()                   /*void*/
 
#else
 
#define ASSERT_require(expr)            ASSERT_always_require(expr)
#define ASSERT_require2(expr, note)     ASSERT_always_require2(expr, note)
#define ASSERT_forbid(expr)             ASSERT_always_forbid(expr)
#define ASSERT_forbid2(expr, note)      ASSERT_always_forbid2(expr, note)
#define ASSERT_not_null(expr)           ASSERT_always_not_null(expr)
#define ASSERT_not_null2(expr, note)    ASSERT_always_not_null2(expr, note)
#define ASSERT_not_reachable(note)      ASSERT_always_not_reachable(note)
#define ASSERT_not_implemented(note)    ASSERT_always_not_implemented(note)
#define ASSERT_this()                   ASSERT_always_this()
 
#endif
 
// Macros recognized by some IDEs
 
#define TODO(note)                                                                                                             \
    Sawyer::Assert::fail("not implemented yet", NULL, boost::lexical_cast<std::string>(note),                                  \
                         __FILE__, __LINE__, SAWYER_PRETTY_FUNCTION)
 
#define FIXME(note)                                                                                                            \
    Sawyer::Assert::fail("needs to be fixed", NULL, boost::lexical_cast<std::string>(note),                                    \
                         __FILE__, __LINE__, SAWYER_PRETTY_FUNCTION)
 
#endif