COIN-OR::LEMON - Graph Library

Ticket #46: lemon_assert.patch

File lemon_assert.patch, 9.1 KB (added by Alpar Juttner, 14 years ago)
  • lemon/assert.h

    # HG changeset patch
    # User Peter Kovacs <kpeter@inf.elte.hu>
    # Date 1206620776 -3600
    # Node ID d2ee5e7f00ef5d8ffe6b293461eba7ec0ca0be47
    # Parent  889d0c289d19d3b4b50387d6ff9b6e5d3bc803aa
    Improvements in assert.h
    
    diff -r 889d0c289d19 -r d2ee5e7f00ef lemon/assert.h
    a b  
    115115                                const std::exception& exception,
    116116                                const char *assertion)
    117117  {
    118     std::cerr << file << ":" << line << ": ";
    119     if (function)
    120       std::cerr << function << ": ";
    121     std::cerr << exception.what();
    122     if (assertion)
    123       std::cerr << " (assertion '" << assertion << "' failed)";
    124     std::cerr << std::endl;
     118    assert_fail_log(file, line, function, exception, assertion);
    125119    std::abort();
    126120  }
    127121
     
    129123                                const char *function, const char* message,
    130124                                const char *assertion)
    131125  {
    132     std::cerr << file << ":" << line << ": ";
    133     if (function)
    134       std::cerr << function << ": ";
    135     std::cerr << message;
    136     if (assertion)
    137       std::cerr << " (assertion '" << assertion << "' failed)";
    138     std::cerr << std::endl;
     126    assert_fail_log(file, line, function, message, assertion);
    139127    std::abort();
    140128  }
    141129
     
    144132                                const std::string& message,
    145133                                const char *assertion)
    146134  {
    147     assert_fail_abort(file, line, function, message.c_str(), assertion);
     135    assert_fail_log(file, line, function, message.c_str(), assertion);
     136    std::abort();
    148137  }
    149138
    150139  inline void assert_fail_error(const char *file, int line,
     
    168157                                  const std::string& message,
    169158                                  const char *assertion)
    170159  {
    171     assert_fail_error(file, line, function, message.c_str(), assertion);
     160    throw AssertionFailedError(file, line, function, message.c_str(), assertion);
    172161  }
    173162
    174163  template <typename Exception>
     
    192181                                    const std::string& message,
    193182                                    const char *assertion)
    194183  {
    195     assert_fail_exception(file, line, function, message.c_str(), assertion);
     184    throw AssertionFailedError(file, line, function, message.c_str(), assertion);
    196185  }
    197186
    198187/// @}
     
    208197  (defined(LEMON_ASSERT_ERROR) ? 1 : 0) +               \
    209198  (defined(LEMON_ASSERT_EXCEPTION) ? 1 : 0) +           \
    210199  (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) > 1
    211 #error "Lemon assertion system is not set properly"
     200#error "LEMON assertion system is not set properly"
    212201#endif
    213202
    214203#if ((defined(LEMON_ASSERT_LOG) ? 1 : 0) +              \
     
    216205     (defined(LEMON_ASSERT_ERROR) ? 1 : 0) +            \
    217206     (defined(LEMON_ASSERT_EXCEPTION) ? 1 : 0) +        \
    218207     (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) == 1 ||     \
    219      defined(LEMON_ENABLE_ASSERT)) &&                   \
     208     defined(LEMON_ENABLE_ASSERTS)) &&                  \
    220209  defined(LEMON_DISABLE_ASSERTS)
    221 #error "Lemon assertion system is not set properly"
     210#error "LEMON assertion system is not set properly"
    222211#endif
    223212
    224213
     
    256245
    257246/// \ingroup exceptions
    258247///
    259 /// \brief Macro for assertions with customizable message
     248/// \brief Macro for assertion with customizable message
    260249///
    261 /// Macro for assertions with customizable message. 
    262 /// \param exp An expression convertible to bool. If the expression is
    263 /// false, then an assertion is raised. The concrete behaviour depends
    264 /// on the settings of the assertion system.
    265 /// \param msg A \e const \e char*, a \e const std::string& or a \e
    266 /// const \e std::exception& parameter. The variable can be used to
    267 /// provide information about the circumstances of failed assertion.
     250/// Macro for assertion with customizable message. 
     251/// \param exp An expression that must be convertible to \c bool.
     252/// If it is \c false, then an assertion is raised. The concrete
     253/// behaviour depends on the settings of the assertion system.
     254/// \param msg A <tt>const char*</tt>, a <tt>const std::string&</tt> or
     255/// a <tt>const std::exception&</tt> parameter, which can be used to
     256/// provide information about the circumstances of the failed assertion.
    268257///
    269 /// The assertions are disabled in the default behaviour. You can
    270 /// enable the assertions with the following code:
     258/// The assertions are disabled in the default behaviour.
     259/// You can enable them with the following code:
    271260/// \code
    272261/// #define LEMON_ENABLE_ASSERTS
    273262/// \endcode
     
    277266/// make CXXFLAGS='-DLEMON_ENABLE_ASSERTS'
    278267/// \endcode
    279268///
    280 /// The %lemon assertion system has a wide range of customization
    281 /// properties. As default behaviour the failed assertion prints a
    282 /// short log message to the standard ouput and aborts the execution.
     269/// The LEMON assertion system has a wide range of customization
     270/// properties. As a default behaviour the failed assertion prints a
     271/// short log message to the standard error and aborts the execution.
    283272///
    284273/// The following modes can be used in the assertion system:
    285274///
    286 /// - \e LEMON_ASSERT_LOG The failed assert print a short convenient
    287 ///   error message to the standard error and continues the
    288 ///   execution.
    289 /// - \e LEMON_ASSERT_ABORT This mode is similar to the \e
    290 ///   LEMON_ASSERT_LOG, but it aborts the program. It is the default
    291 ///   operation mode when the asserts are enabled with \e
    292 ///   LEMON_ENABLE_ASSERTS.
    293 /// - \e LEMON_ASSERT_ERROR The assert throws an \ref
    294 ///   lemon::AssertionFailedError "AssertionFailedError". If the \c
    295 ///   msg parameter is an exception, then the result of the \ref
    296 ///   lemon::Exception::what() "what()" member function is passed as
    297 ///   error message.
    298 /// - \e LEMON_ASSERT_EXCEPTION If the specified \c msg is an
    299 ///   exception then it raised directly (solving that the exception
     275/// - \c LEMON_ASSERT_LOG The failed assertion prints a short log
     276///   message to the standard error and continues the execution.
     277/// - \c LEMON_ASSERT_ABORT This mode is similar to the
     278///   \c LEMON_ASSERT_LOG, but it aborts the program. It is the default
     279///   behaviour mode when the assertions are enabled with
     280///   \c LEMON_ENABLE_ASSERTS.
     281/// - \c LEMON_ASSERT_ERROR The assertion throws an
     282///   \ref lemon::AssertionFailedError "AssertionFailedError".
     283///   If the \c msg parameter is an exception, then the result of the
     284///   \ref lemon::Exception::what() "what()" member function is passed
     285///   as error message.
     286/// - \c LEMON_ASSERT_EXCEPTION If the specified \c msg is an
     287///   exception, then it raised directly (solving that the exception
    300288///   can not be thrown polymorphically), otherwise an \ref
    301289///   lemon::AssertionFailedError "AssertionFailedError" is thrown with
    302 ///   the given parameter.
    303 /// - \e LEMON_ASSERT_CUSTOM The user can define an own assertion
    304 ///   handler functions. Three overloaded functions should be defined
    305 ///   with the following parameter lists:
     290///   the given parameters.
     291/// - \c LEMON_ASSERT_CUSTOM The user can define own assertion handler
     292///   functions. Three overloaded functions should be defined with the
     293///   following parameter lists:
    306294///   \code
    307 ///     void custom_assert_handler(const char* file, int line,
    308 ///                                const char* function, const char* message, const char* expression);
    309 ///     void custom_assert_handler(const char* file, int line,
    310 ///                                const char* function, const std::string& message, const char* expression);
    311 ///     void custom_assert_handler(const char* file, int line,
    312 ///                                const char* function, const std::exception& message, const char* expression);
     295///     void custom_assert_handler(const char* file, int line, const char* function,
     296///                                const char* message, const char* assertion);
     297///     void custom_assert_handler(const char* file, int line, const char* function,
     298///                                const std::string& message, const char* assertion);
     299///     void custom_assert_handler(const char* file, int line, const char* function,
     300///                                const std::exception& message, const char* assertion);
    313301///   \endcode
    314302///   The name of the functions should be defined as the \c
    315303///   LEMON_CUSTOM_ASSERT_HANDLER macro name.
     
    317305///     #define LEMON_CUSTOM_ASSERT_HANDLER custom_assert_handler
    318306///   \endcode
    319307///   Whenever an assertion is occured, one of the custom assertion
    320 ///   handler is called with appropiate parameters.
     308///   handlers is called with appropiate parameters.
    321309///
    322 /// The assertion mode can be changed within one compilation unit, if
    323 /// the macros are redefined with other settings and the
    324 /// lemon/assert.h file is reincluded then the behaviour is changed
    325 /// appropiately to the new settings.
     310/// The assertion mode can also be changed within one compilation unit.
     311/// If the macros are redefined with other settings and the
     312/// \ref lemon/assert.h "assert.h" file is reincluded, then the
     313/// behaviour is changed appropiately to the new settings.
    326314#  define LEMON_ASSERT(exp, msg)                                        \
    327315  (static_cast<void> (!!(exp) ? 0 : (                                   \
    328316    LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                            \
     
    346334#else
    347335
    348336#  ifndef LEMON_ASSERT_HANDLER
    349 #    define LEMON_ASSERT(exp, msg)  (static_cast<void> (0))
     337#    define LEMON_ASSERT(exp, msg)  (static_cast<void>(0))
    350338#    define LEMON_FIXME(msg) (static_cast<void>(0))
    351339#  else
    352340#    define LEMON_ASSERT(exp, msg)                 \