assert.h revision 3b17034e6db69e4f1f9009ea10ef64239a76bd28
/** @file
* IPRT - Assertions.
*/
/*
* Copyright (C) 2006-2012 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* The contents of this file may alternatively be used under the terms
* of the Common Development and Distribution License Version 1.0
* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
* VirtualBox OSE distribution, in which case the provisions of the
* CDDL are applicable instead of those of the GPL.
*
* You may elect to license modified versions of this file under the
* terms and conditions of either the GPL or the CDDL or both.
*/
#ifndef ___iprt_assert_h
#define ___iprt_assert_h
/** @defgroup grp_rt_assert Assert - Assertions
* @ingroup grp_rt
*
* Assertions are generally used to check preconditions and other
* assumptions. Sometimes it is also used to catch odd errors or errors
* that one would like to inspect in the debugger. They should not be
* used for errors that happen frequently.
*
* IPRT provides a host of assertion macros, so many that it can be a bit
* overwhelming at first. Don't despair, there is a system (surprise).
*
* First there are four families of assertions:
* - Assert - The normal strict build only assertions.
* - AssertLogRel - Calls LogRel() in non-strict builds, otherwise like Assert.
* - AssertRelease - Triggers in all builds.
* - AssertFatal - Triggers in all builds and cannot be continued.
*
* Then there are variations wrt to argument list and behavior on failure:
* - Msg - Custom RTStrPrintf-like message with the assertion message.
* - Return - Return the specific rc on failure.
* - ReturnVoid - Return (void) on failure.
* - Stmt - Execute the specified statement(s) on failure.
* - RC - Assert RT_SUCCESS.
* - RCSuccess - Assert VINF_SUCCESS.
*
* In addition there is a very special family AssertCompile that can be
* used for some limited compile-time checking, like structure sizes and member
* alignment. This family doesn't have the same variations.
*
*
* @remarks As you might have noticed, the macros don't follow the
* coding guidelines wrt to macros supposedly being all uppercase
* and underscored. For various reasons they don't, and nobody
* has complained yet. Wonder why... :-)
*
* @remarks Each project has its own specific guidelines on how to use
* assertions, so the above is just trying to give you the general idea
* from the IPRT point of view.
*
* @{
*/
/**
* The 1st part of an assert message.
*
* @param pszExpr Expression. Can be NULL.
* @param uLine Location line number.
* @param pszFile Location file name.
* @param pszFunction Location function name.
*/
RTDECL(void) RTAssertMsg1(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction);
/**
* Weak version of RTAssertMsg1 that can be overridden locally in a module to
* modify, redirect or otherwise mess with the assertion output.
*
* @copydoc RTAssertMsg1
*/
RTDECL(void) RTAssertMsg1Weak(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction);
/**
* The 2nd (optional) part of an assert message.
*
* @param pszFormat Printf like format string.
* @param ... Arguments to that string.
*/
/**
* Weak version of RTAssertMsg2 that forwards to RTAssertMsg2WeakV.
*
* There is not need to override this, check out RTAssertMsg2WeakV instead!
*
* @copydoc RTAssertMsg2
*/
/**
* The 2nd (optional) part of an assert message.
*
* @param pszFormat Printf like format string.
* @param va Arguments to that string.
*/
/**
* Weak version of RTAssertMsg2V that can be overridden locally in a module to
* modify, redirect or otherwise mess with the assertion output.
*
* @copydoc RTAssertMsg2V
*/
/**
* Additional information which should be appended to the 2nd part of an
* assertion message.
*
* @param pszFormat Printf like format string.
* @param ... Arguments to that string.
*/
/**
* Weak version of RTAssertMsg2Add that forwards to RTAssertMsg2AddWeakV.
*
* There is not need to override this, check out RTAssertMsg2AddWeakV instead!
*
* @copydoc RTAssertMsg2Add
*/
/**
* Additional information which should be appended to the 2nd part of an
* assertion message.
*
* @param pszFormat Printf like format string.
* @param va Arguments to that string.
*/
/**
* Weak version of RTAssertMsg2AddV that can be overridden locally in a module
* to modify, redirect or otherwise mess with the assertion output.
*
* @copydoc RTAssertMsg2AddV
*/
#ifdef IN_RING0
/**
* Panics the system as the result of a fail assertion.
*/
RTR0DECL(void) RTR0AssertPanicSystem(void);
#endif /* IN_RING0 */
/**
* Overridable function that decides whether assertions executes the panic
* (breakpoint) or not.
*
* The generic implementation will return true.
*
* @returns true if the breakpoint should be hit, false if it should be ignored.
*
* @remark The RTDECL() makes this a bit difficult to override on Windows. So,
* you'll have to use RTASSERT_HAVE_SHOULD_PANIC or
* RTASSERT_HAVE_SHOULD_PANIC_PRIVATE there to control the kind of
* prototype.
*/
#if !defined(RTASSERT_HAVE_SHOULD_PANIC) && !defined(RTASSERT_HAVE_SHOULD_PANIC_PRIVATE)
RTDECL(bool) RTAssertShouldPanic(void);
#elif defined(RTASSERT_HAVE_SHOULD_PANIC_PRIVATE)
bool RTAssertShouldPanic(void);
#else
#endif
/**
* Controls whether the assertions should be quiet or noisy (default).
*
* @returns The old setting.
* @param fQuiet The new setting.
*/
/**
* Are assertions quiet or noisy?
*
* @returns True if they are quiet, false if noisy.
*/
RTDECL(bool) RTAssertAreQuiet(void);
/**
* Makes the assertions panic (default) or not.
*
* @returns The old setting.
* @param fPanic The new setting.
*/
/**
* Can assertion panic.
*
* @returns True if they can, false if not.
*/
RTDECL(bool) RTAssertMayPanic(void);
/** @name Globals for crash analysis
* @remarks This is the full potential set, it
* @{
*/
/** The last assert message, 1st part. */
/** The last assert message, 2nd part. */
/** The last assert message, expression. */
extern RTDATADECL(const char * volatile) g_pszRTAssertExpr;
/** The last assert message, file name. */
extern RTDATADECL(const char * volatile) g_pszRTAssertFile;
/** The last assert message, line number. */
/** The last assert message, function name. */
extern RTDATADECL(const char * volatile) g_pszRTAssertFunction;
/** @} */
/** @def RTAssertDebugBreak()
* Debugger breakpoint instruction.
*
* @remarks This macro does not depend on RT_STRICT.
*/
#define RTAssertDebugBreak() do { RT_BREAKPOINT(); } while (0)
/** @name Compile time assertions.
*
* and similar compile time expressions.
*
* @{
*/
/**
* RTASSERTTYPE is the type the AssertCompile() macro redefines.
* It has no other function and shouldn't be used.
* Visual C++ uses this.
*/
typedef int RTASSERTTYPE[1];
/**
* RTASSERTVAR is the type the AssertCompile() macro redefines.
* It has no other function and shouldn't be used.
* GCC uses this.
*/
#ifdef __GNUC__
#endif
extern int RTASSERTVAR[1];
#ifdef __GNUC__
#endif
/** @def RTASSERT_HAVE_STATIC_ASSERT
* Indicates that the compiler implements static_assert(expr, msg).
*/
#ifdef _MSC_VER
# define RTASSERT_HAVE_STATIC_ASSERT
# endif
#endif
#if defined(__GNUC__) && defined(__GXX_EXPERIMENTAL_CXX0X__)
# define RTASSERT_HAVE_STATIC_ASSERT
#endif
#ifdef DOXYGEN_RUNNING
# define RTASSERT_HAVE_STATIC_ASSERT
#endif
/** @def AssertCompileNS
* Asserts that a compile-time expression is true. If it's not break the build.
*
* This differs from AssertCompile in that it accepts some more expressions
* than what C++0x allows - NS = Non-standard.
*
* @param expr Expression which should be true.
*/
#ifdef __GNUC__
# define AssertCompileNS(expr) extern int RTASSERTVAR[1] __attribute__((unused)), RTASSERTVAR[(expr) ? 1 : 0] __attribute__((unused))
#else
#endif
/** @def AssertCompile
* Asserts that a C++0x compile-time expression is true. If it's not break the
* build.
* @param expr Expression which should be true.
*/
#ifdef RTASSERT_HAVE_STATIC_ASSERT
#else
#endif
/** @def RTASSERT_OFFSET_OF()
* A offsetof() macro suitable for compile time assertions.
* Both GCC v4 and VisualAge for C++ v3.08 has trouble using RT_OFFSETOF.
*/
#if defined(__GNUC__)
# if __GNUC__ >= 4
# else
# endif
#else
#endif
/** @def AssertCompileSize
* Asserts a size at compile.
* @param type The type.
* @param size The expected type size.
*/
/** @def AssertCompileSizeAlignment
* Asserts a size alignment at compile.
* @param type The type.
* @param align The size alignment to assert.
*/
/** @def AssertCompileMemberSize
* Asserts a member offset alignment at compile.
* @param type The type.
* @param member The member.
* @param size The member size to assert.
*/
/** @def AssertCompileMemberSizeAlignment
* Asserts a member size alignment at compile.
* @param type The type.
* @param member The member.
* @param align The member size alignment to assert.
*/
/** @def AssertCompileMemberAlignment
* Asserts a member offset alignment at compile.
* @param type The type.
* @param member The member.
* @param align The member offset alignment to assert.
*/
/** @def AssertCompileMemberOffset
* Asserts an offset of a structure member at compile.
* @param type The type.
* @param member The member.
* @param off The expected offset.
*/
/** @def AssertCompile2MemberOffsets
* Asserts that two (sub-structure) members in union have the same offset.
* @param type The type.
* @param member1 The first member.
* @param member2 The second member.
*/
/** @def AssertCompileAdjacentMembers
* Asserts that two structure members are adjacent.
* @param type The type.
* @param member1 The first member.
* @param member2 The second member.
*/
AssertCompile(RTASSERT_OFFSET_OF(type, member1) + RT_SIZEOFMEMB(type, member1) == RTASSERT_OFFSET_OF(type, member2))
/** @def AssertCompileMembersAtSameOffset
* Asserts that members of two different structures are at the same offset.
* @param type1 The first type.
* @param member1 The first member.
* @param type2 The second type.
* @param member2 The second member.
*/
/** @def AssertCompileMembersSameSize
* Asserts that members of two different structures have the same size.
* @param type1 The first type.
* @param member1 The first member.
* @param type2 The second type.
* @param member2 The second member.
*/
/** @def AssertCompileMembersSameSizeAndOffset
* Asserts that members of two different structures have the same size and are
* at the same offset.
* @param type1 The first type.
* @param member1 The first member.
* @param type2 The second type.
* @param member2 The second member.
*/
/** @} */
/** @name Assertions
*
* These assertions will only trigger when RT_STRICT is defined. When it is
* undefined they will all be no-ops and generate no code.
*
* @{
*/
/** @def RTASSERT_QUIET
* This can be defined to shut up the messages for a file where this would be
* problematic because the message printing code path passes thru it.
* @internal */
#ifdef DOXYGEN_RUNNING
# define RTASSERT_QUIET
#endif
#if defined(RTASSERT_QUIET) && !defined(DOXYGEN_RUNNING)
do { } while (0)
# define RTAssertMsg2Weak if (0) RTAssertMsg2Weak
#endif
/** @def RTAssertDoPanic
* Raises an assertion panic appropriate to the current context.
* @remarks This macro does not depend on RT_STRICT.
*/
#if defined(IN_RING0) \
# define RTAssertDoPanic() RTR0AssertPanicSystem()
#else
# define RTAssertDoPanic() RTAssertDebugBreak()
#endif
/** @def AssertBreakpoint()
* Assertion Breakpoint.
* @deprecated Use RTAssertPanic or RTAssertDebugBreak instead.
*/
#ifdef RT_STRICT
# define AssertBreakpoint() RTAssertDebugBreak()
#else
# define AssertBreakpoint() do { } while (0)
#endif
/** @def RTAssertPanic()
* If RT_STRICT is defined this macro will invoke RTAssertDoPanic if
* RTAssertShouldPanic returns true. If RT_STRICT isn't defined it won't do any
* thing.
*/
#if defined(RT_STRICT) && !defined(RTASSERT_DONT_PANIC)
#else
# define RTAssertPanic() do { } while (0)
#endif
/** @def Assert
* Assert that an expression is true. If false, hit breakpoint.
* @param expr Expression which should be true.
*/
#ifdef RT_STRICT
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertPanic(); \
} \
} while (0)
#else
#endif
/** @def AssertStmt
* Assert that an expression is true. If false, hit breakpoint and execute the
* statement.
* @param expr Expression which should be true.
* @param stmt Statement to execute on failure.
*/
#ifdef RT_STRICT
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertPanic(); \
stmt; \
} \
} while (0)
#else
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
stmt; \
} \
} while (0)
#endif
/** @def AssertReturn
* Assert that an expression is true and returns if it isn't.
* In RT_STRICT mode it will hit a breakpoint before returning.
*
* @param expr Expression which should be true.
* @param rc What is to be presented to return.
*/
#ifdef RT_STRICT
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertPanic(); \
return (rc); \
} \
} while (0)
#else
do { \
if (RT_UNLIKELY(!(expr))) \
return (rc); \
} while (0)
#endif
/** @def AssertReturnStmt
* Assert that an expression is true, if it isn't execute the given statement
* and return rc.
*
* In RT_STRICT mode it will hit a breakpoint before executing the statement and
* returning.
*
* @param expr Expression which should be true.
* @param stmt Statement to execute before returning on failure.
* @param rc What is to be presented to return.
*/
#ifdef RT_STRICT
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertPanic(); \
stmt; \
return (rc); \
} \
} while (0)
#else
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
stmt; \
return (rc); \
} \
} while (0)
#endif
/** @def AssertReturnVoid
* Assert that an expression is true and returns if it isn't.
* In RT_STRICT mode it will hit a breakpoint before returning.
*
* @param expr Expression which should be true.
*/
#ifdef RT_STRICT
# define AssertReturnVoid(expr) \
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertPanic(); \
return; \
} \
} while (0)
#else
# define AssertReturnVoid(expr) \
do { \
if (RT_UNLIKELY(!(expr))) \
return; \
} while (0)
#endif
/** @def AssertReturnVoidStmt
* Assert that an expression is true, if it isn't execute the given statement
* and return.
*
* In RT_STRICT mode it will hit a breakpoint before returning.
*
* @param expr Expression which should be true.
* @param stmt Statement to execute before returning on failure.
*/
#ifdef RT_STRICT
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertPanic(); \
stmt; \
return; \
} \
} while (0)
#else
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
stmt; \
return; \
} \
} while (0)
#endif
/** @def AssertBreak
* Assert that an expression is true and breaks if it isn't.
* In RT_STRICT mode it will hit a breakpoint before returning.
*
* @param expr Expression which should be true.
*/
#ifdef RT_STRICT
# define AssertBreak(expr) \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertPanic(); \
break; \
} else do {} while (0)
#else
# define AssertBreak(expr) \
if (RT_UNLIKELY(!(expr))) \
break; \
else do {} while (0)
#endif
/** @def AssertBreakStmt
* Assert that an expression is true and breaks if it isn't.
* In RT_STRICT mode it will hit a breakpoint before doing break.
*
* @param expr Expression which should be true.
* @param stmt Statement to execute before break in case of a failed assertion.
*/
#ifdef RT_STRICT
if (RT_UNLIKELY(!(expr))) { \
RTAssertPanic(); \
stmt; \
break; \
} else do {} while (0)
#else
if (RT_UNLIKELY(!(expr))) { \
stmt; \
break; \
} else do {} while (0)
#endif
/** @def AssertMsg
* Assert that an expression is true. If it's not print message and hit breakpoint.
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
*/
#ifdef RT_STRICT
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertMsg2Weak a; \
RTAssertPanic(); \
} \
} while (0)
#else
#endif
/** @def AssertMsgStmt
* Assert that an expression is true. If it's not print message and hit
* breakpoint and execute the statement.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
* @param stmt Statement to execute in case of a failed assertion.
*
* @remarks The expression and statement will be evaluated in all build types.
*/
#ifdef RT_STRICT
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertMsg2Weak a; \
RTAssertPanic(); \
stmt; \
} \
} while (0)
#else
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
stmt; \
} \
} while (0)
#endif
/** @def AssertMsgReturn
* Assert that an expression is true and returns if it isn't.
* In RT_STRICT mode it will hit a breakpoint before returning.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
* @param rc What is to be presented to return.
*/
#ifdef RT_STRICT
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertMsg2Weak a; \
RTAssertPanic(); \
return (rc); \
} \
} while (0)
#else
do { \
if (RT_UNLIKELY(!(expr))) \
return (rc); \
} while (0)
#endif
/** @def AssertMsgReturnStmt
* Assert that an expression is true, if it isn't execute the statement and
* return.
*
* In RT_STRICT mode it will hit a breakpoint before returning.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
* @param stmt Statement to execute before returning in case of a failed
* assertion.
* @param rc What is to be presented to return.
*/
#ifdef RT_STRICT
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertMsg2Weak a; \
RTAssertPanic(); \
stmt; \
return (rc); \
} \
} while (0)
#else
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
stmt; \
return (rc); \
} \
} while (0)
#endif
/** @def AssertMsgReturnVoid
* Assert that an expression is true and returns if it isn't.
* In RT_STRICT mode it will hit a breakpoint before returning.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
*/
#ifdef RT_STRICT
# define AssertMsgReturnVoid(expr, a) \
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertMsg2Weak a; \
RTAssertPanic(); \
return; \
} \
} while (0)
#else
# define AssertMsgReturnVoid(expr, a) \
do { \
if (RT_UNLIKELY(!(expr))) \
return; \
} while (0)
#endif
/** @def AssertMsgReturnVoidStmt
* Assert that an expression is true, if it isn't execute the statement and
* return.
*
* In RT_STRICT mode it will hit a breakpoint before returning.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
* @param stmt Statement to execute before break in case of a failed assertion.
*/
#ifdef RT_STRICT
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertMsg2Weak a; \
RTAssertPanic(); \
stmt; \
return; \
} \
} while (0)
#else
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
stmt; \
return; \
} \
} while (0)
#endif
/** @def AssertMsgBreak
* Assert that an expression is true and breaks if it isn't.
* In RT_STRICT mode it will hit a breakpoint before returning.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
*/
#ifdef RT_STRICT
# define AssertMsgBreak(expr, a) \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertMsg2Weak a; \
RTAssertPanic(); \
break; \
} else do {} while (0)
#else
# define AssertMsgBreak(expr, a) \
if (RT_UNLIKELY(!(expr))) \
break; \
else do {} while (0)
#endif
/** @def AssertMsgBreakStmt
* Assert that an expression is true and breaks if it isn't.
* In RT_STRICT mode it will hit a breakpoint before doing break.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
* @param stmt Statement to execute before break in case of a failed assertion.
*/
#ifdef RT_STRICT
if (RT_UNLIKELY(!(expr))) { \
RTAssertMsg2Weak a; \
RTAssertPanic(); \
stmt; \
break; \
} else do {} while (0)
#else
if (RT_UNLIKELY(!(expr))) { \
stmt; \
break; \
} else do {} while (0)
#endif
/** @def AssertFailed
* An assertion failed hit breakpoint.
*/
#ifdef RT_STRICT
# define AssertFailed() \
do { \
RTAssertPanic(); \
} while (0)
#else
# define AssertFailed() do { } while (0)
#endif
/** @def AssertFailedReturn
* An assertion failed, hit breakpoint (RT_STRICT mode only) and return.
*
* @param rc The rc to return.
*/
#ifdef RT_STRICT
# define AssertFailedReturn(rc) \
do { \
RTAssertPanic(); \
return (rc); \
} while (0)
#else
# define AssertFailedReturn(rc) \
do { \
return (rc); \
} while (0)
#endif
/** @def AssertFailedReturnStmt
* An assertion failed, hit breakpoint (RT_STRICT mode only), execute a
* statement and return a value.
*
* @param stmt The statement to execute before returning.
* @param rc The value to return.
*/
#ifdef RT_STRICT
do { \
RTAssertPanic(); \
stmt; \
return (rc); \
} while (0)
#else
do { \
stmt; \
return (rc); \
} while (0)
#endif
/** @def AssertFailedReturnVoid
* An assertion failed, hit breakpoint (RT_STRICT mode only) and return.
*/
#ifdef RT_STRICT
# define AssertFailedReturnVoid() \
do { \
RTAssertPanic(); \
return; \
} while (0)
#else
# define AssertFailedReturnVoid() \
do { \
return; \
} while (0)
#endif
/** @def AssertFailedReturnVoidStmt
* An assertion failed, hit breakpoint (RT_STRICT mode only), execute a
* statement and return.
*
* @param stmt The statement to execute before returning.
*/
#ifdef RT_STRICT
# define AssertFailedReturnVoidStmt(stmt) \
do { \
RTAssertPanic(); \
stmt; \
return; \
} while (0)
#else
# define AssertFailedReturnVoidStmt(stmt) \
do { \
stmt; \
return; \
} while (0)
#endif
/** @def AssertFailedBreak
* An assertion failed, hit breakpoint (RT_STRICT mode only) and break.
*/
#ifdef RT_STRICT
# define AssertFailedBreak() \
if (1) { \
RTAssertPanic(); \
break; \
} else do {} while (0)
#else
# define AssertFailedBreak() \
if (1) \
break; \
else do {} while (0)
#endif
/** @def AssertFailedBreakStmt
* An assertion failed, hit breakpoint (RT_STRICT mode only), execute
* the given statement and break.
*
* @param stmt Statement to execute before break.
*/
#ifdef RT_STRICT
# define AssertFailedBreakStmt(stmt) \
if (1) { \
RTAssertPanic(); \
stmt; \
break; \
} else do {} while (0)
#else
# define AssertFailedBreakStmt(stmt) \
if (1) { \
stmt; \
break; \
} else do {} while (0)
#endif
/** @def AssertMsgFailed
* An assertion failed print a message and a hit breakpoint.
*
* @param a printf argument list (in parenthesis).
*/
#ifdef RT_STRICT
# define AssertMsgFailed(a) \
do { \
RTAssertMsg2Weak a; \
RTAssertPanic(); \
} while (0)
#else
# define AssertMsgFailed(a) do { } while (0)
#endif
/** @def AssertMsgFailedReturn
* An assertion failed, hit breakpoint with message (RT_STRICT mode only) and return.
*
* @param a printf argument list (in parenthesis).
* @param rc What is to be presented to return.
*/
#ifdef RT_STRICT
# define AssertMsgFailedReturn(a, rc) \
do { \
RTAssertMsg2Weak a; \
RTAssertPanic(); \
return (rc); \
} while (0)
#else
# define AssertMsgFailedReturn(a, rc) \
do { \
return (rc); \
} while (0)
#endif
/** @def AssertMsgFailedReturnVoid
* An assertion failed, hit breakpoint with message (RT_STRICT mode only) and return.
*
* @param a printf argument list (in parenthesis).
*/
#ifdef RT_STRICT
# define AssertMsgFailedReturnVoid(a) \
do { \
RTAssertMsg2Weak a; \
RTAssertPanic(); \
return; \
} while (0)
#else
# define AssertMsgFailedReturnVoid(a) \
do { \
return; \
} while (0)
#endif
/** @def AssertMsgFailedBreak
* An assertion failed, hit breakpoint with message (RT_STRICT mode only) and break.
*
* @param a printf argument list (in parenthesis).
*/
#ifdef RT_STRICT
# define AssertMsgFailedBreak(a) \
if (1) { \
RTAssertMsg2Weak a; \
RTAssertPanic(); \
break; \
} else do {} while (0)
#else
# define AssertMsgFailedBreak(a) \
if (1) \
break; \
else do {} while (0)
#endif
/** @def AssertMsgFailedBreakStmt
* An assertion failed, hit breakpoint (RT_STRICT mode only), execute
* the given statement and break.
*
* @param a printf argument list (in parenthesis).
* @param stmt Statement to execute before break.
*/
#ifdef RT_STRICT
# define AssertMsgFailedBreakStmt(a, stmt) \
if (1) { \
RTAssertMsg2Weak a; \
RTAssertPanic(); \
stmt; \
break; \
} else do {} while (0)
#else
# define AssertMsgFailedBreakStmt(a, stmt) \
if (1) { \
stmt; \
break; \
} else do {} while (0)
#endif
/** @} */
/** @name Release Log Assertions
*
* These assertions will work like normal strict assertion when RT_STRICT is
* defined and LogRel statements when RT_STRICT is undefined. Typically used for
* things which shouldn't go wrong, but when it does you'd like to know one way
* or the other.
*
* @{
*/
/** @def RTAssertLogRelMsg1
* RTAssertMsg1Weak (strict builds) / LogRel wrapper (non-strict).
*/
#ifdef RT_STRICT
#else
LogRel(("AssertLogRel %s(%d) %s: %s\n",\
#endif
/** @def RTAssertLogRelMsg2
* RTAssertMsg2Weak (strict builds) / LogRel wrapper (non-strict).
*/
#ifdef RT_STRICT
# define RTAssertLogRelMsg2(a) RTAssertMsg2Weak a
#else
# define RTAssertLogRelMsg2(a) LogRel(a)
#endif
/** @def AssertLogRel
* Assert that an expression is true.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param expr Expression which should be true.
*/
#define AssertLogRel(expr) \
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertPanic(); \
} \
} while (0)
/** @def AssertLogRelReturn
* Assert that an expression is true, return \a rc if it isn't.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param expr Expression which should be true.
* @param rc What is to be presented to return.
*/
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertPanic(); \
return (rc); \
} \
} while (0)
/** @def AssertLogRelReturnVoid
* Assert that an expression is true, return void if it isn't.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param expr Expression which should be true.
*/
#define AssertLogRelReturnVoid(expr) \
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertPanic(); \
return; \
} \
} while (0)
/** @def AssertLogRelBreak
* Assert that an expression is true, break if it isn't.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param expr Expression which should be true.
*/
#define AssertLogRelBreak(expr) \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertPanic(); \
break; \
} \
else do {} while (0)
/** @def AssertLogRelBreakStmt
* Assert that an expression is true, execute \a stmt and break if it isn't.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param expr Expression which should be true.
* @param stmt Statement to execute before break in case of a failed assertion.
*/
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertPanic(); \
stmt; \
break; \
} else do {} while (0)
/** @def AssertLogRelMsg
* Assert that an expression is true.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
*/
#define AssertLogRelMsg(expr, a) \
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertLogRelMsg2(a); \
RTAssertPanic(); \
} \
} while (0)
/** @def AssertLogRelMsgStmt
* Assert that an expression is true, execute \a stmt and break if it isn't
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
* @param stmt Statement to execute in case of a failed assertion.
*/
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertLogRelMsg2(a); \
RTAssertPanic(); \
stmt; \
} \
} while (0)
/** @def AssertLogRelMsgReturn
* Assert that an expression is true, return \a rc if it isn't.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
* @param rc What is to be presented to return.
*/
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertLogRelMsg2(a); \
RTAssertPanic(); \
return (rc); \
} \
} while (0)
/** @def AssertLogRelMsgReturnStmt
* Assert that an expression is true, execute @a stmt and return @a rcRet if it
* isn't.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
* @param stmt Statement to execute before returning in case of a failed
* assertion.
* @param rcRet What is to be presented to return.
*/
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertLogRelMsg2(a); \
RTAssertPanic(); \
stmt; \
return (rcRet); \
} \
} while (0)
/** @def AssertLogRelMsgReturnVoid
* Assert that an expression is true, return (void) if it isn't.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
*/
#define AssertLogRelMsgReturnVoid(expr, a) \
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertLogRelMsg2(a); \
RTAssertPanic(); \
return; \
} \
} while (0)
/** @def AssertLogRelMsgBreak
* Assert that an expression is true, break if it isn't.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
*/
#define AssertLogRelMsgBreak(expr, a) \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertLogRelMsg2(a); \
RTAssertPanic(); \
break; \
} \
else do {} while (0)
/** @def AssertLogRelMsgBreakStmt
* Assert that an expression is true, execute \a stmt and break if it isn't.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
* @param stmt Statement to execute before break in case of a failed assertion.
*/
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertLogRelMsg2(a); \
RTAssertPanic(); \
stmt; \
break; \
} else do {} while (0)
/** @def AssertLogRelFailed
* An assertion failed.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*/
#define AssertLogRelFailed() \
do { \
RTAssertPanic(); \
} while (0)
/** @def AssertLogRelFailedReturn
* An assertion failed.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param rc What is to be presented to return.
*/
#define AssertLogRelFailedReturn(rc) \
do { \
RTAssertPanic(); \
return (rc); \
} while (0)
/** @def AssertLogRelFailedReturnVoid
* An assertion failed, hit a breakpoint and return.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*/
#define AssertLogRelFailedReturnVoid() \
do { \
RTAssertPanic(); \
return; \
} while (0)
/** @def AssertLogRelFailedBreak
* An assertion failed, break.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*/
#define AssertLogRelFailedBreak() \
if (1) \
{ \
RTAssertPanic(); \
break; \
} else do {} while (0)
/** @def AssertLogRelFailedBreakStmt
* An assertion failed, execute \a stmt and break.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param stmt Statement to execute before break.
*/
#define AssertLogRelFailedBreakStmt(stmt) \
if (1) \
{ \
RTAssertPanic(); \
stmt; \
break; \
} else do {} while (0)
/** @def AssertLogRelMsgFailed
* An assertion failed.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param a printf argument list (in parenthesis).
*/
#define AssertLogRelMsgFailed(a) \
do { \
RTAssertLogRelMsg2(a); \
RTAssertPanic(); \
} while (0)
/** @def AssertLogRelMsgFailedReturn
* An assertion failed, return \a rc.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param a printf argument list (in parenthesis).
* @param rc What is to be presented to return.
*/
#define AssertLogRelMsgFailedReturn(a, rc) \
do { \
RTAssertLogRelMsg2(a); \
RTAssertPanic(); \
return (rc); \
} while (0)
/** @def AssertLogRelMsgFailedReturn
* An assertion failed, execute @a stmt and return @a rc.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param a printf argument list (in parenthesis).
* @param stmt Statement to execute before returning in case of a failed
* assertion.
* @param rc What is to be presented to return.
*/
do { \
RTAssertLogRelMsg2(a); \
RTAssertPanic(); \
stmt; \
return (rc); \
} while (0)
/** @def AssertLogRelMsgFailedReturnVoid
* An assertion failed, return void.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param a printf argument list (in parenthesis).
*/
#define AssertLogRelMsgFailedReturnVoid(a) \
do { \
RTAssertLogRelMsg2(a); \
RTAssertPanic(); \
return; \
} while (0)
/** @def AssertLogRelMsgFailedReturnVoid
* An assertion failed, execute @a stmt and return void.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param a printf argument list (in parenthesis).
* @param stmt Statement to execute before returning in case of a failed
* assertion.
*/
#define AssertLogRelMsgFailedReturnVoidStmt(a, stmt) \
do { \
RTAssertLogRelMsg2(a); \
RTAssertPanic(); \
stmt; \
return; \
} while (0)
/** @def AssertLogRelMsgFailedBreak
* An assertion failed, break.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param a printf argument list (in parenthesis).
*/
#define AssertLogRelMsgFailedBreak(a) \
if (1)\
{ \
RTAssertLogRelMsg2(a); \
RTAssertPanic(); \
break; \
} else do {} while (0)
/** @def AssertLogRelMsgFailedBreakStmt
* An assertion failed, execute \a stmt and break.
* Strict builds will hit a breakpoint, non-strict will only do LogRel.
*
* @param a printf argument list (in parenthesis).
* @param stmt Statement to execute before break.
*/
#define AssertLogRelMsgFailedBreakStmt(a, stmt) \
if (1) \
{ \
RTAssertLogRelMsg2(a); \
RTAssertPanic(); \
stmt; \
break; \
} else do {} while (0)
/** @} */
/** @name Release Assertions
*
* These assertions are always enabled.
* @{
*/
/** @def RTAssertReleasePanic()
* Invokes RTAssertShouldPanic and RTAssertDoPanic.
*
* It might seem odd that RTAssertShouldPanic is necessary when its result isn't
* checked, but it's done since RTAssertShouldPanic is overrideable and might be
* used to bail out before taking down the system (the VMMR0 case).
*/
/** @def AssertRelease
* Assert that an expression is true. If it's not hit a breakpoint.
*
* @param expr Expression which should be true.
*/
#define AssertRelease(expr) \
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertReleasePanic(); \
} \
} while (0)
/** @def AssertReleaseReturn
* Assert that an expression is true, hit a breakpoint and return if it isn't.
*
* @param expr Expression which should be true.
* @param rc What is to be presented to return.
*/
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertReleasePanic(); \
return (rc); \
} \
} while (0)
/** @def AssertReleaseReturnVoid
* Assert that an expression is true, hit a breakpoint and return if it isn't.
*
* @param expr Expression which should be true.
*/
#define AssertReleaseReturnVoid(expr) \
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertReleasePanic(); \
return; \
} \
} while (0)
/** @def AssertReleaseBreak
* Assert that an expression is true, hit a breakpoint and break if it isn't.
*
* @param expr Expression which should be true.
*/
#define AssertReleaseBreak(expr) \
if { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertReleasePanic(); \
break; \
} \
} else do {} while (0)
/** @def AssertReleaseBreakStmt
* Assert that an expression is true, hit a breakpoint and break if it isn't.
*
* @param expr Expression which should be true.
* @param stmt Statement to execute before break in case of a failed assertion.
*/
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertReleasePanic(); \
stmt; \
break; \
} else do {} while (0)
/** @def AssertReleaseMsg
* Assert that an expression is true, print the message and hit a breakpoint if it isn't.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
*/
#define AssertReleaseMsg(expr, a) \
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertMsg2Weak a; \
RTAssertReleasePanic(); \
} \
} while (0)
/** @def AssertReleaseMsgReturn
* Assert that an expression is true, print the message and hit a breakpoint and return if it isn't.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
* @param rc What is to be presented to return.
*/
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertMsg2Weak a; \
RTAssertReleasePanic(); \
return (rc); \
} \
} while (0)
/** @def AssertReleaseMsgReturnVoid
* Assert that an expression is true, print the message and hit a breakpoint and return if it isn't.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
*/
#define AssertReleaseMsgReturnVoid(expr, a) \
do { \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertMsg2Weak a; \
RTAssertReleasePanic(); \
return; \
} \
} while (0)
/** @def AssertReleaseMsgBreak
* Assert that an expression is true, print the message and hit a breakpoint and break if it isn't.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
*/
#define AssertReleaseMsgBreak(expr, a) \
if (RT_UNLIKELY(!(expr))) \
{ \
RTAssertMsg2Weak a; \
RTAssertReleasePanic(); \
break; \
} else do {} while (0)
/** @def AssertReleaseMsgBreakStmt
* Assert that an expression is true, print the message and hit a breakpoint and break if it isn't.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
* @param stmt Statement to execute before break in case of a failed assertion.
*/
if (RT_UNLIKELY(!(expr))) { \
RTAssertMsg2Weak a; \
RTAssertReleasePanic(); \
stmt; \
break; \
} else do {} while (0)
/** @def AssertReleaseFailed
* An assertion failed, hit a breakpoint.
*/
#define AssertReleaseFailed() \
do { \
RTAssertReleasePanic(); \
} while (0)
/** @def AssertReleaseFailedReturn
* An assertion failed, hit a breakpoint and return.
*
* @param rc What is to be presented to return.
*/
#define AssertReleaseFailedReturn(rc) \
do { \
RTAssertReleasePanic(); \
return (rc); \
} while (0)
/** @def AssertReleaseFailedReturnVoid
* An assertion failed, hit a breakpoint and return.
*/
#define AssertReleaseFailedReturnVoid() \
do { \
RTAssertReleasePanic(); \
return; \
} while (0)
/** @def AssertReleaseFailedBreak
* An assertion failed, hit a breakpoint and break.
*/
#define AssertReleaseFailedBreak() \
if (1) { \
RTAssertReleasePanic(); \
break; \
} else do {} while (0)
/** @def AssertReleaseFailedBreakStmt
* An assertion failed, hit a breakpoint and break.
*
* @param stmt Statement to execute before break.
*/
#define AssertReleaseFailedBreakStmt(stmt) \
if (1) { \
RTAssertReleasePanic(); \
stmt; \
break; \
} else do {} while (0)
/** @def AssertReleaseMsgFailed
* An assertion failed, print a message and hit a breakpoint.
*
* @param a printf argument list (in parenthesis).
*/
#define AssertReleaseMsgFailed(a) \
do { \
RTAssertMsg2Weak a; \
RTAssertReleasePanic(); \
} while (0)
/** @def AssertReleaseMsgFailedReturn
* An assertion failed, print a message, hit a breakpoint and return.
*
* @param a printf argument list (in parenthesis).
* @param rc What is to be presented to return.
*/
#define AssertReleaseMsgFailedReturn(a, rc) \
do { \
RTAssertMsg2Weak a; \
RTAssertReleasePanic(); \
return (rc); \
} while (0)
/** @def AssertReleaseMsgFailedReturnVoid
* An assertion failed, print a message, hit a breakpoint and return.
*
* @param a printf argument list (in parenthesis).
*/
#define AssertReleaseMsgFailedReturnVoid(a) \
do { \
RTAssertMsg2Weak a; \
RTAssertReleasePanic(); \
return; \
} while (0)
/** @def AssertReleaseMsgFailedBreak
* An assertion failed, print a message, hit a breakpoint and break.
*
* @param a printf argument list (in parenthesis).
*/
#define AssertReleaseMsgFailedBreak(a) \
if (1) { \
RTAssertMsg2Weak a; \
RTAssertReleasePanic(); \
break; \
} else do {} while (0)
/** @def AssertReleaseMsgFailedBreakStmt
* An assertion failed, print a message, hit a breakpoint and break.
*
* @param a printf argument list (in parenthesis).
* @param stmt Statement to execute before break.
*/
#define AssertReleaseMsgFailedBreakStmt(a, stmt) \
if (1) { \
RTAssertMsg2Weak a; \
RTAssertReleasePanic(); \
stmt; \
break; \
} else do {} while (0)
/** @} */
/** @name Fatal Assertions
* These are similar to release assertions except that you cannot ignore them in
* any way, they will loop for ever if RTAssertDoPanic returns.
*
* @{
*/
/** @def AssertFatal
* Assert that an expression is true. If it's not hit a breakpoint (for ever).
*
* @param expr Expression which should be true.
*/
#define AssertFatal(expr) \
do { \
if (RT_UNLIKELY(!(expr))) \
for (;;) \
{ \
RTAssertReleasePanic(); \
} \
} while (0)
/** @def AssertFatalMsg
* Assert that an expression is true, print the message and hit a breakpoint (for ever) if it isn't.
*
* @param expr Expression which should be true.
* @param a printf argument list (in parenthesis).
*/
#define AssertFatalMsg(expr, a) \
do { \
if (RT_UNLIKELY(!(expr))) \
for (;;) \
{ \
RTAssertMsg2Weak a; \
RTAssertReleasePanic(); \
} \
} while (0)
/** @def AssertFatalFailed
* An assertion failed, hit a breakpoint (for ever).
*/
#define AssertFatalFailed() \
do { \
for (;;) \
{ \
RTAssertReleasePanic(); \
} \
} while (0)
/** @def AssertFatalMsgFailed
* An assertion failed, print a message and hit a breakpoint (for ever).
*
* @param a printf argument list (in parenthesis).
*/
#define AssertFatalMsgFailed(a) \
do { \
for (;;) \
{ \
RTAssertMsg2Weak a; \
RTAssertReleasePanic(); \
} \
} while (0)
/** @} */
/** @name Convenience Assertions Macros
* @{
*/
/** @def AssertRC
* Asserts a iprt status code successful.
*
* On failure it will print info about the rc and hit a breakpoint.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
/** @def AssertRCReturn
* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
*
* @param rc iprt status code.
* @param rcRet What is to be presented to return.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
/** @def AssertRCReturn
* Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
* @a stmt and returns @a rcRet if it isn't.
*
* @param rc iprt status code.
* @param stmt Statement to execute before returning in case of a failed
* assertion.
* @param rcRet What is to be presented to return.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
#define AssertRCReturnStmt(rc, stmt, rcRet) AssertMsgRCReturnStmt(rc, ("%Rra\n", (rc)), stmt, rcRet)
/** @def AssertRCReturnVoid
* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
/** @def AssertReturnVoidStmt
* Asserts a iprt status code successful, bitch (RT_STRICT mode only), and
*
* @param rc iprt status code.
* @param stmt Statement to execute before returning on failure.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
/** @def AssertRCBreak
* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
/** @def AssertRCBreakStmt
* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
*
* @param rc iprt status code.
* @param stmt Statement to execute before break in case of a failed assertion.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
/** @def AssertMsgRC
* Asserts a iprt status code successful.
*
* It prints a custom message and hits a breakpoint on FAILURE.
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
/** @def AssertMsgRCReturn
* Asserts a iprt status code successful and if it's not return the specified status code.
*
* If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @param rcRet What is to be presented to return.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
/** @def AssertMsgRCReturnStmt
* Asserts a iprt status code successful and if it's not execute @a stmt and
* return the specified status code (@a rcRet).
*
* If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @param stmt Statement to execute before returning in case of a failed
* assertion.
* @param rcRet What is to be presented to return.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
/** @def AssertMsgRCReturnVoid
* Asserts a iprt status code successful and if it's not return.
*
* If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
/** @def AssertMsgRCReturnVoidStmt
*
* If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @param stmt Statement to execute before break in case of a failed assertion.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
/** @def AssertMsgRCBreak
* Asserts a iprt status code successful and if it's not break.
*
* If RT_STRICT is defined the message will be printed and a breakpoint hit before it breaks
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
/** @def AssertMsgRCBreakStmt
*
* If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @param stmt Statement to execute before break in case of a failed assertion.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
/** @def AssertRCSuccess
* Asserts an iprt status code equals VINF_SUCCESS.
*
* On failure it will print info about the rc and hit a breakpoint.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
#define AssertRCSuccess(rc) do { AssertMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc))); NOREF(rc); } while (0)
/** @def AssertRCSuccessReturn
* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
*
* @param rc iprt status code.
* @param rcRet What is to be presented to return.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
#define AssertRCSuccessReturn(rc, rcRet) AssertMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
/** @def AssertRCSuccessReturnVoid
* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
/** @def AssertRCSuccessBreak
* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
/** @def AssertRCSuccessBreakStmt
* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
*
* @param rc iprt status code.
* @param stmt Statement to execute before break in case of a failed assertion.
* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
*/
#define AssertRCSuccessBreakStmt(rc, stmt) AssertMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
/** @def AssertLogRelRC
* Asserts a iprt status code successful.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times.
*/
/** @def AssertLogRelRCReturn
* Asserts a iprt status code successful, returning \a rc if it isn't.
*
* @param rc iprt status code.
* @param rcRet What is to be presented to return.
* @remark rc is referenced multiple times.
*/
/** @def AssertLogRelRCReturnStmt
* Asserts a iprt status code successful, executing \a stmt and returning \a rc
* if it isn't.
*
* @param rc iprt status code.
* @param stmt Statement to execute before returning in case of a failed
* assertion.
* @param rcRet What is to be presented to return.
* @remark rc is referenced multiple times.
*/
#define AssertLogRelRCReturnStmt(rc, stmt, rcRet) AssertLogRelMsgRCReturnStmt(rc, ("%Rra\n", (rc)), stmt, rcRet)
/** @def AssertLogRelRCReturnVoid
* Asserts a iprt status code successful, returning (void) if it isn't.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times.
*/
/** @def AssertLogRelRCBreak
* Asserts a iprt status code successful, breaking if it isn't.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times.
*/
/** @def AssertLogRelRCBreakStmt
* Asserts a iprt status code successful, execute \a statement and break if it isn't.
*
* @param rc iprt status code.
* @param stmt Statement to execute before break in case of a failed assertion.
* @remark rc is referenced multiple times.
*/
/** @def AssertLogRelMsgRC
* Asserts a iprt status code successful.
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @remark rc is referenced multiple times.
*/
/** @def AssertLogRelMsgRCReturn
* Asserts a iprt status code successful.
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @param rcRet What is to be presented to return.
* @remark rc is referenced multiple times.
*/
#define AssertLogRelMsgRCReturn(rc, msg, rcRet) AssertLogRelMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet)
/** @def AssertLogRelMsgRCReturnStmt
* Asserts a iprt status code successful, execute \a stmt and return on
* failure.
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @param stmt Statement to execute before returning in case of a failed
* assertion.
* @param rcRet What is to be presented to return.
* @remark rc is referenced multiple times.
*/
#define AssertLogRelMsgRCReturnStmt(rc, msg, stmt, rcRet) AssertLogRelMsgReturnStmt(RT_SUCCESS_NP(rc), msg, stmt, rcRet)
/** @def AssertLogRelMsgRCReturnVoid
* Asserts a iprt status code successful.
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @remark rc is referenced multiple times.
*/
/** @def AssertLogRelMsgRCBreak
* Asserts a iprt status code successful.
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @remark rc is referenced multiple times.
*/
/** @def AssertLogRelMsgRCBreakStmt
* Asserts a iprt status code successful, execute \a stmt and break if it isn't.
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @param stmt Statement to execute before break in case of a failed assertion.
* @remark rc is referenced multiple times.
*/
#define AssertLogRelMsgRCBreakStmt(rc, msg, stmt) AssertLogRelMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt)
/** @def AssertLogRelRCSuccess
* Asserts that an iprt status code equals VINF_SUCCESS.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times.
*/
/** @def AssertLogRelRCSuccessReturn
* Asserts that an iprt status code equals VINF_SUCCESS.
*
* @param rc iprt status code.
* @param rcRet What is to be presented to return.
* @remark rc is referenced multiple times.
*/
#define AssertLogRelRCSuccessReturn(rc, rcRet) AssertLogRelMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
/** @def AssertLogRelRCSuccessReturnVoid
* Asserts that an iprt status code equals VINF_SUCCESS.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times.
*/
#define AssertLogRelRCSuccessReturnVoid(rc) AssertLogRelMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
/** @def AssertLogRelRCSuccessBreak
* Asserts that an iprt status code equals VINF_SUCCESS.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times.
*/
/** @def AssertLogRelRCSuccessBreakStmt
* Asserts that an iprt status code equals VINF_SUCCESS.
*
* @param rc iprt status code.
* @param stmt Statement to execute before break in case of a failed assertion.
* @remark rc is referenced multiple times.
*/
#define AssertLogRelRCSuccessBreakStmt(rc, stmt) AssertLogRelMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
/** @def AssertReleaseRC
* Asserts a iprt status code successful.
*
* On failure information about the error will be printed and a breakpoint hit.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times.
*/
/** @def AssertReleaseRCReturn
* Asserts a iprt status code successful, returning if it isn't.
*
* On failure information about the error will be printed, a breakpoint hit
* and finally returning from the function if the breakpoint is somehow ignored.
*
* @param rc iprt status code.
* @param rcRet What is to be presented to return.
* @remark rc is referenced multiple times.
*/
/** @def AssertReleaseRCReturnVoid
* Asserts a iprt status code successful, returning if it isn't.
*
* On failure information about the error will be printed, a breakpoint hit
* and finally returning from the function if the breakpoint is somehow ignored.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times.
*/
/** @def AssertReleaseRCBreak
* Asserts a iprt status code successful, breaking if it isn't.
*
* On failure information about the error will be printed, a breakpoint hit
* and finally breaking the current statement if the breakpoint is somehow ignored.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times.
*/
/** @def AssertReleaseRCBreakStmt
* Asserts a iprt status code successful, break if it isn't.
*
* On failure information about the error will be printed, a breakpoint hit
* and finally the break statement will be issued if the breakpoint is somehow ignored.
*
* @param rc iprt status code.
* @param stmt Statement to execute before break in case of a failed assertion.
* @remark rc is referenced multiple times.
*/
/** @def AssertReleaseMsgRC
* Asserts a iprt status code successful.
*
* On failure a custom message is printed and a breakpoint is hit.
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @remark rc is referenced multiple times.
*/
/** @def AssertReleaseMsgRCReturn
* Asserts a iprt status code successful.
*
* On failure a custom message is printed, a breakpoint is hit, and finally
* returning from the function if the breakpoint is somehow ignored.
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @param rcRet What is to be presented to return.
* @remark rc is referenced multiple times.
*/
#define AssertReleaseMsgRCReturn(rc, msg, rcRet) AssertReleaseMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet)
/** @def AssertReleaseMsgRCReturnVoid
* Asserts a iprt status code successful.
*
* On failure a custom message is printed, a breakpoint is hit, and finally
* returning from the function if the breakpoint is somehow ignored.
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @remark rc is referenced multiple times.
*/
/** @def AssertReleaseMsgRCBreak
* Asserts a iprt status code successful.
*
* On failure a custom message is printed, a breakpoint is hit, and finally
* breaking the current status if the breakpoint is somehow ignored.
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @remark rc is referenced multiple times.
*/
/** @def AssertReleaseMsgRCBreakStmt
* Asserts a iprt status code successful.
*
* On failure a custom message is printed, a breakpoint is hit, and finally
* the break statement is issued if the breakpoint is somehow ignored.
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @param stmt Statement to execute before break in case of a failed assertion.
* @remark rc is referenced multiple times.
*/
#define AssertReleaseMsgRCBreakStmt(rc, msg, stmt) AssertReleaseMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt)
/** @def AssertReleaseRCSuccess
* Asserts that an iprt status code equals VINF_SUCCESS.
*
* On failure information about the error will be printed and a breakpoint hit.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times.
*/
/** @def AssertReleaseRCSuccessReturn
* Asserts that an iprt status code equals VINF_SUCCESS.
*
* On failure information about the error will be printed, a breakpoint hit
* and finally returning from the function if the breakpoint is somehow ignored.
*
* @param rc iprt status code.
* @param rcRet What is to be presented to return.
* @remark rc is referenced multiple times.
*/
#define AssertReleaseRCSuccessReturn(rc, rcRet) AssertReleaseMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
/** @def AssertReleaseRCSuccessReturnVoid
* Asserts that an iprt status code equals VINF_SUCCESS.
*
* On failure information about the error will be printed, a breakpoint hit
* and finally returning from the function if the breakpoint is somehow ignored.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times.
*/
#define AssertReleaseRCSuccessReturnVoid(rc) AssertReleaseMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
/** @def AssertReleaseRCSuccessBreak
* Asserts that an iprt status code equals VINF_SUCCESS.
*
* On failure information about the error will be printed, a breakpoint hit
* and finally breaking the current statement if the breakpoint is somehow ignored.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times.
*/
#define AssertReleaseRCSuccessBreak(rc) AssertReleaseMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
/** @def AssertReleaseRCSuccessBreakStmt
* Asserts that an iprt status code equals VINF_SUCCESS.
*
* On failure information about the error will be printed, a breakpoint hit
* and finally the break statement will be issued if the breakpoint is somehow ignored.
*
* @param rc iprt status code.
* @param stmt Statement to execute before break in case of a failed assertion.
* @remark rc is referenced multiple times.
*/
#define AssertReleaseRCSuccessBreakStmt(rc, stmt) AssertReleaseMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
/** @def AssertFatalRC
* Asserts a iprt status code successful.
*
* On failure information about the error will be printed and a breakpoint hit.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times.
*/
/** @def AssertReleaseMsgRC
* Asserts a iprt status code successful.
*
* On failure a custom message is printed and a breakpoint is hit.
*
* @param rc iprt status code.
* @param msg printf argument list (in parenthesis).
* @remark rc is referenced multiple times.
*/
/** @def AssertFatalRCSuccess
* Asserts that an iprt status code equals VINF_SUCCESS.
*
* On failure information about the error will be printed and a breakpoint hit.
*
* @param rc iprt status code.
* @remark rc is referenced multiple times.
*/
/** @def AssertPtr
* Asserts that a pointer is valid.
*
* @param pv The pointer.
*/
/** @def AssertPtrReturn
* Asserts that a pointer is valid.
*
* @param pv The pointer.
* @param rcRet What is to be presented to return.
*/
/** @def AssertPtrReturnVoid
* Asserts that a pointer is valid.
*
* @param pv The pointer.
*/
/** @def AssertPtrBreak
* Asserts that a pointer is valid.
*
* @param pv The pointer.
*/
/** @def AssertPtrBreakStmt
* Asserts that a pointer is valid.
*
* @param pv The pointer.
* @param stmt Statement to execute before break in case of a failed assertion.
*/
/** @def AssertPtrNull
* Asserts that a pointer is valid or NULL.
*
* @param pv The pointer.
*/
/** @def AssertPtrNullReturn
* Asserts that a pointer is valid or NULL.
*
* @param pv The pointer.
* @param rcRet What is to be presented to return.
*/
#define AssertPtrNullReturn(pv, rcRet) AssertMsgReturn(VALID_PTR(pv) || (pv) == NULL, ("%p\n", (pv)), rcRet)
/** @def AssertPtrNullReturnVoid
* Asserts that a pointer is valid or NULL.
*
* @param pv The pointer.
*/
#define AssertPtrNullReturnVoid(pv) AssertMsgReturnVoid(VALID_PTR(pv) || (pv) == NULL, ("%p\n", (pv)))
/** @def AssertPtrNullBreak
* Asserts that a pointer is valid or NULL.
*
* @param pv The pointer.
*/
/** @def AssertPtrNullBreakStmt
* Asserts that a pointer is valid or NULL.
*
* @param pv The pointer.
* @param stmt Statement to execute before break in case of a failed assertion.
*/
#define AssertPtrNullBreakStmt(pv, stmt) AssertMsgBreakStmt(VALID_PTR(pv) || (pv) == NULL, ("%p\n", (pv)), stmt)
/** @def AssertGCPhys32
* Asserts that the high dword of a physical address is zero
*
* @param GCPhys The address (RTGCPHYS).
*/
/** @def AssertGCPtr32
* Asserts that the high dword of a physical address is zero
*
* @param GCPtr The address (RTGCPTR).
*/
#if GC_ARCH_BITS == 32
# define AssertGCPtr32(GCPtr) do { } while (0)
#else
# define AssertGCPtr32(GCPtr) AssertMsg(!((GCPtr) & UINT64_C(0xffffffff00000000)), ("%RGv\n", GCPtr))
#endif
/** @def AssertForEach
* Equivalent to Assert for each value of the variable from the starting
* value to the finishing one.
*
* @param var Name of the counter variable.
* @param vartype Type of the counter variable.
* @param first Lowest inclusive value of the counter variable.
* This must be free from side effects.
* @param end Highest exclusive value of the counter variable.
* This must be free from side effects.
* @param expr Expression which should be true for each value of @a var.
*/
do { \
} while (0)
/** @} */
/** @} */
#endif