cdefs.h@ 22650

Last change on this file since 22650 was 21398, checked in by vboxsync, 15 years ago
iprt/cdefs.h: cosmetics.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 59.9 KB

Line
1	/** @file
2	* IPRT - Common C and C++ definitions.
3	*/
4
5	/*
6	* Copyright (C) 2006-2009 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
26	* Clara, CA 95054 USA or visit http://www.sun.com if you need
27	* additional information or have any questions.
28	*/
29
30	#ifndef ___iprt_cdefs_h
31	#define ___iprt_cdefs_h
32
33
34	/** @defgroup grp_rt_cdefs IPRT Common Definitions and Macros
35	* @{
36	*/
37
38	/*
39	* Include sys/cdefs.h if present, if not define the stuff we need.
40	*/
41	#ifdef HAVE_SYS_CDEFS_H
42	# if defined(RT_ARCH_LINUX) && defined(__KERNEL__)
43	# error "oops"
44	# endif
45	# include <sys/cdefs.h>
46	#else
47
48	/** @def RT_C_DECLS_BEGIN
49	* Used to start a block of function declarations which are shared
50	* between C and C++ program.
51	*/
52
53	/** @def RT_C_DECLS_END
54	* Used to end a block of function declarations which are shared
55	* between C and C++ program.
56	*/
57
58	# if defined(__cplusplus)
59	# define RT_C_DECLS_BEGIN extern "C" {
60	# define RT_C_DECLS_END }
61	# else
62	# define RT_C_DECLS_BEGIN
63	# define RT_C_DECLS_END
64	# endif
65
66	#endif
67
68
69	/*
70	* Shut up DOXYGEN warnings and guide it properly thru the code.
71	*/
72	#ifdef DOXYGEN_RUNNING
73	#define __AMD64__
74	#define __X86__
75	#define RT_ARCH_AMD64
76	#define RT_ARCH_X86
77	#define IN_RING0
78	#define IN_RING3
79	#define IN_RC
80	#define IN_RC
81	#define IN_RT_GC
82	#define IN_RT_R0
83	#define IN_RT_R3
84	#define IN_RT_STATIC
85	#define RT_STRICT
86	#define Breakpoint
87	#define RT_NO_DEPRECATED_MACROS
88	#define RT_EXCEPTIONS_ENABLED
89	#endif /* DOXYGEN_RUNNING */
90
91	/** @def RT_ARCH_X86
92	* Indicates that we're compiling for the X86 architecture.
93	*/
94
95	/** @def RT_ARCH_AMD64
96	* Indicates that we're compiling for the AMD64 architecture.
97	*/
98	#if !defined(RT_ARCH_X86) && !defined(RT_ARCH_AMD64)
99	# if defined(__amd64__) \|\| defined(__x86_64__) \|\| defined(_M_X64) \|\| defined(__AMD64__)
100	# define RT_ARCH_AMD64
101	# elif defined(__i386__) \|\| defined(_M_IX86) \|\| defined(__X86__)
102	# define RT_ARCH_X86
103	# else /* PORTME: append test for new archs. */
104	# error "Check what predefined macros your compiler uses to indicate architecture."
105	# endif
106	#elif defined(RT_ARCH_X86) && defined(RT_ARCH_AMD64) /* PORTME: append new archs. */
107	# error "Both RT_ARCH_X86 and RT_ARCH_AMD64 cannot be defined at the same time!"
108	#endif
109
110
111	/** @def __X86__
112	* Indicates that we're compiling for the X86 architecture.
113	* @deprecated
114	*/
115
116	/** @def __AMD64__
117	* Indicates that we're compiling for the AMD64 architecture.
118	* @deprecated
119	*/
120	#if !defined(__X86__) && !defined(__AMD64__)
121	# if defined(RT_ARCH_AMD64)
122	# define __AMD64__
123	# elif defined(RT_ARCH_X86)
124	# define __X86__
125	# else
126	# error "Check what predefined macros your compiler uses to indicate architecture."
127	# endif
128	#elif defined(__X86__) && defined(__AMD64__)
129	# error "Both __X86__ and __AMD64__ cannot be defined at the same time!"
130	#elif defined(__X86__) && !defined(RT_ARCH_X86)
131	# error "Both __X86__ without RT_ARCH_X86!"
132	#elif defined(__AMD64__) && !defined(RT_ARCH_AMD64)
133	# error "Both __AMD64__ without RT_ARCH_AMD64!"
134	#endif
135
136	/** @def IN_RING0
137	* Used to indicate that we're compiling code which is running
138	* in Ring-0 Host Context.
139	*/
140
141	/** @def IN_RING3
142	* Used to indicate that we're compiling code which is running
143	* in Ring-3 Host Context.
144	*/
145
146	/** @def IN_RC
147	* Used to indicate that we're compiling code which is running
148	* in the Raw-mode Context (implies R0).
149	*/
150	#if !defined(IN_RING3) && !defined(IN_RING0) && !defined(IN_RC) && !defined(IN_RC)
151	# error "You must define which context the compiled code should run in; IN_RING3, IN_RING0 or IN_RC"
152	#endif
153	#if (defined(IN_RING3) && (defined(IN_RING0) \|\| defined(IN_RC)) ) \
154	\|\| (defined(IN_RING0) && (defined(IN_RING3) \|\| defined(IN_RC)) ) \
155	\|\| (defined(IN_RC) && (defined(IN_RING3) \|\| defined(IN_RING0)) )
156	# error "Only one of the IN_RING3, IN_RING0, IN_RC defines should be defined."
157	#endif
158
159
160	/** @def ARCH_BITS
161	* Defines the bit count of the current context.
162	*/
163	#if !defined(ARCH_BITS) \|\| defined(DOXYGEN_RUNNING)
164	# if defined(RT_ARCH_AMD64)
165	# define ARCH_BITS 64
166	# else
167	# define ARCH_BITS 32
168	# endif
169	#endif
170
171	/** @def HC_ARCH_BITS
172	* Defines the host architecture bit count.
173	*/
174	#if !defined(HC_ARCH_BITS) \|\| defined(DOXYGEN_RUNNING)
175	# ifndef IN_RC
176	# define HC_ARCH_BITS ARCH_BITS
177	# else
178	# define HC_ARCH_BITS 32
179	# endif
180	#endif
181
182	/** @def GC_ARCH_BITS
183	* Defines the guest architecture bit count.
184	*/
185	#if !defined(GC_ARCH_BITS) && !defined(DOXYGEN_RUNNING)
186	# ifdef VBOX_WITH_64_BITS_GUESTS
187	# define GC_ARCH_BITS 64
188	# else
189	# define GC_ARCH_BITS 32
190	# endif
191	#endif
192
193	/** @def R3_ARCH_BITS
194	* Defines the host ring-3 architecture bit count.
195	*/
196	#if !defined(R3_ARCH_BITS) \|\| defined(DOXYGEN_RUNNING)
197	# ifdef IN_RING3
198	# define R3_ARCH_BITS ARCH_BITS
199	# else
200	# define R3_ARCH_BITS HC_ARCH_BITS
201	# endif
202	#endif
203
204	/** @def R0_ARCH_BITS
205	* Defines the host ring-0 architecture bit count.
206	*/
207	#if !defined(R0_ARCH_BITS) \|\| defined(DOXYGEN_RUNNING)
208	# ifdef IN_RING0
209	# define R0_ARCH_BITS ARCH_BITS
210	# else
211	# define R0_ARCH_BITS HC_ARCH_BITS
212	# endif
213	#endif
214
215	/** @def GC_ARCH_BITS
216	* Defines the guest architecture bit count.
217	*/
218	#if !defined(GC_ARCH_BITS) \|\| defined(DOXYGEN_RUNNING)
219	# ifdef IN_RC
220	# define GC_ARCH_BITS ARCH_BITS
221	# else
222	# define GC_ARCH_BITS 32
223	# endif
224	#endif
225
226
227	/** @def CTXTYPE
228	* Declare a type differently in GC, R3 and R0.
229	*
230	* @param GCType The GC type.
231	* @param R3Type The R3 type.
232	* @param R0Type The R0 type.
233	* @remark For pointers used only in one context use RCPTRTYPE(), R3R0PTRTYPE(), R3PTRTYPE() or R0PTRTYPE().
234	*/
235	#ifdef IN_RC
236	# define CTXTYPE(GCType, R3Type, R0Type) GCType
237	#elif defined(IN_RING3)
238	# define CTXTYPE(GCType, R3Type, R0Type) R3Type
239	#else
240	# define CTXTYPE(GCType, R3Type, R0Type) R0Type
241	#endif
242
243	/** @def RCPTRTYPE
244	* Declare a pointer which is used in the raw mode context but appears in structure(s) used by
245	* both HC and RC. The main purpose is to make sure structures have the same
246	* size when built for different architectures.
247	*
248	* @param RCType The RC type.
249	*/
250	#define RCPTRTYPE(RCType) CTXTYPE(RCType, RTRCPTR, RTRCPTR)
251
252	/** @def R3R0PTRTYPE
253	* Declare a pointer which is used in HC, is explicitly valid in ring 3 and 0,
254	* but appears in structure(s) used by both HC and GC. The main purpose is to
255	* make sure structures have the same size when built for different architectures.
256	*
257	* @param R3R0Type The R3R0 type.
258	* @remarks This used to be called HCPTRTYPE.
259	*/
260	#define R3R0PTRTYPE(R3R0Type) CTXTYPE(RTHCPTR, R3R0Type, R3R0Type)
261
262	/** @def R3PTRTYPE
263	* Declare a pointer which is used in R3 but appears in structure(s) used by
264	* both HC and GC. The main purpose is to make sure structures have the same
265	* size when built for different architectures.
266	*
267	* @param R3Type The R3 type.
268	*/
269	#define R3PTRTYPE(R3Type) CTXTYPE(RTHCUINTPTR, R3Type, RTHCUINTPTR)
270
271	/** @def R0PTRTYPE
272	* Declare a pointer which is used in R0 but appears in structure(s) used by
273	* both HC and GC. The main purpose is to make sure structures have the same
274	* size when built for different architectures.
275	*
276	* @param R0Type The R0 type.
277	*/
278	#define R0PTRTYPE(R0Type) CTXTYPE(RTHCUINTPTR, RTHCUINTPTR, R0Type)
279
280	/** @def CTXSUFF
281	* Adds the suffix of the current context to the passed in
282	* identifier name. The suffix is HC or GC.
283	*
284	* This is macro should only be used in shared code to avoid a forest of ifdefs.
285	* @param var Identifier name.
286	* @deprecated Use CTX_SUFF. Do NOT use this for new code.
287	*/
288	/** @def OTHERCTXSUFF
289	* Adds the suffix of the other context to the passed in
290	* identifier name. The suffix is HC or GC.
291	*
292	* This is macro should only be used in shared code to avoid a forest of ifdefs.
293	* @param var Identifier name.
294	* @deprecated Use CTX_SUFF. Do NOT use this for new code.
295	*/
296	#ifdef IN_RC
297	# define CTXSUFF(var) var##GC
298	# define OTHERCTXSUFF(var) var##HC
299	#else
300	# define CTXSUFF(var) var##HC
301	# define OTHERCTXSUFF(var) var##GC
302	#endif
303
304	/** @def CTXALLSUFF
305	* Adds the suffix of the current context to the passed in
306	* identifier name. The suffix is R3, R0 or GC.
307	*
308	* This is macro should only be used in shared code to avoid a forest of ifdefs.
309	* @param var Identifier name.
310	* @deprecated Use CTX_SUFF. Do NOT use this for new code.
311	*/
312	#ifdef IN_RC
313	# define CTXALLSUFF(var) var##GC
314	#elif defined(IN_RING0)
315	# define CTXALLSUFF(var) var##R0
316	#else
317	# define CTXALLSUFF(var) var##R3
318	#endif
319
320	/** @def CTX_SUFF
321	* Adds the suffix of the current context to the passed in
322	* identifier name. The suffix is R3, R0 or RC.
323	*
324	* This is macro should only be used in shared code to avoid a forest of ifdefs.
325	* @param var Identifier name.
326	*
327	* @remark This will replace CTXALLSUFF and CTXSUFF before long.
328	*/
329	#ifdef IN_RC
330	# define CTX_SUFF(var) var##RC
331	#elif defined(IN_RING0)
332	# define CTX_SUFF(var) var##R0
333	#else
334	# define CTX_SUFF(var) var##R3
335	#endif
336
337	/** @def CTX_SUFF_Z
338	* Adds the suffix of the current context to the passed in
339	* identifier name, combining RC and R0 into RZ.
340	* The suffix thus is R3 or RZ.
341	*
342	* This is macro should only be used in shared code to avoid a forest of ifdefs.
343	* @param var Identifier name.
344	*
345	* @remark This will replace CTXALLSUFF and CTXSUFF before long.
346	*/
347	#ifdef IN_RING3
348	# define CTX_SUFF_Z(var) var##R3
349	#else
350	# define CTX_SUFF_Z(var) var##RZ
351	#endif
352
353
354	/** @def CTXMID
355	* Adds the current context as a middle name of an identifier name
356	* The middle name is HC or GC.
357	*
358	* This is macro should only be used in shared code to avoid a forest of ifdefs.
359	* @param first First name.
360	* @param last Surname.
361	*/
362	/** @def OTHERCTXMID
363	* Adds the other context as a middle name of an identifier name
364	* The middle name is HC or GC.
365	*
366	* This is macro should only be used in shared code to avoid a forest of ifdefs.
367	* @param first First name.
368	* @param last Surname.
369	* @deprecated use CTX_MID or CTX_MID_Z
370	*/
371	#ifdef IN_RC
372	# define CTXMID(first, last) first##GC##last
373	# define OTHERCTXMID(first, last) first##HC##last
374	#else
375	# define CTXMID(first, last) first##HC##last
376	# define OTHERCTXMID(first, last) first##GC##last
377	#endif
378
379	/** @def CTXALLMID
380	* Adds the current context as a middle name of an identifier name.
381	* The middle name is R3, R0 or GC.
382	*
383	* This is macro should only be used in shared code to avoid a forest of ifdefs.
384	* @param first First name.
385	* @param last Surname.
386	* @deprecated use CTX_MID or CTX_MID_Z
387	*/
388	#ifdef IN_RC
389	# define CTXALLMID(first, last) first##GC##last
390	#elif defined(IN_RING0)
391	# define CTXALLMID(first, last) first##R0##last
392	#else
393	# define CTXALLMID(first, last) first##R3##last
394	#endif
395
396	/** @def CTX_MID
397	* Adds the current context as a middle name of an identifier name.
398	* The middle name is R3, R0 or RC.
399	*
400	* This is macro should only be used in shared code to avoid a forest of ifdefs.
401	* @param first First name.
402	* @param last Surname.
403	*/
404	#ifdef IN_RC
405	# define CTX_MID(first, last) first##RC##last
406	#elif defined(IN_RING0)
407	# define CTX_MID(first, last) first##R0##last
408	#else
409	# define CTX_MID(first, last) first##R3##last
410	#endif
411
412	/** @def CTX_MID_Z
413	* Adds the current context as a middle name of an identifier name, combining RC
414	* and R0 into RZ.
415	* The middle name thus is either R3 or RZ.
416	*
417	* This is macro should only be used in shared code to avoid a forest of ifdefs.
418	* @param first First name.
419	* @param last Surname.
420	*/
421	#ifdef IN_RING3
422	# define CTX_MID_Z(first, last) first##R3##last
423	#else
424	# define CTX_MID_Z(first, last) first##RZ##last
425	#endif
426
427
428	/** @def R3STRING
429	* A macro which in GC and R0 will return a dummy string while in R3 it will return
430	* the parameter.
431	*
432	* This is typically used to wrap description strings in structures shared
433	* between R3, R0 and/or GC. The intention is to avoid the \#ifdef IN_RING3 mess.
434	*
435	* @param pR3String The R3 string. Only referenced in R3.
436	* @see R0STRING and GCSTRING
437	*/
438	#ifdef IN_RING3
439	# define R3STRING(pR3String) (pR3String)
440	#else
441	# define R3STRING(pR3String) ("<R3_STRING>")
442	#endif
443
444	/** @def R0STRING
445	* A macro which in GC and R3 will return a dummy string while in R0 it will return
446	* the parameter.
447	*
448	* This is typically used to wrap description strings in structures shared
449	* between R3, R0 and/or GC. The intention is to avoid the \#ifdef IN_RING0 mess.
450	*
451	* @param pR0String The R0 string. Only referenced in R0.
452	* @see R3STRING and GCSTRING
453	*/
454	#ifdef IN_RING0
455	# define R0STRING(pR0String) (pR0String)
456	#else
457	# define R0STRING(pR0String) ("<R0_STRING>")
458	#endif
459
460	/** @def RCSTRING
461	* A macro which in R3 and R0 will return a dummy string while in RC it will return
462	* the parameter.
463	*
464	* This is typically used to wrap description strings in structures shared
465	* between R3, R0 and/or RC. The intention is to avoid the \#ifdef IN_RC mess.
466	*
467	* @param pR0String The RC string. Only referenced in RC.
468	* @see R3STRING, R0STRING
469	*/
470	#ifdef IN_RC
471	# define RCSTRING(pRCString) (pRCString)
472	#else
473	# define RCSTRING(pRCString) ("<RC_STRING>")
474	#endif
475
476
477	/** @def RT_NOTHING
478	* A macro that expands to nothing.
479	* This is primarily intended as a dummy argument for macros to avoid the
480	* undefined behavior passing empty arguments to an macro (ISO C90 and C++98,
481	* gcc v4.4 warns about it).
482	*/
483	#define RT_NOTHING
484
485	/** @def RT_EXCEPTIONS_ENABLED
486	* Defined when C++ exceptions are enabled.
487	*/
488	#if !defined(RT_EXCEPTIONS_ENABLED) \
489	&& defined(__cplusplus) \
490	&& ( (defined(_MSC_VER) && defined(_CPPUNWIND)) \
491	\|\| (defined(__GNUC__) && defined(__EXCEPTIONS)))
492	# define RT_EXCEPTIONS_ENABLED
493	#endif
494
495	/** @def RT_NO_THROW
496	* How to express that a function doesn't throw C++ exceptions
497	* and the compiler can thus save itself the bother of trying
498	* to catch any of them. Put this between the closing parenthesis
499	* and the semicolon in function prototypes (and implementation if C++).
500	*/
501	#ifdef RT_EXCEPTIONS_ENABLED
502	# define RT_NO_THROW throw()
503	#else
504	# define RT_NO_THROW
505	#endif
506
507	/** @def RT_THROW
508	* How to express that a method or function throws a type of exceptions. Some
509	* compilers does not want this kind of information and will warning about it.
510	*
511	* @param type The type exception.
512	*
513	* @remarks If the actual throwing is done from the header, enclose it by
514	* \#ifdef RT_EXCEPTIONS_ENABLED ... \#else ... \#endif so the header
515	* compiles cleanly without exceptions enabled.
516	*
517	* Do NOT use this for the actual throwing of exceptions!
518	*/
519	#ifdef RT_EXCEPTIONS_ENABLED
520	# ifdef _MSC_VER
521	# if _MSC_VER >= 1400
522	# define RT_THROW(type)
523	# else
524	# define RT_THROW(type) throw(type)
525	# endif
526	# else
527	# define RT_THROW(type) throw(type)
528	# endif
529	#else
530	# define RT_THROW(type)
531	#endif
532
533	/** @def RTCALL
534	* The standard calling convention for the Runtime interfaces.
535	*/
536	#ifdef _MSC_VER
537	# define RTCALL __cdecl
538	#elif defined(__GNUC__) && defined(IN_RING0) && !(defined(RT_OS_OS2) \|\| defined(RT_ARCH_AMD64)) /* the latter is kernel/gcc */
539	# define RTCALL __attribute__((cdecl,regparm(0)))
540	#else
541	# define RTCALL
542	#endif
543
544	/** @def DECLEXPORT
545	* How to declare an exported function.
546	* @param type The return type of the function declaration.
547	*/
548	#if defined(_MSC_VER) \|\| defined(RT_OS_OS2)
549	# define DECLEXPORT(type) __declspec(dllexport) type
550	#elif defined(RT_USE_VISIBILITY_DEFAULT)
551	# define DECLEXPORT(type) __attribute__((visibility("default"))) type
552	#else
553	# define DECLEXPORT(type) type
554	#endif
555
556	/** @def DECLIMPORT
557	* How to declare an imported function.
558	* @param type The return type of the function declaration.
559	*/
560	#if defined(_MSC_VER) \|\| (defined(RT_OS_OS2) && !defined(__IBMC__) && !defined(__IBMCPP__))
561	# define DECLIMPORT(type) __declspec(dllimport) type
562	#else
563	# define DECLIMPORT(type) type
564	#endif
565
566	/** @def DECLHIDDEN
567	* How to declare a non-exported function or variable.
568	* @param type The return type of the function or the data type of the variable.
569	*/
570	#if defined(RT_OS_OS2) \|\| defined(RT_OS_WINDOWS) \|\| !defined(RT_USE_VISIBILITY_HIDDEN)
571	# define DECLHIDDEN(type) type
572	#else
573	# define DECLHIDDEN(type) __attribute__((visibility("hidden"))) type
574	#endif
575
576	/** @def DECLASM
577	* How to declare an internal assembly function.
578	* @param type The return type of the function declaration.
579	*/
580	#ifdef __cplusplus
581	# ifdef _MSC_VER
582	# define DECLASM(type) extern "C" type __cdecl
583	# else
584	# define DECLASM(type) extern "C" type
585	# endif
586	#else
587	# ifdef _MSC_VER
588	# define DECLASM(type) type __cdecl
589	# else
590	# define DECLASM(type) type
591	# endif
592	#endif
593
594	/** @def DECLASMTYPE
595	* How to declare an internal assembly function type.
596	* @param type The return type of the function.
597	*/
598	#ifdef _MSC_VER
599	# define DECLASMTYPE(type) type __cdecl
600	#else
601	# define DECLASMTYPE(type) type
602	#endif
603
604	/** @def DECLNORETURN
605	* How to declare a function which does not return.
606	* @note: This macro can be combined with other macros, for example
607	* @code
608	* EMR3DECL(DECLNORETURN(void)) foo(void);
609	* @endcode
610	*/
611	#ifdef _MSC_VER
612	# define DECLNORETURN(type) __declspec(noreturn) type
613	#elif defined(__GNUC__)
614	# define DECLNORETURN(type) __attribute__((noreturn)) type
615	#else
616	# define DECLNORETURN(type) type
617	#endif
618
619	/** @def DECLCALLBACK
620	* How to declare an call back function type.
621	* @param type The return type of the function declaration.
622	*/
623	#define DECLCALLBACK(type) type RTCALL
624
625	/** @def DECLCALLBACKPTR
626	* How to declare an call back function pointer.
627	* @param type The return type of the function declaration.
628	* @param name The name of the variable member.
629	*/
630	#define DECLCALLBACKPTR(type, name) type (RTCALL * name)
631
632	/** @def DECLCALLBACKMEMBER
633	* How to declare an call back function pointer member.
634	* @param type The return type of the function declaration.
635	* @param name The name of the struct/union/class member.
636	*/
637	#define DECLCALLBACKMEMBER(type, name) type (RTCALL * name)
638
639	/** @def DECLR3CALLBACKMEMBER
640	* How to declare an call back function pointer member - R3 Ptr.
641	* @param type The return type of the function declaration.
642	* @param name The name of the struct/union/class member.
643	* @param args The argument list enclosed in parentheses.
644	*/
645	#ifdef IN_RING3
646	# define DECLR3CALLBACKMEMBER(type, name, args) type (RTCALL * name) args
647	#else
648	# define DECLR3CALLBACKMEMBER(type, name, args) RTR3PTR name
649	#endif
650
651	/** @def DECLRCCALLBACKMEMBER
652	* How to declare an call back function pointer member - RC Ptr.
653	* @param type The return type of the function declaration.
654	* @param name The name of the struct/union/class member.
655	* @param args The argument list enclosed in parentheses.
656	*/
657	#ifdef IN_RC
658	# define DECLRCCALLBACKMEMBER(type, name, args) type (RTCALL * name) args
659	#else
660	# define DECLRCCALLBACKMEMBER(type, name, args) RTRCPTR name
661	#endif
662
663	/** @def DECLR0CALLBACKMEMBER
664	* How to declare an call back function pointer member - R0 Ptr.
665	* @param type The return type of the function declaration.
666	* @param name The name of the struct/union/class member.
667	* @param args The argument list enclosed in parentheses.
668	*/
669	#ifdef IN_RING0
670	# define DECLR0CALLBACKMEMBER(type, name, args) type (RTCALL * name) args
671	#else
672	# define DECLR0CALLBACKMEMBER(type, name, args) RTR0PTR name
673	#endif
674
675	/** @def DECLINLINE
676	* How to declare a function as inline.
677	* @param type The return type of the function declaration.
678	* @remarks Don't use this macro on C++ methods.
679	*/
680	#ifdef __GNUC__
681	# define DECLINLINE(type) static __inline__ type
682	#elif defined(__cplusplus)
683	# define DECLINLINE(type) inline type
684	#elif defined(_MSC_VER)
685	# define DECLINLINE(type) _inline type
686	#elif defined(__IBMC__)
687	# define DECLINLINE(type) _Inline type
688	#else
689	# define DECLINLINE(type) inline type
690	#endif
691
692
693	/** @def DECL_FORCE_INLINE
694	* How to declare a function as inline and try convince the compiler to always
695	* inline it regardless of optimization switches.
696	* @param type The return type of the function declaration.
697	* @remarks Use sparsely and with care. Don't use this macro on C++ methods.
698	*/
699	#ifdef __GNUC__
700	# define DECL_FORCE_INLINE(type) __attribute__((always_inline)) DECLINLINE(type)
701	#elif defined(_MSC_VER)
702	# define DECL_FORCE_INLINE(type) __forceinline type
703	#else
704	# define DECL_FORCE_INLINE(type) DECLINLINE(type)
705	#endif
706
707
708	/** @def DECL_NO_INLINE
709	* How to declare a function telling the compiler not to inline it.
710	* @param scope The function scope, static or RT_NOTHING.
711	* @param type The return type of the function declaration.
712	* @remarks Don't use this macro on C++ methods.
713	*/
714	#ifdef __GNUC__
715	# define DECL_NO_INLINE(scope,type) __attribute__((noinline)) scope type
716	#elif defined(_MSC_VER)
717	# define DECL_NO_INLINE(scope,type) __declspec(noline) scope type
718	#else
719	# define DECL_NO_INLINE(scope,type) scope type
720	#endif
721
722
723	/** @def IN_RT_STATIC
724	* Used to indicate whether we're linking against a static IPRT
725	* or not. The IPRT symbols will be declared as hidden (if
726	* supported). Note that this define has no effect without setting
727	* IN_RT_R0, IN_RT_R3 or IN_RT_GC indicators are set first.
728	*/
729
730	/** @def IN_RT_R0
731	* Used to indicate whether we're inside the same link module as
732	* the HC Ring-0 Runtime Library.
733	*/
734	/** @def RTR0DECL(type)
735	* Runtime Library HC Ring-0 export or import declaration.
736	* @param type The return type of the function declaration.
737	*/
738	#ifdef IN_RT_R0
739	# ifdef IN_RT_STATIC
740	# define RTR0DECL(type) DECLHIDDEN(type) RTCALL
741	# else
742	# define RTR0DECL(type) DECLEXPORT(type) RTCALL
743	# endif
744	#else
745	# define RTR0DECL(type) DECLIMPORT(type) RTCALL
746	#endif
747
748	/** @def IN_RT_R3
749	* Used to indicate whether we're inside the same link module as
750	* the HC Ring-3 Runtime Library.
751	*/
752	/** @def RTR3DECL(type)
753	* Runtime Library HC Ring-3 export or import declaration.
754	* @param type The return type of the function declaration.
755	*/
756	#ifdef IN_RT_R3
757	# ifdef IN_RT_STATIC
758	# define RTR3DECL(type) DECLHIDDEN(type) RTCALL
759	# else
760	# define RTR3DECL(type) DECLEXPORT(type) RTCALL
761	# endif
762	#else
763	# define RTR3DECL(type) DECLIMPORT(type) RTCALL
764	#endif
765
766	/** @def IN_RT_GC
767	* Used to indicate whether we're inside the same link module as
768	* the GC Runtime Library.
769	*/
770	/** @def RTGCDECL(type)
771	* Runtime Library HC Ring-3 export or import declaration.
772	* @param type The return type of the function declaration.
773	*/
774	#ifdef IN_RT_GC
775	# ifdef IN_RT_STATIC
776	# define RTGCDECL(type) DECLHIDDEN(type) RTCALL
777	# else
778	# define RTGCDECL(type) DECLEXPORT(type) RTCALL
779	# endif
780	#else
781	# define RTGCDECL(type) DECLIMPORT(type) RTCALL
782	#endif
783
784	/** @def RTDECL(type)
785	* Runtime Library export or import declaration.
786	* Functions declared using this macro exists in all contexts.
787	* @param type The return type of the function declaration.
788	*/
789	#if defined(IN_RT_R3) \|\| defined(IN_RT_GC) \|\| defined(IN_RT_R0)
790	# ifdef IN_RT_STATIC
791	# define RTDECL(type) DECLHIDDEN(type) RTCALL
792	# else
793	# define RTDECL(type) DECLEXPORT(type) RTCALL
794	# endif
795	#else
796	# define RTDECL(type) DECLIMPORT(type) RTCALL
797	#endif
798
799	/** @def RTDATADECL(type)
800	* Runtime Library export or import declaration.
801	* Data declared using this macro exists in all contexts.
802	* @param type The return type of the function declaration.
803	*/
804	#if defined(IN_RT_R3) \|\| defined(IN_RT_GC) \|\| defined(IN_RT_R0)
805	# ifdef IN_RT_STATIC
806	# define RTDATADECL(type) DECLHIDDEN(type)
807	# else
808	# define RTDATADECL(type) DECLEXPORT(type)
809	# endif
810	#else
811	# define RTDATADECL(type) DECLIMPORT(type)
812	#endif
813
814	/** @def RT_DECL_CLASS
815	* Declares an class living in the runtime.
816	*/
817	#if defined(IN_RT_R3) \|\| defined(IN_RT_GC) \|\| defined(IN_RT_R0)
818	# ifdef IN_RT_STATIC
819	# define RT_DECL_CLASS
820	# else
821	# define RT_DECL_CLASS DECLEXPORT_CLASS
822	# endif
823	#else
824	# define RT_DECL_CLASS DECLIMPORT_CLASS
825	#endif
826
827
828	/** @def RT_NOCRT
829	* Symbol name wrapper for the No-CRT bits.
830	*
831	* In order to coexist in the same process as other CRTs, we need to
832	* decorate the symbols such that they don't conflict the ones in the
833	* other CRTs. The result of such conflicts / duplicate symbols can
834	* confuse the dynamic loader on Unix like systems.
835	*
836	* Define RT_WITHOUT_NOCRT_WRAPPERS to drop the wrapping.
837	* Define RT_WITHOUT_NOCRT_WRAPPER_ALIASES to drop the aliases to the
838	* wrapped names.
839	*/
840	/** @def RT_NOCRT_STR
841	* Same as RT_NOCRT only it'll return a double quoted string of the result.
842	*/
843	#ifndef RT_WITHOUT_NOCRT_WRAPPERS
844	# define RT_NOCRT(name) nocrt_ ## name
845	# define RT_NOCRT_STR(name) "nocrt_" # name
846	#else
847	# define RT_NOCRT(name) name
848	# define RT_NOCRT_STR(name) #name
849	#endif
850
851
852
853	/** @def RT_LIKELY
854	* Give the compiler a hint that an expression is very likely to hold true.
855	*
856	* Some compilers support explicit branch prediction so that the CPU backend
857	* can hint the processor and also so that code blocks can be reordered such
858	* that the predicted path sees a more linear flow, thus improving cache
859	* behaviour, etc.
860	*
861	* IPRT provides the macros RT_LIKELY() and RT_UNLIKELY() as a way to utilize
862	* this compiler feature when present.
863	*
864	* A few notes about the usage:
865	*
866	* - Generally, use RT_UNLIKELY() with error condition checks (unless you
867	* have some _strong_ reason to do otherwise, in which case document it),
868	* and/or RT_LIKELY() with success condition checks, assuming you want
869	* to optimize for the success path.
870	*
871	* - Other than that, if you don't know the likelihood of a test succeeding
872	* from empirical or other 'hard' evidence, don't make predictions unless
873	* you happen to be a Dirk Gently.
874	*
875	* - These macros are meant to be used in places that get executed a lot. It
876	* is wasteful to make predictions in code that is executed rarely (e.g.
877	* at subsystem initialization time) as the basic block reordering that this
878	* affects can often generate larger code.
879	*
880	* - Note that RT_SUCCESS() and RT_FAILURE() already makes use of RT_LIKELY()
881	* and RT_UNLIKELY(). Should you wish for prediction free status checks,
882	* use the RT_SUCCESS_NP() and RT_FAILURE_NP() macros instead.
883	*
884	*
885	* @returns the boolean result of the expression.
886	* @param expr The expression that's very likely to be true.
887	* @see RT_UNLIKELY
888	*/
889	/** @def RT_UNLIKELY
890	* Give the compiler a hint that an expression is highly unlikely to hold true.
891	*
892	* See the usage instructions give in the RT_LIKELY() docs.
893	*
894	* @returns the boolean result of the expression.
895	* @param expr The expression that's very unlikely to be true.
896	* @see RT_LIKELY
897	*/
898	#if defined(__GNUC__)
899	# if __GNUC__ >= 3
900	# define RT_LIKELY(expr) __builtin_expect(!!(expr), 1)
901	# define RT_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
902	# else
903	# define RT_LIKELY(expr) (expr)
904	# define RT_UNLIKELY(expr) (expr)
905	# endif
906	#else
907	# define RT_LIKELY(expr) (expr)
908	# define RT_UNLIKELY(expr) (expr)
909	#endif
910
911
912	/** @def RT_STR
913	* Returns the argument as a string constant.
914	* @param str Argument to stringify. */
915	#define RT_STR(str) #str
916	/** @def RT_XSTR
917	* Returns the expanded argument as a string.
918	* @param str Argument to expand and stringy. */
919	#define RT_XSTR(str) RT_STR(str)
920
921
922	/** @def RT_BIT
923	* Convert a bit number into an integer bitmask (unsigned).
924	* @param bit The bit number.
925	*/
926	#define RT_BIT(bit) ( 1U << (bit) )
927
928	/** @def RT_BIT_32
929	* Convert a bit number into a 32-bit bitmask (unsigned).
930	* @param bit The bit number.
931	*/
932	#define RT_BIT_32(bit) ( UINT32_C(1) << (bit) )
933
934	/** @def RT_BIT_64
935	* Convert a bit number into a 64-bit bitmask (unsigned).
936	* @param bit The bit number.
937	*/
938	#define RT_BIT_64(bit) ( UINT64_C(1) << (bit) )
939
940	/** @def RT_ALIGN
941	* Align macro.
942	* @param u Value to align.
943	* @param uAlignment The alignment. Power of two!
944	*
945	* @remark Be extremely careful when using this macro with type which sizeof != sizeof int.
946	* When possible use any of the other RT_ALIGN_* macros. And when that's not
947	* possible, make 101% sure that uAlignment is specified with a right sized type.
948	*
949	* Specifying an unsigned 32-bit alignment constant with a 64-bit value will give
950	* you a 32-bit return value!
951	*
952	* In short: Don't use this macro. Use RT_ALIGN_T() instead.
953	*/
954	#define RT_ALIGN(u, uAlignment) ( ((u) + ((uAlignment) - 1)) & ~((uAlignment) - 1) )
955
956	/** @def RT_ALIGN_T
957	* Align macro.
958	* @param u Value to align.
959	* @param uAlignment The alignment. Power of two!
960	* @param type Integer type to use while aligning.
961	* @remark This macro is the preferred alignment macro, it doesn't have any of the pitfalls RT_ALIGN has.
962	*/
963	#define RT_ALIGN_T(u, uAlignment, type) ( ((type)(u) + ((uAlignment) - 1)) & ~(type)((uAlignment) - 1) )
964
965	/** @def RT_ALIGN_32
966	* Align macro for a 32-bit value.
967	* @param u32 Value to align.
968	* @param uAlignment The alignment. Power of two!
969	*/
970	#define RT_ALIGN_32(u32, uAlignment) RT_ALIGN_T(u32, uAlignment, uint32_t)
971
972	/** @def RT_ALIGN_64
973	* Align macro for a 64-bit value.
974	* @param u64 Value to align.
975	* @param uAlignment The alignment. Power of two!
976	*/
977	#define RT_ALIGN_64(u64, uAlignment) RT_ALIGN_T(u64, uAlignment, uint64_t)
978
979	/** @def RT_ALIGN_Z
980	* Align macro for size_t.
981	* @param cb Value to align.
982	* @param uAlignment The alignment. Power of two!
983	*/
984	#define RT_ALIGN_Z(cb, uAlignment) RT_ALIGN_T(cb, uAlignment, size_t)
985
986	/** @def RT_ALIGN_P
987	* Align macro for pointers.
988	* @param pv Value to align.
989	* @param uAlignment The alignment. Power of two!
990	*/
991	#define RT_ALIGN_P(pv, uAlignment) RT_ALIGN_PT(pv, uAlignment, void *)
992
993	/** @def RT_ALIGN_PT
994	* Align macro for pointers with type cast.
995	* @param u Value to align.
996	* @param uAlignment The alignment. Power of two!
997	* @param CastType The type to cast the result to.
998	*/
999	#define RT_ALIGN_PT(u, uAlignment, CastType) ( (CastType)RT_ALIGN_T(u, uAlignment, uintptr_t) )
1000
1001	/** @def RT_ALIGN_R3PT
1002	* Align macro for ring-3 pointers with type cast.
1003	* @param u Value to align.
1004	* @param uAlignment The alignment. Power of two!
1005	* @param CastType The type to cast the result to.
1006	*/
1007	#define RT_ALIGN_R3PT(u, uAlignment, CastType) ( (CastType)RT_ALIGN_T(u, uAlignment, RTR3UINTPTR) )
1008
1009	/** @def RT_ALIGN_R0PT
1010	* Align macro for ring-0 pointers with type cast.
1011	* @param u Value to align.
1012	* @param uAlignment The alignment. Power of two!
1013	* @param CastType The type to cast the result to.
1014	*/
1015	#define RT_ALIGN_R0PT(u, uAlignment, CastType) ( (CastType)RT_ALIGN_T(u, uAlignment, RTR0UINTPTR) )
1016
1017	/** @def RT_ALIGN_GCPT
1018	* Align macro for GC pointers with type cast.
1019	* @param u Value to align.
1020	* @param uAlignment The alignment. Power of two!
1021	* @param CastType The type to cast the result to.
1022	*/
1023	#define RT_ALIGN_GCPT(u, uAlignment, CastType) ( (CastType)RT_ALIGN_T(u, uAlignment, RTGCUINTPTR) )
1024
1025
1026	/** @def RT_OFFSETOF
1027	* Our own special offsetof() variant, returns a signed result.
1028	*
1029	* This differs from the usual offsetof() in that it's not relying on builtin
1030	* compiler stuff and thus can use variables in arrays the structure may
1031	* contain. This is useful to determine the sizes of structures ending
1032	* with a variable length field.
1033	*
1034	* @returns offset into the structure of the specified member. signed.
1035	* @param type Structure type.
1036	* @param member Member.
1037	*/
1038	#define RT_OFFSETOF(type, member) ( (int)(uintptr_t)&( ((type )(void )0)->member) )
1039
1040	/** @def RT_UOFFSETOF
1041	* Our own special offsetof() variant, returns an unsigned result.
1042	*
1043	* This differs from the usual offsetof() in that it's not relying on builtin
1044	* compiler stuff and thus can use variables in arrays the structure may
1045	* contain. This is useful to determine the sizes of structures ending
1046	* with a variable length field.
1047	*
1048	* @returns offset into the structure of the specified member. unsigned.
1049	* @param type Structure type.
1050	* @param member Member.
1051	*/
1052	#define RT_UOFFSETOF(type, member) ( (uintptr_t)&( ((type )(void )0)->member) )
1053
1054	/** @def RT_OFFSETOF_ADD
1055	* RT_OFFSETOF with an addend.
1056	*
1057	* @returns offset into the structure of the specified member. signed.
1058	* @param type Structure type.
1059	* @param member Member.
1060	* @param addend The addend to add to the offset.
1061	*/
1062	#define RT_OFFSETOF_ADD(type, member, addend) ( (int)RT_UOFFSETOF_ADD(type, member, addend) )
1063
1064	/** @def RT_UOFFSETOF_ADD
1065	* RT_UOFFSETOF with an addend.
1066	*
1067	* @returns offset into the structure of the specified member. signed.
1068	* @param type Structure type.
1069	* @param member Member.
1070	* @param addend The addend to add to the offset.
1071	*/
1072	#define RT_UOFFSETOF_ADD(type, member, addend) ( (uintptr_t)&( ((type )(void )(uintptr_t)(addend))->member) )
1073
1074	/** @def RT_SIZEOFMEMB
1075	* Get the size of a structure member.
1076	*
1077	* @returns size of the structure member.
1078	* @param type Structure type.
1079	* @param member Member.
1080	*/
1081	#define RT_SIZEOFMEMB(type, member) ( sizeof(((type )(void )0)->member) )
1082
1083	/** @def RT_FROM_MEMBER
1084	* Convert a pointer to a structure member into a pointer to the structure.
1085	* @returns pointer to the structure.
1086	* @param pMember Pointer to the member.
1087	* @param Type Strucutre type.
1088	* @param Member Member name.
1089	*/
1090	#define RT_FROM_MEMBER(pMem, Type, Member) ( (Type ) ((uint8_t )(void *)(pMem) - RT_UOFFSETOF(Type, Member)) )
1091
1092	/** @def RT_ELEMENTS
1093	* Calculates the number of elements in a statically sized array.
1094	* @returns Element count.
1095	* @param aArray Array in question.
1096	*/
1097	#define RT_ELEMENTS(aArray) ( sizeof(aArray) / sizeof((aArray)[0]) )
1098
1099	#ifdef RT_OS_OS2
1100	/* Undefine RT_MAX since there is an unfortunate clash with the max
1101	resource type define in os2.h. */
1102	# undef RT_MAX
1103	#endif
1104
1105	/** @def RT_MAX
1106	* Finds the maximum value.
1107	* @returns The higher of the two.
1108	* @param Value1 Value 1
1109	* @param Value2 Value 2
1110	*/
1111	#define RT_MAX(Value1, Value2) ( (Value1) >= (Value2) ? (Value1) : (Value2) )
1112
1113	/** @def RT_MIN
1114	* Finds the minimum value.
1115	* @returns The lower of the two.
1116	* @param Value1 Value 1
1117	* @param Value2 Value 2
1118	*/
1119	#define RT_MIN(Value1, Value2) ( (Value1) <= (Value2) ? (Value1) : (Value2) )
1120
1121	/** @def RT_ABS
1122	* Get the absolute (non-negative) value.
1123	* @returns The absolute value of Value.
1124	* @param Value The value.
1125	*/
1126	#define RT_ABS(Value) ( (Value) >= 0 ? (Value) : -(Value) )
1127
1128	/** @def RT_LODWORD
1129	* Gets the low dword (=uint32_t) of something. */
1130	#define RT_LODWORD(a) ( (uint32_t)(a) )
1131
1132	/** @def RT_HIDWORD
1133	* Gets the high dword (=uint32_t) of a 64-bit of something. */
1134	#define RT_HIDWORD(a) ( (uint32_t)((a) >> 32) )
1135
1136	/** @def RT_LOWORD
1137	* Gets the low word (=uint16_t) of something. */
1138	#define RT_LOWORD(a) ( (a) & 0xffff )
1139
1140	/** @def RT_HIWORD
1141	* Gets the high word (=uint16_t) of a 32-bit something. */
1142	#define RT_HIWORD(a) ( (a) >> 16 )
1143
1144	/** @def RT_LOBYTE
1145	* Gets the low byte of something. */
1146	#define RT_LOBYTE(a) ( (a) & 0xff )
1147
1148	/** @def RT_HIBYTE
1149	* Gets the low byte of a 16-bit something. */
1150	#define RT_HIBYTE(a) ( (a) >> 8 )
1151
1152	/** @def RT_BYTE1
1153	* Gets first byte of something. */
1154	#define RT_BYTE1(a) ( (a) & 0xff )
1155
1156	/** @def RT_BYTE2
1157	* Gets second byte of something. */
1158	#define RT_BYTE2(a) ( ((a) >> 8) & 0xff )
1159
1160	/** @def RT_BYTE3
1161	* Gets second byte of something. */
1162	#define RT_BYTE3(a) ( ((a) >> 16) & 0xff )
1163
1164	/** @def RT_BYTE4
1165	* Gets fourth byte of something. */
1166	#define RT_BYTE4(a) ( ((a) >> 24) & 0xff )
1167
1168
1169	/** @def RT_MAKE_U64
1170	* Constructs a uint64_t value from two uint32_t values.
1171	*/
1172	#define RT_MAKE_U64(Lo, Hi) ( (uint64_t)((uint32_t)(Hi)) << 32 \| (uint32_t)(Lo) )
1173
1174	/** @def RT_MAKE_U64_FROM_U16
1175	* Constructs a uint64_t value from four uint16_t values.
1176	*/
1177	#define RT_MAKE_U64_FROM_U16(w0, w1, w2, w3) \
1178	( (uint64_t)((uint16_t)(w3)) << 48 \
1179	\| (uint64_t)((uint16_t)(w2)) << 32 \
1180	\| (uint32_t)((uint16_t)(w1)) << 16 \
1181	\| (uint16_t)(w0) )
1182
1183	/** @def RT_MAKE_U64_FROM_U8
1184	* Constructs a uint64_t value from eight uint8_t values.
1185	*/
1186	#define RT_MAKE_U64_FROM_U8(b0, b1, b2, b3, b4, b5, b6, b7) \
1187	( (uint64_t)((uint8_t)(b7)) << 56 \
1188	\| (uint64_t)((uint8_t)(b6)) << 48 \
1189	\| (uint64_t)((uint8_t)(b5)) << 40 \
1190	\| (uint64_t)((uint8_t)(b4)) << 32 \
1191	\| (uint32_t)((uint8_t)(b3)) << 24 \
1192	\| (uint32_t)((uint8_t)(b2)) << 16 \
1193	\| (uint16_t)((uint8_t)(b1)) << 8 \
1194	\| (uint8_t)(b0) )
1195
1196	/** @def RT_MAKE_U32
1197	* Constructs a uint32_t value from two uint16_t values.
1198	*/
1199	#define RT_MAKE_U32(Lo, Hi) ( (uint32_t)((uint16_t)(Hi)) << 16 \| (uint16_t)(Lo) )
1200
1201	/** @def RT_MAKE_U32_FROM_U8
1202	* Constructs a uint32_t value from four uint8_t values.
1203	*/
1204	#define RT_MAKE_U32_FROM_U8(b0, b1, b2, b3) \
1205	( (uint32_t)((uint8_t)(b3)) << 24 \
1206	\| (uint32_t)((uint8_t)(b2)) << 16 \
1207	\| (uint16_t)((uint8_t)(b1)) << 8 \
1208	\| (uint8_t)(b0) )
1209
1210	/** @def RT_MAKE_U16
1211	* Constructs a uint32_t value from two uint16_t values.
1212	*/
1213	#define RT_MAKE_U16(Lo, Hi) ( (uint16_t)((uint8_t)(Hi)) << 8 \| (uint8_t)(Lo) )
1214
1215
1216	/** @def RT_BSWAP_U64
1217	* Reverses the byte order of an uint64_t value. */
1218	#if 0
1219	# define RT_BSWAP_U64(u64) RT_BSWAP_U64_C(u64)
1220	#elif defined(__GNUC__)
1221	/** @todo use __builtin_constant_p? */
1222	# define RT_BSWAP_U64(u64) ASMByteSwapU64(u64)
1223	#else
1224	# define RT_BSWAP_U64(u64) ASMByteSwapU64(u64)
1225	#endif
1226
1227	/** @def RT_BSWAP_U32
1228	* Reverses the byte order of an uint32_t value. */
1229	#if 0
1230	# define RT_BSWAP_U32(u32) RT_BSWAP_U32_C(u32)
1231	#elif defined(__GNUC__)
1232	/** @todo use __builtin_constant_p? */
1233	# define RT_BSWAP_U32(u32) ASMByteSwapU32(u32)
1234	#else
1235	# define RT_BSWAP_U32(u32) ASMByteSwapU32(u32)
1236	#endif
1237
1238	/** @def RT_BSWAP_U16
1239	* Reverses the byte order of an uint16_t value. */
1240	#if 0
1241	# define RT_BSWAP_U16(u16) RT_BSWAP_U16_C(u16)
1242	#elif defined(__GNUC__)
1243	/** @todo use __builtin_constant_p? */
1244	# define RT_BSWAP_U16(u16) ASMByteSwapU16(u16)
1245	#else
1246	# define RT_BSWAP_U16(u16) ASMByteSwapU16(u16)
1247	#endif
1248
1249
1250	/** @def RT_BSWAP_U64_C
1251	* Reverses the byte order of an uint64_t constant. */
1252	#define RT_BSWAP_U64_C(u64) RT_MAKE_U64(RT_BSWAP_U32_C((u64) >> 32), RT_BSWAP_U32_C((u64) & 0xffffffff))
1253
1254	/** @def RT_BSWAP_U32_C
1255	* Reverses the byte order of an uint32_t constant. */
1256	#define RT_BSWAP_U32_C(u32) (RT_BYTE4(u32) \| (RT_BYTE3(u32) << 8) \| (RT_BYTE2(u32) << 16) \| (RT_BYTE1(u32) << 24))
1257
1258	/** @def RT_BSWAP_U16_C
1259	* Reverses the byte order of an uint16_t constant. */
1260	#define RT_BSWAP_U16_C(u16) (RT_HIBYTE(u16) \| (RT_LOBYTE(u16) << 8))
1261
1262
1263	/** @def RT_H2LE_U64
1264	* Converts an uint64_t value from host to little endian byte order. */
1265	#ifdef RT_BIG_ENDIAN
1266	# define RT_H2LE_U64(u64) RT_BSWAP_U64(u64)
1267	#else
1268	# define RT_H2LE_U64(u64) (u64)
1269	#endif
1270
1271	/** @def RT_H2LE_U64_C
1272	* Converts an uint64_t constant from host to little endian byte order. */
1273	#ifdef RT_BIG_ENDIAN
1274	# define RT_H2LE_U64_C(u64) RT_BSWAP_U64_C(u64)
1275	#else
1276	# define RT_H2LE_U64_C(u64) (u64)
1277	#endif
1278
1279	/** @def RT_H2LE_U32
1280	* Converts an uint32_t value from host to little endian byte order. */
1281	#ifdef RT_BIG_ENDIAN
1282	# define RT_H2LE_U32(u32) RT_BSWAP_U32(u32)
1283	#else
1284	# define RT_H2LE_U32(u32) (u32)
1285	#endif
1286
1287	/** @def RT_H2LE_U32_C
1288	* Converts an uint32_t constant from host to little endian byte order. */
1289	#ifdef RT_BIG_ENDIAN
1290	# define RT_H2LE_U32_C(u32) RT_BSWAP_U32_C(u32)
1291	#else
1292	# define RT_H2LE_U32_C(u32) (u32)
1293	#endif
1294
1295	/** @def RT_H2LE_U16
1296	* Converts an uint16_t value from host to little endian byte order. */
1297	#ifdef RT_BIG_ENDIAN
1298	# define RT_H2LE_U16(u16) RT_BSWAP_U16(u16)
1299	#else
1300	# define RT_H2LE_U16(u16) (u16)
1301	#endif
1302
1303	/** @def RT_H2LE_U16_C
1304	* Converts an uint16_t constant from host to little endian byte order. */
1305	#ifdef RT_BIG_ENDIAN
1306	# define RT_H2LE_U16_C(u16) RT_BSWAP_U16_C(u16)
1307	#else
1308	# define RT_H2LE_U16_C(u16) (u16)
1309	#endif
1310
1311
1312	/** @def RT_LE2H_U64
1313	* Converts an uint64_t value from little endian to host byte order. */
1314	#ifdef RT_BIG_ENDIAN
1315	# define RT_LE2H_U64(u64) RT_BSWAP_U64(u64)
1316	#else
1317	# define RT_LE2H_U64(u64) (u64)
1318	#endif
1319
1320	/** @def RT_LE2H_U64_C
1321	* Converts an uint64_t constant from little endian to host byte order. */
1322	#ifdef RT_BIG_ENDIAN
1323	# define RT_LE2H_U64_C(u64) RT_BSWAP_U64_C(u64)
1324	#else
1325	# define RT_LE2H_U64_C(u64) (u64)
1326	#endif
1327
1328	/** @def RT_LE2H_U32
1329	* Converts an uint32_t value from little endian to host byte order. */
1330	#ifdef RT_BIG_ENDIAN
1331	# define RT_LE2H_U32(u32) RT_BSWAP_U32(u32)
1332	#else
1333	# define RT_LE2H_U32(u32) (u32)
1334	#endif
1335
1336	/** @def RT_LE2H_U32_C
1337	* Converts an uint32_t constant from little endian to host byte order. */
1338	#ifdef RT_BIG_ENDIAN
1339	# define RT_LE2H_U32_C(u32) RT_BSWAP_U32_C(u32)
1340	#else
1341	# define RT_LE2H_U32_C(u32) (u32)
1342	#endif
1343
1344	/** @def RT_LE2H_U16
1345	* Converts an uint16_t value from little endian to host byte order. */
1346	#ifdef RT_BIG_ENDIAN
1347	# define RT_LE2H_U16(u16) RT_BSWAP_U16(u16)
1348	#else
1349	# define RT_LE2H_U16(u16) (u16)
1350	#endif
1351
1352	/** @def RT_LE2H_U16_C
1353	* Converts an uint16_t constant from little endian to host byte order. */
1354	#ifdef RT_BIG_ENDIAN
1355	# define RT_LE2H_U16_C(u16) RT_BSWAP_U16_C(u16)
1356	#else
1357	# define RT_LE2H_U16_C(u16) (u16)
1358	#endif
1359
1360
1361	/** @def RT_H2BE_U64
1362	* Converts an uint64_t value from host to big endian byte order. */
1363	#ifdef RT_BIG_ENDIAN
1364	# define RT_H2BE_U64(u64) (u64)
1365	#else
1366	# define RT_H2BE_U64(u64) RT_BSWAP_U64(u64)
1367	#endif
1368
1369	/** @def RT_H2BE_U64_C
1370	* Converts an uint64_t constant from host to big endian byte order. */
1371	#ifdef RT_BIG_ENDIAN
1372	# define RT_H2BE_U64_C(u64) (u64)
1373	#else
1374	# define RT_H2BE_U64_C(u64) RT_BSWAP_U64_C(u64)
1375	#endif
1376
1377	/** @def RT_H2BE_U32
1378	* Converts an uint32_t value from host to big endian byte order. */
1379	#ifdef RT_BIG_ENDIAN
1380	# define RT_H2BE_U32(u32) (u32)
1381	#else
1382	# define RT_H2BE_U32(u32) RT_BSWAP_U32(u32)
1383	#endif
1384
1385	/** @def RT_H2BE_U32_C
1386	* Converts an uint32_t constant from host to big endian byte order. */
1387	#ifdef RT_BIG_ENDIAN
1388	# define RT_H2BE_U32_C(u32) (u32)
1389	#else
1390	# define RT_H2BE_U32_C(u32) RT_BSWAP_U32_C(u32)
1391	#endif
1392
1393	/** @def RT_H2BE_U16
1394	* Converts an uint16_t value from host to big endian byte order. */
1395	#ifdef RT_BIG_ENDIAN
1396	# define RT_H2BE_U16(u16) (u16)
1397	#else
1398	# define RT_H2BE_U16(u16) RT_BSWAP_U16(u16)
1399	#endif
1400
1401	/** @def RT_H2BE_U16_C
1402	* Converts an uint16_t constant from host to big endian byte order. */
1403	#ifdef RT_BIG_ENDIAN
1404	# define RT_H2BE_U16_C(u16) (u16)
1405	#else
1406	# define RT_H2BE_U16_C(u16) RT_BSWAP_U16_C(u16)
1407	#endif
1408
1409	/** @def RT_BE2H_U64
1410	* Converts an uint64_t value from big endian to host byte order. */
1411	#ifdef RT_BIG_ENDIAN
1412	# define RT_BE2H_U64(u64) (u64)
1413	#else
1414	# define RT_BE2H_U64(u64) RT_BSWAP_U64(u64)
1415	#endif
1416
1417	/** @def RT_BE2H_U64
1418	* Converts an uint64_t constant from big endian to host byte order. */
1419	#ifdef RT_BIG_ENDIAN
1420	# define RT_BE2H_U64_C(u64) (u64)
1421	#else
1422	# define RT_BE2H_U64_C(u64) RT_BSWAP_U64_C(u64)
1423	#endif
1424
1425	/** @def RT_BE2H_U32
1426	* Converts an uint32_t value from big endian to host byte order. */
1427	#ifdef RT_BIG_ENDIAN
1428	# define RT_BE2H_U32(u32) (u32)
1429	#else
1430	# define RT_BE2H_U32(u32) RT_BSWAP_U32(u32)
1431	#endif
1432
1433	/** @def RT_BE2H_U32_C
1434	* Converts an uint32_t value from big endian to host byte order. */
1435	#ifdef RT_BIG_ENDIAN
1436	# define RT_BE2H_U32_C(u32) (u32)
1437	#else
1438	# define RT_BE2H_U32_C(u32) RT_BSWAP_U32_C(u32)
1439	#endif
1440
1441	/** @def RT_BE2H_U16
1442	* Converts an uint16_t value from big endian to host byte order. */
1443	#ifdef RT_BIG_ENDIAN
1444	# define RT_BE2H_U16(u16) (u16)
1445	#else
1446	# define RT_BE2H_U16(u16) RT_BSWAP_U16(u16)
1447	#endif
1448
1449	/** @def RT_BE2H_U16_C
1450	* Converts an uint16_t constant from big endian to host byte order. */
1451	#ifdef RT_BIG_ENDIAN
1452	# define RT_BE2H_U16_C(u16) (u16)
1453	#else
1454	# define RT_BE2H_U16_C(u16) RT_BSWAP_U16_C(u16)
1455	#endif
1456
1457
1458	/** @def RT_H2N_U64
1459	* Converts an uint64_t value from host to network byte order. */
1460	#define RT_H2N_U64(u64) RT_H2BE_U64(u64)
1461
1462	/** @def RT_H2N_U64_C
1463	* Converts an uint64_t constant from host to network byte order. */
1464	#define RT_H2N_U64_C(u64) RT_H2BE_U64_C(u64)
1465
1466	/** @def RT_H2N_U32
1467	* Converts an uint32_t value from host to network byte order. */
1468	#define RT_H2N_U32(u32) RT_H2BE_U32(u32)
1469
1470	/** @def RT_H2N_U32_C
1471	* Converts an uint32_t constant from host to network byte order. */
1472	#define RT_H2N_U32_C(u32) RT_H2BE_U32_C(u32)
1473
1474	/** @def RT_H2N_U16
1475	* Converts an uint16_t value from host to network byte order. */
1476	#define RT_H2N_U16(u16) RT_H2BE_U16(u16)
1477
1478	/** @def RT_H2N_U16_C
1479	* Converts an uint16_t constant from host to network byte order. */
1480	#define RT_H2N_U16_C(u16) RT_H2BE_U16_C(u16)
1481
1482	/** @def RT_N2H_U64
1483	* Converts an uint64_t value from network to host byte order. */
1484	#define RT_N2H_U64(u64) RT_BE2H_U64(u64)
1485
1486	/** @def RT_N2H_U64_C
1487	* Converts an uint64_t constant from network to host byte order. */
1488	#define RT_N2H_U64_C(u64) RT_BE2H_U64_C(u64)
1489
1490	/** @def RT_N2H_U32
1491	* Converts an uint32_t value from network to host byte order. */
1492	#define RT_N2H_U32(u32) RT_BE2H_U32(u32)
1493
1494	/** @def RT_N2H_U32_C
1495	* Converts an uint32_t constant from network to host byte order. */
1496	#define RT_N2H_U32_C(u32) RT_BE2H_U32_C(u32)
1497
1498	/** @def RT_N2H_U16
1499	* Converts an uint16_t value from network to host byte order. */
1500	#define RT_N2H_U16(u16) RT_BE2H_U16(u16)
1501
1502	/** @def RT_N2H_U16_C
1503	* Converts an uint16_t value from network to host byte order. */
1504	#define RT_N2H_U16_C(u16) RT_BE2H_U16_C(u16)
1505
1506
1507	/*
1508	* The BSD sys/param.h + machine/param.h file is a major source of
1509	* namespace pollution. Kill off some of the worse ones unless we're
1510	* compiling kernel code.
1511	*/
1512	#if defined(RT_OS_DARWIN) \
1513	&& !defined(KERNEL) \
1514	&& !defined(RT_NO_BSD_PARAM_H_UNDEFING) \
1515	&& ( defined(_SYS_PARAM_H_) \|\| defined(_I386_PARAM_H_) )
1516	/* sys/param.h: */
1517	# undef PSWP
1518	# undef PVM
1519	# undef PINOD
1520	# undef PRIBO
1521	# undef PVFS
1522	# undef PZERO
1523	# undef PSOCK
1524	# undef PWAIT
1525	# undef PLOCK
1526	# undef PPAUSE
1527	# undef PUSER
1528	# undef PRIMASK
1529	# undef MINBUCKET
1530	# undef MAXALLOCSAVE
1531	# undef FSHIFT
1532	# undef FSCALE
1533
1534	/* i386/machine.h: */
1535	# undef ALIGN
1536	# undef ALIGNBYTES
1537	# undef DELAY
1538	# undef STATUS_WORD
1539	# undef USERMODE
1540	# undef BASEPRI
1541	# undef MSIZE
1542	# undef CLSIZE
1543	# undef CLSIZELOG2
1544	#endif
1545
1546
1547	/** @def NULL
1548	* NULL pointer.
1549	*/
1550	#ifndef NULL
1551	# ifdef __cplusplus
1552	# define NULL 0
1553	# else
1554	# define NULL ((void*)0)
1555	# endif
1556	#endif
1557
1558	/** @def NIL_OFFSET
1559	* NIL offset.
1560	* Whenever we use offsets instead of pointers to save space and relocation effort
1561	* NIL_OFFSET shall be used as the equivalent to NULL.
1562	*/
1563	#define NIL_OFFSET (~0U)
1564
1565	/** @def NOREF
1566	* Keeps the compiler from bitching about an unused parameter.
1567	*/
1568	#define NOREF(var) (void)(var)
1569
1570	/** @def Breakpoint
1571	* Emit a debug breakpoint instruction.
1572	*
1573	* Use this for instrumenting a debugging session only!
1574	* No committed code shall use Breakpoint().
1575	*/
1576	#ifdef __GNUC__
1577	# define Breakpoint() __asm__ __volatile__("int $3\n\t")
1578	#endif
1579	#ifdef _MSC_VER
1580	# define Breakpoint() __asm int 3
1581	#endif
1582	#if defined(__IBMC__) \|\| defined(__IBMCPP__)
1583	# define Breakpoint() __interrupt(3)
1584	#endif
1585	#ifndef Breakpoint
1586	# error "This compiler is not supported!"
1587	#endif
1588
1589
1590	/** @defgroup grp_rt_cdefs_size Size Constants
1591	* (Of course, these are binary computer terms, not SI.)
1592	* @{
1593	*/
1594	/** 1 K (Kilo) (1 024). */
1595	#define _1K 0x00000400
1596	/** 4 K (Kilo) (4 096). */
1597	#define _4K 0x00001000
1598	/** 32 K (Kilo) (32 678). */
1599	#define _32K 0x00008000
1600	/** 64 K (Kilo) (65 536). */
1601	#define _64K 0x00010000
1602	/** 128 K (Kilo) (131 072). */
1603	#define _128K 0x00020000
1604	/** 256 K (Kilo) (262 144). */
1605	#define _256K 0x00040000
1606	/** 512 K (Kilo) (524 288). */
1607	#define _512K 0x00080000
1608	/** 1 M (Mega) (1 048 576). */
1609	#define _1M 0x00100000
1610	/** 2 M (Mega) (2 097 152). */
1611	#define _2M 0x00200000
1612	/** 4 M (Mega) (4 194 304). */
1613	#define _4M 0x00400000
1614	/** 1 G (Giga) (1 073 741 824). */
1615	#define _1G 0x40000000
1616	/** 2 G (Giga) (2 147 483 648). (32-bit) */
1617	#define _2G32 0x80000000U
1618	/** 2 G (Giga) (2 147 483 648). (64-bit) */
1619	#define _2G 0x0000000080000000LL
1620	/** 4 G (Giga) (4 294 967 296). */
1621	#define _4G 0x0000000100000000LL
1622	/** 1 T (Tera) (1 099 511 627 776). */
1623	#define _1T 0x0000010000000000LL
1624	/** 1 P (Peta) (1 125 899 906 842 624). */
1625	#define _1P 0x0004000000000000LL
1626	/** 1 E (Exa) (1 152 921 504 606 846 976). */
1627	#define _1E 0x1000000000000000LL
1628	/** 2 E (Exa) (2 305 843 009 213 693 952). */
1629	#define _2E 0x2000000000000000ULL
1630	/** @} */
1631
1632
1633	/** @defgroup grp_rt_cdefs_dbgtype Debug Info Types
1634	* @{ */
1635	/** Other format. */
1636	#define RT_DBGTYPE_OTHER RT_BIT_32(0)
1637	/** Stabs. */
1638	#define RT_DBGTYPE_STABS RT_BIT_32(1)
1639	/** Debug With Arbitrary Record Format (DWARF). */
1640	#define RT_DBGTYPE_DWARF RT_BIT_32(2)
1641	/** Microsoft Codeview debug info. */
1642	#define RT_DBGTYPE_CODEVIEW RT_BIT_32(3)
1643	/** Watcom debug info. */
1644	#define RT_DBGTYPE_WATCOM RT_BIT_32(4)
1645	/** IBM High Level Language debug info. */
1646	#define RT_DBGTYPE_HLL RT_BIT_32(5)
1647	/** Old OS/2 and Windows symbol file. */
1648	#define RT_DBGTYPE_SYM RT_BIT_32(6)
1649	/** Map file. */
1650	#define RT_DBGTYPE_MAP RT_BIT_32(7)
1651	/** @} */
1652
1653
1654	/** @defgroup grp_rt_cdefs_exetype Executable Image Types
1655	* @{ */
1656	/** Some other format. */
1657	#define RT_EXETYPE_OTHER RT_BIT_32(0)
1658	/** Portable Executable. */
1659	#define RT_EXETYPE_PE RT_BIT_32(1)
1660	/** Linear eXecutable. */
1661	#define RT_EXETYPE_LX RT_BIT_32(2)
1662	/** Linear Executable. */
1663	#define RT_EXETYPE_LE RT_BIT_32(3)
1664	/** New Executable. */
1665	#define RT_EXETYPE_NE RT_BIT_32(4)
1666	/** DOS Executable (Mark Zbikowski). */
1667	#define RT_EXETYPE_MZ RT_BIT_32(5)
1668	/** COM Executable. */
1669	#define RT_EXETYPE_COM RT_BIT_32(6)
1670	/** a.out Executable. */
1671	#define RT_EXETYPE_AOUT RT_BIT_32(7)
1672	/** Executable and Linkable Format. */
1673	#define RT_EXETYPE_ELF RT_BIT_32(8)
1674	/** Mach-O Executable (including FAT ones). */
1675	#define RT_EXETYPE_MACHO RT_BIT_32(9)
1676	/** TE from UEFI. */
1677	#define RT_EXETYPE_TE RT_BIT_32(9)
1678	/** @} */
1679
1680
1681	/** @def VALID_PTR
1682	* Pointer validation macro.
1683	* @param ptr The pointer.
1684	*/
1685	#if defined(RT_ARCH_AMD64)
1686	# ifdef IN_RING3
1687	# if defined(RT_OS_DARWIN) /* first 4GB is reserved for legacy kernel. */
1688	# define RT_VALID_PTR(ptr) ( (uintptr_t)(ptr) >= _4G \
1689	&& !((uintptr_t)(ptr) & 0xffff800000000000ULL) )
1690	# elif defined(RT_OS_SOLARIS) /* The kernel only used the top 2TB, but keep it simple. */
1691	# define RT_VALID_PTR(ptr) ( (uintptr_t)(ptr) + 0x1000U >= 0x2000U \
1692	&& ( ((uintptr_t)(ptr) & 0xffff800000000000ULL) == 0xffff800000000000ULL \
1693	\|\| ((uintptr_t)(ptr) & 0xffff800000000000ULL) == 0) )
1694	# else
1695	# define RT_VALID_PTR(ptr) ( (uintptr_t)(ptr) + 0x1000U >= 0x2000U \
1696	&& !((uintptr_t)(ptr) & 0xffff800000000000ULL) )
1697	# endif
1698	# else /* !IN_RING3 */
1699	# define RT_VALID_PTR(ptr) ( (uintptr_t)(ptr) + 0x1000U >= 0x2000U \
1700	&& ( ((uintptr_t)(ptr) & 0xffff800000000000ULL) == 0xffff800000000000ULL \
1701	\|\| ((uintptr_t)(ptr) & 0xffff800000000000ULL) == 0) )
1702	# endif /* !IN_RING3 */
1703	#elif defined(RT_ARCH_X86)
1704	# define RT_VALID_PTR(ptr) ( (uintptr_t)(ptr) + 0x1000U >= 0x2000U )
1705	#else
1706	# error "Architecture identifier missing / not implemented."
1707	#endif
1708
1709	/** Old name for RT_VALID_PTR. */
1710	#define VALID_PTR(ptr) RT_VALID_PTR(ptr)
1711
1712	/** @def RT_VALID_ALIGNED_PTR
1713	* Pointer validation macro that also checks the alignment.
1714	* @param ptr The pointer.
1715	* @param align The alignment, must be a power of two.
1716	*/
1717	#define RT_VALID_ALIGNED_PTR(ptr, align) \
1718	( !((uintptr_t)(ptr) & (uintptr_t)((align) - 1)) \
1719	&& VALID_PTR(ptr) )
1720
1721
1722	/** @def VALID_PHYS32
1723	* 32 bits physical address validation macro.
1724	* @param Phys The RTGCPHYS address.
1725	*/
1726	#define VALID_PHYS32(Phys) ( (uint64_t)(Phys) < (uint64_t)_4G )
1727
1728	/** @def N_
1729	* The \#define N_ is used to mark a string for translation. This is usable in
1730	* any part of the code, as it is only used by the tools that create message
1731	* catalogs. This macro is a no-op as far as the compiler and code generation
1732	* is concerned.
1733	*
1734	* If you want to both mark a string for translation and translate it, use _().
1735	*/
1736	#define N_(s) (s)
1737
1738	/** @def _
1739	* The \#define _ is used to mark a string for translation and to translate it
1740	* in one step.
1741	*
1742	* If you want to only mark a string for translation, use N_().
1743	*/
1744	#define _(s) gettext(s)
1745
1746
1747	/** @def __PRETTY_FUNCTION__
1748	* With GNU C we'd like to use the builtin __PRETTY_FUNCTION__, so define that
1749	* for the other compilers.
1750	*/
1751	#if !defined(__GNUC__) && !defined(__PRETTY_FUNCTION__)
1752	# define __PRETTY_FUNCTION__ __FUNCTION__
1753	#endif
1754
1755
1756	/** @def RT_STRICT
1757	* The \#define RT_STRICT controls whether or not assertions and other runtime
1758	* checks should be compiled in or not.
1759	*
1760	* If you want assertions which are not subject to compile time options use
1761	* the AssertRelease*() flavors.
1762	*/
1763	#if !defined(RT_STRICT) && defined(DEBUG)
1764	# define RT_STRICT
1765	#endif
1766
1767	/** Source position. */
1768	#define RT_SRC_POS __FILE__, __LINE__, __PRETTY_FUNCTION__
1769
1770	/** Source position declaration. */
1771	#define RT_SRC_POS_DECL const char pszFile, unsigned iLine, const char pszFunction
1772
1773	/** Source position arguments. */
1774	#define RT_SRC_POS_ARGS pszFile, iLine, pszFunction
1775
1776	/** @} */
1777
1778
1779	/** @defgroup grp_rt_cdefs_cpp Special Macros for C++
1780	* @ingroup grp_rt_cdefs
1781	* @{
1782	*/
1783
1784	#ifdef __cplusplus
1785
1786	/** @def DECLEXPORT_CLASS
1787	* How to declare an exported class. Place this macro after the 'class'
1788	* keyword in the declaration of every class you want to export.
1789	*
1790	* @note It is necessary to use this macro even for inner classes declared
1791	* inside the already exported classes. This is a GCC specific requirement,
1792	* but it seems not to harm other compilers.
1793	*/
1794	#if defined(_MSC_VER) \|\| defined(RT_OS_OS2)
1795	# define DECLEXPORT_CLASS __declspec(dllexport)
1796	#elif defined(RT_USE_VISIBILITY_DEFAULT)
1797	# define DECLEXPORT_CLASS __attribute__((visibility("default")))
1798	#else
1799	# define DECLEXPORT_CLASS
1800	#endif
1801
1802	/** @def DECLIMPORT_CLASS
1803	* How to declare an imported class Place this macro after the 'class'
1804	* keyword in the declaration of every class you want to export.
1805	*
1806	* @note It is necessary to use this macro even for inner classes declared
1807	* inside the already exported classes. This is a GCC specific requirement,
1808	* but it seems not to harm other compilers.
1809	*/
1810	#if defined(_MSC_VER) \|\| (defined(RT_OS_OS2) && !defined(__IBMC__) && !defined(__IBMCPP__))
1811	# define DECLIMPORT_CLASS __declspec(dllimport)
1812	#elif defined(RT_USE_VISIBILITY_DEFAULT)
1813	# define DECLIMPORT_CLASS __attribute__((visibility("default")))
1814	#else
1815	# define DECLIMPORT_CLASS
1816	#endif
1817
1818	/** @def WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP
1819	* Macro to work around error C2593 of the not-so-smart MSVC 7.x ambiguity
1820	* resolver. The following snippet clearly demonstrates the code causing this
1821	* error:
1822	* @code
1823	* class A
1824	* {
1825	* public:
1826	* operator bool() const { return false; }
1827	* operator int*() const { return NULL; }
1828	* };
1829	* int main()
1830	* {
1831	* A a;
1832	* if (!a);
1833	* if (a && 0);
1834	* return 0;
1835	* }
1836	* @endcode
1837	* The code itself seems pretty valid to me and GCC thinks the same.
1838	*
1839	* This macro fixes the compiler error by explicitly overloading implicit
1840	* global operators !, && and \|\| that take the given class instance as one of
1841	* their arguments.
1842	*
1843	* The best is to use this macro right after the class declaration.
1844	*
1845	* @note The macro expands to nothing for compilers other than MSVC.
1846	*
1847	* @param Cls Class to apply the workaround to
1848	*/
1849	#if defined(_MSC_VER)
1850	# define WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP(Cls) \
1851	inline bool operator! (const Cls &that) { return !bool (that); } \
1852	inline bool operator&& (const Cls &that, bool b) { return bool (that) && b; } \
1853	inline bool operator\|\| (const Cls &that, bool b) { return bool (that) \|\| b; } \
1854	inline bool operator&& (bool b, const Cls &that) { return b && bool (that); } \
1855	inline bool operator\|\| (bool b, const Cls &that) { return b \|\| bool (that); }
1856	#else
1857	# define WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP(Cls)
1858	#endif
1859
1860	/** @def WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP_TPL
1861	* Version of WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP for template classes.
1862	*
1863	* @param Tpl Name of the template class to apply the workaround to
1864	* @param ArgsDecl arguments of the template, as declared in \|<>\| after the
1865	* \|template\| keyword, including \|<>\|
1866	* @param Args arguments of the template, as specified in \|<>\| after the
1867	* template class name when using the, including \|<>\|
1868	*
1869	* Example:
1870	* @code
1871	* // template class declaration
1872	* template <class C>
1873	* class Foo { ... };
1874	* // applied workaround
1875	* WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP_TPL (Foo, <class C>, <C>)
1876	* @endcode
1877	*/
1878	#if defined(_MSC_VER)
1879	# define WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP_TPL(Tpl, ArgsDecl, Args) \
1880	template ArgsDecl \
1881	inline bool operator! (const Tpl Args &that) { return !bool (that); } \
1882	template ArgsDecl \
1883	inline bool operator&& (const Tpl Args &that, bool b) { return bool (that) && b; } \
1884	template ArgsDecl \
1885	inline bool operator\|\| (const Tpl Args &that, bool b) { return bool (that) \|\| b; } \
1886	template ArgsDecl \
1887	inline bool operator&& (bool b, const Tpl Args &that) { return b && bool (that); } \
1888	template ArgsDecl \
1889	inline bool operator\|\| (bool b, const Tpl Args &that) { return b \|\| bool (that); }
1890	#else
1891	# define WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP_TPL(Tpl, ArgsDecl, Args)
1892	#endif
1893
1894
1895	/** @def DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP
1896	* Declares the copy constructor and the assignment operation as inlined no-ops
1897	* (non-existent functions) for the given class. Use this macro inside the
1898	* private section if you want to effectively disable these operations for your
1899	* class.
1900	*
1901	* @param Cls class name to declare for
1902	*/
1903
1904	#define DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(Cls) \
1905	inline Cls (const Cls &); \
1906	inline Cls &operator= (const Cls &);
1907
1908
1909	/** @def DECLARE_CLS_NEW_DELETE_NOOP
1910	* Declares the new and delete operations as no-ops (non-existent functions)
1911	* for the given class. Use this macro inside the private section if you want
1912	* to effectively limit creating class instances on the stack only.
1913	*
1914	* @note The destructor of the given class must not be virtual, otherwise a
1915	* compile time error will occur. Note that this is not a drawback: having
1916	* the virtual destructor for a stack-based class is absolutely useless
1917	* (the real class of the stack-based instance is always known to the compiler
1918	* at compile time, so it will always call the correct destructor).
1919	*
1920	* @param Cls class name to declare for
1921	*/
1922	#define DECLARE_CLS_NEW_DELETE_NOOP(Cls) \
1923	inline static void *operator new (size_t); \
1924	inline static void operator delete (void *);
1925
1926	#endif /* defined(__cplusplus) */
1927
1928	/** @} */
1929
1930	#endif
1931

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

source: vbox/trunk/include/iprt/cdefs.h@ 22650

Download in other formats: