1 /****************************************************************************

     2 ** 

     3 **

     4 ** Implementation of QTextStream class

     5 **

     6 ** Created : 940922

     7 **

     8 ** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.

     9 **

    10 ** This file is part of the tools module of the Qt GUI Toolkit.

    11 **

    12 ** This file may be distributed under the terms of the Q Public License

    13 ** as defined by Trolltech AS of Norway and appearing in the file

    14 ** LICENSE.QPL included in the packaging of this file.

    15 **

    16 ** This file may be distributed and/or modified under the terms of the

    17 ** GNU General Public License version 2 as published by the Free Software

    18 ** Foundation and appearing in the file LICENSE.GPL included in the

    19 ** packaging of this file.

    20 **

    21 ** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition

    22 ** licenses may use this file in accordance with the Qt Commercial License

    23 ** Agreement provided with the Software.

    24 **

    25 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE

    26 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

    27 **

    28 ** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for

    29 **   information about Qt Commercial License Agreements.

    30 ** See http://www.trolltech.com/qpl/ for QPL licensing information.

    31 ** See http://www.trolltech.com/gpl/ for GPL licensing information.

    32 **

    33 ** Contact info@trolltech.com if any conditions of this licensing are

    34 ** not clear to you.

    35 **

    36 **********************************************************************/

    37 

    38 #include "qtextstream.h"

    39 

    40 #ifndef QT_NO_TEXTSTREAM

    41 #include "qtextcodec.h"

    42 #include "qregexp.h"

    43 #include "qbuffer.h"

    44 #include "qfile.h"

    45 #include <stdio.h>

    46 #include <ctype.h>

    47 #include <stdlib.h>

    48 

    49 #if defined(_OS_WIN32_)

    50 #include <windows.h>

    51 #endif

    52 

    53 // NOT REVISED

    54 /*!

    55   \class QTextStream qtextstream.h

    56 

    57   \brief The QTextStream class provides basic functions for reading and

    58   writing text using a QIODevice.

    59 

    60   \ingroup io

    61 

    62   \define endl

    63   \define bin

    64   \define oct

    65   \define dec

    66   \define hex

    67   \define flush

    68   \define ws

    69 

    70   The text stream class has a functional interface that is very

    71   similar to that of the standard C++ iostream class.  The difference

    72   between iostream and QTextStream is that our stream operates on a

    73   QIODevice, which is easily subclassed, while iostream operates on

    74   FILE * pointers, which can not be subclassed.

    75 

    76   Qt provides several global functions similar to the ones in iostream:

    77   <ul>

    78   <li> \c bin sets the QTextStream to read/write binary numbers

    79   <li> \c oct sets the QTextStream to read/write octal numbers

    80   <li> \c dec sets the QTextStream to read/write decimal numbers

    81   <li> \c hex sets the QTextStream to read/write hexadecimal numbers

    82   <li> \c endl forces a line break

    83   <li> \c flush forces the QIODevice to flush any buffered data

    84   <li> \c ws eats any available white space (on input)

    85   <li> \c reset resets the QTextStream to its default mode (see reset()).

    86   </ul>

    87 

    88   \warning By default, QTextStream will automatically detect whether

    89   integers in the stream are in decimal, octal, hexadecimal or binary

    90   format when reading from the stream. In particular, a leading '0'

    91   signifies octal, ie. the sequence "0100" will be interpreted as

    92   64.

    93 

    94   The QTextStream class reads and writes text and it is not

    95   appropriate for dealing with binary data (but QDataStream is).

    96 

    97   By default output of Unicode text (ie. QString) is done using the

    98   local 8-bit encoding.  This can be changed using the setEncoding()

    99   method.  For input, the QTextStream will auto-detect standard

   100   Unicode "byte order marked" text files, but otherwise the local

   101   8-bit encoding is used.

   102 

   103   \sa QDataStream

   104 */

   105 

   106 /*

   107   \class QTSManip qtextstream.h

   108 

   109   \brief The QTSManip class is an internal helper class for the

   110   QTextStream.

   111 

   112   It is generally a very bad idea to use this class directly in

   113   application programs.

   114 

   115   \internal

   116 

   117   This class makes it possible to give the QTextStream function objects

   118   with arguments, like this:

   119   \code

   120     QTextStream cout( stdout, IO_WriteOnly );

   121     cout << setprecision( 8 );		// QTSManip used here!

   122     cout << 3.14159265358979323846;

   123   \endcode

   124 

   125   The setprecision() function returns a QTSManip object.

   126   The QTSManip object contains a pointer to a member function in

   127   QTextStream and an integer argument.

   128   When serializing a QTSManip into a QTextStream, the function

   129   is executed with the argument.

   130 */

   131 

   132 /*! \fn QTSManip::QTSManip (QTSMFI m, int a)

   133 

   134   Constructs a QTSManip object which will call \a m (a member function

   135   in QTextStream which accepts a single int) with argument \a a when

   136   QTSManip::exec() is called.  Used internally in e.g. endl:

   137 

   138   \code

   139     s << "some text" << endl << "more text";

   140   \endcode

   141 */

   142 

   143 /*! \fn void QTSManip::exec (QTextStream& s)

   144 

   145   Calls the member function specified in the constructor, for object

   146   \a s.  Used internally in e.g. endl:

   147 

   148   \code

   149     s << "some text" << endl << "more text";

   150   \endcode

   151 */

   152 

   153 

   154 /*****************************************************************************

   155   QTextStream member functions

   156  *****************************************************************************/

   157 

   158 #if defined(CHECK_STATE)

   159 #undef  CHECK_STREAM_PRECOND

   160 #define CHECK_STREAM_PRECOND  if ( !dev ) {				\

   161 				qWarning( "QTextStream: No device" );	\

   162 				return *this; }

   163 #else

   164 #define CHECK_STREAM_PRECOND

   165 #endif

   166 

   167 

   168 #define I_SHORT		0x0010

   169 #define I_INT		0x0020

   170 #define I_LONG		0x0030

   171 #define I_TYPE_MASK	0x00f0

   172 

   173 #define I_BASE_2	QTS::bin

   174 #define I_BASE_8	QTS::oct

   175 #define I_BASE_10	QTS::dec

   176 #define I_BASE_16	QTS::hex

   177 #define I_BASE_MASK	(QTS::bin | QTS::oct | QTS::dec | QTS::hex)

   178 

   179 #define I_SIGNED	0x0100

   180 #define I_UNSIGNED	0x0200

   181 #define I_SIGN_MASK	0x0f00

   182 

   183 

   184 static const QChar QEOF = QChar((ushort)0xffff); //guaranteed not to be a character.

   185 

   186 const int QTextStream::basefield   = I_BASE_MASK;

   187 const int QTextStream::adjustfield = ( QTextStream::left |

   188 				       QTextStream::right |

   189 				       QTextStream::internal );

   190 const int QTextStream::floatfield  = ( QTextStream::scientific |

   191 				       QTextStream::fixed );

   192 

   193 

   194 class QTextStreamPrivate {

   195 public:

   196 #ifndef QT_NO_TEXTCODEC

   197     QTextStreamPrivate() : decoder( 0 ), sourceType( NotSet ) {}

   198     ~QTextStreamPrivate() { delete decoder; }

   199     QTextDecoder *decoder;		//???

   200 #else

   201     QTextStreamPrivate() : sourceType( NotSet ) {}

   202     ~QTextStreamPrivate() { }

   203 #endif

   204     QString ungetcBuf;

   205 

   206     enum SourceType { NotSet, IODevice, String, ByteArray, File };

   207     SourceType sourceType;

   208 };

   209 

   210 

   211 // skips whitespace and returns the first non-whitespace character

   212 QChar QTextStream::eat_ws()

   213 {

   214     QChar c;

   215     do { c = ts_getc(); } while ( c != QEOF && ts_isspace(c) );

   216     return c;

   217 }

   218 

   219 void QTextStream::init()

   220 {

   221     // ### ungetcBuf = QEOF;

   222     dev = 0;					// no device set

   223     fstrm = owndev = FALSE;

   224     mapper = 0;

   225     d = new QTextStreamPrivate;

   226     doUnicodeHeader = TRUE;	 //default to autodetect

   227     latin1 = TRUE;		 // ### should use local?

   228     internalOrder = QChar::networkOrdered(); //default to network order

   229 }

   230 

   231 /*!

   232   Constructs a data stream that has no IO device.

   233 */

   234 

   235 QTextStream::QTextStream()

   236 {

   237     init();

   238     setEncoding( Locale ); //###

   239     reset();

   240     d->sourceType = QTextStreamPrivate::NotSet;

   241 }

   242 

   243 /*!

   244   Constructs a text stream that uses the IO device \a iod.

   245 */

   246 

   247 QTextStream::QTextStream( QIODevice *iod )

   248 {

   249     init();

   250     setEncoding( Locale ); //###

   251     dev = iod;					// set device

   252     reset();

   253     d->sourceType = QTextStreamPrivate::IODevice;

   254 }

   255 

   256 // TODO: use special-case handling of this case in QTextStream, and

   257 //	 simplify this class to only deal with QChar or QString data.

   258 class QStringBuffer : public QIODevice {

   259 public:

   260     QStringBuffer( QString* str );

   261     ~QStringBuffer();

   262     bool  open( int m );

   263     void  close();

   264     void  flush();

   265     uint  size() const;

   266     int   at()   const;

   267     bool  at( int pos );

   268     int   readBlock( char *p, uint len );

   269     int writeBlock( const char *p, uint len );

   270     int   getch();

   271     int   putch( int ch );

   272     int   ungetch( int ch );

   273 protected:

   274     QString* s;

   275 

   276 private:        // Disabled copy constructor and operator=

   277     QStringBuffer( const QStringBuffer & );

   278     QStringBuffer &operator=( const QStringBuffer & );

   279 };

   280 

   281 

   282 QStringBuffer::QStringBuffer( QString* str )

   283 {

   284     s = str;

   285 }

   286 

   287 QStringBuffer::~QStringBuffer()

   288 {

   289 }

   290 

   291 

   292 bool QStringBuffer::open( int m )

   293 {

   294     if ( !s ) {

   295 #if defined(CHECK_STATE)

   296 	qWarning( "QStringBuffer::open: No string" );

   297 #endif

   298 	return FALSE;

   299     }

   300     if ( isOpen() ) {                           // buffer already open

   301 #if defined(CHECK_STATE)

   302 	qWarning( "QStringBuffer::open: Buffer already open" );

   303 #endif

   304 	return FALSE;

   305     }

   306     setMode( m );

   307     if ( m & IO_Truncate ) {                    // truncate buffer

   308 	s->truncate( 0 );

   309     }

   310     if ( m & IO_Append ) {                      // append to end of buffer

   311 	ioIndex = s->length()*sizeof(QChar);

   312     } else {

   313 	ioIndex = 0;

   314     }

   315     setState( IO_Open );

   316     setStatus( 0 );

   317     return TRUE;

   318 }

   319 

   320 void QStringBuffer::close()

   321 {

   322     if ( isOpen() ) {

   323 	setFlags( IO_Direct );

   324 	ioIndex = 0;

   325     }

   326 }

   327 

   328 void QStringBuffer::flush()

   329 {

   330 }

   331 

   332 uint QStringBuffer::size() const

   333 {

   334     return s ? s->length()*sizeof(QChar) : 0;

   335 }

   336 

   337 int  QStringBuffer::at()   const

   338 {

   339     return ioIndex;

   340 }

   341 

   342 bool QStringBuffer::at( int pos )

   343 {

   344 #if defined(CHECK_STATE)

   345     if ( !isOpen() ) {

   346 	qWarning( "QStringBuffer::at: Buffer is not open" );

   347 	return FALSE;

   348     }

   349 #endif

   350     if ( (uint)pos >= s->length()*2 ) {

   351 #if defined(CHECK_RANGE)

   352 	qWarning( "QStringBuffer::at: Index %d out of range", pos );

   353 #endif

   354 	return FALSE;

   355     }

   356     ioIndex = pos;

   357     return TRUE;

   358 }

   359 

   360 

   361 int  QStringBuffer::readBlock( char *p, uint len )

   362 {

   363 #if defined(CHECK_STATE)

   364     CHECK_PTR( p );

   365     if ( !isOpen() ) {                          // buffer not open

   366 	qWarning( "QStringBuffer::readBlock: Buffer not open" );

   367 	return -1;

   368     }

   369     if ( !isReadable() ) {                      // reading not permitted

   370 	qWarning( "QStringBuffer::readBlock: Read operation not permitted" );

   371 	return -1;

   372     }

   373 #endif

   374     if ( (uint)ioIndex + len > s->length()*sizeof(QChar) ) {

   375 	// overflow

   376 	if ( (uint)ioIndex >= s->length()*sizeof(QChar) ) {

   377 	    setStatus( IO_ReadError );

   378 	    return -1;

   379 	} else {

   380 	    len = s->length()*2 - (uint)ioIndex;

   381 	}

   382     }

   383     memcpy( p, ((const char*)(s->unicode()))+ioIndex, len );

   384     ioIndex += len;

   385     return len;

   386 }

   387 

   388 int QStringBuffer::writeBlock( const char *p, uint len )

   389 {

   390 #if defined(CHECK_NULL)

   391     if ( p == 0 && len != 0 )

   392 	qWarning( "QStringBuffer::writeBlock: Null pointer error" );

   393 #endif

   394 #if defined(CHECK_STATE)

   395     if ( !isOpen() ) {                          // buffer not open

   396 	qWarning( "QStringBuffer::writeBlock: Buffer not open" );

   397 	return -1;

   398     }

   399     if ( !isWritable() ) {                      // writing not permitted

   400 	qWarning( "QStringBuffer::writeBlock: Write operation not permitted" );

   401 	return -1;

   402     }

   403     if ( ioIndex&1 ) {

   404 	qWarning( "QStringBuffer::writeBlock: non-even index - non Unicode" );

   405 	return -1;

   406     }

   407     if ( len&1 ) {

   408 	qWarning( "QStringBuffer::writeBlock: non-even length - non Unicode" );

   409 	return -1;

   410     }

   411 #endif

   412     s->replace(ioIndex/2, len/2, (QChar*)p, len/2);

   413     ioIndex += len;

   414     return len;

   415 }

   416 

   417 int QStringBuffer::getch()

   418 {

   419 #if defined(CHECK_STATE)

   420     if ( !isOpen() ) {                          // buffer not open

   421 	qWarning( "QStringBuffer::getch: Buffer not open" );

   422 	return -1;

   423     }

   424     if ( !isReadable() ) {                      // reading not permitted

   425 	qWarning( "QStringBuffer::getch: Read operation not permitted" );

   426 	return -1;

   427     }

   428 #endif

   429     if ( (uint)ioIndex >= s->length()*2 ) {           // overflow

   430 	setStatus( IO_ReadError );

   431 	return -1;

   432     }

   433     return *((char*)s->unicode() + ioIndex++);

   434 }

   435 

   436 int QStringBuffer::putch( int ch )

   437 {

   438     char c = ch;

   439     if ( writeBlock(&c,1) < 0 )

   440 	return -1;

   441     else

   442 	return ch;

   443 }

   444 

   445 int QStringBuffer::ungetch( int ch )

   446 {

   447 #if defined(CHECK_STATE)

   448     if ( !isOpen() ) {                          // buffer not open

   449 	qWarning( "QStringBuffer::ungetch: Buffer not open" );

   450 	return -1;

   451     }

   452     if ( !isReadable() ) {                      // reading not permitted

   453 	qWarning( "QStringBuffer::ungetch: Read operation not permitted" );

   454 	return -1;

   455     }

   456 #endif

   457     if ( ch != -1 ) { // something to do with eof

   458 	if ( ioIndex )

   459 	    ioIndex--;

   460 	else

   461 	    ch = -1;

   462     }

   463     return ch;

   464 }

   465 

   466 

   467 /*!

   468   Constructs a text stream that operates on a Unicode QString through an

   469   internal device.

   470 

   471   If you set an encoding or codec with setEncoding() or setCodec(), this

   472   setting is ignored for text streams that operate on QString.

   473 

   474   Example:

   475   \code

   476     QString str;

   477     QTextStream ts( &str, IO_WriteOnly );

   478     ts << "pi = " << 3.14;			// str == "pi = 3.14"

   479   \endcode

   480 

   481   Writing data to the text stream will modify the contents of the string.

   482   The string will be expanded when data is written beyond the end of the

   483   string. Note that the string will not be truncated:

   484   \code

   485     QString str = "pi = 3.14";

   486     QTextStream ts( &str, IO_WriteOnly );

   487     ts <<  "2+2 = " << 2+2; 		// str == "2+2 = 414"

   488   \endcode

   489 

   490   Note that since QString is Unicode, you should not use readRawBytes()

   491   or writeRawBytes() on such a stream.

   492 */

   493 

   494 QTextStream::QTextStream( QString* str, int filemode )

   495 {

   496     // TODO: optimize for this case as it becomes more common

   497     //        (see QStringBuffer above)

   498     init();

   499     dev = new QStringBuffer( str );

   500     ((QStringBuffer *)dev)->open( filemode );

   501     owndev = TRUE;

   502     setEncoding(RawUnicode);

   503     reset();

   504     d->sourceType = QTextStreamPrivate::String;

   505 }

   506 

   507 /*! \obsolete

   508 

   509   This constructor is equivalent to the constructor taking a QString*

   510   parameter.

   511 */

   512 

   513 QTextStream::QTextStream( QString& str, int filemode )

   514 {

   515     init();

   516     dev = new QStringBuffer( &str );

   517     ((QStringBuffer *)dev)->open( filemode );

   518     owndev = TRUE;

   519     setEncoding(RawUnicode);

   520     reset();

   521     d->sourceType = QTextStreamPrivate::String;

   522 }

   523 

   524 /*!

   525   Constructs a text stream that operates on a byte array through an

   526   internal QBuffer device.

   527 

   528   Example:

   529   \code

   530     QByteArray array;

   531     QTextStream ts( array, IO_WriteOnly );

   532     ts << "pi = " << 3.14 << '\0';		// array == "pi = 3.14"

   533   \endcode

   534 

   535   Writing data to the text stream will modify the contents of the array.

   536   The array will be expanded when data is written beyond the end of the

   537   string.

   538 

   539   Same example, using a QBuffer:

   540   \code

   541     QByteArray array;

   542     QBuffer buf( array );

   543     buf.open( IO_WriteOnly );

   544     QTextStream ts( &buf );

   545     ts << "pi = " << 3.14 << '\0';		// array == "pi = 3.14"

   546     buf.close();

   547   \endcode

   548 */

   549 

   550 QTextStream::QTextStream( QByteArray a, int mode )

   551 {

   552     init();

   553     dev = new QBuffer( a );

   554     ((QBuffer *)dev)->open( mode );

   555     owndev = TRUE;

   556     setEncoding( Latin1 ); //### Locale???

   557     reset();

   558     d->sourceType = QTextStreamPrivate::ByteArray;

   559 }

   560 

   561 /*!

   562   Constructs a text stream that operates on an existing file handle \e fh

   563   through an internal QFile device.

   564 

   565   Example:

   566   \code

   567     QTextStream cout( stdout, IO_WriteOnly );

   568     QTextStream cin ( stdin,  IO_ReadOnly );

   569     QTextStream cerr( stderr, IO_WriteOnly );

   570  \endcode

   571 */

   572 

   573 QTextStream::QTextStream( FILE *fh, int mode )

   574 {

   575     init();

   576     setEncoding( Locale ); //###

   577     dev = new QFile;

   578     ((QFile *)dev)->open( mode, fh );

   579     fstrm = owndev = TRUE;

   580     reset();

   581     d->sourceType = QTextStreamPrivate::File;

   582 }

   583 

   584 /*!

   585   Destructs the text stream.

   586 

   587   The destructor does not affect the current IO device.

   588 */

   589 

   590 QTextStream::~QTextStream()

   591 {

   592     if ( owndev )

   593 	delete dev;

   594     delete d;

   595 }

   596 

   597 /*!

   598   Positions the read pointer at the first non-whitespace character.

   599 */

   600 void QTextStream::skipWhiteSpace()

   601 {

   602     ts_ungetc( eat_ws() );

   603 }

   604 

   605 

   606 /*!

   607   \fn Encoding QTextStream::encoding() const

   608 

   609   Returns the encoding mode of the stream.

   610 

   611   \sa setEncoding()

   612 */

   613 

   614 /*!

   615   Tries to read len characters from the stream and stores them in \a buf.

   616   Returns the number of characters really read.

   617   Attention: There will no QEOF appended if the read reaches the end of

   618   the file. EOF is reached when the return value does not equal \a len.

   619 */

   620 uint QTextStream::ts_getbuf( QChar* buf, uint len )

   621 {

   622     if( len<1 )

   623 	return 0;

   624 

   625     uint rnum=0;   // the number of QChars really read

   626 

   627     if ( d && d->ungetcBuf.length() ) {

   628 	while( rnum < len && rnum < d->ungetcBuf.length() ) {

   629 	    buf[rnum] = d->ungetcBuf.constref(rnum);

   630 	    rnum++;

   631 	}

   632 	d->ungetcBuf = d->ungetcBuf.mid( rnum );

   633 	if ( rnum >= len )

   634 	    return rnum;

   635     }

   636 

   637     // we use dev->ungetch() for one of the bytes of the unicode

   638     // byte-order mark, but a local unget hack for the other byte:

   639     int ungetHack = EOF;

   640 

   641     if ( doUnicodeHeader ) {

   642 	doUnicodeHeader = FALSE; //only at the top

   643 	int c1 = dev->getch();

   644 	if ( c1 == EOF )

   645 	    return rnum;

   646 	int c2 = dev->getch();

   647 	if ( c1 == 0xfe && c2 == 0xff ) {

   648 	    mapper = 0;

   649 	    latin1 = FALSE;

   650 	    internalOrder = QChar::networkOrdered();   //network order

   651 	} else if ( c1 == 0xff && c2 == 0xfe ) {

   652 	    mapper = 0;

   653 	    latin1 = FALSE;

   654 	    internalOrder = !QChar::networkOrdered();   //reverse network order

   655 	} else {

   656 	    if ( c2 != EOF ) {

   657 	 	dev->ungetch( c2 );

   658 		ungetHack = c1;

   659 	    } else {

   660 	 	dev->ungetch( c1 );

   661 		// note that a small possible bug might hide here

   662 		// here, if only the first byte of a file has made it

   663 		// so far, and that first byte is half of the

   664 		// byte-order mark, then the utfness will not be

   665 		// detected.  whether or not this is a bug depends on

   666 		// taste.  I can't really decide.

   667 	    }

   668 	}

   669     }

   670 

   671 #ifndef QT_NO_TEXTCODEC

   672     if ( mapper ) {

   673 	bool shortRead = FALSE;

   674 	if ( !d->decoder )

   675 	    d->decoder = mapper->makeDecoder();

   676 	while( rnum < len ) {

   677 	    QString s;

   678 	    bool readBlock = !( len == 1+rnum );

   679 	    while ( TRUE ) {

   680 		// for efficiency: normally read a whole block

   681 		if ( readBlock ) {

   682 		    // guess buffersize; this may be wrong (too small or too

   683 		    // big). But we can handle this (either iterate reading

   684 		    // or use ungetcBuf).

   685 		    // Note that this might cause problems for codecs where

   686 		    // one byte can result in >1 Unicode Characters if bytes

   687 		    // are written to the stream in the meantime (loss of

   688 		    // synchronicity).

   689 		    uint rlen = len - rnum;

   690 		    char *cbuf = new char[ rlen ];

   691 		    if ( ungetHack != EOF ) {

   692 			rlen = 1+dev->readBlock( cbuf+1, rlen-1 );

   693 			cbuf[0] = (char)ungetHack;

   694 			ungetHack = EOF;

   695 		    } else {

   696 			rlen = dev->readBlock( cbuf, rlen );

   697 		    }

   698 		    s  += d->decoder->toUnicode( cbuf, rlen );

   699 		    delete[] cbuf;

   700 		    // use buffered reading only for the first time, because we

   701 		    // have to get the stream synchronous again (this is easier

   702 		    // with single character reading)

   703 		    readBlock = FALSE;

   704 		}

   705 		// get stream (and codec) in sync

   706 		int c;

   707 		if ( ungetHack == EOF ) {

   708 		    c = dev->getch();

   709 		} else {

   710 		    c = ungetHack;

   711 		    ungetHack = EOF;

   712 		}

   713 		if ( c == EOF ) {

   714 		    shortRead = TRUE;

   715 		    break;

   716 		}

   717 		char b = c;

   718 		uint lengthBefore = s.length();

   719 		s  += d->decoder->toUnicode( &b, 1 );

   720 		if ( s.length() > lengthBefore )

   721 		    break; // it seems we are in sync now

   722 	    }

   723 	    uint i = 0;

   724 	    while( rnum < len && i < s.length() )

   725 		buf[rnum++] = s.constref(i++);

   726 	    if ( s.length() > i )

   727 		// could be = but append is clearer

   728 		d->ungetcBuf.append( s.mid( i ) );

   729 	    if ( shortRead )

   730 		return rnum;

   731 	}

   732     } else

   733 #endif

   734     if ( latin1 ) {

   735 	if ( len == 1+rnum ) {

   736 	    // use this method for one character because it is more efficient

   737 	    // (arnt doubts whether it makes a difference, but lets it stand)

   738 	    int c = (ungetHack == EOF) ? dev->getch() : ungetHack;

   739 	    if ( c != EOF )

   740 		buf[rnum++] = (char)c;

   741 	} else {

   742 	    if ( ungetHack != EOF ) {

   743 		buf[rnum++] = (char)ungetHack;

   744 		ungetHack = EOF;

   745 	    }

   746 	    char *cbuf = new char[len - rnum];

   747 	    while ( !dev->atEnd() && rnum < len ) {

   748 		uint rlen = len - rnum;

   749 		rlen = dev->readBlock( cbuf, rlen );

   750 		uint i = 0;

   751 		while( i < rlen )

   752 		    buf[rnum++] = cbuf[i++];

   753 	    }

   754 	    delete[] cbuf;

   755 	}

   756     } else { // UCS-2 or UTF-16

   757 	if ( len == 1+rnum ) {

   758 	    int c1 = (ungetHack == EOF) ? dev->getch() : ungetHack;

   759 	    if ( c1 == EOF )

   760 		return rnum;

   761 	    int c2 = dev->getch();

   762 	    if ( c2 == EOF )

   763 		return rnum;

   764 	    if ( isNetworkOrder() )

   765 		buf[rnum++] = QChar( c2, c1 );

   766 	    else

   767 		buf[rnum++] = QChar( c1, c2 );

   768 	} else {

   769 	    char *cbuf = new char[ 2*( len - rnum ) ]; // for paranoids: overflow possible

   770 	    while ( !dev->atEnd() && rnum < len ) {

   771 		uint rlen = 2 * ( len-rnum );

   772 		if ( ungetHack != EOF ) {

   773 		    rlen = 1+dev->readBlock( cbuf+1, rlen-1 );

   774 		    cbuf[0] = (char)ungetHack;

   775 		    ungetHack = EOF;

   776 		} else {

   777 		    rlen = dev->readBlock( cbuf, rlen );

   778 		}

   779 		// We can't use an odd number of bytes, so put it back. But

   780 		// do it only if we are capable of reading more -- normally

   781 		// there should not be an odd number, but the file might be

   782 		// truncated or not in UTF-16...

   783 		if ( (rlen & 1) == 1 )

   784 		    if ( !dev->atEnd() )

   785 			dev->ungetch( cbuf[--rlen] );

   786 		uint i = 0;

   787 		if ( isNetworkOrder() ) {

   788 		    while( i < rlen ) {

   789 			buf[rnum++] = QChar( cbuf[i+1], cbuf[i] );

   790 			i+=2;

   791 		    }

   792 		} else {

   793 		    while( i < rlen ) {

   794 			buf[rnum++] = QChar( cbuf[i], cbuf[i+1] );

   795 			i+=2;

   796 		    }

   797 		}

   798 	    }

   799 	    delete[] cbuf;

   800 	}

   801     }

   802     return rnum;

   803 }

   804 

   805 

   806 /*!

   807   Puts one character to the stream.

   808 */

   809 void QTextStream::ts_putc( QChar c )

   810 {

   811 #ifndef QT_NO_TEXTCODEC

   812     if ( mapper ) {

   813 	int len = 1;

   814 	QString s = c;

   815 	QCString block = mapper->fromUnicode( s, len );

   816 	dev->writeBlock( block, len );

   817     } else

   818 #endif

   819     if ( latin1 ) {

   820 	if( c.row() )

   821 	    dev->putch( '?' ); //######unknown character???

   822 	else

   823 	    dev->putch( c.cell() );

   824     } else {

   825 	if ( doUnicodeHeader ) {

   826 	    doUnicodeHeader = FALSE;

   827 	    ts_putc( QChar::byteOrderMark );

   828 	}

   829 	if ( internalOrder ) {

   830 	    dev->writeBlock( (char*)&c, sizeof(QChar) );

   831 	} else if ( isNetworkOrder() ) {

   832 	    dev->putch(c.row());

   833 	    dev->putch(c.cell());

   834 	} else {

   835 	    dev->putch(c.cell());

   836 	    dev->putch(c.row());

   837 	}

   838     }

   839 }

   840 

   841 /*!

   842   Puts one character to the stream.

   843 */

   844 void QTextStream::ts_putc(int ch)

   845 {

   846     ts_putc(QChar((ushort)ch));

   847 }

   848 

   849 bool QTextStream::ts_isdigit(QChar c)

   850 {

   851     return c.isDigit();

   852 }

   853 

   854 bool QTextStream::ts_isspace( QChar c )

   855 {

   856     return c.isSpace();

   857 }

   858 

   859 void QTextStream::ts_ungetc( QChar c )

   860 {

   861     if ( c.unicode() == 0xffff )

   862 	return;

   863 

   864     d->ungetcBuf.prepend( c );

   865 }

   866 

   867 

   868 

   869 /*!

   870   Reads \e len bytes from the stream into \e e s and returns a reference to

   871   the stream.

   872 

   873   The buffer \e s must be preallocated.

   874 

   875   Note that no encoding is done by this function.

   876 

   877   \warning The behaviour of this function is undefined unless the

   878   stream's encoding is set to Unicode or Latin1.

   879 

   880   \sa QIODevice::readBlock()

   881 */

   882 

   883 QTextStream &QTextStream::readRawBytes( char *s, uint len )

   884 {

   885     dev->readBlock( s, len );

   886     return *this;

   887 }

   888 

   889 /*!

   890   Writes the \e len bytes from \e s to the stream and returns a reference to

   891   the stream.

   892 

   893   Note that no encoding is done by this function.

   894 

   895   \sa QIODevice::writeBlock()

   896 */

   897 

   898 QTextStream &QTextStream::writeRawBytes( const char* s, uint len )

   899 {

   900     dev->writeBlock( s, len );

   901     return *this;

   902 }

   903 

   904 

   905 QTextStream &QTextStream::writeBlock( const char* p, uint len )

   906 {

   907     if ( doUnicodeHeader ) {

   908 	doUnicodeHeader = FALSE;

   909 	if ( !mapper && !latin1 )

   910 	    ts_putc( QChar::byteOrderMark );

   911     }

   912     //All QCStrings and const char* are defined to be in Latin1

   913     if ( !mapper && latin1 ) {

   914 	dev->writeBlock( p, len );

   915     } else if ( !mapper && internalOrder ) {

   916 	QChar *u = new QChar[len];

   917 	for (uint i=0; i<len; i++)

   918 	    u[i] = p[i];

   919 	dev->writeBlock( (char*)u, len*sizeof(QChar) );

   920 	delete [] u;

   921     } else {

   922 	for (uint i=0; i<len; i++)

   923 	    ts_putc( (uchar)p[i] );

   924     }

   925     return *this;

   926 }

   927 

   928 QTextStream &QTextStream::writeBlock( const QChar* p, uint len )

   929 {

   930     if ( !mapper && !latin1 && internalOrder ) {

   931 	if ( doUnicodeHeader ) {

   932 	    doUnicodeHeader = FALSE;

   933 	    ts_putc( QChar::byteOrderMark );

   934 	}

   935 	dev->writeBlock( (char*)p, sizeof(QChar)*len );

   936     } else {

   937 	for (uint i=0; i<len; i++)

   938 	    ts_putc( p[i] );

   939     }

   940     return *this;

   941 }

   942 

   943 

   944 

   945 /*!

   946   Resets the text stream.

   947 

   948   <ul>

   949   <li> All flags are set to 0.

   950   <li> The field width is set to 0.

   951   <li> The fill character is set to ' ' (space).

   952   <li> The precision is set to 6.

   953   </ul>

   954 

   955   \sa setf(), width(), fill(), precision()

   956 */

   957 

   958 void QTextStream::reset()

   959 {

   960     fflags = 0;

   961     fwidth = 0;

   962     fillchar = ' ';

   963     fprec = 6;

   964 }

   965 

   966 

   967 /*!

   968   \fn QIODevice *QTextStream::device() const

   969   Returns the IO device currently set.

   970   \sa setDevice(), unsetDevice()

   971 */

   972 

   973 /*!

   974   Sets the IO device to \a iod.

   975   \sa device(), unsetDevice()

   976 */

   977 

   978 void QTextStream::setDevice( QIODevice *iod )

   979 {

   980     if ( owndev ) {

   981 	delete dev;

   982 	owndev = FALSE;

   983     }

   984     dev = iod;

   985     d->sourceType = QTextStreamPrivate::IODevice;

   986 }

   987 

   988 /*!

   989   Unsets the IO device.	 Equivalent to setDevice( 0 ).

   990   \sa device(), setDevice()

   991 */

   992 

   993 void QTextStream::unsetDevice()

   994 {

   995     setDevice( 0 );

   996     d->sourceType = QTextStreamPrivate::NotSet;

   997 }

   998 

   999 /*!

  1000   \fn bool QTextStream::atEnd() const

  1001   Returns TRUE if the IO device has reached the end position (end of

  1002   stream or file) or if there is no IO device set.

  1003 

  1004   Returns FALSE if the current position of the read/write head of the IO

  1005   device is somewhere before the end position.

  1006 

  1007   \sa QIODevice::atEnd()

  1008 */

  1009 

  1010 /*!\fn bool QTextStream::eof() const

  1011 

  1012   \obsolete

  1013 

  1014   This function has been renamed to atEnd().

  1015 

  1016   \sa QIODevice::atEnd()

  1017 */

  1018 

  1019 /*****************************************************************************

  1020   QTextStream read functions

  1021  *****************************************************************************/

  1022 

  1023 

  1024 /*!

  1025   Reads a \c char from the stream and returns a reference to the stream.

  1026   Note that whitespace is skipped.

  1027 */

  1028 

  1029 QTextStream &QTextStream::operator>>( char &c )

  1030 {

  1031     CHECK_STREAM_PRECOND

  1032     c = eat_ws();

  1033     return *this;

  1034 }

  1035 

  1036 /*!

  1037   Reads a \c char from the stream and returns a reference to the stream.

  1038   Note that whitespace is \e not skipped.

  1039 */

  1040 

  1041 QTextStream &QTextStream::operator>>( QChar &c )

  1042 {

  1043     CHECK_STREAM_PRECOND

  1044     c = ts_getc();

  1045     return *this;

  1046 }

  1047 

  1048 

  1049 ulong QTextStream::input_bin()

  1050 {

  1051     ulong val = 0;

  1052     QChar ch = eat_ws();

  1053     int dv = ch.digitValue();

  1054     while (  dv == 0 || dv == 1 ) {

  1055 	val = ( val << 1 ) + dv;

  1056 	ch = ts_getc();

  1057 	dv = ch.digitValue();

  1058     }

  1059     if ( ch != QEOF )

  1060 	ts_ungetc( ch );

  1061     return val;

  1062 }

  1063 

  1064 ulong QTextStream::input_oct()

  1065 {

  1066     ulong val = 0;

  1067     QChar ch = eat_ws();

  1068     int dv = ch.digitValue();

  1069     while ( dv >= 0 && dv <= 7 ) {

  1070 	val = ( val << 3 ) + dv;

  1071 	ch = ts_getc();

  1072 	dv = ch.digitValue();

  1073     }

  1074     if ( dv == 8 || dv == 9 ) {

  1075 	while ( ts_isdigit(ch) )

  1076 	    ch = ts_getc();

  1077     }

  1078     if ( ch != QEOF )

  1079 	ts_ungetc( ch );

  1080     return val;

  1081 }

  1082 

  1083 ulong QTextStream::input_dec()

  1084 {

  1085     ulong val = 0;

  1086     QChar ch = eat_ws();

  1087     int dv = ch.digitValue();

  1088     while ( ts_isdigit(ch) ) {

  1089 	val = val * 10 + dv;

  1090 	ch = ts_getc();

  1091 	dv = ch.digitValue();

  1092     }

  1093     if ( ch != QEOF )

  1094 	ts_ungetc( ch );

  1095     return val;

  1096 }

  1097 

  1098 ulong QTextStream::input_hex()

  1099 {

  1100     ulong val = 0;

  1101     QChar ch = eat_ws();

  1102     char c = ch;

  1103     while ( isxdigit(c) ) {

  1104 	val <<= 4;

  1105 	if ( ts_isdigit(c) )

  1106 	    val += c - '0';

  1107 	else

  1108 	    val += 10 + tolower(c) - 'a';

  1109 	c = ch = ts_getc();

  1110     }

  1111     if ( ch != QEOF )

  1112 	ts_ungetc( ch );

  1113     return val;

  1114 }

  1115 

  1116 long QTextStream::input_int()

  1117 {

  1118     long val;

  1119     QChar ch;

  1120     char c;

  1121     switch ( flags() & basefield ) {

  1122     case bin:

  1123 	val = (long)input_bin();

  1124 	break;

  1125     case oct:

  1126 	val = (long)input_oct();

  1127 	break;

  1128     case dec:

  1129 	c = ch = eat_ws();

  1130 	if ( ch == QEOF ) {

  1131 	    val = 0;

  1132 	} else {

  1133 	    if ( !(c == '-' || c == '+') )

  1134 		ts_ungetc( ch );

  1135 	    if ( c == '-' ) {