assert.h@ 47356

Last change on this file since 47356 was 46689, checked in by vboxsync, 12 years ago
iprt/assert.h: VisualAge for C++ doesn't like using RT_OFFSETOF or typdefs either, just like GCC, so make this a little easier to select.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 84.0 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
76	RT_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	*/
86	RTDECL(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	*/
93	RTDECL(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	*/
101	RTDECL(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	*/
109	RTDECL(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	*/
117	RTDECL(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	*/
124	RTDECL(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	*/
133	RTDECL(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	*/
141	RTDECL(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	*/
150	RTDECL(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	*/
157	RTDECL(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	*/
163	RTR0DECL(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)
180	RTDECL(bool) RTAssertShouldPanic(void);
181	#elif defined(RTASSERT_HAVE_SHOULD_PANIC_PRIVATE)
182	bool RTAssertShouldPanic(void);
183	#else
184	DECLEXPORT(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	*/
193	RTDECL(bool) RTAssertSetQuiet(bool fQuiet);
194
195	/**
196	* Are assertions quiet or noisy?
197	*
198	* @returns True if they are quiet, false if noisy.
199	*/
200	RTDECL(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	*/
208	RTDECL(bool) RTAssertSetMayPanic(bool fPanic);
209
210	/**
211	* Can assertion panic.
212	*
213	* @returns True if they can, false if not.
214	*/
215	RTDECL(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. */
223	extern RTDATADECL(char) g_szRTAssertMsg1[1024];
224	/** The last assert message, 2nd part. */
225	extern RTDATADECL(char) g_szRTAssertMsg2[4096];
226	/** The last assert message, expression. */
227	extern RTDATADECL(const char * volatile) g_pszRTAssertExpr;
228	/** The last assert message, file name. */
229	extern RTDATADECL(const char * volatile) g_pszRTAssertFile;
230	/** The last assert message, line number. */
231	extern RTDATADECL(uint32_t volatile) g_u32RTAssertLine;
232	/** The last assert message, function name. */
233	extern RTDATADECL(const char * volatile) g_pszRTAssertFunction;
234	/** @} */
235
236	RT_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	*/
260	typedef 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__
268	RT_C_DECLS_BEGIN
269	#endif
270	extern int RTASSERTVAR[1];
271	#ifdef __GNUC__
272	RT_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 AssertLogRelMsgFailedReturn
1475	* An assertion failed, return \a rc.
1476	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1477	*
1478	* @param a printf argument list (in parenthesis).
1479	* @param rc What is to be presented to return.
1480	*/
1481	#define AssertLogRelMsgFailedReturn(a, rc) \
1482	do { \
1483	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1484	RTAssertLogRelMsg2(a); \
1485	RTAssertPanic(); \
1486	return (rc); \
1487	} while (0)
1488
1489	/** @def AssertLogRelMsgFailedReturn
1490	* An assertion failed, execute @a stmt and return @a rc.
1491	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1492	*
1493	* @param a printf argument list (in parenthesis).
1494	* @param stmt Statement to execute before returning in case of a failed
1495	* assertion.
1496	* @param rc What is to be presented to return.
1497	*/
1498	#define AssertLogRelMsgFailedReturnStmt(a, stmt, rc) \
1499	do { \
1500	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1501	RTAssertLogRelMsg2(a); \
1502	RTAssertPanic(); \
1503	stmt; \
1504	return (rc); \
1505	} while (0)
1506
1507	/** @def AssertLogRelMsgFailedReturnVoid
1508	* An assertion failed, return void.
1509	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1510	*
1511	* @param a printf argument list (in parenthesis).
1512	*/
1513	#define AssertLogRelMsgFailedReturnVoid(a) \
1514	do { \
1515	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1516	RTAssertLogRelMsg2(a); \
1517	RTAssertPanic(); \
1518	return; \
1519	} while (0)
1520
1521	/** @def AssertLogRelMsgFailedReturnVoid
1522	* An assertion failed, execute @a stmt and return void.
1523	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1524	*
1525	* @param a printf argument list (in parenthesis).
1526	* @param stmt Statement to execute before returning in case of a failed
1527	* assertion.
1528	*/
1529	#define AssertLogRelMsgFailedReturnVoidStmt(a, stmt) \
1530	do { \
1531	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1532	RTAssertLogRelMsg2(a); \
1533	RTAssertPanic(); \
1534	stmt; \
1535	return; \
1536	} while (0)
1537
1538	/** @def AssertLogRelMsgFailedBreak
1539	* An assertion failed, break.
1540	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1541	*
1542	* @param a printf argument list (in parenthesis).
1543	*/
1544	#define AssertLogRelMsgFailedBreak(a) \
1545	if (1)\
1546	{ \
1547	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1548	RTAssertLogRelMsg2(a); \
1549	RTAssertPanic(); \
1550	break; \
1551	} else do {} while (0)
1552
1553	/** @def AssertLogRelMsgFailedBreakStmt
1554	* An assertion failed, execute \a stmt and break.
1555	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1556	*
1557	* @param a printf argument list (in parenthesis).
1558	* @param stmt Statement to execute before break.
1559	*/
1560	#define AssertLogRelMsgFailedBreakStmt(a, stmt) \
1561	if (1) \
1562	{ \
1563	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1564	RTAssertLogRelMsg2(a); \
1565	RTAssertPanic(); \
1566	stmt; \
1567	break; \
1568	} else do {} while (0)
1569
1570	/** @} */
1571
1572
1573
1574	/** @name Release Assertions
1575	*
1576	* These assertions are always enabled.
1577	* @{
1578	*/
1579
1580	/** @def RTAssertReleasePanic()
1581	* Invokes RTAssertShouldPanic and RTAssertDoPanic.
1582	*
1583	* It might seem odd that RTAssertShouldPanic is necessary when its result isn't
1584	* checked, but it's done since RTAssertShouldPanic is overrideable and might be
1585	* used to bail out before taking down the system (the VMMR0 case).
1586	*/
1587	#define RTAssertReleasePanic() do { RTAssertShouldPanic(); RTAssertDoPanic(); } while (0)
1588
1589
1590	/** @def AssertRelease
1591	* Assert that an expression is true. If it's not hit a breakpoint.
1592	*
1593	* @param expr Expression which should be true.
1594	*/
1595	#define AssertRelease(expr) \
1596	do { \
1597	if (RT_UNLIKELY(!(expr))) \
1598	{ \
1599	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1600	RTAssertReleasePanic(); \
1601	} \
1602	} while (0)
1603
1604	/** @def AssertReleaseReturn
1605	* Assert that an expression is true, hit a breakpoint and return if it isn't.
1606	*
1607	* @param expr Expression which should be true.
1608	* @param rc What is to be presented to return.
1609	*/
1610	#define AssertReleaseReturn(expr, rc) \
1611	do { \
1612	if (RT_UNLIKELY(!(expr))) \
1613	{ \
1614	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1615	RTAssertReleasePanic(); \
1616	return (rc); \
1617	} \
1618	} while (0)
1619
1620	/** @def AssertReleaseReturnVoid
1621	* Assert that an expression is true, hit a breakpoint and return if it isn't.
1622	*
1623	* @param expr Expression which should be true.
1624	*/
1625	#define AssertReleaseReturnVoid(expr) \
1626	do { \
1627	if (RT_UNLIKELY(!(expr))) \
1628	{ \
1629	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1630	RTAssertReleasePanic(); \
1631	return; \
1632	} \
1633	} while (0)
1634
1635
1636	/** @def AssertReleaseBreak
1637	* Assert that an expression is true, hit a breakpoint and break if it isn't.
1638	*
1639	* @param expr Expression which should be true.
1640	*/
1641	#define AssertReleaseBreak(expr) \
1642	if { \
1643	if (RT_UNLIKELY(!(expr))) \
1644	{ \
1645	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1646	RTAssertReleasePanic(); \
1647	break; \
1648	} \
1649	} else do {} while (0)
1650
1651	/** @def AssertReleaseBreakStmt
1652	* Assert that an expression is true, hit a breakpoint and break if it isn't.
1653	*
1654	* @param expr Expression which should be true.
1655	* @param stmt Statement to execute before break in case of a failed assertion.
1656	*/
1657	#define AssertReleaseBreakStmt(expr, stmt) \
1658	if (RT_UNLIKELY(!(expr))) \
1659	{ \
1660	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1661	RTAssertReleasePanic(); \
1662	stmt; \
1663	break; \
1664	} else do {} while (0)
1665
1666
1667	/** @def AssertReleaseMsg
1668	* Assert that an expression is true, print the message and hit a breakpoint if it isn't.
1669	*
1670	* @param expr Expression which should be true.
1671	* @param a printf argument list (in parenthesis).
1672	*/
1673	#define AssertReleaseMsg(expr, a) \
1674	do { \
1675	if (RT_UNLIKELY(!(expr))) \
1676	{ \
1677	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1678	RTAssertMsg2Weak a; \
1679	RTAssertReleasePanic(); \
1680	} \
1681	} while (0)
1682
1683	/** @def AssertReleaseMsgReturn
1684	* Assert that an expression is true, print the message and hit a breakpoint and return if it isn't.
1685	*
1686	* @param expr Expression which should be true.
1687	* @param a printf argument list (in parenthesis).
1688	* @param rc What is to be presented to return.
1689	*/
1690	#define AssertReleaseMsgReturn(expr, a, rc) \
1691	do { \
1692	if (RT_UNLIKELY(!(expr))) \
1693	{ \
1694	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1695	RTAssertMsg2Weak a; \
1696	RTAssertReleasePanic(); \
1697	return (rc); \
1698	} \
1699	} while (0)
1700
1701	/** @def AssertReleaseMsgReturnVoid
1702	* Assert that an expression is true, print the message and hit a breakpoint and return if it isn't.
1703	*
1704	* @param expr Expression which should be true.
1705	* @param a printf argument list (in parenthesis).
1706	*/
1707	#define AssertReleaseMsgReturnVoid(expr, a) \
1708	do { \
1709	if (RT_UNLIKELY(!(expr))) \
1710	{ \
1711	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1712	RTAssertMsg2Weak a; \
1713	RTAssertReleasePanic(); \
1714	return; \
1715	} \
1716	} while (0)
1717
1718
1719	/** @def AssertReleaseMsgBreak
1720	* Assert that an expression is true, print the message and hit a breakpoint and break if it isn't.
1721	*
1722	* @param expr Expression which should be true.
1723	* @param a printf argument list (in parenthesis).
1724	*/
1725	#define AssertReleaseMsgBreak(expr, a) \
1726	if (RT_UNLIKELY(!(expr))) \
1727	{ \
1728	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1729	RTAssertMsg2Weak a; \
1730	RTAssertReleasePanic(); \
1731	break; \
1732	} else do {} while (0)
1733
1734	/** @def AssertReleaseMsgBreakStmt
1735	* Assert that an expression is true, print the message and hit a breakpoint and break if it isn't.
1736	*
1737	* @param expr Expression which should be true.
1738	* @param a printf argument list (in parenthesis).
1739	* @param stmt Statement to execute before break in case of a failed assertion.
1740	*/
1741	#define AssertReleaseMsgBreakStmt(expr, a, stmt) \
1742	if (RT_UNLIKELY(!(expr))) { \
1743	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1744	RTAssertMsg2Weak a; \
1745	RTAssertReleasePanic(); \
1746	stmt; \
1747	break; \
1748	} else do {} while (0)
1749
1750
1751	/** @def AssertReleaseFailed
1752	* An assertion failed, hit a breakpoint.
1753	*/
1754	#define AssertReleaseFailed() \
1755	do { \
1756	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1757	RTAssertReleasePanic(); \
1758	} while (0)
1759
1760	/** @def AssertReleaseFailedReturn
1761	* An assertion failed, hit a breakpoint and return.
1762	*
1763	* @param rc What is to be presented to return.
1764	*/
1765	#define AssertReleaseFailedReturn(rc) \
1766	do { \
1767	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1768	RTAssertReleasePanic(); \
1769	return (rc); \
1770	} while (0)
1771
1772	/** @def AssertReleaseFailedReturnVoid
1773	* An assertion failed, hit a breakpoint and return.
1774	*/
1775	#define AssertReleaseFailedReturnVoid() \
1776	do { \
1777	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1778	RTAssertReleasePanic(); \
1779	return; \
1780	} while (0)
1781
1782
1783	/** @def AssertReleaseFailedBreak
1784	* An assertion failed, hit a breakpoint and break.
1785	*/
1786	#define AssertReleaseFailedBreak() \
1787	if (1) { \
1788	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1789	RTAssertReleasePanic(); \
1790	break; \
1791	} else do {} while (0)
1792
1793	/** @def AssertReleaseFailedBreakStmt
1794	* An assertion failed, hit a breakpoint and break.
1795	*
1796	* @param stmt Statement to execute before break.
1797	*/
1798	#define AssertReleaseFailedBreakStmt(stmt) \
1799	if (1) { \
1800	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1801	RTAssertReleasePanic(); \
1802	stmt; \
1803	break; \
1804	} else do {} while (0)
1805
1806
1807	/** @def AssertReleaseMsgFailed
1808	* An assertion failed, print a message and hit a breakpoint.
1809	*
1810	* @param a printf argument list (in parenthesis).
1811	*/
1812	#define AssertReleaseMsgFailed(a) \
1813	do { \
1814	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1815	RTAssertMsg2Weak a; \
1816	RTAssertReleasePanic(); \
1817	} while (0)
1818
1819	/** @def AssertReleaseMsgFailedReturn
1820	* An assertion failed, print a message, hit a breakpoint and return.
1821	*
1822	* @param a printf argument list (in parenthesis).
1823	* @param rc What is to be presented to return.
1824	*/
1825	#define AssertReleaseMsgFailedReturn(a, rc) \
1826	do { \
1827	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1828	RTAssertMsg2Weak a; \
1829	RTAssertReleasePanic(); \
1830	return (rc); \
1831	} while (0)
1832
1833	/** @def AssertReleaseMsgFailedReturnVoid
1834	* An assertion failed, print a message, hit a breakpoint and return.
1835	*
1836	* @param a printf argument list (in parenthesis).
1837	*/
1838	#define AssertReleaseMsgFailedReturnVoid(a) \
1839	do { \
1840	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1841	RTAssertMsg2Weak a; \
1842	RTAssertReleasePanic(); \
1843	return; \
1844	} while (0)
1845
1846
1847	/** @def AssertReleaseMsgFailedBreak
1848	* An assertion failed, print a message, hit a breakpoint and break.
1849	*
1850	* @param a printf argument list (in parenthesis).
1851	*/
1852	#define AssertReleaseMsgFailedBreak(a) \
1853	if (1) { \
1854	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1855	RTAssertMsg2Weak a; \
1856	RTAssertReleasePanic(); \
1857	break; \
1858	} else do {} while (0)
1859
1860	/** @def AssertReleaseMsgFailedBreakStmt
1861	* An assertion failed, print a message, hit a breakpoint and break.
1862	*
1863	* @param a printf argument list (in parenthesis).
1864	* @param stmt Statement to execute before break.
1865	*/
1866	#define AssertReleaseMsgFailedBreakStmt(a, stmt) \
1867	if (1) { \
1868	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1869	RTAssertMsg2Weak a; \
1870	RTAssertReleasePanic(); \
1871	stmt; \
1872	break; \
1873	} else do {} while (0)
1874
1875	/** @} */
1876
1877
1878
1879	/** @name Fatal Assertions
1880	* These are similar to release assertions except that you cannot ignore them in
1881	* any way, they will loop for ever if RTAssertDoPanic returns.
1882	*
1883	* @{
1884	*/
1885
1886	/** @def AssertFatal
1887	* Assert that an expression is true. If it's not hit a breakpoint (for ever).
1888	*
1889	* @param expr Expression which should be true.
1890	*/
1891	#define AssertFatal(expr) \
1892	do { \
1893	if (RT_UNLIKELY(!(expr))) \
1894	for (;;) \
1895	{ \
1896	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1897	RTAssertReleasePanic(); \
1898	} \
1899	} while (0)
1900
1901	/** @def AssertFatalMsg
1902	* Assert that an expression is true, print the message and hit a breakpoint (for ever) if it isn't.
1903	*
1904	* @param expr Expression which should be true.
1905	* @param a printf argument list (in parenthesis).
1906	*/
1907	#define AssertFatalMsg(expr, a) \
1908	do { \
1909	if (RT_UNLIKELY(!(expr))) \
1910	for (;;) \
1911	{ \
1912	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1913	RTAssertMsg2Weak a; \
1914	RTAssertReleasePanic(); \
1915	} \
1916	} while (0)
1917
1918	/** @def AssertFatalFailed
1919	* An assertion failed, hit a breakpoint (for ever).
1920	*/
1921	#define AssertFatalFailed() \
1922	do { \
1923	for (;;) \
1924	{ \
1925	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1926	RTAssertReleasePanic(); \
1927	} \
1928	} while (0)
1929
1930	/** @def AssertFatalMsgFailed
1931	* An assertion failed, print a message and hit a breakpoint (for ever).
1932	*
1933	* @param a printf argument list (in parenthesis).
1934	*/
1935	#define AssertFatalMsgFailed(a) \
1936	do { \
1937	for (;;) \
1938	{ \
1939	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1940	RTAssertMsg2Weak a; \
1941	RTAssertReleasePanic(); \
1942	} \
1943	} while (0)
1944
1945	/** @} */
1946
1947
1948
1949	/** @name Convenience Assertions Macros
1950	* @{
1951	*/
1952
1953	/** @def AssertRC
1954	* Asserts a iprt status code successful.
1955	*
1956	* On failure it will print info about the rc and hit a breakpoint.
1957	*
1958	* @param rc iprt status code.
1959	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1960	*/
1961	#define AssertRC(rc) AssertMsgRC(rc, ("%Rra\n", (rc)))
1962
1963	/** @def AssertRCReturn
1964	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
1965	*
1966	* @param rc iprt status code.
1967	* @param rcRet What is to be presented to return.
1968	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1969	*/
1970	#define AssertRCReturn(rc, rcRet) AssertMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
1971
1972	/** @def AssertRCReturn
1973	* Asserts a iprt status code successful, bitch (RT_STRICT mode only), execute
1974	* @a stmt and returns @a rcRet if it isn't.
1975	*
1976	* @param rc iprt status code.
1977	* @param stmt Statement to execute before returning in case of a failed
1978	* assertion.
1979	* @param rcRet What is to be presented to return.
1980	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1981	*/
1982	#define AssertRCReturnStmt(rc, stmt, rcRet) AssertMsgRCReturnStmt(rc, ("%Rra\n", (rc)), stmt, rcRet)
1983
1984	/** @def AssertRCReturnVoid
1985	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
1986	*
1987	* @param rc iprt status code.
1988	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1989	*/
1990	#define AssertRCReturnVoid(rc) AssertMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
1991
1992	/** @def AssertReturnVoidStmt
1993	* Asserts a iprt status code successful, bitch (RT_STRICT mode only), and
1994	* execute the given statement/return if it isn't.
1995	*
1996	* @param rc iprt status code.
1997	* @param stmt Statement to execute before returning on failure.
1998	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1999	*/
2000	#define AssertRCReturnVoidStmt(rc, stmt) AssertMsgRCReturnVoidStmt(rc, ("%Rra\n", (rc)), stmt)
2001
2002	/** @def AssertRCBreak
2003	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
2004	*
2005	* @param rc iprt status code.
2006	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2007	*/
2008	#define AssertRCBreak(rc) AssertMsgRCBreak(rc, ("%Rra\n", (rc)))
2009
2010	/** @def AssertRCBreakStmt
2011	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
2012	*
2013	* @param rc iprt status code.
2014	* @param stmt Statement to execute before break in case of a failed assertion.
2015	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2016	*/
2017	#define AssertRCBreakStmt(rc, stmt) AssertMsgRCBreakStmt(rc, ("%Rra\n", (rc)), stmt)
2018
2019	/** @def AssertMsgRC
2020	* Asserts a iprt status code successful.
2021	*
2022	* It prints a custom message and hits a breakpoint on FAILURE.
2023	*
2024	* @param rc iprt status code.
2025	* @param msg printf argument list (in parenthesis).
2026	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2027	*/
2028	#define AssertMsgRC(rc, msg) \
2029	do { AssertMsg(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)
2030
2031	/** @def AssertMsgRCReturn
2032	* Asserts a iprt status code successful and if it's not return the specified status code.
2033	*
2034	* If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
2035	*
2036	* @param rc iprt status code.
2037	* @param msg printf argument list (in parenthesis).
2038	* @param rcRet What is to be presented to return.
2039	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2040	*/
2041	#define AssertMsgRCReturn(rc, msg, rcRet) \
2042	do { AssertMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet); NOREF(rc); } while (0)
2043
2044	/** @def AssertMsgRCReturnStmt
2045	* Asserts a iprt status code successful and if it's not execute @a stmt and
2046	* return the specified status code (@a rcRet).
2047	*
2048	* If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
2049	*
2050	* @param rc iprt status code.
2051	* @param msg printf argument list (in parenthesis).
2052	* @param stmt Statement to execute before returning in case of a failed
2053	* assertion.
2054	* @param rcRet What is to be presented to return.
2055	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2056	*/
2057	#define AssertMsgRCReturnStmt(rc, msg, stmt, rcRet) \
2058	do { AssertMsgReturnStmt(RT_SUCCESS_NP(rc), msg, stmt, rcRet); NOREF(rc); } while (0)
2059
2060	/** @def AssertMsgRCReturnVoid
2061	* Asserts a iprt status code successful and if it's not return.
2062	*
2063	* If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
2064	*
2065	* @param rc iprt status code.
2066	* @param msg printf argument list (in parenthesis).
2067	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2068	*/
2069	#define AssertMsgRCReturnVoid(rc, msg) \
2070	do { AssertMsgReturnVoid(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)
2071
2072	/** @def AssertMsgRCReturnVoidStmt
2073	* Asserts a iprt status code successful and execute statement/break if it's not.
2074	*
2075	* If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
2076	*
2077	* @param rc iprt status code.
2078	* @param msg printf argument list (in parenthesis).
2079	* @param stmt Statement to execute before break in case of a failed assertion.
2080	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2081	*/
2082	#define AssertMsgRCReturnVoidStmt(rc, msg, stmt) \
2083	do { AssertMsgReturnVoidStmt(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } while (0)
2084
2085	/** @def AssertMsgRCBreak
2086	* Asserts a iprt status code successful and if it's not break.
2087	*
2088	* If RT_STRICT is defined the message will be printed and a breakpoint hit before it breaks
2089	*
2090	* @param rc iprt status code.
2091	* @param msg printf argument list (in parenthesis).
2092	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2093	*/
2094	#define AssertMsgRCBreak(rc, msg) \
2095	if (1) { AssertMsgBreak(RT_SUCCESS(rc), msg); NOREF(rc); } else do {} while (0)
2096
2097	/** @def AssertMsgRCBreakStmt
2098	* Asserts a iprt status code successful and execute statement/break if it's not.
2099	*
2100	* If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
2101	*
2102	* @param rc iprt status code.
2103	* @param msg printf argument list (in parenthesis).
2104	* @param stmt Statement to execute before break in case of a failed assertion.
2105	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2106	*/
2107	#define AssertMsgRCBreakStmt(rc, msg, stmt) \
2108	if (1) { AssertMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } else do {} while (0)
2109
2110	/** @def AssertRCSuccess
2111	* Asserts an iprt status code equals VINF_SUCCESS.
2112	*
2113	* On failure it will print info about the rc and hit a breakpoint.
2114	*
2115	* @param rc iprt status code.
2116	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2117	*/
2118	#define AssertRCSuccess(rc) do { AssertMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc))); NOREF(rc); } while (0)
2119
2120	/** @def AssertRCSuccessReturn
2121	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
2122	*
2123	* @param rc iprt status code.
2124	* @param rcRet What is to be presented to return.
2125	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2126	*/
2127	#define AssertRCSuccessReturn(rc, rcRet) AssertMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
2128
2129	/** @def AssertRCSuccessReturnVoid
2130	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
2131	*
2132	* @param rc iprt status code.
2133	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2134	*/
2135	#define AssertRCSuccessReturnVoid(rc) AssertMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2136
2137	/** @def AssertRCSuccessBreak
2138	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
2139	*
2140	* @param rc iprt status code.
2141	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2142	*/
2143	#define AssertRCSuccessBreak(rc) AssertMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2144
2145	/** @def AssertRCSuccessBreakStmt
2146	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
2147	*
2148	* @param rc iprt status code.
2149	* @param stmt Statement to execute before break in case of a failed assertion.
2150	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2151	*/
2152	#define AssertRCSuccessBreakStmt(rc, stmt) AssertMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
2153
2154
2155	/** @def AssertLogRelRC
2156	* Asserts a iprt status code successful.
2157	*
2158	* @param rc iprt status code.
2159	* @remark rc is referenced multiple times.
2160	*/
2161	#define AssertLogRelRC(rc) AssertLogRelMsgRC(rc, ("%Rra\n", (rc)))
2162
2163	/** @def AssertLogRelRCReturn
2164	* Asserts a iprt status code successful, returning \a rc if it isn't.
2165	*
2166	* @param rc iprt status code.
2167	* @param rcRet What is to be presented to return.
2168	* @remark rc is referenced multiple times.
2169	*/
2170	#define AssertLogRelRCReturn(rc, rcRet) AssertLogRelMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
2171
2172	/** @def AssertLogRelRCReturnStmt
2173	* Asserts a iprt status code successful, executing \a stmt and returning \a rc
2174	* if it isn't.
2175	*
2176	* @param rc iprt status code.
2177	* @param stmt Statement to execute before returning in case of a failed
2178	* assertion.
2179	* @param rcRet What is to be presented to return.
2180	* @remark rc is referenced multiple times.
2181	*/
2182	#define AssertLogRelRCReturnStmt(rc, stmt, rcRet) AssertLogRelMsgRCReturnStmt(rc, ("%Rra\n", (rc)), stmt, rcRet)
2183
2184	/** @def AssertLogRelRCReturnVoid
2185	* Asserts a iprt status code successful, returning (void) if it isn't.
2186	*
2187	* @param rc iprt status code.
2188	* @remark rc is referenced multiple times.
2189	*/
2190	#define AssertLogRelRCReturnVoid(rc) AssertLogRelMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
2191
2192	/** @def AssertLogRelRCBreak
2193	* Asserts a iprt status code successful, breaking if it isn't.
2194	*
2195	* @param rc iprt status code.
2196	* @remark rc is referenced multiple times.
2197	*/
2198	#define AssertLogRelRCBreak(rc) AssertLogRelMsgRCBreak(rc, ("%Rra\n", (rc)))
2199
2200	/** @def AssertLogRelRCBreakStmt
2201	* Asserts a iprt status code successful, execute \a statement and break if it isn't.
2202	*
2203	* @param rc iprt status code.
2204	* @param stmt Statement to execute before break in case of a failed assertion.
2205	* @remark rc is referenced multiple times.
2206	*/
2207	#define AssertLogRelRCBreakStmt(rc, stmt) AssertLogRelMsgRCBreakStmt(rc, ("%Rra\n", (rc)), stmt)
2208
2209	/** @def AssertLogRelMsgRC
2210	* Asserts a iprt status code successful.
2211	*
2212	* @param rc iprt status code.
2213	* @param msg printf argument list (in parenthesis).
2214	* @remark rc is referenced multiple times.
2215	*/
2216	#define AssertLogRelMsgRC(rc, msg) AssertLogRelMsg(RT_SUCCESS_NP(rc), msg)
2217
2218	/** @def AssertLogRelMsgRCReturn
2219	* Asserts a iprt status code successful.
2220	*
2221	* @param rc iprt status code.
2222	* @param msg printf argument list (in parenthesis).
2223	* @param rcRet What is to be presented to return.
2224	* @remark rc is referenced multiple times.
2225	*/
2226	#define AssertLogRelMsgRCReturn(rc, msg, rcRet) AssertLogRelMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet)
2227
2228	/** @def AssertLogRelMsgRCReturnStmt
2229	* Asserts a iprt status code successful, execute \a stmt and return on
2230	* failure.
2231	*
2232	* @param rc iprt status code.
2233	* @param msg printf argument list (in parenthesis).
2234	* @param stmt Statement to execute before returning in case of a failed
2235	* assertion.
2236	* @param rcRet What is to be presented to return.
2237	* @remark rc is referenced multiple times.
2238	*/
2239	#define AssertLogRelMsgRCReturnStmt(rc, msg, stmt, rcRet) AssertLogRelMsgReturnStmt(RT_SUCCESS_NP(rc), msg, stmt, rcRet)
2240
2241	/** @def AssertLogRelMsgRCReturnVoid
2242	* Asserts a iprt status code successful.
2243	*
2244	* @param rc iprt status code.
2245	* @param msg printf argument list (in parenthesis).
2246	* @remark rc is referenced multiple times.
2247	*/
2248	#define AssertLogRelMsgRCReturnVoid(rc, msg) AssertLogRelMsgReturnVoid(RT_SUCCESS_NP(rc), msg)
2249
2250	/** @def AssertLogRelMsgRCBreak
2251	* Asserts a iprt status code successful.
2252	*
2253	* @param rc iprt status code.
2254	* @param msg printf argument list (in parenthesis).
2255	* @remark rc is referenced multiple times.
2256	*/
2257	#define AssertLogRelMsgRCBreak(rc, msg) AssertLogRelMsgBreak(RT_SUCCESS(rc), msg)
2258
2259	/** @def AssertLogRelMsgRCBreakStmt
2260	* Asserts a iprt status code successful, execute \a stmt and break if it isn't.
2261	*
2262	* @param rc iprt status code.
2263	* @param msg printf argument list (in parenthesis).
2264	* @param stmt Statement to execute before break in case of a failed assertion.
2265	* @remark rc is referenced multiple times.
2266	*/
2267	#define AssertLogRelMsgRCBreakStmt(rc, msg, stmt) AssertLogRelMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt)
2268
2269	/** @def AssertLogRelRCSuccess
2270	* Asserts that an iprt status code equals VINF_SUCCESS.
2271	*
2272	* @param rc iprt status code.
2273	* @remark rc is referenced multiple times.
2274	*/
2275	#define AssertLogRelRCSuccess(rc) AssertLogRelMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2276
2277	/** @def AssertLogRelRCSuccessReturn
2278	* Asserts that an iprt status code equals VINF_SUCCESS.
2279	*
2280	* @param rc iprt status code.
2281	* @param rcRet What is to be presented to return.
2282	* @remark rc is referenced multiple times.
2283	*/
2284	#define AssertLogRelRCSuccessReturn(rc, rcRet) AssertLogRelMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
2285
2286	/** @def AssertLogRelRCSuccessReturnVoid
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 AssertLogRelRCSuccessReturnVoid(rc) AssertLogRelMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2293
2294	/** @def AssertLogRelRCSuccessBreak
2295	* Asserts that an iprt status code equals VINF_SUCCESS.
2296	*
2297	* @param rc iprt status code.
2298	* @remark rc is referenced multiple times.
2299	*/
2300	#define AssertLogRelRCSuccessBreak(rc) AssertLogRelMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2301
2302	/** @def AssertLogRelRCSuccessBreakStmt
2303	* Asserts that an iprt status code equals VINF_SUCCESS.
2304	*
2305	* @param rc iprt status code.
2306	* @param stmt Statement to execute before break in case of a failed assertion.
2307	* @remark rc is referenced multiple times.
2308	*/
2309	#define AssertLogRelRCSuccessBreakStmt(rc, stmt) AssertLogRelMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
2310
2311
2312	/** @def AssertReleaseRC
2313	* Asserts a iprt status code successful.
2314	*
2315	* On failure information about the error will be printed and a breakpoint hit.
2316	*
2317	* @param rc iprt status code.
2318	* @remark rc is referenced multiple times.
2319	*/
2320	#define AssertReleaseRC(rc) AssertReleaseMsgRC(rc, ("%Rra\n", (rc)))
2321
2322	/** @def AssertReleaseRCReturn
2323	* Asserts a iprt status code successful, returning if it isn't.
2324	*
2325	* On failure information about the error will be printed, a breakpoint hit
2326	* and finally returning from the function if the breakpoint is somehow ignored.
2327	*
2328	* @param rc iprt status code.
2329	* @param rcRet What is to be presented to return.
2330	* @remark rc is referenced multiple times.
2331	*/
2332	#define AssertReleaseRCReturn(rc, rcRet) AssertReleaseMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
2333
2334	/** @def AssertReleaseRCReturnVoid
2335	* Asserts a iprt status code successful, returning if it isn't.
2336	*
2337	* On failure information about the error will be printed, a breakpoint hit
2338	* and finally returning from the function if the breakpoint is somehow ignored.
2339	*
2340	* @param rc iprt status code.
2341	* @remark rc is referenced multiple times.
2342	*/
2343	#define AssertReleaseRCReturnVoid(rc) AssertReleaseMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
2344
2345	/** @def AssertReleaseRCBreak
2346	* Asserts a iprt status code successful, breaking if it isn't.
2347	*
2348	* On failure information about the error will be printed, a breakpoint hit
2349	* and finally breaking the current statement if the breakpoint is somehow ignored.
2350	*
2351	* @param rc iprt status code.
2352	* @remark rc is referenced multiple times.
2353	*/
2354	#define AssertReleaseRCBreak(rc) AssertReleaseMsgRCBreak(rc, ("%Rra\n", (rc)))
2355
2356	/** @def AssertReleaseRCBreakStmt
2357	* Asserts a iprt status code successful, break if it isn't.
2358	*
2359	* On failure information about the error will be printed, a breakpoint hit
2360	* and finally the break statement will be issued if the breakpoint is somehow ignored.
2361	*
2362	* @param rc iprt status code.
2363	* @param stmt Statement to execute before break in case of a failed assertion.
2364	* @remark rc is referenced multiple times.
2365	*/
2366	#define AssertReleaseRCBreakStmt(rc, stmt) AssertReleaseMsgRCBreakStmt(rc, ("%Rra\n", (rc)), stmt)
2367
2368	/** @def AssertReleaseMsgRC
2369	* Asserts a iprt status code successful.
2370	*
2371	* On failure a custom message is printed and a breakpoint is hit.
2372	*
2373	* @param rc iprt status code.
2374	* @param msg printf argument list (in parenthesis).
2375	* @remark rc is referenced multiple times.
2376	*/
2377	#define AssertReleaseMsgRC(rc, msg) AssertReleaseMsg(RT_SUCCESS_NP(rc), msg)
2378
2379	/** @def AssertReleaseMsgRCReturn
2380	* Asserts a iprt status code successful.
2381	*
2382	* On failure a custom message is printed, a breakpoint is hit, and finally
2383	* returning from the function if the breakpoint is somehow ignored.
2384	*
2385	* @param rc iprt status code.
2386	* @param msg printf argument list (in parenthesis).
2387	* @param rcRet What is to be presented to return.
2388	* @remark rc is referenced multiple times.
2389	*/
2390	#define AssertReleaseMsgRCReturn(rc, msg, rcRet) AssertReleaseMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet)
2391
2392	/** @def AssertReleaseMsgRCReturnVoid
2393	* Asserts a iprt status code successful.
2394	*
2395	* On failure a custom message is printed, a breakpoint is hit, and finally
2396	* returning from the function if the breakpoint is somehow ignored.
2397	*
2398	* @param rc iprt status code.
2399	* @param msg printf argument list (in parenthesis).
2400	* @remark rc is referenced multiple times.
2401	*/
2402	#define AssertReleaseMsgRCReturnVoid(rc, msg) AssertReleaseMsgReturnVoid(RT_SUCCESS_NP(rc), msg)
2403
2404	/** @def AssertReleaseMsgRCBreak
2405	* Asserts a iprt status code successful.
2406	*
2407	* On failure a custom message is printed, a breakpoint is hit, and finally
2408	* breaking the current status if the breakpoint is somehow ignored.
2409	*
2410	* @param rc iprt status code.
2411	* @param msg printf argument list (in parenthesis).
2412	* @remark rc is referenced multiple times.
2413	*/
2414	#define AssertReleaseMsgRCBreak(rc, msg) AssertReleaseMsgBreak(RT_SUCCESS(rc), msg)
2415
2416	/** @def AssertReleaseMsgRCBreakStmt
2417	* Asserts a iprt status code successful.
2418	*
2419	* On failure a custom message is printed, a breakpoint is hit, and finally
2420	* the break statement is issued if the breakpoint is somehow ignored.
2421	*
2422	* @param rc iprt status code.
2423	* @param msg printf argument list (in parenthesis).
2424	* @param stmt Statement to execute before break in case of a failed assertion.
2425	* @remark rc is referenced multiple times.
2426	*/
2427	#define AssertReleaseMsgRCBreakStmt(rc, msg, stmt) AssertReleaseMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt)
2428
2429	/** @def AssertReleaseRCSuccess
2430	* Asserts that an iprt status code equals VINF_SUCCESS.
2431	*
2432	* On failure information about the error will be printed and a breakpoint hit.
2433	*
2434	* @param rc iprt status code.
2435	* @remark rc is referenced multiple times.
2436	*/
2437	#define AssertReleaseRCSuccess(rc) AssertReleaseMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2438
2439	/** @def AssertReleaseRCSuccessReturn
2440	* Asserts that an iprt status code equals VINF_SUCCESS.
2441	*
2442	* On failure information about the error will be printed, a breakpoint hit
2443	* and finally returning from the function if the breakpoint is somehow ignored.
2444	*
2445	* @param rc iprt status code.
2446	* @param rcRet What is to be presented to return.
2447	* @remark rc is referenced multiple times.
2448	*/
2449	#define AssertReleaseRCSuccessReturn(rc, rcRet) AssertReleaseMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
2450
2451	/** @def AssertReleaseRCSuccessReturnVoid
2452	* Asserts that an iprt status code equals VINF_SUCCESS.
2453	*
2454	* On failure information about the error will be printed, a breakpoint hit
2455	* and finally returning from the function if the breakpoint is somehow ignored.
2456	*
2457	* @param rc iprt status code.
2458	* @remark rc is referenced multiple times.
2459	*/
2460	#define AssertReleaseRCSuccessReturnVoid(rc) AssertReleaseMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2461
2462	/** @def AssertReleaseRCSuccessBreak
2463	* Asserts that an iprt status code equals VINF_SUCCESS.
2464	*
2465	* On failure information about the error will be printed, a breakpoint hit
2466	* and finally breaking the current statement if the breakpoint is somehow ignored.
2467	*
2468	* @param rc iprt status code.
2469	* @remark rc is referenced multiple times.
2470	*/
2471	#define AssertReleaseRCSuccessBreak(rc) AssertReleaseMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2472
2473	/** @def AssertReleaseRCSuccessBreakStmt
2474	* Asserts that an iprt status code equals VINF_SUCCESS.
2475	*
2476	* On failure information about the error will be printed, a breakpoint hit
2477	* and finally the break statement will be issued if the breakpoint is somehow ignored.
2478	*
2479	* @param rc iprt status code.
2480	* @param stmt Statement to execute before break in case of a failed assertion.
2481	* @remark rc is referenced multiple times.
2482	*/
2483	#define AssertReleaseRCSuccessBreakStmt(rc, stmt) AssertReleaseMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
2484
2485
2486	/** @def AssertFatalRC
2487	* Asserts a iprt status code successful.
2488	*
2489	* On failure information about the error will be printed and a breakpoint hit.
2490	*
2491	* @param rc iprt status code.
2492	* @remark rc is referenced multiple times.
2493	*/
2494	#define AssertFatalRC(rc) AssertFatalMsgRC(rc, ("%Rra\n", (rc)))
2495
2496	/** @def AssertReleaseMsgRC
2497	* Asserts a iprt status code successful.
2498	*
2499	* On failure a custom message is printed and a breakpoint is hit.
2500	*
2501	* @param rc iprt status code.
2502	* @param msg printf argument list (in parenthesis).
2503	* @remark rc is referenced multiple times.
2504	*/
2505	#define AssertFatalMsgRC(rc, msg) AssertFatalMsg(RT_SUCCESS_NP(rc), msg)
2506
2507	/** @def AssertFatalRCSuccess
2508	* Asserts that an iprt status code equals VINF_SUCCESS.
2509	*
2510	* On failure information about the error will be printed and a breakpoint hit.
2511	*
2512	* @param rc iprt status code.
2513	* @remark rc is referenced multiple times.
2514	*/
2515	#define AssertFatalRCSuccess(rc) AssertFatalMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2516
2517
2518	/** @def AssertPtr
2519	* Asserts that a pointer is valid.
2520	*
2521	* @param pv The pointer.
2522	*/
2523	#define AssertPtr(pv) AssertMsg(VALID_PTR(pv), ("%p\n", (pv)))
2524
2525	/** @def AssertPtrReturn
2526	* Asserts that a pointer is valid.
2527	*
2528	* @param pv The pointer.
2529	* @param rcRet What is to be presented to return.
2530	*/
2531	#define AssertPtrReturn(pv, rcRet) AssertMsgReturn(VALID_PTR(pv), ("%p\n", (pv)), rcRet)
2532
2533	/** @def AssertPtrReturnVoid
2534	* Asserts that a pointer is valid.
2535	*
2536	* @param pv The pointer.
2537	*/
2538	#define AssertPtrReturnVoid(pv) AssertMsgReturnVoid(VALID_PTR(pv), ("%p\n", (pv)))
2539
2540	/** @def AssertPtrBreak
2541	* Asserts that a pointer is valid.
2542	*
2543	* @param pv The pointer.
2544	*/
2545	#define AssertPtrBreak(pv) AssertMsgBreak(VALID_PTR(pv), ("%p\n", (pv)))
2546
2547	/** @def AssertPtrBreakStmt
2548	* Asserts that a pointer is valid.
2549	*
2550	* @param pv The pointer.
2551	* @param stmt Statement to execute before break in case of a failed assertion.
2552	*/
2553	#define AssertPtrBreakStmt(pv, stmt) AssertMsgBreakStmt(VALID_PTR(pv), ("%p\n", (pv)), stmt)
2554
2555	/** @def AssertPtrNull
2556	* Asserts that a pointer is valid or NULL.
2557	*
2558	* @param pv The pointer.
2559	*/
2560	#define AssertPtrNull(pv) AssertMsg(VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)))
2561
2562	/** @def AssertPtrNullReturn
2563	* Asserts that a pointer is valid or NULL.
2564	*
2565	* @param pv The pointer.
2566	* @param rcRet What is to be presented to return.
2567	*/
2568	#define AssertPtrNullReturn(pv, rcRet) AssertMsgReturn(VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)), rcRet)
2569
2570	/** @def AssertPtrNullReturnVoid
2571	* Asserts that a pointer is valid or NULL.
2572	*
2573	* @param pv The pointer.
2574	*/
2575	#define AssertPtrNullReturnVoid(pv) AssertMsgReturnVoid(VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)))
2576
2577	/** @def AssertPtrNullBreak
2578	* Asserts that a pointer is valid or NULL.
2579	*
2580	* @param pv The pointer.
2581	*/
2582	#define AssertPtrNullBreak(pv) AssertMsgBreak(VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)))
2583
2584	/** @def AssertPtrNullBreakStmt
2585	* Asserts that a pointer is valid or NULL.
2586	*
2587	* @param pv The pointer.
2588	* @param stmt Statement to execute before break in case of a failed assertion.
2589	*/
2590	#define AssertPtrNullBreakStmt(pv, stmt) AssertMsgBreakStmt(VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)), stmt)
2591
2592	/** @def AssertGCPhys32
2593	* Asserts that the high dword of a physical address is zero
2594	*
2595	* @param GCPhys The address (RTGCPHYS).
2596	*/
2597	#define AssertGCPhys32(GCPhys) AssertMsg(VALID_PHYS32(GCPhys), ("%RGp\n", (RTGCPHYS)(GCPhys)))
2598
2599	/** @def AssertGCPtr32
2600	* Asserts that the high dword of a physical address is zero
2601	*
2602	* @param GCPtr The address (RTGCPTR).
2603	*/
2604	#if GC_ARCH_BITS == 32
2605	# define AssertGCPtr32(GCPtr) do { } while (0)
2606	#else
2607	# define AssertGCPtr32(GCPtr) AssertMsg(!((GCPtr) & UINT64_C(0xffffffff00000000)), ("%RGv\n", GCPtr))
2608	#endif
2609
2610	/** @def AssertForEach
2611	* Equivalent to Assert for each value of the variable from the starting
2612	* value to the finishing one.
2613	*
2614	* @param var Name of the counter variable.
2615	* @param vartype Type of the counter variable.
2616	* @param first Lowest inclusive value of the counter variable.
2617	* This must be free from side effects.
2618	* @param end Highest exclusive value of the counter variable.
2619	* This must be free from side effects.
2620	* @param expr Expression which should be true for each value of @a var.
2621	*/
2622	#define AssertForEach(var, vartype, first, end, expr) \
2623	do { \
2624	vartype var; \
2625	Assert((first) == (first) && (end) == (end)); /* partial check for side effects */ \
2626	for (var = (first); var < (end); var++) \
2627	AssertMsg(expr, ("%s = %#RX64 (%RI64)", #var, (uint64_t)var, (int64_t)var)); \
2628	} while (0)
2629
2630	/** @} */
2631
2632	/** @} */
2633
2634	#endif
2635

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: