include/wx/debug.h

   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 /* TODO: add more compilers supporting __FUNCTION__ */
  51 #if defined(__GNUC__) || \
  52     (defined(_MSC_VER) && _MSC_VER >= 1300) || \
  53     defined(__FUNCTION__)
  54     #define __WXFUNCTION__ __FUNCTION__
  55 #else
  56     /* still define __WXFUNCTION__ to avoid #ifdefs elsewhere */
  57     #define __WXFUNCTION__ (NULL)
  58 #endif
  59
  60 /*  ---------------------------------------------------------------------------- */
  61 /*  Debugging macros */
  62 /*  */
  63 /*  All debugging macros rely on ASSERT() which in turn calls user-defined */
  64 /*  OnAssert() function. To keep things simple, it's called even when the */
  65 /*  expression is true (i.e. everything is ok) and by default does nothing: just */
  66 /*  returns the same value back. But if you redefine it to do something more sexy */
  67 /*  (popping up a message box in your favourite GUI, sending you e-mail or */
  68 /*  whatever) it will affect all ASSERTs, FAILs and CHECKs in your code. */
  69 /*  */
  70 /*  Warning: if you don't like advice on programming style, don't read */
  71 /*  further! ;-) */
  72 /*  */
  73 /*  Extensive use of these macros is recommended! Remember that ASSERTs are */
  74 /*  disabled in final build (without __WXDEBUG__ defined), so they add strictly */
  75 /*  nothing to your program's code. On the other hand, CHECK macros do stay */
  76 /*  even in release builds, but in general are not much of a burden, while */
  77 /*  a judicious use of them might increase your program's stability. */
  78 /*  ---------------------------------------------------------------------------- */
  79
  80 /*  Macros which are completely disabled in 'release' mode */
  81 /*  */
  82 /*  NB: these functions are implemented in src/common/appcmn.cpp */
  83 #if defined(__cplusplus) && defined(__WXDEBUG__)
  84   /*
  85     This function is called whenever one of debugging macros fails (i.e.
  86     condition is false in an assertion). To customize its behaviour, override
  87     wxApp::OnAssert().
  88
  89     Parameters:
  90        szFile and nLine - file name and line number of the ASSERT
  91        szFunc           - function name of the ASSERT, may be NULL (NB: ASCII)
  92        szCond           - text form of the condition which failed
  93        szMsg            - optional message explaining the reason
  94   */
  95   extern void WXDLLIMPEXP_BASE wxOnAssert(const wxChar *szFile,
  96                                           int nLine,
  97                                           const char *szFunc,
  98                                           const wxChar *szCond,
  99                                           const wxChar *szMsg = NULL);
 100
 101   /*  call this function to break into the debugger unconditionally (assuming */
 102   /*  the program is running under debugger, of course) */
 103   extern void WXDLLIMPEXP_BASE wxTrap();
 104
 105   /*  generic assert macro */
 106   #define wxASSERT(cond) wxASSERT_MSG(cond, NULL)
 107
 108   /*  assert with additional message explaining it's cause */
 109   #define wxASSERT_MSG(cond, msg)                                             \
 110     if ( cond )                                                               \
 111         ;                                                                     \
 112     else                                                                      \
 113         wxOnAssert(__TFILE__, __LINE__, __WXFUNCTION__, _T(#cond), msg)
 114
 115   /*  special form of assert: always triggers it (in debug mode) */
 116   #define wxFAIL wxFAIL_MSG(NULL)
 117
 118   /*  FAIL with some message */
 119   #define wxFAIL_MSG(msg) wxFAIL_COND_MSG("wxAssertFailure", msg)
 120
 121   /*  FAIL with some message and a condition */
 122   #define wxFAIL_COND_MSG(cond, msg)                                          \
 123       wxOnAssert(__TFILE__, __LINE__,  __WXFUNCTION__, _T(cond), msg)
 124
 125   /*  an assert helper used to avoid warning when testing constant expressions, */
 126   /*  i.e. wxASSERT( sizeof(int) == 4 ) can generate a compiler warning about */
 127   /*  expression being always true, but not using */
 128   /*  wxASSERT( wxAssertIsEqual(sizeof(int), 4) ) */
 129   /*  */
 130   /*  NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and shouldn't be */
 131   /*      used any longer */
 132   extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y);
 133 #else
 134   #define wxTrap()
 135
 136   /*  nothing to do in release modes (hopefully at this moment there are */
 137   /*  no more bugs ;-) */
 138   #define wxASSERT(cond)
 139   #define wxASSERT_MSG(cond, msg)
 140   #define wxFAIL
 141   #define wxFAIL_MSG(msg)
 142   #define wxFAIL_COND_MSG(cond, msg)
 143 #endif  /* __WXDEBUG__ */
 144
 145 #ifdef __cplusplus
 146     /*  Use of wxFalse instead of false suppresses compiler warnings about testing */
 147     /*  constant expression */
 148     extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
 149 #endif
 150
 151 #define wxAssertFailure wxFalse
 152
 153 /*  NB: the following macros work also in release mode! */
 154
 155 /*
 156   These macros must be used only in invalid situation: for example, an
 157   invalid parameter (NULL pointer) is passed to a function. Instead of
 158   dereferencing it and causing core dump the function might try using
 159   CHECK( p != NULL ) or CHECK( p != NULL, return LogError("p is NULL!!") )
 160 */
 161
 162 /*  check that expression is true, "return" if not (also FAILs in debug mode) */
 163 #define wxCHECK(cond, rc)            wxCHECK_MSG(cond, rc, NULL)
 164
 165 /*  as wxCHECK but with a message explaining why we fail */
 166 #define wxCHECK_MSG(cond, rc, msg)   wxCHECK2_MSG(cond, return rc, msg)
 167
 168 /*  check that expression is true, perform op if not */
 169 #define wxCHECK2(cond, op)           wxCHECK2_MSG(cond, op, NULL)
 170
 171 /*  as wxCHECK2 but with a message explaining why we fail */
 172 #define wxCHECK2_MSG(cond, op, msg)                                           \
 173     if ( cond )                                                               \
 174         ;                                                                     \
 175     else                                                                      \
 176     {                                                                         \
 177         wxFAIL_COND_MSG(#cond, msg);                                          \
 178         op;                                                                   \
 179     }                                                                         \
 180     struct wxDummyCheckStruct /* just to force a semicolon */
 181
 182 /*  special form of wxCHECK2: as wxCHECK, but for use in void functions */
 183 /*  */
 184 /*  NB: there is only one form (with msg parameter) and it's intentional: */
 185 /*      there is no other way to tell the caller what exactly went wrong */
 186 /*      from the void function (of course, the function shouldn't be void */
 187 /*      to begin with...) */
 188 #define wxCHECK_RET(cond, msg)       wxCHECK2_MSG(cond, return, msg)
 189
 190 /*  ---------------------------------------------------------------------------- */
 191 /*  Compile time asserts */
 192 /*  */
 193 /*  Unlike the normal assert and related macros above which are checked during */
 194 /*  the program tun-time the macros below will result in a compilation error if */
 195 /*  the condition they check is false. This is usually used to check the */
 196 /*  expressions containing sizeof()s which cannot be tested with the */
 197 /*  preprocessor. If you can use the #if's, do use them as you can give a more */
 198 /*  detailed error message then. */
 199 /*  ---------------------------------------------------------------------------- */
 200
 201 /*
 202   How this works (you don't have to understand it to be able to use the
 203   macros): we rely on the fact that it is invalid to define a named bit field
 204   in a struct of width 0. All the rest are just the hacks to minimize the
 205   possibility of the compiler warnings when compiling this macro: in
 206   particular, this is why we define a struct and not an object (which would
 207   result in a warning about unused variable) and a named struct (otherwise we'd
 208   get a warning about an unnamed struct not used to define an object!).
 209  */
 210
 211 #define wxMAKE_UNIQUE_ASSERT_NAME           wxMAKE_UNIQUE_NAME(wxAssert_)
 212
 213 /*
 214   The second argument of this macro must be a valid C++ identifier and not a
 215   string. I.e. you should use it like this:
 216
 217     wxCOMPILE_TIME_ASSERT( sizeof(int) >= 2, YourIntsAreTooSmall );
 218
 219  It may be used both within a function and in the global scope.
 220 */
 221 #if defined(__WATCOMC__) && defined(__cplusplus)
 222     /* avoid "unused symbol" warning */
 223     #define wxCOMPILE_TIME_ASSERT(expr, msg) \
 224         class wxMAKE_UNIQUE_ASSERT_NAME { \
 225           unsigned int msg: expr; \
 226           wxMAKE_UNIQUE_ASSERT_NAME() { wxUnusedVar(msg); } \
 227         }
 228 #else
 229     #define wxCOMPILE_TIME_ASSERT(expr, msg) \
 230         struct wxMAKE_UNIQUE_ASSERT_NAME { unsigned int msg: expr; }
 231 #endif
 232
 233 /*
 234    When using VC++ 6 with "Edit and Continue" on, the compiler completely
 235    mishandles __LINE__ and so wxCOMPILE_TIME_ASSERT() doesn't work, provide a
 236    way to make "unique" assert names by specifying a unique prefix explicitly
 237  */
 238 #define wxMAKE_UNIQUE_ASSERT_NAME2(text) wxCONCAT(wxAssert_, text)
 239
 240 #define wxCOMPILE_TIME_ASSERT2(expr, msg, text) \
 241     struct wxMAKE_UNIQUE_ASSERT_NAME2(text) { unsigned int msg: expr; }
 242
 243 /*  helpers for wxCOMPILE_TIME_ASSERT below, for private use only */
 244 #define wxMAKE_BITSIZE_MSG(type, size) type ## SmallerThan ## size ## Bits
 245
 246 /*  a special case of compile time assert: check that the size of the given type */
 247 /*  is at least the given number of bits */
 248 #define wxASSERT_MIN_BITSIZE(type, size) \
 249     wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \
 250                           wxMAKE_BITSIZE_MSG(type, size))
 251
 252 /*  ---------------------------------------------------------------------------- */
 253 /*  other miscellaneous debugger-related functions */
 254 /*  ---------------------------------------------------------------------------- */
 255
 256 /*
 257     Return true if we're running under debugger.
 258
 259     Currently this only really works under Win32 and Mac in CodeWarrior builds,
 260     it always returns false in other cases.
 261  */
 262 #ifdef __cplusplus
 263     /* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */
 264     #if defined(__WXMAC__) || defined(__WIN32__)
 265         extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning();
 266     #else /*  !Mac */
 267         inline bool wxIsDebuggerRunning() { return false; }
 268     #endif /*  Mac/!Mac */
 269 #endif /* __cplusplus */
 270
 271 #endif  /*  _WX_DEBUG_H_ */