From 657a8a359826e46a7fc458216403f54deca34989 Mon Sep 17 00:00:00 2001 From: Vadim Zeitlin Date: Sat, 21 Mar 2009 23:36:37 +0000 Subject: [PATCH] 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 git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@59711 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- include/wx/app.h | 2 - include/wx/apptrait.h | 8 +- include/wx/cocoa/app.h | 9 - include/wx/dataview.h | 4 - include/wx/dcbuffer.h | 23 +- include/wx/debug.h | 419 ++++++++++++++++++----------- include/wx/defs.h | 7 - include/wx/event.h | 17 +- include/wx/gtk/app.h | 5 +- include/wx/gtk1/app.h | 10 +- include/wx/hyperlink.h | 4 - include/wx/memory.h | 21 +- include/wx/msgdlg.h | 2 - include/wx/msw/bitmap.h | 2 - include/wx/msw/private.h | 2 - include/wx/object.h | 48 ++-- include/wx/palmos/bitmap.h | 5 - include/wx/propgrid/propgrid.h | 7 - include/wx/stringops.h | 7 +- include/wx/unix/apptrait.h | 2 +- include/wx/x11/app.h | 4 - include/wx/x11/privx.h | 2 - interface/wx/debug.h | 101 ++++++- src/cocoa/app.mm | 13 - src/common/appbase.cpp | 207 ++++++++------ src/common/datavcmn.cpp | 7 - src/common/event.cpp | 8 +- src/common/hyperlnkcmn.cpp | 13 +- src/common/protocol.cpp | 1 + src/common/stringops.cpp | 8 - src/gtk/app.cpp | 21 +- src/gtk/dcclient.cpp | 3 + src/gtk1/app.cpp | 29 +- src/msw/bitmap.cpp | 24 +- src/msw/dcclient.cpp | 6 +- src/os2/dcclient.cpp | 6 +- src/palmos/bitmap.cpp | 24 -- src/propgrid/propgrid.cpp | 44 ++- src/propgrid/propgridpagestate.cpp | 10 +- src/x11/app.cpp | 36 +-- src/x11/utils.cpp | 2 - tests/misc/misctests.cpp | 26 +- tests/testprec.h | 4 +- 43 files changed, 647 insertions(+), 556 deletions(-) diff --git a/include/wx/app.h b/include/wx/app.h index 5e0e97060e..f754a7b117 100644 --- a/include/wx/app.h +++ b/include/wx/app.h @@ -335,7 +335,6 @@ public: // debugging support // ----------------- -#ifdef __WXDEBUG__ // this function is called when an assert failure occurs, the base class // version does the normal processing (i.e. shows the usual assert failure // dialog box) @@ -355,7 +354,6 @@ public: int line, const wxChar *cond, const wxChar *msg); -#endif // __WXDEBUG__ // check that the wxBuildOptions object (constructed in the application // itself, usually the one from IMPLEMENT_APP() macro) matches the build diff --git a/include/wx/apptrait.h b/include/wx/apptrait.h index cbc3867147..4775f4b9de 100644 --- a/include/wx/apptrait.h +++ b/include/wx/apptrait.h @@ -87,7 +87,6 @@ public: // functions abstracting differences between GUI and console modes // ------------------------------------------------------------------------ -#ifdef __WXDEBUG__ // show the assert dialog with the specified message in GUI or just print // the string to stderr in console mode // @@ -96,7 +95,6 @@ public: // // return true to suppress subsequent asserts, false to continue as before virtual bool ShowAssertDialog(const wxString& msg) = 0; -#endif // __WXDEBUG__ // return true if fprintf(stderr) goes somewhere, false otherwise virtual bool HasStderr() = 0; @@ -177,7 +175,7 @@ public: protected: -#if wxUSE_STACKWALKER && defined( __WXDEBUG__ ) +#if wxUSE_STACKWALKER // utility function: returns the stack frame as a plain wxString virtual wxString GetAssertStackTrace(); #endif @@ -232,9 +230,7 @@ public: #endif // wxUSE_FONTMAP virtual wxRendererNative *CreateRenderer(); -#ifdef __WXDEBUG__ virtual bool ShowAssertDialog(const wxString& msg); -#endif // __WXDEBUG__ virtual bool HasStderr(); virtual void ScheduleForDestroy(wxObject *object); @@ -273,9 +269,7 @@ public: #endif // wxUSE_FONTMAP virtual wxRendererNative *CreateRenderer(); -#ifdef __WXDEBUG__ virtual bool ShowAssertDialog(const wxString& msg); -#endif // __WXDEBUG__ virtual bool HasStderr(); virtual void ScheduleForDestroy(wxObject *object); diff --git a/include/wx/cocoa/app.h b/include/wx/cocoa/app.h index a0a65f9427..2f30970f7a 100644 --- a/include/wx/cocoa/app.h +++ b/include/wx/cocoa/app.h @@ -67,17 +67,8 @@ public: virtual bool OnInit(); 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.) static bool sm_isEmbedded; -private: -#ifdef __WXDEBUG__ - bool m_isInAssert; -#endif // __WXDEBUG__ }; #endif // _WX_COCOA_APP_H_ diff --git a/include/wx/dataview.h b/include/wx/dataview.h index 757910d01f..e0c0f30768 100644 --- a/include/wx/dataview.h +++ b/include/wx/dataview.h @@ -81,10 +81,6 @@ public: void* GetID() const { return m_id; } operator const void* () const { return m_id; } -#ifdef __WXDEBUG__ - void Print( const wxString &text ) const; -#endif - private: void* m_id; }; diff --git a/include/wx/dcbuffer.h b/include/wx/dcbuffer.h index 991fdaad39..4d5b408712 100644 --- a/include/wx/dcbuffer.h +++ b/include/wx/dcbuffer.h @@ -216,9 +216,6 @@ private: #define wxAutoBufferedPaintDCBase wxBufferedPaintDC #endif - -#ifdef __WXDEBUG__ - class WXDLLIMPEXP_CORE wxAutoBufferedPaintDC : public wxAutoBufferedPaintDCBase { public: @@ -226,30 +223,18 @@ public: wxAutoBufferedPaintDC(wxWindow* 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() { } 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); }; -#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 diff --git a/include/wx/debug.h b/include/wx/debug.h index 9dc2e1b3fd..59b2d61d37 100644 --- a/include/wx/debug.h +++ b/include/wx/debug.h @@ -20,10 +20,30 @@ #include "wx/chartype.h" // for __TFILE__ and wxChar #include "wx/cpp.h" // for __WXFUNCTION__ +class WXDLLIMPEXP_FWD_BASE wxString; +class WXDLLIMPEXP_FWD_BASE wxCStrData; + // ---------------------------------------------------------------------------- // 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 // __WXDEBUG__ too #ifdef _DEBUG @@ -46,175 +66,235 @@ #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 -// -// 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. +// Handling assertion failures // ---------------------------------------------------------------------------- -// Macros which are completely disabled in 'release' mode +/* + 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); + +#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: 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); +// 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 - /* 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); + +// 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 */ - 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() +// 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 - // 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; +// ---------------------------------------------------------------------------- +// Debugging macros +// ---------------------------------------------------------------------------- -#define wxAssertFailure wxFalse +/* + 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. -// NB: the following macros also work in release mode! + 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. -/* - 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!!") ) -*/ + 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 -// 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) +/* + 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 -// check that expression is true, perform op if not -#define wxCHECK2(cond, op) wxCHECK2_MSG(cond, op, (const char*)NULL) + 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 -// as wxCHECK2 but with a message explaining why we fail + wxCHECK_RET( p != NULL, "pointer can't be NULL" ) +*/ +// the generic macro: takes the condition to check, the statement to be execute +// in case the condition is false and the message to pass to the assert handler #define wxCHECK2_MSG(cond, op, msg) \ if ( cond ) \ {} \ @@ -225,6 +305,15 @@ extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse; } \ 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 // // 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...) #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 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 // 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 @@ -295,6 +385,7 @@ extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse; wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \ wxMAKE_BITSIZE_MSG(type, size)) + // ---------------------------------------------------------------------------- // other miscellaneous debugger-related functions // ---------------------------------------------------------------------------- @@ -311,4 +402,28 @@ extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse; inline bool wxIsDebuggerRunning() { return false; } #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_ diff --git a/include/wx/defs.h b/include/wx/defs.h index ac41fea3a4..1391858c3a 100644 --- a/include/wx/defs.h +++ b/include/wx/defs.h @@ -661,13 +661,6 @@ typedef short int WXTYPE; #define WXUNUSED(identifier) identifier #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 */ #if wxUSE_UNICODE #define WXUNUSED_IN_UNICODE(param) WXUNUSED(param) diff --git a/include/wx/event.h b/include/wx/event.h index 5f03364ba1..51b34461ce 100644 --- a/include/wx/event.h +++ b/include/wx/event.h @@ -1636,7 +1636,9 @@ private: 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 extern WXDLLIMPEXP_CORE int g_isPainting; #endif // debug @@ -1647,15 +1649,15 @@ public: wxPaintEvent(int Id = 0) : wxEvent(Id, wxEVT_PAINT) { -#if defined(__WXDEBUG__) && (defined(__WXMSW__) || defined(__WXPM__)) - // set the internal flag for the duration of processing of WM_PAINT +#ifdef wxHAS_PAINT_DEBUG + // set the internal flag for the duration of redrawing g_isPainting++; #endif // debug } // default copy ctor and dtor are normally fine, we only need them to keep // g_isPainting updated in debug build -#if defined(__WXDEBUG__) && (defined(__WXMSW__) || defined(__WXPM__)) +#ifdef wxHAS_PAINT_DEBUG wxPaintEvent(const wxPaintEvent& event) : wxEvent(event) { @@ -2804,10 +2806,11 @@ public: // Clear table void Clear(); -#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING - // Clear all tables +#if wxUSE_MEMORY_TRACING + // Clear all tables: only used to work around problems in memory tracing + // code static void ClearAll(); -#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING +#endif // wxUSE_MEMORY_TRACING protected: // Init the hash table with the entries of the static event table. diff --git a/include/wx/gtk/app.h b/include/wx/gtk/app.h index 630bf9b04d..0ded824a5f 100644 --- a/include/wx/gtk/app.h +++ b/include/wx/gtk/app.h @@ -45,13 +45,11 @@ public: virtual bool Initialize(int& argc, wxChar **argv); virtual void CleanUp(); -#ifdef __WXDEBUG__ virtual void OnAssertFailure(const wxChar *file, int line, const wxChar *func, const wxChar *cond, const wxChar *msg); -#endif // __WXDEBUG__ // GTK-specific methods // ------------------- @@ -80,9 +78,8 @@ public: private: // true if we're inside an assert modal dialog -#ifdef __WXDEBUG__ bool m_isInAssert; -#endif // __WXDEBUG__ + #if wxUSE_THREADS wxMutex* m_idleMutex; #endif diff --git a/include/wx/gtk1/app.h b/include/wx/gtk1/app.h index 273d29eda4..ee059e1bee 100644 --- a/include/wx/gtk1/app.h +++ b/include/wx/gtk1/app.h @@ -45,11 +45,13 @@ public: static bool InitialzeVisual(); -#ifdef __WXDEBUG__ - virtual void OnAssert(const wxChar *file, int line, const wxChar *cond, const wxChar *msg); + virtual void OnAssertFailure(const wxChar *file, + int line, + const wxChar *func, + const wxChar *cond, + const wxChar *msg); bool IsInAssert() const { return m_isInAssert; } -#endif // __WXDEBUG__ gint m_idleTag; void RemoveIdleTag(); @@ -66,9 +68,7 @@ public: private: // true if we're inside an assert modal dialog -#ifdef __WXDEBUG__ bool m_isInAssert; -#endif // __WXDEBUG__ DECLARE_DYNAMIC_CLASS(wxApp) }; diff --git a/include/wx/hyperlink.h b/include/wx/hyperlink.h index 2b07629443..2678203ff9 100644 --- a/include/wx/hyperlink.h +++ b/include/wx/hyperlink.h @@ -80,10 +80,6 @@ public: void SendEvent(); }; -#ifndef __WXDEBUG__ -inline void wxHyperlinkCtrlBase::CheckParams(const wxString&, const wxString&, long) { } -#endif - // ---------------------------------------------------------------------------- // wxHyperlinkEvent // ---------------------------------------------------------------------------- diff --git a/include/wx/memory.h b/include/wx/memory.h index 23b1a01ef0..1bece9a2d7 100644 --- a/include/wx/memory.h +++ b/include/wx/memory.h @@ -9,24 +9,17 @@ // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifndef _WX_MEMORYH__ -#define _WX_MEMORYH__ +#ifndef _WX_MEMORY_H_ +#define _WX_MEMORY_H_ #include "wx/defs.h" #include "wx/string.h" #include "wx/msgout.h" -/* - 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 +#if wxUSE_MEMORY_TRACING || wxUSE_DEBUG_CONTEXT #include -#ifdef __WXDEBUG__ - 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); @@ -129,7 +122,6 @@ inline void operator delete[](void* pData, wxChar* /* fileName */, int /* lineNu } #endif // __VISUALC__>=1200 #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 WXTRACELEVEL wxTraceLevel -#else // (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT +#else // wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT #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 WXTRACELEVEL true ? (void)0 : wxTraceLevel -#endif // (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT +#endif // wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT -#endif - // _WX_MEMORYH__ +#endif // _WX_MEMORY_H_ diff --git a/include/wx/msgdlg.h b/include/wx/msgdlg.h index 7c4329fa39..4d822d3dc0 100644 --- a/include/wx/msgdlg.h +++ b/include/wx/msgdlg.h @@ -140,7 +140,6 @@ public: // change the dialog style flag void SetMessageDialogStyle(long style) { -#ifdef __WXDEBUG__ wxASSERT_MSG( ((style & wxYES_NO) == wxYES_NO) || !(style & wxYES_NO), "wxYES and wxNO may only be used together" ); @@ -161,7 +160,6 @@ public: if ((style & wxCANCEL_DEFAULT) != 0 && (style & wxNO_DEFAULT) != 0) wxFAIL_MSG("only one default button can be specified"); -#endif m_dialogStyle = style; } diff --git a/include/wx/msw/bitmap.h b/include/wx/msw/bitmap.h index 515ceb966e..205370f459 100644 --- a/include/wx/msw/bitmap.h +++ b/include/wx/msw/bitmap.h @@ -174,10 +174,8 @@ public: void SetHBITMAP(WXHBITMAP bmp) { SetHandle((WXHANDLE)bmp); } WXHBITMAP GetHBITMAP() const { return (WXHBITMAP)GetHandle(); } -#ifdef __WXDEBUG__ void SetSelectedInto(wxDC *dc); wxDC *GetSelectedInto() const; -#endif // __WXDEBUG__ protected: virtual wxGDIImageRefData *CreateData() const; diff --git a/include/wx/msw/private.h b/include/wx/msw/private.h index 64895d855b..a840110a97 100644 --- a/include/wx/msw/private.h +++ b/include/wx/msw/private.h @@ -692,14 +692,12 @@ public: { if ( m_hGlobal && !GlobalUnlock(m_hGlobal) ) { -#ifdef __WXDEBUG__ // this might happen simply because the block became unlocked DWORD dwLastError = ::GetLastError(); if ( dwLastError != NO_ERROR ) { wxLogApiError(_T("GlobalUnlock"), dwLastError); } -#endif // __WXDEBUG__ } } diff --git a/include/wx/object.h b/include/wx/object.h index 26c3c0271c..9da3222c8e 100644 --- a/include/wx/object.h +++ b/include/wx/object.h @@ -328,20 +328,16 @@ name##PluginSentinel m_pluginsentinel; #define wxDynamicCastThis(className) \ (IsKindOf(&className::ms_classInfo) ? (className *)(this) : (className *)0) -#ifdef __WXDEBUG__ -inline void* wxCheckCast(void *ptr) +// FIXME-VC6: dummy argument needed because VC6 doesn't support explicitly +// choosing the template function to call +template +inline T *wxCheckCast(const void *ptr, T * = NULL) { - wxASSERT_MSG( ptr, _T("wxStaticCast() used incorrectly") ); - return ptr; + wxASSERT_MSG( wxDynamicCast(ptr, T), "wxStaticCast() used incorrectly" ); + return const_cast(static_cast(ptr)); } -#define wxStaticCast(obj, className) \ - ((className *)wxCheckCast(wxDynamicCast(obj, className))) - -#else // !__WXDEBUG__ -#define wxStaticCast(obj, className) \ - const_cast(static_cast(obj)) -#endif // __WXDEBUG__ +#define wxStaticCast(obj, className) wxCheckCast((obj), (className *)NULL) // ---------------------------------------------------------------------------- // 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 ) */ -#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING +#if wxUSE_MEMORY_TRACING // All compilers get this one #define _WX_WANT_NEW_SIZET_WXCHAR_INT @@ -400,7 +396,7 @@ inline void* wxCheckCast(void *ptr) #endif // wxUSE_ARRAY_MEMORY_OPERATORS -#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING +#endif // wxUSE_MEMORY_TRACING // ---------------------------------------------------------------------------- // wxObjectRefData: ref counted data meant to be stored in wxObject @@ -653,24 +649,16 @@ private : // more debugging macros // ---------------------------------------------------------------------------- -// Redefine new to be the debugging version. This doesn't work with all -// compilers, in which case you need to use WXDEBUG_NEW explicitly if you wish -// to use the debugging version. - -#ifdef __WXDEBUG__ +#if wxUSE_DEBUG_NEW_ALWAYS #define WXDEBUG_NEW new(__TFILE__,__LINE__) - #if wxUSE_DEBUG_NEW_ALWAYS - #if wxUSE_GLOBAL_MEMORY_OPERATORS - #define new WXDEBUG_NEW - #elif defined(__VISUALC__) - // Including this file redefines new and allows leak reports to - // contain line numbers - #include "wx/msw/msvcrt.h" - #endif - #endif // wxUSE_DEBUG_NEW_ALWAYS -#else // !__WXDEBUG__ - #define WXDEBUG_NEW new -#endif // __WXDEBUG__/!__WXDEBUG__ + #if wxUSE_GLOBAL_MEMORY_OPERATORS + #define new WXDEBUG_NEW + #elif defined(__VISUALC__) + // Including this file redefines new and allows leak reports to + // contain line numbers + #include "wx/msw/msvcrt.h" + #endif +#endif // wxUSE_DEBUG_NEW_ALWAYS #endif // _WX_OBJECTH__ diff --git a/include/wx/palmos/bitmap.h b/include/wx/palmos/bitmap.h index d08b6117d9..e31cf24ce0 100644 --- a/include/wx/palmos/bitmap.h +++ b/include/wx/palmos/bitmap.h @@ -147,11 +147,6 @@ public: void SetHBITMAP(WXHBITMAP bmp) { SetHandle((WXHANDLE)bmp); } WXHBITMAP GetHBITMAP() const { return (WXHBITMAP)GetHandle(); } -#ifdef __WXDEBUG__ - void SetSelectedInto(wxDC *dc); - wxDC *GetSelectedInto() const; -#endif // __WXDEBUG__ - protected: // common part of all ctors void Init(); diff --git a/include/wx/propgrid/propgrid.h b/include/wx/propgrid/propgrid.h index 9b0c23b211..6001261918 100644 --- a/include/wx/propgrid/propgrid.h +++ b/include/wx/propgrid/propgrid.h @@ -87,9 +87,7 @@ public: int m_extraStyle; // global extra style -#ifdef __WXDEBUG__ int m_warnings; -#endif int HasExtraStyle( int style ) const { return (m_extraStyle & style); } }; @@ -1753,11 +1751,6 @@ protected: */ void CorrectEditorWidgetPosY(); -#ifdef __WXDEBUG__ - void _log_items(); - void OnScreenNote( const wxChar* format, ... ); -#endif - /** Deselect current selection, if any. Returns true if success (ie. validator did not intercept). */ bool DoClearSelection(); diff --git a/include/wx/stringops.h b/include/wx/stringops.h index 50aa1376ac..024968ece2 100644 --- a/include/wx/stringops.h +++ b/include/wx/stringops.h @@ -65,9 +65,10 @@ struct WXDLLIMPEXP_BASE wxStringOperationsUtf8 // checks correctness of UTF-8 sequence static bool IsValidUtf8String(const char *c, size_t len = wxStringImpl::npos); -#ifdef __WXDEBUG__ - static bool IsValidUtf8LeadByte(unsigned char c); -#endif + static bool IsValidUtf8LeadByte(unsigned char c) + { + return (c <= 0x7F) || (c >= 0xC2 && c <= 0xF4); + } // table of offsets to skip forward when iterating over UTF-8 sequence static const unsigned char ms_utf8IterTable[256]; diff --git a/include/wx/unix/apptrait.h b/include/wx/unix/apptrait.h index d29686af57..b8dd8e4abf 100644 --- a/include/wx/unix/apptrait.h +++ b/include/wx/unix/apptrait.h @@ -76,7 +76,7 @@ public: wxArrayString& desc) const; #endif // __WXGTK20____ -#if defined(__WXDEBUG__) && defined(__WXGTK20__) +#if defined(__WXGTK20__) virtual bool ShowAssertDialog(const wxString& msg); #endif diff --git a/include/wx/x11/app.h b/include/wx/x11/app.h index d5de438792..3d669c5b86 100644 --- a/include/wx/x11/app.h +++ b/include/wx/x11/app.h @@ -55,10 +55,6 @@ public: // Processes an X 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: // Implementation virtual bool Initialize(int& argc, wxChar **argv); diff --git a/include/wx/x11/privx.h b/include/wx/x11/privx.h index bf8386d641..36f5ac2ce7 100644 --- a/include/wx/x11/privx.h +++ b/include/wx/x11/privx.h @@ -67,9 +67,7 @@ void wxAllocNearestColor(Display *display,Colormap colormap,XColor *xcolor); void wxAllocColor(Display *display,Colormap colormap,XColor *xcolor); // For debugging -#ifdef __WXDEBUG__ wxString wxGetXEventName(XEvent& event); -#endif // Is the window visible? bool wxWindowIsVisible(Window win); diff --git a/interface/wx/debug.h b/interface/wx/debug.h index 1a6e697d97..5c446af318 100644 --- a/interface/wx/debug.h +++ b/interface/wx/debug.h @@ -9,6 +9,31 @@ /** @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 debug mode, but nothing will be done in the release build. @@ -25,6 +50,32 @@ */ #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" 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) +/** + 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). Note that you don't have to (and cannot) use brackets when invoking this @@ -211,23 +269,38 @@ bool wxIsDebuggerRunning(); /** - This function is called whenever one of debugging macros fails (i.e. - 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. + 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. - To override the default behaviour in the debug builds which is to show the - user a dialog asking whether he wants to abort the program, continue or - continue ignoring any subsequent assert failures, you may override - wxApp::OnAssertFailure() which is called by this function if the global - application object exists. + 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} -*/ -void wxOnAssert( const char* fileName, - int lineNumber, - const char* function, - const char* condition, - const char* message = NULL ); + */ +wxAssertHandler_t wxSetAssertHandler(wxAssertHandler_t handler); /** In debug mode (when @c __WXDEBUG__ is defined) this function generates a diff --git a/src/cocoa/app.mm b/src/cocoa/app.mm index 80402ff4f9..0f30885ea9 100644 --- a/src/cocoa/app.mm +++ b/src/cocoa/app.mm @@ -184,10 +184,6 @@ wxApp::wxApp() { m_topWindow = NULL; -#ifdef __WXDEBUG__ - m_isInAssert = false; -#endif // __WXDEBUG__ - argc = 0; #if !wxUSE_UNICODE 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: It's important to understand that Cocoa has a two-level event loop. The diff --git a/src/common/appbase.cpp b/src/common/appbase.cpp index 111ff3c7af..a3caf25a2b 100644 --- a/src/common/appbase.cpp +++ b/src/common/appbase.cpp @@ -63,7 +63,7 @@ #include "wx/fontmap.h" #endif // wxUSE_FONTMAP -#ifdef __WXDEBUG__ +#if wxDEBUG_LEVEL #if wxUSE_STACKWALKER #include "wx/stackwalk.h" #ifdef __WXMSW__ @@ -72,7 +72,7 @@ #endif // wxUSE_STACKWALKER #include "wx/recguard.h" -#endif // __WXDEBUG__ +#endif // wxDEBUG_LEVEL // 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 @@ -85,20 +85,22 @@ // private functions prototypes // ---------------------------------------------------------------------------- -#ifdef __WXDEBUG__ +#if wxDEBUG_LEVEL // really just show the assert dialog static bool DoShowAssertDialog(const wxString& msg); // prepare for showing the assert dialog, use the given traits or // DoShowAssertDialog() as last fallback to really show it static - void ShowAssertDialog(const wxString& szFile, - int nLine, - const wxString& szFunc, - const wxString& szCond, - const wxString& szMsg, + void ShowAssertDialog(const wxString& file, + int line, + const wxString& func, + const wxString& cond, + const wxString& msg, wxAppTraits *traits = NULL); +#endif // wxDEBUG_LEVEL +#ifdef __WXDEBUG__ // turn on the trace masks specified in the env variable WXTRACE static void LINKAGEMODE SetTraceMasks(); #endif // __WXDEBUG__ @@ -655,15 +657,24 @@ bool wxAppConsoleBase::CheckBuildOptions(const char *optionsSignature, return true; } -#ifdef __WXDEBUG__ - void wxAppConsoleBase::OnAssertFailure(const wxChar *file, int line, const wxChar *func, const wxChar *cond, const wxChar *msg) { +#if wxDEBUG_LEVEL 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, @@ -674,8 +685,6 @@ void wxAppConsoleBase::OnAssert(const wxChar *file, OnAssertFailure(file, line, NULL, cond, msg); } -#endif // __WXDEBUG__ - // ============================================================================ // other classes implementations // ============================================================================ @@ -713,12 +722,10 @@ wxRendererNative *wxConsoleAppTraitsBase::CreateRenderer() return NULL; } -#ifdef __WXDEBUG__ bool wxConsoleAppTraitsBase::ShowAssertDialog(const wxString& msg) { return wxAppTraitsBase::ShowAssertDialog(msg); } -#endif bool wxConsoleAppTraitsBase::HasStderr() { @@ -777,10 +784,9 @@ void WXDLLIMPEXP_BASE wxMutexGuiLeave() } #endif // wxUSE_THREADS -#ifdef __WXDEBUG__ - bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal) { +#if wxDEBUG_LEVEL wxString msg = msgOriginal; #if wxUSE_STACKWALKER @@ -797,11 +803,17 @@ bool wxAppTraitsBase::ShowAssertDialog(const wxString& msgOriginal) #endif // wxUSE_STACKWALKER return DoShowAssertDialog(msg); +#else // !wxDEBUG_LEVEL + wxUnusedVar(msgOriginal); + + return false; +#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL } #if wxUSE_STACKWALKER wxString wxAppTraitsBase::GetAssertStackTrace() { +#if wxDEBUG_LEVEL wxString stackTrace; class StackDump : public wxStackWalker @@ -859,12 +871,15 @@ wxString wxAppTraitsBase::GetAssertStackTrace() stackTrace = stackTrace.BeforeLast(wxT('\n')); 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 // __WXDEBUG__ - // ============================================================================ // global functions implementation // ============================================================================ @@ -891,14 +906,14 @@ void wxWakeUpIdle() //else: do nothing, what can we do? } -#ifdef __WXDEBUG__ - // wxASSERT() helper bool wxAssertIsEqual(int x, int y) { return x == y; } +#if wxDEBUG_LEVEL + // break into the debugger void wxTrap() { @@ -913,12 +928,13 @@ void wxTrap() #endif // Win/Unix } -// this function is called when an assert fails -static void wxDoOnAssert(const wxString& szFile, - int nLine, - const wxString& szFunc, - const wxString& szCond, - const wxString& szMsg = wxEmptyString) +// default assert handler +static void +wxDefaultAssertHandler(const wxString& file, + int line, + const wxString& func, + const wxString& cond, + const wxString& msg) { // FIXME MT-unsafe 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 // behaviour - ShowAssertDialog(szFile, nLine, szFunc, szCond, szMsg); + ShowAssertDialog(file, line, func, cond, msg); } else { // let the app process it as it wants // FIXME-UTF8: use wc_str(), not c_str(), when ANSI build is removed - wxTheApp->OnAssertFailure(szFile.c_str(), nLine, szFunc.c_str(), - szCond.c_str(), szMsg.c_str()); + wxTheApp->OnAssertFailure(file.c_str(), line, func.c_str(), + cond.c_str(), msg.c_str()); } } -void wxOnAssert(const wxString& szFile, - int nLine, - const wxString& szFunc, - const wxString& szCond, - const wxString& szMsg) +wxAssertHandler_t wxTheAssertHandler = wxDefaultAssertHandler; + +void wxOnAssert(const wxString& file, + int line, + 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, - int nLine, - const wxString& szFunc, - const wxString& szCond) +void wxOnAssert(const wxString& file, + int line, + const wxString& func, + const wxString& cond) { - wxDoOnAssert(szFile, nLine, szFunc, szCond); + wxTheAssertHandler(file, line, func, cond, wxString()); } -void wxOnAssert(const wxChar *szFile, - int nLine, - const char *szFunc, - const wxChar *szCond, - const wxChar *szMsg) +void wxOnAssert(const wxChar *file, + int line, + const char *func, + const wxChar *cond, + 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, - int nLine, - const char *szFunc, - const char *szCond, - const wxString& szMsg) +void wxOnAssert(const char *file, + int line, + const char *func, + const char *cond, + const wxString& msg) { - wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg); + wxTheAssertHandler(file, line, func, cond, msg); } -void wxOnAssert(const char *szFile, - int nLine, - const char *szFunc, - const char *szCond, +void wxOnAssert(const char *file, + int line, + const char *func, + const char *cond, const wxCStrData& msg) { - wxDoOnAssert(szFile, nLine, szFunc, szCond, msg); + wxTheAssertHandler(file, line, func, cond, msg); } #if wxUSE_UNICODE -void wxOnAssert(const char *szFile, - int nLine, - const char *szFunc, - const char *szCond) +void wxOnAssert(const char *file, + int line, + const char *func, + const char *cond) { - wxDoOnAssert(szFile, nLine, szFunc, szCond); + wxTheAssertHandler(file, line, func, cond, wxString()); } -void wxOnAssert(const char *szFile, - int nLine, - const char *szFunc, - const char *szCond, - const char *szMsg) +void wxOnAssert(const char *file, + int line, + const char *func, + const char *cond, + const char *msg) { - wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg); + wxTheAssertHandler(file, line, func, cond, msg); } -void wxOnAssert(const char *szFile, - int nLine, - const char *szFunc, - const char *szCond, - const wxChar *szMsg) +void wxOnAssert(const char *file, + int line, + const char *func, + const char *cond, + const wxChar *msg) { - wxDoOnAssert(szFile, nLine, szFunc, szCond, szMsg); + wxTheAssertHandler(file, line, func, cond, msg); } #endif // wxUSE_UNICODE -#endif // __WXDEBUG__ +#endif // wxDEBUG_LEVEL // ============================================================================ // private functions implementation @@ -1040,6 +1064,10 @@ static void LINKAGEMODE SetTraceMasks() #endif // wxUSE_LOG } +#endif // __WXDEBUG__ + +#if wxDEBUG_LEVEL + static bool DoShowAssertDialog(const wxString& msg) { @@ -1047,8 +1075,9 @@ bool DoShowAssertDialog(const wxString& msg) #if defined(__WXMSW__) && !defined(__WXMICROWIN__) wxString msgDlg(msg); - // this message is intentionally not translated -- it is for - // developpers only + // this message is intentionally not translated -- it is for developers + // 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") wxT("You can also choose [Cancel] to suppress ") wxT("further warnings."); @@ -1078,13 +1107,13 @@ bool DoShowAssertDialog(const wxString& msg) return false; } -// show the assert modal dialog +// show the standard assert dialog static -void ShowAssertDialog(const wxString& szFile, - int nLine, - const wxString& szFunc, - const wxString& szCond, - const wxString& szMsg, +void ShowAssertDialog(const wxString& file, + int line, + const wxString& func, + const wxString& cond, + const wxString& msgUser, wxAppTraits *traits) { // 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 // this, clicking on the message will take us immediately to the place of // 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 - if ( !szFunc.empty() ) - msg << _T(" in ") << szFunc << _T("()"); + if ( !func.empty() ) + msg << _T(" in ") << func << _T("()"); // and the message itself - if ( !szMsg.empty() ) + if ( !msgUser.empty() ) { - msg << _T(": ") << szMsg; + msg << _T(": ") << msgUser; } else // no message given { @@ -1151,4 +1180,4 @@ void ShowAssertDialog(const wxString& szFile, } } -#endif // __WXDEBUG__ +#endif // wxDEBUG_LEVEL diff --git a/src/common/datavcmn.cpp b/src/common/datavcmn.cpp index 4c3e52e99a..57c2aaecd0 100644 --- a/src/common/datavcmn.cpp +++ b/src/common/datavcmn.cpp @@ -38,13 +38,6 @@ bool operator == (const wxDataViewItem &left, const wxDataViewItem &right) 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 // --------------------------------------------------------- diff --git a/src/common/event.cpp b/src/common/event.cpp index 1024c50332..981d213a80 100644 --- a/src/common/event.cpp +++ b/src/common/event.cpp @@ -126,7 +126,7 @@ const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] = // the memory leaks when using it, however this breaks re-initializing 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 -#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING +#if wxUSE_MEMORY_TRACING class wxEventTableEntryModule: public wxModule { @@ -140,7 +140,7 @@ public: IMPLEMENT_DYNAMIC_CLASS(wxEventTableEntryModule, wxModule) -#endif // __WXDEBUG__ && wxUSE_MEMORY_TRACING +#endif // wxUSE_MEMORY_TRACING // ---------------------------------------------------------------------------- // global variables @@ -878,7 +878,7 @@ void wxEventHashTable::Clear() m_size = 0; } -#if defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING +#if wxUSE_MEMORY_TRACING // Clear all tables 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) { diff --git a/src/common/hyperlnkcmn.cpp b/src/common/hyperlnkcmn.cpp index 83e3349d75..582147736d 100644 --- a/src/common/hyperlnkcmn.cpp +++ b/src/common/hyperlnkcmn.cpp @@ -51,9 +51,12 @@ const char wxHyperlinkCtrlNameStr[] = "hyperlink"; // wxHyperlinkCtrlBase // ---------------------------------------------------------------------------- -#ifdef __WXDEBUG__ -void wxHyperlinkCtrlBase::CheckParams(const wxString& label, const wxString& url, long style) +void +wxHyperlinkCtrlBase::CheckParams(const wxString& label, + const wxString& url, + long style) { +#if wxDEBUG_LEVEL wxASSERT_MSG(!url.empty() || !label.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); wxASSERT_MSG(alignment == 1, wxT("Specify exactly one align flag!")); +#else // !wxDEBUG_LEVEL + wxUnusedVar(label); + wxUnusedVar(url); + wxUnusedVar(style); +#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL } -#endif void wxHyperlinkCtrlBase::SendEvent() { diff --git a/src/common/protocol.cpp b/src/common/protocol.cpp index 321d348ab5..1f508709eb 100644 --- a/src/common/protocol.cpp +++ b/src/common/protocol.cpp @@ -210,6 +210,7 @@ void wxProtocol::LogResponse(const wxString& str) void wxProtocolLog::DoLogString(const wxString& str) { + wxUnusedVar(str); // unused if wxLogTrace() is disabled wxLogTrace(m_traceMask, "%s", str); } diff --git a/src/common/stringops.cpp b/src/common/stringops.cpp index 9ccd34d95c..d51cce4b68 100644 --- a/src/common/stringops.cpp +++ b/src/common/stringops.cpp @@ -191,14 +191,6 @@ bool wxStringOperationsUtf8::IsValidUtf8String(const char *str, size_t len) 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 // code in single place wxUniChar::Utf8CharBuffer wxUniChar::AsUTF8() const diff --git a/src/gtk/app.cpp b/src/gtk/app.cpp index 18c05dda50..c349227bce 100644 --- a/src/gtk/app.cpp +++ b/src/gtk/app.cpp @@ -115,7 +115,8 @@ bool wxApp::DoIdle() id_save = m_idleSourceId; m_idleSourceId = 0; wx_add_idle_hooks(); -#ifdef __WXDEBUG__ + +#if wxDEBUG_LEVEL // don't generate the idle events while the assert modal dialog is shown, // this matches the behavior of wxMSW if (m_isInAssert) @@ -181,9 +182,8 @@ IMPLEMENT_DYNAMIC_CLASS(wxApp,wxEvtHandler) wxApp::wxApp() { -#ifdef __WXDEBUG__ m_isInAssert = false; -#endif // __WXDEBUG__ + #if wxUSE_THREADS m_idleMutex = NULL; #endif @@ -498,25 +498,30 @@ bool wxApp::EventsPending() return gtk_events_pending() != 0; } -#ifdef __WXDEBUG__ - void wxApp::OnAssertFailure(const wxChar *file, int line, 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; wxAppBase::OnAssertFailure(file, line, func, cond, msg); 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 void wxGUIAppTraits::MutexGuiEnter() { diff --git a/src/gtk/dcclient.cpp b/src/gtk/dcclient.cpp index f76a4a21f3..234a38f278 100644 --- a/src/gtk/dcclient.cpp +++ b/src/gtk/dcclient.cpp @@ -2081,6 +2081,9 @@ void wxWindowDCImpl::SetLogicalFunction( wxRasterOperationMode function ) case wxNO_OP: mode = GDK_NOOP; break; case wxSRC_INVERT: mode = GDK_COPY_INVERT; break; case wxNOR: mode = GDK_NOR; break; + default: + wxFAIL_MSG("unknown mode"); + return; } m_logicalFunction = function; diff --git a/src/gtk1/app.cpp b/src/gtk1/app.cpp index 2c4b9bff43..81632fb1a1 100644 --- a/src/gtk1/app.cpp +++ b/src/gtk1/app.cpp @@ -171,7 +171,7 @@ static gint wxapp_idle_callback( gpointer WXUNUSED(data) ) if (!wxTheApp) return TRUE; -#ifdef __WXDEBUG__ +#if wxDEBUG_LEVEL // 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 // from some safely-looking functions @@ -186,7 +186,7 @@ static gint wxapp_idle_callback( gpointer WXUNUSED(data) ) } return TRUE; } -#endif // __WXDEBUG__ +#endif // wxDEBUG_LEVEL // When getting called from GDK's time-out handler // we are no longer within GDK's grab on the GUI @@ -382,9 +382,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxApp,wxEvtHandler) wxApp::wxApp() { -#ifdef __WXDEBUG__ m_isInAssert = false; -#endif // __WXDEBUG__ m_idleTag = 0; g_isIdle = TRUE; @@ -616,19 +614,30 @@ void wxApp::CleanUp() wxAppBase::CleanUp(); } -#ifdef __WXDEBUG__ - -void wxApp::OnAssert(const wxChar *file, int line, const wxChar* cond, const wxChar *msg) +void wxApp::OnAssertFailure(const wxChar *file, + int line, + 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; - wxAppBase::OnAssert(file, line, cond, msg); + wxAppBase::OnAssertFailure(file, line, func, cond, msg); 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() { #if wxUSE_THREADS diff --git a/src/msw/bitmap.cpp b/src/msw/bitmap.cpp index c3ffd63876..ca1456ec66 100644 --- a/src/msw/bitmap.cpp +++ b/src/msw/bitmap.cpp @@ -92,12 +92,12 @@ public: // MSW-specific // ------------ -#ifdef __WXDEBUG__ +#if wxDEBUG_LEVEL // 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 // DC (both are serious programming errors under Windows) wxDC *m_selectedInto; -#endif // __WXDEBUG__ +#endif // wxDEBUG_LEVEL #if wxUSE_WXDIB // 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() { -#ifdef __WXDEBUG__ +#if wxDEBUG_LEVEL m_selectedInto = NULL; #endif m_bitmapMask = NULL; @@ -202,7 +202,7 @@ wxBitmapRefData::wxBitmapRefData() wxBitmapRefData::wxBitmapRefData(const wxBitmapRefData& data) : wxGDIImageRefData(data) { -#ifdef __WXDEBUG__ +#if wxDEBUG_LEVEL m_selectedInto = NULL; #endif @@ -1188,14 +1188,14 @@ wxBitmap wxBitmap::GetMaskBitmap() const return bmp; } -#ifdef __WXDEBUG__ - wxDC *wxBitmap::GetSelectedInto() const { +#if wxDEBUG_LEVEL return GetBitmapData() ? GetBitmapData()->m_selectedInto : NULL; -} - +#else + return NULL; #endif +} void wxBitmap::UseAlpha() { @@ -1212,15 +1212,15 @@ bool wxBitmap::HasAlpha() const // wxBitmap setters // ---------------------------------------------------------------------------- -#ifdef __WXDEBUG__ - void wxBitmap::SetSelectedInto(wxDC *dc) { +#if wxDEBUG_LEVEL if ( GetBitmapData() ) GetBitmapData()->m_selectedInto = dc; -} - +#else + wxUnusedVar(dc); #endif +} #if wxUSE_PALETTE diff --git a/src/msw/dcclient.cpp b/src/msw/dcclient.cpp index 1e667aa704..7adb608854 100644 --- a/src/msw/dcclient.cpp +++ b/src/msw/dcclient.cpp @@ -67,13 +67,13 @@ WX_DEFINE_OBJARRAY(wxArrayDCInfo) static PAINTSTRUCT g_paintStruct; -#ifdef __WXDEBUG__ +#ifdef wxHAS_PAINT_DEBUG // 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 // common programming error among wxWidgets programmers and might lead to // very subtle and difficult to debug refresh/repaint bugs. int g_isPainting = 0; -#endif // __WXDEBUG__ +#endif // wxHAS_PAINT_DEBUG // =========================================================================== // implementation @@ -216,7 +216,7 @@ wxPaintDCImpl::wxPaintDCImpl( wxDC *owner, wxWindow *window ) : { wxCHECK_RET( window, wxT("NULL canvas in wxPaintDCImpl ctor") ); -#ifdef __WXDEBUG__ +#ifdef wxHAS_PAINT_DEBUG if ( g_isPainting <= 0 ) { wxFAIL_MSG( wxT("wxPaintDCImpl may be created only in EVT_PAINT handler!") ); diff --git a/src/os2/dcclient.cpp b/src/os2/dcclient.cpp index 11160fbf97..728e34157f 100644 --- a/src/os2/dcclient.cpp +++ b/src/os2/dcclient.cpp @@ -62,13 +62,13 @@ WX_DEFINE_OBJARRAY(wxArrayDCInfo); static RECT g_paintStruct; -#ifdef __WXDEBUG__ +#ifdef wxHAS_PAINT_DEBUG // 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 // common programming error among wxWidgets programmers and might lead to // very subtle and difficult to debug refresh/repaint bugs. int g_isPainting = 0; -#endif // __WXDEBUG__ +#endif // wxHAS_PAINT_DEBUG // =========================================================================== // implementation @@ -308,7 +308,7 @@ wxPaintDCImpl::wxPaintDCImpl( wxDC *owner, wxWindow *pCanvas) : { wxCHECK_RET(pCanvas, wxT("NULL canvas in wxPaintDC ctor")); -#ifdef __WXDEBUG__ +#ifdef wxHAS_PAINT_DEBUG if (g_isPainting <= 0) { wxFAIL_MSG( wxT("wxPaintDC may be created only in EVT_PAINT handler!") ); diff --git a/src/palmos/bitmap.cpp b/src/palmos/bitmap.cpp index ed435cf0dd..9d25528834 100644 --- a/src/palmos/bitmap.cpp +++ b/src/palmos/bitmap.cpp @@ -77,10 +77,6 @@ public: wxPalette m_bitmapPalette; #endif // wxUSE_PALETTE -#ifdef __WXDEBUG__ - wxDC *m_selectedInto; -#endif // __WXDEBUG__ - #if wxUSE_WXDIB wxDIB *m_dib; #endif @@ -147,9 +143,6 @@ IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject) wxBitmapRefData::wxBitmapRefData() { -#ifdef __WXDEBUG__ - m_selectedInto = NULL; -#endif m_bitmapMask = NULL; m_hBitmap = (WXHBITMAP) NULL; @@ -310,15 +303,6 @@ wxMask *wxBitmap::GetMask() const return NULL; } -#ifdef __WXDEBUG__ - -wxDC *wxBitmap::GetSelectedInto() const -{ - return NULL; -} - -#endif - bool wxBitmap::HasAlpha() const { return false; @@ -328,14 +312,6 @@ bool wxBitmap::HasAlpha() const // wxBitmap setters // ---------------------------------------------------------------------------- -#ifdef __WXDEBUG__ - -void wxBitmap::SetSelectedInto(wxDC *dc) -{ -} - -#endif - #if wxUSE_PALETTE void wxBitmap::SetPalette(const wxPalette& palette) diff --git a/src/propgrid/propgrid.cpp b/src/propgrid/propgrid.cpp index d323c6862d..8c6e80d786 100644 --- a/src/propgrid/propgrid.cpp +++ b/src/propgrid/propgrid.cpp @@ -176,7 +176,7 @@ wxPGGlobalVarsClass::wxPGGlobalVarsClass() wxVariant v; - // Prepare some shared variants + // Prepare some shared variants m_vEmptyString = wxString(); m_vZero = (long) 0; m_vMinusOne = (long) -1; @@ -193,9 +193,7 @@ wxPGGlobalVarsClass::wxPGGlobalVarsClass() m_strUnits = wxS("Units"); m_strInlineHelp = wxS("InlineHelp"); -#ifdef __WXDEBUG__ m_warnings = 0; -#endif } @@ -498,10 +496,10 @@ void wxPropertyGrid::Init1() #endif #ifndef wxPG_ICON_WIDTH - m_expandbmp = NULL; - m_collbmp = NULL; - m_iconWidth = 11; - m_iconHeight = 11; + m_expandbmp = NULL; + m_collbmp = NULL; + m_iconWidth = 11; + m_iconHeight = 11; #else m_iconWidth = wxPG_ICON_WIDTH; #endif @@ -558,19 +556,19 @@ void wxPropertyGrid::Init2() #ifndef wxPG_ICON_WIDTH // create two bitmap nodes for drawing - m_expandbmp = new wxBitmap(expand_xpm); - m_collbmp = new wxBitmap(collapse_xpm); + m_expandbmp = new wxBitmap(expand_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_iconHeight = m_expandbmp->GetHeight(); + m_iconWidth = m_expandbmp->GetWidth(); + m_iconHeight = m_expandbmp->GetHeight(); #endif m_curcursor = wxCURSOR_ARROW; 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; CalculateFontAndBitmapStuff( wxPG_DEFAULT_VSPACING ); @@ -590,9 +588,9 @@ void wxPropertyGrid::Init2() m_tlwHandler = handler; m_tlp->PushEventHandler(handler); - // set virtual size to this window size + // set virtual size to this window size wxSize wndsize = GetSize(); - SetVirtualSize(wndsize.GetWidth(), wndsize.GetWidth()); + SetVirtualSize(wndsize.GetWidth(), wndsize.GetWidth()); m_timeCreated = ::wxGetLocalTimeMillis(); @@ -648,8 +646,8 @@ wxPropertyGrid::~wxPropertyGrid() delete m_cursorSizeWE; #ifndef wxPG_ICON_WIDTH - delete m_expandbmp; - delete m_collbmp; + delete m_expandbmp; + delete m_collbmp; #endif // Delete common value records @@ -843,13 +841,13 @@ wxSize wxPropertyGrid::DoGetBestSize() const void wxPropertyGrid::CalculateFontAndBitmapStuff( int vspacing ) { - int x = 0, y = 0; + int x = 0, y = 0; 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_fontHeight = y; + m_fontHeight = y; #if wxPG_USE_RENDERER_NATIVE m_iconWidth = wxPG_ICON_WIDTH; @@ -878,7 +876,7 @@ void wxPropertyGrid::CalculateFontAndBitmapStuff( int vspacing ) m_marginWidth = m_gutterWidth*2 + m_iconWidth; 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; @@ -3771,7 +3769,7 @@ void wxPropertyGrid::RecalculateVirtualSize( int forceXPos ) GetClientSize(&width,&height); // Now adjust virtual size. - SetVirtualSize(x, y); + SetVirtualSize(x, y); int xAmount = 0; int xPos = 0; @@ -4268,7 +4266,7 @@ bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y, wxMouseEvent &event if ( space ) { int tw, th; - GetTextExtent( tipString, &tw, &th, 0, 0 ); + GetTextExtent( tipString, &tw, &th, 0, 0 ); if ( tw > space ) { SetToolTip( tipString ); diff --git a/src/propgrid/propgridpagestate.cpp b/src/propgrid/propgridpagestate.cpp index 0c6ed468cb..311507eb3e 100644 --- a/src/propgrid/propgridpagestate.cpp +++ b/src/propgrid/propgridpagestate.cpp @@ -1566,16 +1566,18 @@ bool wxPropertyGridPageState::PrepareToAddItem( wxPGProperty* property, } } -#ifdef __WXDEBUG__ +#if wxDEBUG_LEVEL // Warn for identical names in debug mode. if ( BaseGetPropertyByName(property->GetName()) && (!scheduledParent || scheduledParent->IsCategory()) ) { - wxLogError(wxT("wxPropertyGrid: Warning - item with name \"%s\" already exists."), - property->GetName().c_str()); + wxFAIL_MSG(wxString::Format( + "wxPropertyGrid item with name \"%s\" already exists", + property->GetName())); + wxPGGlobalVars->m_warnings++; } -#endif +#endif // wxDEBUG_LEVEL // Make sure nothing is selected. if ( propGrid ) diff --git a/src/x11/app.cpp b/src/x11/app.cpp index e1a396c53f..e18014ec14 100644 --- a/src/x11/app.cpp +++ b/src/x11/app.cpp @@ -64,7 +64,6 @@ static wxWindow *g_prevFocus = NULL; // X11 error handling //------------------------------------------------------------------------ -#ifdef __WXDEBUG__ typedef int (*XErrorHandlerFunc)(Display *, XErrorEvent *); XErrorHandlerFunc gs_pfnXErrorHandler = 0; @@ -77,7 +76,6 @@ static int wxXErrorHandler(Display *dpy, XErrorEvent *xevent) else return 0; } -#endif // __WXDEBUG__ //------------------------------------------------------------------------ // wxApp @@ -89,10 +87,10 @@ IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler) bool wxApp::Initialize(int& argC, wxChar **argV) { -#if defined(__WXDEBUG__) && !wxUSE_NANOX +#if !wxUSE_NANOX // install the X error handler gs_pfnXErrorHandler = XSetErrorHandler( wxXErrorHandler ); -#endif // __WXDEBUG__ +#endif wxString displayName; bool syncDisplay = false; @@ -292,9 +290,6 @@ bool wxApp::ProcessXEvent(WXEvent* _event) return false; } -#ifdef __WXDEBUG__ - wxString windowClass = win->GetClassInfo()->GetClassName(); -#endif switch (event->type) { @@ -453,10 +448,8 @@ bool wxApp::ProcessXEvent(WXEvent* _event) } #if !wxUSE_NANOX case PropertyNotify: - { - //wxLogDebug("PropertyNotify: %s", windowClass.c_str()); return HandlePropertyChange(_event); - } + case ClientMessage: { if (!win->IsEnabled()) @@ -617,13 +610,6 @@ bool wxApp::ProcessXEvent(WXEvent* _event) return win->HandleWindowEvent(focusEvent); } return false; - -#ifdef __WXDEBUG__ - default: - //wxString eventName = wxGetXEventName(XEvent& event); - //wxLogDebug(wxT("Event %s not handled"), eventName.c_str()); - break; -#endif // __WXDEBUG__ } return false; @@ -767,19 +753,3 @@ void wxApp::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__ diff --git a/src/x11/utils.cpp b/src/x11/utils.cpp index 92c6b4c4e3..0aa849ea29 100644 --- a/src/x11/utils.cpp +++ b/src/x11/utils.cpp @@ -370,7 +370,6 @@ void wxAllocColor(Display *d,Colormap cmp,XColor *xc) } } -#ifdef __WXDEBUG__ wxString wxGetXEventName(XEvent& event) { #if wxUSE_NANOX @@ -395,7 +394,6 @@ wxString wxGetXEventName(XEvent& event) return wxString::FromAscii(event_name[type]); #endif } -#endif bool wxWindowIsVisible(Window win) { diff --git a/tests/misc/misctests.cpp b/tests/misc/misctests.cpp index 75b1b55c9d..3ead0b38ec 100644 --- a/tests/misc/misctests.cpp +++ b/tests/misc/misctests.cpp @@ -1,10 +1,11 @@ /////////////////////////////////////////////////////////////////////////////// // Name: tests/misc/misctests.cpp // Purpose: test miscellaneous stuff -// Author: Peter Most +// Author: Peter Most, Vadim Zeitlin // Created: 2008-07-10 // RCS-ID: $Id$ // Copyright: (c) 2008 Peter Most +// (c) 2009 Vadim Zeitlin /////////////////////////////////////////////////////////////////////////////// // ---------------------------------------------------------------------------- @@ -30,9 +31,11 @@ public: private: CPPUNIT_TEST_SUITE( MiscTestCase ); + CPPUNIT_TEST( Assert ); CPPUNIT_TEST( Delete ); CPPUNIT_TEST_SUITE_END(); + void Assert(); void Delete(); 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 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() { // Allocate some arbitrary memory to get a valid pointer: diff --git a/tests/testprec.h b/tests/testprec.h index 3342bb01a8..901a745575 100644 --- a/tests/testprec.h +++ b/tests/testprec.h @@ -11,7 +11,7 @@ class TestAssertFailure { }; // 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 // own #define WX_ASSERT_FAILS_WITH_ASSERT(cond) \ @@ -23,7 +23,7 @@ class TestAssertFailure { }; CPPUNIT_FAIL("expected assertion not generated"); \ } #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)) #endif -- 2.45.2