///////////////////////////////////////////////////////////////////////////////

// Name:        src/common/datetimefmt.cpp

// Purpose:     wxDateTime formatting & parsing code

// Author:      Vadim Zeitlin

// Created:     11.05.99

// Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>

//              parts of code taken from sndcal library by Scott E. Lee:

//

//               Copyright 1993-1995, Scott E. Lee, all rights reserved.

//               Permission granted to use, copy, modify, distribute and sell

//               so long as the above copyright and this permission statement

//               are retained in all copies.

//

// Licence:     wxWindows licence

///////////////////////////////////////////////////////////////////////////////

// ============================================================================

// declarations

// ============================================================================

// ----------------------------------------------------------------------------

// headers

// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".

#include "wx/wxprec.h"

#if !defined(wxUSE_DATETIME) || wxUSE_DATETIME

#ifndef WX_PRECOMP

    #ifdef __WINDOWS__

        #include "wx/msw/wrapwin.h"

    #endif

    #include "wx/string.h"

    #include "wx/log.h"

    #include "wx/intl.h"

    #include "wx/stopwatch.h"           // for wxGetLocalTimeMillis()

    #include "wx/module.h"

    #include "wx/crt.h"

#endif // WX_PRECOMP

#include "wx/thread.h"

#include <ctype.h>

#ifdef __WINDOWS__

    #include <winnls.h>

    #include <locale.h>

#endif

#include "wx/datetime.h"

#include "wx/time.h"

#include "wx/uilocale.h"

// ============================================================================

// implementation of wxDateTime

// ============================================================================

// ----------------------------------------------------------------------------

// helpers shared between datetime.cpp and datetimefmt.cpp

// ----------------------------------------------------------------------------

extern void wxInitTm(struct tm& tm);

extern const tm* wxTryGetTm(tm& tmstruct, time_t t, const wxDateTime::TimeZone& tz);

extern wxString wxCallStrftime(const wxString& format, const tm* tm);

// ----------------------------------------------------------------------------

// constants (see also datetime.cpp)

// ----------------------------------------------------------------------------

static const int DAYS_PER_WEEK = 7;

static const int HOURS_PER_DAY = 24;

static const int SEC_PER_MIN = 60;

static const int MIN_PER_HOUR = 60;

// ----------------------------------------------------------------------------

// parsing helpers

// ----------------------------------------------------------------------------

namespace

{

// all the functions below taking non-const wxString::const_iterator p advance

// it until the end of the match

// Scans all digits (but no more than len) and returns the resulting number.

// Optionally writes number of digits scanned to numScannedDigits.

bool GetNumericToken(size_t len,

                     wxString::const_iterator& p,

                     const wxString::const_iterator& end,

                     unsigned long *number,

                     size_t *numScannedDigits = nullptr)

{

    size_t n = 1;

    wxString s;

    while ( p != end && wxIsdigit(*p) )

    {

        s += *p++;

        if ( len && ++n > len )

            break;

    }

    if (numScannedDigits)

    {

        *numScannedDigits = n - 1;

    }

    return !s.empty() && s.ToULong(number);

}

// scans all alphabetic characters and returns the resulting string

wxString

GetAlphaToken(wxString::const_iterator& p,

              const wxString::const_iterator& end)

{

    wxString s;

    while ( p != end && wxIsalpha(*p) )

    {

        s += *p++;

    }

    return s;

}

enum

{

    DateLang_English = 1,

    DateLang_Local   = 2

};

// return the month if the string is a month name or Inv_Month otherwise

//

// flags can contain wxDateTime::Name_Abbr/Name_Full or both of them and lang

// can be either DateLang_Local (default) to interpret string as a localized

// month name or DateLang_English to parse it as a standard English name or

// their combination to interpret it in any way

wxDateTime::Month

GetMonthFromName(wxString::const_iterator& p,

                 const wxString::const_iterator& end,

                 int flags,

                 int lang)

{

    const wxString::const_iterator pOrig = p;

    const wxString name = GetAlphaToken(p, end);

    if ( name.empty() )

        return wxDateTime::Inv_Month;

    wxDateTime::Month mon;

    for ( mon = wxDateTime::Jan; mon < wxDateTime::Inv_Month; wxNextMonth(mon) )

    {

        // case-insensitive comparison either one of or with both abbreviated

        // and not versions

        if ( flags & wxDateTime::Name_Full )

        {

            if ( lang & DateLang_English )

            {

                if ( name.CmpNoCase(wxDateTime::GetEnglishMonthName(mon,

                        wxDateTime::Name_Full)) == 0 )

                    break;

            }

            if ( lang & DateLang_Local )

            {

                if ( name.CmpNoCase(wxDateTime::GetMonthName(mon,

                        wxDateTime::Name_Full)) == 0 )

                    break;

            }

        }

        if ( flags & wxDateTime::Name_Abbr )

        {

            if ( lang & DateLang_English )

            {

                if ( name.CmpNoCase(wxDateTime::GetEnglishMonthName(mon,

                        wxDateTime::Name_Abbr)) == 0 )

                    break;

            }

            if ( lang & DateLang_Local )

            {

                // some locales (e.g. French one) use periods for the

                // abbreviated month names but it's never part of name so

                // compare it specially

                wxString nameAbbr = wxDateTime::GetMonthName(mon,

                    wxDateTime::Name_Abbr);

                const bool hasPeriod = *nameAbbr.rbegin() == '.';

                if ( hasPeriod )

                    nameAbbr.erase(nameAbbr.end() - 1);

                if ( name.CmpNoCase(nameAbbr) == 0 )

                {

                    if ( hasPeriod )

                    {

                        // skip trailing period if it was part of the match

                        if ( *p == '.' )

                            ++p;

                        else // no match as no matching period

                            continue;

                    }

                    break;

                }

            }

        }

    }

    if ( mon == wxDateTime::Inv_Month )

        p = pOrig;

    return mon;

}

// return the weekday if the string is a weekday name or Inv_WeekDay otherwise

//

// flags and lang parameters have the same meaning as for GetMonthFromName()

// above

wxDateTime::WeekDay

GetWeekDayFromName(wxString::const_iterator& p,

                   const wxString::const_iterator& end,

                   int flags, int lang)

{

    const wxString::const_iterator pOrig = p;

    const wxString name = GetAlphaToken(p, end);

    if ( name.empty() )

        return wxDateTime::Inv_WeekDay;

    wxDateTime::WeekDay wd;

    for ( wd = wxDateTime::Sun; wd < wxDateTime::Inv_WeekDay; wxNextWDay(wd) )

    {

        if ( flags & wxDateTime::Name_Full )

        {

            if ( lang & DateLang_English )

            {

                if ( name.CmpNoCase(wxDateTime::GetEnglishWeekDayName(wd,

                        wxDateTime::Name_Full)) == 0 )

                    break;

            }

            if ( lang & DateLang_Local )

            {

                if ( name.CmpNoCase(wxDateTime::GetWeekDayName(wd,

                        wxDateTime::Name_Full)) == 0 )

                    break;

            }

        }

        if ( flags & wxDateTime::Name_Abbr )

        {

            if ( lang & DateLang_English )

            {

                if ( name.CmpNoCase(wxDateTime::GetEnglishWeekDayName(wd,

                        wxDateTime::Name_Abbr)) == 0 )

                    break;

            }

            if ( lang & DateLang_Local )

            {

                if ( name.CmpNoCase(wxDateTime::GetWeekDayName(wd,

                        wxDateTime::Name_Abbr)) == 0 )

                    break;

            }

        }

    }

    if ( wd == wxDateTime::Inv_WeekDay )

        p = pOrig;

    return wd;

}

// parses string starting at given iterator using the specified format and,

// optionally, a fall back format (and optionally another one... but it stops

// there, really)

//

// if unsuccessful, returns invalid wxDateTime without changing p; otherwise

// advance p to the end of the match and returns wxDateTime containing the

// results of the parsing

wxDateTime

ParseFormatAt(wxString::const_iterator& p,

              const wxString::const_iterator& end,

              const wxString& fmt,

              const wxString& fmtAlt = wxString())

{

    const wxString str(p, end);

    wxString::const_iterator endParse;

    wxDateTime dt;

    // Use a default date outside of the DST period to avoid problems with

    // parsing the time differently depending on the today's date (which is used

    // as the fall back date if none is explicitly specified).

    static const wxDateTime dtDef(1, wxDateTime::Jan, 2012);

    if ( dt.ParseFormat(str, fmt, dtDef, &endParse) ||

            (!fmtAlt.empty() && dt.ParseFormat(str, fmtAlt, dtDef, &endParse)) )

    {

        p += endParse - str.begin();

    }

    //else: all formats failed

    return dt;

}

} // anonymous namespace

// ----------------------------------------------------------------------------

// wxDateTime to/from text representations

// ----------------------------------------------------------------------------

wxString wxDateTime::Format(const wxString& formatp, const TimeZone& tz) const

{

    wxCHECK_MSG( !formatp.empty(), wxEmptyString,

                 wxT("null format in wxDateTime::Format") );

    wxString format = formatp;

#ifdef __WXOSX__

#if wxUSE_INTL

    if ( format.Contains("%c") )

        format.Replace("%c", wxUILocale::GetCurrent().GetInfo(wxLOCALE_DATE_TIME_FMT));

    if ( format.Contains("%x") )

        format.Replace("%x", wxUILocale::GetCurrent().GetInfo(wxLOCALE_SHORT_DATE_FMT));

    if ( format.Contains("%X") )

        format.Replace("%X", wxUILocale::GetCurrent().GetInfo(wxLOCALE_TIME_FMT));

#endif // wxUSE_INTL

#endif // __WXOSX__

    // we have to use our own implementation if the date is out of range of

    // strftime()

#ifdef wxHAS_STRFTIME

    time_t time = GetTicks();

    bool canUseStrftime = time != (time_t)-1;

    bool isPercent = false;

    // We also can't use strftime() if we use non standard specifier: either

    // our own extension "%l" or one of C99/POSIX specifiers not supported when

    // using MinGW, see https://sourceforge.net/p/mingw-w64/bugs/793/

    for ( wxString::const_iterator p = format.begin();

          canUseStrftime && p != format.end();

          ++p )

    {

        if (!isPercent)

        {

            isPercent = *p == '%';

            continue;

        }

        isPercent = false;

        // set the default format

        switch ( (*p).GetValue() )

        {

            case 'l':

#ifdef __MINGW32__

            case 'F':

            case 'g':

            case 'G':

            case 'V':

            case 'z':

#endif // __MINGW32__

                canUseStrftime = false;

                break;

        }

    }

    if ( canUseStrftime )

    {

        // Try using strftime()

        struct tm tmstruct;

        if ( const tm* tm = wxTryGetTm(tmstruct, time, tz) )

        {

            return wxCallStrftime(format, tm);

        }

    }

    //else: use generic code below

#endif // wxHAS_STRFTIME

    // we only parse ANSI C format specifications here, no POSIX 2

    // complications, no GNU extensions but we do add support for a "%l" format

    // specifier allowing to get the number of milliseconds

    Tm tm = GetTm(tz);

    // used for calls to strftime() when we only deal with time

    struct tm tmTimeOnly;

    memset(&tmTimeOnly, 0, sizeof(tmTimeOnly));

    tmTimeOnly.tm_hour = tm.hour;

    tmTimeOnly.tm_min = tm.min;

    tmTimeOnly.tm_sec = tm.sec;

    tmTimeOnly.tm_mday = 1;         // any date will do, use 1976-01-01

    tmTimeOnly.tm_mon = 0;

    tmTimeOnly.tm_year = 76;

    tmTimeOnly.tm_isdst = 0;        // no DST, we adjust for tz ourselves

    wxString res, fmt;

    for ( wxString::const_iterator p = format.begin(); p != format.end(); ++p )

    {

        if ( *p != wxT('%') )

        {

            // copy as is

            res += *p;

            continue;

        }

        // set the default format

        switch ( (*++p).GetValue() )

        {

            case wxT('Y'):               // year has 4 digits

            case wxT('G'):               // (and ISO week year too)

            case wxT('z'):               // time zone as well

                fmt = wxT("%04d");

                break;

            case wxT('j'):               // day of year has 3 digits

            case wxT('l'):               // milliseconds have 3 digits

                fmt = wxT("%03d");

                break;

            case wxT('w'):               // week day as number has only one

                fmt = wxT("%d");

                break;

            default:

                // it's either another valid format specifier in which case

                // the format is "%02d" (for all the rest) or we have the

                // field width preceding the format in which case it will

                // override the default format anyhow

                fmt = wxT("%02d");

        }

        bool restart = true;

        while ( restart )

        {

            restart = false;

            // start of the format specification

            switch ( (*p).GetValue() )

            {

                case wxT('a'):       // a weekday name

                case wxT('A'):

                    // second parameter should be true for abbreviated names

                    res += GetWeekDayName(tm.GetWeekDay(),

                                          *p == wxT('a') ? Name_Abbr : Name_Full);

                    break;

                case wxT('b'):       // a month name

                case wxT('B'):

                    res += GetMonthName(tm.mon,

                                        *p == wxT('b') ? Name_Abbr : Name_Full);

                    break;

                case wxT('c'):       // locale default date and time  representation

                case wxT('x'):       // locale default date representation

#ifdef wxHAS_STRFTIME

                    //

                    // the problem: there is no way to know what do these format

                    // specifications correspond to for the current locale.

                    //

                    // the solution: use a hack and still use strftime(): first

                    // find the YEAR which is a year in the strftime() range (1970

                    // - 2038) whose Jan 1 falls on the same week day as the Jan 1

                    // of the real year. Then make a copy of the format and

                    // replace all occurrences of YEAR in it with some unique

                    // string not appearing anywhere else in it, then use

                    // strftime() to format the date in year YEAR and then replace

                    // YEAR back by the real year and the unique replacement

                    // string back with YEAR. Notice that "all occurrences of YEAR"

                    // means all occurrences of 4 digit as well as 2 digit form!

                    //

                    // the bugs: we assume that neither of %c nor %x contains any

                    // fields which may change between the YEAR and real year. For

                    // example, the week number (%U, %W) and the day number (%j)

                    // will change if one of these years is leap and the other one

                    // is not!

                    {

                        // find the YEAR: normally, for any year X, Jan 1 of the

                        // year X + 28 is the same weekday as Jan 1 of X (because

                        // the weekday advances by 1 for each normal X and by 2

                        // for each leap X, hence by 5 every 4 years or by 35

                        // which is 0 mod 7 every 28 years) but this rule breaks

                        // down if there are years between X and Y which are

                        // divisible by 4 but not leap (i.e. divisible by 100 but

                        // not 400), hence the correction.

                        int yearReal = GetYear(tz);

                        int mod28 = yearReal % 28;

                        // be careful to not go too far - we risk to leave the

                        // supported range

                        int year;

                        if ( mod28 < 10 )

                        {

                            year = 1988 + mod28;      // 1988 == 0 (mod 28)

                        }

                        else

                        {

                            year = 1970 + mod28 - 10; // 1970 == 10 (mod 28)

                        }

                        int nCentury = year / 100,

                            nCenturyReal = yearReal / 100;

                        // need to adjust for the years divisble by 400 which are

                        // not leap but are counted like leap ones if we just take

                        // the number of centuries in between for nLostWeekDays

                        int nLostWeekDays = (nCentury - nCenturyReal) -

                                            (nCentury / 4 - nCenturyReal / 4);

                        // we have to gain back the "lost" weekdays: note that the

                        // effect of this loop is to not do anything to

                        // nLostWeekDays (which we won't use any more), but to

                        // (indirectly) set the year correctly

                        while ( (nLostWeekDays % 7) != 0 )

                        {

                            nLostWeekDays += (year++ % 4) ? 1 : 2;

                        }

                        // finally move the year below 2000 so that the 2-digit

                        // year number can never match the month or day of the

                        // month when we do the replacements below

                        if ( year >= 2000 )

                            year -= 28;

                        wxASSERT_MSG( year >= 1970 && year < 2000,

                                      wxT("logic error in wxDateTime::Format") );

                        // use strftime() to format the same date but in supported

                        // year

                        //

                        // NB: we assume that strftime() doesn't check for the

                        //     date validity and will happily format the date

                        //     corresponding to Feb 29 of a non leap year (which

                        //     may happen if yearReal was leap and year is not)

                        struct tm tmAdjusted;

                        wxInitTm(tmAdjusted);

                        tmAdjusted.tm_hour = tm.hour;

                        tmAdjusted.tm_min = tm.min;

                        tmAdjusted.tm_sec = tm.sec;

                        tmAdjusted.tm_wday = tm.GetWeekDay();

                        tmAdjusted.tm_yday = GetDayOfYear();

                        tmAdjusted.tm_mday = tm.mday;

                        tmAdjusted.tm_mon = tm.mon;

                        tmAdjusted.tm_year = year - 1900;

                        tmAdjusted.tm_isdst = 0; // no DST, already adjusted

                        wxString str = wxCallStrftime(*p == wxT('c') ? wxT("%c")

                                                                  : wxT("%x"),

                                                    &tmAdjusted);

                        // now replace the replacement year with the real year:

                        // notice that we have to replace the 4 digit year with

                        // a unique string not appearing in strftime() output

                        // first to prevent the 2 digit year from matching any

                        // substring of the 4 digit year (but any day, month,

                        // hours or minutes components should be safe because

                        // they are never in 70-99 range)

                        wxString replacement("|");

                        while ( str.find(replacement) != wxString::npos )

                            replacement += '|';

                        str.Replace(wxString::Format("%d", year),

                                    replacement);

                        str.Replace(wxString::Format("%d", year % 100),

                                    wxString::Format("%d", yearReal % 100));

                        str.Replace(replacement,

                                    wxString::Format("%d", yearReal));

                        res += str;

                    }

#else // !wxHAS_STRFTIME

                    // Use "%m/%d/%y %H:%M:%S" format instead

                    res += wxString::Format(wxT("%02d/%02d/%04d %02d:%02d:%02d"),

                            tm.mon+1,tm.mday, tm.year, tm.hour, tm.min, tm.sec);

#endif // wxHAS_STRFTIME/!wxHAS_STRFTIME

                    break;

                case wxT('d'):       // day of a month (01-31)

                    res += wxString::Format(fmt, tm.mday);

                    break;

                case wxT('F'):      // ISO 8601 date

                    res += wxString::Format(wxT("%04d-%02d-%02d"), tm.year, tm.mon + 1, tm.mday);

                    break;

                case wxT('g'):      // 2-digit week-based year

                    res += wxString::Format(fmt, GetWeekBasedYear() % 100);

                    break;

                case wxT('G'):       // week-based year with century

                    res += wxString::Format(fmt, GetWeekBasedYear());

                    break;

                case wxT('H'):       // hour in 24h format (00-23)

                    res += wxString::Format(fmt, tm.hour);

                    break;

                case wxT('I'):       // hour in 12h format (01-12)

                    {

                        // 24h -> 12h, 0h -> 12h too

                        int hour12 = tm.hour > 12 ? tm.hour - 12

                                                  : tm.hour ? tm.hour : 12;

                        res += wxString::Format(fmt, hour12);

                    }

                    break;

                case wxT('j'):       // day of the year

                    res += wxString::Format(fmt, GetDayOfYear(tz));

                    break;

                case wxT('l'):       // milliseconds (NOT STANDARD)

                    res += wxString::Format(fmt, GetMillisecond(tz));

                    break;

                case wxT('m'):       // month as a number (01-12)

                    res += wxString::Format(fmt, tm.mon + 1);

                    break;

                case wxT('M'):       // minute as a decimal number (00-59)

                    res += wxString::Format(fmt, tm.min);

                    break;

                case wxT('p'):       // AM or PM string

#ifdef wxHAS_STRFTIME

                    res += wxCallStrftime(wxS("%p"), &tmTimeOnly);

#else // !wxHAS_STRFTIME

                    res += (tmTimeOnly.tm_hour > 12) ? wxT("pm") : wxT("am");

#endif // wxHAS_STRFTIME/!wxHAS_STRFTIME

                    break;

                case wxT('S'):       // second as a decimal number (00-61)

                    res += wxString::Format(fmt, tm.sec);

                    break;

                case wxT('U'):       // week number in the year (Sunday 1st week day)

                    res += wxString::Format(fmt, GetWeekOfYear(Sunday_First, tz));

                    break;

                case wxT('V'):       // ISO week number

                case wxT('W'):       // week number in the year (Monday 1st week day)

                    res += wxString::Format(fmt, GetWeekOfYear(Monday_First, tz));

                    break;

                case wxT('w'):       // weekday as a number (0-6), Sunday = 0

                    res += wxString::Format(fmt, tm.GetWeekDay());

                    break;

                // case wxT('x'): -- handled with "%c"

                case wxT('X'):       // locale default time representation

                    // just use strftime() to format the time for us

#ifdef wxHAS_STRFTIME

                    res += wxCallStrftime(wxS("%X"), &tmTimeOnly);

#else // !wxHAS_STRFTIME

                    res += wxString::Format(wxT("%02d:%02d:%02d"),tm.hour, tm.min, tm.sec);

#endif // wxHAS_STRFTIME/!wxHAS_STRFTIME

                    break;

                case wxT('y'):       // year without century (00-99)

                    res += wxString::Format(fmt, tm.year % 100);

                    break;

                case wxT('Y'):       // year with century

                    res += wxString::Format(fmt, tm.year);

                    break;

                case wxT('z'):       // time zone as [-+]HHMM

                    {

                        int ofs = tz.GetOffset();

                        // The time zone offset does not include the DST, but

                        // we do need to take it into account when showing the

                        // time in the local time zone to the user.

                        if ( ofs == -wxGetTimeZone() && IsDST() == 1 )

                        {

                            ofs += DST_OFFSET;

                        }

                        if ( ofs < 0 )

                        {

                            res += '-';

                            ofs = -ofs;

                        }

                        else

                        {

                            res += '+';

                        }

                        // Converts seconds to HHMM representation.

                        res += wxString::Format(fmt,

                                                100*(ofs/3600) + (ofs/60)%60);

                    }

                    break;

                case wxT('Z'):       // timezone name

#ifdef wxHAS_STRFTIME

                    res += wxCallStrftime(wxS("%Z"), &tmTimeOnly);

#endif

                    break;

                default:

                    // is it the format width?

                    for ( fmt.clear();

                          *p == wxT('-') || *p == wxT('+') ||

                            *p == wxT(' ') || wxIsdigit(*p);

                          ++p )

                    {

                        fmt += *p;

                    }

                    if ( !fmt.empty() )

                    {

                        // we've only got the flags and width so far in fmt

                        fmt.Prepend(wxT('%'));

                        fmt.Append(wxT('d'));

                        restart = true;

                        break;

                    }

                    // no, it wasn't the width

                    wxFAIL_MSG(wxT("unknown format specifier"));

                    wxFALLTHROUGH;

                case wxT('%'):       // a percent sign

                    res += *p;

                    break;

                case 0:             // the end of string

                    wxFAIL_MSG(wxT("missing format at the end of string"));

                    // just put the '%' which was the last char in format

                    res += wxT('%');

                    break;

            }

        }

    }

    return res;

}

bool

wxDateTime::ParseRFC822TimeZone(wxString::const_iterator *iterator,

                                const wxString::const_iterator &pEnd)

{

    wxString::const_iterator& p = *iterator;

    int offset = 0; // just to suppress warnings

    if ( *p == '-' || *p == '+' )

    {

        // the explicit offset given: it has the form of hhmm

        bool plus = *p++ == '+';

        if ( p == pEnd || !wxIsdigit(*p) ||

             p + 1 == pEnd || !wxIsdigit(*(p + 1)) )

            return false;

        // hours

        offset = MIN_PER_HOUR*(10*(*p - '0') + (*(p + 1) - '0'));

        p += 2;

        if ( p == pEnd || !wxIsdigit(*p) ||

             p + 1 == pEnd || !wxIsdigit(*(p + 1)) )

            return false;

        // minutes

        offset += 10*(*p - '0') + (*(p + 1) - '0');

        if ( !plus )

            offset = -offset;

        p += 2;

    }

    else // not numeric

    {

        // the symbolic timezone given: may be either military timezone or one

        // of standard abbreviations

        if ( p + 1 == pEnd )

        {

            // military: Z = UTC, J unused, A = -1, ..., Y = +12

            static const int offsets[26] =

            {

                //A  B   C   D   E   F   G   H   I    J    K    L    M

                -1, -2, -3, -4, -5, -6, -7, -8, -9,   0, -10, -11, -12,

                //N  O   P   R   Q   S   T   U   V    W    Z    Y    Z

                +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0

            };

            if ( *p < wxT('A') || *p > wxT('Z') || *p == wxT('J') )

                return false;

            offset = offsets[*p++ - 'A'];

        }

        else

        {

            // TZ is max 3 characters long; we do not want to consume

            // characters beyond that.

            wxString::const_iterator pPlusMax3 = pEnd;

            if ( p != pEnd && p + 1 != pEnd && p + 2 != pEnd && p + 3 != pEnd )

                pPlusMax3 = p + 3;

            // abbreviation

            const wxString tz(p, pPlusMax3);

            if ( tz == wxT("UT") || tz == wxT("UTC") || tz == wxT("GMT") )

                offset = 0;

            else if ( tz == wxT("AST") )

                offset = AST - GMT0;

            else if ( tz == wxT("ADT") )

                offset = ADT - GMT0;

            else if ( tz == wxT("EST") )

                offset = EST - GMT0;

            else if ( tz == wxT("EDT") )

                offset = EDT - GMT0;

            else if ( tz == wxT("CST") )

                offset = CST - GMT0;

            else if ( tz == wxT("CDT") )

                offset = CDT - GMT0;

            else if ( tz == wxT("MST") )

                offset = MST - GMT0;

            else if ( tz == wxT("MDT") )

                offset = MDT - GMT0;

            else if ( tz == wxT("PST") )

                offset = PST - GMT0;

            else if ( tz == wxT("PDT") )

                offset = PDT - GMT0;

            else

                return false;

            p += tz.length();

        }

        // make it minutes

        offset *= MIN_PER_HOUR;

    }

    // As always, dealing with the time zone is the most interesting part: we

    // can't just use MakeFromTimeZone() here because it wouldn't handle the

    // DST correctly because the TZ specified in the string is DST-invariant

    // and so we have to manually shift to the UTC first and then convert to

    // the local TZ.

    *this -= wxTimeSpan::Minutes(offset);

    MakeFromUTC();

    return true;

}

// this function parses a string in (strict) RFC 822 format: see the section 5

// of the RFC for the detailed description, but briefly it's something of the

// form "Sat, 18 Dec 1999 00:48:30 +0100"

//

// this function is "strict" by design - it must reject anything except true

// RFC822 time specs.

bool

wxDateTime::ParseRfc822Date(const wxString& originalDate, wxString::const_iterator *end)

{

    // This implementation implicitly relies on the assumption that the

    // input never ends prematurely (all dereferencing of *p assumes that).

    // To avoid iterating beyond the end of buffer, let us append 32 zero bytes

    // to the date string (32 being the length of a typical RFC822 timestamp).

    const wxString date(originalDate + wxString(32, '\0'));

    const wxString::const_iterator pEnd = date.begin() + originalDate.length();

    wxString::const_iterator p = date.begin();

    // 1. week day (optional)

    // if there is a week day present, it must be separated

    // by a comma at position [3].

    if ( date.length() > 3 && date[3] == ',' )

    {

        const wxDateTime::WeekDay

            wd = GetWeekDayFromName(p, pEnd, Name_Abbr, DateLang_English);

        if ( wd == Inv_WeekDay )

            return false;

        //else: ignore week day for now, we could also check that it really

        //      corresponds to the specified date

        // 2. separating comma

        if ( *p++ != ',' || *p++ != ' ' )

            return false;

    }

    // 3. day number

    if ( !wxIsdigit(*p) )

        return false;

    wxDateTime_t day = (wxDateTime_t)(*p++ - '0');

    if ( wxIsdigit(*p) )

    {

        day *= 10;

        day = (wxDateTime_t)(day + (*p++ - '0'));

    }

    if ( *p++ != ' ' )

        return false;

    // 4. month name

    const Month mon = GetMonthFromName(p, pEnd, Name_Abbr, DateLang_English);

    if ( mon == Inv_Month )

        return false;

    if ( *p++ != ' ' )

        return false;

    // 5. year

    if ( !wxIsdigit(*p) )

        return false;

    int year = *p++ - '0';

    if ( !wxIsdigit(*p) ) // should have at least 2 digits in the year

        return false;