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