qbig5codec.cpp

qt-x11-opensource-src-4.1.4.tar.gz源码

    { 0xc843, 0xf7af },
    { 0xc844, 0xf7b0 },
    { 0xc845, 0xf7b1 },
    { 0xc846, 0xf7b2 },
    { 0xc847, 0xf7b3 },
    { 0xc848, 0xf7b4 },
    { 0xc849, 0xf7b5 },
    { 0xc84a, 0xf7b6 },
    { 0xc84b, 0xf7b7 },
    { 0xc84c, 0xf7b8 },
    { 0xc84d, 0xf7b9 },
    { 0xc84e, 0xf7ba },
    { 0xc84f, 0xf7bb },
    { 0xc850, 0xf7bc },
    { 0xc851, 0xf7bd },
    { 0xc852, 0xf7be },
    { 0xc853, 0xf7bf },
    { 0xc854, 0xf7c0 },
    { 0xc855, 0xf7c1 },
    { 0xc856, 0xf7c2 },
    { 0xc857, 0xf7c3 },
    { 0xc858, 0xf7c4 },
    { 0xc859, 0xf7c5 },
    { 0xc85a, 0xf7c6 },
    { 0xc85b, 0xf7c7 },
    { 0xc85c, 0xf7c8 },
    { 0xc85d, 0xf7c9 },
    { 0xc85e, 0xf7ca },
    { 0xc85f, 0xf7cb },
    { 0xc860, 0xf7cc },
    { 0xc861, 0xf7cd },
    { 0xc862, 0xf7ce },
    { 0xc863, 0xf7cf },
    { 0xc864, 0xf7d0 },
    { 0xc865, 0xf7d1 },
    { 0xc866, 0xf7d2 },
    { 0xc867, 0xf7d3 },
    { 0xc868, 0xf7d4 },
    { 0xc869, 0xf7d5 },
    { 0xc86a, 0xf7d6 },
    { 0xc86b, 0xf7d7 },
    { 0xc86c, 0xf7d8 },
    { 0xc86d, 0xf7d9 },
    { 0xc86e, 0xf7da },
    { 0xc86f, 0xf7db },
    { 0xc870, 0xf7dc },
    { 0xc871, 0xf7dd },
    { 0xc872, 0xf7de },
    { 0xc873, 0xf7df },
    { 0xc874, 0xf7e0 },
    { 0xc875, 0xf7e1 },
    { 0xc876, 0xf7e2 },
    { 0xc877, 0xf7e3 },
    { 0xc878, 0xf7e4 },
    { 0xc87b, 0xf7e7 },
    { 0xc87d, 0xf7e9 },
    { 0xc8a2, 0xf7ec },
    { 0xc8cd, 0xf817 },
    { 0xc8ce, 0xf818 },
    { 0xc8cf, 0xf819 },
    { 0xc8d0, 0xf81a },
    { 0xc8d1, 0xf81b },
    { 0xc8d2, 0xf81c },
    { 0xc8d3, 0xf81d },
    { 0xc8d4, 0xf81e },
    { 0xc8d5, 0xf81f },
    { 0xc8d6, 0xf820 },
    { 0xc8d7, 0xf821 },
    { 0xc8d8, 0xf822 },
    { 0xc8d9, 0xf823 },
    { 0xc8da, 0xf824 },
    { 0xc8db, 0xf825 },
    { 0xc8dc, 0xf826 },
    { 0xc8dd, 0xf827 },
    { 0xc8de, 0xf828 },
    { 0xc8df, 0xf829 },
    { 0xc8e0, 0xf82a },
    { 0xc8e1, 0xf82b },
    { 0xc8e2, 0xf82c },
    { 0xc8e3, 0xf82d },
    { 0xc8e4, 0xf82e },
    { 0xc8e5, 0xf82f },
    { 0xc8e6, 0xf830 },
    { 0xc8e7, 0xf831 },
    { 0xc8e8, 0xf832 },
    { 0xc8e9, 0xf833 },
    { 0xc8ea, 0xf834 },
    { 0xc8eb, 0xf835 },
    { 0xc8ec, 0xf836 },
    { 0xc8ed, 0xf837 },
    { 0xc8ee, 0xf838 },
    { 0xc8ef, 0xf839 },
    { 0xc8f0, 0xf83a },
    { 0xc8f1, 0xf83b },
    { 0xc8f5, 0xf83f },
    { 0xc8f6, 0xf840 },
    { 0xc8f7, 0xf841 },
    { 0xc8f8, 0xf842 },
    { 0xc8f9, 0xf843 },
    { 0xc8fa, 0xf844 },
    { 0xc8fb, 0xf845 },
    { 0xc8fc, 0xf846 },
    { 0xc8fd, 0xf847 },
    { 0xc8fe, 0xf848 },
    { 0xf9fe, 0x2593 }
};

static const B5Map uc_to_b5_map[] = {
    { 0x2550, 0xa2a4 },
    { 0x255e, 0xa2a5 },
    { 0x2561, 0xa2a7 },
    { 0x256a, 0xa2a6 },
    { 0x256d, 0xa27e },
    { 0x256e, 0xa2a1 },
    { 0x256f, 0xa2a3 },
    { 0x2570, 0xa2a2 },
};

static int qt_Big5ToUnicode(const uchar *buf, uint *u)
{
    int start = 0;
    int end = sizeof(b5_to_uc_map)/sizeof(B5Map) - 1;

    uint b5 = (buf[0] << 8) + buf[1];
    while (start <= end) {
        int middle = (end + start + 1)/2;
        if (b5_to_uc_map[middle].x == b5) {
            *u = b5_to_uc_map[middle].y;
            return 2;
        } else if (b5_to_uc_map[middle].x > b5) {
            end = middle - 1;
        } else {
            start = middle + 1;
        }
    }
    return qt_Big5hkscsToUnicode(buf, u);
}

static int qt_UnicodeToBig5(ushort ch, uchar *buf)
{
    int start = 0;
    int end = sizeof(uc_to_b5_map)/sizeof(B5Map) - 1;

    while (start <= end) {
        int middle = (end + start + 1)/2;
        if (uc_to_b5_map[middle].x == ch) {
            buf[0] = uc_to_b5_map[middle].y >> 8;
            buf[1] = uc_to_b5_map[middle].y & 0xff;
            return 2;
        } else if (uc_to_b5_map[middle].x > ch) {
            end = middle - 1;
        } else {
            start = middle + 1;
        }
    }
    return qt_UnicodeToBig5hkscs(ch, buf);
}

QString QBig5Codec::convertToUnicode(const char* chars, int len, ConverterState *state) const
{
    QChar replacement = QChar::ReplacementCharacter;
    uchar buf[2];
    int nbuf = 0;
    if (state) {
        if (state->flags & ConvertInvalidToNull)
            replacement = QChar::Null;
        nbuf = state->remainingChars;
        buf[0] = state->state_data[0];
        buf[1] = state->state_data[1];
    }
    int invalid = 0;

    //qDebug("QBig5Codec::toUnicode(const char* chars = \"%s\", int len = %d)", chars, len);
    QString result;
    for (int i=0; i<len; i++) {
        uchar ch = chars[i];
        switch (nbuf) {
        case 0:
            if (IsLatin(ch)) {
                // ASCII
                result += QLatin1Char(ch);
            } else if (IsFirstByte(ch)) {
                // Big5-ETen
                buf[0] = ch;
                nbuf = 1;
            } else {
                // Invalid
                result += replacement;
                ++invalid;
            }
            break;
        case 1:
            if (IsSecondByte(ch)) {
                // Big5-ETen
                uint u;
                buf[1] = ch;
                if (qt_Big5ToUnicode(buf, &u) == 2)
                    result += QValidChar(u);
                else {
                    // Error
                    result += replacement;
                    ++invalid;
                }
            } else {
                // Error
                result += replacement;
                ++invalid;
            }
            nbuf = 0;
            break;
        }
    }
    if (state) {
        state->remainingChars = nbuf;
        state->state_data[0] = buf[0];
        state->state_data[1] = buf[1];
        state->invalidChars += invalid;
    }
    return result;
}

QByteArray QBig5Codec::convertFromUnicode(const QChar *uc, int len, ConverterState *state) const
{
    char replacement = '?';
    if (state) {
        if (state->flags & ConvertInvalidToNull)
            replacement = 0;
    }

    int invalid = 0;

    int rlen = 2*len + 1;
    QByteArray rstr;
    rstr.resize(rlen);

    uchar* cursor = (uchar*)rstr.data();
    for (int i=0; i<len; i++) {
        ushort ch = uc[i].unicode();
        uchar c[2];
        if (ch < 0x80) {
            // ASCII
            *cursor++ = ch;
        } else if (qt_UnicodeToBig5(ch, c) == 2 && c[0] >= 0xa1 && c[0] <= 0xf9) {
            *cursor++ = c[0];
            *cursor++ = c[1];
        } else {
            *cursor++ = replacement;
            ++invalid;
        }
    }
    rstr.resize(cursor - (uchar*)rstr.constData());

    if (state) {
        state->invalidChars += invalid;
    }
    return rstr;
}

QList<QByteArray> QBig5Codec::_aliases()
{
    QList<QByteArray> aliases;
    aliases += "Big5-ETen";
    aliases += "CP950";
    return aliases;
}

int QBig5hkscsCodec::_mibEnum()
{
    return 2101;
}


QByteArray QBig5hkscsCodec::_name()
{
    return "Big5-HKSCS";
}


QString QBig5hkscsCodec::convertToUnicode(const char* chars, int len, ConverterState *state) const
{
    uchar buf[2];
    int nbuf = 0;
    QChar replacement = QChar::ReplacementCharacter;
    if (state) {
        if (state->flags & ConvertInvalidToNull)
            replacement = QChar::Null;
        nbuf = state->remainingChars;
        buf[0] = state->state_data[0];
        buf[1] = state->state_data[1];
    }
    int invalid = 0;

    //qDebug("QBig5hkscsCodec::toUnicode(const char* chars = \"%s\", int len = %d)", chars, len);
    QString result;
    for (int i=0; i<len; i++) {
        uchar ch = chars[i];
        switch (nbuf) {
        case 0:
            if (IsLatin(ch)) {
                // ASCII
                result += QLatin1Char(ch);
            } else if (IsFirstByte(ch)) {
                // Big5-HKSCS