X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/28efe6544f28ba7b37a77c033901fdd6f3978b82..e91e1e3d5cab263883c1cee1689c898b8f7c4ecd:/include/wx/debug.h diff --git a/include/wx/debug.h b/include/wx/debug.h index 7cdaecf9c4..f80f7be680 100644 --- a/include/wx/debug.h +++ b/include/wx/debug.h @@ -1,290 +1,388 @@ -/** -* Name: wx/debug.h -* Purpose: Misc debug functions and macros -* Author: Vadim Zeitlin -* Modified by: Ryan Norton (Converted to C) -* Created: 29/01/98 -* RCS-ID: $Id$ -* Copyright: (c) 1998 Vadim Zeitlin -* Licence: wxWindows licence -*/ +///////////////////////////////////////////////////////////////////////////// +// Name: wx/debug.h +// Purpose: Misc debug functions and macros +// Author: Vadim Zeitlin +// Created: 29/01/98 +// Copyright: (c) 1998-2009 Vadim Zeitlin +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// -/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */ +#ifndef _WX_DEBUG_H_ +#define _WX_DEBUG_H_ -#ifndef _WX_DEBUG_H_ -#define _WX_DEBUG_H_ +#if !defined(__WXWINCE__) + #include +#endif // systems without assert.h -#ifndef __WXWINCE__ -#include -#endif -#include /* for CHAR_BIT used below */ +#include // for CHAR_BIT used below + +#include "wx/chartype.h" // for __TFILE__ and wxChar +#include "wx/cpp.h" // for __WXFUNCTION__ +#include "wx/dlimpexp.h" // for WXDLLIMPEXP_FWD_BASE + +class WXDLLIMPEXP_FWD_BASE wxString; +class WXDLLIMPEXP_FWD_BASE wxCStrData; + +// ---------------------------------------------------------------------------- +// Defines controlling the debugging macros +// ---------------------------------------------------------------------------- -#include "wx/chartype.h" /* for __TFILE__ and wxChar */ +/* + 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. + */ -/* ---------------------------------------------------------------------------- */ -/* Defines controlling the debugging macros */ -/* ---------------------------------------------------------------------------- */ +// unless wxDEBUG_LEVEL is predefined (by configure or via wx/setup.h under +// Windows), use the default +#if !defined(wxDEBUG_LEVEL) + #define wxDEBUG_LEVEL 1 +#endif // !defined(wxDEBUG_LEVEL) -/* if _DEBUG is defined (MS VC++ and others use it in debug builds), define */ -/* __WXDEBUG__ too */ -#ifdef _DEBUG +/* + __WXDEBUG__ is defined when wxDEBUG_LEVEL != 0. This is done mostly for + compatibility but it also provides a simpler way to check if asserts and + debug logging is enabled at all. + */ +#if wxDEBUG_LEVEL > 0 #ifndef __WXDEBUG__ #define __WXDEBUG__ - #endif /* !__WXDEBUG__ */ -#endif /* _DEBUG */ - -/* if NDEBUG is defined ( uses it), undef __WXDEBUG__ and WXDEBUG */ -#ifdef NDEBUG + #endif +#else #undef __WXDEBUG__ - #undef WXDEBUG -#endif /* NDEBUG */ +#endif -/* if __WXDEBUG__ is defined, make sure that WXDEBUG is defined and >= 1 */ +// Finally there is also a very old WXDEBUG macro not used anywhere at all, it +// is only defined for compatibility. #ifdef __WXDEBUG__ #if !defined(WXDEBUG) || !WXDEBUG #undef WXDEBUG #define WXDEBUG 1 - #endif /* !WXDEBUG */ -#endif /* __WXDEBUG__ */ - -#ifndef __WXFUNCTION__ - /* TODO: add more compilers supporting __FUNCTION__ */ - #if defined(__DMC__) - /* - __FUNCTION__ happens to be not defined within class members - http://www.digitalmars.com/drn-bin/wwwnews?c%2B%2B.beta/485 - */ - #define __WXFUNCTION__ (NULL) - #elif defined(__GNUC__) || \ - (defined(_MSC_VER) && _MSC_VER >= 1300) || \ - defined(__FUNCTION__) - #define __WXFUNCTION__ __FUNCTION__ - #else - /* still define __WXFUNCTION__ to avoid #ifdefs elsewhere */ - #define __WXFUNCTION__ (NULL) - #endif -#endif /* __WXFUNCTION__ already defined */ - -/* ---------------------------------------------------------------------------- */ -/* Debugging macros */ -/* */ -/* All debugging macros rely on ASSERT() which in turn calls the user-defined */ -/* OnAssert() function. To keep things simple, it's called even when the */ -/* expression is true (i.e. everything is ok) and by default does nothing: just */ -/* returns the same value back. But if you redefine it to do something more sexy */ -/* (popping up a message box in your favourite GUI, sending you e-mail or */ -/* whatever) it will affect all ASSERTs, FAILs and CHECKs in your code. */ -/* */ -/* Warning: if you don't like advice on programming style, don't read */ -/* further! ;-) */ -/* */ -/* Extensive use of these macros is recommended! Remember that ASSERTs are */ -/* disabled in final build (without __WXDEBUG__ defined), so they add strictly */ -/* nothing to your program's code. On the other hand, CHECK macros do stay */ -/* even in release builds, but in general are not much of a burden, while */ -/* a judicious use of them might increase your program's stability. */ -/* ---------------------------------------------------------------------------- */ - -/* Macros which are completely disabled in 'release' mode */ -/* */ -/* NB: these functions are implemented in src/common/appcmn.cpp */ -#if defined(__cplusplus) && defined(__WXDEBUG__) - /* - This function is called whenever one of debugging macros fails (i.e. - condition is false in an assertion). To customize its behaviour, override - wxApp::OnAssertFailure(). - - Parameters: - szFile and nLine - file name and line number of the ASSERT - szFunc - function name of the ASSERT, may be NULL (NB: ASCII) - szCond - text form of the condition which failed - szMsg - optional message explaining the reason - */ - - /* this version is for compatibility with wx 2.8 Unicode build only: */ - extern void WXDLLIMPEXP_BASE wxOnAssert(const wxChar *szFile, - int nLine, - const char *szFunc, - const wxChar *szCond, - const wxChar *szMsg = NULL); + #endif // !WXDEBUG +#endif // __WXDEBUG__ -#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 */ +// ---------------------------------------------------------------------------- +// Handling assertion failures +// ---------------------------------------------------------------------------- - class WXDLLIMPEXP_BASE wxString; - class WXDLLIMPEXP_BASE wxCStrData; +/* + 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); - /* 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); +#if wxDEBUG_LEVEL - extern void WXDLLIMPEXP_BASE wxOnAssert(const wxString& szFile, - int nLine, - const wxString& szFunc, - const wxString& szCond); +// the global assert handler function, if it is NULL asserts don't check their +// conditions +extern WXDLLIMPEXP_DATA_BASE(wxAssertHandler_t) wxTheAssertHandler; - extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile, - int nLine, - const char *szFunc, - const char *szCond, - const wxCStrData& msg); +/* + Sets the function to be called in case of assertion failure. - extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile, - int nLine, - const char *szFunc, - const char *szCond, - const wxString& szMsg); + 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. - /* call this function to break into the debugger unconditionally (assuming */ - /* the program is running under debugger, of course) */ - extern void WXDLLIMPEXP_BASE wxTrap(); + 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 or after its destruction you + need to provide your assertion handler function. - /* generic assert macro */ - #define wxASSERT(cond) wxASSERT_MSG(cond, (const char*)NULL) + 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. - /* assert with additional message explaining its cause */ + 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; +} - /* compilers can give a warning (such as "possible unwanted ;") when using */ - /* the default definition of wxASSERT_MSG so we provide an alternative */ - #if defined(__MWERKS__) - #define wxASSERT_MSG(cond, msg) \ - if ( cond ) \ - {} \ - else \ - wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg) - #else - #define wxASSERT_MSG(cond, msg) \ - if ( cond ) \ - ; \ - else \ - wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg) - #endif - - /* special form of assert: always triggers it (in debug mode) */ - #define wxFAIL wxFAIL_MSG((const char*)NULL) - - /* FAIL with some message */ - #define wxFAIL_MSG(msg) wxFAIL_COND_MSG("wxAssertFailure", msg) - - /* FAIL with some message and a condition */ - #define wxFAIL_COND_MSG(cond, msg) \ - wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, cond, msg) - - /* An assert helper used to avoid warning when testing constant expressions, */ - /* i.e. wxASSERT( sizeof(int) == 4 ) can generate a compiler warning about */ - /* expression being always true, but not using */ - /* wxASSERT( wxAssertIsEqual(sizeof(int), 4) ) */ - /* */ - /* NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and should no */ - /* longer be used. */ - extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y); +/* + Reset the default assert handler. + + This may be used to enable asserts, which are disabled by default in this + case, for programs built in release build (NDEBUG defined). + */ +extern void WXDLLIMPEXP_BASE wxSetDefaultAssertHandler(); + +#else // !wxDEBUG_LEVEL + +// provide empty stubs 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; +} + +inline void wxSetDefaultAssertHandler() { } + +#endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL + +// simply a synonym for wxSetAssertHandler(NULL) +inline void wxDisableAsserts() { wxSetAssertHandler(NULL); } + +/* + A macro which disables asserts for applications compiled in release build. + + By default, wxIMPLEMENT_APP (or rather wxIMPLEMENT_WXWIN_MAIN) disable the + asserts in the applications compiled in the release build by calling this. + It does nothing if NDEBUG is not defined. + */ +#ifdef NDEBUG + #define wxDISABLE_ASSERTS_IN_RELEASE_BUILD() wxDisableAsserts() #else - #define wxTrap() - - /* nothing to do in release mode (hopefully at this moment there are */ - /* no more bugs ;-) */ - #define wxASSERT(cond) - #define wxASSERT_MSG(cond, msg) - #define wxFAIL - #define wxFAIL_MSG(msg) - #define wxFAIL_COND_MSG(cond, msg) -#endif /* __WXDEBUG__ */ - -#ifdef __cplusplus - /* Use of wxFalse instead of false suppresses compiler warnings about testing */ - /* constant expression */ - extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse; + #define wxDISABLE_ASSERTS_IN_RELEASE_BUILD() #endif -#define wxAssertFailure wxFalse +#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 wxT(). + + 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 -/* NB: the following macros also work in release mode! */ +// these overloads are the ones typically used by debugging macros: we have to +// provide wxChar* msg version because it's common to use wxT() 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 WXDLLIMPEXP_BASE void wxOnAssert(const char *file, + int line, + const char *func, + const char *cond); + +extern WXDLLIMPEXP_BASE void wxOnAssert(const char *file, + int line, + const char *func, + const char *cond, + const char *msg); + +extern WXDLLIMPEXP_BASE void 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 WXDLLIMPEXP_BASE void 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 WXDLLIMPEXP_BASE void wxOnAssert(const wxString& file, + int line, + const wxString& func, + const wxString& cond, + const wxString& msg); + +extern WXDLLIMPEXP_BASE void wxOnAssert(const wxString& file, + int line, + const wxString& func, + const wxString& cond); + +extern WXDLLIMPEXP_BASE void wxOnAssert(const char *file, + int line, + const char *func, + const char *cond, + const wxCStrData& msg); + +extern WXDLLIMPEXP_BASE void wxOnAssert(const char *file, + int line, + const char *func, + const char *cond, + const wxString& msg); + +#endif // wxDEBUG_LEVEL + + +// ---------------------------------------------------------------------------- +// Debugging macros +// ---------------------------------------------------------------------------- /* - 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!!") ) -*/ + 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. -/* check that expression is true, "return" if not (also FAILs in debug mode) */ -#define wxCHECK(cond, rc) wxCHECK_MSG(cond, rc, (const char*)NULL) + 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 + // wxTrap() can be used to break into the debugger unconditionally + // (assuming the program is running under debugger, of course). + // + // If possible, we prefer to define it as a macro rather than as a function + // to open the debugger at the position where we trapped and not inside the + // trap function itself which is not very useful. + #if wxCHECK_VISUALC_VERSION(7) + #define wxTrap() __debugbreak() + #else + extern WXDLLIMPEXP_BASE void wxTrap(); + #endif // Win VisualC + + // Global flag used to indicate that assert macros should call wxTrap(): it + // is set by the default assert handler if the user answers yes to the + // question of whether to trap. + extern WXDLLIMPEXP_DATA_BASE(bool) wxTrapInAssert; + + // This macro checks if the condition is true and calls the assert handler + // with the provided message if it isn't and finally traps if the special + // flag indicating that it should do it was set by the handler. + // + // Notice that we don't use the handler return value for compatibility + // reasons (if we changed its return type, we'd need to change wxApp:: + // OnAssertFailure() too which would break user code overriding it), hence + // the need for the ugly global flag. + #define wxASSERT_MSG(cond, msg) \ + wxSTATEMENT_MACRO_BEGIN \ + if ( wxTheAssertHandler && !(cond) && \ + (wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, \ + #cond, msg), wxTrapInAssert) ) \ + { \ + wxTrapInAssert = false; \ + wxTrap(); \ + } \ + wxSTATEMENT_MACRO_END + + // 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) \ + wxSTATEMENT_MACRO_BEGIN \ + if ( wxTheAssertHandler && \ + (wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, \ + cond, msg), wxTrapInAssert) ) \ + { \ + wxTrapInAssert = false; \ + wxTrap(); \ + } \ + wxSTATEMENT_MACRO_END + + #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(cond, msg) + #define wxASSERT_LEVEL_2(cond) +#endif + +// This is simply a wrapper for the standard abort() which is not available +// under all platforms. +// +// It isn't really debug-related but there doesn't seem to be any better place +// for it, so declare it here and define it in appbase.cpp, together with +// wxTrap(). +extern void WXDLLIMPEXP_BASE wxAbort(); + +/* + 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" ) +*/ -/* as wxCHECK but with a message explaining why we fail */ +// the generic macro: takes the condition to check, the statement to be executed +// in case the condition is false and the message to pass to the assert handler +#define wxCHECK2_MSG(cond, op, msg) \ + if ( cond ) \ + {} \ + else \ + { \ + wxFAIL_COND_MSG(#cond, msg); \ + op; \ + } \ + 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, perform op if not */ -#define wxCHECK2(cond, op) wxCHECK2_MSG(cond, op, (const char*)NULL) +// check that expression is true, "return" if not (also FAILs in debug mode) +#define wxCHECK(cond, rc) wxCHECK_MSG(cond, rc, (const char*)NULL) -/* as wxCHECK2 but with a message explaining why we fail */ - -/* see comment near the definition of wxASSERT_MSG for the # if/else reason */ -#if defined(__MWERKS__) - #define wxCHECK2_MSG(cond, op, msg) \ - if ( cond ) \ - {} \ - else \ - { \ - wxFAIL_COND_MSG(#cond, msg); \ - op; \ - } \ - struct wxDummyCheckStruct /* just to force a semicolon */ -#else - #define wxCHECK2_MSG(cond, op, msg) \ - if ( cond ) \ - ; \ - else \ - { \ - wxFAIL_COND_MSG(#cond, msg); \ - op; \ - } \ - struct wxDummyCheckStruct /* just to force a semicolon */ -#endif +// 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: */ -/* there is no other way to tell the caller what exactly went wrong */ -/* from the void function (of course, the function shouldn't be void */ -/* to begin with...) */ +// special form of wxCHECK2: as wxCHECK, but for use in void functions +// +// NB: there is only one form (with msg parameter) and it's intentional: +// there is no other way to tell the caller what exactly went wrong +// from the void function (of course, the function shouldn't be void +// to begin with...) #define wxCHECK_RET(cond, msg) wxCHECK2_MSG(cond, return, msg) -/* ---------------------------------------------------------------------------- */ -/* Compile time asserts */ -/* */ -/* Unlike the normal assert and related macros above which are checked during */ -/* the program tun-time the macros below will result in a compilation error if */ -/* the condition they check is false. This is usually used to check the */ -/* expressions containing sizeof()s which cannot be tested with the */ -/* preprocessor. If you can use the #if's, do use them as you can give a more */ -/* detailed error message then. */ -/* ---------------------------------------------------------------------------- */ + +// ---------------------------------------------------------------------------- +// Compile time asserts +// +// Unlike the normal assert and related macros above which are checked during +// 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 +// detailed error message then. +// ---------------------------------------------------------------------------- /* How this works (you don't have to understand it to be able to use the @@ -306,13 +404,31 @@ It may be used both within a function and in the global scope. */ -#if defined(__WATCOMC__) && defined(__cplusplus) +#if defined(__WATCOMC__) /* avoid "unused symbol" warning */ #define wxCOMPILE_TIME_ASSERT(expr, msg) \ class wxMAKE_UNIQUE_ASSERT_NAME { \ unsigned int msg: expr; \ wxMAKE_UNIQUE_ASSERT_NAME() { wxUnusedVar(msg); } \ } +#elif defined( __VMS ) +namespace wxdebug{ + +// HP aCC cannot deal with missing names for template value parameters +template struct STATIC_ASSERTION_FAILURE; + +template <> struct STATIC_ASSERTION_FAILURE { enum { value = 1 }; }; + +// HP aCC cannot deal with missing names for template value parameters +template struct static_assert_test{}; + +} + #define WX_JOIN( X, Y ) X##Y + #define WX_STATIC_ASSERT_BOOL_CAST(x) (bool)(x) + #define wxCOMPILE_TIME_ASSERT(expr, msg) \ + typedef ::wxdebug::static_assert_test<\ + sizeof(::wxdebug::STATIC_ASSERTION_FAILURE< WX_STATIC_ASSERT_BOOL_CAST( expr ) >)>\ + WX_JOIN(wx_static_assert_typedef_, __LINE__) #else #define wxCOMPILE_TIME_ASSERT(expr, msg) \ struct wxMAKE_UNIQUE_ASSERT_NAME { unsigned int msg: expr; } @@ -328,32 +444,53 @@ #define wxCOMPILE_TIME_ASSERT2(expr, msg, text) \ struct wxMAKE_UNIQUE_ASSERT_NAME2(text) { unsigned int msg: expr; } -/* helpers for wxCOMPILE_TIME_ASSERT below, for private use only */ +// helpers for wxCOMPILE_TIME_ASSERT below, for private use only #define wxMAKE_BITSIZE_MSG(type, size) type ## SmallerThan ## size ## Bits -/* a special case of compile time assert: check that the size of the given type */ -/* is at least the given number of bits */ +// a special case of compile time assert: check that the size of the given type +// is at least the given number of bits #define wxASSERT_MIN_BITSIZE(type, size) \ wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \ wxMAKE_BITSIZE_MSG(type, size)) -/* ---------------------------------------------------------------------------- */ -/* other miscellaneous debugger-related functions */ -/* ---------------------------------------------------------------------------- */ + +// ---------------------------------------------------------------------------- +// other miscellaneous debugger-related functions +// ---------------------------------------------------------------------------- /* Return true if we're running under debugger. - Currently this only really works under Win32 and Mac in CodeWarrior builds, - it always returns false in other cases. + Currently only really works under Win32 and just returns false elsewhere. */ -#ifdef __cplusplus - /* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */ - #if defined(__WXMAC__) || defined(__WIN32__) - extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning(); - #else /* !Mac */ - inline bool wxIsDebuggerRunning() { return false; } - #endif /* Mac/!Mac */ -#endif /* __cplusplus */ - -#endif /* _WX_DEBUG_H_ */ +#if defined(__WIN32__) + extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning(); +#else // !Mac + 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_