assert.h@ 35788

Last change on this file since 35788 was 33520, checked in by vboxsync, 14 years ago
iprt/assert.h: Added AssertLogRelMsgStmt, AssertLogRelMsgReturnStmt, AssertLogRelRCReturnStmt and AssertLogRelMsgRCReturnStmt. (The Assert*Stmt macros are currently added when needed.)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 82.8 KB

Line
1	/** @file
2	* IPRT - Assertions.
3	*/
4
5	/*
6	* Copyright (C) 2006-2007 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	#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 a 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_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	#ifdef RT_STRICT
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 break in case of a failed assertion.
824	* @param rc What is to be presented to return.
825	*/
826	#ifdef RT_STRICT
827	# define AssertMsgReturnStmt(expr, a, stmt, rc) \
828	do { \
829	if (RT_UNLIKELY(!(expr))) \
830	{ \
831	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
832	RTAssertMsg2Weak a; \
833	RTAssertPanic(); \
834	stmt; \
835	return (rc); \
836	} \
837	} while (0)
838	#else
839	# define AssertMsgReturnStmt(expr, a, stmt, rc) \
840	do { \
841	if (RT_UNLIKELY(!(expr))) \
842	{ \
843	stmt; \
844	return (rc); \
845	} \
846	} while (0)
847	#endif
848
849	/** @def AssertMsgReturnVoid
850	* Assert that an expression is true and returns if it isn't.
851	* In RT_STRICT mode it will hit a breakpoint before returning.
852	*
853	* @param expr Expression which should be true.
854	* @param a printf argument list (in parenthesis).
855	*/
856	#ifdef RT_STRICT
857	# define AssertMsgReturnVoid(expr, a) \
858	do { \
859	if (RT_UNLIKELY(!(expr))) \
860	{ \
861	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
862	RTAssertMsg2Weak a; \
863	RTAssertPanic(); \
864	return; \
865	} \
866	} while (0)
867	#else
868	# define AssertMsgReturnVoid(expr, a) \
869	do { \
870	if (RT_UNLIKELY(!(expr))) \
871	return; \
872	} while (0)
873	#endif
874
875	/** @def AssertMsgReturnVoidStmt
876	* Assert that an expression is true, if it isn't execute the statement and
877	* return.
878	*
879	* In RT_STRICT mode it will hit a breakpoint before returning.
880	*
881	* @param expr Expression which should be true.
882	* @param a printf argument list (in parenthesis).
883	* @param stmt Statement to execute before break in case of a failed assertion.
884	*/
885	#ifdef RT_STRICT
886	# define AssertMsgReturnVoidStmt(expr, a, stmt) \
887	do { \
888	if (RT_UNLIKELY(!(expr))) \
889	{ \
890	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
891	RTAssertMsg2Weak a; \
892	RTAssertPanic(); \
893	stmt; \
894	return; \
895	} \
896	} while (0)
897	#else
898	# define AssertMsgReturnVoidStmt(expr, a, stmt) \
899	do { \
900	if (RT_UNLIKELY(!(expr))) \
901	{ \
902	stmt; \
903	return; \
904	} \
905	} while (0)
906	#endif
907
908
909	/** @def AssertMsgBreak
910	* Assert that an expression is true and breaks if it isn't.
911	* In RT_STRICT mode it will hit a breakpoint before returning.
912	*
913	* @param expr Expression which should be true.
914	* @param a printf argument list (in parenthesis).
915	*/
916	#ifdef RT_STRICT
917	# define AssertMsgBreak(expr, a) \
918	if (RT_UNLIKELY(!(expr))) \
919	{ \
920	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
921	RTAssertMsg2Weak a; \
922	RTAssertPanic(); \
923	break; \
924	} else do {} while (0)
925	#else
926	# define AssertMsgBreak(expr, a) \
927	if (RT_UNLIKELY(!(expr))) \
928	break; \
929	else do {} while (0)
930	#endif
931
932	/** @def AssertMsgBreakStmt
933	* Assert that an expression is true and breaks if it isn't.
934	* In RT_STRICT mode it will hit a breakpoint before doing break.
935	*
936	* @param expr Expression which should be true.
937	* @param a printf argument list (in parenthesis).
938	* @param stmt Statement to execute before break in case of a failed assertion.
939	*/
940	#ifdef RT_STRICT
941	# define AssertMsgBreakStmt(expr, a, stmt) \
942	if (RT_UNLIKELY(!(expr))) { \
943	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
944	RTAssertMsg2Weak a; \
945	RTAssertPanic(); \
946	stmt; \
947	break; \
948	} else do {} while (0)
949	#else
950	# define AssertMsgBreakStmt(expr, a, stmt) \
951	if (RT_UNLIKELY(!(expr))) { \
952	stmt; \
953	break; \
954	} else do {} while (0)
955	#endif
956
957	/** @def AssertFailed
958	* An assertion failed hit breakpoint.
959	*/
960	#ifdef RT_STRICT
961	# define AssertFailed() \
962	do { \
963	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
964	RTAssertPanic(); \
965	} while (0)
966	#else
967	# define AssertFailed() do { } while (0)
968	#endif
969
970	/** @def AssertFailedReturn
971	* An assertion failed, hit breakpoint (RT_STRICT mode only) and return.
972	*
973	* @param rc The rc to return.
974	*/
975	#ifdef RT_STRICT
976	# define AssertFailedReturn(rc) \
977	do { \
978	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
979	RTAssertPanic(); \
980	return (rc); \
981	} while (0)
982	#else
983	# define AssertFailedReturn(rc) \
984	do { \
985	return (rc); \
986	} while (0)
987	#endif
988
989	/** @def AssertFailedReturnStmt
990	* An assertion failed, hit breakpoint (RT_STRICT mode only), execute a
991	* statement and return a value.
992	*
993	* @param stmt The statement to execute before returning.
994	* @param rc The value to return.
995	*/
996	#ifdef RT_STRICT
997	# define AssertFailedReturnStmt(stmt, rc) \
998	do { \
999	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1000	RTAssertPanic(); \
1001	stmt; \
1002	return (rc); \
1003	} while (0)
1004	#else
1005	# define AssertFailedReturnStmt(stmt, rc) \
1006	do { \
1007	stmt; \
1008	return (rc); \
1009	} while (0)
1010	#endif
1011
1012	/** @def AssertFailedReturnVoid
1013	* An assertion failed, hit breakpoint (RT_STRICT mode only) and return.
1014	*/
1015	#ifdef RT_STRICT
1016	# define AssertFailedReturnVoid() \
1017	do { \
1018	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1019	RTAssertPanic(); \
1020	return; \
1021	} while (0)
1022	#else
1023	# define AssertFailedReturnVoid() \
1024	do { \
1025	return; \
1026	} while (0)
1027	#endif
1028
1029	/** @def AssertFailedReturnVoidStmt
1030	* An assertion failed, hit breakpoint (RT_STRICT mode only), execute a
1031	* statement and return.
1032	*
1033	* @param stmt The statement to execute before returning.
1034	*/
1035	#ifdef RT_STRICT
1036	# define AssertFailedReturnVoidStmt(stmt) \
1037	do { \
1038	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1039	RTAssertPanic(); \
1040	stmt; \
1041	return; \
1042	} while (0)
1043	#else
1044	# define AssertFailedReturnVoidStmt(stmt) \
1045	do { \
1046	stmt; \
1047	return; \
1048	} while (0)
1049	#endif
1050
1051
1052	/** @def AssertFailedBreak
1053	* An assertion failed, hit breakpoint (RT_STRICT mode only) and break.
1054	*/
1055	#ifdef RT_STRICT
1056	# define AssertFailedBreak() \
1057	if (1) { \
1058	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1059	RTAssertPanic(); \
1060	break; \
1061	} else do {} while (0)
1062	#else
1063	# define AssertFailedBreak() \
1064	if (1) \
1065	break; \
1066	else do {} while (0)
1067	#endif
1068
1069	/** @def AssertFailedBreakStmt
1070	* An assertion failed, hit breakpoint (RT_STRICT mode only), execute
1071	* the given statement and break.
1072	*
1073	* @param stmt Statement to execute before break.
1074	*/
1075	#ifdef RT_STRICT
1076	# define AssertFailedBreakStmt(stmt) \
1077	if (1) { \
1078	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1079	RTAssertPanic(); \
1080	stmt; \
1081	break; \
1082	} else do {} while (0)
1083	#else
1084	# define AssertFailedBreakStmt(stmt) \
1085	if (1) { \
1086	stmt; \
1087	break; \
1088	} else do {} while (0)
1089	#endif
1090
1091
1092	/** @def AssertMsgFailed
1093	* An assertion failed print a message and a hit breakpoint.
1094	*
1095	* @param a printf argument list (in parenthesis).
1096	*/
1097	#ifdef RT_STRICT
1098	# define AssertMsgFailed(a) \
1099	do { \
1100	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1101	RTAssertMsg2Weak a; \
1102	RTAssertPanic(); \
1103	} while (0)
1104	#else
1105	# define AssertMsgFailed(a) do { } while (0)
1106	#endif
1107
1108	/** @def AssertMsgFailedReturn
1109	* An assertion failed, hit breakpoint with message (RT_STRICT mode only) and return.
1110	*
1111	* @param a printf argument list (in parenthesis).
1112	* @param rc What is to be presented to return.
1113	*/
1114	#ifdef RT_STRICT
1115	# define AssertMsgFailedReturn(a, rc) \
1116	do { \
1117	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1118	RTAssertMsg2Weak a; \
1119	RTAssertPanic(); \
1120	return (rc); \
1121	} while (0)
1122	#else
1123	# define AssertMsgFailedReturn(a, rc) \
1124	do { \
1125	return (rc); \
1126	} while (0)
1127	#endif
1128
1129	/** @def AssertMsgFailedReturnVoid
1130	* An assertion failed, hit breakpoint with message (RT_STRICT mode only) and return.
1131	*
1132	* @param a printf argument list (in parenthesis).
1133	*/
1134	#ifdef RT_STRICT
1135	# define AssertMsgFailedReturnVoid(a) \
1136	do { \
1137	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1138	RTAssertMsg2Weak a; \
1139	RTAssertPanic(); \
1140	return; \
1141	} while (0)
1142	#else
1143	# define AssertMsgFailedReturnVoid(a) \
1144	do { \
1145	return; \
1146	} while (0)
1147	#endif
1148
1149
1150	/** @def AssertMsgFailedBreak
1151	* An assertion failed, hit breakpoint with message (RT_STRICT mode only) and break.
1152	*
1153	* @param a printf argument list (in parenthesis).
1154	*/
1155	#ifdef RT_STRICT
1156	# define AssertMsgFailedBreak(a) \
1157	if (1) { \
1158	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1159	RTAssertMsg2Weak a; \
1160	RTAssertPanic(); \
1161	break; \
1162	} else do {} while (0)
1163	#else
1164	# define AssertMsgFailedBreak(a) \
1165	if (1) \
1166	break; \
1167	else do {} while (0)
1168	#endif
1169
1170	/** @def AssertMsgFailedBreakStmt
1171	* An assertion failed, hit breakpoint (RT_STRICT mode only), execute
1172	* the given statement and break.
1173	*
1174	* @param a printf argument list (in parenthesis).
1175	* @param stmt Statement to execute before break.
1176	*/
1177	#ifdef RT_STRICT
1178	# define AssertMsgFailedBreakStmt(a, stmt) \
1179	if (1) { \
1180	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1181	RTAssertMsg2Weak a; \
1182	RTAssertPanic(); \
1183	stmt; \
1184	break; \
1185	} else do {} while (0)
1186	#else
1187	# define AssertMsgFailedBreakStmt(a, stmt) \
1188	if (1) { \
1189	stmt; \
1190	break; \
1191	} else do {} while (0)
1192	#endif
1193
1194	/** @} */
1195
1196
1197
1198	/** @name Release Log Assertions
1199	*
1200	* These assertions will work like normal strict assertion when RT_STRICT is
1201	* defined and LogRel statements when RT_STRICT is undefined. Typically used for
1202	* things which shouldn't go wrong, but when it does you'd like to know one way
1203	* or the other.
1204	*
1205	* @{
1206	*/
1207
1208	/** @def RTAssertLogRelMsg1
1209	* RTAssertMsg1Weak (strict builds) / LogRel wrapper (non-strict).
1210	*/
1211	#ifdef RT_STRICT
1212	# define RTAssertLogRelMsg1(pszExpr, iLine, pszFile, pszFunction) \
1213	RTAssertMsg1Weak(pszExpr, iLine, pszFile, pszFunction)
1214	#else
1215	# define RTAssertLogRelMsg1(pszExpr, iLine, pszFile, pszFunction) \
1216	LogRel(("AssertLogRel %s(%d) %s: %s\n",\
1217	(pszFile), (iLine), (pszFunction), (pszExpr) ))
1218	#endif
1219
1220	/** @def RTAssertLogRelMsg2
1221	* RTAssertMsg2Weak (strict builds) / LogRel wrapper (non-strict).
1222	*/
1223	#ifdef RT_STRICT
1224	# define RTAssertLogRelMsg2(a) RTAssertMsg2Weak a
1225	#else
1226	# define RTAssertLogRelMsg2(a) LogRel(a)
1227	#endif
1228
1229	/** @def AssertLogRel
1230	* Assert that an expression is true.
1231	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1232	*
1233	* @param expr Expression which should be true.
1234	*/
1235	#define AssertLogRel(expr) \
1236	do { \
1237	if (RT_UNLIKELY(!(expr))) \
1238	{ \
1239	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1240	RTAssertPanic(); \
1241	} \
1242	} while (0)
1243
1244	/** @def AssertLogRelReturn
1245	* Assert that an expression is true, return \a rc if it isn't.
1246	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1247	*
1248	* @param expr Expression which should be true.
1249	* @param rc What is to be presented to return.
1250	*/
1251	#define AssertLogRelReturn(expr, rc) \
1252	do { \
1253	if (RT_UNLIKELY(!(expr))) \
1254	{ \
1255	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1256	RTAssertPanic(); \
1257	return (rc); \
1258	} \
1259	} while (0)
1260
1261	/** @def AssertLogRelReturnVoid
1262	* Assert that an expression is true, return void if it isn't.
1263	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1264	*
1265	* @param expr Expression which should be true.
1266	*/
1267	#define AssertLogRelReturnVoid(expr) \
1268	do { \
1269	if (RT_UNLIKELY(!(expr))) \
1270	{ \
1271	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1272	RTAssertPanic(); \
1273	return; \
1274	} \
1275	} while (0)
1276
1277	/** @def AssertLogRelBreak
1278	* Assert that an expression is true, break if it isn't.
1279	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1280	*
1281	* @param expr Expression which should be true.
1282	*/
1283	#define AssertLogRelBreak(expr) \
1284	if (RT_UNLIKELY(!(expr))) \
1285	{ \
1286	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1287	RTAssertPanic(); \
1288	break; \
1289	} \
1290	else do {} while (0)
1291
1292	/** @def AssertLogRelBreakStmt
1293	* Assert that an expression is true, execute \a stmt and break if it isn't.
1294	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1295	*
1296	* @param expr Expression which should be true.
1297	* @param stmt Statement to execute before break in case of a failed assertion.
1298	*/
1299	#define AssertLogRelBreakStmt(expr, stmt) \
1300	if (RT_UNLIKELY(!(expr))) \
1301	{ \
1302	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1303	RTAssertPanic(); \
1304	stmt; \
1305	break; \
1306	} else do {} while (0)
1307
1308	/** @def AssertLogRelMsg
1309	* Assert that an expression is true.
1310	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1311	*
1312	* @param expr Expression which should be true.
1313	* @param a printf argument list (in parenthesis).
1314	*/
1315	#define AssertLogRelMsg(expr, a) \
1316	do { \
1317	if (RT_UNLIKELY(!(expr))) \
1318	{ \
1319	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1320	RTAssertLogRelMsg2(a); \
1321	RTAssertPanic(); \
1322	} \
1323	} while (0)
1324
1325	/** @def AssertLogRelMsgStmt
1326	* Assert that an expression is true, execute \a stmt and break if it 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 in case of a failed assertion.
1332	*/
1333	#define AssertLogRelMsgStmt(expr, a, stmt) \
1334	do { \
1335	if (RT_UNLIKELY(!(expr))) \
1336	{ \
1337	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1338	RTAssertLogRelMsg2(a); \
1339	RTAssertPanic(); \
1340	stmt; \
1341	} \
1342	} while (0)
1343
1344	/** @def AssertLogRelMsgReturn
1345	* Assert that an expression is true, return \a rc if it isn't.
1346	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1347	*
1348	* @param expr Expression which should be true.
1349	* @param a printf argument list (in parenthesis).
1350	* @param rc What is to be presented to return.
1351	*/
1352	#define AssertLogRelMsgReturn(expr, a, rc) \
1353	do { \
1354	if (RT_UNLIKELY(!(expr))) \
1355	{ \
1356	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1357	RTAssertLogRelMsg2(a); \
1358	RTAssertPanic(); \
1359	return (rc); \
1360	} \
1361	} while (0)
1362
1363	/** @def AssertLogRelMsgReturnStmt
1364	* Assert that an expression is true, execute \a stmt and return \a rc if it
1365	* isn't.
1366	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1367	*
1368	* @param expr Expression which should be true.
1369	* @param a printf argument list (in parenthesis).
1370	* @param rc What is to be presented to return.
1371	* @param stmt Statement to execute before return in case of a failed
1372	* assertion.
1373	*/
1374	#define AssertLogRelMsgReturnStmt(expr, a, rc, stmt) \
1375	do { \
1376	if (RT_UNLIKELY(!(expr))) \
1377	{ \
1378	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1379	RTAssertLogRelMsg2(a); \
1380	RTAssertPanic(); \
1381	stmt; \
1382	return (rc); \
1383	} \
1384	} while (0)
1385
1386	/** @def AssertLogRelMsgReturnVoid
1387	* Assert that an expression is true, return (void) if it isn't.
1388	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1389	*
1390	* @param expr Expression which should be true.
1391	* @param a printf argument list (in parenthesis).
1392	*/
1393	#define AssertLogRelMsgReturnVoid(expr, a) \
1394	do { \
1395	if (RT_UNLIKELY(!(expr))) \
1396	{ \
1397	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1398	RTAssertLogRelMsg2(a); \
1399	RTAssertPanic(); \
1400	return; \
1401	} \
1402	} while (0)
1403
1404	/** @def AssertLogRelMsgBreak
1405	* Assert that an expression is true, break if it isn't.
1406	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1407	*
1408	* @param expr Expression which should be true.
1409	* @param a printf argument list (in parenthesis).
1410	*/
1411	#define AssertLogRelMsgBreak(expr, a) \
1412	if (RT_UNLIKELY(!(expr))) \
1413	{ \
1414	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1415	RTAssertLogRelMsg2(a); \
1416	RTAssertPanic(); \
1417	break; \
1418	} \
1419	else do {} while (0)
1420
1421	/** @def AssertLogRelMsgBreakStmt
1422	* Assert that an expression is true, execute \a stmt and break if it isn't.
1423	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1424	*
1425	* @param expr Expression which should be true.
1426	* @param a printf argument list (in parenthesis).
1427	* @param stmt Statement to execute before break in case of a failed assertion.
1428	*/
1429	#define AssertLogRelMsgBreakStmt(expr, a, stmt) \
1430	if (RT_UNLIKELY(!(expr))) \
1431	{ \
1432	RTAssertLogRelMsg1(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1433	RTAssertLogRelMsg2(a); \
1434	RTAssertPanic(); \
1435	stmt; \
1436	break; \
1437	} else do {} while (0)
1438
1439	/** @def AssertLogRelFailed
1440	* An assertion failed.
1441	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1442	*/
1443	#define AssertLogRelFailed() \
1444	do { \
1445	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1446	RTAssertPanic(); \
1447	} while (0)
1448
1449	/** @def AssertLogRelFailedReturn
1450	* An assertion failed.
1451	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1452	*
1453	* @param rc What is to be presented to return.
1454	*/
1455	#define AssertLogRelFailedReturn(rc) \
1456	do { \
1457	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1458	RTAssertPanic(); \
1459	return (rc); \
1460	} while (0)
1461
1462	/** @def AssertLogRelFailedReturnVoid
1463	* An assertion failed, hit a breakpoint and return.
1464	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1465	*/
1466	#define AssertLogRelFailedReturnVoid() \
1467	do { \
1468	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1469	RTAssertPanic(); \
1470	return; \
1471	} while (0)
1472
1473	/** @def AssertLogRelFailedBreak
1474	* An assertion failed, break.
1475	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1476	*/
1477	#define AssertLogRelFailedBreak() \
1478	if (1) \
1479	{ \
1480	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1481	RTAssertPanic(); \
1482	break; \
1483	} else do {} while (0)
1484
1485	/** @def AssertLogRelFailedBreakStmt
1486	* An assertion failed, execute \a stmt and break.
1487	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1488	*
1489	* @param stmt Statement to execute before break.
1490	*/
1491	#define AssertLogRelFailedBreakStmt(stmt) \
1492	if (1) \
1493	{ \
1494	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1495	RTAssertPanic(); \
1496	stmt; \
1497	break; \
1498	} else do {} while (0)
1499
1500	/** @def AssertLogRelMsgFailed
1501	* An assertion failed.
1502	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1503	*
1504	* @param a printf argument list (in parenthesis).
1505	*/
1506	#define AssertLogRelMsgFailed(a) \
1507	do { \
1508	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1509	RTAssertLogRelMsg2(a); \
1510	RTAssertPanic(); \
1511	} while (0)
1512
1513	/** @def AssertLogRelMsgFailedReturn
1514	* An assertion failed, return \a rc.
1515	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1516	*
1517	* @param a printf argument list (in parenthesis).
1518	* @param rc What is to be presented to return.
1519	*/
1520	#define AssertLogRelMsgFailedReturn(a, rc) \
1521	do { \
1522	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1523	RTAssertLogRelMsg2(a); \
1524	RTAssertPanic(); \
1525	return (rc); \
1526	} while (0)
1527
1528	/** @def AssertLogRelMsgFailedReturnVoid
1529	* An assertion failed, return void.
1530	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1531	*
1532	* @param a printf argument list (in parenthesis).
1533	*/
1534	#define AssertLogRelMsgFailedReturnVoid(a) \
1535	do { \
1536	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1537	RTAssertLogRelMsg2(a); \
1538	RTAssertPanic(); \
1539	return; \
1540	} while (0)
1541
1542	/** @def AssertLogRelMsgFailedBreak
1543	* An assertion failed, break.
1544	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1545	*
1546	* @param a printf argument list (in parenthesis).
1547	*/
1548	#define AssertLogRelMsgFailedBreak(a) \
1549	if (1)\
1550	{ \
1551	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1552	RTAssertLogRelMsg2(a); \
1553	RTAssertPanic(); \
1554	break; \
1555	} else do {} while (0)
1556
1557	/** @def AssertLogRelMsgFailedBreakStmt
1558	* An assertion failed, execute \a stmt and break.
1559	* Strict builds will hit a breakpoint, non-strict will only do LogRel.
1560	*
1561	* @param a printf argument list (in parenthesis).
1562	* @param stmt Statement to execute before break.
1563	*/
1564	#define AssertLogRelMsgFailedBreakStmt(a, stmt) \
1565	if (1) \
1566	{ \
1567	RTAssertLogRelMsg1((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1568	RTAssertLogRelMsg2(a); \
1569	RTAssertPanic(); \
1570	stmt; \
1571	break; \
1572	} else do {} while (0)
1573
1574	/** @} */
1575
1576
1577
1578	/** @name Release Assertions
1579	*
1580	* These assertions are always enabled.
1581	* @{
1582	*/
1583
1584	/** @def RTAssertReleasePanic()
1585	* Invokes RTAssertShouldPanic and RTAssertDoPanic.
1586	*
1587	* It might seem odd that RTAssertShouldPanic is necessary when its result isn't
1588	* checked, but it's done since RTAssertShouldPanic is overrideable and might be
1589	* used to bail out before taking down the system (the VMMR0 case).
1590	*/
1591	#define RTAssertReleasePanic() do { RTAssertShouldPanic(); RTAssertDoPanic(); } while (0)
1592
1593
1594	/** @def AssertRelease
1595	* Assert that an expression is true. If it's not hit a breakpoint.
1596	*
1597	* @param expr Expression which should be true.
1598	*/
1599	#define AssertRelease(expr) \
1600	do { \
1601	if (RT_UNLIKELY(!(expr))) \
1602	{ \
1603	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1604	RTAssertReleasePanic(); \
1605	} \
1606	} while (0)
1607
1608	/** @def AssertReleaseReturn
1609	* Assert that an expression is true, hit a breakpoint and return if it isn't.
1610	*
1611	* @param expr Expression which should be true.
1612	* @param rc What is to be presented to return.
1613	*/
1614	#define AssertReleaseReturn(expr, rc) \
1615	do { \
1616	if (RT_UNLIKELY(!(expr))) \
1617	{ \
1618	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1619	RTAssertReleasePanic(); \
1620	return (rc); \
1621	} \
1622	} while (0)
1623
1624	/** @def AssertReleaseReturnVoid
1625	* Assert that an expression is true, hit a breakpoint and return if it isn't.
1626	*
1627	* @param expr Expression which should be true.
1628	*/
1629	#define AssertReleaseReturnVoid(expr) \
1630	do { \
1631	if (RT_UNLIKELY(!(expr))) \
1632	{ \
1633	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1634	RTAssertReleasePanic(); \
1635	return; \
1636	} \
1637	} while (0)
1638
1639
1640	/** @def AssertReleaseBreak
1641	* Assert that an expression is true, hit a breakpoint and break if it isn't.
1642	*
1643	* @param expr Expression which should be true.
1644	*/
1645	#define AssertReleaseBreak(expr) \
1646	if { \
1647	if (RT_UNLIKELY(!(expr))) \
1648	{ \
1649	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1650	RTAssertReleasePanic(); \
1651	break; \
1652	} \
1653	} else do {} while (0)
1654
1655	/** @def AssertReleaseBreakStmt
1656	* Assert that an expression is true, hit a breakpoint and break if it isn't.
1657	*
1658	* @param expr Expression which should be true.
1659	* @param stmt Statement to execute before break in case of a failed assertion.
1660	*/
1661	#define AssertReleaseBreakStmt(expr, stmt) \
1662	if (RT_UNLIKELY(!(expr))) \
1663	{ \
1664	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1665	RTAssertReleasePanic(); \
1666	stmt; \
1667	break; \
1668	} else do {} while (0)
1669
1670
1671	/** @def AssertReleaseMsg
1672	* Assert that an expression is true, print the message and hit a breakpoint if it isn't.
1673	*
1674	* @param expr Expression which should be true.
1675	* @param a printf argument list (in parenthesis).
1676	*/
1677	#define AssertReleaseMsg(expr, a) \
1678	do { \
1679	if (RT_UNLIKELY(!(expr))) \
1680	{ \
1681	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1682	RTAssertMsg2Weak a; \
1683	RTAssertReleasePanic(); \
1684	} \
1685	} while (0)
1686
1687	/** @def AssertReleaseMsgReturn
1688	* Assert that an expression is true, print the message and hit a breakpoint and return if it isn't.
1689	*
1690	* @param expr Expression which should be true.
1691	* @param a printf argument list (in parenthesis).
1692	* @param rc What is to be presented to return.
1693	*/
1694	#define AssertReleaseMsgReturn(expr, a, rc) \
1695	do { \
1696	if (RT_UNLIKELY(!(expr))) \
1697	{ \
1698	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1699	RTAssertMsg2Weak a; \
1700	RTAssertReleasePanic(); \
1701	return (rc); \
1702	} \
1703	} while (0)
1704
1705	/** @def AssertReleaseMsgReturnVoid
1706	* Assert that an expression is true, print the message and hit a breakpoint and return if it isn't.
1707	*
1708	* @param expr Expression which should be true.
1709	* @param a printf argument list (in parenthesis).
1710	*/
1711	#define AssertReleaseMsgReturnVoid(expr, a) \
1712	do { \
1713	if (RT_UNLIKELY(!(expr))) \
1714	{ \
1715	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1716	RTAssertMsg2Weak a; \
1717	RTAssertReleasePanic(); \
1718	return; \
1719	} \
1720	} while (0)
1721
1722
1723	/** @def AssertReleaseMsgBreak
1724	* Assert that an expression is true, print the message and hit a breakpoint and break if it isn't.
1725	*
1726	* @param expr Expression which should be true.
1727	* @param a printf argument list (in parenthesis).
1728	*/
1729	#define AssertReleaseMsgBreak(expr, a) \
1730	if (RT_UNLIKELY(!(expr))) \
1731	{ \
1732	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1733	RTAssertMsg2Weak a; \
1734	RTAssertReleasePanic(); \
1735	break; \
1736	} else do {} while (0)
1737
1738	/** @def AssertReleaseMsgBreakStmt
1739	* Assert that an expression is true, print the message and hit a breakpoint and break if it isn't.
1740	*
1741	* @param expr Expression which should be true.
1742	* @param a printf argument list (in parenthesis).
1743	* @param stmt Statement to execute before break in case of a failed assertion.
1744	*/
1745	#define AssertReleaseMsgBreakStmt(expr, a, stmt) \
1746	if (RT_UNLIKELY(!(expr))) { \
1747	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1748	RTAssertMsg2Weak a; \
1749	RTAssertReleasePanic(); \
1750	stmt; \
1751	break; \
1752	} else do {} while (0)
1753
1754
1755	/** @def AssertReleaseFailed
1756	* An assertion failed, hit a breakpoint.
1757	*/
1758	#define AssertReleaseFailed() \
1759	do { \
1760	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1761	RTAssertReleasePanic(); \
1762	} while (0)
1763
1764	/** @def AssertReleaseFailedReturn
1765	* An assertion failed, hit a breakpoint and return.
1766	*
1767	* @param rc What is to be presented to return.
1768	*/
1769	#define AssertReleaseFailedReturn(rc) \
1770	do { \
1771	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1772	RTAssertReleasePanic(); \
1773	return (rc); \
1774	} while (0)
1775
1776	/** @def AssertReleaseFailedReturnVoid
1777	* An assertion failed, hit a breakpoint and return.
1778	*/
1779	#define AssertReleaseFailedReturnVoid() \
1780	do { \
1781	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1782	RTAssertReleasePanic(); \
1783	return; \
1784	} while (0)
1785
1786
1787	/** @def AssertReleaseFailedBreak
1788	* An assertion failed, hit a breakpoint and break.
1789	*/
1790	#define AssertReleaseFailedBreak() \
1791	if (1) { \
1792	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1793	RTAssertReleasePanic(); \
1794	break; \
1795	} else do {} while (0)
1796
1797	/** @def AssertReleaseFailedBreakStmt
1798	* An assertion failed, hit a breakpoint and break.
1799	*
1800	* @param stmt Statement to execute before break.
1801	*/
1802	#define AssertReleaseFailedBreakStmt(stmt) \
1803	if (1) { \
1804	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1805	RTAssertReleasePanic(); \
1806	stmt; \
1807	break; \
1808	} else do {} while (0)
1809
1810
1811	/** @def AssertReleaseMsgFailed
1812	* An assertion failed, print a message and hit a breakpoint.
1813	*
1814	* @param a printf argument list (in parenthesis).
1815	*/
1816	#define AssertReleaseMsgFailed(a) \
1817	do { \
1818	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1819	RTAssertMsg2Weak a; \
1820	RTAssertReleasePanic(); \
1821	} while (0)
1822
1823	/** @def AssertReleaseMsgFailedReturn
1824	* An assertion failed, print a message, hit a breakpoint and return.
1825	*
1826	* @param a printf argument list (in parenthesis).
1827	* @param rc What is to be presented to return.
1828	*/
1829	#define AssertReleaseMsgFailedReturn(a, rc) \
1830	do { \
1831	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1832	RTAssertMsg2Weak a; \
1833	RTAssertReleasePanic(); \
1834	return (rc); \
1835	} while (0)
1836
1837	/** @def AssertReleaseMsgFailedReturnVoid
1838	* An assertion failed, print a message, hit a breakpoint and return.
1839	*
1840	* @param a printf argument list (in parenthesis).
1841	*/
1842	#define AssertReleaseMsgFailedReturnVoid(a) \
1843	do { \
1844	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1845	RTAssertMsg2Weak a; \
1846	RTAssertReleasePanic(); \
1847	return; \
1848	} while (0)
1849
1850
1851	/** @def AssertReleaseMsgFailedBreak
1852	* An assertion failed, print a message, hit a breakpoint and break.
1853	*
1854	* @param a printf argument list (in parenthesis).
1855	*/
1856	#define AssertReleaseMsgFailedBreak(a) \
1857	if (1) { \
1858	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1859	RTAssertMsg2Weak a; \
1860	RTAssertReleasePanic(); \
1861	break; \
1862	} else do {} while (0)
1863
1864	/** @def AssertReleaseMsgFailedBreakStmt
1865	* An assertion failed, print a message, hit a breakpoint and break.
1866	*
1867	* @param a printf argument list (in parenthesis).
1868	* @param stmt Statement to execute before break.
1869	*/
1870	#define AssertReleaseMsgFailedBreakStmt(a, stmt) \
1871	if (1) { \
1872	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1873	RTAssertMsg2Weak a; \
1874	RTAssertReleasePanic(); \
1875	stmt; \
1876	break; \
1877	} else do {} while (0)
1878
1879	/** @} */
1880
1881
1882
1883	/** @name Fatal Assertions
1884	* These are similar to release assertions except that you cannot ignore them in
1885	* any way, they will loop for ever if RTAssertDoPanic returns.
1886	*
1887	* @{
1888	*/
1889
1890	/** @def AssertFatal
1891	* Assert that an expression is true. If it's not hit a breakpoint (for ever).
1892	*
1893	* @param expr Expression which should be true.
1894	*/
1895	#define AssertFatal(expr) \
1896	do { \
1897	if (RT_UNLIKELY(!(expr))) \
1898	for (;;) \
1899	{ \
1900	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1901	RTAssertReleasePanic(); \
1902	} \
1903	} while (0)
1904
1905	/** @def AssertFatalMsg
1906	* Assert that an expression is true, print the message and hit a breakpoint (for ever) if it isn't.
1907	*
1908	* @param expr Expression which should be true.
1909	* @param a printf argument list (in parenthesis).
1910	*/
1911	#define AssertFatalMsg(expr, a) \
1912	do { \
1913	if (RT_UNLIKELY(!(expr))) \
1914	for (;;) \
1915	{ \
1916	RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1917	RTAssertMsg2Weak a; \
1918	RTAssertReleasePanic(); \
1919	} \
1920	} while (0)
1921
1922	/** @def AssertFatalFailed
1923	* An assertion failed, hit a breakpoint (for ever).
1924	*/
1925	#define AssertFatalFailed() \
1926	do { \
1927	for (;;) \
1928	{ \
1929	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1930	RTAssertReleasePanic(); \
1931	} \
1932	} while (0)
1933
1934	/** @def AssertFatalMsgFailed
1935	* An assertion failed, print a message and hit a breakpoint (for ever).
1936	*
1937	* @param a printf argument list (in parenthesis).
1938	*/
1939	#define AssertFatalMsgFailed(a) \
1940	do { \
1941	for (;;) \
1942	{ \
1943	RTAssertMsg1Weak((const char *)0, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
1944	RTAssertMsg2Weak a; \
1945	RTAssertReleasePanic(); \
1946	} \
1947	} while (0)
1948
1949	/** @} */
1950
1951
1952
1953	/** @name Convenience Assertions Macros
1954	* @{
1955	*/
1956
1957	/** @def AssertRC
1958	* Asserts a iprt status code successful.
1959	*
1960	* On failure it will print info about the rc and hit a breakpoint.
1961	*
1962	* @param rc iprt status code.
1963	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1964	*/
1965	#define AssertRC(rc) AssertMsgRC(rc, ("%Rra\n", (rc)))
1966
1967	/** @def AssertRCReturn
1968	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
1969	*
1970	* @param rc iprt status code.
1971	* @param rcRet What is to be presented to return.
1972	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1973	*/
1974	#define AssertRCReturn(rc, rcRet) AssertMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
1975
1976	/** @def AssertRCReturnVoid
1977	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and return if it isn't.
1978	*
1979	* @param rc iprt status code.
1980	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1981	*/
1982	#define AssertRCReturnVoid(rc) AssertMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
1983
1984	/** @def AssertReturnVoidStmt
1985	* Asserts a iprt status code successful, bitch (RT_STRICT mode only), and
1986	* execute the given statement/return if it isn't.
1987	*
1988	* @param rc iprt status code.
1989	* @param stmt Statement to execute before returning on failure.
1990	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1991	*/
1992	#define AssertRCReturnVoidStmt(rc, stmt) AssertMsgRCReturnVoidStmt(rc, ("%Rra\n", (rc)), stmt)
1993
1994	/** @def AssertRCBreak
1995	* Asserts a iprt status code successful, bitch (RT_STRICT mode only) and break if it isn't.
1996	*
1997	* @param rc iprt status code.
1998	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
1999	*/
2000	#define AssertRCBreak(rc) AssertMsgRCBreak(rc, ("%Rra\n", (rc)))
2001
2002	/** @def AssertRCBreakStmt
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	* @param stmt Statement to execute before break in case of a failed assertion.
2007	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2008	*/
2009	#define AssertRCBreakStmt(rc, stmt) AssertMsgRCBreakStmt(rc, ("%Rra\n", (rc)), stmt)
2010
2011	/** @def AssertMsgRC
2012	* Asserts a iprt status code successful.
2013	*
2014	* It prints a custom message and hits a breakpoint on FAILURE.
2015	*
2016	* @param rc iprt status code.
2017	* @param msg printf argument list (in parenthesis).
2018	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2019	*/
2020	#define AssertMsgRC(rc, msg) \
2021	do { AssertMsg(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)
2022
2023	/** @def AssertMsgRCReturn
2024	* Asserts a iprt status code successful and if it's not return the specified status code.
2025	*
2026	* If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
2027	*
2028	* @param rc iprt status code.
2029	* @param msg printf argument list (in parenthesis).
2030	* @param rcRet What is to be presented to return.
2031	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2032	*/
2033	#define AssertMsgRCReturn(rc, msg, rcRet) \
2034	do { AssertMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet); NOREF(rc); } while (0)
2035
2036	/** @def AssertMsgRCReturnVoid
2037	* Asserts a iprt status code successful and if it's not return.
2038	*
2039	* If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
2040	*
2041	* @param rc iprt status code.
2042	* @param msg printf argument list (in parenthesis).
2043	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2044	*/
2045	#define AssertMsgRCReturnVoid(rc, msg) \
2046	do { AssertMsgReturnVoid(RT_SUCCESS_NP(rc), msg); NOREF(rc); } while (0)
2047
2048	/** @def AssertMsgRCReturnVoidStmt
2049	* Asserts a iprt status code successful and execute statement/break if it's not.
2050	*
2051	* If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
2052	*
2053	* @param rc iprt status code.
2054	* @param msg printf argument list (in parenthesis).
2055	* @param stmt Statement to execute before break in case of a failed assertion.
2056	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2057	*/
2058	#define AssertMsgRCReturnVoidStmt(rc, msg, stmt) \
2059	do { AssertMsgReturnVoidStmt(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } while (0)
2060
2061	/** @def AssertMsgRCBreak
2062	* Asserts a iprt status code successful and if it's not break.
2063	*
2064	* If RT_STRICT is defined the message will be printed and a breakpoint hit before it breaks
2065	*
2066	* @param rc iprt status code.
2067	* @param msg printf argument list (in parenthesis).
2068	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2069	*/
2070	#define AssertMsgRCBreak(rc, msg) \
2071	if (1) { AssertMsgBreak(RT_SUCCESS(rc), msg); NOREF(rc); } else do {} while (0)
2072
2073	/** @def AssertMsgRCBreakStmt
2074	* Asserts a iprt status code successful and execute statement/break if it's not.
2075	*
2076	* If RT_STRICT is defined the message will be printed and a breakpoint hit before it returns
2077	*
2078	* @param rc iprt status code.
2079	* @param msg printf argument list (in parenthesis).
2080	* @param stmt Statement to execute before break in case of a failed assertion.
2081	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2082	*/
2083	#define AssertMsgRCBreakStmt(rc, msg, stmt) \
2084	if (1) { AssertMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt); NOREF(rc); } else do {} while (0)
2085
2086	/** @def AssertRCSuccess
2087	* Asserts an iprt status code equals VINF_SUCCESS.
2088	*
2089	* On failure it will print info about the rc and hit a breakpoint.
2090	*
2091	* @param rc iprt status code.
2092	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2093	*/
2094	#define AssertRCSuccess(rc) AssertMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2095
2096	/** @def AssertRCSuccessReturn
2097	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
2098	*
2099	* @param rc iprt status code.
2100	* @param rcRet What is to be presented to return.
2101	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2102	*/
2103	#define AssertRCSuccessReturn(rc, rcRet) AssertMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
2104
2105	/** @def AssertRCSuccessReturnVoid
2106	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and return if it isn't.
2107	*
2108	* @param rc iprt status code.
2109	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2110	*/
2111	#define AssertRCSuccessReturnVoid(rc) AssertMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2112
2113	/** @def AssertRCSuccessBreak
2114	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
2115	*
2116	* @param rc iprt status code.
2117	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2118	*/
2119	#define AssertRCSuccessBreak(rc) AssertMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2120
2121	/** @def AssertRCSuccessBreakStmt
2122	* Asserts that an iprt status code equals VINF_SUCCESS, bitch (RT_STRICT mode only) and break if it isn't.
2123	*
2124	* @param rc iprt status code.
2125	* @param stmt Statement to execute before break in case of a failed assertion.
2126	* @remark rc is referenced multiple times. In release mode is NOREF()'ed.
2127	*/
2128	#define AssertRCSuccessBreakStmt(rc, stmt) AssertMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
2129
2130
2131	/** @def AssertLogRelRC
2132	* Asserts a iprt status code successful.
2133	*
2134	* @param rc iprt status code.
2135	* @remark rc is referenced multiple times.
2136	*/
2137	#define AssertLogRelRC(rc) AssertLogRelMsgRC(rc, ("%Rra\n", (rc)))
2138
2139	/** @def AssertLogRelRCReturn
2140	* Asserts a iprt status code successful, returning \a rc if it isn't.
2141	*
2142	* @param rc iprt status code.
2143	* @param rcRet What is to be presented to return.
2144	* @remark rc is referenced multiple times.
2145	*/
2146	#define AssertLogRelRCReturn(rc, rcRet) AssertLogRelMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
2147
2148	/** @def AssertLogRelRCReturnStmt
2149	* Asserts a iprt status code successful, executing \a stmt and returning \a rc
2150	* if it isn't.
2151	*
2152	* @param rc iprt status code.
2153	* @param rcRet What is to be presented to return.
2154	* @param stmt Statement to execute before returning in case of a failed
2155	* assertion.
2156	* @remark rc is referenced multiple times.
2157	*/
2158	#define AssertLogRelRCReturnStmt(rc, rcRet, stmt) AssertLogRelMsgRCReturnStmt(rc, ("%Rra\n", (rc)), rcRet, stmt)
2159
2160	/** @def AssertLogRelRCReturnVoid
2161	* Asserts a iprt status code successful, returning (void) if it isn't.
2162	*
2163	* @param rc iprt status code.
2164	* @remark rc is referenced multiple times.
2165	*/
2166	#define AssertLogRelRCReturnVoid(rc) AssertLogRelMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
2167
2168	/** @def AssertLogRelRCBreak
2169	* Asserts a iprt status code successful, breaking if it isn't.
2170	*
2171	* @param rc iprt status code.
2172	* @remark rc is referenced multiple times.
2173	*/
2174	#define AssertLogRelRCBreak(rc) AssertLogRelMsgRCBreak(rc, ("%Rra\n", (rc)))
2175
2176	/** @def AssertLogRelRCBreakStmt
2177	* Asserts a iprt status code successful, execute \a statement and break if it isn't.
2178	*
2179	* @param rc iprt status code.
2180	* @param stmt Statement to execute before break in case of a failed assertion.
2181	* @remark rc is referenced multiple times.
2182	*/
2183	#define AssertLogRelRCBreakStmt(rc, stmt) AssertLogRelMsgRCBreakStmt(rc, ("%Rra\n", (rc)), stmt)
2184
2185	/** @def AssertLogRelMsgRC
2186	* Asserts a iprt status code successful.
2187	*
2188	* @param rc iprt status code.
2189	* @param msg printf argument list (in parenthesis).
2190	* @remark rc is referenced multiple times.
2191	*/
2192	#define AssertLogRelMsgRC(rc, msg) AssertLogRelMsg(RT_SUCCESS_NP(rc), msg)
2193
2194	/** @def AssertLogRelMsgRCReturn
2195	* Asserts a iprt status code successful.
2196	*
2197	* @param rc iprt status code.
2198	* @param msg printf argument list (in parenthesis).
2199	* @param rcRet What is to be presented to return.
2200	* @remark rc is referenced multiple times.
2201	*/
2202	#define AssertLogRelMsgRCReturn(rc, msg, rcRet) AssertLogRelMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet)
2203
2204	/** @def AssertLogRelMsgRCReturnStmt
2205	* Asserts a iprt status code successful, execute \a stmt and return on
2206	* failure.
2207	*
2208	* @param rc iprt status code.
2209	* @param msg printf argument list (in parenthesis).
2210	* @param rcRet What is to be presented to return.
2211	* @param stmt Statement to execute before break in case of a failed assertion.
2212	* @remark rc is referenced multiple times.
2213	*/
2214	#define AssertLogRelMsgRCReturnStmt(rc, msg, rcRet, stmt) AssertLogRelMsgReturnStmt(RT_SUCCESS_NP(rc), msg, rcRet, stmt)
2215
2216	/** @def AssertLogRelMsgRCReturnVoid
2217	* Asserts a iprt status code successful.
2218	*
2219	* @param rc iprt status code.
2220	* @param msg printf argument list (in parenthesis).
2221	* @remark rc is referenced multiple times.
2222	*/
2223	#define AssertLogRelMsgRCReturnVoid(rc, msg) AssertLogRelMsgReturnVoid(RT_SUCCESS_NP(rc), msg)
2224
2225	/** @def AssertLogRelMsgRCBreak
2226	* Asserts a iprt status code successful.
2227	*
2228	* @param rc iprt status code.
2229	* @param msg printf argument list (in parenthesis).
2230	* @remark rc is referenced multiple times.
2231	*/
2232	#define AssertLogRelMsgRCBreak(rc, msg) AssertLogRelMsgBreak(RT_SUCCESS(rc), msg)
2233
2234	/** @def AssertLogRelMsgRCBreakStmt
2235	* Asserts a iprt status code successful, execute \a stmt and break if it isn't.
2236	*
2237	* @param rc iprt status code.
2238	* @param msg printf argument list (in parenthesis).
2239	* @param stmt Statement to execute before break in case of a failed assertion.
2240	* @remark rc is referenced multiple times.
2241	*/
2242	#define AssertLogRelMsgRCBreakStmt(rc, msg, stmt) AssertLogRelMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt)
2243
2244	/** @def AssertLogRelRCSuccess
2245	* Asserts that an iprt status code equals VINF_SUCCESS.
2246	*
2247	* @param rc iprt status code.
2248	* @remark rc is referenced multiple times.
2249	*/
2250	#define AssertLogRelRCSuccess(rc) AssertLogRelMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2251
2252	/** @def AssertLogRelRCSuccessReturn
2253	* Asserts that an iprt status code equals VINF_SUCCESS.
2254	*
2255	* @param rc iprt status code.
2256	* @param rcRet What is to be presented to return.
2257	* @remark rc is referenced multiple times.
2258	*/
2259	#define AssertLogRelRCSuccessReturn(rc, rcRet) AssertLogRelMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
2260
2261	/** @def AssertLogRelRCSuccessReturnVoid
2262	* Asserts that an iprt status code equals VINF_SUCCESS.
2263	*
2264	* @param rc iprt status code.
2265	* @remark rc is referenced multiple times.
2266	*/
2267	#define AssertLogRelRCSuccessReturnVoid(rc) AssertLogRelMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2268
2269	/** @def AssertLogRelRCSuccessBreak
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 AssertLogRelRCSuccessBreak(rc) AssertLogRelMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2276
2277	/** @def AssertLogRelRCSuccessBreakStmt
2278	* Asserts that an iprt status code equals VINF_SUCCESS.
2279	*
2280	* @param rc iprt status code.
2281	* @param stmt Statement to execute before break in case of a failed assertion.
2282	* @remark rc is referenced multiple times.
2283	*/
2284	#define AssertLogRelRCSuccessBreakStmt(rc, stmt) AssertLogRelMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
2285
2286
2287	/** @def AssertReleaseRC
2288	* Asserts a iprt status code successful.
2289	*
2290	* On failure information about the error will be printed and a breakpoint hit.
2291	*
2292	* @param rc iprt status code.
2293	* @remark rc is referenced multiple times.
2294	*/
2295	#define AssertReleaseRC(rc) AssertReleaseMsgRC(rc, ("%Rra\n", (rc)))
2296
2297	/** @def AssertReleaseRCReturn
2298	* Asserts a iprt status code successful, returning if it isn't.
2299	*
2300	* On failure information about the error will be printed, a breakpoint hit
2301	* and finally returning from the function if the breakpoint is somehow ignored.
2302	*
2303	* @param rc iprt status code.
2304	* @param rcRet What is to be presented to return.
2305	* @remark rc is referenced multiple times.
2306	*/
2307	#define AssertReleaseRCReturn(rc, rcRet) AssertReleaseMsgRCReturn(rc, ("%Rra\n", (rc)), rcRet)
2308
2309	/** @def AssertReleaseRCReturnVoid
2310	* Asserts a iprt status code successful, returning if it isn't.
2311	*
2312	* On failure information about the error will be printed, a breakpoint hit
2313	* and finally returning from the function if the breakpoint is somehow ignored.
2314	*
2315	* @param rc iprt status code.
2316	* @remark rc is referenced multiple times.
2317	*/
2318	#define AssertReleaseRCReturnVoid(rc) AssertReleaseMsgRCReturnVoid(rc, ("%Rra\n", (rc)))
2319
2320	/** @def AssertReleaseRCBreak
2321	* Asserts a iprt status code successful, breaking if it isn't.
2322	*
2323	* On failure information about the error will be printed, a breakpoint hit
2324	* and finally breaking the current statement if the breakpoint is somehow ignored.
2325	*
2326	* @param rc iprt status code.
2327	* @remark rc is referenced multiple times.
2328	*/
2329	#define AssertReleaseRCBreak(rc) AssertReleaseMsgRCBreak(rc, ("%Rra\n", (rc)))
2330
2331	/** @def AssertReleaseRCBreakStmt
2332	* Asserts a iprt status code successful, break if it isn't.
2333	*
2334	* On failure information about the error will be printed, a breakpoint hit
2335	* and finally the break statement will be issued if the breakpoint is somehow ignored.
2336	*
2337	* @param rc iprt status code.
2338	* @param stmt Statement to execute before break in case of a failed assertion.
2339	* @remark rc is referenced multiple times.
2340	*/
2341	#define AssertReleaseRCBreakStmt(rc, stmt) AssertReleaseMsgRCBreakStmt(rc, ("%Rra\n", (rc)), stmt)
2342
2343	/** @def AssertReleaseMsgRC
2344	* Asserts a iprt status code successful.
2345	*
2346	* On failure a custom message is printed and a breakpoint is hit.
2347	*
2348	* @param rc iprt status code.
2349	* @param msg printf argument list (in parenthesis).
2350	* @remark rc is referenced multiple times.
2351	*/
2352	#define AssertReleaseMsgRC(rc, msg) AssertReleaseMsg(RT_SUCCESS_NP(rc), msg)
2353
2354	/** @def AssertReleaseMsgRCReturn
2355	* Asserts a iprt status code successful.
2356	*
2357	* On failure a custom message is printed, a breakpoint is hit, and finally
2358	* returning from the function if the breakpoint is somehow ignored.
2359	*
2360	* @param rc iprt status code.
2361	* @param msg printf argument list (in parenthesis).
2362	* @param rcRet What is to be presented to return.
2363	* @remark rc is referenced multiple times.
2364	*/
2365	#define AssertReleaseMsgRCReturn(rc, msg, rcRet) AssertReleaseMsgReturn(RT_SUCCESS_NP(rc), msg, rcRet)
2366
2367	/** @def AssertReleaseMsgRCReturnVoid
2368	* Asserts a iprt status code successful.
2369	*
2370	* On failure a custom message is printed, a breakpoint is hit, and finally
2371	* returning from the function if the breakpoint is somehow ignored.
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 AssertReleaseMsgRCReturnVoid(rc, msg) AssertReleaseMsgReturnVoid(RT_SUCCESS_NP(rc), msg)
2378
2379	/** @def AssertReleaseMsgRCBreak
2380	* Asserts a iprt status code successful.
2381	*
2382	* On failure a custom message is printed, a breakpoint is hit, and finally
2383	* breaking the current status if the breakpoint is somehow ignored.
2384	*
2385	* @param rc iprt status code.
2386	* @param msg printf argument list (in parenthesis).
2387	* @remark rc is referenced multiple times.
2388	*/
2389	#define AssertReleaseMsgRCBreak(rc, msg) AssertReleaseMsgBreak(RT_SUCCESS(rc), msg)
2390
2391	/** @def AssertReleaseMsgRCBreakStmt
2392	* Asserts a iprt status code successful.
2393	*
2394	* On failure a custom message is printed, a breakpoint is hit, and finally
2395	* the break statement is issued if the breakpoint is somehow ignored.
2396	*
2397	* @param rc iprt status code.
2398	* @param msg printf argument list (in parenthesis).
2399	* @param stmt Statement to execute before break in case of a failed assertion.
2400	* @remark rc is referenced multiple times.
2401	*/
2402	#define AssertReleaseMsgRCBreakStmt(rc, msg, stmt) AssertReleaseMsgBreakStmt(RT_SUCCESS_NP(rc), msg, stmt)
2403
2404	/** @def AssertReleaseRCSuccess
2405	* Asserts that an iprt status code equals VINF_SUCCESS.
2406	*
2407	* On failure information about the error will be printed and a breakpoint hit.
2408	*
2409	* @param rc iprt status code.
2410	* @remark rc is referenced multiple times.
2411	*/
2412	#define AssertReleaseRCSuccess(rc) AssertReleaseMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2413
2414	/** @def AssertReleaseRCSuccessReturn
2415	* Asserts that an iprt status code equals VINF_SUCCESS.
2416	*
2417	* On failure information about the error will be printed, a breakpoint hit
2418	* and finally returning from the function if the breakpoint is somehow ignored.
2419	*
2420	* @param rc iprt status code.
2421	* @param rcRet What is to be presented to return.
2422	* @remark rc is referenced multiple times.
2423	*/
2424	#define AssertReleaseRCSuccessReturn(rc, rcRet) AssertReleaseMsgReturn((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), rcRet)
2425
2426	/** @def AssertReleaseRCSuccessReturnVoid
2427	* Asserts that an iprt status code equals VINF_SUCCESS.
2428	*
2429	* On failure information about the error will be printed, a breakpoint hit
2430	* and finally returning from the function if the breakpoint is somehow ignored.
2431	*
2432	* @param rc iprt status code.
2433	* @remark rc is referenced multiple times.
2434	*/
2435	#define AssertReleaseRCSuccessReturnVoid(rc) AssertReleaseMsgReturnVoid((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2436
2437	/** @def AssertReleaseRCSuccessBreak
2438	* Asserts that an iprt status code equals VINF_SUCCESS.
2439	*
2440	* On failure information about the error will be printed, a breakpoint hit
2441	* and finally breaking the current statement if the breakpoint is somehow ignored.
2442	*
2443	* @param rc iprt status code.
2444	* @remark rc is referenced multiple times.
2445	*/
2446	#define AssertReleaseRCSuccessBreak(rc) AssertReleaseMsgBreak((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2447
2448	/** @def AssertReleaseRCSuccessBreakStmt
2449	* Asserts that an iprt status code equals VINF_SUCCESS.
2450	*
2451	* On failure information about the error will be printed, a breakpoint hit
2452	* and finally the break statement will be issued if the breakpoint is somehow ignored.
2453	*
2454	* @param rc iprt status code.
2455	* @param stmt Statement to execute before break in case of a failed assertion.
2456	* @remark rc is referenced multiple times.
2457	*/
2458	#define AssertReleaseRCSuccessBreakStmt(rc, stmt) AssertReleaseMsgBreakStmt((rc) == VINF_SUCCESS, ("%Rra\n", (rc)), stmt)
2459
2460
2461	/** @def AssertFatalRC
2462	* Asserts a iprt status code successful.
2463	*
2464	* On failure information about the error will be printed and a breakpoint hit.
2465	*
2466	* @param rc iprt status code.
2467	* @remark rc is referenced multiple times.
2468	*/
2469	#define AssertFatalRC(rc) AssertFatalMsgRC(rc, ("%Rra\n", (rc)))
2470
2471	/** @def AssertReleaseMsgRC
2472	* Asserts a iprt status code successful.
2473	*
2474	* On failure a custom message is printed and a breakpoint is hit.
2475	*
2476	* @param rc iprt status code.
2477	* @param msg printf argument list (in parenthesis).
2478	* @remark rc is referenced multiple times.
2479	*/
2480	#define AssertFatalMsgRC(rc, msg) AssertFatalMsg(RT_SUCCESS_NP(rc), msg)
2481
2482	/** @def AssertFatalRCSuccess
2483	* Asserts that an iprt status code equals VINF_SUCCESS.
2484	*
2485	* On failure information about the error will be printed and a breakpoint hit.
2486	*
2487	* @param rc iprt status code.
2488	* @remark rc is referenced multiple times.
2489	*/
2490	#define AssertFatalRCSuccess(rc) AssertFatalMsg((rc) == VINF_SUCCESS, ("%Rra\n", (rc)))
2491
2492
2493	/** @def AssertPtr
2494	* Asserts that a pointer is valid.
2495	*
2496	* @param pv The pointer.
2497	*/
2498	#define AssertPtr(pv) AssertMsg(VALID_PTR(pv), ("%p\n", (pv)))
2499
2500	/** @def AssertPtrReturn
2501	* Asserts that a pointer is valid.
2502	*
2503	* @param pv The pointer.
2504	* @param rcRet What is to be presented to return.
2505	*/
2506	#define AssertPtrReturn(pv, rcRet) AssertMsgReturn(VALID_PTR(pv), ("%p\n", (pv)), rcRet)
2507
2508	/** @def AssertPtrReturnVoid
2509	* Asserts that a pointer is valid.
2510	*
2511	* @param pv The pointer.
2512	*/
2513	#define AssertPtrReturnVoid(pv) AssertMsgReturnVoid(VALID_PTR(pv), ("%p\n", (pv)))
2514
2515	/** @def AssertPtrBreak
2516	* Asserts that a pointer is valid.
2517	*
2518	* @param pv The pointer.
2519	*/
2520	#define AssertPtrBreak(pv) AssertMsgBreak(VALID_PTR(pv), ("%p\n", (pv)))
2521
2522	/** @def AssertPtrBreakStmt
2523	* Asserts that a pointer is valid.
2524	*
2525	* @param pv The pointer.
2526	* @param stmt Statement to execute before break in case of a failed assertion.
2527	*/
2528	#define AssertPtrBreakStmt(pv, stmt) AssertMsgBreakStmt(VALID_PTR(pv), ("%p\n", (pv)), stmt)
2529
2530	/** @def AssertPtrNull
2531	* Asserts that a pointer is valid or NULL.
2532	*
2533	* @param pv The pointer.
2534	*/
2535	#define AssertPtrNull(pv) AssertMsg(VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)))
2536
2537	/** @def AssertPtrNullReturn
2538	* Asserts that a pointer is valid or NULL.
2539	*
2540	* @param pv The pointer.
2541	* @param rcRet What is to be presented to return.
2542	*/
2543	#define AssertPtrNullReturn(pv, rcRet) AssertMsgReturn(VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)), rcRet)
2544
2545	/** @def AssertPtrNullReturnVoid
2546	* Asserts that a pointer is valid or NULL.
2547	*
2548	* @param pv The pointer.
2549	*/
2550	#define AssertPtrNullReturnVoid(pv) AssertMsgReturnVoid(VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)))
2551
2552	/** @def AssertPtrNullBreak
2553	* Asserts that a pointer is valid or NULL.
2554	*
2555	* @param pv The pointer.
2556	*/
2557	#define AssertPtrNullBreak(pv) AssertMsgBreak(VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)))
2558
2559	/** @def AssertPtrNullBreakStmt
2560	* Asserts that a pointer is valid or NULL.
2561	*
2562	* @param pv The pointer.
2563	* @param stmt Statement to execute before break in case of a failed assertion.
2564	*/
2565	#define AssertPtrNullBreakStmt(pv, stmt) AssertMsgBreakStmt(VALID_PTR(pv) \|\| (pv) == NULL, ("%p\n", (pv)), stmt)
2566
2567	/** @def AssertGCPhys32
2568	* Asserts that the high dword of a physical address is zero
2569	*
2570	* @param GCPhys The address (RTGCPHYS).
2571	*/
2572	#define AssertGCPhys32(GCPhys) AssertMsg(VALID_PHYS32(GCPhys), ("%RGp\n", (RTGCPHYS)(GCPhys)))
2573
2574	/** @def AssertGCPtr32
2575	* Asserts that the high dword of a physical address is zero
2576	*
2577	* @param GCPtr The address (RTGCPTR).
2578	*/
2579	#if GC_ARCH_BITS == 32
2580	# define AssertGCPtr32(GCPtr) do { } while (0)
2581	#else
2582	# define AssertGCPtr32(GCPtr) AssertMsg(!((GCPtr) & UINT64_C(0xffffffff00000000)), ("%RGv\n", GCPtr))
2583	#endif
2584
2585	/** @def AssertForEach
2586	* Equivalent to Assert for each value of the variable from the starting
2587	* value to the finishing one.
2588	*
2589	* @param var Name of the counter variable.
2590	* @param vartype Type of the counter variable.
2591	* @param first Lowest inclusive value of the counter variable.
2592	* This must be free from side effects.
2593	* @param end Highest exclusive value of the counter variable.
2594	* This must be free from side effects.
2595	* @param expr Expression which should be true for each value of @a var.
2596	*/
2597	#define AssertForEach(var, vartype, first, end, expr) \
2598	do { \
2599	vartype var; \
2600	Assert((first) == (first) && (end) == (end)); /* partial check for side effects */ \
2601	for (var = (first); var < (end); var++) \
2602	AssertMsg(expr, ("%s = %#RX64 (%RI64)", #var, (uint64_t)var, (int64_t)var)); \
2603	} while (0)
2604
2605	/** @} */
2606
2607	/** @} */
2608
2609	#endif
2610

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

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

Download in other formats: