RhodeCode

#include <lemon/error.h>

  /// Exception-safe convenient "error message" class.

  ///\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 *func,

			 const char *msg, const char *_assertion = 0) :

      assertion(_assertion), file(_file), line(_line), function(func),

      message(msg) {}

    ///\e

    const char* get_assertion() const { return assertion; }

    ///\e

    const char* get_message() const { return message; }

    ///\e

    const char* get_file() const { return file; }

    ///\e

    const char* get_function() const { return function; }

    ///\e

    int get_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() {}

  };

  /****************  Macros  ****************/

  template <typename Exception>

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

                          const char *func,

                          Exception exception,

                          const char *assertion = 0,

                          bool do_abort=true)

  {

    using namespace std;

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

    if (func)

      cerr << func << ": ";

    cerr << exception.what();

    if (assertion)

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

    cerr << endl;

    if (do_abort)

      abort();

  }

  template <>

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

                                        const char *func,

                                        const char *message,

                                        const char *assertion,

                                        bool do_abort)

  {

    using namespace std;

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

    if (func)

      cerr << func << ": ";

    cerr << message;

    if (assertion)

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

    cerr << endl;

    if (do_abort)

      abort();

  }

  template <>

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

                                       const char *func,

                                       std::string message,

                                       const char *assertion,

                                       bool do_abort)

  {

    assert_fail(file, line, func, message.c_str(), assertion, do_abort);

  }

  template <typename Exception>

  inline void assert_fail_failure(const char *file, int line, const char *func,

			   Exception exception,

			   const char *assertion = 0,

			   bool = true)

  {

    throw AssertionFailedError(file, line, func, exception.what(), assertion);

  }

  template <>

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

                                                const char *func,

                                                const char *message,

                                                const char *assertion,

                                                bool)

  {

    throw AssertionFailedError(file, line, func, message, assertion);

  }

  template <>

  inline void assert_fail_failure<std::string>(const char *file, int line,

                                               const char *func,

                                               std::string message,

                                               const char *assertion,

                                               bool)

  {

    assert_fail_failure(file, line, func, message.c_str(), assertion, true);

  }

  template <typename Exception>

  inline void assert_fail_exception(const char *file, int line, const char *func,

			     Exception exception,

			     const char *assertion = 0, bool = true)

  {

    throw exception;

  }

  template <>

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

					   const char *func,

					   const char *message,

					   const char *assertion,

					   bool)

  {

    throw AssertionFailedError(file, line, func, message, assertion);

  }

  template <>

  inline void assert_fail_exception<std::string>(const char *file, int line,

                                                 const char *func,

                                                 std::string message,

                                                 const char *assertion,

                                                 bool)

  {

    assert_fail_exception(file, line, func, message.c_str(), assertion, true);

  }

#undef LEMON_ASSERT

#undef LEMON_FIXME

#ifdef LEMON_ENABLE_ASSERTS

#  define LEMON_ASSERT_ABORT

#endif

#ifndef LEMON_ASSERT_DO_ABORT

#  define LEMON_ASSERT_DO_ABORT 1

#endif

#ifndef LEMON_ASSERT_HANDLER

#  if defined LEMON_ASSERT_EXCEPTION

#    define LEMON_ASSERT_HANDLER ::lemon::assert_fail_exception

#  elif defined LEMON_ASSERT_FAILURE

#    define LEMON_ASSERT_HANDLER ::lemon::assert_fail_failure

#  elif defined LEMON_ASSERT_ABORT

#    define LEMON_ASSERT_HANDLER ::lemon::assert_fail

#  else

#    define LEMON_DISABLE_ASSERTS

#  endif

#endif

#ifdef DOXYGEN

/// \brief Macro for assertions with customizable message

///

/// Macro for assertions with customizable message.

///

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

/// enable the assertions with the

/// \code

/// #define LEMON_ENABLE_ASSERTS

/// \endcode

/// Then an assert

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

/// the program if LEMON_ASSERT_DO_ABORT is also defined (otherwise the

/// program keeps on running).

/// By defining LEMON_ASSERT_FAILURE or

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

/// assertions. In case LEMON_ASSERT_FAILURE is given, LEMON_ASSERT

/// will always throw an \c AssertionFailedError exception with

/// the \c msg error message. By using

/// LEMON_ASSERT_EXCEPTION, one can define an arbitrary exception to be thrown.

///

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

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

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

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

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

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

/// display the error message.

///

/// \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

#  define LEMON_ASSERT(exp, msg)                 \

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

       LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \

                            __PRETTY_FUNCTION__, \

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

#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

/**

 * \brief Macro for mark not yet implemented features.

 *

 * \todo Is this the right place for this? It should be used only in

 * modules under development.

 *

 * \todo __PRETTY_FUNCTION__ should be replaced by something

 * compiler-independent, like BOOST_CURRENT_FUNCTION

 */

#define LEMON_FIXME(msg) \

    (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, __PRETTY_FUNCTION__, \

			  "FIXME: " msg))

#test_error_test_SOURCES = test/error_test.cc

using std::cout;

using std::endl;

void faulty_fn() {

  fault("This is a fault message");

void exception_fn() {

  throw Exception("This is a function throwing exception with some args: ")

    << 5 << ", " << 18;

void unfinished_fn() {

  LEMON_FIXME("unfinished_fn() is unfinished!");

int main() {

    faulty_fn();

    check(false, "A faulty function did not fail.");

  }

  catch(const Exception &e) {

    cout << "Exeption = \"" << e.what() << "\" (Right behaviour)" << endl;

    exception_fn();

    check(false, "The function did not throw Exception.");

  }

  catch(const Exception &e) {

    cout << "Exeption = \"" << e.what() << "\" (Right behaviour)" << endl;

    unfinished_fn();

    check(false, "FIXME macro does not work.");

  catch(const Exception &e) {

    cout << "Exeption = \"" << e.what() << "\" (Right behaviour)" << endl;