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                         // strptime() failed; try generic heuristic code
1200 #endif // HAVE_STRPTIME
1201
1202                         // try the format which corresponds to ctime() output first
1203                         wxString::const_iterator endc;
1204                         if ( !dt.ParseFormat(inc, wxS("%a %b %d %H:%M:%S %Y"), &endc) &&
1205                                 !dt.ParseFormat(inc, wxS("%x %X"), &endc) &&
1206                                     !dt.ParseFormat(inc, wxS("%X %x"), &endc) )
1207                         {
1208                             // we've tried everything and still no match
1209                             return NULL;
1210                         }
1211
1212                         tm = dt.GetTm();
1213                         input += endc - inc.begin();
1214 #ifdef HAVE_STRPTIME
1215                     }
1216                     else
1217                         input = result;     // proceed where strptime() ended
1218 #endif // HAVE_STRPTIME
1219
1220                     haveDay = haveMon = haveYear =
1221                     haveHour = haveMin = haveSec = true;
1222
1223                     hour = tm.hour;
1224                     min = tm.min;
1225                     sec = tm.sec;
1226
1227                     year = tm.year;
1228                     mon = tm.mon;
1229                     mday = tm.mday;
1230                 }
1231                 break;
1232
1233             case _T('d'):       // day of a month (01-31)
1234                 if ( !GetNumericToken(width, input, &num) ||
1235                         (num > 31) || (num < 1) )
1236                 {
1237                     // no match
1238                     return NULL;
1239                 }
1240
1241                 // we can't check whether the day range is correct yet, will
1242                 // do it later - assume ok for now
1243                 haveDay = true;
1244                 mday = (wxDateTime_t)num;
1245                 break;
1246
1247             case _T('H'):       // hour in 24h format (00-23)
1248                 if ( !GetNumericToken(width, input, &num) || (num > 23) )
1249                 {
1250                     // no match
1251                     return NULL;
1252                 }
1253
1254                 haveHour = true;
1255                 hour = (wxDateTime_t)num;
1256                 break;
1257
1258             case _T('I'):       // hour in 12h format (01-12)
1259                 if ( !GetNumericToken(width, input, &num) || !num || (num > 12) )
1260                 {
1261                     // no match
1262                     return NULL;
1263                 }
1264
1265                 haveHour = true;
1266                 hourIsIn12hFormat = true;
1267                 hour = (wxDateTime_t)(num % 12);        // 12 should be 0
1268                 break;
1269
1270             case _T('j'):       // day of the year
1271                 if ( !GetNumericToken(width, input, &num) || !num || (num > 366) )
1272                 {
1273                     // no match
1274                     return NULL;
1275                 }
1276
1277                 haveYDay = true;
1278                 yday = (wxDateTime_t)num;
1279                 break;
1280
1281             case _T('l'):       // milliseconds (0-999)
1282                 if ( !GetNumericToken(width, input, &num) )
1283                     return NULL;
1284
1285                 haveMsec = true;
1286                 msec = (wxDateTime_t)num;
1287                 break;
1288
1289             case _T('m'):       // month as a number (01-12)
1290                 if ( !GetNumericToken(width, input, &num) || !num || (num > 12) )
1291                 {
1292                     // no match
1293                     return NULL;
1294                 }
1295
1296                 haveMon = true;
1297                 mon = (Month)(num - 1);
1298                 break;
1299
1300             case _T('M'):       // minute as a decimal number (00-59)
1301                 if ( !GetNumericToken(width, input, &num) || (num > 59) )
1302                 {
1303                     // no match
1304                     return NULL;
1305                 }
1306
1307                 haveMin = true;
1308                 min = (wxDateTime_t)num;
1309                 break;
1310
1311             case _T('p'):       // AM or PM string
1312                 {
1313                     wxString am, pm, token = GetAlphaToken(input);
1314
1315                     GetAmPmStrings(&am, &pm);
1316                     if (am.empty() && pm.empty())
1317                         return NULL;  // no am/pm strings defined
1318                     if ( token.CmpNoCase(pm) == 0 )
1319                     {
1320                         isPM = true;
1321                     }
1322                     else if ( token.CmpNoCase(am) != 0 )
1323                     {
1324                         // no match
1325                         return NULL;
1326                     }
1327                 }
1328                 break;
1329
1330             case _T('r'):       // time as %I:%M:%S %p
1331                 {
1332                     wxDateTime dt;
1333                     input = dt.ParseFormat(input, wxS("%I:%M:%S %p"));
1334                     if ( !input )
1335                     {
1336                         // no match
1337                         return NULL;
1338                     }
1339
1340                     haveHour = haveMin = haveSec = true;
1341
1342                     Tm tm = dt.GetTm();
1343                     hour = tm.hour;
1344                     min = tm.min;
1345                     sec = tm.sec;
1346                 }
1347                 break;
1348
1349             case _T('R'):       // time as %H:%M
1350                 {
1351                     wxDateTime dt;
1352                     input = dt.ParseFormat(input, wxS("%H:%M"));
1353                     if ( !input )
1354                     {
1355                         // no match
1356                         return NULL;
1357                     }
1358
1359                     haveHour = haveMin = true;
1360
1361                     Tm tm = dt.GetTm();
1362                     hour = tm.hour;
1363                     min = tm.min;
1364                 }
1365                 break;
1366
1367             case _T('S'):       // second as a decimal number (00-61)
1368                 if ( !GetNumericToken(width, input, &num) || (num > 61) )
1369                 {
1370                     // no match
1371                     return NULL;
1372                 }
1373
1374                 haveSec = true;
1375                 sec = (wxDateTime_t)num;
1376                 break;
1377
1378             case _T('T'):       // time as %H:%M:%S
1379                 {
1380                     wxDateTime dt;
1381                     input = dt.ParseFormat(input, _T("%H:%M:%S"));
1382                     if ( !input )
1383                     {
1384                         // no match
1385                         return NULL;
1386                     }
1387
1388                     haveHour = haveMin = haveSec = true;
1389
1390                     Tm tm = dt.GetTm();
1391                     hour = tm.hour;
1392                     min = tm.min;
1393                     sec = tm.sec;
1394                 }
1395                 break;
1396
1397             case _T('w'):       // weekday as a number (0-6), Sunday = 0
1398                 if ( !GetNumericToken(width, input, &num) || (wday > 6) )
1399                 {
1400                     // no match
1401                     return NULL;
1402                 }
1403
1404                 haveWDay = true;
1405                 wday = (WeekDay)num;
1406                 break;
1407
1408             case _T('x'):       // locale default date representation
1409 #ifdef HAVE_STRPTIME
1410                 // try using strptime() -- it may fail even if the input is
1411                 // correct but the date is out of range, so we will fall back
1412                 // to our generic code anyhow
1413                 {
1414                     struct tm tm;
1415
1416                     const wxStringCharType *
1417                         result = CallStrptime(input, "%x", &tm);
1418                     if ( result )
1419                     {
1420                         input = result;
1421
1422                         haveDay = haveMon = haveYear = true;
1423
1424                         year = 1900 + tm.tm_year;
1425                         mon = (Month)tm.tm_mon;
1426                         mday = tm.tm_mday;
1427
1428                         break;
1429                     }
1430                 }
1431 #endif // HAVE_STRPTIME
1432
1433                 {
1434                     wxDateTime dt;
1435                     wxString fmtDate,
1436                              fmtDateAlt;
1437
1438 #ifdef __WINDOWS__
1439                     // The above doesn't work for all locales, try to query
1440                     // Windows for the right way of formatting the date:
1441                     fmtDate = GetLocaleDateFormat();
1442                     if ( fmtDate.empty() )
1443 #endif // __WINDOWS__
1444                     {
1445                         if ( IsWestEuropeanCountry(GetCountry()) ||
1446                              GetCountry() == Russia )
1447                         {
1448                             fmtDate = _T("%d/%m/%y");
1449                             fmtDateAlt = _T("%m/%d/%y");
1450                         }
1451                         else // assume USA
1452                         {
1453                             fmtDate = _T("%m/%d/%y");
1454                             fmtDateAlt = _T("%d/%m/%y");
1455                         }
1456                     }
1457
1458                     const wxString indate(input);
1459                     wxString::const_iterator endDate;
1460                     if ( !dt.ParseFormat(indate, fmtDate, &endDate) )
1461                     {
1462                         // try another one if we have it
1463                         if ( fmtDateAlt.empty() ||
1464                                 !dt.ParseFormat(indate, fmtDateAlt, &endDate) )
1465                         {
1466                             return NULL;
1467                         }
1468                     }
1469
1470                     Tm tm = dt.GetTm();
1471
1472                     haveDay =
1473                     haveMon =
1474                     haveYear = true;
1475
1476                     year = tm.year;
1477                     mon = tm.mon;
1478                     mday = tm.mday;
1479
1480                     input += endDate - indate.begin();
1481                 }
1482
1483                 break;
1484
1485             case _T('X'):       // locale default time representation
1486 #ifdef HAVE_STRPTIME
1487                 {
1488                     // use strptime() to do it for us (FIXME !Unicode friendly)
1489                     struct tm tm;
1490                     input = CallStrptime(input, "%X", &tm);
1491                     if ( !input )
1492                     {
1493                         return NULL;
1494                     }
1495
1496                     haveHour = haveMin = haveSec = true;
1497
1498                     hour = tm.tm_hour;
1499                     min = tm.tm_min;
1500                     sec = tm.tm_sec;
1501                 }
1502 #else // !HAVE_STRPTIME
1503                 // TODO under Win32 we can query the LOCALE_ITIME system
1504                 //      setting which says whether the default time format is
1505                 //      24 or 12 hour
1506                 {
1507                     // try to parse what follows as "%H:%M:%S" and, if this
1508                     // fails, as "%I:%M:%S %p" - this should catch the most
1509                     // common cases
1510                     wxDateTime dt;
1511
1512                     const wxStringCharType *
1513                         result = dt.ParseFormat(input, wxS("%T"));
1514                     if ( !result )
1515                     {
1516                         result = dt.ParseFormat(input, wxS("%r"));
1517                     }
1518
1519                     if ( !result )
1520                     {
1521                         // no match
1522                         return NULL;
1523                     }
1524
1525                     haveHour =
1526                     haveMin =
1527                     haveSec = true;
1528
1529                     Tm tm = dt.GetTm();
1530                     hour = tm.hour;
1531                     min = tm.min;
1532                     sec = tm.sec;
1533
1534                     input = result;
1535                 }
1536 #endif // HAVE_STRPTIME/!HAVE_STRPTIME
1537                 break;
1538
1539             case _T('y'):       // year without century (00-99)
1540                 if ( !GetNumericToken(width, input, &num) || (num > 99) )
1541                 {
1542                     // no match
1543                     return NULL;
1544                 }
1545
1546                 haveYear = true;
1547
1548                 // TODO should have an option for roll over date instead of
1549                 //      hard coding it here
1550                 year = (num > 30 ? 1900 : 2000) + (wxDateTime_t)num;
1551                 break;
1552
1553             case _T('Y'):       // year with century
1554                 if ( !GetNumericToken(width, input, &num) )
1555                 {
1556                     // no match
1557                     return NULL;
1558                 }
1559
1560                 haveYear = true;
1561                 year = (wxDateTime_t)num;
1562                 break;
1563
1564             case _T('Z'):       // timezone name
1565                 wxFAIL_MSG(_T("TODO"));
1566                 break;
1567
1568             case _T('%'):       // a percent sign
1569                 if ( *input++ != _T('%') )
1570                 {
1571                     // no match
1572                     return NULL;
1573                 }
1574                 break;
1575
1576             case 0:             // the end of string
1577                 wxFAIL_MSG(_T("unexpected format end"));
1578
1579                 // fall through
1580
1581             default:            // not a known format spec
1582                 return NULL;
1583         }
1584     }
1585
1586     // format matched, try to construct a date from what we have now
1587     Tm tmDef;
1588     if ( dateDef.IsValid() )
1589     {
1590         // take this date as default
1591         tmDef = dateDef.GetTm();
1592     }
1593     else if ( IsValid() )
1594     {
1595         // if this date is valid, don't change it
1596         tmDef = GetTm();
1597     }
1598     else
1599     {
1600         // no default and this date is invalid - fall back to Today()
1601         tmDef = Today().GetTm();
1602     }
1603
1604     Tm tm = tmDef;
1605
1606     // set the date
1607     if ( haveMon )
1608     {
1609         tm.mon = mon;
1610     }
1611
1612     if ( haveYear )
1613     {
1614         tm.year = year;
1615     }
1616
1617     // TODO we don't check here that the values are consistent, if both year
1618     //      day and month/day were found, we just ignore the year day and we
1619     //      also always ignore the week day
1620     if ( haveDay )
1621     {
1622         if ( mday > GetNumberOfDays(tm.mon, tm.year) )
1623         {
1624             wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
1625
1626             return NULL;
1627         }
1628
1629         tm.mday = mday;
1630     }
1631     else if ( haveYDay )
1632     {
1633         if ( yday > GetNumberOfDays(tm.year) )
1634         {
1635             wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
1636
1637             return NULL;
1638         }
1639
1640         Tm tm2 = wxDateTime(1, Jan, tm.year).SetToYearDay(yday).GetTm();
1641
1642         tm.mon = tm2.mon;
1643         tm.mday = tm2.mday;
1644     }
1645
1646     // deal with AM/PM
1647     if ( haveHour && hourIsIn12hFormat && isPM )
1648     {
1649         // translate to 24hour format
1650         hour += 12;
1651     }
1652     //else: either already in 24h format or no translation needed
1653
1654     // set the time
1655     if ( haveHour )
1656     {
1657         tm.hour = hour;
1658     }
1659
1660     if ( haveMin )
1661     {
1662         tm.min = min;
1663     }
1664
1665     if ( haveSec )
1666     {
1667         tm.sec = sec;
1668     }
1669
1670     if ( haveMsec )
1671         tm.msec = msec;
1672
1673     Set(tm);
1674
1675     // finally check that the week day is consistent -- if we had it
1676     if ( haveWDay && GetWeekDay() != wday )
1677     {
1678         wxLogDebug(_T("inconsistsnet week day in wxDateTime::ParseFormat()"));
1679
1680         return NULL;
1681     }
1682
1683     const size_t endpos = input - date.wx_str();
1684     if ( end )
1685         *end = date.begin() + endpos;
1686
1687     return date.c_str() + endpos;
1688 }
1689
1690 const char *
1691 wxDateTime::ParseDateTime(const wxString& date, wxString::const_iterator *end)
1692 {
1693     // Set to current day and hour, so strings like '14:00' becomes today at
1694     // 14, not some other random date
1695     wxDateTime dtDate = wxDateTime::Today();
1696     wxDateTime dtTime = wxDateTime::Today();
1697
1698     wxString::const_iterator
1699         endTime,
1700         endDate,
1701         endBoth;
1702
1703     // If we got a date in the beginning, see if there is a time specified
1704     // after the date
1705     if ( dtDate.ParseDate(date, &endDate) )
1706     {
1707         // Skip spaces, as the ParseTime() function fails on spaces
1708         while ( endDate != date.end() && wxIsspace(*endDate) )
1709             ++endDate;
1710
1711         const wxString timestr(endDate, date.end());
1712         if ( !dtTime.ParseTime(timestr, &endTime) )
1713             return NULL;
1714
1715         endBoth = endDate + (endTime - timestr.begin());
1716     }
1717     else // no date in the beginning
1718     {
1719         // check if we have a time followed by a date
1720         if ( !dtTime.ParseTime(date, &endTime) )
1721             return NULL;
1722
1723         while ( endTime != date.end() && wxIsspace(*endTime) )
1724             ++endTime;
1725
1726         const wxString datestr(endTime, date.end());
1727         if ( !dtDate.ParseDate(datestr, &endDate) )
1728             return NULL;
1729
1730         endBoth = endTime + (endDate - datestr.begin());
1731     }
1732
1733     Set(dtDate.GetDay(), dtDate.GetMonth(), dtDate.GetYear(),
1734         dtTime.GetHour(), dtTime.GetMinute(), dtTime.GetSecond(),
1735         dtTime.GetMillisecond());
1736
1737     // Return endpoint of scan
1738     if ( end )
1739         *end = endBoth;
1740
1741     return date.c_str() + (endBoth - date.begin());
1742 }
1743
1744 const char *
1745 wxDateTime::ParseDate(const wxString& date, wxString::const_iterator *end)
1746 {
1747     // this is a simplified version of ParseDateTime() which understands only
1748     // "today" (for wxDate compatibility) and digits only otherwise (and not
1749     // all esoteric constructions ParseDateTime() knows about)
1750
1751     const wxStringCharType *p = date.wx_str();
1752     while ( wxIsspace(*p) )
1753         p++;
1754
1755     // some special cases
1756     static struct
1757     {
1758         const char *str;
1759         int dayDiffFromToday;
1760     } literalDates[] =
1761     {
1762         { wxTRANSLATE("today"),             0 },
1763         { wxTRANSLATE("yesterday"),        -1 },
1764         { wxTRANSLATE("tomorrow"),          1 },
1765     };
1766
1767     for ( size_t n = 0; n < WXSIZEOF(literalDates); n++ )
1768     {
1769         const wxString dateStr = wxGetTranslation(literalDates[n].str);
1770         size_t len = dateStr.length();
1771         if ( wxStrlen(p) >= len )
1772         {
1773             wxString str(p, len);
1774             if ( str.CmpNoCase(dateStr) == 0 )
1775             {
1776                 // nothing can follow this, so stop here
1777                 p += len;
1778
1779                 int dayDiffFromToday = literalDates[n].dayDiffFromToday;
1780                 *this = Today();
1781                 if ( dayDiffFromToday )
1782                 {
1783                     *this += wxDateSpan::Days(dayDiffFromToday);
1784                 }
1785
1786                 const size_t endpos = p - date.wx_str();
1787
1788                 if ( end )
1789                     *end = date.begin() + endpos;
1790                 return date.c_str() + endpos;
1791             }
1792         }
1793     }
1794
1795     // We try to guess what we have here: for each new (numeric) token, we
1796     // determine if it can be a month, day or a year. Of course, there is an
1797     // ambiguity as some numbers may be days as well as months, so we also
1798     // have the ability to back track.
1799
1800     // what do we have?
1801     bool haveDay = false,       // the months day?
1802          haveWDay = false,      // the day of week?
1803          haveMon = false,       // the month?
1804          haveYear = false;      // the year?
1805
1806     // and the value of the items we have (init them to get rid of warnings)
1807     WeekDay wday = Inv_WeekDay;
1808     wxDateTime_t day = 0;
1809     wxDateTime::Month mon = Inv_Month;
1810     int year = 0;
1811
1812     // tokenize the string
1813     size_t nPosCur = 0;
1814     static const wxStringCharType *dateDelimiters = wxS(".,/-\t\r\n ");
1815     wxStringTokenizer tok(p, dateDelimiters);
1816     while ( tok.HasMoreTokens() )
1817     {
1818         wxString token = tok.GetNextToken();
1819         if ( !token )
1820             continue;
1821
1822         // is it a number?
1823         unsigned long val;
1824         if ( token.ToULong(&val) )
1825         {
1826             // guess what this number is
1827
1828             bool isDay = false,
1829                  isMonth = false,
1830                  isYear = false;
1831
1832             if ( !haveMon && val > 0 && val <= 12 )
1833             {
1834                 // assume it is month
1835                 isMonth = true;
1836             }
1837             else // not the month
1838             {
1839                 if ( haveDay )
1840                 {
1841                     // this can only be the year
1842                     isYear = true;
1843                 }
1844                 else // may be either day or year
1845                 {
1846                     // use a leap year if we don't have the year yet to allow
1847                     // dates like 2/29/1976 which would be rejected otherwise
1848                     wxDateTime_t max_days = (wxDateTime_t)(
1849                         haveMon
1850                         ? GetNumberOfDays(mon, haveYear ? year : 1976)
1851                         : 31
1852                     );
1853
1854                     // can it be day?
1855                     if ( (val == 0) || (val > (unsigned long)max_days) )
1856                     {
1857                         // no
1858                         isYear = true;
1859                     }
1860                     else // yes, suppose it's the day
1861                     {
1862                         isDay = true;
1863                     }
1864                 }
1865             }
1866
1867             if ( isYear )
1868             {
1869                 if ( haveYear )
1870                     break;
1871
1872                 haveYear = true;
1873
1874                 year = (wxDateTime_t)val;
1875             }
1876             else if ( isDay )
1877             {
1878                 if ( haveDay )
1879                     break;
1880
1881                 haveDay = true;
1882
1883                 day = (wxDateTime_t)val;
1884             }
1885             else if ( isMonth )
1886             {
1887                 haveMon = true;
1888
1889                 mon = (Month)(val - 1);
1890             }
1891         }
1892         else // not a number
1893         {
1894             // be careful not to overwrite the current mon value
1895             Month mon2 = GetMonthFromName(token, Name_Full | Name_Abbr);
1896             if ( mon2 != Inv_Month )
1897             {
1898                 // it's a month
1899                 if ( haveMon )
1900                 {
1901                     // but we already have a month - maybe we guessed wrong?
1902                     if ( !haveDay )
1903                     {
1904                         // no need to check in month range as always < 12, but
1905                         // the days are counted from 1 unlike the months
1906                         day = (wxDateTime_t)(mon + 1);
1907                         haveDay = true;
1908                     }
1909                     else
1910                     {
1911                         // could possible be the year (doesn't the year come
1912                         // before the month in the japanese format?) (FIXME)
1913                         break;
1914                     }
1915                 }
1916
1917                 mon = mon2;
1918
1919                 haveMon = true;
1920             }
1921             else // not a valid month name
1922             {
1923                 WeekDay wday2 = GetWeekDayFromName(token, Name_Full | Name_Abbr);
1924                 if ( wday2 != Inv_WeekDay )
1925                 {
1926                     // a week day
1927                     if ( haveWDay )
1928                     {
1929                         break;
1930                     }
1931
1932                     wday = wday2;
1933
1934                     haveWDay = true;
1935                 }
1936                 else // not a valid weekday name
1937                 {
1938                     // try the ordinals
1939                     static const char *ordinals[] =
1940                     {
1941                         wxTRANSLATE("first"),
1942                         wxTRANSLATE("second"),
1943                         wxTRANSLATE("third"),
1944                         wxTRANSLATE("fourth"),
1945                         wxTRANSLATE("fifth"),
1946                         wxTRANSLATE("sixth"),
1947                         wxTRANSLATE("seventh"),
1948                         wxTRANSLATE("eighth"),
1949                         wxTRANSLATE("ninth"),
1950                         wxTRANSLATE("tenth"),
1951                         wxTRANSLATE("eleventh"),
1952                         wxTRANSLATE("twelfth"),
1953                         wxTRANSLATE("thirteenth"),
1954                         wxTRANSLATE("fourteenth"),
1955                         wxTRANSLATE("fifteenth"),
1956                         wxTRANSLATE("sixteenth"),
1957                         wxTRANSLATE("seventeenth"),
1958                         wxTRANSLATE("eighteenth"),
1959                         wxTRANSLATE("nineteenth"),
1960                         wxTRANSLATE("twentieth"),
1961                         // that's enough - otherwise we'd have problems with
1962                         // composite (or not) ordinals
1963                     };
1964
1965                     size_t n;
1966                     for ( n = 0; n < WXSIZEOF(ordinals); n++ )
1967                     {
1968                         if ( token.CmpNoCase(ordinals[n]) == 0 )
1969                         {
1970                             break;
1971                         }
1972                     }
1973
1974                     if ( n == WXSIZEOF(ordinals) )
1975                     {
1976                         // stop here - something unknown
1977                         break;
1978                     }
1979
1980                     // it's a day
1981                     if ( haveDay )
1982                     {
1983                         // don't try anything here (as in case of numeric day
1984                         // above) - the symbolic day spec should always
1985                         // precede the month/year
1986                         break;
1987                     }
1988
1989                     haveDay = true;
1990
1991                     day = (wxDateTime_t)(n + 1);
1992                 }
1993             }
1994         }
1995
1996         nPosCur = tok.GetPosition();
1997     }
1998
1999     // either no more tokens or the scan was stopped by something we couldn't
2000     // parse - in any case, see if we can construct a date from what we have
2001     if ( !haveDay && !haveWDay )
2002     {
2003         wxLogDebug(_T("ParseDate: no day, no weekday hence no date."));
2004
2005         return NULL;
2006     }
2007
2008     if ( haveWDay && (haveMon || haveYear || haveDay) &&
2009          !(haveDay && haveMon && haveYear) )
2010     {
2011         // without adjectives (which we don't support here) the week day only
2012         // makes sense completely separately or with the full date
2013         // specification (what would "Wed 1999" mean?)
2014         return NULL;
2015     }
2016
2017     if ( !haveWDay && haveYear && !(haveDay && haveMon) )
2018     {
2019         // may be we have month and day instead of day and year?
2020         if ( haveDay && !haveMon )
2021         {
2022             if ( day <= 12  )
2023             {
2024                 // exchange day and month
2025                 mon = (wxDateTime::Month)(day - 1);
2026
2027                 // we're in the current year then
2028                 if ( (year > 0) && (year <= (int)GetNumberOfDays(mon, Inv_Year)) )
2029                 {
2030                     day = (wxDateTime_t)year;
2031
2032                     haveMon = true;
2033                     haveYear = false;
2034                 }
2035                 //else: no, can't exchange, leave haveMon == false
2036             }
2037         }
2038
2039         if ( !haveMon )
2040         {
2041             // if we give the year, month and day must be given too
2042             wxLogDebug(_T("ParseDate: day and month should be specified if year is."));
2043
2044             return NULL;
2045         }
2046     }
2047
2048     if ( !haveMon )
2049     {
2050         mon = GetCurrentMonth();
2051     }
2052
2053     if ( !haveYear )
2054     {
2055         year = GetCurrentYear();
2056     }
2057
2058     if ( haveDay )
2059     {
2060         // normally we check the day above but the check is optimistic in case
2061         // we find the day before its month/year so we have to redo it now
2062         if ( day > GetNumberOfDays(mon, year) )
2063             return NULL;
2064
2065         Set(day, mon, year);
2066
2067         if ( haveWDay )
2068         {
2069             // check that it is really the same
2070             if ( GetWeekDay() != wday )
2071             {
2072                 // inconsistency detected
2073                 wxLogDebug(_T("ParseDate: inconsistent day/weekday."));
2074
2075                 return NULL;
2076             }
2077         }
2078     }
2079     else // haveWDay
2080     {
2081         *this = Today();
2082
2083         SetToWeekDayInSameWeek(wday);
2084     }
2085
2086     // return the pointer to the first unparsed char
2087     p += nPosCur;
2088     if ( nPosCur && wxStrchr(dateDelimiters, *(p - 1)) )
2089     {
2090         // if we couldn't parse the token after the delimiter, put back the
2091         // delimiter as well
2092         p--;
2093     }
2094
2095     const size_t endpos = p - date.wx_str();
2096     if ( end )
2097         *end = date.begin() + endpos;
2098
2099     return date.c_str() + endpos;
2100 }
2101
2102 const char *
2103 wxDateTime::ParseTime(const wxString& time, wxString::const_iterator *end)
2104 {
2105     // first try some extra things
2106     static const struct
2107     {
2108         const char *name;
2109         wxDateTime_t  hour;
2110     } stdTimes[] =
2111     {
2112         { wxTRANSLATE("noon"),      12 },
2113         { wxTRANSLATE("midnight"),  00 },
2114         // anything else?
2115     };
2116
2117     for ( size_t n = 0; n < WXSIZEOF(stdTimes); n++ )
2118     {
2119         wxString timeString = wxGetTranslation(stdTimes[n].name);
2120         size_t len = timeString.length();
2121         if ( timeString.CmpNoCase(wxString(time, len)) == 0 )
2122         {
2123             // casts required by DigitalMars
2124             Set(stdTimes[n].hour, wxDateTime_t(0), wxDateTime_t(0));
2125
2126             if ( end )
2127                 *end = time.begin() + len;
2128
2129             return time.c_str() + len;
2130         }
2131     }
2132
2133     // try all time formats we may think about in the order from longest to
2134     // shortest
2135     static const char *timeFormats[] =
2136     {
2137         "%I:%M:%S %p",  // 12hour with AM/PM
2138         "%H:%M:%S",     // could be the same or 24 hour one so try it too
2139         "%I:%M %p",     // 12hour with AM/PM but without seconds
2140         "%H:%M:%S",     // and a possibly 24 hour version without seconds
2141         "%X",           // possibly something from above or maybe something
2142                         // completely different -- try it last
2143
2144         // TODO: parse timezones
2145     };
2146
2147     for ( size_t nFmt = 0; nFmt < WXSIZEOF(timeFormats); nFmt++ )
2148     {
2149         const char *result = ParseFormat(time, timeFormats[nFmt], end);
2150         if ( result )
2151             return result;
2152     }
2153
2154     return NULL;
2155 }
2156
2157 // ----------------------------------------------------------------------------
2158 // Workdays and holidays support
2159 // ----------------------------------------------------------------------------
2160
2161 bool wxDateTime::IsWorkDay(Country WXUNUSED(country)) const
2162 {
2163     return !wxDateTimeHolidayAuthority::IsHoliday(*this);
2164 }
2165
2166 // ============================================================================
2167 // wxDateSpan
2168 // ============================================================================
2169
2170 wxDateSpan WXDLLIMPEXP_BASE operator*(int n, const wxDateSpan& ds)
2171 {
2172     wxDateSpan ds1(ds);
2173     return ds1.Multiply(n);
2174 }
2175
2176 // ============================================================================
2177 // wxTimeSpan
2178 // ============================================================================
2179
2180 wxTimeSpan WXDLLIMPEXP_BASE operator*(int n, const wxTimeSpan& ts)
2181 {
2182     return wxTimeSpan(ts).Multiply(n);
2183 }
2184
2185 // this enum is only used in wxTimeSpan::Format() below but we can't declare
2186 // it locally to the method as it provokes an internal compiler error in egcs
2187 // 2.91.60 when building with -O2
2188 enum TimeSpanPart
2189 {
2190     Part_Week,
2191     Part_Day,
2192     Part_Hour,
2193     Part_Min,
2194     Part_Sec,
2195     Part_MSec
2196 };
2197
2198 // not all strftime(3) format specifiers make sense here because, for example,
2199 // a time span doesn't have a year nor a timezone
2200 //
2201 // Here are the ones which are supported (all of them are supported by strftime
2202 // as well):
2203 //  %H          hour in 24 hour format
2204 //  %M          minute (00 - 59)
2205 //  %S          second (00 - 59)
2206 //  %%          percent sign
2207 //
2208 // Also, for MFC CTimeSpan compatibility, we support
2209 //  %D          number of days
2210 //
2211 // And, to be better than MFC :-), we also have
2212 //  %E          number of wEeks
2213 //  %l          milliseconds (000 - 999)
2214 wxString wxTimeSpan::Format(const wxString& format) const
2215 {
2216     // we deal with only positive time spans here and just add the sign in
2217     // front for the negative ones
2218     if ( IsNegative() )
2219     {
2220         wxString str(Negate().Format(format));
2221         return "-" + str;
2222     }
2223
2224     wxCHECK_MSG( !format.empty(), wxEmptyString,
2225                  _T("NULL format in wxTimeSpan::Format") );
2226
2227     wxString str;
2228     str.Alloc(format.length());
2229
2230     // Suppose we have wxTimeSpan ts(1 /* hour */, 2 /* min */, 3 /* sec */)
2231     //
2232     // Then, of course, ts.Format("%H:%M:%S") must return "01:02:03", but the
2233     // question is what should ts.Format("%S") do? The code here returns "3273"
2234     // in this case (i.e. the total number of seconds, not just seconds % 60)
2235     // because, for me, this call means "give me entire time interval in
2236     // seconds" and not "give me the seconds part of the time interval"
2237     //
2238     // If we agree that it should behave like this, it is clear that the
2239     // interpretation of each format specifier depends on the presence of the
2240     // other format specs in the string: if there was "%H" before "%M", we
2241     // should use GetMinutes() % 60, otherwise just GetMinutes() &c
2242
2243     // we remember the most important unit found so far
2244     TimeSpanPart partBiggest = Part_MSec;
2245
2246     for ( wxString::const_iterator pch = format.begin(); pch != format.end(); ++pch )
2247     {
2248         wxChar ch = *pch;
2249
2250         if ( ch == _T('%') )
2251         {
2252             // the start of the format specification of the printf() below
2253             wxString fmtPrefix(_T('%'));
2254
2255             // the number
2256             long n;
2257
2258             // the number of digits for the format string, 0 if unused
2259             unsigned digits = 0;
2260
2261             ch = *++pch;    // get the format spec char
2262             switch ( ch )
2263             {
2264                 default:
2265                     wxFAIL_MSG( _T("invalid format character") );
2266                     // fall through
2267
2268                 case _T('%'):
2269                     str += ch;
2270
2271                     // skip the part below switch
2272                     continue;
2273
2274                 case _T('D'):
2275                     n = GetDays();
2276                     if ( partBiggest < Part_Day )
2277                     {
2278                         n %= DAYS_PER_WEEK;
2279                     }
2280                     else
2281                     {
2282                         partBiggest = Part_Day;
2283                     }
2284                     break;
2285
2286                 case _T('E'):
2287                     partBiggest = Part_Week;
2288                     n = GetWeeks();
2289                     break;
2290
2291                 case _T('H'):
2292                     n = GetHours();
2293                     if ( partBiggest < Part_Hour )
2294                     {
2295                         n %= HOURS_PER_DAY;
2296                     }
2297                     else
2298                     {
2299                         partBiggest = Part_Hour;
2300                     }
2301
2302                     digits = 2;
2303                     break;
2304
2305                 case _T('l'):
2306                     n = GetMilliseconds().ToLong();
2307                     if ( partBiggest < Part_MSec )
2308                     {
2309                         n %= 1000;
2310                     }
2311                     //else: no need to reset partBiggest to Part_MSec, it is
2312                     //      the least significant one anyhow
2313
2314                     digits = 3;
2315                     break;
2316
2317                 case _T('M'):
2318                     n = GetMinutes();
2319                     if ( partBiggest < Part_Min )
2320                     {
2321                         n %= MIN_PER_HOUR;
2322                     }
2323                     else
2324                     {
2325                         partBiggest = Part_Min;
2326                     }
2327
2328                     digits = 2;
2329                     break;
2330
2331                 case _T('S'):
2332                     n = GetSeconds().ToLong();
2333                     if ( partBiggest < Part_Sec )
2334                     {
2335                         n %= SEC_PER_MIN;
2336                     }
2337                     else
2338                     {
2339                         partBiggest = Part_Sec;
2340                     }
2341
2342                     digits = 2;
2343                     break;
2344             }
2345
2346             if ( digits )
2347             {
2348                 fmtPrefix << _T("0") << digits;
2349             }
2350
2351             str += wxString::Format(fmtPrefix + _T("ld"), n);
2352         }
2353         else
2354         {
2355             // normal character, just copy
2356             str += ch;
2357         }
2358     }
2359
2360     return str;
2361 }
2362
2363 #endif // wxUSE_DATETIME