Exception.cpp

Go to the documentation of this file.

 
#include <dcl/Config.h>
 
#if __DCL_WINDOWS
    #include <windows.h>
#else
    #include <dcl/_string.h>
#endif
 
#include <dcl/Object.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/Exception.h>
#include <dcl/Numeric.h>
 
#if __DCL_DEBUG
#undef __THIS_FILE__
static const char_t* __THIS_FILE__ = __T("dcl/Exception.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
IMPLEMENT_CLASSINFO(Exception, Object)
 
Exception::Exception(Exception* _cause)
{
    __pCause = _cause;
 
#if __DCL_HAVE_ALLOC_DEBUG
    // DCL 내부적으로 new 연산자에 대하여 메모리 검사 플래그가 false
    // 로 되어 있다. Exception 객체는 반드시 destroy 되어야 한다.
    DCLDebugAllocSetCheckFlag(this, true);
#endif
}
 
String Exception::toString() const
{
    return String();
}
 
String Exception::toStringAll() const
{
    StringBuilder sb;
    const Exception* p = this;
    while(p)
    {
        sb += p->className();
#if __DCL_HAVE_ALLOC_DEBUG
        char_t filename[100];
        unsigned int line;
        if (DCLDebugAllocGetPosition(p, filename,
                __countof(filename, char_t), &line)) {
            sb += L": ";
            sb.append(filename);
            sb += L":";
            sb += UInteger::toString(line, 10);
        }
#endif
        sb += L": ";
        sb += p->toString();
 
        p = p->__pCause;
        if (p)
            sb += L"\n";
    }
 
    return sb;
}
 
void Exception::destroy()
{
    if (__pCause)
    {
        __pCause->destroy();
//      __pCause = NULL;
    }
    Object::destroy();
}
 
IMPLEMENT_CLASSINFO(OutOfMemoryException, Exception)
 
OutOfMemoryException::OutOfMemoryException()
{
}
 
IMPLEMENT_CLASSINFO(SysError, Exception)
 
SysError::SysError(Exception* _cause)
    : Exception(_cause)
{
    __errorNo = 0;
}
 
SysError::SysError(uint32_t _errorNo)
{
    __errorNo = _errorNo;
}
 
String SysError::toString() const
{
    StringBuilder sb;
    if (__errorNo & DCL_ERROR_MASK)
    {
        ;
    }
#if __DCL_WINDOWS
    else if (__errorNo & WINAPI_ERROR_MASK)
    {
        uint32_t _errorNo = __errorNo & ERROR_VALUE_MASK;
        wchar_t* msg = NULL;
        DWORD dwLength = ::FormatMessageW( 
                        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
                        FORMAT_MESSAGE_FROM_SYSTEM | 
                        FORMAT_MESSAGE_IGNORE_INSERTS,
                        NULL,
                        _errorNo,
                        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                        (LPWSTR) &msg,
                        0,
                        NULL 
                    );
        
        if (dwLength > 0)
        {
            for ( ; dwLength; dwLength--)
                if (!(msg[dwLength - 1] == L'\r' || msg[dwLength - 1] == L'\n'))
                    break;
 
            sb.assign(msg, dwLength);
            LocalFree(msg);
 
            sb += L" (ERROR=";
            sb += UInt32::toString(_errorNo, 10);
            sb += L")";
        }
        else
            sb = L"::FormatMessage Fail!";
 
    }
#endif
    else
    {
        // errno
        uint32_t _errorNo = __errorNo & ERROR_VALUE_MASK;
 
#if __DCL_WINDOWS
        CharBuffer* buf = CharBuffer::create(256);
        if (_wcserror_s(buf->data(), buf->__allocLength, __errorNo))
            buf->release();
        else
        {
            buf->__dataLength = String::length(buf->data());
            __DCL_ASSERT(buf->data()[buf->__dataLength] == __T('\0'));
            sb.assign(buf);
            buf->release();
        }
#else
        // UNIX
        String s;
        if (__strerror(s, _errorNo) == 0)
            sb += s;
#endif
 
        sb += L" (errno=" + UInt32::toString(_errorNo, 10) + L")";
    }
    return sb;
}
 
IMPLEMENT_CLASSINFO(IOException, SysError)
 
IOException::IOException(const String& _name, Exception* _cause)
    : SysError(_cause)
{
    __message = L"\"" + _name + L"\"";
}
 
IOException::IOException(const String& _name, uint32_t _errorNo)
    : SysError(WINAPI_ERROR(_errorNo))
{
    __message = L"\"" + _name + L"\"";
}
 
IOException::IOException(const String& _name, const String& _message)
{
    __message = L"\"" + _name + L"\"" + __T(" ") + _message;
}
 
String IOException::toString() const
{
    StringBuilder r = __message;
    if (SysError::errorNo() != 0)
        r += __T(" ") + SysError::toString();
 
    return r;
}
 
IMPLEMENT_CLASSINFO(InvalidIndexException, Exception)
 
InvalidIndexException::InvalidIndexException(const String& _key)
    : Exception(NULL)
{
    __message = L"invalid index key: " + _key;
}
 
InvalidIndexException::InvalidIndexException(ssize_t _minValid, ssize_t _maxValid, size_t _errorValue)
    : Exception(NULL)
{
    __message = String::format(
        L"invalid index. valud: %d, valid range: %d <= valud <= %d",
        _errorValue,
        _minValid, 
        _maxValid
        );
}
 
String InvalidIndexException::toString() const
{
    return __message;
}
 
IMPLEMENT_CLASSINFO(ParseException, Exception)
 
ParseException::ParseException(const String& _message)
    : Exception(NULL)
{
    __message = _message;
    __sourceOffset = -1;
}
 
ParseException::ParseException(const String& _message, size_t _sourceOffset)
    : Exception(NULL)
{
    __message = _message;
    __sourceOffset = _sourceOffset;
}
 
String ParseException::toString() const
{
    StringBuilder sb = __message;
    if (__sourceOffset >= 0)
    {
        sb += L": offset:";
#if __WORDSIZE == 64
        sb += UInt64::toString(__sourceOffset, 10);
#else
        sb += UInt32::toString(__sourceOffset, 10);
#endif
    }
    return sb;
}
 
IMPLEMENT_CLASSINFO(NumericConvertException, ParseException)
 
// eInvalidNumberString
NumericConvertException::NumericConvertException(
                const String& _number,
                int _radix,
                size_t _sourceOffset
                 )
    : ParseException(_number, _sourceOffset)
{
    __error = InvalidNumberString;
    __radix = _radix;
}
 
// eOverflow or eUnderflow
NumericConvertException::NumericConvertException(
                Error _error,
                const String& _number,
                int _radix          //  = 0,
                )
    : ParseException(_number)
{
    __DCL_ASSERT(_error == Overflow || _error == Underflow);
    __error = _error;
    __radix = _radix;
}
 
String NumericConvertException::toString() const
{
    StringBuilder sb;
    if (__error == InvalidNumberString)
    {
        sb = L"Invalid number string: \"" 
            + ParseException::__message
            + L"\"";
 
        if (__radix > 0)
        {
            sb += L", radix:";
            sb += Int32::toString(__radix, 10);
        }
 
        if (ParseException::__sourceOffset >= 0)
        {
            sb += L", offset:";
#if __WORDSIZE == 64
            sb += Int64::toString(ParseException::__sourceOffset, 10);
#else
            sb += Int32::toString(ParseException::__sourceOffset, 10);
#endif
        }
    }
    else
    {
        if (__error == Overflow)
            sb = L"Numerical result overflow \"";
        else
            sb = L"Numerical result underflow \"";
        sb += ParseException::__message + L"\"";
 
        if (__radix > 0)
        {
            sb += L", radix:";
            sb += Int32::toString(__radix, 10);
        }
    }
 
    return sb;
}
 
IMPLEMENT_CLASSINFO(GenerialException, Exception)
 
GenerialException::GenerialException(Exception* _cause)
    : Exception(_cause)
{
}
 
GenerialException::GenerialException(const wchar_t* pszErrorMessage)
    : Exception(NULL)
{
    __DCL_ASSERT(pszErrorMessage != NULL);
    __message = pszErrorMessage;
}
 
String GenerialException::toString() const
{
    StringBuilder sb = __message;
 
    if (Exception::__pCause)
        sb += L": See! Detail";
 
    return  sb;
}
 
IMPLEMENT_CLASSINFO(AssertError, Exception)
 
AssertError::AssertError(
                const char_t*     _filename, 
                unsigned int        _line,
                const char_t*     _expr,
                const char_t*     _message
                    )
    : Exception(NULL)
{
    __DCL_ASSERT(_filename != NULL);
    __DCL_ASSERT(_expr != NULL);
 
    __filename = _filename;
    __line = _line;
 
    __expr = _expr;
    if (_message)
        __message = _message;
}
 
String AssertError::toString() const
{
    return format(__filename, __line, __expr,
        __message.isEmpty() ? NULL : __message.data());
}
 
String AssertError::format(
            const char_t*     _filename, 
            unsigned int        _line,
            const char_t*     _expr,
            const char_t*     _message
            )
{
    StringBuilder sb = L"Assertion Failed ! '";
    sb += _expr;
    sb += L"'";
    if (_message)
    {
        sb += L" ";
        sb += _message;
    }
    sb += L", File ";
    sb += _filename;
    sb += L":";
    sb += Int32::toString((int32_t)_line, 10);
 
 
    return sb;
}
 
 
/*
 
IMPLEMENT_CLASSINFO(SocketException, SysCallException)
 
SocketException::SocketException(const char* pszErrorMessage)
    : Exception(NULL)
{
    __DCL_ASSERT(pszErrorMessage != NULL);
    __message = pszErrorMessage;
}
 
String SocketException::toString() const
{
    return Exception::toStringHeader() + __message;
}
 
*/
 
__DCL_END_NAMESPACE