LEMON/LEMON-main Changeset - r277:7abfb55f1ecc

Repositories » LEMON » LEMON-main

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r277:7abfb55f1ecc

« 276:b4784a

280:e7f864 »
279:6307bb »

r277:7abfb55f1ecc

Mon, 22 Sep 2008 10:56:01

[Not Reviewed]

0 comments (0 inline)

deba@inf.elte.hu
deba@inf.elte.hu

Removing fixme an log assert handler from assertion system

0 2 0

default

2 files changed with 18 insertions and 67 deletions:

lemon/assert.h

test/error_test.cc

↑ Collapse diff ↑

lemon/assert.h

Show inline comments

@@ -14,91 +14,79 @@
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#ifndef LEMON_ASSERT_H
 		#define LEMON_ASSERT_H
 		/// \ingroup exceptions
 		/// \file
 		/// \brief Extended assertion handling
 		#include <lemon/error.h>
 		namespace lemon {
 		  inline void assert_fail_log(const char *file, int line, const char *function,
 		                              const char *message, const char *assertion)
 		  inline void assert_fail_abort(const char *file, int line,
 		                                const char *function, const char* message,
 		                                const char *assertion)
+		  {
 		    std::cerr << file << ":" << line << ": ";
 		    if (function)
 		      std::cerr << function << ": ";
 		    std::cerr << message;
 		    if (assertion)
 		      std::cerr << " (assertion '" << assertion << "' failed)";
 		    std::cerr << std::endl;
+		  }
 		  inline void assert_fail_abort(const char *file, int line,
 		                                const char *function, const char* message,
 		                                const char *assertion)
+		  {
 		    assert_fail_log(file, line, function, message, assertion);
 		    std::abort();
+		  }
 		  namespace _assert_bits {
 		    inline const char* cstringify(const std::string& str) {
 		      return str.c_str();
+		    }
 		    inline const char* cstringify(const char* str) {
 		      return str;
+		    }
+		  }
+		}
 		#endif // LEMON_ASSERT_H
 		#undef LEMON_ASSERT
 		#undef LEMON_FIXME
 		#undef LEMON_DEBUG
 		#if (defined(LEMON_ASSERT_LOG) ? 1 : 0) +               \
 		  (defined(LEMON_ASSERT_ABORT) ? 1 : 0) +               \
 		#if (defined(LEMON_ASSERT_ABORT) ? 1 : 0) +               \
 		  (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) > 1
 		#error "LEMON assertion system is not set properly"
 		#endif
 		#if ((defined(LEMON_ASSERT_LOG) ? 1 : 0) +              \
 		     (defined(LEMON_ASSERT_ABORT) ? 1 : 0) +            \
 		#if ((defined(LEMON_ASSERT_ABORT) ? 1 : 0) +            \
 		     (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) == 1 ||     \
 		     defined(LEMON_ENABLE_ASSERTS)) &&                  \
 		  (defined(LEMON_DISABLE_ASSERTS) ||                    \
 		   defined(NDEBUG))
 		#error "LEMON assertion system is not set properly"
 		#endif
 		#if defined LEMON_ASSERT_LOG
 		#  undef LEMON_ASSERT_HANDLER
 		#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_log
 		#elif defined LEMON_ASSERT_ABORT
 		#if defined LEMON_ASSERT_ABORT
 		#  undef LEMON_ASSERT_HANDLER
 		#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_abort
 		#elif defined LEMON_ASSERT_CUSTOM
 		#  undef LEMON_ASSERT_HANDLER
 		#  ifndef LEMON_CUSTOM_ASSERT_HANDLER
 		#    error "LEMON_CUSTOM_ASSERT_HANDLER is not set"
 		#  endif
 		#  define LEMON_ASSERT_HANDLER LEMON_CUSTOM_ASSERT_HANDLER
 		#elif defined LEMON_DISABLE_ASSERTS
 		#  undef LEMON_ASSERT_HANDLER
 		#elif defined NDEBUG
 		#  undef LEMON_ASSERT_HANDLER
 		#else
 		#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_abort
 		#endif
@@ -107,147 +95,120 @@
 		#    define LEMON_FUNCTION_NAME (__PRETTY_FUNCTION__)
 		#  elif defined _MSC_VER
 		#    define LEMON_FUNCTION_NAME (__FUNCSIG__)
 		#  elif __STDC_VERSION__ >= 199901L
 		#    define LEMON_FUNCTION_NAME (__func__)
 		#  else
 		#    define LEMON_FUNCTION_NAME ("<unknown>")
 		#  endif
 		#endif
 		#ifdef DOXYGEN
 		/// \ingroup exceptions
 		///
 		/// \brief Macro for assertion with customizable message
 		///
 		/// Macro for assertion with customizable message.  \param exp An
 		/// expression that must be convertible to \c bool.  If it is \c
 		/// false, then an assertion is raised. The concrete behaviour depends
 		/// on the settings of the assertion system.  \param msg A <tt>const
 		/// char*</tt> parameter, which can be used to provide information
 		/// about the circumstances of the failed assertion.
 		/// Macro for assertion with customizable message.
 		/// \param exp An expression that must be convertible to \c bool.  If it is \c
 		/// false, then an assertion is raised. The concrete behaviour depends on the
 		/// settings of the assertion system.
 		/// \param msg A <tt>const char*</tt> parameter, which can be used to provide
 		/// information about the circumstances of the failed assertion.
 		///
 		/// The assertions are enabled in the default behaviour.
 		/// You can disable them with the following code:
 		/// \code
 		/// #define LEMON_DISABLE_ASSERTS
 		/// \endcode
 		/// or with compilation parameters:
 		/// \code
 		/// g++ -DLEMON_DISABLE_ASSERTS
 		/// make CXXFLAGS='-DLEMON_DISABLE_ASSERTS'
 		/// \endcode
 		/// The checking is also disabled when the standard macro \c NDEBUG is defined.
 		///
 		/// The LEMON assertion system has a wide range of customization
 		/// properties. As a default behaviour the failed assertion prints a
-		/// short log message to the standard error and aborts the execution.
+		/// As a default behaviour the failed assertion prints a short log message to
 		/// the standard error and aborts the execution.
 		///
 		/// The following modes can be used in the assertion system:
 		///
 		/// - \c LEMON_ASSERT_LOG The failed assertion prints a short log
 		///   message to the standard error and continues the execution.
 		/// - \c LEMON_ASSERT_ABORT This mode is similar to the \c
 		///   LEMON_ASSERT_LOG, but it aborts the program. It is the default
-		///   behaviour.
+		/// However, the following modes can be used in the assertion system:
 		/// - \c LEMON_ASSERT_ABORT The failed assertion prints a short log message to
 		///   the standard error and aborts the program. It is the default behaviour.
 		/// - \c LEMON_ASSERT_CUSTOM The user can define own assertion handler
 		///   function.
 		///   \code
 		///     void custom_assert_handler(const char* file, int line,
 		///                                const char* function, const char* message,
 		///                                const char* assertion);
 		///   \endcode
 		///   The name of the function should be defined as the \c
 		///   LEMON_CUSTOM_ASSERT_HANDLER macro name.
 		///   \code
 		///     #define LEMON_CUSTOM_ASSERT_HANDLER custom_assert_handler
 		///   \endcode
 		///   Whenever an assertion is occured, the custom assertion
 		///   handler is called with appropiate parameters.
 		///
 		/// The assertion mode can also be changed within one compilation unit.
 		/// If the macros are redefined with other settings and the
 		/// \ref lemon/assert.h "assert.h" file is reincluded, then the
 		/// behaviour is changed appropiately to the new settings.
 		#  define LEMON_ASSERT(exp, msg)                                        \
 		  (static_cast<void> (!!(exp) ? 0 : (                                   \
 		    LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                            \
 		                         LEMON_FUNCTION_NAME,                           \
 		                         ::lemon::_assert_bits::cstringify(msg), #exp), 0)))
 		/// \ingroup exceptions
 		///
 		/// \brief Macro for mark not yet implemented features.
 		///
 		/// Macro for mark not yet implemented features and outstanding bugs.
 		/// It is close to be the shortcut of the following code:
 		/// \code
 		///   LEMON_ASSERT(false, msg);
 		/// \endcode
 		///
 		/// \see LEMON_ASSERT
 		#  define LEMON_FIXME(msg)                                              \
 		  (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,        \
 		                        ::lemon::_assert_bits::cstringify(msg),         \
 		                        static_cast<const char*>(0)))
 		/// \ingroup exceptions
 		///
 		/// \brief Macro for internal assertions
 		///
 		/// Macro for internal assertions, it is used in the library to check
 		/// the consistency of results of algorithms, several pre- and
 		/// postconditions and invariants. The checking is disabled by
 		/// default, but it can be turned on with the macro \c
 		/// LEMON_ENABLE_DEBUG.
 		/// \code
 		/// #define LEMON_ENABLE_DEBUG
 		/// \endcode
 		/// or with compilation parameters:
 		/// \code
 		/// g++ -DLEMON_ENABLE_DEBUG
 		/// make CXXFLAGS='-DLEMON_ENABLE_DEBUG'
 		/// \endcode
 		///
 		/// This macro works like the \c LEMON_ASSERT macro, therefore the
 		/// current behaviour depends on the settings of \c LEMON_ASSERT
 		/// macro.
 		///
 		/// \see LEMON_ASSERT
 		#  define LEMON_DEBUG(exp, msg)                                         \
 		  (static_cast<void> (!!(exp) ? 0 : (                                   \
 		    LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                            \
 		                         LEMON_FUNCTION_NAME,                           \
 		                         ::lemon::_assert_bits::cstringify(msg), #exp), 0)))
 		#else
 		#  ifndef LEMON_ASSERT_HANDLER
 		#    define LEMON_ASSERT(exp, msg)  (static_cast<void>(0))
 		#    define LEMON_FIXME(msg) (static_cast<void>(0))
 		#    define LEMON_DEBUG(exp, msg) (static_cast<void>(0))
 		#  else
 		#    define LEMON_ASSERT(exp, msg)                                      \
 		       (static_cast<void> (!!(exp) ? 0 : (                              \
 		        LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                        \
 		                             LEMON_FUNCTION_NAME,                       \
 		                             ::lemon::_assert_bits::cstringify(msg),    \
 		                             #exp), 0)))
 		#    define LEMON_FIXME(msg)                                            \
 		       (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,   \
 		                             ::lemon::_assert_bits::cstringify(msg),    \
 		                             static_cast<const char*>(0)))
 		#    if LEMON_ENABLE_DEBUG
 		#      define LEMON_DEBUG(exp, msg)                                     \
 		         (static_cast<void> (!!(exp) ? 0 : (                            \
 		           LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                     \
 		                                LEMON_FUNCTION_NAME,                    \
 		                                ::lemon::_assert_bits::cstringify(msg), \
 		                                #exp), 0)))
 		#    else
 		#      define LEMON_DEBUG(exp, msg) (static_cast<void>(0))
 		#    endif
 		#  endif
 		#endif

test/error_test.cc

Show inline comments

@@ -34,67 +34,57 @@
 		#ifdef NDEBUG
 		#undef NDEBUG
 		#endif
 		//checking disabled asserts
 		#define LEMON_DISABLE_ASSERTS
 		#include <lemon/assert.h>
 		void no_assertion_text_disable() {
 		  LEMON_ASSERT(true, "This is a fault message");
+		}
 		void assertion_text_disable() {
 		  LEMON_ASSERT(false, "This is a fault message");
+		}
 		void fixme_disable() {
 		  LEMON_FIXME("fixme_disable() is fixme!");
+		}
 		void check_assertion_disable() {
 		  no_assertion_text_disable();
 		  assertion_text_disable();
 		  fixme_disable();
+		}
 		#undef LEMON_DISABLE_ASSERTS
 		//checking custom assert handler
 		#define LEMON_ASSERT_CUSTOM
 		static int cnt = 0;
 		void my_assert_handler(const char*, int, const char*,
 		                       const char*, const char*) {
 		  ++cnt;
+		}
 		#define LEMON_CUSTOM_ASSERT_HANDLER my_assert_handler
 		#include <lemon/assert.h>
 		void no_assertion_text_custom() {
 		  LEMON_ASSERT(true, "This is a fault message");
+		}
 		void assertion_text_custom() {
 		  LEMON_ASSERT(false, "This is a fault message");
+		}
 		void fixme_custom() {
 		  LEMON_FIXME("fixme_custom() is fixme!");
+		}
 		void check_assertion_custom() {
 		  no_assertion_text_custom();
 		  assertion_text_custom();
 		  fixme_custom();
 		  check(cnt == 2, "The custom assert handler does not work");
 		  check(cnt == 1, "The custom assert handler does not work");
+		}
 		#undef LEMON_ASSERT_CUSTOM
 		int main() {
 		  check_assertion_disable();
 		  check_assertion_custom();
 		  return 0;
+		}

0 comments (0 inline)

RhodeCode

Login to your account