qiodevice.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
//#define QIODEVICE_DEBUG
 
#include "qbytearray.h"
#include "qdebug.h"
#include "qiodevice_p.h"
#include "qfile.h"
#include "qstringlist.h"
#include "qdir.h"
#include "private/qbytearray_p.h"
#include "private/qtools_p.h"
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
using namespace QtMiscUtils;
 
[[maybe_unused]]
static void debugBinaryString(const char *input, qint64 maxlen)
{
    QByteArray tmp;
    qlonglong startOffset = 0;
    for (qint64 i = 0; i < maxlen; ++i) {
        tmp += input[i];
 
        if ((i % 16) == 15 || i == (maxlen - 1)) {
            printf("\n%15lld:", startOffset);
            startOffset += tmp.size();
 
            for (qsizetype j = 0; j < tmp.size(); ++j)
                printf(" %02x", int(uchar(tmp[j])));
            for (qsizetype j = tmp.size(); j < 16 + 1; ++j)
                printf("   ");
            for (qsizetype j = 0; j < tmp.size(); ++j)
                printf("%c", isAsciiPrintable(tmp[j]) ? tmp[j] : '.');
            tmp.clear();
        }
    }
    printf("\n\n");
}
 
#define Q_VOID
 
static void checkWarnMessage(const QIODevice *device, const char *function, const char *what)
{
#ifndef QT_NO_WARNING_OUTPUT
    QDebug d = qWarning();
    d.noquote();
    d.nospace();
    d << "QIODevice::" << function;
#ifndef QT_NO_QOBJECT
    d << " (" << device->metaObject()->className();
    if (!device->objectName().isEmpty())
        d << ", \"" << device->objectName() << '"';
    if (const QFile *f = qobject_cast<const QFile *>(device))
        d << ", \"" << QDir::toNativeSeparators(f->fileName()) << '"';
    d << ')';
#else
    Q_UNUSED(device);
#endif // !QT_NO_QOBJECT
    d << ": " << what;
#else
    Q_UNUSED(device);
    Q_UNUSED(function);
    Q_UNUSED(what);
#endif // QT_NO_WARNING_OUTPUT
}
 
#define CHECK_MAXLEN(function, returnType) \
    do { \
        if (maxSize < 0) { \
            checkWarnMessage(this, #function, "Called with maxSize < 0"); \
            return returnType; \
        } \
    } while (0)
 
#define CHECK_LINEMAXLEN(function, returnType) \
    do { \
        if (maxSize < 2) { \
            checkWarnMessage(this, #function, "Called with maxSize < 2"); \
            return returnType; \
        } \
    } while (0)
 
#define CHECK_MAXBYTEARRAYSIZE(function) \
    do { \
        if (maxSize >= MaxByteArraySize) { \
            checkWarnMessage(this, #function, "maxSize argument exceeds QByteArray size limit"); \
            maxSize = MaxByteArraySize - 1; \
        } \
    } while (0)
 
#define CHECK_WRITABLE(function, returnType) \
   do { \
       if ((d->openMode & WriteOnly) == 0) { \
           if (d->openMode == NotOpen) { \
               checkWarnMessage(this, #function, "device not open"); \
               return returnType; \
           } \
           checkWarnMessage(this, #function, "ReadOnly device"); \
           return returnType; \
       } \
   } while (0)
 
#define CHECK_READABLE(function, returnType) \
   do { \
       if ((d->openMode & ReadOnly) == 0) { \
           if (d->openMode == NotOpen) { \
               checkWarnMessage(this, #function, "device not open"); \
               return returnType; \
           } \
           checkWarnMessage(this, #function, "WriteOnly device"); \
           return returnType; \
       } \
   } while (0)
 
QIODevicePrivate::QIODevicePrivate()
{
}
 
QIODevicePrivate::~QIODevicePrivate()
{
}
 
#ifdef QT_NO_QOBJECT
QIODevice::QIODevice()
    : d_ptr(new QIODevicePrivate)
{
    d_ptr->q_ptr = this;
}
 
QIODevice::QIODevice(QIODevicePrivate &dd)
    : d_ptr(&dd)
{
    d_ptr->q_ptr = this;
}
#else
 
QIODevice::QIODevice()
    : QObject(*new QIODevicePrivate, nullptr)
{
#if defined QIODEVICE_DEBUG
    QFile *file = qobject_cast<QFile *>(this);
    printf("%p QIODevice::QIODevice(\"%s\") %s\n", this, metaObject()->className(),
           qPrintable(file ? file->fileName() : QString()));
#endif
}
 
QIODevice::QIODevice(QObject *parent)
    : QObject(*new QIODevicePrivate, parent)
{
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::QIODevice(%p \"%s\")\n", this, parent, metaObject()->className());
#endif
}
 
QIODevice::QIODevice(QIODevicePrivate &dd, QObject *parent)
    : QObject(dd, parent)
{
}
#endif
 
 
QIODevice::~QIODevice()
{
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::~QIODevice()\n", this);
#endif
}
 
bool QIODevice::isSequential() const
{
    return false;
}
 
QIODeviceBase::OpenMode QIODevice::openMode() const
{
    return d_func()->openMode;
}
 
void QIODevice::setOpenMode(QIODeviceBase::OpenMode openMode)
{
    Q_D(QIODevice);
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::setOpenMode(0x%x)\n", this, openMode.toInt());
#endif
    d->openMode = openMode;
    d->accessMode = QIODevicePrivate::Unset;
    d->setReadChannelCount(isReadable() ? qMax(d->readChannelCount, 1) : 0);
    d->setWriteChannelCount(isWritable() ? qMax(d->writeChannelCount, 1) : 0);
}
 
void QIODevice::setTextModeEnabled(bool enabled)
{
    Q_D(QIODevice);
    if (!isOpen()) {
        checkWarnMessage(this, "setTextModeEnabled", "The device is not open");
        return;
    }
    if (enabled)
        d->openMode |= Text;
    else
        d->openMode &= ~Text;
}
 
bool QIODevice::isTextModeEnabled() const
{
    return d_func()->openMode.testAnyFlag(Text);
}
 
bool QIODevice::isOpen() const
{
    return d_func()->openMode != NotOpen;
}
 
bool QIODevice::isReadable() const
{
    return (openMode() & ReadOnly) != 0;
}
 
bool QIODevice::isWritable() const
{
    return (openMode() & WriteOnly) != 0;
}
 
int QIODevice::readChannelCount() const
{
    return d_func()->readChannelCount;
}
 
int QIODevice::writeChannelCount() const
{
    return d_func()->writeChannelCount;
}
 
int QIODevice::currentReadChannel() const
{
    return d_func()->currentReadChannel;
}
 
void QIODevice::setCurrentReadChannel(int channel)
{
    Q_D(QIODevice);
 
    if (d->transactionStarted) {
        checkWarnMessage(this, "setReadChannel", "Failed due to read transaction being in progress");
        return;
    }
 
#if defined QIODEVICE_DEBUG
    qDebug("%p QIODevice::setCurrentReadChannel(%d), d->currentReadChannel = %d, d->readChannelCount = %d\n",
           this, channel, d->currentReadChannel, d->readChannelCount);
#endif
 
    d->setCurrentReadChannel(channel);
}
 
void QIODevicePrivate::setReadChannelCount(int count)
{
    if (count > readBuffers.size()) {
        readBuffers.reserve(count);
 
        // If readBufferChunkSize is zero, we should bypass QIODevice's
        // read buffers, even if the QIODeviceBase::Unbuffered flag is not
        // set when opened. However, if a read transaction is started or
        // ungetChar() is called, we still have to use the internal buffer.
        // To support these cases, pass a default value to the QRingBuffer
        // constructor.
 
        while (readBuffers.size() < count)
            readBuffers.emplace_back(readBufferChunkSize != 0 ? readBufferChunkSize
                                                              : QIODEVICE_BUFFERSIZE);
    } else {
        readBuffers.resize(count);
    }
    readChannelCount = count;
    setCurrentReadChannel(currentReadChannel);
}
 
int QIODevice::currentWriteChannel() const
{
    return d_func()->currentWriteChannel;
}
 
void QIODevice::setCurrentWriteChannel(int channel)
{
    Q_D(QIODevice);
 
#if defined QIODEVICE_DEBUG
    qDebug("%p QIODevice::setCurrentWriteChannel(%d), d->currentWriteChannel = %d, d->writeChannelCount = %d\n",
           this, channel, d->currentWriteChannel, d->writeChannelCount);
#endif
 
    d->setCurrentWriteChannel(channel);
}
 
void QIODevicePrivate::setWriteChannelCount(int count)
{
    if (count > writeBuffers.size()) {
        // If writeBufferChunkSize is zero (default value), we don't use
        // QIODevice's write buffers.
        if (writeBufferChunkSize != 0) {
            writeBuffers.reserve(count);
            while (writeBuffers.size() < count)
                writeBuffers.emplace_back(writeBufferChunkSize);
        }
    } else {
        writeBuffers.resize(count);
    }
    writeChannelCount = count;
    setCurrentWriteChannel(currentWriteChannel);
}
 
bool QIODevicePrivate::allWriteBuffersEmpty() const
{
    for (const QRingBuffer &ringBuffer : writeBuffers) {
        if (!ringBuffer.isEmpty())
            return false;
    }
    return true;
}
 
bool QIODevice::open(QIODeviceBase::OpenMode mode)
{
    Q_D(QIODevice);
    d->openMode = mode;
    d->pos = (mode & Append) ? size() : qint64(0);
    d->accessMode = QIODevicePrivate::Unset;
    d->readBuffers.clear();
    d->writeBuffers.clear();
    d->setReadChannelCount(isReadable() ? 1 : 0);
    d->setWriteChannelCount(isWritable() ? 1 : 0);
    d->errorString.clear();
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::open(0x%x)\n", this, mode.toInt());
#endif
    return true;
}
 
void QIODevice::close()
{
    Q_D(QIODevice);
    if (d->openMode == NotOpen)
        return;
 
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::close()\n", this);
#endif
 
#ifndef QT_NO_QOBJECT
    emit aboutToClose();
#endif
    d->openMode = NotOpen;
    d->pos = 0;
    d->transactionStarted = false;
    d->transactionPos = 0;
    d->setReadChannelCount(0);
    // Do not clear write buffers to allow delayed close in sockets
    d->writeChannelCount = 0;
}
 
qint64 QIODevice::pos() const
{
    Q_D(const QIODevice);
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::pos() == %lld\n", this, d->pos);
#endif
    return d->pos;
}
 
qint64 QIODevice::size() const
{
    return d_func()->isSequential() ? bytesAvailable() : qint64(0);
}
 
bool QIODevice::seek(qint64 pos)
{
    Q_D(QIODevice);
    if (d->isSequential()) {
        checkWarnMessage(this, "seek", "Cannot call seek on a sequential device");
        return false;
    }
    if (d->openMode == NotOpen) {
        checkWarnMessage(this, "seek", "The device is not open");
        return false;
    }
    if (pos < 0) {
        qWarning("QIODevice::seek: Invalid pos: %lld", pos);
        return false;
    }
 
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::seek(%lld), before: d->pos = %lld, d->buffer.size() = %lld\n",
           this, pos, d->pos, d->buffer.size());
#endif
 
    d->devicePos = pos;
    d->seekBuffer(pos);
 
#if defined QIODEVICE_DEBUG
    printf("%p \tafter: d->pos == %lld, d->buffer.size() == %lld\n", this, d->pos,
           d->buffer.size());
#endif
    return true;
}
 
void QIODevicePrivate::seekBuffer(qint64 newPos)
{
    const qint64 offset = newPos - pos;
    pos = newPos;
 
    if (offset < 0 || offset >= buffer.size()) {
        // 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.
        buffer.clear();
    } else {
        buffer.free(offset);
    }
}
 
bool QIODevice::atEnd() const
{
    Q_D(const QIODevice);
    const bool result = (d->openMode == NotOpen || (d->isBufferEmpty()
                                                    && bytesAvailable() == 0));
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::atEnd() returns %s, d->openMode == %d, d->pos == %lld\n", this,
           result ? "true" : "false", d->openMode.toInt(), d->pos);
#endif
    return result;
}
 
bool QIODevice::reset()
{
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::reset()\n", this);
#endif
    return seek(0);
}
 
qint64 QIODevice::bytesAvailable() const
{
    Q_D(const QIODevice);
    if (!d->isSequential())
        return qMax(size() - d->pos, qint64(0));
    return d->buffer.size() - d->transactionPos;
}
 
qint64 QIODevice::bytesToWrite() const
{
    return d_func()->writeBuffer.size();
}
 
qint64 QIODevice::read(char *data, qint64 maxSize)
{
    Q_D(QIODevice);
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::read(%p, %lld), d->pos = %lld, d->buffer.size() = %lld\n",
           this, data, maxSize, d->pos, d->buffer.size());
#endif
 
    CHECK_READABLE(read, qint64(-1));
    const bool sequential = d->isSequential();
 
    // Short-cut for getChar(), unless we need to keep the data in the buffer.
    if (maxSize == 1 && !(sequential && d->transactionStarted)) {
        int chint;
        while ((chint = d->buffer.getChar()) != -1) {
            if (!sequential)
                ++d->pos;
 
            char c = char(uchar(chint));
            if (c == '\r' && (d->openMode & Text))
                continue;
            *data = c;
#if defined QIODEVICE_DEBUG
            printf("%p \tread 0x%hhx (%c) returning 1 (shortcut)\n", this,
                   int(c), isAsciiPrintable(c) ? c : '?');
#endif
            if (d->buffer.isEmpty())
                readData(data, 0);
            return qint64(1);
        }
    }
 
    CHECK_MAXLEN(read, qint64(-1));
    const qint64 readBytes = d->read(data, maxSize);
 
#if defined QIODEVICE_DEBUG
    printf("%p \treturning %lld, d->pos == %lld, d->buffer.size() == %lld\n", this,
           readBytes, d->pos, d->buffer.size());
    if (readBytes > 0)
        debugBinaryString(data - readBytes, readBytes);
#endif
 
    return readBytes;
}
 
qint64 QIODevicePrivate::read(char *data, qint64 maxSize, bool peeking)
{
    Q_Q(QIODevice);
 
    const bool buffered = (readBufferChunkSize != 0 && (openMode & QIODevice::Unbuffered) == 0);
    const bool sequential = isSequential();
    const bool keepDataInBuffer = sequential
                                  ? peeking || transactionStarted
                                  : peeking && buffered;
    const qint64 savedPos = pos;
    qint64 readSoFar = 0;
    bool madeBufferReadsOnly = true;
    bool deviceAtEof = false;
    char *readPtr = data;
    qint64 bufferPos = (sequential && transactionStarted) ? transactionPos : Q_INT64_C(0);
    forever {
        // Try reading from the buffer.
        qint64 bufferReadChunkSize = keepDataInBuffer
                                     ? buffer.peek(data, maxSize, bufferPos)
                                     : buffer.read(data, maxSize);
        if (bufferReadChunkSize > 0) {
            bufferPos += bufferReadChunkSize;
            if (!sequential)
                pos += bufferReadChunkSize;
#if defined QIODEVICE_DEBUG
            printf("%p \treading %lld bytes from buffer into position %lld\n", q,
                   bufferReadChunkSize, readSoFar);
#endif
            readSoFar += bufferReadChunkSize;
            data += bufferReadChunkSize;
            maxSize -= bufferReadChunkSize;
        }
 
        if (maxSize > 0 && !deviceAtEof) {
            qint64 readFromDevice = 0;
            // Make sure the device is positioned correctly.
            if (sequential || pos == devicePos || q->seek(pos)) {
                madeBufferReadsOnly = false; // fix readData attempt
                if ((!buffered || maxSize >= readBufferChunkSize) && !keepDataInBuffer) {
                    // Read big chunk directly to output buffer
                    readFromDevice = q->readData(data, maxSize);
                    deviceAtEof = (readFromDevice != maxSize);
#if defined QIODEVICE_DEBUG
                    printf("%p \treading %lld bytes from device (total %lld)\n", q,
                           readFromDevice, readSoFar);
#endif
                    if (readFromDevice > 0) {
                        readSoFar += readFromDevice;
                        data += readFromDevice;
                        maxSize -= readFromDevice;
                        if (!sequential) {
                            pos += readFromDevice;
                            devicePos += readFromDevice;
                        }
                    }
                } else {
                    // Do not read more than maxSize on unbuffered devices
                    const qint64 bytesToBuffer = (!buffered && maxSize < buffer.chunkSize())
                            ? maxSize
                            : qint64(buffer.chunkSize());
                    // Try to fill QIODevice buffer by single read
                    readFromDevice = q->readData(buffer.reserve(bytesToBuffer), bytesToBuffer);
                    deviceAtEof = (readFromDevice != bytesToBuffer);
                    buffer.chop(bytesToBuffer - qMax(Q_INT64_C(0), readFromDevice));
                    if (readFromDevice > 0) {
                        if (!sequential)
                            devicePos += readFromDevice;
#if defined QIODEVICE_DEBUG
                        printf("%p \treading %lld from device into buffer\n", q,
                               readFromDevice);
#endif
                        continue;
                    }
                }
            } else {
                readFromDevice = -1;
            }
 
            if (readFromDevice < 0 && readSoFar == 0) {
                // error and we haven't read anything: return immediately
                return qint64(-1);
            }
        }
 
        if ((openMode & QIODevice::Text) && readPtr < data) {
            const char *endPtr = data;
 
            // optimization to avoid initial self-assignment
            while (*readPtr != '\r') {
                if (++readPtr == endPtr)
                    break;
            }
 
            char *writePtr = readPtr;
 
            while (readPtr < endPtr) {
                char ch = *readPtr++;
                if (ch != '\r')
                    *writePtr++ = ch;
                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'.
            readPtr = data;
            continue;
        }
 
        break;
    }
 
    // Restore positions after reading
    if (keepDataInBuffer) {
        if (peeking)
            pos = savedPos; // does nothing on sequential devices
        else
            transactionPos = bufferPos;
    } else if (peeking) {
        seekBuffer(savedPos); // unbuffered random-access device
    }
 
    if (madeBufferReadsOnly && isBufferEmpty())
        q->readData(data, 0);
 
    return readSoFar;
}
 
QByteArray QIODevice::read(qint64 maxSize)
{
    Q_D(QIODevice);
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::read(%lld), d->pos = %lld, d->buffer.size() = %lld\n",
           this, maxSize, d->pos, d->buffer.size());
#endif
 
    QByteArray result;
    CHECK_READABLE(read, result);
 
    // Try to prevent the data from being copied, if we have a chunk
    // with the same size in the read buffer.
    if (maxSize == d->buffer.nextDataBlockSize() && !d->transactionStarted
        && (d->openMode & QIODevice::Text) == 0) {
        result = d->buffer.read();
        if (!d->isSequential())
            d->pos += maxSize;
        if (d->buffer.isEmpty())
            readData(nullptr, 0);
        return result;
    }
 
    CHECK_MAXLEN(read, result);
    CHECK_MAXBYTEARRAYSIZE(read);
 
    result.resize(qsizetype(maxSize));
    qint64 readBytes = d->read(result.data(), result.size());
 
    if (readBytes <= 0)
        result.clear();
    else
        result.resize(qsizetype(readBytes));
 
    return result;
}
 
QByteArray QIODevice::readAll()
{
    Q_D(QIODevice);
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::readAll(), d->pos = %lld, d->buffer.size() = %lld\n",
           this, d->pos, d->buffer.size());
#endif
 
    QByteArray result;
    CHECK_READABLE(read, result);
 
    qint64 readBytes = (d->isSequential() ? Q_INT64_C(0) : size());
    if (readBytes == 0) {
        // Size is unknown, read incrementally.
        qint64 readChunkSize = qMax(qint64(d->buffer.chunkSize()),
                                    d->isSequential() ? (d->buffer.size() - d->transactionPos)
                                                      : d->buffer.size());
        qint64 readResult;
        do {
            if (readBytes + readChunkSize >= MaxByteArraySize) {
                // If resize would fail, don't read more, return what we have.
                break;
            }
            result.resize(readBytes + readChunkSize);
            readResult = d->read(result.data() + readBytes, readChunkSize);
            if (readResult > 0 || readBytes == 0) {
                readBytes += readResult;
                readChunkSize = d->buffer.chunkSize();
            }
        } while (readResult > 0);
    } else {
        // Read it all in one go.
        readBytes -= d->pos;
        if (readBytes >= MaxByteArraySize)
            readBytes = MaxByteArraySize;
        result.resize(readBytes);
        readBytes = d->read(result.data(), readBytes);
    }
 
    if (readBytes <= 0)
        result.clear();
    else
        result.resize(qsizetype(readBytes));
 
    return result;
}
 
qint64 QIODevice::readLine(char *data, qint64 maxSize)
{
    Q_D(QIODevice);
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::readLine(%p, %lld), d->pos = %lld, d->buffer.size() = %lld\n",
           this, data, maxSize, d->pos, d->buffer.size());
#endif
 
    CHECK_READABLE(readLine, qint64(-1));
    CHECK_LINEMAXLEN(readLine, qint64(-1));
    const qint64 readBytes = d->readLine(data, maxSize);
 
#if defined QIODEVICE_DEBUG
    printf("%p \treturning %lld, d->pos = %lld, d->buffer.size() = %lld, size() = %lld\n",
           this, readBytes, d->pos, d->buffer.size(), size());
    debugBinaryString(data, readBytes);
#endif
 
    return readBytes;
}
 
qint64 QIODevicePrivate::readLine(char *data, qint64 maxSize)
{
    Q_Q(QIODevice);
    Q_ASSERT(maxSize >= 2);
 
    // Leave room for a '\0'
    --maxSize;
 
    const bool sequential = isSequential();
    const bool keepDataInBuffer = sequential && transactionStarted;
 
    qint64 readSoFar = 0;
    if (keepDataInBuffer) {
        if (transactionPos < buffer.size()) {
            // Peek line from the specified position
            const qint64 i = buffer.indexOf('\n', maxSize, transactionPos);
            readSoFar = buffer.peek(data, i >= 0 ? (i - transactionPos + 1) : maxSize,
                                    transactionPos);
            transactionPos += readSoFar;
            if (transactionPos == buffer.size())
                q->readData(data, 0);
        }
    } else if (!buffer.isEmpty()) {
        // QRingBuffer::readLine() terminates the line with '\0'
        readSoFar = buffer.readLine(data, maxSize + 1);
        if (buffer.isEmpty())
            q->readData(data, 0);
        if (!sequential)
            pos += readSoFar;
    }
 
    if (readSoFar) {
#if defined QIODEVICE_DEBUG
        printf("%p \tread from buffer: %lld bytes, last character read: %hhx\n", q,
               readSoFar, data[readSoFar - 1]);
        debugBinaryString(data, readSoFar);
#endif
        if (data[readSoFar - 1] == '\n') {
            if (openMode & QIODevice::Text) {
                // QRingBuffer::readLine() isn't Text aware.
                if (readSoFar > 1 && data[readSoFar - 2] == '\r') {
                    --readSoFar;
                    data[readSoFar - 1] = '\n';
                }
            }
            data[readSoFar] = '\0';
            return readSoFar;
        }
    }
 
    if (pos != devicePos && !sequential && !q->seek(pos))
        return qint64(-1);
    baseReadLineDataCalled = false;
    // Force base implementation for transaction on sequential device
    // as it stores the data in internal buffer automatically.
    qint64 readBytes = keepDataInBuffer
                       ? q->QIODevice::readLineData(data + readSoFar, maxSize - readSoFar)
                       : q->readLineData(data + readSoFar, maxSize - readSoFar);
#if defined QIODEVICE_DEBUG
    printf("%p \tread from readLineData: %lld bytes, readSoFar = %lld bytes\n", q,
           readBytes, readSoFar);
    if (readBytes > 0) {
        debugBinaryString(data, readSoFar + readBytes);
    }
#endif
    if (readBytes < 0) {
        data[readSoFar] = '\0';
        return readSoFar ? readSoFar : -1;
    }
    readSoFar += readBytes;
    if (!baseReadLineDataCalled && !sequential) {
        pos += readBytes;
        // If the base implementation was not called, then we must
        // assume the device position is invalid and force a seek.
        devicePos = qint64(-1);
    }
    data[readSoFar] = '\0';
 
    if (openMode & QIODevice::Text) {
        if (readSoFar > 1 && data[readSoFar - 1] == '\n' && data[readSoFar - 2] == '\r') {
            data[readSoFar - 2] = '\n';
            data[readSoFar - 1] = '\0';
            --readSoFar;
        }
    }
 
    return readSoFar;
}
 
QByteArray QIODevice::readLine(qint64 maxSize)
{
    Q_D(QIODevice);
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::readLine(%lld), d->pos = %lld, d->buffer.size() = %lld\n",
           this, maxSize, d->pos, d->buffer.size());
#endif
 
    QByteArray result;
    CHECK_READABLE(readLine, result);
 
    qint64 readBytes = 0;
    if (maxSize == 0) {
        // Size is unknown, read incrementally.
        maxSize = MaxByteArraySize - 1;
 
        // The first iteration needs to leave an extra byte for the terminating null
        result.resize(1);
 
        qint64 readResult;
        do {
            result.resize(qsizetype(qMin(maxSize, qint64(result.size() + d->buffer.chunkSize()))));
            readResult = d->readLine(result.data() + readBytes, result.size() - readBytes);
            if (readResult > 0 || readBytes == 0)
                readBytes += readResult;
        } while (readResult == d->buffer.chunkSize()
                && result[qsizetype(readBytes - 1)] != '\n');
    } else {
        CHECK_LINEMAXLEN(readLine, result);
        CHECK_MAXBYTEARRAYSIZE(readLine);
 
        result.resize(maxSize);
        readBytes = d->readLine(result.data(), result.size());
    }
 
    if (readBytes <= 0)
        result.clear();
    else
        result.resize(readBytes);
 
    result.squeeze();
    return result;
}
 
qint64 QIODevice::readLineData(char *data, qint64 maxSize)
{
    Q_D(QIODevice);
    qint64 readSoFar = 0;
    char c;
    qint64 lastReadReturn = 0;
    d->baseReadLineDataCalled = true;
 
    while (readSoFar < maxSize && (lastReadReturn = read(&c, 1)) == 1) {
        *data++ = c;
        ++readSoFar;
        if (c == '\n')
            break;
    }
 
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::readLineData(%p, %lld), d->pos = %lld, d->buffer.size() = %lld, "
           "returns %lld\n", this, data, maxSize, d->pos, d->buffer.size(), readSoFar);
#endif
    if (lastReadReturn != 1 && readSoFar == 0)
        return isSequential() ? lastReadReturn : -1;
    return readSoFar;
}
 
bool QIODevice::canReadLine() const
{
    Q_D(const QIODevice);
    return d->buffer.indexOf('\n', d->buffer.size(),
                             d->isSequential() ? d->transactionPos : Q_INT64_C(0)) >= 0;
}
 
void QIODevice::startTransaction()
{
    Q_D(QIODevice);
    if (d->transactionStarted) {
        checkWarnMessage(this, "startTransaction", "Called while transaction already in progress");
        return;
    }
    d->transactionPos = d->pos;
    d->transactionStarted = true;
}
 
void QIODevice::commitTransaction()
{
    Q_D(QIODevice);
    if (!d->transactionStarted) {
        checkWarnMessage(this, "commitTransaction", "Called while no transaction in progress");
        return;
    }
    if (d->isSequential())
        d->buffer.free(d->transactionPos);
    d->transactionStarted = false;
    d->transactionPos = 0;
}
 
void QIODevice::rollbackTransaction()
{
    Q_D(QIODevice);
    if (!d->transactionStarted) {
        checkWarnMessage(this, "rollbackTransaction", "Called while no transaction in progress");
        return;
    }
    if (!d->isSequential())
        d->seekBuffer(d->transactionPos);
    d->transactionStarted = false;
    d->transactionPos = 0;
}
 
bool QIODevice::isTransactionStarted() const
{
    return d_func()->transactionStarted;
}
 
qint64 QIODevice::write(const char *data, qint64 maxSize)
{
    Q_D(QIODevice);
    CHECK_WRITABLE(write, qint64(-1));
    CHECK_MAXLEN(write, qint64(-1));
 
    const bool sequential = d->isSequential();
    // Make sure the device is positioned correctly.
    if (d->pos != d->devicePos && !sequential && !seek(d->pos))
        return qint64(-1);
 
#ifdef Q_OS_WIN
    if (d->openMode & Text) {
        const char *endOfData = data + maxSize;
        const char *startOfBlock = data;
 
        qint64 writtenSoFar = 0;
        const qint64 savedPos = d->pos;
 
        forever {
            const char *endOfBlock = startOfBlock;
            while (endOfBlock < endOfData && *endOfBlock != '\n')
                ++endOfBlock;
 
            qint64 blockSize = endOfBlock - startOfBlock;
            if (blockSize > 0) {
                qint64 ret = writeData(startOfBlock, blockSize);
                if (ret <= 0) {
                    if (writtenSoFar && !sequential)
                        d->buffer.skip(d->pos - savedPos);
                    return writtenSoFar ? writtenSoFar : ret;
                }
                if (!sequential) {
                    d->pos += ret;
                    d->devicePos += ret;
                }
                writtenSoFar += ret;
            }
 
            if (endOfBlock == endOfData)
                break;
 
            qint64 ret = writeData("\r\n", 2);
            if (ret <= 0) {
                if (writtenSoFar && !sequential)
                    d->buffer.skip(d->pos - savedPos);
                return writtenSoFar ? writtenSoFar : ret;
            }
            if (!sequential) {
                d->pos += ret;
                d->devicePos += ret;
            }
            ++writtenSoFar;
 
            startOfBlock = endOfBlock + 1;
        }
 
        if (writtenSoFar && !sequential)
            d->buffer.skip(d->pos - savedPos);
        return writtenSoFar;
    }
#endif
 
    qint64 written = writeData(data, maxSize);
    if (!sequential && written > 0) {
        d->pos += written;
        d->devicePos += written;
        d->buffer.skip(written);
    }
    return written;
}
 
qint64 QIODevice::write(const char *data)
{
    return write(data, qstrlen(data));
}
 
qint64 QIODevice::write(const QByteArray &data)
{
    Q_D(QIODevice);
 
    // Keep the chunk pointer for further processing in
    // QIODevicePrivate::write(). To reduce fragmentation,
    // the chunk size must be sufficiently large.
    if (data.size() >= QRINGBUFFER_CHUNKSIZE)
        d->currentWriteChunk = &data;
 
    const qint64 ret = write(data.constData(), data.size());
 
    d->currentWriteChunk = nullptr;
    return ret;
}
 
void QIODevicePrivate::write(const char *data, qint64 size)
{
    if (isWriteChunkCached(data, size)) {
        // We are called from write(const QByteArray &) overload.
        // So, we can make a shallow copy of chunk.
        writeBuffer.append(*currentWriteChunk);
    } else {
        writeBuffer.append(data, size);
    }
}
 
void QIODevice::ungetChar(char c)
{
    Q_D(QIODevice);
    CHECK_READABLE(read, Q_VOID);
 
    if (d->transactionStarted) {
        checkWarnMessage(this, "ungetChar", "Called while transaction is in progress");
        return;
    }
 
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::ungetChar(0x%hhx '%c')\n", this, c, isAsciiPrintable(c) ? c : '?');
#endif
 
    d->buffer.ungetChar(c);
    if (!d->isSequential())
        --d->pos;
}
 
bool QIODevice::putChar(char c)
{
    return d_func()->putCharHelper(c);
}
 
bool QIODevicePrivate::putCharHelper(char c)
{
    return q_func()->write(&c, 1) == 1;
}
 
qint64 QIODevicePrivate::peek(char *data, qint64 maxSize)
{
    return read(data, maxSize, true);
}
 
QByteArray QIODevicePrivate::peek(qint64 maxSize)
{
    QByteArray result(maxSize, Qt::Uninitialized);
 
    const qint64 readBytes = read(result.data(), maxSize, true);
 
    if (readBytes < maxSize) {
        if (readBytes <= 0)
            result.clear();
        else
            result.resize(readBytes);
    }
 
    return result;
}
 
bool QIODevice::getChar(char *c)
{
    // readability checked in read()
    char ch;
    return (1 == read(c ? c : &ch, 1));
}
 
qint64 QIODevice::peek(char *data, qint64 maxSize)
{
    Q_D(QIODevice);
 
    CHECK_MAXLEN(peek, qint64(-1));
    CHECK_READABLE(peek, qint64(-1));
 
    return d->peek(data, maxSize);
}
 
QByteArray QIODevice::peek(qint64 maxSize)
{
    Q_D(QIODevice);
 
    CHECK_MAXLEN(peek, QByteArray());
    CHECK_MAXBYTEARRAYSIZE(peek);
    CHECK_READABLE(peek, QByteArray());
 
    return d->peek(maxSize);
}
 
qint64 QIODevice::skip(qint64 maxSize)
{
    Q_D(QIODevice);
    CHECK_MAXLEN(skip, qint64(-1));
    CHECK_READABLE(skip, qint64(-1));
 
    const bool sequential = d->isSequential();
 
#if defined QIODEVICE_DEBUG
    printf("%p QIODevice::skip(%lld), d->pos = %lld, d->buffer.size() = %lld\n",
           this, maxSize, d->pos, d->buffer.size());
#endif
 
    if ((sequential && d->transactionStarted) || (d->openMode & QIODevice::Text) != 0)
        return d->skipByReading(maxSize);
 
    // First, skip over any data in the internal buffer.
    qint64 skippedSoFar = 0;
    if (!d->buffer.isEmpty()) {
        skippedSoFar = d->buffer.skip(maxSize);
#if defined QIODEVICE_DEBUG
        printf("%p \tskipping %lld bytes in buffer\n", this, skippedSoFar);
#endif
        if (!sequential)
            d->pos += skippedSoFar;
        if (d->buffer.isEmpty())
            readData(nullptr, 0);
        if (skippedSoFar == maxSize)
            return skippedSoFar;
 
        maxSize -= skippedSoFar;
    }
 
    // Try to seek on random-access device. At this point,
    // the internal read buffer is empty.
    if (!sequential) {
        const qint64 bytesToSkip = qMin(size() - d->pos, maxSize);
 
        // If the size is unknown or file position is at the end,
        // fall back to reading below.
        if (bytesToSkip > 0) {
            if (!seek(d->pos + bytesToSkip))
                return skippedSoFar ? skippedSoFar : Q_INT64_C(-1);
            if (bytesToSkip == maxSize)
                return skippedSoFar + bytesToSkip;
 
            skippedSoFar += bytesToSkip;
            maxSize -= bytesToSkip;
        }
    }
 
    const qint64 skipResult = skipData(maxSize);
    if (skippedSoFar == 0)
        return skipResult;
 
    if (skipResult == -1)
        return skippedSoFar;
 
    return skippedSoFar + skipResult;
}
 
qint64 QIODevicePrivate::skipByReading(qint64 maxSize)
{
    qint64 readSoFar = 0;
    do {
        char dummy[4096];
        const qint64 readBytes = qMin<qint64>(maxSize, sizeof(dummy));
        const qint64 readResult = read(dummy, readBytes);
 
        // Do not try again, if we got less data.
        if (readResult != readBytes) {
            if (readSoFar == 0)
                return readResult;
 
            if (readResult == -1)
                return readSoFar;
 
            return readSoFar + readResult;
        }
 
        readSoFar += readResult;
        maxSize -= readResult;
    } while (maxSize > 0);
 
    return readSoFar;
}
 
qint64 QIODevice::skipData(qint64 maxSize)
{
    return d_func()->skipByReading(maxSize);
}
 
bool QIODevice::waitForReadyRead(int msecs)
{
    Q_UNUSED(msecs);
    return false;
}
 
bool QIODevice::waitForBytesWritten(int msecs)
{
    Q_UNUSED(msecs);
    return false;
}
 
void QIODevice::setErrorString(const QString &str)
{
    d_func()->errorString = str;
}
 
QString QIODevice::errorString() const
{
    Q_D(const QIODevice);
    if (d->errorString.isEmpty()) {
#ifdef QT_NO_QOBJECT
        return QLatin1StringView(QT_TRANSLATE_NOOP(QIODevice, "Unknown error"));
#else
        return tr("Unknown error");
#endif
    }
    return d->errorString;
}
 
int qt_subtract_from_timeout(int timeout, int elapsed)
{
    if (timeout == -1)
        return -1;
 
    timeout = timeout - elapsed;
    return timeout < 0 ? 0 : timeout;
}
 
 
#if !defined(QT_NO_DEBUG_STREAM)
QDebug operator<<(QDebug debug, QIODevice::OpenMode modes)
{
    debug << "OpenMode(";
    QStringList modeList;
    if (modes == QIODevice::NotOpen) {
        modeList << "NotOpen"_L1;
    } else {
        if (modes & QIODevice::ReadOnly)
            modeList << "ReadOnly"_L1;
        if (modes & QIODevice::WriteOnly)
            modeList << "WriteOnly"_L1;
        if (modes & QIODevice::Append)
            modeList << "Append"_L1;
        if (modes & QIODevice::Truncate)
            modeList << "Truncate"_L1;
        if (modes & QIODevice::Text)
            modeList << "Text"_L1;
        if (modes & QIODevice::Unbuffered)
            modeList << "Unbuffered"_L1;
    }
    std::sort(modeList.begin(), modeList.end());
    debug << modeList.join(u'|');
    debug << ')';
    return debug;
}
#endif
 
QT_END_NAMESPACE
 
#ifndef QT_NO_QOBJECT
#include "moc_qiodevice.cpp"
#endif