/****************************************************************************

**

** Copyright (C) 2010 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"

#ifndef Q_OS_SYMBIAN

#  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

#ifndef QT_NO_TEXTCODECPLUGIN

Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,

    (QTextCodecFactoryInterface_iid, QLatin1String("/codecs")))

#endif

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)

{

#ifndef 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;

static int clearCaches = 0;  // flags specifying if caches should be invalided: 0x1 codecForName, 0x2 codecForMib

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

#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 *uc, int len, ConverterState *) const

{

    return qt_winQString2MB(uc, len);

}

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