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

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 \sa pos(), isSequential()
 */
 bool QIODevice::seek(qint64 pos)
 {
-if (d_func()->openMode == NotOpen) {
+Q_D(QIODevice);
+if (d->openMode == NotOpen) {
 qWarning("QIODevice::seek: The device is not open");
 return false;
 }
 if (pos < 0) {
 qWarning("QIODevice::seek: Invalid pos: %d", int(pos));
 return false;
 }
-Q_D(QIODevice);
 #if defined QIODEVICE_DEBUG
 printf("%p QIODevice::seek(%d), before: d->pos = %d, d->buffer.size() = %d\n",
 this, int(pos), int(d->pos), d->buffer.size());
 #endif
 if (!d->isSequential()) {
 d->pos = pos;
 d->devicePos = pos;
 }
-if (offset > 0 && !d->buffer.isEmpty()) {
+if (offset < 0
-// When seeking forwards, we need to pop bytes off the front of the
+|| offset >= qint64(d->buffer.size()))
-// buffer.
-do {
-int bytesToSkip = int(qMin<qint64>(offset, INT_MAX));
-d->buffer.skip(bytesToSkip);
-offset -= bytesToSkip;
-} while (offset > 0);
-} else if (offset < 0) {
 // When seeking backwards, an operation that is only allowed for
 // random-access devices, the buffer is cleared. The next read
 // operation will then refill the buffer. We can optimize this, if we
 // find that seeking backwards becomes a significant performance hit.
 d->buffer.clear();
-}
+else if (!d->buffer.isEmpty())
+d->buffer.skip(int(offset));
 #if defined QIODEVICE_DEBUG
 printf("%p \tafter: d->pos == %d, d->buffer.size() == %d\n", this, int(d->pos),
 d->buffer.size());
 #endif
 return true;
 #endif
 const bool sequential = d->isSequential();
 // Short circuit for getChar()
 if (maxSize == 1) {
-int chint = d->buffer.getChar();
+int chint;
-if (chint != -1) {
+while ((chint = d->buffer.getChar()) != -1) {
+if (!sequential)
+++d->pos;
 char c = char(uchar(chint));
-if (c == '\r' && (d->openMode & Text)) {
+if (c == '\r' && (d->openMode & Text))
-d->buffer.ungetChar(c);
+continue;
-} else {
+*data = c;
-if (data)
+#if defined QIODEVICE_DEBUG
-*data = c;
+printf("%p \tread 0x%hhx (%c) returning 1 (shortcut)\n", this,
-if (!sequential)
+int(c), isprint(c) ? c : '?');
-++d->pos;
+#endif
-#if defined QIODEVICE_DEBUG
+return qint64(1);
-printf("%p \tread 0x%hhx (%c) returning 1 (shortcut)\n", this,
-int(c), isprint(c) ? c : '?');
-#endif
-return qint64(1);
-}
 }
 }
 qint64 readSoFar = 0;
 bool moreToRead = true;
 for reading, or that an error occurred.
 */
 QByteArray QIODevice::read(qint64 maxSize)
 {
 Q_D(QIODevice);
-CHECK_MAXLEN(read, QByteArray());
+QByteArray result;
-QByteArray tmp;
-qint64 readSoFar = 0;
+CHECK_MAXLEN(read, result);
-char buffer[4096];
 #if defined QIODEVICE_DEBUG
 printf("%p QIODevice::read(%d), d->pos = %d, d->buffer.size() = %d\n",
 this, int(maxSize), int(d->pos), int(d->buffer.size()));
 #else
 Q_UNUSED(d);
 #endif
-do {
+if (maxSize != qint64(int(maxSize))) {
-qint64 bytesToRead = qMin(int(maxSize - readSoFar), int(sizeof(buffer)));
+qWarning("QIODevice::read: maxSize argument exceeds QByteArray size limit");
-qint64 readBytes = read(buffer, bytesToRead);
+maxSize = INT_MAX;
-if (readBytes <= 0)
+}
-break;
-tmp.append(buffer, (int) readBytes);
+qint64 readBytes = 0;
-readSoFar += readBytes;
+if (maxSize) {
-} while (readSoFar < maxSize && bytesAvailable() > 0);
+result.resize(int(maxSize));
+if (!result.size()) {
-return tmp;
+// If resize fails, read incrementally.
+qint64 readResult;
+do {
+result.resize(int(qMin(maxSize, result.size() + QIODEVICE_BUFFERSIZE)));
+readResult = read(result.data() + readBytes, result.size() - readBytes);
+if (readResult > 0 || readBytes == 0)
+readBytes += readResult;
+} while (readResult == QIODEVICE_BUFFERSIZE);
+} else {
+readBytes = read(result.data(), result.size());
+}
+}
+if (readBytes <= 0)
+result.clear();
+else
+result.resize(int(readBytes));
+return result;
 }
 /*!
 \overload
 #if defined QIODEVICE_DEBUG
 printf("%p QIODevice::readAll(), d->pos = %d, d->buffer.size() = %d\n",
 this, int(d->pos), int(d->buffer.size()));
 #endif
-QByteArray tmp;
+QByteArray result;
-if (d->isSequential() || size() == 0) {
+qint64 readBytes = 0;
-// Read it in chunks. Use bytesAvailable() as an unreliable hint for
+if (d->isSequential() || (readBytes = size()) == 0) {
-// sequential devices, but try to read 4K as a minimum.
+// Size is unknown, read incrementally.
-int chunkSize = qMax(qint64(4096), bytesAvailable());
+qint64 readResult;
-qint64 totalRead = 0;
+do {
-forever {
+result.resize(result.size() + QIODEVICE_BUFFERSIZE);
-tmp.resize(tmp.size() + chunkSize);
+readResult = read(result.data() + readBytes, result.size() - readBytes);
-qint64 readBytes = read(tmp.data() + totalRead, chunkSize);
+if (readResult > 0 || readBytes == 0)
-tmp.chop(chunkSize - (readBytes < 0 ? 0 : readBytes));
+readBytes += readResult;
-if (readBytes <= 0)
+} while (readResult > 0);
-return tmp;
-totalRead += readBytes;
-chunkSize = qMax(qint64(4096), bytesAvailable());
-}
 } else {
 // Read it all in one go.
-tmp.resize(int(bytesAvailable()));
+// If resize fails, don't read anything.
-qint64 readBytes = read(tmp.data(), tmp.size());
+result.resize(int(readBytes - d->pos));
-tmp.resize(readBytes < 0 ? 0 : int(readBytes));
+readBytes = read(result.data(), result.size());
 }
-return tmp;
+if (readBytes <= 0)
+result.clear();
+else
+result.resize(int(readBytes));
+return result;
 }
 /*!
 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
 for reading, or that an error occurred.
 */
 QByteArray QIODevice::readLine(qint64 maxSize)
 {
 Q_D(QIODevice);
-CHECK_MAXLEN(readLine, QByteArray());
+QByteArray result;
-QByteArray tmp;
-const int BufferGrowth = 4096;
+CHECK_MAXLEN(readLine, result);
-qint64 readSoFar = 0;
-qint64 readBytes = 0;
 #if defined QIODEVICE_DEBUG
 printf("%p QIODevice::readLine(%d), d->pos = %d, d->buffer.size() = %d\n",
 this, int(maxSize), int(d->pos), int(d->buffer.size()));
 #else
 Q_UNUSED(d);
 #endif
-do {
+if (maxSize > INT_MAX) {
-if (maxSize != 0)
+qWarning("QIODevice::read: maxSize argument exceeds QByteArray size limit");
-tmp.resize(int(readSoFar + qMin(int(maxSize), BufferGrowth)));
+maxSize = INT_MAX;
-else
+}
-tmp.resize(int(readSoFar + BufferGrowth));
-readBytes = readLine(tmp.data() + readSoFar, tmp.size() - readSoFar);
+result.resize(int(maxSize));
-if (readBytes <= 0)
+qint64 readBytes = 0;
-break;
+if (!result.size()) {
+// If resize fails or maxSize == 0, read incrementally
-readSoFar += readBytes;
+if (maxSize == 0)
-} while ((!maxSize || readSoFar < maxSize) &&
+maxSize = INT_MAX;
-readSoFar + 1 == tmp.size() &&   // +1 due to the ending null
-tmp.at(readSoFar - 1) != '\n');
+// The first iteration needs to leave an extra byte for the terminating null
+result.resize(1);
-if (readSoFar == 0 && readBytes == -1)
-tmp.clear();            // return Null if we found an error
+qint64 readResult;
+do {
+result.resize(int(qMin(maxSize, result.size() + QIODEVICE_BUFFERSIZE)));
+readResult = readLine(result.data() + readBytes, result.size() - readBytes);
+if (readResult > 0 || readBytes == 0)
+readBytes += readResult;
+} while (readResult == QIODEVICE_BUFFERSIZE
+&& result[int(readBytes - 1)] != '\n');
+} else
+readBytes = readLine(result.data(), result.size());
+if (readBytes <= 0)
+result.clear();
 else
-tmp.resize(int(readSoFar));
+result.resize(readBytes);
-return tmp;
+return result;
 }
 /*!
 Reads up to \a maxSize characters into \a data and returns the
 number of characters read.
 \sa read() putChar() ungetChar()
 */
 bool QIODevice::getChar(char *c)
 {
 Q_D(QIODevice);
-const OpenMode openMode = d->openMode;
+CHECK_READABLE(getChar, false);
-if (!(openMode & ReadOnly)) {
-if (openMode == NotOpen)
-qWarning("QIODevice::getChar: Closed device");
-else
-qWarning("QIODevice::getChar: WriteOnly device");
-return false;
-}
-// Shortcut for QIODevice::read(c, 1)
-QRingBuffer *buffer = &d->buffer;
-const int chint = buffer->getChar();
-if (chint != -1) {
-char ch = char(uchar(chint));
-if ((openMode & Text) && ch == '\r') {
-buffer->ungetChar(ch);
-} else {
-if (c)
-*c = ch;
-if (!d->isSequential())
-++d->pos;
-return true;
-}
-}
-// Fall back to read().
 char ch;
-if (read(&ch, 1) == 1) {
+return (1 == read(c ? c : &ch, 1));
-if (c)
-*c = ch;
-return true;
-}
-return false;
 }
 /*!
 \since 4.1

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7
child 7	f7bc934e204c