Subversion Repositories openrisc

// This file is part of the uSTL library, an STL implementation.

//

// Copyright (c) 2005-2009 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) __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 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.

///

#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