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

**

** 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 "qglobal.h"

#ifndef QT_NO_SYSTEMLOCALE

QT_BEGIN_NAMESPACE

class QSystemLocale;

static QSystemLocale *QSystemLocale_globalSystemLocale();

QT_END_NAMESPACE

#endif

#include "qplatformdefs.h"

#include "qdatastream.h"

#include "qstring.h"

#include "qlocale.h"

#include "qlocale_p.h"

#include "qdatetime_p.h"

#include "qnamespace.h"

#include "qdatetime.h"

#include "qstringlist.h"

#include "qvariant.h"

#if defined(Q_WS_WIN)

#   include "qt_windows.h"

#   include <time.h>

#endif

#if !defined(QWS) && defined(Q_OS_MAC)

#   include "private/qcore_mac_p.h"

#   include <CoreFoundation/CoreFoundation.h>

#endif

#include "private/qnumeric_p.h"

#include <ctype.h>

#include <float.h>

#include <limits.h>

#include <math.h>

#include <stdlib.h>

#include <qdebug.h>

#include <time.h>

#if defined(Q_OS_LINUX) && !defined(__UCLIBC__)

#    include <fenv.h>

#endif

#if !defined(QT_QLOCALE_NEEDS_VOLATILE)

#  if defined(Q_CC_GNU)

#    if  __GNUC__ == 4

#      define QT_QLOCALE_NEEDS_VOLATILE

#    elif defined(Q_OS_WIN)

#      define QT_QLOCALE_NEEDS_VOLATILE

#    endif

#  endif

#endif

#if defined(QT_QLOCALE_NEEDS_VOLATILE)

#   define NEEDS_VOLATILE volatile

#else

#   define NEEDS_VOLATILE

#endif

// Sizes as defined by the ISO C99 standard - fallback

#ifndef LLONG_MAX

#   define LLONG_MAX Q_INT64_C(0x7fffffffffffffff)

#endif

#ifndef LLONG_MIN

#   define LLONG_MIN (-LLONG_MAX - Q_INT64_C(1))

#endif

#ifndef ULLONG_MAX

#   define ULLONG_MAX Q_UINT64_C(0xffffffffffffffff)

#endif

#define CONVERSION_BUFF_SIZE 255

QT_BEGIN_NAMESPACE

#ifndef QT_QLOCALE_USES_FCVT

static char *_qdtoa( NEEDS_VOLATILE double d, int mode, int ndigits, int *decpt,

                        int *sign, char **rve, char **digits_str);

#endif

Q_CORE_EXPORT char *qdtoa(double d, int mode, int ndigits, int *decpt,

                        int *sign, char **rve, char **digits_str);

Q_CORE_EXPORT double qstrtod(const char *s00, char const **se, bool *ok);

static qlonglong qstrtoll(const char *nptr, const char **endptr, register int base, bool *ok);

static qulonglong qstrtoull(const char *nptr, const char **endptr, register int base, bool *ok);

#if defined(Q_CC_MWERKS) && defined(Q_OS_WIN32)

inline bool isascii(int c)

{

        return (c >= 0 && c <=127);

}

#endif

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

** Helpers for accessing Qt locale database

*/

QT_BEGIN_INCLUDE_NAMESPACE

#include "qlocale_data_p.h"

QT_END_INCLUDE_NAMESPACE

QLocale::MeasurementSystem QLocalePrivate::measurementSystem() const

{

    for (int i = 0; i < ImperialMeasurementSystemsCount; ++i) {

        if (ImperialMeasurementSystems[i].languageId == m_language_id

            && ImperialMeasurementSystems[i].countryId == m_country_id) {

            return QLocale::ImperialSystem;

        }

    }

    return QLocale::MetricSystem;

}

// Assumes that code is a

// QChar code[3];

// If the code is two-digit the third digit must be 0

static QLocale::Language codeToLanguage(const QChar *code)

{

    ushort uc1 = code[0].unicode();

    ushort uc2 = code[1].unicode();

    ushort uc3 = code[2].unicode();

    if (uc1 == 'n' && uc2 == 'o' && uc3 == 0)

        uc2 = 'b';

    const unsigned char *c = language_code_list;

    for (; *c != 0; c += 3) {

        if (uc1 == c[0] && uc2 == c[1] && uc3 == c[2])

            return QLocale::Language((c - language_code_list)/3);

    }

    return QLocale::C;

}

// Assumes that code is a

// QChar code[2];

static QLocale::Country codeToCountry(const QChar *code)

{

    ushort uc1 = code[0].unicode();

    ushort uc2 = code[1].unicode();

    const unsigned char *c = country_code_list;

    for (; *c != 0; c += 2) {

        if (uc1 == c[0] && uc2 == c[1])

            return QLocale::Country((c - country_code_list)/2);

    }

    return QLocale::AnyCountry;

}

static QString languageToCode(QLocale::Language language)

{

    if (language == QLocale::C)

        return QLatin1String("C");

    const unsigned char *c = language_code_list + 3*(uint(language));

    QString code(c[2] == 0 ? 2 : 3, Qt::Uninitialized);

    code[0] = ushort(c[0]);

    code[1] = ushort(c[1]);

    if (c[2] != 0)

        code[2] = ushort(c[2]);

    return code;

}

static QString countryToCode(QLocale::Country country)

{

    if (country == QLocale::AnyCountry)

        return QString();

    QString code(2, Qt::Uninitialized);

    const unsigned char *c = country_code_list + 2*(uint(country));

    code[0] = ushort(c[0]);

    code[1] = ushort(c[1]);

    return code;

}

static const QLocalePrivate *findLocale(QLocale::Language language, QLocale::Country country)

{

    unsigned language_id = language;

    unsigned country_id = country;

    uint idx = locale_index[language_id];

    const QLocalePrivate *d = locale_data + idx;

    if (idx == 0) // default language has no associated country

        return d;

    if (country == QLocale::AnyCountry)

        return d;

    Q_ASSERT(d->languageId() == language_id);

    while (d->languageId() == language_id

                && d->countryId() != country_id)

        ++d;

    if (d->countryId() == country_id

            && d->languageId() == language_id)

        return d;

    return locale_data + idx;

}

static bool splitLocaleName(const QString &name, QChar *lang_begin, QChar *cntry_begin)

{

    for (int i = 0; i < 3; ++i)

        lang_begin[i] = 0;

    for (int i = 0; i < 2; ++i)

        cntry_begin[i] = 0;

    int l = name.length();

    QChar *lang = lang_begin;

    QChar *cntry = cntry_begin;

    int state = 0;

    const QChar *uc = name.unicode();

    for (int i = 0; i < l; ++i) {

        if (uc->unicode() == '.' || uc->unicode() == '@')

            break;

        switch (state) {

            case 0:

                // parsing language

                if (uc->unicode() == '_') {

                    state = 1;

                    break;

                }

                if (lang - lang_begin == 3)

                    return false;

                if (uc->unicode() < 'a' || uc->unicode() > 'z')

                    return false;

                *lang = *uc;

                ++lang;

                break;

            case 1:

                // parsing country

                if (cntry - cntry_begin == 2) {

                    cntry_begin[0] = 0;

                    break;

                }

                *cntry = *uc;

                ++cntry;

                break;

        }

        ++uc;

    }

    int lang_len = lang - lang_begin;

    return lang_len == 2 || lang_len == 3;

}

void getLangAndCountry(const QString &name, QLocale::Language &lang, QLocale::Country &cntry)

{

    lang = QLocale::C;

    cntry = QLocale::AnyCountry;

    QChar lang_code[3];

    QChar cntry_code[2];

    if (!splitLocaleName(name, lang_code, cntry_code))

        return;

    lang = codeToLanguage(lang_code);

    if (lang == QLocale::C)

        return;

    if (cntry_code[0].unicode() != 0)

        cntry = codeToCountry(cntry_code);

}

static const QLocalePrivate *findLocale(const QString &name)

{

    QLocale::Language lang;

    QLocale::Country cntry;

    getLangAndCountry(name, lang, cntry);

    return findLocale(lang, cntry);

}

static QString readEscapedFormatString(const QString &format, int *idx)

{

    int &i = *idx;

    Q_ASSERT(format.at(i) == QLatin1Char('\''));

    ++i;

    if (i == format.size())

        return QString();

    if (format.at(i).unicode() == '\'') { // "''" outside of a quoted stirng

        ++i;

        return QLatin1String("'");

    }

    QString result;

    while (i < format.size()) {

        if (format.at(i).unicode() == '\'') {

            if (i + 1 < format.size() && format.at(i + 1).unicode() == '\'') {

                // "''" inside of a quoted string

                result.append(QLatin1Char('\''));

                i += 2;

            } else {

                break;

            }

        } else {

            result.append(format.at(i++));

        }

    }

    if (i < format.size())

        ++i;

    return result;

}

static int repeatCount(const QString &s, int i)

{

    QChar c = s.at(i);

    int j = i + 1;

    while (j < s.size() && s.at(j) == c)

        ++j;

    return j - i;

}

static const QLocalePrivate *default_lp = 0;

static uint default_number_options = 0;

#ifndef QT_NO_SYSTEMLOCALE

static QByteArray envVarLocale()

{

    static QByteArray lang = 0;

#ifdef Q_OS_UNIX

    lang = qgetenv("LC_ALL");

    if (lang.isNull())

        lang = qgetenv("LC_NUMERIC");

    if (lang.isNull())

#endif

        lang = qgetenv("LANG");

    return lang;

}

#if defined(Q_OS_WIN)

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

** Wrappers for Windows locale system functions

*/

static const char *winLangCodeToIsoName(int code);

static QString winIso639LangName(LCID id = LOCALE_USER_DEFAULT);

static QString winIso3116CtryName(LCID id = LOCALE_USER_DEFAULT);

static QString getWinLocaleInfo(LCTYPE type)

{

    LCID id = GetUserDefaultLCID();

    int cnt = GetLocaleInfo(id, type, 0, 0) * 2;

    if (cnt == 0) {

        qWarning("QLocale: empty windows locale info (%d)", (int)type);

        return QString();

    }

    QByteArray buff(cnt, 0);

    cnt = GetLocaleInfo(id, type, reinterpret_cast<wchar_t*>(buff.data()), buff.size() / 2);

    if (cnt == 0) {

        qWarning("QLocale: empty windows locale info (%d)", (int)type);

        return QString();

    }

    return QString::fromWCharArray(reinterpret_cast<const wchar_t *>(buff.data()));

}

QByteArray getWinLocaleName(LCID id = LOCALE_USER_DEFAULT)

{

    QByteArray result;

    if (id == LOCALE_USER_DEFAULT) {

        result = envVarLocale();

        QChar lang[3];

        QChar cntry[2];

        if ( result == "C" || (!result.isEmpty()

                && splitLocaleName(QString::fromLocal8Bit(result), lang, cntry)) ) {

            long id = 0;

            bool ok = false;

            id = qstrtoll(result.data(), 0, 0, &ok);

            if ( !ok || id == 0 || id < INT_MIN || id > INT_MAX )

                return result;

            else

                return winLangCodeToIsoName( (int)id );

        }

    }

#if defined(Q_OS_WINCE)

    result = winLangCodeToIsoName(id != LOCALE_USER_DEFAULT ? id : GetUserDefaultLCID());

#else

    if (id == LOCALE_USER_DEFAULT)

        id = GetUserDefaultLCID();

    QString resultuage = winIso639LangName(id);

    QString country = winIso3116CtryName(id);

    result = resultuage.toLatin1();

    if (!country.isEmpty()) {

        result += '_';

        result += country.toLatin1();

    }

#endif

    return result;

}

Q_CORE_EXPORT QLocale qt_localeFromLCID(LCID id)

{

    return QLocale(QString::fromLatin1(getWinLocaleName(id)));

}

static QString winToQtFormat(const QString &sys_fmt)

{

    QString result;

    int i = 0;

    while (i < sys_fmt.size()) {

        if (sys_fmt.at(i).unicode() == QLatin1Char('\'')) {

            QString text = readEscapedFormatString(sys_fmt, &i);

            if (text == QLatin1String("'"))

                result += QLatin1String("''");

            else

                result += QLatin1Char('\'') + text + QLatin1Char('\'');

            continue;

        }

        QChar c = sys_fmt.at(i);

        int repeat = repeatCount(sys_fmt, i);

        switch (c.unicode()) {

            // Date

            case 'y':

                if (repeat > 5)

                    repeat = 5;

                else if (repeat == 3)

                    repeat = 2;

                switch (repeat) {

                    case 1:

                        result += QLatin1String("yy"); // "y" unsupported by Qt, use "yy"

                        break;

                    case 5:

                        result += QLatin1String("yyyy"); // "yyyyy" same as "yyyy" on Windows

                        break;

                    default:

                        result += QString(repeat, QLatin1Char('y'));

                        break;

                }

                break;

            case 'g':

                if (repeat > 2)

                    repeat = 2;

                switch (repeat) {

                    case 2:

                        break; // no equivalent of "gg" in Qt

                    default:

                        result += QLatin1Char('g');

                        break;

                }

                break;

            case 't':

                if (repeat > 2)

                    repeat = 2;

                result += QLatin1String("AP"); // "t" unsupported, use "AP"

                break;

            default:

                result += QString(repeat, c);

                break;

        }

        i += repeat;

    }

    return result;

}

static QString winDateToString(const QDate &date, DWORD flags)

{

    SYSTEMTIME st;

    memset(&st, 0, sizeof(SYSTEMTIME));

    st.wYear = date.year();

    st.wMonth = date.month();