| | 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 __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 | /* see comment near the definition of wxASSERT_MSG for the # if/else reason */ |
| | 194 | #if defined(__MWERKS__) |
| | 195 | #define wxCHECK2_MSG(cond, op, msg) \ |
| | 196 | if ( cond ) \ |
| | 197 | {} \ |
| | 198 | else \ |
| | 199 | { \ |
| | 200 | wxFAIL_COND_MSG(#cond, msg); \ |
| | 201 | op; \ |
| | 202 | } \ |
| | 203 | struct wxDummyCheckStruct /* just to force a semicolon */ |
| | 204 | #else |
| | 205 | #define wxCHECK2_MSG(cond, op, msg) \ |
| | 206 | if ( cond ) \ |
| | 207 | ; \ |
| | 208 | else \ |
| | 209 | { \ |
| | 210 | wxFAIL_COND_MSG(#cond, msg); \ |
| | 211 | op; \ |
| | 212 | } \ |
| | 213 | struct wxDummyCheckStruct /* just to force a semicolon */ |
| | 214 | #endif |
| | 215 | |
| | 216 | /* special form of wxCHECK2: as wxCHECK, but for use in void functions */ |
| | 217 | /* */ |
| | 218 | /* NB: there is only one form (with msg parameter) and it's intentional: */ |
| | 219 | /* there is no other way to tell the caller what exactly went wrong */ |
| | 220 | /* from the void function (of course, the function shouldn't be void */ |
| | 221 | /* to begin with...) */ |
| | 222 | #define wxCHECK_RET(cond, msg) wxCHECK2_MSG(cond, return, msg) |
| | 223 | |
| | 224 | /* ---------------------------------------------------------------------------- */ |
| | 225 | /* Compile time asserts */ |
| | 226 | /* */ |
| | 227 | /* Unlike the normal assert and related macros above which are checked during */ |
| | 228 | /* the program tun-time the macros below will result in a compilation error if */ |
| | 229 | /* the condition they check is false. This is usually used to check the */ |
| | 230 | /* expressions containing sizeof()s which cannot be tested with the */ |
| | 231 | /* preprocessor. If you can use the #if's, do use them as you can give a more */ |
| | 232 | /* detailed error message then. */ |
| | 233 | /* ---------------------------------------------------------------------------- */ |
| | 234 | |
| | 235 | /* |
| | 236 | How this works (you don't have to understand it to be able to use the |
| | 237 | macros): we rely on the fact that it is invalid to define a named bit field |
| | 238 | in a struct of width 0. All the rest are just the hacks to minimize the |
| | 239 | possibility of the compiler warnings when compiling this macro: in |
| | 240 | particular, this is why we define a struct and not an object (which would |
| | 241 | result in a warning about unused variable) and a named struct (otherwise we'd |
| | 242 | get a warning about an unnamed struct not used to define an object!). |
| | 243 | */ |
| | 244 | |
| | 245 | #define wxMAKE_UNIQUE_ASSERT_NAME wxMAKE_UNIQUE_NAME(wxAssert_) |
| | 246 | |
| | 247 | /* |
| | 248 | The second argument of this macro must be a valid C++ identifier and not a |
| | 249 | string. I.e. you should use it like this: |
| | 250 | |
| | 251 | wxCOMPILE_TIME_ASSERT( sizeof(int) >= 2, YourIntsAreTooSmall ); |
| | 252 | |
| | 253 | It may be used both within a function and in the global scope. |
| | 254 | */ |
| | 255 | #if defined(__WATCOMC__) && defined(__cplusplus) |
| | 256 | /* avoid "unused symbol" warning */ |
| | 257 | #define wxCOMPILE_TIME_ASSERT(expr, msg) \ |
| | 258 | class wxMAKE_UNIQUE_ASSERT_NAME { \ |
| | 259 | unsigned int msg: expr; \ |
| | 260 | wxMAKE_UNIQUE_ASSERT_NAME() { wxUnusedVar(msg); } \ |
| | 261 | } |
| | 262 | #else |
| | 263 | #define wxCOMPILE_TIME_ASSERT(expr, msg) \ |
| | 264 | struct wxMAKE_UNIQUE_ASSERT_NAME { unsigned int msg: expr; } |
| | 265 | #endif |
| | 266 | |
| | 267 | /* |
| | 268 | When using VC++ 6 with "Edit and Continue" on, the compiler completely |
| | 269 | mishandles __LINE__ and so wxCOMPILE_TIME_ASSERT() doesn't work, provide a |
| | 270 | way to make "unique" assert names by specifying a unique prefix explicitly |
| | 271 | */ |
| | 272 | #define wxMAKE_UNIQUE_ASSERT_NAME2(text) wxCONCAT(wxAssert_, text) |
| | 273 | |
| | 274 | #define wxCOMPILE_TIME_ASSERT2(expr, msg, text) \ |
| | 275 | struct wxMAKE_UNIQUE_ASSERT_NAME2(text) { unsigned int msg: expr; } |
| | 276 | |
| | 277 | /* helpers for wxCOMPILE_TIME_ASSERT below, for private use only */ |
| | 278 | #define wxMAKE_BITSIZE_MSG(type, size) type ## SmallerThan ## size ## Bits |
| | 279 | |
| | 280 | /* a special case of compile time assert: check that the size of the given type */ |
| | 281 | /* is at least the given number of bits */ |
| | 282 | #define wxASSERT_MIN_BITSIZE(type, size) \ |
| | 283 | wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \ |
| | 284 | wxMAKE_BITSIZE_MSG(type, size)) |
| | 285 | |
| | 286 | /* ---------------------------------------------------------------------------- */ |
| | 287 | /* other miscellaneous debugger-related functions */ |
| | 288 | /* ---------------------------------------------------------------------------- */ |
| | 289 | |
| | 290 | /* |
| | 291 | Return true if we're running under debugger. |
| | 292 | |
| | 293 | Currently this only really works under Win32 and Mac in CodeWarrior builds, |
| | 294 | it always returns false in other cases. |
| | 295 | */ |
| | 296 | #ifdef __cplusplus |
| | 297 | /* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */ |
| | 298 | #if defined(__WXMAC__) || defined(__WIN32__) |
| | 299 | extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning(); |
| | 300 | #else /* !Mac */ |
| | 301 | inline bool wxIsDebuggerRunning() { return false; } |
| | 302 | #endif /* Mac/!Mac */ |
| | 303 | #endif /* __cplusplus */ |
| | 304 | |
| | 305 | #endif /* _WX_DEBUG_H_ */ |
projects / wxWidgets.git / blame_incremental