preprocessed source #2

ccCTiBDr.out (text/plain), 170.78 KB, created by Brian Tarricone on 2005-06-03 00:58:31 UTC

// /usr/libexec/gcc/i686-pc-linux-gnu/3.4.4/cc1plus -quiet -I/usr/include/mysql -I/var/tmp/portage/qt-3.3.4-r4/work/qt-x11-free-3.3.4/mkspecs/linux-g++ -I. -I/usr/include/freetype2 -I../../include -I../tools -I. -D_GNU_SOURCE -DQT_MOC -DQT_NO_CODECS -DQT_LITE_UNICODE -DQT_NO_COMPONENT -DQT_NO_STL -DQT_NO_COMPRESS ../tools/qcstring.cpp -quiet -dumpbase qcstring.cpp -march=athlon-tbird -auxbase-strip ./qcstring.o -O2 -fno-exceptions -o - -frandom-seed=0
# 1 "../tools/qcstring.cpp"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "../tools/qcstring.cpp"
# 39 "../tools/qcstring.cpp"
# 1 "../tools/qstring.h" 1
# 42 "../tools/qstring.h"
# 1 "../tools/qcstring.h" 1
# 43 "../tools/qcstring.h"
# 1 "../tools/qmemarray.h" 1
# 42 "../tools/qmemarray.h"
# 1 "../tools/qgarray.h" 1
# 42 "../tools/qgarray.h"
# 1 "../tools/qshared.h" 1
# 42 "../tools/qshared.h"
# 1 "../tools/qglobal.h" 1
# 609 "../tools/qglobal.h"
typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned uint;
typedef unsigned long ulong;
typedef char *pchar;
typedef uchar *puchar;
typedef const char *pcchar;







const bool FALSE = 0;
const bool TRUE = !0;
# 673 "../tools/qglobal.h"
inline int qRound( double d )
{
    return d >= 0.0 ? int(d + 0.5) : int( d - ((int)d-1) + 0.5 ) + ((int)d-1);
}
# 685 "../tools/qglobal.h"
typedef signed char INT8;
typedef unsigned char UINT8;
typedef short INT16;
typedef unsigned short UINT16;
typedef int INT32;
typedef unsigned int UINT32;


typedef signed char Q_INT8;
typedef unsigned char Q_UINT8;
typedef short Q_INT16;
typedef unsigned short Q_UINT16;
typedef int Q_INT32;
typedef unsigned int Q_UINT32;




typedef long Q_LONG;
typedef unsigned long Q_ULONG;
# 714 "../tools/qglobal.h"
typedef long long Q_INT64;
typedef unsigned long long Q_UINT64;

typedef Q_INT64 Q_LLONG;
typedef Q_UINT64 Q_ULLONG;







    typedef Q_ULONG QtOffset;







class QDataStream;
# 768 "../tools/qglobal.h"
# 1 "../../include/qmodules.h" 1
# 769 "../tools/qglobal.h" 2
# 824 "../tools/qglobal.h"
# 1 "../tools/qfeatures.h" 1
# 825 "../tools/qglobal.h" 2
# 891 "../tools/qglobal.h"
 const char *qVersion();
 bool qSysInfo( int *wordSize, bool *bigEndian );
 bool qSharedBuild();
# 952 "../tools/qglobal.h"
 void qDebug( const char *, ... )

    __attribute__ ((format (printf, 1, 2)))

;

 void qWarning( const char *, ... )

    __attribute__ ((format (printf, 1, 2)))

;

 void qFatal( const char *, ... )

    __attribute__ ((format (printf, 1, 2)))

;

 void qSystemWarning( const char *, int code = -1 );



 void debug( const char *, ... )

    __attribute__ ((format (printf, 1, 2)))

;

 void warning( const char *, ... )

    __attribute__ ((format (printf, 1, 2)))

;

 void fatal( const char *, ... )

    __attribute__ ((format (printf, 1, 2)))

;
# 1016 "../tools/qglobal.h"
 bool qt_check_pointer( bool c, const char *, int );
# 1030 "../tools/qglobal.h"
enum QtMsgType { QtDebugMsg, QtWarningMsg, QtFatalMsg };

typedef void (*QtMsgHandler)(QtMsgType, const char *);
 QtMsgHandler qInstallMsgHandler( QtMsgHandler );


typedef QtMsgHandler msg_handler;


 void qSuppressObsoleteWarnings( bool = TRUE );

 void qObsolete( const char *obj, const char *oldfunc,
     const char *newfunc );
 void qObsolete( const char *obj, const char *oldfunc );
 void qObsolete( const char *message );






 const char *qInstallPath();
 const char *qInstallPathDocs();
 const char *qInstallPathHeaders();
 const char *qInstallPathLibs();
 const char *qInstallPathBins();
 const char *qInstallPathPlugins();
 const char *qInstallPathData();
 const char *qInstallPathTranslations();
 const char *qInstallPathSysconf();
# 43 "../tools/qshared.h" 2



struct QShared
{
    QShared() : count( 1 ) { }
    void ref() { count++; }
    bool deref() { return !--count; }
    uint count;
};
# 43 "../tools/qgarray.h" 2



class QGArray
{
friend class QBuffer;
public:


    struct array_data : public QShared {
 array_data():data(0),len(0)



     {}
 char *data;
 uint len;



    };
    QGArray();
    enum Optimization { MemOptim, SpeedOptim };
protected:
    QGArray( int, int );
    QGArray( int size );
    QGArray( const QGArray &a );
    virtual ~QGArray();

    QGArray &operator=( const QGArray &a ) { return assign( a ); }

    virtual void detach() { duplicate(*this); }


    char *data() const { return shd->data; }
    uint nrefs() const { return shd->count; }
    uint size() const { return shd->len; }
    bool isEqual( const QGArray &a ) const;

    bool resize( uint newsize, Optimization optim );
    bool resize( uint newsize );

    bool fill( const char *d, int len, uint sz );

    QGArray &assign( const QGArray &a );
    QGArray &assign( const char *d, uint len );
    QGArray &duplicate( const QGArray &a );
    QGArray &duplicate( const char *d, uint len );
    void store( const char *d, uint len );

    array_data *sharedBlock() const { return shd; }
    void setSharedBlock( array_data *p ) { shd=(array_data*)p; }

    QGArray &setRawData( const char *d, uint len );
    void resetRawData( const char *d, uint len );

    int find( const char *d, uint index, uint sz ) const;
    int contains( const char *d, uint sz ) const;

    void sort( uint sz );
    int bsearch( const char *d, uint sz ) const;

    char *at( uint index ) const;

    bool setExpand( uint index, const char *d, uint sz );

protected:
    virtual array_data *newData();
    virtual void deleteData( array_data *p );

private:
    static void msg_index( uint );
    array_data *shd;
};


inline char *QGArray::at( uint index ) const
{

    if ( index >= size() ) {
 msg_index( index );
 index = 0;
    }

    return &shd->data[index];
}
# 43 "../tools/qmemarray.h" 2



template<class type>
class QMemArray : public QGArray
{
public:
    typedef type* Iterator;
    typedef const type* ConstIterator;
    typedef type ValueType;

protected:
    QMemArray( int, int ) : QGArray( 0, 0 ) {}

public:
    QMemArray() {}
    QMemArray( int size ) : QGArray(size*sizeof(type)) {}
    QMemArray( const QMemArray<type> &a ) : QGArray(a) {}
   ~QMemArray() {}
    QMemArray<type> &operator=(const QMemArray<type> &a)
    { return (QMemArray<type>&)QGArray::assign(a); }
    type *data() const { return (type *)QGArray::data(); }
    uint nrefs() const { return QGArray::nrefs(); }
    uint size() const { return QGArray::size()/sizeof(type); }
    uint count() const { return size(); }
    bool isEmpty() const { return QGArray::size() == 0; }
    bool isNull() const { return QGArray::data() == 0; }
    bool resize( uint size ) { return QGArray::resize(size*sizeof(type)); }
    bool resize( uint size, Optimization optim ) { return QGArray::resize(size*sizeof(type), optim); }
    bool truncate( uint pos ) { return QGArray::resize(pos*sizeof(type)); }
    bool fill( const type &d, int size = -1 )
 { return QGArray::fill((char*)&d,size,sizeof(type) ); }
    void detach() { QGArray::detach(); }
    QMemArray<type> copy() const
 { QMemArray<type> tmp; return tmp.duplicate(*this); }
    QMemArray<type>& assign( const QMemArray<type>& a )
 { return (QMemArray<type>&)QGArray::assign(a); }
    QMemArray<type>& assign( const type *a, uint n )
 { return (QMemArray<type>&)QGArray::assign((char*)a,n*sizeof(type)); }
    QMemArray<type>& duplicate( const QMemArray<type>& a )
 { return (QMemArray<type>&)QGArray::duplicate(a); }
    QMemArray<type>& duplicate( const type *a, uint n )
 { return (QMemArray<type>&)QGArray::duplicate((char*)a,n*sizeof(type)); }
    QMemArray<type>& setRawData( const type *a, uint n )
 { return (QMemArray<type>&)QGArray::setRawData((char*)a,
           n*sizeof(type)); }
    void resetRawData( const type *a, uint n )
 { QGArray::resetRawData((char*)a,n*sizeof(type)); }
    int find( const type &d, uint i=0 ) const
 { return QGArray::find((char*)&d,i,sizeof(type)); }
    int contains( const type &d ) const
 { return QGArray::contains((char*)&d,sizeof(type)); }
    void sort() { QGArray::sort(sizeof(type)); }
    int bsearch( const type &d ) const
 { return QGArray::bsearch((const char*)&d,sizeof(type)); }

    type& operator[]( int i ) const
 { return (type &)(*(type *)QGArray::at(i*sizeof(type))); }
    type& at( uint i ) const
 { return (type &)(*(type *)QGArray::at(i*sizeof(type))); }
  operator const type*() const { return (const type *)QGArray::data(); }
    bool operator==( const QMemArray<type> &a ) const { return isEqual(a); }
    bool operator!=( const QMemArray<type> &a ) const { return !isEqual(a); }
    Iterator begin() { return data(); }
    Iterator end() { return data() + size(); }
    ConstIterator begin() const { return data(); }
    ConstIterator end() const { return data() + size(); }
};






# 1 "../tools/qwinexport.h" 1
# 118 "../tools/qmemarray.h" 2
# 44 "../tools/qcstring.h" 2


# 1 "/usr/include/string.h" 1 3 4
# 26 "/usr/include/string.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 308 "/usr/include/features.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 309 "/usr/include/features.h" 2 3 4
# 331 "/usr/include/features.h" 3 4
# 1 "/usr/include/gnu/stubs.h" 1 3 4
# 332 "/usr/include/features.h" 2 3 4
# 27 "/usr/include/string.h" 2 3 4

extern "C" {




# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/stddef.h" 1 3 4
# 213 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/stddef.h" 3 4
typedef unsigned int size_t;
# 34 "/usr/include/string.h" 2 3 4




extern void *memcpy (void *__restrict __dest,
       __const void *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern void *memmove (void *__dest, __const void *__src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));






extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
        int __c, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));


extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern void *memchr (__const void *__s, int __c, size_t __n)
      throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern void *rawmemchr (__const void *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern void *memrchr (__const void *__s, int __c, size_t __n)
      throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncpy (char *__restrict __dest,
        __const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));

extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
        size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));


extern int strcmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strcoll (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern size_t strxfrm (char *__restrict __dest,
         __const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (2)));






# 1 "/usr/include/xlocale.h" 1 3 4
# 28 "/usr/include/xlocale.h" 3 4
typedef struct __locale_struct
{

  struct locale_data *__locales[13];


  const unsigned short int *__ctype_b;
  const int *__ctype_tolower;
  const int *__ctype_toupper;


  const char *__names[13];
} *__locale_t;
# 119 "/usr/include/string.h" 2 3 4


extern int strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));

extern size_t strxfrm_l (char *__dest, __const char *__src, size_t __n,
    __locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));




extern char *strdup (__const char *__s)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));






extern char *strndup (__const char *__string, size_t __n)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
# 165 "/usr/include/string.h" 3 4


extern char *strchr (__const char *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern char *strrchr (__const char *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern char *strchrnul (__const char *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern size_t strcspn (__const char *__s, __const char *__reject)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern size_t strspn (__const char *__s, __const char *__accept)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strpbrk (__const char *__s, __const char *__accept)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern char *strstr (__const char *__haystack, __const char *__needle)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
     throw () __attribute__ ((__nonnull__ (2)));




extern char *__strtok_r (char *__restrict __s,
    __const char *__restrict __delim,
    char **__restrict __save_ptr)
     throw () __attribute__ ((__nonnull__ (2, 3)));

extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
         char **__restrict __save_ptr)
     throw () __attribute__ ((__nonnull__ (2, 3)));




extern char *strcasestr (__const char *__haystack, __const char *__needle)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));






extern void *memmem (__const void *__haystack, size_t __haystacklen,
       __const void *__needle, size_t __needlelen)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));



extern void *__mempcpy (void *__restrict __dest,
   __const void *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
        __const void *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern size_t strlen (__const char *__s)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern size_t strnlen (__const char *__string, size_t __maxlen)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern char *strerror (int __errnum) throw ();

# 281 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2)));





extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));



extern void bcopy (__const void *__src, void *__dest, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));


extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern char *index (__const char *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern char *rindex (__const char *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));



extern int ffs (int __i) throw () __attribute__ ((__const__));




extern int ffsl (long int __l) throw () __attribute__ ((__const__));

__extension__ extern int ffsll (long long int __ll)
     throw () __attribute__ ((__const__));




extern int strcasecmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));





extern int strcasecmp_l (__const char *__s1, __const char *__s2,
    __locale_t __loc)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));

extern int strncasecmp_l (__const char *__s1, __const char *__s2,
     size_t __n, __locale_t __loc)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));





extern char *strsep (char **__restrict __stringp,
       __const char *__restrict __delim)
     throw () __attribute__ ((__nonnull__ (1, 2)));




extern int strverscmp (__const char *__s1, __const char *__s2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern char *strsignal (int __sig) throw ();


extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern char *__stpncpy (char *__restrict __dest,
   __const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
        __const char *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));


extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));






extern char *basename (__const char *__filename) throw () __attribute__ ((__nonnull__ (1)));
# 426 "/usr/include/string.h" 3 4
}
# 47 "../tools/qcstring.h" 2






 void *qmemmove( void *dst, const void *src, uint len );

 char *qstrdup( const char * );

 inline uint qstrlen( const char *str )
{ return str ? (uint)strlen(str) : 0u; }

 inline char *qstrcpy( char *dst, const char *src )
{ return src ? strcpy(dst, src) : 0; }

 char *qstrncpy( char *dst, const char *src, uint len );

 inline int qstrcmp( const char *str1, const char *str2 )
{
    return ( str1 && str2 ) ? strcmp( str1, str2 )
       : ( str1 ? 1 : ( str2 ? -1 : 0 ) );
}

 inline int qstrncmp( const char *str1, const char *str2, uint len )
{
    return ( str1 && str2 ) ? strncmp( str1, str2, len )
       : ( str1 ? 1 : ( str2 ? -1 : 0 ) );
}

 int qstricmp( const char *, const char * );

 int qstrnicmp( const char *, const char *, uint len );


 inline uint cstrlen( const char *str )
{ return (uint)strlen(str); }

 inline char *cstrcpy( char *dst, const char *src )
{ return strcpy(dst,src); }

 inline int cstrcmp( const char *str1, const char *str2 )
{ return strcmp(str1,str2); }

 inline int cstrncmp( const char *str1, const char *str2, uint len )
{ return strncmp(str1,str2,len); }





 Q_UINT16 qChecksum( const char *s, uint len );
# 116 "../tools/qcstring.h"
typedef QMemArray<char> QByteArray;
# 132 "../tools/qcstring.h"
 QDataStream &operator<<( QDataStream &, const QByteArray & );
 QDataStream &operator>>( QDataStream &, QByteArray & );






class QRegExp;

class QCString : public QByteArray
{
public:
    QCString() {}
    QCString( int size );
    QCString( const QCString &s ) : QByteArray( s ) {}
    QCString( const char *str );
    QCString( const char *str, uint maxlen );
    ~QCString();

    QCString &operator=( const QCString &s );
    QCString &operator=( const char *str );

    bool isNull() const;
    bool isEmpty() const;
    uint length() const;
    bool resize( uint newlen );
    bool truncate( uint pos );
    bool fill( char c, int len = -1 );

    QCString copy() const;

    QCString &sprintf( const char *format, ... );

    int find( char c, int index=0, bool cs=TRUE ) const;
    int find( const char *str, int index=0, bool cs=TRUE ) const;

    int find( const QRegExp &, int index=0 ) const;

    int findRev( char c, int index=-1, bool cs=TRUE) const;
    int findRev( const char *str, int index=-1, bool cs=TRUE) const;

    int findRev( const QRegExp &, int index=-1 ) const;

    int contains( char c, bool cs=TRUE ) const;
    int contains( const char *str, bool cs=TRUE ) const;

    int contains( const QRegExp & ) const;

    QCString left( uint len ) const;
    QCString right( uint len ) const;
    QCString mid( uint index, uint len=0xffffffff) const;

    QCString leftJustify( uint width, char fill=' ', bool trunc=FALSE)const;
    QCString rightJustify( uint width, char fill=' ',bool trunc=FALSE)const;

    QCString lower() const;
    QCString upper() const;

    QCString stripWhiteSpace() const;
    QCString simplifyWhiteSpace() const;

    QCString &insert( uint index, const char * );
    QCString &insert( uint index, char );
    QCString &append( const char * );
    QCString &prepend( const char * );
    QCString &remove( uint index, uint len );
    QCString &replace( uint index, uint len, const char * );

    QCString &replace( const QRegExp &, const char * );

    QCString &replace( char c, const char *after );
    QCString &replace( const char *, const char * );
    QCString &replace( char, char );

    short toShort( bool *ok=0 ) const;
    ushort toUShort( bool *ok=0 ) const;
    int toInt( bool *ok=0 ) const;
    uint toUInt( bool *ok=0 ) const;
    long toLong( bool *ok=0 ) const;
    ulong toULong( bool *ok=0 ) const;
    float toFloat( bool *ok=0 ) const;
    double toDouble( bool *ok=0 ) const;

    QCString &setStr( const char *s );
    QCString &setNum( short );
    QCString &setNum( ushort );
    QCString &setNum( int );
    QCString &setNum( uint );
    QCString &setNum( long );
    QCString &setNum( ulong );
    QCString &setNum( float, char f='g', int prec=6 );
    QCString &setNum( double, char f='g', int prec=6 );

    bool setExpand( uint index, char c );

  operator const char *() const;
    QCString &operator+=( const char *str );
    QCString &operator+=( char c );
private:
    int find( const char *str, int index, bool cs, uint l ) const;
};






 QDataStream &operator<<( QDataStream &, const QCString & );
 QDataStream &operator>>( QDataStream &, QCString & );






inline QCString &QCString::operator=( const QCString &s )
{ return (QCString&)assign( s ); }

inline QCString &QCString::operator=( const char *str )
{ return (QCString&)duplicate( str, qstrlen(str)+1 ); }

inline bool QCString::isNull() const
{ return data() == 0; }

inline bool QCString::isEmpty() const
{ return data() == 0 || *data() == '\0'; }

inline uint QCString::length() const
{ return qstrlen( data() ); }

inline bool QCString::truncate( uint pos )
{ return resize(pos+1); }

inline QCString QCString::copy() const
{ return QCString( data() ); }

inline QCString &QCString::prepend( const char *s )
{ return insert(0,s); }

inline QCString &QCString::append( const char *s )
{ return operator+=(s); }

inline QCString &QCString::setNum( short n )
{ return setNum((long)n); }

inline QCString &QCString::setNum( ushort n )
{ return setNum((ulong)n); }

inline QCString &QCString::setNum( int n )
{ return setNum((long)n); }

inline QCString &QCString::setNum( uint n )
{ return setNum((ulong)n); }

inline QCString &QCString::setNum( float n, char f, int prec )
{ return setNum((double)n,f,prec); }

inline QCString::operator const char *() const
{ return (const char *)data(); }






 inline bool operator==( const QCString &s1, const QCString &s2 )
{ return qstrcmp( s1.data(), s2.data() ) == 0; }

 inline bool operator==( const QCString &s1, const char *s2 )
{ return qstrcmp( s1.data(), s2 ) == 0; }

 inline bool operator==( const char *s1, const QCString &s2 )
{ return qstrcmp( s1, s2.data() ) == 0; }

 inline bool operator!=( const QCString &s1, const QCString &s2 )
{ return qstrcmp( s1.data(), s2.data() ) != 0; }

 inline bool operator!=( const QCString &s1, const char *s2 )
{ return qstrcmp( s1.data(), s2 ) != 0; }

 inline bool operator!=( const char *s1, const QCString &s2 )
{ return qstrcmp( s1, s2.data() ) != 0; }

 inline bool operator<( const QCString &s1, const QCString& s2 )
{ return qstrcmp( s1.data(), s2.data() ) < 0; }

 inline bool operator<( const QCString &s1, const char *s2 )
{ return qstrcmp( s1.data(), s2 ) < 0; }

 inline bool operator<( const char *s1, const QCString &s2 )
{ return qstrcmp( s1, s2.data() ) < 0; }

 inline bool operator<=( const QCString &s1, const QCString &s2 )
{ return qstrcmp( s1.data(), s2.data() ) <= 0; }

 inline bool operator<=( const QCString &s1, const char *s2 )
{ return qstrcmp( s1.data(), s2 ) <= 0; }

 inline bool operator<=( const char *s1, const QCString &s2 )
{ return qstrcmp( s1, s2.data() ) <= 0; }

 inline bool operator>( const QCString &s1, const QCString &s2 )
{ return qstrcmp( s1.data(), s2.data() ) > 0; }

 inline bool operator>( const QCString &s1, const char *s2 )
{ return qstrcmp( s1.data(), s2 ) > 0; }

 inline bool operator>( const char *s1, const QCString &s2 )
{ return qstrcmp( s1, s2.data() ) > 0; }

 inline bool operator>=( const QCString &s1, const QCString& s2 )
{ return qstrcmp( s1.data(), s2.data() ) >= 0; }

 inline bool operator>=( const QCString &s1, const char *s2 )
{ return qstrcmp( s1.data(), s2 ) >= 0; }

 inline bool operator>=( const char *s1, const QCString &s2 )
{ return qstrcmp( s1, s2.data() ) >= 0; }

 inline const QCString operator+( const QCString &s1,
       const QCString &s2 )
{
    QCString tmp( s1.data() );
    tmp += s2;
    return tmp;
}

 inline const QCString operator+( const QCString &s1, const char *s2 )
{
    QCString tmp( s1.data() );
    tmp += s2;
    return tmp;
}

 inline const QCString operator+( const char *s1, const QCString &s2 )
{
    QCString tmp( s1 );
    tmp += s2;
    return tmp;
}

 inline const QCString operator+( const QCString &s1, char c2 )
{
    QCString tmp( s1.data() );
    tmp += c2;
    return tmp;
}

 inline const QCString operator+( char c1, const QCString &s2 )
{
    QCString tmp;
    tmp += c1;
    tmp += s2;
    return tmp;
}
# 1 "../tools/qwinexport.h" 1
# 389 "../tools/qcstring.h" 2
# 43 "../tools/qstring.h" 2



# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/limits.h" 1 3 4
# 11 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/limits.h" 3 4
# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/syslimits.h" 1 3 4






# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/limits.h" 1 3 4
# 122 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 144 "/usr/include/limits.h" 3 4
# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
# 153 "/usr/include/bits/posix1_lim.h" 3 4
# 1 "/usr/include/bits/local_lim.h" 1 3 4
# 36 "/usr/include/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 37 "/usr/include/bits/local_lim.h" 2 3 4
# 154 "/usr/include/bits/posix1_lim.h" 2 3 4
# 145 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
# 149 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
# 34 "/usr/include/bits/xopen_lim.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 35 "/usr/include/bits/xopen_lim.h" 2 3 4
# 153 "/usr/include/limits.h" 2 3 4
# 123 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/limits.h" 2 3 4
# 8 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/syslimits.h" 2 3 4
# 12 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/limits.h" 2 3 4
# 47 "../tools/qstring.h" 2
# 68 "../tools/qstring.h"
class QRegExp;
class QString;
class QCharRef;
template <class T> class QDeepCopy;

class QChar {
public:
    QChar();
    QChar( char c );
    QChar( uchar c );
    QChar( uchar c, uchar r );
    QChar( const QChar& c );
    QChar( ushort rc );
    QChar( short rc );
    QChar( uint rc );
    QChar( int rc );

    static const QChar null;
    static const QChar replacement;
    static const QChar byteOrderMark;
    static const QChar byteOrderSwapped;
    static const QChar nbsp;



    enum Category
    {
        NoCategory,

        Mark_NonSpacing,
        Mark_SpacingCombining,
        Mark_Enclosing,

        Number_DecimalDigit,
        Number_Letter,
        Number_Other,

        Separator_Space,
        Separator_Line,
        Separator_Paragraph,

        Other_Control,
        Other_Format,
        Other_Surrogate,
        Other_PrivateUse,
        Other_NotAssigned,

        Letter_Uppercase,
        Letter_Lowercase,
        Letter_Titlecase,
        Letter_Modifier,
        Letter_Other,

        Punctuation_Connector,
        Punctuation_Dash,
        Punctuation_Dask = Punctuation_Dash,
        Punctuation_Open,
        Punctuation_Close,
        Punctuation_InitialQuote,
        Punctuation_FinalQuote,
        Punctuation_Other,

        Symbol_Math,
        Symbol_Currency,
        Symbol_Modifier,
        Symbol_Other
    };

    enum Direction
    {
        DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON,
        DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN
    };

    enum Decomposition
    {
        Single, Canonical, Font, NoBreak, Initial, Medial,
        Final, Isolated, Circle, Super, Sub, Vertical,
        Wide, Narrow, Small, Square, Compat, Fraction
    };

    enum Joining
    {
        OtherJoining, Dual, Right, Center
    };

    enum CombiningClass
    {
        Combining_BelowLeftAttached = 200,
        Combining_BelowAttached = 202,
        Combining_BelowRightAttached = 204,
        Combining_LeftAttached = 208,
        Combining_RightAttached = 210,
        Combining_AboveLeftAttached = 212,
        Combining_AboveAttached = 214,
        Combining_AboveRightAttached = 216,

        Combining_BelowLeft = 218,
        Combining_Below = 220,
        Combining_BelowRight = 222,
        Combining_Left = 224,
        Combining_Right = 226,
        Combining_AboveLeft = 228,
        Combining_Above = 230,
        Combining_AboveRight = 232,

        Combining_DoubleBelow = 233,
        Combining_DoubleAbove = 234,
        Combining_IotaSubscript = 240
    };



    int digitValue() const;
    QChar lower() const;
    QChar upper() const;

    Category category() const;
    Direction direction() const;
    Joining joining() const;
    bool mirrored() const;
    QChar mirroredChar() const;
    const QString &decomposition() const;
    Decomposition decompositionTag() const;
    unsigned char combiningClass() const;

    char latin1() const { return ucs > 0xff ? 0 : (char) ucs; }
    ushort unicode() const { return ucs; }



    ushort &unicode() { return ucs; }



    operator char() const { return latin1(); }


    bool isNull() const { return unicode()==0; }
    bool isPrint() const;
    bool isPunct() const;
    bool isSpace() const;
    bool isMark() const;
    bool isLetter() const;
    bool isNumber() const;
    bool isLetterOrNumber() const;
    bool isDigit() const;
    bool isSymbol() const;

    uchar cell() const { return ((uchar) ucs & 0xff); }
    uchar row() const { return ((uchar) (ucs>>8)&0xff); }
    void setCell( uchar cell ) { ucs = (ucs & 0xff00) + cell; }
    void setRow( uchar row ) { ucs = (((ushort) row)<<8) + (ucs&0xff); }

    static bool networkOrdered() {
 int wordSize;
 bool bigEndian = FALSE;
 qSysInfo( &wordSize, &bigEndian );
 return bigEndian;
    }

    friend inline bool operator==( char ch, QChar c );
    friend inline bool operator==( QChar c, char ch );
    friend inline bool operator==( QChar c1, QChar c2 );
    friend inline bool operator!=( QChar c1, QChar c2 );
    friend inline bool operator!=( char ch, QChar c );
    friend inline bool operator!=( QChar c, char ch );
    friend inline bool operator<=( QChar c, char ch );
    friend inline bool operator<=( char ch, QChar c );
    friend inline bool operator<=( QChar c1, QChar c2 );

private:
    ushort ucs;



} ;

inline QChar::QChar() : ucs( 0 )



{
}
inline QChar::QChar( char c ) : ucs( (uchar)c )



{
}
inline QChar::QChar( uchar c ) : ucs( c )



{
}
inline QChar::QChar( uchar c, uchar r ) : ucs( (r << 8) | c )



{
}
inline QChar::QChar( const QChar& c ) : ucs( c.ucs )



{
}

inline QChar::QChar( ushort rc ) : ucs( rc )



{
}
inline QChar::QChar( short rc ) : ucs( (ushort) rc )



{
}
inline QChar::QChar( uint rc ) : ucs( (ushort ) (rc & 0xffff) )



{
}
inline QChar::QChar( int rc ) : ucs( (ushort) (rc & 0xffff) )



{
}

inline bool operator==( char ch, QChar c )
{
    return ((uchar) ch) == c.ucs;
}

inline bool operator==( QChar c, char ch )
{
    return ((uchar) ch) == c.ucs;
}

inline bool operator==( QChar c1, QChar c2 )
{
    return c1.ucs == c2.ucs;
}

inline bool operator!=( QChar c1, QChar c2 )
{
    return c1.ucs != c2.ucs;
}

inline bool operator!=( char ch, QChar c )
{
    return ((uchar)ch) != c.ucs;
}

inline bool operator!=( QChar c, char ch )
{
    return ((uchar) ch) != c.ucs;
}

inline bool operator<=( QChar c, char ch )
{
    return c.ucs <= ((uchar) ch);
}

inline bool operator<=( char ch, QChar c )
{
    return ((uchar) ch) <= c.ucs;
}

inline bool operator<=( QChar c1, QChar c2 )
{
    return c1.ucs <= c2.ucs;
}

inline bool operator>=( QChar c, char ch ) { return ch <= c; }
inline bool operator>=( char ch, QChar c ) { return c <= ch; }
inline bool operator>=( QChar c1, QChar c2 ) { return c2 <= c1; }
inline bool operator<( QChar c, char ch ) { return !(ch<=c); }
inline bool operator<( char ch, QChar c ) { return !(c<=ch); }
inline bool operator<( QChar c1, QChar c2 ) { return !(c2<=c1); }
inline bool operator>( QChar c, char ch ) { return !(ch>=c); }
inline bool operator>( char ch, QChar c ) { return !(c>=ch); }
inline bool operator>( QChar c1, QChar c2 ) { return !(c2>=c1); }


struct QStringData : public QShared {
    QStringData() :
        QShared(), unicode(0), ascii(0), len(0), issimpletext(TRUE), maxl(0), islatin1(FALSE) { ref(); }
    QStringData(QChar *u, uint l, uint m) :
        QShared(), unicode(u), ascii(0), len(l), issimpletext(FALSE), maxl(m), islatin1(FALSE) { }
    ~QStringData() { if ( unicode ) delete[] ((char*)unicode);
                     if ( ascii ) delete[] ascii; }

    void deleteSelf();
    QChar *unicode;
    char *ascii;
    void setDirty() {
 if ( ascii ) {
     delete [] ascii;
     ascii = 0;
 }
 issimpletext = FALSE;
    }



    uint len : 30;

    uint issimpletext : 1;



    uint maxl : 30;

    uint islatin1 : 1;

private:

    QStringData( const QStringData& );
    QStringData& operator=( const QStringData& );

};


class QString
{
public:
    QString();
    QString( QChar );
    QString( const QString & );
    QString( const QByteArray& );
    QString( const QChar* unicode, uint length );

    QString( const char *str );




    ~QString();

    QString &operator=( const QString & );
    QString &operator=( const char * );



    QString &operator=( const QCString& );
    QString &operator=( QChar c );
    QString &operator=( char c );

    static const QString null;

    bool isNull() const;
    bool isEmpty() const;
    uint length() const;
    void truncate( uint pos );

    QString & fill( QChar c, int len = -1 );

    QString copy() const;

    QString arg( long a, int fieldWidth = 0, int base = 10 ) const;
    QString arg( ulong a, int fieldWidth = 0, int base = 10 ) const;
    QString arg( Q_LLONG a, int fieldwidth=0, int base=10 ) const;
    QString arg( Q_ULLONG a, int fieldwidth=0, int base=10 ) const;
    QString arg( int a, int fieldWidth = 0, int base = 10 ) const;
    QString arg( uint a, int fieldWidth = 0, int base = 10 ) const;
    QString arg( short a, int fieldWidth = 0, int base = 10 ) const;
    QString arg( ushort a, int fieldWidth = 0, int base = 10 ) const;
    QString arg( double a, int fieldWidth = 0, char fmt = 'g',
   int prec = -1 ) const;
    QString arg( char a, int fieldWidth = 0 ) const;
    QString arg( QChar a, int fieldWidth = 0 ) const;
    QString arg( const QString& a, int fieldWidth = 0 ) const;
    QString arg( const QString& a1, const QString& a2 ) const;
    QString arg( const QString& a1, const QString& a2,
   const QString& a3 ) const;
    QString arg( const QString& a1, const QString& a2, const QString& a3,
   const QString& a4 ) const;


    QString &sprintf( const char* format, ... )

        __attribute__ ((format (printf, 2, 3)))

        ;


    int find( QChar c, int index=0, bool cs=TRUE ) const;
    int find( char c, int index=0, bool cs=TRUE ) const;
    int find( const QString &str, int index=0, bool cs=TRUE ) const;

    int find( const QRegExp &, int index=0 ) const;


    int find( const char* str, int index=0 ) const;

    int findRev( QChar c, int index=-1, bool cs=TRUE) const;
    int findRev( char c, int index=-1, bool cs=TRUE) const;
    int findRev( const QString &str, int index=-1, bool cs=TRUE) const;

    int findRev( const QRegExp &, int index=-1 ) const;


    int findRev( const char* str, int index=-1 ) const;

    int contains( QChar c, bool cs=TRUE ) const;
    int contains( char c, bool cs=TRUE ) const
                    { return contains(QChar(c), cs); }

    int contains( const char* str, bool cs=TRUE ) const;

    int contains( const QString &str, bool cs=TRUE ) const;

    int contains( const QRegExp & ) const;


    enum SectionFlags {
 SectionDefault = 0x00,
 SectionSkipEmpty = 0x01,
 SectionIncludeLeadingSep = 0x02,
 SectionIncludeTrailingSep = 0x04,
 SectionCaseInsensitiveSeps = 0x08
    };
    QString section( QChar sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const;
    QString section( char sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const;

    QString section( const char *in_sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const;

    QString section( const QString &in_sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const;

    QString section( const QRegExp &reg, int start, int end = 0xffffffff, int flags = SectionDefault ) const;


    QString left( uint len ) const;
    QString right( uint len ) const;
    QString mid( uint index, uint len=0xffffffff) const;

    QString leftJustify( uint width, QChar fill=' ', bool trunc=FALSE)const;
    QString rightJustify( uint width, QChar fill=' ',bool trunc=FALSE)const;

    QString lower() const;
    QString upper() const;

    QString stripWhiteSpace() const;
    QString simplifyWhiteSpace() const;

    QString &insert( uint index, const QString & );

    QString &insert( uint index, const QByteArray & );
    QString &insert( uint index, const char * );

    QString &insert( uint index, const QChar*, uint len );
    QString &insert( uint index, QChar );
    QString &insert( uint index, char c ) { return insert(index,QChar(c)); }
    QString &append( char );
    QString &append( QChar );
    QString &append( const QString & );

    QString &append( const QByteArray & );
    QString &append( const char * );




    QString &prepend( char );
    QString &prepend( QChar );
    QString &prepend( const QString & );

    QString &prepend( const QByteArray & );
    QString &prepend( const char * );




    QString &remove( uint index, uint len );




    QString &remove( const QString & );
    QString &remove( const QString &, bool cs );

    QString &remove( QChar c );
    QString &remove( char c )
    { return remove( QChar(c) ); }

    QString &remove( const char * );


    QString &remove( const QRegExp & );

    QString &replace( uint index, uint len, const QString & );
    QString &replace( uint index, uint len, const QChar*, uint clen );
    QString &replace( uint index, uint len, QChar );
    QString &replace( uint index, uint len, char c )
    { return replace( index, len, QChar(c) ); }







    QString &replace( QChar c, const QString & );
    QString &replace( QChar c, const QString &, bool );


    QString &replace( char c, const QString & after )
    { return replace( QChar(c), after, TRUE ); }
    QString &replace( char c, const QString & after, bool cs )
    { return replace( QChar(c), after, cs ); }


    QString &replace( const QString &, const QString & );
    QString &replace( const QString &, const QString &, bool );


    QString &replace( const QRegExp &, const QString & );

    QString &replace( QChar, QChar );

    short toShort( bool *ok=0, int base=10 ) const;
    ushort toUShort( bool *ok=0, int base=10 ) const;
    int toInt( bool *ok=0, int base=10 ) const;
    uint toUInt( bool *ok=0, int base=10 ) const;
    long toLong( bool *ok=0, int base=10 ) const;
    ulong toULong( bool *ok=0, int base=10 ) const;
    Q_LLONG toLongLong( bool *ok=0, int base=10 ) const;
    Q_ULLONG toULongLong( bool *ok=0, int base=10 ) const;
    float toFloat( bool *ok=0 ) const;
    double toDouble( bool *ok=0 ) const;

    QString &setNum( short, int base=10 );
    QString &setNum( ushort, int base=10 );
    QString &setNum( int, int base=10 );
    QString &setNum( uint, int base=10 );
    QString &setNum( long, int base=10 );
    QString &setNum( ulong, int base=10 );
    QString &setNum( Q_LLONG, int base=10 );
    QString &setNum( Q_ULLONG, int base=10 );
    QString &setNum( float, char f='g', int prec=6 );
    QString &setNum( double, char f='g', int prec=6 );

    static QString number( long, int base=10 );
    static QString number( ulong, int base=10);
    static QString number( Q_LLONG, int base=10 );
    static QString number( Q_ULLONG, int base=10);
    static QString number( int, int base=10 );
    static QString number( uint, int base=10);
    static QString number( double, char f='g', int prec=6 );

    void setExpand( uint index, QChar c );

    QString &operator+=( const QString &str );

    QString &operator+=( const QByteArray &str );
    QString &operator+=( const char *str );




    QString &operator+=( QChar c );
    QString &operator+=( char c );

    QChar at( uint i ) const
        { return i < d->len ? d->unicode[i] : QChar::null; }
    QChar operator[]( int i ) const { return at((uint)i); }
    QCharRef at( uint i );
    QCharRef operator[]( int i );

    QChar constref(uint i) const
        { return at(i); }
    QChar& ref(uint i)
        {
            if ( d->count != 1 || i >= d->len )
                subat( i );
            d->setDirty();
            return d->unicode[i];
        }

    const QChar* unicode() const { return d->unicode; }
    const char* ascii() const;
    static QString fromAscii(const char*, int len=-1);
    const char* latin1() const;
    static QString fromLatin1(const char*, int len=-1);
    QCString utf8() const;
    static QString fromUtf8(const char*, int len=-1);
    QCString local8Bit() const;
    static QString fromLocal8Bit(const char*, int len=-1);
    bool operator!() const;

    operator const char *() const { return ascii(); }





    static QString fromUcs2( const unsigned short *ucs2 );
    const unsigned short *ucs2() const;

    QString &setUnicode( const QChar* unicode, uint len );
    QString &setUnicodeCodes( const ushort* unicode_as_ushorts, uint len );
    QString &setAscii( const char*, int len=-1 );
    QString &setLatin1( const char*, int len=-1 );

    int compare( const QString& s ) const;
    static int compare( const QString& s1, const QString& s2 )
    { return s1.compare( s2 ); }

    int localeAwareCompare( const QString& s ) const;
    static int localeAwareCompare( const QString& s1, const QString& s2 )
    { return s1.localeAwareCompare( s2 ); }


    friend QDataStream &operator>>( QDataStream &, QString & );


    void compose();


    const char* data() const { return ascii(); }







    bool startsWith( const QString& str ) const;
    bool startsWith( const QString& str, bool cs ) const;


    bool endsWith( const QString& str ) const;
    bool endsWith( const QString& str, bool cs ) const;


    void setLength( uint newLength );

    uint capacity() const;
    void reserve( uint minCapacity );
    void squeeze();

    bool simpleText() const { if ( !d->issimpletext ) checkSimpleText(); return (bool)d->issimpletext; }
    bool isRightToLeft() const;


private:
    QString( int size, bool );

    void deref();
    void real_detach();
    void subat( uint );
    QString multiArg( int numArgs, const QString& a1, const QString& a2,
        const QString& a3 = QString::null,
        const QString& a4 = QString::null ) const;

    void checkSimpleText() const;
    void grow( uint newLength );

    QString &insertHelper( uint index, const char *s, uint len=(2147483647 * 2U + 1U) );
    QString &operatorPlusEqHelper( const char *s, uint len2=(2147483647 * 2U + 1U) );


    static QChar* latin1ToUnicode( const char*, uint * len, uint maxlen=(uint)-1 );
    static QChar* latin1ToUnicode( const QByteArray&, uint * len );
    static char* unicodeToLatin1( const QChar*, uint len );

    QStringData *d;
    static QStringData* shared_null;
    static QStringData* makeSharedNull();

    friend class QConstString;
    friend class QTextStream;
    QString( QStringData* dd, bool ) : d(dd) { }


    void detach();
    friend class QDeepCopy<QString>;
};

class QCharRef {
    friend class QString;
    QString& s;
    uint p;
    QCharRef(QString* str, uint pos) : s(*str), p(pos) { }

public:




    ushort unicode() const { return s.constref(p).unicode(); }
    char latin1() const { return s.constref(p).latin1(); }


    QCharRef operator=(char c ) { s.ref(p)=c; return *this; }
    QCharRef operator=(uchar c ) { s.ref(p)=c; return *this; }
    QCharRef operator=(QChar c ) { s.ref(p)=c; return *this; }
    QCharRef operator=(const QCharRef& c ) { s.ref(p)=c.unicode(); return *this; }
    QCharRef operator=(ushort rc ) { s.ref(p)=rc; return *this; }
    QCharRef operator=(short rc ) { s.ref(p)=rc; return *this; }
    QCharRef operator=(uint rc ) { s.ref(p)=rc; return *this; }
    QCharRef operator=(int rc ) { s.ref(p)=rc; return *this; }

    operator QChar () const { return s.constref(p); }


    bool isNull() const { return unicode()==0; }
    bool isPrint() const { return s.constref(p).isPrint(); }
    bool isPunct() const { return s.constref(p).isPunct(); }
    bool isSpace() const { return s.constref(p).isSpace(); }
    bool isMark() const { return s.constref(p).isMark(); }
    bool isLetter() const { return s.constref(p).isLetter(); }
    bool isNumber() const { return s.constref(p).isNumber(); }
    bool isLetterOrNumber() { return s.constref(p).isLetterOrNumber(); }
    bool isDigit() const { return s.constref(p).isDigit(); }

    int digitValue() const { return s.constref(p).digitValue(); }
    QChar lower() const { return s.constref(p).lower(); }
    QChar upper() const { return s.constref(p).upper(); }

    QChar::Category category() const { return s.constref(p).category(); }
    QChar::Direction direction() const { return s.constref(p).direction(); }
    QChar::Joining joining() const { return s.constref(p).joining(); }
    bool mirrored() const { return s.constref(p).mirrored(); }
    QChar mirroredChar() const { return s.constref(p).mirroredChar(); }
    const QString &decomposition() const { return s.constref(p).decomposition(); }
    QChar::Decomposition decompositionTag() const { return s.constref(p).decompositionTag(); }
    unsigned char combiningClass() const { return s.constref(p).combiningClass(); }


    uchar cell() const { return s.constref(p).cell(); }
    uchar row() const { return s.constref(p).row(); }

};

inline QCharRef QString::at( uint i ) { return QCharRef(this,i); }
inline QCharRef QString::operator[]( int i ) { return at((uint)i); }


class QConstString : private QString {
public:
    QConstString( const QChar* unicode, uint length );
    ~QConstString();
    const QString& string() const { return *this; }
};






 QDataStream &operator<<( QDataStream &, const QString & );
 QDataStream &operator>>( QDataStream &, QString & );
# 838 "../tools/qstring.h"
inline QString::QString() :
    d(shared_null ? shared_null : makeSharedNull())
{
    d->ref();
}

inline QString::~QString()
{
    if ( d->deref() ) {
        if ( d != shared_null )
     d->deleteSelf();
    }
}


inline void QString::detach()
{ real_detach(); }

inline QString QString::section( QChar sep, int start, int end, int flags ) const
{ return section(QString(sep), start, end, flags); }

inline QString QString::section( char sep, int start, int end, int flags ) const
{ return section(QChar(sep), start, end, flags); }


inline QString QString::section( const char *in_sep, int start, int end, int flags ) const
{ return section(QString(in_sep), start, end, flags); }


inline QString &QString::operator=( QChar c )
{ *this = QString(c); return *this; }

inline QString &QString::operator=( char c )
{ *this = QString(QChar(c)); return *this; }

inline bool QString::isNull() const
{ return unicode() == 0; }

inline bool QString::operator!() const
{ return isNull(); }

inline uint QString::length() const
{ return d->len; }

inline uint QString::capacity() const
{ return d->maxl; }

inline bool QString::isEmpty() const
{ return length() == 0; }

inline QString QString::copy() const
{ return QString( *this ); }


inline QString &QString::insert( uint index, const char *s )
{ return insertHelper( index, s ); }

inline QString &QString::insert( uint index, const QByteArray &s )
{
    int pos = s.find( 0 );
    return insertHelper( index, s, pos==-1 ? s.size() : pos );
}


inline QString &QString::prepend( const QString & s )
{ return insert(0,s); }

inline QString &QString::prepend( QChar c )
{ return insert(0,c); }

inline QString &QString::prepend( char c )
{ return insert(0,c); }


inline QString &QString::prepend( const QByteArray & s )
{ return insert(0,s); }



inline QString &QString::operator+=( const QByteArray &s )
{
    int pos = s.find( 0 );
    return operatorPlusEqHelper( s, pos==-1 ? s.size() : pos );
}


inline QString &QString::append( const QString & s )
{ return operator+=(s); }


inline QString &QString::append( const QByteArray &s )
{ return operator+=(s); }

inline QString &QString::append( const char * s )
{ return operator+=(s); }


inline QString &QString::append( QChar c )
{ return operator+=(c); }

inline QString &QString::append( char c )
{ return operator+=(c); }
# 954 "../tools/qstring.h"
inline QString &QString::setNum( short n, int base )
{ return setNum((Q_LLONG)n, base); }

inline QString &QString::setNum( ushort n, int base )
{ return setNum((Q_ULLONG)n, base); }

inline QString &QString::setNum( int n, int base )
{ return setNum((Q_LLONG)n, base); }

inline QString &QString::setNum( uint n, int base )
{ return setNum((Q_ULLONG)n, base); }

inline QString &QString::setNum( float n, char f, int prec )
{ return setNum((double)n,f,prec); }

inline QString QString::arg( int a, int fieldWidth, int base ) const
{ return arg( (Q_LLONG)a, fieldWidth, base ); }

inline QString QString::arg( uint a, int fieldWidth, int base ) const
{ return arg( (Q_ULLONG)a, fieldWidth, base ); }

inline QString QString::arg( short a, int fieldWidth, int base ) const
{ return arg( (Q_LLONG)a, fieldWidth, base ); }

inline QString QString::arg( ushort a, int fieldWidth, int base ) const
{ return arg( (Q_ULLONG)a, fieldWidth, base ); }

inline QString QString::arg( const QString& a1, const QString& a2 ) const {
    return multiArg( 2, a1, a2 );
}

inline QString QString::arg( const QString& a1, const QString& a2,
        const QString& a3 ) const {
    return multiArg( 3, a1, a2, a3 );
}

inline QString QString::arg( const QString& a1, const QString& a2,
        const QString& a3, const QString& a4 ) const {
    return multiArg( 4, a1, a2, a3, a4 );
}

inline int QString::find( char c, int index, bool cs ) const
{ return find(QChar(c), index, cs); }

inline int QString::findRev( char c, int index, bool cs ) const
{ return findRev( QChar(c), index, cs ); }


inline int QString::find( const char* str, int index ) const
{ return find(QString::fromAscii(str), index); }

inline int QString::findRev( const char* str, int index ) const
{ return findRev(QString::fromAscii(str), index); }







 bool operator!=( const QString &s1, const QString &s2 );
 bool operator<( const QString &s1, const QString &s2 );
 bool operator<=( const QString &s1, const QString &s2 );
 bool operator==( const QString &s1, const QString &s2 );
 bool operator>( const QString &s1, const QString &s2 );
 bool operator>=( const QString &s1, const QString &s2 );

 bool operator!=( const QString &s1, const char *s2 );
 bool operator<( const QString &s1, const char *s2 );
 bool operator<=( const QString &s1, const char *s2 );
 bool operator==( const QString &s1, const char *s2 );
 bool operator>( const QString &s1, const char *s2 );
 bool operator>=( const QString &s1, const char *s2 );
 bool operator!=( const char *s1, const QString &s2 );
 bool operator<( const char *s1, const QString &s2 );
 bool operator<=( const char *s1, const QString &s2 );
 bool operator==( const char *s1, const QString &s2 );

 bool operator>=( const char *s1, const QString &s2 );


 inline const QString operator+( const QString &s1, const QString &s2 )
{
    QString tmp( s1 );
    tmp += s2;
    return tmp;
}


 inline const QString operator+( const QString &s1, const char *s2 )
{
    QString tmp( s1 );
    tmp += QString::fromAscii(s2);
    return tmp;
}

 inline const QString operator+( const char *s1, const QString &s2 )
{
    QString tmp = QString::fromAscii( s1 );
    tmp += s2;
    return tmp;
}


 inline const QString operator+( const QString &s1, QChar c2 )
{
    QString tmp( s1 );
    tmp += c2;
    return tmp;
}

 inline const QString operator+( const QString &s1, char c2 )
{
    QString tmp( s1 );
    tmp += c2;
    return tmp;
}

 inline const QString operator+( QChar c1, const QString &s2 )
{
    QString tmp;
    tmp += c1;
    tmp += s2;
    return tmp;
}

 inline const QString operator+( char c1, const QString &s2 )
{
    QString tmp;
    tmp += c1;
    tmp += s2;
    return tmp;
}
# 1111 "../tools/qstring.h"
# 1 "../tools/qwinexport.h" 1
# 1112 "../tools/qstring.h" 2
# 40 "../tools/qcstring.cpp" 2
# 1 "../tools/qregexp.h" 1
# 42 "../tools/qregexp.h"
# 1 "../tools/qstringlist.h" 1
# 42 "../tools/qstringlist.h"
# 1 "../tools/qvaluelist.h" 1
# 42 "../tools/qvaluelist.h"
# 1 "../tools/qtl.h" 1
# 42 "../tools/qtl.h"
# 1 "../tools/qglobal.h" 1
# 43 "../tools/qtl.h" 2
# 1 "../tools/qtextstream.h" 1
# 42 "../tools/qtextstream.h"
# 1 "../tools/qiodevice.h" 1
# 42 "../tools/qiodevice.h"
# 1 "../tools/qglobal.h" 1
# 43 "../tools/qiodevice.h" 2
# 88 "../tools/qiodevice.h"
class QIODevice
{
public:



    typedef Q_ULONG Offset;


    QIODevice();
    virtual ~QIODevice();

    int flags() const { return ioMode; }
    int mode() const { return ioMode & 0x00ff; }
    int state() const { return ioMode & 0xf000; }

    bool isDirectAccess() const { return ((ioMode & 0x0100) == 0x0100); }
    bool isSequentialAccess() const { return ((ioMode & 0x0200) == 0x0200); }
    bool isCombinedAccess() const { return ((ioMode & 0x0300) == 0x0300); }
    bool isBuffered() const { return ((ioMode & 0x0040) != 0x0040); }
    bool isRaw() const { return ((ioMode & 0x0040) == 0x0040); }
    bool isSynchronous() const { return ((ioMode & 0x0080) != 0x0080); }
    bool isAsynchronous() const { return ((ioMode & 0x0080) == 0x0080); }
    bool isTranslated() const { return ((ioMode & 0x0010) == 0x0010); }
    bool isReadable() const { return ((ioMode & 0x0001) == 0x0001); }
    bool isWritable() const { return ((ioMode & 0x0002) == 0x0002); }
    bool isReadWrite() const { return ((ioMode & 0x0003) == 0x0003); }
    bool isInactive() const { return state() == 0; }
    bool isOpen() const { return state() == 0x1000; }

    int status() const { return ioSt; }
    void resetStatus() { ioSt = 0; }

    virtual bool open( int mode ) = 0;
    virtual void close() = 0;
    virtual void flush() = 0;

    virtual Offset size() const = 0;
    virtual Offset at() const;
    virtual bool at( Offset );
    virtual bool atEnd() const;
    bool reset() { return at(0); }

    virtual Q_LONG readBlock( char *data, Q_ULONG maxlen ) = 0;
    virtual Q_LONG writeBlock( const char *data, Q_ULONG len ) = 0;
    virtual Q_LONG readLine( char *data, Q_ULONG maxlen );
    Q_LONG writeBlock( const QByteArray& data );
    virtual QByteArray readAll();

    virtual int getch() = 0;
    virtual int putch( int ) = 0;
    virtual int ungetch( int ) = 0;

protected:
    void setFlags( int f ) { ioMode = f; }
    void setType( int );
    void setMode( int );
    void setState( int );
    void setStatus( int );
    Offset ioIndex;

private:
    int ioMode;
    int ioSt;

private:

    QIODevice( const QIODevice & );
    QIODevice &operator=( const QIODevice & );

};
# 43 "../tools/qtextstream.h" 2

# 1 "/usr/include/stdio.h" 1 3 4
# 30 "/usr/include/stdio.h" 3 4
extern "C" {



# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/stddef.h" 1 3 4
# 35 "/usr/include/stdio.h" 2 3 4

# 1 "/usr/include/bits/types.h" 1 3 4
# 28 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/usr/include/bits/types.h" 2 3 4


# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/stddef.h" 1 3 4
# 32 "/usr/include/bits/types.h" 2 3 4


typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;


typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;




__extension__ typedef signed long long int __int64_t;
__extension__ typedef unsigned long long int __uint64_t;







__extension__ typedef long long int __quad_t;
__extension__ typedef unsigned long long int __u_quad_t;
# 129 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/typesizes.h" 1 3 4
# 130 "/usr/include/bits/types.h" 2 3 4






__extension__ typedef __u_quad_t __dev_t;
__extension__ typedef unsigned int __uid_t;
__extension__ typedef unsigned int __gid_t;
__extension__ typedef unsigned long int __ino_t;
__extension__ typedef __u_quad_t __ino64_t;
__extension__ typedef unsigned int __mode_t;
__extension__ typedef unsigned int __nlink_t;
__extension__ typedef long int __off_t;
__extension__ typedef __quad_t __off64_t;
__extension__ typedef int __pid_t;
__extension__ typedef struct { int __val[2]; } __fsid_t;
__extension__ typedef long int __clock_t;
__extension__ typedef unsigned long int __rlim_t;
__extension__ typedef __u_quad_t __rlim64_t;
__extension__ typedef unsigned int __id_t;
__extension__ typedef long int __time_t;
__extension__ typedef unsigned int __useconds_t;
__extension__ typedef long int __suseconds_t;

__extension__ typedef int __daddr_t;
__extension__ typedef long int __swblk_t;
__extension__ typedef int __key_t;


__extension__ typedef int __clockid_t;


__extension__ typedef void * __timer_t;


__extension__ typedef long int __blksize_t;




__extension__ typedef long int __blkcnt_t;
__extension__ typedef __quad_t __blkcnt64_t;


__extension__ typedef unsigned long int __fsblkcnt_t;
__extension__ typedef __u_quad_t __fsblkcnt64_t;


__extension__ typedef unsigned long int __fsfilcnt_t;
__extension__ typedef __u_quad_t __fsfilcnt64_t;

__extension__ typedef int __ssize_t;



typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;


__extension__ typedef int __intptr_t;


__extension__ typedef unsigned int __socklen_t;
# 37 "/usr/include/stdio.h" 2 3 4









typedef struct _IO_FILE FILE;





# 62 "/usr/include/stdio.h" 3 4
typedef struct _IO_FILE __FILE;
# 72 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/libio.h" 1 3 4
# 32 "/usr/include/libio.h" 3 4
# 1 "/usr/include/_G_config.h" 1 3 4
# 14 "/usr/include/_G_config.h" 3 4
# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/stddef.h" 1 3 4
# 354 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/stddef.h" 3 4
typedef unsigned int wint_t;
# 15 "/usr/include/_G_config.h" 2 3 4
# 24 "/usr/include/_G_config.h" 3 4
# 1 "/usr/include/wchar.h" 1 3 4
# 48 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/stddef.h" 1 3 4
# 49 "/usr/include/wchar.h" 2 3 4

# 1 "/usr/include/bits/wchar.h" 1 3 4
# 51 "/usr/include/wchar.h" 2 3 4
# 76 "/usr/include/wchar.h" 3 4
typedef struct
{
  int __count;
  union
  {
    wint_t __wch;
    char __wchb[4];
  } __value;
} __mbstate_t;
# 25 "/usr/include/_G_config.h" 2 3 4

typedef struct
{
  __off_t __pos;
  __mbstate_t __state;
} _G_fpos_t;
typedef struct
{
  __off64_t __pos;
  __mbstate_t __state;
} _G_fpos64_t;
# 44 "/usr/include/_G_config.h" 3 4
# 1 "/usr/include/gconv.h" 1 3 4
# 28 "/usr/include/gconv.h" 3 4
# 1 "/usr/include/wchar.h" 1 3 4
# 48 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/stddef.h" 1 3 4
# 49 "/usr/include/wchar.h" 2 3 4
# 29 "/usr/include/gconv.h" 2 3 4


# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/stddef.h" 1 3 4
# 32 "/usr/include/gconv.h" 2 3 4





enum
{
  __GCONV_OK = 0,
  __GCONV_NOCONV,
  __GCONV_NODB,
  __GCONV_NOMEM,

  __GCONV_EMPTY_INPUT,
  __GCONV_FULL_OUTPUT,
  __GCONV_ILLEGAL_INPUT,
  __GCONV_INCOMPLETE_INPUT,

  __GCONV_ILLEGAL_DESCRIPTOR,
  __GCONV_INTERNAL_ERROR
};



enum
{
  __GCONV_IS_LAST = 0x0001,
  __GCONV_IGNORE_ERRORS = 0x0002
};



struct __gconv_step;
struct __gconv_step_data;
struct __gconv_loaded_object;
struct __gconv_trans_data;



typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
       __const unsigned char **, __const unsigned char *,
       unsigned char **, size_t *, int, int);


typedef wint_t (*__gconv_btowc_fct) (struct __gconv_step *, unsigned char);


typedef int (*__gconv_init_fct) (struct __gconv_step *);
typedef void (*__gconv_end_fct) (struct __gconv_step *);



typedef int (*__gconv_trans_fct) (struct __gconv_step *,
      struct __gconv_step_data *, void *,
      __const unsigned char *,
      __const unsigned char **,
      __const unsigned char *, unsigned char **,
      size_t *);


typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
       __const unsigned char *,
       unsigned char *, unsigned char *);


typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***,
     size_t *);


typedef int (*__gconv_trans_init_fct) (void **, const char *);
typedef void (*__gconv_trans_end_fct) (void *);

struct __gconv_trans_data
{

  __gconv_trans_fct __trans_fct;
  __gconv_trans_context_fct __trans_context_fct;
  __gconv_trans_end_fct __trans_end_fct;
  void *__data;
  struct __gconv_trans_data *__next;
};



struct __gconv_step
{
  struct __gconv_loaded_object *__shlib_handle;
  __const char *__modname;

  int __counter;

  char *__from_name;
  char *__to_name;

  __gconv_fct __fct;
  __gconv_btowc_fct __btowc_fct;
  __gconv_init_fct __init_fct;
  __gconv_end_fct __end_fct;



  int __min_needed_from;
  int __max_needed_from;
  int __min_needed_to;
  int __max_needed_to;


  int __stateful;

  void *__data;
};



struct __gconv_step_data
{
  unsigned char *__outbuf;
  unsigned char *__outbufend;



  int __flags;



  int __invocation_counter;



  int __internal_use;

  __mbstate_t *__statep;
  __mbstate_t __state;



  struct __gconv_trans_data *__trans;
};



typedef struct __gconv_info
{
  size_t __nsteps;
  struct __gconv_step *__steps;
  __extension__ struct __gconv_step_data __data [];
} *__gconv_t;
# 45 "/usr/include/_G_config.h" 2 3 4
typedef union
{
  struct __gconv_info __cd;
  struct
  {
    struct __gconv_info __cd;
    struct __gconv_step_data __data;
  } __combined;
} _G_iconv_t;

typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
# 33 "/usr/include/libio.h" 2 3 4
# 53 "/usr/include/libio.h" 3 4
# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/stdarg.h" 1 3 4
# 43 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 54 "/usr/include/libio.h" 2 3 4
# 166 "/usr/include/libio.h" 3 4
struct _IO_jump_t; struct _IO_FILE;
# 176 "/usr/include/libio.h" 3 4
typedef void _IO_lock_t;





struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;



  int _pos;
# 199 "/usr/include/libio.h" 3 4
};


enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};
# 267 "/usr/include/libio.h" 3 4
struct _IO_FILE {
  int _flags;




  char* _IO_read_ptr;
  char* _IO_read_end;
  char* _IO_read_base;
  char* _IO_write_base;
  char* _IO_write_ptr;
  char* _IO_write_end;
  char* _IO_buf_base;
  char* _IO_buf_end;

  char *_IO_save_base;
  char *_IO_backup_base;
  char *_IO_save_end;

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;



  int _flags2;

  __off_t _old_offset;



  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];



  _IO_lock_t *_lock;
# 315 "/usr/include/libio.h" 3 4
  __off64_t _offset;





  void *__pad1;
  void *__pad2;

  int _mode;

  char _unused2[15 * sizeof (int) - 2 * sizeof (void *)];

};





struct _IO_FILE_plus;

extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
# 354 "/usr/include/libio.h" 3 4
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);







typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
     size_t __n);







typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);


typedef int __io_close_fn (void *__cookie);




typedef __io_read_fn cookie_read_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_close_fn cookie_close_function_t;


typedef struct
{
  __io_read_fn *read;
  __io_write_fn *write;
  __io_seek_fn *seek;
  __io_close_fn *close;
} _IO_cookie_io_functions_t;
typedef _IO_cookie_io_functions_t cookie_io_functions_t;

struct _IO_cookie_file;


extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
        void *__cookie, _IO_cookie_io_functions_t __fns);




extern "C" {


extern int __underflow (_IO_FILE *) throw ();
extern int __uflow (_IO_FILE *) throw ();
extern int __overflow (_IO_FILE *, int) throw ();
extern wint_t __wunderflow (_IO_FILE *) throw ();
extern wint_t __wuflow (_IO_FILE *) throw ();
extern wint_t __woverflow (_IO_FILE *, wint_t) throw ();
# 444 "/usr/include/libio.h" 3 4
extern int _IO_getc (_IO_FILE *__fp) throw ();
extern int _IO_putc (int __c, _IO_FILE *__fp) throw ();
extern int _IO_feof (_IO_FILE *__fp) throw ();
extern int _IO_ferror (_IO_FILE *__fp) throw ();

extern int _IO_peekc_locked (_IO_FILE *__fp) throw ();





extern void _IO_flockfile (_IO_FILE *) throw ();
extern void _IO_funlockfile (_IO_FILE *) throw ();
extern int _IO_ftrylockfile (_IO_FILE *) throw ();
# 474 "/usr/include/libio.h" 3 4
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
   __gnuc_va_list, int *__restrict) throw ();
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
    __gnuc_va_list) throw ();
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t) throw ();
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t) throw ();

extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int) throw ();
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int) throw ();

extern void _IO_free_backup_area (_IO_FILE *) throw ();
# 532 "/usr/include/libio.h" 3 4
}
# 73 "/usr/include/stdio.h" 2 3 4




typedef __gnuc_va_list va_list;
# 86 "/usr/include/stdio.h" 3 4


typedef _G_fpos_t fpos_t;





typedef _G_fpos64_t fpos64_t;
# 138 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 139 "/usr/include/stdio.h" 2 3 4



extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;







extern int remove (__const char *__filename) throw ();

extern int rename (__const char *__old, __const char *__new) throw ();









extern FILE *tmpfile (void);
# 174 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile64 (void);



extern char *tmpnam (char *__s) throw ();





extern char *tmpnam_r (char *__s) throw ();
# 196 "/usr/include/stdio.h" 3 4
extern char *tempnam (__const char *__dir, __const char *__pfx)
     throw () __attribute__ ((__malloc__));








extern int fclose (FILE *__stream);




extern int fflush (FILE *__stream);

# 221 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 231 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);









extern FILE *fopen (__const char *__restrict __filename,
      __const char *__restrict __modes);




extern FILE *freopen (__const char *__restrict __filename,
        __const char *__restrict __modes,
        FILE *__restrict __stream);
# 262 "/usr/include/stdio.h" 3 4


extern FILE *fopen64 (__const char *__restrict __filename,
        __const char *__restrict __modes);
extern FILE *freopen64 (__const char *__restrict __filename,
   __const char *__restrict __modes,
   FILE *__restrict __stream);




extern FILE *fdopen (int __fd, __const char *__modes) throw ();





extern FILE *fopencookie (void *__restrict __magic_cookie,
     __const char *__restrict __modes,
     _IO_cookie_io_functions_t __io_funcs) throw ();


extern FILE *fmemopen (void *__s, size_t __len, __const char *__modes) throw ();




extern FILE *open_memstream (char **__restrict __bufloc,
        size_t *__restrict __sizeloc) throw ();






extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();



extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
      int __modes, size_t __n) throw ();





extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
         size_t __size) throw ();


extern void setlinebuf (FILE *__stream) throw ();








extern int fprintf (FILE *__restrict __stream,
      __const char *__restrict __format, ...);




extern int printf (__const char *__restrict __format, ...);

extern int sprintf (char *__restrict __s,
      __const char *__restrict __format, ...) throw ();





extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
       __gnuc_va_list __arg);




extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg);

extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
       __gnuc_va_list __arg) throw ();





extern int snprintf (char *__restrict __s, size_t __maxlen,
       __const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 3, 4)));

extern int vsnprintf (char *__restrict __s, size_t __maxlen,
        __const char *__restrict __format, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 3, 0)));






extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f,
        __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__printf__, 2, 0)));
extern int __asprintf (char **__restrict __ptr,
         __const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int asprintf (char **__restrict __ptr,
       __const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3)));







extern int vdprintf (int __fd, __const char *__restrict __fmt,
       __gnuc_va_list __arg)
     __attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
     __attribute__ ((__format__ (__printf__, 2, 3)));








extern int fscanf (FILE *__restrict __stream,
     __const char *__restrict __format, ...);




extern int scanf (__const char *__restrict __format, ...);

extern int sscanf (__const char *__restrict __s,
     __const char *__restrict __format, ...) throw ();








extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
      __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 2, 0)));





extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 1, 0)));


extern int vsscanf (__const char *__restrict __s,
      __const char *__restrict __format, __gnuc_va_list __arg)
     throw () __attribute__ ((__format__ (__scanf__, 2, 0)));









extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);





extern int getchar (void);

# 454 "/usr/include/stdio.h" 3 4
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 465 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);











extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);





extern int putchar (int __c);

# 498 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);







extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);






extern int getw (FILE *__stream);


extern int putw (int __w, FILE *__stream);








extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream);






extern char *gets (char *__s);

# 543 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
        FILE *__restrict __stream);
# 559 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
          size_t *__restrict __n, int __delimiter,
          FILE *__restrict __stream);
extern __ssize_t getdelim (char **__restrict __lineptr,
        size_t *__restrict __n, int __delimiter,
        FILE *__restrict __stream);







extern __ssize_t getline (char **__restrict __lineptr,
       size_t *__restrict __n,
       FILE *__restrict __stream);








extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);





extern int puts (__const char *__s);






extern int ungetc (int __c, FILE *__stream);






extern size_t fread (void *__restrict __ptr, size_t __size,
       size_t __n, FILE *__restrict __stream);




extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
        size_t __n, FILE *__restrict __s);

# 620 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (__const char *__restrict __s,
      FILE *__restrict __stream);
# 631 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
         size_t __n, FILE *__restrict __stream);
extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
          size_t __n, FILE *__restrict __stream);








extern int fseek (FILE *__stream, long int __off, int __whence);




extern long int ftell (FILE *__stream);




extern void rewind (FILE *__stream);

# 667 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off_t __off, int __whence);




extern __off_t ftello (FILE *__stream);
# 686 "/usr/include/stdio.h" 3 4






extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);




extern int fsetpos (FILE *__stream, __const fpos_t *__pos);
# 709 "/usr/include/stdio.h" 3 4



extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream);
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos);




extern void clearerr (FILE *__stream) throw ();

extern int feof (FILE *__stream) throw ();

extern int ferror (FILE *__stream) throw ();




extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw ();
extern int ferror_unlocked (FILE *__stream) throw ();








extern void perror (__const char *__s);






# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
# 27 "/usr/include/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern __const char *__const sys_errlist[];


extern int _sys_nerr;
extern __const char *__const _sys_errlist[];
# 748 "/usr/include/stdio.h" 2 3 4




extern int fileno (FILE *__stream) throw ();




extern int fileno_unlocked (FILE *__stream) throw ();
# 767 "/usr/include/stdio.h" 3 4
extern FILE *popen (__const char *__command, __const char *__modes);





extern int pclose (FILE *__stream);





extern char *ctermid (char *__s) throw ();





extern char *cuserid (char *__s);




struct obstack;


extern int obstack_printf (struct obstack *__restrict __obstack,
      __const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
       __const char *__restrict __format,
       __gnuc_va_list __args)
     throw () __attribute__ ((__format__ (__printf__, 2, 0)));







extern void flockfile (FILE *__stream) throw ();



extern int ftrylockfile (FILE *__stream) throw ();


extern void funlockfile (FILE *__stream) throw ();
# 828 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio.h" 1 3 4
# 33 "/usr/include/bits/stdio.h" 3 4
inline int
vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg)
{
  return vfprintf (stdout, __fmt, __arg);
}


inline int
getchar (void)
{
  return _IO_getc (stdin);
}




inline int
getc_unlocked (FILE *__fp)
{
  return (__builtin_expect ((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end, 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}


inline int
getchar_unlocked (void)
{
  return (__builtin_expect ((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end, 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}




inline int
putchar (int __c)
{
  return _IO_putc (__c, stdout);
}




inline int
fputc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect ((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end, 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}





inline int
putc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect ((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end, 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}


inline int
putchar_unlocked (int __c)
{
  return (__builtin_expect ((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end, 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}





inline __ssize_t
getline (char **__lineptr, size_t *__n, FILE *__stream)
{
  return __getdelim (__lineptr, __n, '\n', __stream);
}





inline int
feof_unlocked (FILE *__stream) throw ()
{
  return (((__stream)->_flags & 0x10) != 0);
}


inline int
ferror_unlocked (FILE *__stream) throw ()
{
  return (((__stream)->_flags & 0x20) != 0);
}
# 829 "/usr/include/stdio.h" 2 3 4





}
# 45 "../tools/qtextstream.h" 2



class QTextCodec;
class QTextDecoder;

class QTextStreamPrivate;

class QTextStream
{
public:
    enum Encoding { Locale, Latin1, Unicode, UnicodeNetworkOrder,
      UnicodeReverse, RawUnicode, UnicodeUTF8 };

    void setEncoding( Encoding );

    void setCodec( QTextCodec* );
    QTextCodec *codec();


    QTextStream();
    QTextStream( QIODevice * );
    QTextStream( QString*, int mode );
    QTextStream( QString&, int mode );
    QTextStream( QByteArray, int mode );
    QTextStream( FILE *, int mode );
    virtual ~QTextStream();

    QIODevice *device() const;
    void setDevice( QIODevice * );
    void unsetDevice();

    bool atEnd() const;
    bool eof() const;

    QTextStream &operator>>( QChar & );
    QTextStream &operator>>( char & );
    QTextStream &operator>>( signed short & );
    QTextStream &operator>>( unsigned short & );
    QTextStream &operator>>( signed int & );
    QTextStream &operator>>( unsigned int & );
    QTextStream &operator>>( signed long & );
    QTextStream &operator>>( unsigned long & );
    QTextStream &operator>>( float & );
    QTextStream &operator>>( double & );
    QTextStream &operator>>( char * );
    QTextStream &operator>>( QString & );
    QTextStream &operator>>( QCString & );

    QTextStream &operator<<( QChar );
    QTextStream &operator<<( char );
    QTextStream &operator<<( signed short );
    QTextStream &operator<<( unsigned short );
    QTextStream &operator<<( signed int );
    QTextStream &operator<<( unsigned int );
    QTextStream &operator<<( signed long );
    QTextStream &operator<<( unsigned long );
    QTextStream &operator<<( float );
    QTextStream &operator<<( double );
    QTextStream &operator<<( const char* );
    QTextStream &operator<<( const QString & );
    QTextStream &operator<<( const QCString & );
    QTextStream &operator<<( void * );

    QTextStream &readRawBytes( char *, uint len );
    QTextStream &writeRawBytes( const char* , uint len );

    QString readLine();
    QString read();
    void skipWhiteSpace();

    enum {
 skipws = 0x0001,
 left = 0x0002,
 right = 0x0004,
 internal = 0x0008,
 bin = 0x0010,
 oct = 0x0020,
 dec = 0x0040,
 hex = 0x0080,
 showbase = 0x0100,
 showpoint = 0x0200,
 uppercase = 0x0400,
 showpos = 0x0800,
 scientific= 0x1000,
 fixed = 0x2000
    };

    static const int basefield;
    static const int adjustfield;
    static const int floatfield;

    int flags() const;
    int flags( int f );
    int setf( int bits );
    int setf( int bits, int mask );
    int unsetf( int bits );

    void reset();

    int width() const;
    int width( int );
    int fill() const;
    int fill( int );
    int precision() const;
    int precision( int );

private:
    long input_int();
    void init();
    QTextStream &output_int( int, ulong, bool );
    QIODevice *dev;

    int fflags;
    int fwidth;
    int fillchar;
    int fprec;
    bool doUnicodeHeader;
    bool owndev;
    QTextCodec *mapper;
    QTextStreamPrivate * d;
    QChar unused1;
    bool latin1;
    bool internalOrder;
    bool networkOrder;
    void *unused2;

    QChar eat_ws();
    uint ts_getline( QChar* );
    void ts_ungetc( QChar );
    QChar ts_getc();
    uint ts_getbuf( QChar*, uint );
    void ts_putc(int);
    void ts_putc(QChar);
    bool ts_isspace(QChar);
    bool ts_isdigit(QChar);
    ulong input_bin();
    ulong input_oct();
    ulong input_dec();
    ulong input_hex();
    double input_double();
    QTextStream &writeBlock( const char* p, uint len );
    QTextStream &writeBlock( const QChar* p, uint len );

private:

    QTextStream( const QTextStream & );
    QTextStream &operator=( const QTextStream & );

};

typedef QTextStream QTS;

class QTextIStream : public QTextStream {
public:
    QTextIStream( const QString* s ) :
 QTextStream((QString*)s,0x0001) { }
    QTextIStream( QByteArray ba ) :
 QTextStream(ba,0x0001) { }
    QTextIStream( FILE *f ) :
 QTextStream(f,0x0001) { }

private:

    QTextIStream( const QTextIStream & );
    QTextIStream &operator=( const QTextIStream & );

};

class QTextOStream : public QTextStream {
public:
    QTextOStream( QString* s ) :
 QTextStream(s,0x0002) { }
    QTextOStream( QByteArray ba ) :
 QTextStream(ba,0x0002) { }
    QTextOStream( FILE *f ) :
 QTextStream(f,0x0002) { }

private:

    QTextOStream( const QTextOStream & );
    QTextOStream &operator=( const QTextOStream & );

};





inline QIODevice *QTextStream::device() const
{ return dev; }

inline bool QTextStream::atEnd() const
{ return dev ? dev->atEnd() : FALSE; }

inline bool QTextStream::eof() const
{ return atEnd(); }

inline int QTextStream::flags() const
{ return fflags; }

inline int QTextStream::flags( int f )
{ int oldf = fflags; fflags = f; return oldf; }

inline int QTextStream::setf( int bits )
{ int oldf = fflags; fflags |= bits; return oldf; }

inline int QTextStream::setf( int bits, int mask )
{ int oldf = fflags; fflags = (fflags & ~mask) | (bits & mask); return oldf; }

inline int QTextStream::unsetf( int bits )
{ int oldf = fflags; fflags &= ~bits; return oldf; }

inline int QTextStream::width() const
{ return fwidth; }

inline int QTextStream::width( int w )
{ int oldw = fwidth; fwidth = w; return oldw; }

inline int QTextStream::fill() const
{ return fillchar; }

inline int QTextStream::fill( int f )
{ int oldc = fillchar; fillchar = f; return oldc; }

inline int QTextStream::precision() const
{ return fprec; }

inline int QTextStream::precision( int p )
{ int oldp = fprec; fprec = p; return oldp; }




inline QChar QTextStream::ts_getc()
{ QChar r; return ( ts_getbuf( &r,1 ) == 1 ? r : QChar((ushort)0xffff) ); }





typedef QTextStream & (*QTSFUNC)(QTextStream &);
typedef int (QTextStream::*QTSMFI)(int);

class QTSManip {
public:
    QTSManip( QTSMFI m, int a ) { mf=m; arg=a; }
    void exec( QTextStream &s ) { (s.*mf)(arg); }
private:
    QTSMFI mf;
    int arg;
};

 inline QTextStream &operator>>( QTextStream &s, QTSFUNC f )
{ return (*f)( s ); }

 inline QTextStream &operator<<( QTextStream &s, QTSFUNC f )
{ return (*f)( s ); }

 inline QTextStream &operator<<( QTextStream &s, QTSManip m )
{ m.exec(s); return s; }

 QTextStream &bin( QTextStream &s );
 QTextStream &oct( QTextStream &s );
 QTextStream &dec( QTextStream &s );
 QTextStream &hex( QTextStream &s );
 QTextStream &endl( QTextStream &s );
 QTextStream &flush( QTextStream &s );
 QTextStream &ws( QTextStream &s );
 QTextStream &reset( QTextStream &s );

 inline QTSManip qSetW( int w )
{
    QTSMFI func = &QTextStream::width;
    return QTSManip(func,w);
}

 inline QTSManip qSetFill( int f )
{
    QTSMFI func = &QTextStream::fill;
    return QTSManip(func,f);
}

 inline QTSManip qSetPrecision( int p )
{
    QTSMFI func = &QTextStream::precision;
    return QTSManip(func,p);
}
# 44 "../tools/qtl.h" 2




template <class T>
class QTextOStreamIterator
{
protected:
    QTextOStream& stream;
    QString separator;

public:
    QTextOStreamIterator( QTextOStream& s) : stream( s ) {}
    QTextOStreamIterator( QTextOStream& s, const QString& sep )
 : stream( s ), separator( sep ) {}
    QTextOStreamIterator<T>& operator= ( const T& x ) {
 stream << x;
 if ( !separator.isEmpty() )
     stream << separator;
 return *this;
    }
    QTextOStreamIterator<T>& operator*() { return *this; }
    QTextOStreamIterator<T>& operator++() { return *this; }
    QTextOStreamIterator<T>& operator++(int) { return *this; }
};


template <class InputIterator, class OutputIterator>
inline OutputIterator qCopy( InputIterator _begin, InputIterator _end,
        OutputIterator _dest )
{
    while( _begin != _end )
 *_dest++ = *_begin++;
    return _dest;
}

template <class BiIterator, class BiOutputIterator>
inline BiOutputIterator qCopyBackward( BiIterator _begin, BiIterator _end,
           BiOutputIterator _dest )
{
    while ( _begin != _end )
 *--_dest = *--_end;
    return _dest;
}

template <class InputIterator1, class InputIterator2>
inline bool qEqual( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
{

    for ( ; first1 != last1; ++first1, ++first2 )
 if ( *first1 != *first2 )
     return FALSE;
    return TRUE;
}

template <class ForwardIterator, class T>
inline void qFill( ForwardIterator first, ForwardIterator last, const T& val )
{
    for ( ; first != last; ++first )
 *first = val;
}
# 121 "../tools/qtl.h"
template <class InputIterator, class T>
inline InputIterator qFind( InputIterator first, InputIterator last,
       const T& val )
{
    while ( first != last && *first != val )
 ++first;
    return first;
}

template <class InputIterator, class T, class Size>
inline void qCount( InputIterator first, InputIterator last, const T& value,
      Size& n )
{
    for ( ; first != last; ++first )
 if ( *first == value )
     ++n;
}

template <class T>
inline void qSwap( T& _value1, T& _value2 )
{
    T tmp = _value1;
    _value1 = _value2;
    _value2 = tmp;
}


template <class InputIterator>
 void qBubbleSort( InputIterator b, InputIterator e )
{

    InputIterator last = e;
    --last;

    if ( last == b )
 return;


    while( b != last ) {
 bool swapped = FALSE;
 InputIterator swap_pos = b;
 InputIterator x = e;
 InputIterator y = x;
 y--;
 do {
     --x;
     --y;
     if ( *x < *y ) {
  swapped = TRUE;
  qSwap( *x, *y );
  swap_pos = y;
     }
 } while( y != b );
 if ( !swapped )
     return;
 b = swap_pos;
 b++;
    }
}


template <class Container>
inline void qBubbleSort( Container &c )
{
  qBubbleSort( c.begin(), c.end() );
}


template <class Value>
 void qHeapSortPushDown( Value* heap, int first, int last )
{
    int r = first;
    while ( r <= last / 2 ) {
 if ( last == 2 * r ) {

     if ( heap[2 * r] < heap[r] )
  qSwap( heap[r], heap[2 * r] );
     r = last;
 } else {

     if ( heap[2 * r] < heap[r] && !(heap[2 * r + 1] < heap[2 * r]) ) {

  qSwap( heap[r], heap[2 * r] );
  r *= 2;
     } else if ( heap[2 * r + 1] < heap[r]
   && heap[2 * r + 1] < heap[2 * r] ) {

  qSwap( heap[r], heap[2 * r + 1] );
  r = 2 * r + 1;
     } else {
  r = last;
     }
 }
    }
}


template <class InputIterator, class Value>
 void qHeapSortHelper( InputIterator b, InputIterator e, Value, uint n )
{

    InputIterator insert = b;
    Value* realheap = new Value[n];

    Value* heap = realheap - 1;
    int size = 0;
    for( ; insert != e; ++insert ) {
 heap[++size] = *insert;
 int i = size;
 while( i > 1 && heap[i] < heap[i / 2] ) {
     qSwap( heap[i], heap[i / 2] );
     i /= 2;
 }
    }


    for( uint i = n; i > 0; i-- ) {
 *b++ = heap[1];
 if ( i > 1 ) {
     heap[1] = heap[i];
     qHeapSortPushDown( heap, 1, (int)i - 1 );
 }
    }

    delete[] realheap;
}


template <class InputIterator>
 void qHeapSort( InputIterator b, InputIterator e )
{

    if ( b == e )
 return;


    InputIterator it = b;
    uint n = 0;
    while ( it != e ) {
 ++n;
 ++it;
    }



    qHeapSortHelper( b, e, *b, n );
}


template <class Container>
 void qHeapSort( Container &c )
{
    if ( c.begin() == c.end() )
 return;



    qHeapSortHelper( c.begin(), c.end(), *(c.begin()), (uint)c.count() );
}

template <class Container>
class QBackInsertIterator
{
public:
    explicit QBackInsertIterator( Container &c )
 : container( &c )
    {
    }

    QBackInsertIterator<Container>&
    operator=( const typename Container::value_type &value )
    {
 container->push_back( value );
 return *this;
    }

    QBackInsertIterator<Container>& operator*()
    {
 return *this;
    }

    QBackInsertIterator<Container>& operator++()
    {
 return *this;
    }

    QBackInsertIterator<Container>& operator++(int)
    {
 return *this;
    }

protected:
    Container *container;
};

template <class Container>
inline QBackInsertIterator<Container> qBackInserter( Container &c )
{
    return QBackInsertIterator<Container>( c );
}
# 43 "../tools/qvaluelist.h" 2

# 1 "../tools/qdatastream.h" 1
# 47 "../tools/qdatastream.h"
class QDataStream
{
public:
    QDataStream();
    QDataStream( QIODevice * );
    QDataStream( QByteArray, int mode );
    virtual ~QDataStream();

    QIODevice *device() const;
    void setDevice( QIODevice * );
    void unsetDevice();

    bool atEnd() const;
    bool eof() const;

    enum ByteOrder { BigEndian, LittleEndian };
    int byteOrder() const;
    void setByteOrder( int );

    bool isPrintableData() const;
    void setPrintableData( bool );

    int version() const;
    void setVersion( int );

    QDataStream &operator>>( Q_INT8 &i );
    QDataStream &operator>>( Q_UINT8 &i );
    QDataStream &operator>>( Q_INT16 &i );
    QDataStream &operator>>( Q_UINT16 &i );
    QDataStream &operator>>( Q_INT32 &i );
    QDataStream &operator>>( Q_UINT32 &i );
    QDataStream &operator>>( Q_INT64 &i );
    QDataStream &operator>>( Q_UINT64 &i );

    QDataStream &operator>>( Q_LONG &i );
    QDataStream &operator>>( Q_ULONG &i );


    QDataStream &operator>>( float &f );
    QDataStream &operator>>( double &f );
    QDataStream &operator>>( char *&str );

    QDataStream &operator<<( Q_INT8 i );
    QDataStream &operator<<( Q_UINT8 i );
    QDataStream &operator<<( Q_INT16 i );
    QDataStream &operator<<( Q_UINT16 i );
    QDataStream &operator<<( Q_INT32 i );
    QDataStream &operator<<( Q_UINT32 i );
    QDataStream &operator<<( Q_INT64 i );
    QDataStream &operator<<( Q_UINT64 i );

    QDataStream &operator<<( Q_LONG i );
    QDataStream &operator<<( Q_ULONG i );

    QDataStream &operator<<( float f );
    QDataStream &operator<<( double f );
    QDataStream &operator<<( const char *str );

    QDataStream &readBytes( char *&, uint &len );
    QDataStream &readRawBytes( char *, uint len );

    QDataStream &writeBytes( const char *, uint len );
    QDataStream &writeRawBytes( const char *, uint len );

private:
    QIODevice *dev;
    bool owndev;
    int byteorder;
    bool printable;
    bool noswap;
    int ver;

private:

    QDataStream( const QDataStream & );
    QDataStream &operator=( const QDataStream & );

};






inline QIODevice *QDataStream::device() const
{ return dev; }

inline bool QDataStream::atEnd() const
{ return dev ? dev->atEnd() : TRUE; }

inline bool QDataStream::eof() const
{ return atEnd(); }

inline int QDataStream::byteOrder() const
{ return byteorder; }

inline bool QDataStream::isPrintableData() const
{ return printable; }

inline void QDataStream::setPrintableData( bool p )
{ printable = p; }

inline int QDataStream::version() const
{ return ver; }

inline void QDataStream::setVersion( int v )
{ ver = v; }

inline QDataStream &QDataStream::operator>>( Q_UINT8 &i )
{ return *this >> (Q_INT8&)i; }

inline QDataStream &QDataStream::operator>>( Q_UINT16 &i )
{ return *this >> (Q_INT16&)i; }

inline QDataStream &QDataStream::operator>>( Q_UINT32 &i )
{ return *this >> (Q_INT32&)i; }

inline QDataStream &QDataStream::operator>>( Q_UINT64 &i )
{ return *this >> (Q_INT64&)i; }


inline QDataStream &QDataStream::operator>>( Q_ULONG &i )
{ return *this >> (Q_LONG&)i; }


inline QDataStream &QDataStream::operator<<( Q_UINT8 i )
{ return *this << (Q_INT8)i; }

inline QDataStream &QDataStream::operator<<( Q_UINT16 i )
{ return *this << (Q_INT16)i; }

inline QDataStream &QDataStream::operator<<( Q_UINT32 i )
{ return *this << (Q_INT32)i; }

inline QDataStream &QDataStream::operator<<( Q_UINT64 i )
{ return *this << (Q_INT64)i; }


inline QDataStream &QDataStream::operator<<( Q_ULONG i )
{ return *this << (Q_LONG)i; }
# 45 "../tools/qvaluelist.h" 2
# 58 "../tools/qvaluelist.h"
template <class T>
class QValueListNode
{
public:
    QValueListNode( const T& t ) : data( t ) { }
    QValueListNode() { }





    QValueListNode<T>* next;
    QValueListNode<T>* prev;
    T data;
};

template<class T>
class QValueListIterator
{
 public:



    typedef QValueListNode<T>* NodePtr;



    typedef T value_type;
    typedef size_t size_type;



    typedef int difference_type;

    typedef T* pointer;
    typedef T& reference;




    NodePtr node;




    QValueListIterator() : node( 0 ) {}
    QValueListIterator( NodePtr p ) : node( p ) {}
    QValueListIterator( const QValueListIterator<T>& it ) : node( it.node ) {}

    bool operator==( const QValueListIterator<T>& it ) const { return node == it.node; }
    bool operator!=( const QValueListIterator<T>& it ) const { return node != it.node; }
    const T& operator*() const { return node->data; }
    T& operator*() { return node->data; }



    QValueListIterator<T>& operator++() {
 node = node->next;
 return *this;
    }

    QValueListIterator<T> operator++(int) {
 QValueListIterator<T> tmp = *this;
 node = node->next;
 return tmp;
    }

    QValueListIterator<T>& operator--() {
 node = node->prev;
 return *this;
    }

    QValueListIterator<T> operator--(int) {
 QValueListIterator<T> tmp = *this;
 node = node->prev;
 return tmp;
    }

    QValueListIterator<T>& operator+=( int j ) {
 while ( j-- )
     node = node->next;
 return *this;
    }

    QValueListIterator<T>& operator-=( int j ) {
 while ( j-- )
     node = node->prev;
 return *this;
    }

};

template<class T>
class QValueListConstIterator
{
 public:



    typedef QValueListNode<T>* NodePtr;



    typedef T value_type;
    typedef size_t size_type;



    typedef int difference_type;

    typedef const T* pointer;
    typedef const T& reference;




    NodePtr node;




    QValueListConstIterator() : node( 0 ) {}
    QValueListConstIterator( NodePtr p ) : node( p ) {}
    QValueListConstIterator( const QValueListConstIterator<T>& it ) : node( it.node ) {}
    QValueListConstIterator( const QValueListIterator<T>& it ) : node( it.node ) {}

    bool operator==( const QValueListConstIterator<T>& it ) const { return node == it.node; }
    bool operator!=( const QValueListConstIterator<T>& it ) const { return node != it.node; }
    const T& operator*() const { return node->data; }



    QValueListConstIterator<T>& operator++() {
 node = node->next;
 return *this;
    }

    QValueListConstIterator<T> operator++(int) {
 QValueListConstIterator<T> tmp = *this;
 node = node->next;
 return tmp;
    }

    QValueListConstIterator<T>& operator--() {
 node = node->prev;
 return *this;
    }

    QValueListConstIterator<T> operator--(int) {
 QValueListConstIterator<T> tmp = *this;
 node = node->prev;
 return tmp;
    }
};

template <class T>
class QValueListPrivate : public QShared
{
public:



    typedef QValueListIterator<T> Iterator;
    typedef QValueListConstIterator<T> ConstIterator;
    typedef QValueListNode<T> Node;
    typedef QValueListNode<T>* NodePtr;
    typedef size_t size_type;




    QValueListPrivate();
    QValueListPrivate( const QValueListPrivate<T>& _p );

    void derefAndDelete()
    {
 if ( deref() )
     delete this;
    }





    ~QValueListPrivate();

    Iterator insert( Iterator it, const T& x );
    Iterator remove( Iterator it );
    NodePtr find( NodePtr start, const T& x ) const;
    int findIndex( NodePtr start, const T& x ) const;
    uint contains( const T& x ) const;
    uint remove( const T& x );
    NodePtr at( size_type i ) const;
    void clear();

    NodePtr node;
    size_type nodes;
};

template <class T>
 QValueListPrivate<T>::QValueListPrivate()
{
    node = new Node; node->next = node->prev = node; nodes = 0;
}

template <class T>
 QValueListPrivate<T>::QValueListPrivate( const QValueListPrivate<T>& _p )
    : QShared()
{
    node = new Node; node->next = node->prev = node; nodes = 0;
    Iterator b( _p.node->next );
    Iterator e( _p.node );
    Iterator i( node );
    while( b != e )
 insert( i, *b++ );
}

template <class T>
 QValueListPrivate<T>::~QValueListPrivate() {
    NodePtr p = node->next;
    while( p != node ) {
 NodePtr x = p->next;
 delete p;
 p = x;
    }
    delete node;
}

template <class T>
 typename QValueListPrivate<T>::Iterator QValueListPrivate<T>::insert( typename QValueListPrivate<T>::Iterator it, const T& x )
{
    NodePtr p = new Node( x );
    p->next = it.node;
    p->prev = it.node->prev;
    it.node->prev->next = p;
    it.node->prev = p;
    nodes++;
    return p;
}

template <class T>
 typename QValueListPrivate<T>::Iterator QValueListPrivate<T>::remove( typename QValueListPrivate<T>::Iterator it )
{
    ((it.node != node) ? (void)0 : qWarning("ASSERT: \"%s\" in %s (%d)","it.node != node","../tools/qvaluelist.h",301));
    NodePtr next = it.node->next;
    NodePtr prev = it.node->prev;
    prev->next = next;
    next->prev = prev;
    delete it.node;
    nodes--;
    return Iterator( next );
}

template <class T>
 typename QValueListPrivate<T>::NodePtr QValueListPrivate<T>::find( typename QValueListPrivate<T>::NodePtr start, const T& x ) const
{
    ConstIterator first( start );
    ConstIterator last( node );
    while( first != last) {
 if ( *first == x )
     return first.node;
 ++first;
    }
    return last.node;
}

template <class T>
 int QValueListPrivate<T>::findIndex( typename QValueListPrivate<T>::NodePtr start, const T& x ) const
{
    ConstIterator first( start );
    ConstIterator last( node );
    int pos = 0;
    while( first != last) {
 if ( *first == x )
     return pos;
 ++first;
 ++pos;
    }
    return -1;
}

template <class T>
 uint QValueListPrivate<T>::contains( const T& x ) const
{
    uint result = 0;
    Iterator first = Iterator( node->next );
    Iterator last = Iterator( node );
    while( first != last) {
 if ( *first == x )
     ++result;
 ++first;
    }
    return result;
}

template <class T>
 uint QValueListPrivate<T>::remove( const T& _x )
{
    const T x = _x;
    uint result = 0;
    Iterator first = Iterator( node->next );
    Iterator last = Iterator( node );
    while( first != last) {
 if ( *first == x ) {
     first = remove( first );
     ++result;
 } else
     ++first;
    }
    return result;
}

template <class T>
 typename QValueListPrivate<T>::NodePtr QValueListPrivate<T>::at( size_type i ) const
{
    ((i <= nodes) ? (void)0 : qWarning("ASSERT: \"%s\" in %s (%d)","i <= nodes","../tools/qvaluelist.h",373));
    NodePtr p = node->next;
    for( size_type x = 0; x < i; ++x )
 p = p->next;
    return p;
}

template <class T>
 void QValueListPrivate<T>::clear()
{
    nodes = 0;
    NodePtr p = node->next;
    while( p != node ) {
 NodePtr next = p->next;
 delete p;
 p = next;
    }
    node->next = node->prev = node;
}
# 406 "../tools/qvaluelist.h"
template <class T> class QDeepCopy;

template <class T>
class QValueList
{
public:



    typedef QValueListIterator<T> iterator;
    typedef QValueListConstIterator<T> const_iterator;
    typedef T value_type;
    typedef value_type* pointer;
    typedef const value_type* const_pointer;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef size_t size_type;



    typedef int difference_type;





    QValueList() { sh = new QValueListPrivate<T>; }
    QValueList( const QValueList<T>& l ) { sh = l.sh; sh->ref(); }







    ~QValueList() { sh->derefAndDelete(); }

    QValueList<T>& operator= ( const QValueList<T>& l )
    {
 l.sh->ref();
 sh->derefAndDelete();
 sh = l.sh;
 return *this;
    }
# 472 "../tools/qvaluelist.h"
    bool operator== ( const QValueList<T>& l ) const;
    bool operator!= ( const QValueList<T>& l ) const { return !( *this == l ); }
    iterator begin() { detach(); return iterator( sh->node->next ); }
    const_iterator begin() const { return const_iterator( sh->node->next ); }
    const_iterator constBegin() const { return const_iterator( sh->node->next ); }
    iterator end() { detach(); return iterator( sh->node ); }
    const_iterator end() const { return const_iterator( sh->node ); }
    const_iterator constEnd() const { return const_iterator( sh->node ); }
    iterator insert( iterator it, const T& x ) { detach(); return sh->insert( it, x ); }
    uint remove( const T& x ) { detach(); return sh->remove( x ); }
    void clear();


    QValueList<T>& operator<< ( const T& x )
    {
 append( x );
 return *this;
    }

    size_type size() const { return sh->nodes; }
    bool empty() const { return sh->nodes == 0; }
    void push_front( const T& x ) { detach(); sh->insert( begin(), x ); }
    void push_back( const T& x ) { detach(); sh->insert( end(), x ); }
    iterator erase( iterator pos ) { detach(); return sh->remove( pos ); }
    iterator erase( iterator first, iterator last );
    reference front() { ; return *begin(); }
    const_reference front() const { ; return *begin(); }
    reference back() { ; return *(--end()); }
    const_reference back() const { ; return *(--end()); }
    void pop_front() { ; erase( begin() ); }
    void pop_back() {
 ;
 iterator tmp = end();
 erase( --tmp );
    }
    void insert( iterator pos, size_type n, const T& x );
# 518 "../tools/qvaluelist.h"
    QValueList<T> operator+ ( const QValueList<T>& l ) const;
    QValueList<T>& operator+= ( const QValueList<T>& l );

    iterator fromLast() { detach(); return iterator( sh->node->prev ); }
    const_iterator fromLast() const { return const_iterator( sh->node->prev ); }

    bool isEmpty() const { return ( sh->nodes == 0 ); }

    iterator append( const T& x ) { detach(); return sh->insert( end(), x ); }
    iterator prepend( const T& x ) { detach(); return sh->insert( begin(), x ); }

    iterator remove( iterator it ) { detach(); return sh->remove( it ); }

    T& first() { ; detach(); return sh->node->next->data; }
    const T& first() const { ; return sh->node->next->data; }
    T& last() { ; detach(); return sh->node->prev->data; }
    const T& last() const { ; return sh->node->prev->data; }

    T& operator[] ( size_type i ) { ; detach(); return sh->at(i)->data; }
    const T& operator[] ( size_type i ) const { ; return sh->at(i)->data; }
    iterator at( size_type i ) { ; detach(); return iterator( sh->at(i) ); }
    const_iterator at( size_type i ) const { ; return const_iterator( sh->at(i) ); }
    iterator find ( const T& x ) { detach(); return iterator( sh->find( sh->node->next, x) ); }
    const_iterator find ( const T& x ) const { return const_iterator( sh->find( sh->node->next, x) ); }
    iterator find ( iterator it, const T& x ) { detach(); return iterator( sh->find( it.node, x ) ); }
    const_iterator find ( const_iterator it, const T& x ) const { return const_iterator( sh->find( it.node, x ) ); }
    int findIndex( const T& x ) const { return sh->findIndex( sh->node->next, x) ; }
    size_type contains( const T& x ) const { return sh->contains( x ); }

    size_type count() const { return sh->nodes; }

    QValueList<T>& operator+= ( const T& x )
    {
 append( x );
 return *this;
    }
    typedef QValueListIterator<T> Iterator;
    typedef QValueListConstIterator<T> ConstIterator;
    typedef T ValueType;

protected:



    void detach() { if ( sh->count > 1 ) detachInternal(); }




    QValueListPrivate<T>* sh;

private:
    void detachInternal();

    friend class QDeepCopy< QValueList<T> >;
};

template <class T>
 bool QValueList<T>::operator== ( const QValueList<T>& l ) const
{
    if ( size() != l.size() )
 return FALSE;
    const_iterator it2 = begin();
    const_iterator it = l.begin();
    for( ; it != l.end(); ++it, ++it2 )
 if ( !( *it == *it2 ) )
     return FALSE;
    return TRUE;
}

template <class T>
 void QValueList<T>::clear()
{
    if ( sh->count == 1 ) sh->clear(); else { sh->deref(); sh = new QValueListPrivate<T>; }
}

template <class T>
 typename QValueList<T>::iterator QValueList<T>::erase( typename QValueList<T>::iterator first, typename QValueList<T>::iterator last )
{
    while ( first != last )
 erase( first++ );
    return last;
}


template <class T>
 void QValueList<T>::insert( typename QValueList<T>::iterator pos, size_type n, const T& x )
{
    for ( ; n > 0; --n )
 insert( pos, x );
}

template <class T>
 QValueList<T> QValueList<T>::operator+ ( const QValueList<T>& l ) const
{
    QValueList<T> l2( *this );
    for( const_iterator it = l.begin(); it != l.end(); ++it )
 l2.append( *it );
    return l2;
}

template <class T>
 QValueList<T>& QValueList<T>::operator+= ( const QValueList<T>& l )
{
    QValueList<T> copy = l;
    for( const_iterator it = copy.begin(); it != copy.end(); ++it )
 append( *it );
    return *this;
}

template <class T>
 void QValueList<T>::detachInternal()
{
    sh->deref(); sh = new QValueListPrivate<T>( *sh );
}


template <class T>
 QDataStream& operator>>( QDataStream& s, QValueList<T>& l )
{
    l.clear();
    Q_UINT32 c;
    s >> c;
    for( Q_UINT32 i = 0; i < c; ++i )
    {
 T t;
 s >> t;
 l.append( t );
 if ( s.atEnd() )
     break;
    }
    return s;
}

template <class T>
 QDataStream& operator<<( QDataStream& s, const QValueList<T>& l )
{
    s << (Q_UINT32)l.size();
    QValueListConstIterator<T> it = l.begin();
    for( ; it != l.end(); ++it )
 s << *it;
    return s;
}




# 1 "../tools/qwinexport.h" 1
# 666 "../tools/qvaluelist.h" 2
# 43 "../tools/qstringlist.h" 2

# 1 "../tools/qstrlist.h" 1
# 43 "../tools/qstrlist.h"
# 1 "../tools/qptrlist.h" 1
# 40 "../tools/qptrlist.h"
# 1 "../tools/qglist.h" 1
# 42 "../tools/qglist.h"
# 1 "../tools/qptrcollection.h" 1
# 40 "../tools/qptrcollection.h"
# 1 "../tools/qglobal.h" 1
# 41 "../tools/qptrcollection.h" 2



class QGVector;
class QGList;
class QGDict;


class QPtrCollection
{
public:
    bool autoDelete() const { return del_item; }
    void setAutoDelete( bool enable ) { del_item = enable; }

    virtual uint count() const = 0;
    virtual void clear() = 0;

    typedef void *Item;

protected:
    QPtrCollection() { del_item = FALSE; }
    QPtrCollection(const QPtrCollection &) { del_item = FALSE; }
    virtual ~QPtrCollection() {}

    bool del_item;

    virtual Item newItem( Item );
    virtual void deleteItem( Item ) = 0;
};
# 43 "../tools/qglist.h" 2


class QLNode
{
friend class QGList;
friend class QGListIterator;
friend class QGListStdIterator;
public:
    QPtrCollection::Item getData() { return data; }
private:
    QPtrCollection::Item data;
    QLNode *prev;
    QLNode *next;
    QLNode( QPtrCollection::Item d ) { data = d; }
};

class QGListIteratorList;

class QGList : public QPtrCollection
{
friend class QGListIterator;
friend class QGListIteratorList;
friend class QGVector;
public:
    uint count() const;


    QDataStream &read( QDataStream & );
    QDataStream &write( QDataStream & ) const;

protected:
    QGList();
    QGList( const QGList & );
    virtual ~QGList();

    QGList &operator=( const QGList & );
    bool operator==( const QGList& ) const;

    void inSort( QPtrCollection::Item );
    void append( QPtrCollection::Item );
    bool insertAt( uint index, QPtrCollection::Item );
    void relinkNode( QLNode * );
    bool removeNode( QLNode * );
    bool remove( QPtrCollection::Item = 0 );
    bool removeRef( QPtrCollection::Item = 0 );
    bool removeFirst();
    bool removeLast();
    bool removeAt( uint );
    bool replaceAt( uint, QPtrCollection::Item );
    QPtrCollection::Item takeNode( QLNode * );
    QPtrCollection::Item take();
    QPtrCollection::Item takeAt( uint index );
    QPtrCollection::Item takeFirst();
    QPtrCollection::Item takeLast();

    void sort();
    void clear();

    int findRef( QPtrCollection::Item, bool = TRUE );
    int find( QPtrCollection::Item, bool = TRUE );

    uint containsRef( QPtrCollection::Item ) const;
    uint contains( QPtrCollection::Item ) const;

    QPtrCollection::Item at( uint index );
    int at() const;
    QLNode *currentNode() const;

    QPtrCollection::Item get() const;

    QPtrCollection::Item cfirst() const;
    QPtrCollection::Item clast() const;
    QPtrCollection::Item first();
    QPtrCollection::Item last();
    QPtrCollection::Item next();
    QPtrCollection::Item prev();

    void toVector( QGVector * ) const;

    virtual int compareItems( QPtrCollection::Item, QPtrCollection::Item );


    virtual QDataStream &read( QDataStream &, QPtrCollection::Item & );
    virtual QDataStream &write( QDataStream &, QPtrCollection::Item ) const;


    QLNode* begin() const { return firstNode; }
    QLNode* end() const { return 0; }
    QLNode* erase( QLNode* it );

private:
    void prepend( QPtrCollection::Item );

    void heapSortPushDown( QPtrCollection::Item* heap, int first, int last );

    QLNode *firstNode;
    QLNode *lastNode;
    QLNode *curNode;
    int curIndex;
    uint numNodes;
    QGListIteratorList *iterators;

    QLNode *locate( uint );
    QLNode *unlink();
};


inline uint QGList::count() const
{
    return numNodes;
}

inline bool QGList::removeFirst()
{
    first();
    return remove();
}

inline bool QGList::removeLast()
{
    last();
    return remove();
}

inline int QGList::at() const
{
    return curIndex;
}

inline QPtrCollection::Item QGList::at( uint index )
{
    QLNode *n = locate( index );
    return n ? n->data : 0;
}

inline QLNode *QGList::currentNode() const
{
    return curNode;
}

inline QPtrCollection::Item QGList::get() const
{
    return curNode ? curNode->data : 0;
}

inline QPtrCollection::Item QGList::cfirst() const
{
    return firstNode ? firstNode->data : 0;
}

inline QPtrCollection::Item QGList::clast() const
{
    return lastNode ? lastNode->data : 0;
}







 QDataStream &operator>>( QDataStream &, QGList & );
 QDataStream &operator<<( QDataStream &, const QGList & );






class QGListIterator
{
friend class QGList;
friend class QGListIteratorList;
protected:
    QGListIterator( const QGList & );
    QGListIterator( const QGListIterator & );
    QGListIterator &operator=( const QGListIterator & );
   ~QGListIterator();

    bool atFirst() const;
    bool atLast() const;
    QPtrCollection::Item toFirst();
    QPtrCollection::Item toLast();

    QPtrCollection::Item get() const;
    QPtrCollection::Item operator()();
    QPtrCollection::Item operator++();
    QPtrCollection::Item operator+=(uint);
    QPtrCollection::Item operator--();
    QPtrCollection::Item operator-=(uint);

protected:
    QGList *list;

private:
    QLNode *curNode;
};


inline bool QGListIterator::atFirst() const
{
    return curNode == list->firstNode;
}

inline bool QGListIterator::atLast() const
{
    return curNode == list->lastNode;
}

inline QPtrCollection::Item QGListIterator::get() const
{
    return curNode ? curNode->data : 0;
}

class QGListStdIterator
{
public:
    inline QGListStdIterator( QLNode* n ) : node( n ){}
    inline operator QLNode* () { return node; }
protected:
    inline QLNode *next() { return node->next; }
    QLNode *node;
};
# 41 "../tools/qptrlist.h" 2


template<class type>
class QPtrListStdIterator : public QGListStdIterator
{
public:
    inline QPtrListStdIterator( QLNode* n ): QGListStdIterator(n) {}
    type *operator*() { return node ? (type *)node->getData() : 0; }
    inline QPtrListStdIterator<type> operator++()
    { node = next(); return *this; }
    inline QPtrListStdIterator<type> operator++(int)
    { QLNode* n = node; node = next(); return QPtrListStdIterator<type>( n ); }
    inline bool operator==( const QPtrListStdIterator<type>& it ) const { return node == it.node; }
    inline bool operator!=( const QPtrListStdIterator<type>& it ) const { return node != it.node; }
};


template<class type>
class QPtrList



 : public QGList

{
public:

    QPtrList() {}
    QPtrList( const QPtrList<type> &l ) : QGList(l) {}
    ~QPtrList() { clear(); }
    QPtrList<type> &operator=(const QPtrList<type> &l)
   { return (QPtrList<type>&)QGList::operator=(l); }
    bool operator==( const QPtrList<type> &list ) const
    { return QGList::operator==( list ); }
    bool operator!=( const QPtrList<type> &list ) const
    { return !QGList::operator==( list ); }
    uint count() const { return QGList::count(); }
    bool isEmpty() const { return QGList::count() == 0; }
    bool insert( uint i, const type *d){ return QGList::insertAt(i,(QPtrCollection::Item)d); }
    void inSort( const type *d ) { QGList::inSort((QPtrCollection::Item)d); }
    void prepend( const type *d ) { QGList::insertAt(0,(QPtrCollection::Item)d); }
    void append( const type *d ) { QGList::append((QPtrCollection::Item)d); }
    bool remove( uint i ) { return QGList::removeAt(i); }
    bool remove() { return QGList::remove((QPtrCollection::Item)0); }
    bool remove( const type *d ) { return QGList::remove((QPtrCollection::Item)d); }
    bool removeRef( const type *d ) { return QGList::removeRef((QPtrCollection::Item)d); }
    void removeNode( QLNode *n ) { QGList::removeNode(n); }
    bool removeFirst() { return QGList::removeFirst(); }
    bool removeLast() { return QGList::removeLast(); }
    type *take( uint i ) { return (type *)QGList::takeAt(i); }
    type *take() { return (type *)QGList::take(); }
    type *takeNode( QLNode *n ) { return (type *)QGList::takeNode(n); }
    void clear() { QGList::clear(); }
    void sort() { QGList::sort(); }
    int find( const type *d ) { return QGList::find((QPtrCollection::Item)d); }
    int findNext( const type *d ) { return QGList::find((QPtrCollection::Item)d,FALSE); }
    int findRef( const type *d ) { return QGList::findRef((QPtrCollection::Item)d); }
    int findNextRef( const type *d ){ return QGList::findRef((QPtrCollection::Item)d,FALSE);}
    uint contains( const type *d ) const { return QGList::contains((QPtrCollection::Item)d); }
    uint containsRef( const type *d ) const
     { return QGList::containsRef((QPtrCollection::Item)d); }
    bool replace( uint i, const type *d ) { return QGList::replaceAt( i, (QPtrCollection::Item)d ); }
    type *at( uint i ) { return (type *)QGList::at(i); }
    int at() const { return QGList::at(); }
    type *current() const { return (type *)QGList::get(); }
    QLNode *currentNode() const { return QGList::currentNode(); }
    type *getFirst() const { return (type *)QGList::cfirst(); }
    type *getLast() const { return (type *)QGList::clast(); }
    type *first() { return (type *)QGList::first(); }
    type *last() { return (type *)QGList::last(); }
    type *next() { return (type *)QGList::next(); }
    type *prev() { return (type *)QGList::prev(); }
    void toVector( QGVector *vec )const{ QGList::toVector(vec); }



    typedef QPtrListStdIterator<type> Iterator;
    typedef QPtrListStdIterator<type> ConstIterator;
    inline Iterator begin() { return QGList::begin(); }
    inline ConstIterator begin() const { return QGList::begin(); }
    inline ConstIterator constBegin() const { return QGList::begin(); }
    inline Iterator end() { return QGList::end(); }
    inline ConstIterator end() const { return QGList::end(); }
    inline ConstIterator constEnd() const { return QGList::end(); }
    inline Iterator erase( Iterator it ) { return QGList::erase( it ); }

    typedef Iterator iterator;
    typedef ConstIterator const_iterator;
# 138 "../tools/qptrlist.h"
private:
    void deleteItem( Item d );
};


template<> inline void QPtrList<void>::deleteItem( QPtrCollection::Item )
{
}


template<class type> inline void QPtrList<type>::deleteItem( QPtrCollection::Item d )
{
    if ( del_item ) delete (type *)d;
}

template<class type>
class QPtrListIterator : public QGListIterator
{
public:
    QPtrListIterator(const QPtrList<type> &l) :QGListIterator((QGList &)l) {}
   ~QPtrListIterator() {}
    uint count() const { return list->count(); }
    bool isEmpty() const { return list->count() == 0; }
    bool atFirst() const { return QGListIterator::atFirst(); }
    bool atLast() const { return QGListIterator::atLast(); }
    type *toFirst() { return (type *)QGListIterator::toFirst(); }
    type *toLast() { return (type *)QGListIterator::toLast(); }
    operator type *() const { return (type *)QGListIterator::get(); }
    type *operator*() { return (type *)QGListIterator::get(); }







    type *current() const { return (type *)QGListIterator::get(); }
    type *operator()() { return (type *)QGListIterator::operator()();}
    type *operator++() { return (type *)QGListIterator::operator++(); }
    type *operator+=(uint j) { return (type *)QGListIterator::operator+=(j);}
    type *operator--() { return (type *)QGListIterator::operator--(); }
    type *operator-=(uint j) { return (type *)QGListIterator::operator-=(j);}
    QPtrListIterator<type>& operator=(const QPtrListIterator<type>&it)
         { QGListIterator::operator=(it); return *this; }
};







# 1 "../tools/qwinexport.h" 1
# 191 "../tools/qptrlist.h" 2
# 44 "../tools/qstrlist.h" 2
# 52 "../tools/qstrlist.h"
typedef QPtrListIterator<char> QStrListIterator;


class QStrList : public QPtrList<char>
{
public:
    QStrList( bool deepCopies=TRUE ) { dc = deepCopies; del_item = deepCopies; }
    QStrList( const QStrList & );
    ~QStrList() { clear(); }
    QStrList& operator=( const QStrList & );

private:
    QPtrCollection::Item newItem( QPtrCollection::Item d ) { return dc ? qstrdup( (const char*)d ) : d; }
    void deleteItem( QPtrCollection::Item d ) { if ( del_item ) delete[] (char*)d; }
    int compareItems( QPtrCollection::Item s1, QPtrCollection::Item s2 ) { return qstrcmp((const char*)s1,
        (const char*)s2); }

    QDataStream &read( QDataStream &s, QPtrCollection::Item &d )
    { s >> (char *&)d; return s; }
    QDataStream &write( QDataStream &s, QPtrCollection::Item d ) const
    { return s << (const char *)d; }

    bool dc;
};


class QStrIList : public QStrList
{
public:
    QStrIList( bool deepCopies=TRUE ) : QStrList( deepCopies ) {}
    ~QStrIList() { clear(); }
private:
    int compareItems( QPtrCollection::Item s1, QPtrCollection::Item s2 )
    { return qstricmp((const char*)s1,
          (const char*)s2); }
};


inline QStrList & QStrList::operator=( const QStrList &strList )
{
    clear();
    dc = strList.dc;
    del_item = dc;
    QPtrList<char>::operator=( strList );
    return *this;
}

inline QStrList::QStrList( const QStrList &strList )
    : QPtrList<char>( strList )
{
    dc = FALSE;
    operator=( strList );
}
# 45 "../tools/qstringlist.h" 2




class QRegExp;
template <class T> class QDeepCopy;







class QStringList : public QValueList<QString>
{
public:
    QStringList() { }
    QStringList( const QStringList& l ) : QValueList<QString>(l) { }
    QStringList( const QValueList<QString>& l ) : QValueList<QString>(l) { }
    QStringList( const QString& i ) { append(i); }

    QStringList( const char* i ) { append(i); }


    static QStringList fromStrList(const QStrList&);

    void sort();

    static QStringList split( const QString &sep, const QString &str, bool allowEmptyEntries = FALSE );
    static QStringList split( const QChar &sep, const QString &str, bool allowEmptyEntries = FALSE );

    static QStringList split( const QRegExp &sep, const QString &str, bool allowEmptyEntries = FALSE );

    QString join( const QString &sep ) const;

    QStringList grep( const QString &str, bool cs = TRUE ) const;

    QStringList grep( const QRegExp &expr ) const;


    QStringList& gres( const QString &before, const QString &after,
         bool cs = TRUE );

    QStringList& gres( const QRegExp &expr, const QString &after );


protected:
    void detach() { QValueList<QString>::detach(); }
    friend class QDeepCopy< QStringList >;
};


class QDataStream;
extern QDataStream &operator>>( QDataStream &, QStringList& );
extern QDataStream &operator<<( QDataStream &, const QStringList& );
# 43 "../tools/qregexp.h" 2



class QRegExpEngine;
struct QRegExpPrivate;

class QRegExp
{
public:
    enum CaretMode { CaretAtZero, CaretAtOffset, CaretWontMatch };

    QRegExp();
    QRegExp( const QString& pattern, bool caseSensitive = TRUE,
      bool wildcard = FALSE );
    QRegExp( const QRegExp& rx );
    ~QRegExp();
    QRegExp& operator=( const QRegExp& rx );

    bool operator==( const QRegExp& rx ) const;
    bool operator!=( const QRegExp& rx ) const { return !operator==( rx ); }

    bool isEmpty() const;
    bool isValid() const;
    QString pattern() const;
    void setPattern( const QString& pattern );
    bool caseSensitive() const;
    void setCaseSensitive( bool sensitive );

    bool wildcard() const;
    void setWildcard( bool wildcard );

    bool minimal() const;
    void setMinimal( bool minimal );

    bool exactMatch( const QString& str ) const;

    int match( const QString& str, int index = 0, int *len = 0,
        bool indexIsStart = TRUE ) const;
# 90 "../tools/qregexp.h"
    int search( const QString& str, int offset = 0 ) const;
    int search( const QString& str, int offset, CaretMode caretMode ) const;
    int searchRev( const QString& str, int offset = -1 ) const;
    int searchRev( const QString& str, int offset, CaretMode caretMode ) const;

    int matchedLength() const;

    int numCaptures() const;
    QStringList capturedTexts();
    QString cap( int nth = 0 );
    int pos( int nth = 0 );
    QString errorString();


    static QString escape( const QString& str );

private:
    void prepareEngine() const;
    void prepareEngineForMatch( const QString& str ) const;
    void invalidateEngine();

    static int caretIndex( int offset, CaretMode caretMode );

    QRegExpEngine *eng;
    QRegExpPrivate *priv;
};
# 41 "../tools/qcstring.cpp" 2







# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/stdarg.h" 1 3 4
# 49 "../tools/qcstring.cpp" 2
# 1 "/usr/include/stdlib.h" 1 3 4
# 33 "/usr/include/stdlib.h" 3 4
# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/stddef.h" 1 3 4
# 34 "/usr/include/stdlib.h" 2 3 4

extern "C" {






# 1 "/usr/include/bits/waitflags.h" 1 3 4
# 43 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/bits/waitstatus.h" 1 3 4
# 65 "/usr/include/bits/waitstatus.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 37 "/usr/include/endian.h" 3 4
# 1 "/usr/include/bits/endian.h" 1 3 4
# 38 "/usr/include/endian.h" 2 3 4
# 66 "/usr/include/bits/waitstatus.h" 2 3 4

union wait
  {
    int w_status;
    struct
      {

 unsigned int __w_termsig:7;
 unsigned int __w_coredump:1;
 unsigned int __w_retcode:8;
 unsigned int:16;







      } __wait_terminated;
    struct
      {

 unsigned int __w_stopval:8;
 unsigned int __w_stopsig:8;
 unsigned int:16;






      } __wait_stopped;
  };
# 44 "/usr/include/stdlib.h" 2 3 4
# 96 "/usr/include/stdlib.h" 3 4


typedef struct
  {
    int quot;
    int rem;
  } div_t;



typedef struct
  {
    long int quot;
    long int rem;
  } ldiv_t;







__extension__ typedef struct
  {
    long long int quot;
    long long int rem;
  } lldiv_t;


# 140 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) throw ();




extern double atof (__const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern int atoi (__const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));

extern long int atol (__const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





__extension__ extern long long int atoll (__const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern double strtod (__const char *__restrict __nptr,
        char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));





extern float strtof (__const char *__restrict __nptr,
       char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));

extern long double strtold (__const char *__restrict __nptr,
       char **__restrict __endptr)
     throw () __attribute__ ((__nonnull__ (1)));





extern long int strtol (__const char *__restrict __nptr,
   char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

extern unsigned long int strtoul (__const char *__restrict __nptr,
      char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));




__extension__
extern long long int strtoq (__const char *__restrict __nptr,
        char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

__extension__
extern unsigned long long int strtouq (__const char *__restrict __nptr,
           char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));





__extension__
extern long long int strtoll (__const char *__restrict __nptr,
         char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

__extension__
extern unsigned long long int strtoull (__const char *__restrict __nptr,
     char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

# 239 "/usr/include/stdlib.h" 3 4
extern long int strtol_l (__const char *__restrict __nptr,
     char **__restrict __endptr, int __base,
     __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));

extern unsigned long int strtoul_l (__const char *__restrict __nptr,
        char **__restrict __endptr,
        int __base, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4)));

__extension__
extern long long int strtoll_l (__const char *__restrict __nptr,
    char **__restrict __endptr, int __base,
    __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4)));

__extension__
extern unsigned long long int strtoull_l (__const char *__restrict __nptr,
       char **__restrict __endptr,
       int __base, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4)));

extern double strtod_l (__const char *__restrict __nptr,
   char **__restrict __endptr, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));

extern float strtof_l (__const char *__restrict __nptr,
         char **__restrict __endptr, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));

extern long double strtold_l (__const char *__restrict __nptr,
         char **__restrict __endptr,
         __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 3)));






extern double __strtod_internal (__const char *__restrict __nptr,
     char **__restrict __endptr, int __group)
     throw () __attribute__ ((__nonnull__ (1)));
extern float __strtof_internal (__const char *__restrict __nptr,
    char **__restrict __endptr, int __group)
     throw () __attribute__ ((__nonnull__ (1)));
extern long double __strtold_internal (__const char *__restrict __nptr,
           char **__restrict __endptr,
           int __group) throw () __attribute__ ((__nonnull__ (1)));

extern long int __strtol_internal (__const char *__restrict __nptr,
       char **__restrict __endptr,
       int __base, int __group)
     throw () __attribute__ ((__nonnull__ (1)));



extern unsigned long int __strtoul_internal (__const char *__restrict __nptr,
          char **__restrict __endptr,
          int __base, int __group)
     throw () __attribute__ ((__nonnull__ (1)));




__extension__
extern long long int __strtoll_internal (__const char *__restrict __nptr,
      char **__restrict __endptr,
      int __base, int __group)
     throw () __attribute__ ((__nonnull__ (1)));



__extension__
extern unsigned long long int __strtoull_internal (__const char *
         __restrict __nptr,
         char **__restrict __endptr,
         int __base, int __group)
     throw () __attribute__ ((__nonnull__ (1)));








extern __inline double
strtod (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
{
  return __strtod_internal (__nptr, __endptr, 0);
}
extern __inline long int
strtol (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ()

{
  return __strtol_internal (__nptr, __endptr, __base, 0);
}
extern __inline unsigned long int
strtoul (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ()

{
  return __strtoul_internal (__nptr, __endptr, __base, 0);
}




extern __inline float
strtof (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
{
  return __strtof_internal (__nptr, __endptr, 0);
}
extern __inline long double
strtold (__const char *__restrict __nptr, char **__restrict __endptr) throw ()
{
  return __strtold_internal (__nptr, __endptr, 0);
}




__extension__ extern __inline long long int
strtoq (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ()

{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtouq (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ()

{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}




__extension__ extern __inline long long int
strtoll (__const char *__restrict __nptr, char **__restrict __endptr, int __base) throw ()

{
  return __strtoll_internal (__nptr, __endptr, __base, 0);
}
__extension__ extern __inline unsigned long long int
strtoull (__const char * __restrict __nptr, char **__restrict __endptr, int __base) throw ()

{
  return __strtoull_internal (__nptr, __endptr, __base, 0);
}




extern __inline double
atof (__const char *__nptr) throw ()
{
  return strtod (__nptr, (char **) __null);
}
extern __inline int
atoi (__const char *__nptr) throw ()
{
  return (int) strtol (__nptr, (char **) __null, 10);
}
extern __inline long int
atol (__const char *__nptr) throw ()
{
  return strtol (__nptr, (char **) __null, 10);
}




__extension__ extern __inline long long int
atoll (__const char *__nptr) throw ()
{
  return strtoll (__nptr, (char **) __null, 10);
}

# 424 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) throw ();


extern long int a64l (__const char *__s)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));




# 1 "/usr/include/sys/types.h" 1 3 4
# 29 "/usr/include/sys/types.h" 3 4
extern "C" {





typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;




typedef __loff_t loff_t;



typedef __ino_t ino_t;






typedef __ino64_t ino64_t;




typedef __dev_t dev_t;




typedef __gid_t gid_t;




typedef __mode_t mode_t;




typedef __nlink_t nlink_t;




typedef __uid_t uid_t;





typedef __off_t off_t;






typedef __off64_t off64_t;




typedef __pid_t pid_t;




typedef __id_t id_t;




typedef __ssize_t ssize_t;





typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;





typedef __key_t key_t;
# 133 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/time.h" 1 3 4
# 58 "/usr/include/time.h" 3 4


typedef __clock_t clock_t;



# 74 "/usr/include/time.h" 3 4


typedef __time_t time_t;



# 92 "/usr/include/time.h" 3 4
typedef __clockid_t clockid_t;
# 104 "/usr/include/time.h" 3 4
typedef __timer_t timer_t;
# 134 "/usr/include/sys/types.h" 2 3 4



typedef __useconds_t useconds_t;



typedef __suseconds_t suseconds_t;





# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/stddef.h" 1 3 4
# 148 "/usr/include/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 191 "/usr/include/sys/types.h" 3 4
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));


typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));

typedef int register_t __attribute__ ((__mode__ (__word__)));
# 216 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/sys/select.h" 1 3 4
# 31 "/usr/include/sys/select.h" 3 4
# 1 "/usr/include/bits/select.h" 1 3 4
# 32 "/usr/include/sys/select.h" 2 3 4


# 1 "/usr/include/bits/sigset.h" 1 3 4
# 23 "/usr/include/bits/sigset.h" 3 4
typedef int __sig_atomic_t;




typedef struct
  {
    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
  } __sigset_t;
# 35 "/usr/include/sys/select.h" 2 3 4



typedef __sigset_t sigset_t;





# 1 "/usr/include/time.h" 1 3 4
# 118 "/usr/include/time.h" 3 4
struct timespec
  {
    __time_t tv_sec;
    long int tv_nsec;
  };
# 45 "/usr/include/sys/select.h" 2 3 4

# 1 "/usr/include/bits/time.h" 1 3 4
# 69 "/usr/include/bits/time.h" 3 4
struct timeval
  {
    __time_t tv_sec;
    __suseconds_t tv_usec;
  };
# 47 "/usr/include/sys/select.h" 2 3 4
# 55 "/usr/include/sys/select.h" 3 4
typedef long int __fd_mask;
# 67 "/usr/include/sys/select.h" 3 4
typedef struct
  {



    __fd_mask fds_bits[1024 / (8 * sizeof (__fd_mask))];





  } fd_set;






typedef __fd_mask fd_mask;
# 99 "/usr/include/sys/select.h" 3 4
extern "C" {
# 109 "/usr/include/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
     fd_set *__restrict __writefds,
     fd_set *__restrict __exceptfds,
     struct timeval *__restrict __timeout);
# 121 "/usr/include/sys/select.h" 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
      fd_set *__restrict __writefds,
      fd_set *__restrict __exceptfds,
      const struct timespec *__restrict __timeout,
      const __sigset_t *__restrict __sigmask);


}
# 217 "/usr/include/sys/types.h" 2 3 4


# 1 "/usr/include/sys/sysmacros.h" 1 3 4
# 29 "/usr/include/sys/sysmacros.h" 3 4
__extension__
extern __inline unsigned int gnu_dev_major (unsigned long long int __dev)
     throw ();
__extension__
extern __inline unsigned int gnu_dev_minor (unsigned long long int __dev)
     throw ();
__extension__
extern __inline unsigned long long int gnu_dev_makedev (unsigned int __major,
       unsigned int __minor)
     throw ();


__extension__ extern __inline unsigned int
gnu_dev_major (unsigned long long int __dev) throw ()
{
  return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
}

__extension__ extern __inline unsigned int
gnu_dev_minor (unsigned long long int __dev) throw ()
{
  return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
}

__extension__ extern __inline unsigned long long int
gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw ()
{
  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
   | (((unsigned long long int) (__minor & ~0xff)) << 12)
   | (((unsigned long long int) (__major & ~0xfff)) << 32));
}
# 220 "/usr/include/sys/types.h" 2 3 4




typedef __blksize_t blksize_t;






typedef __blkcnt_t blkcnt_t;



typedef __fsblkcnt_t fsblkcnt_t;



typedef __fsfilcnt_t fsfilcnt_t;
# 258 "/usr/include/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;





# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
# 36 "/usr/include/bits/pthreadtypes.h" 3 4
typedef unsigned long int pthread_t;


typedef union
{
  char __size[36];
  long int __align;
} pthread_attr_t;




typedef union
{
  struct
  {
    int __lock;
    unsigned int __count;
    int __owner;


    int __kind;
    unsigned int __nusers;
    int __spins;
  } __data;
  char __size[24];
  long int __align;
} pthread_mutex_t;

typedef union
{
  char __size[4];
  long int __align;
} pthread_mutexattr_t;




typedef union
{
  struct
  {
    int __lock;
    unsigned int __futex;
    __extension__ unsigned long long int __total_seq;
    __extension__ unsigned long long int __wakeup_seq;
    __extension__ unsigned long long int __woken_seq;
    void *__mutex;
    unsigned int __nwaiters;
    unsigned int __broadcast_seq;
  } __data;
  char __size[48];
  __extension__ long long int __align;
} pthread_cond_t;

typedef union
{
  char __size[4];
  long int __align;
} pthread_condattr_t;



typedef unsigned int pthread_key_t;



typedef int pthread_once_t;





typedef union
{
  struct
  {
    int __lock;
    unsigned int __nr_readers;
    unsigned int __readers_wakeup;
    unsigned int __writer_wakeup;
    unsigned int __nr_readers_queued;
    unsigned int __nr_writers_queued;


    unsigned int __flags;
    int __writer;
  } __data;
  char __size[32];
  long int __align;
} pthread_rwlock_t;

typedef union
{
  char __size[8];
  long int __align;
} pthread_rwlockattr_t;





typedef volatile int pthread_spinlock_t;




typedef union
{
  char __size[20];
  long int __align;
} pthread_barrier_t;

typedef union
{
  char __size[4];
  int __align;
} pthread_barrierattr_t;
# 267 "/usr/include/sys/types.h" 2 3 4


}
# 434 "/usr/include/stdlib.h" 2 3 4






extern long int random (void) throw ();


extern void srandom (unsigned int __seed) throw ();





extern char *initstate (unsigned int __seed, char *__statebuf,
   size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));



extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));







struct random_data
  {
    int32_t *fptr;
    int32_t *rptr;
    int32_t *state;
    int rand_type;
    int rand_deg;
    int rand_sep;
    int32_t *end_ptr;
  };

extern int random_r (struct random_data *__restrict __buf,
       int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int srandom_r (unsigned int __seed, struct random_data *__buf)
     throw () __attribute__ ((__nonnull__ (2)));

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
   size_t __statelen,
   struct random_data *__restrict __buf)
     throw () __attribute__ ((__nonnull__ (2, 4)));

extern int setstate_r (char *__restrict __statebuf,
         struct random_data *__restrict __buf)
     throw () __attribute__ ((__nonnull__ (1, 2)));






extern int rand (void) throw ();

extern void srand (unsigned int __seed) throw ();




extern int rand_r (unsigned int *__seed) throw ();







extern double drand48 (void) throw ();
extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));


extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3])
     throw () __attribute__ ((__nonnull__ (1)));


extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3])
     throw () __attribute__ ((__nonnull__ (1)));


extern void srand48 (long int __seedval) throw ();
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
     throw () __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));





struct drand48_data
  {
    unsigned short int __x[3];
    unsigned short int __old_x[3];
    unsigned short int __c;
    unsigned short int __init;
    unsigned long long int __a;
  };


extern int drand48_r (struct drand48_data *__restrict __buffer,
        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));


extern int lrand48_r (struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int mrand48_r (struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     throw () __attribute__ ((__nonnull__ (1, 2)));


extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
     throw () __attribute__ ((__nonnull__ (2)));

extern int seed48_r (unsigned short int __seed16v[3],
       struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));

extern int lcong48_r (unsigned short int __param[7],
        struct drand48_data *__buffer)
     throw () __attribute__ ((__nonnull__ (1, 2)));









extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__));

extern void *calloc (size_t __nmemb, size_t __size)
     throw () __attribute__ ((__malloc__));







extern void *realloc (void *__ptr, size_t __size) throw () __attribute__ ((__malloc__));

extern void free (void *__ptr) throw ();




extern void cfree (void *__ptr) throw ();



# 1 "/usr/include/alloca.h" 1 3 4
# 25 "/usr/include/alloca.h" 3 4
# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/stddef.h" 1 3 4
# 26 "/usr/include/alloca.h" 2 3 4

extern "C" {





extern void *alloca (size_t __size) throw ();





}
# 607 "/usr/include/stdlib.h" 2 3 4




extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__));




extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));




extern void abort (void) throw () __attribute__ ((__noreturn__));



extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));





extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
     throw () __attribute__ ((__nonnull__ (1)));






extern void exit (int __status) throw () __attribute__ ((__noreturn__));






extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));






extern char *getenv (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));




extern char *__secure_getenv (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));





extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));





extern int setenv (__const char *__name, __const char *__value, int __replace)
     throw () __attribute__ ((__nonnull__ (2)));


extern int unsetenv (__const char *__name) throw ();






extern int clearenv (void) throw ();
# 691 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
# 702 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1)));
# 711 "/usr/include/stdlib.h" 3 4
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1)));
# 721 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));








extern int system (__const char *__command);







extern char *canonicalize_file_name (__const char *__name)
     throw () __attribute__ ((__nonnull__ (1)));
# 749 "/usr/include/stdlib.h" 3 4
extern char *realpath (__const char *__restrict __name,
         char *__restrict __resolved) throw ();






typedef int (*__compar_fn_t) (__const void *, __const void *);


typedef __compar_fn_t comparison_fn_t;






extern void *bsearch (__const void *__key, __const void *__base,
        size_t __nmemb, size_t __size, __compar_fn_t __compar)
     __attribute__ ((__nonnull__ (1, 2, 5)));



extern void qsort (void *__base, size_t __nmemb, size_t __size,
     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));



extern int abs (int __x) throw () __attribute__ ((__const__));
extern long int labs (long int __x) throw () __attribute__ ((__const__));



__extension__ extern long long int llabs (long long int __x)
     throw () __attribute__ ((__const__));







extern div_t div (int __numer, int __denom)
     throw () __attribute__ ((__const__));
extern ldiv_t ldiv (long int __numer, long int __denom)
     throw () __attribute__ ((__const__));




__extension__ extern lldiv_t lldiv (long long int __numer,
        long long int __denom)
     throw () __attribute__ ((__const__));

# 814 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4)));




extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4)));




extern char *gcvt (double __value, int __ndigit, char *__buf)
     throw () __attribute__ ((__nonnull__ (3)));




extern char *qecvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     throw () __attribute__ ((__nonnull__ (3, 4)));
extern char *qfcvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     throw () __attribute__ ((__nonnull__ (3, 4)));
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
     throw () __attribute__ ((__nonnull__ (3)));




extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign, char *__restrict __buf,
     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign, char *__restrict __buf,
     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));

extern int qecvt_r (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign,
      char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign,
      char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (3, 4, 5)));







extern int mblen (__const char *__s, size_t __n) throw ();


extern int mbtowc (wchar_t *__restrict __pwc,
     __const char *__restrict __s, size_t __n) throw ();


extern int wctomb (char *__s, wchar_t __wchar) throw ();



extern size_t mbstowcs (wchar_t *__restrict __pwcs,
   __const char *__restrict __s, size_t __n) throw ();

extern size_t wcstombs (char *__restrict __s,
   __const wchar_t *__restrict __pwcs, size_t __n)
     throw ();








extern int rpmatch (__const char *__response) throw () __attribute__ ((__nonnull__ (1)));
# 902 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp,
        char *__const *__restrict __tokens,
        char **__restrict __valuep)
     throw () __attribute__ ((__nonnull__ (1, 2, 3)));





extern void setkey (__const char *__key) throw () __attribute__ ((__nonnull__ (1)));







extern int posix_openpt (int __oflag);







extern int grantpt (int __fd) throw ();



extern int unlockpt (int __fd) throw ();




extern char *ptsname (int __fd) throw ();






extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2)));


extern int getpt (void);






extern int getloadavg (double __loadavg[], int __nelem)
     throw () __attribute__ ((__nonnull__ (1)));





}
# 50 "../tools/qcstring.cpp" 2
# 1 "/usr/include/ctype.h" 1 3 4
# 30 "/usr/include/ctype.h" 3 4
extern "C" {
# 48 "/usr/include/ctype.h" 3 4
enum
{
  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
# 81 "/usr/include/ctype.h" 3 4
extern __const unsigned short int **__ctype_b_loc (void)
     __attribute__ ((__const));
extern __const __int32_t **__ctype_tolower_loc (void)
     __attribute__ ((__const));
extern __const __int32_t **__ctype_toupper_loc (void)
     __attribute__ ((__const));
# 96 "/usr/include/ctype.h" 3 4






extern int isalnum (int) throw ();
extern int isalpha (int) throw ();
extern int iscntrl (int) throw ();
extern int isdigit (int) throw ();
extern int islower (int) throw ();
extern int isgraph (int) throw ();
extern int isprint (int) throw ();
extern int ispunct (int) throw ();
extern int isspace (int) throw ();
extern int isupper (int) throw ();
extern int isxdigit (int) throw ();



extern int tolower (int __c) throw ();


extern int toupper (int __c) throw ();








extern int isblank (int) throw ();






extern int isctype (int __c, int __mask) throw ();






extern int isascii (int __c) throw ();



extern int toascii (int __c) throw ();



extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
# 247 "/usr/include/ctype.h" 3 4
extern int isalnum_l (int, __locale_t) throw ();
extern int isalpha_l (int, __locale_t) throw ();
extern int iscntrl_l (int, __locale_t) throw ();
extern int isdigit_l (int, __locale_t) throw ();
extern int islower_l (int, __locale_t) throw ();
extern int isgraph_l (int, __locale_t) throw ();
extern int isprint_l (int, __locale_t) throw ();
extern int ispunct_l (int, __locale_t) throw ();
extern int isspace_l (int, __locale_t) throw ();
extern int isupper_l (int, __locale_t) throw ();
extern int isxdigit_l (int, __locale_t) throw ();

extern int isblank_l (int, __locale_t) throw ();



extern int __tolower_l (int __c, __locale_t __l) throw ();
extern int tolower_l (int __c, __locale_t __l) throw ();


extern int __toupper_l (int __c, __locale_t __l) throw ();
extern int toupper_l (int __c, __locale_t __l) throw ();
# 323 "/usr/include/ctype.h" 3 4
}
# 51 "../tools/qcstring.cpp" 2
# 1 "/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/include/limits.h" 1 3 4
# 52 "../tools/qcstring.cpp" 2
# 70 "../tools/qcstring.cpp"
void *qmemmove( void *dst, const void *src, uint len )
{
    register char *d;
    register char *s;
    if ( dst > src ) {
 d = (char *)dst + len - 1;
 s = (char *)src + len - 1;
 while ( len-- )
     *d-- = *s--;
    } else if ( dst < src ) {
 d = (char *)dst;
 s = (char *)src;
 while ( len-- )
     *d++ = *s++;
    }
    return dst;
}
# 100 "../tools/qcstring.cpp"
char *qstrdup( const char *src )
{
    if ( !src )
 return 0;
    char *dst = new char[strlen(src)+1];
    (qt_check_pointer((dst)==0,"../tools/qcstring.cpp",105));
    return strcpy( dst, src );
}
# 133 "../tools/qcstring.cpp"
char *qstrncpy( char *dst, const char *src, uint len )
{
    if ( !src || !dst )
 return 0;
    strncpy( dst, src, len );
    if ( len > 0 )
 dst[len-1] = '\0';
    return dst;
}
# 216 "../tools/qcstring.cpp"
int qstricmp( const char *str1, const char *str2 )
{
    register const uchar *s1 = (const uchar *)str1;
    register const uchar *s2 = (const uchar *)str2;
    int res;
    uchar c;
    if ( !s1 || !s2 )
 return s1 ? 1 : ( s2 ? -1 : 0 );
    for ( ; !(res = (c=tolower(*s1)) - tolower(*s2)); s1++, s2++ )
 if ( !c )
     break;
    return res;
}
# 250 "../tools/qcstring.cpp"
int qstrnicmp( const char *str1, const char *str2, uint len )
{
    register const uchar *s1 = (const uchar *)str1;
    register const uchar *s2 = (const uchar *)str2;
    int res;
    uchar c;
    if ( !s1 || !s2 )
 return s1 ? 1 : ( s2 ? -1 : 0 );
    for ( ; len--; s1++, s2++ ) {
 if ( (res = (c=tolower(*s1)) - tolower(*s2)) )
     return res;
 if ( !c )
     break;
    }
    return 0;
}


static Q_UINT16 crc_tbl[16];
static bool crc_tbl_init = FALSE;

static void createCRC16Table()
{
    register uint i;
    register uint j;
    uint v0, v1, v2, v3;
    for ( i = 0; i < 16; i++ ) {
 v0 = i & 1;
 v1 = ( i >> 1 ) & 1;
 v2 = ( i >> 2 ) & 1;
 v3 = ( i >> 3 ) & 1;
 j = 0;


 (j) |= (v0) << (0);
 (j) |= (v0) << (7);
 (j) |= (v0) << (12);
 (j) |= (v1) << (1);
 (j) |= (v1) << (8);
 (j) |= (v1) << (13);
 (j) |= (v2) << (2);
 (j) |= (v2) << (9);
 (j) |= (v2) << (14);
 (j) |= (v3) << (3);
 (j) |= (v3) << (10);
 (j) |= (v3) << (15);
 crc_tbl[i] = j;
    }
}
# 308 "../tools/qcstring.cpp"
Q_UINT16 qChecksum( const char *data, uint len )
{
    if ( !crc_tbl_init ) {






 if ( !crc_tbl_init ) {
     createCRC16Table();
     crc_tbl_init = TRUE;
 }
    }
    register Q_UINT16 crc = 0xffff;
    uchar c;
    uchar *p = (uchar *)data;
    while ( len-- ) {
 c = *p++;
 crc = ( (crc >> 4) & 0x0fff ) ^ crc_tbl[((crc ^ c) & 15)];
 c >>= 4;
 crc = ( (crc >> 4) & 0x0fff ) ^ crc_tbl[((crc ^ c) & 15)];
    }
    return ~crc & 0xffff;
}
# 525 "../tools/qcstring.cpp"
QDataStream &operator<<( QDataStream &s, const QByteArray &a )
{
    return s.writeBytes( a.data(), a.size() );
}
# 539 "../tools/qcstring.cpp"
QDataStream &operator>>( QDataStream &s, QByteArray &a )
{
    Q_UINT32 len;
    s >> len;
    if ( len == 0 || s.eof() ) {
 a.resize( 0 );
 return s;
    }
    if ( !a.resize( (uint)len ) ) {

 qWarning( "QDataStream: Not enough memory to read QByteArray" );

 len = 0;
    }
    if ( len > 0 )
 s.readRawBytes( a.data(), (uint)len );
    return s;
}
# 677 "../tools/qcstring.cpp"
QCString::QCString( int size )
    : QByteArray( size )
{
    if ( size > 0 ) {
 *data() = '\0';
 *(data()+(size-1)) = '\0';
    }
}
# 694 "../tools/qcstring.cpp"
QCString::QCString( const char *str )
{
    duplicate( str, qstrlen(str) + 1 );
}
# 716 "../tools/qcstring.cpp"
QCString::QCString( const char *str, uint maxsize )
{
    if ( str == 0 )
 return;
    uint len;
    for ( len = 0; len < maxsize - 1; len++ ) {
 if ( str[len] == '\0' )
     break;
    }
    QByteArray::resize( len + 1 );
    memcpy( data(), str, len );
    data()[len] = 0;
}





QCString::~QCString()
{
}
# 830 "../tools/qcstring.cpp"
bool QCString::resize( uint len )
{
    detach();
    uint wasNull = isNull();
    if ( !QByteArray::resize(len) )
 return FALSE;
    if ( len )
 data()[len - 1] = '\0';
    if ( len > 0 && wasNull )
 data()[0] = '\0';
    return TRUE;
}
# 872 "../tools/qcstring.cpp"
QCString &QCString::sprintf( const char *format, ... )
{
    detach();
    va_list ap;
    __builtin_va_start(ap,format);
    if ( size() < 256 )
 QByteArray::resize( 256 );
    vsprintf( data(), format, ap );
    resize( qstrlen(data()) + 1 );
    __builtin_va_end(ap);
    return *this;
}
# 896 "../tools/qcstring.cpp"
bool QCString::fill( char c, int len )
{
    detach();
    if ( len < 0 )
 len = length();
    if ( !QByteArray::fill(c,len+1) )
 return FALSE;
    *(data()+len) = '\0';
    return TRUE;
}
# 929 "../tools/qcstring.cpp"
int QCString::find( char c, int index, bool cs ) const
{
    if ( (uint)index >= size() )
 return -1;
    register const char *d;
    if ( cs ) {
 d = strchr( data()+index, c );
    } else {
 d = data()+index;
 c = tolower( (uchar) c );
 while ( *d && tolower((uchar) *d) != c )
     d++;
 if ( !*d && c )
     d = 0;
    }
    return d ? (int)(d - data()) : -1;
}
# 967 "../tools/qcstring.cpp"
int QCString::find( const char *str, int index, bool cs ) const
{
    return find( str, index, cs, length() );
}

int QCString::find( const char *str, int index, bool cs, uint l ) const
{
    if ( (uint)index >= size() )
 return -1;
    if ( !str )
 return -1;
    if ( !*str )
 return index;
    const uint sl = qstrlen( str );
    if ( sl + index > l )
 return -1;

    if ( sl == 1 )
 return find( *str, index, cs );




    const char* needle = str;
    const char* haystack = data() + index;
    const char* end = data() + (l-sl);
    const uint sl_minus_1 = sl-1;
    uint hashNeedle = 0, hashHaystack = 0,i;

    if ( cs ) {
 for ( i = 0; i < sl; ++i ) {
     hashNeedle = ((hashNeedle<<1) + needle[i] );
     hashHaystack = ((hashHaystack<<1) + haystack[i] );
 }
 hashHaystack -= *(haystack+sl_minus_1);

 while ( haystack <= end ) {
     hashHaystack += *(haystack+sl_minus_1);
      if ( hashHaystack == hashNeedle && *needle == *haystack
   && qstrncmp( needle, haystack, sl ) == 0 )
  return haystack - data();

     if ( sl_minus_1 < sizeof(uint) * 8 ) hashHaystack -= (*haystack) << sl_minus_1; hashHaystack <<= 1;
     ++haystack;
 }
    } else {
 for ( i = 0; i < sl; ++i ) {
     hashNeedle = ((hashNeedle<<1) +
     tolower( needle[i] ) );
     hashHaystack = ((hashHaystack<<1) +
       tolower( haystack[i] ) );
 }
 hashHaystack -= tolower(*(haystack+sl_minus_1));

 while ( haystack <= end ) {
     hashHaystack += tolower(*(haystack+sl_minus_1));
     if ( hashHaystack == hashNeedle
   && qstrnicmp( needle, haystack, sl ) == 0 )
  return haystack - data();

     if ( sl_minus_1 < sizeof(uint) * 8 ) hashHaystack -= (tolower(*haystack)) << sl_minus_1; hashHaystack <<= 1;
     ++haystack;
 }
    }
    return -1;
}
# 1047 "../tools/qcstring.cpp"
int QCString::findRev( char c, int index, bool cs ) const
{
    register const char *b = data();
    register const char *d;
    if ( index < 0 )
 index = length();
    if ( (uint)index >= size() )
 return -1;
    d = b + index;
    if ( cs ) {
 while ( d >= b && *d != c )
     d--;
    } else {
 c = tolower( (uchar) c );
 while ( d >= b && tolower((uchar) *d) != c )
     d--;
    }
    return d >= b ? (int)(d - b) : -1;
}
# 1082 "../tools/qcstring.cpp"
int QCString::findRev( const char *str, int index, bool cs ) const
{



    const uint sl = qstrlen( str );
    const uint l = length();
    int delta = l-sl;
    if ( index < 0 )
 index = delta;
    if ( index < 0 || index > (int)l )
 return -1;
    if ( index > delta )
 index = delta;

    if ( sl == 1 )
 return findRev( *str, index, cs );

    const char* needle = str;
    const char* haystack = data() + index;
    const char* end = data();
    const uint sl_minus_1 = sl-1;
    const char* n = needle+sl_minus_1;
    const char* h = haystack+sl_minus_1;
    uint hashNeedle = 0, hashHaystack = 0, i;

    if ( cs ) {
 for ( i = 0; i < sl; ++i ) {
     hashNeedle = ((hashNeedle<<1) + *(n-i) );
     hashHaystack = ((hashHaystack<<1) + *(h-i) );
 }
 hashHaystack -= *haystack;
 while ( haystack >= end ) {
     hashHaystack += *haystack;
      if ( hashHaystack == hashNeedle && qstrncmp( needle, haystack, sl ) == 0 )
  return haystack-data();
     --haystack;
     if ( sl_minus_1 < sizeof(uint) * 8 ) hashHaystack -= (*(haystack+sl)) << sl_minus_1; hashHaystack <<= 1;
 }
    } else {
 for ( i = 0; i < sl; ++i ) {
     hashNeedle = ((hashNeedle<<1) + tolower( *(n-i) ) );
     hashHaystack = ((hashHaystack<<1) + tolower( *(h-i) ) );
 }
 hashHaystack -= tolower(*haystack);
 while ( haystack >= end ) {
     hashHaystack += tolower(*haystack);
     if ( hashHaystack == hashNeedle && qstrnicmp( needle, haystack, sl ) == 0 )
  return haystack-data();
     --haystack;
     if ( sl_minus_1 < sizeof(uint) * 8 ) hashHaystack -= (tolower(*(haystack+sl))) << sl_minus_1; hashHaystack <<= 1;
 }
    }
    return -1;
}
# 1149 "../tools/qcstring.cpp"
int QCString::contains( char c, bool cs ) const
{
    int count = 0;
    char *d = data();
    if ( !d )
 return 0;
    if ( cs ) {
 while ( *d )
     if ( *d++ == c )
  count++;
    } else {
 c = tolower( (uchar) c );
 while ( *d ) {
     if ( tolower((uchar) *d) == c )
  count++;
     d++;
 }
    }
    return count;
}
# 1185 "../tools/qcstring.cpp"
int QCString::contains( const char *str, bool cs ) const
{
    int count = 0;
    int i = -1;
    uint l = length();

    while ( ( i = find ( str, i+1, cs, l ) ) != -1 )
 count++;
    return count;
}
# 1211 "../tools/qcstring.cpp"
QCString QCString::left( uint len ) const
{
    if ( isEmpty() ) {
 QCString empty;
 return empty;
    } else if ( len >= size() ) {
 QCString same( data() );
 return same;
    } else {
 QCString s( len+1 );
 strncpy( s.data(), data(), len );
 *(s.data()+len) = '\0';
 return s;
    }
}
# 1243 "../tools/qcstring.cpp"
QCString QCString::right( uint len ) const
{
    if ( isEmpty() ) {
 QCString empty;
 return empty;
    } else {
 uint l = length();
 if ( len > l )
     len = l;
 char *p = data() + (l - len);
 return QCString( p );
    }
}
# 1274 "../tools/qcstring.cpp"
QCString QCString::mid( uint index, uint len ) const
{
    uint slen = qstrlen( data() );
    if ( isEmpty() || index >= slen ) {
 QCString empty;
 return empty;
    } else {
 if ( len > slen-index )
     len = slen - index;
 register char *p = data()+index;
 QCString s( len+1 );
 strncpy( s.data(), p, len );
 *(s.data()+len) = '\0';
 return s;
    }
}
# 1309 "../tools/qcstring.cpp"
QCString QCString::leftJustify( uint width, char fill, bool truncate ) const
{
    QCString result;
    int len = qstrlen(data());
    int padlen = width - len;
    if ( padlen > 0 ) {
 result.QByteArray::resize( len+padlen+1 );
 memcpy( result.data(), data(), len );
 memset( result.data()+len, fill, padlen );
 result[len+padlen] = '\0';
    } else {
 if ( truncate )
     result = left( width );
 else
     result = copy();
    }
    return result;
}
# 1347 "../tools/qcstring.cpp"
QCString QCString::rightJustify( uint width, char fill, bool truncate ) const
{
    QCString result;
    int len = qstrlen(data());
    int padlen = width - len;
    if ( padlen > 0 ) {
 result.QByteArray::resize( len+padlen+1 );
 memset( result.data(), fill, padlen );
 memcpy( result.data()+padlen, data(), len );
 result[len+padlen] = '\0';
    } else {
 if ( truncate )
     result = left( width );
 else
     result = copy();
    }
    return result;
}
# 1380 "../tools/qcstring.cpp"
QCString QCString::lower() const
{
    QCString s( data() );
    register char *p = s.data();
    if ( p ) {
 while ( *p ) {
     *p = tolower( (uchar) *p );
     p++;
 }
    }
    return s;
}
# 1406 "../tools/qcstring.cpp"
QCString QCString::upper() const
{
    QCString s( data() );
    register char *p = s.data();
    if ( p ) {
 while ( *p ) {
     *p = toupper(*p);
     p++;
 }
    }
    return s;
}
# 1436 "../tools/qcstring.cpp"
QCString QCString::stripWhiteSpace() const
{
    if ( isEmpty() )
 return copy();

    register char *s = data();
    QCString result = s;
    int reslen = result.length();
    if ( !isspace((uchar) s[0]) && !isspace((uchar) s[reslen-1]) )
 return result;

    s = result.data();
    int start = 0;
    int end = reslen - 1;
    while ( isspace((uchar) s[start]) )
 start++;
    if ( s[start] == '\0' ) {
 result.resize( 1 );
 return result;
    }
    while ( end && isspace((uchar) s[end]) )
 end--;
    end -= start - 1;
    memmove( result.data(), &s[start], end );
    result.resize( end + 1 );
    return result;
}
# 1481 "../tools/qcstring.cpp"
QCString QCString::simplifyWhiteSpace() const
{
    if ( isEmpty() )
 return copy();
    QCString result( size() );
    char *from = data();
    char *to = result.data();
    char *first = to;
    for ( ;; ) {
 while ( isspace((uchar) *from) )
     from++;
 while ( *from && !isspace((uchar) *from) )
     *to++ = *from++;
 if ( *from )
     *to++ = 0x20;
 else
     break;
    }
    if ( to > first && *(to-1) == 0x20 )
 to--;
    *to = '\0';
    result.resize( (int)(to - result.data()) + 1 );
    return result;
}
# 1525 "../tools/qcstring.cpp"
QCString &QCString::insert( uint index, const char *s )
{
    int len = qstrlen(s);
    if ( len == 0 )
 return *this;
    uint olen = length();
    int nlen = olen + len;
    if ( index >= olen ) {
 detach();
 if ( QByteArray::resize(nlen+index-olen+1, QByteArray::SpeedOptim ) ) {
     memset( data()+olen, ' ', index-olen );
     memcpy( data()+index, s, len+1 );
 }
    } else {
 detach();
 if ( QByteArray::resize(nlen+1, QByteArray::SpeedOptim ) ) {
     memmove( data()+index+len, data()+index, olen-index+1 );
     memcpy( data()+index, s, len );
 }
    }
    return *this;
}
# 1565 "../tools/qcstring.cpp"
QCString &QCString::insert( uint index, char c )
{
    char buf[2];
    buf[0] = c;
    buf[1] = '\0';
    return insert( index, buf );
}
# 1597 "../tools/qcstring.cpp"
QCString &QCString::remove( uint index, uint len )
{
    uint olen = length();
    if ( index + len >= olen ) {
 if ( index < olen ) {
     detach();
     resize( index+1 );
 }
    } else if ( len != 0 ) {
 detach();
 memmove( data()+index, data()+index+len, olen-index-len+1 );
 QByteArray::resize(olen-len+1, QByteArray::SpeedOptim );
    }
    return *this;
}
# 1630 "../tools/qcstring.cpp"
QCString &QCString::replace( uint index, uint len, const char *str )
{
    remove( index, len );
    insert( index, str );
    return *this;
}
# 1650 "../tools/qcstring.cpp"
QCString &QCString::replace( char c, const char *after )
{
    char str[2];
    str[0] = c;
    str[1] = '\0';
    return replace( str, after );
}
# 1671 "../tools/qcstring.cpp"
QCString &QCString::replace( const char *before, const char *after )
{
    if ( before == after || isNull() )
 return *this;

    detach();

    int index = 0;
    const int bl = before ? int(strlen( before )) : 0;
    const int al = after ? int(strlen( after )) : 0;
    char *d = data();
    uint len = length();

    if ( bl == al ) {
 if ( bl ) {
     while( (index = find( before, index, TRUE, len ) ) != -1 ) {
  memcpy( d+index, after, al );
  index += bl;
     }
 }
    } else if ( al < bl ) {
 uint to = 0;
 uint movestart = 0;
 uint num = 0;
 while( (index = find( before, index, TRUE, len ) ) != -1 ) {
     if ( num ) {
  int msize = index - movestart;
  if ( msize > 0 ) {
      memmove( d + to, d + movestart, msize );
      to += msize;
  }
     } else {
  to = index;
     }
     if ( al ) {
  memcpy( d + to, after, al );
  to += al;
     }
     index += bl;
     movestart = index;
     num++;
 }
 if ( num ) {
     int msize = len - movestart;
     if ( msize > 0 )
  memmove( d + to, d + movestart, msize );
     resize( len - num*(bl-al) + 1 );
 }
    } else {


 while( index != -1 ) {
     uint indices[4096];
     uint pos = 0;
     while( pos < 4095 ) {
  index = find(before, index, TRUE, len);
  if ( index == -1 )
      break;
  indices[pos++] = index;
  index += bl;

  if ( !bl )
      index++;
     }
     if ( !pos )
  break;


     int adjust = pos*(al-bl);

     if ( index != -1 )
  index += adjust;
     uint newlen = len + adjust;
     int moveend = len;
     if ( newlen > len ) {
  resize( newlen + 1 );
  len = newlen;
     }
     d = data();

     while( pos ) {
  pos--;
  int movestart = indices[pos] + bl;
  int insertstart = indices[pos] + pos*(al-bl);
  int moveto = insertstart + al;
  memmove( d + moveto, d + movestart, (moveend - movestart) );
  if ( after )
      memcpy( d + insertstart, after, al );
  moveend = movestart - bl;
     }
 }
    }
    return *this;
}






QCString &QCString::replace( char c1, char c2 )
{
    detach();
    uint i = 0;
    char *d = data();
    uint len = length();
    while ( i < len ) {
 if ( d[i] == c1 )
     d[i] = c2;
 i++;
    }
    return *this;
}
# 1801 "../tools/qcstring.cpp"
int QCString::find( const QRegExp& rx, int index ) const
{
    QString d = QString::fromAscii( data() );
    return d.find( rx, index );
}
# 1821 "../tools/qcstring.cpp"
int QCString::findRev( const QRegExp& rx, int index ) const
{
    QString d = QString::fromAscii( data() );
    return d.findRev( rx, index );
}
# 1846 "../tools/qcstring.cpp"
int QCString::contains( const QRegExp &rx ) const
{
    QString d = QString::fromAscii( data() );
    return d.contains( rx );
}
# 1876 "../tools/qcstring.cpp"
QCString &QCString::replace( const QRegExp &rx, const char *str )
{
    QString d = QString::fromAscii( data() );
    QString r = QString::fromAscii( str );
    d.replace( rx, r );
    setStr( d.ascii() );
    return *this;
}
# 1894 "../tools/qcstring.cpp"
long QCString::toLong( bool *ok ) const
{
    char *p = data();
    long val=0;
    const long max_mult = 2147483647L / 10;
    bool is_ok = FALSE;
    int neg = 0;
    if ( !p )
 goto bye;
    while ( isspace((uchar) *p) )
 p++;
    if ( *p == '-' ) {
 p++;
 neg = 1;
    } else if ( *p == '+' ) {
 p++;
    }
    if ( !isdigit((uchar) *p) )
 goto bye;
    while ( isdigit((uchar) *p) ) {
 if ( val > max_mult || (val == max_mult && (*p-'0') > 7+neg) )
     goto bye;
 val = 10*val + (*p++ - '0');
    }
    if ( neg )
 val = -val;
    while ( isspace((uchar) *p) )
 p++;
    if ( *p == '\0' )
 is_ok = TRUE;
bye:
    if ( ok )
 *ok = is_ok;
    return is_ok ? val : 0;
}
# 1938 "../tools/qcstring.cpp"
ulong QCString::toULong( bool *ok ) const
{
    char *p = data();
    ulong val=0;
    const ulong max_mult = (2147483647L * 2UL + 1UL) / 10;
    bool is_ok = FALSE;
    if ( !p )
 goto bye;
    while ( isspace((uchar) *p) )
 p++;
    if ( *p == '+' )
 p++;
    if ( !isdigit((uchar) *p) )
 goto bye;
    while ( isdigit((uchar) *p) ) {
 if ( val > max_mult || (val == max_mult && (*p-'0') > 5) )
     goto bye;
 val = 10*val + (*p++ - '0');
    }
    while ( isspace((uchar) *p) )
 p++;
    if ( *p == '\0' )
 is_ok = TRUE;
bye:
    if ( ok )
 *ok = is_ok;
    return is_ok ? val : 0;
}
# 1975 "../tools/qcstring.cpp"
short QCString::toShort( bool *ok ) const
{
    long v = toLong( ok );
    if ( v < (-32767 - 1) || v > 32767 ) {
 if ( ok )
     *ok = FALSE;
 v = 0;
    }
    return (short)v;
}
# 1994 "../tools/qcstring.cpp"
ushort QCString::toUShort( bool *ok ) const
{
    ulong v = toULong( ok );
    if ( v > (32767 * 2 + 1) ) {
 if ( ok )
     *ok = FALSE;
 v = 0;
    }
    return (ushort)v;
}
# 2014 "../tools/qcstring.cpp"
int QCString::toInt( bool *ok ) const
{
    long v = toLong( ok );
    if ( v < (-2147483647 - 1) || v > 2147483647 ) {
 if ( ok )
     *ok = FALSE;
 v = 0;
    }
    return (int)v;
}
# 2033 "../tools/qcstring.cpp"
uint QCString::toUInt( bool *ok ) const
{
    ulong v = toULong( ok );
    if ( v > (2147483647 * 2U + 1U) ) {
 if ( ok )
     *ok = FALSE;
 v = 0;
    }
    return (uint)v;
}
# 2052 "../tools/qcstring.cpp"
double QCString::toDouble( bool *ok ) const
{
    char *end;
    double val = strtod( data() ? data() : "", &end );
    if ( ok )
 *ok = ( data() && *data() && ( end == 0 || *end == '\0' ) );
    return val;
}
# 2069 "../tools/qcstring.cpp"
float QCString::toFloat( bool *ok ) const
{
    return (float)toDouble( ok );
}






QCString &QCString::setStr( const char *str )
{
    detach();
    if ( str )
 store( str, qstrlen(str)+1 );
    else
 resize( 0 );
    return *this;
}
# 2096 "../tools/qcstring.cpp"
QCString &QCString::setNum( long n )
{
    detach();
    char buf[20];
    register char *p = &buf[19];
    bool neg;
    if ( n < 0 ) {
 neg = TRUE;
 n = -n;
    } else {
 neg = FALSE;
    }
    *p = '\0';
    do {
 *--p = ((int)(n%10)) + '0';
 n /= 10;
    } while ( n );
    if ( neg )
 *--p = '-';
    store( p, qstrlen(p)+1 );
    return *this;
}
# 2126 "../tools/qcstring.cpp"
QCString &QCString::setNum( ulong n )
{
    detach();
    char buf[20];
    register char *p = &buf[19];
    *p = '\0';
    do {
 *--p = ((int)(n%10)) + '0';
 n /= 10;
    } while ( n );
    store( p, qstrlen(p)+1 );
    return *this;
}
# 2181 "../tools/qcstring.cpp"
QCString &QCString::setNum( double n, char f, int prec )
{

    if ( !(f=='f' || f=='F' || f=='e' || f=='E' || f=='g' || f=='G') )
 qWarning( "QCString::setNum: Invalid format char '%c'", f );

    char format[20];
    register char *fs = format;
    *fs++ = '%';
    if ( prec > 99 )
 prec = 99;
    *fs++ = '.';
    if ( prec >= 10 ) {
 *fs++ = prec / 10 + '0';
 *fs++ = prec % 10 + '0';
    } else {
 *fs++ = prec + '0';
    }
    *fs++ = 'l';
    *fs++ = f;
    *fs = '\0';
    return sprintf( format, n );
}
# 2216 "../tools/qcstring.cpp"
bool QCString::setExpand( uint index, char c )
{
    detach();
    uint oldlen = length();
    if ( index >= oldlen ) {
 if ( !QByteArray::resize( index+2 ) )
     return FALSE;
 if ( index > oldlen )
     memset( data() + oldlen, ' ', index - oldlen );
 *(data() + index+1) = '\0';
    }
    *(data() + index) = c;
    return TRUE;
}
# 2250 "../tools/qcstring.cpp"
QCString& QCString::operator+=( const char *str )
{
    if ( !str )
 return *this;
    detach();
    uint len1 = length();
    uint len2 = qstrlen(str);
    if ( !QByteArray::resize( len1 + len2 + 1, QByteArray::SpeedOptim ) )
 return *this;
    memcpy( data() + len1, str, len2 + 1 );
    return *this;
}







QCString &QCString::operator+=( char c )
{
    detach();
    uint len = length();
    if ( !QByteArray::resize( len + 2, QByteArray::SpeedOptim ) )
 return *this;
    *(data() + len) = c;
    *(data() + len+1) = '\0';
    return *this;
}
# 2292 "../tools/qcstring.cpp"
QDataStream &operator<<( QDataStream &s, const QCString &str )
{
    return s.writeBytes( str.data(), str.size() );
}
# 2305 "../tools/qcstring.cpp"
QDataStream &operator>>( QDataStream &s, QCString &str )
{
    str.detach();
    Q_UINT32 len;
    s >> len;
    if ( len == 0 || s.eof() ) {
 str.resize( 0 );
 return s;
    }
    if ( !str.QByteArray::resize( (uint)len )) {

 qWarning( "QDataStream: Not enough memory to read QCString" );

 len = 0;
    }
    if ( len > 0 )
 s.readRawBytes( str.data(), (uint)len );
    return s;
}