Merge remote-tracking branch 'origin/wip/qt6' into wip/cmake

Change-Id: I715b1d743d5f11560e7b3fbeb8fd64a5e5ddb277

10 files changed, 386 insertions, 192 deletions

diff --git a/util/glgen/codegenerator.cpp b/util/glgen/codegenerator.cpp
index 4627daa48b..08327a62f5 100644
--- a/util/glgen/codegenerator.cpp
+++ b/util/glgen/codegenerator.cpp
@@ -184,7 +184,7 @@ void CodeGenerator::writeCoreFactoryImplementation(const QString &fileName) cons
 
     // Get the set of version functions classes we need to create
     QList<Version> versions = m_parser->versions();
-    qSort(versions.begin(), versions.end(), qGreater<Version>());
+    std::sort(m_versions.begin(), m_versions.end(), std::greater<Version>());
 
     // Outout the #include statements
     stream << QStringLiteral("#if !defined(QT_OPENGL_ES_2)") << endl;
diff --git a/util/glgen/legacyspecparser.cpp b/util/glgen/legacyspecparser.cpp
index 0f4d085bba..ab2c9495e7 100644
--- a/util/glgen/legacyspecparser.cpp
+++ b/util/glgen/legacyspecparser.cpp
@@ -291,7 +291,7 @@ void LegacySpecParser::parseFunctions(QTextStream &stream)
     }
 
     m_versions = versions.toList();
-    qSort(m_versions);
+    std::sort(m_versions.begin(), m_versions.end());
 }
 
 bool LegacySpecParser::inDeprecationException(const QString &functionName) const
diff --git a/util/lexgen/generator.cpp b/util/lexgen/generator.cpp
index 481d586e73..3b966e025b 100644
--- a/util/lexgen/generator.cpp
+++ b/util/lexgen/generator.cpp
@@ -183,7 +183,7 @@ Generator::Generator(const DFA &_dfa, const Config &config)
      : dfa(_dfa), cfg(config)
 {
     QList<InputType> lst = cfg.maxInputSet.toList();
-    qSort(lst);
+    std::sort(lst.begin(), lst.end());
     minInput = lst.first();
     maxInput = lst.last();
 
@@ -230,7 +230,7 @@ static QVector<Generator::TransitionSequence> convertToSequences(const Transitio
         return sequences;
 
     QList<InputType> keys = transitions.keys();
-    qSort(keys);
+    std::sort(keys.begin(), keys.end());
     int i = 0;
     Generator::TransitionSequence sequence;
     sequence.first = keys.at(0);
@@ -359,7 +359,7 @@ void Generator::generateTransitions(CodeBlock &body, const TransitionMap &transi
         }
     } else {
         QList<InputType> keys = transitions.keys();
-        qSort(keys);
+        std::sort(keys.begin(), keys.end());
 
         body << "switch (ch.unicode()) {";
         body.indent();
diff --git a/util/lexgen/nfa.cpp b/util/lexgen/nfa.cpp
index 9047a17fde..f6e3a5c355 100644
--- a/util/lexgen/nfa.cpp
+++ b/util/lexgen/nfa.cpp
@@ -384,7 +384,7 @@ QSet<int> NFA::epsilonClosure(const QSet<int> &initialClosure) const
 
     QStack<int> stateStack;
     stateStack.resize(closure.count());
-    qCopy(closure.constBegin(), closure.constEnd(), stateStack.begin());
+    std::copy(closure.constBegin(), closure.constEnd(), stateStack.begin());
 
     while (!stateStack.isEmpty()) {
         int t = stateStack.pop();
diff --git a/util/locale_database/cldr2qlocalexml.py b/util/locale_database/cldr2qlocalexml.py
index d75ef282f9..5560d8b43f 100755
--- a/util/locale_database/cldr2qlocalexml.py
+++ b/util/locale_database/cldr2qlocalexml.py
@@ -45,6 +45,9 @@ append new entries to enumdata.py's lists and update documentation in
 src/corelib/tools/qlocale.qdoc, adding the new entries in alphabetic
 order.
 
+While updating the locale data, check also for updates to MS-Win's
+time zone names; see cldr2qtimezone.py for details.
+
 .. _CLDR: ftp://unicode.org/Public/cldr/
 """
 
diff --git a/util/locale_database/cldr2qtimezone.py b/util/locale_database/cldr2qtimezone.py
index 0817435d40..c240d0d190 100755
--- a/util/locale_database/cldr2qtimezone.py
+++ b/util/locale_database/cldr2qtimezone.py
@@ -38,17 +38,16 @@ use.
 The XML structure is as follows:
 
  <supplementalData>
-     <version number="$Revision: 7825 $"/>
-     <generation date="$Date: 2012-10-10 14:45:31 -0700 (Wed, 10 Oct 2012) $"/>
+     <version number="$Revision:...$"/>
+     <generation date="$Date:...$"/>
      <windowsZones>
-         <mapTimezones otherVersion="7dc0101" typeVersion="2012f">
+         <mapTimezones otherVersion="..." typeVersion="...">
              <!-- (UTC-08:00) Pacific Time (US & Canada) -->
              <mapZone other="Pacific Standard Time" territory="001" type="America/Los_Angeles"/>
-             <mapZone other="Pacific Standard Time" territory="CA"  type="America/Vancouver America/Dawson America/Whitehorse"/>
-             <mapZone other="Pacific Standard Time" territory="MX"  type="America/Tijuana"/>
-             <mapZone other="Pacific Standard Time" territory="US"  type="America/Los_Angeles"/>
-             <mapZone other="Pacific Standard Time" territory="ZZ"  type="PST8PDT"/>
-       </mapTimezones>
+             <mapZone other="Pacific Standard Time" territory="CA" type="America/Vancouver America/Dawson America/Whitehorse"/>
+             <mapZone other="Pacific Standard Time" territory="US" type="America/Los_Angeles America/Metlakatla"/>
+             <mapZone other="Pacific Standard Time" territory="ZZ" type="PST8PDT"/>
+         </mapTimezones>
      </windowsZones>
  </supplementalData>
 """
@@ -89,169 +88,200 @@ class ByteArrayData:
         self.data += lst
         return index
 
-# List of currently known Windows IDs.  If script fails on missing ID plase add it here
-# Not public so may be safely changed.
-# Windows Key : [ Windows Id, Offset Seconds ]
-windowsIdList = {
-    1 : [ u'Afghanistan Standard Time',        16200  ],
-    2 : [ u'Alaskan Standard Time',           -32400  ],
-    3 : [ u'Arab Standard Time',               10800  ],
-    4 : [ u'Arabian Standard Time',            14400  ],
-    5 : [ u'Arabic Standard Time',             10800  ],
-    6 : [ u'Argentina Standard Time',         -10800  ],
-    7 : [ u'Atlantic Standard Time',          -14400  ],
-    8 : [ u'AUS Central Standard Time',        34200  ],
-    9 : [ u'AUS Eastern Standard Time',        36000  ],
-   10 : [ u'Azerbaijan Standard Time',         14400  ],
-   11 : [ u'Azores Standard Time',             -3600  ],
-   12 : [ u'Bahia Standard Time',             -10800  ],
-   13 : [ u'Bangladesh Standard Time',         21600  ],
-   14 : [ u'Belarus Standard Time',            10800  ],
-   15 : [ u'Canada Central Standard Time',    -21600  ],
-   16 : [ u'Cape Verde Standard Time',         -3600  ],
-   17 : [ u'Caucasus Standard Time',           14400  ],
-   18 : [ u'Cen. Australia Standard Time',     34200  ],
-   19 : [ u'Central America Standard Time',   -21600  ],
-   20 : [ u'Central Asia Standard Time',       21600  ],
-   21 : [ u'Central Brazilian Standard Time', -14400  ],
-   22 : [ u'Central Europe Standard Time',      3600  ],
-   23 : [ u'Central European Standard Time',    3600  ],
-   24 : [ u'Central Pacific Standard Time',    39600  ],
-   25 : [ u'Central Standard Time (Mexico)',  -21600  ],
-   26 : [ u'Central Standard Time',           -21600  ],
-   27 : [ u'China Standard Time',              28800  ],
-   28 : [ u'Dateline Standard Time',          -43200  ],
-   29 : [ u'E. Africa Standard Time',          10800  ],
-   30 : [ u'E. Australia Standard Time',       36000  ],
-   31 : [ u'E. South America Standard Time',  -10800  ],
-   32 : [ u'Eastern Standard Time',           -18000  ],
-   33 : [ u'Eastern Standard Time (Mexico)',  -18000  ],
-   34 : [ u'Egypt Standard Time',               7200  ],
-   35 : [ u'Ekaterinburg Standard Time',       18000  ],
-   36 : [ u'Fiji Standard Time',               43200  ],
-   37 : [ u'FLE Standard Time',                 7200  ],
-   38 : [ u'Georgian Standard Time',           14400  ],
-   39 : [ u'GMT Standard Time',                    0  ],
-   40 : [ u'Greenland Standard Time',         -10800  ],
-   41 : [ u'Greenwich Standard Time',              0  ],
-   42 : [ u'GTB Standard Time',                 7200  ],
-   43 : [ u'Hawaiian Standard Time',          -36000  ],
-   44 : [ u'India Standard Time',              19800  ],
-   45 : [ u'Iran Standard Time',               12600  ],
-   46 : [ u'Israel Standard Time',              7200  ],
-   47 : [ u'Jordan Standard Time',              7200  ],
-   48 : [ u'Kaliningrad Standard Time',         7200  ],
-   49 : [ u'Korea Standard Time',              32400  ],
-   50 : [ u'Libya Standard Time',               7200  ],
-   51 : [ u'Line Islands Standard Time',       50400  ],
-   52 : [ u'Magadan Standard Time',            36000  ],
-   53 : [ u'Mauritius Standard Time',          14400  ],
-   54 : [ u'Middle East Standard Time',         7200  ],
-   55 : [ u'Montevideo Standard Time',        -10800  ],
-   56 : [ u'Morocco Standard Time',                0  ],
-   57 : [ u'Mountain Standard Time (Mexico)', -25200  ],
-   58 : [ u'Mountain Standard Time',          -25200  ],
-   59 : [ u'Myanmar Standard Time',            23400  ],
-   60 : [ u'N. Central Asia Standard Time',    21600  ],
-   61 : [ u'Namibia Standard Time',             3600  ],
-   62 : [ u'Nepal Standard Time',              20700  ],
-   63 : [ u'New Zealand Standard Time',        43200  ],
-   64 : [ u'Newfoundland Standard Time',      -12600  ],
-   65 : [ u'North Asia East Standard Time',    28800  ],
-   66 : [ u'North Asia Standard Time',         25200  ],
-   67 : [ u'Pacific SA Standard Time',        -10800  ],
-   68 : [ u'E. Europe Standard Time',           7200  ],
-   69 : [ u'Pacific Standard Time',           -28800  ],
-   70 : [ u'Pakistan Standard Time',           18000  ],
-   71 : [ u'Paraguay Standard Time',          -14400  ],
-   72 : [ u'Romance Standard Time',             3600  ],
-   73 : [ u'Russia Time Zone 3',               14400  ],
-   74 : [ u'Russia Time Zone 10',              39600  ],
-   75 : [ u'Russia Time Zone 11',              43200  ],
-   76 : [ u'Russian Standard Time',            10800  ],
-   77 : [ u'SA Eastern Standard Time',        -10800  ],
-   78 : [ u'SA Pacific Standard Time',        -18000  ],
-   79 : [ u'SA Western Standard Time',        -14400  ],
-   80 : [ u'Samoa Standard Time',              46800  ],
-   81 : [ u'SE Asia Standard Time',            25200  ],
-   82 : [ u'Singapore Standard Time',          28800  ],
-   83 : [ u'South Africa Standard Time',        7200  ],
-   84 : [ u'Sri Lanka Standard Time',          19800  ],
-   85 : [ u'Syria Standard Time',               7200  ],
-   86 : [ u'Taipei Standard Time',             28800  ],
-   87 : [ u'Tasmania Standard Time',           36000  ],
-   88 : [ u'Tokyo Standard Time',              32400  ],
-   89 : [ u'Tonga Standard Time',              46800  ],
-   90 : [ u'Turkey Standard Time',              7200  ],
-   91 : [ u'Ulaanbaatar Standard Time',        28800  ],
-   92 : [ u'US Eastern Standard Time',        -18000  ],
-   93 : [ u'US Mountain Standard Time',       -25200  ],
-   94 : [ u'UTC-02',                           -7200  ],
-   95 : [ u'UTC-11',                          -39600  ],
-   96 : [ u'UTC',                                  0  ],
-   97 : [ u'UTC+12',                           43200  ],
-   98 : [ u'Venezuela Standard Time',         -16200  ],
-   99 : [ u'Vladivostok Standard Time',        36000  ],
-   100: [ u'W. Australia Standard Time',       28800  ],
-   101: [ u'W. Central Africa Standard Time',   3600  ],
-   102: [ u'W. Europe Standard Time',           3600  ],
-   103: [ u'West Asia Standard Time',          18000  ],
-   104: [ u'West Pacific Standard Time',       36000  ],
-   105: [ u'Yakutsk Standard Time',            32400  ],
-   106: [ u'North Korea Standard Time',        30600  ]
-}
+# List of currently known Windows IDs.
+# If this script reports missing IDs, please add them here.
+# Look up the offset using (google and) timeanddate.com.
+# Not public so may safely be changed.  Please keep in alphabetic order by ID.
+# ( Windows Id, Offset Seconds )
+windowsIdList = (
+    (u'Afghanistan Standard Time',        16200),
+    (u'Alaskan Standard Time',           -32400),
+    (u'Aleutian Standard Time',          -36000),
+    (u'Altai Standard Time',              25200),
+    (u'Arab Standard Time',               10800),
+    (u'Arabian Standard Time',            14400),
+    (u'Arabic Standard Time',             10800),
+    (u'Argentina Standard Time',         -10800),
+    (u'Astrakhan Standard Time',          14400),
+    (u'Atlantic Standard Time',          -14400),
+    (u'AUS Central Standard Time',        34200),
+    (u'Aus Central W. Standard Time',     31500),
+    (u'AUS Eastern Standard Time',        36000),
+    (u'Azerbaijan Standard Time',         14400),
+    (u'Azores Standard Time',             -3600),
+    (u'Bahia Standard Time',             -10800),
+    (u'Bangladesh Standard Time',         21600),
+    (u'Belarus Standard Time',            10800),
+    (u'Bougainville Standard Time',       39600),
+    (u'Canada Central Standard Time',    -21600),
+    (u'Cape Verde Standard Time',         -3600),
+    (u'Caucasus Standard Time',           14400),
+    (u'Cen. Australia Standard Time',     34200),
+    (u'Central America Standard Time',   -21600),
+    (u'Central Asia Standard Time',       21600),
+    (u'Central Brazilian Standard Time', -14400),
+    (u'Central Europe Standard Time',      3600),
+    (u'Central European Standard Time',    3600),
+    (u'Central Pacific Standard Time',    39600),
+    (u'Central Standard Time (Mexico)',  -21600),
+    (u'Central Standard Time',           -21600),
+    (u'China Standard Time',              28800),
+    (u'Chatham Islands Standard Time',    45900),
+    (u'Cuba Standard Time',              -18000),
+    (u'Dateline Standard Time',          -43200),
+    (u'E. Africa Standard Time',          10800),
+    (u'E. Australia Standard Time',       36000),
+    (u'E. Europe Standard Time',           7200),
+    (u'E. South America Standard Time',  -10800),
+    (u'Easter Island Standard Time',     -21600),
+    (u'Eastern Standard Time',           -18000),
+    (u'Eastern Standard Time (Mexico)',  -18000),
+    (u'Egypt Standard Time',               7200),
+    (u'Ekaterinburg Standard Time',       18000),
+    (u'Fiji Standard Time',               43200),
+    (u'FLE Standard Time',                 7200),
+    (u'Georgian Standard Time',           14400),
+    (u'GMT Standard Time',                    0),
+    (u'Greenland Standard Time',         -10800),
+    (u'Greenwich Standard Time',              0),
+    (u'GTB Standard Time',                 7200),
+    (u'Haiti Standard Time',             -18000),
+    (u'Hawaiian Standard Time',          -36000),
+    (u'India Standard Time',              19800),
+    (u'Iran Standard Time',               12600),
+    (u'Israel Standard Time',              7200),
+    (u'Jordan Standard Time',              7200),
+    (u'Kaliningrad Standard Time',         7200),
+    (u'Korea Standard Time',              32400),
+    (u'Libya Standard Time',               7200),
+    (u'Line Islands Standard Time',       50400),
+    (u'Lord Howe Standard Time',          37800),
+    (u'Magadan Standard Time',            36000),
+    (u'Magallanes Standard Time',        -10800), # permanent DST
+    (u'Marquesas Standard Time',         -34200),
+    (u'Mauritius Standard Time',          14400),
+    (u'Middle East Standard Time',         7200),
+    (u'Montevideo Standard Time',        -10800),
+    (u'Morocco Standard Time',                0),
+    (u'Mountain Standard Time (Mexico)', -25200),
+    (u'Mountain Standard Time',          -25200),
+    (u'Myanmar Standard Time',            23400),
+    (u'N. Central Asia Standard Time',    21600),
+    (u'Namibia Standard Time',             3600),
+    (u'Nepal Standard Time',              20700),
+    (u'New Zealand Standard Time',        43200),
+    (u'Newfoundland Standard Time',      -12600),
+    (u'Norfolk Standard Time',            39600),
+    (u'North Asia East Standard Time',    28800),
+    (u'North Asia Standard Time',         25200),
+    (u'North Korea Standard Time',        30600),
+    (u'Omsk Standard Time',               21600),
+    (u'Pacific SA Standard Time',        -10800),
+    (u'Pacific Standard Time',           -28800),
+    (u'Pacific Standard Time (Mexico)',  -28800),
+    (u'Pakistan Standard Time',           18000),
+    (u'Paraguay Standard Time',          -14400),
+    (u'Romance Standard Time',             3600),
+    (u'Russia Time Zone 3',               14400),
+    (u'Russia Time Zone 10',              39600),
+    (u'Russia Time Zone 11',              43200),
+    (u'Russian Standard Time',            10800),
+    (u'SA Eastern Standard Time',        -10800),
+    (u'SA Pacific Standard Time',        -18000),
+    (u'SA Western Standard Time',        -14400),
+    (u'Saint Pierre Standard Time',      -10800), # New France
+    (u'Sakhalin Standard Time',           39600),
+    (u'Samoa Standard Time',              46800),
+    (u'Sao Tome Standard Time',               0),
+    (u'Saratov Standard Time',            14400),
+    (u'SE Asia Standard Time',            25200),
+    (u'Singapore Standard Time',          28800),
+    (u'South Africa Standard Time',        7200),
+    (u'Sri Lanka Standard Time',          19800),
+    (u'Sudan Standard Time',               7200), # unless they mean South Sudan, +03:00
+    (u'Syria Standard Time',               7200),
+    (u'Taipei Standard Time',             28800),
+    (u'Tasmania Standard Time',           36000),
+    (u'Tocantins Standard Time',         -10800),
+    (u'Tokyo Standard Time',              32400),
+    (u'Tomsk Standard Time',              25200),
+    (u'Tonga Standard Time',              46800),
+    (u'Transbaikal Standard Time',        32400), # Yakutsk
+    (u'Turkey Standard Time',              7200),
+    (u'Turks And Caicos Standard Time',  -14400),
+    (u'Ulaanbaatar Standard Time',        28800),
+    (u'US Eastern Standard Time',        -18000),
+    (u'US Mountain Standard Time',       -25200),
+    (u'UTC-11',                          -39600),
+    (u'UTC-09',                          -32400),
+    (u'UTC-08',                          -28800),
+    (u'UTC-02',                           -7200),
+    (u'UTC',                                  0),
+    (u'UTC+12',                           43200),
+    (u'UTC+13',                           46800),
+    (u'Venezuela Standard Time',         -16200),
+    (u'Vladivostok Standard Time',        36000),
+    (u'W. Australia Standard Time',       28800),
+    (u'W. Central Africa Standard Time',   3600),
+    (u'W. Europe Standard Time',           3600),
+    (u'W. Mongolia Standard Time',        25200), # Hovd
+    (u'West Asia Standard Time',          18000),
+    (u'West Bank Standard Time',           7200),
+    (u'West Pacific Standard Time',       36000),
+    (u'Yakutsk Standard Time',            32400),
+)
 
 def windowsIdToKey(windowsId):
-    for windowsKey in windowsIdList:
-        if windowsIdList[windowsKey][0] == windowsId:
-            return windowsKey
+    for index, pair in enumerate(windowsIdList):
+        if pair[0] == windowsId:
+            return index + 1
     return 0
 
 # List of standard UTC IDs to use.  Not public so may be safely changed.
-# Do not remove ID's as is part of API/behavior guarantee
-# Key : [ UTC Id, Offset Seconds ]
-utcIdList = {
-    0 : [ u'UTC',            0  ],  # Goes first so is default
-    1 : [ u'UTC-14:00', -50400  ],
-    2 : [ u'UTC-13:00', -46800  ],
-    3 : [ u'UTC-12:00', -43200  ],
-    4 : [ u'UTC-11:00', -39600  ],
-    5 : [ u'UTC-10:00', -36000  ],
-    6 : [ u'UTC-09:00', -32400  ],
-    7 : [ u'UTC-08:00', -28800  ],
-    8 : [ u'UTC-07:00', -25200  ],
-    9 : [ u'UTC-06:00', -21600  ],
-   10 : [ u'UTC-05:00', -18000  ],
-   11 : [ u'UTC-04:30', -16200  ],
-   12 : [ u'UTC-04:00', -14400  ],
-   13 : [ u'UTC-03:30', -12600  ],
-   14 : [ u'UTC-03:00', -10800  ],
-   15 : [ u'UTC-02:00',  -7200  ],
-   16 : [ u'UTC-01:00',  -3600  ],
-   17 : [ u'UTC-00:00',      0  ],
-   18 : [ u'UTC+00:00',      0  ],
-   19 : [ u'UTC+01:00',   3600  ],
-   20 : [ u'UTC+02:00',   7200  ],
-   21 : [ u'UTC+03:00',  10800  ],
-   22 : [ u'UTC+03:30',  12600  ],
-   23 : [ u'UTC+04:00',  14400  ],
-   24 : [ u'UTC+04:30',  16200  ],
-   25 : [ u'UTC+05:00',  18000  ],
-   26 : [ u'UTC+05:30',  19800  ],
-   27 : [ u'UTC+05:45',  20700  ],
-   28 : [ u'UTC+06:00',  21600  ],
-   29 : [ u'UTC+06:30',  23400  ],
-   30 : [ u'UTC+07:00',  25200  ],
-   31 : [ u'UTC+08:00',  28800  ],
-   32 : [ u'UTC+09:00',  32400  ],
-   33 : [ u'UTC+09:30',  34200  ],
-   34 : [ u'UTC+10:00',  36000  ],
-   35 : [ u'UTC+11:00',  39600  ],
-   36 : [ u'UTC+12:00',  43200  ],
-   37 : [ u'UTC+13:00',  46800  ],
-   38 : [ u'UTC+14:00',  50400  ],
-   39 : [ u'UTC+08:30',  30600  ]
-}
+# Do not remove IDs, as each entry is part of the API/behavior guarantee.
+# ( UTC Id, Offset Seconds )
+utcIdList = (
+    (u'UTC',            0),  # Goes first so is default
+    (u'UTC-14:00', -50400),
+    (u'UTC-13:00', -46800),
+    (u'UTC-12:00', -43200),
+    (u'UTC-11:00', -39600),
+    (u'UTC-10:00', -36000),
+    (u'UTC-09:00', -32400),
+    (u'UTC-08:00', -28800),
+    (u'UTC-07:00', -25200),
+    (u'UTC-06:00', -21600),
+    (u'UTC-05:00', -18000),
+    (u'UTC-04:30', -16200),
+    (u'UTC-04:00', -14400),
+    (u'UTC-03:30', -12600),
+    (u'UTC-03:00', -10800),
+    (u'UTC-02:00',  -7200),
+    (u'UTC-01:00',  -3600),
+    (u'UTC-00:00',      0),
+    (u'UTC+00:00',      0),
+    (u'UTC+01:00',   3600),
+    (u'UTC+02:00',   7200),
+    (u'UTC+03:00',  10800),
+    (u'UTC+03:30',  12600),
+    (u'UTC+04:00',  14400),
+    (u'UTC+04:30',  16200),
+    (u'UTC+05:00',  18000),
+    (u'UTC+05:30',  19800),
+    (u'UTC+05:45',  20700),
+    (u'UTC+06:00',  21600),
+    (u'UTC+06:30',  23400),
+    (u'UTC+07:00',  25200),
+    (u'UTC+08:00',  28800),
+    (u'UTC+08:30',  30600),
+    (u'UTC+09:00',  32400),
+    (u'UTC+09:30',  34200),
+    (u'UTC+10:00',  36000),
+    (u'UTC+11:00',  39600),
+    (u'UTC+12:00',  43200),
+    (u'UTC+13:00',  46800),
+    (u'UTC+14:00',  50400),
+)
 
 def usage():
     print "Usage: cldr2qtimezone.py <path to cldr core/common> <path to qtbase>"
@@ -270,10 +300,7 @@ windowsZonesPath = cldrPath + "/supplemental/windowsZones.xml"
 tempFileDir = qtPath
 dataFilePath = qtPath + "/src/corelib/time/qtimezoneprivate_data_p.h"
 
-if not os.path.isfile(windowsZonesPath):
-    usage()
-
-if not os.path.isfile(dataFilePath):
+if not (os.path.isfile(windowsZonesPath) and os.path.isfile(dataFilePath)):
     usage()
 
 cldr_version = 'unknown'
@@ -291,6 +318,7 @@ defaultDict = {}
 windowsIdDict = {}
 
 if mapTimezones:
+    badZones = set()
     for mapZone in mapTimezones:
         # [u'mapZone', [(u'territory', u'MH'), (u'other', u'UTC+12'), (u'type', u'Pacific/Majuro Pacific/Kwajalein')]]
         if mapZone[0] == u'mapZone':
@@ -305,7 +333,7 @@ if mapTimezones:
 
             data['windowsKey'] = windowsIdToKey(data['windowsId'])
             if data['windowsKey'] <= 0:
-                raise xpathlite.Error("Unknown Windows ID, please add \"%s\"" % data['windowsId'])
+                badZones.add(data['windowsId'])
 
             countryId = 0
             if data['countryCode'] == u'001':
@@ -316,6 +344,10 @@ if mapTimezones:
                     raise xpathlite.Error("Unknown Country Code \"%s\"" % data['countryCode'])
                 data['country'] = enumdata.country_list[data['countryId']][0]
                 windowsIdDict[data['windowsKey'], data['countryId']] = data
+    if badZones:
+        sys.stderr.write('\n\t'.join(["\nUnknown Windows ID, please add:"] + sorted(badZones))
+                         + "\nto the windowIdList in cldr2qtimezone.py\n\n")
+        raise xpathlite.Error("Unknown Windows IDs")
 
 print "Input file parsed, now writing data"
 
@@ -370,13 +402,10 @@ print "Done Zone Data"
 # Write Windows ID key table
 newTempFile.write("// Windows ID Key, Windows ID Index, IANA ID Index, UTC Offset\n")
 newTempFile.write("static const QWindowsData windowsDataTable[] = {\n")
-for windowsKey in windowsIdList:
+for index, pair in enumerate(windowsIdList):
     newTempFile.write("    { %6d,%6d,%6d,%6d }, // %s\n"
-                         % (windowsKey,
-                            windowsIdData.append(windowsIdList[windowsKey][0]),
-                            ianaIdData.append(defaultDict[windowsKey]),
-                            windowsIdList[windowsKey][1],
-                            windowsIdList[windowsKey][0]))
+                      % (index + 1, windowsIdData.append(pair[0]),
+                         ianaIdData.append(defaultDict[index + 1]), pair[1], pair[0]))
 newTempFile.write("    {      0,     0,     0,     0 } // Trailing zeroes\n")
 newTempFile.write("};\n\n")
 
@@ -385,12 +414,9 @@ print "Done Windows Data Table"
 # Write UTC ID key table
 newTempFile.write("// IANA ID Index, UTC Offset\n")
 newTempFile.write("static const QUtcData utcDataTable[] = {\n")
-for index in utcIdList:
-    data = utcIdList[index]
+for pair in utcIdList:
     newTempFile.write("    { %6d,%6d }, // %s\n"
-                         % (ianaIdData.append(data[0]),
-                            data[1],
-                            data[0]))
+                      % (ianaIdData.append(pair[0]), pair[1], pair[0]))
 newTempFile.write("    {     0,      0 } // Trailing zeroes\n")
 newTempFile.write("};\n\n")
 
diff --git a/util/qfloat16-tables/gen_qfloat16_tables.cpp b/util/qfloat16-tables/gen_qfloat16_tables.cpp
new file mode 100644
index 0000000000..faedb5073c
--- /dev/null
+++ b/util/qfloat16-tables/gen_qfloat16_tables.cpp
@@ -0,0 +1,163 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 by Southwest Research Institute (R)
+** Copyright (C) 2019 Intel Corporation.
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <stdint.h>
+#include <stdio.h>
+
+/*
+ * This tool generates the tables used by qfloat16 to implement a
+ * software-emulated version of IEEE 754 binary16. qfloat16 automatically uses
+ * CPU instructions to convert to and from float (IEEE 754 binary32), but if
+ * the CPU is not guaranteed to have those instructions available at compile
+ * time, then qfloat16 needs the tables to perform the conversion with
+ * reasonable performance.
+ *
+ * Because Qt requires float to be IEEE 754 binary32, these tables are
+ * platform-independent and will never change.
+ */
+
+uint32_t convertmantissa(int32_t i)
+{
+    uint32_t m = i << 13; // Zero pad mantissa bits
+    uint32_t e = 0; // Zero exponent
+
+    while (!(m & 0x00800000)) {   // While not normalized
+        e -= 0x00800000;     // Decrement exponent (1<<23)
+        m <<= 1;             // Shift mantissa
+    }
+    m &= ~0x00800000;          // Clear leading 1 bit
+    e += 0x38800000;           // Adjust bias ((127-14)<<23)
+    return m | e;            // Return combined number
+}
+
+// we first build these tables up and then print them out as a separate step in order
+// to more closely map the implementation given in the paper.
+uint32_t basetable[512];
+uint32_t shifttable[512];
+
+int main()
+{
+    uint32_t i;
+
+    printf("/* This file was generated by util/qfloat16-tables/gen_qfloat16_tables.cpp */\n\n");
+    printf("#include <QtCore/qfloat16.h>\n\n");
+
+    printf("QT_BEGIN_NAMESPACE\n\n");
+    printf("#if !defined(__F16C__) && !defined(__ARM_FP16_FORMAT_IEEE)\n\n");
+
+    printf("const quint32 qfloat16::mantissatable[2048] = {\n");
+    printf("0,\n");
+    for (i = 1; i < 1024; i++)
+        printf("0x%XU,\n", convertmantissa(i));
+    for (i = 1024; i < 2048; i++)
+        printf("0x%XU,\n", 0x38000000U + ((i - 1024) << 13));
+    printf("};\n\n");
+
+    printf("const quint32 qfloat16::exponenttable[64] = {\n");
+    printf("0,\n");
+    for (i = 1; i < 31; i++)
+        printf("0x%XU,\n", i << 23);
+    printf("0x47800000U,\n");  // 31
+    printf("0x80000000U,\n");  // 32
+    for (i = 33; i < 63; i++)
+        printf("0x%XU,\n", 0x80000000U + ((i - 32) << 23));
+    printf("0xC7800000U,\n");  // 63
+    printf("};\n\n");
+
+    printf("const quint32 qfloat16::offsettable[64] = {\n");
+    printf("0,\n");
+    for (i = 1; i < 32; i++)
+        printf("1024U,\n");
+    printf("0,\n");
+    for (i = 33; i < 64; i++)
+        printf("1024U,\n");
+    printf("};\n\n");
+
+    int32_t e;
+    for (i = 0; i < 256; ++i) {
+        e = i - 127;
+        if (e < -24) {   // Very small numbers map to zero
+            basetable[i | 0x000] = 0x0000;
+            basetable[i | 0x100] = 0x8000;
+            shifttable[i | 0x000] = 24;
+            shifttable[i | 0x100] = 24;
+
+        } else if (e < -14) {             // Small numbers map to denorms
+            basetable[i | 0x000] = (0x0400 >> (-e - 14));
+            basetable[i | 0x100] = (0x0400 >> (-e - 14)) | 0x8000;
+            shifttable[i | 0x000] = -e - 1;
+            shifttable[i | 0x100] = -e - 1;
+
+        } else if (e <= 15) {            // Normal numbers just lose precision
+            basetable[i | 0x000] = ((e + 15) << 10);
+            basetable[i | 0x100] = ((e + 15) << 10) | 0x8000;
+            shifttable[i | 0x000] = 13;
+            shifttable[i | 0x100] = 13;
+
+        } else if (e < 128) {            // Large numbers map to Infinity
+            basetable[i | 0x000] = 0x7C00;
+            basetable[i | 0x100] = 0xFC00;
+            shifttable[i | 0x000] = 24;
+            shifttable[i | 0x100] = 24;
+
+        } else {                     // Infinity and NaN's stay Infinity and NaN's
+            basetable[i | 0x000] = 0x7C00;
+            basetable[i | 0x100] = 0xFC00;
+            shifttable[i | 0x000] = 13;
+            shifttable[i | 0x100] = 13;
+        }
+    }
+
+    printf("const quint32 qfloat16::basetable[512] = {\n");
+    for (i = 0; i < 512; i++)
+        printf("0x%XU,\n", basetable[i]);
+
+    printf("};\n\n");
+
+    printf("const quint32 qfloat16::shifttable[512] = {\n");
+    for (i = 0; i < 512; i++)
+        printf("0x%XU,\n", shifttable[i]);
+
+    printf("};\n\n");
+
+    printf("#endif // !__F16C__ && !__ARM_FP16_FORMAT_IEEE\n\n");
+    printf("QT_END_NAMESPACE\n");
+    return 0;
+}
diff --git a/util/qfloat16-tables/qfloat16-tables.pro b/util/qfloat16-tables/qfloat16-tables.pro
new file mode 100644
index 0000000000..3c9a1e61a3
--- /dev/null
+++ b/util/qfloat16-tables/qfloat16-tables.pro
@@ -0,0 +1,2 @@
+QT = core
+SOURCES += gen_qfloat16_tables.cpp
diff --git a/util/unicode/codecs/big5/main.cpp b/util/unicode/codecs/big5/main.cpp
index 142db74ffd..54d3839755 100644
--- a/util/unicode/codecs/big5/main.cpp
+++ b/util/unicode/codecs/big5/main.cpp
@@ -128,7 +128,7 @@ int main(int argc, char **argv)
             list += QByteArray("    { 0x" + QByteArray::number(m.b5, 16) + ", 0x" + QByteArray::number(m.uc, 16) + " }\n");;
     }
     QByteArray ba;
-    qSort(list);
+    std::sort(list.begin(), list.end());
     foreach(QByteArray a, list)
         ba += a;
     qDebug() << "struct B5Map b5_to_uc_map = {\n" << ba + "\n};";
@@ -138,7 +138,7 @@ int main(int argc, char **argv)
         if (!b5_ok.contains(m.uc))
             list += QByteArray("    { 0x" + QByteArray::number(m.uc, 16) + ", 0x" + QByteArray::number(m.b5, 16) + " }\n");;
     ba = QByteArray();
-    qSort(list);
+    std::sort(list.begin(), list.end());;
     foreach(QByteArray a, list)
         ba += a;
     qDebug() << "struct B5Map uc_to_b5_map = {\n" << ba + "\n};";
diff --git a/util/unicode/main.cpp b/util/unicode/main.cpp
index 8576f00e35..ec84667ee5 100644
--- a/util/unicode/main.cpp
+++ b/util/unicode/main.cpp
@@ -2832,7 +2832,7 @@ static QByteArray createLigatureInfo()
             QList<Ligature> l = ligatureHashes.value(uc);
             if (!l.isEmpty()) {
                 Q_ASSERT(!QChar::requiresSurrogates(uc));
-                qSort(l); // needed for bsearch in ligatureHelper code
+                std::sort(l.begin(), l.end()); // needed for bsearch in ligatureHelper code
 
                 ligatures.append(l.size());
                 for (int j = 0; j < l.size(); ++j) {
@@ -2864,7 +2864,7 @@ static QByteArray createLigatureInfo()
             QList<Ligature> l = ligatureHashes.value(uc);
             if (!l.isEmpty()) {
                 Q_ASSERT(QChar::requiresSurrogates(uc));
-                qSort(l); // needed for bsearch in ligatureHelper code
+                std::sort(l.begin(), l.end()); // needed for bsearch in ligatureHelper code
 
                 ligatures.append(l.size());
                 for (int j = 0; j < l.size(); ++j) {