qdatetime.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2022 The Qt Company Ltd.
** Copyright (C) 2021 Intel Corporation.
** Contact: https://www.qt.io/licensing/
**
** 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 "qplatformdefs.h"
#include "qdatetime.h"
 
#include "qcalendar.h"
#include "qdatastream.h"
#include "qdebug.h"
#include "qset.h"
#include "qlocale.h"
 
#include "private/qcalendarmath_p.h"
#include "private/qdatetime_p.h"
#if QT_CONFIG(datetimeparser)
#include "private/qdatetimeparser_p.h"
#endif
#ifdef Q_OS_DARWIN
#include "private/qcore_mac_p.h"
#endif
#include "private/qgregoriancalendar_p.h"
#include "private/qnumeric_p.h"
#include "private/qstringiterator_p.h"
#if QT_CONFIG(timezone)
#include "private/qtimezoneprivate_p.h"
#endif
 
#include <cmath>
#ifdef Q_OS_WIN
#  include <qt_windows.h>
#endif
#include <time.h>
 
QT_BEGIN_NAMESPACE
 
/*****************************************************************************
  Date/Time Constants
 *****************************************************************************/
 
constexpr qint64 SECS_PER_DAY = 86400;
constexpr qint64 MSECS_PER_DAY = 86400000;
constexpr qint64 SECS_PER_HOUR = 3600;
constexpr qint64 MSECS_PER_HOUR = 3600000;
constexpr qint64 SECS_PER_MIN = 60;
constexpr qint64 MSECS_PER_MIN = 60000;
constexpr qint64 MSECS_PER_SEC = 1000;
constexpr qint64 TIME_T_MAX = std::numeric_limits<time_t>::max();
constexpr qint64 JULIAN_DAY_FOR_EPOCH = 2440588; // result of julianDayFromDate(1970, 1, 1)
 
/*****************************************************************************
  QDate static helper functions
 *****************************************************************************/
 
static inline QDate fixedDate(QCalendar::YearMonthDay &&parts, QCalendar cal)
{
    if ((parts.year < 0 && !cal.isProleptic()) || (parts.year == 0 && !cal.hasYearZero()))
        return QDate();
 
    parts.day = qMin(parts.day, cal.daysInMonth(parts.month, parts.year));
    return cal.dateFromParts(parts);
}
 
static inline QDate fixedDate(QCalendar::YearMonthDay &&parts)
{
    if (parts.year) {
        parts.day = qMin(parts.day, QGregorianCalendar::monthLength(parts.month, parts.year));
        qint64 jd;
        if (QGregorianCalendar::julianFromParts(parts.year, parts.month, parts.day, &jd))
            return QDate::fromJulianDay(jd);
    }
    return QDate();
}
 
/*****************************************************************************
  Date/Time formatting helper functions
 *****************************************************************************/
 
#if QT_CONFIG(textdate)
static const char qt_shortMonthNames[][4] = {
    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
 
static int fromShortMonthName(QStringView monthName)
{
    for (unsigned int i = 0; i < sizeof(qt_shortMonthNames) / sizeof(qt_shortMonthNames[0]); ++i) {
        if (monthName == QLatin1String(qt_shortMonthNames[i], 3))
            return i + 1;
    }
    return -1;
}
#endif // textdate
 
#if QT_CONFIG(datestring) // depends on, so implies, textdate
struct ParsedRfcDateTime {
    QDate date;
    QTime time;
    int utcOffset;
};
 
static int shortDayFromName(QStringView name)
{
    const char16_t shortDayNames[] = u"MonTueWedThuFriSatSun";
    for (int i = 0; i < 7; i++) {
        if (name == QStringView(shortDayNames + 3 * i, 3))
            return i + 1;
    }
    return 0;
}
 
static ParsedRfcDateTime rfcDateImpl(QStringView s)
{
    // Matches "[ddd,] dd MMM yyyy[ hh:mm[:ss]] [±hhmm]" - correct RFC 822, 2822, 5322 format -
    // or           "ddd MMM dd[ hh:mm:ss] yyyy [±hhmm]" - permissive RFC 850, 1036 (read only)
    ParsedRfcDateTime result;
 
    QVarLengthArray<QStringView, 6> words;
 
    auto tokens = s.tokenize(u' ', Qt::SkipEmptyParts);
    auto it = tokens.begin();
    for (int i = 0; i < 6 && it != tokens.end(); ++i, ++it)
        words.emplace_back(*it);
 
    if (words.size() < 3 || it != tokens.end())
        return result;
    const QChar colon(u':');
    bool ok = true;
    QDate date;
 
    const auto isShortName = [](QStringView name) {
        return (name.length() == 3 && name[0].isUpper()
                && name[1].isLower() && name[2].isLower());
    };
 
    /* Reject entirely (return) if the string is malformed; however, if the date
     * is merely invalid, (break, so as to) go on to parsing of the time.
     */
    int yearIndex;
    do { // "loop" so that we can use break on merely invalid, but "right shape" date.
        QStringView dayName;
        bool rfcX22 = true;
        const QStringView maybeDayName = words.front();
        if (maybeDayName.endsWith(u',')) {
            dayName = maybeDayName.chopped(1);
            words.erase(words.begin());
        } else if (!maybeDayName.front().isDigit()) {
            dayName = maybeDayName;
            words.erase(words.begin());
            rfcX22 = false;
        } // else: dayName is not specified (so we can only be RFC *22)
        if (words.size() < 3 || words.size() > 5)
            return result;
 
        // Don't break before setting yearIndex.
        int dayIndex, monthIndex;
        if (rfcX22) {
            // dd MMM yyyy [hh:mm[:ss]] [±hhmm]
            dayIndex = 0;
            monthIndex = 1;
            yearIndex = 2;
        } else {
            // MMM dd[ hh:mm:ss] yyyy [±hhmm]
            dayIndex = 1;
            monthIndex = 0;
            yearIndex = words.size() > 3 && words.at(2).contains(colon) ? 3 : 2;
        }
 
        int dayOfWeek = 0;
        if (!dayName.isEmpty()) {
            if (!isShortName(dayName))
                return result;
            dayOfWeek = shortDayFromName(dayName);
            if (!dayOfWeek)
                break;
        }
 
        const int day = words.at(dayIndex).toInt(&ok);
        if (!ok)
            return result;
        const int year = words.at(yearIndex).toInt(&ok);
        if (!ok)
            return result;
        const QStringView monthName = words.at(monthIndex);
        if (!isShortName(monthName))
            return result;
        int month = fromShortMonthName(monthName);
        if (month < 0)
            break;
 
        date = QDate(year, month, day);
        if (dayOfWeek && date.dayOfWeek() != dayOfWeek)
            date = QDate();
    } while (false);
    words.remove(yearIndex);
    words.remove(0, 2); // month and day-of-month, in some order
 
    // Time: [hh:mm[:ss]]
    QTime time;
    if (words.size() && words.at(0).contains(colon)) {
        const QStringView when = words.front();
        words.erase(words.begin());
        if (when.size() < 5 || when[2] != colon
            || (when.size() == 8 ? when[5] != colon : when.size() > 5)) {
            return result;
        }
        const int hour = when.first(2).toInt(&ok);
        if (!ok)
            return result;
        const int minute = when.sliced(3, 2).toInt(&ok);
        if (!ok)
            return result;
        const auto secs = when.size() == 8 ? when.last(2).toInt(&ok) : 0;
        if (!ok)
            return result;
        time = QTime(hour, minute, secs);
    }
 
    // Offset: [±hh[mm]]
    int offset = 0;
    if (words.size()) {
        const QStringView zone = words.front();
        words.erase(words.begin());
        if (words.size() || !(zone.size() == 3 || zone.size() == 5))
            return result;
        bool negate = false;
        if (zone[0] == u'-')
            negate = true;
        else if (zone[0] != u'+')
            return result;
        const int hour = zone.sliced(1, 2).toInt(&ok);
        if (!ok)
            return result;
        const auto minute = zone.size() == 5 ? zone.last(2).toInt(&ok) : 0;
        if (!ok)
            return result;
        offset = (hour * 60 + minute) * 60;
        if (negate)
            offset = -offset;
    }
 
    result.date = date;
    result.time = time;
    result.utcOffset = offset;
    return result;
}
#endif // datestring
 
// Return offset in [+-]HH:mm format
static QString toOffsetString(Qt::DateFormat format, int offset)
{
    return QString::asprintf("%c%02d%s%02d",
                             offset >= 0 ? '+' : '-',
                             qAbs(offset) / int(SECS_PER_HOUR),
                             // Qt::ISODate puts : between the hours and minutes, but Qt:TextDate does not:
                             format == Qt::TextDate ? "" : ":",
                             (qAbs(offset) / 60) % 60);
}
 
#if QT_CONFIG(datestring)
// Parse offset in [+-]HH[[:]mm] format
static int fromOffsetString(QStringView offsetString, bool *valid) noexcept
{
    *valid = false;
 
    const int size = offsetString.size();
    if (size < 2 || size > 6)
        return 0;
 
    // sign will be +1 for a positive and -1 for a negative offset
    int sign;
 
    // First char must be + or -
    const QChar signChar = offsetString[0];
    if (signChar == u'+')
        sign = 1;
    else if (signChar == u'-')
        sign = -1;
    else
        return 0;
 
    // Split the hour and minute parts
    const QStringView time = offsetString.sliced(1);
    qsizetype hhLen = time.indexOf(u':');
    qsizetype mmIndex;
    if (hhLen == -1)
        mmIndex = hhLen = 2; // [+-]HHmm or [+-]HH format
    else
        mmIndex = hhLen + 1;
 
    const QStringView hhRef = time.first(qMin(hhLen, time.size()));
    bool ok = false;
    const int hour = hhRef.toInt(&ok);
    if (!ok || hour > 23) // More generous than QTimeZone::MaxUtcOffsetSecs
        return 0;
 
    const QStringView mmRef = time.sliced(qMin(mmIndex, time.size()));
    const int minute = mmRef.isEmpty() ? 0 : mmRef.toInt(&ok);
    if (!ok || minute < 0 || minute > 59)
        return 0;
 
    *valid = true;
    return sign * ((hour * 60) + minute) * 60;
}
#endif // datestring
 
/*****************************************************************************
  QDate member functions
 *****************************************************************************/
 
QDate::QDate(int y, int m, int d)
{
    if (!QGregorianCalendar::julianFromParts(y, m, d, &jd))
        jd = nullJd();
}
 
QDate::QDate(int y, int m, int d, QCalendar cal)
{
    *this = cal.dateFromParts(y, m, d);
}
 
int QDate::year(QCalendar cal) const
{
    if (isValid()) {
        const auto parts = cal.partsFromDate(*this);
        if (parts.isValid())
            return parts.year;
    }
    return 0;
}
 
int QDate::year() const
{
    if (isValid()) {
        const auto parts = QGregorianCalendar::partsFromJulian(jd);
        if (parts.isValid())
            return parts.year;
    }
    return 0;
}
 
int QDate::month(QCalendar cal) const
{
    if (isValid()) {
        const auto parts = cal.partsFromDate(*this);
        if (parts.isValid())
            return parts.month;
    }
    return 0;
}
 
int QDate::month() const
{
    if (isValid()) {
        const auto parts = QGregorianCalendar::partsFromJulian(jd);
        if (parts.isValid())
            return parts.month;
    }
    return 0;
}
 
int QDate::day(QCalendar cal) const
{
    if (isValid()) {
        const auto parts = cal.partsFromDate(*this);
        if (parts.isValid())
            return parts.day;
    }
    return 0;
}
 
int QDate::day() const
{
    if (isValid()) {
        const auto parts = QGregorianCalendar::partsFromJulian(jd);
        if (parts.isValid())
            return parts.day;
    }
    return 0;
}
 
int QDate::dayOfWeek(QCalendar cal) const
{
    if (isNull())
        return 0;
 
    return cal.dayOfWeek(*this);
}
 
int QDate::dayOfWeek() const
{
    return isValid() ? QGregorianCalendar::weekDayOfJulian(jd) : 0;
}
 
int QDate::dayOfYear(QCalendar cal) const
{
    if (isValid()) {
        QDate firstDay = cal.dateFromParts(year(cal), 1, 1);
        if (firstDay.isValid())
            return firstDay.daysTo(*this) + 1;
    }
    return 0;
}
 
int QDate::dayOfYear() const
{
    if (isValid()) {
        qint64 first;
        if (QGregorianCalendar::julianFromParts(year(), 1, 1, &first))
            return jd - first + 1;
    }
    return 0;
}
 
int QDate::daysInMonth(QCalendar cal) const
{
    if (isValid()) {
        const auto parts = cal.partsFromDate(*this);
        if (parts.isValid())
            return cal.daysInMonth(parts.month, parts.year);
    }
    return 0;
}
 
int QDate::daysInMonth() const
{
    if (isValid()) {
        const auto parts = QGregorianCalendar::partsFromJulian(jd);
        if (parts.isValid())
            return QGregorianCalendar::monthLength(parts.month, parts.year);
    }
    return 0;
}
 
int QDate::daysInYear(QCalendar cal) const
{
    if (isNull())
        return 0;
 
    return cal.daysInYear(year(cal));
}
 
int QDate::daysInYear() const
{
    return isValid() ? QGregorianCalendar::leapTest(year()) ? 366 : 365 : 0;
}
 
int QDate::weekNumber(int *yearNumber) const
{
    if (!isValid())
        return 0;
 
    // This could be replaced by use of QIso8601Calendar, once we implement it.
    // The Thursday of the same week determines our answer:
    const QDate thursday(addDays(4 - dayOfWeek()));
    if (yearNumber)
        *yearNumber = thursday.year();
 
    // Week n's Thurs's DOY has 1 <= DOY - 7*(n-1) < 8, so 0 <= DOY + 6 - 7*n < 7:
    return (thursday.dayOfYear() + 6) / 7;
}
 
static bool inDateTimeRange(qint64 jd, bool start)
{
    using Bounds = std::numeric_limits<qint64>;
    if (jd < Bounds::min() + JULIAN_DAY_FOR_EPOCH)
        return false;
    jd -= JULIAN_DAY_FOR_EPOCH;
    const qint64 maxDay = Bounds::max() / MSECS_PER_DAY;
    const qint64 minDay = Bounds::min() / MSECS_PER_DAY - 1;
    // (Divisions rounded towards zero, as MSECS_PER_DAY has factors other than two.)
    // Range includes start of last day and end of first:
    if (start)
        return jd > minDay && jd <= maxDay;
    return jd >= minDay && jd < maxDay;
}
 
static QDateTime toEarliest(QDate day, const QDateTime &form)
{
    const Qt::TimeSpec spec = form.timeSpec();
    const int offset = (spec == Qt::OffsetFromUTC) ? form.offsetFromUtc() : 0;
#if QT_CONFIG(timezone)
    QTimeZone zone;
    if (spec == Qt::TimeZone)
        zone = form.timeZone();
#endif
    auto moment = [=](QTime time) {
        switch (spec) {
        case Qt::OffsetFromUTC: return QDateTime(day, time, spec, offset);
#if QT_CONFIG(timezone)
        case Qt::TimeZone: return QDateTime(day, time, zone);
#endif
        default: return QDateTime(day, time, spec);
        }
    };
    // Longest routine time-zone transition is 2 hours:
    QDateTime when = moment(QTime(2, 0));
    if (!when.isValid()) {
        // Noon should be safe ...
        when = moment(QTime(12, 0));
        if (!when.isValid()) {
            // ... unless it's a 24-hour jump (moving the date-line)
            when = moment(QTime(23, 59, 59, 999));
            if (!when.isValid())
                return QDateTime();
        }
    }
    int high = when.time().msecsSinceStartOfDay() / 60000;
    int low = 0;
    // Binary chop to the right minute
    while (high > low + 1) {
        int mid = (high + low) / 2;
        QDateTime probe = moment(QTime(mid / 60, mid % 60));
        if (probe.isValid() && probe.date() == day) {
            high = mid;
            when = probe;
        } else {
            low = mid;
        }
    }
    return when;
}
 
QDateTime QDate::startOfDay(Qt::TimeSpec spec, int offsetSeconds) const
{
    if (!inDateTimeRange(jd, true))
        return QDateTime();
 
    switch (spec) {
    case Qt::TimeZone: // should pass a QTimeZone instead of Qt::TimeZone
        qWarning() << "Called QDate::startOfDay(Qt::TimeZone) on" << *this;
        return QDateTime();
    case Qt::OffsetFromUTC:
    case Qt::UTC:
        return QDateTime(*this, QTime(0, 0), spec, offsetSeconds);
 
    case Qt::LocalTime:
        if (offsetSeconds)
            qWarning("Ignoring offset (%d seconds) passed with Qt::LocalTime", offsetSeconds);
        break;
    }
    QDateTime when(*this, QTime(0, 0), spec);
    if (!when.isValid())
        when = toEarliest(*this, when);
 
    return when.isValid() ? when : QDateTime();
}
 
#if QT_CONFIG(timezone)
QDateTime QDate::startOfDay(const QTimeZone &zone) const
{
    if (!inDateTimeRange(jd, true) || !zone.isValid())
        return QDateTime();
 
    QDateTime when(*this, QTime(0, 0), zone);
    if (when.isValid())
        return when;
 
    // The start of the day must have fallen in a spring-forward's gap; find the spring-forward:
    if (zone.hasTransitions()) {
        QTimeZone::OffsetData tran
            // There's unlikely to be another transition before noon tomorrow.
            // However, the whole of today may have been skipped !
            = zone.previousTransition(QDateTime(addDays(1), QTime(12, 0), zone));
        const QDateTime &at = tran.atUtc.toTimeZone(zone);
        if (at.isValid() && at.date() == *this)
            return at;
    }
 
    when = toEarliest(*this, when);
    return when.isValid() ? when : QDateTime();
}
#endif // timezone
 
static QDateTime toLatest(QDate day, const QDateTime &form)
{
    const Qt::TimeSpec spec = form.timeSpec();
    const int offset = (spec == Qt::OffsetFromUTC) ? form.offsetFromUtc() : 0;
#if QT_CONFIG(timezone)
    QTimeZone zone;
    if (spec == Qt::TimeZone)
        zone = form.timeZone();
#endif
    auto moment = [=](QTime time) {
        switch (spec) {
        case Qt::OffsetFromUTC: return QDateTime(day, time, spec, offset);
#if QT_CONFIG(timezone)
        case Qt::TimeZone: return QDateTime(day, time, zone);
#endif
        default: return QDateTime(day, time, spec);
        }
    };
    // Longest routine time-zone transition is 2 hours:
    QDateTime when = moment(QTime(21, 59, 59, 999));
    if (!when.isValid()) {
        // Noon should be safe ...
        when = moment(QTime(12, 0));
        if (!when.isValid()) {
            // ... unless it's a 24-hour jump (moving the date-line)
            when = moment(QTime(0, 0));
            if (!when.isValid())
                return QDateTime();
        }
    }
    int high = 24 * 60;
    int low = when.time().msecsSinceStartOfDay() / 60000;
    // Binary chop to the right minute
    while (high > low + 1) {
        int mid = (high + low) / 2;
        QDateTime probe = moment(QTime(mid / 60, mid % 60, 59, 999));
        if (probe.isValid() && probe.date() == day) {
            low = mid;
            when = probe;
        } else {
            high = mid;
        }
    }
    return when;
}
 
QDateTime QDate::endOfDay(Qt::TimeSpec spec, int offsetSeconds) const
{
    if (!inDateTimeRange(jd, false))
        return QDateTime();
 
    switch (spec) {
    case Qt::TimeZone: // should pass a QTimeZone instead of Qt::TimeZone
        qWarning() << "Called QDate::endOfDay(Qt::TimeZone) on" << *this;
        return QDateTime();
    case Qt::UTC:
    case Qt::OffsetFromUTC:
        return QDateTime(*this, QTime(23, 59, 59, 999), spec, offsetSeconds);
 
    case Qt::LocalTime:
        if (offsetSeconds)
            qWarning("Ignoring offset (%d seconds) passed with Qt::LocalTime", offsetSeconds);
        break;
    }
    QDateTime when(*this, QTime(23, 59, 59, 999), spec);
    if (!when.isValid())
        when = toLatest(*this, when);
    return when.isValid() ? when : QDateTime();
}
 
#if QT_CONFIG(timezone)
QDateTime QDate::endOfDay(const QTimeZone &zone) const
{
    if (!inDateTimeRange(jd, false) || !zone.isValid())
        return QDateTime();
 
    QDateTime when(*this, QTime(23, 59, 59, 999), zone);
    if (when.isValid())
        return when;
 
    // The end of the day must have fallen in a spring-forward's gap; find the spring-forward:
    if (zone.hasTransitions()) {
        QTimeZone::OffsetData tran
            // It's unlikely there's been another transition since yesterday noon.
            // However, the whole of today may have been skipped !
            = zone.nextTransition(QDateTime(addDays(-1), QTime(12, 0), zone));
        const QDateTime &at = tran.atUtc.toTimeZone(zone);
        if (at.isValid() && at.date() == *this)
            return at;
    }
 
    when = toLatest(*this, when);
    return when.isValid() ? when : QDateTime();
}
#endif // timezone
 
#if QT_CONFIG(datestring) // depends on, so implies, textdate
 
static QString toStringTextDate(QDate date)
{
    if (date.isValid()) {
        QCalendar cal; // Always Gregorian
        const auto parts = cal.partsFromDate(date);
        if (parts.isValid()) {
            const QLatin1Char sp(' ');
            return QLocale::c().dayName(cal.dayOfWeek(date), QLocale::ShortFormat) + sp
                + cal.monthName(QLocale::c(), parts.month, parts.year, QLocale::ShortFormat)
                // Documented to use 4-digit year
                + sp + QString::asprintf("%d %04d", parts.day, parts.year);
        }
    }
    return QString();
}
 
static QString toStringIsoDate(QDate date)
{
    const auto parts = QCalendar().partsFromDate(date);
    if (parts.isValid() && parts.year >= 0 && parts.year <= 9999)
        return QString::asprintf("%04d-%02d-%02d", parts.year, parts.month, parts.day);
    return QString();
}
 
QString QDate::toString(Qt::DateFormat format) const
{
    if (!isValid())
        return QString();
 
    switch (format) {
    case Qt::RFC2822Date:
        return QLocale::c().toString(*this, u"dd MMM yyyy");
    default:
    case Qt::TextDate:
        return toStringTextDate(*this);
    case Qt::ISODate:
    case Qt::ISODateWithMs:
        // No calendar dependence
        return toStringIsoDate(*this);
    }
}
 
QString QDate::toString(QStringView format, QCalendar cal) const
{
    return QLocale::c().toString(*this, format, cal);
}
#endif // datestring
 
bool QDate::setDate(int year, int month, int day)
{
    if (QGregorianCalendar::julianFromParts(year, month, day, &jd))
        return true;
 
    jd = nullJd();
    return false;
}
 
bool QDate::setDate(int year, int month, int day, QCalendar cal)
{
    *this = QDate(year, month, day, cal);
    return isValid();
}
 
void QDate::getDate(int *year, int *month, int *day) const
{
    QCalendar::YearMonthDay parts; // invalid by default
    if (isValid())
        parts = QGregorianCalendar::partsFromJulian(jd);
 
    const bool ok = parts.isValid();
    if (year)
        *year = ok ? parts.year : 0;
    if (month)
        *month = ok ? parts.month : 0;
    if (day)
        *day = ok ? parts.day : 0;
}
 
QDate QDate::addDays(qint64 ndays) const
{
    if (isNull())
        return QDate();
 
    if (qint64 r; Q_UNLIKELY(qAddOverflow(jd, ndays, &r)))
        return QDate();
    else
        return fromJulianDay(r);
}
 
QDate QDate::addMonths(int nmonths, QCalendar cal) const
{
    if (!isValid())
        return QDate();
 
    if (nmonths == 0)
        return *this;
 
    auto parts = cal.partsFromDate(*this);
 
    if (!parts.isValid())
        return QDate();
    Q_ASSERT(parts.year || cal.hasYearZero());
 
    parts.month += nmonths;
    while (parts.month <= 0) {
        if (--parts.year || cal.hasYearZero())
            parts.month += cal.monthsInYear(parts.year);
    }
    int count = cal.monthsInYear(parts.year);
    while (parts.month > count) {
        parts.month -= count;
        count = (++parts.year || cal.hasYearZero()) ? cal.monthsInYear(parts.year) : 0;
    }
 
    return fixedDate(std::move(parts), cal);
}
 
QDate QDate::addMonths(int nmonths) const
{
    if (isNull())
        return QDate();
 
    if (nmonths == 0)
        return *this;
 
    auto parts = QGregorianCalendar::partsFromJulian(jd);
 
    if (!parts.isValid())
        return QDate();
    Q_ASSERT(parts.year);
 
    parts.month += nmonths;
    while (parts.month <= 0) {
        if (--parts.year) // skip over year 0
            parts.month += 12;
    }
    while (parts.month > 12) {
        parts.month -= 12;
        if (!++parts.year) // skip over year 0
            ++parts.year;
    }
 
    return fixedDate(std::move(parts));
}
 
QDate QDate::addYears(int nyears, QCalendar cal) const
{
    if (!isValid())
        return QDate();
 
    auto parts = cal.partsFromDate(*this);
    if (!parts.isValid())
        return QDate();
 
    int old_y = parts.year;
    parts.year += nyears;
 
    // If we just crossed (or hit) a missing year zero, adjust year by +/- 1:
    if (!cal.hasYearZero() && ((old_y > 0) != (parts.year > 0) || !parts.year))
        parts.year += nyears > 0 ? +1 : -1;
 
    return fixedDate(std::move(parts), cal);
}
 
QDate QDate::addYears(int nyears) const
{
    if (isNull())
        return QDate();
 
    auto parts = QGregorianCalendar::partsFromJulian(jd);
    if (!parts.isValid())
        return QDate();
 
    int old_y = parts.year;
    parts.year += nyears;
 
    // If we just crossed (or hit) a missing year zero, adjust year by +/- 1:
    if ((old_y > 0) != (parts.year > 0) || !parts.year)
        parts.year += nyears > 0 ? +1 : -1;
 
    return fixedDate(std::move(parts));
}
 
qint64 QDate::daysTo(QDate d) const
{
    if (isNull() || d.isNull())
        return 0;
 
    // Due to limits on minJd() and maxJd() we know this will never overflow
    return d.jd - jd;
}
 
 
#if QT_CONFIG(datestring) // depends on, so implies, textdate
namespace {
 
struct ParsedInt { qulonglong value = 0; bool ok = false; };
 
/*
    /internal
 
    Read a whole number that must be the whole text.  QStringView::toULongLong()
    will happily ignore spaces and accept signs; but various date formats'
    fields (e.g. all in ISO) should not.
*/
ParsedInt readInt(QStringView text)
{
    ParsedInt result;
    for (QStringIterator it(text); it.hasNext();) {
        if (!QChar::isDigit(it.next()))
            return result;
    }
    result.value = text.toULongLong(&result.ok);
    return result;
}
 
}
 
QDate QDate::fromString(QStringView string, Qt::DateFormat format)
{
    if (string.isEmpty())
        return QDate();
 
    switch (format) {
    case Qt::RFC2822Date:
        return rfcDateImpl(string).date;
    default:
    case Qt::TextDate: {
        // Documented as "ddd MMM d yyyy"
        QVarLengthArray<QStringView, 4> parts;
        auto tokens = string.tokenize(u' ', Qt::SkipEmptyParts);
        auto it = tokens.begin();
        for (int i = 0; i < 4 && it != tokens.end(); ++i, ++it)
            parts.emplace_back(*it);
 
        if (parts.size() != 4 || it != tokens.end())
            return QDate();
 
        bool ok = false;
        int year = parts.at(3).toInt(&ok);
        int day = ok ? parts.at(2).toInt(&ok) : 0;
        if (!ok || !day)
            return QDate();
 
        const int month = fromShortMonthName(parts.at(1));
        if (month == -1) // Month name matches no English or localised name.
            return QDate();
 
        return QDate(year, month, day);
        }
    case Qt::ISODate:
        // Semi-strict parsing, must be long enough and have punctuators as separators
        if (string.size() >= 10 && string.at(4).isPunct() && string.at(7).isPunct()
                && (string.size() == 10 || !string.at(10).isDigit())) {
            const ParsedInt year = readInt(string.first(4));
            const ParsedInt month = readInt(string.sliced(5, 2));
            const ParsedInt day = readInt(string.sliced(8, 2));
            if (year.ok && year.value > 0 && year.value <= 9999 && month.ok && day.ok)
                return QDate(year.value, month.value, day.value);
        }
        break;
    }
    return QDate();
}
 
QDate QDate::fromString(const QString &string, QStringView format, QCalendar cal)
{
    QDate date;
#if QT_CONFIG(datetimeparser)
    QDateTimeParser dt(QMetaType::QDate, QDateTimeParser::FromString, cal);
    dt.setDefaultLocale(QLocale::c());
    if (dt.parseFormat(format))
        dt.fromString(string, &date, nullptr);
#else
    Q_UNUSED(string);
    Q_UNUSED(format);
    Q_UNUSED(cal);
#endif
    return date;
}
#endif // datestring
 
bool QDate::isValid(int year, int month, int day)
{
    return QGregorianCalendar::validParts(year, month, day);
}
 
bool QDate::isLeapYear(int y)
{
    return QGregorianCalendar::leapTest(y);
}
 
/*****************************************************************************
  QTime member functions
 *****************************************************************************/
 
QTime::QTime(int h, int m, int s, int ms)
{
    setHMS(h, m, s, ms);
}
 
 
bool QTime::isValid() const
{
    return mds > NullTime && mds < MSECS_PER_DAY;
}
 
 
int QTime::hour() const
{
    if (!isValid())
        return -1;
 
    return ds() / MSECS_PER_HOUR;
}
 
int QTime::minute() const
{
    if (!isValid())
        return -1;
 
    return (ds() % MSECS_PER_HOUR) / MSECS_PER_MIN;
}
 
int QTime::second() const
{
    if (!isValid())
        return -1;
 
    return (ds() / MSECS_PER_SEC) % SECS_PER_MIN;
}
 
int QTime::msec() const
{
    if (!isValid())
        return -1;
 
    return ds() % MSECS_PER_SEC;
}
 
#if QT_CONFIG(datestring) // depends on, so implies, textdate
QString QTime::toString(Qt::DateFormat format) const
{
    if (!isValid())
        return QString();
 
    switch (format) {
    case Qt::ISODateWithMs:
        return QString::asprintf("%02d:%02d:%02d.%03d", hour(), minute(), second(), msec());
    case Qt::RFC2822Date:
    case Qt::ISODate:
    case Qt::TextDate:
    default:
        return QString::asprintf("%02d:%02d:%02d", hour(), minute(), second());
    }
}
 
QString QTime::toString(QStringView format) const
{
    return QLocale::c().toString(*this, format);
}
#endif // datestring
 
bool QTime::setHMS(int h, int m, int s, int ms)
{
    if (!isValid(h,m,s,ms)) {
        mds = NullTime;                // make this invalid
        return false;
    }
    mds = (h * SECS_PER_HOUR + m * SECS_PER_MIN + s) * MSECS_PER_SEC + ms;
    Q_ASSERT(mds >= 0 && mds < MSECS_PER_DAY);
    return true;
}
 
QTime QTime::addSecs(int s) const
{
    s %= SECS_PER_DAY;
    return addMSecs(s * MSECS_PER_SEC);
}
 
int QTime::secsTo(QTime t) const
{
    if (!isValid() || !t.isValid())
        return 0;
 
    // Truncate milliseconds as we do not want to consider them.
    int ourSeconds = ds() / MSECS_PER_SEC;
    int theirSeconds = t.ds() / MSECS_PER_SEC;
    return theirSeconds - ourSeconds;
}
 
QTime QTime::addMSecs(int ms) const
{
    QTime t;
    if (isValid())
        t.mds = QRoundingDown::qMod(ds() + ms, MSECS_PER_DAY);
    return t;
}
 
int QTime::msecsTo(QTime t) const
{
    if (!isValid() || !t.isValid())
        return 0;
    return t.ds() - ds();
}
 
 
#if QT_CONFIG(datestring) // depends on, so implies, textdate
 
static QTime fromIsoTimeString(QStringView string, Qt::DateFormat format, bool *isMidnight24)
{
    Q_ASSERT(format == Qt::TextDate || format == Qt::ISODate || format == Qt::ISODateWithMs);
    if (isMidnight24)
        *isMidnight24 = false;
    // Match /\d\d(:\d\d(:\d\d)?)?([,.]\d+)?/ as "HH[:mm[:ss]][.zzz]"
    // The fractional part, if present, is in the same units as the field it follows.
    // TextDate restricts fractional parts to the seconds field.
 
    QStringView tail;
    const int dot = string.indexOf(u'.'), comma = string.indexOf(u',');
    if (dot != -1) {
        tail = string.sliced(dot + 1);
        if (tail.indexOf(u'.') != -1) // Forbid second dot:
            return QTime();
        string = string.first(dot);
    } else if (comma != -1) {
        tail = string.sliced(comma + 1);
        string = string.first(comma);
    }
    if (tail.indexOf(u',') != -1) // Forbid comma after first dot-or-comma:
        return QTime();
 
    const ParsedInt frac = readInt(tail);
    // There must be *some* digits in a fractional part; and it must be all digits:
    if (tail.isEmpty() ? dot != -1 || comma != -1 : !frac.ok)
        return QTime();
    Q_ASSERT(frac.ok ^ tail.isEmpty());
    double fraction = frac.ok ? frac.value * std::pow(0.1, tail.size()) : 0.0;
 
    const int size = string.size();
    if (size < 2 || size > 8)
        return QTime();
 
    ParsedInt hour = readInt(string.first(2));
    if (!hour.ok || hour.value > (format == Qt::TextDate ? 23 : 24))
        return QTime();
 
    ParsedInt minute;
    if (string.size() > 2) {
        if (string[2] == u':' && string.size() > 4)
            minute = readInt(string.sliced(3, 2));
        if (!minute.ok || minute.value >= 60)
            return QTime();
    } else if (format == Qt::TextDate) { // Requires minutes
        return QTime();
    } else if (frac.ok) {
        Q_ASSERT(!(fraction < 0.0) && fraction < 1.0);
        fraction *= 60;
        minute.value = qulonglong(fraction);
        fraction -= minute.value;
    }
 
    ParsedInt second;
    if (string.size() > 5) {
        if (string[5] == u':' && string.size() == 8)
            second = readInt(string.sliced(6, 2));
        if (!second.ok || second.value >= 60)
            return QTime();
    } else if (frac.ok) {
        if (format == Qt::TextDate) // Doesn't allow fraction of minutes
            return QTime();
        Q_ASSERT(!(fraction < 0.0) && fraction < 1.0);
        fraction *= 60;
        second.value = qulonglong(fraction);
        fraction -= second.value;
    }
 
    Q_ASSERT(!(fraction < 0.0) && fraction < 1.0);
    // Round millis to nearest (unlike minutes and seconds, rounded down):
    int msec = frac.ok ? qRound(MSECS_PER_SEC * fraction) : 0;
    // But handle overflow gracefully:
    if (msec == MSECS_PER_SEC) {
        // If we can (when data were otherwise valid) validly propagate overflow
        // into other fields, do so:
        if (isMidnight24 || hour.value < 23 || minute.value < 59 || second.value < 59) {
            msec = 0;
            if (++second.value == 60) {
                second.value = 0;
                if (++minute.value == 60) {
                    minute.value = 0;
                    ++hour.value;
                    // May need to propagate further via isMidnight24, see below
                }
            }
        } else {
            // QTime::fromString() or Qt::TextDate: rounding up would cause
            // 23:59:59.999... to become invalid; clip to 999 ms instead:
            msec = MSECS_PER_SEC - 1;
        }
    }
 
    // For ISO date format, 24:0:0 means 0:0:0 on the next day:
    if (hour.value == 24 && minute.value == 0 && second.value == 0 && msec == 0) {
        Q_ASSERT(format != Qt::TextDate); // It clipped hour at 23, above.
        if (isMidnight24)
            *isMidnight24 = true;
        hour.value = 0;
    }
 
    return QTime(hour.value, minute.value, second.value, msec);
}
 
QTime QTime::fromString(QStringView string, Qt::DateFormat format)
{
    if (string.isEmpty())
        return QTime();
 
    switch (format) {
    case Qt::RFC2822Date:
        return rfcDateImpl(string).time;
    case Qt::ISODate:
    case Qt::ISODateWithMs:
    case Qt::TextDate:
    default:
        return fromIsoTimeString(string, format, nullptr);
    }
}
 
QTime QTime::fromString(const QString &string, QStringView format)
{
    QTime time;
#if QT_CONFIG(datetimeparser)
    QDateTimeParser dt(QMetaType::QTime, QDateTimeParser::FromString, QCalendar());
    dt.setDefaultLocale(QLocale::c());
    if (dt.parseFormat(format))
        dt.fromString(string, nullptr, &time);
#else
    Q_UNUSED(string);
    Q_UNUSED(format);
#endif
    return time;
}
#endif // datestring
 
 
bool QTime::isValid(int h, int m, int s, int ms)
{
    return uint(h) < 24 && uint(m) < 60 && uint(s) < SECS_PER_MIN && uint(ms) < MSECS_PER_SEC;
}
 
/*****************************************************************************
  QDateTime static helper functions
 *****************************************************************************/
 
// get the types from QDateTime (through QDateTimePrivate)
typedef QDateTimePrivate::QDateTimeShortData ShortData;
typedef QDateTimePrivate::QDateTimeData QDateTimeData;
 
// Returns the tzname, assume tzset has been called already
static QString qt_tzname(QDateTimePrivate::DaylightStatus daylightStatus)
{
    int isDst = (daylightStatus == QDateTimePrivate::DaylightTime) ? 1 : 0;
#if defined(Q_CC_MSVC)
    size_t s = 0;
    char name[512];
    if (_get_tzname(&s, name, 512, isDst))
        return QString();
    return QString::fromLocal8Bit(name);
#else
    return QString::fromLocal8Bit(tzname[isDst]);
#endif // Q_OS_WIN
}
 
#if QT_CONFIG(datetimeparser)
/*
  \internal
  Implemented here to share qt_tzname()
*/
int QDateTimeParser::startsWithLocalTimeZone(QStringView name)
{
    QDateTimePrivate::DaylightStatus zones[2] = {
        QDateTimePrivate::StandardTime,
        QDateTimePrivate::DaylightTime
    };
    for (const auto z : zones) {
        QString zone(qt_tzname(z));
        if (name.startsWith(zone))
            return zone.size();
    }
    return 0;
}
#endif // datetimeparser
 
/*
    Qt represents n BCE as -n, whereas struct tm's tm_year field represents a
    year by the number of years after (negative for before) 1900, so that 1+m
    BCE is -1900 -m; so treating 1 BCE as 0 CE. We thus shift by different
    offsets depending on whether the year is BCE or CE.
*/
static constexpr int tmYearFromQYear(int year) { return year - (year < 0 ? 1899 : 1900); }
static constexpr int qYearFromTmYear(int year) { return year + (year < -1899 ? 1899 : 1900); }
 
/* If mktime() returns -1, is it really an error ?
 
   It might return -1 because we're looking at the last second of 1969 and
   mktime does support times before 1970 (POSIX says "If the year is <1970 or
   the value is negative, the relationship is undefined" and MS rejects the
   value, consistent with that; so we don't call qt_mktime() on MS in this case
   and can't get -1 unless it's a real error). However, on UNIX, that's -1 UTC
   time and all we know, aside from mktime's return, is the local time. (We
   could check errno, but we call mktime from within a
   qt_scoped_lock(QBasicMutex), whose unlocking and destruction of the locker
   might frob errno.)
 
   We can assume the zone offset is a multiple of five minutes and less than a
   day, so this can only arise for the last second of a minute that differs from
   59 by a multiple of 5 on the last day of 1969 or the first day of 1970.  That
   makes for a cheap pre-test; if it holds, we can ask mktime about the first
   second of the same minute; if it gives us -60, then the -1 we originally saw
   is not an error (or was an error, but needn't have been).
*/
static inline bool meansEnd1969(tm *local)
{
#ifdef Q_OS_WIN
    Q_UNUSED(local);
    return false;
#else
    if (local->tm_sec < 59 || local->tm_year < 69 || local->tm_year > 70
        || local->tm_min % 5 != 4 // Assume zone offset is a multiple of 5 mins
        || (local->tm_year == 69
            ? local->tm_mon < 11 || local->tm_mday < 31
            : local->tm_mon > 0 || local->tm_mday > 1)) {
        return false;
    }
    tm copy = *local;
    copy.tm_sec--; // Preceding second should get -2, not -1
    if (qMkTime(&copy) != -2)
        return false;
    // The original call to qMkTime() may have returned -1 as failure, not
    // updating local, even though it could have; so fake it here. Assumes there
    // was no transition in the last minute of the day !
    *local = copy;
    local->tm_sec++; // Advance back to the intended second
    return true;
#endif
}
 
/*
    Call mktime but bypass its fixing of denormal times.
 
    The POSIX spec says mktime() accepts a struct tm whose fields lie outside
    the usual ranges; the parameter is not const-qualified and will be updated
    to have values in those ranges. However, MS's implementation doesn't do that
    (or hasn't always done it); and the only member we actually want updated is
    the tm_isdst flag.  (Aside: MS's implementation also only works for tm_year
    >= 70; this is, in fact, in accordance with the POSIX spec; but all known
    UNIX libc implementations in fact have a signed time_t and Do The Sensible
    Thing, to the best of their ability, at least for 0 <= tm_year < 70; see
    meansEnd1969 for the handling of the last second of UTC's 1969.)
 
    If we thought we knew tm_isdst and mktime() disagrees, it'll let us know
    either by correcting it - in which case it adjusts the struct tm to reflect
    the same time, but represented using the right tm_isdst, so typically an
    hour earlier or later - or by returning -1. When this happens, the way we
    actually use qt_mktime(), we don't want a revised time with corrected DST,
    we want the original time with its corrected DST; so we retry the call, this
    time not claiming to know the DST-ness.
 
    POSIX doesn't actually say what to do if the specified struct tm describes a
    time in a spring-forward gap: read literally, this is an unrepresentable
    time and it could return -1, setting errno to EOVERFLOW. However, actual
    implementations chose a time one side or the other of the gap. For example,
    if we claim to know DST, glibc pushes to the other side of the gap (changing
    tm_isdst), but stays on the indicated branch of a repetition (no change to
    tm_isdst); this matches how QTimeZonePrivate::dataForLocalTime() uses its
    hint; in either case, if we don't claim to know DST, glibc picks the DST
    candidate. (Experiments conducted with glibc 2.31-9.)
*/
static inline bool callMkTime(tm *local, time_t *secs)
{
    constexpr time_t maybeError = -1; // mktime()'s return on error; or last second of 1969 UTC.
    const tm copy = *local;
    *secs = qMkTime(local);
    bool good = *secs != maybeError || meansEnd1969(local);
    if (copy.tm_isdst >= 0 && (!good || local->tm_isdst != copy.tm_isdst)) {
        // We thought we knew DST-ness, but were wrong:
        *local = copy;
        local->tm_isdst = -1;
        *secs = qMkTime(local);
        good = *secs != maybeError || meansEnd1969(local);
    }
#if defined(Q_OS_WIN)
    // Windows mktime for the missing hour backs up 1 hour instead of advancing
    // 1 hour. If time differs and is standard time then this has happened, so
    // add 2 hours to the time and 1 hour to the secs
    if (local->tm_isdst == 0 && local->tm_hour != copy.tm_hour) {
        local->tm_hour += 2;
        if (local->tm_hour > 23) {
            local->tm_hour -= 24;
            if (++local->tm_mday > QGregorianCalendar::monthLength(
                    local->tm_mon + 1, qYearFromTmYear(local->tm_year))) {
                local->tm_mday = 1;
                if (++local->tm_mon > 11) {
                    local->tm_mon = 0;
                    ++local->tm_year;
                }
            }
        }
        *secs += SECS_PER_HOUR;
        local->tm_isdst = 1;
    }
#endif // Q_OS_WIN
    return good;
}
 
// Calls the platform variant of mktime for the given date, time and
// daylightStatus, and updates the date, time, daylightStatus and abbreviation
// with the returned values. If the date falls outside the time_t range
// supported by mktime, then date/time will not be updated and *ok is set false.
static qint64 qt_mktime(QDate *date, QTime *time, QDateTimePrivate::DaylightStatus *daylightStatus,
                        QString *abbreviation, bool *ok)
{
    Q_ASSERT(ok && date && time);
    qint64 msec = time->msec();
    Q_ASSERT(msec < MSECS_PER_SEC);
    int yy, mm, dd;
    date->getDate(&yy, &mm, &dd);
 
    tm local = {};
    local.tm_sec = time->second();
    local.tm_min = time->minute();
    local.tm_hour = time->hour();
    local.tm_mday = dd;
    local.tm_mon = mm - 1;
    local.tm_year = tmYearFromQYear(yy);
    local.tm_isdst = daylightStatus ? int(*daylightStatus) : -1;
 
    time_t secsSinceEpoch;
    if (!callMkTime(&local, &secsSinceEpoch)) {
        *date = QDate();
        *time = QTime();
        if (daylightStatus)
            *daylightStatus = QDateTimePrivate::UnknownDaylightTime;
        if (abbreviation)
            *abbreviation = QString();
        *ok = false;
        return 0;
    }
 
    // Store date and time:
    *date = QDate(qYearFromTmYear(local.tm_year), local.tm_mon + 1, local.tm_mday);
    *time = QTime(local.tm_hour, local.tm_min, local.tm_sec, msec);
 
    // Store zone details:
    if (local.tm_isdst > 0) {
        if (daylightStatus)
            *daylightStatus = QDateTimePrivate::DaylightTime;
        if (abbreviation)
            *abbreviation = qt_tzname(QDateTimePrivate::DaylightTime);
    } else {
        if (daylightStatus) {
            *daylightStatus = (local.tm_isdst == 0
                               ? QDateTimePrivate::StandardTime
                               : QDateTimePrivate::UnknownDaylightTime);
        }
        if (abbreviation)
            *abbreviation = qt_tzname(QDateTimePrivate::StandardTime);
    }
 
    // Compute final UTC milliseconds since epoch:
    if (secsSinceEpoch < 0 && msec > 0) {
        secsSinceEpoch++;
        msec -= MSECS_PER_SEC;
    }
    qint64 millis;
    const bool overflow =
        mul_overflow(qint64(secsSinceEpoch),
                     std::integral_constant<qint64, MSECS_PER_SEC>(), &millis)
        || add_overflow(millis, msec, &msec);
    *ok = !overflow;
 
    return msec;
}
 
// Calls the platform variant of localtime for the given msecs, and updates
// the date, time, and DST status with the returned values.
static bool qt_localtime(qint64 msecsSinceEpoch, QDate *localDate, QTime *localTime,
                         QDateTimePrivate::DaylightStatus *daylightStatus)
{
    const int signFix = msecsSinceEpoch % MSECS_PER_SEC && msecsSinceEpoch < 0 ? 1 : 0;
    const time_t secsSinceEpoch = msecsSinceEpoch / MSECS_PER_SEC - signFix;
    const int msec = msecsSinceEpoch % MSECS_PER_SEC + signFix * MSECS_PER_SEC;
    Q_ASSERT(msec >= 0 && msec < MSECS_PER_SEC);
 
    tm local;
    bool valid = false;
 
    // localtime() is specified to work as if it called tzset().
    // localtime_r() does not have this constraint, so make an explicit call.
    // The explicit call should also request the timezone info be re-parsed.
    qTzSet();
    if (qint64(secsSinceEpoch) * MSECS_PER_SEC + msec == msecsSinceEpoch) {
#if QT_CONFIG(thread) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
        // Use the reentrant version of localtime() where available
        // as is thread-safe and doesn't use a shared static data area
        if (tm *res = localtime_r(&secsSinceEpoch, &local)) {
            Q_ASSERT(res == &local);
            valid = true;
        }
#elif defined(Q_OS_WIN)
        if (!localtime_s(&local, &secsSinceEpoch))
            valid = true;
#else
        // Returns shared static data which may be overwritten at any time
        // So copy the result asap
        if (tm *res = localtime(&secsSinceEpoch)) {
            local = *res;
            valid = true;
        }
#endif
    }
    if (valid) {
        *localDate = QDate(qYearFromTmYear(local.tm_year), local.tm_mon + 1, local.tm_mday);
        *localTime = QTime(local.tm_hour, local.tm_min, local.tm_sec, msec);
        if (daylightStatus) {
            if (local.tm_isdst > 0)
                *daylightStatus = QDateTimePrivate::DaylightTime;
            else if (local.tm_isdst < 0)
                *daylightStatus = QDateTimePrivate::UnknownDaylightTime;
            else
                *daylightStatus = QDateTimePrivate::StandardTime;
        }
        return true;
    } else {
        *localDate = QDate();
        *localTime = QTime();
        if (daylightStatus)
            *daylightStatus = QDateTimePrivate::UnknownDaylightTime;
        return false;
    }
}
 
// Converts an msecs value into a date and time
static void msecsToTime(qint64 msecs, QDate *date, QTime *time)
{
    qint64 jd = JULIAN_DAY_FOR_EPOCH;
    qint64 ds = 0;
 
    if (msecs >= MSECS_PER_DAY || msecs <= -MSECS_PER_DAY) {
        jd += msecs / MSECS_PER_DAY;
        msecs %= MSECS_PER_DAY;
    }
 
    if (msecs < 0) {
        ds = MSECS_PER_DAY - msecs - 1;
        jd -= ds / MSECS_PER_DAY;
        ds = ds % MSECS_PER_DAY;
        ds = MSECS_PER_DAY - ds - 1;
    } else {
        ds = msecs;
    }
 
    if (date)
        *date = QDate::fromJulianDay(jd);
    if (time)
        *time = QTime::fromMSecsSinceStartOfDay(ds);
}
 
// Converts a date/time value into msecs
static qint64 timeToMSecs(QDate date, QTime time)
{
    qint64 days = date.toJulianDay() - JULIAN_DAY_FOR_EPOCH;
    qint64 msecs, dayms = time.msecsSinceStartOfDay();
    if (days < 0 && dayms > 0) {
        ++days;
        dayms -= MSECS_PER_DAY;
    }
    if (mul_overflow(days, std::integral_constant<qint64, MSECS_PER_DAY>(), &msecs)
        || add_overflow(msecs, dayms, &msecs)) {
        using Bound = std::numeric_limits<qint64>;
        return days < 0 ? Bound::min() : Bound::max();
    }
    return msecs;
}
 
static auto computeSystemMillisRange()
{
    struct R { qint64 min, max; bool minClip, maxClip; };
    using Bounds = std::numeric_limits<qint64>;
    constexpr bool isNarrow = Bounds::max() / MSECS_PER_SEC > TIME_T_MAX;
    if constexpr (isNarrow) {
        const qint64 msecsMax = quint64(TIME_T_MAX) * MSECS_PER_SEC - 1 + MSECS_PER_SEC;
        const qint64 msecsMin = -1 - msecsMax; // TIME_T_MIN is -1 - TIME_T_MAX
        // If we reach back to msecsMin, use it; otherwise, assume 1970 cut-off (MS).
        struct tm local = {};
        local.tm_year = tmYearFromQYear(1901);
        local.tm_mon = 11;
        local.tm_mday = 15; // A day and a bit after the start of 32-bit time_t:
        local.tm_isdst = -1;
        return R{qMkTime(&local) == -1 ? 0 : msecsMin, msecsMax, false, false};
    } else {
        const struct { int year; qint64 millis; } starts[] = {
            { int(QDateTime::YearRange::First) + 1, Bounds::min() },
            // Beginning of the Common Era:
            { 1, -Q_INT64_C(62135596800000) },
            // Invention of the Gregorian calendar:
            { 1582, -Q_INT64_C(12244089600000) },
            // Its adoption by the anglophone world:
            { 1752, -Q_INT64_C(6879427200000) },
            // Before this, struct tm's tm_year is negative (Darwin):
            { 1900, -Q_INT64_C(2208988800000) },
        }, ends[] = {
            { int(QDateTime::YearRange::Last) - 1, Bounds::max() },
            // MS's end-of-range, end of year 3000:
            { 3000, Q_INT64_C(32535215999999) },
        };
        // Assume we do at least reach the end of a signed 32-bit time_t (since
        // our actual time_t is bigger than that):
        qint64 stop =
            quint64(std::numeric_limits<qint32>::max()) * MSECS_PER_SEC - 1 + MSECS_PER_SEC;
        // Cleared if first pass round loop fails:
        bool stopMax = true;
        for (const auto c : ends) {
            struct tm local = {};
            local.tm_year = tmYearFromQYear(c.year);
            local.tm_mon = 11;
            local.tm_mday = 31;
            local.tm_hour = 23;
            local.tm_min = local.tm_sec = 59;
            local.tm_isdst = -1;
            if (qMkTime(&local) != -1) {
                stop = c.millis;
                break;
            }
            stopMax = false;
        }
        bool startMin = true;
        for (const auto c : starts) {
            struct tm local {};
            local.tm_year = tmYearFromQYear(c.year);
            local.tm_mon = 1;
            local.tm_mday = 1;
            local.tm_isdst = -1;
            if (qMkTime(&local) != -1)
                return R{c.millis, stop, startMin, stopMax};
            startMin = false;
        }
        return R{0, stop, false, stopMax};
    }
}
 
static inline bool millisInSystemRange(qint64 millis, qint64 slack = 0)
{
    static const auto bounds = computeSystemMillisRange();
    return (bounds.minClip || millis >= bounds.min - slack)
        && (bounds.maxClip || millis <= bounds.max + slack);
}
 
static int systemTimeYearMatching(int year)
{
#if defined(Q_OS_WIN) || defined(Q_OS_WASM)// They don't support times before the epoch
    static constexpr int forLeapEarly[] = { 1984, 1996, 1980, 1992, 1976, 1988, 1972 };
    static constexpr int regularEarly[] = { 1978, 1973, 1974, 1975, 1970, 1971, 1977 };
#else // First year fully in 32-bit time_t range is 1902
    static constexpr int forLeapEarly[] = { 1928, 1912, 1924, 1908, 1920, 1904, 1916 };
    static constexpr int regularEarly[] = { 1905, 1906, 1907, 1902, 1903, 1909, 1910 };
#endif
    static constexpr int forLeapLate[] = { 2012, 2024, 2036, 2020, 2032, 2016, 2028 };
    static constexpr int regularLate[] = { 2034, 2035, 2030, 2031, 2037, 2027, 2033 };
    const int dow = QGregorianCalendar::yearStartWeekDay(year);
    Q_ASSERT(dow == QDate(year, 1, 1).dayOfWeek());
    const int res = (QGregorianCalendar::leapTest(year)
                     ? (year < 1970 ? forLeapEarly : forLeapLate)
                     : (year < 1970 ? regularEarly : regularLate))[dow == 7 ? 0 : dow];
    Q_ASSERT(QDate(res, 1, 1).dayOfWeek() == dow);
    Q_ASSERT(QDate(res, 12, 31).dayOfWeek() == QDate(year, 12, 31).dayOfWeek());
    return res;
}
 
// Convert an MSecs Since Epoch into Local Time
bool QDateTimePrivate::epochMSecsToLocalTime(qint64 msecs, QDate *localDate, QTime *localTime,
                                             DaylightStatus *daylightStatus)
{
    if (!millisInSystemRange(msecs)) {
        // Docs state any LocalTime after 2038-01-18 *will* have any DST applied.
        // When this falls outside the supported range, we need to fake it.
#if QT_CONFIG(timezone)
        // Use the system time-zone.
        const auto sys = QTimeZone::systemTimeZone();
        if (sys.isValid()) {
            if (daylightStatus) {
                *daylightStatus = sys.d->isDaylightTime(msecs)
                    ? QDateTimePrivate::DaylightTime
                    : QDateTimePrivate::StandardTime;
            }
            if (add_overflow(msecs, sys.d->offsetFromUtc(msecs) * MSECS_PER_SEC, &msecs))
                return false;
            msecsToTime(msecs, localDate, localTime);
            return true;
        }
#endif // timezone
        // Kludge
        // Use existing method to fake the conversion.
        QDate utcDate;
        QTime utcTime;
        msecsToTime(msecs, &utcDate, &utcTime);
        int year, month, day;
        utcDate.getDate(&year, &month, &day);
 
        QDate fakeDate(systemTimeYearMatching(year), month, day);
        qint64 fakeMsecs = QDateTime(fakeDate, utcTime, Qt::UTC).toMSecsSinceEpoch();
        bool res = qt_localtime(fakeMsecs, localDate, localTime, daylightStatus);
        *localDate = localDate->addDays(fakeDate.daysTo(utcDate));
        return res;
    }
 
    // Falls inside time_t supported range so localtime can handle it:
    return qt_localtime(msecs, localDate, localTime, daylightStatus);
}
 
// Convert a LocalTime expressed in local msecs encoding and the corresponding
// DST status into a UTC epoch msecs. Optionally populate the returned
// values from mktime for the adjusted local date and time.
qint64 QDateTimePrivate::localMSecsToEpochMSecs(qint64 localMsecs,
                                                DaylightStatus *daylightStatus,
                                                QDate *localDate, QTime *localTime,
                                                QString *abbreviation)
{
    // First, if localMsecs is within +/- 1 day of viable range, try mktime() in
    // case it does fall in the range and gets proper DST conversion:
    if (millisInSystemRange(localMsecs, MSECS_PER_DAY)) {
        bool valid;
        QDate dt;
        QTime tm;
        msecsToTime(localMsecs, &dt, &tm);
        const qint64 utcMsecs = qt_mktime(&dt, &tm, daylightStatus, abbreviation, &valid);
        if (valid && millisInSystemRange(utcMsecs)) {
            // mktime worked and falls in valid range, so use it
            if (localDate)
                *localDate = dt;
            if (localTime)
                *localTime = tm;
            return utcMsecs;
        }
    }
 
    // Otherwise, outside the system range.
#if QT_CONFIG(timezone)
    // Use the system zone:
    const auto sys = QTimeZone::systemTimeZone();
    if (sys.isValid()) {
        return QDateTimePrivate::zoneMSecsToEpochMSecs(localMsecs, sys, daylightStatus,
                                                       localDate, localTime, abbreviation);
    }
#endif // timezone
    // Kludge
    // Use existing method to fake the conversion.
    QDate dt;
    QTime tm;
    msecsToTime(localMsecs, &dt, &tm);
    int year, month, day;
    dt.getDate(&year, &month, &day);
    bool ok;
    QDate fakeDate(systemTimeYearMatching(year), month, day);
    const qint64 fakeDiff = fakeDate.daysTo(dt);
    const qint64 utcMsecs = qt_mktime(&fakeDate, &tm, daylightStatus, abbreviation, &ok);
    Q_ASSERT(ok);
    if (localDate)
        *localDate = fakeDate.addDays(fakeDiff);
    if (localTime)
        *localTime = tm;
    QDate utcDate;
    QTime utcTime;
    msecsToTime(utcMsecs, &utcDate, &utcTime);
    return timeToMSecs(utcDate.addDays(fakeDiff), utcTime);
}
 
static inline bool specCanBeSmall(Qt::TimeSpec spec)
{
    return spec == Qt::LocalTime || spec == Qt::UTC;
}
 
static inline bool msecsCanBeSmall(qint64 msecs)
{
    if (!QDateTimeData::CanBeSmall)
        return false;
 
    ShortData sd;
    sd.msecs = qintptr(msecs);
    return sd.msecs == msecs;
}
 
static constexpr inline
QDateTimePrivate::StatusFlags mergeSpec(QDateTimePrivate::StatusFlags status, Qt::TimeSpec spec)
{
    status &= ~QDateTimePrivate::TimeSpecMask;
    status |= QDateTimePrivate::StatusFlags::fromInt(int(spec) << QDateTimePrivate::TimeSpecShift);
    return status;
}
 
static constexpr inline Qt::TimeSpec extractSpec(QDateTimePrivate::StatusFlags status)
{
    return Qt::TimeSpec((status & QDateTimePrivate::TimeSpecMask).toInt() >> QDateTimePrivate::TimeSpecShift);
}
 
// Set the Daylight Status if LocalTime set via msecs
static constexpr inline QDateTimePrivate::StatusFlags
mergeDaylightStatus(QDateTimePrivate::StatusFlags sf, QDateTimePrivate::DaylightStatus status)
{
    sf &= ~QDateTimePrivate::DaylightMask;
    if (status == QDateTimePrivate::DaylightTime) {
        sf |= QDateTimePrivate::SetToDaylightTime;
    } else if (status == QDateTimePrivate::StandardTime) {
        sf |= QDateTimePrivate::SetToStandardTime;
    }
    return sf;
}
 
// Get the DST Status if LocalTime set via msecs
static constexpr inline
QDateTimePrivate::DaylightStatus extractDaylightStatus(QDateTimePrivate::StatusFlags status)
{
    if (status & QDateTimePrivate::SetToDaylightTime)
        return QDateTimePrivate::DaylightTime;
    if (status & QDateTimePrivate::SetToStandardTime)
        return QDateTimePrivate::StandardTime;
    return QDateTimePrivate::UnknownDaylightTime;
}
 
static inline qint64 getMSecs(const QDateTimeData &d)
{
    if (d.isShort()) {
        // same as, but producing better code
        //return d.data.msecs;
        return qintptr(d.d) >> 8;
    }
    return d->m_msecs;
}
 
static inline QDateTimePrivate::StatusFlags getStatus(const QDateTimeData &d)
{
    if (d.isShort()) {
        // same as, but producing better code
        //return StatusFlag(d.data.status);
        return QDateTimePrivate::StatusFlag(qintptr(d.d) & 0xFF);
    }
    return d->m_status;
}
 
static inline Qt::TimeSpec getSpec(const QDateTimeData &d)
{
    return extractSpec(getStatus(d));
}
 
/* True if we *can cheaply determine* that a and b use the same offset.
   If they use different offsets or it would be expensive to find out, false.
   Calls to toMSecsSinceEpoch() are expensive, for these purposes.
   See QDateTime's comparison operators.
*/
static inline bool usesSameOffset(const QDateTimeData &a, const QDateTimeData &b)
{
    const auto status = getStatus(a);
    if (status != getStatus(b))
        return false;
    // Status includes DST-ness, so we now know they match in it.
 
    switch (extractSpec(status)) {
    case Qt::LocalTime:
    case Qt::UTC:
        return true;
 
    case Qt::TimeZone:
        /* TimeZone always determines its offset during construction of the
           private data. Even if we're in different zones, what matters is the
           offset actually in effect at the specific time. (DST can cause things
           with the same time-zone to use different offsets, but we already
           checked their DSTs match.) */
    case Qt::OffsetFromUTC: // always knows its offset, which is all that matters.
        Q_ASSERT(!a.isShort() && !b.isShort());
        return a->m_offsetFromUtc == b->m_offsetFromUtc;
    }
    Q_UNREACHABLE();
    return false;
}
 
// Refresh the LocalTime or TimeZone validity and offset
static void refreshZonedDateTime(QDateTimeData &d, Qt::TimeSpec spec)
{
    Q_ASSERT(spec == Qt::TimeZone || spec == Qt::LocalTime);
    auto status = getStatus(d);
    Q_ASSERT(extractSpec(status) == spec);
    int offsetFromUtc = 0;
 
    // If not valid date and time then is invalid
    if (!(status & QDateTimePrivate::ValidDate) || !(status & QDateTimePrivate::ValidTime)) {
        status &= ~QDateTimePrivate::ValidDateTime;
    } else {
        // We have a valid date and time and a Qt::LocalTime or Qt::TimeZone that needs calculating
        // LocalTime and TimeZone might fall into a "missing" DST transition hour
        // Calling toEpochMSecs will adjust the returned date/time if it does
        const qint64 msecs = getMSecs(d);
        qint64 epochMSecs = 0;
        QDate testDate;
        QTime testTime;
        auto dstStatus = extractDaylightStatus(status);
        if (spec == Qt::LocalTime) {
            epochMSecs =
                QDateTimePrivate::localMSecsToEpochMSecs(msecs, &dstStatus, &testDate, &testTime);
#if QT_CONFIG(timezone)
        // else spec == Qt::TimeZone, so check zone is valid:
        } else if (d->m_timeZone.isValid()) {
            epochMSecs = QDateTimePrivate::zoneMSecsToEpochMSecs(
                msecs, d->m_timeZone, &dstStatus, &testDate, &testTime);
#endif // timezone
        } // else: testDate, testTime haven't been set, so are invalid.
        const bool ok = testDate.isValid() && testTime.isValid();
        // Cache the offset to use in offsetFromUtc() &c., even if the next
        // check marks invalid; this lets fromMSecsSinceEpoch() give a useful
        // fallback for times in spring-forward gaps.
        if (ok)
            offsetFromUtc = (msecs - epochMSecs) / MSECS_PER_SEC;
        Q_ASSERT(offsetFromUtc >= -SECS_PER_DAY && offsetFromUtc <= SECS_PER_DAY);
        if (ok && timeToMSecs(testDate, testTime) == msecs) {
            status = mergeDaylightStatus(status, dstStatus);
            status |= QDateTimePrivate::ValidDateTime;
        } else {
            status &= ~QDateTimePrivate::ValidDateTime;
        }
    }
 
    if (status & QDateTimePrivate::ShortData) {
        d.data.status = status.toInt();
    } else {
        d->m_status = status;
        d->m_offsetFromUtc = offsetFromUtc;
    }
}
 
// Check the UTC / offsetFromUTC validity
static void refreshSimpleDateTime(QDateTimeData &d)
{
    auto status = getStatus(d);
    Q_ASSERT(extractSpec(status) == Qt::UTC || extractSpec(status) == Qt::OffsetFromUTC);
    if ((status & QDateTimePrivate::ValidDate) && (status & QDateTimePrivate::ValidTime))
        status |= QDateTimePrivate::ValidDateTime;
    else
        status &= ~QDateTimePrivate::ValidDateTime;
 
    if (status & QDateTimePrivate::ShortData)
        d.data.status = status.toInt();
    else
        d->m_status = status;
}
 
// Clean up and set status after assorted set-up or reworking:
static void checkValidDateTime(QDateTimeData &d)
{
    auto status = getStatus(d);
    auto spec = extractSpec(status);
    switch (spec) {
    case Qt::OffsetFromUTC:
    case Qt::UTC:
        // for these, a valid date and a valid time imply a valid QDateTime
        refreshSimpleDateTime(d);
        break;
    case Qt::TimeZone:
    case Qt::LocalTime:
        // for these, we need to check whether the timezone is valid and whether
        // the time is valid in that timezone. Expensive, but no other option.
        refreshZonedDateTime(d, spec);
        break;
    }
}
 
// Caller needs to refresh after calling this
static void setTimeSpec(QDateTimeData &d, Qt::TimeSpec spec, int offsetSeconds)
{
    auto status = getStatus(d);
    status &= ~(QDateTimePrivate::ValidDateTime | QDateTimePrivate::DaylightMask |
                QDateTimePrivate::TimeSpecMask);
 
    switch (spec) {
    case Qt::OffsetFromUTC:
        if (offsetSeconds == 0)
            spec = Qt::UTC;
        break;
    case Qt::TimeZone:
        qWarning("Using TimeZone in setTimeSpec() is unsupported"); // Use system time zone instead
        spec = Qt::LocalTime;
        Q_FALLTHROUGH();
    case Qt::UTC:
    case Qt::LocalTime:
        offsetSeconds = 0;
        break;
    }
 
    status = mergeSpec(status, spec);
    if (d.isShort() && offsetSeconds == 0) {
        d.data.status = status.toInt();
    } else {
        d.detach();
        d->m_status = status & ~QDateTimePrivate::ShortData;
        d->m_offsetFromUtc = offsetSeconds;
#if QT_CONFIG(timezone)
        d->m_timeZone = QTimeZone();
#endif // timezone
    }
}
 
static void setDateTime(QDateTimeData &d, QDate date, QTime time)
{
    // If the date is valid and the time is not we set time to 00:00:00
    QTime useTime = time;
    if (!useTime.isValid() && date.isValid())
        useTime = QTime::fromMSecsSinceStartOfDay(0);
 
    QDateTimePrivate::StatusFlags newStatus = { };
 
    // Set date value and status
    qint64 days = 0;
    if (date.isValid()) {
        days = date.toJulianDay() - JULIAN_DAY_FOR_EPOCH;
        newStatus = QDateTimePrivate::ValidDate;
    }
 
    // Set time value and status
    int ds = 0;
    if (useTime.isValid()) {
        ds = useTime.msecsSinceStartOfDay();
        newStatus |= QDateTimePrivate::ValidTime;
    }
    Q_ASSERT(ds < MSECS_PER_DAY);
    // Only the later parts of the very first day are representable - its start
    // would overflow - so get ds the same side of 0 as days:
    if (days < 0 && ds > 0) {
        days++;
        ds -= MSECS_PER_DAY;
    }
 
    // Check in representable range:
    qint64 msecs = 0;
    if (mul_overflow(days, std::integral_constant<qint64, MSECS_PER_DAY>(), &msecs)
        || add_overflow(msecs, qint64(ds), &msecs)) {
        newStatus = QDateTimePrivate::StatusFlags{};
        msecs = 0;
    }
    if (d.isShort()) {
        // let's see if we can keep this short
        if (msecsCanBeSmall(msecs)) {
            // yes, we can
            d.data.msecs = qintptr(msecs);
            d.data.status &= ~(QDateTimePrivate::ValidityMask | QDateTimePrivate::DaylightMask).toInt();
            d.data.status |= newStatus.toInt();
        } else {
            // nope...
            d.detach();
        }
    }
    if (!d.isShort()) {
        d.detach();
        d->m_msecs = msecs;
        d->m_status &= ~(QDateTimePrivate::ValidityMask | QDateTimePrivate::DaylightMask);
        d->m_status |= newStatus;
    }
}
 
static QPair<QDate, QTime> getDateTime(const QDateTimeData &d)
{
    QPair<QDate, QTime> result;
    qint64 msecs = getMSecs(d);
    auto status = getStatus(d);
    msecsToTime(msecs, &result.first, &result.second);
 
    if (!status.testFlag(QDateTimePrivate::ValidDate))
        result.first = QDate();
 
    if (!status.testFlag(QDateTimePrivate::ValidTime))
        result.second = QTime();
 
    return result;
}
 
/*****************************************************************************
  QDateTime::Data member functions
 *****************************************************************************/
 
inline QDateTime::Data::Data() noexcept
{
    // default-constructed data has a special exception:
    // it can be small even if CanBeSmall == false
    // (optimization so we don't allocate memory in the default constructor)
    quintptr value = mergeSpec(QDateTimePrivate::ShortData, Qt::LocalTime).toInt();
    d = reinterpret_cast<QDateTimePrivate *>(value);
}
 
inline QDateTime::Data::Data(Qt::TimeSpec spec)
{
    if (CanBeSmall && Q_LIKELY(specCanBeSmall(spec))) {
        d = reinterpret_cast<QDateTimePrivate *>(quintptr(mergeSpec(QDateTimePrivate::ShortData, spec).toInt()));
    } else {
        // the structure is too small, we need to detach
        d = new QDateTimePrivate;
        d->ref.ref();
        d->m_status = mergeSpec({}, spec);
    }
}
 
inline QDateTime::Data::Data(const Data &other)
    : d(other.d)
{
    if (!isShort()) {
        // check if we could shrink
        if (specCanBeSmall(extractSpec(d->m_status)) && msecsCanBeSmall(d->m_msecs)) {
            ShortData sd;
            sd.msecs = qintptr(d->m_msecs);
            sd.status = (d->m_status | QDateTimePrivate::ShortData).toInt();
            data = sd;
        } else {
            // no, have to keep it big
            d->ref.ref();
        }
    }
}
 
inline QDateTime::Data::Data(Data &&other)
    : d(other.d)
{
    // reset the other to a short state
    Data dummy;
    Q_ASSERT(dummy.isShort());
    other.d = dummy.d;
}
 
inline QDateTime::Data &QDateTime::Data::operator=(const Data &other)
{
    if (d == other.d)
        return *this;
 
    auto x = d;
    d = other.d;
    if (!other.isShort()) {
        // check if we could shrink
        if (specCanBeSmall(extractSpec(other.d->m_status)) && msecsCanBeSmall(other.d->m_msecs)) {
            ShortData sd;
            sd.msecs = qintptr(other.d->m_msecs);
            sd.status = (other.d->m_status | QDateTimePrivate::ShortData).toInt();
            data = sd;
        } else {
            // no, have to keep it big
            other.d->ref.ref();
        }
    }
 
    if (!(quintptr(x) & QDateTimePrivate::ShortData) && !x->ref.deref())
        delete x;
    return *this;
}
 
inline QDateTime::Data::~Data()
{
    if (!isShort() && !d->ref.deref())
        delete d;
}
 
inline bool QDateTime::Data::isShort() const
{
    bool b = quintptr(d) & QDateTimePrivate::ShortData;
 
    // sanity check:
    Q_ASSERT(b || (d->m_status & QDateTimePrivate::ShortData) == 0);
 
    // even if CanBeSmall = false, we have short data for a default-constructed
    // QDateTime object. But it's unlikely.
    if (CanBeSmall)
        return Q_LIKELY(b);
    return Q_UNLIKELY(b);
}
 
inline void QDateTime::Data::detach()
{
    QDateTimePrivate *x;
    bool wasShort = isShort();
    if (wasShort) {
        // force enlarging
        x = new QDateTimePrivate;
        x->m_status = QDateTimePrivate::StatusFlags::fromInt(data.status) & ~QDateTimePrivate::ShortData;
        x->m_msecs = data.msecs;
    } else {
        if (d->ref.loadRelaxed() == 1)
            return;
 
        x = new QDateTimePrivate(*d);
    }
 
    x->ref.storeRelaxed(1);
    if (!wasShort && !d->ref.deref())
        delete d;
    d = x;
}
 
inline const QDateTimePrivate *QDateTime::Data::operator->() const
{
    Q_ASSERT(!isShort());
    return d;
}
 
inline QDateTimePrivate *QDateTime::Data::operator->()
{
    // should we attempt to detach here?
    Q_ASSERT(!isShort());
    Q_ASSERT(d->ref.loadRelaxed() == 1);
    return d;
}
 
/*****************************************************************************
  QDateTimePrivate member functions
 *****************************************************************************/
 
Q_NEVER_INLINE
QDateTime::Data QDateTimePrivate::create(QDate toDate, QTime toTime, Qt::TimeSpec toSpec,
                                         int offsetSeconds)
{
    QDateTime::Data result(toSpec);
    setTimeSpec(result, toSpec, offsetSeconds);
    setDateTime(result, toDate, toTime);
    if (toSpec == Qt::OffsetFromUTC || toSpec == Qt::UTC)
        refreshSimpleDateTime(result);
    else
        refreshZonedDateTime(result, Qt::LocalTime);
    return result;
}
 
#if QT_CONFIG(timezone)
inline QDateTime::Data QDateTimePrivate::create(QDate toDate, QTime toTime,
                                                const QTimeZone &toTimeZone)
{
    QDateTime::Data result(Qt::TimeZone);
    Q_ASSERT(!result.isShort());
 
    result.d->m_status = mergeSpec(result.d->m_status, Qt::TimeZone);
    result.d->m_timeZone = toTimeZone;
    setDateTime(result, toDate, toTime);
    refreshZonedDateTime(result, Qt::TimeZone);
    return result;
}
 
// Convert a TimeZone time expressed in zone msecs encoding into a UTC epoch msecs
// DST transitions are disambiguated by hint.
inline qint64 QDateTimePrivate::zoneMSecsToEpochMSecs(qint64 zoneMSecs, const QTimeZone &zone,
                                                      DaylightStatus *hint,
                                                      QDate *zoneDate, QTime *zoneTime,
                                                      QString *abbreviation)
{
    Q_ASSERT(zone.isValid());
    // Get the effective data from QTimeZone
    DaylightStatus dst = hint ? *hint : UnknownDaylightTime;
    QTimeZonePrivate::Data data = zone.d->dataForLocalTime(zoneMSecs, int(dst));
    const bool badDateTime = data.offsetFromUtc == QTimeZonePrivate::invalidSeconds();
    Q_ASSERT(badDateTime
             || zone.d->offsetFromUtc(data.atMSecsSinceEpoch) == data.offsetFromUtc);
    if (hint) {
        *hint = badDateTime
            ? QDateTimePrivate::UnknownDaylightTime
            : (data.daylightTimeOffset
               ? QDateTimePrivate::DaylightTime
               : QDateTimePrivate::StandardTime);
    }
    if (abbreviation)
        *abbreviation = badDateTime ? QString() : data.abbreviation;
    qint64 msecs;
    if (badDateTime ||
        add_overflow(data.offsetFromUtc * MSECS_PER_SEC, data.atMSecsSinceEpoch, &msecs)) {
        if (zoneDate)
            *zoneDate = QDate();
        if (zoneTime)
            *zoneTime = QTime();
    } else {
        msecsToTime(msecs, zoneDate, zoneTime);
    }
    return data.atMSecsSinceEpoch;
}
#endif // timezone
 
/*****************************************************************************
  QDateTime member functions
 *****************************************************************************/
 
QDateTime::QDateTime() noexcept
{
#if QT_VERSION >= QT_VERSION_CHECK(7,0,0) || QT_POINTER_SIZE == 8
    static_assert(sizeof(ShortData) == sizeof(qint64));
    static_assert(sizeof(Data) == sizeof(qint64));
#endif
    static_assert(sizeof(ShortData) >= sizeof(void*), "oops, Data::swap() is broken!");
}
 
QDateTime::QDateTime(QDate date, QTime time, Qt::TimeSpec spec, int offsetSeconds)
         : d(QDateTimePrivate::create(date, time, spec, offsetSeconds))
{
}
 
#if QT_CONFIG(timezone)
QDateTime::QDateTime(QDate date, QTime time, const QTimeZone &timeZone)
    : d(QDateTimePrivate::create(date, time, timeZone))
{
}
#endif // timezone
 
QDateTime::QDateTime(const QDateTime &other) noexcept
    : d(other.d)
{
}
 
QDateTime::QDateTime(QDateTime &&other) noexcept
    : d(std::move(other.d))
{
}
 
QDateTime::~QDateTime()
{
}
 
QDateTime &QDateTime::operator=(const QDateTime &other) noexcept
{
    d = other.d;
    return *this;
}
bool QDateTime::isNull() const
{
    auto status = getStatus(d);
    return !status.testFlag(QDateTimePrivate::ValidDate) &&
            !status.testFlag(QDateTimePrivate::ValidTime);
}
 
bool QDateTime::isValid() const
{
    auto status = getStatus(d);
    return status.testAnyFlag(QDateTimePrivate::ValidDateTime);
}
 
QDate QDateTime::date() const
{
    auto status = getStatus(d);
    if (!status.testFlag(QDateTimePrivate::ValidDate))
        return QDate();
    QDate dt;
    msecsToTime(getMSecs(d), &dt, nullptr);
    return dt;
}
 
QTime QDateTime::time() const
{
    auto status = getStatus(d);
    if (!status.testFlag(QDateTimePrivate::ValidTime))
        return QTime();
    QTime tm;
    msecsToTime(getMSecs(d), nullptr, &tm);
    return tm;
}
 
Qt::TimeSpec QDateTime::timeSpec() const
{
    return getSpec(d);
}
 
#if QT_CONFIG(timezone)
QTimeZone QDateTime::timeZone() const
{
    switch (getSpec(d)) {
    case Qt::UTC:
        return QTimeZone::utc();
    case Qt::OffsetFromUTC:
        return QTimeZone(d->m_offsetFromUtc);
    case Qt::TimeZone:
        if (d->m_timeZone.isValid())
            return d->m_timeZone;
        break;
    case Qt::LocalTime:
        return QTimeZone::systemTimeZone();
    }
    return QTimeZone();
}
#endif // timezone
 
int QDateTime::offsetFromUtc() const
{
    if (!d.isShort())
        return d->m_offsetFromUtc;
    if (!isValid())
        return 0;
 
    auto spec = getSpec(d);
    if (spec == Qt::LocalTime) {
        // we didn't cache the value, so we need to calculate it now...
        qint64 msecs = getMSecs(d);
        return (msecs - toMSecsSinceEpoch()) / MSECS_PER_SEC;
    }
 
    Q_ASSERT(spec == Qt::UTC);
    return 0;
}
 
QString QDateTime::timeZoneAbbreviation() const
{
    if (!isValid())
        return QString();
 
    switch (getSpec(d)) {
    case Qt::UTC:
        return QLatin1String("UTC");
    case Qt::OffsetFromUTC:
        return QLatin1String("UTC") + toOffsetString(Qt::ISODate, d->m_offsetFromUtc);
    case Qt::TimeZone:
#if !QT_CONFIG(timezone)
        break;
#else
        Q_ASSERT(d->m_timeZone.isValid());
        return d->m_timeZone.abbreviation(*this);
#endif // timezone
    case Qt::LocalTime:  {
        QString abbrev;
        auto status = extractDaylightStatus(getStatus(d));
        QDateTimePrivate::localMSecsToEpochMSecs(getMSecs(d), &status, nullptr, nullptr, &abbrev);
        return abbrev;
        }
    }
    return QString();
}
 
bool QDateTime::isDaylightTime() const
{
    if (!isValid())
        return false;
 
    switch (getSpec(d)) {
    case Qt::UTC:
    case Qt::OffsetFromUTC:
        return false;
    case Qt::TimeZone:
#if !QT_CONFIG(timezone)
        break;
#else
        Q_ASSERT(d->m_timeZone.isValid());
        return d->m_timeZone.d->isDaylightTime(toMSecsSinceEpoch());
#endif // timezone
    case Qt::LocalTime: {
        auto status = extractDaylightStatus(getStatus(d));
        if (status == QDateTimePrivate::UnknownDaylightTime)
            QDateTimePrivate::localMSecsToEpochMSecs(getMSecs(d), &status);
        return (status == QDateTimePrivate::DaylightTime);
        }
    }
    return false;
}
 
void QDateTime::setDate(QDate date)
{
    setDateTime(d, date, time());
    checkValidDateTime(d);
}
 
void QDateTime::setTime(QTime time)
{
    setDateTime(d, date(), time);
    checkValidDateTime(d);
}
 
void QDateTime::setTimeSpec(Qt::TimeSpec spec)
{
    QT_PREPEND_NAMESPACE(setTimeSpec(d, spec, 0));
    if (spec == Qt::OffsetFromUTC || spec == Qt::UTC)
        refreshSimpleDateTime(d);
    else
        refreshZonedDateTime(d, Qt::LocalTime);
}
 
void QDateTime::setOffsetFromUtc(int offsetSeconds)
{
    QT_PREPEND_NAMESPACE(setTimeSpec(d, Qt::OffsetFromUTC, offsetSeconds));
    refreshSimpleDateTime(d);
}
 
#if QT_CONFIG(timezone)
void QDateTime::setTimeZone(const QTimeZone &toZone)
{
    d.detach();         // always detach
    d->m_status = mergeSpec(d->m_status, Qt::TimeZone);
    d->m_offsetFromUtc = 0;
    d->m_timeZone = toZone;
    refreshZonedDateTime(d, Qt::TimeZone);
}
#endif // timezone
 
qint64 QDateTime::toMSecsSinceEpoch() const
{
    // Note: QDateTimeParser relies on this producing a useful result, even when
    // !isValid(), at least when the invalidity is a time in a fall-back (that
    // we'll have adjusted to lie outside it, but marked invalid because it's
    // not what was asked for). Other things may be doing similar.
    switch (getSpec(d)) {
    case Qt::UTC:
        return getMSecs(d);
 
    case Qt::OffsetFromUTC:
        Q_ASSERT(!d.isShort());
        return d->m_msecs - d->m_offsetFromUtc * MSECS_PER_SEC;
 
    case Qt::LocalTime: {
        // recalculate the local timezone
        auto status = extractDaylightStatus(getStatus(d));
        // If short, use offset saved by refreshZonedDateTime() on creation:
        if (!d.isShort())
            return d->m_msecs - d->m_offsetFromUtc * MSECS_PER_SEC;
        // Offset from UTC not recorded: need to recompute.
        return QDateTimePrivate::localMSecsToEpochMSecs(getMSecs(d), &status);
    }
 
    case Qt::TimeZone:
        Q_ASSERT(!d.isShort());
#if QT_CONFIG(timezone)
        // Use offset refreshZonedDateTime() saved on creation:
        if (d->m_timeZone.isValid())
            return d->m_msecs - d->m_offsetFromUtc * MSECS_PER_SEC;
#endif
        return 0;
    }
    Q_UNREACHABLE();
    return 0;
}
 
qint64 QDateTime::toSecsSinceEpoch() const
{
    return toMSecsSinceEpoch() / MSECS_PER_SEC;
}
 
void QDateTime::setMSecsSinceEpoch(qint64 msecs)
{
    auto status = getStatus(d);
    const auto spec = extractSpec(status);
    Q_ASSERT(spec == Qt::UTC || spec == Qt::LocalTime || !d.isShort());
    qint64 local = msecs;
    int offsetFromUtc = 0;
 
    status &= ~QDateTimePrivate::ValidityMask;
    if (spec == Qt::UTC || spec == Qt::OffsetFromUTC) {
        if (spec == Qt::OffsetFromUTC)
            offsetFromUtc = d->m_offsetFromUtc;
        if (!offsetFromUtc || !add_overflow(msecs, offsetFromUtc * MSECS_PER_SEC, &local))
            status |= QDateTimePrivate::ValidWhenMask;
    } else {
        auto dst = extractDaylightStatus(status);
        if (spec == Qt::LocalTime) {
            QDate dt;
            QTime tm;
            if (QDateTimePrivate::epochMSecsToLocalTime(msecs, &dt, &tm, &dst)) {
                setDateTime(d, dt, tm);
                status = getStatus(d);
            } // else leave status marked invalid.
            if ((status & QDateTimePrivate::ValidDate) && (status & QDateTimePrivate::ValidTime)) {
                local = getMSecs(d);
                offsetFromUtc = (local - msecs) / MSECS_PER_SEC;
                status |= QDateTimePrivate::ValidWhenMask;
            }
#if QT_CONFIG(timezone)
        } else if (spec == Qt::TimeZone && (d.detach(), d->m_timeZone.isValid())) {
            const auto data = d->m_timeZone.d->data(msecs);
            if (data.offsetFromUtc != QTimeZonePrivate::invalidSeconds()) {
                dst = data.daylightTimeOffset
                    ? QDateTimePrivate::DaylightTime
                    : QDateTimePrivate::StandardTime;
                offsetFromUtc = data.offsetFromUtc;
                if (!offsetFromUtc
                    || !add_overflow(msecs, offsetFromUtc * MSECS_PER_SEC, &local)) {
                    status |= QDateTimePrivate::ValidWhenMask;
                }
            }
#endif // timezone
        }
        status = mergeDaylightStatus(status, dst);
    }
    Q_ASSERT(!(status & QDateTimePrivate::ValidDateTime)
             || (offsetFromUtc >= -SECS_PER_DAY && offsetFromUtc <= SECS_PER_DAY));
 
    if (msecsCanBeSmall(local) && d.isShort()) {
        // we can keep short
        d.data.msecs = qintptr(local);
        d.data.status = status.toInt();
    } else {
        d.detach();
        d->m_status = status & ~QDateTimePrivate::ShortData;
        d->m_msecs = local;
        d->m_offsetFromUtc = offsetFromUtc;
    }
}
 
void QDateTime::setSecsSinceEpoch(qint64 secs)
{
    qint64 msecs;
    if (!mul_overflow(secs, std::integral_constant<qint64, MSECS_PER_SEC>(), &msecs)) {
        setMSecsSinceEpoch(msecs);
    } else if (d.isShort()) {
        d.data.status &= ~int(QDateTimePrivate::ValidWhenMask);
    } else {
        d.detach();
        d->m_status &= ~QDateTimePrivate::ValidWhenMask;
    }
}
 
#if QT_CONFIG(datestring) // depends on, so implies, textdate
QString QDateTime::toString(Qt::DateFormat format) const
{
    QString buf;
    if (!isValid())
        return buf;
 
    switch (format) {
    case Qt::RFC2822Date:
        buf = QLocale::c().toString(*this, u"dd MMM yyyy hh:mm:ss ");
        buf += toOffsetString(Qt::TextDate, offsetFromUtc());
        return buf;
    default:
    case Qt::TextDate: {
        const QPair<QDate, QTime> p = getDateTime(d);
        buf = toStringTextDate(p.first);
        // Insert time between date's day and year:
        buf.insert(buf.lastIndexOf(u' '),
                   u' ' + p.second.toString(Qt::TextDate));
        // Append zone/offset indicator, as appropriate:
        switch (timeSpec()) {
        case Qt::LocalTime:
            break;
#if QT_CONFIG(timezone)
        case Qt::TimeZone:
            buf += u' ' + d->m_timeZone.displayName(
                *this, QTimeZone::OffsetName, QLocale::c());
            break;
#endif
        default:
#if 0 // ### Qt 7 GMT: use UTC instead, see qnamespace.qdoc documentation
            buf += QLatin1String(" UTC");
#else
            buf += QLatin1String(" GMT");
#endif
            if (getSpec(d) == Qt::OffsetFromUTC)
                buf += toOffsetString(Qt::TextDate, offsetFromUtc());
        }
        return buf;
    }
    case Qt::ISODate:
    case Qt::ISODateWithMs: {
        const QPair<QDate, QTime> p = getDateTime(d);
        buf = toStringIsoDate(p.first);
        if (buf.isEmpty())
            return QString();   // failed to convert
        buf += u'T' + p.second.toString(format);
        switch (getSpec(d)) {
        case Qt::UTC:
            buf += u'Z';
            break;
        case Qt::OffsetFromUTC:
#if QT_CONFIG(timezone)
        case Qt::TimeZone:
#endif
            buf += toOffsetString(Qt::ISODate, offsetFromUtc());
            break;
        default:
            break;
        }
        return buf;
    }
    }
}
 
QString QDateTime::toString(QStringView format, QCalendar cal) const
{
    return QLocale::c().toString(*this, format, cal);
}
#endif // datestring
 
static inline void massageAdjustedDateTime(QDateTimeData &d, QDate date, QTime time)
{
    /*
      If we have just adjusted to a day with a DST transition, our given time
      may lie in the transition hour (either missing or duplicated).  For any
      other time, telling mktime (deep in the bowels of localMSecsToEpochMSecs)
      or QTimeZone (via zoneMSecsToEpochMSecs) what we know about DST-ness, of
      the time we adjusted from, will make no difference; it'll just tell us the
      actual DST-ness of the given time. When landing in a transition that
      repeats an hour, passing the prior DST-ness - when known - will get us the
      indicated side of the duplicate (either local or zone). When landing in a
      gap, the zone gives us the other side of the gap but (for now) local time
      gets us a platform-dependent side of the gap (e.g. DST-side for glibc).
    */
    auto status = getStatus(d);
    Q_ASSERT((status & QDateTimePrivate::ValidDate) && (status & QDateTimePrivate::ValidTime)
             && (status & QDateTimePrivate::ValidDateTime));
    auto spec = extractSpec(status);
    if (spec == Qt::OffsetFromUTC || spec == Qt::UTC) {
        setDateTime(d, date, time);
        refreshSimpleDateTime(d);
        return;
    }
    auto dst = extractDaylightStatus(status);
    qint64 utc = 0, local = timeToMSecs(date, time);
    if (spec == Qt::LocalTime)
        utc = QDateTimePrivate::localMSecsToEpochMSecs(local, &dst, &date, &time);
#if QT_CONFIG(timezone)
    else if (spec == Qt::TimeZone && d.d->m_timeZone.isValid())
        utc = QDateTimePrivate::zoneMSecsToEpochMSecs(local, d.d->m_timeZone, &dst, &date, &time);
#endif // timezone
    else
        dst = QDateTimePrivate::UnknownDaylightTime;
 
    setDateTime(d, date, time); // Detaches d, if needed.
    status = getStatus(d); // Updated by setDateTime()
    const bool ok = (dst != QDateTimePrivate::UnknownDaylightTime
                     && (status & QDateTimePrivate::ValidDate)
                     && (status & QDateTimePrivate::ValidTime));
    if (ok)
        status = mergeDaylightStatus(status | QDateTimePrivate::ValidDateTime, dst);
    else
        status &= ~QDateTimePrivate::ValidDateTime;
 
    if (status & QDateTimePrivate::ShortData) {
        d.data.status = status.toInt();
    } else {
        d->m_status = status;
        if (ok)
            d->m_offsetFromUtc = (local - utc) / MSECS_PER_SEC;
    }
}
 
QDateTime QDateTime::addDays(qint64 ndays) const
{
    if (isNull())
        return QDateTime();
 
    QDateTime dt(*this);
    QPair<QDate, QTime> p = getDateTime(d);
    massageAdjustedDateTime(dt.d, p.first.addDays(ndays), p.second);
    return dt;
}
 
QDateTime QDateTime::addMonths(int nmonths) const
{
    if (isNull())
        return QDateTime();
 
    QDateTime dt(*this);
    QPair<QDate, QTime> p = getDateTime(d);
    massageAdjustedDateTime(dt.d, p.first.addMonths(nmonths), p.second);
    return dt;
}
 
QDateTime QDateTime::addYears(int nyears) const
{
    if (isNull())
        return QDateTime();
 
    QDateTime dt(*this);
    QPair<QDate, QTime> p = getDateTime(d);
    massageAdjustedDateTime(dt.d, p.first.addYears(nyears), p.second);
    return dt;
}
 
QDateTime QDateTime::addSecs(qint64 s) const
{
    qint64 msecs;
    if (mul_overflow(s, std::integral_constant<qint64, MSECS_PER_SEC>(), &msecs))
        return QDateTime();
    return addMSecs(msecs);
}
 
QDateTime QDateTime::addMSecs(qint64 msecs) const
{
    if (!isValid())
        return QDateTime();
 
    QDateTime dt(*this);
    switch (getSpec(d)) {
    case Qt::LocalTime:
    case Qt::TimeZone:
        // Convert to real UTC first in case this crosses a DST transition:
        if (!add_overflow(toMSecsSinceEpoch(), msecs, &msecs)) {
            dt.setMSecsSinceEpoch(msecs);
        } else if (dt.d.isShort()) {
            dt.d.data.status &= ~int(QDateTimePrivate::ValidWhenMask);
        } else {
            dt.d.detach();
            dt.d->m_status &= ~QDateTimePrivate::ValidWhenMask;
        }
        break;
    case Qt::UTC:
    case Qt::OffsetFromUTC:
        // No need to convert, just add on
        if (add_overflow(getMSecs(d), msecs, &msecs)) {
            if (dt.d.isShort()) {
                dt.d.data.status &= ~int(QDateTimePrivate::ValidWhenMask);
            } else {
                dt.d.detach();
                dt.d->m_status &= ~QDateTimePrivate::ValidWhenMask;
            }
        } else if (d.isShort()) {
            // need to check if we need to enlarge first
            if (msecsCanBeSmall(msecs)) {
                dt.d.data.msecs = qintptr(msecs);
            } else {
                dt.d.detach();
                dt.d->m_msecs = msecs;
            }
        } else {
            dt.d.detach();
            dt.d->m_msecs = msecs;
        }
        break;
    }
    return dt;
}
 
qint64 QDateTime::daysTo(const QDateTime &other) const
{
    return date().daysTo(other.date());
}
 
qint64 QDateTime::secsTo(const QDateTime &other) const
{
    return msecsTo(other) / MSECS_PER_SEC;
}
 
qint64 QDateTime::msecsTo(const QDateTime &other) const
{
    if (!isValid() || !other.isValid())
        return 0;
 
    return other.toMSecsSinceEpoch() - toMSecsSinceEpoch();
}
 
QDateTime QDateTime::toTimeSpec(Qt::TimeSpec spec) const
{
    if (getSpec(d) == spec && (spec == Qt::UTC || spec == Qt::LocalTime))
        return *this;
 
    if (!isValid()) {
        QDateTime ret = *this;
        ret.setTimeSpec(spec);
        return ret;
    }
 
    return fromMSecsSinceEpoch(toMSecsSinceEpoch(), spec, 0);
}
 
QDateTime QDateTime::toOffsetFromUtc(int offsetSeconds) const
{
    if (getSpec(d) == Qt::OffsetFromUTC
            && d->m_offsetFromUtc == offsetSeconds)
        return *this;
 
    if (!isValid()) {
        QDateTime ret = *this;
        ret.setOffsetFromUtc(offsetSeconds);
        return ret;
    }
 
    return fromMSecsSinceEpoch(toMSecsSinceEpoch(), Qt::OffsetFromUTC, offsetSeconds);
}
 
#if QT_CONFIG(timezone)
QDateTime QDateTime::toTimeZone(const QTimeZone &timeZone) const
{
    if (getSpec(d) == Qt::TimeZone && d->m_timeZone == timeZone)
        return *this;
 
    if (!isValid()) {
        QDateTime ret = *this;
        ret.setTimeZone(timeZone);
        return ret;
    }
 
    return fromMSecsSinceEpoch(toMSecsSinceEpoch(), timeZone);
}
#endif // timezone
 
bool QDateTime::equals(const QDateTime &other) const
{
    if (!isValid())
        return !other.isValid();
    if (!other.isValid())
        return false;
 
    if (usesSameOffset(d, other.d))
        return getMSecs(d) == getMSecs(other.d);
 
    // Convert to UTC and compare
    return toMSecsSinceEpoch() == other.toMSecsSinceEpoch();
}
 
bool QDateTime::precedes(const QDateTime &other) const
{
    if (!isValid())
        return other.isValid();
    if (!other.isValid())
        return false;
 
    if (usesSameOffset(d, other.d))
        return getMSecs(d) < getMSecs(other.d);
 
    // Convert to UTC and compare
    return toMSecsSinceEpoch() < other.toMSecsSinceEpoch();
}
 
#if defined(Q_OS_WIN)
static inline uint msecsFromDecomposed(int hour, int minute, int sec, int msec = 0)
{
    return MSECS_PER_HOUR * hour + MSECS_PER_MIN * minute + MSECS_PER_SEC * sec + msec;
}
 
QDate QDate::currentDate()
{
    SYSTEMTIME st = {};
    GetLocalTime(&st);
    return QDate(st.wYear, st.wMonth, st.wDay);
}
 
QTime QTime::currentTime()
{
    QTime ct;
    SYSTEMTIME st = {};
    GetLocalTime(&st);
    ct.setHMS(st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
    return ct;
}
 
QDateTime QDateTime::currentDateTime()
{
    QTime t;
    SYSTEMTIME st = {};
    GetLocalTime(&st);
    QDate d(st.wYear, st.wMonth, st.wDay);
    t.mds = msecsFromDecomposed(st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
    return QDateTime(d, t);
}
 
QDateTime QDateTime::currentDateTimeUtc()
{
    QTime t;
    SYSTEMTIME st = {};
    GetSystemTime(&st);
    QDate d(st.wYear, st.wMonth, st.wDay);
    t.mds = msecsFromDecomposed(st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
    return QDateTime(d, t, Qt::UTC);
}
 
qint64 QDateTime::currentMSecsSinceEpoch() noexcept
{
    SYSTEMTIME st = {};
    GetSystemTime(&st);
    const qint64 daysAfterEpoch = QDate(1970, 1, 1).daysTo(QDate(st.wYear, st.wMonth, st.wDay));
 
    return msecsFromDecomposed(st.wHour, st.wMinute, st.wSecond, st.wMilliseconds) +
           daysAfterEpoch * MSECS_PER_DAY;
}
 
qint64 QDateTime::currentSecsSinceEpoch() noexcept
{
    SYSTEMTIME st = {};
    GetSystemTime(&st);
    const qint64 daysAfterEpoch = QDate(1970, 1, 1).daysTo(QDate(st.wYear, st.wMonth, st.wDay));
 
    return st.wHour * SECS_PER_HOUR + st.wMinute * SECS_PER_MIN + st.wSecond +
           daysAfterEpoch * SECS_PER_DAY;
}
 
#elif defined(Q_OS_UNIX)
QDate QDate::currentDate()
{
    return QDateTime::currentDateTime().date();
}
 
QTime QTime::currentTime()
{
    return QDateTime::currentDateTime().time();
}
 
QDateTime QDateTime::currentDateTime()
{
    return fromMSecsSinceEpoch(currentMSecsSinceEpoch(), Qt::LocalTime);
}
 
QDateTime QDateTime::currentDateTimeUtc()
{
    return fromMSecsSinceEpoch(currentMSecsSinceEpoch(), Qt::UTC);
}
 
qint64 QDateTime::currentMSecsSinceEpoch() noexcept
{
    // posix compliant system
    // we have milliseconds
    struct timeval tv;
    gettimeofday(&tv, nullptr);
    return tv.tv_sec * MSECS_PER_SEC + tv.tv_usec / 1000;
}
 
qint64 QDateTime::currentSecsSinceEpoch() noexcept
{
    struct timeval tv;
    gettimeofday(&tv, nullptr);
    return tv.tv_sec;
}
#else
#error "What system is this?"
#endif
 
QDateTime QDateTime::fromMSecsSinceEpoch(qint64 msecs, Qt::TimeSpec spec, int offsetSeconds)
{
    QDateTime dt;
    QT_PREPEND_NAMESPACE(setTimeSpec(dt.d, spec, offsetSeconds));
    dt.setMSecsSinceEpoch(msecs);
    return dt;
}
 
QDateTime QDateTime::fromSecsSinceEpoch(qint64 secs, Qt::TimeSpec spec, int offsetSeconds)
{
    constexpr qint64 maxSeconds = std::numeric_limits<qint64>::max() / MSECS_PER_SEC;
    constexpr qint64 minSeconds = std::numeric_limits<qint64>::min() / MSECS_PER_SEC;
    if (secs > maxSeconds || secs < minSeconds)
        return QDateTime(); // Would {und,ov}erflow
    return fromMSecsSinceEpoch(secs * MSECS_PER_SEC, spec, offsetSeconds);
}
 
#if QT_CONFIG(timezone)
QDateTime QDateTime::fromMSecsSinceEpoch(qint64 msecs, const QTimeZone &timeZone)
{
    QDateTime dt;
    dt.setTimeZone(timeZone);
    if (timeZone.isValid())
        dt.setMSecsSinceEpoch(msecs);
    return dt;
}
 
QDateTime QDateTime::fromSecsSinceEpoch(qint64 secs, const QTimeZone &timeZone)
{
    constexpr qint64 maxSeconds = std::numeric_limits<qint64>::max() / MSECS_PER_SEC;
    constexpr qint64 minSeconds = std::numeric_limits<qint64>::min() / MSECS_PER_SEC;
    if (secs > maxSeconds || secs < minSeconds)
        return QDateTime(); // Would {und,ov}erflow
    return fromMSecsSinceEpoch(secs * MSECS_PER_SEC, timeZone);
}
#endif
 
#if QT_CONFIG(datestring) // depends on, so implies, textdate
 
QDateTime QDateTime::fromString(QStringView string, Qt::DateFormat format)
{
    if (string.isEmpty())
        return QDateTime();
 
    switch (format) {
    case Qt::RFC2822Date: {
        const ParsedRfcDateTime rfc = rfcDateImpl(string);
 
        if (!rfc.date.isValid() || !rfc.time.isValid())
            return QDateTime();
 
        QDateTime dateTime(rfc.date, rfc.time, Qt::UTC);
        dateTime.setOffsetFromUtc(rfc.utcOffset);
        return dateTime;
    }
    case Qt::ISODate:
    case Qt::ISODateWithMs: {
        const int size = string.size();
        if (size < 10)
            return QDateTime();
 
        QDate date = QDate::fromString(string.first(10), Qt::ISODate);
        if (!date.isValid())
            return QDateTime();
        if (size == 10)
            return date.startOfDay();
 
        Qt::TimeSpec spec = Qt::LocalTime;
        QStringView isoString = string.sliced(10); // trim "yyyy-MM-dd"
 
        // Must be left with T (or space) and at least one digit for the hour:
        if (isoString.size() < 2
            || !(isoString.startsWith(u'T', Qt::CaseInsensitive)
                 // RFC 3339 (section 5.6) allows a space here.  (It actually
                 // allows any separator one considers more readable, merely
                 // giving space as an example - but let's not go wild !)
                 || isoString.startsWith(u' '))) {
            return QDateTime();
        }
        isoString = isoString.sliced(1); // trim 'T' (or space)
 
        int offset = 0;
        // Check end of string for Time Zone definition, either Z for UTC or [+-]HH:mm for Offset
        if (isoString.endsWith(u'Z', Qt::CaseInsensitive)) {
            spec = Qt::UTC;
            isoString.chop(1); // trim 'Z'
        } else {
            // the loop below is faster but functionally equal to:
            // const int signIndex = isoString.indexOf(QRegulargExpression(QStringLiteral("[+-]")));
            int signIndex = isoString.size() - 1;
            Q_ASSERT(signIndex >= 0);
            bool found = false;
            do {
                QChar character(isoString[signIndex]);
                found = character == u'+' || character == u'-';
            } while (!found && --signIndex >= 0);
 
            if (found) {
                bool ok;
                offset = fromOffsetString(isoString.sliced(signIndex), &ok);
                if (!ok)
                    return QDateTime();
                isoString = isoString.first(signIndex);
                spec = Qt::OffsetFromUTC;
            }
        }
 
        // Might be end of day (24:00, including variants), which QTime considers invalid.
        // ISO 8601 (section 4.2.3) says that 24:00 is equivalent to 00:00 the next day.
        bool isMidnight24 = false;
        QTime time = fromIsoTimeString(isoString, format, &isMidnight24);
        if (!time.isValid())
            return QDateTime();
        if (isMidnight24) // time is 0:0, but we want the start of next day:
            return date.addDays(1).startOfDay(spec, offset);
        return QDateTime(date, time, spec, offset);
    }
    case Qt::TextDate: {
        QVarLengthArray<QStringView, 6> parts;
 
        auto tokens = string.tokenize(u' ', Qt::SkipEmptyParts);
        auto it = tokens.begin();
        for (int i = 0; i < 6 && it != tokens.end(); ++i, ++it)
            parts.emplace_back(*it);
 
        // Documented as "ddd MMM d HH:mm:ss yyyy" with optional offset-suffix;
        // and allow time either before or after year.
        if (parts.count() < 5 || it != tokens.end())
            return QDateTime();
 
        // Year and time can be in either order.
        // Guess which by looking for ':' in the time
        int yearPart = 3;
        int timePart = 3;
        if (parts.at(3).contains(u':'))
            yearPart = 4;
        else if (parts.at(4).contains(u':'))
            timePart = 4;
        else
            return QDateTime();
 
        bool ok = false;
        int day = parts.at(2).toInt(&ok);
        int year = ok ? parts.at(yearPart).toInt(&ok) : 0;
        int month = fromShortMonthName(parts.at(1));
        if (!ok || year == 0 || day == 0 || month < 1)
            return QDateTime();
 
        const QDate date(year, month, day);
        if (!date.isValid())
            return QDateTime();
 
        const QTime time = fromIsoTimeString(parts.at(timePart), format, nullptr);
        if (!time.isValid())
            return QDateTime();
 
        if (parts.count() == 5)
            return QDateTime(date, time, Qt::LocalTime);
 
        QStringView tz = parts.at(5);
        if (tz.startsWith(QLatin1String("UTC"))
            // GMT has long been deprecated as an alias for UTC.
            || tz.startsWith(QLatin1String("GMT"), Qt::CaseInsensitive)) {
            tz = tz.sliced(3);
            if (tz.isEmpty())
                return QDateTime(date, time, Qt::UTC);
 
            int offset = fromOffsetString(tz, &ok);
            return ok ? QDateTime(date, time, Qt::OffsetFromUTC, offset) : QDateTime();
        }
        return QDateTime();
    }
    }
 
    return QDateTime();
}
 
QDateTime QDateTime::fromString(const QString &string, QStringView format, QCalendar cal)
{
#if QT_CONFIG(datetimeparser)
    QDateTime datetime;
 
    QDateTimeParser dt(QMetaType::QDateTime, QDateTimeParser::FromString, cal);
    dt.setDefaultLocale(QLocale::c());
    if (dt.parseFormat(format) && (dt.fromString(string, &datetime) || !datetime.isValid()))
        return datetime;
#else
    Q_UNUSED(string);
    Q_UNUSED(format);
    Q_UNUSED(cal);
#endif
    return QDateTime();
}
 
#endif // datestring
/*****************************************************************************
  Date/time stream functions
 *****************************************************************************/
 
#ifndef QT_NO_DATASTREAM
QDataStream &operator<<(QDataStream &out, QDate date)
{
    if (out.version() < QDataStream::Qt_5_0)
        return out << quint32(date.jd);
    else
        return out << date.jd;
}
 
QDataStream &operator>>(QDataStream &in, QDate &date)
{
    if (in.version() < QDataStream::Qt_5_0) {
        quint32 jd;
        in >> jd;
        // Older versions consider 0 an invalid jd.
        date.jd = (jd != 0 ? jd : QDate::nullJd());
    } else {
        qint64 jd;
        in >> jd;
        date.jd = jd;
    }
 
    return in;
}
 
QDataStream &operator<<(QDataStream &out, QTime time)
{
    if (out.version() >= QDataStream::Qt_4_0) {
        return out << quint32(time.mds);
    } else {
        // Qt3 had no support for reading -1, QTime() was valid and serialized as 0
        return out << quint32(time.isNull() ? 0 : time.mds);
    }
}
 
QDataStream &operator>>(QDataStream &in, QTime &time)
{
    quint32 ds;
    in >> ds;
    if (in.version() >= QDataStream::Qt_4_0) {
        time.mds = int(ds);
    } else {
        // Qt3 would write 0 for a null time
        time.mds = (ds == 0) ? QTime::NullTime : int(ds);
    }
    return in;
}
 
QDataStream &operator<<(QDataStream &out, const QDateTime &dateTime)
{
    QPair<QDate, QTime> dateAndTime;
 
    if (out.version() >= QDataStream::Qt_5_2) {
 
        // In 5.2 we switched to using Qt::TimeSpec and added offset support
        dateAndTime = getDateTime(dateTime.d);
        out << dateAndTime << qint8(dateTime.timeSpec());
        if (dateTime.timeSpec() == Qt::OffsetFromUTC)
            out << qint32(dateTime.offsetFromUtc());
#if QT_CONFIG(timezone)
        else if (dateTime.timeSpec() == Qt::TimeZone)
            out << dateTime.timeZone();
#endif // timezone
 
    } else if (out.version() == QDataStream::Qt_5_0) {
 
        // In Qt 5.0 we incorrectly serialised all datetimes as UTC.
        // This approach is wrong and should not be used again; it breaks
        // the guarantee that a deserialised local datetime is the same time
        // of day, regardless of which timezone it was serialised in.
        dateAndTime = getDateTime((dateTime.isValid() ? dateTime.toUTC() : dateTime).d);
        out << dateAndTime << qint8(dateTime.timeSpec());
 
    } else if (out.version() >= QDataStream::Qt_4_0) {
 
        // From 4.0 to 5.1 (except 5.0) we used QDateTimePrivate::Spec
        dateAndTime = getDateTime(dateTime.d);
        out << dateAndTime;
        switch (dateTime.timeSpec()) {
        case Qt::UTC:
            out << (qint8)QDateTimePrivate::UTC;
            break;
        case Qt::OffsetFromUTC:
            out << (qint8)QDateTimePrivate::OffsetFromUTC;
            break;
        case Qt::TimeZone:
            out << (qint8)QDateTimePrivate::TimeZone;
            break;
        case Qt::LocalTime:
            out << (qint8)QDateTimePrivate::LocalUnknown;
            break;
        }
 
    } else { // version < QDataStream::Qt_4_0
 
        // Before 4.0 there was no TimeSpec, only Qt::LocalTime was supported
        dateAndTime = getDateTime(dateTime.d);
        out << dateAndTime;
 
    }
 
    return out;
}
 
QDataStream &operator>>(QDataStream &in, QDateTime &dateTime)
{
    QDate dt;
    QTime tm;
    qint8 ts = 0;
    Qt::TimeSpec spec = Qt::LocalTime;
    qint32 offset = 0;
#if QT_CONFIG(timezone)
    QTimeZone tz;
#endif // timezone
 
    if (in.version() >= QDataStream::Qt_5_2) {
 
        // In 5.2 we switched to using Qt::TimeSpec and added offset support
        in >> dt >> tm >> ts;
        spec = static_cast<Qt::TimeSpec>(ts);
        if (spec == Qt::OffsetFromUTC) {
            in >> offset;
            dateTime = QDateTime(dt, tm, spec, offset);
#if QT_CONFIG(timezone)
        } else if (spec == Qt::TimeZone) {
            in >> tz;
            dateTime = QDateTime(dt, tm, tz);
#endif // timezone
        } else {
            dateTime = QDateTime(dt, tm, spec);
        }
 
    } else if (in.version() == QDataStream::Qt_5_0) {
 
        // In Qt 5.0 we incorrectly serialised all datetimes as UTC
        in >> dt >> tm >> ts;
        spec = static_cast<Qt::TimeSpec>(ts);
        dateTime = QDateTime(dt, tm, Qt::UTC);
        dateTime = dateTime.toTimeSpec(spec);
 
    } else if (in.version() >= QDataStream::Qt_4_0) {
 
        // From 4.0 to 5.1 (except 5.0) we used QDateTimePrivate::Spec
        in >> dt >> tm >> ts;
        switch ((QDateTimePrivate::Spec)ts) {
        case QDateTimePrivate::UTC:
            spec = Qt::UTC;
            break;
        case QDateTimePrivate::OffsetFromUTC:
            spec = Qt::OffsetFromUTC;
            break;
        case QDateTimePrivate::TimeZone:
            spec = Qt::TimeZone;
#if QT_CONFIG(timezone)
            // FIXME: need to use a different constructor !
#endif
            break;
        case QDateTimePrivate::LocalUnknown:
        case QDateTimePrivate::LocalStandard:
        case QDateTimePrivate::LocalDST:
            spec = Qt::LocalTime;
            break;
        }
        dateTime = QDateTime(dt, tm, spec, offset);
 
    } else { // version < QDataStream::Qt_4_0
 
        // Before 4.0 there was no TimeSpec, only Qt::LocalTime was supported
        in >> dt >> tm;
        dateTime = QDateTime(dt, tm, spec, offset);
 
    }
 
    return in;
}
#endif // QT_NO_DATASTREAM
 
/*****************************************************************************
  Date / Time Debug Streams
*****************************************************************************/
 
#if !defined(QT_NO_DEBUG_STREAM) && QT_CONFIG(datestring)
QDebug operator<<(QDebug dbg, QDate date)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QDate(";
    if (date.isValid())
        dbg.nospace() << date.toString(Qt::ISODate);
    else
        dbg.nospace() << "Invalid";
    dbg.nospace() << ')';
    return dbg;
}
 
QDebug operator<<(QDebug dbg, QTime time)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QTime(";
    if (time.isValid())
        dbg.nospace() << time.toString(u"HH:mm:ss.zzz");
    else
        dbg.nospace() << "Invalid";
    dbg.nospace() << ')';
    return dbg;
}
 
QDebug operator<<(QDebug dbg, const QDateTime &date)
{
    QDebugStateSaver saver(dbg);
    dbg.nospace() << "QDateTime(";
    if (date.isValid()) {
        const Qt::TimeSpec ts = date.timeSpec();
        dbg.noquote() << date.toString(u"yyyy-MM-dd HH:mm:ss.zzz t")
                      << ' ' << ts;
        switch (ts) {
        case Qt::UTC:
            break;
        case Qt::OffsetFromUTC:
            dbg.space() << date.offsetFromUtc() << 's';
            break;
        case Qt::TimeZone:
#if QT_CONFIG(timezone)
            dbg.space() << date.timeZone().id();
#endif // timezone
            break;
        case Qt::LocalTime:
            break;
        }
    } else {
        dbg.nospace() << "Invalid";
    }
    return dbg.nospace() << ')';
}
#endif // debug_stream && datestring
 
size_t qHash(const QDateTime &key, size_t seed)
{
    // Use to toMSecsSinceEpoch instead of individual qHash functions for
    // QDate/QTime/spec/offset because QDateTime::operator== converts both arguments
    // to the same timezone. If we don't, qHash would return different hashes for
    // two QDateTimes that are equivalent once converted to the same timezone.
    return key.isValid() ? qHash(key.toMSecsSinceEpoch(), seed) : seed;
}
 
size_t qHash(QDate key, size_t seed) noexcept
{
    return qHash(key.toJulianDay(), seed);
}
 
size_t qHash(QTime key, size_t seed) noexcept
{
    return qHash(key.msecsSinceStartOfDay(), seed);
}
 
QT_END_NAMESPACE