/Users/mourrain/Devel/mmx/basix/include/basix/exception.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : exception.hpp
* DESCRIPTION: The type for exceptional behaviour
* COPYRIGHT  : (C) 2006  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#ifndef __EXCEPTION_HPP
#define __EXCEPTION_HPP
#include <basix/syntactic.hpp>


namespace mmx {

/******************************************************************************
* The exception class for generic error messages
******************************************************************************/

class exception {
MMX_ALLOCATORS
  generic rep;
public:
  inline generic operator * () const { return rep; }
  inline exception (): rep (generic ("empty exception")) {}
  inline exception (const generic& g): rep (g) {}
  inline exception (const exception& e): rep (e.rep) {}
  exception (const string& msg, const generic& where);
};

inline nat hash (const exception& e) { return hash (*e); }
inline nat exact_hash (const exception& e) { return exact_hash (*e); }
inline nat hard_hash (const exception& e) { return hard_hash (*e); }
inline bool operator == (const exception& e1, const exception& e2) {
  return (*e1) == (*e2); }
inline bool operator != (const exception& e1, const exception& e2) {
  return (*e1) != (*e2); }
inline bool exact_eq (const exception& e1, const exception& e2) {
  return exact_eq (*e1, *e2); }
inline bool exact_neq (const exception& e1, const exception& e2) {
  return exact_neq (*e1, *e2); }
inline bool hard_eq (const exception& e1, const exception& e2) {
  return hard_eq (*e1, *e2); }
inline bool hard_neq (const exception& e1, const exception& e2) {
  return hard_neq (*e1, *e2); }

inline syntactic flatten (const exception& e) { return flatten (*e); }

generic std_exception (const string& msg, const generic& where);
generic std_exception (const string& msg, const generic& a, const generic& w);
generic user_exception (const vector<generic>& msg, const generic& where);
generic wrong_nr_args (const generic& where);
generic type_mismatch (const generic& expect, const generic& where);
generic trace_push (const generic& exc, const generic& where);
generic trace_pull (const generic& exc);
generic trace_top (const generic& exc);
generic trace_bottom (const generic& exc, nat n= 1);
bool    has_trace (const generic& exc);

/******************************************************************************
* C++ exceptions
******************************************************************************/

#ifdef BASIX_ENABLE_EXCEPTIONS

exception as_exception (const generic& x);

exception error_message (const char* msg);
exception error_message (const string& msg);
#define STRINGIFY(x) #x
#define TOSTRING(x) STRINGIFY(x)
#define ERROR(msg) \
  throw mmx::error_message (__FILE__ ":" TOSTRING(__LINE__) ": " msg);
#define ASSERT(expr,msg)                                         \
  if (!(expr)) ERROR (msg);
#else // disable exceptions
#define ERROR(msg) assert(false)
#define ASSERT(expr,msg) assert(expr)
#endif

#ifdef BASIX_ENABLE_VERIFY
#define VERIFY(expr,msg) ASSERT(expr,msg)
#define XVERIFY(expr,msg,x) \
  if (!(expr)) mmerr << "failed for instance " << x << "\n";    \
  ASSERT(expr,msg)
#else // disable verifications
#define VERIFY(expr,msg)
#define XVERIFY(expr,msg,x)
#endif

volatile void fatal_error (char* message, char* routine, char* file);

/******************************************************************************
* C++ name demangling -- for when ABI is available
******************************************************************************/

string cpp_demangle (const char* name);

} // namespace mmx
#endif // __EXCEPTION_HPP