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
@@ -1,85 +1,89 @@
 /****************************************************************************
 ** $Id$
 **
 ** Implementation of the QString class and related Unicode functions
 **
 ** Created : 920722
 **
-** Copyright (C) 1992-2000 Trolltech AS.  All rights reserved.
+** Copyright (C) 1992-2002 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.
 **
 **********************************************************************/
 
 // Don't define it while compiling this module, or USERS of Qt will
 // not be able to link.
 #ifdef QT_NO_CAST_ASCII
 #undef QT_NO_CAST_ASCII
 #endif
 
 #include "qstring.h"
 #include "qregexp.h"
 #include "qdatastream.h"
 #ifndef QT_NO_TEXTCODEC
 #include "qtextcodec.h"
 #endif
-#include <ctype.h>
 #include <limits.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #if defined(Q_WS_WIN)
 #include "qt_windows.h"
 #endif
 #if !defined( QT_NO_COMPONENT ) && !defined( QT_LITE_COMPONENT )
 #include "qcleanuphandler.h"
 #endif
 
+#ifdef QT_NO_UNICODETABLES
+# include <ctype.h>
+#endif
+
 
 /* -------------------------------------------------------------------------
  * unicode information
  * these tables are generated from the unicode reference file
  * ftp://ftp.unicode.org/Public/3.2-Update/UnicodeData.txt
  *
  * Lars
  * -------------------------------------------------------------------------
  */
 
 /* Perl script to generate (run perl -x tools/qstring.cpp)
 
 #!perl
 
 sub numberize
 {
     my(%r, $n, $id);
     for $id ( @_ ) {
       $i = $id;
         $i="" if $i eq "EMPTY";
         $r{$i}=$n++;
     }
     return %r;
 }
@@ -11766,60 +11770,62 @@ static inline QChar upper( const QChar &c )
 #ifndef QT_NO_UNICODETABLES
     uchar row = c.row();
     uchar cell = c.cell();
     if ( unicode_info[row][cell] != QChar::Letter_Lowercase )
         return c;
     Q_UINT16 upper = *(case_info[row]+cell);
     if ( upper == 0 )
         return c;
     return upper;
 #else
     if ( c.row() )
         return c;
     else
         return QChar( toupper((uchar) c.latin1()) );
 #endif
 }
 
 static inline QChar::Direction direction( const QChar &c )
 {
 #ifndef QT_NO_UNICODETABLES
     const Q_UINT8 *rowp = direction_info[c.row()];
     if(!rowp) return QChar::DirL;
     return (QChar::Direction) ( *(rowp+c.cell()) & 0x1f );
 #else
+    Q_UNUSED(c);
     return QChar::DirL;
 #endif
 }
 
 static inline bool mirrored( const QChar &c )
 {
 #ifndef QT_NO_UNICODETABLES
     const Q_UINT8 *rowp = direction_info[c.row()];
     if ( !rowp )
         return FALSE;
     return *(rowp+c.cell())>128;
 #else
+    Q_UNUSED(c);
     return FALSE;
 #endif
 }
 
 #ifndef QT_NO_UNICODETABLES
 static const Q_UINT16 symmetricPairs[] = {
     0x0028, 0x0029, 0x003C, 0x003E, 0x005B, 0x005D, 0x007B, 0x007D,
     0x00AB, 0x00BB, 0x2039, 0x203A, 0x2045, 0x2046, 0x207D, 0x207E,
     0x208D, 0x208E, 0x2208, 0x220B, 0x2209, 0x220C, 0x220A, 0x220D,
     0x2215, 0x29F5, 0x223C, 0x223D, 0x2243, 0x22CD, 0x2252, 0x2253,
     0x2254, 0x2255, 0x2264, 0x2265, 0x2266, 0x2267, 0x2268, 0x2269,
     0x226A, 0x226B, 0x226E, 0x226F, 0x2270, 0x2271, 0x2272, 0x2273,
     0x2274, 0x2275, 0x2276, 0x2277, 0x2278, 0x2279, 0x227A, 0x227B,
     0x227C, 0x227D, 0x227E, 0x227F, 0x2280, 0x2281, 0x2282, 0x2283,
     0x2284, 0x2285, 0x2286, 0x2287, 0x2288, 0x2289, 0x228A, 0x228B,
     0x228F, 0x2290, 0x2291, 0x2292, 0x2298, 0x29B8, 0x22A2, 0x22A3,
     0x22A6, 0x2ADE, 0x22A8, 0x2AE4, 0x22A9, 0x2AE3, 0x22AB, 0x2AE5,
     0x22B0, 0x22B1, 0x22B2, 0x22B3, 0x22B4, 0x22B5, 0x22B6, 0x22B7,
     0x22C9, 0x22CA, 0x22CB, 0x22CC, 0x22D0, 0x22D1, 0x22D6, 0x22D7,
     0x22D8, 0x22D9, 0x22DA, 0x22DB, 0x22DC, 0x22DD, 0x22DE, 0x22DF,
     0x22E0, 0x22E1, 0x22E2, 0x22E3, 0x22E4, 0x22E5, 0x22E6, 0x22E7,
     0x22E8, 0x22E9, 0x22EA, 0x22EB, 0x22EC, 0x22ED, 0x22F0, 0x22F1,
     0x22F2, 0x22FA, 0x22F3, 0x22FB, 0x22F4, 0x22FC, 0x22F6, 0x22FD,
     0x22F7, 0x22FE, 0x2308, 0x2309, 0x230A, 0x230B, 0x2329, 0x232A,
@@ -11879,49 +11885,49 @@ static int ucstrcmp( const QString &as, const QString &bs )
 
 static int ucstrncmp( const QChar *a, const QChar *b, int l )
 {
     while ( l-- && *a == *b )
         a++,b++;
     if ( l==-1 )
         return 0;
     return a->unicode() - b->unicode();
 }
 
 static int ucstrnicmp( const QChar *a, const QChar *b, int l )
 {
     while ( l-- && ::lower( *a ) == ::lower( *b ) )
         a++,b++;
     if ( l==-1 )
         return 0;
     return ::lower( *a ).unicode() - ::lower( *b ).unicode();
 }
 
 static uint computeNewMax( uint len )
 {
     uint newMax = 4;
     while ( newMax < len )
         newMax *= 2;
-    // try to spare some memory
+    // try to save some memory
     if ( newMax >= 1024 * 1024 && len <= newMax - (newMax >> 2) )
         newMax -= newMax >> 2;
     return newMax;
 }
 
 /*!
     \class QCharRef qstring.h
     \reentrant
     \brief The QCharRef class is a helper class for QString.
 
     \ingroup text
 
     When you get an object of type QCharRef, if you can assign to it,
     the assignment will apply to the character in the string from
     which you got the reference. That is its whole purpose in life.
     The QCharRef becomes invalid once modifications are made to the
     string: if you want to keep the character, copy it into a QChar.
 
     Most of the QChar member functions also exist in QCharRef.
     However, they are not explicitly documented here.
 
     \sa QString::operator[]() QString::at() QChar
 */
 
@@ -12870,152 +12876,152 @@ void QString::compose()
         cindex++;
         index++;
     }
     *this = composed;
 #endif
 }
 
 
 // These macros are used for efficient allocation of QChar strings.
 // IMPORTANT! If you change these, make sure you also change the
 // "delete unicode" statement in ~QStringData() in qstring.h correspondingly!
 
 #define QT_ALLOC_QCHAR_VEC( N ) (QChar*) new char[ sizeof(QChar)*( N ) ]
 #define QT_DELETE_QCHAR_VEC( P ) delete[] ((char*)( P ))
 
 
 /*!
     This utility function converts the 8-bit string \a ba to Unicode,
     returning the result.
 
     The caller is responsible for deleting the return value with
     delete[].
 */
 
-QChar* QString::asciiToUnicode( const QByteArray& ba, uint* len )
+QChar* QString::latin1ToUnicode( const QByteArray& ba, uint* len )
 {
     if ( ba.isNull() ) {
         *len = 0;
         return 0;
     }
     int l = 0;
     while ( l < (int)ba.size() && ba[l] )
         l++;
     char* str = ba.data();
     QChar *uc = new QChar[ l ];   // Can't use macro, since function is public
     QChar *result = uc;
     if ( len )
         *len = l;
     while (l--)
         *uc++ = *str++;
     return result;
 }
 
-static QChar* internalAsciiToUnicode( const QByteArray& ba, uint* len )
+static QChar* internalLatin1ToUnicode( const QByteArray& ba, uint* len )
 {
     if ( ba.isNull() ) {
         *len = 0;
         return 0;
     }
     int l = 0;
     while ( l < (int)ba.size() && ba[l] )
         l++;
     char* str = ba.data();
     QChar *uc = QT_ALLOC_QCHAR_VEC( l );
     QChar *result = uc;
     if ( len )
         *len = l;
     while (l--)
         *uc++ = *str++;
     return result;
 }
 
 /*!
     \overload
 
     This utility function converts the '\0'-terminated 8-bit string \a
     str to Unicode, returning the result and setting \a *len to the
     length of the Unicode string.
 
     The caller is responsible for deleting the return value with
     delete[].
 */
 
-QChar* QString::asciiToUnicode( const char *str, uint* len, uint maxlen )
+QChar* QString::latin1ToUnicode( const char *str, uint* len, uint maxlen )
 {
     QChar* result = 0;
     uint l = 0;
     if ( str ) {
         if ( maxlen != (uint)-1 ) {
             while ( l < maxlen && str[l] )
                 l++;
         } else {
             // Faster?
-            l = qstrlen(str);
+            l = strlen( str );
         }
         QChar *uc = new QChar[ l ]; // Can't use macro since function is public
         result = uc;
         uint i = l;
         while ( i-- )
             *uc++ = *str++;
     }
     if ( len )
         *len = l;
     return result;
 }
 
-static QChar* internalAsciiToUnicode( const char *str, uint* len,
+static QChar* internalLatin1ToUnicode( const char *str, uint* len,
                                       uint maxlen = (uint)-1 )
 {
     QChar* result = 0;
     uint l = 0;
     if ( str ) {
         if ( maxlen != (uint)-1 ) {
             while ( l < maxlen && str[l] )
                 l++;
         } else {
             // Faster?
-            l = qstrlen(str);
+            l = strlen( str );
         }
         QChar *uc = QT_ALLOC_QCHAR_VEC( l );
         result = uc;
         uint i = l;
         while ( i-- )
             *uc++ = *str++;
     }
     if ( len )
         *len = l;
     return result;
 }
 
 /*!
     This utility function converts \a l 16-bit characters from \a uc
     to ASCII, returning a '\0'-terminated string.
 
     The caller is responsible for deleting the resultant string with
     delete[].
 */
-char* QString::unicodeToAscii(const QChar *uc, uint l)
+char* QString::unicodeToLatin1(const QChar *uc, uint l)
 {
     if (!uc) {
         return 0;
     }
     char *a = new char[l+1];
     char *result = a;
     while (l--) {
         *a++ = (uc->unicode() > 0xff) ? '?' : (char)uc->unicode();
         uc++;
     }
     *a = '\0';
     return result;
 }
 
 /*****************************************************************************
   QString member functions
  *****************************************************************************/
 
 /*!
     \class QString qstring.h
     \reentrant
 
     \brief The QString class provides an abstraction of Unicode text
     and the classic C '\0'-terminated char array.
@@ -13136,143 +13142,116 @@ char* QString::unicodeToAscii(const QChar *uc, uint l)
 
     Matching is case-insensitive unless \c CaseSensitive is set. \c
     CaseSensitive may be OR-ed with any combination of the other
     flags.
 
 */
 Q_EXPORT QStringData *QString::shared_null = 0;
 QT_STATIC_CONST_IMPL QString QString::null;
 QT_STATIC_CONST_IMPL QChar QChar::null;
 QT_STATIC_CONST_IMPL QChar QChar::replacement((ushort)0xfffd);
 QT_STATIC_CONST_IMPL QChar QChar::byteOrderMark((ushort)0xfeff);
 QT_STATIC_CONST_IMPL QChar QChar::byteOrderSwapped((ushort)0xfffe);
 QT_STATIC_CONST_IMPL QChar QChar::nbsp((ushort)0x00a0);
 
 QStringData* QString::makeSharedNull()
 {
     QString::shared_null = new QStringData;
 #if defined( Q_OS_MAC )
     QString *that = const_cast<QString *>(&QString::null);
     that->d = QString::shared_null;
 #endif
     return QString::shared_null;
 }
 
-// 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
-
 /*!
     \fn QString::QString()
 
     Constructs a null string, i.e. both the length and data pointer
     are 0.
 
     \sa isNull()
 */
 
 /*!
     Constructs a string of length one, containing the character \a ch.
 */
 QString::QString( QChar ch )
 {
     d = new QStringData( QT_ALLOC_QCHAR_VEC( 1 ), 1, 1 );
     d->unicode[0] = ch;
 }
 
 /*!
     Constructs an implicitly shared copy of \a s. This is very fast
     since it only involves incrementing a reference count.
 */
 QString::QString( const QString &s ) :
     d(s.d)
 {
-    Q2HELPER(stat_fast_copy++)
     d->ref();
 }
 
 /*!
   \internal
 
   Private function.
 
   Constructs a string with preallocated space for \a size characters.
 
   The string is empty.
 
   \sa isNull()
 */
 
 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 );
         d = new QStringData( uc, 0, l );
     } else {
-        Q2HELPER(stat_construct_null++)
         d = shared_null ? shared_null : (shared_null=new QStringData);
         d->ref();
     }
 }
 
 /*!
     Constructs a string that is a deep copy of \a ba interpreted as a
     classic C string.
 */
 
 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);
 }
 
 /*!
     Constructs a string that is a deep copy of the first \a length
     characters in the QChar array.
 
     If \a unicode and \a length are 0, then a null string is created.
 
     If only \a unicode is 0, the string is empty but has \a length
     characters of space preallocated: QString expands automatically
     anyway, but this may speed up some cases a little. We recommend
     using the plain constructor and setLength() for this purpose since
     it will result in more readable code.
 
     \sa isNull() setLength()
 */
 
 QString::QString( const QChar* unicode, uint length )
 {
     if ( !unicode && !length ) {
         d = shared_null ? shared_null : makeSharedNull();
         d->ref();
     } else {
@@ -13281,146 +13260,181 @@ QString::QString( const QChar* unicode, uint length )
             memcpy(uc, unicode, length*sizeof(QChar));
         d = new QStringData(uc,unicode ? length : 0,length);
     }
 }
 
 /*!
     Constructs a string that is a deep copy of \a str, interpreted as
     a classic C string.
 
     If \a str is 0, then a null string is created.
 
     This is a cast constructor, but it is perfectly safe: converting a
     Latin1 const char* to QString preserves all the information. You
     can disable this constructor by defining \c QT_NO_CAST_ASCII when
     you compile your applications. You can also make QString objects
     by using setLatin1(), fromLatin1(), fromLocal8Bit(), and
     fromUtf8(). Or whatever encoding is appropriate for the 8-bit data
     you have.
 
     \sa isNull()
 */
 
 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
 
 /*!
     \fn QString::~QString()
 
     Destroys the string and frees the string's data if this is the
     last reference to the string.
 */
 
 
 /*!
     Deallocates any space reserved solely by this QString.
 
     If the string does not share its data with another QString
     instance, nothing happens; otherwise the function creates a new,
     unique copy of this string. This function is called whenever the
     string is modified.
 */
 
 void QString::real_detach()
 {
     setLength( length() );
 }
 
 void QString::deref()
 {
-    if ( d->deref() ) {
+    if ( d && d->deref() ) {
         if ( d != shared_null )
             delete d;
-        d = 0; // helps debugging
+        d = 0;
     }
 }
 
 void QStringData::deleteSelf()
 {
     delete this;
 }
 
 /*!
     \fn QString& QString::operator=( QChar c )
 
     Sets the string to contain just the single character \a c.
 */
 
 /*!
+    \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 )
 
     \overload
 
     Sets the string to contain just the single character \a c.
 */
 
 /*!
     \overload
 
     Assigns a shallow copy of \a s to this string and returns a
     reference to this string. This is very fast because the string
     isn't actually copied.
 */
 QString &QString::operator=( const QString &s )
 {
-    Q2HELPER(stat_fast_copy++)
     s.d->ref();
     deref();
     d = s.d;
     return *this;
 }
 
 /*!
     \overload
 
     Assigns a deep copy of \a cs, interpreted as a classic C string,
     to this string and returns a reference to this string.
 */
 QString &QString::operator=( const QCString& cs )
 {
-    return setLatin1(cs);
+    return setAscii(cs);
 }
 
 
 /*!
     \overload
 
     Assigns a deep copy of \a str, interpreted as a classic C string
     to this string and returns a reference to this string.
 
     If \a str is 0, then a null string is created.
 
     \sa isNull()
 */
 QString &QString::operator=( const char *str )
 {
-    return setLatin1(str);
+    return setAscii(str);
 }
 
 
 /*!
     \fn bool QString::isNull() const
 
     Returns TRUE if the string is null; otherwise returns FALSE. A
     null string is always empty.
 
     \code
         QString a;          // a.unicode() == 0, a.length() == 0
         a.isNull();         // TRUE, because a.unicode() == 0
         a.isEmpty();        // TRUE
     \endcode
 
     \sa isEmpty(), length()
 */
 
 /*!
     \fn bool QString::isEmpty() const
 
     Returns TRUE if the string is empty, i.e. if length() == 0;
     otherwise returns FALSE. Null strings are also empty.
 
@@ -13450,122 +13464,118 @@ QString &QString::operator=( const char *str )
 /*!
     If \a newLen is less than the length of the string, then the
     string is truncated at position \a newLen. Otherwise nothing
     happens.
 
     \code
         QString s = "truncate me";
         s.truncate( 5 );            // s == "trunc"
     \endcode
 
     \sa setLength()
 */
 
 void QString::truncate( uint newLen )
 {
     if ( newLen < d->len )
         setLength( newLen );
 }
 
 /*!
     Ensures that at least \a newLen characters are allocated to the
     string, and sets the length of the string to \a newLen. Any new
     space allocated contains arbitrary data.
 
-    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).
 
     If it is not possible to allocate enough memory, the string
     remains unchanged.
 
     This function always detaches the string from other references to
     the same data.
 
     This function is useful for code that needs to build up a long
     string and wants to avoid repeated reallocation. In this example,
     we want to add to the string until some condition is true, and
     we're fairly sure that size is big enough:
     \code
         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
 
     If \a newLen is an underestimate, the worst that will happen is
     that the loop will slow down.
 
     \sa truncate(), isNull(), isEmpty(), length()
 */
 
 void QString::setLength( uint newLen )
 {
     if ( d->count != 1 || newLen > d->maxl ||
          ( newLen * 4 < d->maxl && d->maxl > 4 ) ) {
         // detach, grow or shrink
-        Q2HELPER(stat_copy_on_write++)
-        Q2HELPER(stat_copy_on_write_size+=d->len)
         uint newMax = computeNewMax( newLen );
         QChar* nd = QT_ALLOC_QCHAR_VEC( newMax );
         if ( nd ) {
             uint len = QMIN( d->len, newLen );
             if ( d->unicode )
                 memcpy( nd, d->unicode, sizeof(QChar)*len );
             deref();
             d = new QStringData( nd, newLen, newMax );
         }
     } else {
         d->len = newLen;
         d->setDirty();
     }
 }
 
 /*!
     This function will return a string that replaces the lowest
     numbered occurrence of \c %1, \c %2, ..., \c %9 with \a a.
 
     The \a fieldwidth value specifies the minimum amount of space that
     \a a is padded to. A positive value will produce right-aligned
     text, whereas a negative value will produce left-aligned text.
 
+    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.
 
     If there is no place marker (\c %1 or \c %2, etc.), a warning
     message (qWarning()) is output and the text is appended at the
     end of the string. We recommend that the correct number of place
     markers is always used in production code.
 */
 QString QString::arg( const QString& a, int fieldwidth ) const
 {
     int pos, len;
     QString r = *this;
 
     if ( !findArg( pos, len ) ) {
         qWarning( "QString::arg(): Argument missing: %s, %s",
                   latin1(), a.latin1() );
         // Make sure the text at least appears SOMEWHERE
         r += ' ';
         pos = r.length();
         len = 0;
     }
 
     r.replace( pos, len, a );
     if ( fieldwidth < 0 ) {
         QString s;
         while ( (uint)-fieldwidth > a.length() ) {
@@ -13753,49 +13763,49 @@ bool QString::findArg( int& pos, int& len ) const
         int x = ...;
         QTextOStream( &str ) << s << " : " << x;
     \endcode
 
     For \link QObject::tr() translations,\endlink especially if the
     strings contains more than one escape sequence, you should
     consider using the arg() function instead. This allows the order
     of the replacements to be controlled by the translator, and has
     Unicode support.
 
     \sa arg()
 */
 
 #ifndef QT_NO_SPRINTF
 QString &QString::sprintf( const char* cformat, ... )
 {
     va_list ap;
     va_start( ap, cformat );
 
     if ( !cformat || !*cformat ) {
         // Qt 1.x compat
         *this = fromLatin1( "" );
         return *this;
     }
-    QString format = fromLatin1( cformat );
+    QString format = fromAscii( cformat );
 
     QRegExp escape( "%#?0?-? ?\\+?'?[0-9*]*\\.?[0-9*]*h?l?L?q?Z?" );
     QString result;
     uint last = 0;
     int pos;
     int len = 0;
 
     for (;;) {
         pos = escape.search( format, last );
         len = escape.matchedLength();
         // Non-escaped text
         if ( pos > (int)last )
             result += format.mid( last, pos - last );
         if ( pos < 0 ) {
             // The rest
             if ( last < format.length() )
                 result += format.mid( last );
             break;
         }
         last = pos + len + 1;
 
         // Escape
         QString f = format.mid( pos, len );
         uint width, decimals;
@@ -13892,49 +13902,49 @@ QString &QString::sprintf( const char* cformat, ... )
                         break;
                     case 1:
                         ::sprintf( out, in, width, value );
                         break;
                     case 2:
                         ::sprintf( out, in, width, decimals, value );
                     }
                 }
                 break;
             case 'p':
                 {
                     void* value = va_arg( ap, void * );
                     switch ( params ) {
                     case 0:
                         ::sprintf( out, in, value );
                         break;
                     case 1:
                         ::sprintf( out, in, width, value );
                         break;
                     case 2:
                         ::sprintf( out, in, width, decimals, value );
                     }
                 }
             }
-            replacement = fromLatin1( out );
+            replacement = fromAscii( out );
         }
         result += replacement;
     }
     *this = result;
 
     va_end( ap );
     return *this;
 }
 #endif
 
 /*!
     Fills the string with \a len characters of value \a c, and returns
     a reference to the string.
 
     If \a len is negative (the default), the current string length is
     used.
 
     \code
         QString str;
         str.fill( 'g', 5 );      // string == "ggggg"
     \endcode
 */
 
 QString& QString::fill( QChar c, int len )
@@ -14103,50 +14113,52 @@ static int bm_find( const QString &str, int index, const QString &pattern, uint
     \overload
 
     Finds the first occurrence of the string \a str, starting at
     position \a index. If \a index is -1, the search starts at the
     last character, if it is -2, at the next to last character and so
     on. (See findRev() for searching backwards.)
 
     If \a cs is TRUE, the search is case sensitive; otherwise the
     search is case insensitive.
 
     Returns the position of \a str or -1 if \a str could not be found.
 */
 
 int QString::find( const QString& str, int index, bool cs ) const
 {
     const uint l = length();
     const uint sl = str.length();
     if ( index < 0 )
         index += l;
     if ( sl + index > l )
         return -1;
     if ( !sl )
         return index;
 
+#ifndef MACOSX_101
     if ( sl == 1 )
         return find( *str.unicode(), index, cs );
+#endif
 
     // we use the Boyer-Moore algorithm in cases where the overhead
     // for the hash table should pay off, otherwise we use a simple
     // hash function
     if ( l > 500 && sl > 5 ) {
         uint skiptable[0x100];
         bm_init_skiptable( str, skiptable, cs );
         return bm_find( *this, index, str, skiptable, cs );
     }
 
     /*
       We use some hashing for efficiency's sake. Instead of
       comparing strings, we compare the hash value of str with that of
       a part of this QString. Only if that matches, we call ucstrncmp
       or ucstrnicmp.
     */
     const QChar* needle = str.unicode();
     const QChar* haystack = unicode() + index;
     const QChar* end = unicode() + (l-sl);
     const uint sl_minus_1 = sl-1;
     uint hashNeedle = 0, hashHaystack = 0, i;
 
     if ( cs ) {
         for ( i = 0; i < sl; ++i ) {
@@ -14200,102 +14212,108 @@ int QString::find( const QString& str, int index, bool cs ) const
     Equivalent to find(QString(\a str), \a index).
 */
 
 /*!
     \overload
 
     Finds the first occurrence of the character \a c, starting at
     position \a index and searching backwards. If the index is -1, the
     search starts at the last character, if it is -2, at the next to
     last character and so on.
 
     Returns the position of \a c or -1 if \a c could not be found.
 
     If \a cs is TRUE, the search is case sensitive; otherwise the
     search is case insensitive.
 
     \code
         QString string( "bananas" );
         int i = string.findRev( 'a' );      // i == 5
     \endcode
 */
 
 int QString::findRev( QChar c, int index, bool cs ) const
 {
+#ifdef MACOSX_101
+    return findRev( QString( c ), index, cs );
+#else
     const uint l = length();
     if ( index < 0 )
         index += l;
     if ( (uint)index >= l )
         return -1;
     const QChar *end = unicode();
     register const QChar *uc = end + index;
     if ( cs ) {
         while ( uc >= end && *uc != c )
             uc--;
     } else {
         c = ::lower( c );
         while ( uc >= end && ::lower( *uc ) != c )
             uc--;
     }
     return uc - end;
+#endif
 }
 
 /*!
     \overload
 
     Finds the first occurrence of the string \a str, starting at
     position \a index and searching backwards. If the index is -1, the
     search starts at the last character, if it is -2, at the next to
     last character and so on.
 
     Returns the position of \a str or -1 if \a str could not be found.
 
     If \a cs is TRUE, the search is case sensitive; otherwise the
     search is case insensitive.
 
     \code
     QString string("bananas");
     int i = string.findRev( "ana" );      // i == 3
     \endcode
 */
 
 int QString::findRev( const QString& str, int index, bool cs ) const
 {
     /*
       See QString::find() for explanations.
     */
     const uint l = length();
     if ( index < 0 )
         index += l;
     const uint sl = str.length();
     int delta = l-sl;
     if ( index < 0 || index > (int)l || delta < 0 )
         return -1;
     if ( index > delta )
         index = delta;
 
+#ifndef MACOSX_101
     if ( sl == 1 )
         return findRev( *str.unicode(), index, cs );
+#endif
 
     const QChar* needle = str.unicode();
     const QChar* haystack = unicode() + index;
     const QChar* end = unicode();
     const uint sl_minus_1 = sl-1;
     const QChar* n = needle+sl_minus_1;
     const QChar* h = haystack+sl_minus_1;
     uint hashNeedle = 0, hashHaystack = 0, i;
 
     if ( cs ) {
         for ( i = 0; i < sl; ++i ) {
             hashNeedle = ((hashNeedle<<1) + (n-i)->unicode() );
             hashHaystack = ((hashHaystack<<1) + (h-i)->unicode() );
         }
         hashHaystack -= haystack->unicode();
 
         while ( haystack >= end ) {
             hashHaystack += haystack->unicode();
              if ( hashHaystack == hashNeedle
                  && ucstrncmp( needle, haystack, sl ) == 0 )
                 return haystack-unicode();
             --haystack;
             REHASH( (haystack+sl)->unicode() );
         }
@@ -14958,89 +14976,99 @@ QString QString::rightJustify( uint width, QChar fill, bool truncate ) const
         if ( len )
             memcpy( uc, unicode(), sizeof(QChar)*len );
     } else {
         if ( truncate )
             result = left( width );
         else
             result = *this;
     }
     return result;
 }
 
 /*!
     Returns a lowercase copy of the string.
 
     \code
         QString string( "TROlltECH" );
         str = string.lower();   // str == "trolltech"
     \endcode
 
     \sa upper()
 */
 
 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;
 }
 
 /*!
     Returns an uppercase copy of the string.
 
     \code
         QString string( "TeXt" );
         str = string.upper();     // t == "TEXT"
     \endcode
 
     \sa lower()
 */
 
 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;
 }
 
 
 /*!
     Returns a string that has whitespace removed from the start and
     the end.
 
     Whitespace means any character for which QChar::isSpace() returns
     TRUE. This includes Unicode characters with decimal values 9
     (TAB), 10 (LF), 11 (VT), 12 (FF), 13 (CR) and 32 (Space), and may
     also include other Unicode characters.
 
     \code
         QString string = "   white space   ";
         QString s = string.stripWhiteSpace();       // s == "white space"
     \endcode
 
     \sa simplifyWhiteSpace()
 */
 
 QString QString::stripWhiteSpace() const
 {
     if ( isEmpty() )                            // nothing to do
         return *this;
@@ -15116,50 +15144,50 @@ QString QString::simplifyWhiteSpace() const
     Inserts \a s into the string at position \a index.
 
     If \a index is beyond the end of the string, the string is
     extended with spaces to length \a index and \a s is then appended
     and returns a reference to the string.
 
     \code
         QString string( "I like fish" );
         str = string.insert( 2, "don't " );
         // str == "I don't like fish"
     \endcode
 
     \sa remove(), replace()
 */
 
 QString &QString::insert( uint index, const QString &s )
 {
     // the sub function takes care of &s == this case.
     return insert( index, s.unicode(), s.length() );
 }
 
 /*!
     \overload
 
-    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.
 */
 
 QString &QString::insert( uint index, const QChar* s, uint len )
 {
     if ( len == 0 )
         return *this;
     uint olen = length();
     int nlen = olen + len;
 
     if ( s >= d->unicode && (uint)(s - d->unicode) < d->maxl ) {
         // Part of me - take a copy.
         QChar *tmp = QT_ALLOC_QCHAR_VEC( len );
         memcpy(tmp,s,len*sizeof(QChar));
         insert(index,tmp,len);
         QT_DELETE_QCHAR_VEC( tmp );
         return *this;
     }
 
     if ( index >= olen ) {                      // insert after end of string
         setLength( len + index );
         int n = index - olen;
         QChar* uc = d->unicode+olen;
         while (n--)
             *uc++ = ' ';
@@ -15230,48 +15258,58 @@ QString &QString::insert( uint index, QChar c ) // insert char
 
 /*!
     \fn QString& QString::prepend( QChar ch )
 
     \overload
 
     Inserts \a ch at the beginning of the string and returns a
     reference to the string.
 
     Equivalent to insert(0, \a ch).
 
     \sa insert()
 */
 
 /*! \fn QString& QString::prepend( const QByteArray &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()
  */
 
+/*! \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()
+ */
+
 /*!
   \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()
  */
 QString &QString::prepend( const char *s )
 {
     return insert( 0, QString(s) );
 }
 
 /*!
     Removes \a len characters from the string starting at position \a
     index, and returns a reference to the string.
 
     If \a index is beyond the length of the string, nothing happens.
     If \a index is within the string, but \a index + \a len is beyond
     the end of the string, the string is truncated at position \a
     index.
 
     \code
@@ -15827,303 +15865,311 @@ int QString::contains( const QRegExp &rx ) const
 #endif //QT_NO_REGEXP
 
 static bool ok_in_base( QChar c, int base )
 {
     if ( base <= 10 )
         return c.isDigit() && c.digitValue() < base;
     else
         return c.isDigit() || (c >= 'a' && c < char('a'+base-10))
                            || (c >= 'A' && c < char('A'+base-10));
 }
 
 /*!
     Returns the string converted to a \c long value to the base \a
     base, which is 10 by default and must be between 2 and 36.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 
     \sa number()
 */
 
 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;
     int neg = 0;
     if ( !p )
         goto bye;
     while ( l && p->isSpace() )                 // skip leading space
         l--,p++;
     if ( !l )
         goto bye;
     if ( *p == '-' ) {
         l--;
         p++;
         neg = 1;
     } else if ( *p == '+' ) {
         l--;
         p++;
     }
 
     // NOTE: toULong() code is similar
     if ( !l || !ok_in_base(*p,base) )
         goto bye;
     while ( l && ok_in_base(*p,base) ) {
         l--;
         int dv;
         if ( p->isDigit() ) {
             dv = p->digitValue();
         } else {
             if ( *p >= 'a' && *p <= 'z' )
                 dv = *p - 'a' + 10;
             else
                 dv = *p - 'A' + 10;
         }
         if ( val > max_mult ||
-            (val == max_mult && dv > (INT_MAX % base) + neg) )
+            (val == max_mult && dv > (LONG_MAX % base) + neg) )
             goto bye;
         val = base * val + dv;
         p++;
     }
-    if ( neg )
-        val = -val;
     while ( l && p->isSpace() )                 // skip trailing space
-        l--,p++;
+        l--, p++;
     if ( !l )
         is_ok = TRUE;
 bye:
     if ( ok )
         *ok = is_ok;
-    return is_ok ? val : 0;
+    return is_ok ? ( neg ? -( (long) val ) : (long) val ) : 0L;
 }
 
 /*!
     Returns the string converted to an \c {unsigned long} value to the
     base \a base, which is 10 by default and must be between 2 and 36.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 
     \sa number()
 */
 
 ulong QString::toULong( bool *ok, int base ) const
 {
     const QChar *p = unicode();
     ulong val = 0;
     int l = length();
-    const ulong max_mult = UINT_MAX / base;
+    const ulong max_mult = ULONG_MAX / base;
     bool is_ok = FALSE;
     if ( !p )
         goto bye;
     while ( l && p->isSpace() )                 // skip leading space
         l--,p++;
     if ( !l )
         goto bye;
     if ( *p == '+' )
         l--,p++;
 
     // NOTE: toLong() code is similar
     if ( !l || !ok_in_base(*p,base) )
         goto bye;
     while ( l && ok_in_base(*p,base) ) {
         l--;
         uint dv;
         if ( p->isDigit() ) {
             dv = p->digitValue();
         } else {
             if ( *p >= 'a' && *p <= 'z' )
                 dv = *p - 'a' + 10;
             else
                 dv = *p - 'A' + 10;
         }
-        if ( val > max_mult || (val == max_mult && dv > UINT_MAX % base) )
+        if ( val > max_mult || (val == max_mult && dv > ULONG_MAX % base) )
             goto bye;
         val = base * val + dv;
         p++;
     }
 
     while ( l && p->isSpace() )                 // skip trailing space
         l--,p++;
     if ( !l )
         is_ok = TRUE;
 bye:
     if ( ok )
         *ok = is_ok;
     return is_ok ? val : 0;
 }
 
 /*!
     Returns the string converted to a \c short value to the base \a
     base, which is 10 by default and must be between 2 and 36.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 */
 
 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;
         v = 0;
     }
     return (short)v;
 }
 
 /*!
     Returns the string converted to an \c {unsigned short} value to
     the base \a base, which is 10 by default and must be between 2 and
     36.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 */
 
 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;
         v = 0;
     }
     return (ushort)v;
 }
 
 
 /*!
     Returns the string converted to an \c int value to the base \a
     base, which is 10 by default and must be between 2 and 36.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 
     \code
         QString str( "FF" );
         bool ok;
         int hex = str.toInt( &ok, 16 );     // hex == 255, ok == TRUE
         int dec = str.toInt( &ok, 10 );     // dec == 0, ok == FALSE
     \endcode
 
     \sa number()
 */
 
 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;
 }
 
 /*!
     Returns the string converted to an \c{unsigned int} value to the
     base \a base, which is 10 by default and must be between 2 and 36.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 
     \sa number()
 */
 
 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;
 }
 
 /*!
     Returns the string converted to a \c double value.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 
     \code
         QString string( "1234.56" );
         double a = string.toDouble();   // a == 1234.56
     \endcode
 
     \sa number()
 */
 
 double QString::toDouble( bool *ok ) const
 {
     char *end;
 
     const char *a = latin1();
     double val = strtod( a ? a : "", &end );
     if ( ok )
-        *ok = ( a && *a && (end == 0 || (end - a) == (int)length()) );
+        *ok = ( a && *a && (end == 0 || *end == '\0') );
     return val;
 }
 
 /*!
     Returns the string converted to a \c float value.
 
     If \a ok is not 0: if a conversion error occurs, \a *ok is set to
     FALSE; otherwise \a *ok is set to TRUE.
 
     \sa number()
 */
 
 float QString::toFloat( bool *ok ) const
 {
     return (float)toDouble( ok );
 }
 
 
 /*!
     Sets the string to the printed value of \a n in base \a base and
     returns a reference to the string.
 
     The base is 10 by default and must be between 2 and 36.
 
     \code
         QString string;
         string = string.setNum( 1234 );     // string == "1234"
     \endcode
 */
 
 QString &QString::setNum( long n, int base )
 {
 #if defined(QT_CHECK_RANGE)
     if ( base < 2 || base > 36 ) {
         qWarning( "QString::setNum: Invalid base %d", base );
         base = 10;
     }
 #endif
     char   charbuf[65*sizeof(QChar)];
     QChar *buf = (QChar*)charbuf;
     QChar *p = &buf[64];
     int  len = 0;
     bool neg;
     if ( n < 0 ) {
         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;
             return *this;
         }
         n = -n;
     } else {
         neg = FALSE;
     }
     do {
         *--p = "0123456789abcdefghijklmnopqrstuvwxyz"[((int)(n%base))];
         n /= base;
         ++len;
     } while ( n );
     if ( neg ) {
         *--p = '-';
         ++len;
     }
     return setUnicode( p, len );
 }
 
 /*!
     \overload
 
     Sets the string to the printed value of \a n in base \a base and
     returns a reference to the string.
@@ -16440,408 +16486,488 @@ void QString::setExpand( uint index, QChar c )
     the result.
 
     Equivalent to operator+=().
 */
 
 /*!
     \fn QString& QString::append( QChar ch )
 
     \overload
 
     Appends character \a ch to the string and returns a reference to
     the result.
 
     Equivalent to operator+=().
 */
 
 /*! \fn QString& QString::append( const QByteArray &str )
   \overload
 
   Appends \a str to the string and returns a reference to the result.
 
   Equivalent to operator+=().
  */
 
+/*! \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 )
   \overload
 
   Appends \a str to the string and returns a reference to the result.
 
   Equivalent to operator+=().
  */
 
 /*!
     Appends \a str to the string and returns a reference to the string.
 */
 QString& QString::operator+=( const QString &str )
 {
     uint len1 = length();
     uint len2 = str.length();
     if ( len2 ) {
         setLength(len1+len2);
         memcpy( d->unicode+len1, str.unicode(), sizeof(QChar)*len2 );
     } else if ( isNull() && !str.isNull() ) {   // ## just for 1.x compat:
         *this = fromLatin1( "" );
     }
     return *this;
 }
 
 /*!
     \overload
 
   Appends \a str to the string and returns a reference to the string.
 */
+#ifndef QT_NO_CAST_ASCII
 QString& QString::operator+=( const char *str )
 {
     if ( str ) {
+#ifndef QT_NO_TEXTCODEC
+        if ( QTextCodec::codecForCStrings() )
+            return operator+=( fromAscii( str ) );
+#endif
+
         uint len1 = length();
         uint len2 = strlen( str );
         if ( len2 ) {
             setLength(len1+len2);
             uint i = 0;
             while( i < len2 ) {
                 d->unicode[len1+i] = str[i];
                 i++;
             }
         } else if ( isNull() ) {   // ## just for 1.x compat:
             *this = fromLatin1( "" );
         }
     }
     return *this;
 }
+#endif
 
 /*! \overload
 
   Appends \a c to the string and returns a reference to the string.
 */
 
 QString &QString::operator+=( QChar c )
 {
     setLength(length()+1);
     d->unicode[length()-1] = c;
     return *this;
 }
 
 /*!
     \overload
 
     Appends \a c to the string and returns a reference to the string.
 */
 
 QString &QString::operator+=( char c )
 {
+#ifndef QT_NO_TEXTCODEC
+    if ( QTextCodec::codecForCStrings() )
+        return operator+=( fromAscii( &c, 1 ) );
+#endif
     setLength(length()+1);
     d->unicode[length()-1] = c;
     return *this;
 }
 
 /*!
   \fn QString &QString::operator+=( const QByteArray &str )
   \overload
 
   Appends \a str to the string and returns a reference to the string.
 */
 
+/*!
+  \fn QString &QString::operator+=( const std::string &str )
+  \overload
+
+  Appends \a str to the string and returns a reference to the string.
+*/
+
 
 
 /*!
     \fn char QChar::latin1() const
 
-    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.
 */
 
 
 /*!
-    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
     characters. If you want to convert strings into formats other than
     Unicode, see the QTextCodec classes.
 
     This function is mainly useful for boot-strapping legacy code to
     use Unicode.
 
     The result remains valid so long as one unmodified copy of the
     source string exists.
 
-    \sa utf8(), local8Bit()
+    \sa fromLatin1(), ascii(), utf8(), local8Bit()
 */
 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;
     }
     return d->ascii;
 }
 
 /*!
-  \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.
 
     See QTextCodec for more diverse coding/decoding of Unicode strings.
 
-    \sa QString::fromUtf8(), local8Bit(), latin1()
+    \sa fromUtf8(), ascii(), latin1(), local8Bit()
 */
 QCString QString::utf8() const
 {
     int l = length();
     int rlen = l*3+1;
     QCString rstr(rlen);
     uchar* cursor = (uchar*)rstr.data();
     const QChar *ch = d->unicode;
     for (int i=0; i<l; i++) {
         ushort u = ch->unicode();
          if ( u < 0x80 ) {
              *cursor++ = (uchar)u;
          } else {
              if ( u < 0x0800 ) {
                 *cursor++ = 0xc0 | ((uchar) (u >> 6));
              } else {
                 *cursor++ = 0xe0 | ((uchar) (u >> 12));
                 *cursor++ = 0x80 | ( ((uchar) (u >> 6)) & 0x3f);
              }
              *cursor++ = 0x80 | ((uchar) (u&0x3f));
          }
          ch++;
     }
     rstr.truncate( cursor - (uchar*)rstr.data() );
     return rstr;
 }
 
 /*!
     Returns the Unicode string decoded from the first \a len
     characters of \a utf8, ignoring the rest of \a utf8. If \a len is
     -1 then the length of \a utf8 is used. If \a len is bigger than
     the length of \a utf8 then it will use the length of \a utf8.
 
     \code
         QString str = QString::fromUtf8( "123456789", 5 );
         // str == "12345"
     \endcode
 
     See QTextCodec for more diverse coding/decoding of Unicode strings.
 */
 QString QString::fromUtf8( const char* utf8, int len )
 {
     if ( !utf8 )
         return QString::null;
 
-    if ( len < 0 ) len = qstrlen( utf8 );
+    if ( len < 0 )
+        len = strlen( utf8 );
     QString result;
     result.setLength( len ); // worst case
     QChar *qch = (QChar *)result.unicode();
     ushort uc = 0;
     int need = 0;
     for (int i=0; i<len; i++) {
         uchar ch = utf8[i];
         if (need) {
             if ( (ch&0xc0) == 0x80 ) {
                 uc = (uc << 6) | (ch & 0x3f);
                 need--;
                 if ( !need ) {
                     *qch = uc;
                     qch++;
                 }
             } else {
                 // error
                 *qch = QChar::replacement;
                 qch++;
                 need = 0;
             }
         } else {
             if ( ch < 128 ) {
                 *qch = ch;
                 qch++;
             } else if ( (ch&0xe0) == 0xc0 ) {
                 uc = ch &0x1f;
                 need = 1;
             } else if ( (ch&0xf0) == 0xe0 ) {
                 uc = ch &0x0f;
                 need = 2;
             }
         }
     }
     result.truncate( qch - result.unicode() );
     return result;
 }
 
 /*!
     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().
 
     This is the same as the QString(const char*) constructor, but you
     can make that constructor invisible if you compile with the define
     \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()
 */
 QString QString::fromLatin1( const char* chars, int len )
 {
     uint l;
     QChar *uc;
     if ( len < 0 )
          len = -1;
-    uc = internalAsciiToUnicode( chars, &l, len );
+    uc = internalLatin1ToUnicode( chars, &l, len );
     return QString( new QStringData(uc, l, l), TRUE );
 }
 
 /*!
     \fn const QChar* QString::unicode() const
 
     Returns the Unicode representation of the string. The result
     remains valid until the string is modified.
 */
 
 /*!
     Returns the string encoded in a locale-specific format. On X11,
     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.
 
     See QTextCodec for more diverse coding/decoding of Unicode
     strings.
 
-    \sa QString::fromLocal8Bit(), latin1(), utf8()
+    \sa fromLocal8Bit(), ascii(), latin1(), utf8()
 */
 
-
 QCString QString::local8Bit() const
 {
 #ifdef QT_NO_TEXTCODEC
     return latin1();
 #else
 #ifdef Q_WS_X11
     QTextCodec* codec = QTextCodec::codecForLocale();
     return codec
             ? codec->fromUnicode(*this)
             : QCString(latin1());
 #endif
 #if defined( Q_WS_MACX )
     return utf8();
 #endif
 #if defined( Q_WS_MAC9 )
     return QCString(latin1()); //I'm evil..
 #endif
 #ifdef Q_WS_WIN
     return qt_winQString2MB( *this );
 #endif
 #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
 #endif
 }
 
 /*!
     Returns the Unicode string decoded from the first \a len
     characters of \a local8Bit, ignoring the rest of \a local8Bit. If
     \a len is -1 then the length of \a local8Bit is used. If \a len is
     bigger than the length of \a local8Bit then it will use the length
     of \a local8Bit.
 
     \code
         QString str = QString::fromLocal8Bit( "123456789", 5 );
         // str == "12345"
     \endcode
 
     \a local8Bit is assumed to be encoded in a locale-specific format.
 
     See QTextCodec for more diverse coding/decoding of Unicode strings.
 */
 QString QString::fromLocal8Bit( const char* local8Bit, int len )
 {
 #ifdef QT_NO_TEXTCODEC
     return fromLatin1( local8Bit, len );
 #else
 
     if ( !local8Bit )
         return QString::null;
 #ifdef Q_WS_X11
     QTextCodec* codec = QTextCodec::codecForLocale();
-    if ( len < 0 ) len = qstrlen(local8Bit);
+    if ( len < 0 )
+        len = strlen( local8Bit );
     return codec
             ? codec->toUnicode( local8Bit, len )
             : fromLatin1( local8Bit, len );
 #endif
 #if defined( Q_WS_MAC )
     return fromUtf8(local8Bit,len);
 #endif
 // Should this be OS_WIN32?
 #ifdef Q_WS_WIN
     if ( len >= 0 ) {
         QCString s(local8Bit,len+1);
         return qt_winMB2QString(s);
     }
     return qt_winMB2QString( local8Bit );
 #endif
 #ifdef Q_WS_QWS
     return fromUtf8(local8Bit,len);
 #endif
 #endif // QT_NO_TEXTCODEC
 }
 
 /*!
     \fn QString::operator const char *() const
 
     Returns latin1(). Be sure to see the warnings documented in the
     latin1() function. Note that for new code which you wish to be
     strictly Unicode-clean, you can define the macro \c
     QT_NO_ASCII_CAST when compiling your code to hide this function so
     that automatic casts are not done. This has the added advantage
     that you catch the programming error described in operator!().
 */
 
+/*!
+    \fn QString::operator std::string() const
+
+    Returns ascii().
+*/
+
 
 /*!
     Returns the QString as a zero terminated array of unsigned shorts
     if the string is not null; otherwise returns zero.
 
     The result remains valid so long as one unmodified
     copy of the source string exists.
 */
 const unsigned short *QString::ucs2() const
 {
     if ( ! d->unicode )
         return 0;
     unsigned int len = d->len;
     if ( d->maxl < len + 1 ) {
         // detach, grow or shrink
-        Q2HELPER(stat_copy_on_write++)
-        Q2HELPER(stat_copy_on_write_size += len)
         uint newMax = computeNewMax( len + 1 );
         QChar* nd = QT_ALLOC_QCHAR_VEC( newMax );
         if ( nd ) {
             if ( d->unicode )
                 memcpy( nd, d->unicode, sizeof(QChar)*len );
             ((QString *)this)->deref();
             ((QString *)this)->d = new QStringData( nd, len, newMax );
         }
     }
     d->unicode[len] = 0;
     return (unsigned short *) d->unicode;
 }
 
 /*!
   Constructs a string that is a deep copy of \a str, interpreted as a
   UCS2 encoded, zero terminated, Unicode string.
 
   If \a str is 0, then a null string is created.
 
   \sa isNull()
 */
 QString QString::fromUcs2( const unsigned short *str )
 {
     if ( !str ) {
@@ -16962,126 +17088,146 @@ void QString::subat( uint i )
     }
 }
 
 
 /*!
     Resizes the string to \a len characters and copies \a unicode into
     the string. If \a unicode is 0, nothing is copied, but the
     string is still resized to \a len. If \a len is zero, then the
     string becomes a \link isNull() null\endlink string.
 
     \sa setLatin1(), isNull()
 */
 
 QString& QString::setUnicode( const QChar *unicode, uint len )
 {
     if ( len == 0 ) {                           // set to null string
         if ( d != shared_null ) {               // beware of nullstring being set to nullstring
             deref();
             d = shared_null ? shared_null : makeSharedNull();
             d->ref();
         }
     } else if ( d->count != 1 || len > d->maxl ||
                 ( len * 4 < d->maxl && d->maxl > 4 ) ) {
         // detach, grown or shrink
-        Q2HELPER(stat_copy_on_write++)
-        Q2HELPER(stat_copy_on_write_size+=d->len)
         uint newMax = computeNewMax( len );
         QChar* nd = QT_ALLOC_QCHAR_VEC( newMax );
         if ( unicode )
             memcpy( nd, unicode, sizeof(QChar)*len );
         deref();
         d = new QStringData( nd, len, newMax );
     } else {
         d->len = len;
         d->setDirty();
         if ( unicode )
             memcpy( d->unicode, unicode, sizeof(QChar)*len );
     }
     return *this;
 }
 
 /*!
     Resizes the string to \a len characters and copies \a
     unicode_as_ushorts into the string (on some X11 client platforms
     this will involve a byte-swapping pass).
 
     If \a unicode_as_ushorts is 0, nothing is copied, but the string
     is still resized to \a len. If \a len is zero, the string becomes
     a \link isNull() null\endlink string.
 
     \sa setLatin1(), isNull()
 */
 QString& QString::setUnicodeCodes( const ushort* unicode_as_ushorts, uint len )
 {
      return setUnicode((const QChar*)unicode_as_ushorts, 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
     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::setLatin1( const char *str, int len )
 {
     if ( str == 0 )
         return setUnicode(0,0);
     if ( len < 0 )
-        len = qstrlen(str);
+        len = strlen( str );
     if ( len == 0 ) {                           // won't make a null string
         *this = QString::fromLatin1( "" );
     } else {
         setUnicode( 0, len );                   // resize but not copy
         QChar *p = d->unicode;
         while ( len-- )
             *p++ = *str++;
     }
     return *this;
 }
 
 /*! \internal
  */
 void QString::checkSimpleText() const
 {
     QChar *p = d->unicode;
     QChar *end = p + d->len;
-    d->simpletext = 1;
     while( p < end ) {
         ushort uc = p->unicode();
         // sort out regions of complex text formatting
         if ( uc > 0x058f && ( uc < 0x1100 || uc > 0xfb0f ) ) {
-            d->simpletext = 0;
+            d->issimpletext = FALSE;
             return;
         }
         p++;
     }
+    d->issimpletext = TRUE;
 }
 
 /*! \fn bool QString::simpleText() const
   \internal
 */
 
 /*! \internal
  */
 bool QString::isRightToLeft() const
 {
     int len = length();
     QChar *p = d->unicode;
     while( len-- ) {
         switch( ::direction( *p ) )
         {
         case QChar::DirL:
         case QChar::DirLRO:
         case QChar::DirLRE:
             return FALSE;
         case QChar::DirR:
         case QChar::DirAL:
         case QChar::DirRLO:
         case QChar::DirRLE:
             return TRUE;