Removed unnecessary and/or TDE-unrelated code.

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
Signed-off-by: Slávek Banko <slavek.banko@axis.cz>

1 files changed, 0 insertions, 1176 deletions

diff --git a/tqtinterface/qt4/src/tools/tqdatastream.cpp b/tqtinterface/qt4/src/tools/tqdatastream.cpp
deleted file mode 100644
index bf9955a..0000000
--- a/tqtinterface/qt4/src/tools/tqdatastream.cpp
+++ /dev/null
@@ -1,1176 +0,0 @@
-/****************************************************************************
-**
-** Implementation of TQDataStream class
-**
-** Created : 930831
-**
-** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
-**
-** This file is part of the tools module of the TQt 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 TQt 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.TQPL
-** included in the packaging of this file.  Licensees holding valid TQt
-** Commercial licenses may use this file in accordance with the TQt
-** 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 "tqdatastream.h"
-
-#ifndef TQT_NO_DATASTREAM
-#include "tqbuffer.h"
-#include <stdio.h>
-#include <ctype.h>
-#include <stdlib.h>
-#ifndef TQ_OS_TEMP
-#include <locale.h>
-#else
-#include "tqt_windows.h"
-#endif
-
-#ifdef USE_QT4
-
-#else // USE_QT4
-
-/*!
-    \class TQDataStream tqdatastream.h
-    \reentrant
-    \brief The TQDataStream class provides serialization of binary data
-    to a TQIODevice.
-
-    \ingroup io
-
-    A data stream is a binary stream of encoded information which is
-    100% independent of the host computer's operating system, CPU or
-    byte order. For example, a data stream that is written by a PC
-    under Windows can be read by a Sun SPARC running Solaris.
-
-    You can also use a data stream to read/write \link #raw raw
-    unencoded binary data\endlink. If you want a "parsing" input
-    stream, see TQTextStream.
-
-    The TQDataStream class implements the serialization of C++'s basic
-    data types, like \c char, \c short, \c int, \c char*, etc.
-    Serialization of more complex data is accomplished by breaking up
-    the data into primitive units.
-
-    A data stream cooperates closely with a TQIODevice. A TQIODevice
-    represents an input/output medium one can read data from and write
-    data to. The TQFile class is an example of an IO tqdevice.
-
-    Example (write binary data to a stream):
-    \code
-    TQFile file( "file.dat" );
-    file.open( IO_WriteOnly );
-    TQDataStream stream( &file ); // we will serialize the data into the file
-    stream << "the answer is";   // serialize a string
-    stream << (TQ_INT32)42;       // serialize an integer
-    \endcode
-
-    Example (read binary data from a stream):
-    \code
-    TQFile file( "file.dat" );
-    file.open( IO_ReadOnly );
-    TQDataStream stream( &file );  // read the data serialized from the file
-    TQString str;
-    TQ_INT32 a;
-    stream >> str >> a;           // extract "the answer is" and 42
-    \endcode
-
-    Each item written to the stream is written in a predefined binary
-    format that varies depending on the item's type. Supported TQt
-    types include TQBrush, TQColor, TQDateTime, TQFont, TQPixmap, TQString,
-    TQVariant and many others. For the complete list of all TQt types
-    supporting data streaming see the \link datastreamformat.html
-    Format of the TQDataStream operators \endlink.
-
-    For integers it is best to always cast to a TQt integer type for
-    writing, and to read back into the same TQt integer type. This
-    ensures that you get integers of the size you want and insulates
-    you from compiler and platform differences.
-
-    To take one example, a \c char* string is written as a 32-bit
-    integer equal to the length of the string including the NUL byte
-    ('\0'), followed by all the characters of the string including the
-    NUL byte. When reading a \c char* string, 4 bytes are read to
-    create the 32-bit length value, then that many characters for the
-    \c char* string including the NUL are read.
-
-    The initial IODevice is usually set in the constructor, but can be
-    changed with setDevice(). If you've reached the end of the data
-    (or if there is no IODevice set) atEnd() will return TRUE.
-
-    If you want the data to be compatible with an earlier version of
-    TQt use setVersion().
-
-    If you want the data to be human-readable, e.g. for debugging, you
-    can set the data stream into printable data mode with
-    setPrintableData(). The data is then written slower, in a bloated
-    but human readable format.
-
-    If you are producing a new binary data format, such as a file
-    format for documents created by your application, you could use a
-    TQDataStream to write the data in a portable format. Typically, you
-    would write a brief header containing a magic string and a version
-    number to give yourself room for future expansion. For example:
-
-    \code
-    TQFile file( "file.xxx" );
-    file.open( IO_WriteOnly );
-    TQDataStream stream( &file );
-
-    // Write a header with a "magic number" and a version
-    stream << (TQ_UINT32)0xA0B0C0D0;
-    stream << (TQ_INT32)123;
-
-    // Write the data
-    stream << [lots of interesting data]
-    \endcode
-
-    Then read it in with:
-
-    \code
-    TQFile file( "file.xxx" );
-    file.open( IO_ReadOnly );
-    TQDataStream stream( &file );
-
-    // Read and check the header
-    TQ_UINT32 magic;
-    stream >> magic;
-    if ( magic != 0xA0B0C0D0 )
-	return XXX_BAD_FILE_FORMAT;
-
-    // Read the version
-    TQ_INT32 version;
-    stream >> version;
-    if ( version < 100 )
-	return XXX_BAD_FILE_TOO_OLD;
-    if ( version > 123 )
-	return XXX_BAD_FILE_TOO_NEW;
-    if ( version <= 110 )
-	stream.setVersion(1);
-
-    // Read the data
-    stream >> [lots of interesting data];
-    if ( version > 120 )
-	stream >> [data new in XXX version 1.2];
-    stream >> [other interesting data];
-    \endcode
-
-    You can select which byte order to use when serializing data. The
-    default setting is big endian (MSB first). Changing it to little
-    endian breaks the portability (unless the reader also changes to
-    little endian). We recommend keeping this setting unless you have
-    special requirements.
-
-    \target raw
-    \section1 Reading and writing raw binary data
-
-    You may wish to read/write your own raw binary data to/from the
-    data stream directly. Data may be read from the stream into a
-    preallocated char* using readRawBytes(). Similarly data can be
-    written to the stream using writeRawBytes(). Notice that any
-    encoding/decoding of the data must be done by you.
-
-    A similar pair of functions is readBytes() and writeBytes(). These
-    differ from their \e raw counterparts as follows: readBytes()
-    reads a TQ_UINT32 which is taken to be the length of the data to be
-    read, then that number of bytes is read into the preallocated
-    char*; writeBytes() writes a TQ_UINT32 containing the length of the
-    data, followed by the data. Notice that any encoding/decoding of
-    the data (apart from the length TQ_UINT32) must be done by you.
-
-    \sa TQTextStream TQVariant
-*/
-
-/*!
-    \enum TQDataStream::ByteOrder
-
-    The byte order used for reading/writing the data.
-
-    \value BigEndian the default
-    \value LittleEndian
-*/
-
-
-/*****************************************************************************
-  TQDataStream member functions
- *****************************************************************************/
-
-#if defined(TQT_CHECK_STATE)
-#undef  CHECK_STREAM_PRECOND
-#define CHECK_STREAM_PRECOND  if ( !dev ) {				\
-				qWarning( "TQDataStream: No tqdevice" );	\
-				return *this; }
-#else
-#define CHECK_STREAM_PRECOND
-#endif
-
-static int  systemWordSize = 0;
-static bool systemBigEndian;
-
-static const int DefaultStreamVersion = 6;
-// ### On next version bump, TQPen::width() should not be restricted to 8-bit values.
-// ### On next version bump, when streaming invalid TQVariants, just the type should
-// be written, no "data" after it
-// 6 is default in TQt 3.3
-// 5 is default in TQt 3.1
-// 4 is default in TQt 3.0
-// 3 is default in TQt 2.1
-// 2 is the TQt 2.0.x format
-// 1 is the TQt 1.x format
-
-/*!
-    Constructs a data stream that has no IO tqdevice.
-
-    \sa setDevice()
-*/
-
-TQDataStream::TQDataStream()
-{
-    if ( systemWordSize == 0 )			// get system features
-	qSysInfo( &systemWordSize, &systemBigEndian );
-    dev	      = 0;				// no tqdevice set
-    owndev    = FALSE;
-    byteorder = BigEndian;			// default byte order
-    printable = FALSE;
-    ver	      = DefaultStreamVersion;
-    noswap    = systemBigEndian;
-}
-
-/*!
-    Constructs a data stream that uses the IO tqdevice \a d.
-
-    \warning If you use TQSocket or TQSocketDevice as the IO tqdevice \a d
-    for reading data, you must make sure that enough data is available
-    on the socket for the operation to successfully proceed;
-    TQDataStream does not have any means to handle or recover from
-    short-reads.
-
-    \sa setDevice(), tqdevice()
-*/
-
-TQDataStream::TQDataStream( TQIODevice *d )
-{
-    if ( systemWordSize == 0 )			// get system features
-	qSysInfo( &systemWordSize, &systemBigEndian );
-    dev	      = d;				// set tqdevice
-    owndev    = FALSE;
-    byteorder = BigEndian;			// default byte order
-    printable = FALSE;
-    ver	      = DefaultStreamVersion;
-    noswap    = systemBigEndian;
-}
-
-/*!
-    Constructs a data stream that operates on a byte array, \a a,
-    through an internal TQBuffer tqdevice. The \a mode is a
-    TQIODevice::mode(), usually either \c IO_ReadOnly or \c
-    IO_WriteOnly.
-
-    Example:
-    \code
-    static char bindata[] = { 231, 1, 44, ... };
-    TQByteArray a;
-    a.setRawData( bindata, sizeof(bindata) );	// a points to bindata
-    TQDataStream stream( a, IO_ReadOnly );	// open on a's data
-    stream >> [something];			// read raw bindata
-    a.resetRawData( bindata, sizeof(bindata) ); // finished
-    \endcode
-
-    The TQByteArray::setRawData() function is not for the inexperienced.
-*/
-
-TQDataStream::TQDataStream( TQByteArray a, int mode )
-{
-    if ( systemWordSize == 0 )			// get system features
-	qSysInfo( &systemWordSize, &systemBigEndian );
-    dev	      = new TQBuffer( a );		// create tqdevice
-    ((TQBuffer *)dev)->open( mode );		// open tqdevice
-    owndev    = TRUE;
-    byteorder = BigEndian;			// default byte order
-    printable = FALSE;
-    ver	      = DefaultStreamVersion;
-    noswap    = systemBigEndian;
-}
-
-/*!
-    Destroys the data stream.
-
-    The destructor will not affect the current IO tqdevice, unless it is
-    an internal IO tqdevice processing a TQByteArray passed in the \e
-    constructor, in which case the internal IO tqdevice is destroyed.
-*/
-
-TQDataStream::~TQDataStream()
-{
-    if ( owndev )
-	delete dev;
-}
-
-
-/*!
-    \fn TQIODevice *TQDataStream::tqdevice() const
-
-    Returns the IO tqdevice currently set.
-
-    \sa setDevice(), unsetDevice()
-*/
-
-/*!
-    void TQDataStream::setDevice(TQIODevice *d )
-
-    Sets the IO tqdevice to \a d.
-
-    \sa tqdevice(), unsetDevice()
-*/
-
-void TQDataStream::setDevice(TQIODevice *d )
-{
-    if ( owndev ) {
-	delete dev;
-	owndev = FALSE;
-    }
-    dev = d;
-}
-
-/*!
-    Unsets the IO tqdevice. This is the same as calling setDevice( 0 ).
-
-    \sa tqdevice(), setDevice()
-*/
-
-void TQDataStream::unsetDevice()
-{
-    setDevice( 0 );
-}
-
-
-/*!
-    \fn bool TQDataStream::atEnd() const
-
-    Returns TRUE if the IO tqdevice has reached the end position (end of
-    the stream or file) or if there is no IO tqdevice set; otherwise
-    returns FALSE, i.e. if the current position of the IO tqdevice is
-    before the end position.
-
-    \sa TQIODevice::atEnd()
-*/
-
-/*!\fn bool TQDataStream::eof() const
-
-  \obsolete
-
-  Returns TRUE if the IO tqdevice has reached the end position (end of
-  stream or file) or if there is no IO tqdevice set.
-
-  Returns FALSE if the current position of the read/write head of the IO
-  tqdevice is somewhere before the end position.
-
-  \sa TQIODevice::atEnd()
-*/
-
-/*!
-    \fn int TQDataStream::byteOrder() const
-
-    Returns the current byte order setting -- either \c BigEndian or
-    \c LittleEndian.
-
-    \sa setByteOrder()
-*/
-
-/*!
-    Sets the serialization byte order to \a bo.
-
-    The \a bo parameter can be \c TQDataStream::BigEndian or \c
-    TQDataStream::LittleEndian.
-
-    The default setting is big endian. We recommend leaving this
-    setting unless you have special requirements.
-
-    \sa byteOrder()
-*/
-
-void TQDataStream::setByteOrder( int bo )
-{
-    byteorder = bo;
-    if ( systemBigEndian )
-	noswap = byteorder == BigEndian;
-    else
-	noswap = byteorder == LittleEndian;
-}
-
-
-/*!
-    \fn bool TQDataStream::isPrintableData() const
-
-    Returns TRUE if the printable data flag has been set; otherwise
-    returns FALSE.
-
-    \sa setPrintableData()
-*/
-
-/*!
-    \fn void TQDataStream::setPrintableData( bool enable )
-
-    If \a enable is TRUE, data will be output in a human readable
-    format. If \a enable is FALSE, data will be output in a binary
-    format.
-
-    If \a enable is TRUE, the write functions will generate output
-    that consists of printable characters (7 bit ASCII). This output
-    will typically be a lot larger than the default binary output, and
-    consequently slower to write.
-
-    We recommend only enabling printable data for debugging purposes.
-*/
-
-
-/*!
-    \fn int TQDataStream::version() const
-
-    Returns the version number of the data serialization format. In TQt
-    3.1, this number is 5.
-
-    \sa setVersion()
-*/
-
-/*!
-    \fn void TQDataStream::setVersion( int v )
-
-    Sets the version number of the data serialization format to \a v.
-
-    You don't need to set a version if you are using the current
-    version of TQt.
-
-    In order to accommodate new functionality, the datastream
-    serialization format of some TQt classes has changed in some
-    versions of TQt. If you want to read data that was created by an
-    earlier version of TQt, or write data that can be read by a program
-    that was compiled with an earlier version of TQt, use this function
-    to modify the serialization format of TQDataStream.
-
-    \table
-    \header \i TQt Version         \i TQDataStream Version
-    \row \i TQt 3.3                \i11 6
-    \row \i TQt 3.2                \i11 5
-    \row \i TQt 3.1                \i11 5
-    \row \i TQt 3.0                \i11 4
-    \row \i TQt 2.1.x and TQt 2.2.x \i11 3
-    \row \i TQt 2.0.x              \i11 2
-    \row \i TQt 1.x                \i11 1
-    \endtable
-
-    \sa version()
-*/
-
-/*****************************************************************************
-  TQDataStream read functions
- *****************************************************************************/
-
-#if defined(TQ_OS_HPUX) && !defined(__LP64__)
-extern "C" long long __strtoll( const char *, char**, int );
-#endif
-
-static TQ_INT64 read_int_ascii( TQDataStream *s )
-{
-    register int n = 0;
-    char buf[40];
-    for ( ;; ) {
-	buf[n] = s->tqdevice()->getch();
-	if ( buf[n] == '\n' || n > 38 )		// $-terminator
-	    break;
-	n++;
-    }
-    buf[n] = '\0';
-
-#if defined(__LP64__) || defined(TQ_OS_OSF)
-    // sizeof(long) == 8
-    return strtol(buf, (char **)0, 10);
-#else
-#  if defined(TQ_OS_TEMP)
-    return strtol( buf, (char**)0, 10 );
-#  elif defined(TQ_OS_WIN)
-    return _atoi64( buf );
-#  elif defined(TQ_OS_HPUX)
-    return __strtoll( buf, (char**)0, 10 );
-#  elif defined(TQ_OS_MACX) && defined(TQT_MACOSX_VERSION) && TQT_MACOSX_VERSION < 0x1020
-    return strtoq( buf, (char**)0, 10 );
-#  else
-    return strtoll( buf, (char**)0, 10 );	// C99 function
-#  endif
-#endif
-}
-
-/*!
-    \overload TQDataStream &TQDataStream::operator>>( TQ_UINT8 &i )
-
-    Reads an unsigned byte from the stream into \a i, and returns a
-    reference to the stream.
-*/
-
-/*!
-    Reads a signed byte from the stream into \a i, and returns a
-    reference to the stream.
-*/
-
-TQDataStream &TQDataStream::operator>>( TQ_INT8 &i )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable ) {				// printable data
-	i = (TQ_INT8)dev->getch();
-	if ( i == '\\' ) {			// read octal code
-	    char buf[4];
-	    dev->readBlock( buf, 3 );
-	    i = (buf[2] & 0x07)+((buf[1] & 0x07) << 3)+((buf[0] & 0x07) << 6);
-	}
-    } else {					// data or text
-	i = (TQ_INT8)dev->getch();
-    }
-    return *this;
-}
-
-
-/*!
-    \overload TQDataStream &TQDataStream::operator>>( TQ_UINT16 &i )
-
-    Reads an unsigned 16-bit integer from the stream into \a i, and
-    returns a reference to the stream.
-*/
-
-/*!
-    \overload
-
-    Reads a signed 16-bit integer from the stream into \a i, and
-    returns a reference to the stream.
-*/
-
-TQDataStream &TQDataStream::operator>>( TQ_INT16 &i )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable ) {				// printable data
-	i = (TQ_INT16)read_int_ascii( this );
-    } else if ( noswap ) {			// no conversion needed
-	dev->readBlock( (char *)&i, sizeof(TQ_INT16) );
-    } else {					// swap bytes
-	register uchar *p = (uchar *)(&i);
-	char b[2];
-	dev->readBlock( b, 2 );
-	*p++ = b[1];
-	*p   = b[0];
-    }
-    return *this;
-}
-
-
-/*!
-    \overload TQDataStream &TQDataStream::operator>>( TQ_UINT32 &i )
-
-    Reads an unsigned 32-bit integer from the stream into \a i, and
-    returns a reference to the stream.
-*/
-
-/*!
-    \overload
-
-    Reads a signed 32-bit integer from the stream into \a i, and
-    returns a reference to the stream.
-*/
-
-TQDataStream &TQDataStream::operator>>( TQ_INT32 &i )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable ) {				// printable data
-	i = (TQ_INT32)read_int_ascii( this );
-    } else if ( noswap ) {			// no conversion needed
-	dev->readBlock( (char *)&i, sizeof(TQ_INT32) );
-    } else {					// swap bytes
-	uchar *p = (uchar *)(&i);
-	char b[4];
-	dev->readBlock( b, 4 );
-	*p++ = b[3];
-	*p++ = b[2];
-	*p++ = b[1];
-	*p   = b[0];
-    }
-    return *this;
-}
-
-/*!
-    \overload TQDataStream &TQDataStream::operator>>( TQ_UINT64 &i )
-
-    Reads an unsigned 64-bit integer from the stream, into \a i, and
-    returns a reference to the stream.
-*/
-
-/*!
-    \overload
-
-    Reads a signed 64-bit integer from the stream into \a i, and
-    returns a reference to the stream.
-*/
-
-TQDataStream &TQDataStream::operator>>( TQ_INT64 &i )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable ) {				// printable data
-	i = read_int_ascii( this );
-    } else if ( version() < 6 ) {
-	TQ_UINT32 i1, i2;
-	*this >> i2 >> i1;
-	i = ((TQ_UINT64)i1 << 32) + i2;
-    } else if ( noswap ) {			// no conversion needed
-	dev->readBlock( (char *)&i, sizeof(TQ_INT64) );
-    } else {					// swap bytes
-	uchar *p = (uchar *)(&i);
-	char b[8];
-	dev->readBlock( b, 8 );
-	*p++ = b[7];
-	*p++ = b[6];
-	*p++ = b[5];
-	*p++ = b[4];
-	*p++ = b[3];
-	*p++ = b[2];
-	*p++ = b[1];
-	*p   = b[0];
-    }
-    return *this;
-}
-
-
-/*!
-    \overload TQDataStream &TQDataStream::operator>>( TQ_ULONG &i )
-
-    Reads an unsigned integer of the system's word length from the
-    stream, into \a i, and returns a reference to the stream.
-*/
-
-#if !defined(TQ_OS_WIN64)
-/*!
-    \overload
-
-    Reads a signed integer of the system's word length from the stream
-    into \a i, and returns a reference to the stream.
-
-*/
-
-TQDataStream &TQDataStream::operator>>( TQ_LONG &i )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable ) {				// printable data
-	i = (TQ_LONG)read_int_ascii( this );
-    } else if ( noswap ) {			// no conversion needed
-	dev->readBlock( (char *)&i, sizeof(TQ_LONG) );
-    } else {					// swap bytes
-	register uchar *p = (uchar *)(&i);
-	char b[sizeof(TQ_LONG)];
-	dev->readBlock( b, sizeof(TQ_LONG) );
-	for ( int j = sizeof(TQ_LONG); j;  )
-	    *p++ = b[--j];
-    }
-    return *this;
-}
-#endif
-
-static double read_double_ascii( TQDataStream *s )
-{
-    register int n = 0;
-    char buf[80];
-    for ( ;; ) {
-	buf[n] = s->tqdevice()->getch();
-	if ( buf[n] == '\n' || n > 78 )		// $-terminator
-	    break;
-	n++;
-    }
-    buf[n] = '\0';
-    return atof( buf );
-}
-
-
-/*!
-    \overload
-
-    Reads a 32-bit floating point number from the stream into \a f,
-    using the standard IEEE754 format. Returns a reference to the
-    stream.
-*/
-
-TQDataStream &TQDataStream::operator>>( float &f )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable ) {				// printable data
-	f = (float)read_double_ascii( this );
-    } else if ( noswap ) {			// no conversion needed
-	dev->readBlock( (char *)&f, sizeof(float) );
-    } else {					// swap bytes
-	uchar *p = (uchar *)(&f);
-	char b[4];
-	dev->readBlock( b, 4 );
-	*p++ = b[3];
-	*p++ = b[2];
-	*p++ = b[1];
-	*p   = b[0];
-    }
-    return *this;
-}
-
-
-/*!
-    \overload
-
-    Reads a 64-bit floating point number from the stream into \a f,
-    using the standard IEEE754 format. Returns a reference to the
-    stream.
-*/
-
-TQDataStream &TQDataStream::operator>>( double &f )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable ) {				// printable data
-	f = read_double_ascii( this );
-    } else if ( noswap ) {			// no conversion needed
-	dev->readBlock( (char *)&f, sizeof(double) );
-    } else {					// swap bytes
-	register uchar *p = (uchar *)(&f);
-	char b[8];
-	dev->readBlock( b, 8 );
-	*p++ = b[7];
-	*p++ = b[6];
-	*p++ = b[5];
-	*p++ = b[4];
-	*p++ = b[3];
-	*p++ = b[2];
-	*p++ = b[1];
-	*p   = b[0];
-    }
-    return *this;
-}
-
-
-/*!
-    \overload
-
-    Reads the '\0'-terminated string \a s from the stream and returns
-    a reference to the stream.
-
-    Space for the string is allocated using \c new -- the caller must
-    destroy it with delete[].
-*/
-
-TQDataStream &TQDataStream::operator>>( char *&s )
-{
-    uint len = 0;
-    return readBytes( s, len );
-}
-
-
-/*!
-    Reads the buffer \a s from the stream and returns a reference to
-    the stream.
-
-    The buffer \a s is allocated using \c new. Destroy it with the \c
-    delete[] operator. If the length is zero or \a s cannot be
-    allocated, \a s is set to 0.
-
-    The \a l parameter will be set to the length of the buffer.
-
-    The serialization format is a TQ_UINT32 length specifier first,
-    then \a l bytes of data. Note that the data is \e not encoded.
-
-    \sa readRawBytes(), writeBytes()
-*/
-
-TQDataStream &TQDataStream::readBytes( char *&s, uint &l )
-{
-    CHECK_STREAM_PRECOND
-    TQ_UINT32 len;
-    *this >> len;				// first read length spec
-    l = (uint)len;
-    if ( len == 0 || eof() ) {
-	s = 0;
-	return *this;
-    } else {
-	s = new char[len];			// create char array
-	TQ_CHECK_PTR( s );
-	if ( !s )				// no memory
-	    return *this;
-	return readRawBytes( s, (uint)len );
-    }
-}
-
-
-/*!
-    Reads \a len bytes from the stream into \a s and returns a
-    reference to the stream.
-
-    The buffer \a s must be preallocated. The data is \e not encoded.
-
-    \sa readBytes(), TQIODevice::readBlock(), writeRawBytes()
-*/
-
-TQDataStream &TQDataStream::readRawBytes( char *s, uint len )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable ) {				// printable data
-	register TQ_INT8 *p = (TQ_INT8*)s;
-	if ( version() < 4 ) {
-	    while ( len-- ) {
-		TQ_INT32 tmp;
-		*this >> tmp;
-		*p++ = tmp;
-	    }
-	} else {
-	    while ( len-- )
-		*this >> *p++;
-	}
-    } else {					// read data char array
-	dev->readBlock( s, len );
-    }
-    return *this;
-}
-
-
-/*****************************************************************************
-  TQDataStream write functions
- *****************************************************************************/
-
-
-/*!
-    \overload TQDataStream &TQDataStream::operator<<( TQ_UINT8 i )
-
-    Writes an unsigned byte, \a i, to the stream and returns a
-    reference to the stream.
-*/
-
-/*!
-    Writes a signed byte, \a i, to the stream and returns a reference
-    to the stream.
-*/
-
-TQDataStream &TQDataStream::operator<<( TQ_INT8 i )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable && (i == '\\' || !isprint((uchar) i)) ) {
-	char buf[6];				// write octal code
-	buf[0] = '\\';
-	buf[1] = '0' + ((i >> 6) & 0x07);
-	buf[2] = '0' + ((i >> 3) & 0x07);
-	buf[3] = '0' + (i & 0x07);
-	buf[4] = '\0';
-	dev->writeBlock( buf, 4 );
-    } else {
-	dev->putch( i );
-    }
-    return *this;
-}
-
-
-/*!
-    \overload TQDataStream &TQDataStream::operator<<( TQ_UINT16 i )
-
-    Writes an unsigned 16-bit integer, \a i, to the stream and returns
-    a reference to the stream.
-*/
-
-/*!
-    \overload
-
-    Writes a signed 16-bit integer, \a i, to the stream and returns a
-    reference to the stream.
-*/
-
-TQDataStream &TQDataStream::operator<<( TQ_INT16 i )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable ) {				// printable data
-	char buf[16];
-	sprintf( buf, "%d\n", i );
-	dev->writeBlock( buf, strlen(buf) );
-    } else if ( noswap ) {			// no conversion needed
-	dev->writeBlock( (char *)&i, sizeof(TQ_INT16) );
-    } else {					// swap bytes
-	register uchar *p = (uchar *)(&i);
-	char b[2];
-	b[1] = *p++;
-	b[0] = *p;
-	dev->writeBlock( b, 2 );
-    }
-    return *this;
-}
-
-/*!
-    \overload
-
-    Writes a signed 32-bit integer, \a i, to the stream and returns a
-    reference to the stream.
-*/
-
-TQDataStream &TQDataStream::operator<<( TQ_INT32 i )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable ) {				// printable data
-	char buf[16];
-	sprintf( buf, "%d\n", i );
-	dev->writeBlock( buf, strlen(buf) );
-    } else if ( noswap ) {			// no conversion needed
-	dev->writeBlock( (char *)&i, sizeof(TQ_INT32) );
-    } else {					// swap bytes
-	register uchar *p = (uchar *)(&i);
-	char b[4];
-	b[3] = *p++;
-	b[2] = *p++;
-	b[1] = *p++;
-	b[0] = *p;
-	dev->writeBlock( b, 4 );
-    }
-    return *this;
-}
-
-/*!
-    \overload TQDataStream &TQDataStream::operator<<( TQ_UINT64 i )
-
-    Writes an unsigned 64-bit integer, \a i, to the stream and returns a
-    reference to the stream.
-*/
-
-/*!
-    \overload
-
-    Writes a signed 64-bit integer, \a i, to the stream and returns a
-    reference to the stream.
-*/
-
-TQDataStream &TQDataStream::operator<<( TQ_INT64 i )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable ) {				// printable data
-	char buf[16];
-#ifdef TQ_OS_WIN
-	sprintf( buf, "%I64d\n", i );
-#else
-	sprintf( buf, "%lld\n", i );
-#endif
-	dev->writeBlock( buf, strlen(buf) );
-    } else if ( version() < 6 ) {
-	TQ_UINT32 i1 = i & 0xffffffff;
-	TQ_UINT32 i2 = i >> 32;
-	*this << i2 << i1;
-    } else if ( noswap ) {			// no conversion needed
-	dev->writeBlock( (char *)&i, sizeof(TQ_INT64) );
-    } else {					// swap bytes
-	register uchar *p = (uchar *)(&i);
-	char b[8];
-	b[7] = *p++;
-	b[6] = *p++;
-	b[5] = *p++;
-	b[4] = *p++;
-	b[3] = *p++;
-	b[2] = *p++;
-	b[1] = *p++;
-	b[0] = *p;
-	dev->writeBlock( b, 8 );
-    }
-    return *this;
-}
-
-/*!
-    \overload TQDataStream &TQDataStream::operator<<( TQ_ULONG i )
-
-    Writes an unsigned integer \a i, of the system's word length, to
-    the stream and returns a reference to the stream.
-*/
-
-#if !defined(TQ_OS_WIN64)
-/*!
-    \overload
-
-    Writes a signed integer \a i, of the system's word length, to the
-    stream and returns a reference to the stream.
-*/
-
-TQDataStream &TQDataStream::operator<<( TQ_LONG i )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable ) {				// printable data
-	char buf[20];
-	sprintf( buf, "%ld\n", i );
-	dev->writeBlock( buf, strlen(buf) );
-    } else if ( noswap ) {			// no conversion needed
-	dev->writeBlock( (char *)&i, sizeof(TQ_LONG) );
-    } else {					// swap bytes
-	register uchar *p = (uchar *)(&i);
-	char b[sizeof(TQ_LONG)];
-	for ( int j = sizeof(TQ_LONG); j;  )
-	    b[--j] = *p++;
-	dev->writeBlock( b, sizeof(TQ_LONG) );
-    }
-    return *this;
-}
-#endif
-
-
-/*!
-    \overload TQDataStream &TQDataStream::operator<<( TQ_UINT32 i )
-
-    Writes an unsigned integer, \a i, to the stream as a 32-bit
-    unsigned integer (TQ_UINT32). Returns a reference to the stream.
-*/
-
-/*!
-    \overload
-
-    Writes a 32-bit floating point number, \a f, to the stream using
-    the standard IEEE754 format. Returns a reference to the stream.
-*/
-
-TQDataStream &TQDataStream::operator<<( float f )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable ) {				// printable data
-	TQString num = TQString::number((double)f);
-	dev->writeBlock(num.latin1(), num.length());
-	dev->putch('\n');
-    } else {
-	float g = f;				// fixes float-on-stack problem
-	if ( noswap ) {				// no conversion needed
-	    dev->writeBlock( (char *)&g, sizeof(float) );
-	} else {				// swap bytes
-	    register uchar *p = (uchar *)(&g);
-	    char b[4];
-	    b[3] = *p++;
-	    b[2] = *p++;
-	    b[1] = *p++;
-	    b[0] = *p;
-	    dev->writeBlock( b, 4 );
-	}
-    }
-    return *this;
-}
-
-
-/*!
-    \overload
-
-    Writes a 64-bit floating point number, \a f, to the stream using
-    the standard IEEE754 format. Returns a reference to the stream.
-*/
-
-TQDataStream &TQDataStream::operator<<( double f )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable ) {				// printable data
-	TQString num = TQString::number((double)f);
-	dev->writeBlock(num.latin1(), num.length());
-	dev->putch('\n');
-    } else if ( noswap ) {			// no conversion needed
-	dev->writeBlock( (char *)&f, sizeof(double) );
-    } else {					// swap bytes
-	register uchar *p = (uchar *)(&f);
-	char b[8];
-	b[7] = *p++;
-	b[6] = *p++;
-	b[5] = *p++;
-	b[4] = *p++;
-	b[3] = *p++;
-	b[2] = *p++;
-	b[1] = *p++;
-	b[0] = *p;
-	dev->writeBlock( b, 8 );
-    }
-    return *this;
-}
-
-
-/*!
-    \overload
-
-    Writes the '\0'-terminated string \a s to the stream and returns a
-    reference to the stream.
-
-    The string is serialized using writeBytes().
-*/
-
-TQDataStream &TQDataStream::operator<<( const char *s )
-{
-    if ( !s ) {
-	*this << (TQ_UINT32)0;
-	return *this;
-    }
-    uint len = tqstrlen( s ) + 1;			// also write null terminator
-    *this << (TQ_UINT32)len;			// write length specifier
-    return writeRawBytes( s, len );
-}
-
-
-/*!
-    Writes the length specifier \a len and the buffer \a s to the
-    stream and returns a reference to the stream.
-
-    The \a len is serialized as a TQ_UINT32, followed by \a len bytes
-    from \a s. Note that the data is \e not encoded.
-
-    \sa writeRawBytes(), readBytes()
-*/
-
-TQDataStream &TQDataStream::writeBytes(const char *s, uint len)
-{
-    CHECK_STREAM_PRECOND
-    *this << (TQ_UINT32)len;			// write length specifier
-    if ( len )
-	writeRawBytes( s, len );
-    return *this;
-}
-
-
-/*!
-    Writes \a len bytes from \a s to the stream and returns a
-    reference to the stream. The data is \e not encoded.
-
-    \sa writeBytes(), TQIODevice::writeBlock(), readRawBytes()
-*/
-
-TQDataStream &TQDataStream::writeRawBytes( const char *s, uint len )
-{
-    CHECK_STREAM_PRECOND
-    if ( printable ) {				// write printable
-	if ( version() < 4 ) {
-	    register char *p = (char *)s;
-	    while ( len-- )
-		*this << *p++;
-	} else {
-	    register TQ_INT8 *p = (TQ_INT8*)s;
-	    while ( len-- )
-		*this << *p++;
-	}
-    } else {					// write data char array
-	dev->writeBlock( s, len );
-    }
-    return *this;
-}
-
-#endif // TQT_NO_DATASTREAM
-
-#endif // USE_QT4