charset_utf8.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Patrick P. Frey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#ifndef __TEXTWOLF_CHARSET_UTF8_HPP__
#define __TEXTWOLF_CHARSET_UTF8_HPP__
#include "textwolf/char.hpp"
#include "textwolf/charset_interface.hpp"
#include "textwolf/exception.hpp"
#include <cstddef>

namespace textwolf {
namespace charset {

struct UTF8
{
        enum {MaxChar=0x7FFFFFFFU};
        enum {
                B11111111=0xFF,
                B01111111=0x7F,
                B00111111=0x3F,
                B00011111=0x1F,
                B00001111=0x0F,
                B00000111=0x07,
                B00000011=0x03,
                B00000001=0x01,
                B00000000=0x00,
                B10000000=0x80,
                B11000000=0xC0,
                B11100000=0xE0,
                B11110000=0xF0,
                B11111000=0xF8,
                B11111100=0xFC,
                B11111110=0xFE,

                B11011111=B11000000|B00011111,
                B11101111=B11100000|B00001111,
                B11110111=B11110000|B00000111,
                B11111011=B11111000|B00000011,
                B11111101=B11111100|B00000001
        };

        struct CharLengthTab    :public CharMap<unsigned char, 0>
        {
                CharLengthTab()
                {
                        (*this)
                        (B00000000,B01111111,1)
                        (B11000000,B11011111,2)
                        (B11100000,B11101111,3)
                        (B11110000,B11110111,4)
                        (B11111000,B11111011,5)
                        (B11111100,B11111101,6)
                        (B11111110,B11111110,7)
                        (B11111111,B11111111,8);
                }
        };

        template <class Iterator>
        static inline unsigned int size( char* buf, unsigned int& bufpos, Iterator& itr)
        {
                static CharLengthTab charLengthTab;
                if (bufpos==0)
                {
                        buf[0] = *itr;
                        ++itr;
                        ++bufpos;
                }
                return charLengthTab[ (unsigned char)buf[ 0]];
        }

        template <class Iterator>
        static inline void skip( char* buf, unsigned int& bufpos, Iterator& itr)
        {
                unsigned int bufsize = size( buf, bufpos, itr);
                for (;bufpos < bufsize; ++bufpos)
                {
                        ++itr;
                }
        }

        template <class Iterator>
        static inline signed char asciichar( char* buf, unsigned int& bufpos, Iterator& itr)
        {
                if (bufpos==0)
                {
                        buf[0] = *itr;
                        ++itr;
                        ++bufpos;
                }
                return ((unsigned char)(buf[0])>127)?-1:buf[0];
        }

        template <class Iterator>
        static inline void fetchbytes( char* buf, unsigned int& bufpos, Iterator& itr)
        {
                if (bufpos==0)
                {
                        buf[0] = *itr;
                        ++itr;
                        ++bufpos;
                }
                unsigned int bufsize = size( buf, bufpos, itr);
                for (;bufpos < bufsize; ++bufpos)
                {
                        buf[ bufpos] = *itr;
                        ++itr;
                }
        }

        template <class Iterator>
        UChar value( char* buf, unsigned int& bufpos, Iterator& itr) const
        {
                fetchbytes( buf, bufpos, itr);

                UChar res = (unsigned char)buf[0];
                if (res > 127)
                {
                        int gg = bufpos-2;
                        if (gg < 0) return MaxChar;

                        res = ((unsigned char)buf[0])&(B00011111>>gg);
                        for (int ii=0; ii<=gg; ii++)
                        {
                                unsigned char xx = (unsigned char)buf[ii+1];
                                res = (res<<6) | (xx & B00111111);
                                if ((unsigned char)(xx & B11000000) != B10000000)
                                {
                                        return MaxChar;
                                }
                        }
                }
                return res;
        }

        template <class Buffer_>
        void print( UChar chr, Buffer_& buf) const
        {
                unsigned int rt;
                if (chr <= 127)
                {
                        buf.push_back( (char)(unsigned char)chr);
                        return;
                }
                unsigned int pp,sf;
                for (pp=1,sf=5; pp<5; pp++,sf+=5)
                {
                        if (chr < (unsigned int)((1<<6)<<sf)) break;
                }
                rt = pp+1;
                unsigned char HB = (unsigned char)(B11111111 << (8-rt));
                unsigned char shf = (unsigned char)(pp*6);
                unsigned int ii;
                buf.push_back( (char)(((unsigned char)(chr >> shf) & (~HB >> 1)) | HB));
                for (ii=1,shf-=6; ii<=pp; shf-=6,ii++)
                {
                        buf.push_back( (char)(unsigned char) (((chr >> shf) & B00111111) | B10000000));
                }
        }

        static bool is_equal( const UTF8&, const UTF8&)
        {
                return true;
        }
};

}//namespace
}//namespace
#endif