cdefs.h@ 3092

Last change on this file since 3092 was 3007, checked in by vboxsync, 18 years ago
Moved the template code out of cdefs.h, partly because it didn't belong there but mostly because it was at the end of the file and would screw up any attempts made by the object cache at avoid recompiling on cdefs.h changes.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 40.5 KB

Line
1	/** @file
2	* innotek Portable Runtime - Common C and C++ definitions.
3	*/
4
5	/*
6	* Copyright (C) 2006-2007 innotek GmbH
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 as published by the Free Software Foundation,
12	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
13	* distribution. VirtualBox OSE is distributed in the hope that it will
14	* be useful, but WITHOUT ANY WARRANTY of any kind.
15	*
16	* If you received this file as part of a commercial VirtualBox
17	* distribution, then only the terms of your commercial VirtualBox
18	* license agreement apply instead of the previous paragraph.
19	*/
20
21	#ifndef __iprt_cdefs_h__
22	#define __iprt_cdefs_h__
23
24
25	/** @defgroup grp_rt_cdefs innotek Portable Runtime Common Definitions and Macros
26	* @{
27	*/
28
29	/*
30	* Include sys/cdefs.h if present, if not define the stuff we need.
31	*/
32	#ifdef HAVE_SYS_CDEFS_H
33	# if defined(__LINUX__) && defined(__KERNEL__)
34	# error "oops"
35	# endif
36	# include <sys/cdefs.h>
37	#else
38
39	/** @def __BEGIN_DECLS
40	* Used to start a block of function declarations which are shared
41	* between C and C++ program.
42	*/
43
44	/** @def __END_DECLS
45	* Used to end a block of function declarations which are shared
46	* between C and C++ program.
47	*/
48
49	#if defined(__cplusplus)
50	# define __BEGIN_DECLS extern "C" {
51	# define __END_DECLS }
52	#else
53	# define __BEGIN_DECLS
54	# define __END_DECLS
55	#endif
56
57	#endif
58
59
60	/*
61	* Shut up DOXYGEN warnings and guide it properly thru the code.
62	*/
63	#ifdef __DOXYGEN__
64	#define __AMD64__
65	#define __X86__
66	#define IN_RING0
67	#define IN_RING3
68	#define IN_GC
69	#define IN_RT_GC
70	#define IN_RT_R0
71	#define IN_RT_R3
72	#define RT_STRICT
73	#define Breakpoint
74	#define RT_NO_DEPRECATED_MACROS
75	#define ARCH_BITS
76	#define HC_ARCH_BITS
77	#define R3_ARCH_BITS
78	#define R0_ARCH_BITS
79	#define GC_ARCH_BITS
80	#endif /* __DOXYGEN__ */
81
82	/** @def __X86__
83	* Indicates that we're compiling for the X86 architecture.
84	*/
85
86	/** @def __AMD64__
87	* Indicates that we're compiling for the AMD64 architecture.
88	*/
89	#if !defined(__X86__) && !defined(__AMD64__)
90	# if defined(__amd64__) \|\| defined(__x86_64__) \|\| defined(_M_X64)
91	# define __AMD64__
92	# elif defined(__i386__) \|\| defined(_M_IX86)
93	# define __X86__
94	# else
95	# error "Check what predefined stuff your compiler uses to indicate architecture."
96	# endif
97	#elif defined(__X86__) && defined(__AMD64__)
98	# error "Both __X86__ and __AMD64__ cannot be defined at the same time!"
99	#endif
100
101	/** @def IN_RING0
102	* Used to indicate that we're compiling code which is running
103	* in Ring-0 Host Context.
104	*/
105
106	/** @def IN_RING3
107	* Used to indicate that we're compiling code which is running
108	* in Ring-3 Host Context.
109	*/
110
111	/** @def IN_GC
112	* Used to indicate that we're compiling code which is running
113	* in Guest Context (implies R0).
114	*/
115	#if !defined(IN_RING3) && !defined(IN_RING0) && !defined(IN_GC)
116	# error "You must defined which context the compiled code should run in; IN_RING3, IN_RING0 or IN_GC"
117	#endif
118	#if (defined(IN_RING3) && (defined(IN_RING0) \|\| defined(IN_GC)) ) \
119	\|\| (defined(IN_RING0) && (defined(IN_RING3) \|\| defined(IN_GC)) ) \
120	\|\| (defined(IN_GC) && (defined(IN_RING3) \|\| defined(IN_RING0)) )
121	# error "Only one of the IN_RING3, IN_RING0, IN_GC defines should be defined."
122	#endif
123
124
125	/** @def ARCH_BITS
126	* Defines the bit count of the current context.
127	*/
128	#ifndef ARCH_BITS
129	# if defined(__AMD64__)
130	# define ARCH_BITS 64
131	# else
132	# define ARCH_BITS 32
133	# endif
134	#endif
135
136	/** @def HC_ARCH_BITS
137	* Defines the host architechture bit count.
138	*/
139	#ifndef HC_ARCH_BITS
140	# ifndef IN_GC
141	# define HC_ARCH_BITS ARCH_BITS
142	# else
143	# define HC_ARCH_BITS 32
144	# endif
145	#endif
146
147	/** @def R3_ARCH_BITS
148	* Defines the host ring-3 architechture bit count.
149	*/
150	#ifndef R3_ARCH_BITS
151	# ifdef IN_RING3
152	# define R3_ARCH_BITS ARCH_BITS
153	# else
154	# define R3_ARCH_BITS HC_ARCH_BITS
155	# endif
156	#endif
157
158	/** @def R0_ARCH_BITS
159	* Defines the host ring-0 architechture bit count.
160	*/
161	#ifndef R0_ARCH_BITS
162	# ifdef IN_RING0
163	# define R0_ARCH_BITS ARCH_BITS
164	# else
165	# define R0_ARCH_BITS HC_ARCH_BITS
166	# endif
167	#endif
168
169	/** @def GC_ARCH_BITS
170	* Defines the guest architechture bit count.
171	*/
172	#ifndef GC_ARCH_BITS
173	# ifdef IN_GC
174	# define GC_ARCH_BITS ARCH_BITS
175	# else
176	# define GC_ARCH_BITS 32
177	# endif
178	#endif
179
180
181	/** @def CTXTYPE
182	* Declare a type differently in GC, R3 and R0.
183	*
184	* @param GCType The GC type.
185	* @param R3Type The R3 type.
186	* @param R0Type The R0 type.
187	* @remark For pointers used only in one context use GCPTRTYPE(), HCPTRTYPE(), R3PTRTYPE() or R0PTRTYPE().
188	*/
189	#ifdef IN_GC
190	# define CTXTYPE(GCType, R3Type, R0Type) GCType
191	#elif defined(IN_RING3)
192	# define CTXTYPE(GCType, R3Type, R0Type) R3Type
193	#else
194	# define CTXTYPE(GCType, R3Type, R0Type) R0Type
195	#endif
196
197	/** @def GCTYPE
198	* Declare a type differently in GC and HC.
199	*
200	* @param GCType The GC type.
201	* @param HCType The HC type.
202	* @remark For pointers used only in one context use GCPTRTYPE(), HCPTRTYPE(), R3PTRTYPE() or R0PTRTYPE().
203	*/
204	#define GCTYPE(GCType, HCType) CTXTYPE(GCType, HCType, HCType)
205
206	/** @def GCPTRTYPE
207	* Declare a pointer which is used in GC but appears in structure(s) used by
208	* both HC and GC. The main purpose is to make sure structures have the same
209	* size when built for different architectures.
210	*
211	* @param GCType The GC type.
212	*/
213	#define GCPTRTYPE(GCType) CTXTYPE(GCType, RTGCPTR, RTGCPTR)
214
215	/** @def HCPTRTYPE
216	* Declare a pointer which is used in HC but appears in structure(s) used by
217	* both HC and GC. The main purpose is to make sure structures have the same
218	* size when built for different architectures.
219	*
220	* @param HCType The HC type.
221	*/
222	#define HCPTRTYPE(HCType) CTXTYPE(RTHCPTR, HCType, HCType)
223
224	/** @def R3PTRTYPE
225	* Declare a pointer which is used in R3 but appears in structure(s) used by
226	* both HC and GC. The main purpose is to make sure structures have the same
227	* size when built for different architectures.
228	*
229	* @param R3Type The R3 type.
230	*/
231	#define R3PTRTYPE(R3Type) CTXTYPE(RTHCUINTPTR, R3Type, RTHCUINTPTR)
232
233	/** @def R0PTRTYPE
234	* Declare a pointer which is used in R0 but appears in structure(s) used by
235	* both HC and GC. The main purpose is to make sure structures have the same
236	* size when built for different architectures.
237	*
238	* @param R0Type The R0 type.
239	*/
240	#define R0PTRTYPE(R0Type) CTXTYPE(RTHCUINTPTR, RTHCUINTPTR, R0Type)
241
242	/** @def CTXSUFF
243	* Adds the suffix of the current context to the passed in
244	* identifier name. The suffix is HC or GC.
245	*
246	* This is macro should only be used in shared code to avoid a forrest of ifdefs.
247	* @param var Identifier name.
248	*/
249	/** @def OTHERCTXSUFF
250	* Adds the suffix of the other context to the passed in
251	* identifier name. The suffix is HC or GC.
252	*
253	* This is macro should only be used in shared code to avoid a forrest of ifdefs.
254	* @param var Identifier name.
255	*/
256	#ifdef IN_GC
257	# define CTXSUFF(var) var##GC
258	# define OTHERCTXSUFF(var) var##HC
259	#else
260	# define CTXSUFF(var) var##HC
261	# define OTHERCTXSUFF(var) var##GC
262	#endif
263
264	/** @def CTXALLSUFF
265	* Adds the suffix of the current context to the passed in
266	* identifier name. The suffix is R3, R0 or GC.
267	*
268	* This is macro should only be used in shared code to avoid a forrest of ifdefs.
269	* @param var Identifier name.
270	*/
271	#ifdef IN_GC
272	# define CTXALLSUFF(var) var##GC
273	#elif defined(IN_RING0)
274	# define CTXALLSUFF(var) var##R0
275	#else
276	# define CTXALLSUFF(var) var##R3
277	#endif
278
279	/** @def CTXMID
280	* Adds the current context as a middle name of an identifier name
281	* The middle name is HC or GC.
282	*
283	* This is macro should only be used in shared code to avoid a forrest of ifdefs.
284	* @param first First name.
285	* @param last Surname.
286	*/
287	/** @def OTHERCTXMID
288	* Adds the other context as a middle name of an identifier name
289	* The middle name is HC or GC.
290	*
291	* This is macro should only be used in shared code to avoid a forrest of ifdefs.
292	* @param first First name.
293	* @param last Surname.
294	*/
295	#ifdef IN_GC
296	# define CTXMID(first, last) first##GC##last
297	# define OTHERCTXMID(first, last) first##HC##last
298	#else
299	# define CTXMID(first, last) first##HC##last
300	# define OTHERCTXMID(first, last) first##GC##last
301	#endif
302
303	/** @def CTXALLMID
304	* Adds the current context as a middle name of an identifier name
305	* The middle name is R3, R0 or GC.
306	*
307	* This is macro should only be used in shared code to avoid a forrest of ifdefs.
308	* @param first First name.
309	* @param last Surname.
310	*/
311	#ifdef IN_GC
312	# define CTXALLMID(first, last) first##GC##last
313	#elif defined(IN_RING0)
314	# define CTXALLMID(first, last) first##R0##last
315	#else
316	# define CTXALLMID(first, last) first##R3##last
317	#endif
318
319
320	/** @def R3STRING
321	* A macro which in GC and R0 will return a dummy string while in R3 it will return
322	* the parameter.
323	*
324	* This is typically used to wrap description strings in structures shared
325	* between R3, R0 and/or GC. The intention is to avoid the \#ifdef IN_RING3 mess.
326	*
327	* @param pR3String The R3 string. Only referenced in R3.
328	* @see R0STRING and GCSTRING
329	*/
330	#ifdef IN_RING3
331	# define R3STRING(pR3String) (pR3String)
332	#else
333	# define R3STRING(pR3String) ("<R3_STRING>")
334	#endif
335
336	/** @def R0STRING
337	* A macro which in GC and R3 will return a dummy string while in R0 it will return
338	* the parameter.
339	*
340	* This is typically used to wrap description strings in structures shared
341	* between R3, R0 and/or GC. The intention is to avoid the \#ifdef IN_RING0 mess.
342	*
343	* @param pR0String The R0 string. Only referenced in R0.
344	* @see R3STRING and GCSTRING
345	*/
346	#ifdef IN_RING0
347	# define R0STRING(pR0String) (pR0String)
348	#else
349	# define R0STRING(pR0String) ("<R0_STRING>")
350	#endif
351
352	/** @def GCSTRING
353	* A macro which in R3 and R0 will return a dummy string while in GC it will return
354	* the parameter.
355	*
356	* This is typically used to wrap description strings in structures shared
357	* between R3, R0 and/or GC. The intention is to avoid the \#ifdef IN_GC mess.
358	*
359	* @param pR0String The GC string. Only referenced in GC.
360	* @see R3STRING, R0STRING
361	*/
362	#ifdef IN_GC
363	# define GCSTRING(pR0String) (pGCString)
364	#else
365	# define GCSTRING(pR0String) ("<GC_STRING>")
366	#endif
367
368	/** @def HCSTRING
369	* Macro which in GC will return a dummy string while in HC will return
370	* the parameter.
371	*
372	* This is typically used to wrap description strings in structures shared
373	* between HC and GC. The intention is to avoid the \#ifdef IN_GC kludge.
374	*
375	* @param pHCString The HC string. Only referenced in HC.
376	* @deprecated Use R3STRING or R0STRING instead.
377	*/
378	#ifdef IN_GC
379	# define HCSTRING(pHCString) ("<HC_STRING>")
380	#else
381	# define HCSTRING(pHCString) (pHCString)
382	#endif
383
384
385	/** @def RTCALL
386	* The standard calling convention for the Runtime interfaces.
387	*/
388	#ifdef _MSC_VER
389	# define RTCALL __cdecl
390	#elif defined(__GNUC__) && defined(IN_RING0) && !(defined(__OS2__) \|\| defined(__AMD64__)) /* the latter is kernel/gcc */
391	# define RTCALL __attribute__((cdecl,regparm(0)))
392	#else
393	# define RTCALL
394	#endif
395
396	/** @def DECLEXPORT
397	* How to declare an exported function.
398	* @param type The return type of the function declaration.
399	*/
400	#if defined(_MSC_VER) \|\| defined(__OS2__)
401	# define DECLEXPORT(type) __declspec(dllexport) type
402	#else
403	# ifdef VBOX_HAVE_VISIBILITY_HIDDEN
404	# define DECLEXPORT(type) __attribute__((visibility("default"))) type
405	# else
406	# define DECLEXPORT(type) type
407	# endif
408	#endif
409
410	/** @def DECLIMPORT
411	* How to declare an imported function.
412	* @param type The return type of the function declaration.
413	*/
414	#if defined(_MSC_VER) \|\| defined(__OS2__)
415	# define DECLIMPORT(type) __declspec(dllimport) type
416	#else
417	# define DECLIMPORT(type) type
418	#endif
419
420	/** @def DECLASM
421	* How to declare an internal assembly function.
422	* @param type The return type of the function declaration.
423	*/
424	#ifdef __cplusplus
425	# ifdef _MSC_VER
426	# define DECLASM(type) extern "C" type __cdecl
427	# else
428	# define DECLASM(type) extern "C" type
429	# endif
430	#else
431	# ifdef _MSC_VER
432	# define DECLASM(type) type __cdecl
433	# else
434	# define DECLASM(type) type
435	# endif
436	#endif
437
438	/** @def DECLASMTYPE
439	* How to declare an internal assembly function type.
440	* @param type The return type of the function.
441	*/
442	#ifdef _MSC_VER
443	# define DECLASMTYPE(type) type __cdecl
444	#else
445	# define DECLASMTYPE(type) type
446	#endif
447
448	/** @def DECLCALLBACK
449	* How to declare an call back function type.
450	* @param type The return type of the function declaration.
451	*/
452	#define DECLCALLBACK(type) type RTCALL
453
454	/** @def DECLCALLBACKPTR
455	* How to declare an call back function pointer.
456	* @param type The return type of the function declaration.
457	* @param name The name of the variable member.
458	*/
459	#define DECLCALLBACKPTR(type, name) type (RTCALL * name)
460
461	/** @def DECLCALLBACKMEMBER
462	* How to declare an call back function pointer member.
463	* @param type The return type of the function declaration.
464	* @param name The name of the struct/union/class member.
465	*/
466	#define DECLCALLBACKMEMBER(type, name) type (RTCALL * name)
467
468	/** @def DECLR3CALLBACKMEMBER
469	* How to declare an call back function pointer member - R3 Ptr.
470	* @param type The return type of the function declaration.
471	* @param name The name of the struct/union/class member.
472	* @param args The argument list enclosed in parentheses.
473	*/
474	#ifdef IN_RING3
475	# define DECLR3CALLBACKMEMBER(type, name, args) type (RTCALL * name) args
476	#else
477	# define DECLR3CALLBACKMEMBER(type, name, args) RTR3PTR name
478	#endif
479
480	/** @def DECLGCCALLBACKMEMBER
481	* How to declare an call back function pointer member - GC Ptr.
482	* @param type The return type of the function declaration.
483	* @param name The name of the struct/union/class member.
484	* @param args The argument list enclosed in parentheses.
485	*/
486	#ifdef IN_GC
487	# define DECLGCCALLBACKMEMBER(type, name, args) type (RTCALL * name) args
488	#else
489	# define DECLGCCALLBACKMEMBER(type, name, args) RTGCPTR name
490	#endif
491
492	/** @def DECLR0CALLBACKMEMBER
493	* How to declare an call back function pointer member - R0 Ptr.
494	* @param type The return type of the function declaration.
495	* @param name The name of the struct/union/class member.
496	* @param args The argument list enclosed in parentheses.
497	*/
498	#ifdef IN_RING0
499	# define DECLR0CALLBACKMEMBER(type, name, args) type (RTCALL * name) args
500	#else
501	# define DECLR0CALLBACKMEMBER(type, name, args) RTR0PTR name
502	#endif
503
504	/** @def DECLINLINE
505	* How to declare a function as inline.
506	* @param type The return type of the function declaration.
507	*/
508	#ifdef __GNUC__
509	# define DECLINLINE(type) static inline type
510	#elif defined(__cplusplus)
511	# define DECLINLINE(type) inline type
512	#elif defined(_MSC_VER)
513	# define DECLINLINE(type) _inline type
514	#else
515	# define DECLINLINE(type) inline type
516	#endif
517
518
519	/** @def IN_RT_R0
520	* Used to indicate whether we're inside the same link module as
521	* the HC Ring-0 Runtime Library.
522	*/
523	/** @def RTR0DECL(type)
524	* Runtime Library HC Ring-0 export or import declaration.
525	* @param type The return type of the function declaration.
526	*/
527	#ifdef IN_RT_R0
528	# define RTR0DECL(type) DECLEXPORT(type) RTCALL
529	#else
530	# define RTR0DECL(type) DECLIMPORT(type) RTCALL
531	#endif
532
533	/** @def IN_RT_R3
534	* Used to indicate whether we're inside the same link module as
535	* the HC Ring-3 Runtime Library.
536	*/
537	/** @def RTR3DECL(type)
538	* Runtime Library HC Ring-3 export or import declaration.
539	* @param type The return type of the function declaration.
540	*/
541	#ifdef IN_RT_R3
542	# define RTR3DECL(type) DECLEXPORT(type) RTCALL
543	#else
544	# define RTR3DECL(type) DECLIMPORT(type) RTCALL
545	#endif
546
547	/** @def IN_RT_GC
548	* Used to indicate whether we're inside the same link module as
549	* the GC Runtime Library.
550	*/
551	/** @def RTGCDECL(type)
552	* Runtime Library HC Ring-3 export or import declaration.
553	* @param type The return type of the function declaration.
554	*/
555	#ifdef IN_RT_GC
556	# define RTGCDECL(type) DECLEXPORT(type) RTCALL
557	#else
558	# define RTGCDECL(type) DECLIMPORT(type) RTCALL
559	#endif
560
561	/** @def RTDECL(type)
562	* Runtime Library export or import declaration.
563	* Functions declared using this macro exists in all contexts.
564	* @param type The return type of the function declaration.
565	*/
566	#if defined(IN_RT_R3) \|\| defined(IN_RT_GC) \|\| defined(IN_RT_R0)
567	# define RTDECL(type) DECLEXPORT(type) RTCALL
568	#else
569	# define RTDECL(type) DECLIMPORT(type) RTCALL
570	#endif
571
572	/** @def RTDATADECL(type)
573	* Runtime Library export or import declaration.
574	* Data declared using this macro exists in all contexts.
575	* @param type The return type of the function declaration.
576	*/
577	#if defined(IN_RT_R3) \|\| defined(IN_RT_GC) \|\| defined(IN_RT_R0)
578	# define RTDATADECL(type) DECLEXPORT(type)
579	#else
580	# define RTDATADECL(type) DECLIMPORT(type)
581	#endif
582
583
584	/** @def RT_NOCRT
585	* Symbol name wrapper for the No-CRT bits.
586	*
587	* In order to coexist in the same process as other CRTs, we need to
588	* decorate the symbols such that they don't conflict the ones in the
589	* other CRTs. The result of such conflicts / duplicate symbols can
590	* confuse the dynamic loader on unix like systems.
591	*
592	* Define RT_WITHOUT_NOCRT_WRAPPERS to drop the wrapping.
593	*/
594	/** @def RT_NOCRT_STR
595	* Same as RT_NOCRT only it'll return a double quoted string of the result.
596	*/
597	#ifndef RT_WITHOUT_NOCRT_WRAPPERS
598	# define RT_NOCRT(name) nocrt_ ## name
599	# define RT_NOCRT_STR(name) "nocrt_" # name
600	#else
601	# define RT_NOCRT(name) name
602	# define RT_NOCRT_STR(name) #name
603	#endif
604
605
606
607	/** @def RT_LIKELY
608	* Give the compiler a hint that an expression is very likely to hold true.
609	*
610	* Some compilers support explicit branch prediction so that the CPU backend
611	* can hint the processor and also so that code blocks can be reordered such
612	* that the predicted path sees a more linear flow, thus improving cache
613	* behaviour, etc.
614	*
615	* IPRT provides the macros RT_LIKELY() and RT_UNLIKELY() as a way to utilize
616	* this compiler feature when present.
617	*
618	* A few notes about the usage:
619	*
620	* - Generally, use RT_UNLIKELY() with error condition checks (unless you
621	* have some _strong_ reason to do otherwise, in which case document it),
622	* and/or RT_LIKELY() with success condition checks, assuming you want
623	* to optimize for the success path.
624	*
625	* - Other than that, if you don't know the likelihood of a test succeeding
626	* from empirical or other 'hard' evidence, don't make predictions unless
627	* you happen to be a Dirk Gently.
628	*
629	* - These macros are meant to be used in places that get executed a lot. It
630	* is wasteful to make predictions in code that is executed seldomly (e.g.
631	* at subsystem initialization time) as the basic block reording that this
632	* affecs can often generate larger code.
633	*
634	* - Note that RT_SUCCESS() and RT_FAILURE() already makes use of RT_LIKELY()
635	* and RT_UNLIKELY(). Should you wish for prediction free status checks,
636	* use the RT_SUCCESS_NP() and RT_FAILURE_NP() macros instead.
637	*
638	*
639	* @returns the boolean result of the expression.
640	* @param expr The expression that's very likely to be true.
641	* @see RT_UNLIKELY
642	*/
643	/** @def RT_UNLIKELY
644	* Give the compiler a hint that an expression is highly unlikely hold true.
645	*
646	* See the usage instructions give in the RT_LIKELY() docs.
647	*
648	* @returns the boolean result of the expression.
649	* @param expr The expression that's very unlikely to be true.
650	* @see RT_LIKELY
651	*/
652	#if defined(__GNUC__)
653	# if __GNUC__ >= 3
654	# define RT_LIKELY(expr) __builtin_expect(!!(expr), 1)
655	# define RT_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
656	# else
657	# define RT_LIKELY(expr) (expr)
658	# define RT_UNLIKELY(expr) (expr)
659	# endif
660	#else
661	# define RT_LIKELY(expr) (expr)
662	# define RT_UNLIKELY(expr) (expr)
663	#endif
664
665
666	/** @def RT_BIT
667	* Make a bitmask for one integer sized bit.
668	* @param bit Bit number.
669	*/
670	#define RT_BIT(bit) (1U << (bit))
671
672	/** @def RT_BIT_32
673	* Make a 32-bit bitmask for one bit.
674	* @param bit Bit number.
675	*/
676	#define RT_BIT_32(bit) (UINT32_C(1) << (bit))
677
678	/** @def RT_BIT_64
679	* Make a 64-bit bitmask for one bit.
680	* @param bit Bit number.
681	*/
682	#define RT_BIT_64(bit) (UINT64_C(1) << (bit))
683
684	/** @def RT_ALIGN
685	* Align macro.
686	* @param u Value to align.
687	* @param uAlignment The alignment. Power of two!
688	*
689	* @remark Be extremely careful when using this macro with type which sizeof != sizeof int.
690	* When possible use any of the other RT_ALIGN_* macros. And when that's not
691	* possible, make 101% sure that uAlignment is specified with a right sized type.
692	*
693	* Specifying an unsigned 32-bit alignment constant with a 64-bit value will give
694	* you a 32-bit return value!
695	*
696	* In short: Don't use this macro. Use RT_ALIGN_T() instead.
697	*/
698	#define RT_ALIGN(u, uAlignment) ( ((u) + ((uAlignment) - 1)) & ~((uAlignment) - 1) )
699
700	/** @def RT_ALIGN_T
701	* Align macro.
702	* @param u Value to align.
703	* @param uAlignment The alignment. Power of two!
704	* @param type Integer type to use while aligning.
705	* @remark This macro is the prefered alignment macro, it doesn't have any of the pitfalls RT_ALIGN has.
706	*/
707	#define RT_ALIGN_T(u, uAlignment, type) ( ((type)(u) + ((uAlignment) - 1)) & ~(type)((uAlignment) - 1) )
708
709	/** @def RT_ALIGN_32
710	* Align macro for a 32-bit value.
711	* @param u32 Value to align.
712	* @param uAlignment The alignment. Power of two!
713	*/
714	#define RT_ALIGN_32(u32, uAlignment) RT_ALIGN_T(u32, uAlignment, uint32_t)
715
716	/** @def RT_ALIGN_64
717	* Align macro for a 64-bit value.
718	* @param u64 Value to align.
719	* @param uAlignment The alignment. Power of two!
720	*/
721	#define RT_ALIGN_64(u64, uAlignment) RT_ALIGN_T(u64, uAlignment, uint64_t)
722
723	/** @def RT_ALIGN_Z
724	* Align macro for size_t.
725	* @param cb Value to align.
726	* @param uAlignment The alignment. Power of two!
727	*/
728	#define RT_ALIGN_Z(cb, uAlignment) RT_ALIGN_T(cb, uAlignment, size_t)
729
730	/** @def RT_ALIGN_P
731	* Align macro for pointers.
732	* @param pv Value to align.
733	* @param uAlignment The alignment. Power of two!
734	*/
735	#define RT_ALIGN_P(pv, uAlignment) RT_ALIGN_PT(pv, uAlignment, void *)
736
737	/** @def RT_ALIGN_PT
738	* Align macro for pointers with type cast.
739	* @param u Value to align.
740	* @param uAlignment The alignment. Power of two!
741	* @param CastType The type to cast the result to.
742	*/
743	#define RT_ALIGN_PT(u, uAlignment, CastType) ((CastType)RT_ALIGN_T(u, uAlignment, uintptr_t))
744
745	/** @def RT_ALIGN_R3PT
746	* Align macro for ring-3 pointers with type cast.
747	* @param u Value to align.
748	* @param uAlignment The alignment. Power of two!
749	* @param CastType The type to cast the result to.
750	*/
751	#define RT_ALIGN_R3PT(u, uAlignment, CastType) ((CastType)RT_ALIGN_T(u, uAlignment, RTR3UINTPTR))
752
753	/** @def RT_ALIGN_R0PT
754	* Align macro for ring-0 pointers with type cast.
755	* @param u Value to align.
756	* @param uAlignment The alignment. Power of two!
757	* @param CastType The type to cast the result to.
758	*/
759	#define RT_ALIGN_R0PT(u, uAlignment, CastType) ((CastType)RT_ALIGN_T(u, uAlignment, RTR0UINTPTR))
760
761	/** @def RT_ALIGN_GCPT
762	* Align macro for GC pointers with type cast.
763	* @param u Value to align.
764	* @param uAlignment The alignment. Power of two!
765	* @param CastType The type to cast the result to.
766	*/
767	#define RT_ALIGN_GCPT(u, uAlignment, CastType) ((CastType)RT_ALIGN_T(u, uAlignment, RTGCUINTPTR))
768
769
770	/** @def RT_OFFSETOF
771	* Our own special offsetof() variant.
772	*
773	* This differs from the usual offsetof() in that it's not relying on builtin
774	* compiler stuff and thus can use variables in arrays the structure may
775	* contain. If in this usful to determin the sizes of structures ending
776	* with a variable length field.
777	*
778	* @returns offset into the structure of the specified member.
779	* @param type Structure type.
780	* @param member Member.
781	*/
782	#define RT_OFFSETOF(type, member) ( (int)(uintptr_t)&( ((type )(void )0)->member) )
783
784	/** @def RT_SIZEOFMEMB
785	* Get the size of a structure member.
786	*
787	* @returns size of the structure member.
788	* @param type Structure type.
789	* @param member Member.
790	*/
791	#define RT_SIZEOFMEMB(type, member) ( sizeof(((type )(void )0)->member) )
792
793	/** @def RT_ELEMENTS
794	* Calcs the number of elements in an array.
795	* @returns Element count.
796	* @param aArray Array in question.
797	*/
798	#define RT_ELEMENTS(aArray) ( sizeof(aArray) / sizeof((aArray)[0]) )
799
800	/** @def RT_MAX
801	* Finds the maximum value.
802	* @returns The higher of the two.
803	* @param Value1 Value 1
804	* @param Value2 Value 2
805	*/
806	#define RT_MAX(Value1, Value2) ((Value1) >= (Value2) ? (Value1) : (Value2))
807
808	/** @def RT_MIN
809	* Finds the minimum value.
810	* @returns The lower of the two.
811	* @param Value1 Value 1
812	* @param Value2 Value 2
813	*/
814	#define RT_MIN(Value1, Value2) ((Value1) <= (Value2) ? (Value1) : (Value2))
815
816	/** @def RT_ABS
817	* Get the absolute (non-negative) value.
818	* @returns The absolute value of Value.
819	* @param Value The value.
820	*/
821	#define RT_ABS(Value) ((Value) >= 0 ? (Value) : -(Value))
822
823	/** @def RT_LOWORD
824	* Gets the low word (=uint16_t) of something. */
825	#define RT_LOWORD(a) ((a) & 0xffff)
826
827	/** @def RT_HIWORD
828	* Gets the high word (=uint16_t) of a 32 bit something. */
829	#define RT_HIWORD(a) ((a) >> 16)
830
831	/** @def RT_LOBYTE
832	* Gets the low byte of something. */
833	#define RT_LOBYTE(a) ((a) & 0xff)
834
835	/** @def RT_HIBYTE
836	* Gets the low byte of a 16 bit something. */
837	#define RT_HIBYTE(a) ((a) >> 8)
838
839	/** @def RT_BYTE1
840	* Gets first byte of something. */
841	#define RT_BYTE1(a) ((a) & 0xff)
842
843	/** @def RT_BYTE2
844	* Gets second byte of something. */
845	#define RT_BYTE2(a) (((a) >> 8) & 0xff)
846
847	/** @def RT_BYTE3
848	* Gets second byte of something. */
849	#define RT_BYTE3(a) (((a) >> 16) & 0xff)
850
851	/** @def RT_BYTE4
852	* Gets fourth byte of something. */
853	#define RT_BYTE4(a) (((a) >> 24) & 0xff)
854
855
856	/** @def RT_MAKE_U64
857	* Constructs a uint64_t value from two uint32_t values.
858	*/
859	#define RT_MAKE_U64(Lo, Hi) ( (uint64_t)((uint32_t)(Hi)) << 32 \| (uint32_t)(Lo) )
860
861	/** @def RT_MAKE_U64_FROM_U16
862	* Constructs a uint64_t value from four uint16_t values.
863	*/
864	#define RT_MAKE_U64_FROM_U16(w0, w1, w2, w3) \
865	( (uint64_t)((uint16_t)(w3)) << 48 \
866	\| (uint64_t)((uint16_t)(w2)) << 32 \
867	\| (uint32_t)((uint16_t)(w1)) << 16 \
868	\| (uint16_t)(w0) )
869
870	/** @def RT_MAKE_U64_FROM_U8
871	* Constructs a uint64_t value from eight uint8_t values.
872	*/
873	#define RT_MAKE_U64_FROM_U8(b0, b1, b2, b3, b4, b5, b6, b7) \
874	( (uint64_t)((uint8_t)(b7)) << 56 \
875	\| (uint64_t)((uint8_t)(b6)) << 48 \
876	\| (uint64_t)((uint8_t)(b5)) << 40 \
877	\| (uint64_t)((uint8_t)(b4)) << 32 \
878	\| (uint32_t)((uint8_t)(b3)) << 24 \
879	\| (uint32_t)((uint8_t)(b2)) << 16 \
880	\| (uint16_t)((uint8_t)(b1)) << 8 \
881	\| (uint8_t)(b0) )
882
883	/** @def RT_MAKE_U32
884	* Constructs a uint32_t value from two uint16_t values.
885	*/
886	#define RT_MAKE_U32(Lo, Hi) ( (uint32_t)((uint16_t)(Hi)) << 16 \| (uint16_t)(Lo) )
887
888	/** @def RT_MAKE_U32_FROM_U8
889	* Constructs a uint32_t value from four uint8_t values.
890	*/
891	#define RT_MAKE_U32_FROM_U8(b0, b1, b2, b3) \
892	( (uint32_t)((uint8_t)(b3)) << 24 \
893	\| (uint32_t)((uint8_t)(b2)) << 16 \
894	\| (uint16_t)((uint8_t)(b1)) << 8 \
895	\| (uint8_t)(b0) )
896	/** @todo remove this after uses in VUSBUrb.cpp has been corrected. */
897	#define MAKE_U32_FROM_U8(b0,b1,b2,b3) RT_MAKE_U32_FROM_U8(b0,b1,b2,b3)
898
899	/** @def RT_MAKE_U16
900	* Constructs a uint32_t value from two uint16_t values.
901	*/
902	#define RT_MAKE_U16(Lo, Hi) ( (uint16_t)((uint8_t)(Hi)) << 8 \| (uint8_t)(Lo) )
903
904
905	/** @def RT_H2LE_U64
906	* Converts uint64_t value from host to little endian byte order. */
907	#define RT_H2LE_U64(u64) (u64)
908
909	/** @def RT_H2LE_U32
910	* Converts uint32_t value from host to little endian byte order. */
911	#define RT_H2LE_U32(u32) (u32)
912
913	/** @def RT_H2LE_U16
914	* Converts uint16_t value from host to little endian byte order. */
915	#define RT_H2LE_U16(u16) (u16)
916
917	/** @def RT_LE2H_U64
918	* Converts uint64_t value from little endian to host byte order. */
919	#define RT_LE2H_U64(u64) (u64)
920
921	/** @def RT_LE2H_U32
922	* Converts uint32_t value from little endian to host byte order. */
923	#define RT_LE2H_U32(u32) (u32)
924
925	/** @def RT_LE2H_U16
926	* Converts uint16_t value from little endian to host byte order. */
927	#define RT_LE2H_U16(u16) (u16)
928
929
930	/** @def RT_H2BE_U64
931	* Converts uint64_t value from host to big endian byte order. */
932	#define RT_H2BE_U64(u64) RT_MAKE_U64_FROM_U32(RT_H2BE_U32((u64) >> 32), RT_H2BE_U32((u64) & 0xffffffff))
933
934	/** @def RT_H2BE_U32
935	* Converts uint32_t value from host to big endian byte order. */
936	#define RT_H2BE_U32(u32) (RT_BYTE4(u32) \| (RT_BYTE3(u32) << 8) \| (RT_BYTE2(u32) << 16) \| (RT_BYTE1(u32) << 24))
937
938	/** @def RT_H2BE_U16
939	* Converts uint16_t value from host to big endian byte order. */
940	#define RT_H2BE_U16(u16) (RT_HIBYTE(u16) \| (RT_LOBYTE(u16) << 8))
941
942	/** @def RT_BE2H_U64
943	* Converts uint64_t value from big endian to host byte order. */
944	#define RT_BE2H_U64(u64) RT_MAKE_U64_FROM_U32(RT_H2BE_U32((u64) >> 32), RT_H2BE_U32((u64) & 0xffffffff))
945
946	/** @def RT_BE2H_U32
947	* Converts uint32_t value from big endian to host byte order. */
948	#define RT_BE2H_U32(u32) (RT_BYTE4(u32) \| (RT_BYTE3(u32) << 8) \| (RT_BYTE2(u32) << 16) \| (RT_BYTE1(u32) << 24))
949
950	/** @def RT_BE2H_U16
951	* Converts uint16_t value from big endian to host byte order. */
952	#define RT_BE2H_U16(u16) (RT_HIBYTE(u16) \| (RT_LOBYTE(u16) << 8))
953
954
955	/** @def RT_H2N_U32
956	* Converts uint32_t value from host to network byte order. */
957	#define RT_H2N_U32(u32) RT_H2BE_U32(u32)
958
959	/** @def RT_H2N_U16
960	* Converts uint16_t value from host to network byte order. */
961	#define RT_H2N_U16(u16) RT_H2BE_U16(u16)
962
963	/** @def RT_N2H_U32
964	* Converts uint32_t value from network to host byte order. */
965	#define RT_N2H_U32(u32) RT_BE2H_U32(u32)
966
967	/** @def RT_N2H_U16
968	* Converts uint16_t value from network to host byte order. */
969	#define RT_N2H_U16(u16) RT_BE2H_U16(u16)
970
971
972	/** @def RT_NO_DEPRECATED_MACROS
973	* Define RT_NO_DEPRECATED_MACROS to not define deprecated macros.
974	*/
975	#ifndef RT_NO_DEPRECATED_MACROS
976	/** @copydoc BIT
977	* @deprecated Use RT_BIT.
978	*/
979	# define BIT(bit) RT_BIT(bit)
980	/** @deprecated Use RT_BIT64. */
981	# define BIT64(bit) (1ULL << (bit))
982	/** @copydoc RT_ALIGN_P
983	* @deprecated use RT_ALIGN_P. */
984	# define ALIGNP(pv, uAlignment) RT_ALIGN_P(pv, uAlignment)
985	/** @copydoc RT_SIZEOFMEMB
986	* @deprecated Use RT_SIZEOFMEMB. */
987	# define SIZEOFMEMB(type, member) RT_SIZEOFMEMB(type, member)
988	/** @copydoc RT_ELEMENTS
989	* @deprecated use RT_ELEMENTS. */
990	# define ELEMENTS(aArray) RT_ELEMENTS(aArray)
991	#endif
992
993
994	/*
995	* The BSD sys/param.h + machine/param.h file is a major source of
996	* namespace pollution. Kill off some of the worse ones unless we're
997	* compiling kernel code.
998	*/
999	#if defined(__DARWIN__) \
1000	&& !defined(KERNEL) \
1001	&& !defined(RT_NO_BSD_PARAM_H_UNDEFING) \
1002	&& ( defined(_SYS_PARAM_H_) \|\| defined(_I386_PARAM_H_) )
1003	/* sys/param.h: */
1004	# undef PSWP
1005	# undef PVM
1006	# undef PINOD
1007	# undef PRIBO
1008	# undef PVFS
1009	# undef PZERO
1010	# undef PSOCK
1011	# undef PWAIT
1012	# undef PLOCK
1013	# undef PPAUSE
1014	# undef PUSER
1015	# undef PRIMASK
1016	# undef MINBUCKET
1017	# undef MAXALLOCSAVE
1018	# undef FSHIFT
1019	# undef FSCALE
1020
1021	/* i386/machine.h: */
1022	# undef ALIGN
1023	# undef ALIGNBYTES
1024	# undef DELAY
1025	# undef STATUS_WORD
1026	# undef USERMODE
1027	# undef BASEPRI
1028	# undef MSIZE
1029	# undef CLSIZE
1030	# undef CLSIZELOG2
1031	#endif
1032
1033
1034	/** @def NULL
1035	* NULL pointer.
1036	*/
1037	#ifndef NULL
1038	# ifdef __cplusplus
1039	# define NULL 0
1040	# else
1041	# define NULL ((void*)0)
1042	# endif
1043	#endif
1044
1045	/** @def NIL_OFFSET
1046	* NIL offset.
1047	* Whenever we use offsets instead of pointers to save space and relocation effort
1048	* NIL_OFFSET shall be used as the equivalent to NULL.
1049	*/
1050	#define NIL_OFFSET (~0U)
1051
1052	/** @def NOREF
1053	* Keeps the compiler from bitching about an unused parameters.
1054	*/
1055	#define NOREF(var) (void)(var)
1056
1057	/** @def Breakpoint
1058	* Emit a debug breakpoint instruction.
1059	*
1060	* Use this for instrumenting a debugging session only!
1061	* No comitted code shall use Breakpoint().
1062	*/
1063	#ifdef __GNUC__
1064	# define Breakpoint() __asm__ __volatile__("int $3\n\t")
1065	#endif
1066	#ifdef _MSC_VER
1067	# define Breakpoint() __asm int 3
1068	#endif
1069	#ifndef Breakpoint
1070	# error "This compiler is not supported!"
1071	#endif
1072
1073
1074	/** Size Constants
1075	* (Of course, these are binary computer terms, not SI.)
1076	* @{
1077	*/
1078	/** 1 K (Kilo) (1 024). */
1079	#define _1K 0x00000400
1080	/** 4 K (Kilo) (4 096). */
1081	#define _4K 0x00001000
1082	/** 32 K (Kilo) (32 678). */
1083	#define _32K 0x00008000
1084	/** 64 K (Kilo) (65 536). */
1085	#define _64K 0x00010000
1086	/** 128 K (Kilo) (131 072). */
1087	#define _128K 0x00020000
1088	/** 256 K (Kilo) (262 144). */
1089	#define _256K 0x00040000
1090	/** 512 K (Kilo) (524 288). */
1091	#define _512K 0x00080000
1092	/** 1 M (Mega) (1 048 576). */
1093	#define _1M 0x00100000
1094	/** 2 M (Mega) (2 097 152). */
1095	#define _2M 0x00200000
1096	/** 4 M (Mega) (4 194 304). */
1097	#define _4M 0x00400000
1098	/** 1 G (Giga) (1 073 741 824). */
1099	#define _1G 0x40000000
1100	/** 2 G (Giga) (2 147 483 648). (32-bit) */
1101	#define _2G32 0x80000000U
1102	/** 2 G (Giga) (2 147 483 648). (64-bit) */
1103	#define _2G 0x0000000080000000LL
1104	/** 4 G (Giga) (4 294 967 296). */
1105	#define _4G 0x0000000100000000LL
1106	/** 1 T (Tera) (1 099 511 627 776). */
1107	#define _1T 0x0000010000000000LL
1108	/** 1 P (Peta) (1 125 899 906 842 624). */
1109	#define _1P 0x0004000000000000LL
1110	/** 1 E (Exa) (1 152 921 504 606 846 976). */
1111	#define _1E 0x1000000000000000LL
1112	/** 2 E (Exa) (2 305 843 009 213 693 952). */
1113	#define _2E 0x2000000000000000ULL
1114	/** @} */
1115
1116	/** @def VALID_PTR
1117	* Pointer validation macro.
1118	* @param ptr
1119	*/
1120	#if defined(__AMD64__)
1121	# ifdef IN_RING3
1122	# if defined(__DARWIN__) /* first 4GB is reserved for legacy kernel. */
1123	# define VALID_PTR(ptr) ( (uintptr_t)(ptr) >= _4G \
1124	&& !((uintptr_t)(ptr) & 0xffff800000000000ULL) )
1125	# else
1126	# define VALID_PTR(ptr) ( (uintptr_t)(ptr) + 0x1000U >= 0x2000U \
1127	&& !((uintptr_t)(ptr) & 0xffff800000000000ULL) )
1128	# endif
1129	# else /* !IN_RING3 */
1130	# define VALID_PTR(ptr) ( (uintptr_t)(ptr) + 0x1000U >= 0x2000U \
1131	&& ( ((uintptr_t)(ptr) & 0xffff800000000000ULL) == 0xffff800000000000ULL \
1132	\|\| ((uintptr_t)(ptr) & 0xffff800000000000ULL) == 0) )
1133	# endif /* !IN_RING3 */
1134	#elif defined(__X86__)
1135	# define VALID_PTR(ptr) ( (uintptr_t)(ptr) + 0x1000U >= 0x2000U )
1136	#else
1137	# error "Architecture identifier missing / not implemented."
1138	#endif
1139
1140
1141	/** @def N_
1142	* The \#define N_ is used mark a string for translation. This is usable in
1143	* any part of the code, as it is only used by the tools that create message
1144	* catalogs. This macro is a no-op as far as the compiler and code generation
1145	* is concerned.
1146	*
1147	* If you want to both mark a string for translation and translate it, use _.
1148	*/
1149	#define N_(s) (s)
1150
1151	/** @def _
1152	* The \#define _ is used mark a string for translation and to translate it in
1153	* one step.
1154	*
1155	* If you want to only mark a string for translation, use N_.
1156	*/
1157	#define _(s) gettext(s)
1158
1159
1160	/** @def __PRETTY_FUNCTION__
1161	* With GNU C we'd like to use the builtin __PRETTY_FUNCTION__, so define that for the other compilers.
1162	*/
1163	#if !defined(__GNUC__) && !defined(__PRETTY_FUNCTION__)
1164	# define __PRETTY_FUNCTION__ __FUNCTION__
1165	#endif
1166
1167
1168	/** @def RT_STRICT
1169	* The \#define RT_STRICT controls whether or not assertions and other runtime checks
1170	* should be compiled in or not.
1171	*
1172	* If you want assertions which are not a subject to compile time options use
1173	* the AssertRelease*() flavors.
1174	*/
1175	#if !defined(RT_STRICT) && defined(DEBUG)
1176	# define RT_STRICT
1177	#endif
1178
1179	/** Source position. */
1180	#define RT_SRC_POS __FILE__, __LINE__, __PRETTY_FUNCTION__
1181
1182	/** Source position declaration. */
1183	#define RT_SRC_POS_DECL const char pszFile, unsigned iLine, const char pszFunction
1184
1185	/** Source position arguments. */
1186	#define RT_SRC_POS_ARGS pszFile, iLine, pszFunction
1187
1188	/** @} */
1189
1190
1191	/** @defgroup grp_rt_cdefs_cpp Special Macros for C++
1192	* @ingroup grp_rt_cdefs
1193	* @{
1194	*/
1195
1196	#ifdef __cplusplus
1197
1198	/** @def WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP
1199	* Macro to work around error C2593 of the not-so-smart MSVC 7.x ambiguity
1200	* resolver. The following snippet clearly demonstrates the code causing this
1201	* error:
1202	* @code
1203	* class A
1204	* {
1205	* public:
1206	* operator bool() const { return false; }
1207	* operator int*() const { return NULL; }
1208	* };
1209	* int main()
1210	* {
1211	* A a;
1212	* if (!a);
1213	* if (a && 0);
1214	* return 0;
1215	* }
1216	* @endcode
1217	* The code itself seems pretty valid to me and GCC thinks the same.
1218	*
1219	* This macro fixes the compiler error by explicitly overloading implicit
1220	* global operators !, && and \|\| that take the given class instance as one of
1221	* their arguments.
1222	*
1223	* The best is to use this macro right after the class declaration.
1224	*
1225	* @note The macro expands to nothing for compilers other than MSVC.
1226	*
1227	* @param Cls Class to apply the workaround to
1228	*/
1229	#if defined(_MSC_VER)
1230	# define WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP(Cls) \
1231	inline bool operator! (const Cls &that) { return !bool (that); } \
1232	inline bool operator&& (const Cls &that, bool b) { return bool (that) && b; } \
1233	inline bool operator\|\| (const Cls &that, bool b) { return bool (that) \|\| b; } \
1234	inline bool operator&& (bool b, const Cls &that) { return b && bool (that); } \
1235	inline bool operator\|\| (bool b, const Cls &that) { return b \|\| bool (that); }
1236	#else
1237	# define WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP(Cls)
1238	#endif
1239
1240	/** @def WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP_TPL
1241	* Version of WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP for template classes.
1242	*
1243	* @param Tpl Name of the template class to apply the workaround to
1244	* @param ArgsDecl arguments of the template, as declared in \|<>\| after the
1245	* \|template\| keyword, including \|<>\|
1246	* @param Args arguments of the template, as specified in \|<>\| after the
1247	* template class name when using the, including \|<>\|
1248	*
1249	* Example:
1250	* @code
1251	* // template class declaration
1252	* template <class C>
1253	* class Foo { ... };
1254	* // applied workaround
1255	* WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP_TPL (Foo, <class C>, <C>)
1256	* @endcode
1257	*/
1258	#if defined(_MSC_VER)
1259	# define WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP_TPL(Tpl, ArgsDecl, Args) \
1260	template ArgsDecl \
1261	inline bool operator! (const Tpl Args &that) { return !bool (that); } \
1262	template ArgsDecl \
1263	inline bool operator&& (const Tpl Args &that, bool b) { return bool (that) && b; } \
1264	template ArgsDecl \
1265	inline bool operator\|\| (const Tpl Args &that, bool b) { return bool (that) \|\| b; } \
1266	template ArgsDecl \
1267	inline bool operator&& (bool b, const Tpl Args &that) { return b && bool (that); } \
1268	template ArgsDecl \
1269	inline bool operator\|\| (bool b, const Tpl Args &that) { return b \|\| bool (that); }
1270	#else
1271	# define WORKAROUND_MSVC7_ERROR_C2593_FOR_BOOL_OP_TPL(Tpl, ArgsDecl, Args)
1272	#endif
1273
1274
1275	/** @def DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP
1276	* Declares the copy constructor and the assignment operation as inlined no-ops
1277	* (non-existent functions) for the given class. Use this macro inside the
1278	* private section if you want to effectively disable these operations for your
1279	* class.
1280	*
1281	* @param Cls class name to declare for
1282	*/
1283
1284	#define DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(Cls) \
1285	inline Cls (const Cls &); \
1286	inline Cls &operator= (const Cls &);
1287
1288
1289	/** @def DECLARE_CLS_NEW_DELETE_NOOP
1290	* Declares the new and delete operations as no-ops (non-existent functions)
1291	* for the given class. Use this macro inside the private section if you want
1292	* to effectively limit creating class instances on the stack only.
1293	*
1294	* @note The destructor of the given class must not be virtual, otherwise a
1295	* compile time error will occur. Note that this is not a drawback: having
1296	* the virtual destructor for a stack-based class is absolutely useless
1297	* (the real class of the stack-based instance is always known to the compiler
1298	* at compile time, so it will always call the correct destructor).
1299	*
1300	* @param Cls class name to declare for
1301	*/
1302	#define DECLARE_CLS_NEW_DELETE_NOOP(Cls) \
1303	inline static void *operator new (size_t); \
1304	inline static void operator delete (void *);
1305
1306	#endif /* defined(__cplusplus) */
1307
1308	/** @} */
1309
1310	#endif
1311

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

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

Download in other formats: