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 __WXWINCE__
	18	#include <assert.h>
	19	#endif
	20	#include <limits.h> /* for CHAR_BIT used below */
	21
	22	#include "wx/wxchar.h" /* for __TFILE__ and wxChar */
	23
	24	/* ---------------------------------------------------------------------------- */
	25	/* Defines controlling the debugging macros */
	26	/* ---------------------------------------------------------------------------- */
	27
	28	/* if _DEBUG is defined (MS VC++ and others use it in debug builds), define */
	29	/* __WXDEBUG__ too */
	30	#ifdef _DEBUG
	31	#ifndef __WXDEBUG__
	32	#define __WXDEBUG__
	33	#endif /* !__WXDEBUG__ */
	34	#endif /* _DEBUG */
	35
	36	/* if NDEBUG is defined (<assert.h> uses it), undef __WXDEBUG__ and WXDEBUG */
	37	#ifdef NDEBUG
	38	#undef __WXDEBUG__
	39	#undef WXDEBUG
	40	#endif /* NDEBUG */
	41
	42	/* if __WXDEBUG__ is defined, make sure that WXDEBUG is defined and >= 1 */
	43	#ifdef __WXDEBUG__
	44	#if !defined(WXDEBUG) \|\| !WXDEBUG
	45	#undef WXDEBUG
	46	#define WXDEBUG 1
	47	#endif /* !WXDEBUG */
	48	#endif /* __WXDEBUG__ */
	49
	50	/* ---------------------------------------------------------------------------- */
	51	/* Debugging macros */
	52	/* */
	53	/* All debugging macros rely on ASSERT() which in turn calls user-defined */
	54	/* OnAssert() function. To keep things simple, it's called even when the */
	55	/* expression is true (i.e. everything is ok) and by default does nothing: just */
	56	/* returns the same value back. But if you redefine it to do something more sexy */
	57	/* (popping up a message box in your favourite GUI, sending you e-mail or */
	58	/* whatever) it will affect all ASSERTs, FAILs and CHECKs in your code. */
	59	/* */
	60	/* Warning: if you don't like advice on programming style, don't read */
	61	/* further! ;-) */
	62	/* */
	63	/* Extensive use of these macros is recommended! Remember that ASSERTs are */
	64	/* disabled in final build (without __WXDEBUG__ defined), so they add strictly */
	65	/* nothing to your program's code. On the other hand, CHECK macros do stay */
	66	/* even in release builds, but in general are not much of a burden, while */
	67	/* a judicious use of them might increase your program's stability. */
	68	/* ---------------------------------------------------------------------------- */
	69
	70	/* Macros which are completely disabled in 'release' mode */
	71	/* */
	72	/* NB: these functions are implemented in src/common/appcmn.cpp */
	73	#if defined(__cplusplus) && defined(__WXDEBUG__)
	74	/*
	75	this function may be redefined to do something non trivial and is called
	76	whenever one of debugging macros fails (i.e. condition is false in an
	77	assertion)
	78
	79	parameters:
	80	szFile and nLine - file name and line number of the ASSERT
	81	szMsg - optional message explaining the reason
	82	*/
	83	extern void WXDLLIMPEXP_BASE wxOnAssert(const wxChar *szFile,
	84	int nLine,
	85	const wxChar *szCond,
	86	const wxChar *szMsg = NULL);
	87
	88	/* call this function to break into the debugger unconditionally (assuming */
	89	/* the program is running under debugger, of course) */
	90	extern void WXDLLIMPEXP_BASE wxTrap();
	91
	92	/* helper function used to implement wxASSERT and wxASSERT_MSG */
	93	/* */
	94	/* note using "int" and not "bool" for cond to avoid VC++ warnings about */
	95	/* implicit conversions when doing "wxAssert( pointer )" and also use of */
	96	/* "!!cond" below to ensure that everything is converted to int */
	97	extern void WXDLLIMPEXP_BASE wxAssert(int cond,
	98	const wxChar *szFile,
	99	int nLine,
	100	const wxChar *szCond,
	101	const wxChar *szMsg = NULL) ;
	102
	103	/* generic assert macro */
	104	#define wxASSERT(cond) wxAssert(!!(cond), __TFILE__, __LINE__, _T(#cond))
	105
	106	/* assert with additional message explaining it's cause */
	107	#define wxASSERT_MSG(cond, msg) \
	108	wxAssert(!!(cond), __TFILE__, __LINE__, _T(#cond), msg)
	109
	110	/* an assert helper used to avoid warning when testing constant expressions, */
	111	/* i.e. wxASSERT( sizeof(int) == 4 ) can generate a compiler warning about */
	112	/* expression being always true, but not using */
	113	/* wxASSERT( wxAssertIsEqual(sizeof(int), 4) ) */
	114	/* */
	115	/* NB: this is made obsolete by wxCOMPILE_TIME_ASSERT() and shouldn't be */
	116	/* used any longer */
	117	extern bool WXDLLIMPEXP_BASE wxAssertIsEqual(int x, int y);
	118	#else
	119	#define wxTrap()
	120
	121	/* nothing to do in release modes (hopefully at this moment there are */
	122	/* no more bugs ;-) */
	123	#define wxASSERT(cond)
	124	#define wxASSERT_MSG(x, m)
	125	#endif /* __WXDEBUG__ */
	126
	127	#ifdef __cplusplus
	128	/* Use of wxFalse instead of false suppresses compiler warnings about testing */
	129	/* constant expression */
	130	WXDLLIMPEXP_DATA_BASE(extern const bool) wxFalse;
	131	#endif
	132
	133	#define wxAssertFailure wxFalse
	134
	135	/* special form of assert: always triggers it (in debug mode) */
	136	#define wxFAIL wxASSERT(wxAssertFailure)
	137
	138	/* FAIL with some message */
	139	#define wxFAIL_MSG(msg) wxASSERT_MSG(wxAssertFailure, msg)
	140
	141	/* NB: the following macros work also in release mode! */
	142
	143	/*
	144	These macros must be used only in invalid situation: for example, an
	145	invalid parameter (NULL pointer) is passed to a function. Instead of
	146	dereferencing it and causing core dump the function might try using
	147	CHECK( p != NULL ) or CHECK( p != NULL, return LogError("p is NULL!!") )
	148	*/
	149
	150	/* check that expression is true, "return" if not (also FAILs in debug mode) */
	151	#define wxCHECK(x, rc) if (!(x)) {wxFAIL; return rc; }
	152
	153	/* as wxCHECK but with a message explaining why we fail */
	154	#define wxCHECK_MSG(x, rc, msg) if (!(x)) {wxFAIL_MSG(msg); return rc; }
	155
	156	/* check that expression is true, perform op if not */
	157	#define wxCHECK2(x, op) if (!(x)) {wxFAIL; op; }
	158
	159	/* as wxCHECK2 but with a message explaining why we fail */
	160	#define wxCHECK2_MSG(x, op, msg) if (!(x)) {wxFAIL_MSG(msg); op; }
	161
	162	/* special form of wxCHECK2: as wxCHECK, but for use in void functions */
	163	/* */
	164	/* NB: there is only one form (with msg parameter) and it's intentional: */
	165	/* there is no other way to tell the caller what exactly went wrong */
	166	/* from the void function (of course, the function shouldn't be void */
	167	/* to begin with...) */
	168	#define wxCHECK_RET(x, msg) if (!(x)) {wxFAIL_MSG(msg); return; }
	169
	170	/* ---------------------------------------------------------------------------- */
	171	/* Compile time asserts */
	172	/* */
	173	/* Unlike the normal assert and related macros above which are checked during */
	174	/* the program tun-time the macros below will result in a compilation error if */
	175	/* the condition they check is false. This is usually used to check the */
	176	/* expressions containing sizeof()s which cannot be tested with the */
	177	/* preprocessor. If you can use the #if's, do use them as you can give a more */
	178	/* detailed error message then. */
	179	/* ---------------------------------------------------------------------------- */
	180
	181	/*
	182	How this works (you don't have to understand it to be able to use the
	183	macros): we rely on the fact that it is invalid to define a named bit field
	184	in a struct of width 0. All the rest are just the hacks to minimize the
	185	possibility of the compiler warnings when compiling this macro: in
	186	particular, this is why we define a struct and not an object (which would
	187	result in a warning about unused variable) and a named struct (otherwise we'd
	188	get a warning about an unnamed struct not used to define an object!).
	189	*/
	190
	191	#define wxMAKE_UNIQUE_ASSERT_NAME wxMAKE_UNIQUE_NAME(wxAssert_)
	192
	193	/*
	194	The second argument of this macro must be a valid C++ identifier and not a
	195	string. I.e. you should use it like this:
	196
	197	wxCOMPILE_TIME_ASSERT( sizeof(int) >= 2, YourIntsAreTooSmall );
	198
	199	It may be used both within a function and in the global scope.
	200	*/
	201	#define wxCOMPILE_TIME_ASSERT(expr, msg) \
	202	struct wxMAKE_UNIQUE_ASSERT_NAME { unsigned int msg: expr; }
	203
	204	/*
	205	When using VC++ 6 with "Edit and Continue" on, the compiler completely
	206	mishandles __LINE__ and so wxCOMPILE_TIME_ASSERT() doesn't work, provide a
	207	way to make "unique" assert names by specifying a unique prefix explicitly
	208	*/
	209	#define wxMAKE_UNIQUE_ASSERT_NAME2(text) wxCONCAT(wxAssert_, text)
	210
	211	#define wxCOMPILE_TIME_ASSERT2(expr, msg, text) \
	212	struct wxMAKE_UNIQUE_ASSERT_NAME2(text) { unsigned int msg: expr; }
	213
	214	/* helpers for wxCOMPILE_TIME_ASSERT below, for private use only */
	215	#define wxMAKE_BITSIZE_MSG(type, size) type ## SmallerThan ## size ## Bits
	216
	217	/* a special case of compile time assert: check that the size of the given type */
	218	/* is at least the given number of bits */
	219	#define wxASSERT_MIN_BITSIZE(type, size) \
	220	wxCOMPILE_TIME_ASSERT(sizeof(type) * CHAR_BIT >= size, \
	221	wxMAKE_BITSIZE_MSG(type, size))
	222
	223	/* ---------------------------------------------------------------------------- */
	224	/* other miscellaneous debugger-related functions */
	225	/* ---------------------------------------------------------------------------- */
	226
	227	/* return true if we're running under debugger */
	228	/* */
	229	/* currently this only really works under Mac in CodeWarrior builds, it always */
	230	/* returns false otherwise */
	231	#ifdef __cplusplus
	232	#ifdef __WXMAC__
	233	extern bool WXDLLIMPEXP_BASE wxIsDebuggerRunning();
	234	#else /* !Mac */
	235	inline bool wxIsDebuggerRunning() { return false; }
	236	#endif /* Mac/!Mac */
	237	#endif /* __cplusplus */
	238
	239	#endif /* _WX_DEBUG_H_ */
	240