summaryrefslogtreecommitdiffstats
path: root/src/tools/qtextstream.cpp
diff options
context:
space:
mode:
authorTimothy Pearson <kb9vqf@pearsoncomputing.net>2011-07-10 15:24:15 -0500
committerTimothy Pearson <kb9vqf@pearsoncomputing.net>2011-07-10 15:24:15 -0500
commitbd0f3345a938b35ce6a12f6150373b0955b8dd12 (patch)
tree7a520322212d48ebcb9fbe1087e7fca28b76185c /src/tools/qtextstream.cpp
downloadqt3-bd0f3345a938b35ce6a12f6150373b0955b8dd12.tar.gz
qt3-bd0f3345a938b35ce6a12f6150373b0955b8dd12.zip
Add Qt3 development HEAD version
Diffstat (limited to 'src/tools/qtextstream.cpp')
-rw-r--r--src/tools/qtextstream.cpp2609
1 files changed, 2609 insertions, 0 deletions
diff --git a/src/tools/qtextstream.cpp b/src/tools/qtextstream.cpp
new file mode 100644
index 0000000..63f9625
--- /dev/null
+++ b/src/tools/qtextstream.cpp
@@ -0,0 +1,2609 @@
+/****************************************************************************
+**
+** Implementation of QTextStream class
+**
+** Created : 940922
+**
+** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
+**
+** This file is part of the tools module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at sales@trolltech.com.
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file. Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qtextstream.h"
+
+#ifndef QT_NO_TEXTSTREAM
+#include "qtextcodec.h"
+#include "qregexp.h"
+#include "qbuffer.h"
+#include "qfile.h"
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#ifndef Q_OS_TEMP
+#include <locale.h>
+#endif
+
+#if defined(Q_OS_WIN32)
+#include "qt_windows.h"
+#endif
+
+/*!
+ \class QTextStream qtextstream.h
+ \reentrant
+ \brief The QTextStream class provides basic functions for reading
+ and writing text using a QIODevice.
+
+ \ingroup io
+ \ingroup text
+ \mainclass
+
+ The text stream class has a functional interface that is very
+ similar to that of the standard C++ iostream class.
+
+ Qt provides several global functions similar to the ones in iostream:
+ \table
+ \header \i Function \i Meaning
+ \row \i bin \i sets the QTextStream to read/write binary numbers
+ \row \i oct \i sets the QTextStream to read/write octal numbers
+ \row \i dec \i sets the QTextStream to read/write decimal numbers
+ \row \i hex \i sets the QTextStream to read/write hexadecimal numbers
+ \row \i endl \i forces a line break
+ \row \i flush \i forces the QIODevice to flush any buffered data
+ \row \i ws \i eats any available whitespace (on input)
+ \row \i reset \i resets the QTextStream to its default mode (see reset())
+ \row \i qSetW(int) \i sets the \link width() field width \endlink
+ to the given argument
+ \row \i qSetFill(int) \i sets the \link fill() fill character
+ \endlink to the given argument
+ \row \i qSetPrecision(int) \i sets the \link precision() precision
+ \endlink to the given argument
+ \endtable
+
+ \warning By default QTextStream will automatically detect whether
+ integers in the stream are in decimal, octal, hexadecimal or
+ binary format when reading from the stream. In particular, a
+ leading '0' signifies octal, i.e. the sequence "0100" will be
+ interpreted as 64.
+
+ The QTextStream class reads and writes text; it is not appropriate
+ for dealing with binary data (but QDataStream is).
+
+ By default, output of Unicode text (i.e. QString) is done using
+ the local 8-bit encoding. This can be changed using the
+ setEncoding() method. For input, the QTextStream will auto-detect
+ standard Unicode "byte order marked" text files; otherwise the
+ local 8-bit encoding is used.
+
+ The QIODevice is set in the constructor, or later using
+ setDevice(). If the end of the input is reached atEnd() returns
+ TRUE. Data can be read into variables of the appropriate type
+ using the operator>>() overloads, or read in its entirety into a
+ single string using read(), or read a line at a time using
+ readLine(). Whitespace can be skipped over using skipWhiteSpace().
+ You can set flags for the stream using flags() or setf(). The
+ stream also supports width(), precision() and fill(); use reset()
+ to reset the defaults.
+
+ \sa QDataStream
+*/
+
+/*!
+ \enum QTextStream::Encoding
+
+ \value Locale
+ \value Latin1
+ \value Unicode
+ \value UnicodeNetworkOrder
+ \value UnicodeReverse
+ \value RawUnicode
+ \value UnicodeUTF8
+
+ See setEncoding() for an explanation of the encodings.
+*/
+
+/*
+ \class QTSManip
+
+ \brief The QTSManip class is an internal helper class for the
+ QTextStream.
+
+ It is generally a very bad idea to use this class directly in
+ application programs.
+
+ \internal
+
+ This class makes it possible to give the QTextStream function objects
+ with arguments, like this:
+ \code
+ QTextStream cout( stdout, IO_WriteOnly );
+ cout << setprecision( 8 ); // QTSManip used here!
+ cout << 3.14159265358979323846;
+ \endcode
+
+ The setprecision() function returns a QTSManip object.
+ The QTSManip object contains a pointer to a member function in
+ QTextStream and an integer argument.
+ When serializing a QTSManip into a QTextStream, the function
+ is executed with the argument.
+*/
+
+/*! \fn QTSManip::QTSManip( QTSMFI m, int a )
+
+ Constructs a QTSManip object which will call \a m (a member function
+ in QTextStream which accepts a single int) with argument \a a when
+ QTSManip::exec() is called. Used internally in e.g. endl:
+
+ \code
+ s << "some text" << endl << "more text";
+ \endcode
+*/
+
+/*! \fn void QTSManip::exec( QTextStream& s )
+
+ Calls the member function specified in the constructor, for object
+ \a s. Used internally in e.g. endl:
+
+ \code
+ s << "some text" << endl << "more text";
+ \endcode
+*/
+
+
+/*****************************************************************************
+ QTextStream member functions
+ *****************************************************************************/
+
+#if defined(QT_CHECK_STATE)
+#undef CHECK_STREAM_PRECOND
+#define CHECK_STREAM_PRECOND if ( !dev ) { \
+ qWarning( "QTextStream: No device" ); \
+ return *this; }
+#else
+#define CHECK_STREAM_PRECOND
+#endif
+
+
+#define I_SHORT 0x0010
+#define I_INT 0x0020
+#define I_LONG 0x0030
+#define I_TYPE_MASK 0x00f0
+
+#define I_BASE_2 QTS::bin
+#define I_BASE_8 QTS::oct
+#define I_BASE_10 QTS::dec
+#define I_BASE_16 QTS::hex
+#define I_BASE_MASK (QTS::bin | QTS::oct | QTS::dec | QTS::hex)
+
+#define I_SIGNED 0x0100
+#define I_UNSIGNED 0x0200
+#define I_SIGN_MASK 0x0f00
+
+
+static const QChar QEOF = QChar((ushort)0xffff); //guaranteed not to be a character.
+static const uint getline_buf_size = 256; // bufsize used by ts_getline()
+
+const int QTextStream::basefield = I_BASE_MASK;
+const int QTextStream::adjustfield = ( QTextStream::left |
+ QTextStream::right |
+ QTextStream::internal );
+const int QTextStream::floatfield = ( QTextStream::scientific |
+ QTextStream::fixed );
+
+
+class QTextStreamPrivate {
+public:
+#ifndef QT_NO_TEXTCODEC
+ QTextStreamPrivate()
+ : decoder( 0 ), encoder( 0 ), sourceType( NotSet ) { }
+ ~QTextStreamPrivate() {
+ delete decoder;
+ delete encoder;
+ }
+ QTextDecoder *decoder;
+ QTextEncoder *encoder;
+#else
+ QTextStreamPrivate() : sourceType( NotSet ) { }
+ ~QTextStreamPrivate() { }
+#endif
+ QString ungetcBuf;
+
+ enum SourceType { NotSet, IODevice, String, ByteArray, File };
+ SourceType sourceType;
+};
+
+
+// skips whitespace and returns the first non-whitespace character
+QChar QTextStream::eat_ws()
+{
+ QChar c;
+ do { c = ts_getc(); } while ( c != QEOF && ts_isspace(c) );
+ return c;
+}
+
+void QTextStream::init()
+{
+ // ### ungetcBuf = QEOF;
+ dev = 0;
+ owndev = FALSE;
+ mapper = 0;
+ d = new QTextStreamPrivate;
+ doUnicodeHeader = TRUE; // autodetect
+ latin1 = TRUE; // should use locale?
+ internalOrder = QChar::networkOrdered();
+ networkOrder = TRUE;
+}
+
+/*!
+ Constructs a data stream that has no IO device.
+*/
+
+QTextStream::QTextStream()
+{
+ init();
+ setEncoding( Locale );
+ reset();
+ d->sourceType = QTextStreamPrivate::NotSet;
+}
+
+/*!
+ Constructs a text stream that uses the IO device \a iod.
+*/
+
+QTextStream::QTextStream( QIODevice *iod )
+{
+ init();
+ setEncoding( Locale );
+ dev = iod;
+ reset();
+ d->sourceType = QTextStreamPrivate::IODevice;
+}
+
+// TODO: use special-case handling of this case in QTextStream, and
+// simplify this class to only deal with QChar or QString data.
+class QStringBuffer : public QIODevice {
+public:
+ QStringBuffer( QString* str );
+ ~QStringBuffer();
+ bool open( int m );
+ void close();
+ void flush();
+ Offset size() const;
+ Offset at() const;
+ bool at( Offset pos );
+ Q_LONG readBlock( char *p, Q_ULONG len );
+ Q_LONG writeBlock( const char *p, Q_ULONG len );
+ int getch();
+ int putch( int ch );
+ int ungetch( int ch );
+protected:
+ QString* s;
+
+private:
+ QStringBuffer( const QStringBuffer & );
+ QStringBuffer &operator=( const QStringBuffer & );
+};
+
+
+QStringBuffer::QStringBuffer( QString* str )
+{
+ s = str;
+}
+
+QStringBuffer::~QStringBuffer()
+{
+}
+
+
+bool QStringBuffer::open( int m )
+{
+ if ( !s ) {
+#if defined(QT_CHECK_STATE)
+ qWarning( "QStringBuffer::open: No string" );
+#endif
+ return FALSE;
+ }
+ if ( isOpen() ) {
+#if defined(QT_CHECK_STATE)
+ qWarning( "QStringBuffer::open: Buffer already open" );
+#endif
+ return FALSE;
+ }
+ setMode( m );
+ if ( m & IO_Truncate )
+ s->truncate( 0 );
+
+ if ( m & IO_Append ) {
+ ioIndex = s->length()*sizeof(QChar);
+ } else {
+ ioIndex = 0;
+ }
+ setState( IO_Open );
+ resetStatus();
+ return TRUE;
+}
+
+void QStringBuffer::close()
+{
+ if ( isOpen() ) {
+ setFlags( IO_Direct );
+ ioIndex = 0;
+ }
+}
+
+void QStringBuffer::flush()
+{
+}
+
+QIODevice::Offset QStringBuffer::size() const
+{
+ return s ? s->length()*sizeof(QChar) : 0;
+}
+
+QIODevice::Offset QStringBuffer::at() const
+{
+ return ioIndex;
+}
+
+bool QStringBuffer::at( Offset pos )
+{
+#if defined(QT_CHECK_STATE)
+ if ( !isOpen() ) {
+ qWarning( "QStringBuffer::at: Buffer is not open" );
+ return FALSE;
+ }
+#endif
+ if ( pos >= s->length()*2 ) {
+#if defined(QT_CHECK_RANGE)
+#if defined(QT_ABI_QT4)
+ qWarning( "QStringBuffer::at: Index %lld out of range", pos );
+#else
+ qWarning( "QStringBuffer::at: Index %lu out of range", pos );
+#endif
+#endif
+ return FALSE;
+ }
+ ioIndex = pos;
+ return TRUE;
+}
+
+
+Q_LONG QStringBuffer::readBlock( char *p, Q_ULONG len )
+{
+#if defined(QT_CHECK_STATE)
+ Q_CHECK_PTR( p );
+ if ( !isOpen() ) {
+ qWarning( "QStringBuffer::readBlock: Buffer not open" );
+ return -1;
+ }
+ if ( !isReadable() ) {
+ qWarning( "QStringBuffer::readBlock: Read operation not permitted" );
+ return -1;
+ }
+#endif
+ if ( ioIndex + len > s->length()*sizeof(QChar) ) {
+ // overflow
+ if ( (uint)ioIndex >= s->length()*sizeof(QChar) ) {
+ setStatus( IO_ReadError );
+ return -1;
+ } else {
+ len = s->length()*2 - (uint)ioIndex;
+ }
+ }
+ memcpy( p, ((const char*)(s->unicode()))+ioIndex, len );
+ ioIndex += len;
+ return len;
+}
+
+Q_LONG QStringBuffer::writeBlock( const char *p, Q_ULONG len )
+{
+#if defined(QT_CHECK_NULL)
+ if ( p == 0 && len != 0 )
+ qWarning( "QStringBuffer::writeBlock: Null pointer error" );
+#endif
+#if defined(QT_CHECK_STATE)
+ if ( !isOpen() ) {
+ qWarning( "QStringBuffer::writeBlock: Buffer not open" );
+ return -1;
+ }
+ if ( !isWritable() ) {
+ qWarning( "QStringBuffer::writeBlock: Write operation not permitted" );
+ return -1;
+ }
+ if ( ioIndex&1 ) {
+ qWarning( "QStringBuffer::writeBlock: non-even index - non Unicode" );
+ return -1;
+ }
+ if ( len&1 ) {
+ qWarning( "QStringBuffer::writeBlock: non-even length - non Unicode" );
+ return -1;
+ }
+#endif
+ s->replace(ioIndex/2, len/2, (QChar*)p, len/2);
+ ioIndex += len;
+ return len;
+}
+
+int QStringBuffer::getch()
+{
+#if defined(QT_CHECK_STATE)
+ if ( !isOpen() ) {
+ qWarning( "QStringBuffer::getch: Buffer not open" );
+ return -1;
+ }
+ if ( !isReadable() ) {
+ qWarning( "QStringBuffer::getch: Read operation not permitted" );
+ return -1;
+ }
+#endif
+ if ( (uint)ioIndex >= s->length()*2 ) { // overflow
+ setStatus( IO_ReadError );
+ return -1;
+ }
+ return (int)((const uchar *)s->unicode())[ioIndex++];
+}
+
+int QStringBuffer::putch( int ch )
+{
+ char c = ch;
+ if ( writeBlock(&c,1) < 0 )
+ return -1;
+ else
+ return ch;
+}
+
+int QStringBuffer::ungetch( int ch )
+{
+#if defined(QT_CHECK_STATE)
+ if ( !isOpen() ) {
+ qWarning( "QStringBuffer::ungetch: Buffer not open" );
+ return -1;
+ }
+ if ( !isReadable() ) {
+ qWarning( "QStringBuffer::ungetch: Read operation not permitted" );
+ return -1;
+ }
+#endif
+ if ( ch != -1 ) { // something to do with eof
+ if ( ioIndex )
+ ioIndex--;
+ else
+ ch = -1;
+ }
+ return ch;
+}
+
+
+/*!
+ Constructs a text stream that operates on the Unicode QString, \a
+ str, through an internal device. The \a filemode argument is
+ passed to the device's open() function; see \l{QIODevice::mode()}.
+
+ If you set an encoding or codec with setEncoding() or setCodec(),
+ this setting is ignored for text streams that operate on QString.
+
+ Example:
+ \code
+ QString str;
+ QTextStream ts( &str, IO_WriteOnly );
+ ts << "pi = " << 3.14; // str == "pi = 3.14"
+ \endcode
+
+ Writing data to the text stream will modify the contents of the
+ string. The string will be expanded when data is written beyond
+ the end of the string. Note that the string will not be truncated:
+ \code
+ QString str = "pi = 3.14";
+ QTextStream ts( &str, IO_WriteOnly );
+ ts << "2+2 = " << 2+2; // str == "2+2 = 414"
+ \endcode
+
+ Note that because QString is Unicode, you should not use
+ readRawBytes() or writeRawBytes() on such a stream.
+*/
+
+QTextStream::QTextStream( QString* str, int filemode )
+{
+ // TODO: optimize for this case as it becomes more common
+ // (see QStringBuffer above)
+ init();
+ dev = new QStringBuffer( str );
+ ((QStringBuffer *)dev)->open( filemode );
+ owndev = TRUE;
+ setEncoding(RawUnicode);
+ reset();
+ d->sourceType = QTextStreamPrivate::String;
+}
+
+/*! \obsolete
+
+ This constructor is equivalent to the constructor taking a QString*
+ parameter.
+*/
+
+QTextStream::QTextStream( QString& str, int filemode )
+{
+ init();
+ dev = new QStringBuffer( &str );
+ ((QStringBuffer *)dev)->open( filemode );
+ owndev = TRUE;
+ setEncoding(RawUnicode);
+ reset();
+ d->sourceType = QTextStreamPrivate::String;
+}
+
+/*!
+ Constructs a text stream that operates on the byte array, \a a,
+ through an internal QBuffer device. The \a mode argument is passed
+ to the device's open() function; see \l{QIODevice::mode()}.
+
+ Example:
+ \code
+ QByteArray array;
+ QTextStream ts( array, IO_WriteOnly );
+ ts << "pi = " << 3.14 << '\0'; // array == "pi = 3.14"
+ \endcode
+
+ Writing data to the text stream will modify the contents of the
+ array. The array will be expanded when data is written beyond the
+ end of the string.
+
+ Same example, using a QBuffer:
+ \code
+ QByteArray array;
+ QBuffer buf( array );
+ buf.open( IO_WriteOnly );
+ QTextStream ts( &buf );
+ ts << "pi = " << 3.14 << '\0'; // array == "pi = 3.14"
+ buf.close();
+ \endcode
+*/
+
+QTextStream::QTextStream( QByteArray a, int mode )
+{
+ init();
+ dev = new QBuffer( a );
+ ((QBuffer *)dev)->open( mode );
+ owndev = TRUE;
+ setEncoding( Latin1 ); //### Locale???
+ reset();
+ d->sourceType = QTextStreamPrivate::ByteArray;
+}
+
+/*!
+ Constructs a text stream that operates on an existing file handle
+ \a fh through an internal QFile device. The \a mode argument is
+ passed to the device's open() function; see \l{QIODevice::mode()}.
+
+ Note that if you create a QTextStream \c cout or another name that
+ is also used for another variable of a different type, some
+ linkers may confuse the two variables, which will often cause
+ crashes.
+*/
+
+QTextStream::QTextStream( FILE *fh, int mode )
+{
+ init();
+ setEncoding( Locale ); //###
+ dev = new QFile;
+ ((QFile *)dev)->open( mode, fh );
+ owndev = TRUE;
+ reset();
+ d->sourceType = QTextStreamPrivate::File;
+}
+
+/*!
+ Destroys the text stream.
+
+ The destructor does not affect the current IO device.
+*/
+
+QTextStream::~QTextStream()
+{
+ if ( owndev )
+ delete dev;
+ delete d;
+}
+
+/*!
+ Positions the read pointer at the first non-whitespace character.
+*/
+void QTextStream::skipWhiteSpace()
+{
+ ts_ungetc( eat_ws() );
+}
+
+
+/*!
+ Tries to read \a len characters from the stream and stores them in
+ \a buf. Returns the number of characters really read.
+
+ \warning There will no QEOF appended if the read reaches the end
+ of the file. EOF is reached when the return value does not equal
+ \a len.
+*/
+uint QTextStream::ts_getbuf( QChar* buf, uint len )
+{
+ if ( len < 1 )
+ return 0;
+
+ uint rnum = 0; // the number of QChars really read
+
+ if ( d && d->ungetcBuf.length() ) {
+ while ( rnum < len && rnum < d->ungetcBuf.length() ) {
+ *buf = d->ungetcBuf.constref( rnum );
+ buf++;
+ rnum++;
+ }
+ d->ungetcBuf = d->ungetcBuf.mid( rnum );
+ if ( rnum >= len )
+ return rnum;
+ }
+
+ // we use dev->ungetch() for one of the bytes of the unicode
+ // byte-order mark, but a local unget hack for the other byte:
+ int ungetHack = EOF;
+
+ if ( doUnicodeHeader ) {
+ doUnicodeHeader = FALSE; // only at the top
+ int c1 = dev->getch();
+ if ( c1 == EOF )
+ return rnum;
+ int c2 = dev->getch();
+ if ( c1 == 0xfe && c2 == 0xff ) {
+ mapper = 0;
+ latin1 = FALSE;
+ internalOrder = QChar::networkOrdered();
+ networkOrder = TRUE;
+ } else if ( c1 == 0xff && c2 == 0xfe ) {
+ mapper = 0;
+ latin1 = FALSE;
+ internalOrder = !QChar::networkOrdered();
+ networkOrder = FALSE;
+ } else {
+ if ( c2 != EOF ) {
+ dev->ungetch( c2 );
+ ungetHack = c1;
+ } else {
+ /*
+ A small bug might hide here. If only the first byte
+ of a file has made it so far, and that first byte
+ is half of the byte-order mark, then the utfness
+ will not be detected.
+ */
+ dev->ungetch( c1 );
+ }
+ }
+ }
+
+#ifndef QT_NO_TEXTCODEC
+ if ( mapper ) {
+ bool shortRead = FALSE;
+ if ( !d->decoder )
+ d->decoder = mapper->makeDecoder();
+ while( rnum < len ) {
+ QString s;
+ bool readBlock = !( len == 1+rnum );
+ for (;;) {
+ // for efficiency: normally read a whole block
+ if ( readBlock ) {
+ // guess buffersize; this may be wrong (too small or too
+ // big). But we can handle this (either iterate reading
+ // or use ungetcBuf).
+ // Note that this might cause problems for codecs where
+ // one byte can result in >1 Unicode Characters if bytes
+ // are written to the stream in the meantime (loss of
+ // synchronicity).
+ uint rlen = len - rnum;
+ char *cbuf = new char[ rlen ];
+ if ( ungetHack != EOF ) {
+ rlen = 1+dev->readBlock( cbuf+1, rlen-1 );
+ cbuf[0] = (char)ungetHack;
+ ungetHack = EOF;
+ } else {
+ rlen = dev->readBlock( cbuf, rlen );
+ }
+ s += d->decoder->toUnicode( cbuf, rlen );
+ delete[] cbuf;
+ // use buffered reading only for the first time, because we
+ // have to get the stream synchronous again (this is easier
+ // with single character reading)
+ readBlock = FALSE;
+ }
+ // get stream (and codec) in sync
+ int c;
+ if ( ungetHack == EOF ) {
+ c = dev->getch();
+ } else {
+ c = ungetHack;
+ ungetHack = EOF;
+ }
+ if ( c == EOF ) {
+ shortRead = TRUE;
+ break;
+ }
+ char b = c;
+ uint lengthBefore = s.length();
+ s += d->decoder->toUnicode( &b, 1 );
+ if ( s.length() > lengthBefore )
+ break; // it seems we are in sync now
+ }
+ uint i = 0;
+ uint end = QMIN( len-rnum, s.length() );
+ while( i < end ) {
+ *buf = s.constref(i++);
+ buf++;
+ }
+ rnum += end;
+ if ( s.length() > i ) {
+ // could be = but append is clearer
+ d->ungetcBuf.append( s.mid( i ) );
+ }
+ if ( shortRead )
+ return rnum;
+ }
+ } else
+#endif
+ if ( latin1 ) {
+ if ( len == 1+rnum ) {
+ // use this method for one character because it is more efficient
+ // (arnt doubts whether it makes a difference, but lets it stand)
+ int c = (ungetHack == EOF) ? dev->getch() : ungetHack;
+ if ( c != EOF ) {
+ *buf = (char)c;
+ buf++;
+ rnum++;
+ }
+ } else {
+ if ( ungetHack != EOF ) {
+ *buf = (char)ungetHack;
+ buf++;
+ rnum++;
+ ungetHack = EOF;
+ }
+ char *cbuf = new char[len - rnum];
+ while ( !dev->atEnd() && rnum < len ) {
+ uint rlen = len - rnum;
+ rlen = dev->readBlock( cbuf, rlen );
+ char *it = cbuf;
+ char *end = cbuf + rlen;
+ while ( it < end ) {
+ *buf = *it;
+ buf++;
+ it++;
+ }
+ rnum += rlen;
+ }
+ delete[] cbuf;
+ }
+ } else { // UCS-2 or UTF-16
+ if ( len == 1+rnum ) {
+ int c1 = (ungetHack == EOF) ? dev->getch() : ungetHack;
+ if ( c1 == EOF )
+ return rnum;
+ int c2 = dev->getch();
+ if ( c2 == EOF )
+ return rnum;
+
+ if ( networkOrder ) {
+ *buf = QChar( c2, c1 );
+ } else {
+ *buf = QChar( c1, c2 );
+ }
+ buf++;
+ rnum++;
+ } else {
+ char *cbuf = new char[ 2*( len - rnum ) ]; // for paranoids: overflow possible
+ while ( !dev->atEnd() && rnum < len ) {
+ uint rlen = 2 * ( len-rnum );
+ if ( ungetHack != EOF ) {
+ rlen = 1+dev->readBlock( cbuf+1, rlen-1 );
+ cbuf[0] = (char)ungetHack;
+ ungetHack = EOF;
+ } else {
+ rlen = dev->readBlock( cbuf, rlen );
+ }
+ // We can't use an odd number of bytes, so put it back. But
+ // do it only if we are capable of reading more -- normally
+ // there should not be an odd number, but the file might be
+ // truncated or not in UTF-16...
+ if ( (rlen & 1) == 1 )
+ if ( !dev->atEnd() )
+ dev->ungetch( cbuf[--rlen] );
+ uint i = 0;
+ if ( networkOrder ) {
+ while( i < rlen ) {
+ *buf = QChar( cbuf[i+1], cbuf[i] );
+ buf++;
+ i+=2;
+ }
+ } else {
+ while( i < rlen ) {
+ *buf = QChar( cbuf[i], cbuf[i+1] );
+ buf++;
+ i+=2;
+ }
+ }
+ rnum += i/2;
+ }
+ delete[] cbuf;
+ }
+ }
+ return rnum;
+}
+
+/*!
+ Tries to read one line, but at most len characters from the stream
+ and stores them in \a buf.
+
+ Returns the number of characters really read. Newlines are not
+ stripped.
+
+ There will be a QEOF appended if the read reaches the end of file;
+ this is different to ts_getbuf().
+
+ This function works only if a newline (as byte) is also a newline
+ (as resulting character) since it uses QIODevice::readLine(). So
+ use it only for such codecs where this is true!
+
+ This function is (almost) a no-op for UTF 16. Don't use it if
+ doUnicodeHeader is TRUE!
+*/
+uint QTextStream::ts_getline( QChar* buf )
+{
+ uint rnum=0; // the number of QChars really read
+ char cbuf[ getline_buf_size+1 ];
+
+ if ( d && d->ungetcBuf.length() ) {
+ while( rnum < getline_buf_size && rnum < d->ungetcBuf.length() ) {
+ buf[rnum] = d->ungetcBuf.constref(rnum);
+ rnum++;
+ }
+ d->ungetcBuf = d->ungetcBuf.mid( rnum );
+ if ( rnum >= getline_buf_size )
+ return rnum;
+ }
+
+#ifndef QT_NO_TEXTCODEC
+ if ( mapper ) {
+ if ( !d->decoder )
+ d->decoder = mapper->makeDecoder();
+ QString s;
+ bool readBlock = TRUE;
+ for (;;) {
+ // for efficiency: try to read a line
+ if ( readBlock ) {
+ int rlen = getline_buf_size - rnum;
+ rlen = dev->readLine( cbuf, rlen+1 );
+ if ( rlen == -1 )
+ rlen = 0;
+ s += d->decoder->toUnicode( cbuf, rlen );
+ readBlock = FALSE;
+ }
+ if ( dev->atEnd()
+ || s.at( s.length()-1 ) == '\n'
+ || s.at( s.length()-1 ) == '\r'
+ ) {
+ break;
+ } else {
+ // get stream (and codec) in sync
+ int c;
+ c = dev->getch();
+ if ( c == EOF ) {
+ break;
+ }
+ char b = c;
+ uint lengthBefore = s.length();
+ s += d->decoder->toUnicode( &b, 1 );
+ if ( s.length() > lengthBefore )
+ break; // it seems we are in sync now
+ }
+ }
+ uint i = 0;
+ while( rnum < getline_buf_size && i < s.length() )
+ buf[rnum++] = s.constref(i++);
+ if ( s.length() > i )
+ // could be = but append is clearer
+ d->ungetcBuf.append( s.mid( i ) );
+ if ( rnum < getline_buf_size && dev->atEnd() )
+ buf[rnum++] = QEOF;
+ } else
+#endif
+ if ( latin1 ) {
+ int rlen = getline_buf_size - rnum;
+ rlen = dev->readLine( cbuf, rlen+1 );
+ if ( rlen == -1 )
+ rlen = 0;
+ char *end = cbuf+rlen;
+ char *it = cbuf;
+ buf +=rnum;
+ while ( it != end ) {
+ buf->setCell( *(it++) );
+ buf->setRow( 0 );
+ buf++;
+ }
+ rnum += rlen;
+ if ( rnum < getline_buf_size && dev->atEnd() )
+ buf[1] = QEOF;
+ }
+ return rnum;
+}
+
+
+/*!
+ Puts one character into the stream.
+*/
+void QTextStream::ts_putc( QChar c )
+{
+#ifndef QT_NO_TEXTCODEC
+ if ( mapper ) {
+ if ( !d->encoder )
+ d->encoder = mapper->makeEncoder();
+ int len = 1;
+ QString s = c;
+ QCString block = d->encoder->fromUnicode( s, len );
+ dev->writeBlock( block, len );
+ } else
+#endif
+ if ( latin1 ) {
+ if ( c.row() )
+ dev->putch( '?' ); // unknown character
+ else
+ dev->putch( c.cell() );
+ } else {
+ if ( doUnicodeHeader ) {
+ doUnicodeHeader = FALSE;
+ ts_putc( QChar::byteOrderMark );
+ }
+ if ( internalOrder ) {
+ // this case is needed by QStringBuffer
+ dev->writeBlock( (char*)&c, sizeof(QChar) );
+ } else if ( networkOrder ) {
+ dev->putch( c.row() );
+ dev->putch( c.cell() );
+ } else {
+ dev->putch( c.cell() );
+ dev->putch( c.row() );
+ }
+ }
+}
+
+/*!
+ Puts one character into the stream.
+*/
+void QTextStream::ts_putc( int ch )
+{
+ ts_putc( QChar((ushort)ch) );
+}
+
+bool QTextStream::ts_isdigit( QChar c )
+{
+ return c.isDigit();
+}
+
+bool QTextStream::ts_isspace( QChar c )
+{
+ return c.isSpace();
+}
+
+void QTextStream::ts_ungetc( QChar c )
+{
+ if ( c.unicode() == 0xffff )
+ return;
+
+ d->ungetcBuf.prepend( c );
+}
+
+
+
+/*!
+ Reads \a len bytes from the stream into \a s and returns a
+ reference to the stream.
+
+ The buffer \a s must be preallocated.
+
+ Note that no encoding is done by this function.
+
+ \warning The behavior of this function is undefined unless the
+ stream's encoding is set to Unicode or Latin1.
+
+ \sa QIODevice::readBlock()
+*/
+
+QTextStream &QTextStream::readRawBytes( char *s, uint len )
+{
+ dev->readBlock( s, len );
+ return *this;
+}
+
+/*!
+ Writes the \a len bytes from \a s to the stream and returns a
+ reference to the stream.
+
+ Note that no encoding is done by this function.
+
+ \sa QIODevice::writeBlock()
+*/
+
+QTextStream &QTextStream::writeRawBytes( const char* s, uint len )
+{
+ dev->writeBlock( s, len );
+ return *this;
+}
+
+
+QTextStream &QTextStream::writeBlock( const char* p, uint len )
+{
+ if ( doUnicodeHeader ) {
+ doUnicodeHeader = FALSE;
+ if ( !mapper && !latin1 )
+ ts_putc( QChar::byteOrderMark );
+ }
+ // QCString and const char * are treated as Latin-1
+ if ( !mapper && latin1 ) {
+ dev->writeBlock( p, len );
+ } else if ( !mapper && internalOrder ) {
+ QChar *u = new QChar[len];
+ for ( uint i = 0; i < len; i++ )
+ u[i] = p[i];
+ dev->writeBlock( (char*)u, len * sizeof(QChar) );
+ delete [] u;
+ }
+#ifndef QT_NO_TEXTCODEC
+ else if (mapper) {
+ if (!d->encoder)
+ d->encoder = mapper->makeEncoder();
+ QString s = QString::fromLatin1(p, len);
+ int l = len;
+ QCString block = d->encoder->fromUnicode(s, l);
+ dev->writeBlock(block, l);
+ }
+#endif
+ else {
+ for ( uint i = 0; i < len; i++ )
+ ts_putc( (uchar)p[i] );
+ }
+ return *this;
+}
+
+QTextStream &QTextStream::writeBlock( const QChar* p, uint len )
+{
+#ifndef QT_NO_TEXTCODEC
+ if ( mapper ) {
+ if ( !d->encoder )
+ d->encoder = mapper->makeEncoder();
+ QConstString s( p, len );
+ int l = len;
+ QCString block = d->encoder->fromUnicode( s.string(), l );
+ dev->writeBlock( block, l );
+ } else
+#endif
+ if ( latin1 ) {
+ char *str = QString::unicodeToLatin1( p, len );
+ dev->writeBlock( str, len );
+ delete [] str;
+ } else if ( internalOrder ) {
+ if ( doUnicodeHeader ) {
+ doUnicodeHeader = FALSE;
+ ts_putc( QChar::byteOrderMark );
+ }
+ dev->writeBlock( (char*)p, sizeof(QChar)*len );
+ } else {
+ for (uint i=0; i<len; i++)
+ ts_putc( p[i] );
+ }
+ return *this;
+}
+
+/*!
+ Resets the text stream.
+
+ \list
+ \i All flags are set to 0.
+ \i The field width is set to 0.
+ \i The fill character is set to ' ' (Space).
+ \i The precision is set to 6.
+ \endlist
+
+ \sa setf(), width(), fill(), precision()
+*/
+
+void QTextStream::reset()
+{
+ fflags = 0;
+ fwidth = 0;
+ fillchar = ' ';
+ fprec = 6;
+}
+
+/*!
+ \fn QIODevice *QTextStream::device() const
+
+ Returns the IO device currently set.
+
+ \sa setDevice(), unsetDevice()
+*/
+
+/*!
+ Sets the IO device to \a iod.
+
+ \sa device(), unsetDevice()
+*/
+
+void QTextStream::setDevice( QIODevice *iod )
+{
+ if ( owndev ) {
+ delete dev;
+ owndev = FALSE;
+ }
+ dev = iod;
+ d->sourceType = QTextStreamPrivate::IODevice;
+}
+
+/*!
+ Unsets the IO device. Equivalent to setDevice( 0 ).
+
+ \sa device(), setDevice()
+*/
+
+void QTextStream::unsetDevice()
+{
+ setDevice( 0 );
+ d->sourceType = QTextStreamPrivate::NotSet;
+}
+
+/*!
+ \fn bool QTextStream::atEnd() const
+
+ Returns TRUE if the IO device has reached the end position (end of
+ the stream or file) or if there is no IO device set; otherwise
+ returns FALSE.
+
+ \sa QIODevice::atEnd()
+*/
+
+/*!\fn bool QTextStream::eof() const
+
+ \obsolete
+
+ This function has been renamed to atEnd().
+
+ \sa QIODevice::atEnd()
+*/
+
+/*****************************************************************************
+ QTextStream read functions
+ *****************************************************************************/
+
+
+/*!
+ \overload
+
+ Reads a char \a c from the stream and returns a reference to the
+ stream. Note that whitespace is skipped.
+*/
+
+QTextStream &QTextStream::operator>>( char &c )
+{
+ CHECK_STREAM_PRECOND
+ c = eat_ws();
+ return *this;
+}
+
+/*!
+ Reads a char \a c from the stream and returns a reference to the
+ stream. Note that whitespace is \e not skipped.
+*/
+
+QTextStream &QTextStream::operator>>( QChar &c )
+{
+ CHECK_STREAM_PRECOND
+ c = ts_getc();
+ return *this;
+}
+
+
+ulong QTextStream::input_bin()
+{
+ ulong val = 0;
+ QChar ch = eat_ws();
+ int dv = ch.digitValue();
+ while ( dv == 0 || dv == 1 ) {
+ val = ( val << 1 ) + dv;
+ ch = ts_getc();
+ dv = ch.digitValue();
+ }
+ if ( ch != QEOF )
+ ts_ungetc( ch );
+ return val;
+}
+
+ulong QTextStream::input_oct()
+{
+ ulong val = 0;
+ QChar ch = eat_ws();
+ int dv = ch.digitValue();
+ while ( dv >= 0 && dv <= 7 ) {
+ val = ( val << 3 ) + dv;
+ ch = ts_getc();
+ dv = ch.digitValue();
+ }
+ if ( dv == 8 || dv == 9 ) {
+ while ( ts_isdigit(ch) )
+ ch = ts_getc();
+ }
+ if ( ch != QEOF )
+ ts_ungetc( ch );
+ return val;
+}
+
+ulong QTextStream::input_dec()
+{
+ ulong val = 0;
+ QChar ch = eat_ws();
+ int dv = ch.digitValue();
+ while ( ts_isdigit(ch) ) {
+ val = val * 10 + dv;
+ ch = ts_getc();
+ dv = ch.digitValue();
+ }
+ if ( ch != QEOF )
+ ts_ungetc( ch );
+ return val;
+}
+
+ulong QTextStream::input_hex()
+{
+ ulong val = 0;
+ QChar ch = eat_ws();
+ char c = ch;
+ while ( isxdigit((uchar) c) ) {
+ val <<= 4;
+ if ( ts_isdigit(c) )
+ val += c - '0';
+ else
+ val += 10 + tolower( (uchar) c ) - 'a';
+ c = ch = ts_getc();
+ }
+ if ( ch != QEOF )
+ ts_ungetc( ch );
+ return val;
+}
+
+long QTextStream::input_int()
+{
+ long val;
+ QChar ch;
+ char c;
+ switch ( flags() & basefield ) {
+ case bin:
+ val = (long)input_bin();
+ break;
+ case oct:
+ val = (long)input_oct();
+ break;
+ case dec:
+ c = ch = eat_ws();
+ if ( ch == QEOF ) {
+ val = 0;
+ } else {
+ if ( !(c == '-' || c == '+') )
+ ts_ungetc( ch );
+ if ( c == '-' ) {
+ ulong v = input_dec();
+ if ( v ) { // ensure that LONG_MIN can be read
+ v--;
+ val = -((long)v) - 1;
+ } else {
+ val = 0;
+ }
+ } else {
+ val = (long)input_dec();
+ }
+ }
+ break;
+ case hex:
+ val = (long)input_hex();
+ break;
+ default:
+ val = 0;
+ c = ch = eat_ws();
+ if ( c == '0' ) { // bin, oct or hex
+ c = ch = ts_getc();
+ if ( tolower((uchar) c) == 'x' )
+ val = (long)input_hex();
+ else if ( tolower((uchar) c) == 'b' )
+ val = (long)input_bin();
+ else { // octal
+ ts_ungetc( ch );
+ if ( c >= '0' && c <= '7' ) {
+ val = (long)input_oct();
+ } else {
+ val = 0;
+ }
+ }
+ } else if ( ts_isdigit(ch) ) {
+ ts_ungetc( ch );
+ val = (long)input_dec();
+ } else if ( c == '-' || c == '+' ) {
+ ulong v = input_dec();
+ if ( c == '-' ) {
+ if ( v ) { // ensure that LONG_MIN can be read
+ v--;
+ val = -((long)v) - 1;
+ } else {
+ val = 0;
+ }
+ } else {
+ val = (long)v;
+ }
+ }
+ }
+ return val;
+}
+
+//
+// We use a table-driven FSM to parse floating point numbers
+// strtod() cannot be used directly since we're reading from a QIODevice
+//
+
+double QTextStream::input_double()
+{
+ const int Init = 0; // states
+ const int Sign = 1;
+ const int Mantissa = 2;
+ const int Dot = 3;
+ const int Abscissa = 4;
+ const int ExpMark = 5;
+ const int ExpSign = 6;
+ const int Exponent = 7;
+ const int Done = 8;
+
+ const int InputSign = 1; // input tokens
+ const int InputDigit = 2;
+ const int InputDot = 3;
+ const int InputExp = 4;
+
+ static const uchar table[8][5] = {
+ /* None InputSign InputDigit InputDot InputExp */
+ { 0, Sign, Mantissa, Dot, 0, }, // Init
+ { 0, 0, Mantissa, Dot, 0, }, // Sign
+ { Done, Done, Mantissa, Dot, ExpMark,}, // Mantissa
+ { 0, 0, Abscissa, 0, 0, }, // Dot
+ { Done, Done, Abscissa, Done, ExpMark,}, // Abscissa
+ { 0, ExpSign, Exponent, 0, 0, }, // ExpMark
+ { 0, 0, Exponent, 0, 0, }, // ExpSign
+ { Done, Done, Exponent, Done, Done } // Exponent
+ };
+
+ int state = Init; // parse state
+ int input; // input token
+
+ char buf[256];
+ int i = 0;
+ QChar c = eat_ws();
+
+ for (;;) {
+
+ switch ( c ) {
+ case '+':
+ case '-':
+ input = InputSign;
+ break;
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+ input = InputDigit;
+ break;
+ case '.':
+ input = InputDot;
+ break;
+ case 'e':
+ case 'E':
+ input = InputExp;
+ break;
+ default:
+ input = 0;
+ break;
+ }
+
+ state = table[state][input];
+
+ if ( state == 0 || state == Done || i > 250 ) {
+ if ( i > 250 ) { // ignore rest of digits
+ do { c = ts_getc(); } while ( c != QEOF && ts_isdigit(c) );
+ }
+ if ( c != QEOF )
+ ts_ungetc( c );
+ buf[i] = '\0';
+ char *end;
+ return strtod( buf, &end );
+ }
+
+ buf[i++] = c;
+ c = ts_getc();
+ }
+
+#if !defined(Q_CC_EDG)
+ return 0.0;
+#endif
+}
+
+
+/*!
+ \overload
+
+ Reads a signed \c short integer \a i from the stream and returns a
+ reference to the stream. See flags() for an explanation of the
+ expected input format.
+*/
+
+QTextStream &QTextStream::operator>>( signed short &i )
+{
+ CHECK_STREAM_PRECOND
+ i = (signed short)input_int();
+ return *this;
+}
+
+
+/*!
+ \overload
+
+ Reads an unsigned \c short integer \a i from the stream and
+ returns a reference to the stream. See flags() for an explanation
+ of the expected input format.
+*/
+
+QTextStream &QTextStream::operator>>( unsigned short &i )
+{
+ CHECK_STREAM_PRECOND
+ i = (unsigned short)input_int();
+ return *this;
+}
+
+
+/*!
+ \overload
+
+ Reads a signed \c int \a i from the stream and returns a reference
+ to the stream. See flags() for an explanation of the expected
+ input format.
+*/
+
+QTextStream &QTextStream::operator>>( signed int &i )
+{
+ CHECK_STREAM_PRECOND
+ i = (signed int)input_int();
+ return *this;
+}
+
+
+/*!
+ \overload
+
+ Reads an unsigned \c int \a i from the stream and returns a
+ reference to the stream. See flags() for an explanation of the
+ expected input format.
+*/
+
+QTextStream &QTextStream::operator>>( unsigned int &i )
+{
+ CHECK_STREAM_PRECOND
+ i = (unsigned int)input_int();
+ return *this;
+}
+
+
+/*!
+ \overload
+
+ Reads a signed \c long int \a i from the stream and returns a
+ reference to the stream. See flags() for an explanation of the
+ expected input format.
+*/
+
+QTextStream &QTextStream::operator>>( signed long &i )
+{
+ CHECK_STREAM_PRECOND
+ i = (signed long)input_int();
+ return *this;
+}
+
+
+/*!
+ \overload
+
+ Reads an unsigned \c long int \a i from the stream and returns a
+ reference to the stream. See flags() for an explanation of the
+ expected input format.
+*/
+
+QTextStream &QTextStream::operator>>( unsigned long &i )
+{
+ CHECK_STREAM_PRECOND
+ i = (unsigned long)input_int();
+ return *this;
+}
+
+
+/*!
+ \overload
+
+ Reads a \c float \a f from the stream and returns a reference to
+ the stream. See flags() for an explanation of the expected input
+ format.
+*/
+
+QTextStream &QTextStream::operator>>( float &f )
+{
+ CHECK_STREAM_PRECOND
+ f = (float)input_double();
+ return *this;
+}
+
+
+/*!
+ \overload
+
+ Reads a \c double \a f from the stream and returns a reference to
+ the stream. See flags() for an explanation of the expected input
+ format.
+*/
+
+QTextStream &QTextStream::operator>>( double &f )
+{
+ CHECK_STREAM_PRECOND
+ f = input_double();
+ return *this;
+}
+
+
+/*!
+ \overload
+
+ Reads a "word" from the stream into \a s and returns a reference
+ to the stream.
+
+ A word consists of characters for which isspace() returns FALSE.
+*/
+
+QTextStream &QTextStream::operator>>( char *s )
+{
+ CHECK_STREAM_PRECOND
+ int maxlen = width( 0 );
+ QChar c = eat_ws();
+ if ( !maxlen )
+ maxlen = -1;
+ while ( c != QEOF ) {
+ if ( ts_isspace(c) || maxlen-- == 0 ) {
+ ts_ungetc( c );
+ break;
+ }
+ *s++ = c;
+ c = ts_getc();
+ }
+
+ *s = '\0';
+ return *this;
+}
+
+/*!
+ \overload
+
+ Reads a "word" from the stream into \a str and returns a reference
+ to the stream.
+
+ A word consists of characters for which isspace() returns FALSE.
+*/
+
+QTextStream &QTextStream::operator>>( QString &str )
+{
+ CHECK_STREAM_PRECOND
+ str=QString::fromLatin1("");
+ QChar c = eat_ws();
+
+ while ( c != QEOF ) {
+ if ( ts_isspace(c) ) {
+ ts_ungetc( c );
+ break;
+ }
+ str += c;
+ c = ts_getc();
+ }
+ return *this;
+}
+
+/*!
+ \overload
+
+ Reads a "word" from the stream into \a str and returns a reference
+ to the stream.
+
+ A word consists of characters for which isspace() returns FALSE.
+*/
+
+QTextStream &QTextStream::operator>>( QCString &str )
+{
+ CHECK_STREAM_PRECOND
+ QCString *dynbuf = 0;
+ const int buflen = 256;
+ char buffer[buflen];
+ char *s = buffer;
+ int i = 0;
+ QChar c = eat_ws();
+
+ while ( c != QEOF ) {
+ if ( ts_isspace(c) ) {
+ ts_ungetc( c );
+ break;
+ }
+ if ( i >= buflen-1 ) {
+ if ( !dynbuf ) { // create dynamic buffer
+ dynbuf = new QCString(buflen*2);
+ memcpy( dynbuf->data(), s, i ); // copy old data
+ } else if ( i >= (int)dynbuf->size()-1 ) {
+ dynbuf->resize( dynbuf->size()*2 );
+ }
+ s = dynbuf->data();
+ }
+ s[i++] = c;
+ c = ts_getc();
+ }
+ str.resize( i+1 );
+ memcpy( str.data(), s, i );
+ delete dynbuf;
+ return *this;
+}
+
+
+/*!
+ Reads a line from the stream and returns a string containing the
+ text.
+
+ The returned string does not contain any trailing newline or
+ carriage return. Note that this is different from
+ QIODevice::readLine(), which does not strip the newline at the end
+ of the line.
+
+ On EOF you will get a QString that is null. On reading an empty
+ line the returned QString is empty but not null.
+
+ \sa QIODevice::readLine()
+*/
+
+QString QTextStream::readLine()
+{
+#if defined(QT_CHECK_STATE)
+ if ( !dev ) {
+ qWarning( "QTextStream::readLine: No device" );
+ return QString::null;
+ }
+#endif
+ bool readCharByChar = TRUE;
+ QString result;
+#if 0
+ if ( !doUnicodeHeader && (
+ (latin1) ||
+ (mapper != 0 && mapper->mibEnum() == 106 ) // UTF 8
+ ) ) {
+ readCharByChar = FALSE;
+ // use optimized read line
+ QChar c[getline_buf_size];
+ int pos = 0;
+ bool eof = FALSE;
+
+ for (;;) {
+ pos = ts_getline( c );
+ if ( pos == 0 ) {
+ // something went wrong; try fallback
+ readCharByChar = TRUE;
+ //dev->resetStatus();
+ break;
+ }
+ if ( c[pos-1] == QEOF || c[pos-1] == '\n' ) {
+ if ( pos>2 && c[pos-1]==QEOF && c[pos-2]=='\n' ) {
+ result += QString( c, pos-2 );
+ } else if ( pos > 1 ) {
+ result += QString( c, pos-1 );
+ }
+ if ( pos == 1 && c[pos-1] == QEOF )
+ eof = TRUE;
+ break;
+ } else {
+ result += QString( c, pos );
+ }
+ }
+ if ( eof && result.isEmpty() )
+ return QString::null;
+ }
+#endif
+ if ( readCharByChar ) {
+ const int buf_size = 256;
+ QChar c[buf_size];
+ int pos = 0;
+
+ c[pos] = ts_getc();
+ if ( c[pos] == QEOF )
+ return QString::null;
+
+ while ( c[pos] != QEOF && c[pos] != '\n' ) {
+ if ( c[pos] == '\r' ) { // ( handle mac and dos )
+ QChar nextc = ts_getc();
+ if ( nextc != '\n' )
+ ts_ungetc( nextc );
+ break;
+ }
+ pos++;
+ if ( pos >= buf_size ) {
+ result += QString( c, pos );
+ pos = 0;
+ }
+ c[pos] = ts_getc();
+ }
+ result += QString( c, pos );
+ }
+
+ return result;
+}
+
+
+/*!
+ Reads the entire stream from the current position, and returns a string
+ containing the text.
+
+ \sa QIODevice::readLine()
+*/
+
+QString QTextStream::read()
+{
+#if defined(QT_CHECK_STATE)
+ if ( !dev ) {
+ qWarning( "QTextStream::read: No device" );
+ return QString::null;
+ }
+#endif
+ QString result;
+ const uint bufsize = 512;
+ QChar buf[bufsize];
+ uint i, num, start;
+ bool skipped_cr = FALSE;
+
+ for (;;) {
+ num = ts_getbuf(buf,bufsize);
+ // convert dos (\r\n) and mac (\r) style eol to unix style (\n)
+ start = 0;
+ for ( i=0; i<num; i++ ) {
+ if ( buf[i] == '\r' ) {
+ // Only skip single cr's preceding lf's
+ if ( skipped_cr ) {
+ result += buf[i];
+ start++;
+ } else {
+ result += QString( &buf[start], i-start );
+ start = i+1;
+ skipped_cr = TRUE;
+ }
+ } else {
+ if ( skipped_cr ) {
+ if ( buf[i] != '\n' ) {
+ // Should not have skipped it
+ result += '\n';
+ }
+ skipped_cr = FALSE;
+ }
+ }
+ }
+ if ( start < num )
+ result += QString( &buf[start], i-start );
+ if ( num != bufsize ) // if ( EOF )
+ break;
+ }
+ return result;
+}
+
+
+
+/*****************************************************************************
+ QTextStream write functions
+ *****************************************************************************/
+
+/*!
+ Writes character \c char to the stream and returns a reference to
+ the stream.
+
+ The character \a c is assumed to be Latin1 encoded independent of
+ the Encoding set for the QTextStream.
+*/
+QTextStream &QTextStream::operator<<( QChar c )
+{
+ CHECK_STREAM_PRECOND
+ ts_putc( c );
+ return *this;
+}
+
+/*!
+ \overload
+
+ Writes character \a c to the stream and returns a reference to the
+ stream.
+*/
+QTextStream &QTextStream::operator<<( char c )
+{
+ CHECK_STREAM_PRECOND
+ unsigned char uc = (unsigned char) c;
+ ts_putc( uc );
+ return *this;
+}
+
+QTextStream &QTextStream::output_int( int format, ulong n, bool neg )
+{
+ static const char hexdigits_lower[] = "0123456789abcdef";
+ static const char hexdigits_upper[] = "0123456789ABCDEF";
+ CHECK_STREAM_PRECOND
+ char buf[76];
+ register char *p;
+ int len;
+ const char *hexdigits;
+
+ switch ( flags() & I_BASE_MASK ) {
+
+ case I_BASE_2: // output binary number
+ switch ( format & I_TYPE_MASK ) {
+ case I_SHORT: len=16; break;
+ case I_INT: len=sizeof(int)*8; break;
+ case I_LONG: len=32; break;
+ default: len = 0;
+ }
+ p = &buf[74]; // go reverse order
+ *p = '\0';
+ while ( len-- ) {
+ *--p = (char)(n&1) + '0';
+ n >>= 1;
+ if ( !n )
+ break;
+ }
+ if ( flags() & showbase ) { // show base
+ *--p = (flags() & uppercase) ? 'B' : 'b';
+ *--p = '0';
+ }
+ break;
+
+ case I_BASE_8: // output octal number
+ p = &buf[74];
+ *p = '\0';
+ do {
+ *--p = (char)(n&7) + '0';
+ n >>= 3;
+ } while ( n );
+ if ( flags() & showbase )
+ *--p = '0';
+ break;
+
+ case I_BASE_16: // output hexadecimal number
+ p = &buf[74];
+ *p = '\0';
+ hexdigits = (flags() & uppercase) ?
+ hexdigits_upper : hexdigits_lower;
+ do {
+ *--p = hexdigits[(int)n&0xf];
+ n >>= 4;
+ } while ( n );
+ if ( flags() & showbase ) {
+ *--p = (flags() & uppercase) ? 'X' : 'x';
+ *--p = '0';
+ }
+ break;
+
+ default: // decimal base is default
+ p = &buf[74];
+ *p = '\0';
+ if ( neg )
+ n = (ulong)(-(long)n);
+ do {
+ *--p = ((int)(n%10)) + '0';
+ n /= 10;
+ } while ( n );
+ if ( neg )
+ *--p = '-';
+ else if ( flags() & showpos )
+ *--p = '+';
+ if ( (flags() & internal) && fwidth && !ts_isdigit(*p) ) {
+ ts_putc( *p ); // special case for internal
+ ++p; // padding
+ fwidth--;
+ return *this << (const char*)p;
+ }
+ }
+ if ( fwidth ) { // adjustment required
+ if ( !(flags() & left) ) { // but NOT left adjustment
+ len = qstrlen(p);
+ int padlen = fwidth - len;
+ if ( padlen <= 0 ) { // no padding required
+ writeBlock( p, len );
+ } else if ( padlen < (int)(p-buf) ) { // speeds up padding
+ memset( p-padlen, (char)fillchar, padlen );
+ writeBlock( p-padlen, padlen+len );
+ }
+ else // standard padding
+ *this << (const char*)p;
+ }
+ else
+ *this << (const char*)p;
+ fwidth = 0; // reset field width
+ }
+ else
+ writeBlock( p, qstrlen(p) );
+ return *this;
+}
+
+
+/*!
+ \overload
+
+ Writes a \c short integer \a i to the stream and returns a
+ reference to the stream.
+*/
+
+QTextStream &QTextStream::operator<<( signed short i )
+{
+ return output_int( I_SHORT | I_SIGNED, i, i < 0 );
+}
+
+
+/*!
+ \overload
+
+ Writes an \c unsigned \c short integer \a i to the stream and
+ returns a reference to the stream.
+*/
+
+QTextStream &QTextStream::operator<<( unsigned short i )
+{
+ return output_int( I_SHORT | I_UNSIGNED, i, FALSE );
+}
+
+
+/*!
+ \overload
+
+ Writes an \c int \a i to the stream and returns a reference to the
+ stream.
+*/
+
+QTextStream &QTextStream::operator<<( signed int i )
+{
+ return output_int( I_INT | I_SIGNED, i, i < 0 );
+}
+
+
+/*!
+ \overload
+
+ Writes an \c unsigned \c int \a i to the stream and returns a
+ reference to the stream.
+*/
+
+QTextStream &QTextStream::operator<<( unsigned int i )
+{
+ return output_int( I_INT | I_UNSIGNED, i, FALSE );
+}
+
+
+/*!
+ \overload
+
+ Writes a \c long \c int \a i to the stream and returns a reference
+ to the stream.
+*/
+
+QTextStream &QTextStream::operator<<( signed long i )
+{
+ return output_int( I_LONG | I_SIGNED, i, i < 0 );
+}
+
+
+/*!
+ \overload
+
+ Writes an \c unsigned \c long \c int \a i to the stream and
+ returns a reference to the stream.
+*/
+
+QTextStream &QTextStream::operator<<( unsigned long i )
+{
+ return output_int( I_LONG | I_UNSIGNED, i, FALSE );
+}
+
+
+/*!
+ \overload
+
+ Writes a \c float \a f to the stream and returns a reference to
+ the stream.
+*/
+
+QTextStream &QTextStream::operator<<( float f )
+{
+ return *this << (double)f;
+}
+
+/*!
+ \overload
+
+ Writes a \c double \a f to the stream and returns a reference to
+ the stream.
+*/
+
+QTextStream &QTextStream::operator<<( double f )
+{
+ CHECK_STREAM_PRECOND
+ char f_char;
+ char format[16];
+ if ( (flags()&floatfield) == fixed )
+ f_char = 'f';
+ else if ( (flags()&floatfield) == scientific )
+ f_char = (flags() & uppercase) ? 'E' : 'e';
+ else
+ f_char = (flags() & uppercase) ? 'G' : 'g';
+ register char *fs = format; // generate format string
+ *fs++ = '%'; // "%.<prec>l<f_char>"
+ *fs++ = '.';
+ int prec = precision();
+ if ( prec > 99 )
+ prec = 99;
+ if ( prec >= 10 ) {
+ *fs++ = prec / 10 + '0';
+ *fs++ = prec % 10 + '0';
+ } else {
+ *fs++ = prec + '0';
+ }
+ *fs++ = 'l';
+ *fs++ = f_char;
+ *fs = '\0';
+ QString num;
+ num.sprintf(format, f); // convert to text
+ if ( fwidth ) // padding
+ *this << num.latin1();
+ else // just write it
+ writeBlock(num.latin1(), num.length());
+ return *this;
+}
+
+
+/*!
+ \overload
+
+ Writes a string to the stream and returns a reference to the
+ stream.
+
+ The string \a s is assumed to be Latin1 encoded independent of the
+ Encoding set for the QTextStream.
+*/
+
+QTextStream &QTextStream::operator<<( const char* s )
+{
+ CHECK_STREAM_PRECOND
+ char padbuf[48];
+ uint len = qstrlen( s ); // don't write null terminator
+ if ( fwidth ) { // field width set
+ int padlen = fwidth - len;
+ fwidth = 0; // reset width
+ if ( padlen > 0 ) {
+ char *ppad;
+ if ( padlen > 46 ) { // create extra big fill buffer
+ ppad = new char[padlen];
+ Q_CHECK_PTR( ppad );
+ } else {
+ ppad = padbuf;
+ }
+ memset( ppad, (char)fillchar, padlen ); // fill with fillchar
+ if ( !(flags() & left) ) {
+ writeBlock( ppad, padlen );
+ padlen = 0;
+ }
+ writeBlock( s, len );
+ if ( padlen )
+ writeBlock( ppad, padlen );
+ if ( ppad != padbuf ) // delete extra big fill buf
+ delete[] ppad;
+ return *this;
+ }
+ }
+ writeBlock( s, len );
+ return *this;
+}
+
+/*!
+ \overload
+
+ Writes \a s to the stream and returns a reference to the stream.
+
+ The string \a s is assumed to be Latin1 encoded independent of the
+ Encoding set for the QTextStream.
+*/
+
+QTextStream &QTextStream::operator<<( const QCString & s )
+{
+ return operator<<(s.data());
+}
+
+/*!
+ \overload
+
+ Writes \a s to the stream and returns a reference to the stream.
+*/
+
+QTextStream &QTextStream::operator<<( const QString& s )
+{
+ if ( !mapper && latin1 )
+ return operator<<(s.latin1());
+ CHECK_STREAM_PRECOND
+ QString s1 = s;
+ if ( fwidth ) { // field width set
+ if ( !(flags() & left) ) {
+ s1 = s.rightJustify(fwidth, (char)fillchar);
+ } else {
+ s1 = s.leftJustify(fwidth, (char)fillchar);
+ }
+ fwidth = 0; // reset width
+ }
+ writeBlock( s1.unicode(), s1.length() );
+ return *this;
+}
+
+
+/*!
+ \overload
+
+ Writes a pointer to the stream and returns a reference to the
+ stream.
+
+ The \a ptr is output as an unsigned long hexadecimal integer.
+*/
+
+QTextStream &QTextStream::operator<<( void *ptr )
+{
+ int f = flags();
+ setf( hex, basefield );
+ setf( showbase );
+ unsetf( uppercase );
+ output_int( I_LONG | I_UNSIGNED, (ulong)ptr, FALSE );
+ flags( f );
+ return *this;
+}
+
+
+/*!
+ \fn int QTextStream::flags() const
+
+ Returns the current stream flags. The default value is 0.
+
+ \table
+ \header \i Flag \i Meaning
+ \row \i \c skipws \i Not currently used; whitespace always skipped
+ \row \i \c left \i Numeric fields are left-aligned
+ \row \i \c right
+ \i Not currently used (by default, numerics are right-aligned)
+ \row \i \c internal \i Puts any padding spaces between +/- and value
+ \row \i \c bin \i Output \e and input only in binary
+ \row \i \c oct \i Output \e and input only in octal
+ \row \i \c dec \i Output \e and input only in decimal
+ \row \i \c hex \i Output \e and input only in hexadecimal
+ \row \i \c showbase
+ \i Annotates numeric outputs with 0b, 0, or 0x if in \c bin,
+ \c oct, or \c hex format
+ \row \i \c showpoint \i Not currently used
+ \row \i \c uppercase \i Uses 0B and 0X rather than 0b and 0x
+ \row \i \c showpos \i Shows + for positive numeric values
+ \row \i \c scientific \i Uses scientific notation for floating point values
+ \row \i \c fixed \i Uses fixed-point notation for floating point values
+ \endtable
+
+ Note that unless \c bin, \c oct, \c dec, or \c hex is set, the
+ input base is octal if the value starts with 0, hexadecimal if it
+ starts with 0x, binary if it starts with 0b, and decimal
+ otherwise.
+
+ \sa setf(), unsetf()
+*/
+
+/*!
+ \fn int QTextStream::flags( int f )
+
+ \overload
+
+ Sets the stream flags to \a f. Returns the previous stream flags.
+
+ \sa setf(), unsetf(), flags()
+*/
+
+/*!
+ \fn int QTextStream::setf( int bits )
+
+ Sets the stream flag bits \a bits. Returns the previous stream
+ flags.
+
+ Equivalent to \c{flags( flags() | bits )}.
+
+ \sa setf(), unsetf()
+*/
+
+/*!
+ \fn int QTextStream::setf( int bits, int mask )
+
+ \overload
+
+ Sets the stream flag bits \a bits with a bit mask \a mask. Returns
+ the previous stream flags.
+
+ Equivalent to \c{flags( (flags() & ~mask) | (bits & mask) )}.
+
+ \sa setf(), unsetf()
+*/
+
+/*!
+ \fn int QTextStream::unsetf( int bits )
+
+ Clears the stream flag bits \a bits. Returns the previous stream
+ flags.
+
+ Equivalent to \c{flags( flags() & ~mask )}.
+
+ \sa setf()
+*/
+
+/*!
+ \fn int QTextStream::width() const
+
+ Returns the field width. The default value is 0.
+*/
+
+/*!
+ \fn int QTextStream::width( int w )
+
+ \overload
+
+ Sets the field width to \a w. Returns the previous field width.
+*/
+
+/*!
+ \fn int QTextStream::fill() const
+
+ Returns the fill character. The default value is ' ' (space).
+*/
+
+/*!
+ \overload int QTextStream::fill( int f )
+
+ Sets the fill character to \a f. Returns the previous fill character.
+*/
+
+/*!
+ \fn int QTextStream::precision() const
+
+ Returns the precision. The default value is 6.
+*/
+
+/*!
+ \fn int QTextStream::precision( int p )
+
+ \overload
+
+ Sets the precision to \a p. Returns the previous precision setting.
+*/
+
+
+ /*****************************************************************************
+ QTextStream manipulators
+ *****************************************************************************/
+
+QTextStream &bin( QTextStream &s )
+{
+ s.setf(QTS::bin,QTS::basefield);
+ return s;
+}
+
+QTextStream &oct( QTextStream &s )
+{
+ s.setf(QTS::oct,QTS::basefield);
+ return s;
+}
+
+QTextStream &dec( QTextStream &s )
+{
+ s.setf(QTS::dec,QTS::basefield);
+ return s;
+}
+
+QTextStream &hex( QTextStream &s )
+{
+ s.setf(QTS::hex,QTS::basefield);
+ return s;
+}
+
+QTextStream &endl( QTextStream &s )
+{
+ return s << '\n';
+}
+
+QTextStream &flush( QTextStream &s )
+{
+ if ( s.device() )
+ s.device()->flush();
+ return s;
+}
+
+QTextStream &ws( QTextStream &s )
+{
+ s.skipWhiteSpace();
+ return s;
+}
+
+QTextStream &reset( QTextStream &s )
+{
+ s.reset();
+ return s;
+}
+
+
+/*!
+ \class QTextIStream qtextstream.h
+ \reentrant
+ \brief The QTextIStream class is a convenience class for input streams.
+
+ \ingroup io
+ \ingroup text
+
+ This class provides a shorthand for creating simple input
+ \l{QTextStream}s without having to pass a \e mode argument to the
+ constructor.
+
+ This class makes it easy, for example, to write things like this:
+ \code
+ QString data = "123 456";
+ int a, b;
+ QTextIStream(&data) >> a >> b;
+ \endcode
+
+ \sa QTextOStream
+*/
+
+/*!
+ \fn QTextIStream::QTextIStream( const QString *s )
+
+ Constructs a stream to read from the string \a s.
+*/
+/*!
+ \fn QTextIStream::QTextIStream( QByteArray ba )
+
+ Constructs a stream to read from the array \a ba.
+*/
+/*!
+ \fn QTextIStream::QTextIStream( FILE *f )
+
+ Constructs a stream to read from the file \a f.
+*/
+
+
+/*!
+ \class QTextOStream
+ \reentrant
+ \brief The QTextOStream class is a convenience class for output streams.
+
+ \ingroup io
+ \ingroup text
+
+ This class provides a shorthand for creating simple output
+ \l{QTextStream}s without having to pass a \e mode argument to the
+ constructor.
+
+ This makes it easy for example, to write things like this:
+ \code
+ QString result;
+ QTextOStream(&result) << "pi = " << 3.14;
+ \endcode
+*/
+
+/*!
+ \fn QTextOStream::QTextOStream( QString *s )
+
+ Constructs a stream to write to string \a s.
+*/
+/*!
+ \fn QTextOStream::QTextOStream( QByteArray ba )
+
+ Constructs a stream to write to the array \a ba.
+*/
+/*!
+ \fn QTextOStream::QTextOStream( FILE *f )
+
+ Constructs a stream to write to the file \a f.
+*/
+
+
+
+/*!
+ Sets the encoding of this stream to \a e, where \a e is one of the
+ following values:
+ \table
+ \header \i Encoding \i Meaning
+ \row \i Locale
+ \i Uses local file format (Latin1 if locale is not set), but
+ autodetecting Unicode(utf16) on input.
+ \row \i Unicode
+ \i Uses Unicode(utf16) for input and output. Output will be
+ written in the order most efficient for the current platform
+ (i.e. the order used internally in QString).
+ \row \i UnicodeUTF8
+ \i Using Unicode(utf8) for input and output. If you use it for
+ input it will autodetect utf16 and use it instead of utf8.
+ \row \i Latin1
+ \i ISO-8859-1. Will not autodetect utf16.
+ \row \i UnicodeNetworkOrder
+ \i Uses network order Unicode(utf16) for input and output.
+ Useful when reading Unicode data that does not start with the
+ byte order marker.
+ \row \i UnicodeReverse
+ \i Uses reverse network order Unicode(utf16) for input and
+ output. Useful when reading Unicode data that does not start
+ with the byte order marker or when writing data that should be
+ read by buggy Windows applications.
+ \row \i RawUnicode
+ \i Like Unicode, but does not write the byte order marker nor
+ does it auto-detect the byte order. Useful only when writing to
+ non-persistent storage used by a single process.
+ \endtable
+
+ \c Locale and all Unicode encodings, except \c RawUnicode, will look
+ at the first two bytes in an input stream to determine the byte
+ order. The initial byte order marker will be stripped off before
+ data is read.
+
+ Note that this function should be called before any data is read to
+ or written from the stream.
+
+ \sa setCodec()
+*/
+
+void QTextStream::setEncoding( Encoding e )
+{
+ if ( d->sourceType == QTextStreamPrivate::String )
+ return;
+
+ switch ( e ) {
+ case Unicode:
+ mapper = 0;
+ latin1 = FALSE;
+ doUnicodeHeader = TRUE;
+ internalOrder = TRUE;
+ networkOrder = QChar::networkOrdered();
+ break;
+ case UnicodeUTF8:
+#ifndef QT_NO_TEXTCODEC
+ mapper = QTextCodec::codecForMib( 106 );
+ latin1 = FALSE;
+ doUnicodeHeader = TRUE;
+ internalOrder = TRUE;
+ networkOrder = QChar::networkOrdered();
+#else
+ mapper = 0;
+ latin1 = TRUE;
+ doUnicodeHeader = TRUE;
+#endif
+ break;
+ case UnicodeNetworkOrder:
+ mapper = 0;
+ latin1 = FALSE;
+ doUnicodeHeader = TRUE;
+ internalOrder = QChar::networkOrdered();
+ networkOrder = TRUE;
+ break;
+ case UnicodeReverse:
+ mapper = 0;
+ latin1 = FALSE;
+ doUnicodeHeader = TRUE;
+ internalOrder = !QChar::networkOrdered();
+ networkOrder = FALSE;
+ break;
+ case RawUnicode:
+ mapper = 0;
+ latin1 = FALSE;
+ doUnicodeHeader = FALSE;
+ internalOrder = TRUE;
+ networkOrder = QChar::networkOrdered();
+ break;
+ case Locale:
+ latin1 = TRUE; // fallback to Latin-1
+#ifndef QT_NO_TEXTCODEC
+ mapper = QTextCodec::codecForLocale();
+ // optimized Latin-1 processing
+#if defined(Q_OS_WIN32)
+ if ( GetACP() == 1252 )
+ mapper = 0;
+#endif
+ if ( mapper && mapper->mibEnum() == 4 )
+#endif
+ mapper = 0;
+
+ doUnicodeHeader = TRUE; // If it reads as Unicode, accept it
+ break;
+ case Latin1:
+ mapper = 0;
+ doUnicodeHeader = FALSE;
+ latin1 = TRUE;
+ break;
+ }
+}
+
+
+#ifndef QT_NO_TEXTCODEC
+/*!
+ Sets the codec for this stream to \a codec. Will not try to
+ autodetect Unicode.
+
+ Note that this function should be called before any data is read
+ to/written from the stream.
+
+ \sa setEncoding(), codec()
+*/
+
+void QTextStream::setCodec( QTextCodec *codec )
+{
+ if ( d->sourceType == QTextStreamPrivate::String )
+ return; // QString does not need any codec
+ mapper = codec;
+ latin1 = ( codec->mibEnum() == 4 );
+ if ( latin1 )
+ mapper = 0;
+ doUnicodeHeader = FALSE;
+}
+
+/*!
+ Returns the codec actually used for this stream.
+
+ If Unicode is automatically detected in input, a codec with \link
+ QTextCodec::name() name() \endlink "ISO-10646-UCS-2" is returned.
+
+ \sa setCodec()
+*/
+
+QTextCodec *QTextStream::codec()
+{
+ if ( mapper ) {
+ return mapper;
+ } else {
+ // 4 is "ISO 8859-1", 1000 is "ISO-10646-UCS-2"
+ return QTextCodec::codecForMib( latin1 ? 4 : 1000 );
+ }
+}
+
+#endif
+
+#endif // QT_NO_TEXTSTREAM