Changeset 561 for trunk/src/corelib/tools/qbytearray.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/qbytearray.cpp (modified) (31 diffs)

trunk/src/corelib/tools/qbytearray.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$
 **
@@ -48 +48 @@
 #include "qlocale_p.h"
 #include "qunicodetables_p.h"
-#ifndef QT_NO_DATASTREAM
+#i
 #include <qdatastream.h>
-#endif
 
 #ifndef QT_NO_COMPRESS
@@ -536 +535 @@
                        (data[2] <<  8) | (data[3]      );
     ulong len = qMax(expectedSize, 1ul);
-    QByteArray baunzip;
-    int res;
-    do {
-        baunzip.resize(len);
-        res = ::uncompress((uchar*)baunzip.data(), &len,
-                            (uchar*)data+4, nbytes-4);
+    QScopedPointer<QByteArray::Data, QScopedPointerPodDeleter> d;
+
+    forever {
+        ulong alloc = len;
+        d.reset(q_check_ptr(static_cast<QByteArray::Data *>(qRealloc(d.data(), sizeof(QByteArray::Data) + alloc))));
+        if (!d) {
+            // we are not allowed to crash here when compiling with QT_NO_EXCEPTIONS
+            qWarning("qUncompress: could not allocate enough memory to uncompress data");
+            return QByteArray();
+        }
+
+        int res = ::uncompress((uchar*)d->array, &len,
+                               (uchar*)data+4, nbytes-4);
 
         switch (res) {
         case Z_OK:
-            if ((int)len != baunzip.size())
-                baunzip.resize(len);
-            break;
+            if (len != alloc) {
+                d.reset(q_check_ptr(static_cast<QByteArray::Data *>(qRealloc(d.data(), sizeof(QByteArray::Data) + len))));
+                if (!d) {
+                    // we are not allowed to crash here when compiling with QT_NO_EXCEPTIONS
+                    qWarning("qUncompress: could not allocate enough memory to uncompress data");
+                    return QByteArray();
+                }
+            }
+            d->ref = 1;
+            d->alloc = d->size = len;
+            d->data = d->array;
+
+            return QByteArray(d.take(), 0, 0);
+
         case Z_MEM_ERROR:
             qWarning("qUncompress: Z_MEM_ERROR: Not enough memory");
-            break;
+            return QByteArray();
+
         case Z_BUF_ERROR:
             len *= 2;
-            break;
+            continue;
+
         case Z_DATA_ERROR:
             qWarning("qUncompress: Z_DATA_ERROR: Input data is corrupted");
-            break;
+            ;
         }
-    } while (res == Z_BUF_ERROR);
-
-    if (res != Z_OK)
-        baunzip = QByteArray();
-
-    return baunzip;
+    }
 }
 #endif
@@ -580 +594 @@
 }
 
-Q_CORE_EXPORT QByteArray::Data QByteArray::shared_null = {Q_BASIC_ATOMIC_INITIALIZER(1),
+QByteArray::Data QByteArray::shared_null = {Q_BASIC_ATOMIC_INITIALIZER(1),
                                                           0, 0, shared_null.array, {0} };
 QByteArray::Data QByteArray::shared_empty = { Q_BASIC_ATOMIC_INITIALIZER(1),
@@ -591 +605 @@
     \ingroup tools
     \ingroup shared
-    \ingroup text
-    \mainclass
+    \ingroup 
+
     \reentrant
 
@@ -890 +904 @@
     addition, QByteArray ensures that the byte at position size() is
     always '\\0', so that you can use the return value of data() and
-    constData() as arguments to functions that expect
-    '\\0'-terminated strings.
+    constData() as arguments to functions that expect
+    strings.
 
     Example:
@@ -984 +998 @@
     Returns a pointer to the data stored in the byte array. The
     pointer can be used to access and modify the bytes that compose
-    the array. The data is '\\0'-terminated.
+    the array. The data is '\\0'-terminated, i.e. the number of
+    bytes in the returned character string is size() + 1 for the
+    '\\0' terminator.
 
     Example:
@@ -995 +1011 @@
     This function is mostly useful to pass a byte array to a function
     that accepts a \c{const char *}.
+
+
+
+
+
+
+
+
+
+
 
     Note: A QByteArray can store any byte values including '\\0's,
@@ -1234 +1260 @@
         int len = qstrlen(str);
         d = static_cast<Data *>(qMalloc(sizeof(Data)+len));
-        if (!d) {
-            d = &shared_null;
-        } else {
-            d->ref = 0;;
-            d->alloc = d->size = len;
-            d->data = d->array;
-            memcpy(d->array, str, len+1); // include null terminator
-        }
+        Q_CHECK_PTR(d);
+        d->ref = 0;;
+        d->alloc = d->size = len;
+        d->data = d->array;
+        memcpy(d->array, str, len+1); // include null terminator
     }
     d->ref.ref();
@@ -1265 +1288 @@
     } else {
         d = static_cast<Data *>(qMalloc(sizeof(Data) + size));
-        if (!d) {
-            d = &shared_null;
-        } else {
-            d->ref = 0;
-            d->alloc = d->size = size;
-            d->data = d->array;
-            memcpy(d->array, data, size);
-            d->array[size] = '\0';
-        }
+        Q_CHECK_PTR(d);
+        d->ref = 0;
+        d->alloc = d->size = size;
+        d->data = d->array;
+        memcpy(d->array, data, size);
+        d->array[size] = '\0';
     }
     d->ref.ref();
@@ -1291 +1311 @@
     } else {
         d = static_cast<Data *>(qMalloc(sizeof(Data)+size));
-        if (!d) {
-            d = &shared_null;
-        } else {
-            d->ref = 0;
-            d->alloc = d->size = size;
-            d->data = d->array;
-            d->array[size] = '\0';
-            memset(d->array, ch, size);
-        }
+        Q_CHECK_PTR(d);
+        d->ref = 0;
+        d->alloc = d->size = size;
+        d->data = d->array;
+        d->array[size] = '\0';
+        memset(d->array, ch, size);
     }
     d->ref.ref();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 }
 
@@ -1335 +1368 @@
         //
         Data *x = static_cast<Data *>(qMalloc(sizeof(Data)+size));
-        if (!x)
-            return;
+        Q_CHECK_PTR(x);
         x->ref = 1;
         x->alloc = x->size = size;
@@ -1378 +1410 @@
     if (d->ref != 1 || d->data != d->array) {
         Data *x = static_cast<Data *>(qMalloc(sizeof(Data) + alloc));
-        if (!x)
-            return;
+        Q_CHECK_PTR(x);
         x->size = qMin(alloc, d->size);
         ::memcpy(x->array, d->data, x->size);
@@ -1391 +1422 @@
     } else {
         Data *x = static_cast<Data *>(qRealloc(d, sizeof(Data) + alloc));
-        if (!x)
-            return;
+        Q_CHECK_PTR(x);
         x->alloc = alloc;
         x->data = x->array;
@@ -1460 +1490 @@
 QByteArray &QByteArray::prepend(const char *str)
 {
+
+
+
+
+
+
+
+
+
+
+
+
     if (str) {
-        int len = qstrlen(str);
         if (d->ref != 1 || d->size + len > d->alloc)
             realloc(qAllocMore(d->size + len, sizeof(Data)));
@@ -1563 +1604 @@
 
     If \a len is negative, the length of the string will be determined
-    automatically using qstrlen(). If \a len is zero or the length of the
-    string is zero, nothing will be appended to the byte array.
+    automatically using qstrlen(). If \a len is zero or \a str is
+    null, nothing is appended to the byte array. Ensure that \a len is
+    \e not longer than \a str.
 */
 
@@ -1672 +1714 @@
 /*!
     \overload
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
     Inserts character \a ch at index position \a i in the byte array.
@@ -1813 +1871 @@
     if (after >= d->data && after < d->data + d->size) {
         char *copy = (char *)malloc(asize);
+
         memcpy(copy, after, asize);
         a = copy;
@@ -1818 +1877 @@
     if (before >= d->data && before < d->data + d->size) {
         char *copy = (char *)malloc(bsize);
+
         memcpy(copy, before, bsize);
         b = copy;
@@ -2592 +2652 @@
 }
 
+
+
 /*! \relates QByteArray
 
@@ -2599 +2661 @@
     \sa {Format of the QDataStream operators}
 */
-#ifndef QT_NO_DATASTREAM
 
 QDataStream &operator<<(QDataStream &out, const QByteArray &ba)
@@ -2642 +2703 @@
     return in;
 }
-#endif //QT_NO_DATASTREAM
+#endif //QT_NO_DATASTREAM
 
 /*! \fn bool QByteArray::operator==(const QString &str) const
@@ -2977 +3038 @@
     if (d->size == 0)
         return *this;
-    QByteArray result;
-    result.resize(d->size);
+    QByteArray result(d->size, Qt::Uninitialized);
     const char *from = d->data;
     const char *fromend = from + d->size;
@@ -3429 +3489 @@
     int padlen = 0;
 
-    QByteArray tmp;
-    tmp.resize(((d->size * 4) / 3) + 3);
+    QByteArray tmp((d->size * 4) / 3 + 3, Qt::Uninitialized);
 
     int i = 0;
@@ -3739 +3798 @@
 {
     Data *x = static_cast<Data *>(qMalloc(sizeof(Data)));
+
     if (data) {
         x->data = const_cast<char *>(data);
@@ -3768 +3828 @@
     unsigned int buf = 0;
     int nbits = 0;
-    QByteArray tmp;
-    tmp.resize((base64.size() * 3) / 4);
+    QByteArray tmp((base64.size() * 3) / 4, Qt::Uninitialized);
 
     int offset = 0;
@@ -3817 +3876 @@
 QByteArray QByteArray::fromHex(const QByteArray &hexEncoded)
 {
-    QByteArray res;
-    res.resize((hexEncoded.size() + 1)/ 2);
+    QByteArray res((hexEncoded.size() + 1)/ 2, Qt::Uninitialized);
     uchar *result = (uchar *)res.data() + res.size();
 
@@ -3855 +3913 @@
 QByteArray QByteArray::toHex() const
 {
-    QByteArray hex;
-    hex.resize(d->size*2);
+    QByteArray hex(d->size * 2, Qt::Uninitialized);
     char *hexData = hex.data();
     const uchar *data = (const uchar *)d->data;
@@ -4093 +4150 @@
 */
 
+
+
+
+
 /*!
     \fn QByteArray::QByteArray(int size)