VirtualBox

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

Last change on this file since 45948 was 43363, checked in by vboxsync, 12 years ago

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