Ticket #28: assert_rework.hg

# HG changeset patch
# User Balazs Dezso <deba@inf.elte.hu>
# Date 1207923654 -7200
# Node ID 407c08a0eae9616db100ccdda51e1babde3ce3a8
# Parent  7b0ce9fb1169c533d2859b8d48bf8586d16fbc91
Exception related solutions removed and new LEMON_DEBUG macro

diff -r 7b0ce9fb1169 -r 407c08a0eae9 lemon/assert.h
--- a/lemon/assert.h    Wed Apr 09 17:19:40 2008 +0100
+++ b/lemon/assert.h    Fri Apr 11 16:20:54 2008 +0200
@@ -27,71 +27,6 @@
 
 namespace lemon {
 
-  /// @{
-
-  ///\e
-  class AssertionFailedError : public LogicError {
-  protected:
-    const char *_assertion;
-    const char *_file;
-    int _line;
-    const char *_function;
-    const char *_message;
-
-    mutable ExceptionMember<std::string> _message_holder;
-  public:
-    ///\e
-    AssertionFailedError(const char *file, int line, const char *function,
-                        const char *msg, const char *assertion = 0) :
-      _assertion(assertion), _file(file), _line(line), 
-      _function(function), _message(msg) {}
-
-    ///\e
-    const char* assertion() const { return _assertion; }
-    ///\e
-    const char* message() const { return _message; }
-    ///\e
-    const char* file() const { return _file; }
-    ///\e
-    const char* function() const { return _function; }
-    ///\e
-    int line() const { return _line; }
-
-
-    virtual const char* what() const throw() {
-      try {
-       std::ostringstream ostr;
-       ostr << _file << ":" << _line << ": ";
-       if (_function)
-         ostr << _function << ": ";
-       ostr << _message;
-       if (_assertion)
-          ostr << " (assertion '" << _assertion << "' failed)";
-       _message_holder.set(ostr.str());
-       return ostr.str().c_str();
-      }
-      catch(...) {}
-      if( _message_holder.valid() ) return _message_holder.get().c_str();
-      return "lemon::AssertionFailedError";
-    }
-    virtual ~AssertionFailedError() throw() {}
-  };
-
-
-  inline void assert_fail_log(const char *file, int line,
-                             const char *function,
-                             const std::exception& exception, 
-                             const char *assertion)
-  {
-    std::cerr << file << ":" << line << ": ";
-    if (function)
-      std::cerr << function << ": ";
-    std::cerr << exception.what();
-    if (assertion)
-      std::cerr << " (assertion '" << assertion << "' failed)";
-    std::cerr << std::endl;
-  }
-
   inline void assert_fail_log(const char *file, int line, const char *function,
                              const char *message, const char *assertion)
   {
@@ -104,21 +39,6 @@ namespace lemon {
     std::cerr << std::endl;
   }
 
-  inline void assert_fail_log(const char *file, int line, const char *function, 
-                             const std::string& message, const char *assertion)
-  {
-    assert_fail_log(file, line, function, message.c_str(), assertion);
-  }
-
-  inline void assert_fail_abort(const char *file, int line, 
-                               const char *function,
-                               const std::exception& exception,
-                               const char *assertion)
-  {
-    assert_fail_log(file, line, function, exception, assertion);
-    std::abort();
-  }
-
   inline void assert_fail_abort(const char *file, int line,
                                const char *function, const char* message,
                                const char *assertion)
@@ -127,86 +47,37 @@ namespace lemon {
     std::abort();
   }
 
-  inline void assert_fail_abort(const char *file, int line, 
-                               const char *function, 
-                               const std::string& message,
-                               const char *assertion)
-  {
-    assert_fail_log(file, line, function, message.c_str(), 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;
+    }    
   }
+}
 
-  inline void assert_fail_error(const char *file, int line, 
-                                 const char *function,
-                                 const std::exception& exception,
-                                 const char *assertion)
-  {
-    throw AssertionFailedError(file, line, function, 
-                              exception.what(), assertion);
-  }
-
-  inline void assert_fail_error(const char *file, int line,
-                                 const char *function, const char *message,
-                                 const char *assertion)
-  {
-    throw AssertionFailedError(file, line, function, message, assertion);
-  }
-
-  inline void assert_fail_error(const char *file, int line,
-                                 const char *function, 
-                                 const std::string& message,
-                                 const char *assertion)
-  {
-    throw AssertionFailedError(file, line, function, message.c_str(), assertion);
-  }
-
-  template <typename Exception>
-  inline void assert_fail_exception(const char *, int, const char *,
-                                   const Exception& exception,
-                                   const char *, const std::exception* = 
-                                   static_cast<const Exception*>(0))
-  {
-    throw exception;
-  }
-
-  inline void assert_fail_exception(const char *file, int line,
-                                   const char *function, const char *message,
-                                   const char *assertion)
-  {
-    throw AssertionFailedError(file, line, function, message, assertion);
-  }
-
-  inline void assert_fail_exception(const char *file, int line, 
-                                   const char *function, 
-                                   const std::string& message,
-                                   const char *assertion)
-  {
-    throw AssertionFailedError(file, line, function, message.c_str(), assertion);
-  }
-
-/// @}
-
-}
 #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) +              \
-  (defined(LEMON_ASSERT_ERROR) ? 1 : 0) +              \
-  (defined(LEMON_ASSERT_EXCEPTION) ? 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) +           \
-     (defined(LEMON_ASSERT_ERROR) ? 1 : 0) +           \
-     (defined(LEMON_ASSERT_EXCEPTION) ? 1 : 0) +       \
      (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) == 1 ||    \
      defined(LEMON_ENABLE_ASSERTS)) &&                 \
-  defined(LEMON_DISABLE_ASSERTS)
+  (defined(LEMON_DISABLE_ASSERTS) ||                   \
+   defined(NDEBUG))
 #error "LEMON assertion system is not set properly"
 #endif
 
@@ -217,25 +88,19 @@ namespace lemon {
 #elif defined LEMON_ASSERT_ABORT
 #  undef LEMON_ASSERT_HANDLER
 #  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_abort
-#elif defined LEMON_ASSERT_ERROR
-#  undef LEMON_ASSERT_HANDLER
-#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_error
-#elif defined LEMON_ASSERT_EXCEPTION
-#  undef LEMON_ASSERT_HANDLER
-#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_exception
 #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_ENABLE_ASSERTS
+#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
-#else
-#  undef LEMON_ASSERT_HANDLER
 #endif
-
 
 #ifndef LEMON_FUNCTION_NAME
 #  define LEMON_FUNCTION_NAME (__PRETTY_FUNCTION__)
@@ -247,24 +112,24 @@ namespace lemon {
 ///
 /// \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>, a <tt>const std::string&</tt> or
-/// a <tt>const std::exception&</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 disabled in the default behaviour.
-/// You can enable them with the following code:
+/// The assertions are enabled in the default behaviour.
+/// You can disable them with the following code:
 /// \code
-/// #define LEMON_ENABLE_ASSERTS
+/// #define LEMON_DISABLE_ASSERTS
 /// \endcode
 /// or with compilation parameters:
 /// \code
-/// g++ -DLEMON_ENABLE_ASSERTS
-/// make CXXFLAGS='-DLEMON_ENABLE_ASSERTS'
+/// 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
@@ -274,38 +139,22 @@ namespace lemon {
 ///
 /// - \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 mode when the assertions are enabled with
-///   \c LEMON_ENABLE_ASSERTS.
-/// - \c LEMON_ASSERT_ERROR The assertion throws an
-///   \ref lemon::AssertionFailedError "AssertionFailedError".
-///   If the \c msg parameter is an exception, then the result of the
-///   \ref lemon::Exception::what() "what()" member function is passed
-///   as error message.
-/// - \c LEMON_ASSERT_EXCEPTION If the specified \c msg is an
-///   exception, then it raised directly (solving that the exception
-///   can not be thrown polymorphically), otherwise an \ref
-///   lemon::AssertionFailedError "AssertionFailedError" is thrown with
-///   the given parameters.
+/// - \c LEMON_ASSERT_ABORT This mode is similar to the \c
+///   LEMON_ASSERT_LOG, but it aborts the program. It is the default
+///   behaviour.
 /// - \c LEMON_ASSERT_CUSTOM The user can define own assertion handler
-///   functions. Three overloaded functions should be defined with the
-///   following parameter lists:
+///   function.
 ///   \code
 ///     void custom_assert_handler(const char* file, int line, const char* function,
 ///                                const char* message, const char* assertion);
-///     void custom_assert_handler(const char* file, int line, const char* function,
-///                                const std::string& message, const char* assertion);
-///     void custom_assert_handler(const char* file, int line, const char* function,
-///                                const std::exception& message, const char* assertion);
 ///   \endcode
-///   The name of the functions should be defined as the \c
+///   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, one of the custom assertion
-///   handlers is called with appropiate parameters.
+///   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
@@ -315,8 +164,7 @@ namespace lemon {
   (static_cast<void> (!!(exp) ? 0 : (                                  \
     LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                           \
                         LEMON_FUNCTION_NAME,                           \
-                        msg, #exp), 0)))
-
+                        ::lemon::_assert_bits::cstringify(msg), #exp), 0)))
 
 /// \ingroup exceptions
 ///
@@ -327,26 +175,80 @@ namespace lemon {
 /// \code
 ///   LEMON_ASSERT(false, msg);
 /// \endcode
+///
+/// \see LEMON_ASSERT 
 #  define LEMON_FIXME(msg)                                             \
-       (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,  \
-                            "FIXME: " msg, static_cast<const char*>(0)))
+  (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, \
-                              msg, #exp), 0)))
-#    define LEMON_FIXME(msg) \
+#    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,  \
-                            "FIXME: " msg,  static_cast<const char*>(0)))
+                            ::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
 
+#ifdef DOXYGEN
 
+
+#else
+
+
+#endif
+
+
diff -r 7b0ce9fb1169 -r 407c08a0eae9 test/error_test.cc
--- a/test/error_test.cc        Wed Apr 09 17:19:40 2008 +0100
+++ b/test/error_test.cc        Fri Apr 11 16:20:54 2008 +0200
@@ -39,16 +39,8 @@ void no_assertion_text_disable() {
   LEMON_ASSERT(true, "This is a fault message");
 }
 
-void no_assertion_exception_disable() {
-  LEMON_ASSERT(true, Exception());
-}
-
 void assertion_text_disable() {
   LEMON_ASSERT(false, "This is a fault message");
-}
-
-void assertion_exception_disable() {
-  LEMON_ASSERT(false, Exception());
 }
 
 void fixme_disable() {
@@ -57,146 +49,10 @@ void fixme_disable() {
 
 void check_assertion_disable() {
   no_assertion_text_disable();
-  no_assertion_exception_disable();
-  assertion_exception_disable();
   assertion_text_disable();
   fixme_disable();
 }
 #undef LEMON_DISABLE_ASSERTS
-
-
-#define LEMON_ASSERT_ERROR
-#include <lemon/assert.h>
-
-void no_assertion_text_error() {
-  LEMON_ASSERT(true, "This is a fault message");
-}
-
-void no_assertion_exception_error() {
-  LEMON_ASSERT(true, Exception());
-}
-
-void assertion_text_error() {
-  LEMON_ASSERT(false, "This is a fault message");
-}
-
-void assertion_exception_error() {
-  LEMON_ASSERT(false, Exception());
-}
-
-void fixme_error() {
-  LEMON_FIXME("fixme_error() is fixme!");
-}
-
-void check_assertion_error() {
-  no_assertion_text_error();
-  no_assertion_exception_error();
-  try {
-    assertion_exception_error();
-    check(false, "Assertion error");
-  } catch (const AssertionFailedError& e) {
-  }
-
-  try {
-    assertion_text_error();
-    check(false, "Assertion error");
-  } catch (const AssertionFailedError& e) {
-  }
-
-  try {
-    fixme_error();
-    check(false, "Assertion error");
-  } catch (const AssertionFailedError& e) {
-  }
-}
-#undef LEMON_ASSERT_ERROR
-
-#define LEMON_ASSERT_EXCEPTION
-#include <lemon/assert.h>
-
-void no_assertion_text_exception() {
-  LEMON_ASSERT(true, "This is a fault message");
-}
-
-void no_assertion_exception_exception() {
-  LEMON_ASSERT(true, Exception());
-}
-
-void assertion_text_exception() {
-  LEMON_ASSERT(false, "This is a fault message");
-}
-
-void assertion_exception_exception() {
-  LEMON_ASSERT(false, Exception());
-}
-
-void fixme_exception() {
-  LEMON_FIXME("fixme_exception() is fixme!");
-}
-
-void check_assertion_exception() {
-  no_assertion_text_exception();
-  no_assertion_exception_exception();
-  try {
-    assertion_exception_exception();
-    check(false, "Assertion error");
-  } catch (const Exception& e) {
-  }
-
-  try {
-    assertion_text_exception();
-    check(false, "Assertion error");
-  } catch (const AssertionFailedError& e) {
-  }
-
-  try {
-    assertion_text_exception();
-    check(false, "Assertion error");
-  } catch (const AssertionFailedError& e) {
-  }
-
-  try {
-    fixme_exception();
-    check(false, "Assertion error");
-  } catch (const AssertionFailedError& e) {
-  }
-}
-#undef LEMON_ASSERT_EXCEPTION
-
-#define LEMON_ASSERT_LOG
-
-#include <lemon/assert.h>
-
-void no_assertion_text_log() {
-  LEMON_ASSERT(true, "This is a fault message");
-}
-
-void no_assertion_exception_log() {
-  LEMON_ASSERT(true, Exception());
-}
-
-void assertion_text_log() {
-  LEMON_ASSERT(false, "This is a fault message");
-}
-
-void assertion_exception_log() {
-  LEMON_ASSERT(false, Exception());
-}
-
-void fixme_log() {
-  LEMON_FIXME("fixme_log() is fixme!");
-}
-
-void check_assertion_log() {
-  no_assertion_text_log();
-  no_assertion_exception_log();
-  std::cerr << "The next 3 failure messages are expected: " << std::endl;
-  assertion_exception_log();
-  assertion_text_log();
-  fixme_log();
-  std::cerr << "End of expected error messages" << std::endl;
-}
-#undef LEMON_ASSERT_LOG
 
 #define LEMON_ASSERT_CUSTOM
 
@@ -206,17 +62,6 @@ void my_assert_handler(const char*, int,
   ++cnt;
 }
 
-void my_assert_handler(const char*, int, const char*, 
-                      const std::exception&, const char*) {
-  ++cnt;
-}
-
-void my_assert_handler(const char*, int, const char*, 
-                      const std::string&, const char*) {
-  ++cnt;
-}
-
-
 #define LEMON_CUSTOM_ASSERT_HANDLER my_assert_handler
 #include <lemon/assert.h>
 
@@ -224,16 +69,8 @@ void no_assertion_text_custom() {
   LEMON_ASSERT(true, "This is a fault message");
 }
 
-void no_assertion_exception_custom() {
-  LEMON_ASSERT(true, Exception());
-}
-
 void assertion_text_custom() {
   LEMON_ASSERT(false, "This is a fault message");
-}
-
-void assertion_exception_custom() {
-  LEMON_ASSERT(false, Exception());
 }
 
 void fixme_custom() {
@@ -242,11 +79,9 @@ void fixme_custom() {
 
 void check_assertion_custom() {
   no_assertion_text_custom();
-  no_assertion_exception_custom();
-  assertion_exception_custom();
   assertion_text_custom();
   fixme_custom();
-  check(cnt == 3, "The custom assert handler does not work");
+  check(cnt == 2, "The custom assert handler does not work");
 }
 
 #undef LEMON_ASSERT_CUSTOM
@@ -254,9 +89,6 @@ void check_assertion_custom() {
 
 int main() {
   check_assertion_disable();
-  check_assertion_error();
-  check_assertion_exception();
-  check_assertion_log();
   check_assertion_custom();
 
   return 0;