Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first round of debug/release merge: introduce wxDEBUG_LEVEL, for now defined as 1 if __WXDEBUG__ is defined, i.e. no real changes; don't use __WXDEBUG__ in the headers to keep debug and release builds ABI-compatible; add functions to customize or disable asserts handling

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@59711 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2009-03-21 23:36:37 +00:00
parent b822bdc032
commit 657a8a3598
43 changed files with 659 additions and 568 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/wx/app.h
View File

@@ -335,7 +335,6 @@ public:
// debugging support // debugging support
// ----------------- // -----------------
#ifdef __WXDEBUG__
// this function is called when an assert failure occurs, the base class // this function is called when an assert failure occurs, the base class
// version does the normal processing (i.e. shows the usual assert failure // version does the normal processing (i.e. shows the usual assert failure
// dialog box) // dialog box)
@@ -355,7 +354,6 @@ public:
int line, int line,
const wxChar *cond, const wxChar *cond,
const wxChar *msg); const wxChar *msg);
#endif // __WXDEBUG__
// check that the wxBuildOptions object (constructed in the application // check that the wxBuildOptions object (constructed in the application
// itself, usually the one from IMPLEMENT_APP() macro) matches the build // itself, usually the one from IMPLEMENT_APP() macro) matches the build

8
include/wx/apptrait.h
View File

@@ -87,7 +87,6 @@ public:
// functions abstracting differences between GUI and console modes // functions abstracting differences between GUI and console modes
// ------------------------------------------------------------------------ // ------------------------------------------------------------------------
#ifdef __WXDEBUG__
// show the assert dialog with the specified message in GUI or just print // show the assert dialog with the specified message in GUI or just print
// the string to stderr in console mode // the string to stderr in console mode
// //
@@ -96,7 +95,6 @@ public:
// //
// return true to suppress subsequent asserts, false to continue as before // return true to suppress subsequent asserts, false to continue as before
virtual bool ShowAssertDialog(const wxString& msg) = 0; virtual bool ShowAssertDialog(const wxString& msg) = 0;
#endif // __WXDEBUG__
// return true if fprintf(stderr) goes somewhere, false otherwise // return true if fprintf(stderr) goes somewhere, false otherwise
virtual bool HasStderr() = 0; virtual bool HasStderr() = 0;
@@ -177,7 +175,7 @@ public:
protected: protected:
#if wxUSE_STACKWALKER && defined( __WXDEBUG__ ) #if wxUSE_STACKWALKER
// utility function: returns the stack frame as a plain wxString // utility function: returns the stack frame as a plain wxString
virtual wxString GetAssertStackTrace(); virtual wxString GetAssertStackTrace();
#endif #endif
@@ -232,9 +230,7 @@ public:
#endif // wxUSE_FONTMAP #endif // wxUSE_FONTMAP
virtual wxRendererNative *CreateRenderer(); virtual wxRendererNative *CreateRenderer();
#ifdef __WXDEBUG__
virtual bool ShowAssertDialog(const wxString& msg); virtual bool ShowAssertDialog(const wxString& msg);
#endif // __WXDEBUG__
virtual bool HasStderr(); virtual bool HasStderr();
virtual void ScheduleForDestroy(wxObject *object); virtual void ScheduleForDestroy(wxObject *object);
@@ -273,9 +269,7 @@ public:
#endif // wxUSE_FONTMAP #endif // wxUSE_FONTMAP
virtual wxRendererNative *CreateRenderer(); virtual wxRendererNative *CreateRenderer();
#ifdef __WXDEBUG__
virtual bool ShowAssertDialog(const wxString& msg); virtual bool ShowAssertDialog(const wxString& msg);
#endif // __WXDEBUG__
virtual bool HasStderr(); virtual bool HasStderr();
virtual void ScheduleForDestroy(wxObject *object); virtual void ScheduleForDestroy(wxObject *object);

9
include/wx/cocoa/app.h
View File

@@ -67,17 +67,8 @@ public:
virtual bool OnInit(); virtual bool OnInit();
virtual bool OnInitGui(); virtual bool OnInitGui();
#ifdef __WXDEBUG__
virtual void OnAssert(const wxChar *file, int line, const wxChar *cond, const wxChar *msg);
bool IsInAssert() const { return m_isInAssert; }
#endif // __WXDEBUG__
// Set true _before_ initializing wx to force embedded mode (no app delegate, etc.) // Set true _before_ initializing wx to force embedded mode (no app delegate, etc.)
static bool sm_isEmbedded; static bool sm_isEmbedded;
private:
#ifdef __WXDEBUG__
bool m_isInAssert;
#endif // __WXDEBUG__
}; };
#endif // _WX_COCOA_APP_H_ #endif // _WX_COCOA_APP_H_

4
include/wx/dataview.h
View File

@@ -81,10 +81,6 @@ public:
void* GetID() const { return m_id; } void* GetID() const { return m_id; }
operator const void* () const { return m_id; } operator const void* () const { return m_id; }
#ifdef __WXDEBUG__
void Print( const wxString &text ) const;
#endif
private: private:
void* m_id; void* m_id;
}; };

23
include/wx/dcbuffer.h
View File

@@ -216,9 +216,6 @@ private:
#define wxAutoBufferedPaintDCBase wxBufferedPaintDC #define wxAutoBufferedPaintDCBase wxBufferedPaintDC
#endif #endif
#ifdef __WXDEBUG__
class WXDLLIMPEXP_CORE wxAutoBufferedPaintDC : public wxAutoBufferedPaintDCBase class WXDLLIMPEXP_CORE wxAutoBufferedPaintDC : public wxAutoBufferedPaintDCBase
{ {
public: public:
@@ -226,30 +223,18 @@ public:
wxAutoBufferedPaintDC(wxWindow* win) wxAutoBufferedPaintDC(wxWindow* win)
: wxAutoBufferedPaintDCBase(win) : wxAutoBufferedPaintDCBase(win)
{ {
TestWinStyle(win); wxASSERT_MSG( win->GetBackgroundStyle() == wxBG_STYLE_CUSTOM,
"You need to call SetBackgroundStyle(wxBG_STYLE_CUSTOM) in ctor, "
"and also, if needed, paint the background in wxEVT_PAINT handler."
);
} }
virtual ~wxAutoBufferedPaintDC() { } virtual ~wxAutoBufferedPaintDC() { }
private: private:
void TestWinStyle(wxWindow* win)
{
// Help the user to get the double-buffering working properly.
wxASSERT_MSG( win->GetBackgroundStyle() == wxBG_STYLE_CUSTOM,
wxT("In constructor, you need to call SetBackgroundStyle(wxBG_STYLE_CUSTOM), ")
wxT("and also, if needed, paint the background manually in the paint event handler."));
}
wxDECLARE_NO_COPY_CLASS(wxAutoBufferedPaintDC); wxDECLARE_NO_COPY_CLASS(wxAutoBufferedPaintDC);
}; };
#else // !__WXDEBUG__
// In release builds, just use typedef
typedef wxAutoBufferedPaintDCBase wxAutoBufferedPaintDC;
#endif
// Check if the window is natively double buffered and will return a wxPaintDC // Check if the window is natively double buffered and will return a wxPaintDC

443
include/wx/debug.h
View File

@@ -20,10 +20,30 @@
#include "wx/chartype.h" // for __TFILE__ and wxChar #include "wx/chartype.h" // for __TFILE__ and wxChar
#include "wx/cpp.h" // for __WXFUNCTION__ #include "wx/cpp.h" // for __WXFUNCTION__
class WXDLLIMPEXP_FWD_BASE wxString;
class WXDLLIMPEXP_FWD_BASE wxCStrData;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Defines controlling the debugging macros // Defines controlling the debugging macros
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
/*
wxWidgets can be built with several different levels of debug support
specified by the value of wxDEBUG_LEVEL constant:
0: No assertion macros at all, this should only be used when optimizing
for resource-constrained systems (typically embedded ones).
1: Default level, most of the assertions are enabled.
2: Maximal (at least for now): asserts which are "expensive"
(performance-wise) or only make sense for finding errors in wxWidgets
itself, as opposed to bugs in applications using it, are also enabled.
For compatibility reasons, currently wxDEBUG_LEVEL is defined if
__WXDEBUG__ is defined but in the near future (2.9.1) the role of the flags
will change and wxDEBUG_LEVEL will be the primary value with __WXDEBUG__
only used for compatibility.
*/
// if _DEBUG is defined (MS VC++ and others use it in debug builds), define // if _DEBUG is defined (MS VC++ and others use it in debug builds), define
// __WXDEBUG__ too // __WXDEBUG__ too
#ifdef _DEBUG #ifdef _DEBUG
@@ -46,175 +66,235 @@
#endif // !WXDEBUG #endif // !WXDEBUG
#endif // __WXDEBUG__ #endif // __WXDEBUG__
// temporarily define wxDEBUG_LEVEL as function of __WXDEBUG__
#if !defined(wxDEBUG_LEVEL)
#ifdef __WXDEBUG__
#define wxDEBUG_LEVEL 1
#else
#define wxDEBUG_LEVEL 0
#endif
#endif // !defined(wxDEBUG_LEVEL)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Debugging macros // Handling assertion failures
//
// 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(__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_FWD_BASE wxString;
class WXDLLIMPEXP_FWD_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
// Note: some compilers will give a warning (such as
// "possible unwanted ;") when using a ";" instead of the "{}".
#define wxASSERT_MSG(cond, msg) \
if ( cond ) \
{} \
else \
wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg)
// 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__ */
// Use of wxFalse instead of false suppresses compiler warnings about testing
// constant expression
extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
#define wxAssertFailure wxFalse
// NB: the following macros also work in release mode!
/* /*
These macros must be used only in invalid situation: for example, an Type for the function called in case of assert failure, see
invalid parameter (e.g. a NULL pointer) is passed to a function. Instead of wxSetAssertHandler().
dereferencing it and causing core dump the function might try using */
CHECK( p != NULL ) or CHECK( p != NULL, return LogError("p is NULL!!") ) typedef void (*wxAssertHandler_t)(const wxString& file,
int line,
const wxString& func,
const wxString& cond,
const wxString& msg);
#if wxDEBUG_LEVEL
// the global assert handler function, if it is NULL asserts don't check their
// conditions
extern WXDLLIMPEXP_DATA_BASE(wxAssertHandler_t) wxTheAssertHandler;
/*
Sets the function to be called in case of assertion failure.
The default assert handler forwards to wxApp::OnAssertFailure() whose
default behaviour is, in turn, to show the standard assertion failure
dialog if a wxApp object exists or shows the same dialog itself directly
otherwise.
While usually it is enough -- and more convenient -- to just override
OnAssertFailure(), to handle all assertion failures, including those
occurring even before wxApp object creation of after its destruction you
need to provide your assertion handler function.
This function also provides a simple way to disable all asserts: simply
pass NULL pointer to it. Doing this will result in not even evaluating
assert conditions at all, avoiding almost all run-time cost of asserts.
Notice that this function is not MT-safe, so you should call it before
starting any other threads.
The return value of this function is the previous assertion handler. It can
be called after any pre-processing by your handler and can also be restored
later if you uninstall your handler.
*/
inline wxAssertHandler_t wxSetAssertHandler(wxAssertHandler_t handler)
{
const wxAssertHandler_t old = wxTheAssertHandler;
wxTheAssertHandler = handler;
return old;
}
#else // !wxDEBUG_LEVEL
// provide empty subs in case assertions are completely disabled
//
// NB: can't use WXUNUSED() here as we're included from wx/defs.h before it is
// defined
inline wxAssertHandler_t wxSetAssertHandler(wxAssertHandler_t /* handler */)
{
return NULL;
}
#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
// simply a synonym for wxSetAssertHandler(NULL)
inline void wxDisableAsserts() { wxSetAssertHandler(NULL); }
#if wxDEBUG_LEVEL
/*
wxOnAssert() is used by the debugging macros defined below. Different
overloads are needed because these macros can be used with or without _T().
All of them are implemented in src/common/appcmn.cpp and unconditionally
call wxTheAssertHandler so the caller must check that it is non-NULL
(assert macros do it).
*/
#if wxUSE_UNICODE
// these overloads are the ones typically used by debugging macros: we have to
// provide wxChar* msg version because it's common to use _T() in the macros
// and finally, we can't use const wx(char)* msg = NULL, because that would
// be ambiguous
//
// also notice that these functions can't be inline as wxString is not defined
// yet (and can't be as wxString code itself may use assertions)
extern void WXDLLIMPEXP_BASE wxOnAssert(const char *file,
int line,
const char *func,
const char *cond);
extern void WXDLLIMPEXP_BASE wxOnAssert(const char *file,
int line,
const char *func,
const char *cond,
const char *msg);
extern void WXDLLIMPEXP_BASE wxOnAssert(const char *file,
int line,
const char *func,
const char *cond,
const wxChar *msg);
#endif /* wxUSE_UNICODE */
// this version is for compatibility with wx 2.8 Unicode build only, we don't
// use it ourselves any more except in ANSI-only build in which case it is all
// we need
extern void WXDLLIMPEXP_BASE wxOnAssert(const wxChar *file,
int line,
const char *func,
const wxChar *cond,
const wxChar *msg = NULL);
// these overloads work when msg passed to debug macro is a string and 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& file,
int line,
const wxString& func,
const wxString& cond,
const wxString& msg);
extern void WXDLLIMPEXP_BASE wxOnAssert(const wxString& file,
int line,
const wxString& func,
const wxString& cond);
extern void WXDLLIMPEXP_BASE wxOnAssert(const char *file,
int line,
const char *func,
const char *cond,
const wxCStrData& msg);
extern void WXDLLIMPEXP_BASE wxOnAssert(const char *file,
int line,
const char *func,
const char *cond,
const wxString& msg);
#endif // wxDEBUG_LEVEL
// ----------------------------------------------------------------------------
// Debugging macros
// ----------------------------------------------------------------------------
/*
Assertion macros: check if the condition is true and call assert handler
(which will by default notify the user about failure) if it isn't.
wxASSERT and wxFAIL macros as well as wxTrap() function do nothing at all
if wxDEBUG_LEVEL is 0 however they do check their conditions at default
debug level 1, unlike the previous wxWidgets versions.
wxASSERT_LEVEL_2 is meant to be used for "expensive" asserts which should
normally be disabled because they have a big impact on performance and so
this macro only does anything if wxDEBUG_LEVEL >= 2.
*/
#if wxDEBUG_LEVEL
// call this function to break into the debugger unconditionally (assuming
// the program is running under debugger, of course)
extern void WXDLLIMPEXP_BASE wxTrap();
// assert checks if the condition is true and calls the assert handler with
// the provided message if it isn't
//
// NB: the macro is defined like this to ensure that nested if/else
// statements containing it are compiled in the same way whether it is
// defined as empty or not; also notice that we can't use ";" instead
// of "{}" as some compilers warn about "possible unwanted ;" then
#define wxASSERT_MSG(cond, msg) \
if ( !wxTheAssertHandler || (cond) ) \
{} \
else \
wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg)
// a version without any additional message, don't use unless condition
// itself is fully self-explanatory
#define wxASSERT(cond) wxASSERT_MSG(cond, (const char*)NULL)
// wxFAIL is a special form of assert: it always triggers (and so is
// usually used in normally unreachable code)
#define wxFAIL_COND_MSG(cond, msg) \
wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, cond, msg)
#define wxFAIL_MSG(msg) wxFAIL_COND_MSG("Assert failure", msg)
#define wxFAIL wxFAIL_MSG((const char*)NULL)
#else // !wxDEBUG_LEVEL
#define wxTrap()
#define wxASSERT(cond)
#define wxASSERT_MSG(cond, msg)
#define wxFAIL
#define wxFAIL_MSG(msg)
#define wxFAIL_COND_MSG(cond, msg)
#endif // wxDEBUG_LEVEL
#if wxDEBUG_LEVEL >= 2
#define wxASSERT_LEVEL_2_MSG(cond, msg) wxASSERT_MSG(cond, msg)
#define wxASSERT_LEVEL_2(cond) wxASSERT(cond)
#else // wxDEBUG_LEVEL < 2
#define wxASSERT_LEVEL_2_MSG
#define wxASSERT_LEVEL_2
#endif
/*
wxCHECK macros always check their conditions, setting debug level to 0 only
makes them silent in case of failure, otherwise -- including at default
debug level 1 -- they call the assert handler if the condition is false
They are supposed to 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 use
wxCHECK_RET( p != NULL, "pointer can't be NULL" )
*/ */
// check that expression is true, "return" if not (also FAILs in debug mode) // the generic macro: takes the condition to check, the statement to be execute
#define wxCHECK(cond, rc) wxCHECK_MSG(cond, rc, (const char*)NULL) // in case the condition is false and the message to pass to the assert handler
// 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
#define wxCHECK2_MSG(cond, op, msg) \ #define wxCHECK2_MSG(cond, op, msg) \
if ( cond ) \ if ( cond ) \
{} \ {} \
@@ -225,6 +305,15 @@ extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
} \ } \
struct wxDummyCheckStruct /* just to force a semicolon */ struct wxDummyCheckStruct /* just to force a semicolon */
// check which returns with the specified return code if the condition fails
#define wxCHECK_MSG(cond, rc, msg) wxCHECK2_MSG(cond, return rc, msg)
// check that expression is true, "return" if not (also FAILs in debug mode)
#define wxCHECK(cond, rc) wxCHECK_MSG(cond, rc, (const char*)NULL)
// check that expression is true, perform op if not
#define wxCHECK2(cond, op) wxCHECK2_MSG(cond, op, (const char*)NULL)
// special form of wxCHECK2: as wxCHECK, but for use in void functions // 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: // NB: there is only one form (with msg parameter) and it's intentional:
@@ -233,11 +322,12 @@ extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
// to begin with...) // to begin with...)
#define wxCHECK_RET(cond, msg) wxCHECK2_MSG(cond, return, msg) #define wxCHECK_RET(cond, msg) wxCHECK2_MSG(cond, return, msg)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Compile time asserts // Compile time asserts
// //
// Unlike the normal assert and related macros above which are checked during // 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 program run-time the macros below will result in a compilation error if
// the condition they check is false. This is usually used to check the // the condition they check is false. This is usually used to check the
// expressions containing sizeof()s which cannot be tested with 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 // preprocessor. If you can use the #if's, do use them as you can give a more
@@ -295,6 +385,7 @@ extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \ wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \
wxMAKE_BITSIZE_MSG(type, size)) wxMAKE_BITSIZE_MSG(type, size))
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// other miscellaneous debugger-related functions // other miscellaneous debugger-related functions
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -311,4 +402,28 @@ extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
inline bool wxIsDebuggerRunning() { return false; } inline bool wxIsDebuggerRunning() { return false; }
#endif // Mac/!Mac #endif // Mac/!Mac
// 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);
// Use of wxFalse instead of false suppresses compiler warnings about testing
// constant expression
extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
#define wxAssertFailure wxFalse
// This is similar to WXUNUSED() and useful for parameters which are only used
// in assertions.
#if wxDEBUG_LEVEL
#define WXUNUSED_UNLESS_DEBUG(param) param
#else
#define WXUNUSED_UNLESS_DEBUG(param) WXUNUSED(param)
#endif
#endif // _WX_DEBUG_H_ #endif // _WX_DEBUG_H_

7
include/wx/defs.h
View File

@@ -661,13 +661,6 @@ typedef short int WXTYPE;
#define WXUNUSED(identifier) identifier #define WXUNUSED(identifier) identifier
#endif #endif
/* some arguments are only used in debug mode, but unused in release one */
#ifdef __WXDEBUG__
#define WXUNUSED_UNLESS_DEBUG(param) param
#else
#define WXUNUSED_UNLESS_DEBUG(param) WXUNUSED(param)
#endif
/* some arguments are not used in unicode mode */ /* some arguments are not used in unicode mode */
#if wxUSE_UNICODE #if wxUSE_UNICODE
#define WXUNUSED_IN_UNICODE(param) WXUNUSED(param) #define WXUNUSED_IN_UNICODE(param) WXUNUSED(param)

17
include/wx/event.h
View File

@@ -1636,7 +1636,9 @@ private:
wxEVT_PAINT_ICON wxEVT_PAINT_ICON
*/ */
#if defined(__WXDEBUG__) && (defined(__WXMSW__) || defined(__WXPM__)) #if wxDEBUG_LEVEL && (defined(__WXMSW__) || defined(__WXPM__))
#define wxHAS_PAINT_DEBUG
// see comments in src/msw|os2/dcclient.cpp where g_isPainting is defined // see comments in src/msw|os2/dcclient.cpp where g_isPainting is defined
extern WXDLLIMPEXP_CORE int g_isPainting; extern WXDLLIMPEXP_CORE int g_isPainting;
#endif // debug #endif // debug
@@ -1647,15 +1649,15 @@ public:
wxPaintEvent(int Id = 0) wxPaintEvent(int Id = 0)
: wxEvent(Id, wxEVT_PAINT) : wxEvent(Id, wxEVT_PAINT)
{ {
#if defined(__WXDEBUG__) && (defined(__WXMSW__) || defined(__WXPM__)) #ifdef wxHAS_PAINT_DEBUG
// set the internal flag for the duration of processing of WM_PAINT // set the internal flag for the duration of redrawing
g_isPainting++; g_isPainting++;
#endif // debug #endif // debug
} }
// default copy ctor and dtor are normally fine, we only need them to keep // default copy ctor and dtor are normally fine, we only need them to keep
// g_isPainting updated in debug build // g_isPainting updated in debug build
#if defined(__WXDEBUG__) && (defined(__WXMSW__) || defined(__WXPM__)) #ifdef wxHAS_PAINT_DEBUG
wxPaintEvent(const wxPaintEvent& event) wxPaintEvent(const wxPaintEvent& event)
: wxEvent(event) : wxEvent(event)
{ {
@@ -2804,10 +2806,11 @@ public:
// Clear table // Clear table
void Clear(); void Clear();
#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING #if wxUSE_MEMORY_TRACING
// Clear all tables // Clear all tables: only used to work around problems in memory tracing
// code
static void ClearAll(); static void ClearAll();
#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING #endif // wxUSE_MEMORY_TRACING
protected: protected:
// Init the hash table with the entries of the static event table. // Init the hash table with the entries of the static event table.

5
include/wx/gtk/app.h
View File

@@ -45,13 +45,11 @@ public:
virtual bool Initialize(int& argc, wxChar **argv); virtual bool Initialize(int& argc, wxChar **argv);
virtual void CleanUp(); virtual void CleanUp();
#ifdef __WXDEBUG__
virtual void OnAssertFailure(const wxChar *file, virtual void OnAssertFailure(const wxChar *file,
int line, int line,
const wxChar *func, const wxChar *func,
const wxChar *cond, const wxChar *cond,
const wxChar *msg); const wxChar *msg);
#endif // __WXDEBUG__
// GTK-specific methods // GTK-specific methods
// ------------------- // -------------------
@@ -80,9 +78,8 @@ public:
private: private:
// true if we're inside an assert modal dialog // true if we're inside an assert modal dialog
#ifdef __WXDEBUG__
bool m_isInAssert; bool m_isInAssert;
#endif // __WXDEBUG__
#if wxUSE_THREADS #if wxUSE_THREADS
wxMutex* m_idleMutex; wxMutex* m_idleMutex;
#endif #endif

10
include/wx/gtk1/app.h
View File

@@ -45,11 +45,13 @@ public:
static bool InitialzeVisual(); static bool InitialzeVisual();
#ifdef __WXDEBUG__ virtual void OnAssertFailure(const wxChar *file,
virtual void OnAssert(const wxChar *file, int line, const wxChar *cond, const wxChar *msg); int line,
const wxChar *func,
const wxChar *cond,
const wxChar *msg);
bool IsInAssert() const { return m_isInAssert; } bool IsInAssert() const { return m_isInAssert; }
#endif // __WXDEBUG__
gint m_idleTag; gint m_idleTag;
void RemoveIdleTag(); void RemoveIdleTag();
@@ -66,9 +68,7 @@ public:
private: private:
// true if we're inside an assert modal dialog // true if we're inside an assert modal dialog
#ifdef __WXDEBUG__
bool m_isInAssert; bool m_isInAssert;
#endif // __WXDEBUG__
DECLARE_DYNAMIC_CLASS(wxApp) DECLARE_DYNAMIC_CLASS(wxApp)
}; };

4
include/wx/hyperlink.h
View File

@@ -80,10 +80,6 @@ public:
void SendEvent(); void SendEvent();
}; };
#ifndef __WXDEBUG__
inline void wxHyperlinkCtrlBase::CheckParams(const wxString&, const wxString&, long) { }
#endif
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxHyperlinkEvent // wxHyperlinkEvent
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

21
include/wx/memory.h
View File

@@ -9,24 +9,17 @@
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MEMORYH__ #ifndef _WX_MEMORY_H_
#define _WX_MEMORYH__ #define _WX_MEMORY_H_
#include "wx/defs.h" #include "wx/defs.h"
#include "wx/string.h" #include "wx/string.h"
#include "wx/msgout.h" #include "wx/msgout.h"
/* #if wxUSE_MEMORY_TRACING || wxUSE_DEBUG_CONTEXT
The macro which will be expanded to include the file and line number
info, or to be a straight call to the new operator.
*/
#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
#include <stddef.h> #include <stddef.h>
#ifdef __WXDEBUG__
WXDLLIMPEXP_BASE void * wxDebugAlloc(size_t size, wxChar * fileName, int lineNum, bool isObject, bool isVect = false); WXDLLIMPEXP_BASE void * wxDebugAlloc(size_t size, wxChar * fileName, int lineNum, bool isObject, bool isVect = false);
WXDLLIMPEXP_BASE void wxDebugFree(void * buf, bool isVect = false); WXDLLIMPEXP_BASE void wxDebugFree(void * buf, bool isVect = false);
@@ -129,7 +122,6 @@ inline void operator delete[](void* pData, wxChar* /* fileName */, int /* lineNu
} }
#endif // __VISUALC__>=1200 #endif // __VISUALC__>=1200
#endif // wxUSE_GLOBAL_MEMORY_OPERATORS #endif // wxUSE_GLOBAL_MEMORY_OPERATORS
#endif // __WXDEBUG__
//********************************************************************************** //**********************************************************************************
@@ -357,7 +349,7 @@ void WXDLLIMPEXP_BASE wxTraceLevel(int level, const wxChar *fmt ...) WX_ATTRIBUT
#define WXTRACE wxTrace #define WXTRACE wxTrace
#define WXTRACELEVEL wxTraceLevel #define WXTRACELEVEL wxTraceLevel
#else // (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT #else // wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
#define WXDEBUG_DUMPDELAYCOUNTER #define WXDEBUG_DUMPDELAYCOUNTER
@@ -374,7 +366,6 @@ void WXDLLIMPEXP_BASE wxTraceLevel(int level, const wxChar *fmt ...) WX_ATTRIBUT
#define WXTRACE true ? (void)0 : wxTrace #define WXTRACE true ? (void)0 : wxTrace
#define WXTRACELEVEL true ? (void)0 : wxTraceLevel #define WXTRACELEVEL true ? (void)0 : wxTraceLevel
#endif // (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT #endif // wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
#endif #endif // _WX_MEMORY_H_
// _WX_MEMORYH__

2
include/wx/msgdlg.h
View File

@@ -140,7 +140,6 @@ public:
// change the dialog style flag // change the dialog style flag
void SetMessageDialogStyle(long style) void SetMessageDialogStyle(long style)
{ {
#ifdef __WXDEBUG__
wxASSERT_MSG( ((style & wxYES_NO) == wxYES_NO) || !(style & wxYES_NO), wxASSERT_MSG( ((style & wxYES_NO) == wxYES_NO) || !(style & wxYES_NO),
"wxYES and wxNO may only be used together" ); "wxYES and wxNO may only be used together" );
@@ -161,7 +160,6 @@ public:
if ((style & wxCANCEL_DEFAULT) != 0 && (style & wxNO_DEFAULT) != 0) if ((style & wxCANCEL_DEFAULT) != 0 && (style & wxNO_DEFAULT) != 0)
wxFAIL_MSG("only one default button can be specified"); wxFAIL_MSG("only one default button can be specified");
#endif
m_dialogStyle = style; m_dialogStyle = style;
} }

2
include/wx/msw/bitmap.h
View File

@@ -174,10 +174,8 @@ public:
void SetHBITMAP(WXHBITMAP bmp) { SetHandle((WXHANDLE)bmp); } void SetHBITMAP(WXHBITMAP bmp) { SetHandle((WXHANDLE)bmp); }
WXHBITMAP GetHBITMAP() const { return (WXHBITMAP)GetHandle(); } WXHBITMAP GetHBITMAP() const { return (WXHBITMAP)GetHandle(); }
#ifdef __WXDEBUG__
void SetSelectedInto(wxDC *dc); void SetSelectedInto(wxDC *dc);
wxDC *GetSelectedInto() const; wxDC *GetSelectedInto() const;
#endif // __WXDEBUG__
protected: protected:
virtual wxGDIImageRefData *CreateData() const; virtual wxGDIImageRefData *CreateData() const;

2
include/wx/msw/private.h
View File

@@ -692,14 +692,12 @@ public:
{ {
if ( m_hGlobal && !GlobalUnlock(m_hGlobal) ) if ( m_hGlobal && !GlobalUnlock(m_hGlobal) )
{ {
#ifdef __WXDEBUG__
// this might happen simply because the block became unlocked // this might happen simply because the block became unlocked
DWORD dwLastError = ::GetLastError(); DWORD dwLastError = ::GetLastError();
if ( dwLastError != NO_ERROR ) if ( dwLastError != NO_ERROR )
{ {
wxLogApiError(_T("GlobalUnlock"), dwLastError); wxLogApiError(_T("GlobalUnlock"), dwLastError);
} }
#endif // __WXDEBUG__
} }
} }

48
include/wx/object.h
View File

@@ -328,20 +328,16 @@ name##PluginSentinel m_pluginsentinel;
#define wxDynamicCastThis(className) \ #define wxDynamicCastThis(className) \
(IsKindOf(&className::ms_classInfo) ? (className *)(this) : (className *)0) (IsKindOf(&className::ms_classInfo) ? (className *)(this) : (className *)0)
#ifdef __WXDEBUG__ // FIXME-VC6: dummy argument needed because VC6 doesn't support explicitly
inline void* wxCheckCast(void *ptr) // choosing the template function to call
template <class T>
inline T *wxCheckCast(const void *ptr, T * = NULL)
{ {
wxASSERT_MSG( ptr, _T("wxStaticCast() used incorrectly") ); wxASSERT_MSG( wxDynamicCast(ptr, T), "wxStaticCast() used incorrectly" );
return ptr; return const_cast<T *>(static_cast<const T *>(ptr));
} }
#define wxStaticCast(obj, className) \
((className *)wxCheckCast(wxDynamicCast(obj, className)))
#else // !__WXDEBUG__ #define wxStaticCast(obj, className) wxCheckCast((obj), (className *)NULL)
#define wxStaticCast(obj, className) \
const_cast<className *>(static_cast<const className *>(obj))
#endif // __WXDEBUG__
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// set up memory debugging macros // set up memory debugging macros
@@ -359,7 +355,7 @@ inline void* wxCheckCast(void *ptr)
_WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT = void operator delete[] (void* buf, wxChar*, int ) _WX_WANT_ARRAY_DELETE_VOID_WXCHAR_INT = void operator delete[] (void* buf, wxChar*, int )
*/ */
#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING #if wxUSE_MEMORY_TRACING
// All compilers get this one // All compilers get this one
#define _WX_WANT_NEW_SIZET_WXCHAR_INT #define _WX_WANT_NEW_SIZET_WXCHAR_INT
@@ -400,7 +396,7 @@ inline void* wxCheckCast(void *ptr)
#endif // wxUSE_ARRAY_MEMORY_OPERATORS #endif // wxUSE_ARRAY_MEMORY_OPERATORS
#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING #endif // wxUSE_MEMORY_TRACING
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxObjectRefData: ref counted data meant to be stored in wxObject // wxObjectRefData: ref counted data meant to be stored in wxObject
@@ -653,24 +649,16 @@ private :
// more debugging macros // more debugging macros
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Redefine new to be the debugging version. This doesn't work with all #if wxUSE_DEBUG_NEW_ALWAYS
// compilers, in which case you need to use WXDEBUG_NEW explicitly if you wish
// to use the debugging version.
#ifdef __WXDEBUG__
#define WXDEBUG_NEW new(__TFILE__,__LINE__) #define WXDEBUG_NEW new(__TFILE__,__LINE__)
#if wxUSE_DEBUG_NEW_ALWAYS #if wxUSE_GLOBAL_MEMORY_OPERATORS
#if wxUSE_GLOBAL_MEMORY_OPERATORS #define new WXDEBUG_NEW
#define new WXDEBUG_NEW #elif defined(__VISUALC__)
#elif defined(__VISUALC__) // Including this file redefines new and allows leak reports to
// Including this file redefines new and allows leak reports to // contain line numbers
// contain line numbers #include "wx/msw/msvcrt.h"
#include "wx/msw/msvcrt.h" #endif
#endif #endif // wxUSE_DEBUG_NEW_ALWAYS
#endif // wxUSE_DEBUG_NEW_ALWAYS
#else // !__WXDEBUG__
#define WXDEBUG_NEW new
#endif // __WXDEBUG__/!__WXDEBUG__
#endif // _WX_OBJECTH__ #endif // _WX_OBJECTH__

5
include/wx/palmos/bitmap.h
View File

@@ -147,11 +147,6 @@ public:
void SetHBITMAP(WXHBITMAP bmp) { SetHandle((WXHANDLE)bmp); } void SetHBITMAP(WXHBITMAP bmp) { SetHandle((WXHANDLE)bmp); }
WXHBITMAP GetHBITMAP() const { return (WXHBITMAP)GetHandle(); } WXHBITMAP GetHBITMAP() const { return (WXHBITMAP)GetHandle(); }
#ifdef __WXDEBUG__
void SetSelectedInto(wxDC *dc);
wxDC *GetSelectedInto() const;
#endif // __WXDEBUG__
protected: protected:
// common part of all ctors // common part of all ctors
void Init(); void Init();

7
include/wx/propgrid/propgrid.h
View File

@@ -87,9 +87,7 @@ public:
int m_extraStyle; // global extra style int m_extraStyle; // global extra style
#ifdef __WXDEBUG__
int m_warnings; int m_warnings;
#endif
int HasExtraStyle( int style ) const { return (m_extraStyle & style); } int HasExtraStyle( int style ) const { return (m_extraStyle & style); }
}; };
@@ -1753,11 +1751,6 @@ protected:
*/ */
void CorrectEditorWidgetPosY(); void CorrectEditorWidgetPosY();
#ifdef __WXDEBUG__
void _log_items();
void OnScreenNote( const wxChar* format, ... );
#endif
/** Deselect current selection, if any. Returns true if success /** Deselect current selection, if any. Returns true if success
(ie. validator did not intercept). */ (ie. validator did not intercept). */
bool DoClearSelection(); bool DoClearSelection();

7
include/wx/stringops.h
View File

@@ -65,9 +65,10 @@ struct WXDLLIMPEXP_BASE wxStringOperationsUtf8
// checks correctness of UTF-8 sequence // checks correctness of UTF-8 sequence
static bool IsValidUtf8String(const char *c, static bool IsValidUtf8String(const char *c,
size_t len = wxStringImpl::npos); size_t len = wxStringImpl::npos);
#ifdef __WXDEBUG__ static bool IsValidUtf8LeadByte(unsigned char c)
static bool IsValidUtf8LeadByte(unsigned char c); {
#endif return (c <= 0x7F) || (c >= 0xC2 && c <= 0xF4);
}
// table of offsets to skip forward when iterating over UTF-8 sequence // table of offsets to skip forward when iterating over UTF-8 sequence
static const unsigned char ms_utf8IterTable[256]; static const unsigned char ms_utf8IterTable[256];

2
include/wx/unix/apptrait.h
View File

@@ -76,7 +76,7 @@ public:
wxArrayString& desc) const; wxArrayString& desc) const;
#endif // __WXGTK20____ #endif // __WXGTK20____
#if defined(__WXDEBUG__) && defined(__WXGTK20__) #if defined(__WXGTK20__)
virtual bool ShowAssertDialog(const wxString& msg); virtual bool ShowAssertDialog(const wxString& msg);
#endif #endif

4
include/wx/x11/app.h
View File

@@ -55,10 +55,6 @@ public:
// Processes an X event. // Processes an X event.
virtual bool ProcessXEvent(WXEvent* event); virtual bool ProcessXEvent(WXEvent* event);
#ifdef __WXDEBUG__
virtual void OnAssert(const wxChar *file, int line, const wxChar* cond, const wxChar *msg);
#endif // __WXDEBUG__
public: public:
// Implementation // Implementation
virtual bool Initialize(int& argc, wxChar **argv); virtual bool Initialize(int& argc, wxChar **argv);

2
include/wx/x11/privx.h
View File

@@ -67,9 +67,7 @@ void wxAllocNearestColor(Display *display,Colormap colormap,XColor *xcolor);
void wxAllocColor(Display *display,Colormap colormap,XColor *xcolor); void wxAllocColor(Display *display,Colormap colormap,XColor *xcolor);
// For debugging // For debugging
#ifdef __WXDEBUG__
wxString wxGetXEventName(XEvent& event); wxString wxGetXEventName(XEvent& event);
#endif
// Is the window visible? // Is the window visible?
bool wxWindowIsVisible(Window win); bool wxWindowIsVisible(Window win);

101
interface/wx/debug.h
View File

@@ -9,6 +9,31 @@
/** @addtogroup group_funcmacro_debug */ /** @addtogroup group_funcmacro_debug */
//@{ //@{
/**
@def wxDEBUG_LEVEL
Preprocessor symbol defining the level of debug support available.
Currently wxDEBUG_LEVEL is 0 in release builds (__WXDEBUG__ not defined)
and 1 in debug builds (it is). In the immediate future this will change
however and this symbol will be defined directly as 0, 1 or 2 while
__WXDEBUG__ won't be used by wxWidgets any longer.
@header{wx/debug.h}
*/
#define wxDEBUG_LEVEL
/**
Type for the function called in case of assert failure.
@see wxSetAssertHandler()
*/
typedef void (*wxAssertHandler_t)(const wxString& file,
int line,
const wxString& func,
const wxString& cond,
const wxString& msg);
/** /**
Assert macro. An error message will be generated if the condition is @false in Assert macro. An error message will be generated if the condition is @false in
debug mode, but nothing will be done in the release build. debug mode, but nothing will be done in the release build.
@@ -25,6 +50,32 @@
*/ */
#define wxASSERT( condition ) #define wxASSERT( condition )
/**
Assert macro for expensive run-time checks.
This macro does nothing unless wxDEBUG_LEVEL is 2 or more and is meant to
be used for the assertions with noticeable performance impact and which,
hence, should be disabled during run-time.
If wxDEBUG_LEVEL is 2 or more, it becomes the same as wxASSERT().
@header{wx/debug.h}
*/
#define wxASSERT_LEVEL_2( condition )
/**
Assert macro with a custom message for expensive run-time checks.
If wxDEBUG_LEVEL is 2 or more, this is the same as wxASSERT_MSG(),
otherwise it doesn't do anything at all.
@see wxASSERT_LEVEL_2()
@header{wx/debug.h}
*/
#define wxASSERT_LEVEL_2_MSG( condition, msg)
/** /**
This macro results in a @ref wxCOMPILE_TIME_ASSERT "compile time assertion failure" This macro results in a @ref wxCOMPILE_TIME_ASSERT "compile time assertion failure"
if the size of the given @c type is less than @c size bits. if the size of the given @c type is less than @c size bits.
@@ -163,6 +214,13 @@
*/ */
#define wxCOMPILE_TIME_ASSERT2(condition, message, name) #define wxCOMPILE_TIME_ASSERT2(condition, message, name)
/**
Disable the condition checks in the assertions.
This is the same as calling wxSetAssertHandler() with @NULL handler.
*/
void wxDisableAsserts();
/** /**
Will always generate an assert error if this code is reached (in debug mode). Will always generate an assert error if this code is reached (in debug mode).
Note that you don't have to (and cannot) use brackets when invoking this Note that you don't have to (and cannot) use brackets when invoking this
@@ -211,23 +269,38 @@
bool wxIsDebuggerRunning(); bool wxIsDebuggerRunning();
/** /**
This function is called whenever one of debugging macros fails (i.e. Sets the function to be called in case of assertion failure.
condition is @false in an assertion). It is only defined in the debug mode,
in release builds the wxCHECK() failures don't result in anything.
To override the default behaviour in the debug builds which is to show the The default assert handler forwards to wxApp::OnAssertFailure() whose
user a dialog asking whether he wants to abort the program, continue or default behaviour is, in turn, to show the standard assertion failure
continue ignoring any subsequent assert failures, you may override dialog if a wxApp object exists or shows the same dialog itself directly
wxApp::OnAssertFailure() which is called by this function if the global otherwise.
application object exists.
While usually it is enough -- and more convenient -- to just override
OnAssertFailure(), to handle all assertion failures, including those
occurring even before wxApp object creation of after its destruction you
need to provide your assertion handler function.
This function also provides a simple way to disable all asserts: simply
pass @NULL pointer to it. Doing this will result in not even evaluating
assert conditions at all, avoiding almost all run-time cost of asserts.
Notice that this function is not MT-safe, so you should call it before
starting any other threads.
The return value of this function is the previous assertion handler. It can
be called after any pre-processing by your handler and can also be restored
later if you uninstall your handler.
@param handler
The function to call in case of assertion failure or @NULL.
@return
The previous assert handler which is not @NULL by default but could be
@NULL if it had been previously set to this value using this function.
@header{wx/debug.h} @header{wx/debug.h}
*/ */
void wxOnAssert( const char* fileName, wxAssertHandler_t wxSetAssertHandler(wxAssertHandler_t handler);
int lineNumber,
const char* function,
const char* condition,
const char* message = NULL );
/** /**
In debug mode (when @c __WXDEBUG__ is defined) this function generates a In debug mode (when @c __WXDEBUG__ is defined) this function generates a

13
src/cocoa/app.mm
View File

@@ -184,10 +184,6 @@ wxApp::wxApp()
{ {
m_topWindow = NULL; m_topWindow = NULL;
#ifdef __WXDEBUG__
m_isInAssert = false;
#endif // __WXDEBUG__
argc = 0; argc = 0;
#if !wxUSE_UNICODE #if !wxUSE_UNICODE
argv = NULL; argv = NULL;
@@ -466,15 +462,6 @@ void wxApp::CF_ObserveMainRunLoopBeforeWaiting(CFRunLoopObserverRef observer, in
} }
} }
#ifdef __WXDEBUG__
void wxApp::OnAssert(const wxChar *file, int line, const wxChar* cond, const wxChar *msg)
{
m_isInAssert = true;
wxAppBase::OnAssert(file, line, cond, msg);
m_isInAssert = false;
}
#endif // __WXDEBUG__
/* A note about Cocoa's event loops vs. run loops: /* A note about Cocoa's event loops vs. run loops:
It's important to understand that Cocoa has a two-level event loop. The It's important to understand that Cocoa has a two-level event loop. The

207
src/common/appbase.cpp
View File

@@ -63,7 +63,7 @@
#include "wx/fontmap.h" #include "wx/fontmap.h"
#endif // wxUSE_FONTMAP #endif // wxUSE_FONTMAP
#ifdef __WXDEBUG__ #if wxDEBUG_LEVEL
#if wxUSE_STACKWALKER #if wxUSE_STACKWALKER
#include "wx/stackwalk.h" #include "wx/stackwalk.h"
#ifdef __WXMSW__ #ifdef __WXMSW__
@@ -72,7 +72,7 @@
#endif // wxUSE_STACKWALKER #endif // wxUSE_STACKWALKER
#include "wx/recguard.h" #include "wx/recguard.h"
#endif // __WXDEBUG__ #endif // wxDEBUG_LEVEL
// wxABI_VERSION can be defined when compiling applications but it should be // wxABI_VERSION can be defined when compiling applications but it should be
// left undefined when compiling the library itself, it is then set to its // left undefined when compiling the library itself, it is then set to its
@@ -85,20 +85,22 @@
// private functions prototypes // private functions prototypes
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#ifdef __WXDEBUG__ #if wxDEBUG_LEVEL
// really just show the assert dialog // really just show the assert dialog
static bool DoShowAssertDialog(const wxString& msg); static bool DoShowAssertDialog(const wxString& msg);
// prepare for showing the assert dialog, use the given traits or // prepare for showing the assert dialog, use the given traits or
// DoShowAssertDialog() as last fallback to really show it // DoShowAssertDialog() as last fallback to really show it
static static
void ShowAssertDialog(const wxString& szFile, void ShowAssertDialog(const wxString& file,
int nLine, int line,
const wxString& szFunc, const wxString& func,
const wxString& szCond, const wxString& cond,
const wxString& szMsg, const wxString& msg,
wxAppTraits *traits = NULL); wxAppTraits *traits = NULL);
#endif // wxDEBUG_LEVEL
#ifdef __WXDEBUG__
// turn on the trace masks specified in the env variable WXTRACE // turn on the trace masks specified in the env variable WXTRACE
static void LINKAGEMODE SetTraceMasks(); static void LINKAGEMODE SetTraceMasks();
#endif // __WXDEBUG__ #endif // __WXDEBUG__
@@ -655,15 +657,24 @@ bool wxAppConsoleBase::CheckBuildOptions(const char *optionsSignature,
return true; return true;
} }
#ifdef __WXDEBUG__
void wxAppConsoleBase::OnAssertFailure(const wxChar *file, void wxAppConsoleBase::OnAssertFailure(const wxChar *file,
int line, int line,
const wxChar *func, const wxChar *func,
const wxChar *cond, const wxChar *cond,
const wxChar *msg) const wxChar *msg)
{ {
#if wxDEBUG_LEVEL
ShowAssertDialog(file, line, func, cond, msg, GetTraits()); ShowAssertDialog(file, line, func, cond, msg, GetTraits());
#else
// this function is still present even in debug level 0 build for ABI
// compatibility reasons but is never called there and so can simply do
// nothing in it
wxUnusedVar(file);
wxUnusedVar(line);
wxUnusedVar(func);
wxUnusedVar(cond);
wxUnusedVar(msg);
#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
} }
void wxAppConsoleBase::OnAssert(const wxChar *file, void wxAppConsoleBase::OnAssert(const wxChar *file,
@@ -674,8 +685,6 @@ void wxAppConsoleBase::OnAssert(const wxChar *file,
OnAssertFailure(file, line, NULL, cond, msg); OnAssertFailure(file, line, NULL, cond, msg);
} }
#endif // __WXDEBUG__
// ============================================================================ // ============================================================================
// other classes implementations // other classes implementations
// ============================================================================ // ============================================================================
@@ -713,12 +722,10 @@ wxRendererNative *wxConsoleAppTraitsBase::CreateRenderer()
return NULL; return NULL;
} }
#ifdef __WXDEBUG__
bool wxConsoleAppTraitsBase::ShowAssertDialog(const wxString& msg) bool wxConsoleAppTraitsBase::ShowAssertDialog(const wxString& msg)
{ {
return wxAppTraitsBase::ShowAssertDialog(msg); return wxAppTraitsBase::ShowAssertDialog(msg);
} }
#endif
bool wxConsoleAppTraitsBase::HasStderr() bool wxConsoleAppTraitsBase::HasStderr()
{ {
@@ -777,10 +784,9 @@ void WXDLLIMPEXP_BASE wxMutexGuiLeave()
} }
#endif // wxUSE_THREADS #endif // wxUSE_THREADS
#ifdef __WXDEBUG__
bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal) bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal)
{ {
#if wxDEBUG_LEVEL
wxString msg = msgOriginal; wxString msg = msgOriginal;
#if wxUSE_STACKWALKER #if wxUSE_STACKWALKER
@@ -797,11 +803,17 @@ bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal)
#endif // wxUSE_STACKWALKER #endif // wxUSE_STACKWALKER
return DoShowAssertDialog(msg); return DoShowAssertDialog(msg);
#else // !wxDEBUG_LEVEL
wxUnusedVar(msgOriginal);
return false;
#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
} }
#if wxUSE_STACKWALKER #if wxUSE_STACKWALKER
wxString wxAppTraitsBase::GetAssertStackTrace() wxString wxAppTraitsBase::GetAssertStackTrace()
{ {
#if wxDEBUG_LEVEL
wxString stackTrace; wxString stackTrace;
class StackDump : public wxStackWalker class StackDump : public wxStackWalker
@@ -859,12 +871,15 @@ wxString wxAppTraitsBase::GetAssertStackTrace()
stackTrace = stackTrace.BeforeLast(wxT('\n')); stackTrace = stackTrace.BeforeLast(wxT('\n'));
return stackTrace; return stackTrace;
#else // !wxDEBUG_LEVEL
// this function is still present for ABI-compatibility even in debug level
// 0 build but is not used there and so can simply do nothing
return wxString();
#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
} }
#endif // wxUSE_STACKWALKER #endif // wxUSE_STACKWALKER
#endif // __WXDEBUG__
// ============================================================================ // ============================================================================
// global functions implementation // global functions implementation
// ============================================================================ // ============================================================================
@@ -891,14 +906,14 @@ void wxWakeUpIdle()
//else: do nothing, what can we do? //else: do nothing, what can we do?
} }
#ifdef __WXDEBUG__
// wxASSERT() helper // wxASSERT() helper
bool wxAssertIsEqual(int x, int y) bool wxAssertIsEqual(int x, int y)
{ {
return x == y; return x == y;
} }
#if wxDEBUG_LEVEL
// break into the debugger // break into the debugger
void wxTrap() void wxTrap()
{ {
@@ -913,12 +928,13 @@ void wxTrap()
#endif // Win/Unix #endif // Win/Unix
} }
// this function is called when an assert fails // default assert handler
static void wxDoOnAssert(const wxString& szFile, static void
int nLine, wxDefaultAssertHandler(const wxString& file,
const wxString& szFunc, int line,
const wxString& szCond, const wxString& func,
const wxString& szMsg = wxEmptyString) const wxString& cond,
const wxString& msg)
{ {
// FIXME MT-unsafe // FIXME MT-unsafe
static int s_bInAssert = 0; static int s_bInAssert = 0;
@@ -936,90 +952,98 @@ static void wxDoOnAssert(const wxString& szFile,
{ {
// by default, show the assert dialog box -- we can't customize this // by default, show the assert dialog box -- we can't customize this
// behaviour // behaviour
ShowAssertDialog(szFile, nLine, szFunc, szCond, szMsg); ShowAssertDialog(file, line, func, cond, msg);
} }
else else
{ {
// let the app process it as it wants // let the app process it as it wants
// FIXME-UTF8: use wc_str(), not c_str(), when ANSI build is removed // FIXME-UTF8: use wc_str(), not c_str(), when ANSI build is removed
wxTheApp->OnAssertFailure(szFile.c_str(), nLine, szFunc.c_str(), wxTheApp->OnAssertFailure(file.c_str(), line, func.c_str(),
szCond.c_str(), szMsg.c_str()); cond.c_str(), msg.c_str());
} }
} }
void wxOnAssert(const wxString& szFile, wxAssertHandler_t wxTheAssertHandler = wxDefaultAssertHandler;
int nLine,
const wxString& szFunc, void wxOnAssert(const wxString& file,
const wxString& szCond, int line,
const wxString& szMsg) const wxString& func,
const wxString& cond,
const wxString& msg)
{ {
wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg); wxTheAssertHandler(file, line, func, cond, msg);
} }
void wxOnAssert(const wxString& szFile, void wxOnAssert(const wxString& file,
int nLine, int line,
const wxString& szFunc, const wxString& func,
const wxString& szCond) const wxString& cond)
{ {
wxDoOnAssert(szFile, nLine, szFunc, szCond); wxTheAssertHandler(file, line, func, cond, wxString());
} }
void wxOnAssert(const wxChar *szFile, void wxOnAssert(const wxChar *file,
int nLine, int line,
const char *szFunc, const char *func,
const wxChar *szCond, const wxChar *cond,
const wxChar *szMsg) const wxChar *msg)
{ {
wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg); // this is the backwards-compatible version (unless we don't use Unicode)
// so it could be called directly from the user code and this might happen
// even when wxTheAssertHandler is NULL
#if wxUSE_UNICODE
if ( wxTheAssertHandler )
#endif // wxUSE_UNICODE
wxTheAssertHandler(file, line, func, cond, msg);
} }
void wxOnAssert(const char *szFile, void wxOnAssert(const char *file,
int nLine, int line,
const char *szFunc, const char *func,
const char *szCond, const char *cond,
const wxString& szMsg) const wxString& msg)
{ {
wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg); wxTheAssertHandler(file, line, func, cond, msg);
} }
void wxOnAssert(const char *szFile, void wxOnAssert(const char *file,
int nLine, int line,
const char *szFunc, const char *func,
const char *szCond, const char *cond,
const wxCStrData& msg) const wxCStrData& msg)
{ {
wxDoOnAssert(szFile, nLine, szFunc, szCond, msg); wxTheAssertHandler(file, line, func, cond, msg);
} }
#if wxUSE_UNICODE #if wxUSE_UNICODE
void wxOnAssert(const char *szFile, void wxOnAssert(const char *file,
int nLine, int line,
const char *szFunc, const char *func,
const char *szCond) const char *cond)
{ {
wxDoOnAssert(szFile, nLine, szFunc, szCond); wxTheAssertHandler(file, line, func, cond, wxString());
} }
void wxOnAssert(const char *szFile, void wxOnAssert(const char *file,
int nLine, int line,
const char *szFunc, const char *func,
const char *szCond, const char *cond,
const char *szMsg) const char *msg)
{ {
wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg); wxTheAssertHandler(file, line, func, cond, msg);
} }
void wxOnAssert(const char *szFile, void wxOnAssert(const char *file,
int nLine, int line,
const char *szFunc, const char *func,
const char *szCond, const char *cond,
const wxChar *szMsg) const wxChar *msg)
{ {
wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg); wxTheAssertHandler(file, line, func, cond, msg);
} }
#endif // wxUSE_UNICODE #endif // wxUSE_UNICODE
#endif // __WXDEBUG__ #endif // wxDEBUG_LEVEL
// ============================================================================ // ============================================================================
// private functions implementation // private functions implementation
@@ -1040,6 +1064,10 @@ static void LINKAGEMODE SetTraceMasks()
#endif // wxUSE_LOG #endif // wxUSE_LOG
} }
#endif // __WXDEBUG__
#if wxDEBUG_LEVEL
static static
bool DoShowAssertDialog(const wxString& msg) bool DoShowAssertDialog(const wxString& msg)
{ {
@@ -1047,8 +1075,9 @@ bool DoShowAssertDialog(const wxString& msg)
#if defined(__WXMSW__) && !defined(__WXMICROWIN__) #if defined(__WXMSW__) && !defined(__WXMICROWIN__)
wxString msgDlg(msg); wxString msgDlg(msg);
// this message is intentionally not translated -- it is for // this message is intentionally not translated -- it is for developers
// developpers only // only -- and the less code we use here, less is the danger of recursively
// asserting and dying
msgDlg += wxT("\nDo you want to stop the program?\n") msgDlg += wxT("\nDo you want to stop the program?\n")
wxT("You can also choose [Cancel] to suppress ") wxT("You can also choose [Cancel] to suppress ")
wxT("further warnings."); wxT("further warnings.");
@@ -1078,13 +1107,13 @@ bool DoShowAssertDialog(const wxString& msg)
return false; return false;
} }
// show the assert modal dialog // show the standard assert dialog
static static
void ShowAssertDialog(const wxString& szFile, void ShowAssertDialog(const wxString& file,
int nLine, int line,
const wxString& szFunc, const wxString& func,
const wxString& szCond, const wxString& cond,
const wxString& szMsg, const wxString& msgUser,
wxAppTraits *traits) wxAppTraits *traits)
{ {
// this variable can be set to true to suppress "assert failure" messages // this variable can be set to true to suppress "assert failure" messages
@@ -1096,16 +1125,16 @@ void ShowAssertDialog(const wxString& szFile,
// make life easier for people using VC++ IDE by using this format: like // make life easier for people using VC++ IDE by using this format: like
// this, clicking on the message will take us immediately to the place of // this, clicking on the message will take us immediately to the place of
// the failed assert // the failed assert
msg.Printf(wxT("%s(%d): assert \"%s\" failed"), szFile, nLine, szCond); msg.Printf(wxT("%s(%d): assert \"%s\" failed"), file, line, cond);
// add the function name, if any // add the function name, if any
if ( !szFunc.empty() ) if ( !func.empty() )
msg << _T(" in ") << szFunc << _T("()"); msg << _T(" in ") << func << _T("()");
// and the message itself // and the message itself
if ( !szMsg.empty() ) if ( !msgUser.empty() )
{ {
msg << _T(": ") << szMsg; msg << _T(": ") << msgUser;
} }
else // no message given else // no message given
{ {
@@ -1151,4 +1180,4 @@ void ShowAssertDialog(const wxString& szFile,
} }
} }
#endif // __WXDEBUG__ #endif // wxDEBUG_LEVEL

7
src/common/datavcmn.cpp
View File

@@ -38,13 +38,6 @@ bool operator == (const wxDataViewItem &left, const wxDataViewItem &right)
return (left.GetID() == right.GetID() ); return (left.GetID() == right.GetID() );
} }
#ifdef __WXDEBUG__
void wxDataViewItem::Print(const wxString& text) const
{
wxPrintf(wxT("item %s: %lu\n"), text.GetData(), wxPtrToUInt(m_id));
}
#endif
// --------------------------------------------------------- // ---------------------------------------------------------
// wxDataViewModelNotifier // wxDataViewModelNotifier
// --------------------------------------------------------- // ---------------------------------------------------------

8
src/common/event.cpp
View File

@@ -126,7 +126,7 @@ const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] =
// the memory leaks when using it, however this breaks re-initializing the // the memory leaks when using it, however this breaks re-initializing the
// library (i.e. repeated calls to wxInitialize/wxUninitialize) because the // library (i.e. repeated calls to wxInitialize/wxUninitialize) because the
// event tables won't be rebuilt the next time, so disable this by default // event tables won't be rebuilt the next time, so disable this by default
#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING #if wxUSE_MEMORY_TRACING
class wxEventTableEntryModule: public wxModule class wxEventTableEntryModule: public wxModule
{ {
@@ -140,7 +140,7 @@ public:
IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule, wxModule) IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule, wxModule)
#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING #endif // wxUSE_MEMORY_TRACING
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// global variables // global variables
@@ -878,7 +878,7 @@ void wxEventHashTable::Clear()
m_size = 0; m_size = 0;
} }
#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING #if wxUSE_MEMORY_TRACING
// Clear all tables // Clear all tables
void wxEventHashTable::ClearAll() void wxEventHashTable::ClearAll()
@@ -891,7 +891,7 @@ void wxEventHashTable::ClearAll()
} }
} }
#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING #endif // wxUSE_MEMORY_TRACING
bool wxEventHashTable::HandleEvent(wxEvent &event, wxEvtHandler *self) bool wxEventHashTable::HandleEvent(wxEvent &event, wxEvtHandler *self)
{ {

13
src/common/hyperlnkcmn.cpp
View File

@@ -51,9 +51,12 @@ const char wxHyperlinkCtrlNameStr[] = "hyperlink";
// wxHyperlinkCtrlBase // wxHyperlinkCtrlBase
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#ifdef __WXDEBUG__ void
void wxHyperlinkCtrlBase::CheckParams(const wxString& label, const wxString& url, long style) wxHyperlinkCtrlBase::CheckParams(const wxString& label,
const wxString& url,
long style)
{ {
#if wxDEBUG_LEVEL
wxASSERT_MSG(!url.empty() || !label.empty(), wxASSERT_MSG(!url.empty() || !label.empty(),
wxT("Both URL and label are empty ?")); wxT("Both URL and label are empty ?"));
@@ -62,8 +65,12 @@ void wxHyperlinkCtrlBase::CheckParams(const wxString& label, const wxString& url
(int)((style & wxHL_ALIGN_RIGHT) != 0); (int)((style & wxHL_ALIGN_RIGHT) != 0);
wxASSERT_MSG(alignment == 1, wxASSERT_MSG(alignment == 1,
wxT("Specify exactly one align flag!")); wxT("Specify exactly one align flag!"));
#else // !wxDEBUG_LEVEL
wxUnusedVar(label);
wxUnusedVar(url);
wxUnusedVar(style);
#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
} }
#endif
void wxHyperlinkCtrlBase::SendEvent() void wxHyperlinkCtrlBase::SendEvent()
{ {

1
src/common/protocol.cpp
View File

@@ -210,6 +210,7 @@ void wxProtocol::LogResponse(const wxString& str)
void wxProtocolLog::DoLogString(const wxString& str) void wxProtocolLog::DoLogString(const wxString& str)
{ {
wxUnusedVar(str); // unused if wxLogTrace() is disabled
wxLogTrace(m_traceMask, "%s", str); wxLogTrace(m_traceMask, "%s", str);
} }

8
src/common/stringops.cpp
View File

@@ -191,14 +191,6 @@ bool wxStringOperationsUtf8::IsValidUtf8String(const char *str, size_t len)
return true; return true;
} }
#ifdef __WXDEBUG__
bool wxStringOperationsUtf8::IsValidUtf8LeadByte(unsigned char c)
{
return (c <= 0x7F) || (c >= 0xC2 && c <= 0xF4);
}
#endif
// NB: this is in this file and not unichar.cpp to keep all UTF-8 encoding // NB: this is in this file and not unichar.cpp to keep all UTF-8 encoding
// code in single place // code in single place
wxUniChar::Utf8CharBuffer wxUniChar::AsUTF8() const wxUniChar::Utf8CharBuffer wxUniChar::AsUTF8() const

21
src/gtk/app.cpp
View File

@@ -115,7 +115,8 @@ bool wxApp::DoIdle()
id_save = m_idleSourceId; id_save = m_idleSourceId;
m_idleSourceId = 0; m_idleSourceId = 0;
wx_add_idle_hooks(); wx_add_idle_hooks();
#ifdef __WXDEBUG__
#if wxDEBUG_LEVEL
// don't generate the idle events while the assert modal dialog is shown, // don't generate the idle events while the assert modal dialog is shown,
// this matches the behavior of wxMSW // this matches the behavior of wxMSW
if (m_isInAssert) if (m_isInAssert)
@@ -181,9 +182,8 @@ IMPLEMENT_DYNAMIC_CLASS(wxApp,wxEvtHandler)
wxApp::wxApp() wxApp::wxApp()
{ {
#ifdef __WXDEBUG__
m_isInAssert = false; m_isInAssert = false;
#endif // __WXDEBUG__
#if wxUSE_THREADS #if wxUSE_THREADS
m_idleMutex = NULL; m_idleMutex = NULL;
#endif #endif
@@ -498,25 +498,30 @@ bool wxApp::EventsPending()
return gtk_events_pending() != 0; return gtk_events_pending() != 0;
} }
#ifdef __WXDEBUG__
void wxApp::OnAssertFailure(const wxChar *file, void wxApp::OnAssertFailure(const wxChar *file,
int line, int line,
const wxChar* func, const wxChar* func,
const wxChar* cond, const wxChar* cond,
const wxChar *msg) const wxChar *msg)
{ {
// there is no need to do anything if asserts are disabled in this build
// anyhow
#if wxDEBUG_LEVEL
// block wx idle events while assert dialog is showing // block wx idle events while assert dialog is showing
m_isInAssert = true; m_isInAssert = true;
wxAppBase::OnAssertFailure(file, line, func, cond, msg); wxAppBase::OnAssertFailure(file, line, func, cond, msg);
m_isInAssert = false; m_isInAssert = false;
#else // !wxDEBUG_LEVEL
wxUnusedVar(file);
wxUnusedVar(line);
wxUnusedVar(func);
wxUnusedVar(cond);
wxUnusedVar(msg);
#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
} }
#endif // __WXDEBUG__
#if wxUSE_THREADS #if wxUSE_THREADS
void wxGUIAppTraits::MutexGuiEnter() void wxGUIAppTraits::MutexGuiEnter()
{ {

3
src/gtk/dcclient.cpp
View File

@@ -2081,6 +2081,9 @@ void wxWindowDCImpl::SetLogicalFunction( wxRasterOperationMode function )
case wxNO_OP: mode = GDK_NOOP; break; case wxNO_OP: mode = GDK_NOOP; break;
case wxSRC_INVERT: mode = GDK_COPY_INVERT; break; case wxSRC_INVERT: mode = GDK_COPY_INVERT; break;
case wxNOR: mode = GDK_NOR; break; case wxNOR: mode = GDK_NOR; break;
default:
wxFAIL_MSG("unknown mode");
return;
} }
m_logicalFunction = function; m_logicalFunction = function;

29
src/gtk1/app.cpp
View File

@@ -171,7 +171,7 @@ static gint wxapp_idle_callback( gpointer WXUNUSED(data) )
if (!wxTheApp) if (!wxTheApp)
return TRUE; return TRUE;
#ifdef __WXDEBUG__ #if wxDEBUG_LEVEL
// don't generate the idle events while the assert modal dialog is shown, // don't generate the idle events while the assert modal dialog is shown,
// this completely confuses the apps which don't expect to be reentered // this completely confuses the apps which don't expect to be reentered
// from some safely-looking functions // from some safely-looking functions
@@ -186,7 +186,7 @@ static gint wxapp_idle_callback( gpointer WXUNUSED(data) )
} }
return TRUE; return TRUE;
} }
#endif // __WXDEBUG__ #endif // wxDEBUG_LEVEL
// When getting called from GDK's time-out handler // When getting called from GDK's time-out handler
// we are no longer within GDK's grab on the GUI // we are no longer within GDK's grab on the GUI
@@ -382,9 +382,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxApp,wxEvtHandler)
wxApp::wxApp() wxApp::wxApp()
{ {
#ifdef __WXDEBUG__
m_isInAssert = false; m_isInAssert = false;
#endif // __WXDEBUG__
m_idleTag = 0; m_idleTag = 0;
g_isIdle = TRUE; g_isIdle = TRUE;
@@ -616,19 +614,30 @@ void wxApp::CleanUp()
wxAppBase::CleanUp(); wxAppBase::CleanUp();
} }
#ifdef __WXDEBUG__ void wxApp::OnAssertFailure(const wxChar *file,
int line,
void wxApp::OnAssert(const wxChar *file, int line, const wxChar* cond, const wxChar *msg) const wxChar* func,
const wxChar* cond,
const wxChar *msg)
{ {
// there is no need to do anything if asserts are disabled in this build
// anyhow
#if wxDEBUG_LEVEL
// block wx idle events while assert dialog is showing
m_isInAssert = true; m_isInAssert = true;
wxAppBase::OnAssert(file, line, cond, msg); wxAppBase::OnAssertFailure(file, line, func, cond, msg);
m_isInAssert = false; m_isInAssert = false;
#else // !wxDEBUG_LEVEL
wxUnusedVar(file);
wxUnusedVar(line);
wxUnusedVar(func);
wxUnusedVar(cond);
wxUnusedVar(msg);
#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
} }
#endif // __WXDEBUG__
void wxApp::RemoveIdleTag() void wxApp::RemoveIdleTag()
{ {
#if wxUSE_THREADS #if wxUSE_THREADS

24
src/msw/bitmap.cpp
View File

@@ -92,12 +92,12 @@ public:
// MSW-specific // MSW-specific
// ------------ // ------------
#ifdef __WXDEBUG__ #if wxDEBUG_LEVEL
// this field is solely for error checking: we detect selecting a bitmap // this field is solely for error checking: we detect selecting a bitmap
// into more than one DC at once or deleting a bitmap still selected into a // into more than one DC at once or deleting a bitmap still selected into a
// DC (both are serious programming errors under Windows) // DC (both are serious programming errors under Windows)
wxDC *m_selectedInto; wxDC *m_selectedInto;
#endif // __WXDEBUG__ #endif // wxDEBUG_LEVEL
#if wxUSE_WXDIB #if wxUSE_WXDIB
// when GetRawData() is called for a DDB we need to convert it to a DIB // when GetRawData() is called for a DDB we need to convert it to a DIB
@@ -185,7 +185,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
wxBitmapRefData::wxBitmapRefData() wxBitmapRefData::wxBitmapRefData()
{ {
#ifdef __WXDEBUG__ #if wxDEBUG_LEVEL
m_selectedInto = NULL; m_selectedInto = NULL;
#endif #endif
m_bitmapMask = NULL; m_bitmapMask = NULL;
@@ -202,7 +202,7 @@ wxBitmapRefData::wxBitmapRefData()
wxBitmapRefData::wxBitmapRefData(const wxBitmapRefData& data) wxBitmapRefData::wxBitmapRefData(const wxBitmapRefData& data)
: wxGDIImageRefData(data) : wxGDIImageRefData(data)
{ {
#ifdef __WXDEBUG__ #if wxDEBUG_LEVEL
m_selectedInto = NULL; m_selectedInto = NULL;
#endif #endif
@@ -1188,14 +1188,14 @@ wxBitmap wxBitmap::GetMaskBitmap() const
return bmp; return bmp;
} }
#ifdef __WXDEBUG__
wxDC *wxBitmap::GetSelectedInto() const wxDC *wxBitmap::GetSelectedInto() const
{ {
#if wxDEBUG_LEVEL
return GetBitmapData() ? GetBitmapData()->m_selectedInto : NULL; return GetBitmapData() ? GetBitmapData()->m_selectedInto : NULL;
} #else
return NULL;
#endif #endif
}
void wxBitmap::UseAlpha() void wxBitmap::UseAlpha()
{ {
@@ -1212,15 +1212,15 @@ bool wxBitmap::HasAlpha() const
// wxBitmap setters // wxBitmap setters
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#ifdef __WXDEBUG__
void wxBitmap::SetSelectedInto(wxDC *dc) void wxBitmap::SetSelectedInto(wxDC *dc)
{ {
#if wxDEBUG_LEVEL
if ( GetBitmapData() ) if ( GetBitmapData() )
GetBitmapData()->m_selectedInto = dc; GetBitmapData()->m_selectedInto = dc;
} #else
wxUnusedVar(dc);
#endif #endif
}
#if wxUSE_PALETTE #if wxUSE_PALETTE

6
src/msw/dcclient.cpp
View File

@@ -67,13 +67,13 @@ WX_DEFINE_OBJARRAY(wxArrayDCInfo)
static PAINTSTRUCT g_paintStruct; static PAINTSTRUCT g_paintStruct;
#ifdef __WXDEBUG__ #ifdef wxHAS_PAINT_DEBUG
// a global variable which we check to verify that wxPaintDC are only // a global variable which we check to verify that wxPaintDC are only
// created in response to WM_PAINT message - doing this from elsewhere is a // created in response to WM_PAINT message - doing this from elsewhere is a
// common programming error among wxWidgets programmers and might lead to // common programming error among wxWidgets programmers and might lead to
// very subtle and difficult to debug refresh/repaint bugs. // very subtle and difficult to debug refresh/repaint bugs.
int g_isPainting = 0; int g_isPainting = 0;
#endif // __WXDEBUG__ #endif // wxHAS_PAINT_DEBUG
// =========================================================================== // ===========================================================================
// implementation // implementation
@@ -216,7 +216,7 @@ wxPaintDCImpl::wxPaintDCImpl( wxDC *owner, wxWindow *window ) :
{ {
wxCHECK_RET( window, wxT("NULL canvas in wxPaintDCImpl ctor") ); wxCHECK_RET( window, wxT("NULL canvas in wxPaintDCImpl ctor") );
#ifdef __WXDEBUG__ #ifdef wxHAS_PAINT_DEBUG
if ( g_isPainting <= 0 ) if ( g_isPainting <= 0 )
{ {
wxFAIL_MSG( wxT("wxPaintDCImpl may be created only in EVT_PAINT handler!") ); wxFAIL_MSG( wxT("wxPaintDCImpl may be created only in EVT_PAINT handler!") );

6
src/os2/dcclient.cpp
View File

@@ -62,13 +62,13 @@ WX_DEFINE_OBJARRAY(wxArrayDCInfo);
static RECT g_paintStruct; static RECT g_paintStruct;
#ifdef __WXDEBUG__ #ifdef wxHAS_PAINT_DEBUG
// a global variable which we check to verify that wxPaintDC are only // a global variable which we check to verify that wxPaintDC are only
// created in resopnse to WM_PAINT message - doing this from elsewhere is a // created in resopnse to WM_PAINT message - doing this from elsewhere is a
// common programming error among wxWidgets programmers and might lead to // common programming error among wxWidgets programmers and might lead to
// very subtle and difficult to debug refresh/repaint bugs. // very subtle and difficult to debug refresh/repaint bugs.
int g_isPainting = 0; int g_isPainting = 0;
#endif // __WXDEBUG__ #endif // wxHAS_PAINT_DEBUG
// =========================================================================== // ===========================================================================
// implementation // implementation
@@ -308,7 +308,7 @@ wxPaintDCImpl::wxPaintDCImpl( wxDC *owner, wxWindow *pCanvas) :
{ {
wxCHECK_RET(pCanvas, wxT("NULL canvas in wxPaintDC ctor")); wxCHECK_RET(pCanvas, wxT("NULL canvas in wxPaintDC ctor"));
#ifdef __WXDEBUG__ #ifdef wxHAS_PAINT_DEBUG
if (g_isPainting <= 0) if (g_isPainting <= 0)
{ {
wxFAIL_MSG( wxT("wxPaintDC may be created only in EVT_PAINT handler!") ); wxFAIL_MSG( wxT("wxPaintDC may be created only in EVT_PAINT handler!") );

24
src/palmos/bitmap.cpp
View File

@@ -77,10 +77,6 @@ public:
wxPalette m_bitmapPalette; wxPalette m_bitmapPalette;
#endif // wxUSE_PALETTE #endif // wxUSE_PALETTE
#ifdef __WXDEBUG__
wxDC *m_selectedInto;
#endif // __WXDEBUG__
#if wxUSE_WXDIB #if wxUSE_WXDIB
wxDIB *m_dib; wxDIB *m_dib;
#endif #endif
@@ -147,9 +143,6 @@ IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
wxBitmapRefData::wxBitmapRefData() wxBitmapRefData::wxBitmapRefData()
{ {
#ifdef __WXDEBUG__
m_selectedInto = NULL;
#endif
m_bitmapMask = NULL; m_bitmapMask = NULL;
m_hBitmap = (WXHBITMAP) NULL; m_hBitmap = (WXHBITMAP) NULL;
@@ -310,15 +303,6 @@ wxMask *wxBitmap::GetMask() const
return NULL; return NULL;
} }
#ifdef __WXDEBUG__
wxDC *wxBitmap::GetSelectedInto() const
{
return NULL;
}
#endif
bool wxBitmap::HasAlpha() const bool wxBitmap::HasAlpha() const
{ {
return false; return false;
@@ -328,14 +312,6 @@ bool wxBitmap::HasAlpha() const
// wxBitmap setters // wxBitmap setters
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#ifdef __WXDEBUG__
void wxBitmap::SetSelectedInto(wxDC *dc)
{
}
#endif
#if wxUSE_PALETTE #if wxUSE_PALETTE
void wxBitmap::SetPalette(const wxPalette& palette) void wxBitmap::SetPalette(const wxPalette& palette)

44
src/propgrid/propgrid.cpp
View File

@@ -176,7 +176,7 @@ wxPGGlobalVarsClass::wxPGGlobalVarsClass()
wxVariant v; wxVariant v;
// Prepare some shared variants // Prepare some shared variants
m_vEmptyString = wxString(); m_vEmptyString = wxString();
m_vZero = (long) 0; m_vZero = (long) 0;
m_vMinusOne = (long) -1; m_vMinusOne = (long) -1;
@@ -193,9 +193,7 @@ wxPGGlobalVarsClass::wxPGGlobalVarsClass()
m_strUnits = wxS("Units"); m_strUnits = wxS("Units");
m_strInlineHelp = wxS("InlineHelp"); m_strInlineHelp = wxS("InlineHelp");
#ifdef __WXDEBUG__
m_warnings = 0; m_warnings = 0;
#endif
} }
@@ -498,10 +496,10 @@ void wxPropertyGrid::Init1()
#endif #endif
#ifndef wxPG_ICON_WIDTH #ifndef wxPG_ICON_WIDTH
m_expandbmp = NULL; m_expandbmp = NULL;
m_collbmp = NULL; m_collbmp = NULL;
m_iconWidth = 11; m_iconWidth = 11;
m_iconHeight = 11; m_iconHeight = 11;
#else #else
m_iconWidth = wxPG_ICON_WIDTH; m_iconWidth = wxPG_ICON_WIDTH;
#endif #endif
@@ -558,19 +556,19 @@ void wxPropertyGrid::Init2()
#ifndef wxPG_ICON_WIDTH #ifndef wxPG_ICON_WIDTH
// create two bitmap nodes for drawing // create two bitmap nodes for drawing
m_expandbmp = new wxBitmap(expand_xpm); m_expandbmp = new wxBitmap(expand_xpm);
m_collbmp = new wxBitmap(collapse_xpm); m_collbmp = new wxBitmap(collapse_xpm);
// calculate average font height for bitmap centering // calculate average font height for bitmap centering
m_iconWidth = m_expandbmp->GetWidth(); m_iconWidth = m_expandbmp->GetWidth();
m_iconHeight = m_expandbmp->GetHeight(); m_iconHeight = m_expandbmp->GetHeight();
#endif #endif
m_curcursor = wxCURSOR_ARROW; m_curcursor = wxCURSOR_ARROW;
m_cursorSizeWE = new wxCursor( wxCURSOR_SIZEWE ); m_cursorSizeWE = new wxCursor( wxCURSOR_SIZEWE );
// adjust bitmap icon y position so they are centered // adjust bitmap icon y position so they are centered
m_vspacing = wxPG_DEFAULT_VSPACING; m_vspacing = wxPG_DEFAULT_VSPACING;
CalculateFontAndBitmapStuff( wxPG_DEFAULT_VSPACING ); CalculateFontAndBitmapStuff( wxPG_DEFAULT_VSPACING );
@@ -590,9 +588,9 @@ void wxPropertyGrid::Init2()
m_tlwHandler = handler; m_tlwHandler = handler;
m_tlp->PushEventHandler(handler); m_tlp->PushEventHandler(handler);
// set virtual size to this window size // set virtual size to this window size
wxSize wndsize = GetSize(); wxSize wndsize = GetSize();
SetVirtualSize(wndsize.GetWidth(), wndsize.GetWidth()); SetVirtualSize(wndsize.GetWidth(), wndsize.GetWidth());
m_timeCreated = ::wxGetLocalTimeMillis(); m_timeCreated = ::wxGetLocalTimeMillis();
@@ -648,8 +646,8 @@ wxPropertyGrid::~wxPropertyGrid()
delete m_cursorSizeWE; delete m_cursorSizeWE;
#ifndef wxPG_ICON_WIDTH #ifndef wxPG_ICON_WIDTH
delete m_expandbmp; delete m_expandbmp;
delete m_collbmp; delete m_collbmp;
#endif #endif
// Delete common value records // Delete common value records
@@ -843,13 +841,13 @@ wxSize wxPropertyGrid::DoGetBestSize() const
void wxPropertyGrid::CalculateFontAndBitmapStuff( int vspacing ) void wxPropertyGrid::CalculateFontAndBitmapStuff( int vspacing )
{ {
int x = 0, y = 0; int x = 0, y = 0;
m_captionFont = wxScrolledWindow::GetFont(); m_captionFont = wxScrolledWindow::GetFont();
GetTextExtent(wxS("jG"), &x, &y, 0, 0, &m_captionFont); GetTextExtent(wxS("jG"), &x, &y, 0, 0, &m_captionFont);
m_subgroup_extramargin = x + (x/2); m_subgroup_extramargin = x + (x/2);
m_fontHeight = y; m_fontHeight = y;
#if wxPG_USE_RENDERER_NATIVE #if wxPG_USE_RENDERER_NATIVE
m_iconWidth = wxPG_ICON_WIDTH; m_iconWidth = wxPG_ICON_WIDTH;
@@ -878,7 +876,7 @@ void wxPropertyGrid::CalculateFontAndBitmapStuff( int vspacing )
m_marginWidth = m_gutterWidth*2 + m_iconWidth; m_marginWidth = m_gutterWidth*2 + m_iconWidth;
m_captionFont.SetWeight(wxBOLD); m_captionFont.SetWeight(wxBOLD);
GetTextExtent(wxS("jG"), &x, &y, 0, 0, &m_captionFont); GetTextExtent(wxS("jG"), &x, &y, 0, 0, &m_captionFont);
m_lineHeight = m_fontHeight+(2*m_spacingy)+1; m_lineHeight = m_fontHeight+(2*m_spacingy)+1;
@@ -3771,7 +3769,7 @@ void wxPropertyGrid::RecalculateVirtualSize( int forceXPos )
GetClientSize(&width,&height); GetClientSize(&width,&height);
// Now adjust virtual size. // Now adjust virtual size.
SetVirtualSize(x, y); SetVirtualSize(x, y);
int xAmount = 0; int xAmount = 0;
int xPos = 0; int xPos = 0;
@@ -4268,7 +4266,7 @@ bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y, wxMouseEvent &event
if ( space ) if ( space )
{ {
int tw, th; int tw, th;
GetTextExtent( tipString, &tw, &th, 0, 0 ); GetTextExtent( tipString, &tw, &th, 0, 0 );
if ( tw > space ) if ( tw > space )
{ {
SetToolTip( tipString ); SetToolTip( tipString );

10
src/propgrid/propgridpagestate.cpp
View File

@@ -1566,16 +1566,18 @@ bool wxPropertyGridPageState::PrepareToAddItem( wxPGProperty* property,
} }
} }
#ifdef __WXDEBUG__ #if wxDEBUG_LEVEL
// Warn for identical names in debug mode. // Warn for identical names in debug mode.
if ( BaseGetPropertyByName(property->GetName()) && if ( BaseGetPropertyByName(property->GetName()) &&
(!scheduledParent || scheduledParent->IsCategory()) ) (!scheduledParent || scheduledParent->IsCategory()) )
{ {
wxLogError(wxT("wxPropertyGrid: Warning - item with name \"%s\" already exists."), wxFAIL_MSG(wxString::Format(
property->GetName().c_str()); "wxPropertyGrid item with name \"%s\" already exists",
property->GetName()));
wxPGGlobalVars->m_warnings++; wxPGGlobalVars->m_warnings++;
} }
#endif #endif // wxDEBUG_LEVEL
// Make sure nothing is selected. // Make sure nothing is selected.
if ( propGrid ) if ( propGrid )

36
src/x11/app.cpp
View File

@@ -64,7 +64,6 @@ static wxWindow *g_prevFocus = NULL;
// X11 error handling // X11 error handling
//------------------------------------------------------------------------ //------------------------------------------------------------------------
#ifdef __WXDEBUG__
typedef int (*XErrorHandlerFunc)(Display *, XErrorEvent *); typedef int (*XErrorHandlerFunc)(Display *, XErrorEvent *);
XErrorHandlerFunc gs_pfnXErrorHandler = 0; XErrorHandlerFunc gs_pfnXErrorHandler = 0;
@@ -77,7 +76,6 @@ static int wxXErrorHandler(Display *dpy, XErrorEvent *xevent)
else else
return 0; return 0;
} }
#endif // __WXDEBUG__
//------------------------------------------------------------------------ //------------------------------------------------------------------------
// wxApp // wxApp
@@ -89,10 +87,10 @@ IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
bool wxApp::Initialize(int& argC, wxChar **argV) bool wxApp::Initialize(int& argC, wxChar **argV)
{ {
#if defined(__WXDEBUG__) && !wxUSE_NANOX #if !wxUSE_NANOX
// install the X error handler // install the X error handler
gs_pfnXErrorHandler = XSetErrorHandler( wxXErrorHandler ); gs_pfnXErrorHandler = XSetErrorHandler( wxXErrorHandler );
#endif // __WXDEBUG__ #endif
wxString displayName; wxString displayName;
bool syncDisplay = false; bool syncDisplay = false;
@@ -292,9 +290,6 @@ bool wxApp::ProcessXEvent(WXEvent* _event)
return false; return false;
} }
#ifdef __WXDEBUG__
wxString windowClass = win->GetClassInfo()->GetClassName();
#endif
switch (event->type) switch (event->type)
{ {
@@ -453,10 +448,8 @@ bool wxApp::ProcessXEvent(WXEvent* _event)
} }
#if !wxUSE_NANOX #if !wxUSE_NANOX
case PropertyNotify: case PropertyNotify:
{
//wxLogDebug("PropertyNotify: %s", windowClass.c_str());
return HandlePropertyChange(_event); return HandlePropertyChange(_event);
}
case ClientMessage: case ClientMessage:
{ {
if (!win->IsEnabled()) if (!win->IsEnabled())
@@ -617,13 +610,6 @@ bool wxApp::ProcessXEvent(WXEvent* _event)
return win->HandleWindowEvent(focusEvent); return win->HandleWindowEvent(focusEvent);
} }
return false; return false;
#ifdef __WXDEBUG__
default:
//wxString eventName = wxGetXEventName(XEvent& event);
//wxLogDebug(wxT("Event %s not handled"), eventName.c_str());
break;
#endif // __WXDEBUG__
} }
return false; return false;
@@ -767,19 +753,3 @@ void wxApp::Exit()
wxAppConsole::Exit(); wxAppConsole::Exit();
} }
#ifdef __WXDEBUG__
void wxApp::OnAssert(const wxChar *file, int line, const wxChar* cond, const wxChar *msg)
{
// While the GUI isn't working that well, just print out the
// message.
#if 1
wxAppBase::OnAssert(file, line, cond, msg);
#else
wxString msg2;
msg2.Printf("At file %s:%d: %s", file, line, msg);
wxLogDebug(msg2);
#endif
}
#endif // __WXDEBUG__

2
src/x11/utils.cpp
View File

@@ -370,7 +370,6 @@ void wxAllocColor(Display *d,Colormap cmp,XColor *xc)
} }
} }
#ifdef __WXDEBUG__
wxString wxGetXEventName(XEvent& event) wxString wxGetXEventName(XEvent& event)
{ {
#if wxUSE_NANOX #if wxUSE_NANOX
@@ -395,7 +394,6 @@ wxString wxGetXEventName(XEvent& event)
return wxString::FromAscii(event_name[type]); return wxString::FromAscii(event_name[type]);
#endif #endif
} }
#endif
bool wxWindowIsVisible(Window win) bool wxWindowIsVisible(Window win)
{ {

26
tests/misc/misctests.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Name: tests/misc/misctests.cpp // Name: tests/misc/misctests.cpp
// Purpose: test miscellaneous stuff // Purpose: test miscellaneous stuff
// Author: Peter Most // Author: Peter Most, Vadim Zeitlin
// Created: 2008-07-10 // Created: 2008-07-10
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) 2008 Peter Most // Copyright: (c) 2008 Peter Most
// (c) 2009 Vadim Zeitlin
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -30,9 +31,11 @@ public:
private: private:
CPPUNIT_TEST_SUITE( MiscTestCase ); CPPUNIT_TEST_SUITE( MiscTestCase );
CPPUNIT_TEST( Assert );
CPPUNIT_TEST( Delete ); CPPUNIT_TEST( Delete );
CPPUNIT_TEST_SUITE_END(); CPPUNIT_TEST_SUITE_END();
void Assert();
void Delete(); void Delete();
DECLARE_NO_COPY_CLASS(MiscTestCase) DECLARE_NO_COPY_CLASS(MiscTestCase)
@@ -44,6 +47,27 @@ CPPUNIT_TEST_SUITE_REGISTRATION( MiscTestCase );
// also include in it's own registry so that these tests can be run alone // also include in it's own registry so that these tests can be run alone
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( MiscTestCase, "MiscTestCase" ); CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( MiscTestCase, "MiscTestCase" );
namespace
{
void AssertIfOdd(int n)
{
wxASSERT_MSG( !(n % 2), "parameter must be even" );
}
} // anonymous namespace
void MiscTestCase::Assert()
{
AssertIfOdd(0);
WX_ASSERT_FAILS_WITH_ASSERT(AssertIfOdd(1));
// doesn't fail any more
wxAssertHandler_t oldHandler = wxSetAssertHandler(NULL);
AssertIfOdd(17);
wxSetAssertHandler(oldHandler);
}
void MiscTestCase::Delete() void MiscTestCase::Delete()
{ {
// Allocate some arbitrary memory to get a valid pointer: // Allocate some arbitrary memory to get a valid pointer:

4
tests/testprec.h
View File

@@ -11,7 +11,7 @@
class TestAssertFailure { }; class TestAssertFailure { };
// macro to use for the functions which are supposed to fail an assertion // macro to use for the functions which are supposed to fail an assertion
#ifdef __WXDEBUG__ #if wxDEBUG_LEVEL
// some old cppunit versions don't define CPPUNIT_ASSERT_THROW so roll our // some old cppunit versions don't define CPPUNIT_ASSERT_THROW so roll our
// own // own
#define WX_ASSERT_FAILS_WITH_ASSERT(cond) \ #define WX_ASSERT_FAILS_WITH_ASSERT(cond) \
@@ -23,7 +23,7 @@ class TestAssertFailure { };
CPPUNIT_FAIL("expected assertion not generated"); \ CPPUNIT_FAIL("expected assertion not generated"); \
} }
#else #else
// there are no assertions in non-debug build so just check that it fails // there are no assertions in this build so just check that it fails
#define WX_ASSERT_FAILS_WITH_ASSERT(cond) CPPUNIT_ASSERT(!(cond)) #define WX_ASSERT_FAILS_WITH_ASSERT(cond) CPPUNIT_ASSERT(!(cond))
#endif #endif