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 __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   /*  compilers can give a warning (such as "possible unwanted ;") when using */
 176   /*  the default definition of wxASSERT_MSG so we provide an alternative */
 177   #if defined(__MWERKS__)
 178     #define wxASSERT_MSG(cond, msg)                                           \
 179       if ( cond )                                                             \
 180       {}                                                                      \
 181       else                                                                    \
 182           wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg)
 183   #else
 184     #define wxASSERT_MSG(cond, msg)                                           \
 185       if ( cond )                                                             \
 186           ;                                                                   \
 187       else                                                                    \
 188           wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg)
 189   #endif
 190
 191   /*  special form of assert: always triggers it (in debug mode) */
 192   #define wxFAIL wxFAIL_MSG((const char*)NULL)
 193
 194   /*  FAIL with some message */
 195   #define wxFAIL_MSG(msg) wxFAIL_COND_MSG("wxAssertFailure", msg)
 196
 197   /*  FAIL with some message and a condition */
 198   #define wxFAIL_COND_MSG(cond, msg)                                          \
 199       wxOnAssert(__FILE__, __LINE__,  __WXFUNCTION__, cond, msg)
 200
 201   /*  An assert helper used to avoid warning when testing constant expressions, */
 202   /*  i.e. wxASSERT( sizeof(int) == 4 ) can generate a compiler warning about */
 203   /*  expression being always true, but not using */
 204   /*  wxASSERT( wxAssertIsEqual(sizeof(int), 4) ) */
 205   /*  */
 206   /*  NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and should no */
 207   /*      longer be used. */
 208   extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y);
 209 #else
 210   #define wxTrap()
 211
 212   /*  nothing to do in release mode (hopefully at this moment there are */
 213   /*  no more bugs ;-) */
 214   #define wxASSERT(cond)
 215   #define wxASSERT_MSG(cond, msg)
 216   #define wxFAIL
 217   #define wxFAIL_MSG(msg)
 218   #define wxFAIL_COND_MSG(cond, msg)
 219 #endif  /* __WXDEBUG__ */
 220
 221 #ifdef __cplusplus
 222     /*  Use of wxFalse instead of false suppresses compiler warnings about testing */
 223     /*  constant expression */
 224     extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
 225 #endif
 226
 227 #define wxAssertFailure wxFalse
 228
 229 /*  NB: the following macros also work in release mode! */
 230
 231 /*
 232   These macros must be used only in invalid situation: for example, an
 233   invalid parameter (e.g. a NULL pointer) is passed to a function. Instead of
 234   dereferencing it and causing core dump the function might try using
 235   CHECK( p != NULL ) or CHECK( p != NULL, return LogError("p is NULL!!") )
 236 */
 237
 238 /*  check that expression is true, "return" if not (also FAILs in debug mode) */
 239 #define wxCHECK(cond, rc)            wxCHECK_MSG(cond, rc, (const char*)NULL)
 240
 241 /*  as wxCHECK but with a message explaining why we fail */
 242 #define wxCHECK_MSG(cond, rc, msg)   wxCHECK2_MSG(cond, return rc, msg)
 243
 244 /*  check that expression is true, perform op if not */
 245 #define wxCHECK2(cond, op)           wxCHECK2_MSG(cond, op, (const char*)NULL)
 246
 247 /*  as wxCHECK2 but with a message explaining why we fail */
 248
 249 /* see comment near the definition of wxASSERT_MSG for the # if/else reason */
 250 #if defined(__MWERKS__)
 251     #define wxCHECK2_MSG(cond, op, msg)                                       \
 252         if ( cond )                                                           \
 253         {}                                                                    \
 254         else                                                                  \
 255         {                                                                     \
 256             wxFAIL_COND_MSG(#cond, msg);                                      \
 257             op;                                                               \
 258         }                                                                     \
 259         struct wxDummyCheckStruct /* just to force a semicolon */
 260 #else
 261     #define wxCHECK2_MSG(cond, op, msg)                                       \
 262         if ( cond )                                                           \
 263             ;                                                                 \
 264         else                                                                  \
 265         {                                                                     \
 266             wxFAIL_COND_MSG(#cond, msg);                                      \
 267             op;                                                               \
 268         }                                                                     \
 269         struct wxDummyCheckStruct /* just to force a semicolon */
 270 #endif
 271
 272 /*  special form of wxCHECK2: as wxCHECK, but for use in void functions */
 273 /*  */
 274 /*  NB: there is only one form (with msg parameter) and it's intentional: */
 275 /*      there is no other way to tell the caller what exactly went wrong */
 276 /*      from the void function (of course, the function shouldn't be void */
 277 /*      to begin with...) */
 278 #define wxCHECK_RET(cond, msg)       wxCHECK2_MSG(cond, return, msg)
 279
 280 /*  ---------------------------------------------------------------------------- */
 281 /*  Compile time asserts */
 282 /*  */
 283 /*  Unlike the normal assert and related macros above which are checked during */
 284 /*  the program tun-time the macros below will result in a compilation error if */
 285 /*  the condition they check is false. This is usually used to check the */
 286 /*  expressions containing sizeof()s which cannot be tested with the */
 287 /*  preprocessor. If you can use the #if's, do use them as you can give a more */
 288 /*  detailed error message then. */
 289 /*  ---------------------------------------------------------------------------- */
 290
 291 /*
 292   How this works (you don't have to understand it to be able to use the
 293   macros): we rely on the fact that it is invalid to define a named bit field
 294   in a struct of width 0. All the rest are just the hacks to minimize the
 295   possibility of the compiler warnings when compiling this macro: in
 296   particular, this is why we define a struct and not an object (which would
 297   result in a warning about unused variable) and a named struct (otherwise we'd
 298   get a warning about an unnamed struct not used to define an object!).
 299  */
 300
 301 #define wxMAKE_UNIQUE_ASSERT_NAME           wxMAKE_UNIQUE_NAME(wxAssert_)
 302
 303 /*
 304   The second argument of this macro must be a valid C++ identifier and not a
 305   string. I.e. you should use it like this:
 306
 307     wxCOMPILE_TIME_ASSERT( sizeof(int) >= 2, YourIntsAreTooSmall );
 308
 309  It may be used both within a function and in the global scope.
 310 */
 311 #if defined(__WATCOMC__) && defined(__cplusplus)
 312     /* avoid "unused symbol" warning */
 313     #define wxCOMPILE_TIME_ASSERT(expr, msg) \
 314         class wxMAKE_UNIQUE_ASSERT_NAME { \
 315           unsigned int msg: expr; \
 316           wxMAKE_UNIQUE_ASSERT_NAME() { wxUnusedVar(msg); } \
 317         }
 318 #else
 319     #define wxCOMPILE_TIME_ASSERT(expr, msg) \
 320         struct wxMAKE_UNIQUE_ASSERT_NAME { unsigned int msg: expr; }
 321 #endif
 322
 323 /*
 324    When using VC++ 6 with "Edit and Continue" on, the compiler completely
 325    mishandles __LINE__ and so wxCOMPILE_TIME_ASSERT() doesn't work, provide a
 326    way to make "unique" assert names by specifying a unique prefix explicitly
 327  */
 328 #define wxMAKE_UNIQUE_ASSERT_NAME2(text) wxCONCAT(wxAssert_, text)
 329
 330 #define wxCOMPILE_TIME_ASSERT2(expr, msg, text) \
 331     struct wxMAKE_UNIQUE_ASSERT_NAME2(text) { unsigned int msg: expr; }
 332
 333 /*  helpers for wxCOMPILE_TIME_ASSERT below, for private use only */
 334 #define wxMAKE_BITSIZE_MSG(type, size) type ## SmallerThan ## size ## Bits
 335
 336 /*  a special case of compile time assert: check that the size of the given type */
 337 /*  is at least the given number of bits */
 338 #define wxASSERT_MIN_BITSIZE(type, size) \
 339     wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \
 340                           wxMAKE_BITSIZE_MSG(type, size))
 341
 342 /*  ---------------------------------------------------------------------------- */
 343 /*  other miscellaneous debugger-related functions */
 344 /*  ---------------------------------------------------------------------------- */
 345
 346 /*
 347     Return true if we're running under debugger.
 348
 349     Currently this only really works under Win32 and Mac in CodeWarrior builds,
 350     it always returns false in other cases.
 351  */
 352 #ifdef __cplusplus
 353     /* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */
 354     #if defined(__WXMAC__) || defined(__WIN32__)
 355         extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning();
 356     #else /*  !Mac */
 357         inline bool wxIsDebuggerRunning() { return false; }
 358     #endif /*  Mac/!Mac */
 359 #endif /* __cplusplus */
 360
 361 #endif  /*  _WX_DEBUG_H_ */