src/corelib/tools/qdatetime.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 1992-2006 Trolltech ASA. All rights reserved.
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** This file may be used under the terms of the GNU General Public
** License version 2.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of
** this file.  Please review the following information to ensure GNU
** General Public Licensing requirements will be met:
** http://www.trolltech.com/products/qt/opensource.html
**
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://www.trolltech.com/products/qt/licensing.html or contact the
** sales department at sales@trolltech.com.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/

#include "qplatformdefs.h"
#include "private/qdatetime_p.h"

#include "qdatastream.h"
#include "qset.h"
#include "qlocale.h"
#include "qdatetime.h"
#include "qregexp.h"
#include "qdebug.h"
#if defined(Q_OS_WIN32)
#include <windows.h>
#endif
#ifndef Q_WS_WIN
#include <locale.h>
#endif

#include <time.h>

//#define QDATETIMEPARSER_DEBUG
#if defined (QDATETIMEPARSER_DEBUG) && !defined(QT_NO_DEBUG_STREAM)
#  define QDTPDEBUG qDebug() << QString("%1:%2").arg(__FILE__).arg(__LINE__)
#  define QDTPDEBUGN qDebug
#else
#  define QDTPDEBUG if (false) qDebug()
#  define QDTPDEBUGN if (false) qDebug
#endif

#if defined(Q_WS_MAC)
#include <private/qcore_mac_p.h>
extern QString qt_mac_from_pascal_string(const Str255); // qglobal.cpp
#endif

enum {
    FIRST_YEAR = -4713,
    FIRST_MONTH = 1,
    FIRST_DAY = 2,  // ### Qt 5: make FIRST_DAY = 1, by support jd == 0 as valid
    SECS_PER_DAY = 86400,
    MSECS_PER_DAY = 86400000,
    SECS_PER_HOUR = 3600,
    MSECS_PER_HOUR = 3600000,
    SECS_PER_MIN = 60,
    MSECS_PER_MIN = 60000
};

static inline QDate strictDate(int y, int m, int d)
{
    QDate result;
    result.setDate(y, m, d);
    return result;
}

static inline QDate fixedDate(int y, int m, int d)
{
    QDate result(strictDate(y, m, 1));
    result.setDate(y, m, qMin(d, result.daysInMonth()));
    return result;
}

static uint julianDayFromDate(int year, int month, int day)
{
    if (year < 0)
        ++year;

    if (year > 1582 || (year == 1582 && (month > 10 || (month == 10 && day >= 15)))) {
        // Gregorian calendar starting from October 15, 1582
        // Algorithm from Henry F. Fliegel and Thomas C. Van Flandern
        return (1461 * (year + 4800 + (month - 14) / 12)) / 4
               + (367 * (month - 2 - 12 * ((month - 14) / 12))) / 12
               - (3 * ((year + 4900 + (month - 14) / 12) / 100)) / 4
               + day - 32075;
    } else if (year < 1582 || (year == 1582 && (month < 10 || (month == 10 && day <= 4)))) {
        // Julian calendar until October 4, 1582
        // Algorithm from Frequently Asked Questions about Calendars by Claus Toendering
        int a = (14 - month) / 12;
        return (153 * (month + (12 * a) - 3) + 2) / 5
               + (1461 * (year + 4800 - a)) / 4
               + day - 32083;
    } else {
        // the day following October 4, 1582 is October 15, 1582
        return 0;
    }
}

static void getDateFromJulianDay(uint julianDay, int *year, int *month, int *day)
{
    int y, m, d;

    if (julianDay >= 2299161) {
        // Gregorian calendar starting from October 15, 1582
        // This algorithm is from Henry F. Fliegel and Thomas C. Van Flandern
        qulonglong ell, n, i, j;
        ell = qulonglong(julianDay) + 68569;
        n = (4 * ell) / 146097;
        ell = ell - (146097 * n + 3) / 4;
        i = (4000 * (ell + 1)) / 1461001;
        ell = ell - (1461 * i) / 4 + 31;
        j = (80 * ell) / 2447;
        d = ell - (2447 * j) / 80;
        ell = j / 11;
        m = j + 2 - (12 * ell);
        y = 100 * (n - 49) + i + ell;
    } else {
        // Julian calendar until October 4, 1582
        // Algorithm from Frequently Asked Questions about Calendars by Claus Toendering
        julianDay += 32082;
        int dd = (4 * julianDay + 3) / 1461;
        int ee = julianDay - (1461 * dd) / 4;
        int mm = ((5 * ee) + 2) / 153;
        d = ee - (153 * mm + 2) / 5 + 1;
        m = mm + 3 - 12 * (mm / 10);
        y = dd - 4800 + (mm / 10);
        if (y <= 0)
            --y;
    }
    *year = y;
    *month = m;
    *day = d;
}


static const char monthDays[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

#ifndef QT_NO_TEXTDATE
static const char * const qt_shortMonthNames[] = {
    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
#endif
#ifndef QT_NO_DATESTRING
static QString fmtDateTime(const QString& f, const QTime* dt = 0, const QDate* dd = 0);
#endif

/*****************************************************************************
  QDate member functions
 *****************************************************************************/

QDate::QDate(int y, int m, int d)
{
    if (uint(y) <= 99u)
        y += 1900;
    setDate(y, m, d);
}


bool QDate::isValid() const
{
    return !isNull();
}


int QDate::year() const
{
    int y, m, d;
    getDateFromJulianDay(jd, &y, &m, &d);
    return y;
}

int QDate::month() const
{
    int y, m, d;
    getDateFromJulianDay(jd, &y, &m, &d);
    return m;
}

int QDate::day() const
{
    int y, m, d;
    getDateFromJulianDay(jd, &y, &m, &d);
    return d;
}

int QDate::dayOfWeek() const
{
    return (jd % 7) + 1;
}

int QDate::dayOfYear() const
{
    return jd - julianDayFromDate(year(), 1, 1) + 1;
}

int QDate::daysInMonth() const
{
    int y, m, d;
    getDateFromJulianDay(jd, &y, &m, &d);
    if (m == 2 && isLeapYear(y))
        return 29;
    else
        return monthDays[m];
}

int QDate::daysInYear() const
{
    int y, m, d;
    getDateFromJulianDay(jd, &y, &m, &d);
    return isLeapYear(y) ? 366 : 365;
}

int QDate::weekNumber(int *yearNumber) const
{
    if (!isValid())
        return 0;

    int year = QDate::year();
    int yday = dayOfYear() - 1;
    int wday = dayOfWeek();
    if (wday == 7)
        wday = 0;
    int w;

    for (;;) {
        int len;
        int bot;
        int top;

        len = isLeapYear(year) ? 366 : 365;
        /*
        ** What yday (-3 ... 3) does
        ** the ISO year begin on?
        */
        bot = ((yday + 11 - wday) % 7) - 3;
        /*
        ** What yday does the NEXT
        ** ISO year begin on?
        */
        top = bot - (len % 7);
        if (top < -3)
            top += 7;
        top += len;
        if (yday >= top) {
            ++year;
            w = 1;
            break;
        }
        if (yday >= bot) {
            w = 1 + ((yday - bot) / 7);
            break;
        }
        --year;
        yday += isLeapYear(year) ? 366 : 365;
    }
    if (yearNumber != 0)
        *yearNumber = year;
    return w;
}

#ifndef QT_NO_TEXTDATE

QString QDate::shortMonthName(int month)
{
    if (month < 1 || month > 12) {
        qWarning("QDate::shortMonthName: Parameter out ouf range");
        month = 1;
    }
    return QLocale::system().monthName(month, QLocale::ShortFormat);
}

QString QDate::longMonthName(int month)
{
    if (month < 1 || month > 12) {
        qWarning("QDate::longMonthName: Parameter out ouf range");
        month = 1;
    }
    return QLocale::system().monthName(month, QLocale::LongFormat);
}

QString QDate::shortDayName(int weekday)
{
    if (weekday < 1 || weekday > 7) {
        qWarning("QDate::shortDayName: Parameter out of range");
        weekday = 1;
    }
    return QLocale::system().dayName(weekday, QLocale::ShortFormat);
}

QString QDate::longDayName(int weekday)
{
    if (weekday < 1 || weekday > 7) {
        qWarning("QDate::longDayName: Parameter out of range");
        weekday = 1;
    }
    return QLocale::system().dayName(weekday, QLocale::LongFormat);
}
#endif //QT_NO_TEXTDATE

#ifndef QT_NO_DATESTRING

QString QDate::toString(Qt::DateFormat f) const
{
    if (!isValid())
        return QString();
    int y, m, d;
    getDateFromJulianDay(jd, &y, &m, &d);
    switch (f) {
    case Qt::SystemLocaleDate:
        return QLocale::system().toString(*this, QLocale::ShortFormat);
    case Qt::LocaleDate:
        return QLocale().toString(*this, QLocale::ShortFormat);
    default:
#ifndef QT_NO_TEXTDATE
    case Qt::TextDate:
        {
            return QString::fromLatin1("%0 %1 %2 %3")
                .arg(shortDayName(dayOfWeek()))
                .arg(shortMonthName(m))
                .arg(d)
                .arg(y);
        }
#endif
    case Qt::ISODate:
        {
            if (year() < 0 || year() > 9999)
                return QString();
            QString month(QString::number(m).rightJustified(2, QLatin1Char('0')));
            QString day(QString::number(d).rightJustified(2, QLatin1Char('0')));
            return QString::number(y) + QLatin1Char('-') + month + QLatin1Char('-') + day;
        }
    }
}

QString QDate::toString(const QString& format) const
{
    if (uint(year()) > 9999)
        return QString();
    return fmtDateTime(format, 0, this);
}
#endif //QT_NO_DATESTRING

bool QDate::setYMD(int y, int m, int d)
{
    if (uint(y) <= 99)
        y += 1900;
    return setDate(y, m, d);
}

bool QDate::setDate(int year, int month, int day)
{
    if (!isValid(year, month, day)) {
        jd = 0;
    } else {
        jd = julianDayFromDate(year, month, day);
    }
    return jd != 0;
}

QDate QDate::addDays(int ndays) const
{
    QDate d;
    d.jd = jd + ndays;
    return d;
}

QDate QDate::addMonths(int nmonths) const
{
    int y, m, d;
    getDateFromJulianDay(jd, &y, &m, &d);

    while (nmonths != 0) {
        if (nmonths < 0 && nmonths + 12 <= 0) {
            y--;
            nmonths+=12;
        } else if (nmonths < 0) {
            m+= nmonths;
            nmonths = 0;
            if (m <= 0) {
                --y;
                m += 12;
            }
        } else if (nmonths - 12 >= 0) {
            y++;
            nmonths -= 12;
        } else if (m == 12) {
            y++;
            m = 0;
        } else {
            m += nmonths;
            nmonths = 0;
            if (m > 12) {
                ++y;
                m -= 12;
            }
        }
    }

    return fixedDate(y, m, d);
}

QDate QDate::addYears(int nyears) const
{
    int y, m, d;
    getDateFromJulianDay(jd, &y, &m, &d);
    y += nyears;
    return fixedDate(y, m, d);
}

int QDate::daysTo(const QDate &d) const
{
    return d.jd - jd;
}


QDate QDate::currentDate()
{
    QDate d;
#if defined(Q_OS_WIN)
    SYSTEMTIME st;
    memset(&st, 0, sizeof(SYSTEMTIME));
    GetLocalTime(&st);
    d.jd = julianDayFromDate(st.wYear, st.wMonth, st.wDay);
#else
    // posix compliant system
    time_t ltime;
    time(&ltime);
    tm *t;

#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
    // use the reentrant version of localtime() where available
    tm res;
    t = localtime_r(&ltime, &res);
#else
    t = localtime(&ltime);
#endif // !QT_NO_THREAD && _POSIX_THREAD_SAFE_FUNCTIONS

    d.jd = julianDayFromDate(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday);
#endif
    return d;
}

#ifndef QT_NO_DATESTRING

QDate QDate::fromString(const QString& s, Qt::DateFormat f)
{
    if ((s.isEmpty()) || (f == Qt::LocalDate))
        return QDate();

    switch (f) {
    case Qt::ISODate:
        {
            int year(s.mid(0, 4).toInt());
            int month(s.mid(5, 2).toInt());
            int day(s.mid(8, 2).toInt());
            if (year && month && day)
                return strictDate(year, month, day);
        }
        break;
    default:
#ifndef QT_NO_TEXTDATE
    case Qt::TextDate:
        {
            /*
              This will fail gracefully if the input string doesn't
              contain any space.
            */
            int monthPos = s.indexOf(QLatin1Char(' ')) + 1;
            int dayPos = s.indexOf(QLatin1Char(' '), monthPos) + 1;
            int yearPos = s.indexOf(QLatin1Char(' '), dayPos) + 1;

            QString monthName(s.mid(monthPos, dayPos - monthPos - 1));
            int month = -1;

            // try English names first
            for (int i = 0; i < 12; i++) {
                if (monthName == QLatin1String(qt_shortMonthNames[i])) {
                    month = i + 1;
                    break;
                }
            }

            // try the localized names
            if (month == -1) {
                for (int i = 0; i < 12; i++) {
                    if (monthName == shortMonthName(i + 1)) {
                        month = i + 1;
                        break;
                    }
                }
            }
            if (month >= 1 && month <= 12) {
                int day = s.mid(dayPos, 2).trimmed().toInt();
                int year = s.mid(yearPos).toInt();
                return strictDate(year, month, day);
            }
        }
#else
        break;
#endif
    }
    return QDate();
}

QDate QDate::fromString(const QString &string, const QString &format)
{
    QDate date;
#ifndef QT_BOOTSTRAPPED
    QDateTimeParser dt(QVariant::Date);
    if (dt.parseFormat(format))
        dt.fromString(string, &date, 0);
#else
    Q_UNUSED(string);
    Q_UNUSED(format);
#endif
    return date;
}
#endif // QT_NO_DATESTRING

bool QDate::isValid(int year, int month, int day)
{
    if (year < FIRST_YEAR
            || (year == FIRST_YEAR && (month < FIRST_MONTH || month == FIRST_MONTH && day < FIRST_DAY))
            || year == 0) // there is no year 0 in the Julian calendar
        return false;

    // passage from Julian to Gregorian calendar
    if (year == 1582 && month == 10 && day > 4 && day < 15)
        return 0;

    return (day > 0 && month > 0 && month <= 12) &&
           (day <= monthDays[month] || (day == 29 && month == 2 && isLeapYear(year)));
}

bool QDate::isLeapYear(int y)
{
    if (y < 1582) {
        return qAbs(y) % 4 == 0;
    } else {
        return y % 4 == 0 && y % 100 != 0 || y % 400 == 0;
    }
}

uint QDate::gregorianToJulian(int y, int m, int d)
{
    return julianDayFromDate(y, m, d);
}

void QDate::julianToGregorian(uint jd, int &y, int &m, int &d)
{
    getDateFromJulianDay(jd, &y, &m, &d);
}

/*****************************************************************************
  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
{
    return ds() / MSECS_PER_HOUR;
}

int QTime::minute() const
{
    return (ds() % MSECS_PER_HOUR) / MSECS_PER_MIN;
}

int QTime::second() const
{
    return (ds() / 1000)%SECS_PER_MIN;
}

int QTime::msec() const
{
    return ds() % 1000;
}

#ifndef QT_NO_DATESTRING

QString QTime::toString(Qt::DateFormat f) const
{
    if (!isValid())
        return QString();

    switch (f) {
    case Qt::SystemLocaleDate:
        return QLocale::system().toString(*this, QLocale::ShortFormat);
    case Qt::LocaleDate:
        return QLocale().toString(*this, QLocale::ShortFormat);
    default:
    case Qt::ISODate:
    case Qt::TextDate:
        return QString::fromLatin1("%1:%2:%3")
            .arg(hour(), 2, 10, QLatin1Char('0'))
            .arg(minute(), 2, 10, QLatin1Char('0'))
            .arg(second(), 2, 10, QLatin1Char('0'));
    }
}

QString QTime::toString(const QString& format) const
{
    return fmtDateTime(format, this, 0);
}
#endif //QT_NO_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)*1000 + ms;
    return true;
}

QTime QTime::addSecs(int nsecs) const
{
    return addMSecs(nsecs * 1000);
}

int QTime::secsTo(const QTime &t) const
{
    return (t.ds() - ds()) / 1000;
}

QTime QTime::addMSecs(int ms) const
{
    QTime t;
    if (ms < 0) {
        // % not well-defined for -ve, but / is.
        int negdays = (MSECS_PER_DAY - ms) / MSECS_PER_DAY;
        t.mds = (ds() + ms + negdays * MSECS_PER_DAY) % MSECS_PER_DAY;
    } else {
        t.mds = (ds() + ms) % MSECS_PER_DAY;
    }
    return t;
}

int QTime::msecsTo(const QTime &t) const
{
    return t.ds() - ds();
}


QTime QTime::currentTime()
{
    QTime ct;

#if defined(Q_OS_WIN)
    SYSTEMTIME st;
    memset(&st, 0, sizeof(SYSTEMTIME));
    GetLocalTime(&st);
    ct.mds = MSECS_PER_HOUR * st.wHour + MSECS_PER_MIN * st.wMinute + 1000 * st.wSecond
             + st.wMilliseconds;
#elif defined(Q_OS_UNIX)
    // posix compliant system
    struct timeval tv;
    gettimeofday(&tv, 0);
    time_t ltime = tv.tv_sec;
    tm *t;

#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
    // use the reentrant version of localtime() where available
    tm res;
    t = localtime_r(&ltime, &res);
#else
    t = localtime(&ltime);
#endif

    ct.mds = MSECS_PER_HOUR * t->tm_hour + MSECS_PER_MIN * t->tm_min + 1000 * t->tm_sec
             + tv.tv_usec / 1000;
#else
    time_t ltime; // no millisecond resolution
    ::time(&ltime);
    tm *t;
    localtime(&ltime);
    ct.mds = MSECS_PER_HOUR * t->tm_hour + MSECS_PER_MIN * t->tm_min + 1000 * t->tm_sec;
#endif
    return ct;
}

#ifndef QT_NO_DATESTRING

QTime QTime::fromString(const QString& s, Qt::DateFormat f)
{
    if (s.isEmpty() || f == Qt::LocalDate) {
        qWarning("QTime::fromString: Parameter out of range");
        QTime t;
        t.mds = NullTime;
        return t;
    }

    const int hour(s.mid(0, 2).toInt());
    const int minute(s.mid(3, 2).toInt());
    const int second(s.mid(6, 2).toInt());

    const QString msec_s(QLatin1String("0.") + s.mid(9, 4));
    const float msec(msec_s.toFloat());
    return QTime(hour, minute, second, qMin(qRound(msec * 1000.0), 999));
}

QTime QTime::fromString(const QString &string, const QString &format)
{
    QTime time;
#ifndef QT_BOOTSTRAPPED
    QDateTimeParser dt(QVariant::Time);
    if (dt.parseFormat(format))
        dt.fromString(string, 0, &time);
#else
    Q_UNUSED(string);
    Q_UNUSED(format);
#endif
    return time;
}

#endif // QT_NO_DATESTRING


bool QTime::isValid(int h, int m, int s, int ms)
{
    return (uint)h < 24 && (uint)m < 60 && (uint)s < 60 && (uint)ms < 1000;
}


void QTime::start()
{
    *this = currentTime();
}

int QTime::restart()
{
    QTime t = currentTime();
    int n = msecsTo(t);
    if (n < 0)                                // passed midnight
        n += 86400*1000;
    *this = t;
    return n;
}

int QTime::elapsed() const
{
    int n = msecsTo(currentTime());
    if (n < 0)                                // passed midnight
        n += 86400 * 1000;
    return n;
}


/*****************************************************************************
  QDateTime member functions
 *****************************************************************************/

QDateTime::QDateTime()
{
    d = new QDateTimePrivate;
}


QDateTime::QDateTime(const QDate &date)
{
    d = new QDateTimePrivate;
    d->date = date;
    d->time = QTime(0, 0, 0);
}

QDateTime::QDateTime(const QDate &date, const QTime &time, Qt::TimeSpec spec)
{
    d = new QDateTimePrivate;
    d->date = date;
    d->time = date.isValid() && !time.isValid() ? QTime(0, 0, 0) : time;
    d->spec = (spec == Qt::UTC) ? QDateTimePrivate::UTC : QDateTimePrivate::LocalUnknown;
}

QDateTime::QDateTime(const QDateTime &other)
{
    d = other.d;
    d->ref.ref();
}

QDateTime::~QDateTime()
{
    if (!d->ref.deref())
        delete d;
}

QDateTime &QDateTime::operator=(const QDateTime &other)
{
    qAtomicAssign(d, other.d);
    return *this;
}

bool QDateTime::isNull() const
{
    return d->date.isNull() && d->time.isNull();
}

bool QDateTime::isValid() const
{
    return d->date.isValid() && d->time.isValid();
}

QDate QDateTime::date() const
{
    return d->date;
}

QTime QDateTime::time() const
{
    return d->time;
}

Qt::TimeSpec QDateTime::timeSpec() const
{
    return d->spec == QDateTimePrivate::UTC ? Qt::UTC : Qt::LocalTime;
}

void QDateTime::setDate(const QDate &date)
{
    detach();
    d->date = date;
    if (date.isValid() && !d->time.isValid())
        d->time = QTime(0, 0, 0);
}

void QDateTime::setTime(const QTime &time)
{
    detach();
    d->time = time;
}

void QDateTime::setTimeSpec(Qt::TimeSpec spec)
{
    detach();
    d->spec = (spec == Qt::UTC) ? QDateTimePrivate::UTC : QDateTimePrivate::LocalUnknown;
}

static uint toTime_t(const QDate &utcDate, const QTime &utcTime)
{
    int days = QDate(1970, 1, 1).daysTo(utcDate);
    int secs = QTime().secsTo(utcTime);
    if (days < 0 || (days == 0 && secs < 0))
        return uint(-1);

    qlonglong retval = (qlonglong(days) * SECS_PER_DAY) + secs;
    if (retval >= Q_INT64_C(0xFFFFFFFF))
        return uint(-1);
    return uint(retval);
}

uint QDateTime::toTime_t() const
{
    QDate utcDate;
    QTime utcTime;
    d->getUTC(utcDate, utcTime);

    return ::toTime_t(utcDate, utcTime);
}

void QDateTime::setTime_t(uint secsSince1Jan1970UTC)
{
    detach();

    QDateTimePrivate::Spec oldSpec = d->spec;

    d->date = QDate(1970, 1, 1).addDays(secsSince1Jan1970UTC / SECS_PER_DAY);
    d->time = QTime().addSecs(secsSince1Jan1970UTC % SECS_PER_DAY);
    d->spec = QDateTimePrivate::UTC;

    if (oldSpec != QDateTimePrivate::UTC)
        d->spec = d->getLocal(d->date, d->time);
}

#ifndef QT_NO_DATESTRING

QString QDateTime::toString(Qt::DateFormat f) const
{
    QString buf;
    if (!isValid())
        return buf;

    if (f == Qt::ISODate) {
        buf = d->date.toString(Qt::ISODate);
        if (buf.isEmpty())
            return QString();   // failed to convert
        buf += QLatin1Char('T');
        buf += d->time.toString(Qt::ISODate);
    }
#ifndef QT_NO_TEXTDATE
    else if (f == Qt::TextDate) {
#ifndef Q_WS_WIN
        buf = d->date.shortDayName(d->date.dayOfWeek());
        buf += QLatin1Char(' ');
        buf += d->date.shortMonthName(d->date.month());
        buf += QLatin1Char(' ');
        buf += QString::number(d->date.day());
#else
        QString winstr;
        QT_WA({
            TCHAR out[255];
            GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ILDATE, out, 255);
            winstr = QString::fromUtf16((ushort*)out);
        } , {
            char out[255];
            GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_ILDATE, (char*)&out, 255);
            winstr = QString::fromLocal8Bit(out);
        });
        switch (winstr.toInt()) {
        case 1:
            buf = d->date.shortDayName(d->date.dayOfWeek());
            buf += QLatin1Char(' ');
            buf += QString::number(d->date.day());
            buf += QLatin1String(". ");
            buf += d->date.shortMonthName(d->date.month());
            break;
        default:
            buf = d->date.shortDayName(d->date.dayOfWeek());
            buf += QLatin1Char(' ');
            buf += d->date.shortMonthName(d->date.month());
            buf += QLatin1Char(' ');
            buf += QString::number(d->date.day());
        }
#endif
        buf += QLatin1Char(' ');
        buf += d->time.toString();
        buf += QLatin1Char(' ');
        buf += QString::number(d->date.year());
    }
#endif
    else if (f == Qt::LocaleDate || f == Qt::SystemLocaleDate) {
        buf = d->date.toString(f);
        if (buf.isEmpty())
            return QString();   // failed to convert
        buf += QLatin1Char(' ');
        buf += d->time.toString(f);
    }
    return buf;
}

QString QDateTime::toString(const QString& format) const
{
    return fmtDateTime(format, &d->time, &d->date);
}
#endif //QT_NO_DATESTRING

QDateTime QDateTime::addDays(int ndays) const
{
    return QDateTime(d->date.addDays(ndays), d->time, timeSpec());
}

QDateTime QDateTime::addMonths(int nmonths) const
{
    return QDateTime(d->date.addMonths(nmonths), d->time, timeSpec());
}

QDateTime QDateTime::addYears(int nyears) const
{
    return QDateTime(d->date.addYears(nyears), d->time, timeSpec());
}


QDateTime QDateTimePrivate::addMSecs(const QDateTime &dt, qint64 msecs)
{
    QDate utcDate;
    QTime utcTime;
    dt.d->getUTC(utcDate, utcTime);

    uint dd = utcDate.jd;
    int tt = utcTime.ds();
    int sign = 1;
    if (msecs < 0) {
        msecs = -msecs;
        sign = -1;
    }
    if (msecs >= int(MSECS_PER_DAY)) {
        dd += sign * (msecs / MSECS_PER_DAY);
        msecs %= MSECS_PER_DAY;
    }

    tt += sign * msecs;
    if (tt < 0) {
        tt = MSECS_PER_DAY - tt - 1;
        dd -= tt / MSECS_PER_DAY;
        tt = tt % MSECS_PER_DAY;
        tt = MSECS_PER_DAY - tt - 1;
    } else if (tt >= int(MSECS_PER_DAY)) {
        dd += tt / MSECS_PER_DAY;
        tt = tt % MSECS_PER_DAY;
    }

    utcDate.jd = dd;
    utcTime.mds = tt;
    return QDateTime(utcDate, utcTime, Qt::UTC).toTimeSpec(dt.timeSpec());
}

QDateTime QDateTime::addSecs(int nsecs) const
{
    return d->addMSecs(*this, qint64(nsecs) * 1000);
}

QDateTime QDateTime::addMSecs(qint64 msecs) const
{
    return d->addMSecs(*this, msecs);
}

int QDateTime::daysTo(const QDateTime &other) const
{
    return d->date.daysTo(other.d->date);
}

int QDateTime::secsTo(const QDateTime &other) const
{
    QDate date1, date2;
    QTime time1, time2;

    d->getUTC(date1, time1);
    other.d->getUTC(date2, time2);

    return (date1.daysTo(date2) * SECS_PER_DAY) + time1.secsTo(time2);
}

QDateTime QDateTime::toTimeSpec(Qt::TimeSpec spec) const
{
    if ((d->spec == QDateTimePrivate::UTC) == (spec == Qt::UTC))
        return *this;

    QDateTime ret;
    if (spec == Qt::UTC) {
        d->getUTC(ret.d->date, ret.d->time);
        ret.d->spec = QDateTimePrivate::UTC;
    } else {
        ret.d->spec = d->getLocal(ret.d->date, ret.d->time);
    }
    return ret;
}

bool QDateTime::operator==(const QDateTime &other) const
{
    if (d->spec != other.d->spec) {
        if (d->spec == QDateTimePrivate::UTC || other.d->spec == QDateTimePrivate::UTC)
            return false;
        if (d->spec != QDateTimePrivate::LocalUnknown
                && other.d->spec != QDateTimePrivate::LocalUnknown)
            return false;

        QDate date1, date2;
        QTime time1, time2;
        d->getUTC(date1, time1);
        other.d->getUTC(date2, time2);
        return time1 == time2 && date1 == date2;
    } else {
        return d->time == other.d->time && d->date == other.d->date;
    }
}

bool QDateTime::operator<(const QDateTime &other) const
{
    if (d->spec == other.d->spec) {
        if (d->date != other.d->date)
            return d->date < other.d->date;
        return d->time < other.d->time;
    } else {
        QDate date1, date2;
        QTime time1, time2;
        d->getUTC(date1, time1);
        other.d->getUTC(date2, time2);
        if (date1 != date2)
            return date1 < date2;
        return time1 < time2;
    }
}

QDateTime QDateTime::currentDateTime()
{
#if defined(Q_OS_WIN)
    QDate d;
    QTime t;
    SYSTEMTIME st;
    memset(&st, 0, sizeof(SYSTEMTIME));
    GetLocalTime(&st);
    d.jd = julianDayFromDate(st.wYear, st.wMonth, st.wDay);
    t.mds = MSECS_PER_HOUR * st.wHour + MSECS_PER_MIN * st.wMinute + 1000 * st.wSecond
            + st.wMilliseconds;
    return QDateTime(d, t);
#else
    QDateTime dt;
    QTime t;
    dt.setDate(QDate::currentDate());
    t = QTime::currentTime();
    if (t.ds() < MSECS_PER_MIN)                // midnight or right after?
        dt.setDate(QDate::currentDate());          // fetch date again
    dt.setTime(t);
    return dt;
#endif
}

QDateTime QDateTime::fromTime_t(uint seconds)
{
    QDateTime d;
    d.setTime_t(seconds);
    return d;
}

#ifndef QT_NO_DATESTRING

QDateTime QDateTime::fromString(const QString& s, Qt::DateFormat f)
{
    if (s.isEmpty() || f == Qt::LocalDate) {
        qWarning("QDateTime::fromString: Parameter out of range");
        return QDateTime();
    }
    if (f == Qt::ISODate) {
        QString tmp = s;
        Qt::TimeSpec ts = Qt::LocalTime;

        // Recognize UTC specifications
        if (tmp.endsWith(QLatin1Char('Z'))) {
            ts = Qt::UTC;
            tmp.chop(1);
        }
        return QDateTime(QDate::fromString(tmp.mid(0, 10), Qt::ISODate),
                         QTime::fromString(tmp.mid(11), Qt::ISODate), ts);
    }
#if !defined(QT_NO_REGEXP) && !defined(QT_NO_TEXTDATE)
    else if (f == Qt::TextDate) {
        QString monthName(s.mid(4, 3));
        int month = -1;
        // Assume that English monthnames are the default
        for (int i = 0; i < 12; ++i) {
            if (monthName == QLatin1String(qt_shortMonthNames[i])) {
                month = i + 1;
                break;
            }
        }
        // If English names can't be found, search the localized ones
        if (month == -1) {
            for (int i = 1; i <= 12; ++i) {
                if (monthName == QDate::shortMonthName(i)) {
                    month = i;
                    break;
                }
            }
        }
        if (month < 1 || month > 12) {
            qWarning("QDateTime::fromString: Parameter out of range");
            return QDateTime();
        }
        int day = s.mid(8, 2).simplified().toInt();
        int yearPos = s.lastIndexOf(QLatin1Char(' ')) + 1;
        int year = s.mid(yearPos).toInt();
        QDate date = strictDate(year, month, day);
        QTime time;
        int hour, minute, second;
        int pivot = s.indexOf(QRegExp(QString::fromLatin1("[0-9][0-9]:[0-9][0-9]:[0-9][0-9]")));
        if (pivot != -1) {
            hour = s.mid(pivot, 2).toInt();
            minute = s.mid(pivot + 3, 2).toInt();
            second = s.mid(pivot + 6, 2).toInt();
            time.setHMS(hour, minute, second);
        }
        return QDateTime(date, time);
    }
#endif //QT_NO_REGEXP
    return QDateTime();
}

QDateTime QDateTime::fromString(const QString &string, const QString &format)
{
#ifndef QT_BOOTSTRAPPED
    QTime time;
    QDate date;

    QDateTimeParser dt(QVariant::DateTime);
    if (dt.parseFormat(format) && dt.fromString(string, &date, &time))
        return QDateTime(date, time);
#else
    Q_UNUSED(string);
    Q_UNUSED(format);
#endif
    return QDateTime(QDate(), QTime(-1, -1, -1));
}

#endif // QT_NO_DATESTRING

void QDateTime::detach()
{
    qAtomicDetach(d);
}

/*****************************************************************************
  Date/time stream functions
 *****************************************************************************/

#ifndef QT_NO_DATASTREAM

QDataStream &operator<<(QDataStream &out, const QDate &date)
{
    return out << (quint32)(date.jd);
}

QDataStream &operator>>(QDataStream &in, QDate &date)
{
    quint32 jd;
    in >> jd;
    date.jd = jd;
    return in;
}

QDataStream &operator<<(QDataStream &out, const QTime &time)
{
    return out << quint32(time.mds);
}

QDataStream &operator>>(QDataStream &in, QTime &time)
{
    quint32 ds;
    in >> ds;
    time.mds = int(ds);
    return in;
}

QDataStream &operator<<(QDataStream &out, const QDateTime &dateTime)
{
    out << dateTime.d->date << dateTime.d->time;
    if (out.version() >= 7)
        out << (qint8)dateTime.d->spec;
    return out;
}

QDataStream &operator>>(QDataStream &in, QDateTime &dateTime)
{
    dateTime.detach();

    qint8 ts = (qint8)QDateTimePrivate::LocalUnknown;
    in >> dateTime.d->date >> dateTime.d->time;
    if (in.version() >= 7)
        in >> ts;
    dateTime.d->spec = (QDateTimePrivate::Spec)ts;
    return in;
}
#endif // QT_NO_DATASTREAM


// checks if there is an unqoted 'AP' or 'ap' in the string
static bool hasUnquotedAP(const QString &f)
{
    const QLatin1Char quote('\'');
    bool inquote = false;
    for (int i=0; i < f.size(); ++i) {
        if (f.at(i) == quote) {
            inquote = !inquote;
        } else if (!inquote && f.at(i).toUpper() == QLatin1Char('A')) {
            return true;
        }
    }
    return false;
}

#ifndef QT_NO_DATESTRING
/*****************************************************************************
  Some static function used by QDate, QTime and QDateTime
*****************************************************************************/

// Replaces tokens by their value. See QDateTime::toString() for a list of valid tokens
static QString getFmtString(const QString& f, const QTime* dt = 0, const QDate* dd = 0, bool am_pm = false)
{
    if (f.isEmpty())
        return QString();

    QString buf = f;
    int removed = 0;

    if (dt) {
        if (f.startsWith(QLatin1String("hh")) || f.startsWith(QLatin1String("HH"))) {
            const bool hour12 = f.at(0) == QLatin1Char('h') && am_pm;
            if (hour12 && dt->hour() > 12)
                buf = QString::number(dt->hour() - 12).rightJustified(2, QLatin1Char('0'), true);
            else if (hour12 && dt->hour() == 0)
                buf = QLatin1String("12");
            else
                buf = QString::number(dt->hour()).rightJustified(2, QLatin1Char('0'), true);
            removed = 2;
        } else if (f.at(0) == QLatin1Char('h') || f.at(0) == QLatin1Char('H')) {
            const bool hour12 = f.at(0) == QLatin1Char('h') && am_pm;
            if (hour12 && dt->hour() > 12)
                buf = QString::number(dt->hour() - 12);
            else if (hour12 && dt->hour() == 0)
                buf = QLatin1String("12");
            else
                buf = QString::number(dt->hour());
            removed = 1;
        } else if (f.startsWith(QLatin1String("mm"))) {
            buf = QString::number(dt->minute()).rightJustified(2, QLatin1Char('0'), true);
            removed = 2;
        } else if (f.at(0) == (QLatin1Char('m'))) {
            buf = QString::number(dt->minute());
            removed = 1;
        } else if (f.startsWith(QLatin1String("ss"))) {
            buf = QString::number(dt->second()).rightJustified(2, QLatin1Char('0'), true);
            removed = 2;
        } else if (f.at(0) == QLatin1Char('s')) {
            buf = QString::number(dt->second());
        } else if (f.startsWith(QLatin1String("zzz"))) {
            buf = QString::number(dt->msec()).rightJustified(3, QLatin1Char('0'), true);
            removed = 3;
        } else if (f.at(0) == QLatin1Char('z')) {
            buf = QString::number(dt->msec());
            removed = 1;
        } else if (f.at(0).toUpper() == QLatin1Char('A')) {
            const bool upper = f.at(0) == QLatin1Char('A');
            buf = dt->hour() < 12 ? QLatin1String("am") : QLatin1String("pm");
            if (upper)
                buf = buf.toUpper();
            if (f.size() > 1 && f.at(1).toUpper() == QLatin1Char('P') &&
                f.at(0).isUpper() == f.at(1).isUpper()) {
                removed = 2;
            } else {
                removed = 1;
            }
        }
    }

    if (dd) {
        if (f.startsWith(QLatin1String("dddd"))) {
            buf = dd->longDayName(dd->dayOfWeek());
            removed = 4;
        } else if (f.startsWith(QLatin1String("ddd"))) {
            buf = dd->shortDayName(dd->dayOfWeek());
            removed = 3;
        } else if (f.startsWith(QLatin1String("dd"))) {
            buf = QString::number(dd->day()).rightJustified(2, QLatin1Char('0'), true);
            removed = 2;
        } else if (f.at(0) == QLatin1Char('d')) {
            buf = QString::number(dd->day());
            removed = 1;
        } else if (f.startsWith(QLatin1String("MMMM"))) {
            buf = dd->longMonthName(dd->month());
            removed = 4;
        } else if (f.startsWith(QLatin1String("MMM"))) {
            buf = dd->shortMonthName(dd->month());
            removed = 3;
        } else if (f.startsWith(QLatin1String("MM"))) {
            buf = QString::number(dd->month()).rightJustified(2, QLatin1Char('0'), true);
            removed = 2;
        } else if (f.at(0) == QLatin1Char('M')) {
            buf = QString::number(dd->month());
            removed = 1;
        } else if (f.startsWith(QLatin1String("yyyy"))) {
            buf = QString::number(dd->year());
            removed = 4;
        } else if (f.startsWith(QLatin1String("yy"))) {
            buf = QString::number(dd->year()).right(2);
            removed = 2;
        }
    }
    if (removed == 0 || removed >= f.size()) {
        return buf;
    }

    return buf + getFmtString(f.mid(removed), dt, dd, am_pm);
}

// Parses the format string and uses getFmtString to get the values for the tokens. Ret
static QString fmtDateTime(const QString& f, const QTime* dt, const QDate* dd)
{
    const QLatin1Char quote('\'');
    if (f.isEmpty())
        return QString();
    if (dt && !dt->isValid())
        return QString();
    if (dd && !dd->isValid())
        return QString();

    const bool ap = hasUnquotedAP(f);

    QString buf;
    QString frm;
    QChar status = QLatin1Char('0');

    for (int i = 0; i < (int)f.length(); ++i) {
        if (f.at(i) == quote) {
            if (status == quote) {
                status = QLatin1Char('0');
            } else {
                if (!frm.isEmpty()) {
                    buf += getFmtString(frm, dt, dd, ap);
                    frm.clear();
                }
                status = quote;
            }
        } else if (status == quote) {
            buf += f.at(i);
        } else if (f.at(i) == status) {
            if ((ap) && ((f.at(i) == QLatin1Char('P')) || (f.at(i) == QLatin1Char('p'))))
                status = QLatin1Char('0');
            frm += f.at(i);
        } else {
            buf += getFmtString(frm, dt, dd, ap);
            frm.clear();
            if ((f.at(i) == QLatin1Char('h')) || (f.at(i) == QLatin1Char('m'))
                || (f.at(i) == QLatin1Char('H'))
                || (f.at(i) == QLatin1Char('s')) || (f.at(i) == QLatin1Char('z'))) {
                status = f.at(i);
                frm += f.at(i);
            } else if ((f.at(i) == QLatin1Char('d')) || (f.at(i) == QLatin1Char('M')) || (f.at(i) == QLatin1Char('y'))) {
                status = f.at(i);
                frm += f.at(i);
            } else if ((ap) && (f.at(i) == QLatin1Char('A'))) {
                status = QLatin1Char('P');
                frm += f.at(i);
            } else  if((ap) && (f.at(i) == QLatin1Char('a'))) {
                status = QLatin1Char('p');
                frm += f.at(i);
            } else {
                buf += f.at(i);
                status = QLatin1Char('0');
            }
        }
    }

    buf += getFmtString(frm, dt, dd, ap);

    return buf;
}
#endif // QT_NO_DATESTRING

#ifdef Q_OS_WIN
static const int LowerYear = 1980;
#else
static const int LowerYear = 1970;
#endif

static QDateTimePrivate::Spec utcToLocal(QDate &date, QTime &time)
{
    QDate lowerLimit(LowerYear, 1, 2);
    QDate upperLimit(2037, 12, 30);

    QDate fakeDate = date;

    if (fakeDate < lowerLimit) {
        fakeDate = lowerLimit;
    } else if (fakeDate > upperLimit) {
        fakeDate = upperLimit;
    }

    time_t secsSince1Jan1970UTC = toTime_t(fakeDate, time);
    tm *brokenDown = 0;

#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
    // use the reentrant version of localtime() where available
    tm res;
    brokenDown = localtime_r(&secsSince1Jan1970UTC, &res);
#elif defined(_MSC_VER) && _MSC_VER >= 1400
    tm res;
    if (!_localtime64_s(&res, &secsSince1Jan1970UTC))
        brokenDown = &res;
#else
    brokenDown = localtime(&secsSince1Jan1970UTC);
#endif
    if (!brokenDown) {
        date = QDate(1970, 1, 1);
        time = QTime();
        return QDateTimePrivate::LocalUnknown;
    } else {
        int deltaDays = fakeDate.daysTo(date);
        date = QDate(brokenDown->tm_year + 1900, brokenDown->tm_mon + 1, brokenDown->tm_mday);
        time = QTime(brokenDown->tm_hour, brokenDown->tm_min, brokenDown->tm_sec, time.msec());
        date = date.addDays(deltaDays);
        if (brokenDown->tm_isdst > 0)
            return QDateTimePrivate::LocalDST;
        else if (brokenDown->tm_isdst < 0)
            return QDateTimePrivate::LocalUnknown;
        else
            return QDateTimePrivate::LocalStandard;
    }
}

static void localToUtc(QDate &date, QTime &time, int isdst)
{
    if (!date.isValid())
        return;

    QDate lowerLimit(LowerYear, 1, 2);
    QDate upperLimit(2037, 12, 30);

    QDate fakeDate = date;

    if (fakeDate < lowerLimit) {
        fakeDate = lowerLimit;
        isdst = false;
    } else if (fakeDate > upperLimit) {
        fakeDate = upperLimit;
        isdst = false;
    }

    tm localTM;
    localTM.tm_sec = time.second();
    localTM.tm_min = time.minute();
    localTM.tm_hour = time.hour();
    localTM.tm_mday = fakeDate.day();
    localTM.tm_mon = fakeDate.month() - 1;
    localTM.tm_year = fakeDate.year() - 1900;
    localTM.tm_isdst = (int)isdst;

    time_t secsSince1Jan1970UTC = mktime(&localTM);
    tm *brokenDown = 0;

#if !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS)
    // use the reentrant version of gmtime() where available
    tm res;
    brokenDown = gmtime_r(&secsSince1Jan1970UTC, &res);
#elif defined(_MSC_VER) && _MSC_VER >= 1400
    tm res;
    if (!_gmtime64_s(&res, &secsSince1Jan1970UTC))
        brokenDown = &res;
#else
    brokenDown = gmtime(&secsSince1Jan1970UTC);
#endif // !QT_NO_THREAD && _POSIX_THREAD_SAFE_FUNCTIONS
    if (!brokenDown) {
        date = QDate(1970, 1, 1);
        time = QTime();
    } else {
        int deltaDays = fakeDate.daysTo(date);
        date = QDate(brokenDown->tm_year + 1900, brokenDown->tm_mon + 1, brokenDown->tm_mday);
        time = QTime(brokenDown->tm_hour, brokenDown->tm_min, brokenDown->tm_sec, time.msec());
        date = date.addDays(deltaDays);
    }
}

QDateTimePrivate::Spec QDateTimePrivate::getLocal(QDate &outDate, QTime &outTime) const
{
    outDate = date;
    outTime = time;
    if (spec == QDateTimePrivate::UTC)
        return utcToLocal(outDate, outTime);
    return spec;
}

void QDateTimePrivate::getUTC(QDate &outDate, QTime &outTime) const
{
    outDate = date;
    outTime = time;
    if (spec != QDateTimePrivate::UTC)
        localToUtc(outDate, outTime, (int)spec);
}

#if !defined(QT_NO_DEBUG_STREAM) && !defined(QT_NO_DATESTRING)
QDebug operator<<(QDebug dbg, const QDate &date)
{
    dbg.nospace() << "QDate(" << date.toString() << ")";
    return dbg.space();
}

QDebug operator<<(QDebug dbg, const QTime &time)
{
    dbg.nospace() << "QTime(" << time.toString() << ")";
    return dbg.space();
}

QDebug operator<<(QDebug dbg, const QDateTime &date)
{
    dbg.nospace() << "QDateTime(" << date.toString() << ")";
    return dbg.space();
}
#endif

#ifndef QT_BOOTSTRAPPED
bool QDateTimeParser::isSpecial(const QChar &c) const
{
    switch (c.cell()) {
    case 'd': case 'M': case 'y':
        return (typ == QVariant::Date || typ == QVariant::DateTime);
    case 'H': case 'h': case 'm': case 's': case 'z': case 'a': case 'p': case 'A':
        return (typ == QVariant::Time || typ == QVariant::DateTime);
    case '\'': return true;
    default: return false;
    }
}


int QDateTimeParser::getDigit(const QVariant &t, Section s) const
{
    switch (s) {
    case Hour24Section: case Hour12Section: return t.toTime().hour();
    case MinuteSection: return t.toTime().minute();
    case SecondSection: return t.toTime().second();
    case MSecSection: return t.toTime().msec();
    case YearSection: return t.toDate().year();
    case MonthSection: return t.toDate().month();
    case DaySection: return t.toDate().day();
    case AmPmSection: return t.toTime().hour() > 11 ? 1 : 0;

    default: break;
    }
    qFatal("%s passed to getDigit. This should never happen", sectionName(s).toLatin1().constData());
    return -1;
}

void QDateTimeParser::setDigit(QVariant &v, Section section, int newVal) const
{
    int year, month, day, hour, minute, second, msec;
    const QDateTime &dt = v.toDateTime();
    year = dt.date().year();
    month = dt.date().month();
    day = dt.date().day();
    hour = dt.time().hour();
    minute = dt.time().minute();
    second = dt.time().second();
    msec = dt.time().msec();

    switch (section) {
    case Hour24Section: case Hour12Section: hour = newVal; break;
    case MinuteSection: minute = newVal; break;
    case SecondSection: second = newVal; break;
    case MSecSection: msec = newVal; break;
    case YearSection: year = newVal; break;
    case MonthSection: month = newVal; break;
    case DaySection: day = newVal; break;
    case AmPmSection: hour = (newVal == 0 ? hour % 12 : (hour % 12) + 12); break;
    default:
        qFatal("%s passed to setDigit. This should never happen", sectionName(section).toLatin1().constData());
        break;
    }

    if (section != DaySection) {
        day = qMax<int>(cachedDay, day);
    }

    v = QVariant(QDateTime(fixedDate(year, month, day), QTime(hour, minute, second, msec)));
}



int QDateTimeParser::absoluteMax(int s) const
{
    const SectionNode sn = sectionNode(s);
    switch (sn.type) {
    case Hour24Section:
    case Hour12Section: return 23; // this is special-cased in parseSection. We want it to be 23 for the stepBy case.
    case MinuteSection:
    case SecondSection: return 59;
    case MSecSection: return 999;
    case YearSection: return sn.count == 2 ? 99 : 9999;
    case MonthSection: return 12;
    case DaySection: return 31;
    case AmPmSection: return 1;
    default: break;
    }
    qFatal("%s passed to max. This should never happen", sectionName(s).toLatin1().constData());
    return -1;

}

int QDateTimeParser::absoluteMin(int s) const
{
    const SectionNode sn = sectionNode(s);
    switch (sn.type){
    case Hour24Section:
    case Hour12Section:
    case MinuteSection:
    case SecondSection:
    case MSecSection:
    case YearSection: return 0;
    case MonthSection:
    case DaySection: return 1;
    case AmPmSection: return 0;
    default: break;
    }
    qFatal("%s passed to min. This should never happen", sectionName(s).toLatin1().constData());
    return -1;
}

QDateTimeParser::SectionNode QDateTimeParser::sectionNode(int sectionIndex) const
{
    if (sectionIndex == FirstSectionIndex) {
        return first;
    } else if (sectionIndex == LastSectionIndex) {
        return last;
    } else if (sectionIndex == NoSectionIndex) {
        return none;
    }
    Q_ASSERT(sectionIndex >= 0 && sectionIndex < sectionNodes.size());
    return sectionNodes.at(sectionIndex);
}

QDateTimeParser::Section QDateTimeParser::sectionType(int sectionIndex) const
{
    return sectionNode(sectionIndex).type;
}


int QDateTimeParser::sectionPos(int sectionIndex) const
{
    return sectionPos(sectionNode(sectionIndex));
}

int QDateTimeParser::sectionPos(const SectionNode &sn) const
{
    switch (sn.type) {
    case FirstSection: return 0;
    case LastSection: return displayText().size() - 1;
    default: break;
    }
    if (sn.pos == -1)
        QDTPDEBUG << sectionName(sn.type) << sectionNodes.indexOf(sn);
    Q_ASSERT(sn.pos != -1);
    return sn.pos;
}


static QString unquote(const QString &str)
{
    const QLatin1Char quote('\'');
    const QLatin1Char slash('\\');
    const QLatin1Char zero('0');
    QString ret;
    QChar status = zero;
    for (int i=0; i<str.size(); ++i) {
        if (str.at(i) == quote) {
            if (status != quote) {
                status = quote;
            } else if (!ret.isEmpty() && str.at(i - 1) == slash) {
                ret[ret.size() - 1] = quote;
            } else {
                status = zero;
            }
        } else {
            ret += str.at(i);
        }
    }
    return ret;
}
static int countRepeat(const QString &str, int index)
{
    Q_ASSERT(index >= 0 && index < str.size());
    int count = 1;
    const QChar ch = str.at(index);
    while (index + count < str.size() && str.at(index + count) == ch)
        ++count;
    return count;
}

bool QDateTimeParser::parseFormat(const QString &newFormat)
{
    const QLatin1Char quote('\'');
    const QLatin1Char slash('\\');
    const QLatin1Char zero('0');
    if (newFormat == displayFormat && !newFormat.isEmpty()) {
        return true;
    }

    QDTPDEBUGN("parseFormat: %s", newFormat.toLatin1().constData());

    const bool ap = hasUnquotedAP(newFormat);
    QList<SectionNode> newSectionNodes;
    Sections newDisplay = 0;
    QStringList newSeparators;
    int i, index = 0;
    int add = 0;
    QChar status = zero;
    for (i = 0; i<newFormat.size(); ++i) {
        if (newFormat.at(i) == quote) {
            ++add;
            if (status != quote) {
                status = quote;
            } else if (newFormat.at(i - 1) != slash) {
                status = zero;
            }
        } else if (i < newFormat.size() && status != quote) {
            const int repeat = qMin(4, countRepeat(newFormat, i));
            if (isSpecial(newFormat.at(i))) {
                const char sect = newFormat.at(i).toLatin1();
                switch (sect) {
                case 'H':
                case 'h': {
                    const Section hour = (ap && sect == 'h') ? Hour12Section : Hour24Section;
                    const SectionNode sn = { hour, i - add, qMin(2, repeat) };
                    newSectionNodes << sn;
                    newSeparators << unquote(newFormat.mid(index, i - index));
                    i += sn.count - 1;
                    index = i + 1;
                    newDisplay |= hour;
                    break; }
                case 'm': {
                    const SectionNode sn = { MinuteSection, i - add, qMin(2, repeat) };
                    newSectionNodes << sn;
                    newSeparators << unquote(newFormat.mid(index, i - index));
                    i += sn.count - 1;
                    index = i + 1;
                    newDisplay |= MinuteSection;
                    break; }
                case 's': {
                    const SectionNode sn = { SecondSection, i - add, qMin(2, repeat) };
                    newSectionNodes << sn;
                    newSeparators << unquote(newFormat.mid(index, i - index));
                    i += qMin(2, repeat) - 1;
                    index = i + 1;
                    newDisplay |= SecondSection;
                    break; }

                case 'z': {
                    const SectionNode sn = { MSecSection, i - add, (repeat < 3 ? 1 : 3) };
                    newSectionNodes << sn;
                    newSeparators << unquote(newFormat.mid(index, i - index));
                    i += sn.count - 1;
                    index = i + 1;
                    newDisplay |= MSecSection;
                    break; }
                case 'A':
                case 'a': {
                    const bool cap = newFormat.at(i) == QLatin1Char('A');
                    const SectionNode sn = { AmPmSection, i - add, (cap ? 1 : 0) };
                    newSectionNodes << sn;
                    newSeparators << unquote(newFormat.mid(index, i - index));
                    newDisplay |= AmPmSection;
                    if (i + 1 < newFormat.size()
                        && newFormat.at(i+1) == (cap ? QLatin1Char('P') : QLatin1Char('p'))) {
                        ++i;
                    }
                    index = i + 1;
                    break; }
                case 'y':
                    if (repeat >= 2) {
                        const bool four = repeat >= 4;
                        const SectionNode sn = { YearSection, i - add, four ? 4 : 2 };
                        newSectionNodes << sn;
                        newSeparators << unquote(newFormat.mid(index, i - index));
                        i += sn.count - 1;
                        index = i + 1;
                        newDisplay |= YearSection;
                    }
                    break;
                case 'M': {
                    const SectionNode sn = { MonthSection, i - add, repeat };
                    newSectionNodes << sn;
                    newSeparators << unquote(newFormat.mid(index, i - index));
                    i += sn.count - 1;
                    index = i + 1;
                    newDisplay |= MonthSection;
                    break; }
                case 'd': {
                    const SectionNode sn = { DaySection, i - add, repeat };
                    newSectionNodes << sn;
                    newSeparators << unquote(newFormat.mid(index, i - index));
                    i += sn.count - 1;
                    index = i + 1;
                    newDisplay |= DaySection;
                    break; }

                default:
                    break;
                }
            }
        }
    }
    if (newSectionNodes.isEmpty() && !allowEmpty) {
        return false;
    }

    newSeparators << (index < newFormat.size() ? unquote(newFormat.mid(index)) : QString());

    displayFormat = newFormat;
    separators = newSeparators;
    sectionNodes = newSectionNodes;
    display = newDisplay;
    last.pos = -1;

//     for (int i=0; i<sectionNodes.size(); ++i) {
//         QDTPDEBUG << sectionName(sectionNodes.at(i).type) << sectionNodes.at(i).count;
//     }

    QDTPDEBUG << newFormat << displayFormat;
    QDTPDEBUGN("separators:\n'%s'", separators.join(QLatin1String("\n")).toLatin1().constData());

    return true;
}

int QDateTimeParser::sectionSize(int sectionIndex) const
{
    if (sectionIndex < 0)
        return 0;
    Q_ASSERT(sectionIndex < sectionNodes.size());
    if (sectionIndex == sectionNodes.size() - 1) {
        return displayText().size() - sectionPos(sectionIndex) - separators.last().size();
    } else {
        return sectionPos(sectionIndex + 1) - sectionPos(sectionIndex)
            - separators.at(sectionIndex + 1).size();
    }
}


int QDateTimeParser::sectionMaxSize(Section s, int count) const
{
#ifndef QT_NO_TEXTDATE
    int mcount = 12;
    QString(*nameFunction)(int) = 0;
#endif

    switch (s) {
    case FirstSection:
    case NoSection:
    case LastSection: return 0;

    case AmPmSection: {
        const int lowerMax = qMin(getAmPmText(AmText, LowerCase).size(),
                                  getAmPmText(PmText, LowerCase).size());
        const int upperMax = qMin(getAmPmText(AmText, UpperCase).size(),
                                  getAmPmText(PmText, UpperCase).size());
        return qMin(4, qMin(lowerMax, upperMax));
    }

    case Hour24Section:
    case Hour12Section:
    case MinuteSection:
    case SecondSection: return 2;
    case DaySection:
#ifdef QT_NO_TEXTDATE
        return 2;
#else
        if (count <= 2)
            return 2;
        nameFunction = (count == 4 ? &QDate::longDayName : &QDate::shortDayName);
        mcount = 7;
        // fall through
#endif
    case MonthSection:
        if (count <= 2)
            return 2;

#ifdef QT_NO_TEXTDATE
        return 2;
#else
        if (s == MonthSection) {
            nameFunction = count == 4
                           ? &QDate::longMonthName : &QDate::shortMonthName;
        }
        Q_ASSERT(nameFunction);
        {
            int ret = 0;
            for (int i=1; i<=mcount; ++i) {
                ret = qMax(nameFunction(i).size(), ret);
            }
            return ret;
        }
#endif
    case MSecSection: return 3;
    case YearSection: return count;

    case Internal:
    case TimeSectionMask:
    case DateSectionMask: qWarning("QDateTimeParser::sectionMaxSize: Invalid section %s", sectionName(s).toLatin1().constData());
    }
    return -1;
}


int QDateTimeParser::sectionMaxSize(int index) const
{
    const SectionNode sn = sectionNode(index);
    return sectionMaxSize(sn.type, sn.count);
}

QString QDateTimeParser::sectionText(const QString &text, int sectionIndex, int index) const
{
    const SectionNode &sn = sectionNode(sectionIndex);
    switch (sn.type) {
    case NoSectionIndex:
    case FirstSectionIndex:
    case LastSectionIndex:
        return QString();
    default: break;
    }

    return text.mid(index, sectionSize(sectionIndex));
}

#ifndef QT_NO_TEXTDATE

int QDateTimeParser::parseSection(int sectionIndex, QString &text, int index,
                                  State &state, int *usedptr) const
{
    state = Invalid;
    int num = 0;
    const SectionNode sn = sectionNode(sectionIndex);
    Q_ASSERT(sn.type != NoSection && sn.type != FirstSection && sn.type != LastSection);

    QString sectiontext = text.mid(index, sectionMaxSize(sectionIndex));

    QDTPDEBUG << "sectionValue for" << sectionName(sn.type)
              << "with text" << text << "and st" << sectiontext
              << text.mid(index, sectionMaxSize(sectionIndex))
              << index;

    int used = 0;
    if (false && sectiontext.trimmed().isEmpty()) {
        state = Intermediate;
    } else {
        switch (sn.type) {
        case AmPmSection: {
            const int ampm = findAmPm(sectiontext, sectionIndex, &used);
            switch (ampm) {
            case AM: // sectiontext == AM
            case PM: // sectiontext == PM
                num = ampm;
                state = Acceptable;
                break;
            case PossibleAM: // sectiontext => AM
            case PossiblePM: // sectiontext => PM
                num = ampm - 2;
                state = Intermediate;
                break;
            case PossibleBoth: // sectiontext => AM|PM
                num = 0;
                state = Intermediate;
                break;
            case Neither:
                state = Invalid;
                QDTPDEBUG << "invalid because findAmPm(" << sectiontext << ") returned -1";
                break;
            default:
                QDTPDEBUGN("This should never happen(findAmPm returned %d", ampm);
                break;
            }
            if (state != Invalid) {
                QString str = text;
                text.replace(index, used, sectiontext.left(used));
            }
            break;
        }
        case MonthSection:
        case DaySection:
            if (sn.count >= 3) {
                if (sn.type == MonthSection) {
                    num = findMonth(sectiontext.toLower(), 1, sectionIndex, &sectiontext, &used);
                } else {
                    num = findDay(sectiontext.toLower(), 1, sectionIndex, &sectiontext, &used);
                }

                if (num != -1) {
                    state = (used == sectiontext.size() ? Acceptable : Intermediate);
                    QString str = text;
                    text.replace(index, used, sectiontext.left(used));
                } else {
                    state = Intermediate;
                }
                break;
            }
            // fall through
        case YearSection:
        case Hour12Section:
        case Hour24Section:
        case MinuteSection:
        case SecondSection:
        case MSecSection: {
            if (sectiontext.isEmpty()) {
                num = 0;
                used = 0;
                state = Intermediate;
            } else {
                const int absMax = absoluteMax(sectionIndex);
                QLocale loc;
                bool ok = true;
                int last = -1;
                used = -1;

                const int max = qMin(sectionMaxSize(sectionIndex), sectiontext.size());
                for (int digits=1; digits<=max; ++digits) {
                    if (sectiontext.at(digits - 1).isSpace()) // loc.toUInt will allow spaces at the end
                        break;
                    int tmp = (int)loc.toUInt(sectiontext.left(digits), &ok, 10);
                    if (ok && sn.type == Hour12Section) {
                        if (tmp > 12) {
                            tmp = -1;
                            ok = false;
                        } else if (tmp == 12) {
                            tmp = 0;
                        }
                    }
                    if (ok && tmp <= absMax) {
                        QDTPDEBUG << sectiontext.left(digits) << tmp << digits;
                        last = tmp;
                        used = digits;
                    } else {
                        break;
                    }
                }
                if (last == -1) {
                    const QChar &first = sectiontext.at(0);
                    if (separators.at(sectionIndex + 1).startsWith(first)) {
                        used = 0;
                        state = Intermediate;
                    } else {
                        state = Invalid;
                        QDTPDEBUG << "invalid because" << sectiontext << "can't become a uint" << last << ok;
                    }
                } else {
                    num += last;
                    const bool done = (used == sectionMaxSize(sectionIndex));
                    if (num < absoluteMin(sectionIndex)) {
                        state = done ? Invalid : Intermediate;
                        if (done)
                            QDTPDEBUG << "invalid because" << num << "is less than absoluteMin" << absoluteMin(sectionIndex);
                    } else if (num > absMax) {
                        state = Intermediate;
                    } else if (!done && (fieldInfo(sectionIndex) & (FixedWidth|Numeric)) == (FixedWidth|Numeric)) {
                        state = Intermediate;
                    } else {
                        state = Acceptable;
                    }
                }
            }
            break; }
        default: qFatal("NoSection or Internal. This should never happen"); break;
        }
    }

    if (usedptr)
        *usedptr = used;

    return (state != Invalid ? num : -1);
}
#endif // QT_NO_TEXTDATE

#ifndef QT_NO_DATESTRING

QDateTimeParser::StateNode QDateTimeParser::parse(const QString &inp,
                                                  const QVariant &currentValue, bool fixup) const
{
    QString input = inp;
    State state = Acceptable;
    const QVariant maximum = getMaximum();
    const QVariant minimum = getMinimum();

    QVariant tmp;
    SectionNode sn = {NoSection, 0, false};
    int pos = 0;
    bool conflicts = false;

//    QDTPDEBUG << "validateAndInterpret" << input;
    {
        int year, month, day, hour12, hour, minute, second, msec, ampm, dayofweek, year2digits;
        const QDateTime &dt = currentValue.toDateTime();
        year = dt.date().year();
        year2digits = year % 100;
        month = dt.date().month();
        day = dt.date().day();
        hour = dt.time().hour();
        hour12 = -1;
        minute = dt.time().minute();
        second = dt.time().second();
        msec = dt.time().msec();
        dayofweek = dt.date().dayOfWeek();
        ampm = -1;
        QSet<int*> isSet;
        int num;
        State tmpstate;
        int *current;

        state = Acceptable;

        for (int index=0; state != Invalid && index<sectionNodes.size(); ++index) {
            QString sep = input.mid(pos, separators.at(index).size());

            if (sep != separators.at(index)) {
                QDTPDEBUG << "invalid because" << sep << "!=" << separators.at(index)
                          << index << pos << currentSectionIndex;
                state = Invalid;
                goto end;
            }
            pos += separators.at(index).size();
            sectionNodes[index].pos = pos;
            current = 0;
            sn = sectionNodes.at(index);
            int used;

            num = parseSection(index, input, pos, tmpstate, &used);
            QDTPDEBUG << "sectionValue" << sectionName(sectionType(index)) << input
                      << "pos" << pos << "used" << used << stateName(tmpstate);
            if (fixup && tmpstate == Intermediate && (fieldInfo(index) & (Numeric|FixedWidth)) == (Numeric|FixedWidth) && used < sn.count) {
                input.insert(pos, QString().fill(QLatin1Char('0'), sn.count - used)); // ### ltor?
                num = parseSection(index, input, pos, tmpstate, &used);
            }
            pos += qMax(0, used);

            state = qMin<State>(state, tmpstate);
            QDTPDEBUG << index << sectionName(sectionType(index)) << "is set to"
                      << pos << "state is" << stateName(state);


            if (state != Invalid) {
                switch (sn.type) {
                case Hour24Section: current = &hour; break;
                case Hour12Section: current = &hour12; break;
                case MinuteSection: current = &minute; break;
                case SecondSection: current = &second; break;
                case MSecSection: current = &msec; break;
                case YearSection:
                    if (sn.count == 2) {
                        current = &year2digits;
                    } else {
                        current = &year;
                    }
                    break;
                case MonthSection: current = &month; break;
                case DaySection:
                    if (sn.count >= 3) {
                        current = &dayofweek;
                    } else {
                        current = &day; num = qMax<int>(1, num);
                    }
                    break;
                case AmPmSection: current = &ampm; break;
                default:
                    qFatal("%s found in sections validateAndInterpret. This should never happen",
                           sectionName(sn.type).toLatin1().constData());
                    break;
                }
                Q_ASSERT(current);
                if (isSet.contains(current) && *current != num) {
                    QDTPDEBUG << "CONFLICT " << sectionName(sn.type) << *current << num;
                    conflicts = true;
                    if (index != currentSectionIndex || num == -1) {
                        continue;
                    }
                }
                if (num != -1)
                    *current = num;
                isSet.insert(current);
            }
        }

        if (state != Invalid && input.mid(pos) != separators.last()) {
            QDTPDEBUG << "1invalid because" << input.mid(pos)
                      << "!=" << separators.last() << pos;
            state = Invalid;
        }

        if (state != Invalid) {
            if (typ != QVariant::Time) {
                if (year % 100 != year2digits) {
                    if (isSet.contains(&year2digits) && !isSet.contains(&year)) {
                        year = (year / 100) * 100;
                        year += year2digits;
                    } else if (isSet.contains(&year2digits) && isSet.contains(&year)) {
                        conflicts = true;
                        SectionNode sn = sectionNode(currentSectionIndex);
                        if (sn.type == YearSection) {
                            if (sn.count == 2) {
                                year = (year / 100) * 100;
                                year += year2digits;
                            }
                        }
                    }
                }

                const QDate date = strictDate(year, month, day);
                const int diff = dayofweek - date.dayOfWeek() && isSet.contains(&dayofweek);
                if (diff != 0 && state == Acceptable) {
                    conflicts = true;
                    const SectionNode &sn = sectionNode(currentSectionIndex);
                    if (sn.type == DaySection && sn.count >= 3) {
                        day -= diff;
                        if (day < 0) {
                            day += 7;
                        } else if (day > date.daysInMonth()) {
                            day -= 7;
                        }
                        QDTPDEBUG << year << month << day << dayofweek
                                  << diff << strictDate(year, month, day).dayOfWeek();
                    }
                }
                bool needfixday = false;
                if (sectionType(currentSectionIndex) == DaySection) {
                    cachedDay = day;
                } else if (cachedDay > day) {
                    day = cachedDay;
                    needfixday = true;
                }

                if (!QDate::isValid(year, month, day)) {
                    if (day < 32) {
                        cachedDay = day;
                    }
                    if (day > 28 && QDate::isValid(year, month, 1)) {
                        needfixday = true;
                    }
                }
                if (needfixday) {
                    if (state == Acceptable && fixday) {
                        day = qMin<int>(day, strictDate(year, month, 1).daysInMonth());

                        const QLocale loc;
                        for (int i=0; i<sectionNodes.size(); ++i) {
                            if (sectionType(i) == DaySection) {
                                input.replace(sectionPos(i), sectionSize(i), loc.toString(day));
                            }
                        }
                    } else {
                        state = qMin(Intermediate, state);
                    }

                }
            }

            if (typ != QVariant::Date) {
                if (isSet.contains(&hour12)) {
                    const bool hasHour = isSet.contains(&hour);
                    if (ampm == -1) {
                        if (hasHour) {
                            ampm = (hour < 12 ? 0 : 1);
                        } else {
                            ampm = 0; // no way to tell if this is am or pm so I assume am
                        }
                    }
                    hour12 = (ampm == 0 ? hour12 % 12 : (hour12 % 12) + 12);
                    if (!hasHour) {
                        hour = hour12;
                    } else if (hour != hour12) {
                        conflicts = true;
                    }
                } else if (ampm != -1) {
                    if (!isSet.contains(&hour)) {
                        hour = (12 * ampm); // special case. Only ap section
                    } else if ((ampm == 0) != (hour < 12)) {
                        conflicts = true;
                    }
                }

            }

            tmp = QVariant(QDateTime(strictDate(year, month, day), QTime(hour, minute, second, msec)));
            QDTPDEBUG << year << month << day << hour << minute << second << msec;

        }
        QDTPDEBUGN("'%s' => '%s'(%s)", input.toLatin1().constData(),
                   tmp.toString().toLatin1().constData(), stateName(state).toLatin1().constData());
    }
end:
    if (tmp.toDateTime().isValid()) {
        if (state != Invalid && dateTimeCompare(tmp, minimum) < 0) {
            state = checkIntermediate(tmp.toDateTime(), input);
        } else {
            if (dateTimeCompare(tmp, maximum) > 0)
                state = Invalid;
            QDTPDEBUG << "not checking intermediate because tmp is" << tmp  << minimum << maximum;
        }
    }
    StateNode node;
    node.input = input;
    node.state = state;
    node.conflicts = conflicts;
    node.value = tmp;
    text = input; // ### do I need this?
    return node;
}
#endif // QT_NO_DATESTRING

#ifndef QT_NO_TEXTDATE

int QDateTimeParser::findMonth(const QString &str1, int startMonth, int sectionIndex, QString *usedMonth, int *used) const
{
    int bestMatch = -1;
    int bestCount = 0;
    if (!str1.isEmpty()) {
        const SectionNode sn = sectionNode(sectionIndex);
        Q_ASSERT(sn.type == MonthSection);
        QString(*nameFunction)(int) = sn.count == 3
                                      ? &QDate::shortMonthName
                                      : &QDate::longMonthName;

        for (int month=startMonth; month<=12; ++month) {
            for (int attempt=0; attempt<(sn.count == 3 ? 2 : 1); ++attempt) {
                QString str2;
                if (attempt == 0) {
                    str2 = nameFunction(month).toLower();
                } else {
                    str2 = QString::fromAscii(qt_shortMonthNames[month - 1]).toLower();
                }

                if (str1.startsWith(str2)) {
                    if (used) {
                        QDTPDEBUG << "used is set to" << str2.size();
                        *used = str2.size();
                    }
                    if (usedMonth)
                        *usedMonth = nameFunction(month);
                    return month;
                }

                const int limit = qMin(str1.size(), str2.size());

                QDTPDEBUG << "limit is" << limit << str1 << str2;
                bool found = true;
                for (int i=0; i<limit; ++i) {
                    if (str1.at(i) != str2.at(i)) {
                        if (i > bestCount) {
                            bestCount = i;
                            bestMatch = month;
                        }
                        found = false;
                        break;
                    }

                }
                if (found) {
                    if (used) {
                        *used = limit;
                    }
                    if (usedMonth)
                        *usedMonth = nameFunction(month);
                    QDTPDEBUG << "used is set to" << limit << *usedMonth;

                    return month;
                }
            }
        }
        if (usedMonth && bestMatch != -1)
            *usedMonth = nameFunction(bestMatch);

    }
    if (used) {
        QDTPDEBUG << "used is set to" << bestCount;
        *used = bestCount;
    }
    return bestMatch;
}

int QDateTimeParser::findDay(const QString &str1, int startDay, int sectionIndex, QString *usedDay, int *used) const
{
    int bestMatch = -1;
    int bestCount = 0;
    if (!str1.isEmpty()) {
    const SectionNode sn = sectionNode(sectionIndex);
    Q_ASSERT(sn.type == DaySection);
    QString(*nameFunction)(int) = sn.count == 3
                                  ? &QDate::shortDayName
                                  : &QDate::longDayName;

    for (int day=startDay; day<=7; ++day) {
        const QString str2 = nameFunction(day).toLower();

        if (str1.startsWith(str2)) {
            if (used)
                *used = str2.size();
            if (usedDay)
                *usedDay = nameFunction(day);
            return day;
        }

        const int limit = qMin(str1.size(), str2.size());
        bool found = true;
        for (int i=0; i<limit; ++i) {
            if (str1.at(i) != str2.at(i) && !str1.at(i).isSpace()) {
                if (i > bestCount) {
                    bestCount = i;
                    bestMatch = day;
                }
                found = false;
                break;
            }

        }
        if (found) {
            if (used)
                *used = limit;
            if (usedDay)
                *usedDay = nameFunction(day);

            return day;
        }
    }
    if (usedDay && bestMatch != -1)
        *usedDay = nameFunction(bestMatch);
    }
    if (used)
        *used = bestCount;

    return bestMatch;
}
#endif // QT_NO_TEXTDATE

int QDateTimeParser::findAmPm(QString &str, int index, int *used) const
{
    const SectionNode s = sectionNode(index);
    Q_ASSERT(s.type == AmPmSection);
    if (used)
        *used = str.size();
    if (str.trimmed().isEmpty()) {
        return PossibleBoth;
    }
    const QLatin1Char space(' ');
    int size = sectionMaxSize(index);

    enum {
        amindex = 0,
        pmindex = 1
    };
    QString ampm[2];
    ampm[amindex] = getAmPmText(AmText, s.count == 1 ? UpperCase : LowerCase);
    ampm[pmindex] = getAmPmText(PmText, s.count == 1 ? UpperCase : LowerCase);
    for (int i=0; i<2; ++i)
        ampm[i].truncate(size);

    QDTPDEBUG << "findAmPm" << str << ampm[0] << ampm[1];

    if (str.indexOf(ampm[amindex], 0, Qt::CaseInsensitive) == 0) {
        str = ampm[amindex];
        return AM;
    } else if (str.indexOf(ampm[pmindex], 0, Qt::CaseInsensitive) == 0) {
        str = ampm[pmindex];
        return PM;
    } else if (str.count(space) == 0 && str.size() >= size) {
        return Neither;
    }
    size = qMin(size, str.size());

    bool broken[2] = {false, false};
    for (int i=0; i<size; ++i) {
        if (str.at(i) != space) {
            for (int j=0; j<2; ++j) {
                if (!broken[j]) {
                    int index = ampm[j].indexOf(str.at(i));
                    QDTPDEBUG << "looking for" << str.at(i)
                              << "in" << ampm[j] << "and got" << index;
                    if (index == -1) {
                        if (str.at(i).category() == QChar::Letter_Uppercase) {
                            index = ampm[j].indexOf(str.at(i).toLower());
                            QDTPDEBUG << "trying with" << str.at(i).toLower()
                                      << "in" << ampm[j] << "and got" << index;
                        } else if (str.at(i).category() == QChar::Letter_Lowercase) {
                            index = ampm[j].indexOf(str.at(i).toUpper());
                            QDTPDEBUG << "trying with" << str.at(i).toUpper()
                                      << "in" << ampm[j] << "and got" << index;
                        }
                        if (index == -1) {
                            broken[j] = true;
                            if (broken[amindex] && broken[pmindex]) {
                                QDTPDEBUG << str << "didn't make it";
                                return Neither;
                            }
                            continue;
                        } else {
                            str[i] = ampm[j].at(index); // fix case
                        }
                    }
                    ampm[j].remove(index, 1);
                }
            }
        }
    }
    if (!broken[pmindex] && !broken[amindex])
        return PossibleBoth;
    return (!broken[amindex] ? PossibleAM : PossiblePM);
}

int QDateTimeParser::maxChange(int index) const
{
    const SectionNode sn = sectionNode(index);
    switch (sn.type) {
        // Time. unit is msec
    case MSecSection: return 999;
    case SecondSection: return 59 * 1000;
    case MinuteSection: return 59 * 60 * 1000;
    case Hour24Section: case Hour12Section: return 59 * 60 * 60 * 1000;

        // Date. unit is day
    case DaySection: return 30;
    case MonthSection: return 365 - 31;
    case YearSection: return sn.count == 2
            ? 100 * 365
            : 9999 * 365;
    default: qFatal("%s passed to maxChange. This should never happen", sectionName(sectionType(index)).toLatin1().constData());
    }
    return -1;
}

QDateTimeParser::FieldInfo QDateTimeParser::fieldInfo(int index) const
{
    FieldInfo ret = 0;
    const SectionNode sn = sectionNode(index);
    const Section s = sn.type;
    switch (s) {
    case MSecSection:
    case SecondSection:
    case MinuteSection:
    case Hour24Section:
    case Hour12Section:
    case YearSection:
        ret |= Numeric;
        if (s != YearSection) {
            ret |= AllowPartial;
        }
        if (sn.count != 1) {
            ret |= FixedWidth;
        }
        break;
    case MonthSection:
    case DaySection:
        switch (sn.count) {
        case 2:
            ret |= FixedWidth;
        case 1: // fallthrough
            ret |= (Numeric|AllowPartial);
            break;
        case 3:
            ret |= FixedWidth;
            break;
        case 4:
            break;
        default: qFatal("This should not happen %d %s %d",
                        index, qPrintable(sectionName(sn.type)), sn.count);
            break;
        }
        break;
    case AmPmSection:
        ret |= FixedWidth;
        break;
    default: qFatal("This should not happen %d %s",
                    index, qPrintable(sectionName(sn.type)));
    }
    return ret;
}




QString QDateTimeParser::sectionFormat(int index) const
{
    const SectionNode sn = sectionNode(index);
    return sectionFormat(sn.type, sn.count);
}

QString QDateTimeParser::sectionFormat(Section s, int count) const
{
    QChar fillChar;
    switch (s) {
    case AmPmSection: return count == 1 ? QLatin1String("AP") : QLatin1String("ap");
    case MSecSection: fillChar = QLatin1Char('z'); break;
    case SecondSection: fillChar = QLatin1Char('s'); break;
    case MinuteSection: fillChar = QLatin1Char('m'); break;
    case Hour24Section: fillChar = QLatin1Char('H'); break;
    case Hour12Section: fillChar = QLatin1Char('h'); break;
    case DaySection: fillChar = QLatin1Char('d'); break;
    case MonthSection: fillChar = QLatin1Char('M'); break;
    case YearSection: fillChar = QLatin1Char('y'); break;
    default:
        qFatal("%s passed to sectionFormat. This should never happen", sectionName(s).toLatin1().constData());
        return QString();
    }
    Q_ASSERT(!fillChar.isNull());
    QString str;
    str.fill(fillChar, count);
    return str;
}

int QDateTimeParser::potentialValue(const QString &str, int min, int max, int index,
                                    const QVariant &currentValue, int insert) const
{
    const SectionNode sn = sectionNode(index);

    int size = sectionMaxSize(index);
    const int add = (sn.type == YearSection && sn.count == 2) ? currentValue.toDate().year() % 100 : 0;
    min -= add;
    max -= add; // doesn't matter if max is -1 checking for < 0

    const QString simplified = str.simplified();
    if (simplified.isEmpty()) {
        return min + add;
    } else if (simplified.toInt() > max && max >= 0) {
        return -1;
    }

    const int ret = potentialValueHelper(simplified, min, max, size, insert);
    if (ret == -1)
        return -1;
    return ret + add;
}

int QDateTimeParser::potentialValueHelper(const QString &str, int min, int max, int size, int insert) const
{
    if (str.size() == size) {
        const int val = str.toInt();
        if (val < min || val > max)
            return -1;
        QDTPDEBUG << "SUCCESS" << val << "is >=" << min << "and <=" << max;
        return val;
    }

    for (int i=0; i<=str.size(); ++i) {
        for (int j=0; j<10; ++j) {
            int ret = potentialValueHelper(str + QLatin1Char('0' + j), min, max, size, insert);
            if (ret != -1) {
                return ret;
            } else if (insert >= 0) {
                QString tmp = str;
                tmp.insert(insert, QLatin1Char('0' + j));
                ret = potentialValueHelper(tmp, min, max, size, insert);
                if (ret != -1)
                    return ret;
            }
        }
    }
    return -1;
}

#ifndef QT_NO_DATESTRING

QDateTimeParser::State QDateTimeParser::checkIntermediate(const QDateTime &dt, const QString &s) const
{
    const QLatin1Char space(' ');

    const QVariant minimum = getMinimum();
    const QVariant maximum = getMaximum();
    Q_ASSERT(dateTimeCompare(dt, minimum) < 0);

    bool found = false;
    for (int i=0; i<sectionNodes.size(); ++i) {
        const SectionNode &sn = sectionNodes.at(i);
        QString t = sectionText(s, i, sn.pos).toLower();
        if (t.contains(space) || t.size() < sectionMaxSize(i)) {
            found = true;
            switch (sn.type) {
            case AmPmSection:
                switch (findAmPm(t, i)) {
                case AM:
                case PM: qFatal("%d This should not happen", __LINE__); return Acceptable;
                case Neither: return Invalid;
                case PossibleAM:
                case PossiblePM:
                case PossibleBoth: {
                    const QVariant copy(dt.addSecs(12 * 60 * 60));
                    if (dateTimeCompare(copy, minimum) >= 0 && dateTimeCompare(copy, maximum) <= 0)
                        return Intermediate;
                    return Invalid; }
                }
            case MonthSection:
                if (sn.count >= 3) {
                    int tmp = dt.date().month();
                    // I know the first possible month makes the date too early
                    while ((tmp = findMonth(t, tmp + 1, sn.count)) != -1) {
                        const QVariant copy(dt.addMonths(tmp - dt.date().month()));
                        if (dateTimeCompare(copy, minimum) >= 0 && dateTimeCompare(copy, maximum) <= 0)
                            break;
                    }
                    if (tmp == -1) {
                        return Invalid;
                    }
                }
                // fallthrough

            default: {
                int toMin;
                int toMax;

                if (sn.type & TimeSectionMask) {
                    if (dt.daysTo(minimum.toDateTime()) != 0) {
                        QDTPDEBUG << "if (dt.daysTo(minimum.toDateTime()) != 0)" << dt.daysTo(minimum.toDateTime());
                        return Invalid;
                    }
                    toMin = dt.time().msecsTo(minimum.toDateTime().time());
                    if (dt.daysTo(maximum.toDateTime()) > 0) {
                        toMax = -1; // can't get to max
                    } else {
                        toMax = dt.time().msecsTo(maximum.toDateTime().time());
                    }
                } else {
                    toMin = dt.daysTo(minimum.toDateTime());
                    toMax = dt.daysTo(maximum.toDateTime());
                }
                int maxChange = QDateTimeParser::maxChange(i);
                if (toMin > maxChange) {
                    QDTPDEBUG << "invalid because toMin > maxChange" << toMin
                              << maxChange << t << dt << minimum.toDateTime();

                    return Invalid;
                } else if (toMax > maxChange) {
                    toMax = -1; // can't get to max
                }

                int min = getDigit(minimum, sn.type);
                int max = toMax != -1 ? getDigit(maximum, sn.type) : -1;
                int pos = cursorPosition() - sn.pos;
                if (pos < 0 || pos >= t.size())
                    pos = -1;
                int tmp = potentialValue(t, min, max, i, dt, pos);
                QDTPDEBUG << tmp << t << min << max << sectionName(sn.type)
                          << minimum.toDate() << maximum.toDate();
                if (tmp == -1) {
                    QDTPDEBUG << "invalid because potentialValue(" << t << min << max
                              << sectionName(sn.type) << "returned" << tmp << toMax;
                    return Invalid;
                } else if (tmp > absoluteMax(i)) {
                    QDTPDEBUG << "invalid because potentialValue(" << t << min << max
                              << sectionName(sn.type) << "returned a larger number than absoluteMax" << tmp << absoluteMax(i);
                    return Invalid;
                }

                QVariant var(dt);
                setDigit(var, sn.type, tmp);
                if (dateTimeCompare(var, maximum) > 0) {
                    QDTPDEBUG << "invalid because" << var.toString() << ">" << maximum.toString();
                    return Invalid;
                }
                break; }
            }
        }
    }
    return found ? Intermediate : Invalid;
}
#endif // QT_NO_DATESTRING

QString QDateTimeParser::sectionName(int s) const
{
    switch (s) {
    case QDateTimeParser::AmPmSection: return QLatin1String("AmPmSection");
    case QDateTimeParser::DaySection: return QLatin1String("DaySection");
    case QDateTimeParser::Hour24Section: return QLatin1String("Hour24Section");
    case QDateTimeParser::Hour12Section: return QLatin1String("Hour12Section");
    case QDateTimeParser::MSecSection: return QLatin1String("MSecSection");
    case QDateTimeParser::MinuteSection: return QLatin1String("MinuteSection");
    case QDateTimeParser::MonthSection: return QLatin1String("MonthSection");
    case QDateTimeParser::SecondSection: return QLatin1String("SecondSection");
    case QDateTimeParser::YearSection: return QLatin1String("YearSection");
    case QDateTimeParser::NoSection: return QLatin1String("NoSection");
    case QDateTimeParser::FirstSection: return QLatin1String("FirstSection");
    case QDateTimeParser::LastSection: return QLatin1String("LastSection");
    default: return QLatin1String("Unknown section ") + QString::number(s);
    }
}

QString QDateTimeParser::stateName(int s) const
{
    switch (s) {
    case Invalid: return QLatin1String("Invalid");
    case Intermediate: return QLatin1String("Intermediate");
    case Acceptable: return QLatin1String("Acceptable");
    default: return QLatin1String("Unknown state ") + QString::number(s);
    }
}

#ifndef QT_NO_DATESTRING
bool QDateTimeParser::fromString(const QString &text, QDate *date, QTime *time) const
{
    QVariant val;
    if (date && time) {
        val = QDateTime(QDate(1900, 1, 1), QDATETIMEEDIT_TIME_MIN);
    } else if (date) {
        val = QDate(1900, 1, 1);
    } else {
        Q_ASSERT(time);
        val = QDATETIMEEDIT_TIME_MIN;
    }
    const StateNode tmp = parse(text, val, false);
    if (tmp.state != Acceptable || tmp.conflicts) {
        return false;
    }
    if (time) {
        const QTime t = tmp.value.toTime();
        if (!t.isValid()) {
            return false;
        }
        *time = t;
    }

    if (date) {
        const QDate d = tmp.value.toDate();
        if (!d.isValid()) {
            return false;
        }
        *date = d;
    }
    return true;
}

QVariant QDateTimeParser::getMinimum() const
{
    switch (typ) {
    case QVariant::Time: return QDATETIMEEDIT_TIME_MIN;
    case QVariant::Date: return QDATETIMEEDIT_DATE_MIN;
    case QVariant::DateTime: return QDATETIMEEDIT_DATETIME_MIN;
    default: break;
    }
    return QVariant();
}
QVariant QDateTimeParser::getMaximum() const
{
    switch (typ) {
    case QVariant::Time: return QDATETIMEEDIT_TIME_MAX;
    case QVariant::Date: return QDATETIMEEDIT_DATE_MAX;
    case QVariant::DateTime: return QDATETIMEEDIT_DATETIME_MAX;
    default: break;
    }
    return QVariant();
}
#endif // QT_NO_DATESTRING

QString QDateTimeParser::getAmPmText(AmPm ap, Case cs) const
{
    if (ap == AmText) {
        return (cs == UpperCase ? QLatin1String("AM") : QLatin1String("am"));
    } else {
        return (cs == UpperCase ? QLatin1String("PM") : QLatin1String("pm"));
    }
}

/*
  \internal

  I give arg2 preference because arg1 is always a QDateTime.
*/

int QDateTimeParser::dateTimeCompare(const QVariant &arg1, const QVariant &arg2)
{
    if ((arg1.type() == QVariant::Time && arg2.type() == QVariant::Date)
        || (arg1.type() == QVariant::Date && arg2.type() == QVariant::Time)) {
        qWarning("QDateTimeParser::dateTimeCompare: Different types (%s vs. %s)",
                 arg1.typeName(), arg2.typeName());
    }
    switch (arg2.type()) {
    case QVariant::Date:
        if (arg1.toDate() == arg2.toDate()) {
            return 0;
        } else if (arg1.toDate() < arg2.toDate()) {
            return -1;
        } else {
            return 1;
        }
    case QVariant::Time:
        if (arg1.toTime() == arg2.toTime()) {
            return 0;
        } else if (arg1.toTime() < arg2.toTime()) {
            return -1;
        } else {
            return 1;
        }

    case QVariant::DateTime:
        if (arg1.toDateTime() == arg2.toDateTime()) {
            return 0;
        } else if (arg1.toDateTime() < arg2.toDateTime()) {
            return -1;
        } else {
            return 1;
        }
    default: break;
    }
    qWarning("QDateTimeParser::dateTimeCompare: Unsupported types (%s, %s)",
             arg1.typeName(), arg2.typeName());

    return -2;
}

bool operator==(const QDateTimeParser::SectionNode &s1, const QDateTimeParser::SectionNode &s2)
{
    return (s1.type == s2.type) && (s1.pos == s2.pos) && (s1.count == s2.count);
}


#endif // QT_BOOTSTRAPPED

---