/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtCore module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** 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.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

//#define QTEXTSTREAM_DEBUG

static const int QTEXTSTREAM_BUFFERSIZE = 16384;

/*!

    \class QTextStream

    \brief The QTextStream class provides a convenient interface for

    reading and writing text.

    \ingroup io

    \ingroup text

    \reentrant

    QTextStream can operate on a QIODevice, a QByteArray or a

    QString. Using QTextStream's streaming operators, you can

    conveniently read and write words, lines and numbers. For

    generating text, QTextStream supports formatting options for field

    padding and alignment, and formatting of numbers. Example:

    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 0

    It's also common to use QTextStream to read console input and write

    console output. QTextStream is locale aware, and will automatically decode

    standard input using the correct codec. Example:

    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 1

    Note that you cannot use QTextStream::atEnd(), which returns true when you

    have reached the end of the data stream, with stdin. The reason for this is

    that as long as stdin doesn't give any input to the QTextStream, \c atEnd()

    will return true even if the stdin is open and waiting for more characters.

    Besides using QTextStream's constructors, you can also set the

    device or string QTextStream operates on by calling setDevice() or

    setString(). You can seek to a position by calling seek(), and

    atEnd() will return true when there is no data left to be read. If

    you call flush(), QTextStream will empty all data from its write

    buffer into the device and call flush() on the device.

    Internally, QTextStream uses a Unicode based buffer, and

    QTextCodec is used by QTextStream to automatically support

    different character sets. By default, QTextCodec::codecForLocale()

    is used for reading and writing, but you can also set the codec by

    calling setCodec(). Automatic Unicode detection is also

    supported. When this feature is enabled (the default behavior),

    QTextStream will detect the UTF-16 or the UTF-32 BOM (Byte Order Mark) and

    switch to the appropriate UTF codec when reading. QTextStream

    does not write a BOM by default, but you can enable this by calling

    setGenerateByteOrderMark(true). When QTextStream operates on a QString

    directly, the codec is disabled.

    There are three general ways to use QTextStream when reading text

    files:

    \list

    \o Chunk by chunk, by calling readLine() or readAll().

    \o Word by word. QTextStream supports streaming into QStrings,

    QByteArrays and char* buffers. Words are delimited by space, and

    leading white space is automatically skipped.

    \o Character by character, by streaming into QChar or char types.

    This method is often used for convenient input handling when

    parsing files, independent of character encoding and end-of-line

    semantics. To skip white space, call skipWhiteSpace().

    \endlist

    Since the text stream uses a buffer, you should not read from

    the stream using the implementation of a superclass. For instance,

    if you have a QFile and read from it directly using

    QFile::readLine() instead of using the stream, the text stream's

    internal position will be out of sync with the file's position.

    By default, when reading numbers from a stream of text,

    QTextStream will automatically detect the number's base

    representation. For example, if the number starts with "0x", it is

    assumed to be in hexadecimal form. If it starts with the digits

    1-9, it is assumed to be in decimal form, and so on. You can set

    the integer base, thereby disabling the automatic detection, by

    calling setIntegerBase(). Example:

    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 2

    QTextStream supports many formatting options for generating text.

    You can set the field width and pad character by calling

    setFieldWidth() and setPadChar(). Use setFieldAlignment() to set

    the alignment within each field. For real numbers, call

    setRealNumberNotation() and setRealNumberPrecision() to set the

    notation (SmartNotation, ScientificNotation, FixedNotation) and precision in

    digits of the generated number. Some extra number formatting

    options are also available through setNumberFlags().

    \keyword QTextStream manipulators

    Like \c <iostream> in the standard C++ library, QTextStream also

    defines several global manipulator functions:

    \table

    \header \o Manipulator        \o Description

    \row    \o \c bin             \o Same as setIntegerBase(2).

    \row    \o \c oct             \o Same as setIntegerBase(8).

    \row    \o \c dec             \o Same as setIntegerBase(10).

    \row    \o \c hex             \o Same as setIntegerBase(16).

    \row    \o \c showbase        \o Same as setNumberFlags(numberFlags() | ShowBase).

    \row    \o \c forcesign       \o Same as setNumberFlags(numberFlags() | ForceSign).

    \row    \o \c forcepoint      \o Same as setNumberFlags(numberFlags() | ForcePoint).

    \row    \o \c noshowbase      \o Same as setNumberFlags(numberFlags() & ~ShowBase).

    \row    \o \c noforcesign     \o Same as setNumberFlags(numberFlags() & ~ForceSign).

    \row    \o \c noforcepoint    \o Same as setNumberFlags(numberFlags() & ~ForcePoint).

    \row    \o \c uppercasebase   \o Same as setNumberFlags(numberFlags() | UppercaseBase).

    \row    \o \c uppercasedigits \o Same as setNumberFlags(numberFlags() | UppercaseDigits).

    \row    \o \c lowercasebase   \o Same as setNumberFlags(numberFlags() & ~UppercaseBase).

    \row    \o \c lowercasedigits \o Same as setNumberFlags(numberFlags() & ~UppercaseDigits).

    \row    \o \c fixed           \o Same as setRealNumberNotation(FixedNotation).

    \row    \o \c scientific      \o Same as setRealNumberNotation(ScientificNotation).

    \row    \o \c left            \o Same as setFieldAlignment(AlignLeft).

    \row    \o \c right           \o Same as setFieldAlignment(AlignRight).

    \row    \o \c center          \o Same as setFieldAlignment(AlignCenter).

    \row    \o \c endl            \o Same as operator<<('\n') and flush().

    \row    \o \c flush           \o Same as flush().

    \row    \o \c reset           \o Same as reset().

    \row    \o \c ws              \o Same as skipWhiteSpace().

    \row    \o \c bom             \o Same as setGenerateByteOrderMark(true).

    \endtable

    In addition, Qt provides three global manipulators that take a

    parameter: qSetFieldWidth(), qSetPadChar(), and

    qSetRealNumberPrecision().

    \sa QDataStream, QIODevice, QFile, QBuffer, QTcpSocket, {Codecs Example}

*/

/*! \enum QTextStream::RealNumberNotation

    This enum specifies which notations to use for expressing \c

    float and \c double as strings.

    \value ScientificNotation Scientific notation (\c{printf()}'s \c %e flag).

    \value FixedNotation Fixed-point notation (\c{printf()}'s \c %f flag).

    \value SmartNotation Scientific or fixed-point notation, depending on which makes most sense (\c{printf()}'s \c %g flag).

    \sa setRealNumberNotation()

*/

/*! \enum QTextStream::FieldAlignment

    This enum specifies how to align text in fields when the field is

    wider than the text that occupies it.

    \value AlignLeft  Pad on the right side of fields.

    \value AlignRight  Pad on the left side of fields.

    \value AlignCenter  Pad on both sides of field.

    \value AlignAccountingStyle  Same as AlignRight, except that the

                                 sign of a number is flush left.

    \sa setFieldAlignment()

*/

/*! \enum QTextStream::NumberFlag

    This enum specifies various flags that can be set to affect the

    output of integers, \c{float}s, and \c{double}s.

    \value ShowBase  Show the base as a prefix if the base

                     is 16 ("0x"), 8 ("0"), or 2 ("0b").

    \value ForcePoint  Always put the decimal separator in numbers, even if

                       there are no decimals.

    \value ForceSign  Always put the sign in numbers, even for positive numbers.

    \value UppercaseBase  Use uppercase versions of base prefixes ("0X", "0B").

    \value UppercaseDigits  Use uppercase letters for expressing

                            digits 10 to 35 instead of lowercase.

    \sa setNumberFlags()

*/

/*! \enum QTextStream::Status

    This enum describes the current status of the text stream.

    \value Ok               The text stream is operating normally.

    \value ReadPastEnd      The text stream has read past the end of the

                            data in the underlying device.

    \value ReadCorruptData  The text stream has read corrupt data.

    \sa status()

*/

#include "qtextstream.h"

#include "qbuffer.h"

#include "qfile.h"

#include "qnumeric.h"

#ifndef QT_NO_TEXTCODEC

#include "qtextcodec.h"

#endif

#ifndef Q_OS_WINCE

#include <locale.h>

#endif

#include "private/qlocale_p.h"

#include <stdlib.h>

#include <new>

#if defined QTEXTSTREAM_DEBUG

#include <ctype.h>

QT_BEGIN_NAMESPACE

// Returns a human readable representation of the first \a len

// characters in \a data.

static QByteArray qt_prettyDebug(const char *data, int len, int maxSize)

{

    if (!data) return "(null)";

    QByteArray out;

    for (int i = 0; i < len; ++i) {

        char c = data[i];

        if (isprint(int(uchar(c)))) {

            out += c;

        } else switch (c) {

        case '\n': out += "\\n"; break;

        case '\r': out += "\\r"; break;

        case '\t': out += "\\t"; break;

        default:

            QString tmp;

            tmp.sprintf("\\x%x", (unsigned int)(unsigned char)c);

            out += tmp.toLatin1();

        }

    }

    if (len < maxSize)

        out += "...";

    return out;

}

QT_END_NAMESPACE

#endif

// A precondition macro

#define Q_VOID

#define CHECK_VALID_STREAM(x) do { \

    if (!d->string && !d->device) { \

        qWarning("QTextStream: No device"); \

        return x; \

    } } while (0)

// Base implementations of operator>> for ints and reals

#define IMPLEMENT_STREAM_RIGHT_INT_OPERATOR(type) do { \

    Q_D(QTextStream); \

    CHECK_VALID_STREAM(*this); \

    qulonglong tmp; \

    switch (d->getNumber(&tmp)) { \

    case QTextStreamPrivate::npsOk: \

        i = (type)tmp; \

        break; \

    case QTextStreamPrivate::npsMissingDigit: \

    case QTextStreamPrivate::npsInvalidPrefix: \

        i = (type)0; \

        setStatus(atEnd() ? QTextStream::ReadPastEnd : QTextStream::ReadCorruptData); \

        break; \

    } \

    return *this; } while (0)

#define IMPLEMENT_STREAM_RIGHT_REAL_OPERATOR(type) do { \

    Q_D(QTextStream); \

    CHECK_VALID_STREAM(*this); \

    double tmp; \

    if (d->getReal(&tmp)) { \

        f = (type)tmp; \

    } else { \

        f = (type)0; \

        setStatus(atEnd() ? QTextStream::ReadPastEnd : QTextStream::ReadCorruptData); \

    } \

    return *this; } while (0)

QT_BEGIN_NAMESPACE

#ifndef QT_NO_QOBJECT

class QDeviceClosedNotifier : public QObject

{

    Q_OBJECT

public:

    inline QDeviceClosedNotifier()

    { }

    inline void setupDevice(QTextStream *stream, QIODevice *device)

    {

        disconnect();

        if (device)

            connect(device, SIGNAL(aboutToClose()), this, SLOT(flushStream()));

        this->stream = stream;

    }

public slots:

    inline void flushStream() { stream->flush(); }

private:

    QTextStream *stream;

};

#endif

//-------------------------------------------------------------------

class QTextStreamPrivate

{

    Q_DECLARE_PUBLIC(QTextStream)

public:

    QTextStreamPrivate(QTextStream *q_ptr);

    ~QTextStreamPrivate();

    void reset();

    // device

    QIODevice *device;

#ifndef QT_NO_QOBJECT

    QDeviceClosedNotifier deviceClosedNotifier;

#endif

    bool deleteDevice;

    // string

    QString *string;

    int stringOffset;

    QIODevice::OpenMode stringOpenMode;

#ifndef QT_NO_TEXTCODEC

    // codec

    QTextCodec *codec;

    QTextCodec::ConverterState readConverterState;

    QTextCodec::ConverterState writeConverterState;

    QTextCodec::ConverterState *readConverterSavedState;

    bool autoDetectUnicode;

#endif

    // i/o

    enum TokenDelimiter {

        Space,

        NotSpace,

        EndOfLine,

        EndOfFile

    };

    bool scan(const QChar **ptr, int *tokenLength,

              int maxlen, TokenDelimiter delimiter);

    inline const QChar *readPtr() const;

    inline void consumeLastToken();

    inline void consume(int nchars);

    void saveConverterState(qint64 newPos);

    void restoreToSavedConverterState();

    int lastTokenSize;

    // Return value type for getNumber()

    enum NumberParsingStatus {

        npsOk,

        npsMissingDigit,

        npsInvalidPrefix

    };

    inline bool write(const QString &data);

    inline bool getChar(QChar *ch);

    inline void ungetChar(const QChar &ch);

    NumberParsingStatus getNumber(qulonglong *l);

    bool getReal(double *f);

    bool putNumber(qulonglong number, bool negative);

    inline bool putString(const QString &ch, bool number = false);

    // buffers

    bool fillReadBuffer(qint64 maxBytes = -1);

    void resetReadBuffer();

    bool flushWriteBuffer();

    QString writeBuffer;

    QString readBuffer;

    int readBufferOffset;

    qint64 readBufferStartDevicePos;

    // streaming parameters

    int realNumberPrecision;

    int integerBase;

    int fieldWidth;

    QChar padChar;

    QTextStream::FieldAlignment fieldAlignment;

    QTextStream::RealNumberNotation realNumberNotation;

    QTextStream::NumberFlags numberFlags;

    // status

    QTextStream::Status status;

    QLocale locale;

    QTextStream *q_ptr;

};

/*! \internal

*/

QTextStreamPrivate::QTextStreamPrivate(QTextStream *q_ptr)

    :

#ifndef QT_NO_TEXTCODEC

    readConverterSavedState(0),

#endif

    locale(QLocale::C)

{

    this->q_ptr = q_ptr;

    reset();

}

/*! \internal

*/

QTextStreamPrivate::~QTextStreamPrivate()

{

    if (deleteDevice) {

#ifndef QT_NO_QOBJECT

        device->blockSignals(true);

#endif

        delete device;

    }

#ifndef QT_NO_TEXTCODEC

    delete readConverterSavedState;

#endif

}

#ifndef QT_NO_TEXTCODEC

static void resetCodecConverterStateHelper(QTextCodec::ConverterState *state)

{

    state->~ConverterState();

    new (state) QTextCodec::ConverterState;

}

static void copyConverterStateHelper(QTextCodec::ConverterState *dest,

    const QTextCodec::ConverterState *src)

{

    // ### QTextCodec::ConverterState's copy constructors and assignments are

    // private. This function copies the structure manually.

    Q_ASSERT(!src->d);

    dest->flags = src->flags;

    dest->invalidChars = src->invalidChars;

    dest->state_data[0] = src->state_data[0];

    dest->state_data[1] = src->state_data[1];

    dest->state_data[2] = src->state_data[2];

}

#endif

/*! \internal

*/

void QTextStreamPrivate::reset()

{

    realNumberPrecision = 6;

    integerBase = 0;

    fieldWidth = 0;

    padChar = QLatin1Char(' ');

    fieldAlignment = QTextStream::AlignRight;

    realNumberNotation = QTextStream::SmartNotation;

    numberFlags = 0;

    device = 0;

    deleteDevice = false;

    string = 0;

    stringOffset = 0;

    stringOpenMode = QIODevice::NotOpen;

    readBufferOffset = 0;

    readBufferStartDevicePos = 0;

    lastTokenSize = 0;

#ifndef QT_NO_TEXTCODEC

    codec = QTextCodec::codecForLocale();

    resetCodecConverterStateHelper(&readConverterState);

    resetCodecConverterStateHelper(&writeConverterState);

    delete readConverterSavedState;

    readConverterSavedState = 0;

    writeConverterState.flags |= QTextCodec::IgnoreHeader;

    autoDetectUnicode = true;

#endif

}

/*! \internal

*/

bool QTextStreamPrivate::fillReadBuffer(qint64 maxBytes)

{

    // no buffer next to the QString itself; this function should only

    // be called internally, for devices.

    Q_ASSERT(!string);

    Q_ASSERT(device);

    // handle text translation and bypass the Text flag in the device.

    bool textModeEnabled = device->isTextModeEnabled();

    if (textModeEnabled)

        device->setTextModeEnabled(false);

    // read raw data into a temporary buffer

    char buf[QTEXTSTREAM_BUFFERSIZE];

    qint64 bytesRead = 0;

#if defined(Q_OS_WIN)

    // On Windows, there is no non-blocking stdin - so we fall back to reading

    // lines instead. If there is no QOBJECT, we read lines for all sequential

    // devices; otherwise, we read lines only for stdin.

    QFile *file = 0;

    Q_UNUSED(file);

    if (device->isSequential()

#if !defined(QT_NO_QOBJECT)

        && (file = qobject_cast<QFile *>(device)) && file->handle() == 0

#endif

        ) {

        if (maxBytes != -1)

            bytesRead = device->readLine(buf, qMin<qint64>(sizeof(buf), maxBytes));

        else

            bytesRead = device->readLine(buf, sizeof(buf));

    } else

#endif

    {

        if (maxBytes != -1)

            bytesRead = device->read(buf, qMin<qint64>(sizeof(buf), maxBytes));

        else

            bytesRead = device->read(buf, sizeof(buf));

    }

#ifndef QT_NO_TEXTCODEC

    // codec auto detection, explicitly defaults to locale encoding if the

    // codec has been set to 0.

    if (!codec || autoDetectUnicode) {

        autoDetectUnicode = false;

        if (bytesRead >= 4 && ((uchar(buf[0]) == 0xff && uchar(buf[1]) == 0xfe && uchar(buf[2]) == 0 && uchar(buf[3]) == 0)

                               || (uchar(buf[0]) == 0 && uchar(buf[1]) == 0 && uchar(buf[2]) == 0xfe && uchar(buf[3]) == 0xff))) {

            codec = QTextCodec::codecForName("UTF-32");

        } else if (bytesRead >= 2 && ((uchar(buf[0]) == 0xff && uchar(buf[1]) == 0xfe)

                                      || (uchar(buf[0]) == 0xfe && uchar(buf[1]) == 0xff))) {

            codec = QTextCodec::codecForName("UTF-16");

        } else if (!codec) {

            codec = QTextCodec::codecForLocale();

            writeConverterState.flags |= QTextCodec::IgnoreHeader;

        }

    }

#if defined (QTEXTSTREAM_DEBUG)

    qDebug("QTextStreamPrivate::fillReadBuffer(), using %s codec",

           codec->name().constData());

#endif

#endif

#if defined (QTEXTSTREAM_DEBUG)

    qDebug("QTextStreamPrivate::fillReadBuffer(), device->read(\"%s\", %d) == %d",

           qt_prettyDebug(buf, qMin(32,int(bytesRead)) , int(bytesRead)).constData(), sizeof(buf), int(bytesRead));

#endif

    if (bytesRead <= 0)

        return false;

    int oldReadBufferSize = readBuffer.size();

#ifndef QT_NO_TEXTCODEC

    // convert to unicode

    readBuffer += codec->toUnicode(buf, bytesRead, &readConverterState);

#else

    readBuffer += QString::fromLatin1(QByteArray(buf, bytesRead).constData());

#endif

    // reset the Text flag.

    if (textModeEnabled)

        device->setTextModeEnabled(true);

    // remove all '\r\n' in the string.

    if (readBuffer.size() > oldReadBufferSize && textModeEnabled) {

        QChar CR = QLatin1Char('\r');

        QChar *writePtr = readBuffer.data() + oldReadBufferSize;

        QChar *readPtr = readBuffer.data() + oldReadBufferSize;

        QChar *endPtr = readBuffer.data() + readBuffer.size();

        int n = oldReadBufferSize;

        if (readPtr < endPtr) {

            // Cut-off to avoid unnecessary self-copying.

            while (*readPtr++ != CR) {

                ++n;

                if (++writePtr == endPtr)

                    break;

            }

        }

        while (readPtr < endPtr) {

            QChar ch = *readPtr++;

            if (ch != CR) {

                *writePtr++ = ch;

            } else {

                if (n < readBufferOffset)

                    --readBufferOffset;

                --bytesRead;

            }

            ++n;

        }

        readBuffer.resize(writePtr - readBuffer.data());

    }

#if defined (QTEXTSTREAM_DEBUG)

    qDebug("QTextStreamPrivate::fillReadBuffer() read %d bytes from device. readBuffer = [%s]", int(bytesRead),

           qt_prettyDebug(readBuffer.toLatin1(), readBuffer.size(), readBuffer.size()).data());

#endif

    return true;

}

/*! \internal

*/

void QTextStreamPrivate::resetReadBuffer()

{

    readBuffer.clear();

    readBufferOffset = 0;

    readBufferStartDevicePos = (device ? device->pos() : 0);

}

/*! \internal

*/

bool QTextStreamPrivate::flushWriteBuffer()

{

    // no buffer next to the QString itself; this function should only

    // be called internally, for devices.

    if (string || !device)

        return false;

    if (writeBuffer.isEmpty())

        return true;

#if defined (Q_OS_WIN)

    // handle text translation and bypass the Text flag in the device.

    bool textModeEnabled = device->isTextModeEnabled();

    if (textModeEnabled) {

        device->setTextModeEnabled(false);

        writeBuffer.replace(QLatin1Char('\n'), QLatin1String("\r\n"));

    }

#endif

#ifndef QT_NO_TEXTCODEC

    if (!codec)

        codec = QTextCodec::codecForLocale();

#if defined (QTEXTSTREAM_DEBUG)

    qDebug("QTextStreamPrivate::flushWriteBuffer(), using %s codec (%s generating BOM)",

           codec->name().constData(), writeConverterState.flags & QTextCodec::IgnoreHeader ? "not" : "");

#endif

    // convert from unicode to raw data

    QByteArray data = codec->fromUnicode(writeBuffer.data(), writeBuffer.size(), &writeConverterState);

#else

    QByteArray data = writeBuffer.toLocal8Bit();

#endif

    writeBuffer.clear();

    // write raw data to the device

    qint64 bytesWritten = device->write(data);

#if defined (QTEXTSTREAM_DEBUG)

    qDebug("QTextStreamPrivate::flushWriteBuffer(), device->write(\"%s\") == %d",

           qt_prettyDebug(data.constData(), qMin(data.size(),32), data.size()).constData(), int(bytesWritten));

#endif

    if (bytesWritten <= 0)

        return false;

#if defined (Q_OS_WIN)

    // replace the text flag

    if (textModeEnabled)

        device->setTextModeEnabled(true);

#endif

    // flush the file

#ifndef QT_NO_QOBJECT

    QFile *file = qobject_cast<QFile *>(device);

    bool flushed = file && file->flush();

#else

    bool flushed = true;

#endif

#if defined (QTEXTSTREAM_DEBUG)

    qDebug("QTextStreamPrivate::flushWriteBuffer() wrote %d bytes",

           int(bytesWritten));

#endif

    return flushed && bytesWritten == qint64(data.size());

}

/*! \internal

    Scans no more than \a maxlen QChars in the current buffer for the

    first \a delimiter. Stores a pointer to the start offset of the

    token in \a ptr, and the length in QChars in \a length.

*/

bool QTextStreamPrivate::scan(const QChar **ptr, int *length, int maxlen, TokenDelimiter delimiter)

{

    int totalSize = 0;

    int delimSize = 0;

    bool consumeDelimiter = false;

    bool foundToken = false;

    int startOffset = device ? readBufferOffset : stringOffset;

    QChar lastChar;

    bool canStillReadFromDevice = true;

    do {

        int endOffset;

        const QChar *chPtr;

        if (device) {

            chPtr = readBuffer.constData();

            endOffset = readBuffer.size();

        } else {

            chPtr = string->constData();

            endOffset = string->size();

        }

        chPtr += startOffset;

        for (; !foundToken && startOffset < endOffset && (!maxlen || totalSize < maxlen); ++startOffset) {

            const QChar ch = *chPtr++;

            ++totalSize;

            if (delimiter == Space && ch.isSpace()) {

                foundToken = true;

                delimSize = 1;

            } else if (delimiter == NotSpace && !ch.isSpace()) {

                foundToken = true;

                delimSize = 1;

            } else if (delimiter == EndOfLine && ch == QLatin1Char('\n')) {

                foundToken = true;

                delimSize = (lastChar == QLatin1Char('\r')) ? 2 : 1;

                consumeDelimiter = true;

            }

            lastChar = ch;

        }

    } while (!foundToken

             && (!maxlen || totalSize < maxlen)

             && (device && (canStillReadFromDevice = fillReadBuffer())));

    // if the token was not found, but we reached the end of input,

    // then we accept what we got. if we are not at the end of input,

    // we return false.

    if (!foundToken && (!maxlen || totalSize < maxlen)

        && (totalSize == 0

            || (string && stringOffset + totalSize < string->size())

            || (device && !device->atEnd() && canStillReadFromDevice))) {

#if defined (QTEXTSTREAM_DEBUG)

        qDebug("QTextStreamPrivate::scan() did not find the token.");

#endif

        return false;

    }

    // if we find a '\r' at the end of the data when reading lines,

    // don't make it part of the line.

    if (totalSize > 0 && !foundToken && delimiter == EndOfLine) {

        if (((string && stringOffset + totalSize == string->size()) || (device && device->atEnd()))

            && lastChar == QLatin1Char('\r')) {

            consumeDelimiter = true;

            ++delimSize;

        }

    }

    // set the read offset and length of the token

    if (length)

        *length = totalSize - delimSize;

    if (ptr)

        *ptr = readPtr();

    // update last token size. the callee will call consumeLastToken() when

    // done.

    lastTokenSize = totalSize;

    if (!consumeDelimiter)

        lastTokenSize -= delimSize;

#if defined (QTEXTSTREAM_DEBUG)

    qDebug("QTextStreamPrivate::scan(%p, %p, %d, %x) token length = %d, delimiter = %d",

           ptr, length, maxlen, (int)delimiter, totalSize - delimSize, delimSize);

#endif

    return true;

}

/*! \internal

*/

inline const QChar *QTextStreamPrivate::readPtr() const

{

    Q_ASSERT(readBufferOffset <= readBuffer.size());

    if (string)

        return string->constData() + stringOffset;

    return readBuffer.constData() + readBufferOffset;

}

/*! \internal

*/

inline void QTextStreamPrivate::consumeLastToken()

{

    if (lastTokenSize)

        consume(lastTokenSize);

    lastTokenSize = 0;

}

/*! \internal

*/

inline void QTextStreamPrivate::consume(int size)

{

#if defined (QTEXTSTREAM_DEBUG)

    qDebug("QTextStreamPrivate::consume(%d)", size);

#endif

    if (string) {

        stringOffset += size;

        if (stringOffset > string->size())

            stringOffset = string->size();

    } else {

        readBufferOffset += size;

        if (readBufferOffset >= readBuffer.size()) {

            readBufferOffset = 0;

            readBuffer.clear();

            saveConverterState(device->pos());

        }

    }

}

/*! \internal

*/

inline void QTextStreamPrivate::saveConverterState(qint64 newPos)

{

#ifndef QT_NO_TEXTCODEC

    if (readConverterState.d) {

        // converter cannot be copied, so don't save anything

        // don't update readBufferStartDevicePos either

        return;

    }

    if (!readConverterSavedState)

        readConverterSavedState = new QTextCodec::ConverterState;

    copyConverterStateHelper(readConverterSavedState, &readConverterState);

#endif

    readBufferStartDevicePos = newPos;

}

/*! \internal

*/

inline void QTextStreamPrivate::restoreToSavedConverterState()

{

#ifndef QT_NO_TEXTCODEC

    if (readConverterSavedState) {

        // we have a saved state

        // that means the converter can be copied

        copyConverterStateHelper(&readConverterState, readConverterSavedState);

    } else {

        // the only state we could save was the initial

        // so reset to that

        resetCodecConverterStateHelper(&readConverterState);

    }

#endif

}

/*! \internal

*/

inline bool QTextStreamPrivate::write(const QString &data)

{

    if (string) {

        // ### What about seek()??

        string->append(data);

    } else {

        writeBuffer += data;

        if (writeBuffer.size() > QTEXTSTREAM_BUFFERSIZE)

            return flushWriteBuffer();

    }

    return true;

}

/*! \internal

*/

inline bool QTextStreamPrivate::getChar(QChar *ch)

{

    if ((string && stringOffset == string->size())

        || (device && readBuffer.isEmpty() && !fillReadBuffer())) {

        if (ch)

            *ch = 0;

        return false;

    }

    if (ch)

        *ch = *readPtr();

    consume(1);

    return true;

}

/*! \internal

*/

inline void QTextStreamPrivate::ungetChar(const QChar &ch)

{

    if (string) {

        if (stringOffset == 0)

            string->prepend(ch);

        else

            (*string)[--stringOffset] = ch;

        return;

    }

    if (readBufferOffset == 0) {

        readBuffer.prepend(ch);

        return;

    }

    readBuffer[--readBufferOffset] = ch;

}

/*! \internal

*/

inline bool QTextStreamPrivate::putString(const QString &s, bool number)

{

    QString tmp = s;

    // handle padding

    int padSize = fieldWidth - s.size();

    if (padSize > 0) {

        QString pad(padSize > 0 ? padSize : 0, padChar);

        if (fieldAlignment == QTextStream::AlignLeft) {

            tmp.append(QString(padSize, padChar));

        } else if (fieldAlignment == QTextStream::AlignRight

                   || fieldAlignment == QTextStream::AlignAccountingStyle) {

            tmp.prepend(QString(padSize, padChar));

            if (fieldAlignment == QTextStream::AlignAccountingStyle && number) {

                const QChar sign = s.size() > 0 ? s.at(0) : QChar();

                if (sign == locale.negativeSign() || sign == locale.positiveSign()) {

                    QChar *data = tmp.data();

                    data[padSize] = tmp.at(0);

                    data[0] = sign;

                }

           }

        } else if (fieldAlignment == QTextStream::AlignCenter) {

            tmp.prepend(QString(padSize/2, padChar));

            tmp.append(QString(padSize - padSize/2, padChar));

        }

    }

#if defined (QTEXTSTREAM_DEBUG)

    QByteArray a = s.toUtf8();

    QByteArray b = tmp.toUtf8();

    qDebug("QTextStreamPrivate::putString(\"%s\") calls write(\"%s\")",

           qt_prettyDebug(a.constData(), a.size(), qMax(16, a.size())).constData(),

           qt_prettyDebug(b.constData(), b.size(), qMax(16, b.size())).constData());

#endif

    return write(tmp);

}

/*!

    Constructs a QTextStream. Before you can use it for reading or

    writing, you must assign a device or a string.

    \sa setDevice(), setString()

*/

QTextStream::QTextStream()

    : d_ptr(new QTextStreamPrivate(this))

{

#if defined (QTEXTSTREAM_DEBUG)

    qDebug("QTextStream::QTextStream()");

#endif

    Q_D(QTextStream);

    d->status = Ok;

}

/*!

    Constructs a QTextStream that operates on \a device.

*/

QTextStream::QTextStream(QIODevice *device)

    : d_ptr(new QTextStreamPrivate(this))

{

#if defined (QTEXTSTREAM_DEBUG)

    qDebug("QTextStream::QTextStream(QIODevice *device == *%p)",

           device);

#endif

    Q_D(QTextStream);

    d->device = device;

#ifndef QT_NO_QOBJECT

    d->deviceClosedNotifier.setupDevice(this, d->device);

#endif

    d->status = Ok;

}

/*!

    Constructs a QTextStream that operates on \a string, using \a

    openMode to define the open mode.

*/

QTextStream::QTextStream(QString *string, QIODevice::OpenMode openMode)

    : d_ptr(new QTextStreamPrivate(this))

{

#if defined (QTEXTSTREAM_DEBUG)

    qDebug("QTextStream::QTextStream(QString *string == *%p, openMode = %d)",

           string, int(openMode));

#endif

    Q_D(QTextStream);

    d->string = string;

    d->stringOpenMode = openMode;

    d->status = Ok;

}

/*!

    Constructs a QTextStream that operates on \a array, using \a

    openMode to define the open mode. Internally, the array is wrapped

    by a QBuffer.

*/

QTextStream::QTextStream(QByteArray *array, QIODevice::OpenMode openMode)

    : d_ptr(new QTextStreamPrivate(this))

{

#if defined (QTEXTSTREAM_DEBUG)

    qDebug("QTextStream::QTextStream(QByteArray *array == *%p, openMode = %d)",

           array, int(openMode));

#endif

    Q_D(QTextStream);

    d->device = new QBuffer(array);

    d->device->open(openMode);

    d->deleteDevice = true;

#ifndef QT_NO_QOBJECT

    d->deviceClosedNotifier.setupDevice(this, d->device);

#endif

    d->status = Ok;

}

/*!

    Constructs a QTextStream that operates on \a array, using \a

    openMode to define the open mode. The array is accessed as

    read-only, regardless of the values in \a openMode.

    This constructor is convenient for working on constant

    strings. Example:

    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 3

*/

QTextStream::QTextStream(const QByteArray &array, QIODevice::OpenMode openMode)

    : d_ptr(new QTextStreamPrivate(this))

{

#if defined (QTEXTSTREAM_DEBUG)

    qDebug("QTextStream::QTextStream(const QByteArray &array == *(%p), openMode = %d)",

           &array, int(openMode));

#endif

    QBuffer *buffer = new QBuffer;

    buffer->setData(array);

    buffer->open(openMode);

    Q_D(QTextStream);

    d->device = buffer;

    d->deleteDevice = true;

#ifndef QT_NO_QOBJECT

    d->deviceClosedNotifier.setupDevice(this, d->device);

#endif

    d->status = Ok;

}

/*!

    Constructs a QTextStream that operates on \a fileHandle, using \a

    openMode to define the open mode. Internally, a QFile is created

    to handle the FILE pointer.

    This constructor is useful for working directly with the common

    FILE based input and output streams: stdin, stdout and stderr. Example:

    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 4

*/

QTextStream::QTextStream(FILE *fileHandle, QIODevice::OpenMode openMode)

    : d_ptr(new QTextStreamPrivate(this))

{

#if defined (QTEXTSTREAM_DEBUG)

    qDebug("QTextStream::QTextStream(FILE *fileHandle = %p, openMode = %d)",

           fileHandle, int(openMode));

#endif

    QFile *file = new QFile;

    file->open(fileHandle, openMode);

    Q_D(QTextStream);

    d->device = file;

    d->deleteDevice = true;

#ifndef QT_NO_QOBJECT

    d->deviceClosedNotifier.setupDevice(this, d->device);

#endif

    d->status = Ok;

}

/*!

    Destroys the QTextStream.

    If the stream operates on a device, flush() will be called

    implicitly. Otherwise, the device is unaffected.

*/

QTextStream::~QTextStream()

{

    Q_D(QTextStream);

#if defined (QTEXTSTREAM_DEBUG)

    qDebug("QTextStream::~QTextStream()");

#endif

    if (!d->writeBuffer.isEmpty())

        d->flushWriteBuffer();

    delete d;

    d_ptr = 0;

}

/*!

    Resets QTextStream's formatting options, bringing it back to its

    original constructed state. The device, string and any buffered

    data is left untouched.

*/

void QTextStream::reset()

{

    Q_D(QTextStream);

    d->realNumberPrecision = 6;

    d->integerBase = 0;

    d->fieldWidth = 0;

    d->padChar = QLatin1Char(' ');

    d->fieldAlignment = QTextStream::AlignRight;

    d->realNumberNotation = QTextStream::SmartNotation;

    d->numberFlags = 0;

}

/*!

    Flushes any buffered data waiting to be written to the device.

    If QTextStream operates on a string, this function does nothing.

*/

void QTextStream::flush()

{

    Q_D(QTextStream);

    d->flushWriteBuffer();

}

/*!

    Seeks to the position \a pos in the device. Returns true on

    success; otherwise returns false.

*/

bool QTextStream::seek(qint64 pos)

{

    Q_D(QTextStream);

    d->lastTokenSize = 0;

    if (d->device) {

        // Empty the write buffer

        d->flushWriteBuffer();

        if (!d->device->seek(pos))

            return false;

        d->resetReadBuffer();

#ifndef QT_NO_TEXTCODEC

        // Reset the codec converter states.

        resetCodecConverterStateHelper(&d->readConverterState);

        resetCodecConverterStateHelper(&d->writeConverterState);

        delete d->readConverterSavedState;

        d->readConverterSavedState = 0;

#endif

        return true;

    }

    // string

    if (d->string && pos <= d->string->size()) {

        d->stringOffset = int(pos);

        return true;

    }

    return false;

}

/*!

    \since 4.2

    Returns the device position corresponding to the current position of the

    stream, or -1 if an error occurs (e.g., if there is no device or string,

    or if there's a device error).

    Because QTextStream is buffered, this function may have to

    seek the device to reconstruct a valid device position. This

    operation can be expensive, so you may want to avoid calling this

    function in a tight loop.

    \sa seek()

*/

qint64 QTextStream::pos() const

{

    Q_D(const QTextStream);

    if (d->device) {

        // Cutoff

        if (d->readBuffer.isEmpty())

            return d->device->pos();

        if (d->device->isSequential())

            return 0;

        // Seek the device

        if (!d->device->seek(d->readBufferStartDevicePos))

            return qint64(-1);

        // Reset the read buffer

        QTextStreamPrivate *thatd = const_cast<QTextStreamPrivate *>(d);

        thatd->readBuffer.clear();

#ifndef QT_NO_TEXTCODEC

        thatd->restoreToSavedConverterState();

        if (d->readBufferStartDevicePos == 0)

            thatd->autoDetectUnicode = true;

#endif

        // Rewind the device to get to the current position Ensure that

        // readBufferOffset is unaffected by fillReadBuffer()

        int oldReadBufferOffset = d->readBufferOffset;

        while (d->readBuffer.size() < oldReadBufferOffset) {

            if (!thatd->fillReadBuffer(1))

                return qint64(-1);

        }

        thatd->readBufferOffset = oldReadBufferOffset;

        // Return the device position.

        return d->device->pos();

    }

    if (d->string)

        return d->stringOffset;

    qWarning("QTextStream::pos: no device");

    return qint64(-1);

}

/*!

    Reads and discards whitespace from the stream until either a

    non-space character is detected, or until atEnd() returns

    true. This function is useful when reading a stream character by

    character.

    Whitespace characters are all characters for which

    QChar::isSpace() returns true.

    \sa operator>>()

*/

void QTextStream::skipWhiteSpace()

{

    Q_D(QTextStream);

    CHECK_VALID_STREAM(Q_VOID);

    d->scan(0, 0, 0, QTextStreamPrivate::NotSpace);

    d->consumeLastToken();

}

/*!

    Sets the current device to \a device. If a device has already been

    assigned, QTextStream will call flush() before the old device is

    replaced.

    \note This function resets locale to the default locale ('C')

    and codec to the default codec, QTextCodec::codecForLocale().

    \sa device(), setString()

*/

void QTextStream::setDevice(QIODevice *device)

{

    Q_D(QTextStream);

    flush();

    if (d->deleteDevice) {

#ifndef QT_NO_QOBJECT

        d->deviceClosedNotifier.disconnect();

#endif

        delete d->device;

        d->deleteDevice = false;

    }

    d->reset();

    d->status = Ok;

    d->device = device;

    d->resetReadBuffer();

#ifndef QT_NO_QOBJECT

    d->deviceClosedNotifier.setupDevice(this, d->device);

#endif

}

/*!

    Returns the current device associated with the QTextStream,

    or 0 if no device has been assigned.

    \sa setDevice(), string()

*/

QIODevice *QTextStream::device() const

{

    Q_D(const QTextStream);

    return d->device;

}

/*!

    Sets the current string to \a string, using the given \a

    openMode. If a device has already been assigned, QTextStream will

    call flush() before replacing it.

    \sa string(), setDevice()

*/

void QTextStream::setString(QString *string, QIODevice::OpenMode openMode)

{

    Q_D(QTextStream);

    flush();

    if (d->deleteDevice) {

#ifndef QT_NO_QOBJECT

        d->deviceClosedNotifier.disconnect();

        d->device->blockSignals(true);

#endif

        delete d->device;

        d->deleteDevice = false;

    }

    d->reset();

    d->status = Ok;

    d->string = string;

    d->stringOpenMode = openMode;

}

/*!

    Returns the current string assigned to the QTextStream, or 0 if no

    string has been assigned.

    \sa setString(), device()

*/

QString *QTextStream::string() const

{

    Q_D(const QTextStream);

    return d->string;

}

/*!

    Sets the field alignment to \a mode. When used together with

    setFieldWidth(), this function allows you to generate formatted

    output with text aligned to the left, to the right or center

    aligned.

    \sa fieldAlignment(), setFieldWidth()

*/

void QTextStream::setFieldAlignment(FieldAlignment mode)

{

    Q_D(QTextStream);

    d->fieldAlignment = mode;

}

/*!

    Returns the current field alignment.

    \sa setFieldAlignment(), fieldWidth()

*/

QTextStream::FieldAlignment QTextStream::fieldAlignment() const

{

    Q_D(const QTextStream);

    return d->fieldAlignment;

}

/*!

    Sets the pad character to \a ch. The default value is the ASCII

    space character (' '), or QChar(0x20). This character is used to

    fill in the space in fields when generating text.

    Example:

    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 5

    The string \c s contains:

    \snippet doc/src/snippets/code/src_corelib_io_qtextstream.cpp 6

    \sa padChar(), setFieldWidth()

*/

void QTextStream::setPadChar(QChar ch)

{

    Q_D(QTextStream);

    d->padChar = ch;

}

/*!

    Returns the current pad character.

    \sa setPadChar(), setFieldWidth()

*/

QChar QTextStream::padChar() const

{

    Q_D(const QTextStream);

    return d->padChar;

}

/*!

    Sets the current field width to \a width. If \a width is 0 (the

    default), the field width is equal to the length of the generated

    text.

    \note The field width applies to every element appended to this

    stream after this function has been called (e.g., it also pads

    endl). This behavior is different from similar classes in the STL,

    where the field width only applies to the next element.

    \sa fieldWidth(), setPadChar()

*/

void QTextStream::setFieldWidth(int width)

{

    Q_D(QTextStream);

    d->fieldWidth = width;

}

/*!

    Returns the current field width.

    \sa setFieldWidth()

*/

int QTextStream::fieldWidth() const

{

    Q_D(const QTextStream);

    return d->fieldWidth;

}

/*!

    Sets the current number flags to \a flags. \a flags is a set of

    flags from the NumberFlag enum, and describes options for

    formatting generated code (e.g., whether or not to always write

    the base or sign of a number).

    \sa numberFlags(), setIntegerBase(), setRealNumberNotation()

*/

void QTextStream::setNumberFlags(NumberFlags flags)

{

    Q_D(QTextStream);

    d->numberFlags = flags;

}

/*!

    Returns the current number flags.

    \sa setNumberFlags(), integerBase(), realNumberNotation()

*/

QTextStream::NumberFlags QTextStream::numberFlags() const

{

    Q_D(const QTextStream);

    return d->numberFlags;

}

/*!

    Sets the base of integers to \a base, both for reading and for

    generating numbers. \a base can be either 2 (binary), 8 (octal),

    10 (decimal) or 16 (hexadecimal). If \a base is 0, QTextStream

    will attempt to detect the base by inspecting the data on the

    stream. When generating numbers, QTextStream assumes base is 10

    unless the base has been set explicitly.

    \sa integerBase(), QString::number(), setNumberFlags()

*/

void QTextStream::setIntegerBase(int base)

{

    Q_D(QTextStream);

    d->integerBase = base;

}

/*!

    Returns the current base of integers. 0 means that the base is

    detected when reading, or 10 (decimal) when generating numbers.

    \sa setIntegerBase(), QString::number(), numberFlags()

*/

int QTextStream::integerBase() const

{

    Q_D(const QTextStream);

    return d->integerBase;

}

/*!

    Sets the real number notation to \a notation (SmartNotation,

    FixedNotation, ScientificNotation). When reading and generating

    numbers, QTextStream uses this value to detect the formatting of

    real numbers.

    \sa realNumberNotation(), setRealNumberPrecision(), setNumberFlags(), setIntegerBase()

*/

void QTextStream::setRealNumberNotation(RealNumberNotation notation)

{

    Q_D(QTextStream);

    d->realNumberNotation = notation;

}

/*!

    Returns the current real number notation.

    \sa setRealNumberNotation(), realNumberPrecision(), numberFlags(), integerBase()

*/

QTextStream::RealNumberNotation QTextStream::realNumberNotation() const

{

    Q_D(const QTextStream);

    return d->realNumberNotation;

}

/*!

    Sets the precision of real numbers to \a precision. This value

    describes the number of fraction digits QTextStream should

    write when generating real numbers.

    The precision cannot be a negative value. The default value is 6.

    \sa realNumberPrecision(), setRealNumberNotation()

*/

void QTextStream::setRealNumberPrecision(int precision)

{

    Q_D(QTextStream);

    if (precision < 0) {

        qWarning("QTextStream::setRealNumberPrecision: Invalid precision (%d)", precision);

        d->realNumberPrecision = 6;

        return;

    }

    d->realNumberPrecision = precision;

}

/*!

    Returns the current real number precision, or the number of fraction

    digits QTextStream will write when generating real numbers.

    \sa setRealNumberNotation(), realNumberNotation(), numberFlags(), integerBase()

*/

int QTextStream::realNumberPrecision() const

{

    Q_D(const QTextStream);

    return d->realNumberPrecision;

}

/*!

    Returns the status of the text stream.

    \sa QTextStream::Status, setStatus(), resetStatus()

*/

QTextStream::Status QTextStream::status() const

{

    Q_D(const QTextStream);

    return d->status;

}

/*!

    \since 4.1

    Resets the status of the text stream.

    \sa QTextStream::Status, status(), setStatus()

*/

void QTextStream::resetStatus()

{

    Q_D(QTextStream);

    d->status = Ok;

}

/*!

    \since 4.1

    Sets the status of the text stream to the \a status given.

    \sa Status status() resetStatus()

*/

void QTextStream::setStatus(Status status)

{

    Q_D(QTextStream);

    if (d->status == Ok)

        d->status = status;

}

/*!

    Returns true if there is no more data to be read from the

    QTextStream; otherwise returns false. This is similar to, but not

    the same as calling QIODevice::atEnd(), as QTextStream also takes

    into account its internal Unicode buffer.

*/

bool QTextStream::atEnd() const

{

    Q_D(const QTextStream);

    CHECK_VALID_STREAM(true);

    if (d->string)