Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

1 files changed, 1878 insertions, 0 deletions

diff --git a/src/corelib/codecs/qtextcodec.cpp b/src/corelib/codecs/qtextcodec.cpp
new file mode 100644
index 0000000000..3c3d39ed99
--- /dev/null
+++ b/src/corelib/codecs/qtextcodec.cpp
@@ -0,0 +1,1878 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformdefs.h"
+#include "qtextcodec.h"
+#include "qtextcodec_p.h"
+
+#ifndef QT_NO_TEXTCODEC
+
+#include "qlist.h"
+#include "qfile.h"
+#ifndef QT_NO_LIBRARY
+# include "qcoreapplication.h"
+# include "qtextcodecplugin.h"
+# include "private/qfactoryloader_p.h"
+#endif
+#include "qstringlist.h"
+
+#ifdef Q_OS_UNIX
+#  include "qiconvcodec_p.h"
+#endif
+
+#include "qutfcodec_p.h"
+#include "qsimplecodec_p.h"
+#include "qlatincodec_p.h"
+#ifndef QT_NO_CODECS
+#  include "qtsciicodec_p.h"
+#  include "qisciicodec_p.h"
+#if !defined(Q_OS_SYMBIAN) && !defined(Q_OS_INTEGRITY)
+#  if defined(QT_NO_ICONV) && !defined(QT_BOOTSTRAPPED)
+// no iconv(3) support, must build all codecs into the library
+#    include "../../plugins/codecs/cn/qgb18030codec.h"
+#    include "../../plugins/codecs/jp/qeucjpcodec.h"
+#    include "../../plugins/codecs/jp/qjiscodec.h"
+#    include "../../plugins/codecs/jp/qsjiscodec.h"
+#    include "../../plugins/codecs/kr/qeuckrcodec.h"
+#    include "../../plugins/codecs/tw/qbig5codec.h"
+#  endif // QT_NO_ICONV
+#  if defined(Q_WS_X11) && !defined(QT_BOOTSTRAPPED)
+#    include "qfontlaocodec_p.h"
+#    include "../../plugins/codecs/jp/qfontjpcodec.h"
+#  endif
+#endif // QT_NO_SYMBIAN
+#endif // QT_NO_CODECS
+#include "qlocale.h"
+#include "qmutex.h"
+#include "qhash.h"
+
+#include <stdlib.h>
+#include <ctype.h>
+#include <locale.h>
+#if defined (_XOPEN_UNIX) && !defined(Q_OS_QNX) && !defined(Q_OS_OSF)
+#include <langinfo.h>
+#endif
+
+#if defined(Q_OS_WINCE)
+#  define QT_NO_SETLOCALE
+#endif
+
+#ifdef Q_OS_SYMBIAN
+#include "qtextcodec_symbian.cpp"
+#endif
+
+
+// enabling this is not exception safe!
+// #define Q_DEBUG_TEXTCODEC
+
+QT_BEGIN_NAMESPACE
+
+#if !defined(QT_NO_LIBRARY) && !defined(QT_NO_TEXTCODECPLUGIN)
+Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,
+    (QTextCodecFactoryInterface_iid, QLatin1String("/codecs")))
+#endif
+
+//Cache for QTextCodec::codecForName and codecForMib.
+typedef QHash<QByteArray, QTextCodec *> QTextCodecCache;
+Q_GLOBAL_STATIC(QTextCodecCache, qTextCodecCache)
+
+
+static char qtolower(register char c)
+{ if (c >= 'A' && c <= 'Z') return c + 0x20; return c; }
+static bool qisalnum(register char c)
+{ return (c >= '0' && c <= '9') || ((c | 0x20) >= 'a' && (c | 0x20) <= 'z'); }
+
+static bool nameMatch(const QByteArray &name, const QByteArray &test)
+{
+    // if they're the same, return a perfect score
+    if (qstricmp(name, test) == 0)
+        return true;
+
+    const char *n = name.constData();
+    const char *h = test.constData();
+
+    // if the letters and numbers are the same, we have a match
+    while (*n != '\0') {
+        if (qisalnum(*n)) {
+            for (;;) {
+                if (*h == '\0')
+                    return false;
+                if (qisalnum(*h))
+                    break;
+                ++h;
+            }
+            if (qtolower(*n) != qtolower(*h))
+                return false;
+            ++h;
+        }
+        ++n;
+    }
+    while (*h && !qisalnum(*h))
+           ++h;
+    return (*h == '\0');
+}
+
+
+static QTextCodec *createForName(const QByteArray &name)
+{
+#if !defined(QT_NO_LIBRARY) && !defined(QT_NO_TEXTCODECPLUGIN)
+    QFactoryLoader *l = loader();
+    QStringList keys = l->keys();
+    for (int i = 0; i < keys.size(); ++i) {
+        if (nameMatch(name, keys.at(i).toLatin1())) {
+            QString realName = keys.at(i);
+            if (QTextCodecFactoryInterface *factory
+                = qobject_cast<QTextCodecFactoryInterface*>(l->instance(realName))) {
+                return factory->create(realName);
+            }
+        }
+    }
+#else
+    Q_UNUSED(name);
+#endif
+    return 0;
+}
+
+static QTextCodec *createForMib(int mib)
+{
+#ifndef QT_NO_TEXTCODECPLUGIN
+    QString name = QLatin1String("MIB: ") + QString::number(mib);
+    if (QTextCodecFactoryInterface *factory
+        = qobject_cast<QTextCodecFactoryInterface*>(loader()->instance(name)))
+        return factory->create(name);
+#else
+    Q_UNUSED(mib);
+#endif
+    return 0;
+}
+
+static QList<QTextCodec*> *all = 0;
+#ifdef Q_DEBUG_TEXTCODEC
+static bool destroying_is_ok = false;
+#endif
+
+static QTextCodec *localeMapper = 0;
+QTextCodec *QTextCodec::cftr = 0;
+
+
+class QTextCodecCleanup
+{
+public:
+    ~QTextCodecCleanup();
+};
+
+/*
+    Deletes all the created codecs. This destructor is called just
+    before exiting to delete any QTextCodec objects that may be lying
+    around.
+*/
+QTextCodecCleanup::~QTextCodecCleanup()
+{
+    if (!all)
+        return;
+
+#ifdef Q_DEBUG_TEXTCODEC
+    destroying_is_ok = true;
+#endif
+
+    for (QList<QTextCodec *>::const_iterator it = all->constBegin()
+            ; it != all->constEnd(); ++it) {
+        delete *it;
+    }
+    delete all;
+    all = 0;
+    localeMapper = 0;
+
+#ifdef Q_DEBUG_TEXTCODEC
+    destroying_is_ok = false;
+#endif
+}
+
+Q_GLOBAL_STATIC(QTextCodecCleanup, createQTextCodecCleanup)
+
+bool QTextCodec::validCodecs()
+{
+#ifdef Q_OS_SYMBIAN
+    // If we don't have a trap handler, we're outside of the main() function,
+    // ie. in global constructors or destructors. Don't use codecs in this
+    // case as it would lead to crashes because we don't have a cleanup stack on Symbian
+    return (User::TrapHandler() != NULL);
+#else
+    return true;
+#endif
+}
+
+
+#if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)
+class QWindowsLocalCodec: public QTextCodec
+{
+public:
+    QWindowsLocalCodec();
+    ~QWindowsLocalCodec();
+
+    QString convertToUnicode(const char *, int, ConverterState *) const;
+    QByteArray convertFromUnicode(const QChar *, int, ConverterState *) const;
+    QString convertToUnicodeCharByChar(const char *chars, int length, ConverterState *state) const;
+
+    QByteArray name() const;
+    int mibEnum() const;
+
+};
+
+QWindowsLocalCodec::QWindowsLocalCodec()
+{
+}
+
+QWindowsLocalCodec::~QWindowsLocalCodec()
+{
+}
+
+QString QWindowsLocalCodec::convertToUnicode(const char *chars, int length, ConverterState *state) const
+{
+    const char *mb = chars;
+    int mblen = length;
+
+    if (!mb || !mblen)
+        return QString();
+
+    const int wclen_auto = 4096;
+    wchar_t wc_auto[wclen_auto];
+    int wclen = wclen_auto;
+    wchar_t *wc = wc_auto;
+    int len;
+    QString sp;
+    bool prepend = false;
+    char state_data = 0;
+    int remainingChars = 0;
+
+    //save the current state information
+    if (state) {
+        state_data = (char)state->state_data[0];
+        remainingChars = state->remainingChars;
+    }
+
+    //convert the pending charcter (if available)
+    if (state && remainingChars) {
+        char prev[3] = {0};
+        prev[0] = state_data;
+        prev[1] = mb[0];
+        remainingChars = 0;
+        len = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
+                                    prev, 2, wc, wclen);
+        if (len) {
+            prepend = true;
+            sp.append(QChar(wc[0]));
+            mb++;
+            mblen--;
+            wc[0] = 0;
+        }
+    }
+
+    while (!(len=MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
+                mb, mblen, wc, wclen))) {
+        int r = GetLastError();
+        if (r == ERROR_INSUFFICIENT_BUFFER) {
+            if (wc != wc_auto) {
+                qWarning("MultiByteToWideChar: Size changed");
+                break;
+            } else {
+                wclen = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
+                                    mb, mblen, 0, 0);
+                wc = new wchar_t[wclen];
+                // and try again...
+            }
+        } else if (r == ERROR_NO_UNICODE_TRANSLATION) {
+            //find the last non NULL character
+            while (mblen > 1  && !(mb[mblen-1]))
+                mblen--;
+            //check whether,  we hit an invalid character in the middle
+            if ((mblen <= 1) || (remainingChars && state_data))
+                return convertToUnicodeCharByChar(chars, length, state);
+            //Remove the last character and try again...
+            state_data = mb[mblen-1];
+            remainingChars = 1;
+            mblen--;
+        } else {
+            // Fail.
+            qWarning("MultiByteToWideChar: Cannot convert multibyte text");
+            break;
+        }
+    }
+    if (len <= 0)
+        return QString();
+    if (wc[len-1] == 0) // len - 1: we don't want terminator
+        --len;
+
+    //save the new state information
+    if (state) {
+        state->state_data[0] = (char)state_data;
+        state->remainingChars = remainingChars;
+    }
+    QString s((QChar*)wc, len);
+    if (wc != wc_auto)
+        delete [] wc;
+    if (prepend) {
+        return sp+s;
+    }
+    return s;
+}
+
+QString QWindowsLocalCodec::convertToUnicodeCharByChar(const char *chars, int length, ConverterState *state) const
+{
+    if (!chars || !length)
+        return QString();
+
+    int copyLocation = 0;
+    int extra = 2;
+    if (state && state->remainingChars) {
+        copyLocation = state->remainingChars;
+        extra += copyLocation;
+    }
+    int newLength = length + extra;
+    char *mbcs = new char[newLength];
+    //ensure that we have a NULL terminated string
+    mbcs[newLength-1] = 0;
+    mbcs[newLength-2] = 0;
+    memcpy(&(mbcs[copyLocation]), chars, length);
+    if (copyLocation) {
+        //copy the last character from the state
+        mbcs[0] = (char)state->state_data[0];
+        state->remainingChars = 0;
+    }
+    const char *mb = mbcs;
+#ifndef Q_OS_WINCE
+    const char *next = 0;
+    QString s;
+    while((next = CharNextExA(CP_ACP, mb, 0)) != mb) {
+        wchar_t wc[2] ={0};
+        int charlength = next - mb;
+        int len = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS, mb, charlength, wc, 2);
+        if (len>0) {
+            s.append(QChar(wc[0]));
+        } else {
+            int r = GetLastError();
+            //check if the character being dropped is the last character
+            if (r == ERROR_NO_UNICODE_TRANSLATION && mb == (mbcs+newLength -3) && state) {
+                state->remainingChars = 1;
+                state->state_data[0] = (char)*mb;
+            }
+        }
+        mb = next;
+    }
+#else
+    QString s;
+    int size = mbstowcs(NULL, mb, length);
+    if (size < 0) {
+        Q_ASSERT("Error in CE TextCodec");
+        return QString();
+    }
+    wchar_t* ws = new wchar_t[size + 2];
+    ws[size +1] = 0;
+    ws[size] = 0;
+    size = mbstowcs(ws, mb, length);
+    for (int i=0; i< size; i++)
+        s.append(QChar(ws[i]));
+    delete [] ws;
+#endif
+    delete mbcs;
+    return s;
+}
+
+QByteArray QWindowsLocalCodec::convertFromUnicode(const QChar *ch, int uclen, ConverterState *) const
+{
+    if (!ch)
+        return QByteArray();
+    if (uclen == 0)
+        return QByteArray("");
+    BOOL used_def;
+    QByteArray mb(4096, 0);
+    int len;
+    while (!(len=WideCharToMultiByte(CP_ACP, 0, (const wchar_t*)ch, uclen,
+                mb.data(), mb.size()-1, 0, &used_def)))
+    {
+        int r = GetLastError();
+        if (r == ERROR_INSUFFICIENT_BUFFER) {
+            mb.resize(1+WideCharToMultiByte(CP_ACP, 0,
+                                (const wchar_t*)ch, uclen,
+                                0, 0, 0, &used_def));
+                // and try again...
+        } else {
+#ifndef QT_NO_DEBUG
+            // Fail.
+            qWarning("WideCharToMultiByte: Cannot convert multibyte text (error %d): %s (UTF-8)",
+                r, QString(ch, uclen).toLocal8Bit().data());
+#endif
+            break;
+        }
+    }
+    mb.resize(len);
+    return mb;
+}
+
+
+QByteArray QWindowsLocalCodec::name() const
+{
+    return "System";
+}
+
+int QWindowsLocalCodec::mibEnum() const
+{
+    return 0;
+}
+
+#else
+
+/* locale names mostly copied from XFree86 */
+static const char * const iso8859_2locales[] = {
+    "croatian", "cs", "cs_CS", "cs_CZ","cz", "cz_CZ", "czech", "hr",
+    "hr_HR", "hu", "hu_HU", "hungarian", "pl", "pl_PL", "polish", "ro",
+    "ro_RO", "rumanian", "serbocroatian", "sh", "sh_SP", "sh_YU", "sk",
+    "sk_SK", "sl", "sl_CS", "sl_SI", "slovak", "slovene", "sr_SP", 0 };
+
+static const char * const iso8859_3locales[] = {
+    "eo", 0 };
+
+static const char * const iso8859_4locales[] = {
+    "ee", "ee_EE", 0 };
+
+static const char * const iso8859_5locales[] = {
+    "mk", "mk_MK", "sp", "sp_YU", 0 };
+
+static const char * const cp_1251locales[] = {
+    "be", "be_BY", "bg", "bg_BG", "bulgarian", 0 };
+
+static const char * const pt_154locales[] = {
+    "ba_RU", "ky", "ky_KG", "kk", "kk_KZ", 0 };
+
+static const char * const iso8859_6locales[] = {
+    "ar_AA", "ar_SA", "arabic", 0 };
+
+static const char * const iso8859_7locales[] = {
+    "el", "el_GR", "greek", 0 };
+
+static const char * const iso8859_8locales[] = {
+    "hebrew", "he", "he_IL", "iw", "iw_IL", 0 };
+
+static const char * const iso8859_9locales[] = {
+    "tr", "tr_TR", "turkish", 0 };
+
+static const char * const iso8859_13locales[] = {
+    "lt", "lt_LT", "lv", "lv_LV", 0 };
+
+static const char * const iso8859_15locales[] = {
+    "et", "et_EE",
+    // Euro countries
+    "br_FR", "ca_ES", "de", "de_AT", "de_BE", "de_DE", "de_LU", "en_IE",
+    "es", "es_ES", "eu_ES", "fi", "fi_FI", "finnish", "fr", "fr_FR",
+    "fr_BE", "fr_LU", "french", "ga_IE", "gl_ES", "it", "it_IT", "oc_FR",
+    "nl", "nl_BE", "nl_NL", "pt", "pt_PT", "sv_FI", "wa_BE",
+    0 };
+
+static const char * const koi8_ulocales[] = {
+    "uk", "uk_UA", "ru_UA", "ukrainian", 0 };
+
+static const char * const tis_620locales[] = {
+    "th", "th_TH", "thai", 0 };
+
+// static const char * const tcvnlocales[] = {
+//     "vi", "vi_VN", 0 };
+
+static bool try_locale_list(const char * const locale[], const QByteArray &lang)
+{
+    int i;
+    for(i=0; locale[i] && lang != locale[i]; i++)
+        ;
+    return locale[i] != 0;
+}
+
+// For the probably_koi8_locales we have to look. the standard says
+// these are 8859-5, but almost all Russian users use KOI8-R and
+// incorrectly set $LANG to ru_RU. We'll check tolower() to see what
+// it thinks ru_RU means.
+
+// If you read the history, it seems that many Russians blame ISO and
+// Perestroika for the confusion.
+//
+// The real bug is that some programs break if the user specifies
+// ru_RU.KOI8-R.
+
+static const char * const probably_koi8_rlocales[] = {
+    "ru", "ru_SU", "ru_RU", "russian", 0 };
+
+static QTextCodec * ru_RU_hack(const char * i) {
+    QTextCodec * ru_RU_codec = 0;
+
+#if !defined(QT_NO_SETLOCALE)
+    QByteArray origlocale(setlocale(LC_CTYPE, i));
+#else
+    QByteArray origlocale(i);
+#endif
+    // unicode   koi8r   latin5   name
+    // 0x044E    0xC0    0xEE     CYRILLIC SMALL LETTER YU
+    // 0x042E    0xE0    0xCE     CYRILLIC CAPITAL LETTER YU
+    int latin5 = tolower(0xCE);
+    int koi8r = tolower(0xE0);
+    if (koi8r == 0xC0 && latin5 != 0xEE) {
+        ru_RU_codec = QTextCodec::codecForName("KOI8-R");
+    } else if (koi8r != 0xC0 && latin5 == 0xEE) {
+        ru_RU_codec = QTextCodec::codecForName("ISO 8859-5");
+    } else {
+        // something else again... let's assume... *throws dice*
+        ru_RU_codec = QTextCodec::codecForName("KOI8-R");
+        qWarning("QTextCodec: Using KOI8-R, probe failed (%02x %02x %s)",
+                  koi8r, latin5, i);
+    }
+#if !defined(QT_NO_SETLOCALE)
+    setlocale(LC_CTYPE, origlocale);
+#endif
+
+    return ru_RU_codec;
+}
+
+#endif
+
+#if !defined(Q_OS_WIN32) && !defined(Q_OS_WINCE)
+static QTextCodec *checkForCodec(const QByteArray &name) {
+    QTextCodec *c = QTextCodec::codecForName(name);
+    if (!c) {
+        const int index = name.indexOf('@');
+        if (index != -1) {
+            c = QTextCodec::codecForName(name.left(index));
+        }
+    }
+    return c;
+}
+#endif
+
+/* the next two functions are implicitely thread safe,
+   as they are only called by setup() which uses a mutex.
+*/
+static void setupLocaleMapper()
+{
+#ifdef Q_OS_SYMBIAN
+    localeMapper = QSymbianTextCodec::localeMapper;
+    if (localeMapper)
+        return;
+#endif
+
+#if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)
+    localeMapper = QTextCodec::codecForName("System");
+#else
+
+#ifndef QT_NO_ICONV
+    localeMapper = QTextCodec::codecForName("System");
+#endif
+
+#if defined (_XOPEN_UNIX) && !defined(Q_OS_QNX) && !defined(Q_OS_OSF)
+    if (!localeMapper) {
+        char *charset = nl_langinfo (CODESET);
+        if (charset)
+            localeMapper = QTextCodec::codecForName(charset);
+    }
+#endif
+
+    if (!localeMapper) {
+        // Very poorly defined and followed standards causes lots of
+        // code to try to get all the cases... This logic is
+        // duplicated in QIconvCodec, so if you change it here, change
+        // it there too.
+
+        // Try to determine locale codeset from locale name assigned to
+        // LC_CTYPE category.
+
+        // First part is getting that locale name.  First try setlocale() which
+        // definitely knows it, but since we cannot fully trust it, get ready
+        // to fall back to environment variables.
+#if !defined(QT_NO_SETLOCALE)
+        const QByteArray ctype = setlocale(LC_CTYPE, 0);
+#else
+        const QByteArray ctype;
+#endif
+
+        // Get the first nonempty value from $LC_ALL, $LC_CTYPE, and $LANG
+        // environment variables.
+        QByteArray lang = qgetenv("LC_ALL");
+        if (lang.isEmpty() || lang == "C") {
+            lang = qgetenv("LC_CTYPE");
+        }
+        if (lang.isEmpty() || lang == "C") {
+            lang = qgetenv("LANG");
+        }
+
+        // Now try these in order:
+        // 1. CODESET from ctype if it contains a .CODESET part (e.g. en_US.ISO8859-15)
+        // 2. CODESET from lang if it contains a .CODESET part
+        // 3. ctype (maybe the locale is named "ISO-8859-1" or something)
+        // 4. locale (ditto)
+        // 5. check for "@euro"
+        // 6. guess locale from ctype unless ctype is "C"
+        // 7. guess locale from lang
+
+        // 1. CODESET from ctype if it contains a .CODESET part (e.g. en_US.ISO8859-15)
+        int indexOfDot = ctype.indexOf('.');
+        if (indexOfDot != -1)
+            localeMapper = checkForCodec( ctype.mid(indexOfDot + 1) );
+
+        // 2. CODESET from lang if it contains a .CODESET part
+        if (!localeMapper) {
+            indexOfDot = lang.indexOf('.');
+            if (indexOfDot != -1)
+                localeMapper = checkForCodec( lang.mid(indexOfDot + 1) );
+        }
+
+        // 3. ctype (maybe the locale is named "ISO-8859-1" or something)
+        if (!localeMapper && !ctype.isEmpty() && ctype != "C")
+            localeMapper = checkForCodec(ctype);
+
+        // 4. locale (ditto)
+        if (!localeMapper && !lang.isEmpty())
+            localeMapper = checkForCodec(lang);
+
+        // 5. "@euro"
+        if ((!localeMapper && ctype.contains("@euro")) || lang.contains("@euro"))
+            localeMapper = checkForCodec("ISO 8859-15");
+
+        // 6. guess locale from ctype unless ctype is "C"
+        // 7. guess locale from lang
+        const QByteArray &try_by_name = (!ctype.isEmpty() && ctype != "C") ? lang : ctype;
+
+        // Now do the guessing.
+        if (!lang.isEmpty() && !localeMapper && !try_by_name.isEmpty()) {
+            if (try_locale_list(iso8859_15locales, lang))
+                localeMapper = QTextCodec::codecForName("ISO 8859-15");
+            else if (try_locale_list(iso8859_2locales, lang))
+                localeMapper = QTextCodec::codecForName("ISO 8859-2");
+            else if (try_locale_list(iso8859_3locales, lang))
+                localeMapper = QTextCodec::codecForName("ISO 8859-3");
+            else if (try_locale_list(iso8859_4locales, lang))
+                localeMapper = QTextCodec::codecForName("ISO 8859-4");
+            else if (try_locale_list(iso8859_5locales, lang))
+                localeMapper = QTextCodec::codecForName("ISO 8859-5");
+            else if (try_locale_list(iso8859_6locales, lang))
+                localeMapper = QTextCodec::codecForName("ISO 8859-6");
+            else if (try_locale_list(iso8859_7locales, lang))
+                localeMapper = QTextCodec::codecForName("ISO 8859-7");
+            else if (try_locale_list(iso8859_8locales, lang))
+                localeMapper = QTextCodec::codecForName("ISO 8859-8-I");
+            else if (try_locale_list(iso8859_9locales, lang))
+                localeMapper = QTextCodec::codecForName("ISO 8859-9");
+            else if (try_locale_list(iso8859_13locales, lang))
+                localeMapper = QTextCodec::codecForName("ISO 8859-13");
+            else if (try_locale_list(tis_620locales, lang))
+                localeMapper = QTextCodec::codecForName("ISO 8859-11");
+            else if (try_locale_list(koi8_ulocales, lang))
+                localeMapper = QTextCodec::codecForName("KOI8-U");
+            else if (try_locale_list(cp_1251locales, lang))
+                localeMapper = QTextCodec::codecForName("CP 1251");
+            else if (try_locale_list(pt_154locales, lang))
+                localeMapper = QTextCodec::codecForName("PT 154");
+            else if (try_locale_list(probably_koi8_rlocales, lang))
+                localeMapper = ru_RU_hack(lang);
+        }
+
+    }
+
+    // If everything failed, we default to 8859-1
+    // We could perhaps default to 8859-15.
+    if (!localeMapper)
+        localeMapper = QTextCodec::codecForName("ISO 8859-1");
+#endif
+}
+
+#ifndef QT_NO_THREAD
+Q_GLOBAL_STATIC_WITH_ARGS(QMutex, textCodecsMutex, (QMutex::Recursive));
+#endif
+
+// textCodecsMutex need to be locked to enter this function
+static void setup()
+{
+    if (all)
+        return;
+
+#ifdef Q_OS_SYMBIAN
+    // If we don't have a trap handler, we're outside of the main() function,
+    // ie. in global constructors or destructors. Don't create codecs in this
+    // case as it would lead to crashes because of a missing cleanup stack on Symbian
+    if (User::TrapHandler() == NULL)
+        return;
+#endif
+
+#ifdef Q_DEBUG_TEXTCODEC
+    if (destroying_is_ok)
+        qWarning("QTextCodec: Creating new codec during codec cleanup");
+#endif
+    all = new QList<QTextCodec*>;
+    // create the cleanup object to cleanup all codecs on exit
+    (void) createQTextCodecCleanup();
+
+#ifndef QT_NO_CODECS
+    (void)new QTsciiCodec;
+    for (int i = 0; i < 9; ++i)
+        (void)new QIsciiCodec(i);
+
+    for (int i = 0; i < QSimpleTextCodec::numSimpleCodecs; ++i)
+        (void)new QSimpleTextCodec(i);
+
+#ifdef Q_OS_SYMBIAN
+    localeMapper = QSymbianTextCodec::init();
+#endif
+
+#  if defined(Q_WS_X11) && !defined(QT_BOOTSTRAPPED)
+    // no font codecs when bootstrapping
+    (void)new QFontLaoCodec;
+#    if defined(QT_NO_ICONV)
+    // no iconv(3) support, must build all codecs into the library
+    (void)new QFontGb2312Codec;
+    (void)new QFontGbkCodec;
+    (void)new QFontGb18030_0Codec;
+    (void)new QFontJis0208Codec;
+    (void)new QFontJis0201Codec;
+    (void)new QFontKsc5601Codec;
+    (void)new QFontBig5hkscsCodec;
+    (void)new QFontBig5Codec;
+#    endif // QT_NO_ICONV && !QT_BOOTSTRAPPED
+#  endif // Q_WS_X11
+
+
+#if !defined(Q_OS_SYMBIAN) && !defined(Q_OS_INTEGRITY)
+#  if defined(QT_NO_ICONV) && !defined(QT_BOOTSTRAPPED)
+    // no asian codecs when bootstrapping, sorry
+    (void)new QGb18030Codec;
+    (void)new QGbkCodec;
+    (void)new QGb2312Codec;
+    (void)new QEucJpCodec;
+    (void)new QJisCodec;
+    (void)new QSjisCodec;
+    (void)new QEucKrCodec;
+    (void)new QCP949Codec;
+    (void)new QBig5Codec;
+    (void)new QBig5hkscsCodec;
+#  endif // QT_NO_ICONV && !QT_BOOTSTRAPPED
+#endif //Q_OS_SYMBIAN
+#endif // QT_NO_CODECS
+
+#if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)
+    (void) new QWindowsLocalCodec;
+#endif // Q_OS_WIN32
+
+    (void)new QUtf16Codec;
+    (void)new QUtf16BECodec;
+    (void)new QUtf16LECodec;
+    (void)new QUtf32Codec;
+    (void)new QUtf32BECodec;
+    (void)new QUtf32LECodec;
+#ifndef Q_OS_SYMBIAN
+    (void)new QLatin15Codec;
+#endif
+    (void)new QLatin1Codec;
+    (void)new QUtf8Codec;
+
+#if !defined(Q_OS_SYMBIAN) && !defined(Q_OS_INTEGRITY)
+#if defined(Q_OS_UNIX) && !defined(QT_NO_ICONV) && !defined(QT_BOOTSTRAPPED)
+    // QIconvCodec depends on the UTF-16 codec, so it needs to be created last
+    (void) new QIconvCodec();
+#endif
+#endif
+
+    if (!localeMapper)
+        setupLocaleMapper();
+}
+
+/*!
+    \enum QTextCodec::ConversionFlag
+
+    \value DefaultConversion  No flag is set.
+    \value ConvertInvalidToNull  If this flag is set, each invalid input
+                                 character is output as a null character.
+    \value IgnoreHeader  Ignore any Unicode byte-order mark and don't generate any.
+
+    \omitvalue FreeFunction
+*/
+
+/*!
+    \fn QTextCodec::ConverterState::ConverterState(ConversionFlags flags)
+
+    Constructs a ConverterState object initialized with the given \a flags.
+*/
+
+/*!
+    Destroys the ConverterState object.
+*/
+QTextCodec::ConverterState::~ConverterState()
+{
+    if (flags & FreeFunction)
+        (QTextCodecUnalignedPointer::decode(state_data))(this);
+    else if (d)
+        qFree(d);
+}
+
+/*!
+    \class QTextCodec
+    \brief The QTextCodec class provides conversions between text encodings.
+    \reentrant
+    \ingroup i18n
+
+    Qt uses Unicode to store, draw and manipulate strings. In many
+    situations you may wish to deal with data that uses a different
+    encoding. For example, most Japanese documents are still stored
+    in Shift-JIS or ISO 2022-JP, while Russian users often have their
+    documents in KOI8-R or Windows-1251.
+
+    Qt provides a set of QTextCodec classes to help with converting
+    non-Unicode formats to and from Unicode. You can also create your
+    own codec classes.
+
+    The supported encodings are:
+
+    \list
+    \o Apple Roman
+    \o \l{Big5 Text Codec}{Big5}
+    \o \l{Big5-HKSCS Text Codec}{Big5-HKSCS}
+    \o CP949
+    \o \l{EUC-JP Text Codec}{EUC-JP}
+    \o \l{EUC-KR Text Codec}{EUC-KR}
+    \o \l{GBK Text Codec}{GB18030-0}
+    \o IBM 850
+    \o IBM 866
+    \o IBM 874
+    \o \l{ISO 2022-JP (JIS) Text Codec}{ISO 2022-JP}
+    \o ISO 8859-1 to 10
+    \o ISO 8859-13 to 16
+    \o Iscii-Bng, Dev, Gjr, Knd, Mlm, Ori, Pnj, Tlg, and Tml
+    \o JIS X 0201
+    \o JIS X 0208
+    \o KOI8-R
+    \o KOI8-U
+    \o MuleLao-1
+    \o ROMAN8
+    \o \l{Shift-JIS Text Codec}{Shift-JIS}
+    \o TIS-620
+    \o \l{TSCII Text Codec}{TSCII}
+    \o UTF-8
+    \o UTF-16
+    \o UTF-16BE
+    \o UTF-16LE
+    \o UTF-32
+    \o UTF-32BE
+    \o UTF-32LE
+    \o Windows-1250 to 1258
+    \o WINSAMI2
+    \endlist
+
+    QTextCodecs can be used as follows to convert some locally encoded
+    string to Unicode. Suppose you have some string encoded in Russian
+    KOI8-R encoding, and want to convert it to Unicode. The simple way
+    to do it is like this:
+
+    \snippet doc/src/snippets/code/src_corelib_codecs_qtextcodec.cpp 0
+
+    After this, \c string holds the text converted to Unicode.
+    Converting a string from Unicode to the local encoding is just as
+    easy:
+
+    \snippet doc/src/snippets/code/src_corelib_codecs_qtextcodec.cpp 1
+
+    To read or write files in various encodings, use QTextStream and
+    its \l{QTextStream::setCodec()}{setCodec()} function. See the
+    \l{tools/codecs}{Codecs} example for an application of QTextCodec
+    to file I/O.
+
+    Some care must be taken when trying to convert the data in chunks,
+    for example, when receiving it over a network. In such cases it is
+    possible that a multi-byte character will be split over two
+    chunks. At best this might result in the loss of a character and
+    at worst cause the entire conversion to fail.
+
+    The approach to use in these situations is to create a QTextDecoder
+    object for the codec and use this QTextDecoder for the whole
+    decoding process, as shown below:
+
+    \snippet doc/src/snippets/code/src_corelib_codecs_qtextcodec.cpp 2
+
+    The QTextDecoder object maintains state between chunks and therefore
+    works correctly even if a multi-byte character is split between
+    chunks.
+
+    \section1 Creating Your Own Codec Class
+
+    Support for new text encodings can be added to Qt by creating
+    QTextCodec subclasses.
+
+    The pure virtual functions describe the encoder to the system and
+    the coder is used as required in the different text file formats
+    supported by QTextStream, and under X11, for the locale-specific
+    character input and output.
+
+    To add support for another encoding to Qt, make a subclass of
+    QTextCodec and implement the functions listed in the table below.
+
+    \table
+    \header \o Function \o Description
+
+    \row \o name()
+         \o Returns the official name for the encoding. If the
+            encoding is listed in the
+            \l{IANA character-sets encoding file}, the name
+            should be the preferred MIME name for the encoding.
+
+    \row \o aliases()
+         \o Returns a list of alternative names for the encoding.
+            QTextCodec provides a default implementation that returns
+            an empty list. For example, "ISO-8859-1" has "latin1",
+            "CP819", "IBM819", and "iso-ir-100" as aliases.
+
+    \row \o mibEnum()
+         \o Return the MIB enum for the encoding if it is listed in
+            the \l{IANA character-sets encoding file}.
+
+    \row \o convertToUnicode()
+         \o Converts an 8-bit character string to Unicode.
+
+    \row \o convertFromUnicode()
+         \o Converts a Unicode string to an 8-bit character string.
+    \endtable
+
+    You may find it more convenient to make your codec class
+    available as a plugin; see \l{How to Create Qt Plugins} for
+    details.
+
+    \sa QTextStream, QTextDecoder, QTextEncoder, {Codecs Example}
+*/
+
+/*!
+    Constructs a QTextCodec, and gives it the highest precedence. The
+    QTextCodec should always be constructed on the heap (i.e. with \c
+    new). Qt takes ownership and will delete it when the application
+    terminates.
+*/
+QTextCodec::QTextCodec()
+{
+#ifndef QT_NO_THREAD
+    QMutexLocker locker(textCodecsMutex());
+#endif
+    setup();
+    all->prepend(this);
+}
+
+
+/*!
+    \nonreentrant
+
+    Destroys the QTextCodec. Note that you should not delete codecs
+    yourself: once created they become Qt's responsibility.
+*/
+QTextCodec::~QTextCodec()
+{
+#ifdef Q_DEBUG_TEXTCODEC
+    if (!destroying_is_ok)
+        qWarning("QTextCodec::~QTextCodec: Called by application");
+#endif
+    if (all) {
+#ifndef QT_NO_THREAD
+        QMutexLocker locker(textCodecsMutex());
+#endif
+        all->removeAll(this);
+        QTextCodecCache *cache = qTextCodecCache();
+        if (cache)
+            cache->clear();
+    }
+}
+
+/*!
+    \fn QTextCodec *QTextCodec::codecForName(const char *name)
+
+    Searches all installed QTextCodec objects and returns the one
+    which best matches \a name; the match is case-insensitive. Returns
+    0 if no codec matching the name \a name could be found.
+*/
+
+/*!
+    Searches all installed QTextCodec objects and returns the one
+    which best matches \a name; the match is case-insensitive. Returns
+    0 if no codec matching the name \a name could be found.
+*/
+QTextCodec *QTextCodec::codecForName(const QByteArray &name)
+{
+    if (name.isEmpty())
+        return 0;
+
+#ifndef QT_NO_THREAD
+    QMutexLocker locker(textCodecsMutex());
+#endif
+    setup();
+
+    if (!validCodecs())
+        return 0;
+
+    QTextCodecCache *cache = qTextCodecCache();
+    QTextCodec *codec;
+    if (cache) {
+        codec = cache->value(name);
+        if (codec)
+            return codec;
+    }
+
+    for (int i = 0; i < all->size(); ++i) {
+        QTextCodec *cursor = all->at(i);
+        if (nameMatch(cursor->name(), name)) {
+            if (cache)
+                cache->insert(name, cursor);
+            return cursor;
+        }
+        QList<QByteArray> aliases = cursor->aliases();
+        for (int y = 0; y < aliases.size(); ++y)
+            if (nameMatch(aliases.at(y), name)) {
+                if (cache)
+                    cache->insert(name, cursor);
+                return cursor;
+            }
+    }
+
+    codec = createForName(name);
+    if (codec && cache)
+        cache->insert(name, codec);
+    return codec;
+}
+
+
+/*!
+    Returns the QTextCodec which matches the \link
+    QTextCodec::mibEnum() MIBenum\endlink \a mib.
+*/
+QTextCodec* QTextCodec::codecForMib(int mib)
+{
+#ifndef QT_NO_THREAD
+    QMutexLocker locker(textCodecsMutex());
+#endif
+    setup();
+
+    if (!validCodecs())
+        return 0;
+
+    QByteArray key = "MIB: " + QByteArray::number(mib);
+    QTextCodecCache *cache = qTextCodecCache();
+    QTextCodec *codec;
+    if (cache) {
+        codec = cache->value(key);
+        if (codec)
+            return codec;
+    }
+
+    QList<QTextCodec*>::ConstIterator i;
+    for (int i = 0; i < all->size(); ++i) {
+        QTextCodec *cursor = all->at(i);
+        if (cursor->mibEnum() == mib) {
+            if (cache)
+                cache->insert(key, cursor);
+            return cursor;
+        }
+    }
+
+    codec = createForMib(mib);
+
+    // Qt 3 used 1000 (mib for UCS2) as its identifier for the utf16 codec. Map
+    // this correctly for compatibility.
+    if (!codec && mib == 1000)
+        return codecForMib(1015);
+
+    if (codec && cache)
+        cache->insert(key, codec);
+    return codec;
+}
+
+/*!
+    Returns the list of all available codecs, by name. Call
+    QTextCodec::codecForName() to obtain the QTextCodec for the name.
+
+    The list may contain many mentions of the same codec
+    if the codec has aliases.
+
+    \sa availableMibs(), name(), aliases()
+*/
+QList<QByteArray> QTextCodec::availableCodecs()
+{
+#ifndef QT_NO_THREAD
+    QMutexLocker locker(textCodecsMutex());
+#endif
+    setup();
+
+    QList<QByteArray> codecs;
+
+    if (!validCodecs())
+        return codecs;
+
+    for (int i = 0; i < all->size(); ++i) {
+        codecs += all->at(i)->name();
+        codecs += all->at(i)->aliases();
+    }
+
+#ifndef QT_NO_THREAD
+    locker.unlock();
+#endif
+
+#if !defined(QT_NO_LIBRARY) && !defined(QT_NO_TEXTCODECPLUGIN)
+    QFactoryLoader *l = loader();
+    QStringList keys = l->keys();
+    for (int i = 0; i < keys.size(); ++i) {
+        if (!keys.at(i).startsWith(QLatin1String("MIB: "))) {
+            QByteArray name = keys.at(i).toLatin1();
+            if (!codecs.contains(name))
+                codecs += name;
+        }
+    }
+#endif
+
+    return codecs;
+}
+
+/*!
+    Returns the list of MIBs for all available codecs. Call
+    QTextCodec::codecForMib() to obtain the QTextCodec for the MIB.
+
+    \sa availableCodecs(), mibEnum()
+*/
+QList<int> QTextCodec::availableMibs()
+{
+#ifndef QT_NO_THREAD
+    QMutexLocker locker(textCodecsMutex());
+#endif
+    setup();
+
+    QList<int> codecs;
+
+    if (!validCodecs())
+        return codecs;
+
+    for (int i = 0; i < all->size(); ++i)
+        codecs += all->at(i)->mibEnum();
+
+#ifndef QT_NO_THREAD
+    locker.unlock();
+#endif
+
+#if !defined(QT_NO_LIBRARY) && !defined(QT_NO_TEXTCODECPLUGIN)
+    QFactoryLoader *l = loader();
+    QStringList keys = l->keys();
+    for (int i = 0; i < keys.size(); ++i) {
+        if (keys.at(i).startsWith(QLatin1String("MIB: "))) {
+            int mib = keys.at(i).mid(5).toInt();
+            if (!codecs.contains(mib))
+                codecs += mib;
+        }
+    }
+#endif
+
+    return codecs;
+}
+
+/*!
+    Set the codec to \a c; this will be returned by
+    codecForLocale(). If \a c is a null pointer, the codec is reset to
+    the default.
+
+    This might be needed for some applications that want to use their
+    own mechanism for setting the locale.
+
+    \sa codecForLocale()
+*/
+void QTextCodec::setCodecForLocale(QTextCodec *c)
+{
+#ifndef QT_NO_THREAD
+    QMutexLocker locker(textCodecsMutex());
+#endif
+    localeMapper = c;
+    if (!localeMapper)
+        setupLocaleMapper();
+}
+
+/*!
+    Returns a pointer to the codec most suitable for this locale.
+
+    On Windows, the codec will be based on a system locale. On Unix
+    systems, starting with Qt 4.2, the codec will be using the \e
+    iconv library. Note that in both cases the codec's name will be
+    "System".
+*/
+
+QTextCodec* QTextCodec::codecForLocale()
+{
+    if (!validCodecs())
+        return 0;
+
+    if (localeMapper)
+        return localeMapper;
+
+#ifndef QT_NO_THREAD
+    QMutexLocker locker(textCodecsMutex());
+#endif
+    setup();
+
+    return localeMapper;
+}
+
+
+/*!
+    \fn QByteArray QTextCodec::name() const
+
+    QTextCodec subclasses must reimplement this function. It returns
+    the name of the encoding supported by the subclass.
+
+    If the codec is registered as a character set in the
+    \l{IANA character-sets encoding file} this method should
+    return the preferred mime name for the codec if defined,
+    otherwise its name.
+*/
+
+/*!
+    \fn int QTextCodec::mibEnum() const
+
+    Subclasses of QTextCodec must reimplement this function. It
+    returns the MIBenum (see \l{IANA character-sets encoding file}
+    for more information). It is important that each QTextCodec
+    subclass returns the correct unique value for this function.
+*/
+
+/*!
+  Subclasses can return a number of aliases for the codec in question.
+
+  Standard aliases for codecs can be found in the
+  \l{IANA character-sets encoding file}.
+*/
+QList<QByteArray> QTextCodec::aliases() const
+{
+    return QList<QByteArray>();
+}
+
+/*!
+    \fn QString QTextCodec::convertToUnicode(const char *chars, int len,
+                                             ConverterState *state) const
+
+    QTextCodec subclasses must reimplement this function.
+
+    Converts the first \a len characters of \a chars from the
+    encoding of the subclass to Unicode, and returns the result in a
+    QString.
+
+    \a state can be 0, in which case the conversion is stateless and
+    default conversion rules should be used. If state is not 0, the
+    codec should save the state after the conversion in \a state, and
+    adjust the remainingChars and invalidChars members of the struct.
+*/
+
+/*!
+    \fn QByteArray QTextCodec::convertFromUnicode(const QChar *input, int number,
+                                                  ConverterState *state) const
+
+    QTextCodec subclasses must reimplement this function.
+
+    Converts the first \a number of characters from the \a input array
+    from Unicode to the encoding of the subclass, and returns the result
+    in a QByteArray.
+
+    \a state can be 0 in which case the conversion is stateless and
+    default conversion rules should be used. If state is not 0, the
+    codec should save the state after the conversion in \a state, and
+    adjust the remainingChars and invalidChars members of the struct.
+*/
+
+/*!
+    Creates a QTextDecoder which stores enough state to decode chunks
+    of \c{char *} data to create chunks of Unicode data.
+
+    The caller is responsible for deleting the returned object.
+*/
+QTextDecoder* QTextCodec::makeDecoder() const
+{
+    return new QTextDecoder(this);
+}
+
+/*!
+    Creates a QTextDecoder with a specified \a flags to decode chunks
+    of \c{char *} data to create chunks of Unicode data.
+
+    The caller is responsible for deleting the returned object.
+
+    \since 4.7
+*/
+QTextDecoder* QTextCodec::makeDecoder(QTextCodec::ConversionFlags flags) const
+{
+    return new QTextDecoder(this, flags);
+}
+
+
+/*!
+    Creates a QTextEncoder which stores enough state to encode chunks
+    of Unicode data as \c{char *} data.
+
+    The caller is responsible for deleting the returned object.
+*/
+QTextEncoder* QTextCodec::makeEncoder() const
+{
+    return new QTextEncoder(this);
+}
+
+/*!
+    Creates a QTextEncoder with a specified \a flags to encode chunks
+    of Unicode data as \c{char *} data.
+
+    The caller is responsible for deleting the returned object.
+
+    \since 4.7
+*/
+QTextEncoder* QTextCodec::makeEncoder(QTextCodec::ConversionFlags flags) const
+{
+    return new QTextEncoder(this, flags);
+}
+
+/*!
+    \fn QByteArray QTextCodec::fromUnicode(const QChar *input, int number,
+                                           ConverterState *state) const
+
+    Converts the first \a number of characters from the \a input array
+    from Unicode to the encoding of this codec, and returns the result
+    in a QByteArray.
+
+    The \a state of the convertor used is updated.
+*/
+
+/*!
+    Converts \a str from Unicode to the encoding of this codec, and
+    returns the result in a QByteArray.
+*/
+QByteArray QTextCodec::fromUnicode(const QString& str) const
+{
+    return convertFromUnicode(str.constData(), str.length(), 0);
+}
+
+/*!
+    \fn QString QTextCodec::toUnicode(const char *input, int size,
+                                      ConverterState *state) const
+
+    Converts the first \a size characters from the \a input from the
+    encoding of this codec to Unicode, and returns the result in a
+    QString.
+
+    The \a state of the convertor used is updated.
+*/
+
+/*!
+    Converts \a a from the encoding of this codec to Unicode, and
+    returns the result in a QString.
+*/
+QString QTextCodec::toUnicode(const QByteArray& a) const
+{
+    return convertToUnicode(a.constData(), a.length(), 0);
+}
+
+/*!
+    Returns true if the Unicode character \a ch can be fully encoded
+    with this codec; otherwise returns false.
+*/
+bool QTextCodec::canEncode(QChar ch) const
+{
+    ConverterState state;
+    state.flags = ConvertInvalidToNull;
+    convertFromUnicode(&ch, 1, &state);
+    return (state.invalidChars == 0);
+}
+
+/*!
+    \overload
+
+    \a s contains the string being tested for encode-ability.
+*/
+bool QTextCodec::canEncode(const QString& s) const
+{
+    ConverterState state;
+    state.flags = ConvertInvalidToNull;
+    convertFromUnicode(s.constData(), s.length(), &state);
+    return (state.invalidChars == 0);
+}
+
+#ifdef QT3_SUPPORT
+/*!
+    Returns a string representing the current language and
+    sublanguage, e.g. "pt" for Portuguese, or "pt_br" for Portuguese/Brazil.
+
+    \sa QLocale
+*/
+const char *QTextCodec::locale()
+{
+    static char locale[6];
+    QByteArray l = QLocale::system().name().toLatin1();
+    int len = qMin(l.length(), 5);
+    memcpy(locale, l.constData(), len);
+    locale[len] = '\0';
+
+    return locale;
+}
+
+/*!
+    \overload
+*/
+
+QByteArray QTextCodec::fromUnicode(const QString& uc, int& lenInOut) const
+{
+    QByteArray result = convertFromUnicode(uc.constData(), lenInOut, 0);
+    lenInOut = result.length();
+    return result;
+}
+
+/*!
+    \overload
+
+    \a a contains the source characters; \a len contains the number of
+    characters in \a a to use.
+*/
+QString QTextCodec::toUnicode(const QByteArray& a, int len) const
+{
+    len = qMin(a.size(), len);
+    return convertToUnicode(a.constData(), len, 0);
+}
+#endif
+
+/*!
+    \overload
+
+    \a chars contains the source characters.
+*/
+QString QTextCodec::toUnicode(const char *chars) const
+{
+    int len = qstrlen(chars);
+    return convertToUnicode(chars, len, 0);
+}
+
+
+/*!
+    \class QTextEncoder
+    \brief The QTextEncoder class provides a state-based encoder.
+    \reentrant
+    \ingroup i18n
+
+    A text encoder converts text from Unicode into an encoded text format
+    using a specific codec.
+
+    The encoder converts Unicode into another format, remembering any
+    state that is required between calls.
+
+    \sa QTextCodec::makeEncoder(), QTextDecoder
+*/
+
+/*!
+    \fn QTextEncoder::QTextEncoder(const QTextCodec *codec)
+
+    Constructs a text encoder for the given \a codec.
+*/
+
+/*!
+    Constructs a text encoder for the given \a codec and conversion \a flags.
+
+    \since 4.7
+*/
+QTextEncoder::QTextEncoder(const QTextCodec *codec, QTextCodec::ConversionFlags flags)
+    : c(codec), state()
+{
+    state.flags = flags;
+}
+
+/*!
+    Destroys the encoder.
+*/
+QTextEncoder::~QTextEncoder()
+{
+}
+
+/*! \internal
+    \since 4.5
+    Determines whether the eecoder encountered a failure while decoding the input. If
+    an error was encountered, the produced result is undefined, and gets converted as according
+    to the conversion flags.
+ */
+bool QTextEncoder::hasFailure() const
+{
+    return state.invalidChars != 0;
+}
+
+/*!
+    Converts the Unicode string \a str into an encoded QByteArray.
+*/
+QByteArray QTextEncoder::fromUnicode(const QString& str)
+{
+    QByteArray result = c->fromUnicode(str.constData(), str.length(), &state);
+    return result;
+}
+
+/*!
+    \overload
+
+    Converts \a len characters (not bytes) from \a uc, and returns the
+    result in a QByteArray.
+*/
+QByteArray QTextEncoder::fromUnicode(const QChar *uc, int len)
+{
+    QByteArray result = c->fromUnicode(uc, len, &state);
+    return result;
+}
+
+#ifdef QT3_SUPPORT
+/*!
+  \overload
+
+  Converts \a lenInOut characters (not bytes) from \a uc, and returns the
+  result in a QByteArray. The number of characters read is returned in
+  the \a lenInOut parameter.
+*/
+QByteArray QTextEncoder::fromUnicode(const QString& uc, int& lenInOut)
+{
+    QByteArray result = c->fromUnicode(uc.constData(), lenInOut, &state);
+    lenInOut = result.length();
+    return result;
+}
+#endif
+
+/*!
+    \class QTextDecoder
+    \brief The QTextDecoder class provides a state-based decoder.
+    \reentrant
+    \ingroup i18n
+
+    A text decoder converts text from an encoded text format into Unicode
+    using a specific codec.
+
+    The decoder converts text in this format into Unicode, remembering any
+    state that is required between calls.
+
+    \sa QTextCodec::makeDecoder(), QTextEncoder
+*/
+
+/*!
+    \fn QTextDecoder::QTextDecoder(const QTextCodec *codec)
+
+    Constructs a text decoder for the given \a codec.
+*/
+
+/*!
+    Constructs a text decoder for the given \a codec and conversion \a flags.
+
+    \since 4.7
+*/
+
+QTextDecoder::QTextDecoder(const QTextCodec *codec, QTextCodec::ConversionFlags flags)
+    : c(codec), state()
+{
+    state.flags = flags;
+}
+
+/*!
+    Destroys the decoder.
+*/
+QTextDecoder::~QTextDecoder()
+{
+}
+
+/*!
+    \fn QString QTextDecoder::toUnicode(const char *chars, int len)
+
+    Converts the first \a len bytes in \a chars to Unicode, returning
+    the result.
+
+    If not all characters are used (e.g. if only part of a multi-byte
+    encoding is at the end of the characters), the decoder remembers
+    enough state to continue with the next call to this function.
+*/
+QString QTextDecoder::toUnicode(const char *chars, int len)
+{
+    return c->toUnicode(chars, len, &state);
+}
+
+
+/*! \overload
+
+    The converted string is returned in \a target.
+ */
+void QTextDecoder::toUnicode(QString *target, const char *chars, int len)
+{
+    Q_ASSERT(target);
+    switch (c->mibEnum()) {
+    case 106: // utf8
+        static_cast<const QUtf8Codec*>(c)->convertToUnicode(target, chars, len, &state);
+        break;
+    case 4: { // latin1
+        target->resize(len);
+        ushort *data = (ushort*)target->data();
+        for (int i = len; i >=0; --i)
+            data[i] = (uchar) chars[i];
+    } break;
+    default:
+        *target = c->toUnicode(chars, len, &state);
+    }
+}
+
+
+/*!
+    \overload
+
+    Converts the bytes in the byte array specified by \a ba to Unicode
+    and returns the result.
+*/
+QString QTextDecoder::toUnicode(const QByteArray &ba)
+{
+    return c->toUnicode(ba.constData(), ba.length(), &state);
+}
+
+
+/*!
+    \fn QTextCodec* QTextCodec::codecForTr()
+
+    Returns the codec used by QObject::tr() on its argument. If this
+    function returns 0 (the default), tr() assumes Latin-1.
+
+    \sa setCodecForTr()
+*/
+
+/*!
+    \fn void QTextCodec::setCodecForTr(QTextCodec *c)
+    \nonreentrant
+
+    Sets the codec used by QObject::tr() on its argument to \a c. If
+    \a c is 0 (the default), tr() assumes Latin-1.
+
+    If the literal quoted text in the program is not in the Latin-1
+    encoding, this function can be used to set the appropriate
+    encoding. For example, software developed by Korean programmers
+    might use eucKR for all the text in the program, in which case the
+    main() function might look like this:
+
+    \snippet doc/src/snippets/code/src_corelib_codecs_qtextcodec.cpp 3
+
+    Note that this is not the way to select the encoding that the \e
+    user has chosen. For example, to convert an application containing
+    literal English strings to Korean, all that is needed is for the
+    English strings to be passed through tr() and for translation
+    files to be loaded. For details of internationalization, see
+    \l{Internationalization with Qt}.
+
+    \sa codecForTr(), setCodecForCStrings()
+*/
+
+
+/*!
+    \fn QTextCodec* QTextCodec::codecForCStrings()
+
+    Returns the codec used by QString to convert to and from \c{const
+    char *} and QByteArrays. If this function returns 0 (the default),
+    QString assumes Latin-1.
+
+    \sa setCodecForCStrings()
+*/
+
+/*!
+    \fn void QTextCodec::setCodecForCStrings(QTextCodec *codec)
+    \nonreentrant
+
+    Sets the codec used by QString to convert to and from \c{const
+    char *} and QByteArrays. If the \a codec is 0 (the default),
+    QString assumes Latin-1.
+
+    \warning Some codecs do not preserve the characters in the ASCII
+    range (0x00 to 0x7F). For example, the Japanese Shift-JIS
+    encoding maps the backslash character (0x5A) to the Yen
+    character. To avoid undesirable side-effects, we recommend
+    avoiding such codecs with setCodecsForCString().
+
+    \sa codecForCStrings(), setCodecForTr()
+*/
+
+/*!
+    \since 4.4
+
+    Tries to detect the encoding of the provided snippet of HTML in
+    the given byte array, \a ba, by checking the BOM (Byte Order Mark)
+    and the content-type meta header and returns a QTextCodec instance
+    that is capable of decoding the html to unicode.  If the codec
+    cannot be detected from the content provided, \a defaultCodec is
+    returned.
+
+    \sa codecForUtfText()
+*/
+QTextCodec *QTextCodec::codecForHtml(const QByteArray &ba, QTextCodec *defaultCodec)
+{
+    // determine charset
+    int pos;
+    QTextCodec *c = 0;
+
+    c = QTextCodec::codecForUtfText(ba, c);
+    if (!c) {
+        QByteArray header = ba.left(512).toLower();
+        if ((pos = header.indexOf("http-equiv=")) != -1) {
+            if ((pos = header.lastIndexOf("meta ", pos)) != -1) {
+                pos = header.indexOf("charset=", pos) + int(strlen("charset="));
+                if (pos != -1) {
+                    int pos2 = header.indexOf('\"', pos+1);
+                    QByteArray cs = header.mid(pos, pos2-pos);
+                    //            qDebug("found charset: %s", cs.data());
+                    c = QTextCodec::codecForName(cs);
+                }
+            }
+        }
+    }
+    if (!c)
+        c = defaultCodec;
+
+    return c;
+}
+
+/*!
+    \overload
+
+    Tries to detect the encoding of the provided snippet of HTML in
+    the given byte array, \a ba, by checking the BOM (Byte Order Mark)
+    and the content-type meta header and returns a QTextCodec instance
+    that is capable of decoding the html to unicode. If the codec cannot
+    be detected, this overload returns a Latin-1 QTextCodec.
+*/
+QTextCodec *QTextCodec::codecForHtml(const QByteArray &ba)
+{
+    return codecForHtml(ba, QTextCodec::codecForMib(/*Latin 1*/ 4));
+}
+
+/*!
+    \since 4.6
+
+    Tries to detect the encoding of the provided snippet \a ba by
+    using the BOM (Byte Order Mark) and returns a QTextCodec instance
+    that is capable of decoding the text to unicode. If the codec
+    cannot be detected from the content provided, \a defaultCodec is
+    returned.
+
+    \sa codecForHtml()
+*/
+QTextCodec *QTextCodec::codecForUtfText(const QByteArray &ba, QTextCodec *defaultCodec)
+{
+    const int arraySize = ba.size();
+
+    if (arraySize > 3) {
+        if ((uchar)ba[0] == 0x00
+            && (uchar)ba[1] == 0x00
+            && (uchar)ba[2] == 0xFE
+            && (uchar)ba[3] == 0xFF)
+            return QTextCodec::codecForMib(1018); // utf-32 be
+        else if ((uchar)ba[0] == 0xFF
+                 && (uchar)ba[1] == 0xFE
+                 && (uchar)ba[2] == 0x00
+                 && (uchar)ba[3] == 0x00)
+            return QTextCodec::codecForMib(1019); // utf-32 le
+    }
+
+    if (arraySize < 2)
+        return defaultCodec;
+    if ((uchar)ba[0] == 0xfe && (uchar)ba[1] == 0xff)
+        return QTextCodec::codecForMib(1013); // utf16 be
+    else if ((uchar)ba[0] == 0xff && (uchar)ba[1] == 0xfe)
+        return QTextCodec::codecForMib(1014); // utf16 le
+
+    if (arraySize < 3)
+        return defaultCodec;
+    if ((uchar)ba[0] == 0xef
+        && (uchar)ba[1] == 0xbb
+        && (uchar)ba[2] == 0xbf)
+        return QTextCodec::codecForMib(106); // utf-8
+
+    return defaultCodec;
+}
+
+/*!
+    \overload
+
+    Tries to detect the encoding of the provided snippet \a ba by
+    using the BOM (Byte Order Mark) and returns a QTextCodec instance
+    that is capable of decoding the text to unicode. If the codec
+    cannot be detected, this overload returns a Latin-1 QTextCodec.
+
+    \sa codecForHtml()
+*/
+QTextCodec *QTextCodec::codecForUtfText(const QByteArray &ba)
+{
+    return codecForUtfText(ba, QTextCodec::codecForMib(/*Latin 1*/ 4));
+}
+
+
+/*! \internal
+    \since 4.3
+    Determines whether the decoder encountered a failure while decoding the input. If
+    an error was encountered, the produced result is undefined, and gets converted as according
+    to the conversion flags.
+ */
+bool QTextDecoder::hasFailure() const
+{
+    return state.invalidChars != 0;
+}
+
+/*!
+    \fn QTextCodec *QTextCodec::codecForContent(const char *str, int size)
+
+    This functionality is no longer provided by Qt. This
+    compatibility function always returns a null pointer.
+*/
+
+/*!
+    \fn QTextCodec *QTextCodec::codecForName(const char *hint, int accuracy)
+
+    Use the codecForName(const QByteArray &) overload instead.
+*/
+
+/*!
+    \fn QTextCodec *QTextCodec::codecForIndex(int i)
+
+    Use availableCodecs() or availableMibs() instead and iterate
+    through the resulting list.
+*/
+
+
+/*!
+    \fn QByteArray QTextCodec::mimeName() const
+
+    Use name() instead.
+*/
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_TEXTCODEC