git.saurik.com Git - wxWidgets.git/blame_incremental

... / ...

Commit	Line	Data
	1	/**
	2	* Name: wx/debug.h
	3	* Purpose: Misc debug functions and macros
	4	* Author: Vadim Zeitlin
	5	* Modified by: Ryan Norton (Converted to C)
	6	* Created: 29/01/98
	7	* RCS-ID: $Id$
	8	* Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	9	* Licence: wxWindows licence
	10	*/
	11
	12	/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
	13
	14	#ifndef _WX_DEBUG_H_
	15	#define _WX_DEBUG_H_
	16
	17	#ifndef __WXPALMOS5__
	18	#ifndef __WXWINCE__
	19	#include <assert.h>
	20	#endif
	21	#endif // ! __WXPALMOS5__
	22	#include <limits.h> /* for CHAR_BIT used below */
	23
	24	#include "wx/chartype.h" /* for __TFILE__ and wxChar */
	25
	26	/* ---------------------------------------------------------------------------- */
	27	/* Defines controlling the debugging macros */
	28	/* ---------------------------------------------------------------------------- */
	29
	30	/* if _DEBUG is defined (MS VC++ and others use it in debug builds), define */
	31	/* __WXDEBUG__ too */
	32	#ifdef _DEBUG
	33	#ifndef __WXDEBUG__
	34	#define __WXDEBUG__
	35	#endif /* !__WXDEBUG__ */
	36	#endif /* _DEBUG */
	37
	38	/* if NDEBUG is defined (<assert.h> uses it), undef __WXDEBUG__ and WXDEBUG */
	39	#ifdef NDEBUG
	40	#undef __WXDEBUG__
	41	#undef WXDEBUG
	42	#endif /* NDEBUG */
	43
	44	/* if __WXDEBUG__ is defined, make sure that WXDEBUG is defined and >= 1 */
	45	#ifdef __WXDEBUG__
	46	#if !defined(WXDEBUG) \|\| !WXDEBUG
	47	#undef WXDEBUG
	48	#define WXDEBUG 1
	49	#endif /* !WXDEBUG */
	50	#endif /* __WXDEBUG__ */
	51
	52	#ifndef __WXFUNCTION__
	53	/* TODO: add more compilers supporting __FUNCTION__ */
	54	#if defined(__DMC__)
	55	/*
	56	__FUNCTION__ happens to be not defined within class members
	57	http://www.digitalmars.com/drn-bin/wwwnews?c%2B%2B.beta/485
	58	*/
	59	#define __WXFUNCTION__ (NULL)
	60	#elif defined(__GNUC__) \|\| \
	61	(defined(_MSC_VER) && _MSC_VER >= 1300) \|\| \
	62	defined(__FUNCTION__)
	63	#define __WXFUNCTION__ __FUNCTION__
	64	#else
	65	/* still define __WXFUNCTION__ to avoid #ifdefs elsewhere */
	66	#define __WXFUNCTION__ (NULL)
	67	#endif
	68	#endif /* __WXFUNCTION__ already defined */
	69
	70	/* ---------------------------------------------------------------------------- */
	71	/* Debugging macros */
	72	/* */
	73	/* All debugging macros rely on ASSERT() which in turn calls the user-defined */
	74	/* OnAssert() function. To keep things simple, it's called even when the */
	75	/* expression is true (i.e. everything is ok) and by default does nothing: just */
	76	/* returns the same value back. But if you redefine it to do something more sexy */
	77	/* (popping up a message box in your favourite GUI, sending you e-mail or */
	78	/* whatever) it will affect all ASSERTs, FAILs and CHECKs in your code. */
	79	/* */
	80	/* Warning: if you don't like advice on programming style, don't read */
	81	/* further! ;-) */
	82	/* */
	83	/* Extensive use of these macros is recommended! Remember that ASSERTs are */
	84	/* disabled in final build (without __WXDEBUG__ defined), so they add strictly */
	85	/* nothing to your program's code. On the other hand, CHECK macros do stay */
	86	/* even in release builds, but in general are not much of a burden, while */
	87	/* a judicious use of them might increase your program's stability. */
	88	/* ---------------------------------------------------------------------------- */
	89
	90	/* Macros which are completely disabled in 'release' mode */
	91	/* */
	92	/* NB: these functions are implemented in src/common/appcmn.cpp */
	93	#if defined(__cplusplus) && defined(__WXDEBUG__)
	94	/*
	95	This function is called whenever one of debugging macros fails (i.e.
	96	condition is false in an assertion). To customize its behaviour, override
	97	wxApp::OnAssertFailure().
	98
	99	Parameters:
	100	szFile and nLine - file name and line number of the ASSERT
	101	szFunc - function name of the ASSERT, may be NULL (NB: ASCII)
	102	szCond - text form of the condition which failed
	103	szMsg - optional message explaining the reason
	104	*/
	105
	106	/* this version is for compatibility with wx 2.8 Unicode build only: */
	107	extern void WXDLLIMPEXP_BASE wxOnAssert(const wxChar *szFile,
	108	int nLine,
	109	const char *szFunc,
	110	const wxChar *szCond,
	111	const wxChar *szMsg = NULL);
	112
	113	#if wxUSE_UNICODE
	114	/* char versions are used by debugging macros; we have to provide
	115	wxChar* szMsg version because it's common to use _T() in the macros
	116	and finally, we can't use const wx(char)* szMsg = NULL, because that
	117	would be ambiguous: */
	118	extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
	119	int nLine,
	120	const char *szFunc,
	121	const char *szCond);
	122
	123	extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
	124	int nLine,
	125	const char *szFunc,
	126	const char *szCond,
	127	const char *szMsg);
	128
	129	extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
	130	int nLine,
	131	const char *szFunc,
	132	const char *szCond,
	133	const wxChar *szMsg);
	134	#endif /* wxUSE_UNICODE */
	135
	136	class WXDLLIMPEXP_FWD_BASE wxString;
	137	class WXDLLIMPEXP_FWD_BASE wxCStrData;
	138
	139	/* these two work when szMsg passed to debug macro is a string,
	140	we also have to provide wxCStrData overload to resolve ambiguity
	141	which would otherwise arise from wxASSERT( s.c_str() ): */
	142	extern void WXDLLIMPEXP_BASE wxOnAssert(const wxString& szFile,
	143	int nLine,
	144	const wxString& szFunc,
	145	const wxString& szCond,
	146	const wxString& szMsg);
	147
	148	extern void WXDLLIMPEXP_BASE wxOnAssert(const wxString& szFile,
	149	int nLine,
	150	const wxString& szFunc,
	151	const wxString& szCond);
	152
	153	extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
	154	int nLine,
	155	const char *szFunc,
	156	const char *szCond,
	157	const wxCStrData& msg);
	158
	159	extern void WXDLLIMPEXP_BASE wxOnAssert(const char *szFile,
	160	int nLine,
	161	const char *szFunc,
	162	const char *szCond,
	163	const wxString& szMsg);
	164
	165	/* call this function to break into the debugger unconditionally (assuming */
	166	/* the program is running under debugger, of course) */
	167	extern void WXDLLIMPEXP_BASE wxTrap();
	168
	169	/* generic assert macro */
	170	#define wxASSERT(cond) wxASSERT_MSG(cond, (const char*)NULL)
	171
	172
	173	/* assert with additional message explaining its cause */
	174
	175	/* Note: some compilers will give a warning (such as */
	176	/* "possible unwanted ;") when using a ";" instead of the "{}". */
	177	#define wxASSERT_MSG(cond, msg) \
	178	if ( cond ) \
	179	{} \
	180	else \
	181	wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg)
	182
	183	/* special form of assert: always triggers it (in debug mode) */
	184	#define wxFAIL wxFAIL_MSG((const char*)NULL)
	185
	186	/* FAIL with some message */
	187	#define wxFAIL_MSG(msg) wxFAIL_COND_MSG("wxAssertFailure", msg)
	188
	189	/* FAIL with some message and a condition */
	190	#define wxFAIL_COND_MSG(cond, msg) \
	191	wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, cond, msg)
	192
	193	/* An assert helper used to avoid warning when testing constant expressions, */
	194	/* i.e. wxASSERT( sizeof(int) == 4 ) can generate a compiler warning about */
	195	/* expression being always true, but not using */
	196	/* wxASSERT( wxAssertIsEqual(sizeof(int), 4) ) */
	197	/* */
	198	/* NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and should no */
	199	/* longer be used. */
	200	extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y);
	201	#else
	202	#define wxTrap()
	203
	204	/* nothing to do in release mode (hopefully at this moment there are */
	205	/* no more bugs ;-) */
	206	#define wxASSERT(cond)
	207	#define wxASSERT_MSG(cond, msg)
	208	#define wxFAIL
	209	#define wxFAIL_MSG(msg)
	210	#define wxFAIL_COND_MSG(cond, msg)
	211	#endif /* __WXDEBUG__ */
	212
	213	#ifdef __cplusplus
	214	/* Use of wxFalse instead of false suppresses compiler warnings about testing */
	215	/* constant expression */
	216	extern WXDLLIMPEXP_DATA_BASE(const bool) wxFalse;
	217	#endif
	218
	219	#define wxAssertFailure wxFalse
	220
	221	/* NB: the following macros also work in release mode! */
	222
	223	/*
	224	These macros must be used only in invalid situation: for example, an
	225	invalid parameter (e.g. a NULL pointer) is passed to a function. Instead of
	226	dereferencing it and causing core dump the function might try using
	227	CHECK( p != NULL ) or CHECK( p != NULL, return LogError("p is NULL!!") )
	228	*/
	229
	230	/* check that expression is true, "return" if not (also FAILs in debug mode) */
	231	#define wxCHECK(cond, rc) wxCHECK_MSG(cond, rc, (const char*)NULL)
	232
	233	/* as wxCHECK but with a message explaining why we fail */
	234	#define wxCHECK_MSG(cond, rc, msg) wxCHECK2_MSG(cond, return rc, msg)
	235
	236	/* check that expression is true, perform op if not */
	237	#define wxCHECK2(cond, op) wxCHECK2_MSG(cond, op, (const char*)NULL)
	238
	239	/* as wxCHECK2 but with a message explaining why we fail */
	240
	241	#define wxCHECK2_MSG(cond, op, msg) \
	242	if ( cond ) \
	243	{} \
	244	else \
	245	{ \
	246	wxFAIL_COND_MSG(#cond, msg); \
	247	op; \
	248	} \
	249	struct wxDummyCheckStruct /* just to force a semicolon */
	250
	251	/* special form of wxCHECK2: as wxCHECK, but for use in void functions */
	252	/* */
	253	/* NB: there is only one form (with msg parameter) and it's intentional: */
	254	/* there is no other way to tell the caller what exactly went wrong */
	255	/* from the void function (of course, the function shouldn't be void */
	256	/* to begin with...) */
	257	#define wxCHECK_RET(cond, msg) wxCHECK2_MSG(cond, return, msg)
	258
	259	/* ---------------------------------------------------------------------------- */
	260	/* Compile time asserts */
	261	/* */
	262	/* Unlike the normal assert and related macros above which are checked during */
	263	/* the program tun-time the macros below will result in a compilation error if */
	264	/* the condition they check is false. This is usually used to check the */
	265	/* expressions containing sizeof()s which cannot be tested with the */
	266	/* preprocessor. If you can use the #if's, do use them as you can give a more */
	267	/* detailed error message then. */
	268	/* ---------------------------------------------------------------------------- */
	269
	270	/*
	271	How this works (you don't have to understand it to be able to use the
	272	macros): we rely on the fact that it is invalid to define a named bit field
	273	in a struct of width 0. All the rest are just the hacks to minimize the
	274	possibility of the compiler warnings when compiling this macro: in
	275	particular, this is why we define a struct and not an object (which would
	276	result in a warning about unused variable) and a named struct (otherwise we'd
	277	get a warning about an unnamed struct not used to define an object!).
	278	*/
	279
	280	#define wxMAKE_UNIQUE_ASSERT_NAME wxMAKE_UNIQUE_NAME(wxAssert_)
	281
	282	/*
	283	The second argument of this macro must be a valid C++ identifier and not a
	284	string. I.e. you should use it like this:
	285
	286	wxCOMPILE_TIME_ASSERT( sizeof(int) >= 2, YourIntsAreTooSmall );
	287
	288	It may be used both within a function and in the global scope.
	289	*/
	290	#if defined(__WATCOMC__) && defined(__cplusplus)
	291	/* avoid "unused symbol" warning */
	292	#define wxCOMPILE_TIME_ASSERT(expr, msg) \
	293	class wxMAKE_UNIQUE_ASSERT_NAME { \
	294	unsigned int msg: expr; \
	295	wxMAKE_UNIQUE_ASSERT_NAME() { wxUnusedVar(msg); } \
	296	}
	297	#else
	298	#define wxCOMPILE_TIME_ASSERT(expr, msg) \
	299	struct wxMAKE_UNIQUE_ASSERT_NAME { unsigned int msg: expr; }
	300	#endif
	301
	302	/*
	303	When using VC++ 6 with "Edit and Continue" on, the compiler completely
	304	mishandles __LINE__ and so wxCOMPILE_TIME_ASSERT() doesn't work, provide a
	305	way to make "unique" assert names by specifying a unique prefix explicitly
	306	*/
	307	#define wxMAKE_UNIQUE_ASSERT_NAME2(text) wxCONCAT(wxAssert_, text)
	308
	309	#define wxCOMPILE_TIME_ASSERT2(expr, msg, text) \
	310	struct wxMAKE_UNIQUE_ASSERT_NAME2(text) { unsigned int msg: expr; }
	311
	312	/* helpers for wxCOMPILE_TIME_ASSERT below, for private use only */
	313	#define wxMAKE_BITSIZE_MSG(type, size) type ## SmallerThan ## size ## Bits
	314
	315	/* a special case of compile time assert: check that the size of the given type */
	316	/* is at least the given number of bits */
	317	#define wxASSERT_MIN_BITSIZE(type, size) \
	318	wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \
	319	wxMAKE_BITSIZE_MSG(type, size))
	320
	321	/* ---------------------------------------------------------------------------- */
	322	/* other miscellaneous debugger-related functions */
	323	/* ---------------------------------------------------------------------------- */
	324
	325	/*
	326	Return true if we're running under debugger.
	327
	328	Currently this only really works under Win32 and Mac in CodeWarrior builds,
	329	it always returns false in other cases.
	330	*/
	331	#ifdef __cplusplus
	332	/* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */
	333	#if defined(__WXMAC__) \|\| defined(__WIN32__)
	334	extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning();
	335	#else /* !Mac */
	336	inline bool wxIsDebuggerRunning() { return false; }
	337	#endif /* Mac/!Mac */
	338	#endif /* __cplusplus */
	339
	340	#endif /* _WX_DEBUG_H_ */