/[pcsx2_0.9.7]/branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/debug.h
ViewVC logotype

Contents of /branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/debug.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 32 - (show annotations) (download)
Tue Sep 7 03:29:01 2010 UTC (9 years, 5 months ago) by william
File MIME type: text/plain
File size: 13885 byte(s)
branching from upstream revision (http://pcsx2.googlecode.com/svn/trunk
): r3113 to
https://svn.netsolutions.dnsalias.com/websvn/ps2/pcsx2/pcsx2_0.9.7/branch/r3113_0.9.7_beta
1 /**
2 * Name: wx/debug.h
3 * Purpose: Misc debug functions and macros
4 * Author: Vadim Zeitlin
5 * Modified by: Ryan Norton (Converted to C)
6 * Created: 29/01/98
7 * RCS-ID: $Id: debug.h 54492 2008-07-05 17:54:03Z SN $
8 * Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 * Licence: wxWindows licence
10 */
11
12 /* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
13
14 #ifndef _WX_DEBUG_H_
15 #define _WX_DEBUG_H_
16
17 #ifndef __WXWINCE__
18 #include <assert.h>
19 #endif
20 #include <limits.h> /* for CHAR_BIT used below */
21
22 #include "wx/wxchar.h" /* for __TFILE__ and wxChar */
23
24 /* ---------------------------------------------------------------------------- */
25 /* Defines controlling the debugging macros */
26 /* ---------------------------------------------------------------------------- */
27
28 /* if _DEBUG is defined (MS VC++ and others use it in debug builds), define */
29 /* __WXDEBUG__ too */
30 #ifdef _DEBUG
31 #ifndef __WXDEBUG__
32 #define __WXDEBUG__
33 #endif /* !__WXDEBUG__ */
34 #endif /* _DEBUG */
35
36 /* if NDEBUG is defined (<assert.h> uses it), undef __WXDEBUG__ and WXDEBUG */
37 #ifdef NDEBUG
38 #undef __WXDEBUG__
39 #undef WXDEBUG
40 #endif /* NDEBUG */
41
42 /* if __WXDEBUG__ is defined, make sure that WXDEBUG is defined and >= 1 */
43 #ifdef __WXDEBUG__
44 #if !defined(WXDEBUG) || !WXDEBUG
45 #undef WXDEBUG
46 #define WXDEBUG 1
47 #endif /* !WXDEBUG */
48 #endif /* __WXDEBUG__ */
49
50 #ifndef __WXFUNCTION__
51 /* TODO: add more compilers supporting __FUNCTION__ */
52 #if defined(__DMC__)
53 /*
54 __FUNCTION__ happens to be not defined within class members
55 http://www.digitalmars.com/drn-bin/wwwnews?c%2B%2B.beta/485
56 */
57 #define __WXFUNCTION__ (NULL)
58 #elif defined(__GNUC__) || \
59 (defined(_MSC_VER) && _MSC_VER >= 1300) || \
60 defined(__FUNCTION__)
61 #define __WXFUNCTION__ __FUNCTION__
62 #else
63 /* still define __WXFUNCTION__ to avoid #ifdefs elsewhere */
64 #define __WXFUNCTION__ (NULL)
65 #endif
66 #endif /* __WXFUNCTION__ already defined */
67
68 /* ---------------------------------------------------------------------------- */
69 /* Debugging macros */
70 /* */
71 /* All debugging macros rely on ASSERT() which in turn calls the user-defined */
72 /* OnAssert() function. To keep things simple, it's called even when the */
73 /* expression is true (i.e. everything is ok) and by default does nothing: just */
74 /* returns the same value back. But if you redefine it to do something more sexy */
75 /* (popping up a message box in your favourite GUI, sending you e-mail or */
76 /* whatever) it will affect all ASSERTs, FAILs and CHECKs in your code. */
77 /* */
78 /* Warning: if you don't like advice on programming style, don't read */
79 /* further! ;-) */
80 /* */
81 /* Extensive use of these macros is recommended! Remember that ASSERTs are */
82 /* disabled in final build (without __WXDEBUG__ defined), so they add strictly */
83 /* nothing to your program's code. On the other hand, CHECK macros do stay */
84 /* even in release builds, but in general are not much of a burden, while */
85 /* a judicious use of them might increase your program's stability. */
86 /* ---------------------------------------------------------------------------- */
87
88 /* Macros which are completely disabled in 'release' mode */
89 /* */
90 /* NB: these functions are implemented in src/common/appcmn.cpp */
91 #if defined(__cplusplus) && defined(__WXDEBUG__)
92 /*
93 This function is called whenever one of debugging macros fails (i.e.
94 condition is false in an assertion). To customize its behaviour, override
95 wxApp::OnAssert().
96
97 Parameters:
98 szFile and nLine - file name and line number of the ASSERT
99 szFunc - function name of the ASSERT, may be NULL (NB: ASCII)
100 szCond - text form of the condition which failed
101 szMsg - optional message explaining the reason
102 */
103 extern void WXDLLIMPEXP_BASE wxOnAssert(const wxChar *szFile,
104 int nLine,
105 const char *szFunc,
106 const wxChar *szCond,
107 const wxChar *szMsg = NULL);
108
109 /* call this function to break into the debugger unconditionally (assuming */
110 /* the program is running under debugger, of course) */
111 extern void WXDLLIMPEXP_BASE wxTrap();
112
113 /* generic assert macro */
114 #define wxASSERT(cond) wxASSERT_MSG(cond, NULL)
115
116
117 /* assert with additional message explaining its cause */
118
119 /* compilers can give a warning (such as "possible unwanted ;") when using */
120 /* the default definition of wxASSERT_MSG so we provide an alternative */
121 #if defined(__MWERKS__)
122 #define wxASSERT_MSG(cond, msg) \
123 if ( cond ) \
124 {} \
125 else \
126 wxOnAssert(__TFILE__, __LINE__, __WXFUNCTION__, _T(#cond), msg)
127 #else
128 #define wxASSERT_MSG(cond, msg) \
129 if ( cond ) \
130 ; \
131 else \
132 wxOnAssert(__TFILE__, __LINE__, __WXFUNCTION__, _T(#cond), msg)
133 #endif
134
135 /* special form of assert: always triggers it (in debug mode) */
136 #define wxFAIL wxFAIL_MSG(NULL)
137
138 /* FAIL with some message */
139 #define wxFAIL_MSG(msg) wxFAIL_COND_MSG("wxAssertFailure", msg)
140
141 /* FAIL with some message and a condition */
142 #define wxFAIL_COND_MSG(cond, msg) \
143 wxOnAssert(__TFILE__, __LINE__, __WXFUNCTION__, _T(cond), msg)
144
145 /* An assert helper used to avoid warning when testing constant expressions, */
146 /* i.e. wxASSERT( sizeof(int) == 4 ) can generate a compiler warning about */
147 /* expression being always true, but not using */
148 /* wxASSERT( wxAssertIsEqual(sizeof(int), 4) ) */
149 /* */
150 /* NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and should no */
151 /* longer be used. */
152 extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y);
153 #else
154 #define wxTrap()
155
156 /* nothing to do in release mode (hopefully at this moment there are */
157 /* no more bugs ;-) */
158 #define wxASSERT(cond)
159 #define wxASSERT_MSG(cond, msg)
160 #define wxFAIL
161 #define wxFAIL_MSG(msg)
162 #define wxFAIL_COND_MSG(cond, msg)
163 #endif /* __WXDEBUG__ */
164
165 #ifdef __cplusplus
166 /* Use of wxFalse instead of false suppresses compiler warnings about testing */
167 /* constant expression */
168 extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
169 #endif
170
171 #define wxAssertFailure wxFalse
172
173 /* NB: the following macros also work in release mode! */
174
175 /*
176 These macros must be used only in invalid situation: for example, an
177 invalid parameter (e.g. a NULL pointer) is passed to a function. Instead of
178 dereferencing it and causing core dump the function might try using
179 CHECK( p != NULL ) or CHECK( p != NULL, return LogError("p is NULL!!") )
180 */
181
182 /* check that expression is true, "return" if not (also FAILs in debug mode) */
183 #define wxCHECK(cond, rc) wxCHECK_MSG(cond, rc, NULL)
184
185 /* as wxCHECK but with a message explaining why we fail */
186 #define wxCHECK_MSG(cond, rc, msg) wxCHECK2_MSG(cond, return rc, msg)
187
188 /* check that expression is true, perform op if not */
189 #define wxCHECK2(cond, op) wxCHECK2_MSG(cond, op, NULL)
190
191 /* as wxCHECK2 but with a message explaining why we fail */
192
193 #ifdef __GNUC__
194 #define wxFORCE_SEMICOLON typedef int wxDummyCheckInt
195 /* Note: old gcc versions (e.g. 2.8) give an internal compiler error */
196 /* on a simple forward declaration, when used in a template */
197 /* function, so rather use a dummy typedef which does work... */
198 #else
199 #define wxFORCE_SEMICOLON struct wxDummyCheckStruct
200 /* Note2: however, some other compilers (notably Digital Mars */
201 /* don't like multiple typedefs (even though the standard */
202 /* does allow them), so use a forward declaration for non-gcc. */
203 #endif
204 /* see comment near the definition of wxASSERT_MSG for the # if/else reason */
205 #if defined(__MWERKS__)
206 #define wxCHECK2_MSG(cond, op, msg) \
207 if ( cond ) \
208 {} \
209 else \
210 { \
211 wxFAIL_COND_MSG(#cond, msg); \
212 op; \
213 } \
214 struct wxDummyCheckStruct /* just to force a semicolon */
215 #else
216 #define wxCHECK2_MSG(cond, op, msg) \
217 if ( cond ) \
218 ; \
219 else \
220 { \
221 wxFAIL_COND_MSG(#cond, msg); \
222 op; \
223 } \
224 wxFORCE_SEMICOLON /* just to force a semicolon */
225 #endif
226
227 /* special form of wxCHECK2: as wxCHECK, but for use in void functions */
228 /* */
229 /* NB: there is only one form (with msg parameter) and it's intentional: */
230 /* there is no other way to tell the caller what exactly went wrong */
231 /* from the void function (of course, the function shouldn't be void */
232 /* to begin with...) */
233 #define wxCHECK_RET(cond, msg) wxCHECK2_MSG(cond, return, msg)
234
235 /* ---------------------------------------------------------------------------- */
236 /* Compile time asserts */
237 /* */
238 /* Unlike the normal assert and related macros above which are checked during */
239 /* the program tun-time the macros below will result in a compilation error if */
240 /* the condition they check is false. This is usually used to check the */
241 /* expressions containing sizeof()s which cannot be tested with the */
242 /* preprocessor. If you can use the #if's, do use them as you can give a more */
243 /* detailed error message then. */
244 /* ---------------------------------------------------------------------------- */
245
246 /*
247 How this works (you don't have to understand it to be able to use the
248 macros): we rely on the fact that it is invalid to define a named bit field
249 in a struct of width 0. All the rest are just the hacks to minimize the
250 possibility of the compiler warnings when compiling this macro: in
251 particular, this is why we define a struct and not an object (which would
252 result in a warning about unused variable) and a named struct (otherwise we'd
253 get a warning about an unnamed struct not used to define an object!).
254 */
255
256 #define wxMAKE_UNIQUE_ASSERT_NAME wxMAKE_UNIQUE_NAME(wxAssert_)
257
258 /*
259 The second argument of this macro must be a valid C++ identifier and not a
260 string. I.e. you should use it like this:
261
262 wxCOMPILE_TIME_ASSERT( sizeof(int) >= 2, YourIntsAreTooSmall );
263
264 It may be used both within a function and in the global scope.
265 */
266 #if defined(__WATCOMC__) && defined(__cplusplus)
267 /* avoid "unused symbol" warning */
268 #define wxCOMPILE_TIME_ASSERT(expr, msg) \
269 class wxMAKE_UNIQUE_ASSERT_NAME { \
270 unsigned int msg: expr; \
271 wxMAKE_UNIQUE_ASSERT_NAME() { wxUnusedVar(msg); } \
272 }
273 #else
274 #define wxCOMPILE_TIME_ASSERT(expr, msg) \
275 struct wxMAKE_UNIQUE_ASSERT_NAME { unsigned int msg: expr; }
276 #endif
277
278 /*
279 When using VC++ 6 with "Edit and Continue" on, the compiler completely
280 mishandles __LINE__ and so wxCOMPILE_TIME_ASSERT() doesn't work, provide a
281 way to make "unique" assert names by specifying a unique prefix explicitly
282 */
283 #define wxMAKE_UNIQUE_ASSERT_NAME2(text) wxCONCAT(wxAssert_, text)
284
285 #define wxCOMPILE_TIME_ASSERT2(expr, msg, text) \
286 struct wxMAKE_UNIQUE_ASSERT_NAME2(text) { unsigned int msg: expr; }
287
288 /* helpers for wxCOMPILE_TIME_ASSERT below, for private use only */
289 #define wxMAKE_BITSIZE_MSG(type, size) type ## SmallerThan ## size ## Bits
290
291 /* a special case of compile time assert: check that the size of the given type */
292 /* is at least the given number of bits */
293 #define wxASSERT_MIN_BITSIZE(type, size) \
294 wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \
295 wxMAKE_BITSIZE_MSG(type, size))
296
297 /* ---------------------------------------------------------------------------- */
298 /* other miscellaneous debugger-related functions */
299 /* ---------------------------------------------------------------------------- */
300
301 /*
302 Return true if we're running under debugger.
303
304 Currently this only really works under Win32 and Mac in CodeWarrior builds,
305 it always returns false in other cases.
306 */
307 #ifdef __cplusplus
308 /* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */
309 #if defined(__WXMAC__) || defined(__WIN32__)
310 extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning();
311 #else /* !Mac */
312 inline bool wxIsDebuggerRunning() { return false; }
313 #endif /* Mac/!Mac */
314 #endif /* __cplusplus */
315
316 #endif /* _WX_DEBUG_H_ */

  ViewVC Help
Powered by ViewVC 1.1.22