qstring.cpp File Reference

#include "qstringlist.h"
#include "qregexp.h"
#include "qunicodetables_p.h"
#include <qtextcodec.h>
#include <private/qutfcodec_p.h>
#include "qsimd_p.h"
#include <qdatastream.h>
#include <qlist.h>
#include "qlocale.h"
#include "qlocale_p.h"
#include "qstringmatcher.h"
#include "qvarlengtharray.h"
#include "qtools_p.h"
#include "qhash.h"
#include "qdebug.h"
#include "qendian.h"
#include "qmutex.h"
#include <private/qcore_mac_p.h>
#include <private/qfunctions_p.h>
#include <windows.h>
#include <winnls.h>
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include "qchar.cpp"
#include "qstringmatcher.cpp"
#include "qt_windows.h"

Go to the source code of this file.

Classes
struct	ArgEscapeData
struct	QStringCapture
class	qt_section_chunk

Macros
#define	CSTR_EQUAL   2
#define	CSTR_GREATER_THAN   3
#define	CSTR_LESS_THAN   1
#define	LLONG_MAX   qint64_C(9223372036854775807)
#define	LLONG_MIN   (-LLONG_MAX - qint64_C(1))
#define	QT_MAX_FLOAT   3.4028234663852886e+38
	Returns the string converted to a float value. More...
#define	REHASH(a)
#define	ULLONG_MAX   quint64_C(18446744073709551615)

Functions
static ArgEscapeData	findArgEscapes (const QString &s)
static int	findChar (const QChar *str, int len, QChar ch, int from, Qt::CaseSensitivity cs)
	Returns the index position of the first occurrence of the character ch in the string given by str and len, searching forward from index position from. More...
static int	getEscape (const QChar *uc, int *pos, int len, int maxNumber=999)
static bool	isStringRightToLeft (const ushort *p, const ushort *end)
static int	lastIndexOfHelper (const ushort *haystack, int from, const ushort *needle, int sl, Qt::CaseSensitivity cs)
QDataStream &	operator<< (QDataStream &out, const QString &str)
QDataStream &	operator>> (QDataStream &in, QString &str)
int	qFindString (const QChar *haystack, int haystackLen, int from, const QChar *needle, int needleLen, Qt::CaseSensitivity cs)
int	qFindStringBoyerMoore (const QChar *haystack, int haystackLen, int from, const QChar *needle, int needleLen, Qt::CaseSensitivity cs)
bool	qIsDigit (char ch)
bool	qIsUpper (char ch)
static bool	qMemEquals (const quint16 *a, const quint16 *b, int length)
static bool	qt_ends_with (const QChar *haystack, int haystackLen, const QChar *needle, int needleLen, Qt::CaseSensitivity cs)
static bool	qt_ends_with (const QChar *haystack, int haystackLen, const QLatin1String &needle, Qt::CaseSensitivity cs)
static int	qt_find_latin1_string (const QChar *hay, int size, const QLatin1String &needle, int from, Qt::CaseSensitivity cs)
static int	qt_last_index_of (const QChar *haystack, int haystackLen, const QChar &needle, int from, Qt::CaseSensitivity cs)
static bool	qt_starts_with (const QChar *haystack, int haystackLen, const QChar *needle, int needleLen, Qt::CaseSensitivity cs)
static bool	qt_starts_with (const QChar *haystack, int haystackLen, const QLatin1String &needle, Qt::CaseSensitivity cs)
static int	qt_string_count (const QChar *haystack, int haystackLen, const QChar *needle, int needleLen, Qt::CaseSensitivity cs)
static int	qt_string_count (const QChar *haystack, int haystackLen, const QChar &needle, Qt::CaseSensitivity cs)
void	qt_string_normalize (QString *data, QString::NormalizationForm mode, QChar::UnicodeVersion version, int from)
char	qToLower (char ch)
static QString	replaceArgEscapes (const QString &s, const ArgEscapeData &d, int field_width, const QString &arg, const QString &larg, const QChar &fillChar=QLatin1Char(' '))
static QByteArray	toLatin1_helper (const QChar *data, int length)
template<typename T >
int	toUcs4_helper (const unsigned short *uc, int length, T *out)
static int	ucstrcmp (const QChar *a, int alen, const QChar *b, int blen)
static int	ucstricmp (const ushort *a, const ushort *ae, const ushort *b, const ushort *be)
static int	ucstricmp (const ushort *a, const ushort *ae, const uchar *b)
static int	ucstrncmp (const QChar *a, const QChar *b, int l)
static int	ucstrnicmp (const ushort *a, const ushort *b, int l)

Macro Definition Documentation

CSTR_EQUAL

#define CSTR_EQUAL   2

Definition at line 5180 of file qstring.cpp.

CSTR_GREATER_THAN

#define CSTR_GREATER_THAN   3

Definition at line 5181 of file qstring.cpp.

Referenced by QString::localeAwareCompare_helper().

CSTR_LESS_THAN

#define CSTR_LESS_THAN   1

Definition at line 5179 of file qstring.cpp.

Referenced by QString::localeAwareCompare_helper().

LLONG_MAX

#define LLONG_MAX   qint64_C(9223372036854775807)

Definition at line 91 of file qstring.cpp.

LLONG_MIN

#define LLONG_MIN   (-LLONG_MAX - qint64_C(1))

Definition at line 94 of file qstring.cpp.

QT_MAX_FLOAT

#define QT_MAX_FLOAT   3.4028234663852886e+38

Returns the string converted to a float value.

If a conversion error occurs, *{ok} is set to false; otherwise {ok} is set to true. Returns 0.0 if the conversion fails.

Example:

    QString str1 = "1234.56";
    str1.toFloat();             // returns 1234.56

    bool ok;
    QString str2 = "R2D2";
    str2.toFloat(&ok);          // returns 0.0, sets ok to false

See also

number(), toDouble(), toInt()

Definition at line 6255 of file qstring.cpp.

Referenced by QString::toFloat().

REHASH

#define REHASH

(

a

)

Value:

if (sl_minus_1 < (int)sizeof(int) * CHAR_BIT)       \
        hashHaystack -= (a) << sl_minus_1; \
    hashHaystack <<= 1

Definition at line 357 of file qstring.cpp.

Referenced by lastIndexOfHelper(), and qFindString().

ULLONG_MAX

#define ULLONG_MAX   quint64_C(18446744073709551615)

Definition at line 97 of file qstring.cpp.

Function Documentation

findArgEscapes()

static ArgEscapeData findArgEscapes ( const QString &  s )

static

Definition at line 6780 of file qstring.cpp.

Referenced by QString::arg().

{
    const QChar *uc_begin = s.unicode();
    const QChar *uc_end = uc_begin + s.length();

    ArgEscapeData d;

    d.min_escape = INT_MAX;
    d.occurrences = 0;
    d.escape_len = 0;
    d.locale_occurrences = 0;

    const QChar *c = uc_begin;
    while (c != uc_end) {
        while (c != uc_end && c->unicode() != '%')
            ++c;

        if (c == uc_end)
            break;
        const QChar *escape_start = c;
        if (++c == uc_end)
            break;

        bool locale_arg = false;
        if (c->unicode() == 'L') {
            locale_arg = true;
            if (++c == uc_end)
                break;
        }

        if (c->digitValue() == -1)
            continue;

        int escape = c->digitValue();
        ++c;

        if (c != uc_end && c->digitValue() != -1) {
            escape = (10 * escape) + c->digitValue();
            ++c;
        }

        if (escape > d.min_escape)
            continue;

        if (escape < d.min_escape) {
            d.min_escape = escape;
            d.occurrences = 0;
            d.escape_len = 0;
            d.locale_occurrences = 0;
        }

        ++d.occurrences;
        if (locale_arg)
            ++d.locale_occurrences;
        d.escape_len += c - escape_start;
    }
    return d;
}

findChar()

static int findChar ( const QChar *  str, int  len, QChar  ch, int  from, Qt::CaseSensitivity  cs  )

static

Returns the index position of the first occurrence of the character ch in the string given by str and len, searching forward from index position from.

Warning

This function is not part of the public interface.

Returns -1 if ch could not be found.

Definition at line 333 of file qstring.cpp.

Referenced by QString::indexOf(), QStringRef::indexOf(), and qFindString().

{
    const ushort *s = (const ushort *)str;
    ushort c = ch.unicode();
    if (from < 0)
        from = qMax(from + len, 0);
    if (from < len) {
        const ushort *n = s + from - 1;
        const ushort *e = s + len;
        if (cs == Qt::CaseSensitive) {
            while (++n != e)
                if (*n == c)
                    return  n - s;
        } else {
            c = foldCase(c);
            while (++n != e)
                if (foldCase(*n) == c)
                    return  n - s;
        }
    }
    return -1;
}

getEscape()

static int getEscape ( const QChar *  uc, int *  pos, int  len, int  maxNumber = 999  )

static

Definition at line 7408 of file qstring.cpp.

Referenced by QString::multiArg().

{
    int i = *pos;
    ++i;
    if (i < len && uc[i] == QLatin1Char('L'))
        ++i;
    if (i < len) {
        int escape = uc[i].unicode() - '0';
        if (uint(escape) >= 10U)
            return -1;
        ++i;
        while (i < len) {
            int digit = uc[i].unicode() - '0';
            if (uint(digit) >= 10U)
                break;
            escape = (escape * 10) + digit;
            ++i;
        }
        if (escape <= maxNumber) {
            *pos = i;
            return escape;
        }
    }
    return -1;
}

isStringRightToLeft()

static bool isStringRightToLeft ( const ushort *  p, const ushort *  end  )

static

Definition at line 7487 of file qstring.cpp.

Referenced by QString::isRightToLeft(), and QString::updateProperties().

{
    bool righttoleft = false;
    while (p < end) {
        switch(QChar::direction(*p))
        {
        case QChar::DirL:
            goto end;
        case QChar::DirR:
        case QChar::DirAL:
            righttoleft = true;
            goto end;
        default:
            break;
        }
        ++p;
    }
 end:
    return righttoleft;
}

lastIndexOfHelper()

static int lastIndexOfHelper ( const ushort *  haystack, int  from, const ushort *  needle, int  sl, Qt::CaseSensitivity  cs  )

static

Definition at line 2863 of file qstring.cpp.

Referenced by QString::lastIndexOf(), and QStringRef::lastIndexOf().

{
    /*
        See indexOf() for explanations.
    */

    const ushort *end = haystack;
    haystack += from;
    const int sl_minus_1 = sl-1;
    const ushort *n = needle+sl_minus_1;
    const ushort *h = haystack+sl_minus_1;
    int hashNeedle = 0, hashHaystack = 0, idx;

    if (cs == Qt::CaseSensitive) {
        for (idx = 0; idx < sl; ++idx) {
            hashNeedle = ((hashNeedle<<1) + *(n-idx));
            hashHaystack = ((hashHaystack<<1) + *(h-idx));
        }
        hashHaystack -= *haystack;

        while (haystack >= end) {
            hashHaystack += *haystack;
            if (hashHaystack == hashNeedle
                 && ucstrncmp((const QChar *)needle, (const QChar *)haystack, sl) == 0)
                return haystack - end;
            --haystack;
            REHASH(haystack[sl]);
        }
    } else {
        for (idx = 0; idx < sl; ++idx) {
            hashNeedle = ((hashNeedle<<1) + foldCase(n-idx, needle));
            hashHaystack = ((hashHaystack<<1) + foldCase(h-idx, end));
        }
        hashHaystack -= foldCase(haystack, end);

        while (haystack >= end) {
            hashHaystack += foldCase(haystack, end);
            if (hashHaystack == hashNeedle && ucstrnicmp(needle, haystack, sl) == 0)
                return haystack - end;
            --haystack;
            REHASH(foldCase(haystack + sl, end));
        }
    }
    return -1;
}

operator<<()

QDataStream& operator<< ( QDataStream &  out, const QString &  str  )

related

Definition at line 8034 of file qstring.cpp.

{
    if (out.version() == 1) {
        out << str.toLatin1();
    } else {
        if (!str.isNull() || out.version() < 3) {
            if ((out.byteOrder() == QDataStream::BigEndian) == (QSysInfo::ByteOrder == QSysInfo::BigEndian)) {
                out.writeBytes(reinterpret_cast<const char *>(str.unicode()), sizeof(QChar) * str.length());
            } else {
                QVarLengthArray<ushort> buffer(str.length());
                const ushort *data = reinterpret_cast<const ushort *>(str.constData());
                for (int i = 0; i < str.length(); i++) {
                    buffer[i] = qbswap(*data);
                    ++data;
                }
                out.writeBytes(reinterpret_cast<const char *>(buffer.data()), sizeof(ushort) * buffer.size());
            }
        } else {
            // write null marker
            out << (quint32)0xffffffff;
        }
    }
    return out;
}

operator>>()

QDataStream& operator>> ( QDataStream &  in, QString &  str  )

related

Definition at line 8071 of file qstring.cpp.

{
#ifdef QT_QSTRING_UCS_4
#if defined(Q_CC_GNU)
#warning "operator>> not working properly"
#endif
#endif

    if (in.version() == 1) {
        QByteArray l;
        in >> l;
        str = QString::fromLatin1(l);
    } else {
        quint32 bytes = 0;
        in >> bytes;                                  // read size of string
        if (bytes == 0xffffffff) {                    // null string
            str.clear();
        } else if (bytes > 0) {                       // not empty
            if (bytes & 0x1) {
                str.clear();
                in.setStatus(QDataStream::ReadCorruptData);
                return in;
            }

            const quint32 Step = 1024 * 1024;
            quint32 len = bytes / 2;
            quint32 allocated = 0;

            while (allocated < len) {
                int blockSize = qMin(Step, len - allocated);
                str.resize(allocated + blockSize);
                if (in.readRawData(reinterpret_cast<char *>(str.data()) + allocated * 2,
                                   blockSize * 2) != blockSize * 2) {
                    str.clear();
                    in.setStatus(QDataStream::ReadPastEnd);
                    return in;
                }
                allocated += blockSize;
            }

            if ((in.byteOrder() == QDataStream::BigEndian)
                    != (QSysInfo::ByteOrder == QSysInfo::BigEndian)) {
                ushort *data = reinterpret_cast<ushort *>(str.data());
                while (len--) {
                    *data = qbswap(*data);
                    ++data;
                }
            }
        } else {
            str = QLatin1String("");
        }
    }
    return in;
}

qFindString()

int qFindString	(	const QChar *	haystack,
		int	haystackLen,
		int	from,
		const QChar *	needle,
		int	needleLen,
		Qt::CaseSensitivity	cs
	)

Definition at line 2753 of file qstring.cpp.

Referenced by QString::indexOf(), QStringRef::indexOf(), QRegExpMatchState::match(), qt_find_latin1_string(), and qt_string_count().

{
    const int l = haystackLen;
    const int sl = needleLen;
    if (from < 0)
        from += l;
    if (uint(sl + from) > (uint)l)
        return -1;
    if (!sl)
        return from;
    if (!l)
        return -1;

    if (sl == 1)
        return findChar(haystack0, haystackLen, needle0[0], from, cs);

    /*
        We use the Boyer-Moore algorithm in cases where the overhead
        for the skip table should pay off, otherwise we use a simple
        hash function.
    */
    if (l > 500 && sl > 5)
        return qFindStringBoyerMoore(haystack0, haystackLen, from,
            needle0, needleLen, cs);

    /*
        We use some hashing for efficiency's sake. Instead of
        comparing strings, we compare the hash value of str with that
        of a part of this QString. Only if that matches, we call
        ucstrncmp() or ucstrnicmp().
    */
    const ushort *needle = (const ushort *)needle0;
    const ushort *haystack = (const ushort *)haystack0 + from;
    const ushort *end = (const ushort *)haystack0 + (l-sl);
    const int sl_minus_1 = sl-1;
    int hashNeedle = 0, hashHaystack = 0, idx;

    if (cs == Qt::CaseSensitive) {
        for (idx = 0; idx < sl; ++idx) {
            hashNeedle = ((hashNeedle<<1) + needle[idx]);
            hashHaystack = ((hashHaystack<<1) + haystack[idx]);
        }
        hashHaystack -= haystack[sl_minus_1];

        while (haystack <= end) {
            hashHaystack += haystack[sl_minus_1];
            if (hashHaystack == hashNeedle
                 && ucstrncmp((const QChar *)needle, (const QChar *)haystack, sl) == 0)
                return haystack - (const ushort *)haystack0;

            REHASH(*haystack);
            ++haystack;
        }
    } else {
        const ushort *haystack_start = (const ushort *)haystack0;
        for (idx = 0; idx < sl; ++idx) {
            hashNeedle = (hashNeedle<<1) + foldCase(needle + idx, needle);
            hashHaystack = (hashHaystack<<1) + foldCase(haystack + idx, haystack_start);
        }
        hashHaystack -= foldCase(haystack + sl_minus_1, haystack_start);

        while (haystack <= end) {
            hashHaystack += foldCase(haystack + sl_minus_1, haystack_start);
            if (hashHaystack == hashNeedle && ucstrnicmp(needle, haystack, sl) == 0)
                return haystack - (const ushort *)haystack0;

            REHASH(foldCase(haystack, haystack_start));
            ++haystack;
        }
    }
    return -1;
}

qFindStringBoyerMoore()

int qFindStringBoyerMoore	(	const QChar *	haystack,
		int	haystackLen,
		int	haystackOffset,
		const QChar *	needle,
		int	needleLen,
		Qt::CaseSensitivity	cs
	)

Warning

This function is not part of the public interface.

Definition at line 322 of file qstringmatcher.cpp.

Referenced by qFindString().

{
    uchar skiptable[256];
    bm_init_skiptable((const ushort *)needle, needleLen, skiptable, cs);
    if (haystackOffset < 0)
        haystackOffset = 0;
    return bm_find((const ushort *)haystack, haystackLen, haystackOffset,
                   (const ushort *)needle, needleLen, skiptable, cs);
}

qIsDigit()

bool qIsDigit ( char  ch )

inline

Definition at line 367 of file qstring.cpp.

Referenced by QString::vsprintf().

{
    return ch >= '0' && ch <= '9';
}

qIsUpper()

bool qIsUpper ( char  ch )

inline

Definition at line 362 of file qstring.cpp.

Referenced by QString::arg(), QString::setNum(), and QString::vsprintf().

{
    return ch >= 'A' && ch <= 'Z';
}

qMemEquals()

static bool qMemEquals ( const quint16 *  a, const quint16 *  b, int  length  )

static

Definition at line 273 of file qstring.cpp.

Referenced by QString::operator==(), QStringRef::operator==(), qt_ends_with(), and qt_starts_with().

{
    if (a == b || !length)
        return true;

    register union {
        const quint16 *w;
        const quint32 *d;
        quintptr value;
    } sa, sb;
    sa.w = a;
    sb.w = b;

    // check alignment
    if ((sa.value & 2) == (sb.value & 2)) {
        // both addresses have the same alignment
        if (sa.value & 2) {
            // both addresses are not aligned to 4-bytes boundaries
            // compare the first character
            if (*sa.w != *sb.w)
                return false;
            --length;
            ++sa.w;
            ++sb.w;

            // now both addresses are 4-bytes aligned
        }

        // both addresses are 4-bytes aligned
        // do a fast 32-bit comparison
        register const quint32 *e = sa.d + (length >> 1);
        for ( ; sa.d != e; ++sa.d, ++sb.d) {
            if (*sa.d != *sb.d)
                return false;
        }

        // do we have a tail?
        return (length & 1) ? *sa.w == *sb.w : true;
    } else {
        // one of the addresses isn't 4-byte aligned but the other is
        register const quint16 *e = sa.w + length;
        for ( ; sa.w != e; ++sa.w, ++sb.w) {
            if (*sa.w != *sb.w)
                return false;
        }
    }
    return true;
}

qt_ends_with() [1/2]

static bool qt_ends_with ( const QChar *  haystack, int  haystackLen, const QChar *  needle, int  needleLen, Qt::CaseSensitivity  cs  )

inlinestatic

Definition at line 9722 of file qstring.cpp.

Referenced by QString::endsWith(), and QStringRef::endsWith().

{
    if (!haystack)
        return !needle;
    if (haystackLen == 0)
        return needleLen == 0;
    const int pos = haystackLen - needleLen;
    if (pos < 0)
        return false;

    const ushort *h = reinterpret_cast<const ushort*>(haystack);
    const ushort *n = reinterpret_cast<const ushort*>(needle);

    if (cs == Qt::CaseSensitive) {
        return qMemEquals(h + pos, n, needleLen);
    } else {
        uint last = 0;
        uint olast = 0;
        for (int i = 0; i < needleLen; i++)
            if (foldCase(h[pos+i], last) != foldCase(n[i], olast))
                return false;
    }
    return true;
}

qt_ends_with() [2/2]

static bool qt_ends_with ( const QChar *  haystack, int  haystackLen, const QLatin1String &  needle, Qt::CaseSensitivity  cs  )

inlinestatic

Definition at line 9749 of file qstring.cpp.

{
    if (!haystack)
        return !needle.latin1();
    if (haystackLen == 0)
        return !needle.latin1() || *needle.latin1() == 0;
    const int slen = qstrlen(needle.latin1());
    int pos = haystackLen - slen;
    if (pos < 0)
        return false;
    const uchar *latin = reinterpret_cast<const uchar*>(needle.latin1());
    const ushort *data = reinterpret_cast<const ushort*>(haystack);
    if (cs == Qt::CaseSensitive) {
        for (int i = 0; i < slen; i++)
            if (data[pos+i] != latin[i])
                return false;
    } else {
        for (int i = 0; i < slen; i++)
            if (foldCase(data[pos+i]) != foldCase((ushort)latin[i]))
                return false;
    }
    return true;
}

qt_find_latin1_string()

static int qt_find_latin1_string ( const QChar *  hay, int  size, const QLatin1String &  needle, int  from, Qt::CaseSensitivity  cs  )

inlinestatic

Definition at line 9659 of file qstring.cpp.

Referenced by QString::indexOf(), and QStringRef::indexOf().

{
    const char *latin1 = needle.latin1();
    int len = qstrlen(latin1);
    QVarLengthArray<ushort> s(len);
    for (int i = 0; i < len; ++i)
        s[i] = latin1[i];

    return qFindString(haystack, size, from,
                       reinterpret_cast<const QChar*>(s.constData()), len, cs);
}

qt_last_index_of()

static int qt_last_index_of ( const QChar *  haystack, int  haystackLen, const QChar &  needle, int  from, Qt::CaseSensitivity  cs  )

inlinestatic

Definition at line 9595 of file qstring.cpp.

Referenced by QString::lastIndexOf(), and QStringRef::lastIndexOf().

{
    ushort c = needle.unicode();
    if (from < 0)
        from += haystackLen;
    if (from < 0 || from >= haystackLen)
        return -1;
    if (from >= 0) {
        const ushort *b = reinterpret_cast<const ushort*>(haystack);
        const ushort *n = b + from;
        if (cs == Qt::CaseSensitive) {
            for (; n >= b; --n)
                if (*n == c)
                    return n - b;
        } else {
            c = foldCase(c);
            for (; n >= b; --n)
                if (foldCase(*n) == c)
                    return n - b;
        }
    }
    return -1;


}

qt_starts_with() [1/2]

static bool qt_starts_with ( const QChar *  haystack, int  haystackLen, const QChar *  needle, int  needleLen, Qt::CaseSensitivity  cs  )

inlinestatic

Definition at line 9673 of file qstring.cpp.

Referenced by QString::startsWith(), and QStringRef::startsWith().

{
    if (!haystack)
        return !needle;
    if (haystackLen == 0)
        return needleLen == 0;
    if (needleLen > haystackLen)
        return false;

    const ushort *h = reinterpret_cast<const ushort*>(haystack);
    const ushort *n = reinterpret_cast<const ushort*>(needle);

    if (cs == Qt::CaseSensitive) {
        return qMemEquals(h, n, needleLen);
    } else {
        uint last = 0;
        uint olast = 0;
        for (int i = 0; i < needleLen; ++i)
            if (foldCase(h[i], last) != foldCase(n[i], olast))
                return false;
    }
    return true;
}

qt_starts_with() [2/2]

static bool qt_starts_with ( const QChar *  haystack, int  haystackLen, const QLatin1String &  needle, Qt::CaseSensitivity  cs  )

inlinestatic

Definition at line 9698 of file qstring.cpp.

{
    if (!haystack)
        return !needle.latin1();
    if (haystackLen == 0)
        return !needle.latin1() || *needle.latin1() == 0;
    const int slen = qstrlen(needle.latin1());
    if (slen > haystackLen)
        return false;
    const ushort *data = reinterpret_cast<const ushort*>(haystack);
    const uchar *latin = reinterpret_cast<const uchar*>(needle.latin1());
    if (cs == Qt::CaseSensitive) {
        for (int i = 0; i < slen; ++i)
            if (data[i] != latin[i])
                return false;
    } else {
        for (int i = 0; i < slen; ++i)
            if (foldCase(data[i]) != foldCase((ushort)latin[i]))
                return false;
    }
    return true;
}

qt_string_count() [1/2]

static int qt_string_count ( const QChar *  haystack, int  haystackLen, const QChar *  needle, int  needleLen, Qt::CaseSensitivity  cs  )

inlinestatic

Definition at line 9622 of file qstring.cpp.

Referenced by QString::count(), and QStringRef::count().

{
    int num = 0;
    int i = -1;
    if (haystackLen > 500 && needleLen > 5) {
        QStringMatcher matcher(needle, needleLen, cs);
        while ((i = matcher.indexIn(haystack, haystackLen, i + 1)) != -1)
            ++num;
    } else {
        while ((i = qFindString(haystack, haystackLen, i + 1, needle, needleLen, cs)) != -1)
            ++num;
    }
    return num;
}

qt_string_count() [2/2]

static int qt_string_count ( const QChar *  haystack, int  haystackLen, const QChar &  needle, Qt::CaseSensitivity  cs  )

inlinestatic

Definition at line 9639 of file qstring.cpp.

{
    ushort c = ch.unicode();
    int num = 0;
    const ushort *b = reinterpret_cast<const ushort*>(unicode);
    const ushort *i = b + size;
    if (cs == Qt::CaseSensitive) {
        while (i != b)
            if (*--i == c)
                ++num;
    } else {
        c = foldCase(c);
        while (i != b)
            if (foldCase(*(--i)) == c)
                ++num;
    }
    return num;
}

qt_string_normalize()

void qt_string_normalize	(	QString *	data,
		QString::NormalizationForm	mode,
		QChar::UnicodeVersion	version,
		int	from
	)

Definition at line 6710 of file qstring.cpp.

Referenced by QString::normalized(), qt_nameprep(), and QString::repeated().

{
    bool simple = true;
    const QChar *p = data->constData();
    int len = data->length();
    for (int i = from; i < len; ++i) {
        if (p[i].unicode() >= 0x80) {
            simple = false;
            break;
        }
    }
    if (simple)
        return;

    if (version == QChar::Unicode_Unassigned) {
        version = UNICODE_DATA_VERSION;
    } else if (version != UNICODE_DATA_VERSION) {
        const QString &s = *data;
        QChar *d = 0;
        for (int i = 0; i < NumNormalizationCorrections; ++i) {
            const NormalizationCorrection &n = uc_normalization_corrections[i];
            if (n.version > version) {
                int pos = from;
                if (QChar::requiresSurrogates(n.ucs4)) {
                    ushort ucs4High = QChar::highSurrogate(n.ucs4);
                    ushort ucs4Low = QChar::lowSurrogate(n.ucs4);
                    ushort oldHigh = QChar::highSurrogate(n.old_mapping);
                    ushort oldLow = QChar::lowSurrogate(n.old_mapping);
                    while (pos < s.length() - 1) {
                        if (s.at(pos).unicode() == ucs4High && s.at(pos + 1).unicode() == ucs4Low) {
                            if (!d)
                                d = data->data();
                            d[pos] = QChar(oldHigh);
                            d[++pos] = QChar(oldLow);
                        }
                        ++pos;
                    }
                } else {
                    while (pos < s.length()) {
                        if (s.at(pos).unicode() == n.ucs4) {
                            if (!d)
                                d = data->data();
                            d[pos] = QChar(n.old_mapping);
                        }
                        ++pos;
                    }
                }
            }
        }
    }
    decomposeHelper(data, mode < QString::NormalizationForm_KD, version, from);

    canonicalOrderHelper(data, version, from);

    if (mode == QString::NormalizationForm_D || mode == QString::NormalizationForm_KD)
        return;

    composeHelper(data, version, from);
}

qToLower()

char qToLower ( char  ch )

inline

Definition at line 372 of file qstring.cpp.

Referenced by QString::arg(), QString::setNum(), and QString::vsprintf().

{
    if (ch >= 'A' && ch <= 'Z')
        return ch - 'A' + 'a';
    else
        return ch;
}

replaceArgEscapes()

static QString replaceArgEscapes ( const QString &  s, const ArgEscapeData &  d, int  field_width, const QString &  arg, const QString &  larg, const QChar &  fillChar = QLatin1Char(' ')  )

static

Definition at line 6839 of file qstring.cpp.

Referenced by QString::arg().

{
    const QChar *uc_begin = s.unicode();
    const QChar *uc_end = uc_begin + s.length();

    int abs_field_width = qAbs(field_width);
    int result_len = s.length()
                     - d.escape_len
                     + (d.occurrences - d.locale_occurrences)
                     *qMax(abs_field_width, arg.length())
                     + d.locale_occurrences
                     *qMax(abs_field_width, larg.length());

    QString result(result_len, Qt::Uninitialized);
    QChar *result_buff = (QChar*) result.unicode();

    QChar *rc = result_buff;
    const QChar *c = uc_begin;
    int repl_cnt = 0;
    while (c != uc_end) {
        /* We don't have to check if we run off the end of the string with c,
           because as long as d.occurrences > 0 we KNOW there are valid escape
           sequences. */

        const QChar *text_start = c;

        while (c->unicode() != '%')
            ++c;

        const QChar *escape_start = c++;

        bool locale_arg = false;
        if (c->unicode() == 'L') {
            locale_arg = true;
            ++c;
        }

        int escape = c->digitValue();
        if (escape != -1) {
            if (c + 1 != uc_end && (c + 1)->digitValue() != -1) {
                escape = (10 * escape) + (c + 1)->digitValue();
                ++c;
            }
        }

        if (escape != d.min_escape) {
            memcpy(rc, text_start, (c - text_start)*sizeof(QChar));
            rc += c - text_start;
        }
        else {
            ++c;

            memcpy(rc, text_start, (escape_start - text_start)*sizeof(QChar));
            rc += escape_start - text_start;

            uint pad_chars;
            if (locale_arg)
                pad_chars = qMax(abs_field_width, larg.length()) - larg.length();
            else
                pad_chars = qMax(abs_field_width, arg.length()) - arg.length();

            if (field_width > 0) { // left padded
                for (uint i = 0; i < pad_chars; ++i)
                    (rc++)->unicode() = fillChar.unicode();
            }

            if (locale_arg) {
                memcpy(rc, larg.unicode(), larg.length()*sizeof(QChar));
                rc += larg.length();
            }
            else {
                memcpy(rc, arg.unicode(), arg.length()*sizeof(QChar));
                rc += arg.length();
            }

            if (field_width < 0) { // right padded
                for (uint i = 0; i < pad_chars; ++i)
                    (rc++)->unicode() = fillChar.unicode();
            }

            if (++repl_cnt == d.occurrences) {
                memcpy(rc, c, (uc_end - c)*sizeof(QChar));
                rc += uc_end - c;
                Q_ASSERT(rc - result_buff == result_len);
                c = uc_end;
            }
        }
    }
    Q_ASSERT(rc == result_buff + result_len);

    return result;
}

toLatin1_helper()

static QByteArray toLatin1_helper ( const QChar *  data, int  length  )

static

Definition at line 3924 of file qstring.cpp.

Referenced by QString::toAscii(), QString::toLatin1(), and QStringRef::toLatin1().

{
    QByteArray ba;
    if (length) {
        ba.resize(length);
        const ushort *src = reinterpret_cast<const ushort *>(data);
        uchar *dst = (uchar*) ba.data();
#if defined(QT_ALWAYS_HAVE_SSE2)
        if (length >= 16) {
            const int chunkCount = length >> 4; // divided by 16

            for (int i = 0; i < chunkCount; ++i) {
                __m128i chunk1 = _mm_loadu_si128((__m128i*)src); // load
                chunk1 = mergeQuestionMarks(chunk1);
                src += 8;

                __m128i chunk2 = _mm_loadu_si128((__m128i*)src); // load
                chunk2 = mergeQuestionMarks(chunk2);
                src += 8;

                // pack the two vector to 16 x 8bits elements
                const __m128i result = _mm_packus_epi16(chunk1, chunk2);

                _mm_storeu_si128((__m128i*)dst, result); // store
                dst += 16;
            }
            length = length % 16;
        }
#elif defined(QT_ALWAYS_HAVE_NEON)
        // Refer to the documentation of the SSE2 implementation
        // this use eactly the same method as for SSE except:
        // 1) neon has unsigned comparison
        // 2) packing is done to 64 bits (8 x 8bits component).
        if (length >= 16) {
            const int chunkCount = length >> 3; // divided by 8
            const uint16x8_t questionMark = vdupq_n_u16('?'); // set
            const uint16x8_t thresholdMask = vdupq_n_u16(0xff); // set
            for (int i = 0; i < chunkCount; ++i) {
                uint16x8_t chunk = vld1q_u16((uint16_t *)src); // load
                src += 8;

                const uint16x8_t offLimitMask = vcgtq_u16(chunk, thresholdMask); // chunk > thresholdMask
                const uint16x8_t offLimitQuestionMark = vandq_u16(offLimitMask, questionMark); // offLimitMask & questionMark
                const uint16x8_t correctBytes = vbicq_u16(chunk, offLimitMask); // !offLimitMask & chunk
                chunk = vorrq_u16(correctBytes, offLimitQuestionMark); // correctBytes | offLimitQuestionMark
                const uint8x8_t result = vmovn_u16(chunk); // narrowing move->packing
                vst1_u8(dst, result); // store
                dst += 8;
            }
            length = length % 8;
        }
#endif
        while (length--) {
            *dst++ = (*src>0xff) ? '?' : (uchar) *src;
            ++src;
        }
    }
    return ba;
}

toUcs4_helper()

template<typename T >

int toUcs4_helper	(	const unsigned short *	uc,
		int	length,
		T *	out
	)

Definition at line 1047 of file qstring.cpp.

{
    int i = 0;
    for (; i < length; ++i) {
        uint u = uc[i];
        if (QChar::isHighSurrogate(u) && i < length-1) {
            ushort low = uc[i+1];
            if (QChar::isLowSurrogate(low)) {
                ++i;
                u = QChar::surrogateToUcs4(u, low);
            }
        }
        *out = T(u);
        ++out;
    }
    return i;
}

ucstrcmp()

static int ucstrcmp ( const QChar *  a, int  alen, const QChar *  b, int  blen  )

static

Definition at line 211 of file qstring.cpp.

Referenced by QString::compare(), QString::compare_helper(), QString::localeAwareCompare_helper(), QString::operator<(), and QStringRef::operator<().

{
    if (a == b && alen == blen)
        return 0;
    int l = qMin(alen, blen);
    int cmp = ucstrncmp(a, b, l);
    return cmp ? cmp : (alen-blen);
}

ucstricmp() [1/2]

static int ucstricmp ( const ushort *  a, const ushort *  ae, const ushort *  b, const ushort *  be  )

static

Definition at line 141 of file qstring.cpp.

Referenced by QString::compare(), QString::compare_helper(), and ucstrnicmp().

{
    if (a == b)
        return (ae - be);
    if (a == 0)
        return 1;
    if (b == 0)
        return -1;

    const ushort *e = ae;
    if (be - b < ae - a)
        e = a + (be - b);

    uint alast = 0;
    uint blast = 0;
    while (a < e) {
//         qDebug() << hex << alast << blast;
//         qDebug() << hex << "*a=" << *a << "alast=" << alast << "folded=" << foldCase (*a, alast);
//         qDebug() << hex << "*b=" << *b << "blast=" << blast << "folded=" << foldCase (*b, blast);
        int diff = foldCase(*a, alast) - foldCase(*b, blast);
        if ((diff))
            return diff;
        ++a;
        ++b;
    }
    if (a == ae) {
        if (b == be)
            return 0;
        return -1;
    }
    return 1;
}

ucstricmp() [2/2]

static int ucstricmp ( const ushort *  a, const ushort *  ae, const uchar *  b  )

static

Definition at line 175 of file qstring.cpp.

{
    if (a == 0) {
        if (b == 0)
            return 0;
        return 1;
    }
    if (b == 0)
        return -1;

    while (a < ae && *b) {
        int diff = foldCase(*a) - foldCase(*b);
        if ((diff))
            return diff;
        ++a;
        ++b;
    }
    if (a == ae) {
        if (!*b)
            return 0;
        return -1;
    }
    return 1;
}

ucstrncmp()

static int ucstrncmp ( const QChar *  a, const QChar *  b, int  l  )

static

Definition at line 201 of file qstring.cpp.

Referenced by lastIndexOfHelper(), qFindString(), and ucstrcmp().

{
    while (l-- && *a == *b)
        a++,b++;
    if (l==-1)
        return 0;
    return a->unicode() - b->unicode();
}

ucstrnicmp()

static int ucstrnicmp ( const ushort *  a, const ushort *  b, int  l  )

static

Definition at line 221 of file qstring.cpp.

Referenced by lastIndexOfHelper(), and qFindString().

{
    return ucstricmp(a, a + l, b, b + l);
}