UTF-8 Kodlama Algoritması

RFC2231 Kodlaması başlıklı yazıda, wchar_t türündeki bir string'i utf8 olarak kodlamak için işletim sisteminin sağladığı fonksiyonları kullanmıştım. Ancak, daha sonra, kodlama egzersizi olarak wchar_t türündeki bir string'i utf8 olarak kodlayan fonksiyonu kendim yazmak istedim. Referans olarak, RFC 3629'daki tanımlamaları kullandım. Bu yazıda, geniş karakter (wchar_t) türündeki veriyi, nasıl utf8 olarak kodlayabileceğimizden bahsedeceğim.

Bahsettiğim RFC'nin 3. başlığı altında, UTF-8'in tanımı yapılmış. Buna göre, 0x0 ile 0x10FFFF arasındaki unicode karakterler, 1-4 byte dizilimle kodlanıyor. Kodlamada kullanılan her bir byte'a octet (eng. sekizli) deniyor. Tek bir octet'den oluşan dizilimde üst bit (MSB) 0 olmak zorunda, kalan 7 bit ile karakterimizi kodluyoruz. Dolayısıyla, karakter kodu 127 ve altı için, UTF8 kodlama ile us-ascii kodlama eşdeğer oluyor. n octetli'li (n > 1) dizilimlerde iste, ilk octet'in üst n biti 1 olarak, bunları takip eden ilk bit ise 0 olarak ayarlanıp, kalan bitler kodlama amaçlı kullanılıyor. Devamında gelen octetlerin ise, hepsinin en üst biti 1, onu takip eden bit ise 0 olarak ayarlanıp, kalan bitler kodlama amaçlı kullanılıyor. RFC'deki örnek tabloyu buraya kopyalıyorum.

   Karakter Kodu Aralığı  |        UTF-8 octet dizilimi
         (hexadecimal)    |              (binary)
      --------------------+---------------------------------------------
      0000 0000-0000 007F | 0xxxxxxx
      0000 0080-0000 07FF | 110xxxxx 10xxxxxx
      0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
      0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

Şimdi adım adım, UTF8 kodlama algoritmasının aşamalarına geçeceğiz. Aşamalara geçmeden önce, işimizi daha anlaşılır yapabilmek için, tanımlamalarımızı yapalım.

#define UTF8_OCTET1_MAX 0x7F
#define UTF8_OCTET2_MAX 0x7FF
#define UTF8_OCTET3_MAX 0xFFFF
#define UTF8_OCTET4_MAX 0x10FFFF

#define UTF8_SEQUENCE1_START 0x00
#define UTF8_SEQUENCE2_START 0xC0
#define UTF8_SEQUENCE3_START 0xE0
#define UTF8_SEQUENCE4_START 0xF0

#define UTF8_CONTINUATION_BYTE 0x80
#define UTF8_CONTINUATION_BYTE_MASK 0x3F

İlk 4 tanım, sırasıyla 1 octet, 2 octet, 3 octet ve 4 octet ile kodlanabilecek karakter kodlarının üst sınırını belirtiyor. Bu sayılarını doğrudan örnek tablodan kopyaladım. Daha sonra gelen 4 tanım ise, yine sırasıyla 1 octet, 2 octet, 3 octet ve 4 octet dizilimlerinde ilk octet'in üst bitlerinde olması gereken değeri belirtiyor. Bu sayıları elde etmek için, örnek tabloda binary olarak gösterilen birinci octet'leri (b00000000,b11000000,b11100000,b11110000), hex gösterimine çevirdim. UTF8_CONTINUATION_BYTE tanımı, çoklu octet dizilimlerinde, her bir octet'in üst bitlerinin alması gerektiği değeri gösteriyor. Bunu da aynı şekilde örnek tablodan hex'e çevirdim. Son olarak, UTF8_CONTINUATION_BYTE_MASK ile tanımlanan değeri, bir sayının en alttaki 6 bitini maskelemek için kullanacağım.

Şimdi adım adım, algoritmayı inceleyelim. Birinci adım olarak, karakterin kaç octet ile kodlanacağını hesaplayacağız. Bunun için mümkün olan en düşük octet sayının kullanacağız.

// 1. Gerekli Octet Sayısını Hesapla
size_t cbOctet = 1  
               + (c > UTF8_OCTET1_MAX)
               + (c > UTF8_OCTET2_MAX)
               + (c > UTF8_OCTET3_MAX)
               + (c > UTF8_OCTET4_MAX);

Yukarıdaki örnekte, eğer UTF8_OCTET4_MAX'dan büyük bir karakter kodu ile karşılaşırsak, cbOctet 5 olacak. En fazla 4 octet kullanabileceğimiz için, bu durumu hata durumu olarak değerlendireceğiz. İkinci adımda ise, kullanılacak octet'lerin, üst bitleri tabloda gösterildiği şekilde ayarlayacağız.

// 2a. Başlangıç octet'inin üst bitlerini ayala
switch (cbOctet)
{
    case 1:
        result[0] = UTF8_SEQUENCE1_START;
        break;
    case 2:
        result[0] = UTF8_SEQUENCE2_START;
        break;
    case 3:
        result[0] = UTF8_SEQUENCE3_START;
        break;
    case 4:
        result[0] = UTF8_SEQUENCE4_START;
        break;
    default: // utf8 ile kodlanamayacak bir karakter varsa, 0 döndür
        return 0;
}

// 2b. devam octetlerinin üst bitlerini ayarla
size_t i;
for(i = 1; i < cbOctet; i++)
{
    result[i] = UTF8_CONTINUATION_BYTE;
}

İkinci adımda çok ilginç birşey yok. Her bir octet'in üst bitlerini olması gerektiği gibi ayarlayıp, kalan bitlerini sıfırladık. Üçüncü adımda, karakter kodundaki bitleri, octet'lerdeki kullanılabilir bitlere kopyalacağız. Bunun için, karakter kodunun en alttaki bitlerini en sondaki octet'e kopyalarak, yukarı doğru devam edeceğiz. Bunu yapmak için, en baştaki octet dışında, UTF8_CONTINUATION_BYTE_MASK maskesi ile alttaki 6 biti seçip, karakter kodunu 6 bit sağa kaydıracağız. En baştaki octet'e gelindiğinde, sadece ihtiyacımız olan bitler kaldığı için, herhangi bir maskeleme yapmamıza gerek yok.

// 3. Son octetten başa doğru, bitleri
// doldur. Her devam octet'inde 6'şar
// bit kullanacağız. Geriye kalan bitler
// teknik olarak başlangıç octet'ine
// sığmak zorunda
for(i = cbOctet; i > 1; i--)
{
    result[i-1] |= c & UTF8_CONTINUATION_BYTE_MASK;
    c = c >> 6;
}

result[0] |= c;

Böylece, tek bir unicode karakteri, utf8 olarak kodlamış olduk. Bu işlemi bir string üzerinde gerçekleştirmek için, sırayla tüm karakleri yukarıdaki şekilde kodlamak yeterli. Örnek programın son hali aşağıdaki gibi olacak.

#include <stdlib.h> // malloc
#include <string.h> // memcpy
#include <stdio.h>  // fopen, fwrite, fclose
#include <wchar.h>  // wchar_t

#define UTF8_OCTET1_MAX 0x7F
#define UTF8_OCTET2_MAX 0x7FF
#define UTF8_OCTET3_MAX 0xFFFF
#define UTF8_OCTET4_MAX 0x10FFFF

#define UTF8_SEQUENCE1_START 0x00
#define UTF8_SEQUENCE2_START 0xC0
#define UTF8_SEQUENCE3_START 0xE0
#define UTF8_SEQUENCE4_START 0xF0

#define UTF8_CONTINUATION_BYTE 0x80
#define UTF8_CONTINUATION_BYTE_MASK 0x3F

size_t utf8_encode_char(wchar_t c, unsigned char result[4])
{
    // 1. Gerekli Octet Sayısını Hesapla
    size_t cbOctet = 1  
                   + (c > UTF8_OCTET1_MAX)
                   + (c > UTF8_OCTET2_MAX)
                   + (c > UTF8_OCTET3_MAX)
                   + (c > UTF8_OCTET4_MAX);


    // 2a. Başlangıç octet'inin üst bitlerini ayala
    switch (cbOctet)
    {
        case 1:
            result[0] = UTF8_SEQUENCE1_START;
            break;
        case 2:
            result[0] = UTF8_SEQUENCE2_START;
            break;
        case 3:
            result[0] = UTF8_SEQUENCE3_START;
            break;
        case 4:
            result[0] = UTF8_SEQUENCE4_START;
            break;
        default: // utf8 ile kodlanamayacak bir karakter varsa, 0 döndür
            return 0;
    }

    // 2b. devam octetlerinin üst bitlerini ayarla
    size_t i;
    for(i = 1; i < cbOctet; i++)
    {
        result[i] = UTF8_CONTINUATION_BYTE;
    }

    // 3. Son octetten başa doğru, bitleri
    // doldur. Her devam octet'inde 6'şar
    // bit kullanacağız. Geriye kalan bitler
    // teknik olarak başlangıç octet'ine
    // sığmak zorunda
    for(i = cbOctet; i > 1; i--)
    {
        result[i-1] |= c & UTF8_CONTINUATION_BYTE_MASK;
        c = c >> 6;
    }

    result[0] |= c;

    return cbOctet;
}

/*
    IN: wchar_t *pwszWide: NULL ile biten, wchar_t stringi
    OUT: size_t *cbEncoded : Kodlamış string'in boyutu

    RETURN: utf8 ile kodlanmış, NULL ile biten array
*/
char *utf8_encode(wchar_t *pwszWide, size_t *cbEncoded)
{
    *cbEncoded = 0;
    size_t cbTemp;
    unsigned char encoded_char[4];
    wchar_t *pwcTemp;
    char    *pcTemp2;

    // realloc yapmak zorunda kalmamak için
    // pwszWide üzerinden 1 tur geçip, kodlanmış
    // veri için gerekli hafızayı hesaplayacağız.
    for(pwcTemp = pwszWide; *pwcTemp; pwcTemp++)
    {
        *cbEncoded += utf8_encode_char(*pwcTemp, encoded_char);
    }

    char *pszEncoded = malloc(*cbEncoded + 1); // +1 null

    for(pwcTemp = pwszWide, pcTemp2 = pszEncoded; *pwcTemp; pwcTemp++)
    {
        cbTemp = utf8_encode_char(*pwcTemp, encoded_char);
        memcpy(pcTemp2, encoded_char, cbTemp);
        pcTemp2 += cbTemp;
    }

    *pcTemp2 = 0; // NULL terminator

    return pszEncoded;
}

int main(void)
{

    wchar_t example1[] = L"İŞTE BUNLAR HEP TÜRKÇE KARAKTERLER: ÜĞİŞÇÖ";
    wchar_t example2[] = {0xD55C, 0xAD6D, 0xC5B4, 0x0}; // korece korece
    wchar_t example3[] = {0x65E5, 0x672C, 0x8A9E, 0x0}; // japonca japon
    wchar_t example4[] = {0x233B4, 0x0};                // çince bir karater

    FILE *f = fopen("examples.txt","wb");

    size_t cbEncoded;
    char *pszEncoded = utf8_encode(example1, &cbEncoded);
    fprintf(f, "%s\n", pszEncoded);
    free(pszEncoded);

    pszEncoded = utf8_encode(example2, &cbEncoded);
    fprintf(f, "%s\n", pszEncoded);
    free(pszEncoded);

    pszEncoded = utf8_encode(example3, &cbEncoded);
    fprintf(f, "%s\n", pszEncoded);
    free(pszEncoded);

    pszEncoded = utf8_encode(example4, &cbEncoded);
    fprintf(f, "%s\n", pszEncoded);
    free(pszEncoded);

    fclose(f);


}

Öyle sanıyorum ki, yukarıdaki kodlarda optimize edilebilecek kısımlar vardır. Ancak, kolayca anlaşılabilr olması açısından, yapılabilecek optimizasyonlara dikkat etmedim. Faydalı bir yazı olmuştur diye ümit ediyorum.