first commit

extern/ustl/1.5/uexception.h

@@ -0,0 +1,192 @@
+// 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.
+
+#ifndef UEXCEPTION_H_18DE3EF55C4F00673268F0D66546AF5D
+#define UEXCEPTION_H_18DE3EF55C4F00673268F0D66546AF5D
+
+#include "utypes.h"
+#ifndef WITHOUT_LIBSTDCPP
+    #include <exception>
+    #include <new>
+#endif
+#include "bktrace.h"
+
+#if WITHOUT_LIBSTDCPP
+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) throw() __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.
+///
+#if 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 			bad_cast (void) throw()		: exception() {}
+    inline virtual const char*	what (void) const throw()	{ return ("bad cast"); }
+};
+
+class bad_typeid : public exception {
+public:
+    inline			bad_typeid (void) throw()	{ }
+    inline virtual const char*	what (void) const throw()	{ return ("bad typeid"); }
+};
+
+//----------------------------------------------------------------------
+
+/// \class bad_alloc uexception.h ustl.h
+/// \ingroup Exceptions
+///
+/// \brief Exception thrown on memory allocation failure by memblock::reserve.
+///
+#if 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