QLocalePrivate: move the xxxToString functions to QLocaleData

Those functions do not need any of extra QLocale settings in
QLocalePrivate, so we can move them easily, along with their flags.

It's also very convenient that we can now bypass completely QLocale
when formatting numbers to strings.

Change-Id: I8cae64e8e2056a6b2d716758e4be79f746644732
Reviewed-by: Lars Knoll <lars.knoll@digia.com>

7 files changed, 176 insertions, 189 deletions

diff --git a/src/corelib/io/qtextstream.cpp b/src/corelib/io/qtextstream.cpp
index 8188628f57..163b087436 100644
--- a/src/corelib/io/qtextstream.cpp
+++ b/src/corelib/io/qtextstream.cpp
@@ -2191,20 +2191,20 @@ void QTextStreamPrivate::putNumber(qulonglong number, bool negative)
     unsigned flags = 0;
     const QTextStream::NumberFlags numberFlags = params.numberFlags;
     if (numberFlags & QTextStream::ShowBase)
-        flags |= QLocalePrivate::ShowBase;
+        flags |= QLocaleData::ShowBase;
     if (numberFlags & QTextStream::ForceSign)
-        flags |= QLocalePrivate::AlwaysShowSign;
+        flags |= QLocaleData::AlwaysShowSign;
     if (numberFlags & QTextStream::UppercaseBase)
-        flags |= QLocalePrivate::UppercaseBase;
+        flags |= QLocaleData::UppercaseBase;
     if (numberFlags & QTextStream::UppercaseDigits)
-        flags |= QLocalePrivate::CapitalEorX;
+        flags |= QLocaleData::CapitalEorX;
 
     // add thousands group separators. For backward compatibility we
     // don't add a group separator for C locale.
     if (locale != QLocale::c())
-        flags |= QLocalePrivate::ThousandsGroup;
+        flags |= QLocaleData::ThousandsGroup;
 
-    const QLocalePrivate *dd = locale.d;
+    const QLocaleData *dd = locale.d->m_data;
     int base = params.integerBase ? params.integerBase : 10;
     if (negative && base == 10) {
         result = dd->longLongToString(-static_cast<qlonglong>(number), -1,
@@ -2388,32 +2388,32 @@ QTextStream &QTextStream::operator<<(double f)
     Q_D(QTextStream);
     CHECK_VALID_STREAM(*this);
 
-    QLocalePrivate::DoubleForm form = QLocalePrivate::DFDecimal;
+    QLocaleData::DoubleForm form = QLocaleData::DFDecimal;
     switch (realNumberNotation()) {
     case FixedNotation:
-        form = QLocalePrivate::DFDecimal;
+        form = QLocaleData::DFDecimal;
         break;
     case ScientificNotation:
-        form = QLocalePrivate::DFExponent;
+        form = QLocaleData::DFExponent;
         break;
     case SmartNotation:
-        form = QLocalePrivate::DFSignificantDigits;
+        form = QLocaleData::DFSignificantDigits;
         break;
     }
 
     uint flags = 0;
     if (numberFlags() & ShowBase)
-        flags |= QLocalePrivate::ShowBase;
+        flags |= QLocaleData::ShowBase;
     if (numberFlags() & ForceSign)
-        flags |= QLocalePrivate::AlwaysShowSign;
+        flags |= QLocaleData::AlwaysShowSign;
     if (numberFlags() & UppercaseBase)
-        flags |= QLocalePrivate::UppercaseBase;
+        flags |= QLocaleData::UppercaseBase;
     if (numberFlags() & UppercaseDigits)
-        flags |= QLocalePrivate::CapitalEorX;
+        flags |= QLocaleData::CapitalEorX;
     if (numberFlags() & ForcePoint)
-        flags |= QLocalePrivate::Alternate;
+        flags |= QLocaleData::Alternate;
 
-    const QLocalePrivate *dd = d->locale.d;
+    const QLocaleData *dd = d->locale.d->m_data;
     QString num = dd->doubleToString(f, d->params.realNumberPrecision, form, -1, flags);
     d->putString(num, true);
     return *this;
diff --git a/src/corelib/tools/qbytearray.cpp b/src/corelib/tools/qbytearray.cpp
index ab1167d0f6..0b645d536b 100644
--- a/src/corelib/tools/qbytearray.cpp
+++ b/src/corelib/tools/qbytearray.cpp
@@ -3772,22 +3772,22 @@ QByteArray &QByteArray::setNum(qulonglong n, int base)
 
 QByteArray &QByteArray::setNum(double n, char f, int prec)
 {
-    QLocalePrivate::DoubleForm form = QLocalePrivate::DFDecimal;
+    QLocaleData::DoubleForm form = QLocaleData::DFDecimal;
     uint flags = 0;
 
     if (qIsUpper(f))
-        flags = QLocalePrivate::CapitalEorX;
+        flags = QLocaleData::CapitalEorX;
     f = qToLower(f);
 
     switch (f) {
         case 'f':
-            form = QLocalePrivate::DFDecimal;
+            form = QLocaleData::DFDecimal;
             break;
         case 'e':
-            form = QLocalePrivate::DFExponent;
+            form = QLocaleData::DFExponent;
             break;
         case 'g':
-            form = QLocalePrivate::DFSignificantDigits;
+            form = QLocaleData::DFSignificantDigits;
             break;
         default:
 #if defined(QT_CHECK_RANGE)
@@ -3796,8 +3796,7 @@ QByteArray &QByteArray::setNum(double n, char f, int prec)
             break;
     }
 
-    QLocale locale(QLocale::C);
-    *this = locale.d->doubleToString(n, prec, form, -1, flags).toLatin1();
+    *this = QLocaleData::c()->doubleToString(n, prec, form, -1, flags).toLatin1();
     return *this;
 }
 
diff --git a/src/corelib/tools/qlocale.cpp b/src/corelib/tools/qlocale.cpp
index d2d49637d3..ef69442ca1 100644
--- a/src/corelib/tools/qlocale.cpp
+++ b/src/corelib/tools/qlocale.cpp
@@ -1551,9 +1551,9 @@ QString QLocale::toString(qlonglong i) const
 {
     int flags = d->m_numberOptions & OmitGroupSeparator
                     ? 0
-                    : QLocalePrivate::ThousandsGroup;
+                    : QLocaleData::ThousandsGroup;
 
-    return d->longLongToString(i, -1, 10, -1, flags);
+    return d->m_data->longLongToString(i, -1, 10, -1, flags);
 }
 
 /*!
@@ -1566,9 +1566,9 @@ QString QLocale::toString(qulonglong i) const
 {
     int flags = d->m_numberOptions & OmitGroupSeparator
                     ? 0
-                    : QLocalePrivate::ThousandsGroup;
+                    : QLocaleData::ThousandsGroup;
 
-    return d->unsLongLongToString(i, -1, 10, -1, flags);
+    return d->m_data->unsLongLongToString(i, -1, 10, -1, flags);
 }
 
 /*!
@@ -2040,30 +2040,30 @@ static char qToLower(char c)
 
 QString QLocale::toString(double i, char f, int prec) const
 {
-    QLocalePrivate::DoubleForm form = QLocalePrivate::DFDecimal;
+    QLocaleData::DoubleForm form = QLocaleData::DFDecimal;
     uint flags = 0;
 
     if (qIsUpper(f))
-        flags = QLocalePrivate::CapitalEorX;
+        flags = QLocaleData::CapitalEorX;
     f = qToLower(f);
 
     switch (f) {
         case 'f':
-            form = QLocalePrivate::DFDecimal;
+            form = QLocaleData::DFDecimal;
             break;
         case 'e':
-            form = QLocalePrivate::DFExponent;
+            form = QLocaleData::DFExponent;
             break;
         case 'g':
-            form = QLocalePrivate::DFSignificantDigits;
+            form = QLocaleData::DFSignificantDigits;
             break;
         default:
             break;
     }
 
     if (!(d->m_numberOptions & OmitGroupSeparator))
-        flags |= QLocalePrivate::ThousandsGroup;
-    return d->doubleToString(i, prec, form, -1, flags);
+        flags |= QLocaleData::ThousandsGroup;
+    return d->m_data->doubleToString(i, prec, form, -1, flags);
 }
 
 /*!
@@ -2577,12 +2577,12 @@ QString QLocalePrivate::dateTimeToString(const QString &format, const QDateTime
                 case 4: {
                     const int yr = date.year();
                     const int len = (yr < 0) ? 5 : 4;
-                    result.append(longLongToString(yr, -1, 10, len, QLocalePrivate::ZeroPadded));
+                    result.append(m_data->longLongToString(yr, -1, 10, len, QLocaleData::ZeroPadded));
                     break;
                 }
                 case 2:
-                    result.append(longLongToString(date.year() % 100, -1, 10, 2,
-                                                   QLocalePrivate::ZeroPadded));
+                    result.append(m_data->longLongToString(date.year() % 100, -1, 10, 2,
+                                                   QLocaleData::ZeroPadded));
                     break;
                 default:
                     repeat = 1;
@@ -2596,10 +2596,10 @@ QString QLocalePrivate::dateTimeToString(const QString &format, const QDateTime
                 repeat = qMin(repeat, 4);
                 switch (repeat) {
                 case 1:
-                    result.append(longLongToString(date.month()));
+                    result.append(m_data->longLongToString(date.month()));
                     break;
                 case 2:
-                    result.append(longLongToString(date.month(), -1, 10, 2, QLocalePrivate::ZeroPadded));
+                    result.append(m_data->longLongToString(date.month(), -1, 10, 2, QLocaleData::ZeroPadded));
                     break;
                 case 3:
                     result.append(q->monthName(date.month(), QLocale::ShortFormat));
@@ -2615,10 +2615,10 @@ QString QLocalePrivate::dateTimeToString(const QString &format, const QDateTime
                 repeat = qMin(repeat, 4);
                 switch (repeat) {
                 case 1:
-                    result.append(longLongToString(date.day()));
+                    result.append(m_data->longLongToString(date.day()));
                     break;
                 case 2:
-                    result.append(longLongToString(date.day(), -1, 10, 2, QLocalePrivate::ZeroPadded));
+                    result.append(m_data->longLongToString(date.day(), -1, 10, 2, QLocaleData::ZeroPadded));
                     break;
                 case 3:
                     result.append(q->dayName(date.dayOfWeek(), QLocale::ShortFormat));
@@ -2648,10 +2648,10 @@ QString QLocalePrivate::dateTimeToString(const QString &format, const QDateTime
 
                 switch (repeat) {
                 case 1:
-                    result.append(longLongToString(hour));
+                    result.append(m_data->longLongToString(hour));
                     break;
                 case 2:
-                    result.append(longLongToString(hour, -1, 10, 2, QLocalePrivate::ZeroPadded));
+                    result.append(m_data->longLongToString(hour, -1, 10, 2, QLocaleData::ZeroPadded));
                     break;
                 }
                 break;
@@ -2661,10 +2661,10 @@ QString QLocalePrivate::dateTimeToString(const QString &format, const QDateTime
                 repeat = qMin(repeat, 2);
                 switch (repeat) {
                 case 1:
-                    result.append(longLongToString(time.hour()));
+                    result.append(m_data->longLongToString(time.hour()));
                     break;
                 case 2:
-                    result.append(longLongToString(time.hour(), -1, 10, 2, QLocalePrivate::ZeroPadded));
+                    result.append(m_data->longLongToString(time.hour(), -1, 10, 2, QLocaleData::ZeroPadded));
                     break;
                 }
                 break;
@@ -2674,10 +2674,10 @@ QString QLocalePrivate::dateTimeToString(const QString &format, const QDateTime
                 repeat = qMin(repeat, 2);
                 switch (repeat) {
                 case 1:
-                    result.append(longLongToString(time.minute()));
+                    result.append(m_data->longLongToString(time.minute()));
                     break;
                 case 2:
-                    result.append(longLongToString(time.minute(), -1, 10, 2, QLocalePrivate::ZeroPadded));
+                    result.append(m_data->longLongToString(time.minute(), -1, 10, 2, QLocaleData::ZeroPadded));
                     break;
                 }
                 break;
@@ -2687,10 +2687,10 @@ QString QLocalePrivate::dateTimeToString(const QString &format, const QDateTime
                 repeat = qMin(repeat, 2);
                 switch (repeat) {
                 case 1:
-                    result.append(longLongToString(time.second()));
+                    result.append(m_data->longLongToString(time.second()));
                     break;
                 case 2:
-                    result.append(longLongToString(time.second(), -1, 10, 2, QLocalePrivate::ZeroPadded));
+                    result.append(m_data->longLongToString(time.second(), -1, 10, 2, QLocaleData::ZeroPadded));
                     break;
                 }
                 break;
@@ -2724,10 +2724,10 @@ QString QLocalePrivate::dateTimeToString(const QString &format, const QDateTime
                 }
                 switch (repeat) {
                 case 1:
-                    result.append(longLongToString(time.msec()));
+                    result.append(m_data->longLongToString(time.msec()));
                     break;
                 case 3:
-                    result.append(longLongToString(time.msec(), -1, 10, 3, QLocalePrivate::ZeroPadded));
+                    result.append(m_data->longLongToString(time.msec(), -1, 10, 3, QLocaleData::ZeroPadded));
                     break;
                 }
                 break;
@@ -2756,24 +2756,16 @@ QString QLocalePrivate::dateTimeToString(const QString &format, const QDateTime
     return result;
 }
 
-QString QLocalePrivate::doubleToString(double d,
-                                       int precision,
-                                       DoubleForm form,
-                                       int width,
-                                       unsigned flags) const
+QString QLocaleData::doubleToString(double d, int precision, DoubleForm form,
+                                    int width, unsigned flags) const
 {
-    return QLocalePrivate::doubleToString(zero(), plus(), minus(), exponential(),
-                                          group(), decimal(),
-                                          d, precision, form, width, flags);
+    return doubleToString(m_zero, m_plus, m_minus, m_exponential, m_group, m_decimal,
+                          d, precision, form, width, flags);
 }
 
-QString QLocalePrivate::doubleToString(const QChar _zero, const QChar plus, const QChar minus,
-                                       const QChar exponential, const QChar group, const QChar decimal,
-                                       double d,
-                                       int precision,
-                                       DoubleForm form,
-                                       int width,
-                                       unsigned flags)
+QString QLocaleData::doubleToString(const QChar _zero, const QChar plus, const QChar minus,
+                                    const QChar exponential, const QChar group, const QChar decimal,
+                                    double d, int precision, DoubleForm form, int width, unsigned flags)
 {
     if (precision == -1)
         precision = 6;
@@ -2893,14 +2885,14 @@ QString QLocalePrivate::doubleToString(const QChar _zero, const QChar plus, cons
 
     // pad with zeros. LeftAdjusted overrides this flag). Also, we don't
     // pad special numbers
-    if (flags & QLocalePrivate::ZeroPadded
-            && !(flags & QLocalePrivate::LeftAdjusted)
+    if (flags & QLocaleData::ZeroPadded
+            && !(flags & QLocaleData::LeftAdjusted)
             && !special_number) {
         int num_pad_chars = width - num_str.length();
         // leave space for the sign
         if (negative
-                || flags & QLocalePrivate::AlwaysShowSign
-                || flags & QLocalePrivate::BlankBeforePositive)
+                || flags & QLocaleData::AlwaysShowSign
+                || flags & QLocaleData::BlankBeforePositive)
             --num_pad_chars;
 
         for (int i = 0; i < num_pad_chars; ++i)
@@ -2910,26 +2902,26 @@ QString QLocalePrivate::doubleToString(const QChar _zero, const QChar plus, cons
     // add sign
     if (negative)
         num_str.prepend(minus);
-    else if (flags & QLocalePrivate::AlwaysShowSign)
+    else if (flags & QLocaleData::AlwaysShowSign)
         num_str.prepend(plus);
-    else if (flags & QLocalePrivate::BlankBeforePositive)
+    else if (flags & QLocaleData::BlankBeforePositive)
         num_str.prepend(QLatin1Char(' '));
 
-    if (flags & QLocalePrivate::CapitalEorX)
+    if (flags & QLocaleData::CapitalEorX)
         num_str = num_str.toUpper();
 
     return num_str;
 }
 
-QString QLocalePrivate::longLongToString(qlonglong l, int precision,
+QString QLocaleData::longLongToString(qlonglong l, int precision,
                                             int base, int width,
                                             unsigned flags) const
 {
-    return QLocalePrivate::longLongToString(zero(), group(), plus(), minus(),
+    return longLongToString(m_zero, m_group, m_plus, m_minus,
                                             l, precision, base, width, flags);
 }
 
-QString QLocalePrivate::longLongToString(const QChar zero, const QChar group,
+QString QLocaleData::longLongToString(const QChar zero, const QChar group,
                                          const QChar plus, const QChar minus,
                                          qlonglong l, int precision,
                                          int base, int width,
@@ -3016,15 +3008,15 @@ QString QLocalePrivate::longLongToString(const QChar zero, const QChar group,
     return num_str;
 }
 
-QString QLocalePrivate::unsLongLongToString(qulonglong l, int precision,
+QString QLocaleData::unsLongLongToString(qulonglong l, int precision,
                                             int base, int width,
                                             unsigned flags) const
 {
-    return QLocalePrivate::unsLongLongToString(zero(), group(), plus(),
+    return unsLongLongToString(m_zero, m_group, m_plus,
                                                l, precision, base, width, flags);
 }
 
-QString QLocalePrivate::unsLongLongToString(const QChar zero, const QChar group,
+QString QLocaleData::unsLongLongToString(const QChar zero, const QChar group,
                                             const QChar plus,
                                             qulonglong l, int precision,
                                             int base, int width,
diff --git a/src/corelib/tools/qlocale_p.h b/src/corelib/tools/qlocale_p.h
index b544a55c31..0063990125 100644
--- a/src/corelib/tools/qlocale_p.h
+++ b/src/corelib/tools/qlocale_p.h
@@ -166,6 +166,58 @@ public:
                                              QLocale::Country country);
     static const QLocaleData *c();
 
+    enum DoubleForm {
+        DFExponent = 0,
+        DFDecimal,
+        DFSignificantDigits,
+        _DFMax = DFSignificantDigits
+    };
+
+    enum Flags {
+        NoFlags             = 0,
+        Alternate           = 0x01,
+        ZeroPadded          = 0x02,
+        LeftAdjusted        = 0x04,
+        BlankBeforePositive = 0x08,
+        AlwaysShowSign      = 0x10,
+        ThousandsGroup      = 0x20,
+        CapitalEorX         = 0x40,
+
+        ShowBase            = 0x80,
+        UppercaseBase       = 0x100,
+        ForcePoint          = Alternate
+    };
+
+    static QString doubleToString(const QChar zero, const QChar plus,
+                                  const QChar minus, const QChar exponent,
+                                  const QChar group, const QChar decimal,
+                                  double d, int precision,
+                                  DoubleForm form,
+                                  int width, unsigned flags);
+    static QString longLongToString(const QChar zero, const QChar group,
+                                    const QChar plus, const QChar minus,
+                                    qint64 l, int precision, int base,
+                                    int width, unsigned flags);
+    static QString unsLongLongToString(const QChar zero, const QChar group,
+                                       const QChar plus,
+                                       quint64 l, int precision,
+                                       int base, int width,
+                                       unsigned flags);
+
+    QString doubleToString(double d,
+                           int precision = -1,
+                           DoubleForm form = DFSignificantDigits,
+                           int width = -1,
+                           unsigned flags = NoFlags) const;
+    QString longLongToString(qint64 l, int precision = -1,
+                             int base = 10,
+                             int width = -1,
+                             unsigned flags = NoFlags) const;
+    QString unsLongLongToString(quint64 l, int precision = -1,
+                                int base = 10,
+                                int width = -1,
+                                unsigned flags = NoFlags) const;
+
     quint16 m_language_id, m_script_id, m_country_id;
 
     quint16 m_decimal, m_group, m_list, m_percent, m_zero, m_minus, m_plus, m_exponential;
@@ -250,62 +302,11 @@ public:
 
     QLocale::MeasurementSystem measurementSystem() const;
 
-    enum DoubleForm {
-        DFExponent = 0,
-        DFDecimal,
-        DFSignificantDigits,
-        _DFMax = DFSignificantDigits
-    };
-
-    enum Flags {
-        NoFlags             = 0,
-        Alternate           = 0x01,
-        ZeroPadded          = 0x02,
-        LeftAdjusted        = 0x04,
-        BlankBeforePositive = 0x08,
-        AlwaysShowSign      = 0x10,
-        ThousandsGroup      = 0x20,
-        CapitalEorX         = 0x40,
-
-        ShowBase            = 0x80,
-        UppercaseBase       = 0x100,
-        ForcePoint          = Alternate
-    };
-
     enum GroupSeparatorMode {
         FailOnGroupSeparators,
         ParseGroupSeparators
     };
 
-    static QString doubleToString(const QChar zero, const QChar plus,
-                                  const QChar minus, const QChar exponent,
-                                  const QChar group, const QChar decimal,
-                                  double d, int precision,
-                                  DoubleForm form,
-                                  int width, unsigned flags);
-    static QString longLongToString(const QChar zero, const QChar group,
-                                    const QChar plus, const QChar minus,
-                                    qint64 l, int precision, int base,
-                                    int width, unsigned flags);
-    static QString unsLongLongToString(const QChar zero, const QChar group,
-                                       const QChar plus,
-                                       quint64 l, int precision,
-                                       int base, int width,
-                                       unsigned flags);
-
-    QString doubleToString(double d,
-                           int precision = -1,
-                           DoubleForm form = DFSignificantDigits,
-                           int width = -1,
-                           unsigned flags = NoFlags) const;
-    QString longLongToString(qint64 l, int precision = -1,
-                             int base = 10,
-                             int width = -1,
-                             unsigned flags = NoFlags) const;
-    QString unsLongLongToString(quint64 l, int precision = -1,
-                                int base = 10,
-                                int width = -1,
-                                unsigned flags = NoFlags) const;
     double stringToDouble(const QChar *begin, int len, bool *ok, GroupSeparatorMode group_sep_mode) const;
     qint64 stringToLongLong(const QChar *begin, int len, int base, bool *ok, GroupSeparatorMode group_sep_mode) const;
     quint64 stringToUnsLongLong(const QChar *begin, int len, int base, bool *ok, GroupSeparatorMode group_sep_mode) const;
diff --git a/src/corelib/tools/qlocale_tools.cpp b/src/corelib/tools/qlocale_tools.cpp
index 072a35aa4e..81f9d20db7 100644
--- a/src/corelib/tools/qlocale_tools.cpp
+++ b/src/corelib/tools/qlocale_tools.cpp
@@ -178,8 +178,8 @@ QString &exponentForm(QChar zero, QChar decimal, QChar exponential,
         digits.insert(1, decimal);
 
     digits.append(exponential);
-    digits.append(QLocalePrivate::longLongToString(zero, group, plus, minus,
-                   exp, 2, 10, -1, QLocalePrivate::AlwaysShowSign));
+    digits.append(QLocaleData::longLongToString(zero, group, plus, minus,
+                   exp, 2, 10, -1, QLocaleData::AlwaysShowSign));
 
     return digits;
 }
diff --git a/src/corelib/tools/qlocale_win.cpp b/src/corelib/tools/qlocale_win.cpp
index b03866681e..1690dd83ee 100644
--- a/src/corelib/tools/qlocale_win.cpp
+++ b/src/corelib/tools/qlocale_win.cpp
@@ -527,24 +527,24 @@ QVariant QSystemLocalePrivate::toCurrencyString(const QSystemLocale::CurrencyToS
     QString value;
     switch (arg.value.type()) {
     case QVariant::Int:
-        value = QLocalePrivate::longLongToString(QLatin1Char('0'), QLatin1Char(','), QLatin1Char('+'), QLatin1Char('-'),
+        value = QLocaleData::longLongToString(QLatin1Char('0'), QLatin1Char(','), QLatin1Char('+'), QLatin1Char('-'),
                                                  arg.value.toInt(), -1, 10, -1, QLocale::OmitGroupSeparator);
         break;
     case QVariant::UInt:
-        value = QLocalePrivate::unsLongLongToString(QLatin1Char('0'), QLatin1Char(','), QLatin1Char('+'),
+        value = QLocaleData::unsLongLongToString(QLatin1Char('0'), QLatin1Char(','), QLatin1Char('+'),
                                                     arg.value.toUInt(), -1, 10, -1, QLocale::OmitGroupSeparator);
         break;
     case QVariant::Double:
-        value = QLocalePrivate::doubleToString(QLatin1Char('0'), QLatin1Char('+'), QLatin1Char('-'),
+        value = QLocaleData::doubleToString(QLatin1Char('0'), QLatin1Char('+'), QLatin1Char('-'),
                                                QLatin1Char(' '), QLatin1Char(','), QLatin1Char('.'),
-                                               arg.value.toDouble(), -1, QLocalePrivate::DFDecimal, -1, QLocale::OmitGroupSeparator);
+                                               arg.value.toDouble(), -1, QLocaleData::DFDecimal, -1, QLocale::OmitGroupSeparator);
         break;
     case QVariant::LongLong:
-        value = QLocalePrivate::longLongToString(QLatin1Char('0'), QLatin1Char(','), QLatin1Char('+'), QLatin1Char('-'),
+        value = QLocaleData::longLongToString(QLatin1Char('0'), QLatin1Char(','), QLatin1Char('+'), QLatin1Char('-'),
                                                  arg.value.toLongLong(), -1, 10, -1, QLocale::OmitGroupSeparator);
         break;
     case QVariant::ULongLong:
-        value = QLocalePrivate::unsLongLongToString(QLatin1Char('0'), QLatin1Char(','), QLatin1Char('+'),
+        value = QLocaleData::unsLongLongToString(QLatin1Char('0'), QLatin1Char(','), QLatin1Char('+'),
                                                     arg.value.toULongLong(), -1, 10, -1, QLocale::OmitGroupSeparator);
         break;
     default:
diff --git a/src/corelib/tools/qstring.cpp b/src/corelib/tools/qstring.cpp
index 909e50e86e..f02b09b836 100644
--- a/src/corelib/tools/qstring.cpp
+++ b/src/corelib/tools/qstring.cpp
@@ -5720,8 +5720,6 @@ QString &QString::sprintf(const char *cformat, ...)
 
 QString &QString::vsprintf(const char* cformat, va_list ap)
 {
-    const QLocale locale(QLocale::C);
-
     if (!cformat || !*cformat) {
         // Qt 1.x compat
         *this = fromLatin1("");
@@ -5761,12 +5759,12 @@ QString &QString::vsprintf(const char* cformat, va_list ap)
         bool no_more_flags = false;
         do {
             switch (*c) {
-                case '#': flags |= QLocalePrivate::Alternate; break;
-                case '0': flags |= QLocalePrivate::ZeroPadded; break;
-                case '-': flags |= QLocalePrivate::LeftAdjusted; break;
-                case ' ': flags |= QLocalePrivate::BlankBeforePositive; break;
-                case '+': flags |= QLocalePrivate::AlwaysShowSign; break;
-                case '\'': flags |= QLocalePrivate::ThousandsGroup; break;
+                case '#': flags |= QLocaleData::Alternate; break;
+                case '0': flags |= QLocaleData::ZeroPadded; break;
+                case '-': flags |= QLocaleData::LeftAdjusted; break;
+                case ' ': flags |= QLocaleData::BlankBeforePositive; break;
+                case '+': flags |= QLocaleData::AlwaysShowSign; break;
+                case '\'': flags |= QLocaleData::ThousandsGroup; break;
                 default: no_more_flags = true; break;
             }
 
@@ -5898,7 +5896,7 @@ QString &QString::vsprintf(const char* cformat, va_list ap)
                     case lm_t: i = va_arg(ap, int); break;
                     default: i = 0; break;
                 }
-                subst = locale.d->longLongToString(i, precision, 10, width, flags);
+                subst = QLocaleData::c()->longLongToString(i, precision, 10, width, flags);
                 ++c;
                 break;
             }
@@ -5918,7 +5916,7 @@ QString &QString::vsprintf(const char* cformat, va_list ap)
                 }
 
                 if (qIsUpper(*c))
-                    flags |= QLocalePrivate::CapitalEorX;
+                    flags |= QLocaleData::CapitalEorX;
 
                 int base = 10;
                 switch (qToLower(*c)) {
@@ -5930,7 +5928,7 @@ QString &QString::vsprintf(const char* cformat, va_list ap)
                         base = 16; break;
                     default: break;
                 }
-                subst = locale.d->unsLongLongToString(u, precision, base, width, flags);
+                subst = QLocaleData::c()->unsLongLongToString(u, precision, base, width, flags);
                 ++c;
                 break;
             }
@@ -5949,17 +5947,17 @@ QString &QString::vsprintf(const char* cformat, va_list ap)
                     d = va_arg(ap, double);
 
                 if (qIsUpper(*c))
-                    flags |= QLocalePrivate::CapitalEorX;
+                    flags |= QLocaleData::CapitalEorX;
 
-                QLocalePrivate::DoubleForm form = QLocalePrivate::DFDecimal;
+                QLocaleData::DoubleForm form = QLocaleData::DFDecimal;
                 switch (qToLower(*c)) {
-                    case 'e': form = QLocalePrivate::DFExponent; break;
+                    case 'e': form = QLocaleData::DFExponent; break;
                     case 'a':                             // not supported - decimal form used instead
-                    case 'f': form = QLocalePrivate::DFDecimal; break;
-                    case 'g': form = QLocalePrivate::DFSignificantDigits; break;
+                    case 'f': form = QLocaleData::DFDecimal; break;
+                    case 'g': form = QLocaleData::DFSignificantDigits; break;
                     default: break;
                 }
-                subst = locale.d->doubleToString(d, precision, form, width, flags);
+                subst = QLocaleData::c()->doubleToString(d, precision, form, width, flags);
                 ++c;
                 break;
             }
@@ -5992,8 +5990,8 @@ QString &QString::vsprintf(const char* cformat, va_list ap)
 #else
                 quint64 i = reinterpret_cast<unsigned long>(arg);
 #endif
-                flags |= QLocalePrivate::Alternate;
-                subst = locale.d->unsLongLongToString(i, precision, 16, width, flags);
+                flags |= QLocaleData::Alternate;
+                subst = QLocaleData::c()->unsLongLongToString(i, precision, 16, width, flags);
                 ++c;
                 break;
             }
@@ -6035,7 +6033,7 @@ QString &QString::vsprintf(const char* cformat, va_list ap)
                 continue;
         }
 
-        if (flags & QLocalePrivate::LeftAdjusted)
+        if (flags & QLocaleData::LeftAdjusted)
             result.append(subst.leftJustified(width));
         else
             result.append(subst.rightJustified(width));
@@ -6435,8 +6433,7 @@ QString &QString::setNum(qlonglong n, int base)
         base = 10;
     }
 #endif
-    QLocale locale(QLocale::C);
-    *this = locale.d->longLongToString(n, -1, base);
+    *this = QLocaleData::c()->longLongToString(n, -1, base);
     return *this;
 }
 
@@ -6451,8 +6448,7 @@ QString &QString::setNum(qulonglong n, int base)
         base = 10;
     }
 #endif
-    QLocale locale(QLocale::C);
-    *this = locale.d->unsLongLongToString(n, -1, base);
+    *this = QLocaleData::c()->unsLongLongToString(n, -1, base);
     return *this;
 }
 
@@ -6484,22 +6480,22 @@ QString &QString::setNum(qulonglong n, int base)
 
 QString &QString::setNum(double n, char f, int prec)
 {
-    QLocalePrivate::DoubleForm form = QLocalePrivate::DFDecimal;
+    QLocaleData::DoubleForm form = QLocaleData::DFDecimal;
     uint flags = 0;
 
     if (qIsUpper(f))
-        flags = QLocalePrivate::CapitalEorX;
+        flags = QLocaleData::CapitalEorX;
     f = qToLower(f);
 
     switch (f) {
         case 'f':
-            form = QLocalePrivate::DFDecimal;
+            form = QLocaleData::DFDecimal;
             break;
         case 'e':
-            form = QLocalePrivate::DFExponent;
+            form = QLocaleData::DFExponent;
             break;
         case 'g':
-            form = QLocalePrivate::DFSignificantDigits;
+            form = QLocaleData::DFSignificantDigits;
             break;
         default:
 #if defined(QT_CHECK_RANGE)
@@ -6508,8 +6504,7 @@ QString &QString::setNum(double n, char f, int prec)
             break;
     }
 
-    QLocale locale(QLocale::C);
-    *this = locale.d->doubleToString(n, prec, form, -1, flags);
+    *this = QLocaleData::c()->doubleToString(n, prec, form, -1, flags);
     return *this;
 }
 
@@ -7307,20 +7302,20 @@ QString QString::arg(qlonglong a, int fieldWidth, int base, QChar fillChar) cons
         return *this;
     }
 
-    unsigned flags = QLocalePrivate::NoFlags;
+    unsigned flags = QLocaleData::NoFlags;
     if (fillChar == QLatin1Char('0'))
-        flags = QLocalePrivate::ZeroPadded;
+        flags = QLocaleData::ZeroPadded;
 
     QString arg;
     if (d.occurrences > d.locale_occurrences)
-        arg = QLocale::c().d->longLongToString(a, -1, base, fieldWidth, flags);
+        arg = QLocaleData::c()->longLongToString(a, -1, base, fieldWidth, flags);
 
     QString locale_arg;
     if (d.locale_occurrences > 0) {
         QLocale locale;
         if (!(locale.numberOptions() & QLocale::OmitGroupSeparator))
-            flags |= QLocalePrivate::ThousandsGroup;
-        locale_arg = locale.d->longLongToString(a, -1, base, fieldWidth, flags);
+            flags |= QLocaleData::ThousandsGroup;
+        locale_arg = locale.d->m_data->longLongToString(a, -1, base, fieldWidth, flags);
     }
 
     return replaceArgEscapes(*this, d, fieldWidth, arg, locale_arg, fillChar);
@@ -7351,20 +7346,20 @@ QString QString::arg(qulonglong a, int fieldWidth, int base, QChar fillChar) con
         return *this;
     }
 
-    unsigned flags = QLocalePrivate::NoFlags;
+    unsigned flags = QLocaleData::NoFlags;
     if (fillChar == QLatin1Char('0'))
-        flags = QLocalePrivate::ZeroPadded;
+        flags = QLocaleData::ZeroPadded;
 
     QString arg;
     if (d.occurrences > d.locale_occurrences)
-        arg = QLocale::c().d->unsLongLongToString(a, -1, base, fieldWidth, flags);
+        arg = QLocaleData::c()->unsLongLongToString(a, -1, base, fieldWidth, flags);
 
     QString locale_arg;
     if (d.locale_occurrences > 0) {
         QLocale locale;
         if (!(locale.numberOptions() & QLocale::OmitGroupSeparator))
-            flags |= QLocalePrivate::ThousandsGroup;
-        locale_arg = locale.d->unsLongLongToString(a, -1, base, fieldWidth, flags);
+            flags |= QLocaleData::ThousandsGroup;
+        locale_arg = locale.d->m_data->unsLongLongToString(a, -1, base, fieldWidth, flags);
     }
 
     return replaceArgEscapes(*this, d, fieldWidth, arg, locale_arg, fillChar);
@@ -7463,24 +7458,24 @@ QString QString::arg(double a, int fieldWidth, char fmt, int prec, QChar fillCha
         return *this;
     }
 
-    unsigned flags = QLocalePrivate::NoFlags;
+    unsigned flags = QLocaleData::NoFlags;
     if (fillChar == QLatin1Char('0'))
-        flags = QLocalePrivate::ZeroPadded;
+        flags = QLocaleData::ZeroPadded;
 
     if (qIsUpper(fmt))
-        flags |= QLocalePrivate::CapitalEorX;
+        flags |= QLocaleData::CapitalEorX;
     fmt = qToLower(fmt);
 
-    QLocalePrivate::DoubleForm form = QLocalePrivate::DFDecimal;
+    QLocaleData::DoubleForm form = QLocaleData::DFDecimal;
     switch (fmt) {
     case 'f':
-        form = QLocalePrivate::DFDecimal;
+        form = QLocaleData::DFDecimal;
         break;
     case 'e':
-        form = QLocalePrivate::DFExponent;
+        form = QLocaleData::DFExponent;
         break;
     case 'g':
-        form = QLocalePrivate::DFSignificantDigits;
+        form = QLocaleData::DFSignificantDigits;
         break;
     default:
 #if defined(QT_CHECK_RANGE)
@@ -7491,15 +7486,15 @@ QString QString::arg(double a, int fieldWidth, char fmt, int prec, QChar fillCha
 
     QString arg;
     if (d.occurrences > d.locale_occurrences)
-        arg = QLocale::c().d->doubleToString(a, prec, form, fieldWidth, flags);
+        arg = QLocaleData::c()->doubleToString(a, prec, form, fieldWidth, flags);
 
     QString locale_arg;
     if (d.locale_occurrences > 0) {
         QLocale locale;
 
         if (!(locale.numberOptions() & QLocale::OmitGroupSeparator))
-            flags |= QLocalePrivate::ThousandsGroup;
-        locale_arg = locale.d->doubleToString(a, prec, form, fieldWidth, flags);
+            flags |= QLocaleData::ThousandsGroup;
+        locale_arg = locale.d->m_data->doubleToString(a, prec, form, fieldWidth, flags);
     }
 
     return replaceArgEscapes(*this, d, fieldWidth, arg, locale_arg, fillChar);