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

1.

Browse Source 
Converted debug.h to C

2.
Cosmetics


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@24896 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Ryan Norton
2003-12-17 19:51:03 +00:00
parent 5d61dafdfa
commit e0c749a72f
6 changed files with 151 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
include/wx/chkconf.h
View File

@@ -1,13 +1,13 @@
/* /**
* Name: wx/chkconf.h * Name: wx/chkconf.h
* Purpose: check the config settings for consistency * Purpose: check the config settings for consistency
* Author: Vadim Zeitlin * Author: Vadim Zeitlin
* Modified by: * Modified by:
* Created: 09.08.00 * Created: 09.08.00
* RCS-ID: $Id$ * RCS-ID: $Id$
* Copyright: (c) 2000 Vadim Zeitlin <vadim@wxwindows.org> * Copyright: (c) 2000 Vadim Zeitlin <vadim@wxwindows.org>
* Licence: wxWindows licence * Licence: wxWindows licence
*/ */
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */ /* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */

210
include/wx/debug.h
View File

@@ -1,13 +1,15 @@
///////////////////////////////////////////////////////////////////////////// /**
// 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: * Modified by: Ryan Norton (Converted to C)
// Created: 29/01/98 * Created: 29/01/98
// RCS-ID: $Id$ * RCS-ID: $Id$
// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr> * 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_ #ifndef _WX_DEBUG_H_
#define _WX_DEBUG_H_ #define _WX_DEBUG_H_
@@ -15,59 +17,59 @@
#ifndef __WXWINCE__ #ifndef __WXWINCE__
#include <assert.h> #include <assert.h>
#endif #endif
#include <limits.h> // for CHAR_BIT used below #include <limits.h> /* for CHAR_BIT used below */
#include "wx/wxchar.h" // for __TFILE__ and wxChar #include "wx/wxchar.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__ */
// ---------------------------------------------------------------------------- /* ---------------------------------------------------------------------------- */
// Debugging macros /* Debugging macros */
// /* */
// All debugging macros rely on ASSERT() which in turn calls user-defined /* All debugging macros rely on ASSERT() which in turn calls 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(__cplusplus) && defined(__WXDEBUG__)
/* /*
this function may be redefined to do something non trivial and is called this function may be redefined to do something non trivial and is called
@@ -83,60 +85,60 @@
const wxChar *szCond, const wxChar *szCond,
const wxChar *szMsg = NULL); const wxChar *szMsg = NULL);
// 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();
// helper function used to implement wxASSERT and wxASSERT_MSG /* helper function used to implement wxASSERT and wxASSERT_MSG */
// /* */
// note using "int" and not "bool" for cond to avoid VC++ warnings about /* note using "int" and not "bool" for cond to avoid VC++ warnings about */
// implicit conversions when doing "wxAssert( pointer )" and also use of /* implicit conversions when doing "wxAssert( pointer )" and also use of */
// "!!cond" below to ensure that everything is converted to int /* "!!cond" below to ensure that everything is converted to int */
extern void WXDLLIMPEXP_BASE wxAssert(int cond, extern void WXDLLIMPEXP_BASE wxAssert(int cond,
const wxChar *szFile, const wxChar *szFile,
int nLine, int nLine,
const wxChar *szCond, const wxChar *szCond,
const wxChar *szMsg = NULL) ; const wxChar *szMsg = NULL) ;
// generic assert macro /* generic assert macro */
#define wxASSERT(cond) wxAssert(!!(cond), __TFILE__, __LINE__, _T(#cond)) #define wxASSERT(cond) wxAssert(!!(cond), __TFILE__, __LINE__, _T(#cond))
// assert with additional message explaining it's cause /* assert with additional message explaining it's cause */
#define wxASSERT_MSG(cond, msg) \ #define wxASSERT_MSG(cond, msg) \
wxAssert(!!(cond), __TFILE__, __LINE__, _T(#cond), msg) wxAssert(!!(cond), __TFILE__, __LINE__, _T(#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 shouldn't be /* NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and shouldn't be */
// used any longer /* used any longer */
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 modes (hopefully at this moment there are /* nothing to do in release modes (hopefully at this moment there are */
// no more bugs ;-) /* no more bugs ;-) */
#define wxASSERT(cond) #define wxASSERT(cond)
#define wxASSERT_MSG(x, m) #define wxASSERT_MSG(x, m)
#endif //__WXDEBUG__ #endif /* __WXDEBUG__ */
#ifdef __cplusplus #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 */
WXDLLIMPEXP_DATA_BASE(extern const bool) wxFalse; WXDLLIMPEXP_DATA_BASE(extern const bool) wxFalse;
#endif #endif
#define wxAssertFailure wxFalse #define wxAssertFailure wxFalse
// special form of assert: always triggers it (in debug mode) /* special form of assert: always triggers it (in debug mode) */
#define wxFAIL wxASSERT(wxAssertFailure) #define wxFAIL wxASSERT(wxAssertFailure)
// FAIL with some message /* FAIL with some message */
#define wxFAIL_MSG(msg) wxASSERT_MSG(wxAssertFailure, msg) #define wxFAIL_MSG(msg) wxASSERT_MSG(wxAssertFailure, msg)
// NB: the following macros work also in release mode! /* NB: the following macros work also 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
@@ -145,36 +147,36 @@
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(x, rc) if (!(x)) {wxFAIL; return rc; } #define wxCHECK(x, rc) if (!(x)) {wxFAIL; return rc; }
// as wxCHECK but with a message explaining why we fail /* as wxCHECK but with a message explaining why we fail */
#define wxCHECK_MSG(x, rc, msg) if (!(x)) {wxFAIL_MSG(msg); return rc; } #define wxCHECK_MSG(x, rc, msg) if (!(x)) {wxFAIL_MSG(msg); return rc; }
// check that expression is true, perform op if not /* check that expression is true, perform op if not */
#define wxCHECK2(x, op) if (!(x)) {wxFAIL; op; } #define wxCHECK2(x, op) if (!(x)) {wxFAIL; op; }
// as wxCHECK2 but with a message explaining why we fail /* as wxCHECK2 but with a message explaining why we fail */
#define wxCHECK2_MSG(x, op, msg) if (!(x)) {wxFAIL_MSG(msg); op; } #define wxCHECK2_MSG(x, op, msg) if (!(x)) {wxFAIL_MSG(msg); op; }
// 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(x, msg) if (!(x)) {wxFAIL_MSG(msg); return; } #define wxCHECK_RET(x, msg) if (!(x)) {wxFAIL_MSG(msg); return; }
// ---------------------------------------------------------------------------- /* ---------------------------------------------------------------------------- */
// 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
@@ -209,30 +211,30 @@
#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 */
// /* */
// currently this only really works under Mac in CodeWarrior builds, it always /* currently this only really works under Mac in CodeWarrior builds, it always */
// returns false otherwise /* returns false otherwise */
#ifdef __cplusplus #ifdef __cplusplus
#ifdef __WXMAC__ #ifdef __WXMAC__
extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning(); extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning();
#else // !Mac #else /* !Mac */
inline bool wxIsDebuggerRunning() { return false; } inline bool wxIsDebuggerRunning() { return false; }
#endif // Mac/!Mac #endif /* Mac/!Mac */
#endif //__cplusplus #endif /* __cplusplus */
#endif // _WX_DEBUG_H_ #endif /* _WX_DEBUG_H_ */

22
include/wx/features.h
View File

@@ -1,14 +1,14 @@
/* /////////////////////////////////////////////////////////////////////////// */ /**
/* Name: wx/features.h */ * Name: wx/features.h
/* Purpose: test macros for the features which might be available in some */ * Purpose: test macros for the features which might be available in some
/* wxWindows ports but not others */ * wxWindows ports but not others
/* Author: Vadim Zeitlin */ * Author: Vadim Zeitlin
/* Modified by: */ * Modified by: Ryan Norton (Converted to C)
/* Created: 18.03.02 */ * Created: 18.03.02
/* RCS-ID: $Id$ */ * RCS-ID: $Id$
/* Copyright: (c) 2002 Vadim Zeitlin <vadim@wxwindows.org> */ * Copyright: (c) 2002 Vadim Zeitlin <vadim@wxwindows.org>
/* Licence: wxWindows licence */ * Licence: wxWindows licence
/* /////////////////////////////////////////////////////////////////////////// */ */
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */ /* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */

20
include/wx/platform.h
View File

@@ -1,13 +1,13 @@
/* /**
* Name: wx/platform.h * Name: wx/platform.h
* Purpose: define the OS and compiler identification macros * Purpose: define the OS and compiler identification macros
* Author: Vadim Zeitlin * Author: Vadim Zeitlin
* Modified by: * Modified by:
* Created: 29.10.01 (extracted from wx/defs.h) * Created: 29.10.01 (extracted from wx/defs.h)
* RCS-ID: $Id$ * RCS-ID: $Id$
* Copyright: (c) 1997-2001 wxWindows team * Copyright: (c) 1997-2001 wxWindows team
* Licence: wxWindows licence * Licence: wxWindows licence
*/ */
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */ /* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */

20
include/wx/version.h
View File

@@ -1,13 +1,13 @@
/* /////////////////////////////////////////////////////////////////////////// */ /**
/* Name: wx/version.h */ * Name: wx/version.h
/* Purpose: wxWindows version numbers */ * Purpose: wxWindows version numbers
/* Author: Julian Smart */ * Author: Julian Smart
/* Modified by: */ * Modified by: Ryan Norton (Converted to C)
/* Created: 29/01/98 */ * Created: 29/01/98
/* RCS-ID: $Id$ */ * RCS-ID: $Id$
/* Copyright: (c) 1998 Julian Smart */ * Copyright: (c) 1998 Julian Smart
/* Licence: wxWindows licence */ * Licence: wxWindows licence
/* /////////////////////////////////////////////////////////////////////////// */ */
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */ /* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */

8
src/wxWindows.dsp
View File

@@ -1935,10 +1935,6 @@ SOURCE=..\include\wx\dde.h
# End Source File # End Source File
# Begin Source File # Begin Source File
SOURCE=..\include\wx\debug.h
# End Source File
# Begin Source File
SOURCE=..\include\wx\dialog.h SOURCE=..\include\wx\dialog.h
# End Source File # End Source File
# Begin Source File # Begin Source File
@@ -3411,6 +3407,10 @@ SOURCE=..\include\wx\chkconf.h
# End Source File # End Source File
# Begin Source File # Begin Source File
SOURCE=..\include\wx\debug.h
# End Source File
# Begin Source File
SOURCE=..\include\wx\defs.h SOURCE=..\include\wx\defs.h
# End Source File # End Source File
# Begin Source File # Begin Source File