qlocale_unix.cpp - mozsearch

++ // Copyright (C) 2022 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++ // Qt-Security score:critical reason:data-parser

++

++ #include "qlocale_p.h"

++

++ #include "qstringbuilder.h"

++ #include "qdatetime.h"

++ #include "qstringlist.h"

++ #include "qvariant.h"

++ #include "qreadwritelock.h"

++

++ QT_BEGIN_NAMESPACE

++

++ using namespace Qt::StringLiterals;

++

++ #ifndef QT_NO_SYSTEMLOCALE

++ namespace {

++ struct QSystemLocaleData

++ {

++     QSystemLocaleData()

++         : lc_numeric(QLocale::C)

++          ,lc_time(QLocale::C)

++          ,lc_monetary(QLocale::C)

++          ,lc_messages(QLocale::C)

++     {

++         initFromEnvironmentUnprotected();

++     }

++

++     void readEnvironment();

++

++     QReadWriteLock lock;

++

++     QLocale lc_numeric;

++     QLocale lc_time;

++     QLocale lc_monetary;

++     QLocale lc_messages;

++     QByteArray lc_messages_var;

++     QByteArray lc_measurement_var;

++     QByteArray lc_collate_var;

++     QStringList uiLanguages;

++

++ private:

++     void initFromEnvironmentUnprotected();

++ };

++

++ void QSystemLocaleData::readEnvironment()

++ {

++     QWriteLocker locker(&lock);

++     initFromEnvironmentUnprotected();

++ }

++

++ void QSystemLocaleData::initFromEnvironmentUnprotected()

++ {

++     // See https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap08.html#tag_08_02

++     // for the semantics of each of these:

++     QByteArray all = qgetenv("LC_ALL");

++     QByteArray numeric  = all.isEmpty() ? qgetenv("LC_NUMERIC") : all;

++     QByteArray time     = all.isEmpty() ? qgetenv("LC_TIME") : all;

++     QByteArray monetary = all.isEmpty() ? qgetenv("LC_MONETARY") : all;

++     lc_messages_var     = all.isEmpty() ? qgetenv("LC_MESSAGES") : all;

++     lc_measurement_var  = all.isEmpty() ? qgetenv("LC_MEASUREMENT") : all;

++     lc_collate_var      = all.isEmpty() ? qgetenv("LC_COLLATE") : all;

++     QByteArray lang = qgetenv("LANG");

++     if (lang.isEmpty())

++         lang = QByteArray("C");

++     if (numeric.isEmpty())

++         numeric = lang;

++     if (time.isEmpty())

++         time = lang;

++     if (monetary.isEmpty())

++         monetary = lang;

++     if (lc_messages_var.isEmpty())

++         lc_messages_var = lang;

++     if (lc_measurement_var.isEmpty())

++         lc_measurement_var = lang;

++     if (lc_collate_var.isEmpty())

++         lc_collate_var = lang;

++     lc_numeric = QLocale(QString::fromLatin1(numeric));

++     lc_time = QLocale(QString::fromLatin1(time));

++     lc_monetary = QLocale(QString::fromLatin1(monetary));

++     lc_messages = QLocale(QString::fromLatin1(lc_messages_var));

++ }

++

++ Q_GLOBAL_STATIC(QSystemLocaleData, qSystemLocaleData)

++

++ } // unnamed namespace

++

++ static bool contradicts(QStringView maybe, const QString &known)

++ {

++     if (maybe.isEmpty())

++         return false;

++

++     /*

++       If \a known (our current best shot at deciding which language to use)

++       provides more information (e.g. script, country) than \a maybe (a

++       candidate to replace \a known) and \a maybe agrees with \a known in what

++       it does provide, we keep \a known; this happens when \a maybe comes from

++       LANGUAGE (usually a simple language code) and LANG includes script and/or

++       country.  A textual comparison won't do because, for example, bn (Bengali)

++       isn't a prefix of ben_IN, but the latter is a refinement of the former.

++       (Meanwhile, bn is a prefix of bnt, Bantu; and a prefix of ben is be,

++       Belarusian.  There are many more such prefixings between two- and

++       three-letter codes.)

++      */

++     QLocaleId knownId = QLocaleId::fromName(known);

++     QLocaleId maybeId = QLocaleId::fromName(maybe);

++     return !(maybeId.acceptLanguage(knownId.language_id) && maybeId.acceptScriptTerritory(knownId));

++ }

++

++ QLocale QSystemLocale::fallbackLocale() const

++ {

++     // See man 7 locale for precedence - LC_ALL beats LC_MESSAGES beats LANG:

++     QString lang = qEnvironmentVariable("LC_ALL");

++     if (lang.isEmpty())

++         lang = qEnvironmentVariable("LC_MESSAGES");

++     if (lang.isEmpty())

++         lang = qEnvironmentVariable("LANG");

++     // if the locale is the "C" locale, then we can return the language we found here:

++     if (lang.isEmpty() || lang == "C"_L1 || lang == "POSIX"_L1)

++         return QLocale(lang);

++

++     // ... otherwise, if the first part of LANGUAGE says more than or

++     // contradicts what we have, use that:

++     {

++         QString language = qEnvironmentVariable("LANGUAGE");

++         // We only look at the first entry:

++         if (const auto colon = language.indexOf(u':'); colon >= 0)

++             language.truncate(colon); // unshared QString; this is cheap

++         if (contradicts(language, lang))

++             return QLocale(language);

++     }

++

++     return QLocale(lang);

++ }

++

++ QVariant QSystemLocale::query(QueryType type, QVariant &&in) const

++ {

++     QSystemLocaleData *d = qSystemLocaleData();

++     if (!d)

++         return QVariant();

++

++     if (type == LocaleChanged) {

++         d->readEnvironment();

++         return QVariant();

++     }

++

++     QReadLocker locker(&d->lock);

++

++     const QLocale &lc_numeric = d->lc_numeric;

++     const QLocale &lc_time = d->lc_time;

++     const QLocale &lc_monetary = d->lc_monetary;

++     const QLocale &lc_messages = d->lc_messages;

++

++     switch (type) {

++     case DecimalPoint:

++         return lc_numeric.decimalPoint();

++     case Grouping:

++         return QVariant::fromValue(lc_numeric.d->m_data->groupSizes());

++     case GroupSeparator:

++         return lc_numeric.groupSeparator();

++     case ZeroDigit:

++         return lc_numeric.zeroDigit();

++     case NegativeSign:

++         return lc_numeric.negativeSign();

++     case DateFormatLong:

++         return lc_time.dateFormat(QLocale::LongFormat);

++     case DateFormatShort:

++         return lc_time.dateFormat(QLocale::ShortFormat);

++     case TimeFormatLong:

++         return lc_time.timeFormat(QLocale::LongFormat);

++     case TimeFormatShort:

++         return lc_time.timeFormat(QLocale::ShortFormat);

++     case DayNameLong:

++         return lc_time.dayName(in.toInt(), QLocale::LongFormat);

++     case DayNameShort:

++         return lc_time.dayName(in.toInt(), QLocale::ShortFormat);

++     case DayNameNarrow:

++         return lc_time.dayName(in.toInt(), QLocale::NarrowFormat);

++     case StandaloneDayNameLong:

++         return lc_time.standaloneDayName(in.toInt(), QLocale::LongFormat);

++     case StandaloneDayNameShort:

++         return lc_time.standaloneDayName(in.toInt(), QLocale::ShortFormat);

++     case StandaloneDayNameNarrow:

++         return lc_time.standaloneDayName(in.toInt(), QLocale::NarrowFormat);

++     case MonthNameLong:

++         return lc_time.monthName(in.toInt(), QLocale::LongFormat);

++     case MonthNameShort:

++         return lc_time.monthName(in.toInt(), QLocale::ShortFormat);

++     case MonthNameNarrow:

++         return lc_time.monthName(in.toInt(), QLocale::NarrowFormat);

++     case StandaloneMonthNameLong:

++         return lc_time.standaloneMonthName(in.toInt(), QLocale::LongFormat);

++     case StandaloneMonthNameShort:

++         return lc_time.standaloneMonthName(in.toInt(), QLocale::ShortFormat);

++     case StandaloneMonthNameNarrow:

++         return lc_time.standaloneMonthName(in.toInt(), QLocale::NarrowFormat);

++     case DateToStringLong:

++         return lc_time.toString(in.toDate(), QLocale::LongFormat);

++     case DateToStringShort:

++         return lc_time.toString(in.toDate(), QLocale::ShortFormat);

++     case TimeToStringLong:

++         return lc_time.toString(in.toTime(), QLocale::LongFormat);

++     case TimeToStringShort:

++         return lc_time.toString(in.toTime(), QLocale::ShortFormat);

++     case DateTimeFormatLong:

++         return lc_time.dateTimeFormat(QLocale::LongFormat);

++     case DateTimeFormatShort:

++         return lc_time.dateTimeFormat(QLocale::ShortFormat);

++     case DateTimeToStringLong:

++         return lc_time.toString(in.toDateTime(), QLocale::LongFormat);

++     case DateTimeToStringShort:

++         return lc_time.toString(in.toDateTime(), QLocale::ShortFormat);

++     case PositiveSign:

++         return lc_numeric.positiveSign();

++     case AMText:

++         return lc_time.amText();

++     case PMText:

++         return lc_time.pmText();

++     case FirstDayOfWeek:

++         return lc_time.firstDayOfWeek();

++     case CurrencySymbol:

++         return lc_monetary.currencySymbol(QLocale::CurrencySymbolFormat(in.toUInt()));

++     case CurrencyToString: {

++         switch (in.userType()) {

++         case QMetaType::Int:

++             return lc_monetary.toCurrencyString(in.toInt());

++         case QMetaType::UInt:

++             return lc_monetary.toCurrencyString(in.toUInt());

++         case QMetaType::Double:

++             return lc_monetary.toCurrencyString(in.toDouble());

++         case QMetaType::LongLong:

++             return lc_monetary.toCurrencyString(in.toLongLong());

++         case QMetaType::ULongLong:

++             return lc_monetary.toCurrencyString(in.toULongLong());

++         default:

++             break;

++         }

++         return QString();

++     }

++     case MeasurementSystem: {

++         const QString meas_locale = QString::fromLatin1(d->lc_measurement_var);

++         if (meas_locale.compare("Metric"_L1, Qt::CaseInsensitive) == 0)

++             return QLocale::MetricSystem;

++         if (meas_locale.compare("Other"_L1, Qt::CaseInsensitive) == 0)

++             return QLocale::MetricSystem;

++         return QVariant((int)QLocale(meas_locale).measurementSystem());

++     }

++     case Collation:

++         return QString::fromLatin1(d->lc_collate_var);

++     case UILanguages: {

++         if (!d->uiLanguages.isEmpty())

++             return d->uiLanguages;

++         QString languages = QString::fromLatin1(qgetenv("LANGUAGE"));

++         QStringList lst;

++         if (languages.isEmpty())

++             lst.append(QString::fromLatin1(d->lc_messages_var));

++         else

++             lst = languages.split(u':');

++

++         for (const QString &e : std::as_const(lst)) {

++             QStringView language, script, territory;

++             if (qt_splitLocaleName(e, &language, &script, &territory)) {

++                 QString joined = language.isEmpty() ? u"und"_s : language.toString();

++                 if (!script.isEmpty())

++                     joined += u'-' + script;

++                 if (!territory.isEmpty())

++                     joined += u'-' + territory;

++                 d->uiLanguages.append(joined);

++             }

++         }

++         return d->uiLanguages.isEmpty() ? QVariant() : QVariant(d->uiLanguages);

++     }

++     case StringToStandardQuotation:

++         return lc_messages.quoteString(qvariant_cast<QStringView>(std::move(in)));

++     case StringToAlternateQuotation:

++         return lc_messages.quoteString(qvariant_cast<QStringView>(std::move(in)),

++                                        QLocale::AlternateQuotation);

++     case ListToSeparatedString:

++         return lc_messages.createSeparatedList(in.toStringList());

++     case LocaleChanged:

++         Q_UNREACHABLE(); // handled before the switch

++     case LanguageId:

++     case TerritoryId:

++     case Weekdays:

++     case ScriptId:

++     case NativeLanguageName:

++     case NativeTerritoryName:

++         break;

++     }

++     return QVariant();

++ }

++ #endif // QT_NO_SYSTEMLOCALE

++

++ QT_END_NAMESPACE

Revision control