qcstring.cpp

Go to the documentation of this file.

/****************************************************************************
** $Id: qcstring.cpp,v 1.2 2003/07/10 02:40:11 llornkcor Exp $
**
** Implementation of extended char array operations, and QByteArray and
** QCString classes
**
** Created : 920722
**
** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
**
** This file is part of the tools module of the Qt GUI Toolkit.
**
** This file may be distributed under the terms of the Q Public License
** as defined by Trolltech AS of Norway and appearing in the file
** LICENSE.QPL included in the packaging of this file.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
** licenses may use this file in accordance with the Qt Commercial License
** Agreement provided with the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
**   information about Qt Commercial License Agreements.
** See http://www.trolltech.com/qpl/ for QPL licensing information.
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#include "qstring.h"
#include "qregexp.h"
#include "qdatastream.h"

#ifdef QT_THREAD_SUPPORT
#  include <private/qmutexpool_p.h>
#endif // QT_THREAD_SUPPORT

#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <ctype.h>
#include <limits.h>
#ifndef QT_NO_COMPRESS
#include "../3rdparty/zlib/zlib.h"
#endif

/*****************************************************************************
  Safe and portable C string functions; extensions to standard string.h
 *****************************************************************************/

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;
}


char *qstrdup( const char *src )
{
    if ( !src )
        return 0;
    char *dst = new char[strlen(src)+1];
    Q_CHECK_PTR( dst );
    return strcpy( dst, src );
}

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;
}

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 )                               // strings are equal
            break;
    return res;
}

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 )                               // strings are equal
            break;
    }
    return 0;
}


static Q_UINT16 crc_tbl[16];
static bool   crc_tbl_init = FALSE;

static void createCRC16Table()                  // build CRC16 lookup table
{
    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;
#undef SET_BIT
#define SET_BIT(x, b, v) (x) |= (v) << (b)
        SET_BIT( j,  0, v0 );
        SET_BIT( j,  7, v0 );
        SET_BIT( j, 12, v0 );
        SET_BIT( j,  1, v1 );
        SET_BIT( j,  8, v1 );
        SET_BIT( j, 13, v1 );
        SET_BIT( j,  2, v2 );
        SET_BIT( j,  9, v2 );
        SET_BIT( j, 14, v2 );
        SET_BIT( j,  3, v3 );
        SET_BIT( j, 10, v3 );
        SET_BIT( j, 15, v3 );
        crc_tbl[i] = j;
    }
}

Q_UINT16 qChecksum( const char *data, uint len )
{
    if ( !crc_tbl_init ) {                      // create lookup table

#ifdef QT_THREAD_SUPPORT
        QMutexLocker locker( qt_global_mutexpool ?
                             qt_global_mutexpool->get( &crc_tbl_init ) : 0 );
#endif // QT_THREAD_SUPPORT

        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;
}

#ifndef QT_NO_COMPRESS
QByteArray qCompress( const uchar* data, int nbytes )
{
    if ( nbytes == 0 ) {
        QByteArray tmp( 4 );
        tmp.fill( 0 );
        return tmp;
    }
    if ( !data ) {
#if defined(QT_CHECK_RANGE)
        qWarning( "qCompress: data is NULL." );
#endif
        return QByteArray();
    }

    ulong len = nbytes * 2;
    QByteArray bazip;
    int res;
    do {
        bazip.resize( len + 4 );
        res = ::compress(  (uchar*)bazip.data()+4, &len, (uchar*)data, nbytes );

        switch ( res ) {
        case Z_OK:
            bazip.resize( len + 4 );
            bazip[0] = ( nbytes & 0xff000000 ) >> 24;
            bazip[1] = ( nbytes & 0x00ff0000 ) >> 16;
            bazip[2] = ( nbytes & 0x0000ff00 ) >> 8;
            bazip[3] = ( nbytes & 0x000000ff );
            break;
        case Z_MEM_ERROR:
#if defined(QT_CHECK_RANGE)
            qWarning( "qCompress: Z_MEM_ERROR: Not enough memory." );
#endif
            bazip.resize( 0 );
            break;
        case Z_BUF_ERROR:
            len *= 2;
            break;
        }
    } while ( res == Z_BUF_ERROR );

    return bazip;
}
#endif

#ifndef QT_NO_COMPRESS
QByteArray qUncompress( const uchar* data, int nbytes )
{
    if ( !data ) {
#if defined(QT_CHECK_RANGE)
        qWarning( "qUncompress: data is NULL." );
#endif
        return QByteArray();
    }
    if ( nbytes <= 4 ) {
#if defined(QT_CHECK_RANGE)
        if ( nbytes < 4 || ( data[0]!=0 || data[1]!=0 || data[2]!=0 || data[3]!=0 ) )
            qWarning( "qUncompress: Input data is corrupted." );
#endif
        return QByteArray();
    }
    ulong expectedSize = ( data[0] << 24 ) | ( data[1] << 16 ) | ( data[2] << 8 ) | data[3];
    ulong len = QMAX( expectedSize,  1 );
    QByteArray baunzip;
    int res;
    do {
        baunzip.resize( len );
        res = ::uncompress( (uchar*)baunzip.data(), &len,
                                (uchar*)data+4, nbytes-4 );

        switch ( res ) {
        case Z_OK:
            if ( len != baunzip.size() )
                baunzip.resize( len );
            break;
        case Z_MEM_ERROR:
#if defined(QT_CHECK_RANGE)
            qWarning( "qUncompress: Z_MEM_ERROR: Not enough memory." );
#endif
            break;
        case Z_BUF_ERROR:
            len *= 2;
            break;
        case Z_DATA_ERROR:
#if defined(QT_CHECK_RANGE)
            qWarning( "qUncompress: Z_DATA_ERROR: Input data is corrupted." );
#endif
            break;
        }
    } while ( res == Z_BUF_ERROR );

    if ( res != Z_OK )
        baunzip = QByteArray();

    return baunzip;
}
#endif

/*****************************************************************************
  QByteArray documentation
 *****************************************************************************/

/*****************************************************************************
  QByteArray stream functions
 *****************************************************************************/

#ifndef QT_NO_DATASTREAM

QDataStream &operator<<( QDataStream &s, const QByteArray &a )
{
    return s.writeBytes( a.data(), a.size() );
}

QDataStream &operator>>( QDataStream &s, QByteArray &a )
{
    Q_UINT32 len;
    s >> len;                                   // read size of array
    if ( len == 0 || s.eof() ) {                // end of file reached
        a.resize( 0 );
        return s;
    }
    if ( !a.resize( (uint)len ) ) {             // resize array
#if defined(QT_CHECK_NULL)
        qWarning( "QDataStream: Not enough memory to read QByteArray" );
#endif
        len = 0;
    }
    if ( len > 0 )                              // not null array
        s.readRawBytes( a.data(), (uint)len );
    return s;
}

#endif //QT_NO_DATASTREAM

/*****************************************************************************
  QCString member functions
 *****************************************************************************/

QCString::QCString( int size )
    : QByteArray( size )
{
    if ( size > 0 ) {
        *data() = '\0';                         // set terminator
        *(data()+(size-1)) = '\0';
    }
}

QCString::QCString( const char *str )
{
    duplicate( str, qstrlen(str) + 1 );
}


QCString::QCString( const char *str, uint maxsize )
{
    if ( str == 0 )
        return;
    uint len; // index of first '\0'
    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()
{
}

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;
}


QCString &QCString::sprintf( const char *format, ... )
{
    detach();
    va_list ap;
    va_start( ap, format );
    if ( size() < 256 )
        QByteArray::resize( 256 );              // make string big enough
    vsprintf( data(), format, ap );
    resize( qstrlen(data()) + 1 );              // truncate
    va_end( ap );
    return *this;
}


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;
}


int QCString::find( char c, int index, bool cs ) const
{
    if ( (uint)index >= size() )                // index outside string
        return -1;
    register const char *d;
    if ( cs ) {                                 // case sensitive
        d = strchr( data()+index, c );
    } else {
        d = data()+index;
        c = tolower( (uchar) c );
        while ( *d && tolower((uchar) *d) != c )
            d++;
        if ( !*d && c )                         // not found
            d = 0;
    }
    return d ? (int)(d - data()) : -1;
}

#define REHASH( a ) \
    if ( sl_minus_1 < sizeof(uint) * CHAR_BIT ) \
        hashHaystack -= (a) << sl_minus_1; \
    hashHaystack <<= 1

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 );

    /*
      See QString::find() for details.
    */
    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();

            REHASH( *haystack );
            ++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();

            REHASH( tolower(*haystack) );
            ++haystack;
        }
    }
    return -1;
}


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;
}

int QCString::findRev( const char *str, int index, bool cs ) const
{
    /*
      See QString::find() for explanations.
    */
    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;
            REHASH( *(haystack+sl) );
        }
    } 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;
            REHASH( tolower(*(haystack+sl)) );
        }
    }
    return -1;
}


int QCString::contains( char c, bool cs ) const
{
    int count = 0;
    char *d = data();
    if ( !d )
        return 0;
    if ( cs ) {                                 // case sensitive
        while ( *d )
            if ( *d++ == c )
                count++;
    } else {                                    // case insensitive
        c = tolower( (uchar) c );
        while ( *d ) {
            if ( tolower((uchar) *d) == c )
                count++;
            d++;
        }
    }
    return count;
}

int QCString::contains( const char *str, bool cs ) const
{
    int count = 0;
    int i = -1;
    uint l = length();
    // use find for the faster hashing algorithm
    while ( ( i = find ( str, i+1, cs, l ) ) != -1 )
        count++;
    return count;
}

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;
    }
}

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 );
    }
}

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;
    }
}

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;
}

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;
}

QCString QCString::lower() const
{
    QCString s( data() );
    register char *p = s.data();
    if ( p ) {
        while ( *p ) {
            *p = tolower( (uchar) *p );
            p++;
        }
    }
    return s;
}

QCString QCString::upper() const
{
    QCString s( data() );
    register char *p = s.data();
    if ( p ) {
        while ( *p ) {
            *p = toupper(*p);
            p++;
        }
    }
    return s;
}


QCString QCString::stripWhiteSpace() const
{
    if ( isEmpty() )                            // nothing to do
        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;                          // returns a copy

    s = result.data();
    int start = 0;
    int end = reslen - 1;
    while ( isspace((uchar) s[start]) )         // skip white space from start
        start++;
    if ( s[start] == '\0' ) {                   // only white space
        result.resize( 1 );
        return result;
    }
    while ( end && isspace((uchar) s[end]) )    // skip white space from end
        end--;
    end -= start - 1;
    memmove( result.data(), &s[start], end );
    result.resize( end + 1 );
    return result;
}


QCString QCString::simplifyWhiteSpace() const
{
    if ( isEmpty() )                            // nothing to do
        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;
}


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 ) {                      // insert after end of string
        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 ) ) {    // normal insert
            memmove( data()+index+len, data()+index, olen-index+1 );
            memcpy( data()+index, s, len );
        }
    }
    return *this;
}

QCString &QCString::insert( uint index, char c )        // insert char
{
    char buf[2];
    buf[0] = c;
    buf[1] = '\0';
    return insert( index, buf );
}

QCString &QCString::remove( uint index, uint len )
{
    uint olen = length();
    if ( index + len >= olen ) {                // range problems
        if ( index < olen ) {                   // index ok
            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;
}

QCString &QCString::replace( uint index, uint len, const char *str )
{
    remove( index, len );
    insert( index, str );
    return *this;
}


QCString &QCString::replace( char c, const char *after )
{
    char str[2];
    str[0] = c;
    str[1] = '\0';
    return replace( str, after );
}

QCString &QCString::replace( const char *before, const char *after )
{
    if ( before == after || isNull() )
        return *this;

    detach();

    int index = 0;
    const int bl = before ? strlen( before ) : 0;
    const int al = after ? 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 {
        // the most complex case. We don't want to loose performance by doing repeated
        // copies and reallocs of the string.
        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;
                // avoid infinite loop
                if ( !bl )
                    index++;
            }
            if ( !pos )
                break;

            // we have a table of replacement positions, use them for fast replacing
            int adjust = pos*(al-bl);
            // index has to be adjusted in case we get back into the loop above.
            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;
}


#ifndef QT_NO_REGEXP_CAPTURE

int QCString::find( const QRegExp& rx, int index ) const
{
    QString d = QString::fromAscii( data() );
    return d.find( rx, index );
}

int QCString::findRev( const QRegExp& rx, int index ) const
{
    QString d = QString::fromAscii( data() );
    return d.findRev( rx, index );
}

int QCString::contains( const QRegExp &rx ) const
{
    QString d = QString::fromAscii( data() );
    return d.contains( rx );
}


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;
}
#endif //QT_NO_REGEXP

long QCString::toLong( bool *ok ) const
{
    char *p = data();
    long val=0;
    const long max_mult = 214748364;
    bool is_ok = FALSE;
    int neg = 0;
    if ( !p )
        goto bye;
    while ( isspace((uchar) *p) )               // skip leading space
        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) )               // skip trailing space
        p++;
    if ( *p == '\0' )
        is_ok = TRUE;
bye:
    if ( ok )
        *ok = is_ok;
    return is_ok ? val : 0;
}

ulong QCString::toULong( bool *ok ) const
{
    char *p = data();
    ulong val=0;
    const ulong max_mult = 429496729;
    bool is_ok = FALSE;
    if ( !p )
        goto bye;
    while ( isspace((uchar) *p) )               // skip leading space
        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) )               // skip trailing space
        p++;
    if ( *p == '\0' )
        is_ok = TRUE;
bye:
    if ( ok )
        *ok = is_ok;
    return is_ok ? val : 0;
}

short QCString::toShort( bool *ok ) const
{
    long v = toLong( ok );
    if ( ok && *ok && (v < -32768 || v > 32767) )
        *ok = FALSE;
    return (short)v;
}

ushort QCString::toUShort( bool *ok ) const
{
    ulong v = toULong( ok );
    if ( ok && *ok && (v > 65535) )
        *ok = FALSE;
    return (ushort)v;
}


int QCString::toInt( bool *ok ) const
{
    return (int)toLong( ok );
}

uint QCString::toUInt( bool *ok ) const
{
    return (uint)toULong( ok );
}

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;
}

float QCString::toFloat( bool *ok ) const
{
    return (float)toDouble( ok );
}


QCString &QCString::setStr( const char *str )
{
    detach();
    if ( str )                                  // valid string
        store( str, qstrlen(str)+1 );
    else                                        // empty
        resize( 0 );
    return *this;
}

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;
}

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;
}

QCString &QCString::setNum( double n, char f, int prec )
{
#if defined(QT_CHECK_RANGE)
    if ( !(f=='f' || f=='F' || f=='e' || f=='E' || f=='g' || f=='G') )
        qWarning( "QCString::setNum: Invalid format char '%c'", f );
#endif
    char format[20];
    register char *fs = format;                 // generate format string
    *fs++ = '%';                                //   "%.<prec>l<f>"
    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 );
}

bool QCString::setExpand( uint index, char c )
{
    detach();
    uint oldlen = length();
    if ( index >= oldlen ) {
        if ( !QByteArray::resize( index+2 ) )   // no memory
            return FALSE;
        if ( index > oldlen )
            memset( data() + oldlen, ' ', index - oldlen );
        *(data() + index+1) = '\0';             // terminate padded string
    }
    *(data() + index) = c;
    return TRUE;
}


QCString& QCString::operator+=( const char *str )
{
    if ( !str )
        return *this;                           // nothing to append
    detach();
    uint len1 = length();
    uint len2 = qstrlen(str);
    if ( !QByteArray::resize( len1 + len2 + 1, QByteArray::SpeedOptim ) )
        return *this;                           // no memory
    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;                           // no memory
    *(data() + len) = c;
    *(data() + len+1) = '\0';
    return *this;
}


/*****************************************************************************
  QCString stream functions
 *****************************************************************************/
#ifndef QT_NO_DATASTREAM

QDataStream &operator<<( QDataStream &s, const QCString &str )
{
    return s.writeBytes( str.data(), str.size() );
}

QDataStream &operator>>( QDataStream &s, QCString &str )
{
    str.detach();
    Q_UINT32 len;
    s >> len;                                   // read size of string
    if ( len == 0 || s.eof() ) {                // end of file reached
        str.resize( 0 );
        return s;
    }
    if ( !str.QByteArray::resize( (uint)len )) {// resize string
#if defined(QT_CHECK_NULL)
        qWarning( "QDataStream: Not enough memory to read QCString" );
#endif
        len = 0;
    }
    if ( len > 0 )                              // not null array
        s.readRawBytes( str.data(), (uint)len );
    return s;
}
#endif //QT_NO_DATASTREAM

/*****************************************************************************
  Documentation for related functions
 *****************************************************************************/

---