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