assert.h revision 0c8eec6f5b79d800c3d25b5c0e0d7ad3f867c25c
* 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! * 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. * Additional information which should be appended to the 2nd part of an * @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 * @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 * Panics the system as the result of a fail assertion. * Overridable function that decides whether assertions executes the panic * 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 * 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. * Makes the assertions panic (default) or not. * @returns The old setting. * @param fPanic The new setting. * @returns True if they can, false if not. /** @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. */ /** The last assert message, file name. */ /** The last assert message, line number. */ /** The last assert message, function name. */ /** @def RTAssertDebugBreak() * Debugger breakpoint instruction. * @remarks This macro does not depend on RT_STRICT. /** @name Compile time assertions. * These assertions are used to check structure sizes, member/size alignments * and similar compile time expressions. * RTASSERTTYPE is the type the AssertCompile() macro redefines. * It has no other function and shouldn't be used. * RTASSERTVAR is the type the AssertCompile() macro redefines. * It has no other function and shouldn't be used. /** @def RTASSERT_HAVE_STATIC_ASSERT * Indicates that the compiler implements static_assert(expr, msg). * 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. * Asserts that a C++0x compile-time expression is true. If it's not break the * @param expr Expression which should be true. /** @def AssertCompileSize * Asserts a size at compile. * @param size The expected type size. /** @def AssertCompileSizeAlignment * Asserts a size alignment at compile. * @param align The size alignment to assert. /** @def AssertCompileMemberSize * Asserts a member offset alignment at compile. * @param member The member. * @param size The member size to assert. /** @def AssertCompileMemberSizeAlignment * Asserts a member size alignment at compile. * @param member The member. * @param align The member size alignment to assert. /** @def AssertCompileMemberAlignment * Asserts a member offset alignment at compile. * @param member The member. * @param align The member offset alignment to assert. /** @def AssertCompileMemberOffset * Asserts a offset of a structure member at compile. * @param member The member. * @param off The expected offset. /** @def AssertCompile2MemberOffsets * Asserts that two (sub-structure) members in union have the same offset. * @param member1 The first member. * @param member2 The second member. /** @def AssertCompileAdjacentMembers * Asserts that two structure members are adjacent. * @param member1 The first member. * @param member2 The second member. /** @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 * @param type1 The first type. * @param member1 The first member. * @param type2 The second type. * @param member2 The second member. * These assertions will only trigger when RT_STRICT is defined. When it is * undefined they will all be no-ops and generate no code. * 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. * Raises an assertion panic appropriate to the current context. * @remarks This macro does not depend on RT_STRICT. /** @def AssertBreakpoint() * @deprecated Use RTAssertPanic or RTAssertDebugBreak instead. * 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 * Assert that an expression is true. If false, hit breakpoint. * @param expr Expression which should be true. * Assert that an expression is true. If false, hit breakpoint and execute the * @param expr Expression which should be true. * @param stmt Statement to execute on failure. * 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. /** @def AssertReturnStmt * Assert that an expression is true, if it isn't execute the given statement * In RT_STRICT mode it will hit a breakpoint before executing the statement and * @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. /** @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. /** @def AssertReturnVoidStmt * Assert that an expression is true, if it isn't execute the given statement * 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. * 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. * 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. * 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). * 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. * 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. /** @def AssertMsgReturnStmt * Assert that an expression is true, if it isn't execute the statement and * 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. * @param rc What is to be presented to return. /** @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). /** @def AssertMsgReturnVoidStmt * Assert that an expression is true, if it isn't execute the statement and * 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. * 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). /** @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. * An assertion failed hit breakpoint. /** @def AssertFailedReturn * An assertion failed, hit breakpoint (RT_STRICT mode only) and return. * @param rc The rc to return. /** @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. /** @def AssertFailedReturnVoid * An assertion failed, hit breakpoint (RT_STRICT mode only) and return. /** @def AssertFailedReturnVoidStmt * An assertion failed, hit breakpoint (RT_STRICT mode only), execute a * @param stmt The statement to execute before returning. /** @def AssertFailedBreak * An assertion failed, hit breakpoint (RT_STRICT mode only) and break. /** @def AssertFailedBreakStmt * An assertion failed, hit breakpoint (RT_STRICT mode only), execute * the given statement and break. * @param stmt Statement to execute before break. * An assertion failed print a message and a hit breakpoint. * @param a printf argument list (in parenthesis). /** @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. /** @def AssertMsgFailedReturnVoid * An assertion failed, hit breakpoint with message (RT_STRICT mode only) and return. * @param a printf argument list (in parenthesis). /** @def AssertMsgFailedBreak * An assertion failed, hit breakpoint with message (RT_STRICT mode only) and break. * @param a printf argument list (in parenthesis). /** @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. /** @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 /** @def RTAssertLogRelMsg1 * RTAssertMsg1Weak (strict builds) / LogRel wrapper (non-strict). LogRel((
"AssertLogRel %s(%d) %s: %s\n",\
/** @def RTAssertLogRelMsg2 * RTAssertMsg2Weak (strict builds) / LogRel wrapper (non-strict). * 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. /** @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. /** @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. /** @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. /** @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. * 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). /** @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. /** @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). /** @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). /** @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. /** @def AssertLogRelFailed * Strict builds will hit a breakpoint, non-strict will only do LogRel. /** @def AssertLogRelFailedReturn * Strict builds will hit a breakpoint, non-strict will only do LogRel. * @param rc What is to be presented to return. /** @def AssertLogRelFailedReturnVoid * An assertion failed, hit a breakpoint and return. * Strict builds will hit a breakpoint, non-strict will only do LogRel. /** @def AssertLogRelFailedBreak * An assertion failed, break. * Strict builds will hit a breakpoint, non-strict will only do LogRel. /** @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. /** @def AssertLogRelMsgFailed * Strict builds will hit a breakpoint, non-strict will only do LogRel. * @param a printf argument list (in parenthesis). /** @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. /** @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). /** @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). /** @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. /** @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). * Assert that an expression is true. If it's not hit a breakpoint. * @param expr Expression which should be true. /** @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. /** @def AssertReleaseReturnVoid * Assert that an expression is true, hit a breakpoint and return if it isn't. * @param expr Expression which should be true. /** @def AssertReleaseBreak * Assert that an expression is true, hit a breakpoint and break if it isn't. * @param expr Expression which should be true. /** @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. /** @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). /** @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. /** @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). /** @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). /** @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. /** @def AssertReleaseFailed * An assertion failed, hit a breakpoint. /** @def AssertReleaseFailedReturn * An assertion failed, hit a breakpoint and return. * @param rc What is to be presented to return. /** @def AssertReleaseFailedReturnVoid * An assertion failed, hit a breakpoint and return. /** @def AssertReleaseFailedBreak * An assertion failed, hit a breakpoint and break. /** @def AssertReleaseFailedBreakStmt * An assertion failed, hit a breakpoint and break. * @param stmt Statement to execute before break. /** @def AssertReleaseMsgFailed * An assertion failed, print a message and hit a breakpoint. * @param a printf argument list (in parenthesis). /** @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. /** @def AssertReleaseMsgFailedReturnVoid * An assertion failed, print a message, hit a breakpoint and return. * @param a printf argument list (in parenthesis). /** @def AssertReleaseMsgFailedBreak * An assertion failed, print a message, hit a breakpoint and break. * @param a printf argument list (in parenthesis). /** @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. /** @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. * Assert that an expression is true. If it's not hit a breakpoint (for ever). * @param expr Expression which should be true. * 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). /** @def AssertFatalFailed * An assertion failed, hit a breakpoint (for ever). /** @def AssertFatalMsgFailed * An assertion failed, print a message and hit a breakpoint (for ever). * @param a printf argument list (in parenthesis). /** @name Convenience Assertions Macros * 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. * 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 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. * 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. * 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 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 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 * Asserts a iprt status code successful and break if it's not. * 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. * 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. /** @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. /** @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. * 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 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. /** @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. /** @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. /** @def AssertLogRelRCSuccessReturnVoid * Asserts that an iprt status code equals VINF_SUCCESS. * @param rc iprt status code. * @remark rc is referenced multiple times. /** @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. * 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. /** @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. /** @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. /** @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. /** @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. /** @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. * 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. * Asserts that a pointer is valid. * Asserts that a pointer is valid. * @param rcRet What is to be presented to return. /** @def AssertPtrReturnVoid * Asserts that a pointer is valid. * Asserts that a pointer is valid. /** @def AssertPtrBreakStmt * Asserts that a pointer is valid. * @param stmt Statement to execute before break in case of a failed assertion. * Asserts that a pointer is valid or NULL. /** @def AssertPtrNullReturn * Asserts that a pointer is valid or NULL. * @param rcRet What is to be presented to return. /** @def AssertPtrNullReturnVoid * Asserts that a pointer is valid or NULL. /** @def AssertPtrNullBreak * Asserts that a pointer is valid or NULL. /** @def AssertPtrNullBreakStmt * Asserts that a pointer is valid or NULL. * @param stmt Statement to execute before break in case of a failed assertion. * Asserts that the high dword of a physical address is zero * @param GCPhys The address (RTGCPHYS). * Asserts that the high dword of a physical address is zero * @param GCPtr The address (RTGCPTR). * 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.