[wxWidgets.git] / include / wx / debug.h

/**
*  Name:        wx/debug.h
*  Purpose:     Misc debug functions and macros
*  Author:      Vadim Zeitlin
*  Modified by: Ryan Norton (Converted to C)
*  Created:     29/01/98
*  RCS-ID:      $Id$
*  Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
*  Licence:     wxWindows licence
*/

/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */

#ifndef   _WX_DEBUG_H_
#define   _WX_DEBUG_H_

#ifndef __WXWINCE__
#include  <assert.h>
#endif
#include  <limits.h>            /*  for CHAR_BIT used below */

#include  "wx/chartype.h"     /*  for __TFILE__ and wxChar */

/*  ---------------------------------------------------------------------------- */
/*  Defines controlling the debugging macros */
/*  ---------------------------------------------------------------------------- */

/*  if _DEBUG is defined (MS VC++ and others use it in debug builds), define */
/*  __WXDEBUG__ too */
#ifdef _DEBUG
    #ifndef __WXDEBUG__
        #define __WXDEBUG__
    #endif /*  !__WXDEBUG__ */
#endif /*  _DEBUG */

/*  if NDEBUG is defined (<assert.h> uses it), undef __WXDEBUG__ and WXDEBUG */
#ifdef NDEBUG
    #undef __WXDEBUG__
    #undef WXDEBUG
#endif /*  NDEBUG */

/*  if __WXDEBUG__ is defined, make sure that WXDEBUG is defined and >= 1 */
#ifdef __WXDEBUG__
    #if !defined(WXDEBUG) || !WXDEBUG
        #undef WXDEBUG
        #define WXDEBUG 1
    #endif /*  !WXDEBUG */
#endif /*  __WXDEBUG__ */

#ifndef __WXFUNCTION__
    /* TODO: add more compilers supporting __FUNCTION__ */
    #if defined(__DMC__)
        /* 
           __FUNCTION__ happens to be not defined within class members
           http://www.digitalmars.com/drn-bin/wwwnews?c%2B%2B.beta/485
        */
        #define __WXFUNCTION__ (NULL)
    #elif defined(__GNUC__) || \
          (defined(_MSC_VER) && _MSC_VER >= 1300) || \
          defined(__FUNCTION__)
        #define __WXFUNCTION__ __FUNCTION__
    #else
        /* still define __WXFUNCTION__ to avoid #ifdefs elsewhere */
        #define __WXFUNCTION__ (NULL)
    #endif
#endif /* __WXFUNCTION__ already defined */

/*  ---------------------------------------------------------------------------- */
/*  Debugging macros */
/*  */
/*  All debugging macros rely on ASSERT() which in turn calls the user-defined */
/*  OnAssert() function. To keep things simple, it's called even when the */
/*  expression is true (i.e. everything is ok) and by default does nothing: just */
/*  returns the same value back. But if you redefine it to do something more sexy */
/*  (popping up a message box in your favourite GUI, sending you e-mail or */
/*  whatever) it will affect all ASSERTs, FAILs and CHECKs in your code. */
/*  */
/*  Warning: if you don't like advice on programming style, don't read */
/*  further! ;-) */
/*  */
/*  Extensive use of these macros is recommended! Remember that ASSERTs are */
/*  disabled in final build (without __WXDEBUG__ defined), so they add strictly */
/*  nothing to your program's code. On the other hand, CHECK macros do stay */
/*  even in release builds, but in general are not much of a burden, while */
/*  a judicious use of them might increase your program's stability. */
/*  ---------------------------------------------------------------------------- */

/*  Macros which are completely disabled in 'release' mode */
/*  */
/*  NB: these functions are implemented in src/common/appcmn.cpp */
#if defined(__cplusplus) && defined(__WXDEBUG__)
  /*
    This function is called whenever one of debugging macros fails (i.e.
    condition is false in an assertion). To customize its behaviour, override
    wxApp::OnAssertFailure().

    Parameters:
       szFile and nLine - file name and line number of the ASSERT
       szFunc           - function name of the ASSERT, may be NULL (NB: ASCII)
       szCond           - text form of the condition which failed
       szMsg            - optional message explaining the reason
  */

  /* this version is for compatibility with wx 2.8 Unicode build only: */
  extern void WXDLLIMPEXP_BASE wxOnAssert(const wxChar *szFile,
                                          int nLine,
                                          const char *szFunc,
                                          const wxChar *szCond,
                                          const wxChar *szMsg = NULL);

#if wxUSE_UNICODE
  /* char versions are used by debugging macros; we have to provide
     wxChar* szMsg version because it's common to use _T() in the macros
     and finally, we can't use const wx(char)* szMsg = NULL, because that
     would be ambiguous: */
  extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
                                          int nLine,
                                          const char *szFunc,
                                          const char *szCond);

  extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
                                          int nLine,
                                          const char *szFunc,
                                          const char *szCond,
                                          const char *szMsg);

  extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
                                          int nLine,
                                          const char *szFunc,
                                          const char *szCond,
                                          const wxChar *szMsg);
#endif /* wxUSE_UNICODE */

  class WXDLLIMPEXP_BASE wxString;
  class WXDLLIMPEXP_BASE wxCStrData;

  /* these two work when szMsg passed to debug macro is a string,
     we also have to provide wxCStrData overload to resolve ambiguity
     which would otherwise arise from wxASSERT( s.c_str() ): */
  extern void WXDLLIMPEXP_BASE wxOnAssert(const wxString& szFile,
                                          int nLine,
                                          const wxString& szFunc,
                                          const wxString& szCond,
                                          const wxString& szMsg);

  extern void WXDLLIMPEXP_BASE wxOnAssert(const wxString& szFile,
                                          int nLine,
                                          const wxString& szFunc,
                                          const wxString& szCond);

  extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
                                          int nLine,
                                          const char *szFunc,
                                          const char *szCond,
                                          const wxCStrData& msg);

  extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
                                          int nLine,
                                          const char *szFunc,
                                          const char *szCond,
                                          const wxString& szMsg);

  /*  call this function to break into the debugger unconditionally (assuming */
  /*  the program is running under debugger, of course) */
  extern void WXDLLIMPEXP_BASE wxTrap();

  /*  generic assert macro */
  #define wxASSERT(cond) wxASSERT_MSG(cond, (const char*)NULL)


  /*  assert with additional message explaining its cause */

  /*  compilers can give a warning (such as "possible unwanted ;") when using */
  /*  the default definition of wxASSERT_MSG so we provide an alternative */
  #if defined(__MWERKS__)
    #define wxASSERT_MSG(cond, msg)                                           \
      if ( cond )                                                             \
      {}                                                                      \
      else                                                                    \
          wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg)
  #else
    #define wxASSERT_MSG(cond, msg)                                           \
      if ( cond )                                                             \
          ;                                                                   \
      else                                                                    \
          wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg)
  #endif

  /*  special form of assert: always triggers it (in debug mode) */
  #define wxFAIL wxFAIL_MSG((const char*)NULL)

  /*  FAIL with some message */
  #define wxFAIL_MSG(msg) wxFAIL_COND_MSG("wxAssertFailure", msg)

  /*  FAIL with some message and a condition */
  #define wxFAIL_COND_MSG(cond, msg)                                          \
      wxOnAssert(__FILE__, __LINE__,  __WXFUNCTION__, cond, msg)

  /*  An assert helper used to avoid warning when testing constant expressions, */
  /*  i.e. wxASSERT( sizeof(int) == 4 ) can generate a compiler warning about */
  /*  expression being always true, but not using */
  /*  wxASSERT( wxAssertIsEqual(sizeof(int), 4) ) */
  /*  */
  /*  NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and should no */
  /*      longer be used. */
  extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y);
#else
  #define wxTrap()

  /*  nothing to do in release mode (hopefully at this moment there are */
  /*  no more bugs ;-) */
  #define wxASSERT(cond)
  #define wxASSERT_MSG(cond, msg)
  #define wxFAIL
  #define wxFAIL_MSG(msg)
  #define wxFAIL_COND_MSG(cond, msg)
#endif  /* __WXDEBUG__ */

#ifdef __cplusplus
    /*  Use of wxFalse instead of false suppresses compiler warnings about testing */
    /*  constant expression */
    extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
#endif

#define wxAssertFailure wxFalse

/*  NB: the following macros also work in release mode! */

/*
  These macros must be used only in invalid situation: for example, an
  invalid parameter (e.g. a NULL pointer) is passed to a function. Instead of
  dereferencing it and causing core dump the function might try using
  CHECK( p != NULL ) or CHECK( p != NULL, return LogError("p is NULL!!") )
*/

/*  check that expression is true, "return" if not (also FAILs in debug mode) */
#define wxCHECK(cond, rc)            wxCHECK_MSG(cond, rc, (const char*)NULL)

/*  as wxCHECK but with a message explaining why we fail */
#define wxCHECK_MSG(cond, rc, msg)   wxCHECK2_MSG(cond, return rc, msg)

/*  check that expression is true, perform op if not */
#define wxCHECK2(cond, op)           wxCHECK2_MSG(cond, op, (const char*)NULL)

/*  as wxCHECK2 but with a message explaining why we fail */

/* see comment near the definition of wxASSERT_MSG for the # if/else reason */
#if defined(__MWERKS__)
    #define wxCHECK2_MSG(cond, op, msg)                                       \
        if ( cond )                                                           \
        {}                                                                    \
        else                                                                  \
        {                                                                     \
            wxFAIL_COND_MSG(#cond, msg);                                      \
            op;                                                               \
        }                                                                     \
        struct wxDummyCheckStruct /* just to force a semicolon */
#else
    #define wxCHECK2_MSG(cond, op, msg)                                       \
        if ( cond )                                                           \
            ;                                                                 \
        else                                                                  \
        {                                                                     \
            wxFAIL_COND_MSG(#cond, msg);                                      \
            op;                                                               \
        }                                                                     \
        struct wxDummyCheckStruct /* just to force a semicolon */
#endif

/*  special form of wxCHECK2: as wxCHECK, but for use in void functions */
/*  */
/*  NB: there is only one form (with msg parameter) and it's intentional: */
/*      there is no other way to tell the caller what exactly went wrong */
/*      from the void function (of course, the function shouldn't be void */
/*      to begin with...) */
#define wxCHECK_RET(cond, msg)       wxCHECK2_MSG(cond, return, msg)

/*  ---------------------------------------------------------------------------- */
/*  Compile time asserts */
/*  */
/*  Unlike the normal assert and related macros above which are checked during */
/*  the program tun-time the macros below will result in a compilation error if */
/*  the condition they check is false. This is usually used to check the */
/*  expressions containing sizeof()s which cannot be tested with the */
/*  preprocessor. If you can use the #if's, do use them as you can give a more */
/*  detailed error message then. */
/*  ---------------------------------------------------------------------------- */

/*
  How this works (you don't have to understand it to be able to use the
  macros): we rely on the fact that it is invalid to define a named bit field
  in a struct of width 0. All the rest are just the hacks to minimize the
  possibility of the compiler warnings when compiling this macro: in
  particular, this is why we define a struct and not an object (which would
  result in a warning about unused variable) and a named struct (otherwise we'd
  get a warning about an unnamed struct not used to define an object!).
 */

#define wxMAKE_UNIQUE_ASSERT_NAME           wxMAKE_UNIQUE_NAME(wxAssert_)

/*
  The second argument of this macro must be a valid C++ identifier and not a
  string. I.e. you should use it like this:

    wxCOMPILE_TIME_ASSERT( sizeof(int) >= 2, YourIntsAreTooSmall );

 It may be used both within a function and in the global scope.
*/
#if defined(__WATCOMC__) && defined(__cplusplus)
    /* avoid "unused symbol" warning */
    #define wxCOMPILE_TIME_ASSERT(expr, msg) \
        class wxMAKE_UNIQUE_ASSERT_NAME { \
          unsigned int msg: expr; \
          wxMAKE_UNIQUE_ASSERT_NAME() { wxUnusedVar(msg); } \
        }
#else
    #define wxCOMPILE_TIME_ASSERT(expr, msg) \
        struct wxMAKE_UNIQUE_ASSERT_NAME { unsigned int msg: expr; }
#endif

/*
   When using VC++ 6 with "Edit and Continue" on, the compiler completely
   mishandles __LINE__ and so wxCOMPILE_TIME_ASSERT() doesn't work, provide a
   way to make "unique" assert names by specifying a unique prefix explicitly
 */
#define wxMAKE_UNIQUE_ASSERT_NAME2(text) wxCONCAT(wxAssert_, text)

#define wxCOMPILE_TIME_ASSERT2(expr, msg, text) \
    struct wxMAKE_UNIQUE_ASSERT_NAME2(text) { unsigned int msg: expr; }

/*  helpers for wxCOMPILE_TIME_ASSERT below, for private use only */
#define wxMAKE_BITSIZE_MSG(type, size) type ## SmallerThan ## size ## Bits

/*  a special case of compile time assert: check that the size of the given type */
/*  is at least the given number of bits */
#define wxASSERT_MIN_BITSIZE(type, size) \
    wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \
                          wxMAKE_BITSIZE_MSG(type, size))

/*  ---------------------------------------------------------------------------- */
/*  other miscellaneous debugger-related functions */
/*  ---------------------------------------------------------------------------- */

/*
    Return true if we're running under debugger.

    Currently this only really works under Win32 and Mac in CodeWarrior builds,
    it always returns false in other cases.
 */
#ifdef __cplusplus
    /* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */
    #if defined(__WXMAC__) || defined(__WIN32__)
        extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning();
    #else /*  !Mac */
        inline bool wxIsDebuggerRunning() { return false; }
    #endif /*  Mac/!Mac */
#endif /* __cplusplus */

#endif  /*  _WX_DEBUG_H_ */
Commit	Line	Data
e0c749a7	1	/**
68379eaf WS	2	* Name: wx/debug.h
	3	* Purpose: Misc debug functions and macros
	4	* Author: Vadim Zeitlin
e0c749a7	5	* Modified by: Ryan Norton (Converted to C)
68379eaf WS	6	* Created: 29/01/98
	7	* RCS-ID: $Id$
	8	* Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	9	* Licence: wxWindows licence
e0c749a7 RN	10	*/
	11
	12	/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
c801d85f	13
34138703 JS	14	#ifndef _WX_DEBUG_H_
34138703 JS	15	#define _WX_DEBUG_H_
c801d85f	16
0e0126c2	17	#ifndef __WXWINCE__
c801d85f	18	#include <assert.h>
0e0126c2	19	#endif
e0c749a7	20	#include <limits.h> /* for CHAR_BIT used below */
c801d85f	21
e3f6cbd9	22	#include "wx/chartype.h" /* for __TFILE__ and wxChar */
9e3d3318	23
e0c749a7 RN	24	/* ---------------------------------------------------------------------------- */
	25	/* Defines controlling the debugging macros */
	26	/* ---------------------------------------------------------------------------- */
8b0bd21b	27
e0c749a7 RN	28	/* if _DEBUG is defined (MS VC++ and others use it in debug builds), define */
e0c749a7 RN	29	/* __WXDEBUG__ too */
8b0bd21b VZ	30	#ifdef _DEBUG
	31	#ifndef __WXDEBUG__
	32	#define __WXDEBUG__
e0c749a7 RN	33	#endif /* !__WXDEBUG__ */
e0c749a7 RN	34	#endif /* _DEBUG */
8b0bd21b	35
e0c749a7	36	/* if NDEBUG is defined (<assert.h> uses it), undef __WXDEBUG__ and WXDEBUG */
8b0bd21b VZ	37	#ifdef NDEBUG
	38	#undef __WXDEBUG__
	39	#undef WXDEBUG
e0c749a7	40	#endif /* NDEBUG */
8b0bd21b	41
e0c749a7	42	/* if __WXDEBUG__ is defined, make sure that WXDEBUG is defined and >= 1 */
8b0bd21b VZ	43	#ifdef __WXDEBUG__
	44	#if !defined(WXDEBUG) \|\| !WXDEBUG
	45	#undef WXDEBUG
	46	#define WXDEBUG 1
e0c749a7 RN	47	#endif /* !WXDEBUG */
	48	#endif /* __WXDEBUG__ */
	49
986d27c3 VZ	50	#ifndef __WXFUNCTION__
986d27c3 VZ	51	/* TODO: add more compilers supporting __FUNCTION__ */
a9672e89 WS	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__)
986d27c3 VZ	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 */
dfa0b52f	67
e0c749a7 RN	68	/* ---------------------------------------------------------------------------- */
	69	/* Debugging macros */
	70	/* */
6a17b868	71	/* All debugging macros rely on ASSERT() which in turn calls the user-defined */
e0c749a7	72	/* OnAssert() function. To keep things simple, it's called even when the */
68379eaf	73	/* expression is true (i.e. everything is ok) and by default does nothing: just */
e0c749a7 RN	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 */
34cbe514	91	#if defined(__cplusplus) && defined(__WXDEBUG__)
7ba4fbeb	92	/*
497a2d6d VZ	93	This function is called whenever one of debugging macros fails (i.e.
497a2d6d VZ	94	condition is false in an assertion). To customize its behaviour, override
2b232d20	95	wxApp::OnAssertFailure().
7ba4fbeb	96
497a2d6d	97	Parameters:
7ba4fbeb	98	szFile and nLine - file name and line number of the ASSERT
acc476c5	99	szFunc - function name of the ASSERT, may be NULL (NB: ASCII)
497a2d6d	100	szCond - text form of the condition which failed
7ba4fbeb	101	szMsg - optional message explaining the reason
c801d85f	102	*/
0accd1cf	103
2b232d20	104	/* this version is for compatibility with wx 2.8 Unicode build only: */
bddd7a8d	105	extern void WXDLLIMPEXP_BASE wxOnAssert(const wxChar *szFile,
886dd7d2	106	int nLine,
acc476c5	107	const char *szFunc,
886dd7d2 VZ	108	const wxChar *szCond,
886dd7d2 VZ	109	const wxChar *szMsg = NULL);
749b01f0	110
0accd1cf VS	111	#if wxUSE_UNICODE
	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,
	117	int nLine,
	118	const char *szFunc,
	119	const char *szCond);
	120
	121	extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
	122	int nLine,
	123	const char *szFunc,
	124	const char *szCond,
	125	const char *szMsg);
	126
	127	extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
	128	int nLine,
	129	const char *szFunc,
	130	const char *szCond,
	131	const wxChar *szMsg);
28efe654	132	#endif /* wxUSE_UNICODE */
0accd1cf VS	133
0accd1cf VS	134	class WXDLLIMPEXP_BASE wxString;
2b232d20 VZ	135	class WXDLLIMPEXP_BASE wxCStrData;
	136
	137	/* these two work when szMsg passed to debug macro is a string,
	138	we also have to provide wxCStrData overload to resolve ambiguity
	139	which would otherwise arise from wxASSERT( s.c_str() ): */
0accd1cf VS	140	extern void WXDLLIMPEXP_BASE wxOnAssert(const wxString& szFile,
	141	int nLine,
	142	const wxString& szFunc,
	143	const wxString& szCond,
	144	const wxString& szMsg);
	145
	146	extern void WXDLLIMPEXP_BASE wxOnAssert(const wxString& szFile,
	147	int nLine,
	148	const wxString& szFunc,
	149	const wxString& szCond);
	150
2b232d20 VZ	151	extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
	152	int nLine,
	153	const char *szFunc,
	154	const char *szCond,
	155	const wxCStrData& msg);
	156
fbaf7d45 VS	157	extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
	158	int nLine,
	159	const char *szFunc,
	160	const char *szCond,
	161	const wxString& szMsg);
	162
e0c749a7 RN	163	/* call this function to break into the debugger unconditionally (assuming */
e0c749a7 RN	164	/* the program is running under debugger, of course) */
bddd7a8d	165	extern void WXDLLIMPEXP_BASE wxTrap();
c801d85f	166
e0c749a7	167	/* generic assert macro */
0accd1cf	168	#define wxASSERT(cond) wxASSERT_MSG(cond, (const char*)NULL)
3b1de9c2	169
9d73af58 DS	170
	171	/* assert with additional message explaining its cause */
	172
	173	/* compilers can give a warning (such as "possible unwanted ;") when using */
	174	/* the default definition of wxASSERT_MSG so we provide an alternative */
	175	#if defined(__MWERKS__)
	176	#define wxASSERT_MSG(cond, msg) \
	177	if ( cond ) \
	178	{} \
	179	else \
0accd1cf	180	wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg)
9d73af58 DS	181	#else
	182	#define wxASSERT_MSG(cond, msg) \
	183	if ( cond ) \
	184	; \
	185	else \
0accd1cf	186	wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg)
9d73af58	187	#endif
497a2d6d VZ	188
497a2d6d VZ	189	/* special form of assert: always triggers it (in debug mode) */
0accd1cf	190	#define wxFAIL wxFAIL_MSG((const char*)NULL)
497a2d6d VZ	191
497a2d6d VZ	192	/* FAIL with some message */
b503b407 VZ	193	#define wxFAIL_MSG(msg) wxFAIL_COND_MSG("wxAssertFailure", msg)
	194
	195	/* FAIL with some message and a condition */
	196	#define wxFAIL_COND_MSG(cond, msg) \
0accd1cf	197	wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, cond, msg)
749b01f0	198
6a17b868	199	/* An assert helper used to avoid warning when testing constant expressions, */
e0c749a7 RN	200	/* i.e. wxASSERT( sizeof(int) == 4 ) can generate a compiler warning about */
	201	/* expression being always true, but not using */
	202	/* wxASSERT( wxAssertIsEqual(sizeof(int), 4) ) */
	203	/* */
6a17b868 SN	204	/* NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and should no */
6a17b868 SN	205	/* longer be used. */
bddd7a8d	206	extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y);
c801d85f	207	#else
749b01f0 VZ	208	#define wxTrap()
749b01f0 VZ	209
6a17b868	210	/* nothing to do in release mode (hopefully at this moment there are */
e0c749a7	211	/* no more bugs ;-) */
7ba4fbeb	212	#define wxASSERT(cond)
dfa0b52f	213	#define wxASSERT_MSG(cond, msg)
497a2d6d VZ	214	#define wxFAIL
497a2d6d VZ	215	#define wxFAIL_MSG(msg)
b503b407	216	#define wxFAIL_COND_MSG(cond, msg)
e0c749a7	217	#endif /* __WXDEBUG__ */
c801d85f	218
34cbe514	219	#ifdef __cplusplus
68379eaf	220	/* Use of wxFalse instead of false suppresses compiler warnings about testing */
e0c749a7	221	/* constant expression */
16cba29d	222	extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
34cbe514 RN	223	#endif
34cbe514 RN	224
2b5f62a0	225	#define wxAssertFailure wxFalse
8b0bd21b	226
6a17b868	227	/* NB: the following macros also work in release mode! */
c801d85f	228
7ba4fbeb	229	/*
c801d85f	230	These macros must be used only in invalid situation: for example, an
6a17b868	231	invalid parameter (e.g. a NULL pointer) is passed to a function. Instead of
c801d85f KB	232	dereferencing it and causing core dump the function might try using
c801d85f KB	233	CHECK( p != NULL ) or CHECK( p != NULL, return LogError("p is NULL!!") )
c801d85f	234	*/
7ba4fbeb	235
e0c749a7	236	/* check that expression is true, "return" if not (also FAILs in debug mode) */
0accd1cf	237	#define wxCHECK(cond, rc) wxCHECK_MSG(cond, rc, (const char*)NULL)
7ba4fbeb	238
e0c749a7	239	/* as wxCHECK but with a message explaining why we fail */
dfa0b52f	240	#define wxCHECK_MSG(cond, rc, msg) wxCHECK2_MSG(cond, return rc, msg)
7ba4fbeb	241
e0c749a7	242	/* check that expression is true, perform op if not */
0accd1cf	243	#define wxCHECK2(cond, op) wxCHECK2_MSG(cond, op, (const char*)NULL)
7ba4fbeb	244
e0c749a7	245	/* as wxCHECK2 but with a message explaining why we fail */
9d73af58 DS	246
	247	/* see comment near the definition of wxASSERT_MSG for the # if/else reason */
	248	#if defined(__MWERKS__)
	249	#define wxCHECK2_MSG(cond, op, msg) \
	250	if ( cond ) \
	251	{} \
	252	else \
	253	{ \
	254	wxFAIL_COND_MSG(#cond, msg); \
	255	op; \
	256	} \
	257	struct wxDummyCheckStruct /* just to force a semicolon */
	258	#else
	259	#define wxCHECK2_MSG(cond, op, msg) \
	260	if ( cond ) \
	261	; \
	262	else \
	263	{ \
	264	wxFAIL_COND_MSG(#cond, msg); \
	265	op; \
	266	} \
	267	struct wxDummyCheckStruct /* just to force a semicolon */
	268	#endif
7ba4fbeb	269
e0c749a7 RN	270	/* special form of wxCHECK2: as wxCHECK, but for use in void functions */
	271	/* */
	272	/* NB: there is only one form (with msg parameter) and it's intentional: */
	273	/* there is no other way to tell the caller what exactly went wrong */
	274	/* from the void function (of course, the function shouldn't be void */
	275	/* to begin with...) */
dfa0b52f	276	#define wxCHECK_RET(cond, msg) wxCHECK2_MSG(cond, return, msg)
c801d85f	277
e0c749a7 RN	278	/* ---------------------------------------------------------------------------- */
	279	/* Compile time asserts */
	280	/* */
	281	/* Unlike the normal assert and related macros above which are checked during */
	282	/* the program tun-time the macros below will result in a compilation error if */
	283	/* the condition they check is false. This is usually used to check the */
	284	/* expressions containing sizeof()s which cannot be tested with the */
	285	/* preprocessor. If you can use the #if's, do use them as you can give a more */
	286	/* detailed error message then. */
	287	/* ---------------------------------------------------------------------------- */
8f5d9104 VZ	288
	289	/*
	290	How this works (you don't have to understand it to be able to use the
	291	macros): we rely on the fact that it is invalid to define a named bit field
	292	in a struct of width 0. All the rest are just the hacks to minimize the
	293	possibility of the compiler warnings when compiling this macro: in
	294	particular, this is why we define a struct and not an object (which would
	295	result in a warning about unused variable) and a named struct (otherwise we'd
	296	get a warning about an unnamed struct not used to define an object!).
	297	*/
	298
9bf41e06	299	#define wxMAKE_UNIQUE_ASSERT_NAME wxMAKE_UNIQUE_NAME(wxAssert_)
8f5d9104 VZ	300
	301	/*
	302	The second argument of this macro must be a valid C++ identifier and not a
	303	string. I.e. you should use it like this:
	304
	305	wxCOMPILE_TIME_ASSERT( sizeof(int) >= 2, YourIntsAreTooSmall );
	306
	307	It may be used both within a function and in the global scope.
	308	*/
0872eaf9	309	#if defined(__WATCOMC__) && defined(__cplusplus)
1c6f2414 WS	310	/* avoid "unused symbol" warning */
	311	#define wxCOMPILE_TIME_ASSERT(expr, msg) \
	312	class wxMAKE_UNIQUE_ASSERT_NAME { \
	313	unsigned int msg: expr; \
871cc651	314	wxMAKE_UNIQUE_ASSERT_NAME() { wxUnusedVar(msg); } \
1c6f2414 WS	315	}
	316	#else
	317	#define wxCOMPILE_TIME_ASSERT(expr, msg) \
	318	struct wxMAKE_UNIQUE_ASSERT_NAME { unsigned int msg: expr; }
	319	#endif
8f5d9104	320
871cc651 VZ	321	/*
	322	When using VC++ 6 with "Edit and Continue" on, the compiler completely
	323	mishandles __LINE__ and so wxCOMPILE_TIME_ASSERT() doesn't work, provide a
	324	way to make "unique" assert names by specifying a unique prefix explicitly
	325	*/
	326	#define wxMAKE_UNIQUE_ASSERT_NAME2(text) wxCONCAT(wxAssert_, text)
7bb688a8	327
17dc7ddd WS	328	#define wxCOMPILE_TIME_ASSERT2(expr, msg, text) \
17dc7ddd WS	329	struct wxMAKE_UNIQUE_ASSERT_NAME2(text) { unsigned int msg: expr; }
8de1759c	330
e0c749a7	331	/* helpers for wxCOMPILE_TIME_ASSERT below, for private use only */
8f5d9104 VZ	332	#define wxMAKE_BITSIZE_MSG(type, size) type ## SmallerThan ## size ## Bits
8f5d9104 VZ	333
e0c749a7 RN	334	/* a special case of compile time assert: check that the size of the given type */
e0c749a7 RN	335	/* is at least the given number of bits */
8f5d9104 VZ	336	#define wxASSERT_MIN_BITSIZE(type, size) \
	337	wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \
	338	wxMAKE_BITSIZE_MSG(type, size))
	339
e0c749a7 RN	340	/* ---------------------------------------------------------------------------- */
	341	/* other miscellaneous debugger-related functions */
	342	/* ---------------------------------------------------------------------------- */
a434b43f	343
c50a4038 VZ	344	/*
	345	Return true if we're running under debugger.
	346
	347	Currently this only really works under Win32 and Mac in CodeWarrior builds,
	348	it always returns false in other cases.
	349	*/
34cbe514	350	#ifdef __cplusplus
532d575b WS	351	/* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */
532d575b WS	352	#if defined(__WXMAC__) \|\| defined(__WIN32__)
34cbe514	353	extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning();
e0c749a7	354	#else /* !Mac */
34cbe514	355	inline bool wxIsDebuggerRunning() { return false; }
e0c749a7 RN	356	#endif /* Mac/!Mac */
e0c749a7 RN	357	#endif /* __cplusplus */
a434b43f	358
e0c749a7	359	#endif /* _WX_DEBUG_H_ */