exception.cpp

Go to the documentation of this file.

 
// expand _TEST_EXPORT macros
#define _RWSTD_TEST_SRC
 
#include <rw_exception.h>
#include <rw_driver.h>   
#include <rw_printf.h>
 
#include <string.h>         // for size_t, strcpy()
#include <stdlib.h>         // for free()
#include <stdarg.h>         // for va_arg(), va_list
#include <new>              // for std::bad_alloc
 
 
_TEST_EXPORT int
rw_vasnprintf (char**, size_t*, const char*, va_list);
 
static int
_rw_format (char** pbuf, size_t* pbufsize, const char* file, int line,
            const char* function, const char* fmt, va_list va);
 
 
Exception::~Exception ()
{
}
 
 
struct ExceptionBase
{
private:
    struct ExceptionString;
 
public:
    char             buf_ [256];
    ExceptionString* ex_str_;
 
    ExceptionBase ();
    ExceptionBase (const ExceptionBase&);
 
    ~ExceptionBase ();
 
    ExceptionBase& operator= (const ExceptionBase&);
 
    void format (const char* file, int line, const char* function,
        const char* fmt, va_list va);
 
    const char* what () const;
 
private:
 
    struct ExceptionString
    {
        long  refs_;
        char* str_;
 
        void init (char* str)
        {
            refs_ = 1;
            str_ = str;
        }
 
        void addref () { ++refs_; }
 
        long release ()
        {
            if (0 == --refs_) {
                free (str_);
                str_ = 0;
            }
            return refs_;
        }
 
    private:
        // not defined
        ExceptionString (const ExceptionString&);
        ExceptionString& operator= (const ExceptionString&);
    };
 
 
    void free_ ();
};
 
ExceptionBase::ExceptionBase () : ex_str_ (0)
{
    buf_ [0] = '\0';
}
 
ExceptionBase::ExceptionBase (const ExceptionBase& ex) : ex_str_ (0)
{
    *this = ex;
}
 
ExceptionBase::~ExceptionBase ()
{
    free_ ();
}
 
ExceptionBase& ExceptionBase::operator= (const ExceptionBase& ex)
{
    if (&ex != this) {
 
        free_ ();
 
        if (ex.ex_str_) {
            ex_str_ = ex.ex_str_;
            ex_str_->addref ();
        }
        else
            strcpy (buf_, ex.buf_);
    }
 
    return *this;
}
 
 
void ExceptionBase::
format (const char* file, int line,
        const char* function, const char* fmt, va_list va)
{
    free_ ();
 
    char* tmpbuf = 0;
    size_t bufsize = 0;
 
    const int nchars =
        _rw_format (&tmpbuf, &bufsize, file, line, function, fmt, va);
 
    if (0 > nchars)
        return;
 
    if (sizeof buf_ <= size_t (nchars)) {
        // tmpbuf_ size is too small
        ex_str_ = _RWSTD_STATIC_CAST (ExceptionString*,
                                      malloc (sizeof (*ex_str_)));
 
        if (ex_str_) {
            ex_str_->init (tmpbuf);
            return;
        }
    }
 
    // buf_ size if enough or cannot allocate memory for the ex_str_
    const size_t len =
        size_t (nchars) < sizeof buf_ ? size_t (nchars) : sizeof buf_ - 1;
    memcpy (buf_, tmpbuf, len);
    buf_ [len] = '\0';
    free (tmpbuf);
}
 
 
const char* ExceptionBase::what () const
{
    return ex_str_ && ex_str_->str_ ? ex_str_->str_ : buf_;
}
 
void ExceptionBase::free_ ()
{
    buf_ [0] = '\0';
 
    if (ex_str_ && 0 == ex_str_->release ()) {
        free (ex_str_);
        ex_str_ = 0;
    }
}
 
 
struct BadAlloc : std::bad_alloc, ExceptionBase
{
    BadAlloc ()
    {
    }
 
    BadAlloc (const ExceptionBase& ex) : ExceptionBase (ex)
    {
    }
 
    ~BadAlloc () _THROWS (()) {}
 
    const char* what () const _THROWS (())
    {
        const char* msg = ExceptionBase::what ();
        return (msg && msg[0]) ? msg : std::bad_alloc::what ();
    }
};
 
 
struct StreamException : Exception, ExceptionBase
{
    StreamException () : Exception (ex_stream)
    {
    }
 
    StreamException (const ExceptionBase& ex) :
        Exception (ex_stream), ExceptionBase (ex)
    {
    }
 
    const char* what () const
    {
        return ExceptionBase::what ();
    }
};
 
 
static int
_rw_format (char** pbuf, size_t* pbufsize, const char* file, int line,
            const char* function, const char* fmt, va_list va)
{
    const int nchars1 = function ?
        rw_asnprintf (pbuf, pbufsize, "\"%s\", %d, \"%s\" ",
                      file, line, function) :
        rw_asnprintf (pbuf, pbufsize, "\"%s\", %d, ", file, line);
 
    if (0 > nchars1)
        return nchars1;
 
    char *tmpbuf = 0;
    size_t tmpsize = 0;
 
    const int nchars2 = rw_vasnprintf (&tmpbuf, &tmpsize, fmt, va);
 
    if (0 > nchars2) {
        free (tmpbuf);
        return nchars1;
    }
 
    const int nchars3 = rw_asnprintf (pbuf, pbufsize, "%{+}%s", tmpbuf);
 
    free (tmpbuf);
 
    return 0 > nchars3 ? nchars1 : nchars1 + nchars3;
}
 
_TEST_EXPORT void
rw_throw (ExceptionId exid, const char *file, int line,
          const char *function, const char *fmt, ...)
{
    va_list va;
    va_start (va, fmt);
 
    ExceptionBase base;
    base.format (file, line, function, fmt, va);
 
    va_end (va);
 
    switch (exid) {
 
    case ex_stream:
        throw StreamException (base);
 
    case ex_bad_alloc:
        throw BadAlloc (base);
 
    default:
        throw ex_unknown;
    }
}