]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/datetime.cpp
added some utils (tex2rtf, helpgen, makegen) to make system
[wxWidgets.git] / src / common / datetime.cpp
... / ...
CommitLineData
1///////////////////////////////////////////////////////////////////////////////
2// Name: wx/datetime.h
3// Purpose: implementation of time/date related classes
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 license
17///////////////////////////////////////////////////////////////////////////////
18
19/*
20 * Implementation notes:
21 *
22 * 1. the time is stored as a 64bit integer containing the signed number of
23 * milliseconds since Jan 1. 1970 (the Unix Epoch) - so it is always
24 * expressed in GMT.
25 *
26 * 2. the range is thus something about 580 million years, but due to current
27 * algorithms limitations, only dates from Nov 24, 4714BC are handled
28 *
29 * 3. standard ANSI C functions are used to do time calculations whenever
30 * possible, i.e. when the date is in the range Jan 1, 1970 to 2038
31 *
32 * 4. otherwise, the calculations are done by converting the date to/from JDN
33 * first (the range limitation mentioned above comes from here: the
34 * algorithm used by Scott E. Lee's code only works for positive JDNs, more
35 * or less)
36 *
37 * 5. the object constructed for the given DD-MM-YYYY HH:MM:SS corresponds to
38 * this moment in local time and may be converted to the object
39 * corresponding to the same date/time in another time zone by using
40 * ToTimezone()
41 *
42 * 6. the conversions to the current (or any other) timezone are done when the
43 * internal time representation is converted to the broken-down one in
44 * wxDateTime::Tm.
45 */
46
47// ============================================================================
48// declarations
49// ============================================================================
50
51// ----------------------------------------------------------------------------
52// headers
53// ----------------------------------------------------------------------------
54
55#ifdef __GNUG__
56 #pragma implementation "datetime.h"
57#endif
58
59// For compilers that support precompilation, includes "wx.h".
60#include "wx/wxprec.h"
61
62#ifdef __BORLANDC__
63 #pragma hdrstop
64#endif
65
66#ifndef WX_PRECOMP
67 #include "wx/string.h"
68 #include "wx/intl.h"
69 #include "wx/log.h"
70#endif // WX_PRECOMP
71
72#include "wx/thread.h"
73#include "wx/tokenzr.h"
74#include "wx/module.h"
75
76#define wxDEFINE_TIME_CONSTANTS // before including datetime.h
77
78#include "wx/datetime.h"
79
80// ----------------------------------------------------------------------------
81// conditional compilation
82// ----------------------------------------------------------------------------
83
84#if defined(HAVE_STRPTIME) && defined(__LINUX__)
85 // glibc 2.0.7 strptime() is broken - the following snippet causes it to
86 // crash (instead of just failing):
87 //
88 // strncpy(buf, "Tue Dec 21 20:25:40 1999", 128);
89 // strptime(buf, "%x", &tm);
90 //
91 // so don't use it
92 #undef HAVE_STRPTIME
93#endif // broken strptime()
94
95#ifndef WX_TIMEZONE
96 #if defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)
97 #define WX_TIMEZONE _timezone
98 #elif defined(__MWERKS__)
99 long wxmw_timezone = 28800;
100 #define WX_TIMEZONE wxmw_timezone ;
101 #else // unknown platform - try timezone
102 #define WX_TIMEZONE timezone
103 #endif
104#endif // !WX_TIMEZONE
105
106// ----------------------------------------------------------------------------
107// private classes
108// ----------------------------------------------------------------------------
109
110class wxDateTimeHolidaysModule : public wxModule
111{
112public:
113 virtual bool OnInit()
114 {
115 wxDateTimeHolidayAuthority::AddAuthority(new wxDateTimeWorkDays);
116
117 return TRUE;
118 }
119
120 virtual void OnExit()
121 {
122 wxDateTimeHolidayAuthority::ClearAllAuthorities();
123 }
124
125private:
126 DECLARE_DYNAMIC_CLASS(wxDateTimeHolidaysModule)
127};
128
129IMPLEMENT_DYNAMIC_CLASS(wxDateTimeHolidaysModule, wxModule)
130
131// ----------------------------------------------------------------------------
132// constants
133// ----------------------------------------------------------------------------
134
135// some trivial ones
136static const int MONTHS_IN_YEAR = 12;
137
138static const int SECONDS_IN_MINUTE = 60;
139
140static const long SECONDS_PER_DAY = 86400l;
141
142static const long MILLISECONDS_PER_DAY = 86400000l;
143
144// this is the integral part of JDN of the midnight of Jan 1, 1970
145// (i.e. JDN(Jan 1, 1970) = 2440587.5)
146static const long EPOCH_JDN = 2440587l;
147
148// the date of JDN -0.5 (as we don't work with fractional parts, this is the
149// reference date for us) is Nov 24, 4714BC
150static const int JDN_0_YEAR = -4713;
151static const int JDN_0_MONTH = wxDateTime::Nov;
152static const int JDN_0_DAY = 24;
153
154// the constants used for JDN calculations
155static const long JDN_OFFSET = 32046l;
156static const long DAYS_PER_5_MONTHS = 153l;
157static const long DAYS_PER_4_YEARS = 1461l;
158static const long DAYS_PER_400_YEARS = 146097l;
159
160// this array contains the cumulated number of days in all previous months for
161// normal and leap years
162static const wxDateTime::wxDateTime_t gs_cumulatedDays[2][MONTHS_IN_YEAR] =
163{
164 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
165 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
166};
167
168// ----------------------------------------------------------------------------
169// global data
170// ----------------------------------------------------------------------------
171
172static wxDateTime gs_dtDefault;
173
174wxDateTime& wxDefaultDateTime = gs_dtDefault;
175
176wxDateTime::Country wxDateTime::ms_country = wxDateTime::Country_Unknown;
177
178// ----------------------------------------------------------------------------
179// private globals
180// ----------------------------------------------------------------------------
181
182// a critical section is needed to protect GetTimeZone() static
183// variable in MT case
184#if wxUSE_THREADS
185 static wxCriticalSection gs_critsectTimezone;
186#endif // wxUSE_THREADS
187
188// ----------------------------------------------------------------------------
189// private functions
190// ----------------------------------------------------------------------------
191
192// debugger helper: shows what the date really is
193#ifdef __WXDEBUG__
194extern const wxChar *wxDumpDate(const wxDateTime* dt)
195{
196 static wxChar buf[128];
197
198 wxStrcpy(buf, dt->Format(_T("%Y-%m-%d (%a) %H:%M:%S")));
199
200 return buf;
201}
202#endif // Debug
203
204// get the number of days in the given month of the given year
205static inline
206wxDateTime::wxDateTime_t GetNumOfDaysInMonth(int year, wxDateTime::Month month)
207{
208 // the number of days in month in Julian/Gregorian calendar: the first line
209 // is for normal years, the second one is for the leap ones
210 static wxDateTime::wxDateTime_t daysInMonth[2][MONTHS_IN_YEAR] =
211 {
212 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
213 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
214 };
215
216 return daysInMonth[wxDateTime::IsLeapYear(year)][month];
217}
218
219// ensure that the timezone variable is set by calling localtime
220static int GetTimeZone()
221{
222 // set to TRUE when the timezone is set
223 static bool s_timezoneSet = FALSE;
224
225 wxCRIT_SECT_LOCKER(lock, gs_critsectTimezone);
226
227 if ( !s_timezoneSet )
228 {
229 // just call localtime() instead of figuring out whether this system
230 // supports tzset(), _tzset() or something else
231 time_t t;
232 (void)localtime(&t);
233
234 s_timezoneSet = TRUE;
235 }
236
237 return (int)WX_TIMEZONE;
238}
239
240// return the integral part of the JDN for the midnight of the given date (to
241// get the real JDN you need to add 0.5, this is, in fact, JDN of the
242// noon of the previous day)
243static long GetTruncatedJDN(wxDateTime::wxDateTime_t day,
244 wxDateTime::Month mon,
245 int year)
246{
247 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
248
249 // check the date validity
250 wxASSERT_MSG(
251 (year > JDN_0_YEAR) ||
252 ((year == JDN_0_YEAR) && (mon > JDN_0_MONTH)) ||
253 ((year == JDN_0_YEAR) && (mon == JDN_0_MONTH) && (day >= JDN_0_DAY)),
254 _T("date out of range - can't convert to JDN")
255 );
256
257 // make the year positive to avoid problems with negative numbers division
258 year += 4800;
259
260 // months are counted from March here
261 int month;
262 if ( mon >= wxDateTime::Mar )
263 {
264 month = mon - 2;
265 }
266 else
267 {
268 month = mon + 10;
269 year--;
270 }
271
272 // now we can simply add all the contributions together
273 return ((year / 100) * DAYS_PER_400_YEARS) / 4
274 + ((year % 100) * DAYS_PER_4_YEARS) / 4
275 + (month * DAYS_PER_5_MONTHS + 2) / 5
276 + day
277 - JDN_OFFSET;
278}
279
280// this function is a wrapper around strftime(3)
281static wxString CallStrftime(const wxChar *format, const tm* tm)
282{
283 wxChar buf[4096];
284 if ( !wxStrftime(buf, WXSIZEOF(buf), format, tm) )
285 {
286 // buffer is too small?
287 wxFAIL_MSG(_T("strftime() failed"));
288 }
289
290 return wxString(buf);
291}
292
293// if year and/or month have invalid values, replace them with the current ones
294static void ReplaceDefaultYearMonthWithCurrent(int *year,
295 wxDateTime::Month *month)
296{
297 struct tm *tmNow = NULL;
298
299 if ( *year == wxDateTime::Inv_Year )
300 {
301 tmNow = wxDateTime::GetTmNow();
302
303 *year = 1900 + tmNow->tm_year;
304 }
305
306 if ( *month == wxDateTime::Inv_Month )
307 {
308 if ( !tmNow )
309 tmNow = wxDateTime::GetTmNow();
310
311 *month = (wxDateTime::Month)tmNow->tm_mon;
312 }
313}
314
315// fll the struct tm with default values
316static void InitTm(struct tm& tm)
317{
318 // struct tm may have etxra fields (undocumented and with unportable
319 // names) which, nevertheless, must be set to 0
320 memset(&tm, 0, sizeof(struct tm));
321
322 tm.tm_mday = 1; // mday 0 is invalid
323 tm.tm_year = 76; // any valid year
324 tm.tm_isdst = -1; // auto determine
325}
326
327// parsing helpers
328// ---------------
329
330// return the month if the string is a month name or Inv_Month otherwise
331static wxDateTime::Month GetMonthFromName(const wxString& name, int flags)
332{
333 wxDateTime::Month mon;
334 for ( mon = wxDateTime::Jan; mon < wxDateTime::Inv_Month; wxNextMonth(mon) )
335 {
336 // case-insensitive comparison either one of or with both abbreviated
337 // and not versions
338 if ( flags & wxDateTime::Name_Full )
339 {
340 if ( name.CmpNoCase(wxDateTime::
341 GetMonthName(mon, wxDateTime::Name_Full)) == 0 )
342 {
343 break;
344 }
345 }
346
347 if ( flags & wxDateTime::Name_Abbr )
348 {
349 if ( name.CmpNoCase(wxDateTime::
350 GetMonthName(mon, wxDateTime::Name_Abbr)) == 0 )
351 {
352 break;
353 }
354 }
355 }
356
357 return mon;
358}
359
360// return the weekday if the string is a weekday name or Inv_WeekDay otherwise
361static wxDateTime::WeekDay GetWeekDayFromName(const wxString& name, int flags)
362{
363 wxDateTime::WeekDay wd;
364 for ( wd = wxDateTime::Sun; wd < wxDateTime::Inv_WeekDay; wxNextWDay(wd) )
365 {
366 // case-insensitive comparison either one of or with both abbreviated
367 // and not versions
368 if ( flags & wxDateTime::Name_Full )
369 {
370 if ( name.CmpNoCase(wxDateTime::
371 GetWeekDayName(wd, wxDateTime::Name_Full)) == 0 )
372 {
373 break;
374 }
375 }
376
377 if ( flags & wxDateTime::Name_Abbr )
378 {
379 if ( name.CmpNoCase(wxDateTime::
380 GetWeekDayName(wd, wxDateTime::Name_Abbr)) == 0 )
381 {
382 break;
383 }
384 }
385 }
386
387 return wd;
388}
389
390// scans all digits and returns the resulting number
391static bool GetNumericToken(const wxChar*& p, unsigned long *number)
392{
393 wxString s;
394 while ( wxIsdigit(*p) )
395 {
396 s += *p++;
397 }
398
399 return !!s && s.ToULong(number);
400}
401
402// scans all alphabetic characters and returns the resulting string
403static wxString GetAlphaToken(const wxChar*& p)
404{
405 wxString s;
406 while ( wxIsalpha(*p) )
407 {
408 s += *p++;
409 }
410
411 return s;
412}
413
414// ============================================================================
415// implementation of wxDateTime
416// ============================================================================
417
418// ----------------------------------------------------------------------------
419// struct Tm
420// ----------------------------------------------------------------------------
421
422wxDateTime::Tm::Tm()
423{
424 year = (wxDateTime_t)wxDateTime::Inv_Year;
425 mon = wxDateTime::Inv_Month;
426 mday = 0;
427 hour = min = sec = msec = 0;
428 wday = wxDateTime::Inv_WeekDay;
429}
430
431wxDateTime::Tm::Tm(const struct tm& tm, const TimeZone& tz)
432 : m_tz(tz)
433{
434 msec = 0;
435 sec = tm.tm_sec;
436 min = tm.tm_min;
437 hour = tm.tm_hour;
438 mday = tm.tm_mday;
439 mon = (wxDateTime::Month)tm.tm_mon;
440 year = 1900 + tm.tm_year;
441 wday = tm.tm_wday;
442 yday = tm.tm_yday;
443}
444
445bool wxDateTime::Tm::IsValid() const
446{
447 // we allow for the leap seconds, although we don't use them (yet)
448 return (year != wxDateTime::Inv_Year) && (mon != wxDateTime::Inv_Month) &&
449 (mday <= GetNumOfDaysInMonth(year, mon)) &&
450 (hour < 24) && (min < 60) && (sec < 62) && (msec < 1000);
451}
452
453void wxDateTime::Tm::ComputeWeekDay()
454{
455 // compute the week day from day/month/year: we use the dumbest algorithm
456 // possible: just compute our JDN and then use the (simple to derive)
457 // formula: weekday = (JDN + 1.5) % 7
458 wday = (wxDateTime::WeekDay)(GetTruncatedJDN(mday, mon, year) + 2) % 7;
459}
460
461void wxDateTime::Tm::AddMonths(int monDiff)
462{
463 // normalize the months field
464 while ( monDiff < -mon )
465 {
466 year--;
467
468 monDiff += MONTHS_IN_YEAR;
469 }
470
471 while ( monDiff + mon >= MONTHS_IN_YEAR )
472 {
473 year++;
474
475 monDiff -= MONTHS_IN_YEAR;
476 }
477
478 mon = (wxDateTime::Month)(mon + monDiff);
479
480 wxASSERT_MSG( mon >= 0 && mon < MONTHS_IN_YEAR, _T("logic error") );
481
482 // NB: we don't check here that the resulting date is valid, this function
483 // is private and the caller must check it if needed
484}
485
486void wxDateTime::Tm::AddDays(int dayDiff)
487{
488 // normalize the days field
489 while ( dayDiff + mday < 1 )
490 {
491 AddMonths(-1);
492
493 dayDiff += GetNumOfDaysInMonth(year, mon);
494 }
495
496 mday += dayDiff;
497 while ( mday > GetNumOfDaysInMonth(year, mon) )
498 {
499 mday -= GetNumOfDaysInMonth(year, mon);
500
501 AddMonths(1);
502 }
503
504 wxASSERT_MSG( mday > 0 && mday <= GetNumOfDaysInMonth(year, mon),
505 _T("logic error") );
506}
507
508// ----------------------------------------------------------------------------
509// class TimeZone
510// ----------------------------------------------------------------------------
511
512wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz)
513{
514 switch ( tz )
515 {
516 case wxDateTime::Local:
517 // get the offset from C RTL: it returns the difference GMT-local
518 // while we want to have the offset _from_ GMT, hence the '-'
519 m_offset = -GetTimeZone();
520 break;
521
522 case wxDateTime::GMT_12:
523 case wxDateTime::GMT_11:
524 case wxDateTime::GMT_10:
525 case wxDateTime::GMT_9:
526 case wxDateTime::GMT_8:
527 case wxDateTime::GMT_7:
528 case wxDateTime::GMT_6:
529 case wxDateTime::GMT_5:
530 case wxDateTime::GMT_4:
531 case wxDateTime::GMT_3:
532 case wxDateTime::GMT_2:
533 case wxDateTime::GMT_1:
534 m_offset = -3600*(wxDateTime::GMT0 - tz);
535 break;
536
537 case wxDateTime::GMT0:
538 case wxDateTime::GMT1:
539 case wxDateTime::GMT2:
540 case wxDateTime::GMT3:
541 case wxDateTime::GMT4:
542 case wxDateTime::GMT5:
543 case wxDateTime::GMT6:
544 case wxDateTime::GMT7:
545 case wxDateTime::GMT8:
546 case wxDateTime::GMT9:
547 case wxDateTime::GMT10:
548 case wxDateTime::GMT11:
549 case wxDateTime::GMT12:
550 m_offset = 3600*(tz - wxDateTime::GMT0);
551 break;
552
553 case wxDateTime::A_CST:
554 // Central Standard Time in use in Australia = UTC + 9.5
555 m_offset = 60l*(9*60 + 30);
556 break;
557
558 default:
559 wxFAIL_MSG( _T("unknown time zone") );
560 }
561}
562
563// ----------------------------------------------------------------------------
564// static functions
565// ----------------------------------------------------------------------------
566
567/* static */
568bool wxDateTime::IsLeapYear(int year, wxDateTime::Calendar cal)
569{
570 if ( year == Inv_Year )
571 year = GetCurrentYear();
572
573 if ( cal == Gregorian )
574 {
575 // in Gregorian calendar leap years are those divisible by 4 except
576 // those divisible by 100 unless they're also divisible by 400
577 // (in some countries, like Russia and Greece, additional corrections
578 // exist, but they won't manifest themselves until 2700)
579 return (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0));
580 }
581 else if ( cal == Julian )
582 {
583 // in Julian calendar the rule is simpler
584 return year % 4 == 0;
585 }
586 else
587 {
588 wxFAIL_MSG(_T("unknown calendar"));
589
590 return FALSE;
591 }
592}
593
594/* static */
595int wxDateTime::GetCentury(int year)
596{
597 return year > 0 ? year / 100 : year / 100 - 1;
598}
599
600/* static */
601int wxDateTime::ConvertYearToBC(int year)
602{
603 // year 0 is BC 1
604 return year > 0 ? year : year - 1;
605}
606
607/* static */
608int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal)
609{
610 switch ( cal )
611 {
612 case Gregorian:
613 return Now().GetYear();
614
615 case Julian:
616 wxFAIL_MSG(_T("TODO"));
617 break;
618
619 default:
620 wxFAIL_MSG(_T("unsupported calendar"));
621 break;
622 }
623
624 return Inv_Year;
625}
626
627/* static */
628wxDateTime::Month wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal)
629{
630 switch ( cal )
631 {
632 case Gregorian:
633 return Now().GetMonth();
634
635 case Julian:
636 wxFAIL_MSG(_T("TODO"));
637 break;
638
639 default:
640 wxFAIL_MSG(_T("unsupported calendar"));
641 break;
642 }
643
644 return Inv_Month;
645}
646
647/* static */
648wxDateTime::wxDateTime_t wxDateTime::GetNumberOfDays(int year, Calendar cal)
649{
650 if ( year == Inv_Year )
651 {
652 // take the current year if none given
653 year = GetCurrentYear();
654 }
655
656 switch ( cal )
657 {
658 case Gregorian:
659 case Julian:
660 return IsLeapYear(year) ? 366 : 365;
661
662 default:
663 wxFAIL_MSG(_T("unsupported calendar"));
664 break;
665 }
666
667 return 0;
668}
669
670/* static */
671wxDateTime::wxDateTime_t wxDateTime::GetNumberOfDays(wxDateTime::Month month,
672 int year,
673 wxDateTime::Calendar cal)
674{
675 wxCHECK_MSG( month < MONTHS_IN_YEAR, 0, _T("invalid month") );
676
677 if ( cal == Gregorian || cal == Julian )
678 {
679 if ( year == Inv_Year )
680 {
681 // take the current year if none given
682 year = GetCurrentYear();
683 }
684
685 return GetNumOfDaysInMonth(year, month);
686 }
687 else
688 {
689 wxFAIL_MSG(_T("unsupported calendar"));
690
691 return 0;
692 }
693}
694
695/* static */
696wxString wxDateTime::GetMonthName(wxDateTime::Month month,
697 wxDateTime::NameFlags flags)
698{
699 wxCHECK_MSG( month != Inv_Month, _T(""), _T("invalid month") );
700
701 // notice that we must set all the fields to avoid confusing libc (GNU one
702 // gets confused to a crash if we don't do this)
703 tm tm;
704 InitTm(tm);
705 tm.tm_mon = month;
706
707 return CallStrftime(flags == Name_Abbr ? _T("%b") : _T("%B"), &tm);
708}
709
710/* static */
711wxString wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday,
712 wxDateTime::NameFlags flags)
713{
714 wxCHECK_MSG( wday != Inv_WeekDay, _T(""), _T("invalid weekday") );
715
716 // take some arbitrary Sunday
717 tm tm;
718 InitTm(tm);
719 tm.tm_mday = 28;
720 tm.tm_mon = Nov;
721 tm.tm_year = 99;
722
723 // and offset it by the number of days needed to get the correct wday
724 tm.tm_mday += wday;
725
726 // call mktime() to normalize it...
727 (void)mktime(&tm);
728
729 // ... and call strftime()
730 return CallStrftime(flags == Name_Abbr ? _T("%a") : _T("%A"), &tm);
731}
732
733/* static */
734void wxDateTime::GetAmPmStrings(wxString *am, wxString *pm)
735{
736 tm tm;
737 InitTm(tm);
738 if ( am )
739 {
740 *am = CallStrftime(_T("%p"), &tm);
741 }
742 if ( pm )
743 {
744 tm.tm_hour = 13;
745 *pm = CallStrftime(_T("%p"), &tm);
746 }
747}
748
749// ----------------------------------------------------------------------------
750// Country stuff: date calculations depend on the country (DST, work days,
751// ...), so we need to know which rules to follow.
752// ----------------------------------------------------------------------------
753
754/* static */
755wxDateTime::Country wxDateTime::GetCountry()
756{
757 // TODO use LOCALE_ICOUNTRY setting under Win32
758
759 if ( ms_country == Country_Unknown )
760 {
761 // try to guess from the time zone name
762 time_t t = time(NULL);
763 struct tm *tm = localtime(&t);
764
765 wxString tz = CallStrftime(_T("%Z"), tm);
766 if ( tz == _T("WET") || tz == _T("WEST") )
767 {
768 ms_country = UK;
769 }
770 else if ( tz == _T("CET") || tz == _T("CEST") )
771 {
772 ms_country = Country_EEC;
773 }
774 else if ( tz == _T("MSK") || tz == _T("MSD") )
775 {
776 ms_country = Russia;
777 }
778 else if ( tz == _T("AST") || tz == _T("ADT") ||
779 tz == _T("EST") || tz == _T("EDT") ||
780 tz == _T("CST") || tz == _T("CDT") ||
781 tz == _T("MST") || tz == _T("MDT") ||
782 tz == _T("PST") || tz == _T("PDT") )
783 {
784 ms_country = USA;
785 }
786 else
787 {
788 // well, choose a default one
789 ms_country = USA;
790 }
791 }
792
793 return ms_country;
794}
795
796/* static */
797void wxDateTime::SetCountry(wxDateTime::Country country)
798{
799 ms_country = country;
800}
801
802/* static */
803bool wxDateTime::IsWestEuropeanCountry(Country country)
804{
805 if ( country == Country_Default )
806 {
807 country = GetCountry();
808 }
809
810 return (Country_WesternEurope_Start <= country) &&
811 (country <= Country_WesternEurope_End);
812}
813
814// ----------------------------------------------------------------------------
815// DST calculations: we use 3 different rules for the West European countries,
816// USA and for the rest of the world. This is undoubtedly false for many
817// countries, but I lack the necessary info (and the time to gather it),
818// please add the other rules here!
819// ----------------------------------------------------------------------------
820
821/* static */
822bool wxDateTime::IsDSTApplicable(int year, Country country)
823{
824 if ( year == Inv_Year )
825 {
826 // take the current year if none given
827 year = GetCurrentYear();
828 }
829
830 if ( country == Country_Default )
831 {
832 country = GetCountry();
833 }
834
835 switch ( country )
836 {
837 case USA:
838 case UK:
839 // DST was first observed in the US and UK during WWI, reused
840 // during WWII and used again since 1966
841 return year >= 1966 ||
842 (year >= 1942 && year <= 1945) ||
843 (year == 1918 || year == 1919);
844
845 default:
846 // assume that it started after WWII
847 return year > 1950;
848 }
849}
850
851/* static */
852wxDateTime wxDateTime::GetBeginDST(int year, Country country)
853{
854 if ( year == Inv_Year )
855 {
856 // take the current year if none given
857 year = GetCurrentYear();
858 }
859
860 if ( country == Country_Default )
861 {
862 country = GetCountry();
863 }
864
865 if ( !IsDSTApplicable(year, country) )
866 {
867 return wxInvalidDateTime;
868 }
869
870 wxDateTime dt;
871
872 if ( IsWestEuropeanCountry(country) || (country == Russia) )
873 {
874 // DST begins at 1 a.m. GMT on the last Sunday of March
875 if ( !dt.SetToLastWeekDay(Sun, Mar, year) )
876 {
877 // weird...
878 wxFAIL_MSG( _T("no last Sunday in March?") );
879 }
880
881 dt += wxTimeSpan::Hours(1);
882
883 // disable DST tests because it could result in an infinite recursion!
884 dt.MakeGMT(TRUE);
885 }
886 else switch ( country )
887 {
888 case USA:
889 switch ( year )
890 {
891 case 1918:
892 case 1919:
893 // don't know for sure - assume it was in effect all year
894
895 case 1943:
896 case 1944:
897 case 1945:
898 dt.Set(1, Jan, year);
899 break;
900
901 case 1942:
902 // DST was installed Feb 2, 1942 by the Congress
903 dt.Set(2, Feb, year);
904 break;
905
906 // Oil embargo changed the DST period in the US
907 case 1974:
908 dt.Set(6, Jan, 1974);
909 break;
910
911 case 1975:
912 dt.Set(23, Feb, 1975);
913 break;
914
915 default:
916 // before 1986, DST begun on the last Sunday of April, but
917 // in 1986 Reagan changed it to begin at 2 a.m. of the
918 // first Sunday in April
919 if ( year < 1986 )
920 {
921 if ( !dt.SetToLastWeekDay(Sun, Apr, year) )
922 {
923 // weird...
924 wxFAIL_MSG( _T("no first Sunday in April?") );
925 }
926 }
927 else
928 {
929 if ( !dt.SetToWeekDay(Sun, 1, Apr, year) )
930 {
931 // weird...
932 wxFAIL_MSG( _T("no first Sunday in April?") );
933 }
934 }
935
936 dt += wxTimeSpan::Hours(2);
937
938 // TODO what about timezone??
939 }
940
941 break;
942
943 default:
944 // assume Mar 30 as the start of the DST for the rest of the world
945 // - totally bogus, of course
946 dt.Set(30, Mar, year);
947 }
948
949 return dt;
950}
951
952/* static */
953wxDateTime wxDateTime::GetEndDST(int year, Country country)
954{
955 if ( year == Inv_Year )
956 {
957 // take the current year if none given
958 year = GetCurrentYear();
959 }
960
961 if ( country == Country_Default )
962 {
963 country = GetCountry();
964 }
965
966 if ( !IsDSTApplicable(year, country) )
967 {
968 return wxInvalidDateTime;
969 }
970
971 wxDateTime dt;
972
973 if ( IsWestEuropeanCountry(country) || (country == Russia) )
974 {
975 // DST ends at 1 a.m. GMT on the last Sunday of October
976 if ( !dt.SetToLastWeekDay(Sun, Oct, year) )
977 {
978 // weirder and weirder...
979 wxFAIL_MSG( _T("no last Sunday in October?") );
980 }
981
982 dt += wxTimeSpan::Hours(1);
983
984 // disable DST tests because it could result in an infinite recursion!
985 dt.MakeGMT(TRUE);
986 }
987 else switch ( country )
988 {
989 case USA:
990 switch ( year )
991 {
992 case 1918:
993 case 1919:
994 // don't know for sure - assume it was in effect all year
995
996 case 1943:
997 case 1944:
998 dt.Set(31, Dec, year);
999 break;
1000
1001 case 1945:
1002 // the time was reset after the end of the WWII
1003 dt.Set(30, Sep, year);
1004 break;
1005
1006 default:
1007 // DST ends at 2 a.m. on the last Sunday of October
1008 if ( !dt.SetToLastWeekDay(Sun, Oct, year) )
1009 {
1010 // weirder and weirder...
1011 wxFAIL_MSG( _T("no last Sunday in October?") );
1012 }
1013
1014 dt += wxTimeSpan::Hours(2);
1015
1016 // TODO what about timezone??
1017 }
1018 break;
1019
1020 default:
1021 // assume October 26th as the end of the DST - totally bogus too
1022 dt.Set(26, Oct, year);
1023 }
1024
1025 return dt;
1026}
1027
1028// ----------------------------------------------------------------------------
1029// constructors and assignment operators
1030// ----------------------------------------------------------------------------
1031
1032// the values in the tm structure contain the local time
1033wxDateTime& wxDateTime::Set(const struct tm& tm)
1034{
1035 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1036
1037 struct tm tm2(tm);
1038 time_t timet = mktime(&tm2);
1039
1040 if ( timet == (time_t)-1 )
1041 {
1042 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1043 // less than timezone - try to make it work for this case
1044 if ( tm2.tm_year == 70 && tm2.tm_mon == 0 && tm2.tm_mday == 1 )
1045 {
1046 // add timezone to make sure that date is in range
1047 tm2.tm_sec -= GetTimeZone();
1048
1049 timet = mktime(&tm2);
1050 if ( timet != (time_t)-1 )
1051 {
1052 timet += GetTimeZone();
1053
1054 return Set(timet);
1055 }
1056 }
1057
1058 wxFAIL_MSG( _T("mktime() failed") );
1059
1060 return wxInvalidDateTime;
1061 }
1062 else
1063 {
1064 return Set(timet);
1065 }
1066}
1067
1068wxDateTime& wxDateTime::Set(wxDateTime_t hour,
1069 wxDateTime_t minute,
1070 wxDateTime_t second,
1071 wxDateTime_t millisec)
1072{
1073 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1074
1075 // we allow seconds to be 61 to account for the leap seconds, even if we
1076 // don't use them really
1077 wxCHECK_MSG( hour < 24 && second < 62 && minute < 60 && millisec < 1000,
1078 wxInvalidDateTime,
1079 _T("Invalid time in wxDateTime::Set()") );
1080
1081 // get the current date from system
1082 struct tm *tm = GetTmNow();
1083
1084 wxCHECK_MSG( tm, wxInvalidDateTime, _T("localtime() failed") );
1085
1086 // adjust the time
1087 tm->tm_hour = hour;
1088 tm->tm_min = minute;
1089 tm->tm_sec = second;
1090
1091 (void)Set(*tm);
1092
1093 // and finally adjust milliseconds
1094 return SetMillisecond(millisec);
1095}
1096
1097wxDateTime& wxDateTime::Set(wxDateTime_t day,
1098 Month month,
1099 int year,
1100 wxDateTime_t hour,
1101 wxDateTime_t minute,
1102 wxDateTime_t second,
1103 wxDateTime_t millisec)
1104{
1105 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1106
1107 wxCHECK_MSG( hour < 24 && second < 62 && minute < 60 && millisec < 1000,
1108 wxInvalidDateTime,
1109 _T("Invalid time in wxDateTime::Set()") );
1110
1111 ReplaceDefaultYearMonthWithCurrent(&year, &month);
1112
1113 wxCHECK_MSG( (0 < day) && (day <= GetNumberOfDays(month, year)),
1114 wxInvalidDateTime,
1115 _T("Invalid date in wxDateTime::Set()") );
1116
1117 // the range of time_t type (inclusive)
1118 static const int yearMinInRange = 1970;
1119 static const int yearMaxInRange = 2037;
1120
1121 // test only the year instead of testing for the exact end of the Unix
1122 // time_t range - it doesn't bring anything to do more precise checks
1123 if ( year >= yearMinInRange && year <= yearMaxInRange )
1124 {
1125 // use the standard library version if the date is in range - this is
1126 // probably more efficient than our code
1127 struct tm tm;
1128 tm.tm_year = year - 1900;
1129 tm.tm_mon = month;
1130 tm.tm_mday = day;
1131 tm.tm_hour = hour;
1132 tm.tm_min = minute;
1133 tm.tm_sec = second;
1134 tm.tm_isdst = -1; // mktime() will guess it
1135
1136 (void)Set(tm);
1137
1138 // and finally adjust milliseconds
1139 return SetMillisecond(millisec);
1140 }
1141 else
1142 {
1143 // do time calculations ourselves: we want to calculate the number of
1144 // milliseconds between the given date and the epoch
1145
1146 // get the JDN for the midnight of this day
1147 m_time = GetTruncatedJDN(day, month, year);
1148 m_time -= EPOCH_JDN;
1149 m_time *= SECONDS_PER_DAY * TIME_T_FACTOR;
1150
1151 // JDN corresponds to GMT, we take localtime
1152 Add(wxTimeSpan(hour, minute, second + GetTimeZone(), millisec));
1153 }
1154
1155 return *this;
1156}
1157
1158wxDateTime& wxDateTime::Set(double jdn)
1159{
1160 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1161 // EPOCH_JDN + 0.5
1162 jdn -= EPOCH_JDN + 0.5;
1163
1164 jdn *= MILLISECONDS_PER_DAY;
1165
1166 m_time.Assign(jdn);
1167
1168 return *this;
1169}
1170
1171wxDateTime& wxDateTime::ResetTime()
1172{
1173 Tm tm = GetTm();
1174
1175 if ( tm.hour || tm.min || tm.sec || tm.msec )
1176 {
1177 tm.msec =
1178 tm.sec =
1179 tm.min =
1180 tm.hour = 0;
1181
1182 Set(tm);
1183 }
1184
1185 return *this;
1186}
1187
1188// ----------------------------------------------------------------------------
1189// time_t <-> broken down time conversions
1190// ----------------------------------------------------------------------------
1191
1192wxDateTime::Tm wxDateTime::GetTm(const TimeZone& tz) const
1193{
1194 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1195
1196 time_t time = GetTicks();
1197 if ( time != (time_t)-1 )
1198 {
1199 // use C RTL functions
1200 tm *tm;
1201 if ( tz.GetOffset() == -GetTimeZone() )
1202 {
1203 // we are working with local time
1204 tm = localtime(&time);
1205
1206 // should never happen
1207 wxCHECK_MSG( tm, Tm(), _T("gmtime() failed") );
1208 }
1209 else
1210 {
1211 time += (time_t)tz.GetOffset();
1212#ifdef __VMS__ // time is unsigned so avoid warning
1213 int time2 = (int) time;
1214 if ( time2 >= 0 )
1215#else
1216 if ( time >= 0 )
1217#endif
1218 {
1219 tm = gmtime(&time);
1220
1221 // should never happen
1222 wxCHECK_MSG( tm, Tm(), _T("gmtime() failed") );
1223 }
1224 else
1225 {
1226 tm = (struct tm *)NULL;
1227 }
1228 }
1229
1230 if ( tm )
1231 {
1232 return Tm(*tm, tz);
1233 }
1234 //else: use generic code below
1235 }
1236
1237 // remember the time and do the calculations with the date only - this
1238 // eliminates rounding errors of the floating point arithmetics
1239
1240 wxLongLong timeMidnight = m_time + tz.GetOffset() * 1000;
1241
1242 long timeOnly = (timeMidnight % MILLISECONDS_PER_DAY).ToLong();
1243
1244 // we want to always have positive time and timeMidnight to be really
1245 // the midnight before it
1246 if ( timeOnly < 0 )
1247 {
1248 timeOnly = MILLISECONDS_PER_DAY + timeOnly;
1249 }
1250
1251 timeMidnight -= timeOnly;
1252
1253 // calculate the Gregorian date from JDN for the midnight of our date:
1254 // this will yield day, month (in 1..12 range) and year
1255
1256 // actually, this is the JDN for the noon of the previous day
1257 long jdn = (timeMidnight / MILLISECONDS_PER_DAY).ToLong() + EPOCH_JDN;
1258
1259 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1260
1261 wxASSERT_MSG( jdn > -2, _T("JDN out of range") );
1262
1263 // calculate the century
1264 long temp = (jdn + JDN_OFFSET) * 4 - 1;
1265 long century = temp / DAYS_PER_400_YEARS;
1266
1267 // then the year and day of year (1 <= dayOfYear <= 366)
1268 temp = ((temp % DAYS_PER_400_YEARS) / 4) * 4 + 3;
1269 long year = (century * 100) + (temp / DAYS_PER_4_YEARS);
1270 long dayOfYear = (temp % DAYS_PER_4_YEARS) / 4 + 1;
1271
1272 // and finally the month and day of the month
1273 temp = dayOfYear * 5 - 3;
1274 long month = temp / DAYS_PER_5_MONTHS;
1275 long day = (temp % DAYS_PER_5_MONTHS) / 5 + 1;
1276
1277 // month is counted from March - convert to normal
1278 if ( month < 10 )
1279 {
1280 month += 3;
1281 }
1282 else
1283 {
1284 year += 1;
1285 month -= 9;
1286 }
1287
1288 // year is offset by 4800
1289 year -= 4800;
1290
1291 // check that the algorithm gave us something reasonable
1292 wxASSERT_MSG( (0 < month) && (month <= 12), _T("invalid month") );
1293 wxASSERT_MSG( (1 <= day) && (day < 32), _T("invalid day") );
1294 wxASSERT_MSG( (INT_MIN <= year) && (year <= INT_MAX),
1295 _T("year range overflow") );
1296
1297 // construct Tm from these values
1298 Tm tm;
1299 tm.year = (int)year;
1300 tm.mon = (Month)(month - 1); // algorithm yields 1 for January, not 0
1301 tm.mday = (wxDateTime_t)day;
1302 tm.msec = (wxDateTime_t)(timeOnly % 1000);
1303 timeOnly -= tm.msec;
1304 timeOnly /= 1000; // now we have time in seconds
1305
1306 tm.sec = (wxDateTime_t)(timeOnly % 60);
1307 timeOnly -= tm.sec;
1308 timeOnly /= 60; // now we have time in minutes
1309
1310 tm.min = (wxDateTime_t)(timeOnly % 60);
1311 timeOnly -= tm.min;
1312
1313 tm.hour = (wxDateTime_t)(timeOnly / 60);
1314
1315 return tm;
1316}
1317
1318wxDateTime& wxDateTime::SetYear(int year)
1319{
1320 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1321
1322 Tm tm(GetTm());
1323 tm.year = year;
1324 Set(tm);
1325
1326 return *this;
1327}
1328
1329wxDateTime& wxDateTime::SetMonth(Month month)
1330{
1331 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1332
1333 Tm tm(GetTm());
1334 tm.mon = month;
1335 Set(tm);
1336
1337 return *this;
1338}
1339
1340wxDateTime& wxDateTime::SetDay(wxDateTime_t mday)
1341{
1342 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1343
1344 Tm tm(GetTm());
1345 tm.mday = mday;
1346 Set(tm);
1347
1348 return *this;
1349}
1350
1351wxDateTime& wxDateTime::SetHour(wxDateTime_t hour)
1352{
1353 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1354
1355 Tm tm(GetTm());
1356 tm.hour = hour;
1357 Set(tm);
1358
1359 return *this;
1360}
1361
1362wxDateTime& wxDateTime::SetMinute(wxDateTime_t min)
1363{
1364 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1365
1366 Tm tm(GetTm());
1367 tm.min = min;
1368 Set(tm);
1369
1370 return *this;
1371}
1372
1373wxDateTime& wxDateTime::SetSecond(wxDateTime_t sec)
1374{
1375 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1376
1377 Tm tm(GetTm());
1378 tm.sec = sec;
1379 Set(tm);
1380
1381 return *this;
1382}
1383
1384wxDateTime& wxDateTime::SetMillisecond(wxDateTime_t millisecond)
1385{
1386 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1387
1388 // we don't need to use GetTm() for this one
1389 m_time -= m_time % 1000l;
1390 m_time += millisecond;
1391
1392 return *this;
1393}
1394
1395// ----------------------------------------------------------------------------
1396// wxDateTime arithmetics
1397// ----------------------------------------------------------------------------
1398
1399wxDateTime& wxDateTime::Add(const wxDateSpan& diff)
1400{
1401 Tm tm(GetTm());
1402
1403 tm.year += diff.GetYears();
1404 tm.AddMonths(diff.GetMonths());
1405
1406 // check that the resulting date is valid
1407 if ( tm.mday > GetNumOfDaysInMonth(tm.year, tm.mon) )
1408 {
1409 // We suppose that when adding one month to Jan 31 we want to get Feb
1410 // 28 (or 29), i.e. adding a month to the last day of the month should
1411 // give the last day of the next month which is quite logical.
1412 //
1413 // Unfortunately, there is no logic way to understand what should
1414 // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1415 // We make it Feb 28 (last day too), but it is highly questionable.
1416 tm.mday = GetNumOfDaysInMonth(tm.year, tm.mon);
1417 }
1418
1419 tm.AddDays(diff.GetTotalDays());
1420
1421 Set(tm);
1422
1423 wxASSERT_MSG( IsSameTime(tm),
1424 _T("Add(wxDateSpan) shouldn't modify time") );
1425
1426 return *this;
1427}
1428
1429// ----------------------------------------------------------------------------
1430// Weekday and monthday stuff
1431// ----------------------------------------------------------------------------
1432
1433bool wxDateTime::SetToTheWeek(wxDateTime_t numWeek, WeekDay weekday)
1434{
1435 int year = GetYear();
1436
1437 // Jan 4 always lies in the 1st week of the year
1438 Set(4, Jan, year);
1439 SetToWeekDayInSameWeek(weekday) += wxDateSpan::Weeks(numWeek);
1440
1441 if ( GetYear() != year )
1442 {
1443 // oops... numWeek was too big
1444 return FALSE;
1445 }
1446
1447 return TRUE;
1448}
1449
1450wxDateTime& wxDateTime::SetToLastMonthDay(Month month,
1451 int year)
1452{
1453 // take the current month/year if none specified
1454 if ( year == Inv_Year )
1455 year = GetYear();
1456 if ( month == Inv_Month )
1457 month = GetMonth();
1458
1459 return Set(GetNumOfDaysInMonth(year, month), month, year);
1460}
1461
1462wxDateTime& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday)
1463{
1464 wxCHECK_MSG( weekday != Inv_WeekDay, wxInvalidDateTime, _T("invalid weekday") );
1465
1466 WeekDay wdayThis = GetWeekDay();
1467 if ( weekday == wdayThis )
1468 {
1469 // nothing to do
1470 return *this;
1471 }
1472 else if ( weekday < wdayThis )
1473 {
1474 return Substract(wxDateSpan::Days(wdayThis - weekday));
1475 }
1476 else // weekday > wdayThis
1477 {
1478 return Add(wxDateSpan::Days(weekday - wdayThis));
1479 }
1480}
1481
1482wxDateTime& wxDateTime::SetToNextWeekDay(WeekDay weekday)
1483{
1484 wxCHECK_MSG( weekday != Inv_WeekDay, wxInvalidDateTime, _T("invalid weekday") );
1485
1486 int diff;
1487 WeekDay wdayThis = GetWeekDay();
1488 if ( weekday == wdayThis )
1489 {
1490 // nothing to do
1491 return *this;
1492 }
1493 else if ( weekday < wdayThis )
1494 {
1495 // need to advance a week
1496 diff = 7 - (wdayThis - weekday);
1497 }
1498 else // weekday > wdayThis
1499 {
1500 diff = weekday - wdayThis;
1501 }
1502
1503 return Add(wxDateSpan::Days(diff));
1504}
1505
1506wxDateTime& wxDateTime::SetToPrevWeekDay(WeekDay weekday)
1507{
1508 wxCHECK_MSG( weekday != Inv_WeekDay, wxInvalidDateTime, _T("invalid weekday") );
1509
1510 int diff;
1511 WeekDay wdayThis = GetWeekDay();
1512 if ( weekday == wdayThis )
1513 {
1514 // nothing to do
1515 return *this;
1516 }
1517 else if ( weekday > wdayThis )
1518 {
1519 // need to go to previous week
1520 diff = 7 - (weekday - wdayThis);
1521 }
1522 else // weekday < wdayThis
1523 {
1524 diff = wdayThis - weekday;
1525 }
1526
1527 return Substract(wxDateSpan::Days(diff));
1528}
1529
1530bool wxDateTime::SetToWeekDay(WeekDay weekday,
1531 int n,
1532 Month month,
1533 int year)
1534{
1535 wxCHECK_MSG( weekday != Inv_WeekDay, FALSE, _T("invalid weekday") );
1536
1537 // we don't check explicitly that -5 <= n <= 5 because we will return FALSE
1538 // anyhow in such case - but may be should still give an assert for it?
1539
1540 // take the current month/year if none specified
1541 ReplaceDefaultYearMonthWithCurrent(&year, &month);
1542
1543 wxDateTime dt;
1544
1545 // TODO this probably could be optimised somehow...
1546
1547 if ( n > 0 )
1548 {
1549 // get the first day of the month
1550 dt.Set(1, month, year);
1551
1552 // get its wday
1553 WeekDay wdayFirst = dt.GetWeekDay();
1554
1555 // go to the first weekday of the month
1556 int diff = weekday - wdayFirst;
1557 if ( diff < 0 )
1558 diff += 7;
1559
1560 // add advance n-1 weeks more
1561 diff += 7*(n - 1);
1562
1563 dt += wxDateSpan::Days(diff);
1564 }
1565 else // count from the end of the month
1566 {
1567 // get the last day of the month
1568 dt.SetToLastMonthDay(month, year);
1569
1570 // get its wday
1571 WeekDay wdayLast = dt.GetWeekDay();
1572
1573 // go to the last weekday of the month
1574 int diff = wdayLast - weekday;
1575 if ( diff < 0 )
1576 diff += 7;
1577
1578 // and rewind n-1 weeks from there
1579 diff += 7*(-n - 1);
1580
1581 dt -= wxDateSpan::Days(diff);
1582 }
1583
1584 // check that it is still in the same month
1585 if ( dt.GetMonth() == month )
1586 {
1587 *this = dt;
1588
1589 return TRUE;
1590 }
1591 else
1592 {
1593 // no such day in this month
1594 return FALSE;
1595 }
1596}
1597
1598wxDateTime::wxDateTime_t wxDateTime::GetDayOfYear(const TimeZone& tz) const
1599{
1600 Tm tm(GetTm(tz));
1601
1602 return gs_cumulatedDays[IsLeapYear(tm.year)][tm.mon] + tm.mday;
1603}
1604
1605wxDateTime::wxDateTime_t wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags,
1606 const TimeZone& tz) const
1607{
1608 if ( flags == Default_First )
1609 {
1610 flags = GetCountry() == USA ? Sunday_First : Monday_First;
1611 }
1612
1613 wxDateTime_t nDayInYear = GetDayOfYear(tz);
1614 wxDateTime_t week;
1615
1616 WeekDay wd = GetWeekDay(tz);
1617 if ( flags == Sunday_First )
1618 {
1619 week = (nDayInYear - wd + 7) / 7;
1620 }
1621 else
1622 {
1623 // have to shift the week days values
1624 week = (nDayInYear - (wd - 1 + 7) % 7 + 7) / 7;
1625 }
1626
1627 // FIXME some more elegant way??
1628 WeekDay wdYearStart = wxDateTime(1, Jan, GetYear()).GetWeekDay();
1629 if ( wdYearStart == Wed || wdYearStart == Thu )
1630 {
1631 week++;
1632 }
1633
1634 return week;
1635}
1636
1637wxDateTime::wxDateTime_t wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags,
1638 const TimeZone& tz) const
1639{
1640 Tm tm = GetTm(tz);
1641 wxDateTime dtMonthStart = wxDateTime(1, tm.mon, tm.year);
1642 size_t nWeek = GetWeekOfYear(flags) - dtMonthStart.GetWeekOfYear(flags) + 1;
1643#ifdef __VMS__ // nWeek is unsigned so avoid the warning
1644 int nweek2 = (int) nWeek;
1645 if ( nweek2 < 0 )
1646#else
1647 if ( nWeek < 0 )
1648#endif
1649 {
1650 // this may happen for January when Jan, 1 is the last week of the
1651 // previous year
1652 nWeek += IsLeapYear(tm.year - 1) ? 53 : 52;
1653 }
1654
1655 return nWeek;
1656}
1657
1658wxDateTime& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday)
1659{
1660 int year = GetYear();
1661 wxCHECK_MSG( (0 < yday) && (yday <= GetNumberOfDays(year)),
1662 wxInvalidDateTime, _T("invalid year day") );
1663
1664 bool isLeap = IsLeapYear(year);
1665 for ( Month mon = Jan; mon < Inv_Month; wxNextMonth(mon) )
1666 {
1667 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
1668 // don't need it neither - because of the CHECK above we know that
1669 // yday lies in December then
1670 if ( (mon == Dec) || (yday < gs_cumulatedDays[isLeap][mon + 1]) )
1671 {
1672 Set(yday - gs_cumulatedDays[isLeap][mon], mon, year);
1673
1674 break;
1675 }
1676 }
1677
1678 return *this;
1679}
1680
1681// ----------------------------------------------------------------------------
1682// Julian day number conversion and related stuff
1683// ----------------------------------------------------------------------------
1684
1685double wxDateTime::GetJulianDayNumber() const
1686{
1687 // JDN are always expressed for the GMT dates
1688 Tm tm(ToTimezone(GMT0).GetTm(GMT0));
1689
1690 double result = GetTruncatedJDN(tm.mday, tm.mon, tm.year);
1691
1692 // add the part GetTruncatedJDN() neglected
1693 result += 0.5;
1694
1695 // and now add the time: 86400 sec = 1 JDN
1696 return result + ((double)(60*(60*tm.hour + tm.min) + tm.sec)) / 86400;
1697}
1698
1699double wxDateTime::GetRataDie() const
1700{
1701 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
1702 return GetJulianDayNumber() - 1721119.5 - 306;
1703}
1704
1705// ----------------------------------------------------------------------------
1706// timezone and DST stuff
1707// ----------------------------------------------------------------------------
1708
1709int wxDateTime::IsDST(wxDateTime::Country country) const
1710{
1711 wxCHECK_MSG( country == Country_Default, -1,
1712 _T("country support not implemented") );
1713
1714 // use the C RTL for the dates in the standard range
1715 time_t timet = GetTicks();
1716 if ( timet != (time_t)-1 )
1717 {
1718 tm *tm = localtime(&timet);
1719
1720 wxCHECK_MSG( tm, -1, _T("localtime() failed") );
1721
1722 return tm->tm_isdst;
1723 }
1724 else
1725 {
1726 int year = GetYear();
1727
1728 if ( !IsDSTApplicable(year, country) )
1729 {
1730 // no DST time in this year in this country
1731 return -1;
1732 }
1733
1734 return IsBetween(GetBeginDST(year, country), GetEndDST(year, country));
1735 }
1736}
1737
1738wxDateTime& wxDateTime::MakeTimezone(const TimeZone& tz, bool noDST)
1739{
1740 long secDiff = GetTimeZone() + tz.GetOffset();
1741
1742 // we need to know whether DST is or not in effect for this date unless
1743 // the test disabled by the caller
1744 if ( !noDST && (IsDST() == 1) )
1745 {
1746 // FIXME we assume that the DST is always shifted by 1 hour
1747 secDiff -= 3600;
1748 }
1749
1750 return Substract(wxTimeSpan::Seconds(secDiff));
1751}
1752
1753// ----------------------------------------------------------------------------
1754// wxDateTime to/from text representations
1755// ----------------------------------------------------------------------------
1756
1757wxString wxDateTime::Format(const wxChar *format, const TimeZone& tz) const
1758{
1759 wxCHECK_MSG( format, _T(""), _T("NULL format in wxDateTime::Format") );
1760
1761 time_t time = GetTicks();
1762 if ( time != (time_t)-1 )
1763 {
1764 // use strftime()
1765 tm *tm;
1766 if ( tz.GetOffset() == -GetTimeZone() )
1767 {
1768 // we are working with local time
1769 tm = localtime(&time);
1770
1771 // should never happen
1772 wxCHECK_MSG( tm, wxEmptyString, _T("localtime() failed") );
1773 }
1774 else
1775 {
1776 time += (int)tz.GetOffset();
1777
1778#ifdef __VMS__ // time is unsigned so avoid the warning
1779 int time2 = (int) time;
1780 if ( time2 >= 0 )
1781#else
1782 if ( time >= 0 )
1783#endif
1784 {
1785 tm = gmtime(&time);
1786
1787 // should never happen
1788 wxCHECK_MSG( tm, wxEmptyString, _T("gmtime() failed") );
1789 }
1790 else
1791 {
1792 tm = (struct tm *)NULL;
1793 }
1794 }
1795
1796 if ( tm )
1797 {
1798 return CallStrftime(format, tm);
1799 }
1800 //else: use generic code below
1801 }
1802
1803 // we only parse ANSI C format specifications here, no POSIX 2
1804 // complications, no GNU extensions
1805 Tm tm = GetTm(tz);
1806
1807 // used for calls to strftime() when we only deal with time
1808 struct tm tmTimeOnly;
1809 tmTimeOnly.tm_hour = tm.hour;
1810 tmTimeOnly.tm_min = tm.min;
1811 tmTimeOnly.tm_sec = tm.sec;
1812 tmTimeOnly.tm_wday = 0;
1813 tmTimeOnly.tm_yday = 0;
1814 tmTimeOnly.tm_mday = 1; // any date will do
1815 tmTimeOnly.tm_mon = 0;
1816 tmTimeOnly.tm_year = 76;
1817 tmTimeOnly.tm_isdst = 0; // no DST, we adjust for tz ourselves
1818
1819 wxString tmp, res, fmt;
1820 for ( const wxChar *p = format; *p; p++ )
1821 {
1822 if ( *p != _T('%') )
1823 {
1824 // copy as is
1825 res += *p;
1826
1827 continue;
1828 }
1829
1830 // set the default format
1831 switch ( *++p )
1832 {
1833 case _T('Y'): // year has 4 digits
1834 fmt = _T("%04d");
1835 break;
1836
1837 case _T('j'): // day of year has 3 digits
1838 fmt = _T("%03d");
1839 break;
1840
1841 default:
1842 // it's either another valid format specifier in which case
1843 // the format is "%02d" (for all the rest) or we have the
1844 // field width preceding the format in which case it will
1845 // override the default format anyhow
1846 fmt = _T("%02d");
1847 }
1848
1849restart:
1850 // start of the format specification
1851 switch ( *p )
1852 {
1853 case _T('a'): // a weekday name
1854 case _T('A'):
1855 // second parameter should be TRUE for abbreviated names
1856 res += GetWeekDayName(tm.GetWeekDay(),
1857 *p == _T('a') ? Name_Abbr : Name_Full);
1858 break;
1859
1860 case _T('b'): // a month name
1861 case _T('B'):
1862 res += GetMonthName(tm.mon,
1863 *p == _T('b') ? Name_Abbr : Name_Full);
1864 break;
1865
1866 case _T('c'): // locale default date and time representation
1867 case _T('x'): // locale default date representation
1868 //
1869 // the problem: there is no way to know what do these format
1870 // specifications correspond to for the current locale.
1871 //
1872 // the solution: use a hack and still use strftime(): first
1873 // find the YEAR which is a year in the strftime() range (1970
1874 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
1875 // of the real year. Then make a copy of the format and
1876 // replace all occurences of YEAR in it with some unique
1877 // string not appearing anywhere else in it, then use
1878 // strftime() to format the date in year YEAR and then replace
1879 // YEAR back by the real year and the unique replacement
1880 // string back with YEAR. Notice that "all occurences of YEAR"
1881 // means all occurences of 4 digit as well as 2 digit form!
1882 //
1883 // the bugs: we assume that neither of %c nor %x contains any
1884 // fields which may change between the YEAR and real year. For
1885 // example, the week number (%U, %W) and the day number (%j)
1886 // will change if one of these years is leap and the other one
1887 // is not!
1888 {
1889 // find the YEAR: normally, for any year X, Jan 1 or the
1890 // year X + 28 is the same weekday as Jan 1 of X (because
1891 // the weekday advances by 1 for each normal X and by 2
1892 // for each leap X, hence by 5 every 4 years or by 35
1893 // which is 0 mod 7 every 28 years) but this rule breaks
1894 // down if there are years between X and Y which are
1895 // divisible by 4 but not leap (i.e. divisible by 100 but
1896 // not 400), hence the correction.
1897
1898 int yearReal = GetYear(tz);
1899 int mod28 = yearReal % 28;
1900
1901 // be careful to not go too far - we risk to leave the
1902 // supported range
1903 int year;
1904 if ( mod28 < 10 )
1905 {
1906 year = 1988 + mod28; // 1988 == 0 (mod 28)
1907 }
1908 else
1909 {
1910 year = 1970 + mod28 - 10; // 1970 == 10 (mod 28)
1911 }
1912
1913 int nCentury = year / 100,
1914 nCenturyReal = yearReal / 100;
1915
1916 // need to adjust for the years divisble by 400 which are
1917 // not leap but are counted like leap ones if we just take
1918 // the number of centuries in between for nLostWeekDays
1919 int nLostWeekDays = (nCentury - nCenturyReal) -
1920 (nCentury / 4 - nCenturyReal / 4);
1921
1922 // we have to gain back the "lost" weekdays: note that the
1923 // effect of this loop is to not do anything to
1924 // nLostWeekDays (which we won't use any more), but to
1925 // (indirectly) set the year correctly
1926 while ( (nLostWeekDays % 7) != 0 )
1927 {
1928 nLostWeekDays += year++ % 4 ? 1 : 2;
1929 }
1930
1931 // at any rate, we couldn't go further than 1988 + 9 + 28!
1932 wxASSERT_MSG( year < 2030,
1933 _T("logic error in wxDateTime::Format") );
1934
1935 wxString strYear, strYear2;
1936 strYear.Printf(_T("%d"), year);
1937 strYear2.Printf(_T("%d"), year % 100);
1938
1939 // find two strings not occuring in format (this is surely
1940 // not optimal way of doing it... improvements welcome!)
1941 wxString fmt = format;
1942 wxString replacement = (wxChar)-1;
1943 while ( fmt.Find(replacement) != wxNOT_FOUND )
1944 {
1945 replacement << (wxChar)-1;
1946 }
1947
1948 wxString replacement2 = (wxChar)-2;
1949 while ( fmt.Find(replacement) != wxNOT_FOUND )
1950 {
1951 replacement << (wxChar)-2;
1952 }
1953
1954 // replace all occurences of year with it
1955 bool wasReplaced = fmt.Replace(strYear, replacement) > 0;
1956 if ( !wasReplaced )
1957 wasReplaced = fmt.Replace(strYear2, replacement2) > 0;
1958
1959 // use strftime() to format the same date but in supported
1960 // year
1961 //
1962 // NB: we assume that strftime() doesn't check for the
1963 // date validity and will happily format the date
1964 // corresponding to Feb 29 of a non leap year (which
1965 // may happen if yearReal was leap and year is not)
1966 struct tm tmAdjusted;
1967 InitTm(tmAdjusted);
1968 tmAdjusted.tm_hour = tm.hour;
1969 tmAdjusted.tm_min = tm.min;
1970 tmAdjusted.tm_sec = tm.sec;
1971 tmAdjusted.tm_wday = tm.GetWeekDay();
1972 tmAdjusted.tm_yday = GetDayOfYear();
1973 tmAdjusted.tm_mday = tm.mday;
1974 tmAdjusted.tm_mon = tm.mon;
1975 tmAdjusted.tm_year = year - 1900;
1976 tmAdjusted.tm_isdst = 0; // no DST, already adjusted
1977 wxString str = CallStrftime(*p == _T('c') ? _T("%c")
1978 : _T("%x"),
1979 &tmAdjusted);
1980
1981 // now replace the occurence of 1999 with the real year
1982 wxString strYearReal, strYearReal2;
1983 strYearReal.Printf(_T("%04d"), yearReal);
1984 strYearReal2.Printf(_T("%02d"), yearReal % 100);
1985 str.Replace(strYear, strYearReal);
1986 str.Replace(strYear2, strYearReal2);
1987
1988 // and replace back all occurences of replacement string
1989 if ( wasReplaced )
1990 {
1991 str.Replace(replacement2, strYear2);
1992 str.Replace(replacement, strYear);
1993 }
1994
1995 res += str;
1996 }
1997 break;
1998
1999 case _T('d'): // day of a month (01-31)
2000 res += wxString::Format(fmt, tm.mday);
2001 break;
2002
2003 case _T('H'): // hour in 24h format (00-23)
2004 res += wxString::Format(fmt, tm.hour);
2005 break;
2006
2007 case _T('I'): // hour in 12h format (01-12)
2008 {
2009 // 24h -> 12h, 0h -> 12h too
2010 int hour12 = tm.hour > 12 ? tm.hour - 12
2011 : tm.hour ? tm.hour : 12;
2012 res += wxString::Format(fmt, hour12);
2013 }
2014 break;
2015
2016 case _T('j'): // day of the year
2017 res += wxString::Format(fmt, GetDayOfYear(tz));
2018 break;
2019
2020 case _T('m'): // month as a number (01-12)
2021 res += wxString::Format(fmt, tm.mon + 1);
2022 break;
2023
2024 case _T('M'): // minute as a decimal number (00-59)
2025 res += wxString::Format(fmt, tm.min);
2026 break;
2027
2028 case _T('p'): // AM or PM string
2029 res += CallStrftime(_T("%p"), &tmTimeOnly);
2030 break;
2031
2032 case _T('S'): // second as a decimal number (00-61)
2033 res += wxString::Format(fmt, tm.sec);
2034 break;
2035
2036 case _T('U'): // week number in the year (Sunday 1st week day)
2037 res += wxString::Format(fmt, GetWeekOfYear(Sunday_First, tz));
2038 break;
2039
2040 case _T('W'): // week number in the year (Monday 1st week day)
2041 res += wxString::Format(fmt, GetWeekOfYear(Monday_First, tz));
2042 break;
2043
2044 case _T('w'): // weekday as a number (0-6), Sunday = 0
2045 res += wxString::Format(fmt, tm.GetWeekDay());
2046 break;
2047
2048 // case _T('x'): -- handled with "%c"
2049
2050 case _T('X'): // locale default time representation
2051 // just use strftime() to format the time for us
2052 res += CallStrftime(_T("%X"), &tmTimeOnly);
2053 break;
2054
2055 case _T('y'): // year without century (00-99)
2056 res += wxString::Format(fmt, tm.year % 100);
2057 break;
2058
2059 case _T('Y'): // year with century
2060 res += wxString::Format(fmt, tm.year);
2061 break;
2062
2063 case _T('Z'): // timezone name
2064 res += CallStrftime(_T("%Z"), &tmTimeOnly);
2065 break;
2066
2067 default:
2068 // is it the format width?
2069 fmt.Empty();
2070 while ( *p == _T('-') || *p == _T('+') ||
2071 *p == _T(' ') || wxIsdigit(*p) )
2072 {
2073 fmt += *p;
2074 }
2075
2076 if ( !fmt.IsEmpty() )
2077 {
2078 // we've only got the flags and width so far in fmt
2079 fmt.Prepend(_T('%'));
2080 fmt.Append(_T('d'));
2081
2082 goto restart;
2083 }
2084
2085 // no, it wasn't the width
2086 wxFAIL_MSG(_T("unknown format specificator"));
2087
2088 // fall through and just copy it nevertheless
2089
2090 case _T('%'): // a percent sign
2091 res += *p;
2092 break;
2093
2094 case 0: // the end of string
2095 wxFAIL_MSG(_T("missing format at the end of string"));
2096
2097 // just put the '%' which was the last char in format
2098 res += _T('%');
2099 break;
2100 }
2101 }
2102
2103 return res;
2104}
2105
2106// this function parses a string in (strict) RFC 822 format: see the section 5
2107// of the RFC for the detailed description, but briefly it's something of the
2108// form "Sat, 18 Dec 1999 00:48:30 +0100"
2109//
2110// this function is "strict" by design - it must reject anything except true
2111// RFC822 time specs.
2112//
2113// TODO a great candidate for using reg exps
2114const wxChar *wxDateTime::ParseRfc822Date(const wxChar* date)
2115{
2116 wxCHECK_MSG( date, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
2117
2118 const wxChar *p = date;
2119 const wxChar *comma = wxStrchr(p, _T(','));
2120 if ( comma )
2121 {
2122 // the part before comma is the weekday
2123
2124 // skip it for now - we don't use but might check that it really
2125 // corresponds to the specfied date
2126 p = comma + 1;
2127
2128 if ( *p != _T(' ') )
2129 {
2130 wxLogDebug(_T("no space after weekday in RFC822 time spec"));
2131
2132 return (wxChar *)NULL;
2133 }
2134
2135 p++; // skip space
2136 }
2137
2138 // the following 1 or 2 digits are the day number
2139 if ( !wxIsdigit(*p) )
2140 {
2141 wxLogDebug(_T("day number expected in RFC822 time spec, none found"));
2142
2143 return (wxChar *)NULL;
2144 }
2145
2146 wxDateTime_t day = *p++ - _T('0');
2147 if ( wxIsdigit(*p) )
2148 {
2149 day *= 10;
2150 day += *p++ - _T('0');
2151 }
2152
2153 if ( *p++ != _T(' ') )
2154 {
2155 return (wxChar *)NULL;
2156 }
2157
2158 // the following 3 letters specify the month
2159 wxString monName(p, 3);
2160 Month mon;
2161 if ( monName == _T("Jan") )
2162 mon = Jan;
2163 else if ( monName == _T("Feb") )
2164 mon = Feb;
2165 else if ( monName == _T("Mar") )
2166 mon = Mar;
2167 else if ( monName == _T("Apr") )
2168 mon = Apr;
2169 else if ( monName == _T("May") )
2170 mon = May;
2171 else if ( monName == _T("Jun") )
2172 mon = Jun;
2173 else if ( monName == _T("Jul") )
2174 mon = Jul;
2175 else if ( monName == _T("Aug") )
2176 mon = Aug;
2177 else if ( monName == _T("Sep") )
2178 mon = Sep;
2179 else if ( monName == _T("Oct") )
2180 mon = Oct;
2181 else if ( monName == _T("Nov") )
2182 mon = Nov;
2183 else if ( monName == _T("Dec") )
2184 mon = Dec;
2185 else
2186 {
2187 wxLogDebug(_T("Invalid RFC 822 month name '%s'"), monName.c_str());
2188
2189 return (wxChar *)NULL;
2190 }
2191
2192 p += 3;
2193
2194 if ( *p++ != _T(' ') )
2195 {
2196 return (wxChar *)NULL;
2197 }
2198
2199 // next is the year
2200 if ( !wxIsdigit(*p) )
2201 {
2202 // no year?
2203 return (wxChar *)NULL;
2204 }
2205
2206 int year = *p++ - _T('0');
2207
2208 if ( !wxIsdigit(*p) )
2209 {
2210 // should have at least 2 digits in the year
2211 return (wxChar *)NULL;
2212 }
2213
2214 year *= 10;
2215 year += *p++ - _T('0');
2216
2217 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
2218 if ( wxIsdigit(*p) )
2219 {
2220 year *= 10;
2221 year += *p++ - _T('0');
2222
2223 if ( !wxIsdigit(*p) )
2224 {
2225 // no 3 digit years please
2226 return (wxChar *)NULL;
2227 }
2228
2229 year *= 10;
2230 year += *p++ - _T('0');
2231 }
2232
2233 if ( *p++ != _T(' ') )
2234 {
2235 return (wxChar *)NULL;
2236 }
2237
2238 // time is in the format hh:mm:ss and seconds are optional
2239 if ( !wxIsdigit(*p) )
2240 {
2241 return (wxChar *)NULL;
2242 }
2243
2244 wxDateTime_t hour = *p++ - _T('0');
2245
2246 if ( !wxIsdigit(*p) )
2247 {
2248 return (wxChar *)NULL;
2249 }
2250
2251 hour *= 10;
2252 hour += *p++ - _T('0');
2253
2254 if ( *p++ != _T(':') )
2255 {
2256 return (wxChar *)NULL;
2257 }
2258
2259 if ( !wxIsdigit(*p) )
2260 {
2261 return (wxChar *)NULL;
2262 }
2263
2264 wxDateTime_t min = *p++ - _T('0');
2265
2266 if ( !wxIsdigit(*p) )
2267 {
2268 return (wxChar *)NULL;
2269 }
2270
2271 min *= 10;
2272 min += *p++ - _T('0');
2273
2274 wxDateTime_t sec = 0;
2275 if ( *p++ == _T(':') )
2276 {
2277 if ( !wxIsdigit(*p) )
2278 {
2279 return (wxChar *)NULL;
2280 }
2281
2282 sec = *p++ - _T('0');
2283
2284 if ( !wxIsdigit(*p) )
2285 {
2286 return (wxChar *)NULL;
2287 }
2288
2289 sec *= 10;
2290 sec += *p++ - _T('0');
2291 }
2292
2293 if ( *p++ != _T(' ') )
2294 {
2295 return (wxChar *)NULL;
2296 }
2297
2298 // and now the interesting part: the timezone
2299 int offset;
2300 if ( *p == _T('-') || *p == _T('+') )
2301 {
2302 // the explicit offset given: it has the form of hhmm
2303 bool plus = *p++ == _T('+');
2304
2305 if ( !wxIsdigit(*p) || !wxIsdigit(*(p + 1)) )
2306 {
2307 return (wxChar *)NULL;
2308 }
2309
2310 // hours
2311 offset = 60*(10*(*p - _T('0')) + (*(p + 1) - _T('0')));
2312
2313 p += 2;
2314
2315 if ( !wxIsdigit(*p) || !wxIsdigit(*(p + 1)) )
2316 {
2317 return (wxChar *)NULL;
2318 }
2319
2320 // minutes
2321 offset += 10*(*p - _T('0')) + (*(p + 1) - _T('0'));
2322
2323 if ( !plus )
2324 {
2325 offset = -offset;
2326 }
2327
2328 p += 2;
2329 }
2330 else
2331 {
2332 // the symbolic timezone given: may be either military timezone or one
2333 // of standard abbreviations
2334 if ( !*(p + 1) )
2335 {
2336 // military: Z = UTC, J unused, A = -1, ..., Y = +12
2337 static const int offsets[26] =
2338 {
2339 //A B C D E F G H I J K L M
2340 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
2341 //N O P R Q S T U V W Z Y Z
2342 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
2343 };
2344
2345 if ( *p < _T('A') || *p > _T('Z') || *p == _T('J') )
2346 {
2347 wxLogDebug(_T("Invalid militaty timezone '%c'"), *p);
2348
2349 return (wxChar *)NULL;
2350 }
2351
2352 offset = offsets[*p++ - _T('A')];
2353 }
2354 else
2355 {
2356 // abbreviation
2357 wxString tz = p;
2358 if ( tz == _T("UT") || tz == _T("UTC") || tz == _T("GMT") )
2359 offset = 0;
2360 else if ( tz == _T("AST") )
2361 offset = AST - GMT0;
2362 else if ( tz == _T("ADT") )
2363 offset = ADT - GMT0;
2364 else if ( tz == _T("EST") )
2365 offset = EST - GMT0;
2366 else if ( tz == _T("EDT") )
2367 offset = EDT - GMT0;
2368 else if ( tz == _T("CST") )
2369 offset = CST - GMT0;
2370 else if ( tz == _T("CDT") )
2371 offset = CDT - GMT0;
2372 else if ( tz == _T("MST") )
2373 offset = MST - GMT0;
2374 else if ( tz == _T("MDT") )
2375 offset = MDT - GMT0;
2376 else if ( tz == _T("PST") )
2377 offset = PST - GMT0;
2378 else if ( tz == _T("PDT") )
2379 offset = PDT - GMT0;
2380 else
2381 {
2382 wxLogDebug(_T("Unknown RFC 822 timezone '%s'"), p);
2383
2384 return (wxChar *)NULL;
2385 }
2386
2387 p += tz.length();
2388 }
2389
2390 // make it minutes
2391 offset *= 60;
2392 }
2393
2394 // the spec was correct
2395 Set(day, mon, year, hour, min, sec);
2396 MakeTimezone((wxDateTime_t)(60*offset));
2397
2398 return p;
2399}
2400
2401const wxChar *wxDateTime::ParseFormat(const wxChar *date,
2402 const wxChar *format,
2403 const wxDateTime& dateDef)
2404{
2405 wxCHECK_MSG( date && format, (wxChar *)NULL,
2406 _T("NULL pointer in wxDateTime::ParseFormat()") );
2407
2408 wxString str;
2409 unsigned long num;
2410
2411 // what fields have we found?
2412 bool haveWDay = FALSE,
2413 haveYDay = FALSE,
2414 haveDay = FALSE,
2415 haveMon = FALSE,
2416 haveYear = FALSE,
2417 haveHour = FALSE,
2418 haveMin = FALSE,
2419 haveSec = FALSE;
2420
2421 bool hourIsIn12hFormat = FALSE, // or in 24h one?
2422 isPM = FALSE; // AM by default
2423
2424 // and the value of the items we have (init them to get rid of warnings)
2425 wxDateTime_t sec = 0,
2426 min = 0,
2427 hour = 0;
2428 WeekDay wday = Inv_WeekDay;
2429 wxDateTime_t yday = 0,
2430 mday = 0;
2431 wxDateTime::Month mon = Inv_Month;
2432 int year = 0;
2433
2434 const wxChar *input = date;
2435 for ( const wxChar *fmt = format; *fmt; fmt++ )
2436 {
2437 if ( *fmt != _T('%') )
2438 {
2439 if ( wxIsspace(*fmt) )
2440 {
2441 // a white space in the format string matches 0 or more white
2442 // spaces in the input
2443 while ( wxIsspace(*input) )
2444 {
2445 input++;
2446 }
2447 }
2448 else // !space
2449 {
2450 // any other character (not whitespace, not '%') must be
2451 // matched by itself in the input
2452 if ( *input++ != *fmt )
2453 {
2454 // no match
2455 return (wxChar *)NULL;
2456 }
2457 }
2458
2459 // done with this format char
2460 continue;
2461 }
2462
2463 // start of a format specification
2464 switch ( *++fmt )
2465 {
2466 case _T('a'): // a weekday name
2467 case _T('A'):
2468 {
2469 int flag = *fmt == _T('a') ? Name_Abbr : Name_Full;
2470 wday = GetWeekDayFromName(GetAlphaToken(input), flag);
2471 if ( wday == Inv_WeekDay )
2472 {
2473 // no match
2474 return (wxChar *)NULL;
2475 }
2476 }
2477 haveWDay = TRUE;
2478 break;
2479
2480 case _T('b'): // a month name
2481 case _T('B'):
2482 {
2483 int flag = *fmt == _T('b') ? Name_Abbr : Name_Full;
2484 mon = GetMonthFromName(GetAlphaToken(input), flag);
2485 if ( mon == Inv_Month )
2486 {
2487 // no match
2488 return (wxChar *)NULL;
2489 }
2490 }
2491 haveMon = TRUE;
2492 break;
2493
2494 case _T('c'): // locale default date and time representation
2495 {
2496 wxDateTime dt;
2497
2498 // this is the format which corresponds to ctime() output
2499 // and strptime("%c") should parse it, so try it first
2500 static const wxChar *fmtCtime = _T("%a %b %d %H:%M:%S %Y");
2501
2502 const wxChar *result = dt.ParseFormat(input, fmtCtime);
2503 if ( !result )
2504 {
2505 result = dt.ParseFormat(input, _T("%x %X"));
2506 }
2507
2508 if ( !result )
2509 {
2510 result = dt.ParseFormat(input, _T("%X %x"));
2511 }
2512
2513 if ( !result )
2514 {
2515 // we've tried everything and still no match
2516 return (wxChar *)NULL;
2517 }
2518
2519 Tm tm = dt.GetTm();
2520
2521 haveDay = haveMon = haveYear =
2522 haveHour = haveMin = haveSec = TRUE;
2523
2524 hour = tm.hour;
2525 min = tm.min;
2526 sec = tm.sec;
2527
2528 year = tm.year;
2529 mon = tm.mon;
2530 mday = tm.mday;
2531
2532 input = result;
2533 }
2534 break;
2535
2536 case _T('d'): // day of a month (01-31)
2537 if ( !GetNumericToken(input, &num) || (num > 31) )
2538 {
2539 // no match
2540 return (wxChar *)NULL;
2541 }
2542
2543 // we can't check whether the day range is correct yet, will
2544 // do it later - assume ok for now
2545 haveDay = TRUE;
2546 mday = (wxDateTime_t)num;
2547 break;
2548
2549 case _T('H'): // hour in 24h format (00-23)
2550 if ( !GetNumericToken(input, &num) || (num > 23) )
2551 {
2552 // no match
2553 return (wxChar *)NULL;
2554 }
2555
2556 haveHour = TRUE;
2557 hour = (wxDateTime_t)num;
2558 break;
2559
2560 case _T('I'): // hour in 12h format (01-12)
2561 if ( !GetNumericToken(input, &num) || !num || (num > 12) )
2562 {
2563 // no match
2564 return (wxChar *)NULL;
2565 }
2566
2567 haveHour = TRUE;
2568 hourIsIn12hFormat = TRUE;
2569 hour = (wxDateTime_t)(num % 12); // 12 should be 0
2570 break;
2571
2572 case _T('j'): // day of the year
2573 if ( !GetNumericToken(input, &num) || !num || (num > 366) )
2574 {
2575 // no match
2576 return (wxChar *)NULL;
2577 }
2578
2579 haveYDay = TRUE;
2580 yday = (wxDateTime_t)num;
2581 break;
2582
2583 case _T('m'): // month as a number (01-12)
2584 if ( !GetNumericToken(input, &num) || !num || (num > 12) )
2585 {
2586 // no match
2587 return (wxChar *)NULL;
2588 }
2589
2590 haveMon = TRUE;
2591 mon = (Month)(num - 1);
2592 break;
2593
2594 case _T('M'): // minute as a decimal number (00-59)
2595 if ( !GetNumericToken(input, &num) || (num > 59) )
2596 {
2597 // no match
2598 return (wxChar *)NULL;
2599 }
2600
2601 haveMin = TRUE;
2602 min = (wxDateTime_t)num;
2603 break;
2604
2605 case _T('p'): // AM or PM string
2606 {
2607 wxString am, pm, token = GetAlphaToken(input);
2608
2609 GetAmPmStrings(&am, &pm);
2610 if ( token.CmpNoCase(pm) == 0 )
2611 {
2612 isPM = TRUE;
2613 }
2614 else if ( token.CmpNoCase(am) != 0 )
2615 {
2616 // no match
2617 return (wxChar *)NULL;
2618 }
2619 }
2620 break;
2621
2622 case _T('r'): // time as %I:%M:%S %p
2623 {
2624 wxDateTime dt;
2625 input = dt.ParseFormat(input, _T("%I:%M:%S %p"));
2626 if ( !input )
2627 {
2628 // no match
2629 return (wxChar *)NULL;
2630 }
2631
2632 haveHour = haveMin = haveSec = TRUE;
2633
2634 Tm tm = dt.GetTm();
2635 hour = tm.hour;
2636 min = tm.min;
2637 sec = tm.sec;
2638 }
2639 break;
2640
2641 case _T('R'): // time as %H:%M
2642 {
2643 wxDateTime dt;
2644 input = dt.ParseFormat(input, _T("%H:%M"));
2645 if ( !input )
2646 {
2647 // no match
2648 return (wxChar *)NULL;
2649 }
2650
2651 haveHour = haveMin = TRUE;
2652
2653 Tm tm = dt.GetTm();
2654 hour = tm.hour;
2655 min = tm.min;
2656 }
2657
2658 case _T('S'): // second as a decimal number (00-61)
2659 if ( !GetNumericToken(input, &num) || (num > 61) )
2660 {
2661 // no match
2662 return (wxChar *)NULL;
2663 }
2664
2665 haveSec = TRUE;
2666 sec = (wxDateTime_t)num;
2667 break;
2668
2669 case _T('T'): // time as %H:%M:%S
2670 {
2671 wxDateTime dt;
2672 input = dt.ParseFormat(input, _T("%H:%M:%S"));
2673 if ( !input )
2674 {
2675 // no match
2676 return (wxChar *)NULL;
2677 }
2678
2679 haveHour = haveMin = haveSec = TRUE;
2680
2681 Tm tm = dt.GetTm();
2682 hour = tm.hour;
2683 min = tm.min;
2684 sec = tm.sec;
2685 }
2686 break;
2687
2688 case _T('w'): // weekday as a number (0-6), Sunday = 0
2689 if ( !GetNumericToken(input, &num) || (wday > 6) )
2690 {
2691 // no match
2692 return (wxChar *)NULL;
2693 }
2694
2695 haveWDay = TRUE;
2696 wday = (WeekDay)num;
2697 break;
2698
2699 case _T('x'): // locale default date representation
2700#ifdef HAVE_STRPTIME
2701 // try using strptime() - it may fail even if the input is
2702 // correct but the date is out of range, so we will fall back
2703 // to our generic code anyhow (FIXME !Unicode friendly)
2704 {
2705 struct tm tm;
2706 const wxChar *result = strptime(input, "%x", &tm);
2707 if ( result )
2708 {
2709 input = result;
2710
2711 haveDay = haveMon = haveYear = TRUE;
2712
2713 year = 1900 + tm.tm_year;
2714 mon = (Month)tm.tm_mon;
2715 mday = tm.tm_mday;
2716
2717 break;
2718 }
2719 }
2720#endif // HAVE_STRPTIME
2721
2722 // TODO query the LOCALE_IDATE setting under Win32
2723 {
2724 wxDateTime dt;
2725
2726 wxString fmtDate, fmtDateAlt;
2727 if ( IsWestEuropeanCountry(GetCountry()) ||
2728 GetCountry() == Russia )
2729 {
2730 fmtDate = _T("%d/%m/%y");
2731 fmtDateAlt = _T("%m/%d/%y");
2732 }
2733 else // assume USA
2734 {
2735 fmtDate = _T("%m/%d/%y");
2736 fmtDateAlt = _T("%d/%m/%y");
2737 }
2738
2739 const wxChar *result = dt.ParseFormat(input, fmtDate);
2740
2741 if ( !result )
2742 {
2743 // ok, be nice and try another one
2744 result = dt.ParseFormat(input, fmtDateAlt);
2745 }
2746
2747 if ( !result )
2748 {
2749 // bad luck
2750 return (wxChar *)NULL;
2751 }
2752
2753 Tm tm = dt.GetTm();
2754
2755 haveDay = haveMon = haveYear = TRUE;
2756
2757 year = tm.year;
2758 mon = tm.mon;
2759 mday = tm.mday;
2760
2761 input = result;
2762 }
2763
2764 break;
2765
2766 case _T('X'): // locale default time representation
2767#ifdef HAVE_STRPTIME
2768 {
2769 // use strptime() to do it for us (FIXME !Unicode friendly)
2770 struct tm tm;
2771 input = strptime(input, "%X", &tm);
2772 if ( !input )
2773 {
2774 return (wxChar *)NULL;
2775 }
2776
2777 haveHour = haveMin = haveSec = TRUE;
2778
2779 hour = tm.tm_hour;
2780 min = tm.tm_min;
2781 sec = tm.tm_sec;
2782 }
2783#else // !HAVE_STRPTIME
2784 // TODO under Win32 we can query the LOCALE_ITIME system
2785 // setting which says whether the default time format is
2786 // 24 or 12 hour
2787 {
2788 // try to parse what follows as "%H:%M:%S" and, if this
2789 // fails, as "%I:%M:%S %p" - this should catch the most
2790 // common cases
2791 wxDateTime dt;
2792
2793 const wxChar *result = dt.ParseFormat(input, _T("%T"));
2794 if ( !result )
2795 {
2796 result = dt.ParseFormat(input, _T("%r"));
2797 }
2798
2799 if ( !result )
2800 {
2801 // no match
2802 return (wxChar *)NULL;
2803 }
2804
2805 haveHour = haveMin = haveSec = TRUE;
2806
2807 Tm tm = dt.GetTm();
2808 hour = tm.hour;
2809 min = tm.min;
2810 sec = tm.sec;
2811
2812 input = result;
2813 }
2814#endif // HAVE_STRPTIME/!HAVE_STRPTIME
2815 break;
2816
2817 case _T('y'): // year without century (00-99)
2818 if ( !GetNumericToken(input, &num) || (num > 99) )
2819 {
2820 // no match
2821 return (wxChar *)NULL;
2822 }
2823
2824 haveYear = TRUE;
2825 year = 1900 + (wxDateTime_t)num;
2826 break;
2827
2828 case _T('Y'): // year with century
2829 if ( !GetNumericToken(input, &num) )
2830 {
2831 // no match
2832 return (wxChar *)NULL;
2833 }
2834
2835 haveYear = TRUE;
2836 year = (wxDateTime_t)num;
2837 break;
2838
2839 case _T('Z'): // timezone name
2840 wxFAIL_MSG(_T("TODO"));
2841 break;
2842
2843 case _T('%'): // a percent sign
2844 if ( *input++ != _T('%') )
2845 {
2846 // no match
2847 return (wxChar *)NULL;
2848 }
2849 break;
2850
2851 case 0: // the end of string
2852 wxFAIL_MSG(_T("unexpected format end"));
2853
2854 // fall through
2855
2856 default: // not a known format spec
2857 return (wxChar *)NULL;
2858 }
2859 }
2860
2861 // format matched, try to construct a date from what we have now
2862 Tm tmDef;
2863 if ( dateDef.IsValid() )
2864 {
2865 // take this date as default
2866 tmDef = dateDef.GetTm();
2867 }
2868 else if ( m_time != 0 )
2869 {
2870 // if this date is valid, don't change it
2871 tmDef = GetTm();
2872 }
2873 else
2874 {
2875 // no default and this date is invalid - fall back to Today()
2876 tmDef = Today().GetTm();
2877 }
2878
2879 Tm tm = tmDef;
2880
2881 // set the date
2882 if ( haveYear )
2883 {
2884 tm.year = year;
2885 }
2886
2887 // TODO we don't check here that the values are consistent, if both year
2888 // day and month/day were found, we just ignore the year day and we
2889 // also always ignore the week day
2890 if ( haveMon && haveDay )
2891 {
2892 if ( mday > GetNumOfDaysInMonth(tm.year, mon) )
2893 {
2894 wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
2895
2896 return (wxChar *)NULL;
2897 }
2898
2899 tm.mon = mon;
2900 tm.mday = mday;
2901 }
2902 else if ( haveYDay )
2903 {
2904 if ( yday > GetNumberOfDays(tm.year) )
2905 {
2906 wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
2907
2908 return (wxChar *)NULL;
2909 }
2910
2911 Tm tm2 = wxDateTime(1, Jan, tm.year).SetToYearDay(yday).GetTm();
2912
2913 tm.mon = tm2.mon;
2914 tm.mday = tm2.mday;
2915 }
2916
2917 // deal with AM/PM
2918 if ( haveHour && hourIsIn12hFormat && isPM )
2919 {
2920 // translate to 24hour format
2921 hour += 12;
2922 }
2923 //else: either already in 24h format or no translation needed
2924
2925 // set the time
2926 if ( haveHour )
2927 {
2928 tm.hour = hour;
2929 }
2930
2931 if ( haveMin )
2932 {
2933 tm.min = min;
2934 }
2935
2936 if ( haveSec )
2937 {
2938 tm.sec = sec;
2939 }
2940
2941 Set(tm);
2942
2943 return input;
2944}
2945
2946const wxChar *wxDateTime::ParseDateTime(const wxChar *date)
2947{
2948 wxCHECK_MSG( date, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
2949
2950 // there is a public domain version of getdate.y, but it only works for
2951 // English...
2952 wxFAIL_MSG(_T("TODO"));
2953
2954 return (wxChar *)NULL;
2955}
2956
2957const wxChar *wxDateTime::ParseDate(const wxChar *date)
2958{
2959 // this is a simplified version of ParseDateTime() which understands only
2960 // "today" (for wxDate compatibility) and digits only otherwise (and not
2961 // all esoteric constructions ParseDateTime() knows about)
2962
2963 wxCHECK_MSG( date, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
2964
2965 const wxChar *p = date;
2966 while ( wxIsspace(*p) )
2967 p++;
2968
2969 // some special cases
2970 static struct
2971 {
2972 const wxChar *str;
2973 int dayDiffFromToday;
2974 } literalDates[] =
2975 {
2976 { wxTRANSLATE("today"), 0 },
2977 { wxTRANSLATE("yesterday"), -1 },
2978 { wxTRANSLATE("tomorrow"), 1 },
2979 };
2980
2981 for ( size_t n = 0; n < WXSIZEOF(literalDates); n++ )
2982 {
2983 wxString date = wxGetTranslation(literalDates[n].str);
2984 size_t len = date.length();
2985 if ( wxString(p, len).CmpNoCase(date) == 0 )
2986 {
2987 // nothing can follow this, so stop here
2988 p += len;
2989
2990 int dayDiffFromToday = literalDates[n].dayDiffFromToday;
2991 *this = Today();
2992 if ( dayDiffFromToday )
2993 {
2994 *this += wxDateSpan::Days(dayDiffFromToday);
2995 }
2996
2997 return p;
2998 }
2999 }
3000
3001 // what do we have?
3002 bool haveDay = FALSE, // the months day?
3003 haveWDay = FALSE, // the day of week?
3004 haveMon = FALSE, // the month?
3005 haveYear = FALSE; // the year?
3006
3007 // and the value of the items we have (init them to get rid of warnings)
3008 WeekDay wday = Inv_WeekDay;
3009 wxDateTime_t day = 0;
3010 wxDateTime::Month mon = Inv_Month;
3011 int year = 0;
3012
3013 // tokenize the string
3014 wxStringTokenizer tok(p, _T(",/-\t\n "));
3015 while ( tok.HasMoreTokens() )
3016 {
3017 wxString token = tok.GetNextToken();
3018
3019 // is it a number?
3020 unsigned long val;
3021 if ( token.ToULong(&val) )
3022 {
3023 // guess what this number is
3024
3025 bool isDay = FALSE,
3026 isMonth = FALSE,
3027 // only years are counted from 0
3028 isYear = (val == 0) || (val > 31);
3029 if ( !isYear )
3030 {
3031 // may be the month or month day or the year, assume the
3032 // month day by default and fallback to month if the range
3033 // allow it or to the year if our assumption doesn't work
3034 if ( haveDay )
3035 {
3036 // we already have the day, so may only be a month or year
3037 if ( val > 12 )
3038 {
3039 isYear = TRUE;
3040 }
3041 else
3042 {
3043 isMonth = TRUE;
3044 }
3045 }
3046 else // it may be day
3047 {
3048 isDay = TRUE;
3049
3050 // check the range
3051 if ( haveMon )
3052 {
3053 if ( val > GetNumOfDaysInMonth(haveYear ? year
3054 : Inv_Year,
3055 mon) )
3056 {
3057 // oops, it can't be a day finally
3058 isDay = FALSE;
3059
3060 if ( val > 12 )
3061 {
3062 isYear = TRUE;
3063 }
3064 else
3065 {
3066 isMonth = TRUE;
3067 }
3068 }
3069 }
3070 }
3071 }
3072
3073 // remember that we have this and stop the scan if it's the second
3074 // time we find this, except for the day logic (see there)
3075 if ( isYear )
3076 {
3077 if ( haveYear )
3078 {
3079 break;
3080 }
3081
3082 haveYear = TRUE;
3083
3084 // no roll over - 99 means 99, not 1999 for us
3085 year = (wxDateTime_t)val;
3086 }
3087 else if ( isMonth )
3088 {
3089 if ( haveMon )
3090 {
3091 break;
3092 }
3093
3094 haveMon = TRUE;
3095
3096 mon = (wxDateTime::Month)val;
3097 }
3098 else
3099 {
3100 wxASSERT_MSG( isDay, _T("logic error") );
3101
3102 if ( haveDay )
3103 {
3104 // may be were mistaken when we found it for the first
3105 // time? may be it was a month or year instead?
3106 //
3107 // this ability to "backtrack" allows us to correctly parse
3108 // both things like 01/13 and 13/01 - but, of course, we
3109 // still can't resolve the ambiguity in 01/02 (it will be
3110 // Feb 1 for us, not Jan 2 as americans might expect!)
3111 if ( (day <= 12) && !haveMon )
3112 {
3113 // exchange day and month
3114 mon = (wxDateTime::Month)day;
3115
3116 haveMon = TRUE;
3117 }
3118 else if ( !haveYear )
3119 {
3120 // exchange day and year
3121 year = day;
3122
3123 haveYear = TRUE;
3124 }
3125 }
3126
3127 haveDay = TRUE;
3128
3129 day = (wxDateTime_t)val;
3130 }
3131 }
3132 else // not a number
3133 {
3134 mon = GetMonthFromName(token, Name_Full | Name_Abbr);
3135 if ( mon != Inv_Month )
3136 {
3137 // it's a month
3138 if ( haveMon )
3139 {
3140 break;
3141 }
3142
3143 haveMon = TRUE;
3144 }
3145 else
3146 {
3147 wday = GetWeekDayFromName(token, Name_Full | Name_Abbr);
3148 if ( wday != Inv_WeekDay )
3149 {
3150 // a week day
3151 if ( haveWDay )
3152 {
3153 break;
3154 }
3155
3156 haveWDay = TRUE;
3157 }
3158 else
3159 {
3160 // try the ordinals
3161 static const wxChar *ordinals[] =
3162 {
3163 wxTRANSLATE("first"),
3164 wxTRANSLATE("second"),
3165 wxTRANSLATE("third"),
3166 wxTRANSLATE("fourth"),
3167 wxTRANSLATE("fifth"),
3168 wxTRANSLATE("sixth"),
3169 wxTRANSLATE("seventh"),
3170 wxTRANSLATE("eighth"),
3171 wxTRANSLATE("ninth"),
3172 wxTRANSLATE("tenth"),
3173 wxTRANSLATE("eleventh"),
3174 wxTRANSLATE("twelfth"),
3175 wxTRANSLATE("thirteenth"),
3176 wxTRANSLATE("fourteenth"),
3177 wxTRANSLATE("fifteenth"),
3178 wxTRANSLATE("sixteenth"),
3179 wxTRANSLATE("seventeenth"),
3180 wxTRANSLATE("eighteenth"),
3181 wxTRANSLATE("nineteenth"),
3182 wxTRANSLATE("twentieth"),
3183 // that's enough - otherwise we'd have problems with
3184 // composite (or not) ordinals otherwise
3185 };
3186
3187 size_t n;
3188 for ( n = 0; n < WXSIZEOF(ordinals); n++ )
3189 {
3190 if ( token.CmpNoCase(ordinals[n]) == 0 )
3191 {
3192 break;
3193 }
3194 }
3195
3196 if ( n == WXSIZEOF(ordinals) )
3197 {
3198 // stop here - something unknown
3199 break;
3200 }
3201
3202 // it's a day
3203 if ( haveDay )
3204 {
3205 // don't try anything here (as in case of numeric day
3206 // above) - the symbolic day spec should always
3207 // precede the month/year
3208 break;
3209 }
3210
3211 haveDay = TRUE;
3212
3213 day = n + 1;
3214 }
3215 }
3216 }
3217 }
3218
3219 // either no more tokens or the scan was stopped by something we couldn't
3220 // parse - in any case, see if we can construct a date from what we have
3221 if ( !haveDay && !haveWDay )
3222 {
3223 wxLogDebug(_T("no day, no weekday hence no date."));
3224
3225 return (wxChar *)NULL;
3226 }
3227
3228 if ( haveWDay && (haveMon || haveYear || haveDay) &&
3229 !(haveMon && haveMon && haveYear) )
3230 {
3231 // without adjectives (which we don't support here) the week day only
3232 // makes sense completely separately or with the full date
3233 // specification (what would "Wed 1999" mean?)
3234 return (wxChar *)NULL;
3235 }
3236
3237 if ( !haveMon )
3238 {
3239 mon = GetCurrentMonth();
3240 }
3241
3242 if ( !haveYear )
3243 {
3244 year = GetCurrentYear();
3245 }
3246
3247 if ( haveDay )
3248 {
3249 Set(day, mon, year);
3250
3251 if ( haveWDay )
3252 {
3253 // check that it is really the same
3254 if ( GetWeekDay() != wday )
3255 {
3256 // inconsistency detected
3257 return (wxChar *)NULL;
3258 }
3259 }
3260 }
3261 else // haveWDay
3262 {
3263 *this = Today();
3264
3265 SetToWeekDayInSameWeek(wday);
3266 }
3267
3268 // return the pointer to the next char
3269 return p + wxStrlen(p) - wxStrlen(tok.GetString());
3270}
3271
3272const wxChar *wxDateTime::ParseTime(const wxChar *time)
3273{
3274 wxCHECK_MSG( time, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
3275
3276 // first try some extra things
3277 static const struct
3278 {
3279 const wxChar *name;
3280 wxDateTime_t hour;
3281 } stdTimes[] =
3282 {
3283 { wxTRANSLATE("noon"), 12 },
3284 { wxTRANSLATE("midnight"), 00 },
3285 // anything else?
3286 };
3287
3288 for ( size_t n = 0; n < WXSIZEOF(stdTimes); n++ )
3289 {
3290 wxString timeString = wxGetTranslation(stdTimes[n].name);
3291 size_t len = timeString.length();
3292 if ( timeString.CmpNoCase(wxString(time, len)) == 0 )
3293 {
3294 Set(stdTimes[n].hour, 0, 0);
3295
3296 return time + len;
3297 }
3298 }
3299
3300 // try all time formats we may think about starting with the standard one
3301 const wxChar *result = ParseFormat(time, _T("%X"));
3302 if ( !result )
3303 {
3304 // normally, it's the same, but why not try it?
3305 result = ParseFormat(time, _T("%H:%M:%S"));
3306 }
3307
3308 if ( !result )
3309 {
3310 // 12hour with AM/PM?
3311 result = ParseFormat(time, _T("%I:%M:%S %p"));
3312 }
3313
3314 if ( !result )
3315 {
3316 // without seconds?
3317 result = ParseFormat(time, _T("%H:%M"));
3318 }
3319
3320 if ( !result )
3321 {
3322 // 12hour with AM/PM but without seconds?
3323 result = ParseFormat(time, _T("%I:%M %p"));
3324 }
3325
3326 if ( !result )
3327 {
3328 // just the hour?
3329 result = ParseFormat(time, _T("%H"));
3330 }
3331
3332 if ( !result )
3333 {
3334 // just the hour and AM/PM?
3335 result = ParseFormat(time, _T("%I %p"));
3336 }
3337
3338 // TODO: parse timezones
3339
3340 return result;
3341}
3342
3343// ----------------------------------------------------------------------------
3344// Workdays and holidays support
3345// ----------------------------------------------------------------------------
3346
3347bool wxDateTime::IsWorkDay(Country WXUNUSED(country)) const
3348{
3349 return !wxDateTimeHolidayAuthority::IsHoliday(*this);
3350}
3351
3352// ============================================================================
3353// wxTimeSpan
3354// ============================================================================
3355
3356// not all strftime(3) format specifiers make sense here because, for example,
3357// a time span doesn't have a year nor a timezone
3358//
3359// Here are the ones which are supported (all of them are supported by strftime
3360// as well):
3361// %H hour in 24 hour format
3362// %M minute (00 - 59)
3363// %S second (00 - 59)
3364// %% percent sign
3365//
3366// Also, for MFC CTimeSpan compatibility, we support
3367// %D number of days
3368//
3369// And, to be better than MFC :-), we also have
3370// %E number of wEeks
3371// %l milliseconds (000 - 999)
3372wxString wxTimeSpan::Format(const wxChar *format) const
3373{
3374 wxCHECK_MSG( format, _T(""), _T("NULL format in wxTimeSpan::Format") );
3375
3376 wxString str;
3377 str.Alloc(wxStrlen(format));
3378
3379 for ( const wxChar *pch = format; pch; pch++ )
3380 {
3381 wxChar ch = *pch;
3382
3383 if ( ch == '%' )
3384 {
3385 wxString tmp;
3386
3387 ch = *pch++;
3388 switch ( ch )
3389 {
3390 default:
3391 wxFAIL_MSG( _T("invalid format character") );
3392 // fall through
3393
3394 case '%':
3395 // will get to str << ch below
3396 break;
3397
3398 case 'D':
3399 tmp.Printf(_T("%d"), GetDays());
3400 break;
3401
3402 case 'E':
3403 tmp.Printf(_T("%d"), GetWeeks());
3404 break;
3405
3406 case 'H':
3407 tmp.Printf(_T("%02d"), GetHours());
3408 break;
3409
3410 case 'l':
3411 tmp.Printf(_T("%03ld"), GetMilliseconds().ToLong());
3412 break;
3413
3414 case 'M':
3415 tmp.Printf(_T("%02d"), GetMinutes());
3416 break;
3417
3418 case 'S':
3419 tmp.Printf(_T("%02ld"), GetSeconds().ToLong());
3420 break;
3421 }
3422
3423 if ( !!tmp )
3424 {
3425 str += tmp;
3426
3427 // skip str += ch below
3428 continue;
3429 }
3430 }
3431
3432 str += ch;
3433 }
3434
3435 return str;
3436}
3437
3438// ============================================================================
3439// wxDateTimeHolidayAuthority and related classes
3440// ============================================================================
3441
3442#include "wx/arrimpl.cpp"
3443
3444WX_DEFINE_OBJARRAY(wxDateTimeArray)
3445
3446static int wxCMPFUNC_CONV
3447wxDateTimeCompareFunc(wxDateTime **first, wxDateTime **second)
3448{
3449 wxDateTime dt1 = **first,
3450 dt2 = **second;
3451
3452 return dt1 == dt2 ? 0 : dt1 < dt2 ? -1 : +1;
3453}
3454
3455// ----------------------------------------------------------------------------
3456// wxDateTimeHolidayAuthority
3457// ----------------------------------------------------------------------------
3458
3459wxHolidayAuthoritiesArray wxDateTimeHolidayAuthority::ms_authorities;
3460
3461/* static */
3462bool wxDateTimeHolidayAuthority::IsHoliday(const wxDateTime& dt)
3463{
3464 size_t count = ms_authorities.GetCount();
3465 for ( size_t n = 0; n < count; n++ )
3466 {
3467 if ( ms_authorities[n]->DoIsHoliday(dt) )
3468 {
3469 return TRUE;
3470 }
3471 }
3472
3473 return FALSE;
3474}
3475
3476/* static */
3477size_t
3478wxDateTimeHolidayAuthority::GetHolidaysInRange(const wxDateTime& dtStart,
3479 const wxDateTime& dtEnd,
3480 wxDateTimeArray& holidays)
3481{
3482 wxDateTimeArray hol;
3483
3484 holidays.Empty();
3485
3486 size_t count = ms_authorities.GetCount();
3487 for ( size_t n = 0; n < count; n++ )
3488 {
3489 ms_authorities[n]->DoGetHolidaysInRange(dtStart, dtEnd, hol);
3490
3491 WX_APPEND_ARRAY(holidays, hol);
3492 }
3493
3494 holidays.Sort(wxDateTimeCompareFunc);
3495
3496 return holidays.GetCount();
3497}
3498
3499/* static */
3500void wxDateTimeHolidayAuthority::ClearAllAuthorities()
3501{
3502 WX_CLEAR_ARRAY(ms_authorities);
3503}
3504
3505/* static */
3506void wxDateTimeHolidayAuthority::AddAuthority(wxDateTimeHolidayAuthority *auth)
3507{
3508 ms_authorities.Add(auth);
3509}
3510
3511// ----------------------------------------------------------------------------
3512// wxDateTimeWorkDays
3513// ----------------------------------------------------------------------------
3514
3515bool wxDateTimeWorkDays::DoIsHoliday(const wxDateTime& dt) const
3516{
3517 wxDateTime::WeekDay wd = dt.GetWeekDay();
3518
3519 return (wd == wxDateTime::Sun) || (wd == wxDateTime::Sat);
3520}
3521
3522size_t wxDateTimeWorkDays::DoGetHolidaysInRange(const wxDateTime& dtStart,
3523 const wxDateTime& dtEnd,
3524 wxDateTimeArray& holidays) const
3525{
3526 if ( dtStart > dtEnd )
3527 {
3528 wxFAIL_MSG( _T("invalid date range in GetHolidaysInRange") );
3529
3530 return 0u;
3531 }
3532
3533 holidays.Empty();
3534
3535 // instead of checking all days, start with the first Sat after dtStart and
3536 // end with the last Sun before dtEnd
3537 wxDateTime dtSatFirst = dtStart.GetNextWeekDay(wxDateTime::Sat),
3538 dtSatLast = dtEnd.GetPrevWeekDay(wxDateTime::Sat),
3539 dtSunFirst = dtStart.GetNextWeekDay(wxDateTime::Sun),
3540 dtSunLast = dtEnd.GetPrevWeekDay(wxDateTime::Sun),
3541 dt;
3542
3543 for ( dt = dtSatFirst; dt <= dtSatLast; dt += wxDateSpan::Week() )
3544 {
3545 holidays.Add(dt);
3546 }
3547
3548 for ( dt = dtSunFirst; dt <= dtSunLast; dt += wxDateSpan::Week() )
3549 {
3550 holidays.Add(dt);
3551 }
3552
3553 return holidays.GetCount();
3554}