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

made wx/debug.h C++ header again (reverting changes of r24896); simply don't include it from wx/defs.h when compiling C files which have no need for the stuff defined in it anyhow

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@59702 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2009-03-21 16:34:46 +00:00
parent 23c26b99e0
commit 993df0402c
2 changed files with 111 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

223
include/wx/debug.h
View File

@@ -1,58 +1,54 @@
/** /////////////////////////////////////////////////////////////////////////////
* Name: wx/debug.h // Name: wx/debug.h
* Purpose: Misc debug functions and macros // Purpose: Misc debug functions and macros
* Author: Vadim Zeitlin // Author: Vadim Zeitlin
* Modified by: Ryan Norton (Converted to C) // Created: 29/01/98
* Created: 29/01/98 // RCS-ID: $Id$
* RCS-ID: $Id$ // Copyright: (c) 1998-2009 Vadim Zeitlin <vadim@wxwidgets.org>
* Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr> // Licence: wxWindows licence
* 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_ #if !defined(__WXPALMOS5__) && !defined(__WXWINCE__)
#define _WX_DEBUG_H_ #include <assert.h>
#endif // systems without assert.h
#ifndef __WXPALMOS5__ #include <limits.h> // for CHAR_BIT used below
#ifndef __WXWINCE__
#include <assert.h>
#endif
#endif // ! __WXPALMOS5__
#include <limits.h> /* for CHAR_BIT used below */
#include "wx/chartype.h" /* for __TFILE__ and wxChar */ #include "wx/chartype.h" // for __TFILE__ and wxChar
/* ---------------------------------------------------------------------------- */ // ----------------------------------------------------------------------------
/* Defines controlling the debugging macros */ // Defines controlling the debugging macros
/* ---------------------------------------------------------------------------- */ // ----------------------------------------------------------------------------
/* if _DEBUG is defined (MS VC++ and others use it in debug builds), define */ // if _DEBUG is defined (MS VC++ and others use it in debug builds), define
/* __WXDEBUG__ too */ // __WXDEBUG__ too
#ifdef _DEBUG #ifdef _DEBUG
#ifndef __WXDEBUG__ #ifndef __WXDEBUG__
#define __WXDEBUG__ #define __WXDEBUG__
#endif /* !__WXDEBUG__ */ #endif // !__WXDEBUG__
#endif /* _DEBUG */ #endif // _DEBUG
/* if NDEBUG is defined (<assert.h> uses it), undef __WXDEBUG__ and WXDEBUG */ // if NDEBUG is defined (<assert.h> uses it), undef __WXDEBUG__ and WXDEBUG
#ifdef NDEBUG #ifdef NDEBUG
#undef __WXDEBUG__ #undef __WXDEBUG__
#undef WXDEBUG #undef WXDEBUG
#endif /* NDEBUG */ #endif // NDEBUG
/* if __WXDEBUG__ is defined, make sure that WXDEBUG is defined and >= 1 */ // if __WXDEBUG__ is defined, make sure that WXDEBUG is defined and >= 1
#ifdef __WXDEBUG__ #ifdef __WXDEBUG__
#if !defined(WXDEBUG) || !WXDEBUG #if !defined(WXDEBUG) || !WXDEBUG
#undef WXDEBUG #undef WXDEBUG
#define WXDEBUG 1 #define WXDEBUG 1
#endif /* !WXDEBUG */ #endif // !WXDEBUG
#endif /* __WXDEBUG__ */ #endif // __WXDEBUG__
#ifndef __WXFUNCTION__ #ifndef __WXFUNCTION__
/* TODO: add more compilers supporting __FUNCTION__ */ /* TODO: add more compilers supporting __FUNCTION__ */
#if defined(__DMC__) #if defined(__DMC__)
/* /*
__FUNCTION__ happens to be not defined within class members __FUNCTION__ happens to be not defined within class members
http://www.digitalmars.com/drn-bin/wwwnews?c%2B%2B.beta/485 http://www.digitalmars.com/drn-bin/wwwnews?c%2B%2B.beta/485
*/ */
@@ -67,30 +63,30 @@
#endif #endif
#endif /* __WXFUNCTION__ already defined */ #endif /* __WXFUNCTION__ already defined */
/* ---------------------------------------------------------------------------- */ // ----------------------------------------------------------------------------
/* Debugging macros */ // Debugging macros
/* */ //
/* All debugging macros rely on ASSERT() which in turn calls the user-defined */ // 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 */ // 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 */ // 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 */ // 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 */ // (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. */ // 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 */ // Warning: if you don't like advice on programming style, don't read
/* further! ;-) */ // further! ;-)
/* */ //
/* Extensive use of these macros is recommended! Remember that ASSERTs are */ // Extensive use of these macros is recommended! Remember that ASSERTs are
/* disabled in final build (without __WXDEBUG__ defined), so they add strictly */ // 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 */ // 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 */ // 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. */ // a judicious use of them might increase your program's stability.
/* ---------------------------------------------------------------------------- */ // ----------------------------------------------------------------------------
/* Macros which are completely disabled in 'release' mode */ // Macros which are completely disabled in 'release' mode
/* */ //
/* NB: these functions are implemented in src/common/appcmn.cpp */ // NB: these functions are implemented in src/common/appcmn.cpp
#if defined(__cplusplus) && defined(__WXDEBUG__) #if defined(__WXDEBUG__)
/* /*
This function is called whenever one of debugging macros fails (i.e. This function is called whenever one of debugging macros fails (i.e.
condition is false in an assertion). To customize its behaviour, override condition is false in an assertion). To customize its behaviour, override
@@ -162,47 +158,47 @@
const char *szCond, const char *szCond,
const wxString& szMsg); const wxString& szMsg);
/* call this function to break into the debugger unconditionally (assuming */ // call this function to break into the debugger unconditionally (assuming
/* the program is running under debugger, of course) */ // the program is running under debugger, of course)
extern void WXDLLIMPEXP_BASE wxTrap(); extern void WXDLLIMPEXP_BASE wxTrap();
/* generic assert macro */ // generic assert macro
#define wxASSERT(cond) wxASSERT_MSG(cond, (const char*)NULL) #define wxASSERT(cond) wxASSERT_MSG(cond, (const char*)NULL)
/* assert with additional message explaining its cause */ // assert with additional message explaining its cause
/* Note: some compilers will give a warning (such as */ // Note: some compilers will give a warning (such as
/* "possible unwanted ;") when using a ";" instead of the "{}". */ // "possible unwanted ;") when using a ";" instead of the "{}".
#define wxASSERT_MSG(cond, msg) \ #define wxASSERT_MSG(cond, msg) \
if ( cond ) \ if ( cond ) \
{} \ {} \
else \ else \
wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg) wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg)
/* special form of assert: always triggers it (in debug mode) */ // special form of assert: always triggers it (in debug mode)
#define wxFAIL wxFAIL_MSG((const char*)NULL) #define wxFAIL wxFAIL_MSG((const char*)NULL)
/* FAIL with some message */ // FAIL with some message
#define wxFAIL_MSG(msg) wxFAIL_COND_MSG("wxAssertFailure", msg) #define wxFAIL_MSG(msg) wxFAIL_COND_MSG("wxAssertFailure", msg)
/* FAIL with some message and a condition */ // FAIL with some message and a condition
#define wxFAIL_COND_MSG(cond, msg) \ #define wxFAIL_COND_MSG(cond, msg) \
wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, cond, msg) wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, cond, msg)
/* An assert helper used to avoid warning when testing constant expressions, */ // An assert helper used to avoid warning when testing constant expressions,
/* i.e. wxASSERT( sizeof(int) == 4 ) can generate a compiler warning about */ // i.e. wxASSERT( sizeof(int) == 4 ) can generate a compiler warning about
/* expression being always true, but not using */ // expression being always true, but not using
/* wxASSERT( wxAssertIsEqual(sizeof(int), 4) ) */ // wxASSERT( wxAssertIsEqual(sizeof(int), 4) )
/* */ //
/* NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and should no */ // NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and should no
/* longer be used. */ // longer be used.
extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y); extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y);
#else #else
#define wxTrap() #define wxTrap()
/* nothing to do in release mode (hopefully at this moment there are */ // nothing to do in release mode (hopefully at this moment there are
/* no more bugs ;-) */ // no more bugs ;-)
#define wxASSERT(cond) #define wxASSERT(cond)
#define wxASSERT_MSG(cond, msg) #define wxASSERT_MSG(cond, msg)
#define wxFAIL #define wxFAIL
@@ -210,15 +206,13 @@
#define wxFAIL_COND_MSG(cond, msg) #define wxFAIL_COND_MSG(cond, msg)
#endif /* __WXDEBUG__ */ #endif /* __WXDEBUG__ */
#ifdef __cplusplus // Use of wxFalse instead of false suppresses compiler warnings about testing
/* Use of wxFalse instead of false suppresses compiler warnings about testing */ // constant expression
/* constant expression */ extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
#endif
#define wxAssertFailure wxFalse #define wxAssertFailure wxFalse
/* NB: the following macros also work in release mode! */ // NB: the following macros also work in release mode!
/* /*
These macros must be used only in invalid situation: for example, an These macros must be used only in invalid situation: for example, an
@@ -227,16 +221,16 @@
CHECK( p != NULL ) or CHECK( p != NULL, return LogError("p is NULL!!") ) CHECK( p != NULL ) or CHECK( p != NULL, return LogError("p is NULL!!") )
*/ */
/* check that expression is true, "return" if not (also FAILs in debug mode) */ // check that expression is true, "return" if not (also FAILs in debug mode)
#define wxCHECK(cond, rc) wxCHECK_MSG(cond, rc, (const char*)NULL) #define wxCHECK(cond, rc) wxCHECK_MSG(cond, rc, (const char*)NULL)
/* as wxCHECK but with a message explaining why we fail */ // as wxCHECK but with a message explaining why we fail
#define wxCHECK_MSG(cond, rc, msg) wxCHECK2_MSG(cond, return rc, msg) #define wxCHECK_MSG(cond, rc, msg) wxCHECK2_MSG(cond, return rc, msg)
/* check that expression is true, perform op if not */ // check that expression is true, perform op if not
#define wxCHECK2(cond, op) wxCHECK2_MSG(cond, op, (const char*)NULL) #define wxCHECK2(cond, op) wxCHECK2_MSG(cond, op, (const char*)NULL)
/* as wxCHECK2 but with a message explaining why we fail */ // as wxCHECK2 but with a message explaining why we fail
#define wxCHECK2_MSG(cond, op, msg) \ #define wxCHECK2_MSG(cond, op, msg) \
if ( cond ) \ if ( cond ) \
@@ -248,24 +242,24 @@
} \ } \
struct wxDummyCheckStruct /* just to force a semicolon */ struct wxDummyCheckStruct /* just to force a semicolon */
/* special form of wxCHECK2: as wxCHECK, but for use in void functions */ // special form of wxCHECK2: as wxCHECK, but for use in void functions
/* */ //
/* NB: there is only one form (with msg parameter) and it's intentional: */ // NB: there is only one form (with msg parameter) and it's intentional:
/* there is no other way to tell the caller what exactly went wrong */ // 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 */ // from the void function (of course, the function shouldn't be void
/* to begin with...) */ // to begin with...)
#define wxCHECK_RET(cond, msg) wxCHECK2_MSG(cond, return, msg) #define wxCHECK_RET(cond, msg) wxCHECK2_MSG(cond, return, msg)
/* ---------------------------------------------------------------------------- */ // ----------------------------------------------------------------------------
/* Compile time asserts */ // Compile time asserts
/* */ //
/* Unlike the normal assert and related macros above which are checked during */ // Unlike the normal assert and related macros above which are checked during
/* the program tun-time the macros below will result in a compilation error if */ // the program 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 */ // the condition they check is false. This is usually used to check the
/* expressions containing sizeof()s which cannot be tested with the */ // expressions containing sizeof()s which cannot be tested with the
/* preprocessor. If you can use the #if's, do use them as you can give a more */ // preprocessor. If you can use the #if's, do use them as you can give a more
/* detailed error message then. */ // detailed error message then.
/* ---------------------------------------------------------------------------- */ // ----------------------------------------------------------------------------
/* /*
How this works (you don't have to understand it to be able to use the How this works (you don't have to understand it to be able to use the
@@ -287,7 +281,7 @@
It may be used both within a function and in the global scope. 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 */ /* avoid "unused symbol" warning */
#define wxCOMPILE_TIME_ASSERT(expr, msg) \ #define wxCOMPILE_TIME_ASSERT(expr, msg) \
class wxMAKE_UNIQUE_ASSERT_NAME { \ class wxMAKE_UNIQUE_ASSERT_NAME { \
@@ -309,18 +303,18 @@
#define wxCOMPILE_TIME_ASSERT2(expr, msg, text) \ #define wxCOMPILE_TIME_ASSERT2(expr, msg, text) \
struct wxMAKE_UNIQUE_ASSERT_NAME2(text) { unsigned int msg: expr; } 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 #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 */ // a special case of compile time assert: check that the size of the given type
/* is at least the given number of bits */ // is at least the given number of bits
#define wxASSERT_MIN_BITSIZE(type, size) \ #define wxASSERT_MIN_BITSIZE(type, size) \
wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \ wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \
wxMAKE_BITSIZE_MSG(type, size)) wxMAKE_BITSIZE_MSG(type, size))
/* ---------------------------------------------------------------------------- */ // ----------------------------------------------------------------------------
/* other miscellaneous debugger-related functions */ // other miscellaneous debugger-related functions
/* ---------------------------------------------------------------------------- */ // ----------------------------------------------------------------------------
/* /*
Return true if we're running under debugger. Return true if we're running under debugger.
@@ -328,13 +322,10 @@
Currently this only really works under Win32 and Mac in CodeWarrior builds, Currently this only really works under Win32 and Mac in CodeWarrior builds,
it always returns false in other cases. it always returns false in other cases.
*/ */
#ifdef __cplusplus #if defined(__WXMAC__) || defined(__WIN32__)
/* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */ extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning();
#if defined(__WXMAC__) || defined(__WIN32__) #else // !Mac
extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning(); inline bool wxIsDebuggerRunning() { return false; }
#else /* !Mac */ #endif // Mac/!Mac
inline bool wxIsDebuggerRunning() { return false; }
#endif /* Mac/!Mac */
#endif /* __cplusplus */
#endif /* _WX_DEBUG_H_ */ #endif // _WX_DEBUG_H_

7
include/wx/defs.h
View File

@@ -541,9 +541,6 @@ typedef short int WXTYPE;
wxDEPRECATED(func) { body } wxDEPRECATED(func) { body }
#endif #endif
/* everybody gets the assert and other debug macros */
#include "wx/debug.h"
/* NULL declaration: it must be defined as 0 for C++ programs (in particular, */ /* NULL declaration: it must be defined as 0 for C++ programs (in particular, */
/* it must not be defined as "(void *)0" which is standard for C but completely */ /* it must not be defined as "(void *)0" which is standard for C but completely */
/* breaks C++ code) */ /* breaks C++ code) */
@@ -552,6 +549,10 @@ typedef short int WXTYPE;
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
// everybody gets the assert and other debug macros
#include "wx/debug.h"
// delete pointer if it is not NULL and NULL it afterwards // delete pointer if it is not NULL and NULL it afterwards
template <typename T> template <typename T>
inline void wxDELETE(T*& ptr) inline void wxDELETE(T*& ptr)