VirtualBox

source: vbox/trunk/include/iprt/assert.h@ 53370

Last change on this file since 53370 was 48934, checked in by vboxsync, 11 years ago

include/: Whitespace cleanup by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 84.6 KB
Line 
1/** @file
2 * IPRT - Assertions.
3 */
4
5/*
6 * Copyright (C) 2006-2012 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 *
16 * The contents of this file may alternatively be used under the terms
17 * of the Common Development and Distribution License Version 1.0
18 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19 * VirtualBox OSE distribution, in which case the provisions of the
20 * CDDL are applicable instead of those of the GPL.
21 *
22 * You may elect to license modified versions of this file under the
23 * terms and conditions of either the GPL or the CDDL or both.
24 */
25
26#ifndef ___iprt_assert_h
27#define ___iprt_assert_h
28
29#include <iprt/cdefs.h>
30#include <iprt/types.h>
31#include <iprt/stdarg.h>
32
33/** @defgroup grp_rt_assert Assert - Assertions
34 * @ingroup grp_rt
35 *
36 * Assertions are generally used to check preconditions and other
37 * assumptions. Sometimes it is also used to catch odd errors or errors
38 * that one would like to inspect in the debugger. They should not be
39 * used for errors that happen frequently.
40 *
41 * IPRT provides a host of assertion macros, so many that it can be a bit
42 * overwhelming at first. Don't despair, there is a system (surprise).
43 *
44 * First there are four families of assertions:
45 * - Assert - The normal strict build only assertions.
46 * - AssertLogRel - Calls LogRel() in non-strict builds, otherwise like Assert.
47 * - AssertRelease - Triggers in all builds.
48 * - AssertFatal - Triggers in all builds and cannot be continued.
49 *
50 * Then there are variations wrt to argument list and behavior on failure:
51 * - Msg - Custom RTStrPrintf-like message with the assertion message.
52 * - Return - Return the specific rc on failure.
53 * - ReturnVoid - Return (void) on failure.
54 * - Break - Break (out of switch/loop) on failure.
55 * - Stmt - Execute the specified statement(s) on failure.
56 * - RC - Assert RT_SUCCESS.
57 * - RCSuccess - Assert VINF_SUCCESS.
58 *
59 * In addition there is a very special family AssertCompile that can be
60 * used for some limited compile-time checking, like structure sizes and member
61 * alignment. This family doesn't have the same variations.
62 *
63 *
64 * @remarks As you might have noticed, the macros don't follow the
65 * coding guidelines wrt to macros supposedly being all uppercase
66 * and underscored. For various reasons they don't, and nobody
67 * has complained yet. Wonder why... :-)
68 *
69 * @remarks Each project has its own specific guidelines on how to use
70 * assertions, so the above is just trying to give you the general idea
71 * from the IPRT point of view.
72 *
73 * @{
74 */
75
76RT_C_DECLS_BEGIN
77
78/**
79 * The 1st part of an assert message.
80 *
81 * @param pszExpr Expression. Can be NULL.
82 * @param uLine Location line number.
83 * @param pszFile Location file name.
84 * @param pszFunction Location function name.
85 */
86RTDECL(void) RTAssertMsg1(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction);
87/**
88 * Weak version of RTAssertMsg1 that can be overridden locally in a module to
89 * modify, redirect or otherwise mess with the assertion output.
90 *
91 * @copydoc RTAssertMsg1
92 */
93RTDECL(void) RTAssertMsg1Weak(const char *pszExpr, unsigned uLine, const char *pszFile, const char *pszFunction);
94
95/**
96 * The 2nd (optional) part of an assert message.
97 *
98 * @param pszFormat Printf like format string.
99 * @param ... Arguments to that string.
100 */
101RTDECL(void) RTAssertMsg2(const char *pszFormat, ...);
102/**
103 * Weak version of RTAssertMsg2 that forwards to RTAssertMsg2WeakV.
104 *
105 * There is not need to override this, check out RTAssertMsg2WeakV instead!
106 *
107 * @copydoc RTAssertMsg2
108 */
109RTDECL(void) RTAssertMsg2Weak(const char *pszFormat, ...);
110
111/**
112 * The 2nd (optional) part of an assert message.
113 *
114 * @param pszFormat Printf like format string.
115 * @param va Arguments to that string.
116 */
117RTDECL(void) RTAssertMsg2V(const char *pszFormat, va_list va);
118/**
119 * Weak version of RTAssertMsg2V that can be overridden locally in a module to
120 * modify, redirect or otherwise mess with the assertion output.
121 *
122 * @copydoc RTAssertMsg2V
123 */
124RTDECL(void) RTAssertMsg2WeakV(const char *pszFormat, va_list va);
125
126/**
127 * Additional information which should be appended to the 2nd part of an
128 * assertion message.
129 *
130 * @param pszFormat Printf like format string.
131 * @param ... Arguments to that string.
132 */
133RTDECL(void) RTAssertMsg2Add(const char *pszFormat, ...);
134/**
135 * Weak version of RTAssertMsg2Add that forwards to RTAssertMsg2AddWeakV.
136 *
137 * There is not need to override this, check out RTAssertMsg2AddWeakV instead!
138 *
139 * @copydoc RTAssertMsg2Add
140 */
141RTDECL(void) RTAssertMsg2AddWeak(const char *pszFormat, ...);
142
143/**
144 * Additional information which should be appended to the 2nd part of an
145 * assertion message.
146 *
147 * @param pszFormat Printf like format string.
148 * @param va Arguments to that string.
149 */
150RTDECL(void) RTAssertMsg2AddV(const char *pszFormat, va_list va);
151/**
152 * Weak version of RTAssertMsg2AddV that can be overridden locally in a module
153 * to modify, redirect or otherwise mess with the assertion output.
154 *
155 * @copydoc RTAssertMsg2AddV
156 */
157RTDECL(void) RTAssertMsg2AddWeakV(const char *pszFormat, va_list va);
158
159#ifdef IN_RING0
160/**
161 * Panics the system as the result of a fail assertion.
162 */
163RTR0DECL(void) RTR0AssertPanicSystem(void);
164#endif /* IN_RING0 */
165
166/**
167 * Overridable function that decides whether assertions executes the panic
168 * (breakpoint) or not.
169 *
170 * The generic implementation will return true.
171 *
172 * @returns true if the breakpoint should be hit, false if it should be ignored.
173 *
174 * @remark The RTDECL() makes this a bit difficult to override on Windows. So,
175 * you'll have to use RTASSERT_HAVE_SHOULD_PANIC or
176 * RTASSERT_HAVE_SHOULD_PANIC_PRIVATE there to control the kind of
177 * prototype.
178 */
179#if !defined(RTASSERT_HAVE_SHOULD_PANIC) && !defined(RTASSERT_HAVE_SHOULD_PANIC_PRIVATE)
180RTDECL(bool) RTAssertShouldPanic(void);
181#elif defined(RTASSERT_HAVE_SHOULD_PANIC_PRIVATE)
182bool RTAssertShouldPanic(void);
183#else
184DECLEXPORT(bool) RTCALL RTAssertShouldPanic(void);
185#endif
186
187/**
188 * Controls whether the assertions should be quiet or noisy (default).
189 *
190 * @returns The old setting.
191 * @param fQuiet The new setting.
192 */
193RTDECL(bool) RTAssertSetQuiet(bool fQuiet);
194
195/**
196 * Are assertions quiet or noisy?
197 *
198 * @returns True if they are quiet, false if noisy.
199 */
200RTDECL(bool) RTAssertAreQuiet(void);
201
202/**
203 * Makes the assertions panic (default) or not.
204 *
205 * @returns The old setting.
206 * @param fPanic The new setting.
207 */
208RTDECL(bool) RTAssertSetMayPanic(bool fPanic);
209
210/**
211 * Can assertion panic.
212 *
213 * @returns True if they can, false if not.
214 */
215RTDECL(bool) RTAssertMayPanic(void);
216
217
218/** @name Globals for crash analysis
219 * @remarks This is the full potential set, it
220 * @{
221 */
222/** The last assert message, 1st part. */
223extern RTDATADECL(char) g_szRTAssertMsg1[1024];
224/** The last assert message, 2nd part. */
225extern RTDATADECL(char) g_szRTAssertMsg2[4096];
226/** The last assert message, expression. */
227extern RTDATADECL(const char * volatile) g_pszRTAssertExpr;
228/** The last assert message, file name. */
229extern RTDATADECL(const char * volatile) g_pszRTAssertFile;
230/** The last assert message, line number. */
231extern RTDATADECL(uint32_t volatile) g_u32RTAssertLine;
232/** The last assert message, function name. */
233extern RTDATADECL(const char * volatile) g_pszRTAssertFunction;
234/** @} */
235
236RT_C_DECLS_END
237
238/** @def RTAssertDebugBreak()
239 * Debugger breakpoint instruction.
240 *
241 * @remarks This macro does not depend on RT_STRICT.
242 */
243#define RTAssertDebugBreak() do { RT_BREAKPOINT(); } while (0)
244
245
246
247/** @name Compile time assertions.
248 *
249 * These assertions are used to check structure sizes, member/size alignments
250 * and similar compile time expressions.
251 *
252 * @{
253 */
254
255/**
256 * RTASSERTTYPE is the type the AssertCompile() macro redefines.
257 * It has no other function and shouldn't be used.
258 * Visual C++ uses this.
259 */
260typedef int RTASSERTTYPE[1];
261
262/**
263 * RTASSERTVAR is the type the AssertCompile() macro redefines.
264 * It has no other function and shouldn't be used.
265 * GCC uses this.
266 */
267#ifdef __GNUC__
268RT_C_DECLS_BEGIN
269#endif
270extern int RTASSERTVAR[1];
271#ifdef __GNUC__
272RT_C_DECLS_END
273#endif
274
275/** @def RTASSERT_HAVE_STATIC_ASSERT
276 * Indicates that the compiler implements static_assert(expr, msg).
277 */
278#ifdef _MSC_VER
279# if _MSC_VER >= 1600 && defined(__cplusplus)
280# define RTASSERT_HAVE_STATIC_ASSERT
281# endif
282#endif
283#if defined(__GNUC__) && defined(__GXX_EXPERIMENTAL_CXX0X__)
284# define RTASSERT_HAVE_STATIC_ASSERT
285#endif
286#ifdef DOXYGEN_RUNNING
287# define RTASSERT_HAVE_STATIC_ASSERT
288#endif
289
290/** @def AssertCompileNS
291 * Asserts that a compile-time expression is true. If it's not break the build.
292 *
293 * This differs from AssertCompile in that it accepts some more expressions
294 * than what C++0x allows - NS = Non-standard.
295 *
296 * @param expr Expression which should be true.
297 */
298#ifdef __GNUC__
299# define AssertCompileNS(expr) extern int RTASSERTVAR[1] __attribute__((unused)), RTASSERTVAR[(expr) ? 1 : 0] __attribute__((unused))
300#elif defined(__IBMC__) || defined(__IBMCPP__)
301# define AssertCompileNS(expr) extern int RTASSERTVAR[(expr) ? 1 : 0]
302#else
303# define AssertCompileNS(expr) typedef int RTASSERTTYPE[(expr) ? 1 : 0]
304#endif
305
306/** @def AssertCompile
307 * Asserts that a C++0x compile-time expression is true. If it's not break the
308 * build.
309 * @param expr Expression which should be true.
310 */
311#ifdef RTASSERT_HAVE_STATIC_ASSERT
312# define AssertCompile(expr) static_assert(!!(expr), #expr)
313#else
314# define AssertCompile(expr) AssertCompileNS(expr)
315#endif
316
317/** @def RTASSERT_OFFSET_OF()
318 * A offsetof() macro suitable for compile time assertions.
319 * Both GCC v4 and VisualAge for C++ v3.08 has trouble using RT_OFFSETOF.
320 */
321#if defined(__GNUC__)
322# if __GNUC__ >= 4
323# define RTASSERT_OFFSET_OF(a_Type, a_Member) __builtin_offsetof(a_Type, a_Member)
324# else
325# define RTASSERT_OFFSET_OF(a_Type, a_Member) RT_OFFSETOF(a_Type, a_Member)
326# endif
327#elif (defined(__IBMC__) || defined(__IBMCPP__)) && defined(RT_OS_OS2)
328# define RTASSERT_OFFSET_OF(a_Type, a_Member) __offsetof(a_Type, a_Member)
329#else
330# define RTASSERT_OFFSET_OF(a_Type, a_Member) RT_OFFSETOF(a_Type, a_Member)
331#endif
332
333
334/** @def AssertCompileSize
335 * Asserts a size at compile.
336 * @param type The type.
337 * @param size The expected type size.
338 */
339#define AssertCompileSize(type, size) \
340 AssertCompile(sizeof(type) == (size))
341
342/** @def AssertCompileSizeAlignment
343 * Asserts a size alignment at compile.
344 * @param type The type.
345 * @param align The size alignment to assert.
346 */
347#define AssertCompileSizeAlignment(type, align) \
348 AssertCompile(!(sizeof(type) & ((align) - 1)))
349
350/** @def AssertCompileMemberSize
351 * Asserts a member offset alignment at compile.
352 * @param type The type.
353 * @param member The member.
354 * @param size The member size to assert.
355 */
356#define AssertCompileMemberSize(type, member, size) \
357 AssertCompile(RT_SIZEOFMEMB(type, member) == (size))
358
359/** @def AssertCompileMemberSizeAlignment
360 * Asserts a member size alignment at compile.
361 * @param type The type.
362 * @param member The member.
363 * @param align The member size alignment to assert.
364 */
365#define AssertCompileMemberSizeAlignment(type, member, align) \
366 AssertCompile(!(RT_SIZEOFMEMB(type, member) & ((align) - 1)))
367
368/** @def AssertCompileMemberAlignment
369 * Asserts a member offset alignment at compile.
370 * @param type The type.
371 * @param member The member.
372 * @param align The member offset alignment to assert.
373 */
374#define AssertCompileMemberAlignment(type, member, align) \
375 AssertCompile(!(RTASSERT_OFFSET_OF(type, member) & ((align) - 1)))
376
377/** @def AssertCompileMemberOffset
378 * Asserts an offset of a structure member at compile.
379 * @param type The type.
380 * @param member The member.
381 * @param off The expected offset.
382 */
383#define AssertCompileMemberOffset(type, member, off) \
384 AssertCompile(RTASSERT_OFFSET_OF(type, member) == (off))
385
386/** @def AssertCompile2MemberOffsets
387 * Asserts that two (sub-structure) members in union have the same offset.
388 * @param type The type.
389 * @param member1 The first member.
390 * @param member2 The second member.
391 */
392#define AssertCompile2MemberOffsets(type, member1, member2) \
393 AssertCompile(RTASSERT_OFFSET_OF(type, member1) == RTASSERT_OFFSET_OF(type, member2))
394
395/** @def AssertCompileAdjacentMembers
396 * Asserts that two structure members are adjacent.
397 * @param type The type.
398 * @param member1 The first member.
399 * @param member2 The second member.
400 */
401#define AssertCompileAdjacentMembers(type, member1, member2) \
402 AssertCompile(RTASSERT_OFFSET_OF(type, member1) + RT_SIZEOFMEMB(type, member1) == RTASSERT_OFFSET_OF(type, member2))
403
404/** @def AssertCompileMembersAtSameOffset
405 * Asserts that members of two different structures are at the same offset.
406 * @param type1 The first type.
407 * @param member1 The first member.
408 * @param type2 The second type.
409 * @param member2 The second member.
410 */
411#define AssertCompileMembersAtSameOffset(type1, member1, type2, member2) \
412 AssertCompile(RTASSERT_OFFSET_OF(type1, member1) == RTASSERT_OFFSET_OF(type2, member2))
413
414/** @def AssertCompileMembersSameSize
415 * Asserts that members of two different structures have the same size.
416 * @param type1 The first type.
417 * @param member1 The first member.
418 * @param type2 The second type.
419 * @param member2 The second member.
420 */
421#define AssertCompileMembersSameSize(type1, member1, type2, member2) \
422 AssertCompile(RT_SIZEOFMEMB(type1, member1) == RT_SIZEOFMEMB(type2, member2))
423
424/** @def AssertCompileMembersSameSizeAndOffset
425 * Asserts that members of two different structures have the same size and are
426 * at the same offset.
427 * @param type1 The first type.
428 * @param member1 The first member.
429 * @param type2 The second type.
430 * @param member2 The second member.
431 */
432#define AssertCompileMembersSameSizeAndOffset(type1, member1, type2, member2) \
433 AssertCompile( RTASSERT_OFFSET_OF(type1, member1) == RTASSERT_OFFSET_OF(type2, member2) \
434 && RT_SIZEOFMEMB(type1, member1) == RT_SIZEOFMEMB(type2, member2))
435
436/** @} */
437
438
439
440/** @name Assertions
441 *
442 * These assertions will only trigger when RT_STRICT is defined. When it is
443 * undefined they will all be no-ops and generate no code.
444 *
445 * @{
446 */
447
448
449/** @def RTASSERT_QUIET
450 * This can be defined to shut up the messages for a file where this would be
451 * problematic because the message printing code path passes thru it.
452 * @internal */
453#ifdef DOXYGEN_RUNNING
454# define RTASSERT_QUIET
455#endif
456#if defined(RTASSERT_QUIET) && !defined(DOXYGEN_RUNNING)
457# define RTAssertMsg1Weak(pszExpr, uLine, pszfile, pszFunction) \
458 do { } while (0)
459# define RTAssertMsg2Weak if (0) RTAssertMsg2Weak
460#endif
461
462/** @def RTAssertDoPanic
463 * Raises an assertion panic appropriate to the current context.
464 * @remarks This macro does not depend on RT_STRICT.
465 */
466#if defined(IN_RING0) \
467 && (defined(RT_OS_DARWIN) || defined(RT_OS_HAIKU) || defined(RT_OS_SOLARIS))
468# define RTAssertDoPanic() RTR0AssertPanicSystem()
469#else
470# define RTAssertDoPanic() RTAssertDebugBreak()
471#endif
472
473/** @def AssertBreakpoint()
474 * Assertion Breakpoint.
475 * @deprecated Use RTAssertPanic or RTAssertDebugBreak instead.
476 */
477#ifdef RT_STRICT
478# define AssertBreakpoint() RTAssertDebugBreak()
479#else
480# define AssertBreakpoint() do { } while (0)
481#endif
482
483/** @def RTAssertPanic()
484 * If RT_STRICT is defined this macro will invoke RTAssertDoPanic if
485 * RTAssertShouldPanic returns true. If RT_STRICT isn't defined it won't do any
486 * thing.
487 */
488#if defined(RT_STRICT) && !defined(RTASSERT_DONT_PANIC)
489# define RTAssertPanic() do { if (RTAssertShouldPanic()) RTAssertDoPanic(); } while (0)
490#else
491# define RTAssertPanic() do { } while (0)
492#endif
493
494/** @def Assert
495 * Assert that an expression is true. If false, hit breakpoint.
496 * @param expr Expression which should be true.
497 */
498#ifdef RT_STRICT
499# define Assert(expr) \
500 do { \
501 if (RT_UNLIKELY(!(expr))) \
502 { \
503 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
504 RTAssertPanic(); \
505 } \
506 } while (0)
507#else
508# define Assert(expr) do { } while (0)
509#endif
510
511
512/** @def AssertStmt
513 * Assert that an expression is true. If false, hit breakpoint and execute the
514 * statement.
515 * @param expr Expression which should be true.
516 * @param stmt Statement to execute on failure.
517 */
518#ifdef RT_STRICT
519# define AssertStmt(expr, stmt) \
520 do { \
521 if (RT_UNLIKELY(!(expr))) \
522 { \
523 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
524 RTAssertPanic(); \
525 stmt; \
526 } \
527 } while (0)
528#else
529# define AssertStmt(expr, stmt) \
530 do { \
531 if (RT_UNLIKELY(!(expr))) \
532 { \
533 stmt; \
534 } \
535 } while (0)
536#endif
537
538
539/** @def AssertReturn
540 * Assert that an expression is true and returns if it isn't.
541 * In RT_STRICT mode it will hit a breakpoint before returning.
542 *
543 * @param expr Expression which should be true.
544 * @param rc What is to be presented to return.
545 */
546#ifdef RT_STRICT
547# define AssertReturn(expr, rc) \
548 do { \
549 if (RT_UNLIKELY(!(expr))) \
550 { \
551 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
552 RTAssertPanic(); \
553 return (rc); \
554 } \
555 } while (0)
556#else
557# define AssertReturn(expr, rc) \
558 do { \
559 if (RT_UNLIKELY(!(expr))) \
560 return (rc); \
561 } while (0)
562#endif
563
564/** @def AssertReturnStmt
565 * Assert that an expression is true, if it isn't execute the given statement
566 * and return rc.
567 *
568 * In RT_STRICT mode it will hit a breakpoint before executing the statement and
569 * returning.
570 *
571 * @param expr Expression which should be true.
572 * @param stmt Statement to execute before returning on failure.
573 * @param rc What is to be presented to return.
574 */
575#ifdef RT_STRICT
576# define AssertReturnStmt(expr, stmt, rc) \
577 do { \
578 if (RT_UNLIKELY(!(expr))) \
579 { \
580 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
581 RTAssertPanic(); \
582 stmt; \
583 return (rc); \
584 } \
585 } while (0)
586#else
587# define AssertReturnStmt(expr, stmt, rc) \
588 do { \
589 if (RT_UNLIKELY(!(expr))) \
590 { \
591 stmt; \
592 return (rc); \
593 } \
594 } while (0)
595#endif
596
597/** @def AssertReturnVoid
598 * Assert that an expression is true and returns if it isn't.
599 * In RT_STRICT mode it will hit a breakpoint before returning.
600 *
601 * @param expr Expression which should be true.
602 */
603#ifdef RT_STRICT
604# define AssertReturnVoid(expr) \
605 do { \
606 if (RT_UNLIKELY(!(expr))) \
607 { \
608 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
609 RTAssertPanic(); \
610 return; \
611 } \
612 } while (0)
613#else
614# define AssertReturnVoid(expr) \
615 do { \
616 if (RT_UNLIKELY(!(expr))) \
617 return; \
618 } while (0)
619#endif
620
621/** @def AssertReturnVoidStmt
622 * Assert that an expression is true, if it isn't execute the given statement
623 * and return.
624 *
625 * In RT_STRICT mode it will hit a breakpoint before returning.
626 *
627 * @param expr Expression which should be true.
628 * @param stmt Statement to execute before returning on failure.
629 */
630#ifdef RT_STRICT
631# define AssertReturnVoidStmt(expr, stmt) \
632 do { \
633 if (RT_UNLIKELY(!(expr))) \
634 { \
635 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
636 RTAssertPanic(); \
637 stmt; \
638 return; \
639 } \
640 } while (0)
641#else
642# define AssertReturnVoidStmt(expr, stmt) \
643 do { \
644 if (RT_UNLIKELY(!(expr))) \
645 { \
646 stmt; \
647 return; \
648 } \
649 } while (0)
650#endif
651
652
653/** @def AssertBreak
654 * Assert that an expression is true and breaks if it isn't.
655 * In RT_STRICT mode it will hit a breakpoint before returning.
656 *
657 * @param expr Expression which should be true.
658 */
659#ifdef RT_STRICT
660# define AssertBreak(expr) \
661 if (RT_UNLIKELY(!(expr))) \
662 { \
663 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
664 RTAssertPanic(); \
665 break; \
666 } else do {} while (0)
667#else
668# define AssertBreak(expr) \
669 if (RT_UNLIKELY(!(expr))) \
670 break; \
671 else do {} while (0)
672#endif
673
674/** @def AssertBreakStmt
675 * Assert that an expression is true and breaks if it isn't.
676 * In RT_STRICT mode it will hit a breakpoint before doing break.
677 *
678 * @param expr Expression which should be true.
679 * @param stmt Statement to execute before break in case of a failed assertion.
680 */
681#ifdef RT_STRICT
682# define AssertBreakStmt(expr, stmt) \
683 if (RT_UNLIKELY(!(expr))) { \
684 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
685 RTAssertPanic(); \
686 stmt; \
687 break; \
688 } else do {} while (0)
689#else
690# define AssertBreakStmt(expr, stmt) \
691 if (RT_UNLIKELY(!(expr))) { \
692 stmt; \
693 break; \
694 } else do {} while (0)
695#endif
696
697
698/** @def AssertMsg
699 * Assert that an expression is true. If it's not print message and hit breakpoint.
700 * @param expr Expression which should be true.
701 * @param a printf argument list (in parenthesis).
702 */
703#ifdef RT_STRICT
704# define AssertMsg(expr, a) \
705 do { \
706 if (RT_UNLIKELY(!(expr))) \
707 { \
708 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
709 RTAssertMsg2Weak a; \
710 RTAssertPanic(); \
711 } \
712 } while (0)
713#else
714# define AssertMsg(expr, a) do { } while (0)
715#endif
716
717/** @def AssertMsgStmt
718 * Assert that an expression is true. If it's not print message and hit
719 * breakpoint and execute the statement.
720 *
721 * @param expr Expression which should be true.
722 * @param a printf argument list (in parenthesis).
723 * @param stmt Statement to execute in case of a failed assertion.
724 *
725 * @remarks The expression and statement will be evaluated in all build types.
726 */
727#ifdef RT_STRICT
728# define AssertMsgStmt(expr, a, stmt) \
729 do { \
730 if (RT_UNLIKELY(!(expr))) \
731 { \
732 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
733 RTAssertMsg2Weak a; \
734 RTAssertPanic(); \
735 stmt; \
736 } \
737 } while (0)
738#else
739# define AssertMsgStmt(expr, a, stmt) \
740 do { \
741 if (RT_UNLIKELY(!(expr))) \
742 { \
743 stmt; \
744 } \
745 } while (0)
746#endif
747
748/** @def AssertMsgReturn
749 * Assert that an expression is true and returns if it isn't.
750 * In RT_STRICT mode it will hit a breakpoint before returning.
751 *
752 * @param expr Expression which should be true.
753 * @param a printf argument list (in parenthesis).
754 * @param rc What is to be presented to return.
755 */
756#ifdef RT_STRICT
757# define AssertMsgReturn(expr, a, rc) \
758 do { \
759 if (RT_UNLIKELY(!(expr))) \
760 { \
761 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
762 RTAssertMsg2Weak a; \
763 RTAssertPanic(); \
764 return (rc); \
765 } \
766 } while (0)
767#else
768# define AssertMsgReturn(expr, a, rc) \
769 do { \
770 if (RT_UNLIKELY(!(expr))) \
771 return (rc); \
772 } while (0)
773#endif
774
775/** @def AssertMsgReturnStmt
776 * Assert that an expression is true, if it isn't execute the statement and
777 * return.
778 *
779 * In RT_STRICT mode it will hit a breakpoint before returning.
780 *
781 * @param expr Expression which should be true.
782 * @param a printf argument list (in parenthesis).
783 * @param stmt Statement to execute before returning in case of a failed
784 * assertion.
785 * @param rc What is to be presented to return.
786 */
787#ifdef RT_STRICT
788# define AssertMsgReturnStmt(expr, a, stmt, rc) \
789 do { \
790 if (RT_UNLIKELY(!(expr))) \
791 { \
792 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
793 RTAssertMsg2Weak a; \
794 RTAssertPanic(); \
795 stmt; \
796 return (rc); \
797 } \
798 } while (0)
799#else
800# define AssertMsgReturnStmt(expr, a, stmt, rc) \
801 do { \
802 if (RT_UNLIKELY(!(expr))) \
803 { \
804 stmt; \
805 return (rc); \
806 } \
807 } while (0)
808#endif
809
810/** @def AssertMsgReturnVoid
811 * Assert that an expression is true and returns if it isn't.
812 * In RT_STRICT mode it will hit a breakpoint before returning.
813 *
814 * @param expr Expression which should be true.
815 * @param a printf argument list (in parenthesis).
816 */
817#ifdef RT_STRICT
818# define AssertMsgReturnVoid(expr, a) \
819 do { \
820 if (RT_UNLIKELY(!(expr))) \
821 { \
822 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
823 RTAssertMsg2Weak a; \
824 RTAssertPanic(); \
825 return; \
826 } \
827 } while (0)
828#else
829# define AssertMsgReturnVoid(expr, a) \
830 do { \
831 if (RT_UNLIKELY(!(expr))) \
832 return; \
833 } while (0)
834#endif
835
836/** @def AssertMsgReturnVoidStmt
837 * Assert that an expression is true, if it isn't execute the statement and
838 * return.
839 *
840 * In RT_STRICT mode it will hit a breakpoint before returning.
841 *
842 * @param expr Expression which should be true.
843 * @param a printf argument list (in parenthesis).
844 * @param stmt Statement to execute before break in case of a failed assertion.
845 */
846#ifdef RT_STRICT
847# define AssertMsgReturnVoidStmt(expr, a, stmt) \
848 do { \
849 if (RT_UNLIKELY(!(expr))) \
850 { \
851 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
852 RTAssertMsg2Weak a; \
853 RTAssertPanic(); \
854 stmt; \
855 return; \
856 } \
857 } while (0)
858#else
859# define AssertMsgReturnVoidStmt(expr, a, stmt) \
860 do { \
861 if (RT_UNLIKELY(!(expr))) \
862 { \
863 stmt; \
864 return; \
865 } \
866 } while (0)
867#endif
868
869
870/** @def AssertMsgBreak
871 * Assert that an expression is true and breaks if it isn't.
872 * In RT_STRICT mode it will hit a breakpoint before returning.
873 *
874 * @param expr Expression which should be true.
875 * @param a printf argument list (in parenthesis).
876 */
877#ifdef RT_STRICT
878# define AssertMsgBreak(expr, a) \
879 if (RT_UNLIKELY(!(expr))) \
880 { \
881 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
882 RTAssertMsg2Weak a; \
883 RTAssertPanic(); \
884 break; \
885 } else do {} while (0)
886#else
887# define AssertMsgBreak(expr, a) \
888 if (RT_UNLIKELY(!(expr))) \
889 break; \
890 else do {} while (0)
891#endif
892
893/** @def AssertMsgBreakStmt
894 * Assert that an expression is true and breaks if it isn't.
895 * In RT_STRICT mode it will hit a breakpoint before doing break.
896 *
897 * @param expr Expression which should be true.
898 * @param a printf argument list (in parenthesis).
899 * @param stmt Statement to execute before break in case of a failed assertion.
900 */
901#ifdef RT_STRICT
902# define AssertMsgBreakStmt(expr, a, stmt) \
903 if (RT_UNLIKELY(!(expr))) { \
904 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
905 RTAssertMsg2Weak a; \
906 RTAssertPanic(); \
907 stmt; \
908 break; \
909 } else do {} while (0)
910#else
911# define AssertMsgBreakStmt(expr, a, stmt) \
912 if (RT_UNLIKELY(!(expr))) { \
913 stmt; \
914 break; \
915 } else do {} while (0)
916#endif
917
918/** @def AssertFailed
919 * An assertion failed hit breakpoint.
920 */
921#ifdef RT_STRICT
922# define AssertFailed() \
923 do { \
924 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
925 RTAssertPanic(); \
926 } while (0)
927#else
928# define AssertFailed() do { } while (0)
929#endif
930
931/** @def AssertFailedReturn
932 * An assertion failed, hit breakpoint (RT_STRICT mode only) and return.
933 *
934 * @param rc The rc to return.
935 */
936#ifdef RT_STRICT
937# define AssertFailedReturn(rc) \
938 do { \
939 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
940 RTAssertPanic(); \
941 return (rc); \
942 } while (0)
943#else
944# define AssertFailedReturn(rc) \
945 do { \
946 return (rc); \
947 } while (0)
948#endif
949
950/** @def AssertFailedReturnStmt
951 * An assertion failed, hit breakpoint (RT_STRICT mode only), execute a
952 * statement and return a value.
953 *
954 * @param stmt The statement to execute before returning.
955 * @param rc The value to return.
956 */
957#ifdef RT_STRICT
958# define AssertFailedReturnStmt(stmt, rc) \
959 do { \
960 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
961 RTAssertPanic(); \
962 stmt; \
963 return (rc); \
964 } while (0)
965#else
966# define AssertFailedReturnStmt(stmt, rc) \
967 do { \
968 stmt; \
969 return (rc); \
970 } while (0)
971#endif
972
973/** @def AssertFailedReturnVoid
974 * An assertion failed, hit breakpoint (RT_STRICT mode only) and return.
975 */
976#ifdef RT_STRICT
977# define AssertFailedReturnVoid() \
978 do { \
979 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
980 RTAssertPanic(); \
981 return; \
982 } while (0)
983#else
984# define AssertFailedReturnVoid() \
985 do { \
986 return; \
987 } while (0)
988#endif
989
990/** @def AssertFailedReturnVoidStmt
991 * An assertion failed, hit breakpoint (RT_STRICT mode only), execute a
992 * statement and return.
993 *
994 * @param stmt The statement to execute before returning.
995 */
996#ifdef RT_STRICT
997# define AssertFailedReturnVoidStmt(stmt) \
998 do { \
999 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1000 RTAssertPanic(); \
1001 stmt; \
1002 return; \
1003 } while (0)
1004#else
1005# define AssertFailedReturnVoidStmt(stmt) \
1006 do { \
1007 stmt; \
1008 return; \
1009 } while (0)
1010#endif
1011
1012
1013/** @def AssertFailedBreak
1014 * An assertion failed, hit breakpoint (RT_STRICT mode only) and break.
1015 */
1016#ifdef RT_STRICT
1017# define AssertFailedBreak() \
1018 if (1) { \
1019 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1020 RTAssertPanic(); \
1021 break; \
1022 } else do {} while (0)
1023#else
1024# define AssertFailedBreak() \
1025 if (1) \
1026 break; \
1027 else do {} while (0)
1028#endif
1029
1030/** @def AssertFailedBreakStmt
1031 * An assertion failed, hit breakpoint (RT_STRICT mode only), execute
1032 * the given statement and break.
1033 *
1034 * @param stmt Statement to execute before break.
1035 */
1036#ifdef RT_STRICT
1037# define AssertFailedBreakStmt(stmt) \
1038 if (1) { \
1039 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1040 RTAssertPanic(); \
1041 stmt; \
1042 break; \
1043 } else do {} while (0)
1044#else
1045# define AssertFailedBreakStmt(stmt) \
1046 if (1) { \
1047 stmt; \
1048 break; \
1049 } else do {} while (0)
1050#endif
1051
1052
1053/** @def AssertMsgFailed
1054 * An assertion failed print a message and a hit breakpoint.
1055 *
1056 * @param a printf argument list (in parenthesis).
1057 */
1058#ifdef RT_STRICT
1059# define AssertMsgFailed(a) \
1060 do { \
1061 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1062 RTAssertMsg2Weak a; \
1063 RTAssertPanic(); \
1064 } while (0)
1065#else
1066# define AssertMsgFailed(a) do { } while (0)
1067#endif
1068
1069/** @def AssertMsgFailedReturn
1070 * An assertion failed, hit breakpoint with message (RT_STRICT mode only) and return.
1071 *
1072 * @param a printf argument list (in parenthesis).
1073 * @param rc What is to be presented to return.
1074 */
1075#ifdef RT_STRICT
1076# define AssertMsgFailedReturn(a, rc) \
1077 do { \
1078 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1079 RTAssertMsg2Weak a; \
1080 RTAssertPanic(); \
1081 return (rc); \
1082 } while (0)
1083#else
1084# define AssertMsgFailedReturn(a, rc) \
1085 do { \
1086 return (rc); \
1087 } while (0)
1088#endif
1089
1090/** @def AssertMsgFailedReturnVoid
1091 * An assertion failed, hit breakpoint with message (RT_STRICT mode only) and return.
1092 *
1093 * @param a printf argument list (in parenthesis).
1094 */
1095#ifdef RT_STRICT
1096# define AssertMsgFailedReturnVoid(a) \
1097 do { \
1098 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1099 RTAssertMsg2Weak a; \
1100 RTAssertPanic(); \
1101 return; \
1102 } while (0)
1103#else
1104# define AssertMsgFailedReturnVoid(a) \
1105 do { \
1106 return; \
1107 } while (0)
1108#endif
1109
1110
1111/** @def AssertMsgFailedBreak
1112 * An assertion failed, hit breakpoint with message (RT_STRICT mode only) and break.
1113 *
1114 * @param a printf argument list (in parenthesis).
1115 */
1116#ifdef RT_STRICT
1117# define AssertMsgFailedBreak(a) \
1118 if (1) { \
1119 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1120 RTAssertMsg2Weak a; \
1121 RTAssertPanic(); \
1122 break; \
1123 } else do {} while (0)
1124#else
1125# define AssertMsgFailedBreak(a) \
1126 if (1) \
1127 break; \
1128 else do {} while (0)
1129#endif
1130
1131/** @def AssertMsgFailedBreakStmt
1132 * An assertion failed, hit breakpoint (RT_STRICT mode only), execute
1133 * the given statement and break.
1134 *
1135 * @param a printf argument list (in parenthesis).
1136 * @param stmt Statement to execute before break.
1137 */
1138#ifdef RT_STRICT
1139# define AssertMsgFailedBreakStmt(a, stmt) \
1140 if (1) { \
1141 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1142 RTAssertMsg2Weak a; \
1143 RTAssertPanic(); \
1144 stmt; \
1145 break; \
1146 } else do {} while (0)
1147#else
1148# define AssertMsgFailedBreakStmt(a, stmt) \
1149 if (1) { \
1150 stmt; \
1151 break; \
1152 } else do {} while (0)
1153#endif
1154
1155/** @} */
1156
1157
1158
1159/** @name Release Log Assertions
1160 *
1161 * These assertions will work like normal strict assertion when RT_STRICT is
1162 * defined and LogRel statements when RT_STRICT is undefined. Typically used for
1163 * things which shouldn't go wrong, but when it does you'd like to know one way
1164 * or the other.
1165 *
1166 * @{
1167 */
1168
1169/** @def RTAssertLogRelMsg1
1170 * RTAssertMsg1Weak (strict builds) / LogRel wrapper (non-strict).
1171 */
1172#ifdef RT_STRICT
1173# define RTAssertLogRelMsg1(pszExpr, iLine, pszFile, pszFunction) \
1174 RTAssertMsg1Weak(pszExpr, iLine, pszFile, pszFunction)
1175#else
1176# define RTAssertLogRelMsg1(pszExpr, iLine, pszFile, pszFunction) \
1177 LogRel(("AssertLogRel %s(%d) %s: %s\n",\
1178 (pszFile), (iLine), (pszFunction), (pszExpr) ))
1179#endif
1180
1181/** @def RTAssertLogRelMsg2
1182 * RTAssertMsg2Weak (strict builds) / LogRel wrapper (non-strict).
1183 */
1184#ifdef RT_STRICT
1185# define RTAssertLogRelMsg2(a) RTAssertMsg2Weak a
1186#else
1187# define RTAssertLogRelMsg2(a) LogRel(a)
1188#endif
1189
1190/** @def AssertLogRel
1191 * Assert that an expression is true.
1192 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1193 *
1194 * @param expr Expression which should be true.
1195 */
1196#define AssertLogRel(expr) \
1197 do { \
1198 if (RT_UNLIKELY(!(expr))) \
1199 { \
1200 RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1201 RTAssertPanic(); \
1202 } \
1203 } while (0)
1204
1205/** @def AssertLogRelReturn
1206 * Assert that an expression is true, return \a rc if it isn't.
1207 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1208 *
1209 * @param expr Expression which should be true.
1210 * @param rc What is to be presented to return.
1211 */
1212#define AssertLogRelReturn(expr, rc) \
1213 do { \
1214 if (RT_UNLIKELY(!(expr))) \
1215 { \
1216 RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1217 RTAssertPanic(); \
1218 return (rc); \
1219 } \
1220 } while (0)
1221
1222/** @def AssertLogRelReturnVoid
1223 * Assert that an expression is true, return void if it isn't.
1224 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1225 *
1226 * @param expr Expression which should be true.
1227 */
1228#define AssertLogRelReturnVoid(expr) \
1229 do { \
1230 if (RT_UNLIKELY(!(expr))) \
1231 { \
1232 RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1233 RTAssertPanic(); \
1234 return; \
1235 } \
1236 } while (0)
1237
1238/** @def AssertLogRelBreak
1239 * Assert that an expression is true, break if it isn't.
1240 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1241 *
1242 * @param expr Expression which should be true.
1243 */
1244#define AssertLogRelBreak(expr) \
1245 if (RT_UNLIKELY(!(expr))) \
1246 { \
1247 RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1248 RTAssertPanic(); \
1249 break; \
1250 } \
1251 else do {} while (0)
1252
1253/** @def AssertLogRelBreakStmt
1254 * Assert that an expression is true, execute \a stmt and break if it isn't.
1255 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1256 *
1257 * @param expr Expression which should be true.
1258 * @param stmt Statement to execute before break in case of a failed assertion.
1259 */
1260#define AssertLogRelBreakStmt(expr, stmt) \
1261 if (RT_UNLIKELY(!(expr))) \
1262 { \
1263 RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1264 RTAssertPanic(); \
1265 stmt; \
1266 break; \
1267 } else do {} while (0)
1268
1269/** @def AssertLogRelMsg
1270 * Assert that an expression is true.
1271 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1272 *
1273 * @param expr Expression which should be true.
1274 * @param a printf argument list (in parenthesis).
1275 */
1276#define AssertLogRelMsg(expr, a) \
1277 do { \
1278 if (RT_UNLIKELY(!(expr))) \
1279 { \
1280 RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1281 RTAssertLogRelMsg2(a); \
1282 RTAssertPanic(); \
1283 } \
1284 } while (0)
1285
1286/** @def AssertLogRelMsgStmt
1287 * Assert that an expression is true, execute \a stmt and break if it isn't
1288 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1289 *
1290 * @param expr Expression which should be true.
1291 * @param a printf argument list (in parenthesis).
1292 * @param stmt Statement to execute in case of a failed assertion.
1293 */
1294#define AssertLogRelMsgStmt(expr, a, stmt) \
1295 do { \
1296 if (RT_UNLIKELY(!(expr))) \
1297 { \
1298 RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1299 RTAssertLogRelMsg2(a); \
1300 RTAssertPanic(); \
1301 stmt; \
1302 } \
1303 } while (0)
1304
1305/** @def AssertLogRelMsgReturn
1306 * Assert that an expression is true, return \a rc if it isn't.
1307 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1308 *
1309 * @param expr Expression which should be true.
1310 * @param a printf argument list (in parenthesis).
1311 * @param rc What is to be presented to return.
1312 */
1313#define AssertLogRelMsgReturn(expr, a, rc) \
1314 do { \
1315 if (RT_UNLIKELY(!(expr))) \
1316 { \
1317 RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1318 RTAssertLogRelMsg2(a); \
1319 RTAssertPanic(); \
1320 return (rc); \
1321 } \
1322 } while (0)
1323
1324/** @def AssertLogRelMsgReturnStmt
1325 * Assert that an expression is true, execute @a stmt and return @a rcRet if it
1326 * isn't.
1327 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1328 *
1329 * @param expr Expression which should be true.
1330 * @param a printf argument list (in parenthesis).
1331 * @param stmt Statement to execute before returning in case of a failed
1332 * assertion.
1333 * @param rcRet What is to be presented to return.
1334 */
1335#define AssertLogRelMsgReturnStmt(expr, a, stmt, rcRet) \
1336 do { \
1337 if (RT_UNLIKELY(!(expr))) \
1338 { \
1339 RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1340 RTAssertLogRelMsg2(a); \
1341 RTAssertPanic(); \
1342 stmt; \
1343 return (rcRet); \
1344 } \
1345 } while (0)
1346
1347/** @def AssertLogRelMsgReturnVoid
1348 * Assert that an expression is true, return (void) if it isn't.
1349 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1350 *
1351 * @param expr Expression which should be true.
1352 * @param a printf argument list (in parenthesis).
1353 */
1354#define AssertLogRelMsgReturnVoid(expr, a) \
1355 do { \
1356 if (RT_UNLIKELY(!(expr))) \
1357 { \
1358 RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1359 RTAssertLogRelMsg2(a); \
1360 RTAssertPanic(); \
1361 return; \
1362 } \
1363 } while (0)
1364
1365/** @def AssertLogRelMsgBreak
1366 * Assert that an expression is true, break if it isn't.
1367 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1368 *
1369 * @param expr Expression which should be true.
1370 * @param a printf argument list (in parenthesis).
1371 */
1372#define AssertLogRelMsgBreak(expr, a) \
1373 if (RT_UNLIKELY(!(expr))) \
1374 { \
1375 RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1376 RTAssertLogRelMsg2(a); \
1377 RTAssertPanic(); \
1378 break; \
1379 } \
1380 else do {} while (0)
1381
1382/** @def AssertLogRelMsgBreakStmt
1383 * Assert that an expression is true, execute \a stmt and break if it isn't.
1384 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1385 *
1386 * @param expr Expression which should be true.
1387 * @param a printf argument list (in parenthesis).
1388 * @param stmt Statement to execute before break in case of a failed assertion.
1389 */
1390#define AssertLogRelMsgBreakStmt(expr, a, stmt) \
1391 if (RT_UNLIKELY(!(expr))) \
1392 { \
1393 RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1394 RTAssertLogRelMsg2(a); \
1395 RTAssertPanic(); \
1396 stmt; \
1397 break; \
1398 } else do {} while (0)
1399
1400/** @def AssertLogRelFailed
1401 * An assertion failed.
1402 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1403 */
1404#define AssertLogRelFailed() \
1405 do { \
1406 RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1407 RTAssertPanic(); \
1408 } while (0)
1409
1410/** @def AssertLogRelFailedReturn
1411 * An assertion failed.
1412 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1413 *
1414 * @param rc What is to be presented to return.
1415 */
1416#define AssertLogRelFailedReturn(rc) \
1417 do { \
1418 RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1419 RTAssertPanic(); \
1420 return (rc); \
1421 } while (0)
1422
1423/** @def AssertLogRelFailedReturnVoid
1424 * An assertion failed, hit a breakpoint and return.
1425 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1426 */
1427#define AssertLogRelFailedReturnVoid() \
1428 do { \
1429 RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1430 RTAssertPanic(); \
1431 return; \
1432 } while (0)
1433
1434/** @def AssertLogRelFailedBreak
1435 * An assertion failed, break.
1436 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1437 */
1438#define AssertLogRelFailedBreak() \
1439 if (1) \
1440 { \
1441 RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1442 RTAssertPanic(); \
1443 break; \
1444 } else do {} while (0)
1445
1446/** @def AssertLogRelFailedBreakStmt
1447 * An assertion failed, execute \a stmt and break.
1448 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1449 *
1450 * @param stmt Statement to execute before break.
1451 */
1452#define AssertLogRelFailedBreakStmt(stmt) \
1453 if (1) \
1454 { \
1455 RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1456 RTAssertPanic(); \
1457 stmt; \
1458 break; \
1459 } else do {} while (0)
1460
1461/** @def AssertLogRelMsgFailed
1462 * An assertion failed.
1463 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1464 *
1465 * @param a printf argument list (in parenthesis).
1466 */
1467#define AssertLogRelMsgFailed(a) \
1468 do { \
1469 RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1470 RTAssertLogRelMsg2(a); \
1471 RTAssertPanic(); \
1472 } while (0)
1473
1474/** @def AssertLogRelMsgFailedStmt
1475 * An assertion failed, execute @a stmt.
1476 *
1477 * Strict builds will hit a breakpoint, non-strict will only do LogRel. The
1478 * statement will be executed in regardless of build type.
1479 *
1480 * @param a printf argument list (in parenthesis).
1481 * @param stmt Statement to execute after raising/logging the assertion.
1482 */
1483#define AssertLogRelMsgFailedStmt(a, stmt) \
1484 do { \
1485 RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1486 RTAssertLogRelMsg2(a); \
1487 RTAssertPanic(); \
1488 stmt; \
1489 } while (0)
1490
1491/** @def AssertLogRelMsgFailedReturn
1492 * An assertion failed, return \a rc.
1493 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1494 *
1495 * @param a printf argument list (in parenthesis).
1496 * @param rc What is to be presented to return.
1497 */
1498#define AssertLogRelMsgFailedReturn(a, rc) \
1499 do { \
1500 RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1501 RTAssertLogRelMsg2(a); \
1502 RTAssertPanic(); \
1503 return (rc); \
1504 } while (0)
1505
1506/** @def AssertLogRelMsgFailedReturn
1507 * An assertion failed, execute @a stmt and return @a rc.
1508 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1509 *
1510 * @param a printf argument list (in parenthesis).
1511 * @param stmt Statement to execute before returning in case of a failed
1512 * assertion.
1513 * @param rc What is to be presented to return.
1514 */
1515#define AssertLogRelMsgFailedReturnStmt(a, stmt, rc) \
1516 do { \
1517 RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1518 RTAssertLogRelMsg2(a); \
1519 RTAssertPanic(); \
1520 stmt; \
1521 return (rc); \
1522 } while (0)
1523
1524/** @def AssertLogRelMsgFailedReturnVoid
1525 * An assertion failed, return void.
1526 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1527 *
1528 * @param a printf argument list (in parenthesis).
1529 */
1530#define AssertLogRelMsgFailedReturnVoid(a) \
1531 do { \
1532 RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1533 RTAssertLogRelMsg2(a); \
1534 RTAssertPanic(); \
1535 return; \
1536 } while (0)
1537
1538/** @def AssertLogRelMsgFailedReturnVoid
1539 * An assertion failed, execute @a stmt and return void.
1540 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1541 *
1542 * @param a printf argument list (in parenthesis).
1543 * @param stmt Statement to execute before returning in case of a failed
1544 * assertion.
1545 */
1546#define AssertLogRelMsgFailedReturnVoidStmt(a, stmt) \
1547 do { \
1548 RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1549 RTAssertLogRelMsg2(a); \
1550 RTAssertPanic(); \
1551 stmt; \
1552 return; \
1553 } while (0)
1554
1555/** @def AssertLogRelMsgFailedBreak
1556 * An assertion failed, break.
1557 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1558 *
1559 * @param a printf argument list (in parenthesis).
1560 */
1561#define AssertLogRelMsgFailedBreak(a) \
1562 if (1)\
1563 { \
1564 RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1565 RTAssertLogRelMsg2(a); \
1566 RTAssertPanic(); \
1567 break; \
1568 } else do {} while (0)
1569
1570/** @def AssertLogRelMsgFailedBreakStmt
1571 * An assertion failed, execute \a stmt and break.
1572 * Strict builds will hit a breakpoint, non-strict will only do LogRel.
1573 *
1574 * @param a printf argument list (in parenthesis).
1575 * @param stmt Statement to execute before break.
1576 */
1577#define AssertLogRelMsgFailedBreakStmt(a, stmt) \
1578 if (1) \
1579 { \
1580 RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1581 RTAssertLogRelMsg2(a); \
1582 RTAssertPanic(); \
1583 stmt; \
1584 break; \
1585 } else do {} while (0)
1586
1587/** @} */
1588
1589
1590
1591/** @name Release Assertions
1592 *
1593 * These assertions are always enabled.
1594 * @{
1595 */
1596
1597/** @def RTAssertReleasePanic()
1598 * Invokes RTAssertShouldPanic and RTAssertDoPanic.
1599 *
1600 * It might seem odd that RTAssertShouldPanic is necessary when its result isn't
1601 * checked, but it's done since RTAssertShouldPanic is overrideable and might be
1602 * used to bail out before taking down the system (the VMMR0 case).
1603 */
1604#define RTAssertReleasePanic() do { RTAssertShouldPanic(); RTAssertDoPanic(); } while (0)
1605
1606
1607/** @def AssertRelease
1608 * Assert that an expression is true. If it's not hit a breakpoint.
1609 *
1610 * @param expr Expression which should be true.
1611 */
1612#define AssertRelease(expr) \
1613 do { \
1614 if (RT_UNLIKELY(!(expr))) \
1615 { \
1616 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1617 RTAssertReleasePanic(); \
1618 } \
1619 } while (0)
1620
1621/** @def AssertReleaseReturn
1622 * Assert that an expression is true, hit a breakpoint and return if it isn't.
1623 *
1624 * @param expr Expression which should be true.
1625 * @param rc What is to be presented to return.
1626 */
1627#define AssertReleaseReturn(expr, rc) \
1628 do { \
1629 if (RT_UNLIKELY(!(expr))) \
1630 { \
1631 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1632 RTAssertReleasePanic(); \
1633 return (rc); \
1634 } \
1635 } while (0)
1636
1637/** @def AssertReleaseReturnVoid
1638 * Assert that an expression is true, hit a breakpoint and return if it isn't.
1639 *
1640 * @param expr Expression which should be true.
1641 */
1642#define AssertReleaseReturnVoid(expr) \
1643 do { \
1644 if (RT_UNLIKELY(!(expr))) \
1645 { \
1646 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1647 RTAssertReleasePanic(); \
1648 return; \
1649 } \
1650 } while (0)
1651
1652
1653/** @def AssertReleaseBreak
1654 * Assert that an expression is true, hit a breakpoint and break if it isn't.
1655 *
1656 * @param expr Expression which should be true.
1657 */
1658#define AssertReleaseBreak(expr) \
1659 if { \
1660 if (RT_UNLIKELY(!(expr))) \
1661 { \
1662 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1663 RTAssertReleasePanic(); \
1664 break; \
1665 } \
1666 } else do {} while (0)
1667
1668/** @def AssertReleaseBreakStmt
1669 * Assert that an expression is true, hit a breakpoint and break if it isn't.
1670 *
1671 * @param expr Expression which should be true.
1672 * @param stmt Statement to execute before break in case of a failed assertion.
1673 */
1674#define AssertReleaseBreakStmt(expr, stmt) \
1675 if (RT_UNLIKELY(!(expr))) \
1676 { \
1677 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1678 RTAssertReleasePanic(); \
1679 stmt; \
1680 break; \
1681 } else do {} while (0)
1682
1683
1684/** @def AssertReleaseMsg
1685 * Assert that an expression is true, print the message and hit a breakpoint if it isn't.
1686 *
1687 * @param expr Expression which should be true.
1688 * @param a printf argument list (in parenthesis).
1689 */
1690#define AssertReleaseMsg(expr, a) \
1691 do { \
1692 if (RT_UNLIKELY(!(expr))) \
1693 { \
1694 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1695 RTAssertMsg2Weak a; \
1696 RTAssertReleasePanic(); \
1697 } \
1698 } while (0)
1699
1700/** @def AssertReleaseMsgReturn
1701 * Assert that an expression is true, print the message and hit a breakpoint and return if it isn't.
1702 *
1703 * @param expr Expression which should be true.
1704 * @param a printf argument list (in parenthesis).
1705 * @param rc What is to be presented to return.
1706 */
1707#define AssertReleaseMsgReturn(expr, a, rc) \
1708 do { \
1709 if (RT_UNLIKELY(!(expr))) \
1710 { \
1711 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1712 RTAssertMsg2Weak a; \
1713 RTAssertReleasePanic(); \
1714 return (rc); \
1715 } \
1716 } while (0)
1717
1718/** @def AssertReleaseMsgReturnVoid
1719 * Assert that an expression is true, print the message and hit a breakpoint and return if it isn't.
1720 *
1721 * @param expr Expression which should be true.
1722 * @param a printf argument list (in parenthesis).
1723 */
1724#define AssertReleaseMsgReturnVoid(expr, a) \
1725 do { \
1726 if (RT_UNLIKELY(!(expr))) \
1727 { \
1728 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1729 RTAssertMsg2Weak a; \
1730 RTAssertReleasePanic(); \
1731 return; \
1732 } \
1733 } while (0)
1734
1735
1736/** @def AssertReleaseMsgBreak
1737 * Assert that an expression is true, print the message and hit a breakpoint and break if it isn't.
1738 *
1739 * @param expr Expression which should be true.
1740 * @param a printf argument list (in parenthesis).
1741 */
1742#define AssertReleaseMsgBreak(expr, a) \
1743 if (RT_UNLIKELY(!(expr))) \
1744 { \
1745 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1746 RTAssertMsg2Weak a; \
1747 RTAssertReleasePanic(); \
1748 break; \
1749 } else do {} while (0)
1750
1751/** @def AssertReleaseMsgBreakStmt
1752 * Assert that an expression is true, print the message and hit a breakpoint and break if it isn't.
1753 *
1754 * @param expr Expression which should be true.
1755 * @param a printf argument list (in parenthesis).
1756 * @param stmt Statement to execute before break in case of a failed assertion.
1757 */
1758#define AssertReleaseMsgBreakStmt(expr, a, stmt) \
1759 if (RT_UNLIKELY(!(expr))) { \
1760 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1761 RTAssertMsg2Weak a; \
1762 RTAssertReleasePanic(); \
1763 stmt; \
1764 break; \
1765 } else do {} while (0)
1766
1767
1768/** @def AssertReleaseFailed
1769 * An assertion failed, hit a breakpoint.
1770 */
1771#define AssertReleaseFailed() \
1772 do { \
1773 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1774 RTAssertReleasePanic(); \
1775 } while (0)
1776
1777/** @def AssertReleaseFailedReturn
1778 * An assertion failed, hit a breakpoint and return.
1779 *
1780 * @param rc What is to be presented to return.
1781 */
1782#define AssertReleaseFailedReturn(rc) \
1783 do { \
1784 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1785 RTAssertReleasePanic(); \
1786 return (rc); \
1787 } while (0)
1788
1789/** @def AssertReleaseFailedReturnVoid
1790 * An assertion failed, hit a breakpoint and return.
1791 */
1792#define AssertReleaseFailedReturnVoid() \
1793 do { \
1794 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1795 RTAssertReleasePanic(); \
1796 return; \
1797 } while (0)
1798
1799
1800/** @def AssertReleaseFailedBreak
1801 * An assertion failed, hit a breakpoint and break.
1802 */
1803#define AssertReleaseFailedBreak() \
1804 if (1) { \
1805 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1806 RTAssertReleasePanic(); \
1807 break; \
1808 } else do {} while (0)
1809
1810/** @def AssertReleaseFailedBreakStmt
1811 * An assertion failed, hit a breakpoint and break.
1812 *
1813 * @param stmt Statement to execute before break.
1814 */
1815#define AssertReleaseFailedBreakStmt(stmt) \
1816 if (1) { \
1817 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1818 RTAssertReleasePanic(); \
1819 stmt; \
1820 break; \
1821 } else do {} while (0)
1822
1823
1824/** @def AssertReleaseMsgFailed
1825 * An assertion failed, print a message and hit a breakpoint.
1826 *
1827 * @param a printf argument list (in parenthesis).
1828 */
1829#define AssertReleaseMsgFailed(a) \
1830 do { \
1831 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1832 RTAssertMsg2Weak a; \
1833 RTAssertReleasePanic(); \
1834 } while (0)
1835
1836/** @def AssertReleaseMsgFailedReturn
1837 * An assertion failed, print a message, hit a breakpoint and return.
1838 *
1839 * @param a printf argument list (in parenthesis).
1840 * @param rc What is to be presented to return.
1841 */
1842#define AssertReleaseMsgFailedReturn(a, rc) \
1843 do { \
1844 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1845 RTAssertMsg2Weak a; \
1846 RTAssertReleasePanic(); \
1847 return (rc); \
1848 } while (0)
1849
1850/** @def AssertReleaseMsgFailedReturnVoid
1851 * An assertion failed, print a message, hit a breakpoint and return.
1852 *
1853 * @param a printf argument list (in parenthesis).
1854 */
1855#define AssertReleaseMsgFailedReturnVoid(a) \
1856 do { \
1857 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1858 RTAssertMsg2Weak a; \
1859 RTAssertReleasePanic(); \
1860 return; \
1861 } while (0)
1862
1863
1864/** @def AssertReleaseMsgFailedBreak
1865 * An assertion failed, print a message, hit a breakpoint and break.
1866 *
1867 * @param a printf argument list (in parenthesis).
1868 */
1869#define AssertReleaseMsgFailedBreak(a) \
1870 if (1) { \
1871 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1872 RTAssertMsg2Weak a; \
1873 RTAssertReleasePanic(); \
1874 break; \
1875 } else do {} while (0)
1876
1877/** @def AssertReleaseMsgFailedBreakStmt
1878 * An assertion failed, print a message, hit a breakpoint and break.
1879 *
1880 * @param a printf argument list (in parenthesis).
1881 * @param stmt Statement to execute before break.
1882 */
1883#define AssertReleaseMsgFailedBreakStmt(a, stmt) \
1884 if (1) { \
1885 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1886 RTAssertMsg2Weak a; \
1887 RTAssertReleasePanic(); \
1888 stmt; \
1889 break; \
1890 } else do {} while (0)
1891
1892/** @} */
1893
1894
1895
1896/** @name Fatal Assertions
1897 * These are similar to release assertions except that you cannot ignore them in
1898 * any way, they will loop for ever if RTAssertDoPanic returns.
1899 *
1900 * @{
1901 */
1902
1903/** @def AssertFatal
1904 * Assert that an expression is true. If it's not hit a breakpoint (for ever).
1905 *
1906 * @param expr Expression which should be true.
1907 */
1908#define AssertFatal(expr) \
1909 do { \
1910 if (RT_UNLIKELY(!(expr))) \
1911 for (;;) \
1912 { \
1913 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1914 RTAssertReleasePanic(); \
1915 } \
1916 } while (0)
1917
1918/** @def AssertFatalMsg
1919 * Assert that an expression is true, print the message and hit a breakpoint (for ever) if it isn't.
1920 *
1921 * @param expr Expression which should be true.
1922 * @param a printf argument list (in parenthesis).
1923 */
1924#define AssertFatalMsg(expr, a) \
1925 do { \
1926 if (RT_UNLIKELY(!(expr))) \
1927 for (;;) \
1928 { \
1929 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1930 RTAssertMsg2Weak a; \
1931 RTAssertReleasePanic(); \
1932 } \
1933 } while (0)
1934
1935/** @def AssertFatalFailed
1936 * An assertion failed, hit a breakpoint (for ever).
1937 */
1938#define AssertFatalFailed() \
1939 do { \
1940 for (;;) \
1941 { \
1942 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1943 RTAssertReleasePanic(); \
1944 } \
1945 } while (0)
1946
1947/** @def AssertFatalMsgFailed
1948 * An assertion failed, print a message and hit a breakpoint (for ever).
1949 *
1950 * @param a printf argument list (in parenthesis).
1951 */
1952#define AssertFatalMsgFailed(a) \
1953 do { \
1954 for (;;) \
1955 { \
1956 RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1957 RTAssertMsg2Weak a; \
1958 RTAssertReleasePanic(); \
1959 } \
1960 } while (0)
1961
1962/** @} */
1963
1964
1965
1966/** @name Convenience Assertions Macros
1967 * @{
1968 */
1969
1970/** @def AssertRC
1971 * Asserts a iprt status code successful.
1972 *
1973 * On failure it will print info about the rc and hit a breakpoint.
1974 *
1975 * @param rc iprt status code.
1976 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1977 */
1978#define AssertRC(rc) AssertMsgRC(rc, ("%Rra\n", (rc)))
1979
1980/** @def AssertRCReturn
1981 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
1982 *
1983 * @param rc iprt status code.
1984 * @param rcRet What is to be presented to return.
1985 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1986 */
1987#define AssertRCReturn(rc, rcRet) AssertMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
1988
1989/** @def AssertRCReturn
1990 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
1991 * @a stmt and returns @a rcRet if it isn't.
1992 *
1993 * @param rc iprt status code.
1994 * @param stmt Statement to execute before returning in case of a failed
1995 * assertion.
1996 * @param rcRet What is to be presented to return.
1997 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1998 */
1999#define AssertRCReturnStmt(rc, stmt, rcRet) AssertMsgRCReturnStmt(rc, ("%Rra\n", (rc)), stmt, rcRet)
2000
2001/** @def AssertRCReturnVoid
2002 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
2003 *
2004 * @param rc iprt status code.
2005 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2006 */
2007#define AssertRCReturnVoid(rc) AssertMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
2008
2009/** @def AssertReturnVoidStmt
2010 * Asserts a iprt status code successful, bitch (RT_STRICT mode only), and
2011 * execute the given statement/return if it isn't.
2012 *
2013 * @param rc iprt status code.
2014 * @param stmt Statement to execute before returning on failure.
2015 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2016 */
2017#define AssertRCReturnVoidStmt(rc, stmt) AssertMsgRCReturnVoidStmt(rc, ("%Rra\n", (rc)), stmt)
2018
2019/** @def AssertRCBreak
2020 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
2021 *
2022 * @param rc iprt status code.
2023 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2024 */
2025#define AssertRCBreak(rc) AssertMsgRCBreak(rc, ("%Rra\n", (rc)))
2026
2027/** @def AssertRCBreakStmt
2028 * Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
2029 *
2030 * @param rc iprt status code.
2031 * @param stmt Statement to execute before break in case of a failed assertion.
2032 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2033 */
2034#define AssertRCBreakStmt(rc, stmt) AssertMsgRCBreakStmt(rc, ("%Rra\n", (rc)), stmt)
2035
2036/** @def AssertMsgRC
2037 * Asserts a iprt status code successful.
2038 *
2039 * It prints a custom message and hits a breakpoint on FAILURE.
2040 *
2041 * @param rc iprt status code.
2042 * @param msg printf argument list (in parenthesis).
2043 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2044 */
2045#define AssertMsgRC(rc, msg) \
2046 do { AssertMsg(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)
2047
2048/** @def AssertMsgRCReturn
2049 * Asserts a iprt status code successful and if it's not return the specified status code.
2050 *
2051 * If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
2052 *
2053 * @param rc iprt status code.
2054 * @param msg printf argument list (in parenthesis).
2055 * @param rcRet What is to be presented to return.
2056 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2057 */
2058#define AssertMsgRCReturn(rc, msg, rcRet) \
2059 do { AssertMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet); NOREF(rc); } while (0)
2060
2061/** @def AssertMsgRCReturnStmt
2062 * Asserts a iprt status code successful and if it's not execute @a stmt and
2063 * return the specified status code (@a rcRet).
2064 *
2065 * If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
2066 *
2067 * @param rc iprt status code.
2068 * @param msg printf argument list (in parenthesis).
2069 * @param stmt Statement to execute before returning in case of a failed
2070 * assertion.
2071 * @param rcRet What is to be presented to return.
2072 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2073 */
2074#define AssertMsgRCReturnStmt(rc, msg, stmt, rcRet) \
2075 do { AssertMsgReturnStmt(RT_SUCCESS_NP(rc), msg, stmt, rcRet); NOREF(rc); } while (0)
2076
2077/** @def AssertMsgRCReturnVoid
2078 * Asserts a iprt status code successful and if it's not return.
2079 *
2080 * If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
2081 *
2082 * @param rc iprt status code.
2083 * @param msg printf argument list (in parenthesis).
2084 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2085 */
2086#define AssertMsgRCReturnVoid(rc, msg) \
2087 do { AssertMsgReturnVoid(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)
2088
2089/** @def AssertMsgRCReturnVoidStmt
2090 * Asserts a iprt status code successful and execute statement/break if it's not.
2091 *
2092 * If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
2093 *
2094 * @param rc iprt status code.
2095 * @param msg printf argument list (in parenthesis).
2096 * @param stmt Statement to execute before break in case of a failed assertion.
2097 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2098 */
2099#define AssertMsgRCReturnVoidStmt(rc, msg, stmt) \
2100 do { AssertMsgReturnVoidStmt(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } while (0)
2101
2102/** @def AssertMsgRCBreak
2103 * Asserts a iprt status code successful and if it's not break.
2104 *
2105 * If RT_STRICT is defined the message will be printed and a breakpoint hit before it breaks
2106 *
2107 * @param rc iprt status code.
2108 * @param msg printf argument list (in parenthesis).
2109 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2110 */
2111#define AssertMsgRCBreak(rc, msg) \
2112 if (1) { AssertMsgBreak(RT_SUCCESS(rc), msg); NOREF(rc); } else do {} while (0)
2113
2114/** @def AssertMsgRCBreakStmt
2115 * Asserts a iprt status code successful and execute statement/break if it's not.
2116 *
2117 * If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
2118 *
2119 * @param rc iprt status code.
2120 * @param msg printf argument list (in parenthesis).
2121 * @param stmt Statement to execute before break in case of a failed assertion.
2122 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2123 */
2124#define AssertMsgRCBreakStmt(rc, msg, stmt) \
2125 if (1) { AssertMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } else do {} while (0)
2126
2127/** @def AssertRCSuccess
2128 * Asserts an iprt status code equals VINF_SUCCESS.
2129 *
2130 * On failure it will print info about the rc and hit a breakpoint.
2131 *
2132 * @param rc iprt status code.
2133 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2134 */
2135#define AssertRCSuccess(rc) do { AssertMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc))); NOREF(rc); } while (0)
2136
2137/** @def AssertRCSuccessReturn
2138 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
2139 *
2140 * @param rc iprt status code.
2141 * @param rcRet What is to be presented to return.
2142 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2143 */
2144#define AssertRCSuccessReturn(rc, rcRet) AssertMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
2145
2146/** @def AssertRCSuccessReturnVoid
2147 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
2148 *
2149 * @param rc iprt status code.
2150 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2151 */
2152#define AssertRCSuccessReturnVoid(rc) AssertMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2153
2154/** @def AssertRCSuccessBreak
2155 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
2156 *
2157 * @param rc iprt status code.
2158 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2159 */
2160#define AssertRCSuccessBreak(rc) AssertMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2161
2162/** @def AssertRCSuccessBreakStmt
2163 * Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
2164 *
2165 * @param rc iprt status code.
2166 * @param stmt Statement to execute before break in case of a failed assertion.
2167 * @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2168 */
2169#define AssertRCSuccessBreakStmt(rc, stmt) AssertMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
2170
2171
2172/** @def AssertLogRelRC
2173 * Asserts a iprt status code successful.
2174 *
2175 * @param rc iprt status code.
2176 * @remark rc is referenced multiple times.
2177 */
2178#define AssertLogRelRC(rc) AssertLogRelMsgRC(rc, ("%Rra\n", (rc)))
2179
2180/** @def AssertLogRelRCReturn
2181 * Asserts a iprt status code successful, returning \a rc if it isn't.
2182 *
2183 * @param rc iprt status code.
2184 * @param rcRet What is to be presented to return.
2185 * @remark rc is referenced multiple times.
2186 */
2187#define AssertLogRelRCReturn(rc, rcRet) AssertLogRelMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
2188
2189/** @def AssertLogRelRCReturnStmt
2190 * Asserts a iprt status code successful, executing \a stmt and returning \a rc
2191 * if it isn't.
2192 *
2193 * @param rc iprt status code.
2194 * @param stmt Statement to execute before returning in case of a failed
2195 * assertion.
2196 * @param rcRet What is to be presented to return.
2197 * @remark rc is referenced multiple times.
2198 */
2199#define AssertLogRelRCReturnStmt(rc, stmt, rcRet) AssertLogRelMsgRCReturnStmt(rc, ("%Rra\n", (rc)), stmt, rcRet)
2200
2201/** @def AssertLogRelRCReturnVoid
2202 * Asserts a iprt status code successful, returning (void) if it isn't.
2203 *
2204 * @param rc iprt status code.
2205 * @remark rc is referenced multiple times.
2206 */
2207#define AssertLogRelRCReturnVoid(rc) AssertLogRelMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
2208
2209/** @def AssertLogRelRCBreak
2210 * Asserts a iprt status code successful, breaking if it isn't.
2211 *
2212 * @param rc iprt status code.
2213 * @remark rc is referenced multiple times.
2214 */
2215#define AssertLogRelRCBreak(rc) AssertLogRelMsgRCBreak(rc, ("%Rra\n", (rc)))
2216
2217/** @def AssertLogRelRCBreakStmt
2218 * Asserts a iprt status code successful, execute \a statement and break if it isn't.
2219 *
2220 * @param rc iprt status code.
2221 * @param stmt Statement to execute before break in case of a failed assertion.
2222 * @remark rc is referenced multiple times.
2223 */
2224#define AssertLogRelRCBreakStmt(rc, stmt) AssertLogRelMsgRCBreakStmt(rc, ("%Rra\n", (rc)), stmt)
2225
2226/** @def AssertLogRelMsgRC
2227 * Asserts a iprt status code successful.
2228 *
2229 * @param rc iprt status code.
2230 * @param msg printf argument list (in parenthesis).
2231 * @remark rc is referenced multiple times.
2232 */
2233#define AssertLogRelMsgRC(rc, msg) AssertLogRelMsg(RT_SUCCESS_NP(rc), msg)
2234
2235/** @def AssertLogRelMsgRCReturn
2236 * Asserts a iprt status code successful.
2237 *
2238 * @param rc iprt status code.
2239 * @param msg printf argument list (in parenthesis).
2240 * @param rcRet What is to be presented to return.
2241 * @remark rc is referenced multiple times.
2242 */
2243#define AssertLogRelMsgRCReturn(rc, msg, rcRet) AssertLogRelMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet)
2244
2245/** @def AssertLogRelMsgRCReturnStmt
2246 * Asserts a iprt status code successful, execute \a stmt and return on
2247 * failure.
2248 *
2249 * @param rc iprt status code.
2250 * @param msg printf argument list (in parenthesis).
2251 * @param stmt Statement to execute before returning in case of a failed
2252 * assertion.
2253 * @param rcRet What is to be presented to return.
2254 * @remark rc is referenced multiple times.
2255 */
2256#define AssertLogRelMsgRCReturnStmt(rc, msg, stmt, rcRet) AssertLogRelMsgReturnStmt(RT_SUCCESS_NP(rc), msg, stmt, rcRet)
2257
2258/** @def AssertLogRelMsgRCReturnVoid
2259 * Asserts a iprt status code successful.
2260 *
2261 * @param rc iprt status code.
2262 * @param msg printf argument list (in parenthesis).
2263 * @remark rc is referenced multiple times.
2264 */
2265#define AssertLogRelMsgRCReturnVoid(rc, msg) AssertLogRelMsgReturnVoid(RT_SUCCESS_NP(rc), msg)
2266
2267/** @def AssertLogRelMsgRCBreak
2268 * Asserts a iprt status code successful.
2269 *
2270 * @param rc iprt status code.
2271 * @param msg printf argument list (in parenthesis).
2272 * @remark rc is referenced multiple times.
2273 */
2274#define AssertLogRelMsgRCBreak(rc, msg) AssertLogRelMsgBreak(RT_SUCCESS(rc), msg)
2275
2276/** @def AssertLogRelMsgRCBreakStmt
2277 * Asserts a iprt status code successful, execute \a stmt and break if it isn't.
2278 *
2279 * @param rc iprt status code.
2280 * @param msg printf argument list (in parenthesis).
2281 * @param stmt Statement to execute before break in case of a failed assertion.
2282 * @remark rc is referenced multiple times.
2283 */
2284#define AssertLogRelMsgRCBreakStmt(rc, msg, stmt) AssertLogRelMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt)
2285
2286/** @def AssertLogRelRCSuccess
2287 * Asserts that an iprt status code equals VINF_SUCCESS.
2288 *
2289 * @param rc iprt status code.
2290 * @remark rc is referenced multiple times.
2291 */
2292#define AssertLogRelRCSuccess(rc) AssertLogRelMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2293
2294/** @def AssertLogRelRCSuccessReturn
2295 * Asserts that an iprt status code equals VINF_SUCCESS.
2296 *
2297 * @param rc iprt status code.
2298 * @param rcRet What is to be presented to return.
2299 * @remark rc is referenced multiple times.
2300 */
2301#define AssertLogRelRCSuccessReturn(rc, rcRet) AssertLogRelMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
2302
2303/** @def AssertLogRelRCSuccessReturnVoid
2304 * Asserts that an iprt status code equals VINF_SUCCESS.
2305 *
2306 * @param rc iprt status code.
2307 * @remark rc is referenced multiple times.
2308 */
2309#define AssertLogRelRCSuccessReturnVoid(rc) AssertLogRelMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2310
2311/** @def AssertLogRelRCSuccessBreak
2312 * Asserts that an iprt status code equals VINF_SUCCESS.
2313 *
2314 * @param rc iprt status code.
2315 * @remark rc is referenced multiple times.
2316 */
2317#define AssertLogRelRCSuccessBreak(rc) AssertLogRelMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2318
2319/** @def AssertLogRelRCSuccessBreakStmt
2320 * Asserts that an iprt status code equals VINF_SUCCESS.
2321 *
2322 * @param rc iprt status code.
2323 * @param stmt Statement to execute before break in case of a failed assertion.
2324 * @remark rc is referenced multiple times.
2325 */
2326#define AssertLogRelRCSuccessBreakStmt(rc, stmt) AssertLogRelMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
2327
2328
2329/** @def AssertReleaseRC
2330 * Asserts a iprt status code successful.
2331 *
2332 * On failure information about the error will be printed and a breakpoint hit.
2333 *
2334 * @param rc iprt status code.
2335 * @remark rc is referenced multiple times.
2336 */
2337#define AssertReleaseRC(rc) AssertReleaseMsgRC(rc, ("%Rra\n", (rc)))
2338
2339/** @def AssertReleaseRCReturn
2340 * Asserts a iprt status code successful, returning if it isn't.
2341 *
2342 * On failure information about the error will be printed, a breakpoint hit
2343 * and finally returning from the function if the breakpoint is somehow ignored.
2344 *
2345 * @param rc iprt status code.
2346 * @param rcRet What is to be presented to return.
2347 * @remark rc is referenced multiple times.
2348 */
2349#define AssertReleaseRCReturn(rc, rcRet) AssertReleaseMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
2350
2351/** @def AssertReleaseRCReturnVoid
2352 * Asserts a iprt status code successful, returning if it isn't.
2353 *
2354 * On failure information about the error will be printed, a breakpoint hit
2355 * and finally returning from the function if the breakpoint is somehow ignored.
2356 *
2357 * @param rc iprt status code.
2358 * @remark rc is referenced multiple times.
2359 */
2360#define AssertReleaseRCReturnVoid(rc) AssertReleaseMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
2361
2362/** @def AssertReleaseRCBreak
2363 * Asserts a iprt status code successful, breaking if it isn't.
2364 *
2365 * On failure information about the error will be printed, a breakpoint hit
2366 * and finally breaking the current statement if the breakpoint is somehow ignored.
2367 *
2368 * @param rc iprt status code.
2369 * @remark rc is referenced multiple times.
2370 */
2371#define AssertReleaseRCBreak(rc) AssertReleaseMsgRCBreak(rc, ("%Rra\n", (rc)))
2372
2373/** @def AssertReleaseRCBreakStmt
2374 * Asserts a iprt status code successful, break if it isn't.
2375 *
2376 * On failure information about the error will be printed, a breakpoint hit
2377 * and finally the break statement will be issued if the breakpoint is somehow ignored.
2378 *
2379 * @param rc iprt status code.
2380 * @param stmt Statement to execute before break in case of a failed assertion.
2381 * @remark rc is referenced multiple times.
2382 */
2383#define AssertReleaseRCBreakStmt(rc, stmt) AssertReleaseMsgRCBreakStmt(rc, ("%Rra\n", (rc)), stmt)
2384
2385/** @def AssertReleaseMsgRC
2386 * Asserts a iprt status code successful.
2387 *
2388 * On failure a custom message is printed and a breakpoint is hit.
2389 *
2390 * @param rc iprt status code.
2391 * @param msg printf argument list (in parenthesis).
2392 * @remark rc is referenced multiple times.
2393 */
2394#define AssertReleaseMsgRC(rc, msg) AssertReleaseMsg(RT_SUCCESS_NP(rc), msg)
2395
2396/** @def AssertReleaseMsgRCReturn
2397 * Asserts a iprt status code successful.
2398 *
2399 * On failure a custom message is printed, a breakpoint is hit, and finally
2400 * returning from the function if the breakpoint is somehow ignored.
2401 *
2402 * @param rc iprt status code.
2403 * @param msg printf argument list (in parenthesis).
2404 * @param rcRet What is to be presented to return.
2405 * @remark rc is referenced multiple times.
2406 */
2407#define AssertReleaseMsgRCReturn(rc, msg, rcRet) AssertReleaseMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet)
2408
2409/** @def AssertReleaseMsgRCReturnVoid
2410 * Asserts a iprt status code successful.
2411 *
2412 * On failure a custom message is printed, a breakpoint is hit, and finally
2413 * returning from the function if the breakpoint is somehow ignored.
2414 *
2415 * @param rc iprt status code.
2416 * @param msg printf argument list (in parenthesis).
2417 * @remark rc is referenced multiple times.
2418 */
2419#define AssertReleaseMsgRCReturnVoid(rc, msg) AssertReleaseMsgReturnVoid(RT_SUCCESS_NP(rc), msg)
2420
2421/** @def AssertReleaseMsgRCBreak
2422 * Asserts a iprt status code successful.
2423 *
2424 * On failure a custom message is printed, a breakpoint is hit, and finally
2425 * breaking the current status if the breakpoint is somehow ignored.
2426 *
2427 * @param rc iprt status code.
2428 * @param msg printf argument list (in parenthesis).
2429 * @remark rc is referenced multiple times.
2430 */
2431#define AssertReleaseMsgRCBreak(rc, msg) AssertReleaseMsgBreak(RT_SUCCESS(rc), msg)
2432
2433/** @def AssertReleaseMsgRCBreakStmt
2434 * Asserts a iprt status code successful.
2435 *
2436 * On failure a custom message is printed, a breakpoint is hit, and finally
2437 * the break statement is issued if the breakpoint is somehow ignored.
2438 *
2439 * @param rc iprt status code.
2440 * @param msg printf argument list (in parenthesis).
2441 * @param stmt Statement to execute before break in case of a failed assertion.
2442 * @remark rc is referenced multiple times.
2443 */
2444#define AssertReleaseMsgRCBreakStmt(rc, msg, stmt) AssertReleaseMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt)
2445
2446/** @def AssertReleaseRCSuccess
2447 * Asserts that an iprt status code equals VINF_SUCCESS.
2448 *
2449 * On failure information about the error will be printed and a breakpoint hit.
2450 *
2451 * @param rc iprt status code.
2452 * @remark rc is referenced multiple times.
2453 */
2454#define AssertReleaseRCSuccess(rc) AssertReleaseMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2455
2456/** @def AssertReleaseRCSuccessReturn
2457 * Asserts that an iprt status code equals VINF_SUCCESS.
2458 *
2459 * On failure information about the error will be printed, a breakpoint hit
2460 * and finally returning from the function if the breakpoint is somehow ignored.
2461 *
2462 * @param rc iprt status code.
2463 * @param rcRet What is to be presented to return.
2464 * @remark rc is referenced multiple times.
2465 */
2466#define AssertReleaseRCSuccessReturn(rc, rcRet) AssertReleaseMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
2467
2468/** @def AssertReleaseRCSuccessReturnVoid
2469 * Asserts that an iprt status code equals VINF_SUCCESS.
2470 *
2471 * On failure information about the error will be printed, a breakpoint hit
2472 * and finally returning from the function if the breakpoint is somehow ignored.
2473 *
2474 * @param rc iprt status code.
2475 * @remark rc is referenced multiple times.
2476 */
2477#define AssertReleaseRCSuccessReturnVoid(rc) AssertReleaseMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2478
2479/** @def AssertReleaseRCSuccessBreak
2480 * Asserts that an iprt status code equals VINF_SUCCESS.
2481 *
2482 * On failure information about the error will be printed, a breakpoint hit
2483 * and finally breaking the current statement if the breakpoint is somehow ignored.
2484 *
2485 * @param rc iprt status code.
2486 * @remark rc is referenced multiple times.
2487 */
2488#define AssertReleaseRCSuccessBreak(rc) AssertReleaseMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2489
2490/** @def AssertReleaseRCSuccessBreakStmt
2491 * Asserts that an iprt status code equals VINF_SUCCESS.
2492 *
2493 * On failure information about the error will be printed, a breakpoint hit
2494 * and finally the break statement will be issued if the breakpoint is somehow ignored.
2495 *
2496 * @param rc iprt status code.
2497 * @param stmt Statement to execute before break in case of a failed assertion.
2498 * @remark rc is referenced multiple times.
2499 */
2500#define AssertReleaseRCSuccessBreakStmt(rc, stmt) AssertReleaseMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
2501
2502
2503/** @def AssertFatalRC
2504 * Asserts a iprt status code successful.
2505 *
2506 * On failure information about the error will be printed and a breakpoint hit.
2507 *
2508 * @param rc iprt status code.
2509 * @remark rc is referenced multiple times.
2510 */
2511#define AssertFatalRC(rc) AssertFatalMsgRC(rc, ("%Rra\n", (rc)))
2512
2513/** @def AssertReleaseMsgRC
2514 * Asserts a iprt status code successful.
2515 *
2516 * On failure a custom message is printed and a breakpoint is hit.
2517 *
2518 * @param rc iprt status code.
2519 * @param msg printf argument list (in parenthesis).
2520 * @remark rc is referenced multiple times.
2521 */
2522#define AssertFatalMsgRC(rc, msg) AssertFatalMsg(RT_SUCCESS_NP(rc), msg)
2523
2524/** @def AssertFatalRCSuccess
2525 * Asserts that an iprt status code equals VINF_SUCCESS.
2526 *
2527 * On failure information about the error will be printed and a breakpoint hit.
2528 *
2529 * @param rc iprt status code.
2530 * @remark rc is referenced multiple times.
2531 */
2532#define AssertFatalRCSuccess(rc) AssertFatalMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2533
2534
2535/** @def AssertPtr
2536 * Asserts that a pointer is valid.
2537 *
2538 * @param pv The pointer.
2539 */
2540#define AssertPtr(pv) AssertMsg(VALID_PTR(pv), ("%p\n", (pv)))
2541
2542/** @def AssertPtrReturn
2543 * Asserts that a pointer is valid.
2544 *
2545 * @param pv The pointer.
2546 * @param rcRet What is to be presented to return.
2547 */
2548#define AssertPtrReturn(pv, rcRet) AssertMsgReturn(VALID_PTR(pv), ("%p\n", (pv)), rcRet)
2549
2550/** @def AssertPtrReturnVoid
2551 * Asserts that a pointer is valid.
2552 *
2553 * @param pv The pointer.
2554 */
2555#define AssertPtrReturnVoid(pv) AssertMsgReturnVoid(VALID_PTR(pv), ("%p\n", (pv)))
2556
2557/** @def AssertPtrBreak
2558 * Asserts that a pointer is valid.
2559 *
2560 * @param pv The pointer.
2561 */
2562#define AssertPtrBreak(pv) AssertMsgBreak(VALID_PTR(pv), ("%p\n", (pv)))
2563
2564/** @def AssertPtrBreakStmt
2565 * Asserts that a pointer is valid.
2566 *
2567 * @param pv The pointer.
2568 * @param stmt Statement to execute before break in case of a failed assertion.
2569 */
2570#define AssertPtrBreakStmt(pv, stmt) AssertMsgBreakStmt(VALID_PTR(pv), ("%p\n", (pv)), stmt)
2571
2572/** @def AssertPtrNull
2573 * Asserts that a pointer is valid or NULL.
2574 *
2575 * @param pv The pointer.
2576 */
2577#define AssertPtrNull(pv) AssertMsg(VALID_PTR(pv) || (pv) == NULL, ("%p\n", (pv)))
2578
2579/** @def AssertPtrNullReturn
2580 * Asserts that a pointer is valid or NULL.
2581 *
2582 * @param pv The pointer.
2583 * @param rcRet What is to be presented to return.
2584 */
2585#define AssertPtrNullReturn(pv, rcRet) AssertMsgReturn(VALID_PTR(pv) || (pv) == NULL, ("%p\n", (pv)), rcRet)
2586
2587/** @def AssertPtrNullReturnVoid
2588 * Asserts that a pointer is valid or NULL.
2589 *
2590 * @param pv The pointer.
2591 */
2592#define AssertPtrNullReturnVoid(pv) AssertMsgReturnVoid(VALID_PTR(pv) || (pv) == NULL, ("%p\n", (pv)))
2593
2594/** @def AssertPtrNullBreak
2595 * Asserts that a pointer is valid or NULL.
2596 *
2597 * @param pv The pointer.
2598 */
2599#define AssertPtrNullBreak(pv) AssertMsgBreak(VALID_PTR(pv) || (pv) == NULL, ("%p\n", (pv)))
2600
2601/** @def AssertPtrNullBreakStmt
2602 * Asserts that a pointer is valid or NULL.
2603 *
2604 * @param pv The pointer.
2605 * @param stmt Statement to execute before break in case of a failed assertion.
2606 */
2607#define AssertPtrNullBreakStmt(pv, stmt) AssertMsgBreakStmt(VALID_PTR(pv) || (pv) == NULL, ("%p\n", (pv)), stmt)
2608
2609/** @def AssertGCPhys32
2610 * Asserts that the high dword of a physical address is zero
2611 *
2612 * @param GCPhys The address (RTGCPHYS).
2613 */
2614#define AssertGCPhys32(GCPhys) AssertMsg(VALID_PHYS32(GCPhys), ("%RGp\n", (RTGCPHYS)(GCPhys)))
2615
2616/** @def AssertGCPtr32
2617 * Asserts that the high dword of a physical address is zero
2618 *
2619 * @param GCPtr The address (RTGCPTR).
2620 */
2621#if GC_ARCH_BITS == 32
2622# define AssertGCPtr32(GCPtr) do { } while (0)
2623#else
2624# define AssertGCPtr32(GCPtr) AssertMsg(!((GCPtr) & UINT64_C(0xffffffff00000000)), ("%RGv\n", GCPtr))
2625#endif
2626
2627/** @def AssertForEach
2628 * Equivalent to Assert for each value of the variable from the starting
2629 * value to the finishing one.
2630 *
2631 * @param var Name of the counter variable.
2632 * @param vartype Type of the counter variable.
2633 * @param first Lowest inclusive value of the counter variable.
2634 * This must be free from side effects.
2635 * @param end Highest exclusive value of the counter variable.
2636 * This must be free from side effects.
2637 * @param expr Expression which should be true for each value of @a var.
2638 */
2639#define AssertForEach(var, vartype, first, end, expr) \
2640 do { \
2641 vartype var; \
2642 Assert((first) == (first) && (end) == (end)); /* partial check for side effects */ \
2643 for (var = (first); var < (end); var++) \
2644 AssertMsg(expr, ("%s = %#RX64 (%RI64)", #var, (uint64_t)var, (int64_t)var)); \
2645 } while (0)
2646
2647/** @} */
2648
2649/** @} */
2650
2651#endif
2652
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette