Changeset 561 for trunk/src/corelib/tools/qstring.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/corelib/tools/qstring.cpp (modified) (57 diffs)

trunk/src/corelib/tools/qstring.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information ([email protected])
+** All rights reserved.
+** Contact: Nokia Corporation ([email protected])
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
@@ -21 +22 @@
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you 
+** @nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -46 +46 @@
 #include <qtextcodec.h>
 #endif
+
 #include <qdatastream.h>
 #include <qlist.h>
@@ -175 +176 @@
 static int ucstrcmp(const QChar *a, int alen, const QChar *b, int blen)
 {
-    if (a == b)
+    if (a == b)
         return 0;
     int l = qMin(alen, blen);
@@ -201 +202 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 /*!
@@ -302 +365 @@
     \internal
 
-    \ingroup text
+    \ingroup 
 
     When you get an object of type QCharRef, if you can assign to it,
@@ -324 +387 @@
     \ingroup tools
     \ingroup shared
-    \ingroup text
-    \mainclass
+    \ingroup 
+
 
     QString stores a string of 16-bit \l{QChar}s, where each QChar
@@ -607 +670 @@
     significant digits (trailing zeroes are omitted).
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     \sa fromRawData(), QChar, QLatin1String, QByteArray, QStringRef
 */
@@ -749 +880 @@
     \since 4.2
 
-    Returns a copy of the \a string string encoded in ucs4.
+    Returns a copy of the \a string, where the encoding of \a string depends on 
+    the size of wchar. If wchar is 4 bytes, the \a string is interpreted as ucs-4,
+    if wchar is 2 bytes it is interpreted as ucs-2.
 
     If \a size is -1 (default), the \a string has to be 0 terminated.
@@ -838 +971 @@
     of the QChar array \a unicode.
 
-    QString makes a deep copy of the string data.
+    QString makes a deep copy of the string data. The unicode data is copied as
+    is and the Byte Order Mark is preserved if present.
 */
 QString::QString(const QChar *unicode, int size)
@@ -850 +984 @@
     } else {
         d = (Data*) qMalloc(sizeof(Data)+size*sizeof(QChar));
+
         d->ref = 1;
         d->alloc = d->size = size;
@@ -873 +1008 @@
     } else {
         d = (Data*) qMalloc(sizeof(Data)+size*sizeof(QChar));
+
         d->ref = 1;
         d->alloc = d->size = size;
@@ -886 +1022 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 /*! \fn QString::QString(const QLatin1String &str)
 
@@ -898 +1051 @@
 QString::QString(QChar ch)
 {
-    d = (Data *)qMalloc(sizeof(Data) + sizeof(QChar));
+    void *buf = qMalloc(sizeof(Data) + sizeof(QChar));
+    Q_CHECK_PTR(buf);
+    d = reinterpret_cast<Data *>(buf);
     d->ref = 1;
     d->alloc = d->size = 1;
@@ -1068 +1223 @@
     if (d->ref != 1 || d->data != d->array) {
         Data *x = static_cast<Data *>(qMalloc(sizeof(Data) + alloc * sizeof(QChar)));
-        if (!x)
-            return;
+        Q_CHECK_PTR(x);
         x->size = qMin(alloc, d->size);
         ::memcpy(x->array, d->data, x->size * sizeof(QChar));
@@ -1091 +1245 @@
         }
 #endif
-        Data *x = static_cast<Data *>(qRealloc(d, sizeof(Data) + alloc * sizeof(QChar)));
-        if (!x)
-            return;
-        x->alloc = alloc;
-        x->data = x->array;
-        d = x;
+        d = static_cast<Data *>(q_check_ptr(qRealloc(d, sizeof(Data) + alloc * sizeof(QChar))));
+        d->alloc = alloc;
+        d->data = d->array;
     }
 }
@@ -1250 +1401 @@
         // Part of me - take a copy
         ushort *tmp = static_cast<ushort *>(qMalloc(size * sizeof(QChar)));
+
         memcpy(tmp, s, size * sizeof(QChar));
         insert(i, reinterpret_cast<const QChar *>(tmp), size);
@@ -1444 +1596 @@
 QString &QString::remove(int pos, int len)
 {
-    if (pos < 0)
+    if (pos < 0)
         pos += d->size;
     if (pos < 0 || pos >= d->size) {
         // range problems
-    } else if (pos + len >= d->size) {  // pos ok
-        resize(pos);
+    } else if (
+        resize(pos);
     } else if (len > 0) {
         detach();
@@ -1604 +1756 @@
 void QString::replace_helper(uint *indices, int nIndices, int blen, const QChar *after, int alen)
 {
-    if (blen == alen) {
+    // copy *after in case it lies inside our own d->data area
+    // (which we could possibly invalidate via a realloc or corrupt via memcpy operations.)
+    QChar *afterBuffer = const_cast<QChar *>(after);
+    if (after >= reinterpret_cast<QChar *>(d->data) && after < reinterpret_cast<QChar *>(d->data) + d->size) {
+        afterBuffer = static_cast<QChar *>(qMalloc(alen*sizeof(QChar)));
+        Q_CHECK_PTR(afterBuffer);
+        ::memcpy(afterBuffer, after, alen*sizeof(QChar));
+    }
+
+    QT_TRY {
         detach();
-        for (int i = 0; i < nIndices; ++i)
-            memcpy(d->data + indices[i], after, alen * sizeof(QChar));
-    } else if (alen < blen) {
-        detach();
-        uint to = indices[0];
-        if (alen)
-            memcpy(d->data+to, after, alen*sizeof(QChar));
-        to += alen;
-        uint movestart = indices[0] + blen;
-        for (int i = 1; i < nIndices; ++i) {
-            int msize = indices[i] - movestart;
-            if (msize > 0) {
+        if (blen == alen) {
+            // replace in place
+            for (int i = 0; i < nIndices; ++i)
+                memcpy(d->data + indices[i], afterBuffer, alen * sizeof(QChar));
+        } else if (alen < blen) {
+            // replace from front
+            uint to = indices[0];
+            if (alen)
+                memcpy(d->data+to, after, alen*sizeof(QChar));
+            to += alen;
+            uint movestart = indices[0] + blen;
+            for (int i = 1; i < nIndices; ++i) {
+                int msize = indices[i] - movestart;
+                if (msize > 0) {
+                    memmove(d->data + to, d->data + movestart, msize * sizeof(QChar));
+                    to += msize;
+                }
+                if (alen) {
+                    memcpy(d->data + to, afterBuffer, alen*sizeof(QChar));
+                    to += alen;
+                }
+                movestart = indices[i] + blen;
+            }
+            int msize = d->size - movestart;
+            if (msize > 0)
                 memmove(d->data + to, d->data + movestart, msize * sizeof(QChar));
-                to += msize;
+            resize(d->size - nIndices*(blen-alen));
+        } else {
+            // replace from back
+            int adjust = nIndices*(alen-blen);
+            int newLen = d->size + adjust;
+            int moveend = d->size;
+            resize(newLen);
+
+            while (nIndices) {
+                --nIndices;
+                int movestart = indices[nIndices] + blen;
+                int insertstart = indices[nIndices] + nIndices*(alen-blen);
+                int moveto = insertstart + alen;
+                memmove(d->data + moveto, d->data + movestart,
+                        (moveend - movestart)*sizeof(QChar));
+                memcpy(d->data + insertstart, afterBuffer, alen*sizeof(QChar));
+                moveend = movestart-blen;
             }
-            if (alen) {
-                memcpy(d->data + to, after, alen*sizeof(QChar));
-                to += alen;
-            }
-            movestart = indices[i] + blen;
         }
-        int msize = d->size - movestart;
-        if (msize > 0)
-            memmove(d->data + to, d->data + movestart, msize * sizeof(QChar));
-        resize(d->size - nIndices*(blen-alen));
-    } else {
-        // we have a table of replacement positions, use them for fast replacing
-        int adjust = nIndices*(alen-blen);
-        int newLen = d->size + adjust;
-        int moveend = d->size;
-        resize(newLen);
-
-        while (nIndices) {
-            --nIndices;
-            int movestart = indices[nIndices] + blen;
-            int insertstart = indices[nIndices] + nIndices*(alen-blen);
-            int moveto = insertstart + alen;
-            memmove(d->data + moveto, d->data + movestart,
-                    (moveend - movestart)*sizeof(QChar));
-            memcpy(d->data + insertstart, after, alen*sizeof(QChar));
-            moveend = movestart-blen;
-        }
-    }
+    } QT_CATCH(const std::bad_alloc &) {
+        if (afterBuffer != after)
+            qFree(afterBuffer);
+        QT_RETHROW;
+    }
+    if (afterBuffer != after)
+        qFree(afterBuffer);
 }
 
@@ -1676 +1846 @@
         return *this;
 
-    // protect against before or after being part of this
-    const QChar *a = after;
-    const QChar *b = before;
-    if (after >= (const QChar *)d->data && after < (const QChar *)d->data + d->size) {
-        QChar *copy = (QChar *)malloc(alen*sizeof(QChar));
-        memcpy(copy, after, alen*sizeof(QChar));
-        a = copy;
-    }
-    if (before >= (const QChar *)d->data && before < (const QChar *)d->data + d->size) {
-        QChar *copy = (QChar *)malloc(blen*sizeof(QChar));
-        memcpy(copy, before, blen*sizeof(QChar));
-        b = copy;
-    }
-
-    QStringMatcher matcher(b, blen, cs);
+    QStringMatcher matcher(before, blen, cs);
 
     int index = 0;
@@ -1709 +1865 @@
             break;
 
-        replace_helper(indices, pos, blen, a, alen);
+        replace_helper(indices, pos, blen, a, alen);
 
         if (index == -1)
@@ -1716 +1872 @@
         index += pos*(alen-blen);
     }
-
-    if (a != after)
-        ::free((QChar *)a);
-    if (b != before)
-        ::free((QChar *)b);
 
     return *this;
@@ -1912 +2063 @@
 bool QString::operator==(const QString &other) const
 {
-    return (size() == other.size()) &&
-        (memcmp((char*)unicode(),(char*)other.unicode(), size()*sizeof(QChar))==0);
+    if (d->size != other.d->size)
+        return false;
+
+    return qMemEquals(d->data, other.d->data, d->size);
 }
 
@@ -2534 +2687 @@
 
     int index = 0;
-    int numCaptures = rx2.numCaptures();
+    int numCaptures = rx2.();
     int al = after.length();
     QRegExp::CaretMode caretMode = QRegExp::CaretAtZero;
@@ -3140 +3293 @@
         return false;
     if (cs == Qt::CaseSensitive) {
-        return memcmp((char*)d->data, (char*)s.d->data, s.d->size*sizeof(QChar)) == 0;
+        return ;
     } else {
         uint last = 0;
@@ -3211 +3364 @@
         return false;
     if (cs == Qt::CaseSensitive) {
-        return memcmp((char*)&d->data[pos], (char*)s.d->data, s.d->size*sizeof(QChar)) == 0;
+        return ;
     } else {
         uint last = 0;
@@ -3336 +3489 @@
 }
 
-#if !defined(Q_WS_MAC) && !defined(Q_OS_OS2)
+#if !defined(Q_WS_MAC) && !defined(Q_OS_OS2)
 static QByteArray toLocal8Bit_helper(const QChar *data, int length)
 {
@@ -3454 +3607 @@
             size = qstrlen(str);
         d = static_cast<Data *>(qMalloc(sizeof(Data) + size * sizeof(QChar)));
+
         d->ref = 1;
         d->alloc = d->size = size;
@@ -3461 +3615 @@
         d->array[size] = '\0';
         while (size--)
-           *i++ = (uchar)*str++;
+           *i++ = (uchar)*str++;
     }
     return d;
@@ -3570 +3724 @@
     QByteArray mb(4096, 0);
     int len;
-    while (!(len=WideCharToMultiByte(CP_ACP, 0, (const WCHAR*)ch, uclen,
+    while (!(len=WideCharToMultiByte(CP_ACP, 0, (const *)ch, uclen,
                 mb.data(), mb.size()-1, 0, &used_def)))
     {
@@ -3576 +3730 @@
         if (r == ERROR_INSUFFICIENT_BUFFER) {
             mb.resize(1+WideCharToMultiByte(CP_ACP, 0,
-                                (const WCHAR*)ch, uclen,
+                                (const *)ch, uclen,
                                 0, 0, 0, &used_def));
                 // and try again...
@@ -3597 +3751 @@
         return QString();
     const int wclen_auto = 4096;
-    WCHAR wc_auto[wclen_auto];
+     wc_auto[wclen_auto];
     int wclen = wclen_auto;
-    WCHAR *wc = wc_auto;
+     *wc = wc_auto;
     int len;
     while (!(len=MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
@@ -3612 +3766 @@
                 wclen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
                                     mb, mblen, 0, 0);
-                wc = new WCHAR[wclen];
+                wc = new [wclen];
                 // and try again...
             }
@@ -3655 +3809 @@
     if (size == 0 || (!*str && size < 0))
         return QLatin1String("");
-#if defined(Q_OS_WIN32)
-    if(QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based) {
-        return qt_winMB2QString(str, size);
-    }
-#endif
 #if !defined(QT_NO_TEXTCODEC)
     if (size < 0)
@@ -3704 +3853 @@
         size = qstrlen(str);
 
-    QString result;
-    result.resize(size); // worst case
-    ushort *qch = result.d->data;
-    uint uc = 0;
-    uint min_uc = 0;
-    int need = 0;
-    int error = -1;
-    uchar ch;
-    int i = 0;
-
-    // skip utf8-encoded byte order mark
-    if (size >= 3
-        && (uchar)str[0] == 0xef && (uchar)str[1] == 0xbb && (uchar)str[2] == 0xbf)
-        i += 3;
-
-    for (; i < size; ++i) {
-        ch = str[i];
-        if (need) {
-            if ((ch&0xc0) == 0x80) {
-                uc = (uc << 6) | (ch & 0x3f);
-                need--;
-                if (!need) {
-                    if (uc > 0xffffU && uc < 0x110000U) {
-                        // surrogate pair
-                        *qch++ = QChar::highSurrogate(uc);
-                        uc = QChar::lowSurrogate(uc);
-                    } else if ((uc < min_uc) || (uc >= 0xd800 && uc <= 0xdfff) || (uc >= 0xfffe)) {
-                        // overlong seqence, UTF16 surrogate or BOM
-                        uc = QChar::ReplacementCharacter;
-                    }
-                    *qch++ = uc;
-                }
-            } else {
-                i = error;
-                need = 0;
-                *qch++ = QChar::ReplacementCharacter;
-            }
-        } else {
-            if (ch < 128) {
-                *qch++ = ch;
-            } else if ((ch & 0xe0) == 0xc0) {
-                uc = ch & 0x1f;
-                need = 1;
-                error = i;
-                min_uc = 0x80;
-            } else if ((ch & 0xf0) == 0xe0) {
-                uc = ch & 0x0f;
-                need = 2;
-                error = i;
-                min_uc = 0x800;
-            } else if ((ch&0xf8) == 0xf0) {
-                uc = ch & 0x07;
-                need = 3;
-                error = i;
-                min_uc = 0x10000;
-            } else {
-                // Error
-                *qch++ = QChar::ReplacementCharacter;
-            }
-        }
-    }
-    if (need) {
-        // we have some invalid characters remaining we need to add to the string
-        for (int i = error; i < size; ++i)
-            *qch++ = QChar::ReplacementCharacter;
-    }
-
-    result.truncate(qch - result.d->data);
-    return result;
+    return QUtf8::convertToUnicode(str, size, 0);
 }
 
@@ -3795 +3876 @@
             ++size;
     }
-    return QString((const QChar *)unicode, size);
+    return Q);
 }
 
@@ -3819 +3900 @@
             ++size;
     }
-
-    QString s;
-    s.resize(size*2); // worst case
-    ushort *uc = s.d->data;
-    for (int i = 0; i < size; ++i) {
-        uint u = unicode[i];
-        if (u > 0xffff) {
-            // decompose into a surrogate pair
-            *uc++ = QChar::highSurrogate(u);
-            u = QChar::lowSurrogate(u);
-        }
-        *uc++ = u;
-    }
-    s.resize(uc - s.d->data);
-    return s;
+    return QUtf32::convertToUnicode((const char *)unicode, size*4, 0);
 }
 
@@ -3884 +3951 @@
     if (d->size == 0)
         return *this;
-    QString result;
-    result.resize(d->size);
+    QString result(d->size, Qt::Uninitialized);
     const QChar *from = (const QChar*) d->data;
     const QChar *fromend = (const QChar*) from+d->size;
@@ -4556 +4622 @@
 
 #if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)
-    int res;
-    QT_WA({
-        const TCHAR* s1 = (TCHAR*)data1;
-        const TCHAR* s2 = (TCHAR*)data2;
-        res = CompareStringW(GetUserDefaultLCID(), 0, s1, length1, s2, length2);
-    } , {
-        QByteArray s1 = toLocal8Bit_helper(data1, length1);
-        QByteArray s2 = toLocal8Bit_helper(data2, length2);
-        res = CompareStringA(GetUserDefaultLCID(), 0, s1.data(), s1.length(), s2.data(), s2.length());
-    });
+    int res = CompareString(GetUserDefaultLCID(), 0, (wchar_t*)data1, length1, (wchar_t*)data2, length2);
 
     switch (res) {
@@ -4762 +4819 @@
         const QUnicodeTables::Properties *prop = qGetProp(c);
         if (prop->lowerCaseDiff || prop->lowerCaseSpecial) {
-            QString s;
-            s.resize(d->size);
+            QString s(d->size, Qt::Uninitialized);
             memcpy(s.d->data, d->data, (p - d->data)*sizeof(ushort));
             ushort *pp = s.d->data + (p - d->data);
@@ -4854 +4910 @@
         const QUnicodeTables::Properties *prop = qGetProp(c);
         if (prop->upperCaseDiff || prop->upperCaseSpecial) {
-            QString s;
-            s.resize(d->size);
+            QString s(d->size, Qt::Uninitialized);
             memcpy(s.d->data, d->data, (p - d->data)*sizeof(ushort));
             ushort *pp = s.d->data + (p - d->data);
@@ -6006 +6061 @@
 }
 
+
 /*!
     \overload
@@ -6015 +6071 @@
 QString QString::normalized(QString::NormalizationForm mode, QChar::UnicodeVersion version) const
 {
+
+
+
+
+
+
+
     bool simple = true;
-    for (int i = 0; i < d->size; ++i) {
-        if (d->data[i] >= 0x80) {
+    const QChar *p = data->constData();
+    int len = data->length();
+    for (int i = from; i < len; ++i) {
+        if (p[i].unicode() >= 0x80) {
             simple = false;
             break;
@@ -6023 +6088 @@
     }
     if (simple)
-        return *this;
-
-    QString s = *this;
+        return;
+
+    QString ;
     if (version != CURRENT_VERSION) {
         for (int i = 0; i < NumNormalizationCorrections; ++i) {
             const NormalizationCorrection &n = uc_normalization_corrections[i];
             if (n.version > version) {
+
                 if (n.ucs4 > 0xffff) {
                     ushort ucs4High = QChar::highSurrogate(n.ucs4);
@@ -6035 +6101 @@
                     ushort oldHigh = QChar::highSurrogate(n.old_mapping);
                     ushort oldLow = QChar::lowSurrogate(n.old_mapping);
-                    int pos = 0;
-                    while (pos < s.d->size - 1) {
-                        if (s.d->data[pos] == ucs4High && s.d->data[pos + 1] == ucs4Low) {
-                            s.detach();
-                            s.d->data[pos] = oldHigh;
-                            s.d->data[pos + 1] = oldLow;
+                    while (pos < s.length() - 1) {
+                        if (s.at(pos).unicode() == ucs4High && s.at(pos + 1).unicode() == ucs4Low) {
+                            s[pos] = oldHigh;
+                            s[pos + 1] = oldLow;
                             ++pos;
                         }
@@ -6046 +6110 @@
                     }
                 } else {
-                    int pos = 0;
-                    while (pos < s.d->size) {
-                        if (s.d->data[pos] == n.ucs4) {
-                            s.detach();
-                            s.d->data[pos] = n.old_mapping;
+                    while (pos < s.length()) {
+                        if (s.at(pos).unicode() == n.ucs4) {
+                            s[pos] = n.old_mapping;
                         }
                         ++pos;
@@ -6058 +6120 @@
         }
     }
-    s = decomposeHelper(s, mode < QString::NormalizationForm_KD, version);
-
-    s = canonicalOrderHelper(s, version);
+    );
+
+    );
 
     if (mode == QString::NormalizationForm_D || mode == QString::NormalizationForm_KD)
-        return s;
-
-    return composeHelper(s);
-
+        return;
+
+    composeHelper(data, from);
 }
 
@@ -6152 +6213 @@
                      *qMax(abs_field_width, larg.length());
 
-    QString result;
-    result.resize(result_len);
+    QString result(result_len, Qt::Uninitialized);
     QChar *result_buff = (QChar*) result.unicode();
 
@@ -6452 +6512 @@
 
     if (d.occurrences == 0) {
-        qWarning("QString::arg: Argument missing: %s, %lld", toLocal8Bit().data(), a);
+        qWarning(;
         return *this;
     }
@@ -6495 +6555 @@
 
     if (d.occurrences == 0) {
-        qWarning("QString::arg: Argument missing: %s, %llu", toLocal8Bit().data(), a);
+        qWarning(;
         return *this;
     }
@@ -6896 +6956 @@
 {
     Data *x = static_cast<Data *>(qMalloc(sizeof(Data)));
+
     if (unicode) {
         x->data = (ushort *)unicode;
@@ -6912 +6973 @@
     \brief The QLatin1String class provides a thin wrapper around an ASCII/Latin-1 encoded string literal.
 
-    \ingroup text
+    \ingroup 
     \reentrant
 
@@ -7174 +7235 @@
 
 
-#ifndef QT_NO_DATASTREAM
+#if
 /*!
     \fn QDataStream &operator<<(QDataStream &stream, const QString &string)
@@ -7534 +7595 @@
     \reentrant
     \ingroup tools
-    \ingroup text
+    \ingroup 
 
     QStringRef provides a read-only subset of the QString API.
@@ -7721 +7782 @@
 bool operator==(const QStringRef &s1,const QStringRef &s2)
 { return (s1.size() == s2.size() &&
-          (memcmp((char*)s1.unicode(), (char*)s2.unicode(), s1.size()*sizeof(QChar))==0)); }
+          qMemEquals((const ushort *)s1.unicode(), (const ushort *)s2.unicode(), s1.size()));
+}
 
 /*! \relates QStringRef
@@ -7730 +7792 @@
 bool operator==(const QString &s1,const QStringRef &s2)
 { return (s1.size() == s2.size() &&
-          (memcmp((char*)s1.unicode(), (char*)s2.unicode(), s1.size()*sizeof(QChar))==0)); }
+          qMemEquals((const ushort *)s1.unicode(), (const ushort *)s2.unicode(), s1.size()));
+}
 
 /*! \relates QStringRef