MCL/sf/mw/qt: comparison src/corelib/io/qiodevice.cpp

equal deleted inserted replaced

-:dee5afe5301f
+:3f74d0d4af4c
 {
 debugBinaryString(QByteArray(data, maxlen));
 }
 #endif
-#ifndef QIODEVICE_BUFFERSIZE
-#define QIODEVICE_BUFFERSIZE Q_INT64_C(16384)
-#endif
 #define Q_VOID
 #define CHECK_MAXLEN(function, returnType) \
 do { \
 if (maxSize < 0) { \
 /*! \internal
 */
 QIODevicePrivate::QIODevicePrivate()
 : openMode(QIODevice::NotOpen), buffer(QIODEVICE_BUFFERSIZE),
 pos(0), devicePos(0)
+, pPos(&pos), pDevicePos(&devicePos)
 , baseReadLineDataCalled(false)
+, firstRead(true)
 , accessMode(Unset)
 #ifdef QT_NO_QOBJECT
 , q_ptr(0)
 #endif
 {
 \value Unbuffered Any buffer in the device is bypassed.
 Certain flags, such as \c Unbuffered and \c Truncate, are
 meaningless when used with some subclasses. Some of these
 restrictions are implied by the type of device that is represented
-by a subclass; for example, access to a QBuffer is always
+by a subclass. In other cases, the restriction may be due to the
-unbuffered. In other cases, the restriction may be due to the
 implementation, or may be imposed by the underlying platform; for
 example, QTcpSocket does not support \c Unbuffered mode, and
 limitations in the native API prevent QFile from supporting \c
 Unbuffered on Windows.
 */
 \sa openMode() OpenMode
 */
 void QIODevice::setOpenMode(OpenMode openMode)
 {
+Q_D(QIODevice);
 #if defined QIODEVICE_DEBUG
 printf("%p QIODevice::setOpenMode(0x%x)\n", this, int(openMode));
 #endif
-d_func()->openMode = openMode;
+d->openMode = openMode;
-d_func()->accessMode = QIODevicePrivate::Unset;
+d->accessMode = QIODevicePrivate::Unset;
+d->firstRead = true;
+if (!isReadable())
+d->buffer.clear();
 }
 /*!
 If \a enabled is true, this function sets the \l Text flag on the device;
 otherwise the \l Text flag is removed. This feature is useful for classes
 Q_D(QIODevice);
 d->openMode = mode;
 d->pos = (mode & Append) ? size() : qint64(0);
 d->buffer.clear();
 d->accessMode = QIODevicePrivate::Unset;
+d->firstRead = true;
 #if defined QIODEVICE_DEBUG
 printf("%p QIODevice::open(0x%x)\n", this, quint32(mode));
 #endif
 return true;
 }
 #endif
 d->openMode = NotOpen;
 d->errorString.clear();
 d->pos = 0;
 d->buffer.clear();
+d->firstRead = true;
 }
 /*!
 For random-access devices, this function returns the position that
 data is written to or read from. For sequential devices or closed
 qint64 QIODevice::bytesToWrite() const
 {
 return qint64(0);
 }
+#ifdef Q_CC_RVCT
+// arm mode makes the 64-bit integer operations much faster in RVCT 2.2
+#pragma push
+#pragma arm
+#endif
 /*!
 Reads at most \a maxSize bytes from the device into \a data, and
 returns the number of bytes read. If an error occurs, such as when
 attempting to read from a device opened in WriteOnly mode, this
 function returns -1.
 \sa readData() readLine() write()
 */
 qint64 QIODevice::read(char *data, qint64 maxSize)
 {
 Q_D(QIODevice);
-CHECK_READABLE(read, qint64(-1));
-CHECK_MAXLEN(read, qint64(-1));
 #if defined QIODEVICE_DEBUG
 printf("%p QIODevice::read(%p, %d), d->pos = %d, d->buffer.size() = %d\n",
 this, data, int(maxSize), int(d->pos), int(d->buffer.size()));
 #endif
-const bool sequential = d->isSequential();
 // Short circuit for getChar()
 if (maxSize == 1) {
 int chint;
 while ((chint = d->buffer.getChar()) != -1) {
-if (!sequential)
+++(*d->pPos);
-++d->pos;
 char c = char(uchar(chint));
 if (c == '\r' && (d->openMode & Text))
 continue;
 *data = c;
 #endif
 return qint64(1);
 }
 }
+CHECK_MAXLEN(read, qint64(-1));
 qint64 readSoFar = 0;
 bool moreToRead = true;
 do {
-int lastReadChunkSize = 0;
 // Try reading from the buffer.
-if (!d->buffer.isEmpty()) {
+int lastReadChunkSize = d->buffer.read(data, maxSize);
-lastReadChunkSize = d->buffer.read(data + readSoFar, maxSize - readSoFar);
+*d->pPos += lastReadChunkSize;
 readSoFar += lastReadChunkSize;
-if (!sequential)
+// fast exit when satisfied by buffer
-d->pos += lastReadChunkSize;
+if (lastReadChunkSize == maxSize && !(d->openMode & Text))
+return readSoFar;
+if (lastReadChunkSize > 0) {
+data += lastReadChunkSize;
+maxSize -= lastReadChunkSize;
 #if defined QIODEVICE_DEBUG
 printf("%p \treading %d bytes from buffer into position %d\n", this, lastReadChunkSize,
 int(readSoFar) - lastReadChunkSize);
 #endif
-} else if ((d->openMode & Unbuffered) == 0 && maxSize < QIODEVICE_BUFFERSIZE) {
+} else {
-// In buffered mode, we try to fill up the QIODevice buffer before
+if (d->firstRead) {
-// we do anything else.
+// this is the first time the file has been read, check it's valid and set up pos pointers
-int bytesToBuffer = qMax(maxSize - readSoFar, QIODEVICE_BUFFERSIZE);
+// for fast pos updates.
-char *writePointer = d->buffer.reserve(bytesToBuffer);
+CHECK_READABLE(read, qint64(-1));
+d->firstRead = false;
-// Make sure the device is positioned correctly.
+if (d->isSequential()) {
-if (d->pos != d->devicePos && !sequential && !seek(d->pos))
+d->pPos = &d->seqDumpPos;
-return qint64(-1);
+d->pDevicePos = &d->seqDumpPos;
-qint64 readFromDevice = readData(writePointer, bytesToBuffer);
+}
-d->buffer.chop(bytesToBuffer - (readFromDevice < 0 ? 0 : int(readFromDevice)));
+}
-if (readFromDevice > 0) {
+if ((d->openMode & Unbuffered) == 0 && maxSize < QIODEVICE_BUFFERSIZE) {
-if (!sequential)
+// In buffered mode, we try to fill up the QIODevice buffer before
-d->devicePos += readFromDevice;
+// we do anything else.
-#if defined QIODEVICE_DEBUG
+// buffer is empty at this point, try to fill it
-printf("%p \treading %d from device into buffer\n", this, int(readFromDevice));
+int bytesToBuffer = QIODEVICE_BUFFERSIZE;
-#endif
+char *writePointer = d->buffer.reserve(bytesToBuffer);
-if (readFromDevice < bytesToBuffer)
+// Make sure the device is positioned correctly.
-d->buffer.truncate(int(readFromDevice));
+if (d->pos != d->devicePos && !d->isSequential() && !seek(d->pos))
-if (!d->buffer.isEmpty()) {
+return readSoFar ? readSoFar : qint64(-1);
-lastReadChunkSize = d->buffer.read(data + readSoFar, maxSize - readSoFar);
+qint64 readFromDevice = readData(writePointer, bytesToBuffer);
-readSoFar += lastReadChunkSize;
+d->buffer.chop(bytesToBuffer - (readFromDevice < 0 ? 0 : int(readFromDevice)));
-if (!sequential)
-d->pos += lastReadChunkSize;
+if (readFromDevice > 0) {
-#if defined QIODEVICE_DEBUG
+*d->pDevicePos += readFromDevice;
-printf("%p \treading %d bytes from buffer at position %d\n", this,
+#if defined QIODEVICE_DEBUG
-lastReadChunkSize, int(readSoFar));
+printf("%p \treading %d from device into buffer\n", this, int(readFromDevice));
 #endif
+if (!d->buffer.isEmpty()) {
+lastReadChunkSize = d->buffer.read(data, maxSize);
+readSoFar += lastReadChunkSize;
+data += lastReadChunkSize;
+maxSize -= lastReadChunkSize;
+*d->pPos += lastReadChunkSize;
+#if defined QIODEVICE_DEBUG
+printf("%p \treading %d bytes from buffer at position %d\n", this,
+lastReadChunkSize, int(readSoFar));
+#endif
+}
 }
 }
 }
 // If we need more, try reading from the device.
-if (readSoFar < maxSize) {
+if (maxSize > 0) {
 // Make sure the device is positioned correctly.
-if (d->pos != d->devicePos && !sequential && !seek(d->pos))
+if (d->pos != d->devicePos && !d->isSequential() && !seek(d->pos))
-return qint64(-1);
+return readSoFar ? readSoFar : qint64(-1);
-qint64 readFromDevice = readData(data + readSoFar, maxSize - readSoFar);
+qint64 readFromDevice = readData(data, maxSize);
 #if defined QIODEVICE_DEBUG
 printf("%p \treading %d bytes from device (total %d)\n", this, int(readFromDevice), int(readSoFar));
 #endif
 if (readFromDevice == -1 && readSoFar == 0) {
 // error and we haven't read anything: return immediately
 return -1;
 }
-if (readFromDevice <= 0) {
+if (readFromDevice > 0) {
-moreToRead = false;
-} else {
-// see if we read as much data as we asked for
-if (readFromDevice < maxSize - readSoFar)
-moreToRead = false;
 lastReadChunkSize += int(readFromDevice);
 readSoFar += readFromDevice;
-if (!sequential) {
+data += readFromDevice;
-d->pos += readFromDevice;
+maxSize -= readFromDevice;
-d->devicePos += readFromDevice;
+*d->pPos += readFromDevice;
-}
+*d->pDevicePos += readFromDevice;
 }
-} else {
-moreToRead = false;
 }
+// Best attempt has been made to read data, don't try again except for text mode adjustment below
+moreToRead = false;
 if (readSoFar && d->openMode & Text) {
-char *readPtr = data + readSoFar - lastReadChunkSize;
+char *readPtr = data - lastReadChunkSize;
-const char *endPtr = data + readSoFar;
+const char *endPtr = data;
 if (readPtr < endPtr) {
 // optimization to avoid initial self-assignment
 while (*readPtr != '\r') {
 if (++readPtr == endPtr)
 while (readPtr < endPtr) {
 char ch = *readPtr++;
 if (ch != '\r')
 *writePtr++ = ch;
-else
+else {
 --readSoFar;
+--data;
+++maxSize;
+}
 }
 // Make sure we get more data if there is room for more. This
 // is very important for when someone seeks to the start of a
 // '\r\n' and reads one character - they should get the '\n'.
 } while (moreToRead);
 #if defined QIODEVICE_DEBUG
 printf("%p \treturning %d, d->pos == %d, d->buffer.size() == %d\n", this,
 int(readSoFar), int(d->pos), d->buffer.size());
-debugBinaryString(data, readSoFar);
+debugBinaryString(data - readSoFar, readSoFar);
 #endif
 return readSoFar;
 }
+#ifdef Q_CC_RVCT
+#pragma pop
+#endif
 /*!
 \overload
 Reads at most \a maxSize bytes from the device, and returns the
 result.resize(int(readBytes));
 return result;
 }
+#ifdef Q_CC_RVCT
+// arm mode makes the 64-bit integer operations much faster in RVCT 2.2
+#pragma push
+#pragma arm
+#endif
 /*!
 This function reads a line of ASCII characters from the device, up
 to a maximum of \a maxSize - 1 bytes, stores the characters in \a
 data, and returns the number of bytes read. If a line could not be
 read but no error ocurred, this function returns 0. If an error
-occurs, this function returns what it could the length of what
+occurs, this function returns the length of what could be read, or
-could be read, or -1 if nothing was read.
+-1 if nothing was read.
 A terminating '\0' byte is always appended to \a data, so \a
 maxSize must be larger than 1.
 Data is read until either of the following conditions are met:
 #endif
 if (lastReadReturn != 1 && readSoFar == 0)
 return isSequential() ? lastReadReturn : -1;
 return readSoFar;
 }
+#ifdef Q_CC_RVCT
+#pragma pop
+#endif
 /*!
 Returns true if a complete line of data can be read from the device;
 otherwise returns false.
 \sa read() putChar() ungetChar()
 */
 bool QIODevice::getChar(char *c)
 {
-Q_D(QIODevice);
+// readability checked in read()
-CHECK_READABLE(getChar, false);
 char ch;
 return (1 == read(c ? c : &ch, 1));
 }
 /*!

branch	RCL_3
changeset 7	3f74d0d4af4c
parent 4	3b1da2848fc7
child 13	c0432d11811c