RhodeCode

    std::cerr << file << ":" << line << ": ";

    if (function)

      std::cerr << function << ": ";

    std::cerr << exception.what();

    if (assertion)

      std::cerr << " (assertion '" << assertion << "' failed)";

    std::cerr << std::endl;

    std::cerr << file << ":" << line << ": ";

    if (function)

      std::cerr << function << ": ";

    std::cerr << message;

    if (assertion)

      std::cerr << " (assertion '" << assertion << "' failed)";

    std::cerr << std::endl;

    assert_fail_abort(file, line, function, message.c_str(), assertion);

    assert_fail_error(file, line, function, message.c_str(), assertion);

    assert_fail_exception(file, line, function, message.c_str(), assertion);

#error "Lemon assertion system is not set properly"

     defined(LEMON_ENABLE_ASSERT)) &&			\

#error "Lemon assertion system is not set properly"

/// \brief Macro for assertions with customizable message

/// Macro for assertions with customizable message.  

/// \param exp An expression convertible to bool. If the expression is

/// false, then an assertion is raised. The concrete behaviour depends

/// on the settings of the assertion system.

/// \param msg A \e const \e char*, a \e const std::string& or a \e

/// const \e std::exception& parameter. The variable can be used to

/// provide information about the circumstances of failed assertion.

/// The assertions are disabled in the default behaviour. You can

/// enable the assertions with the following code:

/// The %lemon assertion system has a wide range of customization

/// properties. As default behaviour the failed assertion prints a

/// short log message to the standard ouput and aborts the execution.

/// - \e LEMON_ASSERT_LOG The failed assert print a short convenient

///   error message to the standard error and continues the

///   execution.

/// - \e LEMON_ASSERT_ABORT This mode is similar to the \e

///   LEMON_ASSERT_LOG, but it aborts the program. It is the default

///   operation mode when the asserts are enabled with \e

///   LEMON_ENABLE_ASSERTS.

/// - \e LEMON_ASSERT_ERROR The assert 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.

/// - \e LEMON_ASSERT_EXCEPTION If the specified \c msg is an

///   exception then it raised directly (solving that the exception

///   the given parameter.

/// - \e LEMON_ASSERT_CUSTOM The user can define an own assertion

///   handler functions. Three overloaded functions should be defined

///   with the following parameter lists:

///     void custom_assert_handler(const char* file, int line, 

///                                const char* function, const char* message, const char* expression);

///     void custom_assert_handler(const char* file, int line, 

///                                const char* function, const std::string& message, const char* expression);

///     void custom_assert_handler(const char* file, int line, 

///                                const char* function, const std::exception& message, const char* expression);

///   handler is called with appropiate parameters.

/// The assertion mode can be changed within one compilation unit, if

/// the macros are redefined with other settings and the

/// lemon/assert.h file is reincluded then the behaviour is changed

/// appropiately to the new settings.

#    define LEMON_ASSERT(exp, msg)  (static_cast<void> (0))