+ wxOnAssert() is used by the debugging macros defined below. Different
+ overloads are needed because these macros can be used with or without _T().
+
+ 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
+
+// these overloads are the ones typically used by debugging macros: we have to
+// provide wxChar* msg version because it's common to use _T() 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 void WXDLLIMPEXP_BASE wxOnAssert(const char *file,
+ int line,
+ const char *func,
+ const char *cond);
+
+extern void WXDLLIMPEXP_BASE wxOnAssert(const char *file,
+ int line,
+ const char *func,
+ const char *cond,
+ const char *msg);
+
+extern void WXDLLIMPEXP_BASE 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 void WXDLLIMPEXP_BASE 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 void WXDLLIMPEXP_BASE wxOnAssert(const wxString& file,
+ int line,
+ const wxString& func,
+ const wxString& cond,
+ const wxString& msg);
+
+extern void WXDLLIMPEXP_BASE wxOnAssert(const wxString& file,
+ int line,
+ const wxString& func,
+ const wxString& cond);
+
+extern void WXDLLIMPEXP_BASE wxOnAssert(const char *file,
+ int line,
+ const char *func,
+ const char *cond,
+ const wxCStrData& msg);
+
+extern void WXDLLIMPEXP_BASE wxOnAssert(const char *file,
+ int line,
+ const char *func,
+ const char *cond,
+ const wxString& msg);
+
+#endif // wxDEBUG_LEVEL
+
+
+// ----------------------------------------------------------------------------
+// Debugging macros
+// ----------------------------------------------------------------------------
+
+/*
+ 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.
+
+ 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
+ // call this function to break into the debugger unconditionally (assuming
+ // the program is running under debugger, of course)
+ extern void WXDLLIMPEXP_BASE wxTrap();
+
+ // assert checks if the condition is true and calls the assert handler with
+ // the provided message if it isn't
+ //
+ // NB: the macro is defined like this to ensure that nested if/else
+ // statements containing it are compiled in the same way whether it is
+ // defined as empty or not; also notice that we can't use ";" instead
+ // of "{}" as some compilers warn about "possible unwanted ;" then
+ #define wxASSERT_MSG(cond, msg) \
+ if ( !wxTheAssertHandler || (cond) ) \
+ {} \
+ else \
+ wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, #cond, msg)
+
+ // 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) \
+ if ( !wxTheAssertHandler ) \
+ {} \
+ else \
+ wxOnAssert(__FILE__, __LINE__, __WXFUNCTION__, cond, msg)
+ #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
+
+
+/*
+ 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" )
projects / wxWidgets.git / blobdiff