1 files changed, 290 insertions, 144 deletions

diff --git a/qmake/tools/qstring.cpp b/qmake/tools/qstring.cpp
index 56df62b..7f1fac3 100644
--- a/qmake/tools/qstring.cpp
+++ b/qmake/tools/qstring.cpp
@@ -7,3 +7,3 @@
 **
-** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
+** Copyright (C) 1992-2002 Trolltech AS.  All rights reserved.
 **
@@ -49,3 +49,2 @@
 #endif
-#include <ctype.h>
 #include <limits.h>
@@ -54,2 +53,3 @@
 #include <stdlib.h>
+#include <string.h>
 #if defined(Q_WS_WIN)
@@ -61,2 +61,6 @@
 
+#ifdef QT_NO_UNICODETABLES
+# include <ctype.h>
+#endif
+
 
@@ -11789,2 +11793,3 @@ static inline QChar::Direction direction( const QChar &c )
 #else
+    Q_UNUSED(c);
     return QChar::DirL;
@@ -11801,2 +11806,3 @@ static inline bool mirrored( const QChar &c )
 #else
+    Q_UNUSED(c);
     return FALSE;
@@ -11902,3 +11908,3 @@ static uint computeNewMax( uint len )
         newMax *= 2;
-    // try to spare some memory
+    // try to save some memory
     if ( newMax >= 1024 * 1024 && len <= newMax - (newMax >> 2) )
@@ -12893,3 +12899,3 @@ void QString::compose()
 
-QChar* QString::asciiToUnicode( const QByteArray& ba, uint* len )
+QChar* QString::latin1ToUnicode( const QByteArray& ba, uint* len )
 {
@@ -12912,3 +12918,3 @@ QChar* QString::asciiToUnicode( const QByteArray& ba, uint* len )
 
-static QChar* internalAsciiToUnicode( const QByteArray& ba, uint* len )
+static QChar* internalLatin1ToUnicode( const QByteArray& ba, uint* len )
 {
@@ -12942,3 +12948,3 @@ static QChar* internalAsciiToUnicode( const QByteArray& ba, uint* len )
 
-QChar* QString::asciiToUnicode( const char *str, uint* len, uint maxlen )
+QChar* QString::latin1ToUnicode( const char *str, uint* len, uint maxlen )
 {
@@ -12952,3 +12958,3 @@ QChar* QString::asciiToUnicode( const char *str, uint* len, uint maxlen )
             // Faster?
-            l = qstrlen(str);
+            l = strlen( str );
         }
@@ -12965,3 +12971,3 @@ QChar* QString::asciiToUnicode( const char *str, uint* len, uint maxlen )
 
-static QChar* internalAsciiToUnicode( const char *str, uint* len,
+static QChar* internalLatin1ToUnicode( const char *str, uint* len,
                                       uint maxlen = (uint)-1 )
@@ -12976,3 +12982,3 @@ static QChar* internalAsciiToUnicode( const char *str, uint* len,
             // Faster?
-            l = qstrlen(str);
+            l = strlen( str );
         }
@@ -12996,3 +13002,3 @@ static QChar* internalAsciiToUnicode( const char *str, uint* len,
 */
-char* QString::unicodeToAscii(const QChar *uc, uint l)
+char* QString::unicodeToLatin1(const QChar *uc, uint l)
 {
@@ -13159,31 +13165,2 @@ QStringData* QString::makeSharedNull()
 
-// Uncomment this to get some useful statistics.
-// #define Q2HELPER(x) x
-
-#ifdef Q2HELPER
-static int stat_construct_charstar=0;
-static int stat_construct_charstar_size=0;
-static int stat_construct_null=0;
-static int stat_construct_int=0;
-static int stat_construct_int_size=0;
-static int stat_construct_ba=0;
-static int stat_get_ascii=0;
-static int stat_get_ascii_size=0;
-static int stat_copy_on_write=0;
-static int stat_copy_on_write_size=0;
-static int stat_fast_copy=0;
-Q_EXPORT void qt_qstring_stats()
-{
-        qDebug("construct_charstar = %d (%d chars)", stat_construct_charstar, stat_construct_charstar_size);
-        qDebug("construct_null = %d", stat_construct_null);
-        qDebug("construct_int = %d (%d chars)", stat_construct_int, stat_construct_int_size);
-        qDebug("construct_ba = %d", stat_construct_ba);
-        qDebug("get_ascii = %d (%d chars)", stat_get_ascii, stat_get_ascii_size);
-        qDebug("copy_on_write = %d (%d chars)", stat_copy_on_write, stat_copy_on_write_size);
-        qDebug("fast_copy = %d", stat_fast_copy);
-}
-#else
-#define Q2HELPER(x)
-#endif
-
 /*!
@@ -13213,3 +13190,2 @@ QString::QString( const QString &s ) :
 {
-    Q2HELPER(stat_fast_copy++)
     d->ref();
@@ -13232,5 +13208,3 @@ QString::QString( int size, bool /*dummy*/ )
     if ( size ) {
-        Q2HELPER(stat_construct_int++)
         int l = size;
-        Q2HELPER(stat_construct_int_size+=l)
         QChar* uc = QT_ALLOC_QCHAR_VEC( l );
@@ -13238,3 +13212,2 @@ QString::QString( int size, bool /*dummy*/ )
     } else {
-        Q2HELPER(stat_construct_null++)
         d = shared_null ? shared_null : (shared_null=new QStringData);
@@ -13251,5 +13224,11 @@ QString::QString( const QByteArray& ba )
 {
-    Q2HELPER(stat_construct_ba++)
+#ifndef QT_NO_TEXTCODEC
+    if ( QTextCodec::codecForCStrings() ) {
+        d = 0;
+        *this = fromAscii( ba.data(), ba.size() );
+        return;
+    }
+#endif
     uint l;
-    QChar *uc = internalAsciiToUnicode(ba,&l);
+    QChar *uc = internalLatin1ToUnicode(ba,&l);
     d = new QStringData(uc,l,l);
@@ -13304,8 +13283,35 @@ QString::QString( const char *str )
 {
-    Q2HELPER(stat_construct_charstar++)
+#ifndef QT_NO_TEXTCODEC
+    if ( QTextCodec::codecForCStrings() ) {
+        d = 0;
+        *this = fromAscii( str );
+        return;
+    }
+#endif
+    uint l;
+    QChar *uc = internalLatin1ToUnicode(str,&l);
+    d = new QStringData(uc,l,l);
+}
+
+#ifndef QT_NO_STL
+/*!
+    Constructs a string that is a deep copy of \a str.
+
+    This is the same as fromAscii(\a str).
+*/
+
+QString::QString( const std::string &str )
+{
+#ifndef QT_NO_TEXTCODEC
+    if ( QTextCodec::codecForCStrings() ) {
+        d = 0;
+        *this = fromAscii( str.c_str() );
+        return;
+    }
+#endif
     uint l;
-    QChar *uc = internalAsciiToUnicode(str,&l);
-    Q2HELPER(stat_construct_charstar_size+=l)
+    QChar *uc = internalLatin1ToUnicode(str.c_str(),&l);
     d = new QStringData(uc,l,l);
 }
+#endif
 
@@ -13335,6 +13341,6 @@ void QString::deref()
 {
-    if ( d->deref() ) {
+    if ( d && d->deref() ) {
         if ( d != shared_null )
             delete d;
-        d = 0; // helps debugging
+        d = 0;
     }
@@ -13354,2 +13360,11 @@ void QStringData::deleteSelf()
 /*!
+    \fn QString& QString::operator=( const std::string& s )
+
+    \overload
+
+    Makes a deep copy of \a s and returns a reference to the deep
+    copy.
+*/
+
+/*!
     \fn QString& QString::operator=( char c )
@@ -13370,3 +13385,2 @@ QString &QString::operator=( const QString &s )
 {
-    Q2HELPER(stat_fast_copy++)
     s.d->ref();
@@ -13385,3 +13399,3 @@ QString &QString::operator=( const QCString& cs )
 {
-    return setLatin1(cs);
+    return setAscii(cs);
 }
@@ -13401,3 +13415,3 @@ QString &QString::operator=( const char *str )
 {
-    return setLatin1(str);
+    return setAscii(str);
 }
@@ -13473,4 +13487,3 @@ void QString::truncate( uint newLen )
 
-    If \a newLen is 0, then the string becomes empty, unless the
-    string is null, in which case it remains null.
+    If \a newLen is 0, then the string becomes empty (non-null).
 
@@ -13488,8 +13501,8 @@ void QString::truncate( uint newLen )
         QString result;
-        int resultLength = 0;
-        result.setLength( newLen ) // allocate some space
+        int len = 0;
+        result.setLength( maxLen );     // allocate some space
         while ( ... ) {
-            result[resultLength++] = ... // fill (part of) the space with data
+            result[len++] = ...         // fill part of the space
         }
-        result.truncate[resultLength]; // and get rid of the undefined junk
+        result.truncate( len );         // and get rid of the rest
     \endcode
@@ -13507,4 +13520,2 @@ void QString::setLength( uint newLen )
         // detach, grow or shrink
-        Q2HELPER(stat_copy_on_write++)
-        Q2HELPER(stat_copy_on_write_size+=d->len)
         uint newMax = computeNewMax( newLen );
@@ -13532,17 +13543,16 @@ void QString::setLength( uint newLen )
 
+    The following example shows how we could create a 'status' string
+    when processing a list of files:
     \code
-        QString firstName( "Joe" );
-        QString lastName( "Bloggs" );
-        QString fullName;
-        fullName = QString( "First name is '%1', last name is '%2'" )
-                    .arg( firstName )
-                    .arg( lastName );
-
-        // fullName == First name is 'Joe', last name is 'Bloggs'
+    QString status = QString( "Processing file %1 of %2: %3" )
+                        .arg( i )         // current file's number
+                        .arg( total )     // number of files to process
+                        .arg( fileName ); // current file's name
     \endcode
 
-    Note that using arg() to construct sentences as we've done in the
-    example above does not usually translate well into other languages
-    because sentence structure and word order often differ between
-    languages.
+    It is generally fine to use filenames and numbers as we have done
+    in the example above. But note that using arg() to construct
+    natural language sentences does not usually translate well into
+    other languages because sentence structure and word order often
+    differ between languages.
 
@@ -13776,3 +13786,3 @@ QString &QString::sprintf( const char* cformat, ... )
     }
-    QString format = fromLatin1( cformat );
+    QString format = fromAscii( cformat );
 
@@ -13915,3 +13925,3 @@ QString &QString::sprintf( const char* cformat, ... )
             }
-            replacement = fromLatin1( out );
+            replacement = fromAscii( out );
         }
@@ -14126,4 +14136,6 @@ int QString::find( const QString& str, int index, bool cs ) const
 
+#ifndef MACOSX_101
     if ( sl == 1 )
         return find( *str.unicode(), index, cs );
+#endif
 
@@ -14223,2 +14235,5 @@ int QString::findRev( QChar c, int index, bool cs ) const
 {
+#ifdef MACOSX_101
+    return findRev( QString( c ), index, cs );
+#else
     const uint l = length();
@@ -14239,2 +14254,3 @@ int QString::findRev( QChar c, int index, bool cs ) const
     return uc - end;
+#endif
 }
@@ -14275,4 +14291,6 @@ int QString::findRev( const QString& str, int index, bool cs ) const
 
+#ifndef MACOSX_101
     if ( sl == 1 )
         return findRev( *str.unicode(), index, cs );
+#endif
 
@@ -14981,15 +14999,20 @@ QString QString::lower() const
 {
-    QString s(*this);
-    int l=length();
-    if ( l ) {
-        s.real_detach(); // could do this only when we find a change
-        register QChar *p=s.d->unicode;
-        if ( p ) {
-            while ( l-- ) {
+    int l = length();
+    register QChar *p = d->unicode;
+    while ( l ) {
+        if ( *p != ::lower(*p) ) {
+            QString s( *this );
+            s.real_detach();
+            p = s.d->unicode + ( p - d->unicode );
+            while ( l ) {
                 *p = ::lower( *p );
+                l--;
                 p++;
             }
+            return s;
         }
+        l--;
+        p++;
     }
-    return s;
+    return *this;
 }
@@ -15009,15 +15032,20 @@ QString QString::upper() const
 {
-    QString s(*this);
-    int l=length();
-    if ( l ) {
-        s.real_detach(); // could do this only when we find a change
-        register QChar *p=s.d->unicode;
-        if ( p ) {
-            while ( l-- ) {
+    int l = length();
+    register QChar *p = d->unicode;
+    while ( l ) {
+        if ( *p != ::upper(*p) ) {
+            QString s( *this );
+            s.real_detach();
+            p = s.d->unicode + ( p - d->unicode );
+            while ( l ) {
                 *p = ::upper( *p );
+                l--;
                 p++;
             }
+            return s;
         }
+        l--;
+        p++;
     }
-    return s;
+    return *this;
 }
@@ -15139,4 +15167,4 @@ QString &QString::insert( uint index, const QString &s )
 
-    Inserts the character in \a s into the string at position \a index
-    \a len number of times and returns a reference to the string.
+    Inserts the first \a len characters in \a s into the string at
+    position \a index and returns a reference to the string.
 */
@@ -15253,2 +15281,12 @@ QString &QString::insert( uint index, QChar c ) // insert char
 
+/*! \fn QString& QString::prepend( const std::string &s )
+  \overload
+
+  Inserts \a s at the beginning of the string and returns a reference to the string.
+
+  Equivalent to insert(0, \a s).
+
+  \sa insert()
+ */
+
 /*!
@@ -15850,5 +15888,5 @@ long QString::toLong( bool *ok, int base ) const
     const QChar *p = unicode();
-    long val = 0;
+    ulong val = 0;
     int l = length();
-    const long max_mult = INT_MAX / base;
+    const ulong max_mult = LONG_MAX / base;
     bool is_ok = FALSE;
@@ -15885,3 +15923,3 @@ long QString::toLong( bool *ok, int base ) const
         if ( val > max_mult ||
-            (val == max_mult && dv > (INT_MAX % base) + neg) )
+            (val == max_mult && dv > (LONG_MAX % base) + neg) )
             goto bye;
@@ -15890,6 +15928,4 @@ long QString::toLong( bool *ok, int base ) const
     }
-    if ( neg )
-        val = -val;
     while ( l && p->isSpace() )                 // skip trailing space
-        l--,p++;
+        l--, p++;
     if ( !l )
@@ -15899,3 +15935,3 @@ bye:
         *ok = is_ok;
-    return is_ok ? val : 0;
+    return is_ok ? ( neg ? -( (long) val ) : (long) val ) : 0L;
 }
@@ -15917,3 +15953,3 @@ ulong QString::toULong( bool *ok, int base ) const
     int l = length();
-    const ulong max_mult = UINT_MAX / base;
+    const ulong max_mult = ULONG_MAX / base;
     bool is_ok = FALSE;
@@ -15942,3 +15978,3 @@ ulong QString::toULong( bool *ok, int base ) const
         }
-        if ( val > max_mult || (val == max_mult && dv > UINT_MAX % base) )
+        if ( val > max_mult || (val == max_mult && dv > ULONG_MAX % base) )
             goto bye;
@@ -15969,3 +16005,3 @@ short QString::toShort( bool *ok, int base ) const
     long v = toLong( ok, base );
-    if ( ok && *ok && (v < -32768 || v > 32767) ) {
+    if ( ok && *ok && (v < SHRT_MIN || v > SHRT_MAX) ) {
         *ok = FALSE;
@@ -15988,3 +16024,3 @@ ushort QString::toUShort( bool *ok, int base ) const
     ulong v = toULong( ok, base );
-    if ( ok && *ok && (v > 65535) ) {
+    if ( ok && *ok && (v > USHRT_MAX) ) {
         *ok = FALSE;
@@ -16015,3 +16051,8 @@ int QString::toInt( bool *ok, int base ) const
 {
-    return (int)toLong( ok, base );
+    long v = toLong( ok, base );
+    if ( ok && *ok && (v < INT_MIN || v > INT_MAX) ) {
+        *ok = FALSE;
+        v = 0;
+    }
+    return (int)v;
 }
@@ -16030,3 +16071,8 @@ uint QString::toUInt( bool *ok, int base ) const
 {
-    return (uint)toULong( ok, base );
+    ulong v = toULong( ok, base );
+    if ( ok && *ok && (v > UINT_MAX) ) {
+        *ok = FALSE;
+        v = 0;
+    }
+    return (uint)v;
 }
@@ -16054,3 +16100,3 @@ double QString::toDouble( bool *ok ) const
     if ( ok )
-        *ok = ( a && *a && (end == 0 || (end - a) == (int)length()) );
+        *ok = ( a && *a && (end == 0 || *end == '\0') );
     return val;
@@ -16100,7 +16146,7 @@ QString &QString::setNum( long n, int base )
         neg = TRUE;
-        if ( n == INT_MIN ) {
+        if ( n == LONG_MIN ) {
             // Cannot always negate this special case
             QString s1, s2;
-            s1.setNum(n/base);
-            s2.setNum((-(n+base))%base);
+            s1.setNum(n/base, base );
+            s2.setNum((-(n+base))%base, base );
             *this = s1 + s2;
@@ -16463,2 +16509,11 @@ void QString::setExpand( uint index, QChar c )
 
+/*! \fn QString& QString::append( const std::string &str )
+  \overload
+
+  Appends \a str to the string and returns a reference to the result.
+
+  Equivalent to operator+=().
+ */
+
+
 /*! \fn QString& QString::append( const char *str )
@@ -16492,2 +16547,3 @@ QString& QString::operator+=( const QString &str )
 */
+#ifndef QT_NO_CAST_ASCII
 QString& QString::operator+=( const char *str )
@@ -16495,2 +16551,7 @@ QString& QString::operator+=( const char *str )
     if ( str ) {
+#ifndef QT_NO_TEXTCODEC
+        if ( QTextCodec::codecForCStrings() )
+            return operator+=( fromAscii( str ) );
+#endif
+
         uint len1 = length();
@@ -16510,2 +16571,3 @@ QString& QString::operator+=( const char *str )
 }
+#endif
 
@@ -16531,2 +16593,6 @@ QString &QString::operator+=( char c )
 {
+#ifndef QT_NO_TEXTCODEC
+    if ( QTextCodec::codecForCStrings() )
+        return operator+=( fromAscii( &c, 1 ) );
+#endif
     setLength(length()+1);
@@ -16543,2 +16609,9 @@ QString &QString::operator+=( char c )
 
+/*!
+  \fn QString &QString::operator+=( const std::string &str )
+  \overload
+
+  Appends \a str to the string and returns a reference to the string.
+*/
+
 
@@ -16548,4 +16621,4 @@ QString &QString::operator+=( char c )
 
-    Returns a latin-1 copy of this character, if this character is in
-    the latin-1 character set. If not, this function returns 0.
+    Returns the Latin-1 value of this character, or 0 if it
+    cannot be represented in Latin-1.
 */
@@ -16554,3 +16627,3 @@ QString &QString::operator+=( char c )
 /*!
-    Returns a Latin-1 representation of the string. Note that the
+    Returns a Latin-1 representation of the string. The
     returned value is undefined if the string contains non-Latin-1
@@ -16565,3 +16638,3 @@ QString &QString::operator+=( char c )
 
-    \sa utf8(), local8Bit()
+    \sa fromLatin1(), ascii(), utf8(), local8Bit()
 */
@@ -16569,6 +16642,5 @@ const char* QString::latin1() const
 {
-    if ( !d->ascii ) {
-        Q2HELPER(stat_get_ascii++)
-        Q2HELPER(stat_get_ascii_size+=d->len)
-        d->ascii = unicodeToAscii( d->unicode, d->len );
+    if ( !d->ascii  || !d->islatin1 ) {
+        d->ascii = unicodeToLatin1( d->unicode, d->len );
+        d->islatin1 = TRUE;
     }
@@ -16578,10 +16650,29 @@ const char* QString::latin1() const
 /*!
-  \fn const char* QString::ascii() const
-  \obsolete
+    Returns an 8-bit ASCII representation of the string.
 
-  This function simply calls latin1() and returns the result.
+    If a codec has been set using QTextCodec::codecForCStrings(),
+    it is used to convert Unicode to 8-bit char. Otherwise, this function
+    does the same as latin1().
+
+    \sa fromAscii(), latin1(), utf8(), local8Bit()
 */
+const char* QString::ascii() const
+{
+#ifndef QT_NO_TEXTCODEC
+    if ( QTextCodec::codecForCStrings() ) {
+        if ( !d->ascii || d->islatin1 ) {
+            QCString s = QTextCodec::codecForCStrings()->fromUnicode( *this );
+            s.detach();
+            d->ascii = s.data();
+            d->islatin1 = FALSE;
+            s.resetRawData( s.data(), s.size() ); // we have stolen the data
+        }
+        return d->ascii;
+    }
+#endif // QT_NO_TEXTCODEC
+    return latin1();
+}
 
 /*!
-    Returns the string encoded in UTF8 format.
+    Returns the string encoded in UTF-8 format.
 
@@ -16589,3 +16680,3 @@ const char* QString::latin1() const
 
-    \sa QString::fromUtf8(), local8Bit(), latin1()
+    \sa fromUtf8(), ascii(), latin1(), local8Bit()
 */
@@ -16635,3 +16726,4 @@ QString QString::fromUtf8( const char* utf8, int len )
 
-    if ( len < 0 ) len = qstrlen( utf8 );
+    if ( len < 0 )
+        len = strlen( utf8 );
     QString result;
@@ -16676,6 +16768,10 @@ QString QString::fromUtf8( const char* utf8, int len )
     Returns the Unicode string decoded from the first \a len
-    characters of \a chars, ignoring the rest of \a chars. If \a len
-    is -1 then the length of \a chars is used. If \a len is bigger
-    than the length of \a chars then it will use the length of \a
-    chars.
+    characters of \a ascii, ignoring the rest of \a ascii. If \a len
+    is -1 then the length of \a ascii is used. If \a len is bigger
+    than the length of \a ascii then it will use the length of \a
+    ascii.
+
+    If a codec has been set using QTextCodec::codecForCStrings(),
+    it is used to convert Unicode to 8-bit char. Otherwise, this function
+    does the same as fromLatin1().
 
@@ -16684,8 +16780,34 @@ QString QString::fromUtf8( const char* utf8, int len )
     \c QT_NO_CAST_ASCII, in which case you can explicitly create a
-    QString from Latin-1 text using this function.
+    QString from 8-bit ASCII text using this function.
 
     \code
-        QString str = QString::fromLatin1( "123456789", 5 );
+        QString str = QString::fromAscii( "123456789", 5 );
         // str == "12345"
     \endcode
+ */
+QString QString::fromAscii( const char* ascii, int len )
+{
+#ifndef QT_NO_TEXTCODEC
+    if ( QTextCodec::codecForCStrings() ) {
+        if ( !ascii )
+            return QString::null;
+        if ( len < 0 )
+            len = strlen( ascii );
+        if ( len == 0 || *ascii == '\0' )
+            return QString::fromLatin1( "" );
+        return QTextCodec::codecForCStrings()->toUnicode( ascii, len );
+    }
+#endif
+    return fromLatin1( ascii, len );
+}
+
+
+/*!
+    Returns the Unicode string decoded from the first \a len
+    characters of \a chars, ignoring the rest of \a chars. If \a len
+    is -1 then the length of \a chars is used. If \a len is bigger
+    than the length of \a chars then it will use the length of \a
+    chars.
+
+    \sa fromAscii()
 */
@@ -16697,3 +16819,3 @@ QString QString::fromLatin1( const char* chars, int len )
          len = -1;
-    uc = internalAsciiToUnicode( chars, &l, len );
+    uc = internalLatin1ToUnicode( chars, &l, len );
     return QString( new QStringData(uc, l, l), TRUE );
@@ -16711,4 +16833,4 @@ QString QString::fromLatin1( const char* chars, int len )
     this is the QTextCodec::codecForLocale(). On Windows, it is a
-    system-defined encoding. On Mac OS X, this always uses utf8 as the
-    encoding.
+    system-defined encoding. On Mac OS X, this always uses UTF-8 as
+    the encoding.
 
@@ -16717,6 +16839,5 @@ QString QString::fromLatin1( const char* chars, int len )
 
-    \sa QString::fromLocal8Bit(), latin1(), utf8()
+    \sa fromLocal8Bit(), ascii(), latin1(), utf8()
 */
 
-
 QCString QString::local8Bit() const
@@ -16742,3 +16863,3 @@ QCString QString::local8Bit() const
 #ifdef Q_WS_QWS
-    return utf8(); // ##### if there is ANY 8 bit format supported?
+    return utf8(); // ### if there is any 8 bit format supported?
 #endif
@@ -16773,3 +16894,4 @@ QString QString::fromLocal8Bit( const char* local8Bit, int len )
     QTextCodec* codec = QTextCodec::codecForLocale();
-    if ( len < 0 ) len = qstrlen(local8Bit);
+    if ( len < 0 )
+        len = strlen( local8Bit );
     return codec
@@ -16806,2 +16928,8 @@ QString QString::fromLocal8Bit( const char* local8Bit, int len )
 
+/*!
+    \fn QString::operator std::string() const
+
+    Returns ascii().
+*/
+
 
@@ -16821,4 +16949,2 @@ const unsigned short *QString::ucs2() const
         // detach, grow or shrink
-        Q2HELPER(stat_copy_on_write++)
-        Q2HELPER(stat_copy_on_write_size += len)
         uint newMax = computeNewMax( len + 1 );
@@ -16985,4 +17111,2 @@ QString& QString::setUnicode( const QChar *unicode, uint len )
         // detach, grown or shrink
-        Q2HELPER(stat_copy_on_write++)
-        Q2HELPER(stat_copy_on_write_size+=d->len)
         uint newMax = computeNewMax( len );
@@ -17020,2 +17144,24 @@ QString& QString::setUnicodeCodes( const ushort* unicode_as_ushorts, uint len )
 /*!
+    Sets this string to \a str, interpreted as a classic 8-bit ASCII C
+    string. If \a len is -1 (the default), then it is set to
+    strlen(str).
+
+    If \a str is 0 a null string is created. If \a str is "", an empty
+    string is created.
+
+    \sa isNull(), isEmpty()
+*/
+
+QString &QString::setAscii( const char *str, int len )
+{
+#ifndef QT_NO_TEXTCODEC
+    if ( QTextCodec::codecForCStrings() ) {
+        *this = QString::fromAscii( str, len );
+        return *this;
+    }
+#endif // QT_NO_TEXTCODEC
+    return setLatin1( str, len );
+}
+
+/*!
     Sets this string to \a str, interpreted as a classic Latin1 C
@@ -17035,3 +17181,3 @@ QString &QString::setLatin1( const char *str, int len )
     if ( len < 0 )
-        len = qstrlen(str);
+        len = strlen( str );
     if ( len == 0 ) {                           // won't make a null string
@@ -17053,3 +17199,2 @@ void QString::checkSimpleText() const
     QChar *end = p + d->len;
-    d->simpletext = 1;
     while( p < end ) {
@@ -17058,3 +17203,3 @@ void QString::checkSimpleText() const
         if ( uc > 0x058f && ( uc < 0x1100 || uc > 0xfb0f ) ) {
-            d->simpletext = 0;
+            d->issimpletext = FALSE;
             return;
@@ -17063,2 +17208,3 @@ void QString::checkSimpleText() const
     }
+    d->issimpletext = TRUE;
 }