UT/UT_Assert.h

Go to the documentation of this file.

// UT_Assert.h
//
// Custom portable UT_ASSERT macro
//

#ifndef UT_ASSERT_H_INCLUDED
#define UT_ASSERT_H_INCLUDED

#include "UT_API.h"
#define UT_ASSERT_LEVEL_NONE        0
#define UT_ASSERT_LEVEL_NORMAL      1
#define UT_ASSERT_LEVEL_PARANOID    2
#define UT_ASSERT_LEVEL_SLOW        3

#ifndef UT_ASSERT_LEVEL
    #define UT_ASSERT_LEVEL UT_ASSERT_LEVEL_NONE
#endif

// Generates an assertion. Returns TRUE if we should ignore further asserts.
UT_API void UT_Assert( const char *file, int linenum, const char *function,
               const char *condition, const char *reason, int &ignoreflag);

// Methods to temporarily disable interactive asserts in specific dangerous
// situations.
UT_API void UTdisableInteractiveAssertsOn();
UT_API void UTdisableInteractiveAssertsOff();

#if defined(__GNUC__)
#   define UT_ASSERT_FUNC __PRETTY_FUNCTION__
#elif defined(_MSC_VER) || defined(__FUNCTION__)
#   define UT_ASSERT_FUNC __FUNCTION__ "()"
#else
#   define UT_ASSERT_FUNC ((char *)0)
#endif

#if (UT_ASSERT_LEVEL > UT_ASSERT_LEVEL_NONE)
    #ifdef UT_INTERNAL_ASSERT
        #error UT_INTERNAL_UT_ASSERT is already defined!
    #endif
    #define UT_INTERNAL_ASSERT(ZZ, MM)  \
            do {                        \
                static int ignore = 0;  \
                if( !ignore && !(ZZ) )  \
                    UT_Assert( __FILE__, __LINE__, UT_ASSERT_FUNC, #ZZ, MM, \
                               ignore); \
            } while (false)
#endif

#ifdef UT_ASSERT_P
    #error UT_ASSERT_P is already defined!
#endif
#ifdef UT_ASSERT_SLOW
    #error UT_ASSERT_SLOW is already defined!
#endif
#ifdef UT_ASSERT
    #error UT_ASSERT is already defined!
#endif

// do these in descending order:
#if (UT_ASSERT_LEVEL >= UT_ASSERT_LEVEL_SLOW)
    #define UT_ASSERT_SLOW(ZZ)          UT_INTERNAL_ASSERT(ZZ, 0)
    #define UT_ASSERT_P(ZZ)             UT_INTERNAL_ASSERT(ZZ, 0)
    #define UT_ASSERT(ZZ)               UT_INTERNAL_ASSERT(ZZ, 0)
    #define UT_ASSERT_MSG_SLOW(ZZ, MM)  UT_INTERNAL_ASSERT(ZZ, MM)
    #define UT_ASSERT_MSG_P(ZZ, MM)     UT_INTERNAL_ASSERT(ZZ, MM)
    #define UT_ASSERT_MSG(ZZ, MM)       UT_INTERNAL_ASSERT(ZZ, MM)
#elif (UT_ASSERT_LEVEL >= UT_ASSERT_LEVEL_PARANOID)
    #define UT_ASSERT_SLOW(ZZ)          ((void)0)
    #define UT_ASSERT_P(ZZ)             UT_INTERNAL_ASSERT(ZZ, 0)
    #define UT_ASSERT(ZZ)               UT_INTERNAL_ASSERT(ZZ, 0)
    #define UT_ASSERT_MSG_SLOW(ZZ, MM)  ((void)0)
    #define UT_ASSERT_MSG_P(ZZ, MM)     UT_INTERNAL_ASSERT(ZZ, MM)
    #define UT_ASSERT_MSG(ZZ, MM)       UT_INTERNAL_ASSERT(ZZ, MM)
#elif (UT_ASSERT_LEVEL >= UT_ASSERT_LEVEL_NORMAL)
    #define UT_ASSERT_SLOW(ZZ)          ((void)0)
    #define UT_ASSERT_P(ZZ)             ((void)0)
    #define UT_ASSERT(ZZ)               UT_INTERNAL_ASSERT(ZZ, 0)
    #define UT_ASSERT_MSG_SLOW(ZZ, MM)  ((void)0)
    #define UT_ASSERT_MSG_P(ZZ, MM)     ((void)0)
    #define UT_ASSERT_MSG(ZZ, MM)       UT_INTERNAL_ASSERT(ZZ, MM)
#else // if (UT_ASSERT_LEVEL >= UT_ASSERT_LEVEL_NONE)
    #define UT_ASSERT_SLOW(ZZ)          ((void)0)
    #define UT_ASSERT_P(ZZ)             ((void)0)
    #define UT_ASSERT(ZZ)               ((void)0)
    #define UT_ASSERT_MSG_SLOW(ZZ, MM)  ((void)0)
    #define UT_ASSERT_MSG_P(ZZ, MM)     ((void)0)
    #define UT_ASSERT_MSG(ZZ, MM)       ((void)0)
#endif

// Compile-time assertion support.
#if defined(IRIX6)
    #define UT_ASSERT_COMPILETIME(expr)
#else
template<bool> struct CompileTimeError;
template<> struct CompileTimeError<true> {};
#define UT_ASSERT_COMPILETIME(expr) \
        CompileTimeError<(expr) != 0>()
#endif

// This macro allows you to enable a block of code only
// when UT_ASSERT is enabled. This will help clean up
// "unreferenced variables" in the case where you have variables that
// are only referenced in asserts.

#if UT_ASSERT_LEVEL >= 1
#define UT_IF_ASSERT(ZZ) ZZ
#define UT_IFNOT_ASSERT(ZZ)
#else
#define UT_IF_ASSERT(ZZ)
#define UT_IFNOT_ASSERT(ZZ) ZZ
#endif

// When asserts are enabled, UT_VERIFY() will trigger an assert if the expr
// is false. When asserts are disabled, the expr is still evaluated.
#if UT_ASSERT_LEVEL >= 1
    #define UT_VERIFY(expr) UT_ASSERT(expr)
#else
    #define UT_VERIFY(expr) ((void)(expr))
#endif

enum UT_AssertResponse
{
    UT_ASSERT_RESPONSE_DEBUG,
    UT_ASSERT_RESPONSE_IGNORE,
    UT_ASSERT_RESPONSE_IGNORE_ALL,
    UT_ASSERT_RESPONSE_TRACE,
    UT_ASSERT_RESPONSE_ERROR
};

#endif // UT_ASSERT_H_INCLUDED

---