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,109 +1,113 @@
 /****************************************************************************
 ** $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;
 }
 
 
 sub readUnicodeDataLine {
     $code = shift @_;
     for $n (qw{
             name category combining_class bidi_category
             character_decomposition decimal_digit_value digit_value
             numeric_value mirrored oldname comment
             uppercase lowercase titlecase})
     {
         $id = shift @_;
         $codes = "${n}_code";
         if ( defined %$codes && defined $$codes{$id} ) {
             $id = $$codes{$id};
         }
         ${$n}{$code}=$id;
     }
     $decomp = $character_decomposition{$code};
     if ( length $decomp == 0 ) {
         $decomp = "<single>";
     }
     if (substr($decomp, 0, 1) ne '<') {
         $decomp = "<canonical> " . $decomp;
     }
@@ -11742,108 +11746,110 @@ static inline QChar::Category category( const QChar &c )
 #endif
 }
 
 static inline QChar lower( const QChar &c )
 {
 #ifndef QT_NO_UNICODETABLES
     uchar row = c.row();
     uchar cell = c.cell();
     if ( unicode_info[row][cell] != QChar::Letter_Uppercase )
         return c;
     Q_UINT16 lower = *( case_info[row] + cell );
     if ( lower == 0 )
         return c;
     return lower;
 #else
     if ( c.row() )
         return c;
     else
         return QChar( tolower((uchar) c.latin1()) );
 #endif
 }
 
 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,
     0x2768, 0x2769, 0x276A, 0x276B, 0x276C, 0x276D, 0x276E, 0x276F,
     0x2770, 0x2771, 0x2772, 0x2773, 0x2774, 0x2775, 0x27D5, 0x27D6,
     0x27DD, 0x27DE, 0x27E2, 0x27E3, 0x27E4, 0x27E5, 0x27E6, 0x27E7,
     0x27E8, 0x27E9, 0x27EA, 0x27EB, 0x2983, 0x2984, 0x2985, 0x2986,
     0x2987, 0x2988, 0x2989, 0x298A, 0x298B, 0x298C, 0x298D, 0x2990,
     0x298E, 0x298F, 0x2991, 0x2992, 0x2993, 0x2994, 0x2995, 0x2996,
     0x2997, 0x2998, 0x29C0, 0x29C1, 0x29C4, 0x29C5, 0x29CF, 0x29D0,
     0x29D1, 0x29D2, 0x29D4, 0x29D5, 0x29D8, 0x29D9, 0x29DA, 0x29DB,
     0x29F8, 0x29F9, 0x29FC, 0x29FD, 0x2A2B, 0x2A2C, 0x2A34, 0x2A35,
     0x2A3C, 0x2A3D, 0x2A64, 0x2A65, 0x2A79, 0x2A7A, 0x2A7D, 0x2A7E,
     0x2A7F, 0x2A80, 0x2A81, 0x2A82, 0x2A83, 0x2A84, 0x2A8B, 0x2A8C,
     0x2A91, 0x2A92, 0x2A93, 0x2A94, 0x2A95, 0x2A96, 0x2A97, 0x2A98,
     0x2A99, 0x2A9A, 0x2A9B, 0x2A9C, 0x2AA1, 0x2AA2, 0x2AA6, 0x2AA7,
     0x2AA8, 0x2AA9, 0x2AAA, 0x2AAB, 0x2AAC, 0x2AAD, 0x2AAF, 0x2AB0,
     0x2AB3, 0x2AB4, 0x2ABB, 0x2ABC, 0x2ABD, 0x2ABE, 0x2ABF, 0x2AC0,
     0x2AC1, 0x2AC2, 0x2AC3, 0x2AC4, 0x2AC5, 0x2AC6, 0x2ACD, 0x2ACE,
     0x2ACF, 0x2AD0, 0x2AD1, 0x2AD2, 0x2AD3, 0x2AD4, 0x2AD5, 0x2AD6,
     0x2AEC, 0x2AED, 0x2AF7, 0x2AF8, 0x2AF9, 0x2AFA, 0x3008, 0x3009,
     0x300A, 0x300B, 0x300C, 0x300D, 0x300E, 0x300F, 0x3010, 0x3011,
     0x3014, 0x3015, 0x3016, 0x3017, 0x3018, 0x3019, 0x301A, 0x301B,
     0xFF08, 0xFF09, 0xFF1C, 0xFF1E, 0xFF3B, 0xFF3D, 0xFF5B, 0xFF5D,
     0xFF5F, 0xFF60, 0xFF62, 0xFF63,
 };
 
@@ -11855,97 +11861,97 @@ static const int symmetricPairsSize =
  * ----------------------------------------------------------------------
  * End of unicode tables
  * ----------------------------------------------------------------------
  */
 
 #endif
 
 static int ucstrcmp( const QString &as, const QString &bs )
 {
     const QChar *a = as.unicode();
     const QChar *b = bs.unicode();
     if ( a == b )
         return 0;
     if ( a == 0 )
         return 1;
     if ( b == 0 )
         return -1;
     int l=QMIN(as.length(),bs.length());
     while ( l-- && *a == *b )
         a++,b++;
     if ( l==-1 )
         return ( as.length()-bs.length() );
     return a->unicode() - b->unicode();
 }
 
 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
 */
 
 /*!
     \class QChar qstring.h
     \reentrant
     \brief The QChar class provides a lightweight Unicode character.
 
     \ingroup text
 
     Unicode characters are (so far) 16-bit entities without any markup
     or structure. This class represents such an entity. It is
     lightweight, so it can be used everywhere. Most compilers treat it
     like a "short int".  (In a few years it may be necessary to make
     QChar 32-bit when more than 65536 Unicode code points have been
     defined and come into use.)
 
     QChar provides a full complement of testing/classification
     functions, converting to and from other formats, converting from
     composed to decomposed Unicode, and trying to compare and
     case-convert if you ask it to.
 
     The classification functions include functions like those in
     ctype.h, but operating on the full range of Unicode characters.
     They all return TRUE if the character is a certain type of
     character; otherwise they return FALSE. These classification
     functions are isNull() (returns TRUE if the character is U+0000),
@@ -12846,200 +12852,200 @@ void QString::compose()
         ligature.first();
         while(ligature.current()) {
             if ((len = ligature.match(*this, index)) != 0) {
                 head = ligature.head();
                 unsigned short code = head.unicode();
                 // we exclude Arabic presentation forms A and a few
                 // other ligatures, which are undefined in most fonts
                 if(!(code > 0xfb50 && code < 0xfe80) &&
                    !(code > 0xfb00 && code < 0xfb2a)) {
                                 // joining info is only needed for Arabic
                     if (format(ligature.tag(), *this, index, len)) {
                         //printf("using ligature 0x%x, len=%d\n",code,len);
                         // replace letter
                         composed.replace(cindex, len, QChar(head));
                         index += len-1;
                         // we continue searching in case we have a final
                         // form because medial ones are preferred.
                         if ( len != 1 || ligature.tag() !=QChar::Final )
                             break;
                     }
                 }
             }
             ligature.next();
         }
         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.
 
     \ingroup tools
     \ingroup shared
     \ingroup text
     \mainclass
 
     QString uses \link shclass.html implicit sharing\endlink, which
     makes it very efficient and easy to use.
 
     In all of the QString methods that take \c {const char *}
     parameters, the \c {const char *} is interpreted as a classic
     C-style '\0'-terminated ASCII string. It is legal for the \c
     {const char *} parameter to be 0. If the \c {const char *} is not
     '\0'-terminated, the results are undefined. Functions that copy
     classic C strings into a QString will not copy the terminating
     '\0' character. The QChar array of the QString (as returned by
     unicode()) is generally not terminated by a '\0'. If you need to
     pass a QString to a function that requires a C '\0'-terminated
     string use latin1().
 
     \keyword QString::null
     A QString that has not been assigned to anything is \e null, i.e.
     both the length and data pointer is 0. A QString that references
     the empty string ("", a single '\0' char) is \e empty. Both null
@@ -13112,484 +13118,488 @@ char* QString::unicodeToAscii(const QChar *uc, uint l)
 
     \sa QChar QCString QByteArray QConstString
 */
 
 /*! \enum Qt::ComparisonFlags
 \internal
 */
 /*!
     \enum Qt::StringComparisonMode
 
     This enum type is used to set the string comparison mode when
     searching for an item. It is used by QListBox, QListView and
     QIconView, for example. We'll refer to the string being searched
     as the 'target' string.
 
     \value CaseSensitive The strings must match case sensitively.
     \value ExactMatch The target and search strings must match exactly.
     \value BeginsWith The target string begins with the search string.
     \value EndsWith The target string ends with the search string.
     \value Contains The target string contains the search string.
 
     If you OR these flags together (excluding \c CaseSensitive), the
     search criteria be applied in the following order: \c ExactMatch,
     \c BeginsWith, \c EndsWith, \c Contains.
 
     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 {
         QChar* uc = QT_ALLOC_QCHAR_VEC( length );
         if ( unicode )
             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.
 
     \code
         QString a( "" );
         a.isEmpty();        // TRUE
         a.isNull();         // FALSE
 
         QString b;
         b.isEmpty();        // TRUE
         b.isNull();         // TRUE
     \endcode
 
     \sa isNull(), length()
 */
 
 /*!
     \fn uint QString::length() const
 
     Returns the length of the string.
 
     Null strings and empty strings have zero length.
 
     \sa isNull(), isEmpty()
 */
 
 /*!
     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() ) {
             s += ' ';
             fieldwidth++;
         }
         r.insert( pos + a.length(), s );
     } else if ( fieldwidth ) {
         QString s;
         while ( (uint)fieldwidth > a.length() ) {
             s += ' ';
             fieldwidth--;
         }
         r.insert( pos, s );
     }
 
     return r;
 }
 
 
 /*!
     \overload
 
     The \a fieldwidth value specifies the minimum amount of space that
     \a a is padded to. A positive value will produce a right-aligned
     number, whereas a negative value will produce a left-aligned
     number.
@@ -13729,97 +13739,97 @@ bool QString::findArg( int& pos, int& len ) const
                     lowest = dig;
                     pos = i;
                     len = 2;
                 }
             }
         }
     }
     return lowest != 0;
 }
 
 /*!
     Safely builds a formatted string from the format string \a cformat
     and an arbitrary list of arguments. The format string supports all
     the escape sequences of printf() in the standard C library.
 
     The %s escape sequence expects a utf8() encoded string. The format
     string \e cformat is expected to be in latin1. If you need a
     Unicode format string, use arg() instead. For typesafe string
     building, with full Unicode support, you can use QTextOStream like
     this:
 
     \code
         QString str;
         QString s = ...;
         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;
         int params = 0;
         int wpos = f.find('*');
         if ( wpos >= 0 ) {
             params++;
             width = va_arg( ap, int );
             if ( f.find('*', wpos + 1) >= 0 ) {
                 decimals = va_arg( ap, int );
                 params++;
             } else {
                 decimals = 0;
             }
         } else {
             decimals = width = 0;
         }
         QString replacement;
         if ( format[pos + len] == 's' || format[pos + len] == 'S' ||
              format[pos + len] == 'c' )
         {
             bool rightjust = ( f.find('-') < 0 );
             // %-5s really means left adjust in sprintf
 
             if ( wpos < 0 ) {
                 QRegExp num( fromLatin1("[0-9]+") );
                 int p = num.search( f );
@@ -13868,97 +13878,97 @@ QString &QString::sprintf( const char* cformat, ... )
                 {
                     int value = va_arg( ap, int );
                     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 );
                     }
                 }
                 break;
             case 'e':
             case 'E':
             case 'f':
             case 'g':
             case 'G':
                 {
                     double value = va_arg( ap, double );
                     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 );
                     }
                 }
                 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 )
 {
     if ( len < 0 )
         len = length();
     if ( len == 0 ) {
         *this = "";
     } else {
         deref();
         QChar * nd = QT_ALLOC_QCHAR_VEC( len );
         d = new QStringData(nd,len,len);
         while (len--) *nd++ = c;
     }
     return *this;
 }
 
 
 /*!
   \fn QString QString::copy() const
 
   \obsolete
 
   In Qt 2.0 and later, all calls to this function are needless. Just
   remove them.
 */
 
@@ -14079,247 +14089,255 @@ static int bm_find( const QString &str, int index, const QString &pattern, uint
                 }
                 if ( skip > pl_minus_one ) // we have a match
                     return (current - uc) - skip + 1;
                 // in case we don't have a match we are a bit inefficient as we only skip by one
                 // when we have the non matching char in the string.
                 if ( skiptable[ ::lower( (current - skip)->cell() ) ] == pl )
                     skip = pl - skip;
                 else
                     skip = 1;
             }
             current += skip;
         }
     }
     // not found
     return -1;
 }
 
 
 #define REHASH( a ) \
     if ( sl_minus_1 < sizeof(uint) * CHAR_BIT ) \
         hashHaystack -= (a) << sl_minus_1; \
     hashHaystack <<= 1
 
 /*!
     \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 ) {
             hashNeedle = ((hashNeedle<<1) + needle[i].unicode() );
             hashHaystack = ((hashHaystack<<1) + haystack[i].unicode() );
         }
         hashHaystack -= (haystack+sl_minus_1)->unicode();
 
         while ( haystack <= end ) {
             hashHaystack += (haystack+sl_minus_1)->unicode();
              if ( hashHaystack == hashNeedle
                  && ucstrncmp( needle, haystack, sl ) == 0 )
                 return haystack-unicode();
 
             REHASH( haystack->unicode() );
             ++haystack;
         }
     } else {
         for ( i = 0; i < sl; ++i ) {
             hashNeedle = ((hashNeedle<<1) +
                           ::lower( needle[i].unicode() ).unicode() );
             hashHaystack = ((hashHaystack<<1) +
                             ::lower( haystack[i].unicode() ).unicode() );
         }
 
         hashHaystack -= ::lower(*(haystack+sl_minus_1)).unicode();
         while ( haystack <= end ) {
             hashHaystack += ::lower(*(haystack+sl_minus_1)).unicode();
             if ( hashHaystack == hashNeedle
                  && ucstrnicmp( needle, haystack, sl ) == 0 )
                 return haystack-unicode();
 
             REHASH( ::lower(*haystack).unicode() );
             ++haystack;
         }
     }
     return -1;
 }
 
 /*!
     \fn int QString::findRev( const char* str, int index ) const
 
     Equivalent to findRev(QString(\a str), \a index).
 */
 
 /*!
     \fn int QString::find( const char* str, int index ) const
 
     \overload
 
     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() );
         }
     } else {
         for ( i = 0; i < sl; ++i ) {
             hashNeedle = ((hashNeedle<<1)
                           + ::lower( (n-i)->unicode() ).unicode() );
             hashHaystack = ((hashHaystack<<1)
                             + ::lower( (h-i)->unicode() ).unicode() );
         }
         hashHaystack -= ::lower(*haystack).unicode();
 
         while ( haystack >= end ) {
             hashHaystack += ::lower(*haystack).unicode();
             if ( hashHaystack == hashNeedle
                  && ucstrnicmp( needle, haystack, sl ) == 0 )
                 return haystack-unicode();
             --haystack;
             REHASH( ::lower(*(haystack+sl)).unicode() );
         }
     }
     return -1;
 }
 
 #undef REHASH
 
 /*!
@@ -14934,137 +14952,147 @@ QString QString::leftJustify( uint width, QChar fill, bool truncate ) const
     \a width, then the returned string is a copy of the string.
 
     If \a truncate is TRUE and the length of the string is more than
     \a width, then the resulting string is truncated at position \a
     width.
 
     \code
         QString string( "apple" );
         QString t = string.rightJustify( 8, '.' );  // t == "...apple"
     \endcode
 
     \sa leftJustify()
 */
 
 QString QString::rightJustify( uint width, QChar fill, bool truncate ) const
 {
     QString result;
     int len = length();
     int padlen = width - len;
     if ( padlen > 0 ) {
         result.setLength( len+padlen );
         QChar* uc = result.d->unicode;
         while (padlen--)
             *uc++ = fill;
         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;
     register const QChar *s = unicode();
     if ( !s->isSpace() && !s[length()-1].isSpace() )
         return *this;
 
     int start = 0;
     int end = length() - 1;
     while ( start<=end && s[start].isSpace() )  // skip white space from start
         start++;
     if ( start <= end ) {                          // only white space
         while ( end && s[end].isSpace() )           // skip white space from end
             end--;
     }
     int l = end - start + 1;
     if ( l <= 0 )
             return QString::fromLatin1("");
 
     QString result( l, TRUE );
     memcpy( result.d->unicode, &s[start], sizeof(QChar)*l );
     result.d->len = l;
     return result;
 }
 
 
 /*!
@@ -15092,98 +15120,98 @@ QString QString::simplifyWhiteSpace() const
     QString result;
     result.setLength( length() );
     const QChar *from = unicode();
     const QChar *fromend = from+length();
     int outc=0;
     QChar *to   = result.d->unicode;
     for (;;) {
         while ( from!=fromend && from->isSpace() )
             from++;
         while ( from!=fromend && !from->isSpace() )
             to[outc++] = *from++;
         if ( from!=fromend )
             to[outc++] = ' ';
         else
             break;
     }
     if ( outc > 0 && to[outc-1] == ' ' )
         outc--;
     result.truncate( outc );
     return result;
 }
 
 
 /*!
     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++ = ' ';
         memcpy( d->unicode+index, s, sizeof(QChar)*len );
     } else {                                    // normal insert
         setLength( nlen );
         memmove( d->unicode + index + len, unicode() + index,
                  sizeof(QChar) * (olen - index) );
         memcpy( d->unicode + index, s, sizeof(QChar) * len );
     }
     return *this;
 }
 
 /*!
     \overload
 
     Insert \a c into the string at position \a index and returns a
     reference to the string.
 
     If \a index is beyond the end of the string, the string is
     extended with spaces (ASCII 32) to length \a index and \a c is
     then appended.
 */
 
 QString &QString::insert( uint index, QChar c ) // insert char
 {
     QString s( c );
@@ -15206,96 +15234,106 @@ QString &QString::insert( uint index, QChar c ) // insert char
 
     Equivalent to insert(0, \a s).
 
     \code
         QString string = "42";
         string.prepend( "The answer is " );
         // string == "The answer is 42"
     \endcode
 
     \sa insert()
 */
 
 /*!
     \fn QString& QString::prepend( char 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( 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
         QString string( "Montreal" );
         string.remove( 1, 4 );      // string == "Meal"
     \endcode
 
     \sa insert(), replace()
 */
 
 QString &QString::remove( uint index, uint len )
 {
     uint olen = length();
     if ( index >= olen  ) {
         // range problems
     } else if ( index + len >= olen ) {  // index ok
         setLength( index );
     } else if ( len != 0 ) {
         real_detach();
         memmove( d->unicode+index, d->unicode+index+len,
                  sizeof(QChar)*(olen-index-len) );
         setLength( olen-len );
     }
     return *this;
 }
 
 /*! \overload
@@ -15803,351 +15841,359 @@ int QString::findRev( const QRegExp &rx, int index ) const
 
     \code
         QString str = "banana and panama";
         QRegExp rxp = QRegExp( "a[nm]a", TRUE, FALSE );
         int i = str.contains( rxp );    // i == 4
     \endcode
 
     \sa find() findRev()
 */
 
 int QString::contains( const QRegExp &rx ) const
 {
     int count = 0;
     int index = -1;
     int len = length();
     while ( index < len - 1 ) {                 // count overlapping matches
         index = rx.search( *this, index + 1 );
         if ( index == -1 )
             break;
         count++;
     }
     return count;
 }
 
 #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.
 
     The base is 10 by default and must be between 2 and 36.
 */
 
 QString &QString::setNum( ulong 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;
     do {
         *--p = "0123456789abcdefghijklmnopqrstuvwxyz"[((int)(n%base))];
         n /= base;
         len++;
     } while ( n );
     return setUnicode(p,len);
 }
 
@@ -16416,456 +16462,536 @@ void QString::setExpand( uint index, QChar c )
     \sa isEmpty()
 */
 
 
 /*!
     \fn QString& QString::append( const QString& str )
 
     Appends \a str to the string and returns a reference to the
     result.
 
     \code
         string = "Test";
         string.append( "ing" );        // string == "Testing"
     \endcode
 
     Equivalent to operator+=().
 */
 
 /*!
     \fn QString& QString::append( char ch )
 
     \overload
 
     Appends character \a ch to the string and returns a reference to
     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 ) {
         return QString::null;
     } else {
         int length = 0;
         while( str[length] != 0 )
             length++;
         QChar* uc = QT_ALLOC_QCHAR_VEC( length );
         memcpy( uc, str, length*sizeof(QChar) );
         return QString( new QStringData( uc, length, length ), TRUE );
     }
 }
 
 /*!
   \fn QChar QString::at( uint ) const
 
     Returns the character at index \a i, or 0 if \a i is beyond the
     length of the string.
 
     \code
         const QString string( "abcdefgh" );
         QChar ch = string.at( 4 );
         // ch == 'e'
     \endcode
 
     If the QString is not const (i.e. const QString) or const& (i.e.
@@ -16938,174 +17064,194 @@ QString QString::fromUcs2( const unsigned short *str )
 
     The function returns a reference to the character at index \a i.
     The resulting reference can then be assigned to, or used
     immediately, but it will become invalid once further modifications
     are made to the original string.
 
     If \a i is beyond the length of the string then the string is
     expanded with QChar::null.
 */
 
 /*
   Internal chunk of code to handle the
   uncommon cases of at() above.
 */
 void QString::subat( uint i )
 {
     uint olen = d->len;
     if ( i >= olen ) {
         setLength( i+1 );               // i is index; i+1 is needed length
         for ( uint j=olen; j<=i; j++ )
             d->unicode[j] = QChar::null;
     } else {
         // Just be sure to detach
         real_detach();
     }
 }
 
 
 /*!
     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;
         default:
             break;
         }
         ++p;
     }
     return FALSE;
 }
 
 
 /*!
     \fn int QString::compare( const QString & s1, const QString & s2 )
 
     Lexically compares \a s1 with \a s2 and returns an integer less
     than, equal to, or greater than zero if \a s1 is less than, equal
     to, or greater than \a s2.
 
     The comparison is based exclusively on the numeric Unicode values
     of the characters and is very fast, but is not what a human would
     expect. Consider sorting user-interface strings with
     QString::localeAwareCompare().
 
     \code
         int a = QString::compare( "def", "abc" );   // a > 0
         int b = QString::compare( "abc", "def" );   // b < 0