// This file is part of the ustl library, an STL implementation.
//
// Copyright (C) 2005 by Mike Sharov <msharov@users.sourceforge.net>
// This file is free software, distributed under the MIT License.
//
// uexception.h
//
// This file contains stuff from \<exception\>.
// The standard C++ headers are duplicated because uSTL is intended
// to completely replace all C++ standard library functions.
//
#ifndef UEXCEPTION_H_18DE3EF55C4F00673268F0D66546AF5D
#define UEXCEPTION_H_18DE3EF55C4F00673268F0D66546AF5D
#include "utypes.h"
#ifndef WITHOUT_LIBSTDCPP
#include <exception>
#include <new>
#endif
#include "bktrace.h"
#ifdef WITHOUT_LIBSTDCPP // This code is copied from <exception>
namespace std {
/// If you write a replacement terminate handler, it must be of this type.
typedef void (*terminate_handler) (void);
/// If you write a replacement unexpected handler, it must be of this type.
typedef void (*unexpected_handler) (void);
/// Takes a new handler function as an argument, returns the old function.
terminate_handler set_terminate (terminate_handler pHandler) throw();
/// The runtime will call this function if exception handling must be
/// abandoned for any reason. It can also be called by the user.
void terminate (void) __attribute__ ((__noreturn__));
/// Takes a new handler function as an argument, returns the old function.
unexpected_handler set_unexpected (unexpected_handler pHandler) throw();
/// The runtime will call this function if an exception is thrown which
/// violates the function's exception specification.
void unexpected (void) __attribute__ ((__noreturn__));
/// Returns true when the caught exception violates the throw specification.
bool uncaught_exception() throw();
} // namespace std
#endif
namespace ustl {
class string;
typedef uint32_t xfmt_t;
enum {
xfmt_Exception,
xfmt_BadAlloc,
xfmt_LibcException = 12,
xfmt_FileException = 13,
xfmt_StreamBoundsException = 14
};
/// \class exception uexception.h ustl.h
/// \ingroup Exceptions
///
/// \brief Base class for exceptions, equivalent to std::exception.
///
#ifdef WITHOUT_LIBSTDCPP
class exception {
#else
class exception : public std::exception {
#endif
public:
typedef const CBacktrace& rcbktrace_t;
public:
inline exception (void) throw() : m_Format (xfmt_Exception) {}
inline virtual ~exception (void) throw() {}
inline virtual const char* what (void) const throw() { return ("error"); }
virtual void info (string& msgbuf, const char* fmt = NULL) const throw();
virtual void read (istream& is);
virtual void write (ostream& os) const;
void text_write (ostringstream& os) const;
inline virtual size_t stream_size (void) const { return (sizeof(m_Format) + sizeof(uint32_t) + m_Backtrace.stream_size()); }
/// Format of the exception is used to lookup exception::info format string.
/// Another common use is the instantiation of serialized exceptions, used
/// by the error handler node chain to troubleshoot specific errors.
inline xfmt_t format (void) const { return (m_Format); }
inline rcbktrace_t backtrace (void) const { return (m_Backtrace); }
protected:
inline void set_format (xfmt_t fmt) { m_Format = fmt; }
private:
CBacktrace m_Backtrace; ///< Backtrace of the throw point.
xfmt_t m_Format; ///< Format of the exception's data.
};
/// \class bad_cast uexception.h ustl.h
/// \ingroup Exceptions
///
/// \brief Thrown to indicate a bad dynamic_cast usage.
///
class bad_cast : public exception {
public:
inline explicit bad_cast (void) throw() : exception() {}
inline virtual const char* what (void) const throw() { return ("bad cast"); }
};
//----------------------------------------------------------------------
/// \class bad_alloc uexception.h ustl.h
/// \ingroup Exceptions
///
/// \brief Exception thrown on memory allocation failure by memblock::reserve.
///
#ifdef WITHOUT_LIBSTDCPP
class bad_alloc : public exception {
#else
class bad_alloc : public std::bad_alloc, public exception {
#endif
public:
explicit bad_alloc (size_t nBytes = 0) throw();
inline virtual const char* what (void) const throw() { return ("memory allocation failed"); }
virtual void info (string& msgbuf, const char* fmt = NULL) const throw();
virtual void read (istream& is);
virtual void write (ostream& os) const;
virtual size_t stream_size (void) const;
protected:
size_t m_nBytesRequested; ///< Number of bytes requested by the failed allocation.
};
/// \class libc_exception uexception.h ustl.h
/// \ingroup Exceptions
///
/// \brief Thrown when a libc function returns an error.
///
/// Contains an errno and description. This is a uSTL extension.
///
class libc_exception : public exception {
public:
explicit libc_exception (const char* operation) throw();
libc_exception (const libc_exception& v) throw();
const libc_exception& operator= (const libc_exception& v);
inline virtual const char* what (void) const throw() { return ("libc function failed"); }
virtual void info (string& msgbuf, const char* fmt = NULL) const throw();
virtual void read (istream& is);
virtual void write (ostream& os) const;
virtual size_t stream_size (void) const;
protected:
intptr_t m_Errno; ///< Error code returned by the failed operation.
const char* m_Operation; ///< Name of the failed operation.
};
/// \class file_exception uexception.h ustl.h
/// \ingroup Exceptions
///
/// \brief File-related exceptions.
///
/// Contains the file name. This is a uSTL extension.
///
class file_exception : public libc_exception {
public:
file_exception (const char* operation, const char* filename) throw();
inline virtual const char* what (void) const throw() { return ("file error"); }
virtual void info (string& msgbuf, const char* fmt = NULL) const throw();
virtual void read (istream& is);
virtual void write (ostream& os) const;
virtual size_t stream_size (void) const;
protected:
char m_Filename [PATH_MAX]; ///< Name of the file causing the error.
};
/// \class stream_bounds_exception uexception.h ustl.h
/// \ingroup Exceptions
///
/// \brief Stream bounds checking.
///
/// Only thrown in debug builds unless you say otherwise in config.h
/// This is a uSTL extension.
///
class stream_bounds_exception : public libc_exception {
public:
stream_bounds_exception (const char* operation, const char* type, uoff_t offset, size_t expected, size_t remaining) throw();
inline virtual const char* what (void) const throw() { return ("stream bounds exception"); }
virtual void info (string& msgbuf, const char* fmt = NULL) const throw();
virtual void read (istream& is);
virtual void write (ostream& os) const;
virtual size_t stream_size (void) const;
protected:
const char* m_TypeName;
uoff_t m_Offset;
size_t m_Expected;
size_t m_Remaining;
};
const char* demangle_type_name (char* buf, size_t bufSize, size_t* pdmSize = NULL);
} // namespace ustl
#endif