COIN-OR::LEMON - Graph Library

source: lemon-1.0/lemon/assert.h @ 174:2ec3c1bbc687

Last change on this file since 174:2ec3c1bbc687 was 142:8b703d177341, checked in by Akos Ladanyi <ladanyi@…>, 12 years ago

Improved LEMON_FUNCTION_NAME macro.
It should work fine with GCC and the MS C++ compilers. Otherwise it reverts to
using the func variable which is C99, but I couldn't find a better
alternative.

File size: 7.9 KB
RevLine 
[66]1/* -*- C++ -*-
2 *
3 * This file is a part of LEMON, a generic C++ optimization library
4 *
5 * Copyright (C) 2003-2008
6 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7 * (Egervary Research Group on Combinatorial Optimization, EGRES).
8 *
9 * Permission to use, modify and distribute this software is granted
10 * provided that this copyright notice appears in all copies. For
11 * precise terms see the accompanying LICENSE file.
12 *
13 * This software is provided "AS IS" with no warranty of any kind,
14 * express or implied, and with no claim as to its suitability for any
15 * purpose.
16 *
17 */
18
[108]19#ifndef LEMON_ASSERT_H
20#define LEMON_ASSERT_H
[66]21
22/// \ingroup exceptions
23/// \file
[108]24/// \brief Extended assertion handling
[66]25
[108]26#include <lemon/error.h>
[66]27
28namespace lemon {
29
[108]30  inline void assert_fail_log(const char *file, int line, const char *function,
31                              const char *message, const char *assertion)
[66]32  {
[108]33    std::cerr << file << ":" << line << ": ";
34    if (function)
35      std::cerr << function << ": ";
36    std::cerr << message;
[66]37    if (assertion)
[108]38      std::cerr << " (assertion '" << assertion << "' failed)";
39    std::cerr << std::endl;
[66]40  }
41
[108]42  inline void assert_fail_abort(const char *file, int line,
43                                const char *function, const char* message,
44                                const char *assertion)
45  {
[112]46    assert_fail_log(file, line, function, message, assertion);
[108]47    std::abort();
48  }
49
[118]50  namespace _assert_bits {
51   
52   
53    inline const char* cstringify(const std::string& str) {
54      return str.c_str();
55    }
56
57    inline const char* cstringify(const char* str) {
58      return str;
59    }   
[108]60  }
[118]61}
[108]62
63#endif // LEMON_ASSERT_H
[66]64
65#undef LEMON_ASSERT
66#undef LEMON_FIXME
[118]67#undef LEMON_DEBUG
[66]68
[108]69#if (defined(LEMON_ASSERT_LOG) ? 1 : 0) +               \
70  (defined(LEMON_ASSERT_ABORT) ? 1 : 0) +               \
71  (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) > 1
[112]72#error "LEMON assertion system is not set properly"
[66]73#endif
74
[108]75#if ((defined(LEMON_ASSERT_LOG) ? 1 : 0) +              \
76     (defined(LEMON_ASSERT_ABORT) ? 1 : 0) +            \
77     (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) == 1 ||     \
[112]78     defined(LEMON_ENABLE_ASSERTS)) &&                  \
[118]79  (defined(LEMON_DISABLE_ASSERTS) ||                    \
80   defined(NDEBUG))
[112]81#error "LEMON assertion system is not set properly"
[66]82#endif
83
[108]84
85#if defined LEMON_ASSERT_LOG
86#  undef LEMON_ASSERT_HANDLER
87#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_log
88#elif defined LEMON_ASSERT_ABORT
89#  undef LEMON_ASSERT_HANDLER
90#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_abort
91#elif defined LEMON_ASSERT_CUSTOM
92#  undef LEMON_ASSERT_HANDLER
93#  ifndef LEMON_CUSTOM_ASSERT_HANDLER
94#    error "LEMON_CUSTOM_ASSERT_HANDLER is not set"
[66]95#  endif
[108]96#  define LEMON_ASSERT_HANDLER LEMON_CUSTOM_ASSERT_HANDLER
[118]97#elif defined LEMON_DISABLE_ASSERTS
[108]98#  undef LEMON_ASSERT_HANDLER
[118]99#elif defined NDEBUG
100#  undef LEMON_ASSERT_HANDLER
101#else
[108]102#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_abort
103#endif
104
105#ifndef LEMON_FUNCTION_NAME
[142]106#  if defined __GNUC__
107#    define LEMON_FUNCTION_NAME (__PRETTY_FUNCTION__)
108#  elif defined _MSC_VER
109#    define LEMON_FUNCTION_NAME (__FUNCSIG__)
110#  else
111#    define LEMON_FUNCTION_NAME (__func__)
112#  endif
[66]113#endif
114
115#ifdef DOXYGEN
116
[108]117/// \ingroup exceptions
118///
[112]119/// \brief Macro for assertion with customizable message
[66]120///
[118]121/// Macro for assertion with customizable message.  \param exp An
122/// expression that must be convertible to \c bool.  If it is \c
123/// false, then an assertion is raised. The concrete behaviour depends
124/// on the settings of the assertion system.  \param msg A <tt>const
125/// char*</tt> parameter, which can be used to provide information
126/// about the circumstances of the failed assertion.
[66]127///
[118]128/// The assertions are enabled in the default behaviour.
129/// You can disable them with the following code:
[66]130/// \code
[118]131/// #define LEMON_DISABLE_ASSERTS
[66]132/// \endcode
[108]133/// or with compilation parameters:
134/// \code
[118]135/// g++ -DLEMON_DISABLE_ASSERTS
136/// make CXXFLAGS='-DLEMON_DISABLE_ASSERTS'
[108]137/// \endcode
[118]138/// The checking is also disabled when the standard macro \c NDEBUG is defined.
[108]139///
[112]140/// The LEMON assertion system has a wide range of customization
141/// properties. As a default behaviour the failed assertion prints a
142/// short log message to the standard error and aborts the execution.
[66]143///
[108]144/// The following modes can be used in the assertion system:
[66]145///
[112]146/// - \c LEMON_ASSERT_LOG The failed assertion prints a short log
147///   message to the standard error and continues the execution.
[118]148/// - \c LEMON_ASSERT_ABORT This mode is similar to the \c
149///   LEMON_ASSERT_LOG, but it aborts the program. It is the default
150///   behaviour.
[112]151/// - \c LEMON_ASSERT_CUSTOM The user can define own assertion handler
[118]152///   function.
[108]153///   \code
[112]154///     void custom_assert_handler(const char* file, int line, const char* function,
155///                                const char* message, const char* assertion);
[108]156///   \endcode
[118]157///   The name of the function should be defined as the \c
[108]158///   LEMON_CUSTOM_ASSERT_HANDLER macro name.
159///   \code
160///     #define LEMON_CUSTOM_ASSERT_HANDLER custom_assert_handler
161///   \endcode
[118]162///   Whenever an assertion is occured, the custom assertion
163///   handler is called with appropiate parameters.
[66]164///
[112]165/// The assertion mode can also be changed within one compilation unit.
166/// If the macros are redefined with other settings and the
167/// \ref lemon/assert.h "assert.h" file is reincluded, then the
168/// behaviour is changed appropiately to the new settings.
[108]169#  define LEMON_ASSERT(exp, msg)                                        \
170  (static_cast<void> (!!(exp) ? 0 : (                                   \
171    LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                            \
172                         LEMON_FUNCTION_NAME,                           \
[118]173                         ::lemon::_assert_bits::cstringify(msg), #exp), 0)))
[108]174
175/// \ingroup exceptions
[66]176///
[108]177/// \brief Macro for mark not yet implemented features.
178///
179/// Macro for mark not yet implemented features and outstanding bugs.
180/// It is close to be the shortcut of the following code:
181/// \code
182///   LEMON_ASSERT(false, msg);
183/// \endcode
[118]184///
185/// \see LEMON_ASSERT
[108]186#  define LEMON_FIXME(msg)                                              \
[118]187  (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,        \
188                        ::lemon::_assert_bits::cstringify(msg),         \
189                        static_cast<const char*>(0)))
190
191/// \ingroup exceptions
192///
193/// \brief Macro for internal assertions
194///
195/// Macro for internal assertions, it is used in the library to check
196/// the consistency of results of algorithms, several pre- and
197/// postconditions and invariants. The checking is disabled by
198/// default, but it can be turned on with the macro \c
199/// LEMON_ENABLE_DEBUG.
200/// \code
201/// #define LEMON_ENABLE_DEBUG
202/// \endcode
203/// or with compilation parameters:
204/// \code
205/// g++ -DLEMON_ENABLE_DEBUG
206/// make CXXFLAGS='-DLEMON_ENABLE_DEBUG'
207/// \endcode
208///
209/// This macro works like the \c LEMON_ASSERT macro, therefore the
210/// current behaviour depends on the settings of \c LEMON_ASSERT
211/// macro.
212///
213/// \see LEMON_ASSERT
214#  define LEMON_DEBUG(exp, msg)                                         \
215  (static_cast<void> (!!(exp) ? 0 : (                                   \
216    LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                            \
217                         LEMON_FUNCTION_NAME,                           \
218                         ::lemon::_assert_bits::cstringify(msg), #exp), 0)))
[66]219
220#else
221
[108]222#  ifndef LEMON_ASSERT_HANDLER
[112]223#    define LEMON_ASSERT(exp, msg)  (static_cast<void>(0))
[108]224#    define LEMON_FIXME(msg) (static_cast<void>(0))
[118]225#    define LEMON_DEBUG(exp, msg) (static_cast<void>(0))
[66]226#  else
[118]227#    define LEMON_ASSERT(exp, msg)                                      \
228       (static_cast<void> (!!(exp) ? 0 : (                              \
229        LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                        \
230                             LEMON_FUNCTION_NAME,                       \
231                             ::lemon::_assert_bits::cstringify(msg),    \
232                             #exp), 0)))
233#    define LEMON_FIXME(msg)                                            \
[108]234       (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,   \
[118]235                             ::lemon::_assert_bits::cstringify(msg),    \
236                             static_cast<const char*>(0)))
237
238#    if LEMON_ENABLE_DEBUG
239#      define LEMON_DEBUG(exp, msg)
240         (static_cast<void> (!!(exp) ? 0 : (         \
241           LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \
242                                LEMON_FUNCTION_NAME, \
243                                ::lemon::_assert_bits::cstringify(msg), \
244                                #exp), 0)))
245#    else
246#      define LEMON_DEBUG(exp, msg) (static_cast<void>(0))
247#    endif
[66]248#  endif
[108]249
[66]250#endif
251
[118]252#ifdef DOXYGEN
[66]253
[118]254
255#else
256
257
258#endif
259
260
Note: See TracBrowser for help on using the repository browser.