inline void assert_fail<const char *>(const char *file, int line, const char *func,

   inline void assert_fail<const char *>(const char *file, int line, 

 				 const char *message, 

                                         const char *func,

 				 const char *assertion,

                                         const char *message, 

 				 bool do_abort)

                                         const char *assertion,

                                         bool do_abort)

 #ifndef LEMON_ASSERT_ABORT

 #ifdef LEMON_ENABLE_ASSERTS

 #  define LEMON_ASSERT_ABORT 1

 #  define LEMON_ASSERT_ABORT

 #endif

 #ifndef LEMON_ASSERT_DO_ABORT

 #  define LEMON_ASSERT_DO_ABORT 1

 #    define LEMON_ASSERT_HANDLER ::lemon::assert_fail

 #    define LEMON_DISABLE_ASSERTS

 #if defined(NDEBUG) || defined(LEMON_DISABLE_ASSERTS)

 #ifdef DOXYGEN

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

 /// \brief Macro for assertions with customizable message

 ///

 #else

 /// Macro for assertions with customizable message.

 ///

 /**

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

  * \brief Macro for assertions with customizable message

 /// enable the assertions with the LEMON_ENABLE_ASSERTS macro what

  *

 /// provides a log on the standard error about the assertion and aborts

  * Macro for assertions with customizable message.

 /// the program.  If the LEMON_ASSERT_DO_ABORT macro is setted to false

  *

 /// then the just the log message can be seen on the standard error but

  * The behaviour can be customized with LEMON_ASSERT_HANDLER,

 /// the program is not stopped. With the LEMON_ASSERT_FAILURE and

  * LEMON_ASSERT_EXCEPTION and LEMON_ASSERT_ABORT defines. Asserts can be

 /// LEMON_ASSERT_EXCEPTION macros you can set other behaviour to the

  * disabled by defining either NDEBUG or LEMON_DISABLE_ASSERTS macros.

 /// assertions. The LEMON_ASSERT_FAILURE will always throw an \c

  *

 /// AssertionFailedError exception with the \c msg error message. The

  * \todo We should provide some way to reset to the default behaviour,

 /// \c LEMON_ASSERT_EXCEPTION can throw a user defined exception.

  * shouldn't we?

 ///

  *

 /// The LEMON_ASSERT macro should be called with the \c exp parameter

  * \todo This whole 'assert' business should be placed in a separate

 /// which should be an expression convertible to bool. If the given

  * include file. The boost assert is not guarded by header sentries

 /// parameter is false the assertion is raised and one of the assertion

  * which may help to change the behaviour of the assertions in 

 /// behaviour will be activated. The \c msg should be either a const

  * the files.

 /// char* message or an exception. When the \c msg is an exception the

  *

 /// \ref "Exception::what" what() function is called to retrieve and

  * \todo __PRETTY_FUNCTION__ should be replaced by something

 /// display the error message.

  * compiler-independent, like BOOST_CURRENT_FUNCTION

 ///

  */

 ///

 /// \todo We should provide some way to reset to the default behaviour,

 /// shouldn't we?

 ///

 /// \todo This whole 'assert' business should be placed in a separate

 /// include file. The boost assert is not guarded by header sentries

 /// which may help to change the behaviour of the assertions in 

 /// the files.

 ///

 /// \todo __PRETTY_FUNCTION__ should be replaced by something

 /// compiler-independent, like BOOST_CURRENT_FUNCTION

 			    msg, #exp, LEMON_ASSERT_ABORT), 0)))

                             msg, #exp, LEMON_ASSERT_DO_ABORT), 0)))

 #endif // NDEBUG || LEMON_DISABLE_ASSERTS

 #else 

 #  if defined LEMON_DISABLE_ASSERTS

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

 #  else

 #    define LEMON_ASSERT(exp, msg)                 \

        (static_cast<void> (!!(exp) ? 0 : (         \

          LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \

                               __PRETTY_FUNCTION__, \

                               msg, #exp, LEMON_ASSERT_DO_ABORT), 0)))

 #  endif

 #endif