source: trunk/sample/EncodeString.cpp @ 25

#include <iconv.h>
#include "EncodeString.hpp"

using namespace std;

EncodeStringImpl::cnmap_t const EncodeStringImpl::CharsetNames = {
    { chset_Utf8, "UTF-8" }, { chset_C99, "C99" }, { chset_Java, "JAVA" },
    { chset_Ucs2, "UCS-2" }, { chset_Ucs2Be, "UCS-2BE" }, { chset_Ucs2Le, "UCS-2LE" },
    { chset_Ucs4, "UCS-4" }, { chset_Ucs4Be, "UCS-4BE" }, { chset_Ucs4Le, "UCS-4LE" },
    { chset_Utf16, "UTF-16" }, { chset_Utf16Be, "UTF-16BE" }, { chset_Utf16Le, "UTF-16LE" },
    { chset_Utf32, "UTF-32" }, { chset_Utf32Be, "UTF-32BE" }, { chset_Utf32Le, "UTF-32LE" },
    { chset_Utf7, "UTF-7" },
    { chset_EucJp, "EUC-JP" }, { chset_EucJis0213, "EUC-JISX0213" },
    { chset_Iso2022Jp, "ISO-2022-JP" }, { chset_Iso2022Jp2, "ISO-2022-JP2" },
    { chset_Iso2022Jp1, "ISO-2022-JP1" }, { chset_Iso2022Jp3, "ISO-2022-JP3" },
    { chset_ShiftJis, "SHIFT_JIS" }, { chset_Cp932, "CP932" }, { chset_ShiftJisX0213, "SHIFT_JISX0213" },
};

EncodeStringImpl::EncodeStringImpl()
{
    result_length = 0;
}

void EncodeStringImpl::encode(void const *src, size_t src_length, size_t chr_size, charset_t from_charset,
    charset_t to_charset)
{
    if (from_charset == to_charset) {
        char const *p = reinterpret_cast<char const *>(src);
        result.assign(p, &p[(src_length + 1) * chr_size]);
        return;
    }
    class auto_iconv_t {
        const iconv_t impl;
    public:
        auto_iconv_t(charset_t from_cs, charset_t to_cs) :
            impl(iconv_open(CharsetNames.find(to_cs)->second, CharsetNames.find(from_cs)->second))
        {
            if (impl == reinterpret_cast<iconv_t>(-1)) {
                throw EncodeStringException(string("LIBICONV initialize error: please check character set name \"") +
                    CharsetNames.find(from_cs)->second + "\"(from) or \"" + CharsetNames.find(to_cs)->second +
                    "\"(to)");
            }
        }
        ~auto_iconv_t() { iconv_close(impl); }
        iconv_t get() const { return impl; }
    } iconv_handle(from_charset, to_charset);
    size_t const src_size = src_length * chr_size;
    result.resize(src_size + TerminateNullCharNum, '\0');   // ヌル文字分余裕を持って確保する。
    char const *from_current = reinterpret_cast<char const *>(src);
    char *to_current = &result[0];
    size_t from_left = src_size, to_left = src_size;
    
#if defined(_ICONV_H)
    while (iconv(iconv_handle.get(), const_cast<char **>(&from_current), &from_left, &to_current, &to_left) ==
    static_cast<size_t>(-1)) {
#elif defined(_LIBICONV_H)
    while (iconv(iconv_handle.get(), &from_current, &from_left, &to_current, &to_left) == static_cast<size_t>(-1)) {
#endif //_ICONV_H, _LIBICONV_H
        // ループ内はエラー処理
        
        if (errno == EINVAL)    // マルチバイトの下位オクテットが欠けている?
            break;
        
        switch (errno) {
        case E2BIG:     // 出力先バッファが足りない
            // バッファを拡張し、継続
            {
                size_t pre_size = result.size();
                result.resize(pre_size + src_size, '\0');
                to_current = &result[pre_size - TerminateNullCharNum - to_left];
                to_left += src_size;
            }
            break;
        case EILSEQ:    // あり得ないコードが出現
            // エラー回避し、続きから変換を継続
            from_current++;
            from_left--;
            break;
        case EBADF:     // 変換に失敗 (原因不明)
            throw EncodeStringException("LIBICONV bad conversion error (EBADF)");
        default:        // 未定義のエラー
            throw EncodeStringException("LIBICONV unknown error");
        }
    }
    result_length = result.size() - to_left - TerminateNullCharNum;
}