3 * Purpose: Misc debug functions and macros
4 * Author: Vadim Zeitlin
5 * Modified by: Ryan Norton (Converted to C)
8 * Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 * Licence: wxWindows licence
12 /* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
20 #include <limits.h> /* for CHAR_BIT used below */
22 #include "wx/chartype.h" /* for __TFILE__ and wxChar */
24 /* ---------------------------------------------------------------------------- */
25 /* Defines controlling the debugging macros */
26 /* ---------------------------------------------------------------------------- */
28 /* if _DEBUG is defined (MS VC++ and others use it in debug builds), define */
33 #endif /* !__WXDEBUG__ */
36 /* if NDEBUG is defined (<assert.h> uses it), undef __WXDEBUG__ and WXDEBUG */
42 /* if __WXDEBUG__ is defined, make sure that WXDEBUG is defined and >= 1 */
44 #if !defined(WXDEBUG) || !WXDEBUG
48 #endif /* __WXDEBUG__ */
50 #ifndef __WXFUNCTION__
51 /* TODO: add more compilers supporting __FUNCTION__ */
54 __FUNCTION__ happens to be not defined within class members
55 http://www.digitalmars.com/drn-bin/wwwnews?c%2B%2B.beta/485
57 #define __WXFUNCTION__ (NULL)
58 #elif defined(__GNUC__) || \
59 (defined(_MSC_VER) && _MSC_VER >= 1300) || \
61 #define __WXFUNCTION__ __FUNCTION__
63 /* still define __WXFUNCTION__ to avoid #ifdefs elsewhere */
64 #define __WXFUNCTION__ (NULL)
66 #endif /* __WXFUNCTION__ already defined */
68 /* ---------------------------------------------------------------------------- */
69 /* Debugging macros */
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. */
78 /* Warning: if you don't like advice on programming style, don't read */
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 /* ---------------------------------------------------------------------------- */
88 /* Macros which are completely disabled in 'release' mode */
90 /* NB: these functions are implemented in src/common/appcmn.cpp */
91 #if defined(__cplusplus) && defined(__WXDEBUG__)
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
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
104 /* this version is for compatibility with wx 2.8: */
105 extern void WXDLLIMPEXP_BASE
wxOnAssert(const wxChar
*szFile
,
108 const wxChar
*szCond
,
109 const wxChar
*szMsg
= NULL
);
112 /* char versions are used by debugging macros; we have to provide
113 wxChar* szMsg version because it's common to use _T() in the macros
114 and finally, we can't use const wx(char)* szMsg = NULL, because that
115 would be ambiguous: */
116 extern void WXDLLIMPEXP_BASE
wxOnAssert(const char *szFile
,
121 extern void WXDLLIMPEXP_BASE
wxOnAssert(const char *szFile
,
127 extern void WXDLLIMPEXP_BASE
wxOnAssert(const char *szFile
,
131 const wxChar
*szMsg
);
132 #endif // wxUSE_UNICODE
134 class WXDLLIMPEXP_BASE wxString
;
135 /* these two work when szMsg passed to debug macro is a string: */
136 extern void WXDLLIMPEXP_BASE
wxOnAssert(const wxString
& szFile
,
138 const wxString
& szFunc
,
139 const wxString
& szCond
,
140 const wxString
& szMsg
);
142 extern void WXDLLIMPEXP_BASE
wxOnAssert(const wxString
& szFile
,
144 const wxString
& szFunc
,
145 const wxString
& szCond
);
147 /* call this function to break into the debugger unconditionally (assuming */
148 /* the program is running under debugger, of course) */
149 extern void WXDLLIMPEXP_BASE
wxTrap();
151 /* generic assert macro */
152 #define wxASSERT(cond) wxASSERT_MSG(cond, (const char*)NULL)
155 /* assert with additional message explaining its cause */
157 /* compilers can give a warning (such as "possible unwanted ;") when using */
158 /* the default definition of wxASSERT_MSG so we provide an alternative */
159 #if defined(__MWERKS__)
160 #define wxASSERT_MSG(cond, msg) \
164 wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg)
166 #define wxASSERT_MSG(cond, msg) \
170 wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg)
173 /* special form of assert: always triggers it (in debug mode) */
174 #define wxFAIL wxFAIL_MSG((const char*)NULL)
176 /* FAIL with some message */
177 #define wxFAIL_MSG(msg) wxFAIL_COND_MSG("wxAssertFailure", msg)
179 /* FAIL with some message and a condition */
180 #define wxFAIL_COND_MSG(cond, msg) \
181 wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, cond, msg)
183 /* An assert helper used to avoid warning when testing constant expressions, */
184 /* i.e. wxASSERT( sizeof(int) == 4 ) can generate a compiler warning about */
185 /* expression being always true, but not using */
186 /* wxASSERT( wxAssertIsEqual(sizeof(int), 4) ) */
188 /* NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and should no */
189 /* longer be used. */
190 extern bool WXDLLIMPEXP_BASE
wxAssertIsEqual(int x
, int y
);
194 /* nothing to do in release mode (hopefully at this moment there are */
195 /* no more bugs ;-) */
196 #define wxASSERT(cond)
197 #define wxASSERT_MSG(cond, msg)
199 #define wxFAIL_MSG(msg)
200 #define wxFAIL_COND_MSG(cond, msg)
201 #endif /* __WXDEBUG__ */
204 /* Use of wxFalse instead of false suppresses compiler warnings about testing */
205 /* constant expression */
206 extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse
;
209 #define wxAssertFailure wxFalse
211 /* NB: the following macros also work in release mode! */
214 These macros must be used only in invalid situation: for example, an
215 invalid parameter (e.g. a NULL pointer) is passed to a function. Instead of
216 dereferencing it and causing core dump the function might try using
217 CHECK( p != NULL ) or CHECK( p != NULL, return LogError("p is NULL!!") )
220 /* check that expression is true, "return" if not (also FAILs in debug mode) */
221 #define wxCHECK(cond, rc) wxCHECK_MSG(cond, rc, (const char*)NULL)
223 /* as wxCHECK but with a message explaining why we fail */
224 #define wxCHECK_MSG(cond, rc, msg) wxCHECK2_MSG(cond, return rc, msg)
226 /* check that expression is true, perform op if not */
227 #define wxCHECK2(cond, op) wxCHECK2_MSG(cond, op, (const char*)NULL)
229 /* as wxCHECK2 but with a message explaining why we fail */
231 /* see comment near the definition of wxASSERT_MSG for the # if/else reason */
232 #if defined(__MWERKS__)
233 #define wxCHECK2_MSG(cond, op, msg) \
238 wxFAIL_COND_MSG(#cond, msg); \
241 struct wxDummyCheckStruct /* just to force a semicolon */
243 #define wxCHECK2_MSG(cond, op, msg) \
248 wxFAIL_COND_MSG(#cond, msg); \
251 struct wxDummyCheckStruct /* just to force a semicolon */
254 /* special form of wxCHECK2: as wxCHECK, but for use in void functions */
256 /* NB: there is only one form (with msg parameter) and it's intentional: */
257 /* there is no other way to tell the caller what exactly went wrong */
258 /* from the void function (of course, the function shouldn't be void */
259 /* to begin with...) */
260 #define wxCHECK_RET(cond, msg) wxCHECK2_MSG(cond, return, msg)
262 /* ---------------------------------------------------------------------------- */
263 /* Compile time asserts */
265 /* Unlike the normal assert and related macros above which are checked during */
266 /* the program tun-time the macros below will result in a compilation error if */
267 /* the condition they check is false. This is usually used to check the */
268 /* expressions containing sizeof()s which cannot be tested with the */
269 /* preprocessor. If you can use the #if's, do use them as you can give a more */
270 /* detailed error message then. */
271 /* ---------------------------------------------------------------------------- */
274 How this works (you don't have to understand it to be able to use the
275 macros): we rely on the fact that it is invalid to define a named bit field
276 in a struct of width 0. All the rest are just the hacks to minimize the
277 possibility of the compiler warnings when compiling this macro: in
278 particular, this is why we define a struct and not an object (which would
279 result in a warning about unused variable) and a named struct (otherwise we'd
280 get a warning about an unnamed struct not used to define an object!).
283 #define wxMAKE_UNIQUE_ASSERT_NAME wxMAKE_UNIQUE_NAME(wxAssert_)
286 The second argument of this macro must be a valid C++ identifier and not a
287 string. I.e. you should use it like this:
289 wxCOMPILE_TIME_ASSERT( sizeof(int) >= 2, YourIntsAreTooSmall );
291 It may be used both within a function and in the global scope.
293 #if defined(__WATCOMC__) && defined(__cplusplus)
294 /* avoid "unused symbol" warning */
295 #define wxCOMPILE_TIME_ASSERT(expr, msg) \
296 class wxMAKE_UNIQUE_ASSERT_NAME { \
297 unsigned int msg: expr; \
298 wxMAKE_UNIQUE_ASSERT_NAME() { wxUnusedVar(msg); } \
301 #define wxCOMPILE_TIME_ASSERT(expr, msg) \
302 struct wxMAKE_UNIQUE_ASSERT_NAME { unsigned int msg: expr; }
306 When using VC++ 6 with "Edit and Continue" on, the compiler completely
307 mishandles __LINE__ and so wxCOMPILE_TIME_ASSERT() doesn't work, provide a
308 way to make "unique" assert names by specifying a unique prefix explicitly
310 #define wxMAKE_UNIQUE_ASSERT_NAME2(text) wxCONCAT(wxAssert_, text)
312 #define wxCOMPILE_TIME_ASSERT2(expr, msg, text) \
313 struct wxMAKE_UNIQUE_ASSERT_NAME2(text) { unsigned int msg: expr; }
315 /* helpers for wxCOMPILE_TIME_ASSERT below, for private use only */
316 #define wxMAKE_BITSIZE_MSG(type, size) type ## SmallerThan ## size ## Bits
318 /* a special case of compile time assert: check that the size of the given type */
319 /* is at least the given number of bits */
320 #define wxASSERT_MIN_BITSIZE(type, size) \
321 wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \
322 wxMAKE_BITSIZE_MSG(type, size))
324 /* ---------------------------------------------------------------------------- */
325 /* other miscellaneous debugger-related functions */
326 /* ---------------------------------------------------------------------------- */
329 Return true if we're running under debugger.
331 Currently this only really works under Win32 and Mac in CodeWarrior builds,
332 it always returns false in other cases.
335 /* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */
336 #if defined(__WXMAC__) || defined(__WIN32__)
337 extern bool WXDLLIMPEXP_BASE
wxIsDebuggerRunning();
339 inline bool wxIsDebuggerRunning() { return false; }
340 #endif /* Mac/!Mac */
341 #endif /* __cplusplus */
343 #endif /* _WX_DEBUG_H_ */