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

     assert_fail_log(file, line, function, exception, assertion);

     if (function)

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

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

     if (assertion)

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

     std::cerr << std::endl;

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

     assert_fail_log(file, line, function, message, assertion);

     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_log(file, line, function, message.c_str(), assertion);

     std::abort();

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

     throw AssertionFailedError(file, line, function, message.c_str(), assertion);

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

     throw AssertionFailedError(file, line, function, message.c_str(), assertion);

 #error "Lemon assertion system is not set properly"

 #error "LEMON assertion system is not set properly"

      defined(LEMON_ENABLE_ASSERT)) &&			\

      defined(LEMON_ENABLE_ASSERTS)) &&			\

 #error "Lemon assertion system is not set properly"

 #error "LEMON assertion system is not set properly"

 /// \brief Macro for assertions with customizable message

 /// \brief Macro for assertion with customizable message

 ///

 ///

 /// Macro for assertions with customizable message.  

 /// Macro for assertion with customizable message.  

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

 /// \param exp An expression that must be convertible to \c bool.

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

 /// If it is \c false, then an assertion is raised. The concrete

 /// on the settings of the assertion system.

 /// behaviour depends on the settings of the assertion system.

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

 /// \param msg A <tt>const char*</tt>, a <tt>const std::string&</tt> or

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

 /// a <tt>const std::exception&</tt> parameter, which can be used to

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

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

 ///

 ///

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

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

 /// enable the assertions with the following code:

 /// You can enable them with the following code:

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

 /// The LEMON assertion system has a wide range of customization

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

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

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

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

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

 /// - \c LEMON_ASSERT_LOG The failed assertion prints a short log

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

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

 ///   execution.

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

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

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

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

 ///   behaviour mode when the assertions are enabled with

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

 ///   \c LEMON_ENABLE_ASSERTS.

 ///   LEMON_ENABLE_ASSERTS.

 /// - \c LEMON_ASSERT_ERROR The assertion throws an

 /// - \e LEMON_ASSERT_ERROR The assert throws an \ref

 ///   \ref lemon::AssertionFailedError "AssertionFailedError".

 ///   lemon::AssertionFailedError "AssertionFailedError". If the \c

 ///   If the \c msg parameter is an exception, then the result of the

 ///   msg parameter is an exception, then the result of the \ref

 ///   \ref lemon::Exception::what() "what()" member function is passed

 ///   lemon::Exception::what() "what()" member function is passed as

 ///   as error message.

 ///   error message.

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

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

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

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

 ///   the given parameter.

 ///   the given parameters.

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

 /// - \c LEMON_ASSERT_CUSTOM The user can define own assertion handler

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

 ///   functions. Three overloaded functions should be defined with the

 ///   with the following parameter lists:

 ///   following parameter lists:

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

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

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

 ///                                const char* message, const char* assertion);

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

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

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

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

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

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

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

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

 ///   handler is called with appropiate parameters.

 ///   handlers is called with appropiate parameters.

 ///

 ///

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

 /// The assertion mode can also be changed within one compilation unit.

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

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

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

 /// \ref lemon/assert.h "assert.h" file is reincluded, then the

 /// appropiately to the new settings.

 /// behaviour is changed appropiately to the new settings.

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

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