utf.h

Go to the documentation of this file.

 
#ifndef __UTF_H__
#define __UTF_H__
 
#include <stdint.h>
 
#define UTF8_1BYTE_CODEMAX 0x7F
#define UTF8_2BYTE_CODEMAX 0x7FF
#define UTF8_3BYTE_CODEMAX 0xFFFF
#define UTF8_4BYTE_CODEMAX 0x10FFFF
 
#define UTF8_1BYTE_MASK   0x80
#define UTF8_2BYTE_MASK   0xE0
#define UTF8_3BYTE_MASK   0xF0
#define UTF8_4BYTE_MASK   0xF8
#define UTF8_EXTBYTE_MASK 0xC0
 
#define UTF8_1BYTE_PREFIX   0x00
#define UTF8_2BYTE_PREFIX   0xC0
#define UTF8_3BYTE_PREFIX   0xE0
#define UTF8_4BYTE_PREFIX   0xF0
#define UTF8_EXTBYTE_PREFIX 0x80
 
#define UTF8_IS_1BYTE(ptr) ((ptr[0] & UTF8_1BYTE_MASK) == UTF8_1BYTE_PREFIX)
 
#define UTF8_IS_2BYTE(ptr)                                                                         \
    (((ptr[0] & UTF8_2BYTE_MASK) == UTF8_2BYTE_PREFIX) &&                                          \
     ((ptr[1] & UTF8_EXTBYTE_MASK) == UTF8_EXTBYTE_PREFIX))
 
#define UTF8_IS_3BYTE(ptr)                                                                         \
    (((ptr[0] & UTF8_3BYTE_MASK) == UTF8_3BYTE_PREFIX) &&                                          \
     (((ptr[1] | ptr[2]) & UTF8_EXTBYTE_MASK) == UTF8_EXTBYTE_PREFIX))
 
#define UTF8_IS_4BYTE(ptr)                                                                         \
    (((ptr[0] & UTF8_4BYTE_MASK) == UTF8_4BYTE_PREFIX) &&                                          \
     (((ptr[1] | ptr[2] | ptr[3]) & UTF8_EXTBYTE_MASK) == UTF8_EXTBYTE_PREFIX))
 
static inline unsigned utf8CharToUnicode(const char* ptr, unsigned len) {
    unsigned code = 0;
 
    if ((len >= 1) && UTF8_IS_1BYTE(ptr)) {
        code = (unsigned)(ptr[0] & (char)~UTF8_1BYTE_MASK);
    } else if ((len >= 2) && UTF8_IS_2BYTE(ptr)) {
        code = (((unsigned)(ptr[0] & (char)~UTF8_2BYTE_MASK) << 6) |
                (ptr[1] & (char)~UTF8_EXTBYTE_MASK));
    } else if ((len >= 3) && UTF8_IS_3BYTE(ptr)) {
        code = (((unsigned)(ptr[0] & (char)~UTF8_3BYTE_MASK) << 12) |
                ((unsigned)(ptr[1] & (char)~UTF8_EXTBYTE_MASK) << 6) |
                (ptr[2] & (char)~UTF8_EXTBYTE_MASK));
    } else if ((len >= 4) && UTF8_IS_4BYTE(ptr)) {
        code = (((unsigned)(ptr[0] & (char)~UTF8_4BYTE_MASK) << 18) |
                ((unsigned)(ptr[1] & (char)~UTF8_EXTBYTE_MASK) << 12) |
                ((unsigned)(ptr[2] & (char)~UTF8_EXTBYTE_MASK) << 6) |
                (ptr[3] & (char)~UTF8_EXTBYTE_MASK));
    }
 
    return (code);
}
 
static inline unsigned utf8CodeWidth(unsigned code) {
    if (code <= UTF8_1BYTE_CODEMAX)
        return (1);
    else if (code <= UTF8_2BYTE_CODEMAX)
        return (2);
    else if (code <= UTF8_3BYTE_CODEMAX)
        return (3);
    else if (code <= UTF8_4BYTE_CODEMAX)
        return (4);
    else
        return (0);
}
 
static inline void unicodeToUtf8Char(unsigned code, unsigned char* ptr, unsigned len) {
    unsigned codeWidth = utf8CodeWidth(code);
 
    if ((codeWidth == 1) && (len >= codeWidth)) {
        ptr[0] = (code & UTF8_1BYTE_CODEMAX);
    } else if ((codeWidth == 2) && (len >= codeWidth)) {
        ptr[0] = (UTF8_2BYTE_PREFIX | ((code & 0x07D0) >> 6));
        ptr[1] = (UTF8_EXTBYTE_PREFIX | (code & 0x003F));
    } else if ((codeWidth == 3) && (len >= codeWidth)) {
        ptr[0] = (UTF8_3BYTE_PREFIX | ((code & 0xF000) >> 12));
        ptr[1] = (UTF8_EXTBYTE_PREFIX | ((code & 0x0FD0) >> 6));
        ptr[2] = (UTF8_EXTBYTE_PREFIX | (code & 0x003F));
    } else if ((codeWidth == 4) && (len >= codeWidth)) {
        ptr[0] = (UTF8_4BYTE_PREFIX | ((code & 0x001D0000) >> 18));
        ptr[1] = (UTF8_EXTBYTE_PREFIX | ((code & 0x0003F000) >> 12));
        ptr[2] = (UTF8_EXTBYTE_PREFIX | ((code & 0x00000FD0) >> 6));
        ptr[3] = (UTF8_EXTBYTE_PREFIX | (code & 0x0000003F));
    }
}
 
#define UTF8_ACCEPT 0
#define UTF8_REJECT 1
 
static uint32_t decode(uint32_t* state, uint32_t* codep, uint32_t byte) {
    static int state_table[32] = {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xxxxxxx */
        1, 1, 1, 1, 1, 1, 1, 1,                         /* 10xxxxxx */
        2, 2, 2, 2,                                     /* 110xxxxx */
        3, 3,                                           /* 1110xxxx */
        4,                                              /* 11110xxx */
        1                                               /* 11111xxx */
    };
 
    static int mask_bytes[32] = {0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F,
                                 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                                 0x00, 0x00, 0x1F, 0x1F, 0x1F, 0x1F, 0x0F, 0x0F, 0x07, 0x00};
 
    static int next[5] = {0, 1, 0, 2, 3};
 
    if (*state == UTF8_ACCEPT) {
        *codep = byte & mask_bytes[byte >> 3];
        *state = state_table[byte >> 3];
    } else if (*state > 0) {
        *codep = (byte & 0x3F) | (*codep << 6);
        *state = next[*state];
    }
    return *state;
    //return 0;
}
 
#endif