Fix a typo and swap two sentences to give a clearer reading.
Pick-to: 6.2
Change-Id: I4a24ad5ba2e022edd121eb686de3638af2c242a6
Reviewed-by: Paul Wicking <paul.wicking@qt.io>
Decrementing decDigits and checking for zero is less complicated than
incrementing a counter to check against it if it's not negative.
A plethora of unenlightening local variables could be replaced by
keeping track of the last character and of a simple state variable
that make checks easier to understand (and explain).
Various conditions could be expressed more simply.
Comment on the condition for omitting grouping characters from the
transcript - it was easy to mistake the comma for a dot !
Comment on the lack of checking of grouping sizes.
Change-Id: Iff8da2376507d2abbbaf5739baf6cbb23e55edaf
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Converting a negative signed value to its absolute value in the
matching unsigned type can be done by adding one, negating (which we
can now do without the UB), casting and then adding one again.
This is cleaner than casting the negative value to the unsigned type
in order to then "negate" it within that type, about which MSVC
grumbles; we can now avoid the need to suppress that grumble.
Change-Id: I9148ead23c928aeb2b90884a2f2e292fdf3af5e3
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Change it to take a QByteArrayView instead of a plain char *; all its
callers do know the size and propagating it enables the implementation
to call strntou?ll() rather than strtou?ll(), thereby escaping the
need for '\0'-termination.
Fixes: QTBUG-74286
Change-Id: Ie9394786e9fcf25c1d1be2421805f47c018d13bb
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
When checking whether a floating-point value is "inf" or "nan", the
code actually only checked they *started* with those. Check the
length first and thereby avoid the check when the string is longer in
any case. This incidentally avoids tripping over any string that
merely starts with "inf" or "nan" - such a string should not be able
to arise here; but we still shouldn't give it the special treatment
reserved for these two, were one to arise. Add an assertion to the one
remaining branch that wouldn't have caught such a malformed string.
Change-Id: I63828e3a99a33cf236e4d1a2e247ad832b7a00fd
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Move the documentation of the format and precision parameters to
QLocale::toString(double, char, int), reference it from various
QString methods (instead of repeating there and referencing one of
those from QLocale). Add brief first lines for various documentation
comments.
Mention the special handling of negative precision in the moved
documentation. Mention QLocale::FloatingPointShortest, add its type to
\sa lines of methods it affects. Change a comment on some code
implementing its special treatment to make clear that it does apply to
'e' and 'f' formats, not only to 'g', even though it has no overt
special handling in that code; and update docs to report the
undocumented behavior the comment previously described.
Document how infinity and NaN are represented. Be somewhat more
consistent about single-quoting the format names where referred to and
applying \c to character constants.
Make clear what things are different between different methods using
these parameters. Reference QString::number() from QByteArray's
relevant methods, since they share its quirks.
In the process, rename the format and precision parameters of relevant
functions so they're consistently named, replacing a mixture of
abbreviated forms.
Pick-to: 6.2
Change-Id: I077521b30346000e4b4f6968a8e750e934f72937
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Because we're using a thread-specific global static, we need to recreate
the QCollator type every time setDefault() is called. Since one is
stored per-thread, we simply increment a generational counter and check
that the next time that QString::localeAwareCompare is called in each
thread.
The issue was introduced on f6425da424
(5.12) even though we were supposed to be using QCollator since commit
5279134935 (5.3).
Fixes: QTBUG-95050
Pick-to: 6.2
Change-Id: I7e0b82c2d2fe464082d8fffd1696a8c9f74e5b30
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
wholePartSpace asserts that its input is >= 0, but NaN is not a number
Change-Id: Iafc075663d5f8841f21edf0a3d4d36694287a51f
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
* Change all outbound links in user-facing documentation.
* Reflow lines that exceed 100 cols as mandated by clang-format.
* Add unicode.org as a global \externalsite.
Pick-to: 6.2 6.1 5.15
Change-Id: I2ba1e434aa913e678406d62c2801f1a8b2d9e4f4
Reviewed-by: Topi Reiniö <topi.reinio@qt.io>
Previously, for locales other than the system locale, no entry was
added to the list for the actual locale whose variants - with and
without likely sub-tags - were being appended. In most cases the
standard name will in fact coincide with the variant without likely
sub-tags, so this was unlikely to cause a problem, but it should be
present regardless.
At the same time, turn tst_QLocale::uiLanguages() into a data-driven
test and add another row to its table.
Change-Id: I5cb2d805d78fc3415d82b169caa6154b0f284708
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Previously, the augmentation wasn't being applied to the system
locale, due to a mistaken test claiming the locale's name didn't
resemble the string from which it was constructed. The test dates from
before various fixes to likely sub-tag processing that should make it
redundant now. This makes QLocalePrivate::rawName() also redundant
(and its conversion of QLatin1String to QByteArray relied on '\0'
termination which wasn't actually present in the various codes).
Expanded the test of systemLocale() to also test uiLanguages() turns a
single entry into the list we expect; and add two new test-cases.
(The test uses a mock system locale class, making this independent of
the platform backend.)
Fixes: QTBUG-92234
Pick-to: 6.1 5.15
Change-Id: I0cdf6eae152a42dc377f4ea3e62c282ff4be1764
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
CLDR v39 has no locales for Abkhazian, so the locale_index[] entry for
it actually indexes the last entry before the next language up the
enum. This has m_language_id less than Abkhazian.
Change-Id: If8b88f30476a981b3ee00ff8760a46ede0b7aab7
Reviewed-by: Morten Johan Sørvig <morten.sorvig@qt.io>
It was originally marked \obsolete without any comment on what was to
be used to replace it, or deprecation markings in the declaration, so
it got missed at 6.0. More recently it's been deprecated in favor of a
territory-based name; but actually it was obsoleted by (iterating the
territory() of each return from) matchingLocales() in Qt 4.8.
So back out of adding territoriesForLanguage to replace it and,
instead, mark it as deprecated in the declaration, in favor of
matchingLocales(). Also rewrite the implementation to be exactly that
replacement. Rewrote the one example using it.
Fixes: QTBUG-92484
Change-Id: Iedaf30378446dd9adac5128b7ee5fee48aab1636
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Documented the fall-back process by which QLocale selects an actual
locale based on what it is asked for. The prior documentation was
wrong.
In the process, removed some out-of-date claims about QString's
toInt() and toDouble() caring about the default locale; and caught a
few more cases (in \internal docs) of country -> territory.
Fixes: QTBUG-90962
Change-Id: I5e7cfa66443c9335a71fb2048c3f2ebf7af64573
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
The use of "Country" is misleading as some entries in the enumeration
are not countries (eg, HongKong), for all that most are. The Unicode
Consortium's Common Locale Data Repository (CLDR, from which QLocale's
data is taken) calls these territories, so introduce territory-based
names and prepare to deprecate the country-based ones in due course.
[ChangeLog][QtCore][QLocale] QLocale now has Territory as an alias for
its Country enumeration, and associated territory-based names to match
its country-named methods, to better match the usage in relevant
standards. The country-based names shall in due course be deprecated
in favor of the territory-based names.
Fixes: QTBUG-91686
Change-Id: Ia1ae1ad7323867016186fb775c9600cd5113aa42
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Quoting from https://en.wikipedia.org/wiki/ISO_3166:
"ISO 3166 is a standard published by the International
Organization for Standardization (ISO) that defines
codes for the names of countries, dependent territories,
special areas of geographical interest, and their
principal subdivisions (e.g., provinces or states).
The official name of the standard is Codes for the
representation of names of countries and their subdivisions."
In order to prevent the word "Country" from causing ambiguity, the
document should clearly state that this enumeration refers to a country
or region.
Change-Id: I05543faa4193b3ddaf31d02c670b4b5f46e94389
Reviewed-by: Paul Wicking <paul.wicking@qt.io>
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
This complements patch a148c7b5d71d244, where languageToCode(),
countryToCode() scriptToCode() methods were introduced, with matching
codeToLanguage(), codeToCountry(), and codeToScript() methods.
This allows us to remove the use of private Qt Core API in Qt Linguist.
[ChangeLog][QtCore][QLocale] Added static codeToLanguage(),
codeToCountry(), codeToScript() methods that convert ISO code strings
to the respective enum values.
Change-Id: If5c0843a718c006ade086a6f74ceb86ac6e0fce4
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
Currently the codes are only exposed in aggregated form, i.e. through
name(), bcp47Name(). There are use cases though where you are only
interested in either language, country, or script codes. One example
is in Qt Linguist.
This patch therefore exposes the static languageToCode(),
countryToCode(), scriptToCode() methods that were so far only available
in the private API also in the public API.
[ChangeLog][QtCore][QLocale] Added static languageToCode(),
countryToCode() scriptToCode() methods that convert enum values
to the respective ISO code strings.
Fixes: QTBUG-39542
Fixes: QTBUG-64942
Change-Id: Ib1d5c3293e2f53245ba4c1fc8159275bcb290080
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
The code using it got removed in qttools commit 01da5d9a
Change-Id: I14d36ac939f2647139fcc42591a044a03e707553
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
Up to 5.15.0, QDateTime::fromString(), when parsing a string that
matched the format but represented a date-time in a spring-forward's
gap, would return an invalid date-time object that represented a "best
shot" date-time, correcting the error in the string as best it could.
In 5.15, in order to handle time-spec information correctly, we
adapted the date-time parser to have a fromString() variant that
parsed a date-time as a whole, rather than as a date and a time; as a
result, QDTP::fromString() now returns false and QDT::fromString()
returned a default-constructed instance instead of the invalid
date-time that QDTP had produced.
Amend 7605451604 to restore the prior
behavior of returning the invalid date-time object from QDTP instead
of a default-constructed invalid date-time. Also document what this
implies for the caller's ability to recover from the situation, if a
best shot result is better than nothing.
[ChangeLog][QtCore][QDateTime] Restored pre-5.15.0 behavior when
parsing a date-time from a string (and document what it implies): if
the string has the right form but represents a date-time that was
skipped by a time-zone transition (e.g. a DST spring-forward), the
invalid date-time object returned can, none the less, be used to
recover a near-by date-time that may be more useful in some cases.
From 5.15.0 to 5.15.2 and in 6.0.0, a default-constructed QDateTime
was returned in place of this more informative invalid date-time.
Task-number: QTBUG-88633
Pick-to: 6.0 5.15
Change-Id: If0b439038d5fe48eefb951c62f3aae2933bb5651
Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Some of the new functions were added without documentation, or without
updating the docs to mention the optional calendars. Shuffle the
methods so that the one with calendar is what the primary
documentation comment describes and the one without is documented as
an overload.
Pick-to: 5.15
Change-Id: Iee4cdb1d3b0ed21a50e205a5275a0695a2667550
Reviewed-by: Paul Wicking <paul.wicking@qt.io>
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
For bases other than 10, negative numbers have been converted
to QString by casting them to an unsigned number and
converting that. Thus QString::number(-17, 16) returned
"0xffffffffffffffef", for example.
This patch changes the behavior so that
negative numbers are converted like positive numbers.
Additinally, this patch adds unit tests for QString::number.
[ChangeLog][Important Behavior Changes]
Changed QString::number(integer, base) for negative numbers
and bases other than 10 to return the string corresponding
to the absolute value, prefixed by "-".
Fixes: QTBUG-53706
Change-Id: I0ad3ca3f035d553860b262f5bec17dc81714d8ac
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
We were extracting several candidate display names from CLDR for each
currency, joining them with semicolons, storing in a table, then using
only the first entry from the list - where we should probably have
used the first non-empty entry in any case.
So instead extract the first non-empty candidate name from CLDR and
store that simply, saving the need for semicolon-joining or parsing
out the first entry from the thus-joined list. This significantly
reduces the size of the currency name data table.
Change-Id: I201d0528348d5fcb9eceb5df86211b9c77de3485
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Make declarations use same parameter name as implementation and
documentation, in the process. Fixed indent of some doc comments.
Change-Id: Ibaa3a5f6316a16c5b65f6ea6e0034f4eb2864b98
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Two of its callers didn't even care about the fragments it was
returning, one only cared about two of them. The parsing could be more
straightforward and less verbose. Parsing into QStringView saves the
need to allocate copies of the substrings parsed. Cleaned up around
the code that called it.
Change-Id: Ie65d2b1b3eb891c20bc82275d7a0da00c30d7b8d
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
While simplifying uses of QSystemLocale::query() I declared a
shadowing local variable instead of setting a function-scope variable
that the code had previously set. Restore prior correct behavior.
Fixup for commit b5bc3ee036.
Fixes: QTBUG-87858
Change-Id: I6bd64aef1eb7df9ec4a703c59aa7369245ab2472
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
This patch reduced the runtime of "QString::number(12345678)"
from 119ns to 84ns in one measurement. It removes one copy of a
QString into a local lambda function, it adds a std::move on
return, removing another QString instantiation and it removes
the usage of StringBuilder on return, which created another QString.
Task-number: QTBUG-87330
Change-Id: Ia37e314353c354ae04402cd482d0f7aeabbfc0cb
Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
Instead of looking up each candidate pattern in a separte O(log(n))
search, exploit the fact that the array is in the right order to put
each candidate we try after the ones we'd have preferred over it.
At the same time, add und_script_region and und_region searches, which
aren't mentioned in the spec's algorithm but are clearly meant to be
searched (the spec's examples include some). Also, document what's
going on - because it's a bit complicated !
Change-Id: Id88ced335b0d2dfd18fb59c9a3dc75571f2a44ef
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Follow through on a comment from 2012: sort the likely subtag array
(in the CLDR update script) and use bsearch to find entries in it.
This simplifies QLocaleXmlReader.likelyMap() slightly, moving the
detection of last entry to LocaleDataWriter.likelySubtags(), but
requires collecting all likely sub-tag mapping pairs (rather than just
passing them through from read to write via generators) in order to
sort them.
Change-Id: Ieb6875ccde1ddbd475ae68c0766a666ec32b7005
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Be up front about using new in all the places where it's created.
Made one of the global statics into a function-local static.
Eliminated a static made redundant by its const sibling.
Made two members const now that they can be.
Change-Id: I46532b3c1e0e62d1f8c84f55494f70cff09d4404
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
This means always initializing globalLocaleData from an entry in the
locale_data array, where in principle the fallbackUiLocale() could be
the system locale, which isn't held in the array. However, no actual
implementation of fallbackUiLocale() uses the system locale (nor is it
clear this would work if one did).
Change-Id: Ie1c5ef3e8a97f21e0d82fa2dfb3cf3eb9e4c8840
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
Calling systemData() locks a mutex but the tests against its return
are just testing whether some m_data we're looking at is the
&globalLocaleData it's returning; any other m_data points into the
locale_data global array. So bypass the expensive mutex for these
tests and just compare against the pointer systemData() would be
returning.
Thanks to Andreas Buhr <andreas.buhr@qt.io> for the analysis that
showed the need for this.
Task-number: QTBUG-87330
Change-Id: Ib06233773511dc9d532cb4658319b6d589d17b56
Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Previously, two calls using the default locale (which has an index in
the locale_data array when it isn't the system locale) neglected to
pass the index and the call for the system locale had no idnex, where
it should really set the index appropriate to its language, script and
country, so that we get appropriate calendar data to go with the
system locale. One other place that handled the default locale also
neglected to revise the index it was using.
Change-Id: I4cc52e2d085a99e61236c91c0ae873b3bde5f11d
Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Various uses of uint were simply redundant, now that Language, Script
and Country are ushort-based. Others should in any case have been
quint16 or char32_t.
Change-Id: Id0d0dc2558e1724907907cde56059f70972e824a
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Pass a single argument in place of three; and (prepare to) replace
QLocalePrivate::getLangAndCountry(), taking three out parameters, with
QLocaleId::fromName(). Removal of getLangAndCountry() must wait for
removal of linguist's use of it in qttools, which has to wait for this
change to land in qtbase. In the process, change findLocaleIndex()'s
return to int.
Change-Id: I9f5c44c41f2dd1598c53ed5ccb0abddc6b17d21f
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Instead of returning a pointer (from which we then have to infer an
index for use in calendar data access), compute the index as primary
and infer the data pointer from it. Also refer to the index as such,
rather than as an offset.
Comments advocating this wanted to dispense with the pointer entirely;
that's not an option, however, due to the system locale having its
data in a separate object, outside the array that contains all the
other locales' data.
Change-Id: I1c60e688229394003e61372dbfc6cfb11086eafa
Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Give QLocaleId matchesAny() and isValid() checks and some acceptance
tests for their use as filters. Give QLocaleData a QLocaleId id().
A few messy pieces of code get easier to read.
In the process, greatly simplify a do-while loop (sacrificing some
pretest-before-loop optimizations - benchmarking shows they made
negligible difference) and change a while loop to match its form,
since it was doing essentially the same iteration and (thus) its
condition was guaranteed true on the first iteration.
Change-Id: I36b1a6ca8a3cf350b3f3abbe75b177e5a7637cd8
Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Update docs to match. Add note on the conditions for equality.
Change-Id: I973b7a5dae3fae2e62f8a0d1db1f3115d24bee8b
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
[ChangeLog][QtCore][QLocale] Deprecated several Language and Country
aliases, ready for removal in Qt 6.0, in favor of their newer names.
Task-number: QTBUG-84669
Pick-to: 5.15 5.15.2
Change-Id: Iebaa0a5a77bfa12f7014de53fab4a25b5f1cc92c
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Looking up a locale with unspecified language got the C locale, due to
taking a short-cut that would make sense if no locale were found for a
specified language. Stop assuming the language was specified.
Task-number: QTBUG-74287
Pick-to: 5.15 5.12
Change-Id: I8b3c232da584fb187ebb6c190729c377d0083808
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Clarify that the "minus sign" is a plain ASCII U+002D dash, not U+2212
minus sign; and, for symmetry, that the underscore is U+005F.
Change-Id: I7250959d36e56f960dac24a739a1a8826a6bc578
Reviewed-by: Paul Wicking <paul.wicking@qt.io>
It was always called in pairs, first with likely sub-tags added, then
with the base that started from. So doing a likely sub-tag lookup
inside the function was redundant for the former while making the
latter redundant - and it's needed.
Task-number: QTBUG-84669
Pick-to: 5.15
Change-Id: I18bf1d4976a51d9436efd20d1a84a36cfc60f618
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
A loop's condition could be simplified.
Use std::size() rather than sizeof()/sizeof().
Clarify two comments.
Change-Id: Ideba2e0e1ba9c9656297aefb0a375cc122ee8626
Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
It's a value type, we don't need a pseudo-constructor to bypass constructors.
Change-Id: Ic4774c82e43ab7e2c54ac743026ce087e34c150f
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
Mostly related to qstrlen().
Change-Id: I69e2052c83766e4fc466ed398d0d0eac011a77ec
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Reviewed-by: Oliver Wolff <oliver.wolff@qt.io>
Also catch some stray ushort that should be char16_t by now, use
unicode character values for some constants and rename a UCS2 variable
to not claim it's UCS4.
Change-Id: I374b791947f5c965eaa22ad5b16060b475081c9d
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
We already manage to compile without this code, and none of it are full
classes or separate functions suitable for qt5compat.
Change-Id: I47facac7ec621cfc4b0b26214b7de37897443519
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io>
Since 5.15 - toTime() with a calendar in the argument list
The calendar was never used.
Change-Id: I37897d47b42e69d1a8312e6389d6349febb889ae
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
This only arises when the system locale tells us to use its zero as
our zero digit, since no CLDR locale uses it by default. Adapt an
MS-specific QLocale::system() test to use Suzhou numbering, so as to
test this.
While updating the locale-restoration code to also restore the digits
being set in that test, add restore code for the long time format,
where previously only the short time format was restored. Add a
comment to make it less likely one of those shall be missed in future.
Fixes: QTBUG-85409
Change-Id: I343324bb563ee0e455dfe77d4825bf8c3082ca30
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
QVariant::isNull() shall no longer return true when the variant does
package an object, but that object's isNull() is true, so take care to
catch QString-wrapping returns that contain an empty string, except
where this is a valid return. Generally tidy code processing the
returned value.
At the same time, make the second argument of query() optional, since
it's only used by a subset of the query types.
Change-Id: I3dba9a59260f9f182ca277784c77277e2ea255e2
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Read three more values from CLDR and add a byte to the bit-fields at
the end of QLocaleData, indicating the three group sizes. This adds
three new parameters to various low-level formatting functions. At the
same time, rename ThousandsGroup to GroupDigits, more faithfully
expressing what this (internal) option means.
This replaces commit 27d1391280 with a
fuller implementation that handles digit-grouping in any of the ways
that CLDR supports. The formerly "Indian" formatting now also applies
to at least some locales for Bangladesh, Bhutan and Sri Lanka.
Fixed Costa Rica currency formatting test that wrongly put a separator
after the first digit; the locale (in common with several Spanish
locales) requires at least two digits before the first separator.
[ChangeLog][QtCore][Important Behavior Changes] Some locales require
more than one digit before the first grouping separator; others use
group sizes other than three. The latter was partially supported (only
for India) at 5.15 but is now systematically supported; the former is
now also supported.
Task-number: QTBUG-24301
Fixes: QTBUG-81050
Change-Id: I4ea4e331f3254d1f34801cddf51f3c65d3815573
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Break out some shared code in the integer formatting to save
duplicating it. Simplify what's left.
Renamed some variables to match Qt style.
Change-Id: I369a013802a267a94725302de0d1d33291c29538
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Instead of passing lots of instance data around among public static
methods and functions in qlocale_tools, do the work in instance
methods that can access the relevant attributes of the locale when
they need them. Incidentally reduces clutter in the global namespace.
Add a signPrefix() to handle a repeated computation. Keep new internal
methods private.
Change-Id: I9556a960acac9fb645872337c61f509fb902984e
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
During review of a refactor (coming shortly), Thiago wondered what the
magic numbers were. On closer examination, I concluded that they were
wrong and wrote some tests to prove it. This commit adds those tests;
replaces the misguided old code with something that passes them; and
documents the reasons for the various parts of its decisions.
In the process, tidy up QLocaleData::doubleToString() somewhat and
rename some of its variables to conform to Qt coding style.
Change-Id: Ibee43659b1bdb0707639cdb444cfe941c31d409f
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
As a comment noted, the reason for QLocaleData rolling its own values
describing the ranges of digits and exponents in a double were all
about std::numeric_limits's constants not being constexpr - which they
have now been since C++11, so we can do away with our own.
One of the constants was used in two places in the same way; so
abstract that use out into an inline function in qlocale_tools, to
save duplication and give somewhere to document it.
Change-Id: I7e3740ece9b499c0ec434de18d70abe69e1fe079
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Omitting state machine and docs for now.
Task-number: QTBUG-84469
Change-Id: Ibfa5e7035515773461f6cdbff35299315ef65737
Reviewed-by: Sona Kurazyan <sona.kurazyan@qt.io>
There is no reason for keep using our macro now that we have C++17.
The macro itself is left in for the moment being, as well as its
detection logic, because it's needed for C code (not everything
supports C11 yet). A few more cleanups will arrive in the next few
patches.
Note that this is a mere search/replace; some places were using
double braces to work around the presence of commas in a macro, no
attempt has been done to fix those.
tst_qglobal had just some minor changes to keep testing the macro.
Change-Id: I1c1c397d9f3e63db3338842bf350c9069ea57639
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
The QStringView versions will do the job just fine :)
Task-number: QTBUG-84319
Change-Id: I376b310deb27683fd98bbcc55e0f56014cacecc3
Reviewed-by: Alex Blasche <alexander.blasche@qt.io>
LongFormat and ShortFormat are not limited to day and month names.
Different locales might also use numbers for months instead of strings,
so the example is a bit misleading.
Instead of extending the enum description even more there's now
examples in the dateFormat(), timeFormat(), dateTimeFormat()
functions.
Task-number: QTBUG-83841
Pick-to: 5.15
Change-Id: Icea2cbce7e9505d706a2171e7d1f4486abdb20be
Reviewed-by: Paul Wicking <paul.wicking@qt.io>
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
A check to prevent crash-on-exit if QLocale::setDefault() was called
after the default store was torn down had the side-effect of causing
setDefault() to not record data if it was called before the first
access to the default store caused it to come into being.
Change the check to test that the default store has been destroyed
and, if not, create it if it doesn't exist yet. This refines commit
4d6572aac0 (as modified by commit
11c5c078c7).
Fixes: QTBUG-83016
Fixes: QTBUG-83415
Pick-to: 5.15
Change-Id: Icbce9bd9c75d0258d403e2f90957561b5a18bdf3
Reviewed-by: Andrei Golubev <andrei.golubev@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
This is a folllow-up to commits
548513a4bd and
a9aa206b7b, renaming the snippets files
referenced by the files moved out of corelib/tools/ to match the new
locations of the files using them.
Change-Id: I59f5d3c217ef835e9244387cc769e7212de9d8f5
Reviewed-by: Paul Wicking <paul.wicking@qt.io>
Also replace one case of QChar(0) with QChar::Null.
These were errors in my local tree, which means they're included in
bootstrap builds (incl. qmake).
Change-Id: I3dffa9383fd1a30aa43fe2491ad95bb2b1869b40
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Add a helper function so that we have a shortcut.
Instead of writing:
QHashCombine hash;
seed = hash(seed, fieldA);
seed = hash(seed, fieldB);
// etc.
return seed;
one can now simply write:
return qHashMulti(seed, fieldA, fieldB, fieldC);
Port a few usages inside qtbase as a demonstration.
[ChangeLog][QtCore][QHash] Added the qHashMulti and
qHashMultiCommutative functions as convenience helpers
to calculate a hash from multiple variables (typically,
data members of a class).
Change-Id: I881a9ad41168df20ceecc6588a94abe7ddc6a532
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Reviewed-by: Marc Mutz <marc.mutz@kdab.com>
When a date-time was parsed from a string, the result was equal (as a
date-time) to the correct value, but had (at least in some cases) the
wrong spec, where it should have had a spec reflecting the zone
specifier parsed.
The time-spec imposed for the benefit of QDateTimeEdit is now moved
from QDateTimeParser to QDateTimeEditPrivate, which takes over
responsibility for imposing it. QDateTimeParser assumes Qt::LocalTime
in member functions (where applicable) and uses the time-spec parsed
from the string when constructing the date-time.
QDateTime::fromString() and QLocale::toDateTime() are updated to
use the full QDateTime returned by QDateTimeParser.
Fixes: QTBUG-83075
Done-With: Edward Welbourne <edward.welbourne@qt.io>
Change-Id: I8b79add2c7fc13a200e1252d48dbfa70b36757bf
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
This is a follow-up to commit ed2b110b6a
to fix indexing errors. Added the test that should have accompanied
that commit, which found some bugs, and refined the Indian number
formatting test (on which it's based).
Make variable i in the loops that insert grouping characters in a
number be consistently a *character* offset - which, when each digit
is a surrogate pair, isn't the same as an index into the
QString. Apply the needed scaling when indexing with it, not when
setting it or decrementing it. Don't assume the separator has the same
width as a digit.
Differences in index no longer give the number of digits between two
points in a string, so actively track how many digits we've seen in a
group when converting a numeric string to the C locale. Partially
cleaned up the code for that in the process (more shall follow when I
sort out digit grouping properly, without special-casing India).
Change-Id: I13d0f24efa26e599dfefb5733e062088fa56d375
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Fix some warnings that are flagged as errors on clang10.
Change-Id: I906634c8b2bd94db42d74a7f3d10efb086e373cc
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
This is required, so that QHash and QSet can hold more
than 2^32 items on 64 bit platforms.
The actual hashing functions for strings are still 32bit, this will
be changed in a follow-up commit.
Change-Id: I4372125252486075ff3a0b45ecfa818359fe103b
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
It's what they are, so const refs are needless burden.
In the process, consolidate two of the affected methods (one of which
just adds another argument to the other's signature) into one.
Change-Id: I80de35ffe078a652d1999889dede0b10302abaa9
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Extract the character in its proper unicode form and encode it in a
new single_character_data table of locale data. Record each entry as
the range within that table that encodes it. Also added an assertion
in the generator script to check that the digits CLDR gives us are a
contiguous sequence in increasing order, as has been assumed by the
C++ code for some time. Lots of number-formatting code now has to take
account of how wide the digits are.
This leaves nowhere for updateSystemPrivate() to record values read
from sys_locale->query(), so we must always consult that function when
accessing these members of the systemData() object. Various internal
users of these single-character fields need the system-or-CLDR value
rather than the raw CLDR value, so move QLocalePrivate's methods to
supply them down to QLocaleData and ensure they check for system
values, where appropriate first.
This allows us to finally support the Chakma language and script, for
whose number system UTF-16 needs surrogate pairs.
Costs 10.8 kB in added data, much of it due to adding two new locales
that need surrogates to represent digits.
[ChangeLog][QtCore][QLocale] Various QLocale methods that returned
single QChar values now return QString values to accommodate those
locales which need a surrogate pair to represent the (single
character) return value.
Fixes: QTBUG-69324
Fixes: QTBUG-81053
Change-Id: I481722d6f5ee266164f09031679a851dfa6e7839
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Conflicts:
examples/widgets/graphicsview/boxes/scene.h
src/corelib/Qt5CoreMacros.cmake
src/corelib/Qt6CoreMacros.cmake
src/network/ssl/qsslsocket.cpp
src/network/ssl/qsslsocket.h
src/platformsupport/fontdatabases/windows/qwindowsfontenginedirectwrite.cpp
src/testlib/CMakeLists.txt
src/testlib/.prev_CMakeLists.txt
tests/auto/corelib/tools/qscopeguard/tst_qscopeguard.cpp
Disabled building manual tests with CMake for now, because qmake
doesn't do it, and it confuses people.
Done-With: Alexandru Croitor <alexandru.croitor@qt.io>
Done-With: Volker Hilsheimer <volker.hilsheimer@qt.io>
Change-Id: I865ae347bd01f4e59f16d007b66d175a52f1f152
On macOS it's possible to configure the system locale to not do digit
grouping (separating "thousands", in most western locales); it then
returns an empty string when asked for the grouping character, which
QLocale's system-configuration then ignored, falling back on using the
base UI locale's grouping separator. This could lead to the same
separator being used for decimal and grouping, which should never
happen, least of all when configured to not group at all.
In order to notice when this happens, query() must take care to return
an empty QString (as a QVariant, which is then non-null) when it *has*
a value for the locale property, and that value is empty, as opposed
to a null QVariant when it doesn't find a configured value. The caller
can then distinguish the two cases.
Furthermore, the group and decimal separators need to be distinct, so
we need to take care to avoid cases where the system overrides one
with what the CLDR has given for the other and doesn't over-ride that
other.
Only presently implemented for macOS and MS-Win, since the (other)
Unix implementation of the system locale returns single QChar values
for the numeric tokens - see QTBUG-69324, QTBUG-81053.
Fixes: QTBUG-80459
Change-Id: Ic3fbb0fb86e974604a60781378b09abc13bab15d
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
The calendar is ignored, so adding these methods was a mistake.
[ChangeLog][QtCore][QLocale] Deprecated toTime() variants taking a
calendar. The calendar is ignored in time parsing.
Change-Id: I79fa994ce88f13fdb931163b447eb1a9ad655c09
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>
This enables us to make the sizes quint8 and benefit from the
resulting packing, making the locale data smaller. The sizes for long
month-name lists (which concatenate twelve names with semicolon as
separator) can overflow an 8-bit member, so use quint16 where needed.
Re-ordered the data in QLocaleData and QCalendarLocale. Now all
long-short(-narrow) families arise in that order; and any standalone
is grouped with the one of the same length. (This cost 20 bytes in the
date-format table, which optimises out more duplication if short is
before long, but the saving in the (smaller) time-format table more
than make up for it; and 20 bytes isn't worth the confusion that being
inconsistent in ordering might cause.)
At the same time, drop trailing semicolons from list entries (which
join various names with semicolon) as they're not needed: we know
where the end of the list is, because we know the size of the string
that results from concatenation. The code that parses such lists can
even correctly handle empty entries at the end.
Saves 26 kB of data in the compiled binaries.
Task-number: QTBUG-81053
Change-Id: If6ccc96a6910828817aa605d10fd814f567ae1e8
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Add QLocaleData::DataRange and methods returning it, to package each
of the m_*_idx, m_*_size pairs of data members, to simplify access to
these data. This extends the experiment started in QCalendarLocale,
which is now adapted to use the new DataRange also. Two static
functions of qlocale.cpp are replaced by methods of DataRange, saving
considerable duplication of long member names in callers.
Change-Id: Iad9899ba72f00522594b55a0402baec47491999c
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
We have long (since 4.5.1) coerced it to lower-case, for no readily
apparent, much less documented, reason. CLDR says most locales use an
upper-case E for this - let's actually use what CLDR says we should
use.
The code that matches the exponent separator was doing so
case-insensitively in any case; that needed adaptation now that the
separator's case isn't pre-determined; and, in any case, should have
been done using case-folding rather than upper-casing. In the process,
removed some spurious checks for "'e' or 'E'" in the result, since the
exponent separator is always represented by 'e' (and an 'e' might also
be present for the separate reason of its use as a beyond-decimal
digit representing fourteen).
[ChangeLog][QtCore][QLocale] QLocale::exponential() now preserves the
case of the CLDR source, where previously it was lower-cased.
Change-Id: Ic9ac02136cff79cb9f136d72141b5dbf54d9e0a6
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
QSystemLocale::query() can return an empty string for PositiveSign on
Windows, apparently. In any case, we shouldn't be taking .at(0) of a
QString without checking it's non-empty.
Fixes: QTBUG-81530
Change-Id: I4d496a2650362f225d02998bd7b8be9fd783edb4
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io>
I made a clazy automated check that replaced the use of QVariant::Type
by the equivalent in QMetaType.
This has been deprecated since Qt 5.0, but many uses were not yet removed.
In addition, there was some manual changes to fix the compilation errors.
Adapted the Private API of QDateTimeParser and QMimeDataPrivate
and adjust QDateTimeEdit and QSpinBox.
QVariant(QVariant::Invalid) in qstylesheet made no sense.
But note that in QVariant::save, we actually wanted to use the non-user type.
In the SQL module, many changes were actually reverted because the API
still expects QVarient::Type.
Change-Id: I98c368490e4ee465ed3a3b63bda8b8eaa50ea67e
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
On iOS, it was no longer using the Cocoa specific code needed to get
the locale and uiLanguages information so this functionality is brought
back as it was accidently lost.
In addition, this has a side-effect of fixing a problem with Android
versions below API 24 where it has no UiLanguages functionality so it
gets the information based on the system locale as a fallback.
Fixes: QTBUG-81307
Fixes: QTBUG-81357
Change-Id: I1709675b5bd5e9cedefb99eaec28279f20a347a4
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
It had create()'s default number options when passed to create, so
wasn't useful then; and otherwise shadowed the value held by the
cached private for the default locale. Noticed in the course of adding
an analogous global for the system locale.
Drive-by - eliminated a redundant language != C check.
Change-Id: I5601dc09188804c11dede5be460bfdd12b8152ce
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Add missing \sa lines, clarify what the exponential character is and
mention that C is an exception to the "no number options set".
Change-Id: I13ca483a07738908640408e0ca512de31586cec9
Reviewed-by: Paul Wicking <paul.wicking@qt.io>
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
The QLocale methods that report the fragments used in making up
numbers all return QChar. A note dating from before Qt5 times warned
that we need to change these to return QString (since we might need a
surrogate pair to represent the relevant characters). Give advance
warning in the documentation that this shall happen at Qt 6.
[ChangeLog][QtCore][QLocale] decimalPoint(), groupSeparator(),
percent(), zeroDigit(), negativeSign(), positiveSign() and
exponential() still return QChar but shall be changed to return
QString in Qt 6. Callers are encouraged to switch to QString early,
exploiting the QString(QChar) constructor.
Task-number: QTBUG-81053
Change-Id: Ia802c7665676ecf13669c6a6f173f2e70eac578e
Reviewed-by: Paul Wicking <paul.wicking@qt.io>
When QLocale::Country is set to QLocale::India numbers are written so that
after first three from the right and then after every second will be comma.
E.g. 10000000 is written as 1,00,00,000
Task-number: QTBUG-24301
Change-Id: Ic06241c127b0af1824104f94f7e2ce6e2058a070
Reviewed-by: Venugopal Shivashankar <Venugopal.Shivashankar@qt.io>
Reviewed-by: Teemu Holappa <teemu.holappa@qt.io>
Edward Welbourne
Thiago Macieira
Mårten Nordheim
Nico Vertriest
Paul Wicking
JiDe Zhang
Tasuku Suzuki
Tor Arne Vestbø
Kai Köhne
Andreas Buhr
Friedemann Kleint
Allan Sandfeld Jensen
Jarek Kobus
Giuseppe D'Angelo
Lars Knoll
Marc Mutz
Qt Forward Merge Bot
Andrei Golubev
Liang Qi
Olivier Goffart
Andy Shaw
Tuomas Heimonen