qchar.cpp File Reference

#include "qchar.h"
#include "qdatastream.h"
#include "qtextcodec.h"
#include "qunicodetables_p.h"
#include "qunicodetables.cpp"

Go to the source code of this file.

Classes
struct	UCS2Pair

Macros
#define	FLAG(x)   (1 << (x))

Enumerations
enum	{   Hangul_SBase = 0xac00, Hangul_LBase = 0x1100, Hangul_VBase = 0x1161, Hangul_TBase = 0x11a7,   Hangul_SCount = 11172, Hangul_LCount = 19, Hangul_VCount = 21, Hangul_TCount = 28,   Hangul_NCount = 21*28 }

Functions
static void	canonicalOrderHelper (QString *str, QChar::UnicodeVersion version, int from)
static void	composeHelper (QString *str, QChar::UnicodeVersion version, int from)
static void	decomposeHelper (QString *str, bool canonical, QChar::UnicodeVersion version, int from)
static const unsigned short *QT_FASTCALL	decompositionHelper (uint ucs4, int *length, int *tag, unsigned short *buffer)
static uint	foldCase (const ushort *ch, const ushort *start)
static uint	foldCase (uint ch, uint &last)
static ushort	foldCase (ushort ch)
static ushort	ligatureHelper (ushort u1, ushort u2)
bool	operator< (ushort u1, const UCS2Pair &ligature)
bool	operator< (const UCS2Pair &ligature, ushort u1)

Macro Definition Documentation

FLAG

#define FLAG

(

x

)

(1 << (x))

Definition at line 66 of file qchar.cpp.

Referenced by QChar::isLetter(), QChar::isLetterOrNumber(), QChar::isMark(), QChar::isNumber(), QChar::isPrint(), QChar::isPunct(), QChar::isSpace(), and QChar::isSymbol().

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
Hangul_SBase
Hangul_LBase
Hangul_VBase
Hangul_TBase
Hangul_SCount
Hangul_LCount
Hangul_VCount
Hangul_TCount
Hangul_NCount

Definition at line 1054 of file qchar.cpp.

     {
    Hangul_SBase = 0xac00,
    Hangul_LBase = 0x1100,
    Hangul_VBase = 0x1161,
    Hangul_TBase = 0x11a7,
    Hangul_SCount = 11172,
    Hangul_LCount = 19,
    Hangul_VCount = 21,
    Hangul_TCount = 28,
    Hangul_NCount = 21*28
};

Function Documentation

canonicalOrderHelper()

static void canonicalOrderHelper ( QString *  str, QChar::UnicodeVersion  version, int  from  )

static

Definition at line 1821 of file qchar.cpp.

Referenced by qt_string_normalize().

{
    QString &s = *str;
    const int l = s.length()-1;
    int pos = from;
    while (pos < l) {
        int p2 = pos+1;
        uint u1 = s.at(pos).unicode();
        if (QChar(u1).isHighSurrogate()) {
            ushort low = s.at(p2).unicode();
            if (QChar(low).isLowSurrogate()) {
                u1 = QChar::surrogateToUcs4(u1, low);
                if (p2 >= l)
                    break;
                ++p2;
            }
        }
        uint u2 = s.at(p2).unicode();
        if (QChar(u2).isHighSurrogate() && p2 < l) {
            ushort low = s.at(p2+1).unicode();
            if (QChar(low).isLowSurrogate()) {
                u2 = QChar::surrogateToUcs4(u2, low);
                ++p2;
            }
        }

        ushort c2 = 0;
        {
            const QUnicodeTables::Properties *p = qGetProp(u2);
            if (p->unicodeVersion != QChar::Unicode_Unassigned && p->unicodeVersion <= version)
                c2 = p->combiningClass;
        }
        if (c2 == 0) {
            pos = p2+1;
            continue;
        }

        ushort c1 = 0;
        {
            const QUnicodeTables::Properties *p = qGetProp(u1);
            if (p->unicodeVersion != QChar::Unicode_Unassigned && p->unicodeVersion <= version)
                c1 = p->combiningClass;
        }

        if (c1 > c2) {
            QChar *uc = s.data();
            int p = pos;
            // exchange characters
            if (!QChar::requiresSurrogates(u2)) {
                uc[p++] = u2;
            } else {
                uc[p++] = QChar::highSurrogate(u2);
                uc[p++] = QChar::lowSurrogate(u2);
            }
            if (!QChar::requiresSurrogates(u1)) {
                uc[p++] = u1;
            } else {
                uc[p++] = QChar::highSurrogate(u1);
                uc[p++] = QChar::lowSurrogate(u1);
            }
            if (pos > 0)
                --pos;
            if (pos > 0 && s.at(pos).isLowSurrogate())
                --pos;
        } else {
            ++pos;
            if (QChar::requiresSurrogates(u1))
                ++pos;
        }
    }
}

composeHelper()

static void composeHelper ( QString *  str, QChar::UnicodeVersion  version, int  from  )

static

Definition at line 1776 of file qchar.cpp.

Referenced by qt_string_normalize().

{
    QString &s = *str;

    if (from < 0 || s.length() - from < 2)
        return;

    // the loop can partly ignore high Unicode as all ligatures are in the BMP
    int starter = -2; // to prevent starter == pos - 1
    int lastCombining = 255; // to prevent combining > lastCombining
    int pos = from;
    while (pos < s.length()) {
        uint uc = s.at(pos).unicode();
        if (QChar(uc).isHighSurrogate() && pos < s.length()-1) {
            ushort low = s.at(pos+1).unicode();
            if (QChar(low).isLowSurrogate()) {
                uc = QChar::surrogateToUcs4(uc, low);
                ++pos;
            }
        }
        const QUnicodeTables::Properties *p = qGetProp(uc);
        if (p->unicodeVersion == QChar::Unicode_Unassigned || p->unicodeVersion > version) {
            starter = -1; // to prevent starter == pos - 1
            lastCombining = 255; // to prevent combining > lastCombining
            ++pos;
            continue;
        }
        int combining = p->combiningClass;
        if ((starter == pos - 1 || combining > lastCombining) && starter >= from) {
            // allowed to form ligature with S
            QChar ligature = ligatureHelper(s.at(starter).unicode(), uc);
            if (ligature.unicode()) {
                s[starter] = ligature;
                s.remove(pos, 1);
                continue;
            }
        }
        if (!combining)
            starter = pos;
        lastCombining = combining;
        ++pos;
    }
}

decomposeHelper()

static void decomposeHelper ( QString *  str, bool  canonical, QChar::UnicodeVersion  version, int  from  )

static

Definition at line 1698 of file qchar.cpp.

Referenced by qt_string_normalize().

{
    unsigned short buffer[3];

    QString &s = *str;

    const unsigned short *utf16 = reinterpret_cast<unsigned short *>(s.data());
    const unsigned short *uc = utf16 + s.length();
    while (uc != utf16 + from) {
        uint ucs4 = *(--uc);
        if (QChar(ucs4).isLowSurrogate() && uc != utf16) {
            ushort high = *(uc - 1);
            if (QChar(high).isHighSurrogate()) {
                --uc;
                ucs4 = QChar::surrogateToUcs4(high, ucs4);
            }
        }
        QChar::UnicodeVersion v = QChar::unicodeVersion(ucs4);
        if (v == QChar::Unicode_Unassigned || v > version)
            continue;
        int length;
        int tag;
        const unsigned short *d = decompositionHelper(ucs4, &length, &tag, buffer);
        if (!d || (canonical && tag != QChar::Canonical))
            continue;

        int pos = uc - utf16;
        s.replace(pos, QChar::requiresSurrogates(ucs4) ? 2 : 1, reinterpret_cast<const QChar *>(d), length);
        // since the insert invalidates the pointers and we do decomposition recursive
        utf16 = reinterpret_cast<unsigned short *>(s.data());
        uc = utf16 + pos + length;
    }
}

decompositionHelper()

static const unsigned short* QT_FASTCALL decompositionHelper ( uint  ucs4, int *  length, int *  tag, unsigned short *  buffer  )

static

Definition at line 1068 of file qchar.cpp.

Referenced by decomposeHelper(), and QChar::decomposition().

{
    *length = 0;
    if (ucs4 > UNICODE_LAST_CODEPOINT)
        return 0;
    if (ucs4 >= Hangul_SBase && ucs4 < Hangul_SBase + Hangul_SCount) {
        int SIndex = ucs4 - Hangul_SBase;
        buffer[0] = Hangul_LBase + SIndex / Hangul_NCount; // L
        buffer[1] = Hangul_VBase + (SIndex % Hangul_NCount) / Hangul_TCount; // V
        buffer[2] = Hangul_TBase + SIndex % Hangul_TCount; // T
        *length = buffer[2] == Hangul_TBase ? 2 : 3;
        *tag = QChar::Canonical;
        return buffer;
    }

    const unsigned short index = GET_DECOMPOSITION_INDEX(ucs4);
    if (index == 0xffff)
        return 0;
    const unsigned short *decomposition = uc_decomposition_map+index;
    *tag = (*decomposition) & 0xff;
    *length = (*decomposition) >> 8;
    return decomposition+1;
}

foldCase() [1/3]

static uint foldCase ( const ushort *  ch, const ushort *  start  )

inlinestatic

Definition at line 1380 of file qchar.cpp.

Referenced by bm_find(), bm_init_skiptable(), QString::endsWith(), QStringRef::endsWith(), findChar(), lastIndexOfHelper(), qFindString(), qt_ends_with(), qt_last_index_of(), qt_starts_with(), qt_string_count(), QString::remove(), QString::replace(), QString::startsWith(), QStringRef::startsWith(), QString::toCaseFolded(), and ucstricmp().

{
    uint c = *ch;
    if (QChar(c).isLowSurrogate() && ch > start && QChar(*(ch - 1)).isHighSurrogate())
        c = QChar::surrogateToUcs4(*(ch - 1), c);
    return *ch + qGetProp(c)->caseFoldDiff;
}

foldCase() [2/3]

static uint foldCase ( uint  ch, uint &  last  )

inlinestatic

Definition at line 1388 of file qchar.cpp.

{
    uint c = ch;
    if (QChar(c).isLowSurrogate() && QChar(last).isHighSurrogate())
        c = QChar::surrogateToUcs4(last, c);
    last = ch;
    return ch + qGetProp(c)->caseFoldDiff;
}

foldCase() [3/3]

static ushort foldCase ( ushort  ch )

inlinestatic

Definition at line 1397 of file qchar.cpp.

{
    return ch + qGetProp(ch)->caseFoldDiff;
}

ligatureHelper()

static ushort ligatureHelper ( ushort  u1, ushort  u2  )

static

Definition at line 1743 of file qchar.cpp.

Referenced by composeHelper().

{
    // hangul L-V pair
    int LIndex = u1 - Hangul_LBase;
    if (0 <= LIndex && LIndex < Hangul_LCount) {
        int VIndex = u2 - Hangul_VBase;
        if (0 <= VIndex && VIndex < Hangul_VCount)
            return Hangul_SBase + (LIndex * Hangul_VCount + VIndex) * Hangul_TCount;
    }

    // hangul LV-T pair
    int SIndex = u1 - Hangul_SBase;
    if (0 <= SIndex && SIndex < Hangul_SCount && (SIndex % Hangul_TCount) == 0) {
        int TIndex = u2 - Hangul_TBase;
        if (0 <= TIndex && TIndex <= Hangul_TCount)
            return u1 + TIndex;
    }

    const unsigned short index = GET_LIGATURE_INDEX(u2);
    if (index == 0xffff)
        return 0;
    const unsigned short *ligatures = uc_ligature_map+index;
    ushort length = *ligatures++;
    {
        const UCS2Pair *data = reinterpret_cast<const UCS2Pair *>(ligatures);
        const UCS2Pair *r = qBinaryFind(data, data + length, u1);
        if (r != data + length)
            return r->u2;
    }

    return 0;
}

operator<() [1/2]

bool operator< ( ushort  u1, const UCS2Pair &  ligature  )

inline

Definition at line 1738 of file qchar.cpp.

{ return u1 < ligature.u1; }

operator<() [2/2]

bool operator< ( const UCS2Pair &  ligature, ushort  u1  )

inline

Definition at line 1740 of file qchar.cpp.

{ return ligature.u1 < u1; }