source: trunk/sample/guessutf8.cpp @ 15

/**
    @file   guessutf8.cpp
    @brief  libiconv を用いた文字セット自動認識処理のサンプル (内部コード UCS4 版)
    @author T.MURACHI (Toshiyuki Murayama) / (C)2010 Harapeko Inc.
*/

#include <string>
#include <map>
#include <vector>
#include <cstdio>
#include <cerrno>
#include <iconv.h>
#include <exception>

using namespace std;

/// 文字を扱う内部コード型
typedef uint32_t ucs4_t;
typedef basic_string<ucs4_t, char_traits<ucs4_t>, allocator<ucs4_t> > ucs4string;

/**
    @brief  デコード時例外クラス
*/
class UcsDecoderException : public exception
{
    const string message;
    UcsDecoderException();
    UcsDecoderException &operator =(const UcsDecoderException &);
public:
    UcsDecoderException(const string &mess) : exception(), message(mess) {}
    UcsDecoderException(const UcsDecoderException &src) : exception(), message(src.message) {}
    virtual ~UcsDecoderException() throw () {}
    virtual const char* what() const throw () { return message.c_str(); }
};

/**
    @brief  エンコード時例外クラス
*/
class UcsEncoderException : public exception
{
    const string message;
    UcsEncoderException();
    UcsEncoderException &operator =(const UcsEncoderException &);
public:
    UcsEncoderException(const string &mess) : exception(), message(mess) {}
    UcsEncoderException(const UcsEncoderException &src) : exception(), message(src.message) {}
    virtual ~UcsEncoderException() throw () {}
    virtual const char* what() const throw () { return message.c_str(); }
};

/**
    @brief デコーダクラス
    
    ファイルから読み込んだ文字列データを、内部コードの文字列に変換する。
    変換時に、元の文字列データの文字セットを自動認識する。
*/
class UcsDecoder
{
    char *src;
    ucs4string result;
    size_t src_size;
    
    // デフォルトコンストラクタ、コピーコンストラクタ、代入演算子は使用禁止
    UcsDecoder();
    UcsDecoder(const UcsDecoder &);
    UcsDecoder &operator =(const UcsDecoder &);
    
    /// 文字コードセットのリスト
    static char const* const ENCODE_LIST[];
    
    
    typedef map<string, int> IllSeqCountMap;
    typedef IllSeqCountMap::value_type IllSeqCountPair;
    typedef IllSeqCountMap::const_iterator IllSeqCountCIter;
    
public:
    /**
        @brief コンストラクタ
        @param bytes    (I) ファイルから読み込んだ文字列データ
        
        引数に渡された文字列データの文字セットを解析し、 UCS4 の内部コードを生成する。
        UCS4 テキストには get() メソッドにてアクセスできる。
    */
    UcsDecoder(char const* bytes)
    {
        src_size = 0;
        while (*bytes++) src_size++;
        src_size++;
        bytes -= src_size;
        src = new char[src_size];
        char *tp = src;
        while (*tp++ = *bytes++) ;
        
        string guess_encode = guessEncodeType();
        fprintf(stderr, "guess encode type: %s\n", guess_encode.c_str());
        decodeToUcs4(guess_encode);
    }
    
    /**
        @brief 内部コードテキストを取得する
        @return 内部コードに変換されたテキストの文字列オブジェクト。
    */
    ucs4string const& get() const { return result; }
    
    ~UcsDecoder()
    {
        delete[] src;
    }

private:
    // 文字セットを解析する。
    string guessEncodeType() const
    {
        IllSeqCountMap ill_seq_count_map;
        for (char const* const* encode_type = ENCODE_LIST; *encode_type; encode_type++) {
            iconv_t iconv_handle = iconv_open("UCS-4-INTERNAL", *encode_type);
            if (iconv_handle == reinterpret_cast<iconv_t>(-1)) {
                throw UcsDecoderException(string("iconv_open faild: from_code = ") + *encode_type +
                    ", to_code = UCS-4-INTERNAL");
            }
            char const* from_current = src;
            vector<ucs4_t> buf(src_size);
            char * to_current = reinterpret_cast<char *>(&buf[0]);
            size_t from_left = src_size - 1, to_left = (src_size - 1) * sizeof(ucs4_t);
            int ill_seq_count = 0;
            for (;;) {
                size_t ret = iconv(iconv_handle, &from_current, &from_left, &to_current, &to_left);
                // エラー無し
                if (ret != static_cast<size_t>(-1))
                    break;
                
                // マルチバイトの下位オクテッドが欠けている場合、
                // データソースはここで終了しているはずなので、エラーはカウントせず終了。
                if (errno == EINVAL)
                    break;
                
                switch (errno) {
                    case E2BIG:
                        // 出力先バッファのサイズが足りない。
                        // 変換自体が目的ではないので、続きは上書きする。
                        to_current = reinterpret_cast<char *>(&buf[0]);
                        to_left = src_size * sizeof(ucs4_t);
                        break;
                    case EILSEQ:
                        // あり得ないコードが出現。
                        // エラーをカウントし、続きから変換を継続する。
                        ill_seq_count++;
                        from_current++;
                        from_left--;
                        break;
                    case EBADF:
                        // 何らかの理由により変換に失敗。通常はあり得ないはず。
                        iconv_close(iconv_handle);
                        throw UcsDecoderException("iconv faild");
                    default:
                        // 未定義のエラー番号
                        iconv_close(iconv_handle);
                        throw UcsDecoderException("unknown error");
                }
            }
            iconv_close(iconv_handle);
            
            // エラーが一つもなければ確定
            if (ill_seq_count == 0)
                return *encode_type;
            
            ill_seq_count_map[*encode_type] = ill_seq_count;
        }
        // エラーの数が最も少ないものを候補として返す。
        string guess_code;
        int ill_seq_count = 0;
        for (IllSeqCountCIter i = ill_seq_count_map.begin(); i != ill_seq_count_map.end(); i++) {
            if (ill_seq_count == 0 || i->second < ill_seq_count) {
                ill_seq_count = i->second;
                guess_code = i->first;
            }
        }
        return guess_code;
    }
    
    // 元データの文字セットを指定して、 UCS4 内部コードテキストに変換する。
    void decodeToUcs4(const string &encode_type)
    {
        iconv_t iconv_handle = iconv_open("UCS-4-INTERNAL", encode_type.c_str());
        if (iconv_handle == reinterpret_cast<iconv_t>(-1)) {
            throw UcsDecoderException(string("iconv_open faild: from_code = ") + encode_type +
                ", to_code = UCS-4-INTERNAL");
        }
        char const* from_current = src;
        vector<ucs4_t> buf(src_size, 0);
        char * to_current = reinterpret_cast<char *>(&buf[0]);
        size_t from_left = src_size - 1, to_left = (src_size - 1) * sizeof(ucs4_t);
        for (;;) {
            size_t ret = iconv(iconv_handle, &from_current, &from_left, &to_current, &to_left);
            // エラー無し
            if (ret != static_cast<size_t>(-1))
                break;
            
            // マルチバイトの下位オクテッドが欠けている場合、
            // データソースはここで終了しているはずなので、ここまでで終了。
            if (errno == EINVAL)
                break;
            
            switch (errno) {
                case E2BIG:
                    // 出力先バッファのサイズが足りない。
                    // バッファを拡張し、継続する。
                    {
                        size_t pre_size = buf.size();
                        buf.resize(pre_size + src_size, 0);
                        to_current = reinterpret_cast<char *>(&buf[pre_size - 1 - (to_left / sizeof(ucs4_t))]);
                        to_left += src_size * sizeof(ucs4_t);
                    }
                    break;
                case EILSEQ:
                    // あり得ないコードが出現。
                    // エラーを回避し、続きから変換を継続する。
                    from_current++;
                    from_left--;
                    break;
                case EBADF:
                    // 何らかの理由により変換に失敗。通常はあり得ないはず。
                    iconv_close(iconv_handle);
                    throw UcsDecoderException("iconv faild");
                default:
                    // 未定義のエラー番号
                    iconv_close(iconv_handle);
                    throw UcsDecoderException("unknown error");
            }
        }
        iconv_close(iconv_handle);
        result = &buf[0];
    }
};

char const* const UcsDecoder::ENCODE_LIST[] = {
    "UTF-8", "C99",// "JAVA",
    "EUC-JP",// "EUC-JISX0213",
    "UCS-2", "UCS-2BE", "UCS-2LE",
    "UCS-4",
    "UTF-16", "UTF-16BE", "UTF-16LE",
    "UTF-32", "UTF-32BE", "UTF-32LE",
    "ISO-2022-JP", "ISO-2022-JP-2", "ISO-2022-JP-1",// "ISO-2022-JP-3",
    "UTF-7",
    "SHIFT_JIS", "CP932",// "SHIFT_JISX0213",
    "UCS-4BE", "UCS-4LE",
    NULL
};

/**
    @brief エンコーダクラス
    
    内部コードの文字列を、UTF-8 形式の文字列データに変換する。
*/
class UcsEncoder
{
    const ucs4string ucs_text;
    vector<char> result_bytes;
    
    // デフォルトコンストラクタ、コピーコンストラクタ、代入演算子は使用禁止
    UcsEncoder();
    UcsEncoder(const UcsEncoder &);
    UcsEncoder &operator =(const UcsEncoder &);
    
public:
    /**
        @brief コンストラクタ
        @param src  (I) UCS4 内部コード文字列
        
        引数に渡された UCS4 内部コード文字列を、UTF-8 形式の文字列データに変換する。
    */
    UcsEncoder(const ucs4string &src) : ucs_text(src), result_bytes(src.size() + 1, '\0')
    {
        encodeFromUcs4();
    }
    /**
        @brief UTF-8 形式の文字列データを取得する
        @return UTF-8 形式の文字列データへのポインタ
    */
    char const* get() const { return &result_bytes[0]; }
    
private:
    // UCS4 内部コード文字列を UTF-8 形式に変換する
    void encodeFromUcs4()
    {
        iconv_t iconv_handle = iconv_open("UTF-8", "UCS-4-INTERNAL");
        if (iconv_handle == reinterpret_cast<iconv_t>(-1)) {
            throw UcsEncoderException("iconv_open faild: from_code = UCS-4-INTERNAL, to_code = UTF-8");
        }
        char const* from_current = reinterpret_cast<char const*>(ucs_text.c_str());
        char * to_current = &result_bytes[0];
        size_t from_left = ucs_text.size() * sizeof(ucs4_t), to_left = ucs_text.size();
        for (;;) {
            size_t ret = iconv(iconv_handle, &from_current, &from_left, &to_current, &to_left);
            // エラー無し
            if (ret != static_cast<size_t>(-1))
                break;
            
            // マルチバイトの下位オクテッドが欠けている場合、
            // データソースはここで終了しているはずなので、ここまでで終了。
            // ※ありえないが…
            if (errno == EINVAL)
                break;
            
            switch (errno) {
                case E2BIG:
                    // 出力先バッファのサイズが足りない。
                    // バッファを拡張し、継続する。
                    {
                        size_t pre_size = result_bytes.size();
                        result_bytes.resize(pre_size + ucs_text.size(), '\0');
                        to_current = reinterpret_cast<char *>(&result_bytes[pre_size - 1 - to_left]);
                        to_left += ucs_text.size();
                    }
                    break;
                case EILSEQ:
                    // あり得ないコードが出現。
                    // エラーを回避し、続きから変換を継続する。
                    from_current++;
                    from_left--;
                    break;
                case EBADF:
                    // 何らかの理由により変換に失敗。通常はあり得ないはず。
                    iconv_close(iconv_handle);
                    throw UcsEncoderException("iconv faild");
                default:
                    // 未定義のエラー番号
                    iconv_close(iconv_handle);
                    throw UcsEncoderException("unknown error");
            }
        }
        iconv_close(iconv_handle);
    }
};

int main()
{
    try {
        // 標準入力を一気読み…
        vector<char> buf(32768, '\0');
        char * target = &buf[0];
        size_t readed_size = 0;
        for (;;) {
            readed_size += fread(target, 1, 32767, stdin);
            if (ferror(stdin))
                throw "stdin read error";
            if (feof(stdin)) {
                buf[readed_size] = '\0';
                break;
            }
            size_t pre_size = buf.size();
            buf.resize(pre_size + 32767, '\0');
            target = &buf[pre_size - 1];
        }
        // デコード
        ucs4string text = UcsDecoder(&buf[0]).get();
        // 「、」を「,」に変換する
        for (size_t i = text.find_first_of(0x3001ul); i != ucs4string::npos; i = text.find_first_of(0x3001ul, i + 1))
            text[i] = 0x2cul;
        // 「。」を「.」に変換する
        for (size_t i = text.find_first_of(0x3002ul); i != ucs4string::npos; i = text.find_first_of(0x3002ul, i + 1))
            text[i] = 0x2eul;
        // エンコードして出力
        fputs(UcsEncoder(text).get(), stdout);
    }
    
    catch (UcsDecoderException const& ex) {
        fprintf(stderr, "guessutf8: UCS Decoding error - %s\n", ex.what());
        return 1;
    }
    catch (UcsEncoderException const& ex) {
        fprintf(stderr, "guessutf8: UCS Encoding error - %s\n", ex.what());
        return 1;
    }
    catch (exception const& ex) {
        fprintf(stderr, "guessutf8: Unknown error - %s\n", ex.what());
        return 1;
    }
    catch (char const* mess) {
        fprintf(stderr, "guessutf8: main() error - %s\n", mess);
        return 1;
    }
    catch (...) {
        throw;
    }
    
    return 0;
}