UTF8Decoder Class Reference

#include <Charset.h>

Inheritance diagram for UTF8Decoder:

Protected Member Functions
virtual int	toWideChar (const byte_t *_mbs, size_t _mbslen, ucs4_t *_uc)
Protected Member Functions inherited from CharsetDecoder
	CharsetDecoder ()
Protected Member Functions inherited from Object
virtual	~Object ()
	Object ()

Additional Inherited Members
Public Member Functions inherited from CharsetDecoder
virtual int	decode (const byte_t *_in, size_t &_inCount, wchar_t *_out, size_t &_outCount)
size_t	getDecodedLength (const char *_mbs, size_t _mbslen) __DCL_THROWS1(CharsetConvertException *)
String	decode (const char *_mbs, size_t _mbslen=(size_t) -1) __DCL_THROWS1(CharsetConvertException *)
String	decode (const ByteString &_str) __DCL_THROWS1(CharsetConvertException *)
Public Member Functions inherited from Object
virtual String	toString () const
virtual void	destroy ()
String	className () const
bool	isInstanceOf (const std::type_info &typeinfo) const
virtual const std::type_info &	typeInfo () const

Detailed Description

Definition at line 174 of file Charset.h.

Member Function Documentation

toWideChar()

int UTF8Decoder::toWideChar ( const byte_t * _mbs, size_t _mbslen, ucs4_t * _uc )

protectedvirtual

Implements CharsetDecoder.

Definition at line 180 of file CharsetDecoder.cpp.

{
    int count = 0;
    while (_mbslen > 0) {
        byte_t c = _mbs[0];
 
        if (c < 0x80) {
            *_uc = c;
            return count + 1;
        }
        else if (c < 0xC2) {
            return ILLEGAL_SEQUENCE;
        }
        else if (c < 0xE0) {
            if (_mbslen < 2)
                return SOURCE_FEW_N(0);
 
            if (!((_mbs[1] ^ 0x80) < 0x40))
                return ILLEGAL_SEQUENCE;
 
            *_uc = ((ucs4_t)(c & 0x1F) << 6)
                | (ucs4_t)(_mbs[1] ^ 0x80);
            
            return count + 2;
        }
        else if (c < 0xF0) {
            if (_mbslen < 3)
                return SOURCE_FEW_N(0);
 
            if (!((_mbs[1] ^ 0x80) < 0x40 && (_mbs[2] ^ 0x80) < 0x40
                && (c >= 0xE1 || _mbs[1] >= 0xA0)))
                return ILLEGAL_SEQUENCE;
 
            ucs4_t ucTemp = ((ucs4_t) (c & 0x0F) << 12)
                | ((ucs4_t) (_mbs[1] ^ 0x80) << 6)
                | (ucs4_t) (_mbs[2] ^ 0x80);
            if (ucTemp == 0xFEFF) {
                // BOM
                __hasBOM = true;
                _mbslen -= 3;
                _mbs += 3;
            }
            else {
                *_uc = ucTemp;
                return count + 3;
            }
        }
        else if (c < 0xF8) {
            if (_mbslen < 4)
                return SOURCE_FEW_N(0);
 
            if (!((_mbs[1] ^ 0x80) < 0x40 && (_mbs[2] ^ 0x80) < 0x40
                && (_mbs[3] ^ 0x80) < 0x40 && (c >= 0xF1 || _mbs[1] >= 0x90)))
                return ILLEGAL_SEQUENCE;
 
            *_uc = ((ucs4_t) (c & 0x07) << 18)
                | ((ucs4_t) (_mbs[1] ^ 0x80) << 12)
                | ((ucs4_t) (_mbs[2] ^ 0x80) << 6)
                | (ucs4_t) (_mbs[3] ^ 0x80);
 
            return count + 4;
        }
        else if (c < 0xFC) {
            if (_mbslen < 5)
                return SOURCE_FEW_N(0);
 
            if (!((_mbs[1] ^ 0x80) < 0x40 && (_mbs[2] ^ 0x80) < 0x40
                && (_mbs[3] ^ 0x80) < 0x40 && (_mbs[4] ^ 0x80) < 0x40
                && (c >= 0xF9 || _mbs[1] >= 0x88)))
                return ILLEGAL_SEQUENCE;
 
            *_uc = ((ucs4_t) (c & 0x03) << 24)
                | ((ucs4_t) (_mbs[1] ^ 0x80) << 18)
                | ((ucs4_t) (_mbs[2] ^ 0x80) << 12)
                | ((ucs4_t) (_mbs[3] ^ 0x80) << 6)
                | (ucs4_t) (_mbs[4] ^ 0x80);
 
            return count + 5;
        }
        else if (c < 0xFE) {
            if (_mbslen < 6)
                return SOURCE_FEW_N(0);
 
            if (!((_mbs[1] ^ 0x80) < 0x40 && (_mbs[2] ^ 0x80) < 0x40
                && (_mbs[3] ^ 0x80) < 0x40 && (_mbs[4] ^ 0x80) < 0x40
                && (_mbs[5] ^ 0x80) < 0x40
                && (c >= 0xFD || _mbs[1] >= 0x84)))
                return ILLEGAL_SEQUENCE;
 
            *_uc = ((ucs4_t) (c & 0x01) << 30)
                | ((ucs4_t) (_mbs[1] ^ 0x80) << 24)
                | ((ucs4_t) (_mbs[2] ^ 0x80) << 18)
                | ((ucs4_t) (_mbs[3] ^ 0x80) << 12)
                | ((ucs4_t) (_mbs[4] ^ 0x80) << 6)
                | (ucs4_t) (_mbs[5] ^ 0x80);
 
                return count + 6;
        }
        else
            return ILLEGAL_SEQUENCE;
    }
    return SOURCE_FEW_N(0);
}

---

The documentation for this class was generated from the following files:

• Charset.h
• CharsetDecoder.cpp