src/common/datetimefmt.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/datetimefmt.cpp
   3 // Purpose:     wxDateTime formatting & parsing code
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     11.05.99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 //              parts of code taken from sndcal library by Scott E. Lee:
  10 //
  11 //               Copyright 1993-1995, Scott E. Lee, all rights reserved.
  12 //               Permission granted to use, copy, modify, distribute and sell
  13 //               so long as the above copyright and this permission statement
  14 //               are retained in all copies.
  15 //
  16 // Licence:     wxWindows licence
  17 ///////////////////////////////////////////////////////////////////////////////
  18
  19 // ============================================================================
  20 // declarations
  21 // ============================================================================
  22
  23 // ----------------------------------------------------------------------------
  24 // headers
  25 // ----------------------------------------------------------------------------
  26
  27 // For compilers that support precompilation, includes "wx.h".
  28 #include "wx/wxprec.h"
  29
  30 #ifdef __BORLANDC__
  31     #pragma hdrstop
  32 #endif
  33
  34 #if !defined(wxUSE_DATETIME) || wxUSE_DATETIME
  35
  36 #ifndef WX_PRECOMP
  37     #ifdef __WXMSW__
  38         #include "wx/msw/wrapwin.h"
  39     #endif
  40     #include "wx/string.h"
  41     #include "wx/log.h"
  42     #include "wx/intl.h"
  43     #include "wx/stopwatch.h"           // for wxGetLocalTimeMillis()
  44     #include "wx/module.h"
  45     #include "wx/crt.h"
  46 #endif // WX_PRECOMP
  47
  48 #include "wx/thread.h"
  49
  50 #include <ctype.h>
  51
  52 #ifdef __WINDOWS__
  53     #include <winnls.h>
  54     #ifndef __WXWINCE__
  55         #include <locale.h>
  56     #endif
  57 #endif
  58
  59 #include "wx/datetime.h"
  60
  61 // ============================================================================
  62 // implementation of wxDateTime
  63 // ============================================================================
  64
  65 // ----------------------------------------------------------------------------
  66 // helpers shared between datetime.cpp and datetimefmt.cpp
  67 // ----------------------------------------------------------------------------
  68
  69 extern void InitTm(struct tm& tm);
  70
  71 extern int GetTimeZone();
  72
  73 extern wxString CallStrftime(const wxString& format, const tm* tm);
  74
  75 // ----------------------------------------------------------------------------
  76 // constants (see also datetime.cpp)
  77 // ----------------------------------------------------------------------------
  78
  79 static const int DAYS_PER_WEEK = 7;
  80
  81 static const int HOURS_PER_DAY = 24;
  82
  83 static const int SEC_PER_MIN = 60;
  84
  85 static const int MIN_PER_HOUR = 60;
  86
  87 // ----------------------------------------------------------------------------
  88 // parsing helpers
  89 // ----------------------------------------------------------------------------
  90
  91 namespace
  92 {
  93
  94 // all the functions below taking non-const wxString::const_iterator p advance
  95 // it until the end of the match
  96
  97 // scans all digits (but no more than len) and returns the resulting number
  98 bool GetNumericToken(size_t len,
  99                      wxString::const_iterator& p,
 100                      const wxString::const_iterator& end,
 101                      unsigned long *number)
 102 {
 103     size_t n = 1;
 104     wxString s;
 105     while ( p != end && wxIsdigit(*p) )
 106     {
 107         s += *p++;
 108
 109         if ( len && ++n > len )
 110             break;
 111     }
 112
 113     return !s.empty() && s.ToULong(number);
 114 }
 115
 116 // scans all alphabetic characters and returns the resulting string
 117 wxString
 118 GetAlphaToken(wxString::const_iterator& p,
 119               const wxString::const_iterator& end)
 120 {
 121     wxString s;
 122     while ( p != end && wxIsalpha(*p) )
 123     {
 124         s += *p++;
 125     }
 126
 127     return s;
 128 }
 129
 130 enum
 131 {
 132     DateLang_English = 1,
 133     DateLang_Local   = 2
 134 };
 135
 136 // return the month if the string is a month name or Inv_Month otherwise
 137 //
 138 // flags can contain wxDateTime::Name_Abbr/Name_Full or both of them and lang
 139 // can be either DateLang_Local (default) to interpret string as a localized
 140 // month name or DateLang_English to parse it as a standard English name or
 141 // their combination to interpret it in any way
 142 wxDateTime::Month
 143 GetMonthFromName(wxString::const_iterator& p,
 144                  const wxString::const_iterator& end,
 145                  int flags,
 146                  int lang)
 147 {
 148     const wxString::const_iterator pOrig = p;
 149     const wxString name = GetAlphaToken(p, end);
 150     if ( name.empty() )
 151         return wxDateTime::Inv_Month;
 152
 153     wxDateTime::Month mon;
 154     for ( mon = wxDateTime::Jan; mon < wxDateTime::Inv_Month; wxNextMonth(mon) )
 155     {
 156         // case-insensitive comparison either one of or with both abbreviated
 157         // and not versions
 158         if ( flags & wxDateTime::Name_Full )
 159         {
 160             if ( lang & DateLang_English )
 161             {
 162                 if ( name.CmpNoCase(wxDateTime::GetEnglishMonthName(mon,
 163                         wxDateTime::Name_Full)) == 0 )
 164                     break;
 165             }
 166
 167             if ( lang & DateLang_Local )
 168             {
 169                 if ( name.CmpNoCase(wxDateTime::GetMonthName(mon,
 170                         wxDateTime::Name_Full)) == 0 )
 171                     break;
 172             }
 173         }
 174
 175         if ( flags & wxDateTime::Name_Abbr )
 176         {
 177             if ( lang & DateLang_English )
 178             {
 179                 if ( name.CmpNoCase(wxDateTime::GetEnglishMonthName(mon,
 180                         wxDateTime::Name_Abbr)) == 0 )
 181                     break;
 182             }
 183
 184             if ( lang & DateLang_Local )
 185             {
 186                 // some locales (e.g. French one) use periods for the
 187                 // abbreviated month names but it's never part of name so
 188                 // compare it specially
 189                 wxString nameAbbr = wxDateTime::GetMonthName(mon,
 190                     wxDateTime::Name_Abbr);
 191                 const bool hasPeriod = *nameAbbr.rbegin() == '.';
 192                 if ( hasPeriod )
 193                     nameAbbr.erase(nameAbbr.end() - 1);
 194
 195                 if ( name.CmpNoCase(nameAbbr) == 0 )
 196                 {
 197                     if ( hasPeriod )
 198                     {
 199                         // skip trailing period if it was part of the match
 200                         if ( *p == '.' )
 201                             ++p;
 202                         else // no match as no matching period
 203                             continue;
 204                     }
 205
 206                     break;
 207                 }
 208             }
 209         }
 210     }
 211
 212     if ( mon == wxDateTime::Inv_Month )
 213         p = pOrig;
 214
 215     return mon;
 216 }
 217
 218 // return the weekday if the string is a weekday name or Inv_WeekDay otherwise
 219 //
 220 // flags and lang parameters have the same meaning as for GetMonthFromName()
 221 // above
 222 wxDateTime::WeekDay
 223 GetWeekDayFromName(wxString::const_iterator& p,
 224                    const wxString::const_iterator& end,
 225                    int flags, int lang)
 226 {
 227     const wxString::const_iterator pOrig = p;
 228     const wxString name = GetAlphaToken(p, end);
 229     if ( name.empty() )
 230         return wxDateTime::Inv_WeekDay;
 231
 232     wxDateTime::WeekDay wd;
 233     for ( wd = wxDateTime::Sun; wd < wxDateTime::Inv_WeekDay; wxNextWDay(wd) )
 234     {
 235         if ( flags & wxDateTime::Name_Full )
 236         {
 237             if ( lang & DateLang_English )
 238             {
 239                 if ( name.CmpNoCase(wxDateTime::GetEnglishWeekDayName(wd,
 240                         wxDateTime::Name_Full)) == 0 )
 241                     break;
 242             }
 243
 244             if ( lang & DateLang_Local )
 245             {
 246                 if ( name.CmpNoCase(wxDateTime::GetWeekDayName(wd,
 247                         wxDateTime::Name_Full)) == 0 )
 248                     break;
 249             }
 250         }
 251
 252         if ( flags & wxDateTime::Name_Abbr )
 253         {
 254             if ( lang & DateLang_English )
 255             {
 256                 if ( name.CmpNoCase(wxDateTime::GetEnglishWeekDayName(wd,
 257                         wxDateTime::Name_Abbr)) == 0 )
 258                     break;
 259             }
 260
 261             if ( lang & DateLang_Local )
 262             {
 263                 if ( name.CmpNoCase(wxDateTime::GetWeekDayName(wd,
 264                         wxDateTime::Name_Abbr)) == 0 )
 265                     break;
 266             }
 267         }
 268     }
 269
 270     if ( wd == wxDateTime::Inv_WeekDay )
 271         p = pOrig;
 272
 273     return wd;
 274 }
 275
 276 // parses string starting at given iterator using the specified format and,
 277 // optionally, a fall back format (and optionally another one... but it stops
 278 // there, really)
 279 //
 280 // if unsuccessful, returns invalid wxDateTime without changing p; otherwise
 281 // advance p to the end of the match and returns wxDateTime containing the
 282 // results of the parsing
 283 wxDateTime
 284 ParseFormatAt(wxString::const_iterator& p,
 285               const wxString::const_iterator& end,
 286               const wxString& fmt,
 287               // FIXME-VC6: using wxString() instead of wxEmptyString in the
 288               //            line below results in error C2062: type 'class
 289               //            wxString (__cdecl *)(void)' unexpected
 290               const wxString& fmtAlt = wxEmptyString)
 291 {
 292     const wxString str(p, end);
 293     wxString::const_iterator endParse;
 294     wxDateTime dt;
 295     if ( dt.ParseFormat(str, fmt, &endParse) ||
 296             (!fmtAlt.empty() && dt.ParseFormat(str, fmtAlt, &endParse)) )
 297     {
 298         p += endParse - str.begin();
 299     }
 300     //else: all formats failed
 301
 302     return dt;
 303 }
 304
 305 } // anonymous namespace
 306
 307 // ----------------------------------------------------------------------------
 308 // wxDateTime to/from text representations
 309 // ----------------------------------------------------------------------------
 310
 311 wxString wxDateTime::Format(const wxString& formatp, const TimeZone& tz) const
 312 {
 313     wxCHECK_MSG( !formatp.empty(), wxEmptyString,
 314                  _T("NULL format in wxDateTime::Format") );
 315
 316     wxString format = formatp;
 317 #ifdef __WXOSX__
 318     format.Replace("%c",wxLocale::GetInfo(wxLOCALE_DATE_TIME_FMT));
 319     format.Replace("%x",wxLocale::GetInfo(wxLOCALE_SHORT_DATE_FMT));
 320     format.Replace("%X",wxLocale::GetInfo(wxLOCALE_TIME_FMT));
 321 #endif
 322     // we have to use our own implementation if the date is out of range of
 323     // strftime() or if we use non standard specificators
 324 #ifdef wxHAS_STRFTIME
 325     time_t time = GetTicks();
 326
 327     if ( (time != (time_t)-1) && !wxStrstr(format, _T("%l")) )
 328     {
 329         // use strftime()
 330         struct tm tmstruct;
 331         struct tm *tm;
 332         if ( tz.GetOffset() == -GetTimeZone() )
 333         {
 334             // we are working with local time
 335             tm = wxLocaltime_r(&time, &tmstruct);
 336
 337             // should never happen
 338             wxCHECK_MSG( tm, wxEmptyString, _T("wxLocaltime_r() failed") );
 339         }
 340         else
 341         {
 342             time += (int)tz.GetOffset();
 343
 344 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
 345             int time2 = (int) time;
 346             if ( time2 >= 0 )
 347 #else
 348             if ( time >= 0 )
 349 #endif
 350             {
 351                 tm = wxGmtime_r(&time, &tmstruct);
 352
 353                 // should never happen
 354                 wxCHECK_MSG( tm, wxEmptyString, _T("wxGmtime_r() failed") );
 355             }
 356             else
 357             {
 358                 tm = (struct tm *)NULL;
 359             }
 360         }
 361
 362         if ( tm )
 363         {
 364             return CallStrftime(format, tm);
 365         }
 366     }
 367     //else: use generic code below
 368 #endif // wxHAS_STRFTIME
 369
 370     // we only parse ANSI C format specifications here, no POSIX 2
 371     // complications, no GNU extensions but we do add support for a "%l" format
 372     // specifier allowing to get the number of milliseconds
 373     Tm tm = GetTm(tz);
 374
 375     // used for calls to strftime() when we only deal with time
 376     struct tm tmTimeOnly;
 377     tmTimeOnly.tm_hour = tm.hour;
 378     tmTimeOnly.tm_min = tm.min;
 379     tmTimeOnly.tm_sec = tm.sec;
 380     tmTimeOnly.tm_wday = 0;
 381     tmTimeOnly.tm_yday = 0;
 382     tmTimeOnly.tm_mday = 1;         // any date will do
 383     tmTimeOnly.tm_mon = 0;
 384     tmTimeOnly.tm_year = 76;
 385     tmTimeOnly.tm_isdst = 0;        // no DST, we adjust for tz ourselves
 386
 387     wxString tmp, res, fmt;
 388     for ( wxString::const_iterator p = format.begin(); p != format.end(); ++p )
 389     {
 390         if ( *p != _T('%') )
 391         {
 392             // copy as is
 393             res += *p;
 394
 395             continue;
 396         }
 397
 398         // set the default format
 399         switch ( (*++p).GetValue() )
 400         {
 401             case _T('Y'):               // year has 4 digits
 402                 fmt = _T("%04d");
 403                 break;
 404
 405             case _T('j'):               // day of year has 3 digits
 406             case _T('l'):               // milliseconds have 3 digits
 407                 fmt = _T("%03d");
 408                 break;
 409
 410             case _T('w'):               // week day as number has only one
 411                 fmt = _T("%d");
 412                 break;
 413
 414             default:
 415                 // it's either another valid format specifier in which case
 416                 // the format is "%02d" (for all the rest) or we have the
 417                 // field width preceding the format in which case it will
 418                 // override the default format anyhow
 419                 fmt = _T("%02d");
 420         }
 421
 422         bool restart = true;
 423         while ( restart )
 424         {
 425             restart = false;
 426
 427             // start of the format specification
 428             switch ( (*p).GetValue() )
 429             {
 430                 case _T('a'):       // a weekday name
 431                 case _T('A'):
 432                     // second parameter should be true for abbreviated names
 433                     res += GetWeekDayName(tm.GetWeekDay(),
 434                                           *p == _T('a') ? Name_Abbr : Name_Full);
 435                     break;
 436
 437                 case _T('b'):       // a month name
 438                 case _T('B'):
 439                     res += GetMonthName(tm.mon,
 440                                         *p == _T('b') ? Name_Abbr : Name_Full);
 441                     break;
 442
 443                 case _T('c'):       // locale default date and time  representation
 444                 case _T('x'):       // locale default date representation
 445 #ifdef wxHAS_STRFTIME
 446                     //
 447                     // the problem: there is no way to know what do these format
 448                     // specifications correspond to for the current locale.
 449                     //
 450                     // the solution: use a hack and still use strftime(): first
 451                     // find the YEAR which is a year in the strftime() range (1970
 452                     // - 2038) whose Jan 1 falls on the same week day as the Jan 1
 453                     // of the real year. Then make a copy of the format and
 454                     // replace all occurrences of YEAR in it with some unique
 455                     // string not appearing anywhere else in it, then use
 456                     // strftime() to format the date in year YEAR and then replace
 457                     // YEAR back by the real year and the unique replacement
 458                     // string back with YEAR. Notice that "all occurrences of YEAR"
 459                     // means all occurrences of 4 digit as well as 2 digit form!
 460                     //
 461                     // the bugs: we assume that neither of %c nor %x contains any
 462                     // fields which may change between the YEAR and real year. For
 463                     // example, the week number (%U, %W) and the day number (%j)
 464                     // will change if one of these years is leap and the other one
 465                     // is not!
 466                     {
 467                         // find the YEAR: normally, for any year X, Jan 1 of the
 468                         // year X + 28 is the same weekday as Jan 1 of X (because
 469                         // the weekday advances by 1 for each normal X and by 2
 470                         // for each leap X, hence by 5 every 4 years or by 35
 471                         // which is 0 mod 7 every 28 years) but this rule breaks
 472                         // down if there are years between X and Y which are
 473                         // divisible by 4 but not leap (i.e. divisible by 100 but
 474                         // not 400), hence the correction.
 475
 476                         int yearReal = GetYear(tz);
 477                         int mod28 = yearReal % 28;
 478
 479                         // be careful to not go too far - we risk to leave the
 480                         // supported range
 481                         int year;
 482                         if ( mod28 < 10 )
 483                         {
 484                             year = 1988 + mod28;      // 1988 == 0 (mod 28)
 485                         }
 486                         else
 487                         {
 488                             year = 1970 + mod28 - 10; // 1970 == 10 (mod 28)
 489                         }
 490
 491                         int nCentury = year / 100,
 492                             nCenturyReal = yearReal / 100;
 493
 494                         // need to adjust for the years divisble by 400 which are
 495                         // not leap but are counted like leap ones if we just take
 496                         // the number of centuries in between for nLostWeekDays
 497                         int nLostWeekDays = (nCentury - nCenturyReal) -
 498                                             (nCentury / 4 - nCenturyReal / 4);
 499
 500                         // we have to gain back the "lost" weekdays: note that the
 501                         // effect of this loop is to not do anything to
 502                         // nLostWeekDays (which we won't use any more), but to
 503                         // (indirectly) set the year correctly
 504                         while ( (nLostWeekDays % 7) != 0 )
 505                         {
 506                             nLostWeekDays += year++ % 4 ? 1 : 2;
 507                         }
 508
 509                         // finally move the year below 2000 so that the 2-digit
 510                         // year number can never match the month or day of the
 511                         // month when we do the replacements below
 512                         if ( year >= 2000 )
 513                             year -= 28;
 514
 515                         wxASSERT_MSG( year >= 1970 && year < 2000,
 516                                       _T("logic error in wxDateTime::Format") );
 517
 518
 519                         // use strftime() to format the same date but in supported
 520                         // year
 521                         //
 522                         // NB: we assume that strftime() doesn't check for the
 523                         //     date validity and will happily format the date
 524                         //     corresponding to Feb 29 of a non leap year (which
 525                         //     may happen if yearReal was leap and year is not)
 526                         struct tm tmAdjusted;
 527                         InitTm(tmAdjusted);
 528                         tmAdjusted.tm_hour = tm.hour;
 529                         tmAdjusted.tm_min = tm.min;
 530                         tmAdjusted.tm_sec = tm.sec;
 531                         tmAdjusted.tm_wday = tm.GetWeekDay();
 532                         tmAdjusted.tm_yday = GetDayOfYear();
 533                         tmAdjusted.tm_mday = tm.mday;
 534                         tmAdjusted.tm_mon = tm.mon;
 535                         tmAdjusted.tm_year = year - 1900;
 536                         tmAdjusted.tm_isdst = 0; // no DST, already adjusted
 537                         wxString str = CallStrftime(*p == _T('c') ? _T("%c")
 538                                                                   : _T("%x"),
 539                                                     &tmAdjusted);
 540
 541                         // now replace the replacement year with the real year:
 542                         // notice that we have to replace the 4 digit year with
 543                         // a unique string not appearing in strftime() output
 544                         // first to prevent the 2 digit year from matching any
 545                         // substring of the 4 digit year (but any day, month,
 546                         // hours or minutes components should be safe because
 547                         // they are never in 70-99 range)
 548                         wxString replacement("|");
 549                         while ( str.find(replacement) != wxString::npos )
 550                             replacement += '|';
 551
 552                         str.Replace(wxString::Format("%d", year),
 553                                     replacement);
 554                         str.Replace(wxString::Format("%d", year % 100),
 555                                     wxString::Format("%d", yearReal % 100));
 556                         str.Replace(replacement,
 557                                     wxString::Format("%d", yearReal));
 558
 559                         res += str;
 560                     }
 561 #else // !wxHAS_STRFTIME
 562                     // Use "%m/%d/%y %H:%M:%S" format instead
 563                     res += wxString::Format(wxT("%02d/%02d/%04d %02d:%02d:%02d"),
 564                             tm.mon+1,tm.mday, tm.year, tm.hour, tm.min, tm.sec);
 565 #endif // wxHAS_STRFTIME/!wxHAS_STRFTIME
 566                     break;
 567
 568                 case _T('d'):       // day of a month (01-31)
 569                     res += wxString::Format(fmt, tm.mday);
 570                     break;
 571
 572                 case _T('H'):       // hour in 24h format (00-23)
 573                     res += wxString::Format(fmt, tm.hour);
 574                     break;
 575
 576                 case _T('I'):       // hour in 12h format (01-12)
 577                     {
 578                         // 24h -> 12h, 0h -> 12h too
 579                         int hour12 = tm.hour > 12 ? tm.hour - 12
 580                                                   : tm.hour ? tm.hour : 12;
 581                         res += wxString::Format(fmt, hour12);
 582                     }
 583                     break;
 584
 585                 case _T('j'):       // day of the year
 586                     res += wxString::Format(fmt, GetDayOfYear(tz));
 587                     break;
 588
 589                 case _T('l'):       // milliseconds (NOT STANDARD)
 590                     res += wxString::Format(fmt, GetMillisecond(tz));
 591                     break;
 592
 593                 case _T('m'):       // month as a number (01-12)
 594                     res += wxString::Format(fmt, tm.mon + 1);
 595                     break;
 596
 597                 case _T('M'):       // minute as a decimal number (00-59)
 598                     res += wxString::Format(fmt, tm.min);
 599                     break;
 600
 601                 case _T('p'):       // AM or PM string
 602 #ifdef wxHAS_STRFTIME
 603                     res += CallStrftime(_T("%p"), &tmTimeOnly);
 604 #else // !wxHAS_STRFTIME
 605                     res += (tmTimeOnly.tm_hour > 12) ? wxT("pm") : wxT("am");
 606 #endif // wxHAS_STRFTIME/!wxHAS_STRFTIME
 607                     break;
 608
 609                 case _T('S'):       // second as a decimal number (00-61)
 610                     res += wxString::Format(fmt, tm.sec);
 611                     break;
 612
 613                 case _T('U'):       // week number in the year (Sunday 1st week day)
 614                     res += wxString::Format(fmt, GetWeekOfYear(Sunday_First, tz));
 615                     break;
 616
 617                 case _T('W'):       // week number in the year (Monday 1st week day)
 618                     res += wxString::Format(fmt, GetWeekOfYear(Monday_First, tz));
 619                     break;
 620
 621                 case _T('w'):       // weekday as a number (0-6), Sunday = 0
 622                     res += wxString::Format(fmt, tm.GetWeekDay());
 623                     break;
 624
 625                 // case _T('x'): -- handled with "%c"
 626
 627                 case _T('X'):       // locale default time representation
 628                     // just use strftime() to format the time for us
 629 #ifdef wxHAS_STRFTIME
 630                     res += CallStrftime(_T("%X"), &tmTimeOnly);
 631 #else // !wxHAS_STRFTIME
 632                     res += wxString::Format(wxT("%02d:%02d:%02d"),tm.hour, tm.min, tm.sec);
 633 #endif // wxHAS_STRFTIME/!wxHAS_STRFTIME
 634                     break;
 635
 636                 case _T('y'):       // year without century (00-99)
 637                     res += wxString::Format(fmt, tm.year % 100);
 638                     break;
 639
 640                 case _T('Y'):       // year with century
 641                     res += wxString::Format(fmt, tm.year);
 642                     break;
 643
 644                 case _T('Z'):       // timezone name
 645 #ifdef wxHAS_STRFTIME
 646                     res += CallStrftime(_T("%Z"), &tmTimeOnly);
 647 #endif
 648                     break;
 649
 650                 default:
 651                     // is it the format width?
 652                     fmt.Empty();
 653                     while ( *p == _T('-') || *p == _T('+') ||
 654                             *p == _T(' ') || wxIsdigit(*p) )
 655                     {
 656                         fmt += *p;
 657                     }
 658
 659                     if ( !fmt.empty() )
 660                     {
 661                         // we've only got the flags and width so far in fmt
 662                         fmt.Prepend(_T('%'));
 663                         fmt.Append(_T('d'));
 664
 665                         restart = true;
 666
 667                         break;
 668                     }
 669
 670                     // no, it wasn't the width
 671                     wxFAIL_MSG(_T("unknown format specificator"));
 672
 673                     // fall through and just copy it nevertheless
 674
 675                 case _T('%'):       // a percent sign
 676                     res += *p;
 677                     break;
 678
 679                 case 0:             // the end of string
 680                     wxFAIL_MSG(_T("missing format at the end of string"));
 681
 682                     // just put the '%' which was the last char in format
 683                     res += _T('%');
 684                     break;
 685             }
 686         }
 687     }
 688
 689     return res;
 690 }
 691
 692 // this function parses a string in (strict) RFC 822 format: see the section 5
 693 // of the RFC for the detailed description, but briefly it's something of the
 694 // form "Sat, 18 Dec 1999 00:48:30 +0100"
 695 //
 696 // this function is "strict" by design - it must reject anything except true
 697 // RFC822 time specs.
 698 bool
 699 wxDateTime::ParseRfc822Date(const wxString& date, wxString::const_iterator *end)
 700 {
 701     const wxString::const_iterator pEnd = date.end();
 702     wxString::const_iterator p = date.begin();
 703
 704     // 1. week day
 705     const wxDateTime::WeekDay
 706         wd = GetWeekDayFromName(p, pEnd, Name_Abbr, DateLang_English);
 707     if ( wd == Inv_WeekDay )
 708         return false;
 709     //else: ignore week day for now, we could also check that it really
 710     //      corresponds to the specified date
 711
 712     // 2. separating comma
 713     if ( *p++ != ',' || *p++ != ' ' )
 714         return false;
 715
 716     // 3. day number
 717     if ( !wxIsdigit(*p) )
 718         return false;
 719
 720     wxDateTime_t day = (wxDateTime_t)(*p++ - '0');
 721     if ( wxIsdigit(*p) )
 722     {
 723         day *= 10;
 724         day = (wxDateTime_t)(day + (*p++ - '0'));
 725     }
 726
 727     if ( *p++ != ' ' )
 728         return false;
 729
 730     // 4. month name
 731     const Month mon = GetMonthFromName(p, pEnd, Name_Abbr, DateLang_English);
 732     if ( mon == Inv_Month )
 733         return false;
 734
 735     if ( *p++ != ' ' )
 736         return false;
 737
 738     // 5. year
 739     if ( !wxIsdigit(*p) )
 740         return false;
 741
 742     int year = *p++ - '0';
 743     if ( !wxIsdigit(*p) ) // should have at least 2 digits in the year
 744         return false;
 745
 746     year *= 10;
 747     year += *p++ - '0';
 748
 749     // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
 750     if ( wxIsdigit(*p) )
 751     {
 752         year *= 10;
 753         year += *p++ - '0';
 754
 755         if ( !wxIsdigit(*p) )
 756         {
 757             // no 3 digit years please
 758             return false;
 759         }
 760
 761         year *= 10;
 762         year += *p++ - '0';
 763     }
 764
 765     if ( *p++ != ' ' )
 766         return false;
 767
 768     // 6. time in hh:mm:ss format with seconds being optional
 769     if ( !wxIsdigit(*p) )
 770         return false;
 771
 772     wxDateTime_t hour = (wxDateTime_t)(*p++ - '0');
 773
 774     if ( !wxIsdigit(*p) )
 775         return false;
 776
 777     hour *= 10;
 778     hour = (wxDateTime_t)(hour + (*p++ - '0'));
 779
 780     if ( *p++ != ':' )
 781         return false;
 782
 783     if ( !wxIsdigit(*p) )
 784         return false;
 785
 786     wxDateTime_t min = (wxDateTime_t)(*p++ - '0');
 787
 788     if ( !wxIsdigit(*p) )
 789         return false;
 790
 791     min *= 10;
 792     min += (wxDateTime_t)(*p++ - '0');
 793
 794     wxDateTime_t sec = 0;
 795     if ( *p == ':' )
 796     {
 797         p++;
 798         if ( !wxIsdigit(*p) )
 799             return false;
 800
 801         sec = (wxDateTime_t)(*p++ - '0');
 802
 803         if ( !wxIsdigit(*p) )
 804             return false;
 805
 806         sec *= 10;
 807         sec += (wxDateTime_t)(*p++ - '0');
 808     }
 809
 810     if ( *p++ != ' ' )
 811         return false;
 812
 813     // 7. now the interesting part: the timezone
 814     int offset = 0; // just to suppress warnings
 815     if ( *p == '-' || *p == '+' )
 816     {
 817         // the explicit offset given: it has the form of hhmm
 818         bool plus = *p++ == '+';
 819
 820         if ( !wxIsdigit(*p) || !wxIsdigit(*(p + 1)) )
 821             return false;
 822
 823
 824         // hours
 825         offset = MIN_PER_HOUR*(10*(*p - '0') + (*(p + 1) - '0'));
 826
 827         p += 2;
 828
 829         if ( !wxIsdigit(*p) || !wxIsdigit(*(p + 1)) )
 830             return false;
 831
 832         // minutes
 833         offset += 10*(*p - '0') + (*(p + 1) - '0');
 834
 835         if ( !plus )
 836             offset = -offset;
 837
 838         p += 2;
 839     }
 840     else // not numeric
 841     {
 842         // the symbolic timezone given: may be either military timezone or one
 843         // of standard abbreviations
 844         if ( !*(p + 1) )
 845         {
 846             // military: Z = UTC, J unused, A = -1, ..., Y = +12
 847             static const int offsets[26] =
 848             {
 849                 //A  B   C   D   E   F   G   H   I    J    K    L    M
 850                 -1, -2, -3, -4, -5, -6, -7, -8, -9,   0, -10, -11, -12,
 851                 //N  O   P   R   Q   S   T   U   V    W    Z    Y    Z
 852                 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
 853             };
 854
 855             if ( *p < _T('A') || *p > _T('Z') || *p == _T('J') )
 856                 return false;
 857
 858             offset = offsets[*p++ - 'A'];
 859         }
 860         else
 861         {
 862             // abbreviation
 863             const wxString tz(p, date.end());
 864             if ( tz == _T("UT") || tz == _T("UTC") || tz == _T("GMT") )
 865                 offset = 0;
 866             else if ( tz == _T("AST") )
 867                 offset = AST - GMT0;
 868             else if ( tz == _T("ADT") )
 869                 offset = ADT - GMT0;
 870             else if ( tz == _T("EST") )
 871                 offset = EST - GMT0;
 872             else if ( tz == _T("EDT") )
 873                 offset = EDT - GMT0;
 874             else if ( tz == _T("CST") )
 875                 offset = CST - GMT0;
 876             else if ( tz == _T("CDT") )
 877                 offset = CDT - GMT0;
 878             else if ( tz == _T("MST") )
 879                 offset = MST - GMT0;
 880             else if ( tz == _T("MDT") )
 881                 offset = MDT - GMT0;
 882             else if ( tz == _T("PST") )
 883                 offset = PST - GMT0;
 884             else if ( tz == _T("PDT") )
 885                 offset = PDT - GMT0;
 886             else
 887                 return false;
 888
 889             p += tz.length();
 890         }
 891
 892         // make it minutes
 893         offset *= MIN_PER_HOUR;
 894     }
 895
 896
 897     // the spec was correct, construct the date from the values we found
 898     Set(day, mon, year, hour, min, sec);
 899     MakeFromTimezone(TimeZone::Make(offset*SEC_PER_MIN));
 900
 901     if ( end )
 902         *end = p;
 903
 904     return true;
 905 }
 906
 907 bool
 908 wxDateTime::ParseFormat(const wxString& date,
 909                         const wxString& format,
 910                         const wxDateTime& dateDef,
 911                         wxString::const_iterator *endParse)
 912 {
 913     wxCHECK_MSG( !format.empty(), false, "format can't be empty" );
 914     wxCHECK_MSG( endParse, false, "end iterator pointer must be specified" );
 915
 916     wxString str;
 917     unsigned long num;
 918
 919     // what fields have we found?
 920     bool haveWDay = false,
 921          haveYDay = false,
 922          haveDay = false,
 923          haveMon = false,
 924          haveYear = false,
 925          haveHour = false,
 926          haveMin = false,
 927          haveSec = false,
 928          haveMsec = false;
 929
 930     bool hourIsIn12hFormat = false, // or in 24h one?
 931          isPM = false;              // AM by default
 932
 933     // and the value of the items we have (init them to get rid of warnings)
 934     wxDateTime_t msec = 0,
 935                  sec = 0,
 936                  min = 0,
 937                  hour = 0;
 938     WeekDay wday = Inv_WeekDay;
 939     wxDateTime_t yday = 0,
 940                  mday = 0;
 941     wxDateTime::Month mon = Inv_Month;
 942     int year = 0;
 943
 944     wxString::const_iterator input = date.begin();
 945     const wxString::const_iterator end = date.end();
 946     for ( wxString::const_iterator fmt = format.begin(); fmt != format.end(); ++fmt )
 947     {
 948         if ( *fmt != _T('%') )
 949         {
 950             if ( wxIsspace(*fmt) )
 951             {
 952                 // a white space in the format string matches 0 or more white
 953                 // spaces in the input
 954                 while ( input != end && wxIsspace(*input) )
 955                 {
 956                     input++;
 957                 }
 958             }
 959             else // !space
 960             {
 961                 // any other character (not whitespace, not '%') must be
 962                 // matched by itself in the input
 963                 if ( input == end || *input++ != *fmt )
 964                 {
 965                     // no match
 966                     return false;
 967                 }
 968             }
 969
 970             // done with this format char
 971             continue;
 972         }
 973
 974         // start of a format specification
 975
 976         // parse the optional width
 977         size_t width = 0;
 978         while ( wxIsdigit(*++fmt) )
 979         {
 980             width *= 10;
 981             width += *fmt - '0';
 982         }
 983
 984         // the default widths for the various fields
 985         if ( !width )
 986         {
 987             switch ( (*fmt).GetValue() )
 988             {
 989                 case _T('Y'):               // year has 4 digits
 990                     width = 4;
 991                     break;
 992
 993                 case _T('j'):               // day of year has 3 digits
 994                 case _T('l'):               // milliseconds have 3 digits
 995                     width = 3;
 996                     break;
 997
 998                 case _T('w'):               // week day as number has only one
 999                     width = 1;
1000                     break;
1001
1002                 default:
1003                     // default for all other fields
1004                     width = 2;
1005             }
1006         }
1007
1008         // then the format itself
1009         switch ( (*fmt).GetValue() )
1010         {
1011             case _T('a'):       // a weekday name
1012             case _T('A'):
1013                 {
1014                     wday = GetWeekDayFromName
1015                            (
1016                             input, end,
1017                             *fmt == 'a' ? Name_Abbr : Name_Full,
1018                             DateLang_Local
1019                            );
1020                     if ( wday == Inv_WeekDay )
1021                     {
1022                         // no match
1023                         return false;
1024                     }
1025                 }
1026                 haveWDay = true;
1027                 break;
1028
1029             case _T('b'):       // a month name
1030             case _T('B'):
1031                 {
1032                     mon = GetMonthFromName
1033                           (
1034                             input, end,
1035                             *fmt == 'b' ? Name_Abbr : Name_Full,
1036                             DateLang_Local
1037                           );
1038                     if ( mon == Inv_Month )
1039                     {
1040                         // no match
1041                         return false;
1042                     }
1043                 }
1044                 haveMon = true;
1045                 break;
1046
1047             case _T('c'):       // locale default date and time  representation
1048                 {
1049                     wxDateTime dt;
1050
1051                     const wxString
1052                         fmtDateTime = wxLocale::GetInfo(wxLOCALE_DATE_TIME_FMT);
1053                     if ( !fmtDateTime.empty() )
1054                         dt = ParseFormatAt(input, end, fmtDateTime);
1055
1056                     if ( !dt.IsValid() )
1057                     {
1058                         // also try the format which corresponds to ctime()
1059                         // output (i.e. the "C" locale default)
1060                         dt = ParseFormatAt(input, end, wxS("%a %b %d %H:%M:%S %Y"));
1061                     }
1062
1063                     if ( !dt.IsValid() )
1064                     {
1065                         // and finally also the two generic date/time formats
1066                         dt = ParseFormatAt(input, end, wxS("%x %X"), wxS("%X %x"));
1067                     }
1068
1069                     if ( !dt.IsValid() )
1070                         return false;
1071
1072                     const Tm tm = dt.GetTm();
1073
1074                     hour = tm.hour;
1075                     min = tm.min;
1076                     sec = tm.sec;
1077
1078                     year = tm.year;
1079                     mon = tm.mon;
1080                     mday = tm.mday;
1081
1082                     haveDay = haveMon = haveYear =
1083                     haveHour = haveMin = haveSec = true;
1084                 }
1085                 break;
1086
1087             case _T('d'):       // day of a month (01-31)
1088             case 'e':           // day of a month (1-31) (GNU extension)
1089                 if ( !GetNumericToken(width, input, end, &num) ||
1090                         (num > 31) || (num < 1) )
1091                 {
1092                     // no match
1093                     return false;
1094                 }
1095
1096                 // we can't check whether the day range is correct yet, will
1097                 // do it later - assume ok for now
1098                 haveDay = true;
1099                 mday = (wxDateTime_t)num;
1100                 break;
1101
1102             case _T('H'):       // hour in 24h format (00-23)
1103                 if ( !GetNumericToken(width, input, end, &num) || (num > 23) )
1104                 {
1105                     // no match
1106                     return false;
1107                 }
1108
1109                 haveHour = true;
1110                 hour = (wxDateTime_t)num;
1111                 break;
1112
1113             case _T('I'):       // hour in 12h format (01-12)
1114                 if ( !GetNumericToken(width, input, end, &num) ||
1115                         !num || (num > 12) )
1116                 {
1117                     // no match
1118                     return false;
1119                 }
1120
1121                 haveHour = true;
1122                 hourIsIn12hFormat = true;
1123                 hour = (wxDateTime_t)(num % 12);        // 12 should be 0
1124                 break;
1125
1126             case _T('j'):       // day of the year
1127                 if ( !GetNumericToken(width, input, end, &num) ||
1128                         !num || (num > 366) )
1129                 {
1130                     // no match
1131                     return false;
1132                 }
1133
1134                 haveYDay = true;
1135                 yday = (wxDateTime_t)num;
1136                 break;
1137
1138             case _T('l'):       // milliseconds (0-999)
1139                 if ( !GetNumericToken(width, input, end, &num) )
1140                     return false;
1141
1142                 haveMsec = true;
1143                 msec = (wxDateTime_t)num;
1144                 break;
1145
1146             case _T('m'):       // month as a number (01-12)
1147                 if ( !GetNumericToken(width, input, end, &num) ||
1148                         !num || (num > 12) )
1149                 {
1150                     // no match
1151                     return false;
1152                 }
1153
1154                 haveMon = true;
1155                 mon = (Month)(num - 1);
1156                 break;
1157
1158             case _T('M'):       // minute as a decimal number (00-59)
1159                 if ( !GetNumericToken(width, input, end, &num) ||
1160                         (num > 59) )
1161                 {
1162                     // no match
1163                     return false;
1164                 }
1165
1166                 haveMin = true;
1167                 min = (wxDateTime_t)num;
1168                 break;
1169
1170             case _T('p'):       // AM or PM string
1171                 {
1172                     wxString am, pm;
1173                     GetAmPmStrings(&am, &pm);
1174
1175                     // we can never match %p in locales which don't use AM/PM
1176                     if ( am.empty() || pm.empty() )
1177                         return false;
1178
1179                     const size_t pos = input - date.begin();
1180                     if ( date.compare(pos, pm.length(), pm) == 0 )
1181                     {
1182                         isPM = true;
1183                         input += pm.length();
1184                     }
1185                     else if ( date.compare(pos, am.length(), am) == 0 )
1186                     {
1187                         input += am.length();
1188                     }
1189                     else // no match
1190                     {
1191                         return false;
1192                     }
1193                 }
1194                 break;
1195
1196             case _T('r'):       // time as %I:%M:%S %p
1197                 {
1198                     wxDateTime dt;
1199                     if ( !dt.ParseFormat(wxString(input, end),
1200                                          wxS("%I:%M:%S %p"), &input) )
1201                         return false;
1202
1203                     haveHour = haveMin = haveSec = true;
1204
1205                     const Tm tm = dt.GetTm();
1206                     hour = tm.hour;
1207                     min = tm.min;
1208                     sec = tm.sec;
1209                 }
1210                 break;
1211
1212             case _T('R'):       // time as %H:%M
1213                 {
1214                     const wxDateTime
1215                         dt = ParseFormatAt(input, end, wxS("%H:%M"));
1216                     if ( !dt.IsValid() )
1217                         return false;
1218
1219                     haveHour =
1220                     haveMin = true;
1221
1222                     const Tm tm = dt.GetTm();
1223                     hour = tm.hour;
1224                     min = tm.min;
1225                 }
1226                 break;
1227
1228             case _T('S'):       // second as a decimal number (00-61)
1229                 if ( !GetNumericToken(width, input, end, &num) ||
1230                         (num > 61) )
1231                 {
1232                     // no match
1233                     return false;
1234                 }
1235
1236                 haveSec = true;
1237                 sec = (wxDateTime_t)num;
1238                 break;
1239
1240             case _T('T'):       // time as %H:%M:%S
1241                 {
1242                     const wxDateTime
1243                         dt = ParseFormatAt(input, end, wxS("%H:%M:%S"));
1244                     if ( !dt.IsValid() )
1245                         return false;
1246
1247                     haveHour =
1248                     haveMin =
1249                     haveSec = true;
1250
1251                     const Tm tm = dt.GetTm();
1252                     hour = tm.hour;
1253                     min = tm.min;
1254                     sec = tm.sec;
1255                 }
1256                 break;
1257
1258             case _T('w'):       // weekday as a number (0-6), Sunday = 0
1259                 if ( !GetNumericToken(width, input, end, &num) ||
1260                         (wday > 6) )
1261                 {
1262                     // no match
1263                     return false;
1264                 }
1265
1266                 haveWDay = true;
1267                 wday = (WeekDay)num;
1268                 break;
1269
1270             case _T('x'):       // locale default date representation
1271                 {
1272                     wxString
1273                         fmtDate = wxLocale::GetInfo(wxLOCALE_SHORT_DATE_FMT),
1274                         fmtDateAlt = wxLocale::GetInfo(wxLOCALE_LONG_DATE_FMT);
1275
1276                     if ( fmtDate.empty() )
1277                     {
1278                         if ( IsWestEuropeanCountry(GetCountry()) ||
1279                              GetCountry() == Russia )
1280                         {
1281                             fmtDate = wxS("%d/%m/%Y");
1282                             fmtDateAlt = wxS("%m/%d/%Y");
1283                          }
1284                         else // assume USA
1285                         {
1286                             fmtDate = wxS("%m/%d/%Y");
1287                             fmtDateAlt = wxS("%d/%m/%Y");
1288                         }
1289                     }
1290
1291                     wxDateTime
1292                         dt = ParseFormatAt(input, end, fmtDate, fmtDateAlt);
1293
1294                     if ( !dt.IsValid() )
1295                     {
1296                         // try with short years too
1297                         fmtDate.Replace("%Y","%y");
1298                         fmtDateAlt.Replace("%Y","%y");
1299                         dt = ParseFormatAt(input, end, fmtDate, fmtDateAlt);
1300
1301                         if ( !dt.IsValid() )
1302                             return false;
1303                     }
1304
1305                     const Tm tm = dt.GetTm();
1306
1307                     haveDay =
1308                     haveMon =
1309                     haveYear = true;
1310
1311                     year = tm.year;
1312                     mon = tm.mon;
1313                     mday = tm.mday;
1314                 }
1315
1316                 break;
1317
1318             case _T('X'):       // locale default time representation
1319                 {
1320                     wxString fmtTime = wxLocale::GetInfo(wxLOCALE_TIME_FMT),
1321                              fmtTimeAlt;
1322
1323                     if ( fmtTime.empty() )
1324                     {
1325                         // try to parse what follows as "%H:%M:%S" and, if this
1326                         // fails, as "%I:%M:%S %p" - this should catch the most
1327                         // common cases
1328                         fmtTime = "%T";
1329                         fmtTimeAlt = "%r";
1330                     }
1331
1332                     const wxDateTime
1333                         dt = ParseFormatAt(input, end, fmtTime, fmtTimeAlt);
1334                     if ( !dt.IsValid() )
1335                         return false;
1336
1337                     haveHour =
1338                     haveMin =
1339                     haveSec = true;
1340
1341                     const Tm tm = dt.GetTm();
1342                     hour = tm.hour;
1343                     min = tm.min;
1344                     sec = tm.sec;
1345                 }
1346                 break;
1347
1348             case _T('y'):       // year without century (00-99)
1349                 if ( !GetNumericToken(width, input, end, &num) ||
1350                         (num > 99) )
1351                 {
1352                     // no match
1353                     return false;
1354                 }
1355
1356                 haveYear = true;
1357
1358                 // TODO should have an option for roll over date instead of
1359                 //      hard coding it here
1360                 year = (num > 30 ? 1900 : 2000) + (wxDateTime_t)num;
1361                 break;
1362
1363             case _T('Y'):       // year with century
1364                 if ( !GetNumericToken(width, input, end, &num) )
1365                 {
1366                     // no match
1367                     return false;
1368                 }
1369
1370                 haveYear = true;
1371                 year = (wxDateTime_t)num;
1372                 break;
1373
1374             case _T('Z'):       // timezone name
1375                 // FIXME: currently we just ignore everything that looks like a
1376                 //        time zone here
1377                 GetAlphaToken(input, end);
1378                 break;
1379
1380             case _T('%'):       // a percent sign
1381                 if ( *input++ != _T('%') )
1382                 {
1383                     // no match
1384                     return false;
1385                 }
1386                 break;
1387
1388             case 0:             // the end of string
1389                 wxFAIL_MSG(_T("unexpected format end"));
1390
1391                 // fall through
1392
1393             default:            // not a known format spec
1394                 return false;
1395         }
1396     }
1397
1398     // format matched, try to construct a date from what we have now
1399     Tm tmDef;
1400     if ( dateDef.IsValid() )
1401     {
1402         // take this date as default
1403         tmDef = dateDef.GetTm();
1404     }
1405     else if ( IsValid() )
1406     {
1407         // if this date is valid, don't change it
1408         tmDef = GetTm();
1409     }
1410     else
1411     {
1412         // no default and this date is invalid - fall back to Today()
1413         tmDef = Today().GetTm();
1414     }
1415
1416     Tm tm = tmDef;
1417
1418     // set the date
1419     if ( haveMon )
1420     {
1421         tm.mon = mon;
1422     }
1423
1424     if ( haveYear )
1425     {
1426         tm.year = year;
1427     }
1428
1429     // TODO we don't check here that the values are consistent, if both year
1430     //      day and month/day were found, we just ignore the year day and we
1431     //      also always ignore the week day
1432     if ( haveDay )
1433     {
1434         if ( mday > GetNumberOfDays(tm.mon, tm.year) )
1435             return false;
1436
1437         tm.mday = mday;
1438     }
1439     else if ( haveYDay )
1440     {
1441         if ( yday > GetNumberOfDays(tm.year) )
1442             return false;
1443
1444         Tm tm2 = wxDateTime(1, Jan, tm.year).SetToYearDay(yday).GetTm();
1445
1446         tm.mon = tm2.mon;
1447         tm.mday = tm2.mday;
1448     }
1449
1450     // deal with AM/PM
1451     if ( haveHour && hourIsIn12hFormat && isPM )
1452     {
1453         // translate to 24hour format
1454         hour += 12;
1455     }
1456     //else: either already in 24h format or no translation needed
1457
1458     // set the time
1459     if ( haveHour )
1460     {
1461         tm.hour = hour;
1462     }
1463
1464     if ( haveMin )
1465     {
1466         tm.min = min;
1467     }
1468
1469     if ( haveSec )
1470     {
1471         tm.sec = sec;
1472     }
1473
1474     if ( haveMsec )
1475         tm.msec = msec;
1476
1477     Set(tm);
1478
1479     // finally check that the week day is consistent -- if we had it
1480     if ( haveWDay && GetWeekDay() != wday )
1481         return false;
1482
1483     *endParse = input;
1484
1485     return true;
1486 }
1487
1488 bool
1489 wxDateTime::ParseDateTime(const wxString& date, wxString::const_iterator *end)
1490 {
1491     wxCHECK_MSG( end, false, "end iterator pointer must be specified" );
1492
1493     // Set to current day and hour, so strings like '14:00' becomes today at
1494     // 14, not some other random date
1495     wxDateTime dtDate = wxDateTime::Today();
1496     wxDateTime dtTime = wxDateTime::Today();
1497
1498     wxString::const_iterator
1499         endTime,
1500         endDate,
1501         endBoth;
1502
1503     // If we got a date in the beginning, see if there is a time specified
1504     // after the date
1505     if ( dtDate.ParseDate(date, &endDate) )
1506     {
1507         // Skip spaces, as the ParseTime() function fails on spaces
1508         while ( endDate != date.end() && wxIsspace(*endDate) )
1509             ++endDate;
1510
1511         const wxString timestr(endDate, date.end());
1512         if ( !dtTime.ParseTime(timestr, &endTime) )
1513             return false;
1514
1515         endBoth = endDate + (endTime - timestr.begin());
1516     }
1517     else // no date in the beginning
1518     {
1519         // check if we have a time followed by a date
1520         if ( !dtTime.ParseTime(date, &endTime) )
1521             return false;
1522
1523         while ( endTime != date.end() && wxIsspace(*endTime) )
1524             ++endTime;
1525
1526         const wxString datestr(endTime, date.end());
1527         if ( !dtDate.ParseDate(datestr, &endDate) )
1528             return false;
1529
1530         endBoth = endTime + (endDate - datestr.begin());
1531     }
1532
1533     Set(dtDate.GetDay(), dtDate.GetMonth(), dtDate.GetYear(),
1534         dtTime.GetHour(), dtTime.GetMinute(), dtTime.GetSecond(),
1535         dtTime.GetMillisecond());
1536
1537     *end = endBoth;
1538
1539     return true;
1540 }
1541
1542 bool
1543 wxDateTime::ParseDate(const wxString& date, wxString::const_iterator *end)
1544 {
1545     wxCHECK_MSG( end, false, "end iterator pointer must be specified" );
1546
1547     // this is a simplified version of ParseDateTime() which understands only
1548     // "today" (for wxDate compatibility) and digits only otherwise (and not
1549     // all esoteric constructions ParseDateTime() knows about)
1550
1551     const wxString::const_iterator pBegin = date.begin();
1552     const wxString::const_iterator pEnd = date.end();
1553
1554     wxString::const_iterator p = pBegin;
1555     while ( wxIsspace(*p) )
1556         p++;
1557
1558     // some special cases
1559     static struct
1560     {
1561         const char *str;
1562         int dayDiffFromToday;
1563     } literalDates[] =
1564     {
1565         { wxTRANSLATE("today"),             0 },
1566         { wxTRANSLATE("yesterday"),        -1 },
1567         { wxTRANSLATE("tomorrow"),          1 },
1568     };
1569
1570     const size_t lenRest = pEnd - p;
1571     for ( size_t n = 0; n < WXSIZEOF(literalDates); n++ )
1572     {
1573         const wxString dateStr = wxGetTranslation(literalDates[n].str);
1574         size_t len = dateStr.length();
1575
1576         if ( len > lenRest )
1577             continue;
1578
1579         const wxString::const_iterator pEnd = p + len;
1580         if ( wxString(p, pEnd).CmpNoCase(dateStr) == 0 )
1581         {
1582             // nothing can follow this, so stop here
1583
1584             p = pEnd;
1585
1586             int dayDiffFromToday = literalDates[n].dayDiffFromToday;
1587             *this = Today();
1588             if ( dayDiffFromToday )
1589             {
1590                 *this += wxDateSpan::Days(dayDiffFromToday);
1591             }
1592
1593             *end = pEnd;
1594
1595             return true;
1596         }
1597     }
1598
1599     // We try to guess what we have here: for each new (numeric) token, we
1600     // determine if it can be a month, day or a year. Of course, there is an
1601     // ambiguity as some numbers may be days as well as months, so we also
1602     // have the ability to back track.
1603
1604     // what do we have?
1605     bool haveDay = false,       // the months day?
1606          haveWDay = false,      // the day of week?
1607          haveMon = false,       // the month?
1608          haveYear = false;      // the year?
1609
1610     bool monWasNumeric = false; // was month specified as a number?
1611
1612     // and the value of the items we have (init them to get rid of warnings)
1613     WeekDay wday = Inv_WeekDay;
1614     wxDateTime_t day = 0;
1615     wxDateTime::Month mon = Inv_Month;
1616     int year = 0;
1617
1618     // tokenize the string
1619     while ( p != pEnd )
1620     {
1621         // skip white space and date delimiters
1622         while ( wxStrchr(".,/-\t\r\n ", *p) )
1623         {
1624             ++p;
1625         }
1626
1627         // modify copy of the iterator as we're not sure if the next token is
1628         // still part of the date at all
1629         wxString::const_iterator pCopy = p;
1630
1631         // we can have either alphabetic or numeric token, start by testing if
1632         // it's the latter
1633         unsigned long val;
1634         if ( GetNumericToken(10 /* max length */, pCopy, pEnd, &val) )
1635         {
1636             // guess what this number is
1637
1638             bool isDay = false,
1639                  isMonth = false,
1640                  isYear = false;
1641
1642             if ( !haveMon && val > 0 && val <= 12 )
1643             {
1644                 // assume it is month
1645                 isMonth = true;
1646             }
1647             else // not the month
1648             {
1649                 if ( haveDay )
1650                 {
1651                     // this can only be the year
1652                     isYear = true;
1653                 }
1654                 else // may be either day or year
1655                 {
1656                     // use a leap year if we don't have the year yet to allow
1657                     // dates like 2/29/1976 which would be rejected otherwise
1658                     wxDateTime_t max_days = (wxDateTime_t)(
1659                         haveMon
1660                         ? GetNumberOfDays(mon, haveYear ? year : 1976)
1661                         : 31
1662                     );
1663
1664                     // can it be day?
1665                     if ( (val == 0) || (val > (unsigned long)max_days) )
1666                     {
1667                         // no
1668                         isYear = true;
1669                     }
1670                     else // yes, suppose it's the day
1671                     {
1672                         isDay = true;
1673                     }
1674                 }
1675             }
1676
1677             if ( isYear )
1678             {
1679                 if ( haveYear )
1680                     break;
1681
1682                 haveYear = true;
1683
1684                 year = (wxDateTime_t)val;
1685             }
1686             else if ( isDay )
1687             {
1688                 if ( haveDay )
1689                     break;
1690
1691                 haveDay = true;
1692
1693                 day = (wxDateTime_t)val;
1694             }
1695             else if ( isMonth )
1696             {
1697                 haveMon = true;
1698                 monWasNumeric = true;
1699
1700                 mon = (Month)(val - 1);
1701             }
1702         }
1703         else // not a number
1704         {
1705             // be careful not to overwrite the current mon value
1706             Month mon2 = GetMonthFromName
1707                          (
1708                             pCopy, pEnd,
1709                             Name_Full | Name_Abbr,
1710                             DateLang_Local | DateLang_English
1711                          );
1712             if ( mon2 != Inv_Month )
1713             {
1714                 // it's a month
1715                 if ( haveMon )
1716                 {
1717                     // but we already have a month - maybe we guessed wrong
1718                     // when we had interpreted that numeric value as a month
1719                     // and it was the day number instead?
1720                     if ( haveDay || !monWasNumeric )
1721                         break;
1722
1723                     // assume we did and change our mind: reinterpret the month
1724                     // value as a day (notice that there is no need to check
1725                     // that it is valid as month values are always < 12, but
1726                     // the days are counted from 1 unlike the months)
1727                     day = (wxDateTime_t)(mon + 1);
1728                     haveDay = true;
1729                 }
1730
1731                 mon = mon2;
1732
1733                 haveMon = true;
1734             }
1735             else // not a valid month name
1736             {
1737                 WeekDay wday2 = GetWeekDayFromName
1738                                 (
1739                                     pCopy, pEnd,
1740                                     Name_Full | Name_Abbr,
1741                                     DateLang_Local | DateLang_English
1742                                 );
1743                 if ( wday2 != Inv_WeekDay )
1744                 {
1745                     // a week day
1746                     if ( haveWDay )
1747                         break;
1748
1749                     wday = wday2;
1750
1751                     haveWDay = true;
1752                 }
1753                 else // not a valid weekday name
1754                 {
1755                     // try the ordinals
1756                     static const char *ordinals[] =
1757                     {
1758                         wxTRANSLATE("first"),
1759                         wxTRANSLATE("second"),
1760                         wxTRANSLATE("third"),
1761                         wxTRANSLATE("fourth"),
1762                         wxTRANSLATE("fifth"),
1763                         wxTRANSLATE("sixth"),
1764                         wxTRANSLATE("seventh"),
1765                         wxTRANSLATE("eighth"),
1766                         wxTRANSLATE("ninth"),
1767                         wxTRANSLATE("tenth"),
1768                         wxTRANSLATE("eleventh"),
1769                         wxTRANSLATE("twelfth"),
1770                         wxTRANSLATE("thirteenth"),
1771                         wxTRANSLATE("fourteenth"),
1772                         wxTRANSLATE("fifteenth"),
1773                         wxTRANSLATE("sixteenth"),
1774                         wxTRANSLATE("seventeenth"),
1775                         wxTRANSLATE("eighteenth"),
1776                         wxTRANSLATE("nineteenth"),
1777                         wxTRANSLATE("twentieth"),
1778                         // that's enough - otherwise we'd have problems with
1779                         // composite (or not) ordinals
1780                     };
1781
1782                     size_t n;
1783                     for ( n = 0; n < WXSIZEOF(ordinals); n++ )
1784                     {
1785                         const wxString ord = wxGetTranslation(ordinals[n]);
1786                         const size_t len = ord.length();
1787                         if ( date.compare(p - pBegin, len, ord) == 0 )
1788                         {
1789                             p += len;
1790                             break;
1791                         }
1792                     }
1793
1794                     if ( n == WXSIZEOF(ordinals) )
1795                     {
1796                         // stop here - something unknown
1797                         break;
1798                     }
1799
1800                     // it's a day
1801                     if ( haveDay )
1802                     {
1803                         // don't try anything here (as in case of numeric day
1804                         // above) - the symbolic day spec should always
1805                         // precede the month/year
1806                         break;
1807                     }
1808
1809                     haveDay = true;
1810
1811                     day = (wxDateTime_t)(n + 1);
1812                 }
1813             }
1814         }
1815
1816         // advance iterator past a successfully parsed token
1817         p = pCopy;
1818     }
1819
1820     // either no more tokens or the scan was stopped by something we couldn't
1821     // parse - in any case, see if we can construct a date from what we have
1822     if ( !haveDay && !haveWDay )
1823         return false;
1824
1825     if ( haveWDay && (haveMon || haveYear || haveDay) &&
1826          !(haveDay && haveMon && haveYear) )
1827     {
1828         // without adjectives (which we don't support here) the week day only
1829         // makes sense completely separately or with the full date
1830         // specification (what would "Wed 1999" mean?)
1831         return false;
1832     }
1833
1834     if ( !haveWDay && haveYear && !(haveDay && haveMon) )
1835     {
1836         // may be we have month and day instead of day and year?
1837         if ( haveDay && !haveMon )
1838         {
1839             if ( day <= 12  )
1840             {
1841                 // exchange day and month
1842                 mon = (wxDateTime::Month)(day - 1);
1843
1844                 // we're in the current year then
1845                 if ( (year > 0) && (year <= (int)GetNumberOfDays(mon, Inv_Year)) )
1846                 {
1847                     day = (wxDateTime_t)year;
1848
1849                     haveMon = true;
1850                     haveYear = false;
1851                 }
1852                 //else: no, can't exchange, leave haveMon == false
1853             }
1854         }
1855
1856         if ( !haveMon )
1857             return false;
1858     }
1859
1860     if ( !haveMon )
1861     {
1862         mon = GetCurrentMonth();
1863     }
1864
1865     if ( !haveYear )
1866     {
1867         year = GetCurrentYear();
1868     }
1869
1870     if ( haveDay )
1871     {
1872         // normally we check the day above but the check is optimistic in case
1873         // we find the day before its month/year so we have to redo it now
1874         if ( day > GetNumberOfDays(mon, year) )
1875             return false;
1876
1877         Set(day, mon, year);
1878
1879         if ( haveWDay )
1880         {
1881             // check that it is really the same
1882             if ( GetWeekDay() != wday )
1883                 return false;
1884         }
1885     }
1886     else // haveWDay
1887     {
1888         *this = Today();
1889
1890         SetToWeekDayInSameWeek(wday);
1891     }
1892
1893     *end = p;
1894
1895     return true;
1896 }
1897
1898 bool
1899 wxDateTime::ParseTime(const wxString& time, wxString::const_iterator *end)
1900 {
1901     wxCHECK_MSG( end, false, "end iterator pointer must be specified" );
1902
1903     // first try some extra things
1904     static const struct
1905     {
1906         const char *name;
1907         wxDateTime_t hour;
1908     } stdTimes[] =
1909     {
1910         { wxTRANSLATE("noon"),      12 },
1911         { wxTRANSLATE("midnight"),  00 },
1912         // anything else?
1913     };
1914
1915     for ( size_t n = 0; n < WXSIZEOF(stdTimes); n++ )
1916     {
1917         const wxString timeString = wxGetTranslation(stdTimes[n].name);
1918         const wxString::const_iterator p = time.begin() + timeString.length();
1919         if ( timeString.CmpNoCase(wxString(time.begin(), p)) == 0 )
1920         {
1921             // casts required by DigitalMars
1922             Set(stdTimes[n].hour, wxDateTime_t(0), wxDateTime_t(0));
1923
1924             if ( end )
1925                 *end = p;
1926
1927             return true;
1928         }
1929     }
1930
1931     // try all time formats we may think about in the order from longest to
1932     // shortest
1933     static const char *timeFormats[] =
1934     {
1935         "%I:%M:%S %p",  // 12hour with AM/PM
1936         "%H:%M:%S",     // could be the same or 24 hour one so try it too
1937         "%I:%M %p",     // 12hour with AM/PM but without seconds
1938         "%H:%M:%S",     // and a possibly 24 hour version without seconds
1939         "%X",           // possibly something from above or maybe something
1940                         // completely different -- try it last
1941
1942         // TODO: parse timezones
1943     };
1944
1945     for ( size_t nFmt = 0; nFmt < WXSIZEOF(timeFormats); nFmt++ )
1946     {
1947         if ( ParseFormat(time, timeFormats[nFmt], end) )
1948             return true;
1949     }
1950
1951     return false;
1952 }
1953
1954 // ----------------------------------------------------------------------------
1955 // Workdays and holidays support
1956 // ----------------------------------------------------------------------------
1957
1958 bool wxDateTime::IsWorkDay(Country WXUNUSED(country)) const
1959 {
1960     return !wxDateTimeHolidayAuthority::IsHoliday(*this);
1961 }
1962
1963 // ============================================================================
1964 // wxDateSpan
1965 // ============================================================================
1966
1967 wxDateSpan WXDLLIMPEXP_BASE operator*(int n, const wxDateSpan& ds)
1968 {
1969     wxDateSpan ds1(ds);
1970     return ds1.Multiply(n);
1971 }
1972
1973 // ============================================================================
1974 // wxTimeSpan
1975 // ============================================================================
1976
1977 wxTimeSpan WXDLLIMPEXP_BASE operator*(int n, const wxTimeSpan& ts)
1978 {
1979     return wxTimeSpan(ts).Multiply(n);
1980 }
1981
1982 // this enum is only used in wxTimeSpan::Format() below but we can't declare
1983 // it locally to the method as it provokes an internal compiler error in egcs
1984 // 2.91.60 when building with -O2
1985 enum TimeSpanPart
1986 {
1987     Part_Week,
1988     Part_Day,
1989     Part_Hour,
1990     Part_Min,
1991     Part_Sec,
1992     Part_MSec
1993 };
1994
1995 // not all strftime(3) format specifiers make sense here because, for example,
1996 // a time span doesn't have a year nor a timezone
1997 //
1998 // Here are the ones which are supported (all of them are supported by strftime
1999 // as well):
2000 //  %H          hour in 24 hour format
2001 //  %M          minute (00 - 59)
2002 //  %S          second (00 - 59)
2003 //  %%          percent sign
2004 //
2005 // Also, for MFC CTimeSpan compatibility, we support
2006 //  %D          number of days
2007 //
2008 // And, to be better than MFC :-), we also have
2009 //  %E          number of wEeks
2010 //  %l          milliseconds (000 - 999)
2011 wxString wxTimeSpan::Format(const wxString& format) const
2012 {
2013     // we deal with only positive time spans here and just add the sign in
2014     // front for the negative ones
2015     if ( IsNegative() )
2016     {
2017         wxString str(Negate().Format(format));
2018         return "-" + str;
2019     }
2020
2021     wxCHECK_MSG( !format.empty(), wxEmptyString,
2022                  _T("NULL format in wxTimeSpan::Format") );
2023
2024     wxString str;
2025     str.Alloc(format.length());
2026
2027     // Suppose we have wxTimeSpan ts(1 /* hour */, 2 /* min */, 3 /* sec */)
2028     //
2029     // Then, of course, ts.Format("%H:%M:%S") must return "01:02:03", but the
2030     // question is what should ts.Format("%S") do? The code here returns "3273"
2031     // in this case (i.e. the total number of seconds, not just seconds % 60)
2032     // because, for me, this call means "give me entire time interval in
2033     // seconds" and not "give me the seconds part of the time interval"
2034     //
2035     // If we agree that it should behave like this, it is clear that the
2036     // interpretation of each format specifier depends on the presence of the
2037     // other format specs in the string: if there was "%H" before "%M", we
2038     // should use GetMinutes() % 60, otherwise just GetMinutes() &c
2039
2040     // we remember the most important unit found so far
2041     TimeSpanPart partBiggest = Part_MSec;
2042
2043     for ( wxString::const_iterator pch = format.begin(); pch != format.end(); ++pch )
2044     {
2045         wxChar ch = *pch;
2046
2047         if ( ch == _T('%') )
2048         {
2049             // the start of the format specification of the printf() below
2050             wxString fmtPrefix(_T('%'));
2051
2052             // the number
2053             long n;
2054
2055             // the number of digits for the format string, 0 if unused
2056             unsigned digits = 0;
2057
2058             ch = *++pch;    // get the format spec char
2059             switch ( ch )
2060             {
2061                 default:
2062                     wxFAIL_MSG( _T("invalid format character") );
2063                     // fall through
2064
2065                 case _T('%'):
2066                     str += ch;
2067
2068                     // skip the part below switch
2069                     continue;
2070
2071                 case _T('D'):
2072                     n = GetDays();
2073                     if ( partBiggest < Part_Day )
2074                     {
2075                         n %= DAYS_PER_WEEK;
2076                     }
2077                     else
2078                     {
2079                         partBiggest = Part_Day;
2080                     }
2081                     break;
2082
2083                 case _T('E'):
2084                     partBiggest = Part_Week;
2085                     n = GetWeeks();
2086                     break;
2087
2088                 case _T('H'):
2089                     n = GetHours();
2090                     if ( partBiggest < Part_Hour )
2091                     {
2092                         n %= HOURS_PER_DAY;
2093                     }
2094                     else
2095                     {
2096                         partBiggest = Part_Hour;
2097                     }
2098
2099                     digits = 2;
2100                     break;
2101
2102                 case _T('l'):
2103                     n = GetMilliseconds().ToLong();
2104                     if ( partBiggest < Part_MSec )
2105                     {
2106                         n %= 1000;
2107                     }
2108                     //else: no need to reset partBiggest to Part_MSec, it is
2109                     //      the least significant one anyhow
2110
2111                     digits = 3;
2112                     break;
2113
2114                 case _T('M'):
2115                     n = GetMinutes();
2116                     if ( partBiggest < Part_Min )
2117                     {
2118                         n %= MIN_PER_HOUR;
2119                     }
2120                     else
2121                     {
2122                         partBiggest = Part_Min;
2123                     }
2124
2125                     digits = 2;
2126                     break;
2127
2128                 case _T('S'):
2129                     n = GetSeconds().ToLong();
2130                     if ( partBiggest < Part_Sec )
2131                     {
2132                         n %= SEC_PER_MIN;
2133                     }
2134                     else
2135                     {
2136                         partBiggest = Part_Sec;
2137                     }
2138
2139                     digits = 2;
2140                     break;
2141             }
2142
2143             if ( digits )
2144             {
2145                 fmtPrefix << _T("0") << digits;
2146             }
2147
2148             str += wxString::Format(fmtPrefix + _T("ld"), n);
2149         }
2150         else
2151         {
2152             // normal character, just copy
2153             str += ch;
2154         }
2155     }
2156
2157     return str;
2158 }
2159
2160 #endif // wxUSE_DATETIME