~frankencode/drycore/trunk

 /*

  * Copyright (C) 2007-2013 Frank Mertens.

  *

  * This program is free software; you can redistribute it and/or

  * modify it under the terms of the GNU General Public License

  * as published by the Free Software Foundation; either version

  * 2 of the License, or (at your option) any later version.

  */

#ifndef DRY_UTF8ENCODER_HPP

#define DRY_UTF8ENCODER_HPP

 

#include "ByteEncoder.hpp"

 

namespace dry

{

 

class Utf8Encoder: public Sink<uchar_t>

{

public:

        inline static Ref<Utf8Encoder> open(Stream *stream, int bufSize = 0x4000) {

                return new Utf8Encoder(stream, bufSize);

        }

 

        inline static Ref<Utf8Encoder> open(void *buf, int bufSize) {

                return new Utf8Encoder(buf, bufSize);

        }

 

        void write(uchar_t ch);

        static int encodedSize(uchar_t ch);

 

        inline ByteEncoder *byteEncoder() const { return byteEncoder_; }

 

private:

        Utf8Encoder(Stream *stream, int bufSize)

                : byteEncoder_(ByteEncoder::open(stream, bufSize))

        {}

 

        Utf8Encoder(void *buf, int bufSize)

                : byteEncoder_(ByteEncoder::open(buf, bufSize))

        {}

 

        Ref<ByteEncoder> byteEncoder_;

};

 

inline void Utf8Encoder::write(uchar_t ch)

{

        if (ch < 0x80) { // ASCII range: 0xxxxxxx

                byteEncoder_->writeUInt8(ch);

        }

        else if (ch < 0x800) { // two-byte codes: 110yyyxx | 10xxxxx

                byteEncoder_->writeUInt8((ch >> 6) | 0xC0);   // 0xC = (1100)2, code prefix: (110)2

                byteEncoder_->writeUInt8((ch & 0x3F) | 0x80); // 0x8 = (1000)2, code prefix: (10)2

        }

        else if (ch < 0x10000) { // three-byte codes: 1110yyyy | 10yyyyxx | 10xxxxxx

                if ((0xD800 <= ch) && (ch <= 0xDFFF))

                        DRY_THROW(EncodingException, "UTF-8 disallows encoding of UTF-16 surrogate pairs 0xD800..0xDFFF");

                else if ((0xFDD0 <= ch) && (ch <= 0xFDEF))

                        DRY_THROW(EncodingException, "UTF-8 disallows encoding of non-characters 0xFDD0..0xFDEF");

                byteEncoder_->writeUInt8((ch >> 12) | 0xE0);         // 0xE = (1110)2, code prefix: (1110)2

                byteEncoder_->writeUInt8(((ch >> 6) & 0x3F) | 0x80); // 0x8 = (1000)2, code prefix: (10)2

                byteEncoder_->writeUInt8((ch & 0x3F) | 0x80);        // 0x8 = (1000)2, code prefix: (10)2

        }

        else if (ch < 0x110000) { // four-byte codes: 11110zzz | 10zzyyyy | 10yyyyxx | 10xxxxxx

                if ((ch & 0xFFFE) == 0xFFFE)

                        DRY_THROW(EncodingException, "UTF-8 disallows encoding of non-characters 0x??FFFE,0x??FFFF");

                byteEncoder_->writeUInt8((ch >> 18) | 0xF0);           // 0xF = (1111)2, code prefix: (11110)2

                byteEncoder_->writeUInt8(((ch >> 12) & 0x3F) | 0x80); // 0x8 = (1000)2, code prefix: (10)2

                byteEncoder_->writeUInt8(((ch >> 6) & 0x3F) | 0x80);  // 0x8 = (1000)2, code prefix: (10)2

                byteEncoder_->writeUInt8((ch & 0x3F) | 0x80);         // 0x8 = (1000)2, code prefix: (10)2

        }

        else {

                DRY_THROW(EncodingException, "UTF-8 disallows encoding of code points above 0x10FFFF");

        }

}

 

inline int Utf8Encoder::encodedSize(uchar_t ch)

{

        int n = 0;

        if (ch < 0x80)         n = 1; // ASCII range: 0xxxxxxx

        else if (ch < 0x800)   n = 2; // two-byte codes: 110yyyxx | 10xxxxx

        else if (ch < 0x10000) n = 3; // three-byte codes: 1110yyyy | 10yyyyxx | 10xxxxxx

        else if (ch < 0x11000) n = 4; // four-byte codes: 11110zzz | 10zzyyyy | 10yyyyxx | 10xxxxxx

        return n;

}

 

} // namespace dry

 

#endif // DRY_UTF8ENCODER_HPP