1 ///////////////////////////////////////////////////////////////////////////////
3 // Purpose: implementation of time/date related classes
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // parts of code taken from sndcal library by Scott E. Lee:
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.
16 // Licence: wxWindows license
17 ///////////////////////////////////////////////////////////////////////////////
20 * Implementation notes:
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
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
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
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
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
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
47 // ============================================================================
49 // ============================================================================
51 // ----------------------------------------------------------------------------
53 // ----------------------------------------------------------------------------
56 #pragma implementation "datetime.h"
59 // For compilers that support precompilation, includes "wx.h".
60 #include "wx/wxprec.h"
67 #include "wx/string.h"
72 #include "wx/thread.h"
73 #include "wx/tokenzr.h"
75 #define wxDEFINE_TIME_CONSTANTS // before including datetime.h
77 #include "wx/datetime.h"
79 // ----------------------------------------------------------------------------
80 // conditional compilation
81 // ----------------------------------------------------------------------------
83 #if defined(HAVE_STRPTIME) && defined(__LINUX__)
84 // glibc 2.0.7 strptime() is broken - the following snippet causes it to
85 // crash (instead of just failing):
87 // strncpy(buf, "Tue Dec 21 20:25:40 1999", 128);
88 // strptime(buf, "%x", &tm);
92 #endif // broken strptime()
95 #if defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)
96 #define WX_TIMEZONE _timezone
97 #else // unknown platform - try timezone
98 #define WX_TIMEZONE timezone
100 #endif // !WX_TIMEZONE
102 // ----------------------------------------------------------------------------
104 // ----------------------------------------------------------------------------
107 static const int MONTHS_IN_YEAR
= 12;
109 static const int SECONDS_IN_MINUTE
= 60;
111 static const long SECONDS_PER_DAY
= 86400l;
113 static const long MILLISECONDS_PER_DAY
= 86400000l;
115 // this is the integral part of JDN of the midnight of Jan 1, 1970
116 // (i.e. JDN(Jan 1, 1970) = 2440587.5)
117 static const long EPOCH_JDN
= 2440587l;
119 // the date of JDN -0.5 (as we don't work with fractional parts, this is the
120 // reference date for us) is Nov 24, 4714BC
121 static const int JDN_0_YEAR
= -4713;
122 static const int JDN_0_MONTH
= wxDateTime::Nov
;
123 static const int JDN_0_DAY
= 24;
125 // the constants used for JDN calculations
126 static const long JDN_OFFSET
= 32046l;
127 static const long DAYS_PER_5_MONTHS
= 153l;
128 static const long DAYS_PER_4_YEARS
= 1461l;
129 static const long DAYS_PER_400_YEARS
= 146097l;
131 // this array contains the cumulated number of days in all previous months for
132 // normal and leap years
133 static const wxDateTime::wxDateTime_t gs_cumulatedDays
[2][MONTHS_IN_YEAR
] =
135 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
136 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
139 // ----------------------------------------------------------------------------
141 // ----------------------------------------------------------------------------
143 static wxDateTime gs_dtDefault
;
145 wxDateTime
& wxDefaultDateTime
= gs_dtDefault
;
147 wxDateTime::Country
wxDateTime::ms_country
= wxDateTime::Country_Unknown
;
149 // ----------------------------------------------------------------------------
151 // ----------------------------------------------------------------------------
153 // a critical section is needed to protect GetTimeZone() static
154 // variable in MT case
156 static wxCriticalSection gs_critsectTimezone
;
157 #endif // wxUSE_THREADS
159 // ----------------------------------------------------------------------------
161 // ----------------------------------------------------------------------------
163 // get the number of days in the given month of the given year
165 wxDateTime::wxDateTime_t
GetNumOfDaysInMonth(int year
, wxDateTime::Month month
)
167 // the number of days in month in Julian/Gregorian calendar: the first line
168 // is for normal years, the second one is for the leap ones
169 static wxDateTime::wxDateTime_t daysInMonth
[2][MONTHS_IN_YEAR
] =
171 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
172 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
175 return daysInMonth
[wxDateTime::IsLeapYear(year
)][month
];
178 // ensure that the timezone variable is set by calling localtime
179 static int GetTimeZone()
181 // set to TRUE when the timezone is set
182 static bool s_timezoneSet
= FALSE
;
184 wxCRIT_SECT_LOCKER(lock
, gs_critsectTimezone
);
186 if ( !s_timezoneSet
)
188 // just call localtime() instead of figuring out whether this system
189 // supports tzset(), _tzset() or something else
193 s_timezoneSet
= TRUE
;
196 return (int)WX_TIMEZONE
;
199 // return the integral part of the JDN for the midnight of the given date (to
200 // get the real JDN you need to add 0.5, this is, in fact, JDN of the
201 // noon of the previous day)
202 static long GetTruncatedJDN(wxDateTime::wxDateTime_t day
,
203 wxDateTime::Month mon
,
206 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
208 // check the date validity
210 (year
> JDN_0_YEAR
) ||
211 ((year
== JDN_0_YEAR
) && (mon
> JDN_0_MONTH
)) ||
212 ((year
== JDN_0_YEAR
) && (mon
== JDN_0_MONTH
) && (day
>= JDN_0_DAY
)),
213 _T("date out of range - can't convert to JDN")
216 // make the year positive to avoid problems with negative numbers division
219 // months are counted from March here
221 if ( mon
>= wxDateTime::Mar
)
231 // now we can simply add all the contributions together
232 return ((year
/ 100) * DAYS_PER_400_YEARS
) / 4
233 + ((year
% 100) * DAYS_PER_4_YEARS
) / 4
234 + (month
* DAYS_PER_5_MONTHS
+ 2) / 5
239 // this function is a wrapper around strftime(3)
240 static wxString
CallStrftime(const wxChar
*format
, const tm
* tm
)
243 if ( !wxStrftime(buf
, WXSIZEOF(buf
), format
, tm
) )
245 // buffer is too small?
246 wxFAIL_MSG(_T("strftime() failed"));
249 return wxString(buf
);
252 // if year and/or month have invalid values, replace them with the current ones
253 static void ReplaceDefaultYearMonthWithCurrent(int *year
,
254 wxDateTime::Month
*month
)
256 struct tm
*tmNow
= NULL
;
258 if ( *year
== wxDateTime::Inv_Year
)
260 tmNow
= wxDateTime::GetTmNow();
262 *year
= 1900 + tmNow
->tm_year
;
265 if ( *month
== wxDateTime::Inv_Month
)
268 tmNow
= wxDateTime::GetTmNow();
270 *month
= (wxDateTime::Month
)tmNow
->tm_mon
;
274 // fll the struct tm with default values
275 static void InitTm(struct tm
& tm
)
277 // struct tm may have etxra fields (undocumented and with unportable
278 // names) which, nevertheless, must be set to 0
279 memset(&tm
, 0, sizeof(struct tm
));
281 tm
.tm_mday
= 1; // mday 0 is invalid
282 tm
.tm_year
= 76; // any valid year
283 tm
.tm_isdst
= -1; // auto determine
289 // return the month if the string is a month name or Inv_Month otherwise
290 static wxDateTime::Month
GetMonthFromName(const wxString
& name
, int flags
)
292 wxDateTime::Month mon
;
293 for ( mon
= wxDateTime::Jan
; mon
< wxDateTime::Inv_Month
; wxNextMonth(mon
) )
295 // case-insensitive comparison either one of or with both abbreviated
297 if ( flags
& wxDateTime::Name_Full
)
299 if ( name
.CmpNoCase(wxDateTime::
300 GetMonthName(mon
, wxDateTime::Name_Full
)) == 0 )
306 if ( flags
& wxDateTime::Name_Abbr
)
308 if ( name
.CmpNoCase(wxDateTime::
309 GetMonthName(mon
, wxDateTime::Name_Abbr
)) == 0 )
319 // return the weekday if the string is a weekday name or Inv_WeekDay otherwise
320 static wxDateTime::WeekDay
GetWeekDayFromName(const wxString
& name
, int flags
)
322 wxDateTime::WeekDay wd
;
323 for ( wd
= wxDateTime::Sun
; wd
< wxDateTime::Inv_WeekDay
; wxNextWDay(wd
) )
325 // case-insensitive comparison either one of or with both abbreviated
327 if ( flags
& wxDateTime::Name_Full
)
329 if ( name
.CmpNoCase(wxDateTime::
330 GetWeekDayName(wd
, wxDateTime::Name_Full
)) == 0 )
336 if ( flags
& wxDateTime::Name_Abbr
)
338 if ( name
.CmpNoCase(wxDateTime::
339 GetWeekDayName(wd
, wxDateTime::Name_Abbr
)) == 0 )
349 // scans all digits and returns the resulting number
350 static bool GetNumericToken(const wxChar
*& p
, unsigned long *number
)
353 while ( wxIsdigit(*p
) )
358 return !!s
&& s
.ToULong(number
);
361 // scans all alphabetic characters and returns the resulting string
362 static wxString
GetAlphaToken(const wxChar
*& p
)
365 while ( wxIsalpha(*p
) )
373 // ============================================================================
374 // implementation of wxDateTime
375 // ============================================================================
377 // ----------------------------------------------------------------------------
379 // ----------------------------------------------------------------------------
383 year
= (wxDateTime_t
)wxDateTime::Inv_Year
;
384 mon
= wxDateTime::Inv_Month
;
386 hour
= min
= sec
= msec
= 0;
387 wday
= wxDateTime::Inv_WeekDay
;
390 wxDateTime::Tm::Tm(const struct tm
& tm
, const TimeZone
& tz
)
398 mon
= (wxDateTime::Month
)tm
.tm_mon
;
399 year
= 1900 + tm
.tm_year
;
404 bool wxDateTime::Tm::IsValid() const
406 // we allow for the leap seconds, although we don't use them (yet)
407 return (year
!= wxDateTime::Inv_Year
) && (mon
!= wxDateTime::Inv_Month
) &&
408 (mday
<= GetNumOfDaysInMonth(year
, mon
)) &&
409 (hour
< 24) && (min
< 60) && (sec
< 62) && (msec
< 1000);
412 void wxDateTime::Tm::ComputeWeekDay()
414 // compute the week day from day/month/year: we use the dumbest algorithm
415 // possible: just compute our JDN and then use the (simple to derive)
416 // formula: weekday = (JDN + 1.5) % 7
417 wday
= (wxDateTime::WeekDay
)(GetTruncatedJDN(mday
, mon
, year
) + 2) % 7;
420 void wxDateTime::Tm::AddMonths(int monDiff
)
422 // normalize the months field
423 while ( monDiff
< -mon
)
427 monDiff
+= MONTHS_IN_YEAR
;
430 while ( monDiff
+ mon
>= MONTHS_IN_YEAR
)
434 monDiff
-= MONTHS_IN_YEAR
;
437 mon
= (wxDateTime::Month
)(mon
+ monDiff
);
439 wxASSERT_MSG( mon
>= 0 && mon
< MONTHS_IN_YEAR
, _T("logic error") );
442 void wxDateTime::Tm::AddDays(int dayDiff
)
444 // normalize the days field
445 while ( dayDiff
+ mday
< 1 )
449 dayDiff
+= GetNumOfDaysInMonth(year
, mon
);
453 while ( mday
> GetNumOfDaysInMonth(year
, mon
) )
455 mday
-= GetNumOfDaysInMonth(year
, mon
);
460 wxASSERT_MSG( mday
> 0 && mday
<= GetNumOfDaysInMonth(year
, mon
),
464 // ----------------------------------------------------------------------------
466 // ----------------------------------------------------------------------------
468 wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz
)
472 case wxDateTime::Local
:
473 // get the offset from C RTL: it returns the difference GMT-local
474 // while we want to have the offset _from_ GMT, hence the '-'
475 m_offset
= -GetTimeZone();
478 case wxDateTime::GMT_12
:
479 case wxDateTime::GMT_11
:
480 case wxDateTime::GMT_10
:
481 case wxDateTime::GMT_9
:
482 case wxDateTime::GMT_8
:
483 case wxDateTime::GMT_7
:
484 case wxDateTime::GMT_6
:
485 case wxDateTime::GMT_5
:
486 case wxDateTime::GMT_4
:
487 case wxDateTime::GMT_3
:
488 case wxDateTime::GMT_2
:
489 case wxDateTime::GMT_1
:
490 m_offset
= -3600*(wxDateTime::GMT0
- tz
);
493 case wxDateTime::GMT0
:
494 case wxDateTime::GMT1
:
495 case wxDateTime::GMT2
:
496 case wxDateTime::GMT3
:
497 case wxDateTime::GMT4
:
498 case wxDateTime::GMT5
:
499 case wxDateTime::GMT6
:
500 case wxDateTime::GMT7
:
501 case wxDateTime::GMT8
:
502 case wxDateTime::GMT9
:
503 case wxDateTime::GMT10
:
504 case wxDateTime::GMT11
:
505 case wxDateTime::GMT12
:
506 m_offset
= 3600*(tz
- wxDateTime::GMT0
);
509 case wxDateTime::A_CST
:
510 // Central Standard Time in use in Australia = UTC + 9.5
511 m_offset
= 60l*(9*60 + 30);
515 wxFAIL_MSG( _T("unknown time zone") );
519 // ----------------------------------------------------------------------------
521 // ----------------------------------------------------------------------------
524 bool wxDateTime::IsLeapYear(int year
, wxDateTime::Calendar cal
)
526 if ( year
== Inv_Year
)
527 year
= GetCurrentYear();
529 if ( cal
== Gregorian
)
531 // in Gregorian calendar leap years are those divisible by 4 except
532 // those divisible by 100 unless they're also divisible by 400
533 // (in some countries, like Russia and Greece, additional corrections
534 // exist, but they won't manifest themselves until 2700)
535 return (year
% 4 == 0) && ((year
% 100 != 0) || (year
% 400 == 0));
537 else if ( cal
== Julian
)
539 // in Julian calendar the rule is simpler
540 return year
% 4 == 0;
544 wxFAIL_MSG(_T("unknown calendar"));
551 int wxDateTime::GetCentury(int year
)
553 return year
> 0 ? year
/ 100 : year
/ 100 - 1;
557 int wxDateTime::ConvertYearToBC(int year
)
560 return year
> 0 ? year
: year
- 1;
564 int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal
)
569 return Now().GetYear();
572 wxFAIL_MSG(_T("TODO"));
576 wxFAIL_MSG(_T("unsupported calendar"));
584 wxDateTime::Month
wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal
)
589 return Now().GetMonth();
592 wxFAIL_MSG(_T("TODO"));
596 wxFAIL_MSG(_T("unsupported calendar"));
604 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(int year
, Calendar cal
)
606 if ( year
== Inv_Year
)
608 // take the current year if none given
609 year
= GetCurrentYear();
616 return IsLeapYear(year
) ? 366 : 365;
619 wxFAIL_MSG(_T("unsupported calendar"));
627 wxDateTime::wxDateTime_t
wxDateTime::GetNumberOfDays(wxDateTime::Month month
,
629 wxDateTime::Calendar cal
)
631 wxCHECK_MSG( month
< MONTHS_IN_YEAR
, 0, _T("invalid month") );
633 if ( cal
== Gregorian
|| cal
== Julian
)
635 if ( year
== Inv_Year
)
637 // take the current year if none given
638 year
= GetCurrentYear();
641 return GetNumOfDaysInMonth(year
, month
);
645 wxFAIL_MSG(_T("unsupported calendar"));
652 wxString
wxDateTime::GetMonthName(wxDateTime::Month month
,
653 wxDateTime::NameFlags flags
)
655 wxCHECK_MSG( month
!= Inv_Month
, _T(""), _T("invalid month") );
657 // notice that we must set all the fields to avoid confusing libc (GNU one
658 // gets confused to a crash if we don't do this)
663 return CallStrftime(flags
== Name_Abbr
? _T("%b") : _T("%B"), &tm
);
667 wxString
wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday
,
668 wxDateTime::NameFlags flags
)
670 wxCHECK_MSG( wday
!= Inv_WeekDay
, _T(""), _T("invalid weekday") );
672 // take some arbitrary Sunday
679 // and offset it by the number of days needed to get the correct wday
682 // call mktime() to normalize it...
685 // ... and call strftime()
686 return CallStrftime(flags
== Name_Abbr
? _T("%a") : _T("%A"), &tm
);
690 void wxDateTime::GetAmPmStrings(wxString
*am
, wxString
*pm
)
696 *am
= CallStrftime(_T("%p"), &tm
);
701 *pm
= CallStrftime(_T("%p"), &tm
);
705 // ----------------------------------------------------------------------------
706 // Country stuff: date calculations depend on the country (DST, work days,
707 // ...), so we need to know which rules to follow.
708 // ----------------------------------------------------------------------------
711 wxDateTime::Country
wxDateTime::GetCountry()
713 // TODO use LOCALE_ICOUNTRY setting under Win32
715 if ( ms_country
== Country_Unknown
)
717 // try to guess from the time zone name
718 time_t t
= time(NULL
);
719 struct tm
*tm
= localtime(&t
);
721 wxString tz
= CallStrftime(_T("%Z"), tm
);
722 if ( tz
== _T("WET") || tz
== _T("WEST") )
726 else if ( tz
== _T("CET") || tz
== _T("CEST") )
728 ms_country
= Country_EEC
;
730 else if ( tz
== _T("MSK") || tz
== _T("MSD") )
734 else if ( tz
== _T("AST") || tz
== _T("ADT") ||
735 tz
== _T("EST") || tz
== _T("EDT") ||
736 tz
== _T("CST") || tz
== _T("CDT") ||
737 tz
== _T("MST") || tz
== _T("MDT") ||
738 tz
== _T("PST") || tz
== _T("PDT") )
744 // well, choose a default one
753 void wxDateTime::SetCountry(wxDateTime::Country country
)
755 ms_country
= country
;
759 bool wxDateTime::IsWestEuropeanCountry(Country country
)
761 if ( country
== Country_Default
)
763 country
= GetCountry();
766 return (Country_WesternEurope_Start
<= country
) &&
767 (country
<= Country_WesternEurope_End
);
770 // ----------------------------------------------------------------------------
771 // DST calculations: we use 3 different rules for the West European countries,
772 // USA and for the rest of the world. This is undoubtedly false for many
773 // countries, but I lack the necessary info (and the time to gather it),
774 // please add the other rules here!
775 // ----------------------------------------------------------------------------
778 bool wxDateTime::IsDSTApplicable(int year
, Country country
)
780 if ( year
== Inv_Year
)
782 // take the current year if none given
783 year
= GetCurrentYear();
786 if ( country
== Country_Default
)
788 country
= GetCountry();
795 // DST was first observed in the US and UK during WWI, reused
796 // during WWII and used again since 1966
797 return year
>= 1966 ||
798 (year
>= 1942 && year
<= 1945) ||
799 (year
== 1918 || year
== 1919);
802 // assume that it started after WWII
808 wxDateTime
wxDateTime::GetBeginDST(int year
, Country country
)
810 if ( year
== Inv_Year
)
812 // take the current year if none given
813 year
= GetCurrentYear();
816 if ( country
== Country_Default
)
818 country
= GetCountry();
821 if ( !IsDSTApplicable(year
, country
) )
823 return wxInvalidDateTime
;
828 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
830 // DST begins at 1 a.m. GMT on the last Sunday of March
831 if ( !dt
.SetToLastWeekDay(Sun
, Mar
, year
) )
834 wxFAIL_MSG( _T("no last Sunday in March?") );
837 dt
+= wxTimeSpan::Hours(1);
839 // disable DST tests because it could result in an infinite recursion!
842 else switch ( country
)
849 // don't know for sure - assume it was in effect all year
854 dt
.Set(1, Jan
, year
);
858 // DST was installed Feb 2, 1942 by the Congress
859 dt
.Set(2, Feb
, year
);
862 // Oil embargo changed the DST period in the US
864 dt
.Set(6, Jan
, 1974);
868 dt
.Set(23, Feb
, 1975);
872 // before 1986, DST begun on the last Sunday of April, but
873 // in 1986 Reagan changed it to begin at 2 a.m. of the
874 // first Sunday in April
877 if ( !dt
.SetToLastWeekDay(Sun
, Apr
, year
) )
880 wxFAIL_MSG( _T("no first Sunday in April?") );
885 if ( !dt
.SetToWeekDay(Sun
, 1, Apr
, year
) )
888 wxFAIL_MSG( _T("no first Sunday in April?") );
892 dt
+= wxTimeSpan::Hours(2);
894 // TODO what about timezone??
900 // assume Mar 30 as the start of the DST for the rest of the world
901 // - totally bogus, of course
902 dt
.Set(30, Mar
, year
);
909 wxDateTime
wxDateTime::GetEndDST(int year
, Country country
)
911 if ( year
== Inv_Year
)
913 // take the current year if none given
914 year
= GetCurrentYear();
917 if ( country
== Country_Default
)
919 country
= GetCountry();
922 if ( !IsDSTApplicable(year
, country
) )
924 return wxInvalidDateTime
;
929 if ( IsWestEuropeanCountry(country
) || (country
== Russia
) )
931 // DST ends at 1 a.m. GMT on the last Sunday of October
932 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
934 // weirder and weirder...
935 wxFAIL_MSG( _T("no last Sunday in October?") );
938 dt
+= wxTimeSpan::Hours(1);
940 // disable DST tests because it could result in an infinite recursion!
943 else switch ( country
)
950 // don't know for sure - assume it was in effect all year
954 dt
.Set(31, Dec
, year
);
958 // the time was reset after the end of the WWII
959 dt
.Set(30, Sep
, year
);
963 // DST ends at 2 a.m. on the last Sunday of October
964 if ( !dt
.SetToLastWeekDay(Sun
, Oct
, year
) )
966 // weirder and weirder...
967 wxFAIL_MSG( _T("no last Sunday in October?") );
970 dt
+= wxTimeSpan::Hours(2);
972 // TODO what about timezone??
977 // assume October 26th as the end of the DST - totally bogus too
978 dt
.Set(26, Oct
, year
);
984 // ----------------------------------------------------------------------------
985 // constructors and assignment operators
986 // ----------------------------------------------------------------------------
988 // the values in the tm structure contain the local time
989 wxDateTime
& wxDateTime::Set(const struct tm
& tm
)
991 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
994 time_t timet
= mktime(&tm2
);
996 if ( timet
== (time_t)-1 )
998 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
999 // less than timezone - try to make it work for this case
1000 if ( tm2
.tm_year
== 70 && tm2
.tm_mon
== 0 && tm2
.tm_mday
== 1 )
1002 // add timezone to make sure that date is in range
1003 tm2
.tm_sec
-= GetTimeZone();
1005 timet
= mktime(&tm2
);
1006 if ( timet
!= (time_t)-1 )
1008 timet
+= GetTimeZone();
1014 wxFAIL_MSG( _T("mktime() failed") );
1016 return wxInvalidDateTime
;
1024 wxDateTime
& wxDateTime::Set(wxDateTime_t hour
,
1025 wxDateTime_t minute
,
1026 wxDateTime_t second
,
1027 wxDateTime_t millisec
)
1029 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1031 // we allow seconds to be 61 to account for the leap seconds, even if we
1032 // don't use them really
1033 wxCHECK_MSG( hour
< 24 && second
< 62 && minute
< 60 && millisec
< 1000,
1035 _T("Invalid time in wxDateTime::Set()") );
1037 // get the current date from system
1038 struct tm
*tm
= GetTmNow();
1040 wxCHECK_MSG( tm
, wxInvalidDateTime
, _T("localtime() failed") );
1044 tm
->tm_min
= minute
;
1045 tm
->tm_sec
= second
;
1049 // and finally adjust milliseconds
1050 return SetMillisecond(millisec
);
1053 wxDateTime
& wxDateTime::Set(wxDateTime_t day
,
1057 wxDateTime_t minute
,
1058 wxDateTime_t second
,
1059 wxDateTime_t millisec
)
1061 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1063 wxCHECK_MSG( hour
< 24 && second
< 62 && minute
< 60 && millisec
< 1000,
1065 _T("Invalid time in wxDateTime::Set()") );
1067 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1069 wxCHECK_MSG( (0 < day
) && (day
<= GetNumberOfDays(month
, year
)),
1071 _T("Invalid date in wxDateTime::Set()") );
1073 // the range of time_t type (inclusive)
1074 static const int yearMinInRange
= 1970;
1075 static const int yearMaxInRange
= 2037;
1077 // test only the year instead of testing for the exact end of the Unix
1078 // time_t range - it doesn't bring anything to do more precise checks
1079 if ( year
>= yearMinInRange
&& year
<= yearMaxInRange
)
1081 // use the standard library version if the date is in range - this is
1082 // probably more efficient than our code
1084 tm
.tm_year
= year
- 1900;
1090 tm
.tm_isdst
= -1; // mktime() will guess it
1094 // and finally adjust milliseconds
1095 return SetMillisecond(millisec
);
1099 // do time calculations ourselves: we want to calculate the number of
1100 // milliseconds between the given date and the epoch
1102 // get the JDN for the midnight of this day
1103 m_time
= GetTruncatedJDN(day
, month
, year
);
1104 m_time
-= EPOCH_JDN
;
1105 m_time
*= SECONDS_PER_DAY
* TIME_T_FACTOR
;
1107 // JDN corresponds to GMT, we take localtime
1108 Add(wxTimeSpan(hour
, minute
, second
+ GetTimeZone(), millisec
));
1114 wxDateTime
& wxDateTime::Set(double jdn
)
1116 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1118 jdn
-= EPOCH_JDN
+ 0.5;
1120 jdn
*= MILLISECONDS_PER_DAY
;
1127 wxDateTime
& wxDateTime::ResetTime()
1131 if ( tm
.hour
|| tm
.min
|| tm
.sec
|| tm
.msec
)
1144 // ----------------------------------------------------------------------------
1145 // time_t <-> broken down time conversions
1146 // ----------------------------------------------------------------------------
1148 wxDateTime::Tm
wxDateTime::GetTm(const TimeZone
& tz
) const
1153 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1155 time_t time
= GetTicks();
1156 if ( time
!= (time_t)-1 )
1158 // use C RTL functions
1160 if ( tz
.GetOffset() == -GetTimeZone() )
1162 // we are working with local time
1163 tm
= localtime(&time
);
1165 // should never happen
1166 wxCHECK_MSG( tm
, Tm(), _T("gmtime() failed") );
1170 time
+= tz
.GetOffset();
1171 #ifdef __VMS__ // time is unsigned so avoid warning
1180 // should never happen
1181 wxCHECK_MSG( tm
, Tm(), _T("gmtime() failed") );
1185 tm
= (struct tm
*)NULL
;
1193 //else: use generic code below
1196 // remember the time and do the calculations with the date only - this
1197 // eliminates rounding errors of the floating point arithmetics
1199 wxLongLong timeMidnight
= m_time
+ tz
.GetOffset() * 1000;
1201 long timeOnly
= (timeMidnight
% MILLISECONDS_PER_DAY
).ToLong();
1203 // we want to always have positive time and timeMidnight to be really
1204 // the midnight before it
1207 timeOnly
= MILLISECONDS_PER_DAY
+ timeOnly
;
1210 timeMidnight
-= timeOnly
;
1212 // calculate the Gregorian date from JDN for the midnight of our date:
1213 // this will yield day, month (in 1..12 range) and year
1215 // actually, this is the JDN for the noon of the previous day
1216 long jdn
= (timeMidnight
/ MILLISECONDS_PER_DAY
).ToLong() + EPOCH_JDN
;
1218 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1220 wxASSERT_MSG( jdn
> -2, _T("JDN out of range") );
1222 // calculate the century
1223 int temp
= (jdn
+ JDN_OFFSET
) * 4 - 1;
1224 int century
= temp
/ DAYS_PER_400_YEARS
;
1226 // then the year and day of year (1 <= dayOfYear <= 366)
1227 temp
= ((temp
% DAYS_PER_400_YEARS
) / 4) * 4 + 3;
1228 int year
= (century
* 100) + (temp
/ DAYS_PER_4_YEARS
);
1229 int dayOfYear
= (temp
% DAYS_PER_4_YEARS
) / 4 + 1;
1231 // and finally the month and day of the month
1232 temp
= dayOfYear
* 5 - 3;
1233 int month
= temp
/ DAYS_PER_5_MONTHS
;
1234 int day
= (temp
% DAYS_PER_5_MONTHS
) / 5 + 1;
1236 // month is counted from March - convert to normal
1247 // year is offset by 4800
1250 // check that the algorithm gave us something reasonable
1251 wxASSERT_MSG( (0 < month
) && (month
<= 12), _T("invalid month") );
1252 wxASSERT_MSG( (1 <= day
) && (day
< 32), _T("invalid day") );
1253 wxASSERT_MSG( (INT_MIN
<= year
) && (year
<= INT_MAX
),
1254 _T("year range overflow") );
1256 // construct Tm from these values
1258 tm
.year
= (int)year
;
1259 tm
.mon
= (Month
)(month
- 1); // algorithm yields 1 for January, not 0
1260 tm
.mday
= (wxDateTime_t
)day
;
1261 tm
.msec
= timeOnly
% 1000;
1262 timeOnly
-= tm
.msec
;
1263 timeOnly
/= 1000; // now we have time in seconds
1265 tm
.sec
= timeOnly
% 60;
1267 timeOnly
/= 60; // now we have time in minutes
1269 tm
.min
= timeOnly
% 60;
1272 tm
.hour
= timeOnly
/ 60;
1277 wxDateTime
& wxDateTime::SetYear(int year
)
1279 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1288 wxDateTime
& wxDateTime::SetMonth(Month month
)
1290 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1299 wxDateTime
& wxDateTime::SetDay(wxDateTime_t mday
)
1301 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1310 wxDateTime
& wxDateTime::SetHour(wxDateTime_t hour
)
1312 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1321 wxDateTime
& wxDateTime::SetMinute(wxDateTime_t min
)
1323 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1332 wxDateTime
& wxDateTime::SetSecond(wxDateTime_t sec
)
1334 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1343 wxDateTime
& wxDateTime::SetMillisecond(wxDateTime_t millisecond
)
1345 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1347 // we don't need to use GetTm() for this one
1348 m_time
-= m_time
% 1000l;
1349 m_time
+= millisecond
;
1354 // ----------------------------------------------------------------------------
1355 // wxDateTime arithmetics
1356 // ----------------------------------------------------------------------------
1358 wxDateTime
& wxDateTime::Add(const wxDateSpan
& diff
)
1362 tm
.year
+= diff
.GetYears();
1363 tm
.AddMonths(diff
.GetMonths());
1364 tm
.AddDays(diff
.GetTotalDays());
1368 wxASSERT_MSG( IsSameTime(tm
),
1369 _T("Add(wxDateSpan) shouldn't modify time") );
1374 // ----------------------------------------------------------------------------
1375 // Weekday and monthday stuff
1376 // ----------------------------------------------------------------------------
1378 wxDateTime
& wxDateTime::SetToLastMonthDay(Month month
,
1381 // take the current month/year if none specified
1382 if ( year
== Inv_Year
)
1384 if ( month
== Inv_Month
)
1387 return Set(GetNumOfDaysInMonth(year
, month
), month
, year
);
1390 wxDateTime
& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday
)
1392 wxCHECK_MSG( weekday
!= Inv_WeekDay
, wxInvalidDateTime
, _T("invalid weekday") );
1394 WeekDay wdayThis
= GetWeekDay();
1395 if ( weekday
== wdayThis
)
1400 else if ( weekday
< wdayThis
)
1402 return Substract(wxTimeSpan::Days(wdayThis
- weekday
));
1404 else // weekday > wdayThis
1406 return Add(wxTimeSpan::Days(weekday
- wdayThis
));
1410 wxDateTime
& wxDateTime::SetToNextWeekDay(WeekDay weekday
)
1412 wxCHECK_MSG( weekday
!= Inv_WeekDay
, wxInvalidDateTime
, _T("invalid weekday") );
1415 WeekDay wdayThis
= GetWeekDay();
1416 if ( weekday
== wdayThis
)
1421 else if ( weekday
< wdayThis
)
1423 // need to advance a week
1424 diff
= 7 - (wdayThis
- weekday
);
1426 else // weekday > wdayThis
1428 diff
= weekday
- wdayThis
;
1431 return Add(wxTimeSpan::Days(diff
));
1434 wxDateTime
& wxDateTime::SetToPrevWeekDay(WeekDay weekday
)
1436 wxCHECK_MSG( weekday
!= Inv_WeekDay
, wxInvalidDateTime
, _T("invalid weekday") );
1439 WeekDay wdayThis
= GetWeekDay();
1440 if ( weekday
== wdayThis
)
1445 else if ( weekday
> wdayThis
)
1447 // need to go to previous week
1448 diff
= 7 - (weekday
- wdayThis
);
1450 else // weekday < wdayThis
1452 diff
= wdayThis
- weekday
;
1455 return Substract(wxTimeSpan::Days(diff
));
1458 bool wxDateTime::SetToWeekDay(WeekDay weekday
,
1463 wxCHECK_MSG( weekday
!= Inv_WeekDay
, FALSE
, _T("invalid weekday") );
1465 // we don't check explicitly that -5 <= n <= 5 because we will return FALSE
1466 // anyhow in such case - but may be should still give an assert for it?
1468 // take the current month/year if none specified
1469 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1473 // TODO this probably could be optimised somehow...
1477 // get the first day of the month
1478 dt
.Set(1, month
, year
);
1481 WeekDay wdayFirst
= dt
.GetWeekDay();
1483 // go to the first weekday of the month
1484 int diff
= weekday
- wdayFirst
;
1488 // add advance n-1 weeks more
1491 dt
+= wxDateSpan::Days(diff
);
1493 else // count from the end of the month
1495 // get the last day of the month
1496 dt
.SetToLastMonthDay(month
, year
);
1499 WeekDay wdayLast
= dt
.GetWeekDay();
1501 // go to the last weekday of the month
1502 int diff
= wdayLast
- weekday
;
1506 // and rewind n-1 weeks from there
1509 dt
-= wxDateSpan::Days(diff
);
1512 // check that it is still in the same month
1513 if ( dt
.GetMonth() == month
)
1521 // no such day in this month
1526 wxDateTime::wxDateTime_t
wxDateTime::GetDayOfYear(const TimeZone
& tz
) const
1530 return gs_cumulatedDays
[IsLeapYear(tm
.year
)][tm
.mon
] + tm
.mday
;
1533 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags
,
1534 const TimeZone
& tz
) const
1536 if ( flags
== Default_First
)
1538 flags
= GetCountry() == USA
? Sunday_First
: Monday_First
;
1541 wxDateTime_t nDayInYear
= GetDayOfYear(tz
);
1544 WeekDay wd
= GetWeekDay(tz
);
1545 if ( flags
== Sunday_First
)
1547 week
= (nDayInYear
- wd
+ 7) / 7;
1551 // have to shift the week days values
1552 week
= (nDayInYear
- (wd
- 1 + 7) % 7 + 7) / 7;
1555 // FIXME some more elegant way??
1556 WeekDay wdYearStart
= wxDateTime(1, Jan
, GetYear()).GetWeekDay();
1557 if ( wdYearStart
== Wed
|| wdYearStart
== Thu
)
1565 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags
,
1566 const TimeZone
& tz
) const
1569 wxDateTime dtMonthStart
= wxDateTime(1, tm
.mon
, tm
.year
);
1570 size_t nWeek
= GetWeekOfYear(flags
) - dtMonthStart
.GetWeekOfYear(flags
) + 1;
1573 // this may happen for January when Jan, 1 is the last week of the
1575 nWeek
+= IsLeapYear(tm
.year
- 1) ? 53 : 52;
1581 wxDateTime
& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday
)
1583 int year
= GetYear();
1584 wxCHECK_MSG( (0 < yday
) && (yday
<= GetNumberOfDays(year
)),
1585 wxInvalidDateTime
, _T("invalid year day") );
1587 bool isLeap
= IsLeapYear(year
);
1588 for ( Month mon
= Jan
; mon
< Inv_Month
; wxNextMonth(mon
) )
1590 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
1591 // don't need it neither - because of the CHECK above we know that
1592 // yday lies in December then
1593 if ( (mon
== Dec
) || (yday
< gs_cumulatedDays
[isLeap
][mon
+ 1]) )
1595 Set(yday
- gs_cumulatedDays
[isLeap
][mon
], mon
, year
);
1604 // ----------------------------------------------------------------------------
1605 // Julian day number conversion and related stuff
1606 // ----------------------------------------------------------------------------
1608 double wxDateTime::GetJulianDayNumber() const
1610 // JDN are always expressed for the GMT dates
1611 Tm
tm(ToTimezone(GMT0
).GetTm(GMT0
));
1613 double result
= GetTruncatedJDN(tm
.mday
, tm
.mon
, tm
.year
);
1615 // add the part GetTruncatedJDN() neglected
1618 // and now add the time: 86400 sec = 1 JDN
1619 return result
+ ((double)(60*(60*tm
.hour
+ tm
.min
) + tm
.sec
)) / 86400;
1622 double wxDateTime::GetRataDie() const
1624 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
1625 return GetJulianDayNumber() - 1721119.5 - 306;
1628 // ----------------------------------------------------------------------------
1629 // timezone and DST stuff
1630 // ----------------------------------------------------------------------------
1632 int wxDateTime::IsDST(wxDateTime::Country country
) const
1634 wxCHECK_MSG( country
== Country_Default
, -1,
1635 _T("country support not implemented") );
1637 // use the C RTL for the dates in the standard range
1638 time_t timet
= GetTicks();
1639 if ( timet
!= (time_t)-1 )
1641 tm
*tm
= localtime(&timet
);
1643 wxCHECK_MSG( tm
, -1, _T("localtime() failed") );
1645 return tm
->tm_isdst
;
1649 int year
= GetYear();
1651 if ( !IsDSTApplicable(year
, country
) )
1653 // no DST time in this year in this country
1657 return IsBetween(GetBeginDST(year
, country
), GetEndDST(year
, country
));
1661 wxDateTime
& wxDateTime::MakeTimezone(const TimeZone
& tz
, bool noDST
)
1663 int secDiff
= GetTimeZone() + tz
.GetOffset();
1665 // we need to know whether DST is or not in effect for this date unless
1666 // the test disabled by the caller
1667 if ( !noDST
&& (IsDST() == 1) )
1669 // FIXME we assume that the DST is always shifted by 1 hour
1673 return Substract(wxTimeSpan::Seconds(secDiff
));
1676 // ----------------------------------------------------------------------------
1677 // wxDateTime to/from text representations
1678 // ----------------------------------------------------------------------------
1680 wxString
wxDateTime::Format(const wxChar
*format
, const TimeZone
& tz
) const
1685 wxCHECK_MSG( format
, _T(""), _T("NULL format in wxDateTime::Format") );
1687 time_t time
= GetTicks();
1688 if ( time
!= (time_t)-1 )
1692 if ( tz
.GetOffset() == -GetTimeZone() )
1694 // we are working with local time
1695 tm
= localtime(&time
);
1697 // should never happen
1698 wxCHECK_MSG( tm
, wxEmptyString
, _T("localtime() failed") );
1702 time
+= tz
.GetOffset();
1704 #ifdef __VMS__ /* time is unsigned so VMS gives a warning on the original */
1713 // should never happen
1714 wxCHECK_MSG( tm
, wxEmptyString
, _T("gmtime() failed") );
1718 tm
= (struct tm
*)NULL
;
1724 return CallStrftime(format
, tm
);
1726 //else: use generic code below
1729 // we only parse ANSI C format specifications here, no POSIX 2
1730 // complications, no GNU extensions
1733 // used for calls to strftime() when we only deal with time
1734 struct tm tmTimeOnly
;
1735 tmTimeOnly
.tm_hour
= tm
.hour
;
1736 tmTimeOnly
.tm_min
= tm
.min
;
1737 tmTimeOnly
.tm_sec
= tm
.sec
;
1738 tmTimeOnly
.tm_wday
= 0;
1739 tmTimeOnly
.tm_yday
= 0;
1740 tmTimeOnly
.tm_mday
= 1; // any date will do
1741 tmTimeOnly
.tm_mon
= 0;
1742 tmTimeOnly
.tm_year
= 76;
1743 tmTimeOnly
.tm_isdst
= 0; // no DST, we adjust for tz ourselves
1745 wxString tmp
, res
, fmt
;
1746 for ( const wxChar
*p
= format
; *p
; p
++ )
1748 if ( *p
!= _T('%') )
1756 // set the default format
1759 case _T('Y'): // year has 4 digits
1763 case _T('j'): // day of year has 3 digits
1768 // it's either another valid format specifier in which case
1769 // the format is "%02d" (for all the rest) or we have the
1770 // field width preceding the format in which case it will
1771 // override the default format anyhow
1776 // start of the format specification
1779 case _T('a'): // a weekday name
1781 // second parameter should be TRUE for abbreviated names
1782 res
+= GetWeekDayName(tm
.GetWeekDay(),
1783 *p
== _T('a') ? Name_Abbr
: Name_Full
);
1786 case _T('b'): // a month name
1788 res
+= GetMonthName(tm
.mon
,
1789 *p
== _T('b') ? Name_Abbr
: Name_Full
);
1792 case _T('c'): // locale default date and time representation
1793 case _T('x'): // locale default date representation
1795 // the problem: there is no way to know what do these format
1796 // specifications correspond to for the current locale.
1798 // the solution: use a hack and still use strftime(): first
1799 // find the YEAR which is a year in the strftime() range (1970
1800 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
1801 // of the real year. Then make a copy of the format and
1802 // replace all occurences of YEAR in it with some unique
1803 // string not appearing anywhere else in it, then use
1804 // strftime() to format the date in year YEAR and then replace
1805 // YEAR back by the real year and the unique replacement
1806 // string back with YEAR. Notice that "all occurences of YEAR"
1807 // means all occurences of 4 digit as well as 2 digit form!
1809 // the bugs: we assume that neither of %c nor %x contains any
1810 // fields which may change between the YEAR and real year. For
1811 // example, the week number (%U, %W) and the day number (%j)
1812 // will change if one of these years is leap and the other one
1815 // find the YEAR: normally, for any year X, Jan 1 or the
1816 // year X + 28 is the same weekday as Jan 1 of X (because
1817 // the weekday advances by 1 for each normal X and by 2
1818 // for each leap X, hence by 5 every 4 years or by 35
1819 // which is 0 mod 7 every 28 years) but this rule breaks
1820 // down if there are years between X and Y which are
1821 // divisible by 4 but not leap (i.e. divisible by 100 but
1822 // not 400), hence the correction.
1824 int yearReal
= GetYear(tz
);
1825 int mod28
= yearReal
% 28;
1827 // be careful to not go too far - we risk to leave the
1832 year
= 1988 + mod28
; // 1988 == 0 (mod 28)
1836 year
= 1970 + mod28
- 10; // 1970 == 10 (mod 28)
1839 int nCentury
= year
/ 100,
1840 nCenturyReal
= yearReal
/ 100;
1842 // need to adjust for the years divisble by 400 which are
1843 // not leap but are counted like leap ones if we just take
1844 // the number of centuries in between for nLostWeekDays
1845 int nLostWeekDays
= (nCentury
- nCenturyReal
) -
1846 (nCentury
/ 4 - nCenturyReal
/ 4);
1848 // we have to gain back the "lost" weekdays: note that the
1849 // effect of this loop is to not do anything to
1850 // nLostWeekDays (which we won't use any more), but to
1851 // (indirectly) set the year correctly
1852 while ( (nLostWeekDays
% 7) != 0 )
1854 nLostWeekDays
+= year
++ % 4 ? 1 : 2;
1857 // at any rate, we couldn't go further than 1988 + 9 + 28!
1858 wxASSERT_MSG( year
< 2030,
1859 _T("logic error in wxDateTime::Format") );
1861 wxString strYear
, strYear2
;
1862 strYear
.Printf(_T("%d"), year
);
1863 strYear2
.Printf(_T("%d"), year
% 100);
1865 // find two strings not occuring in format (this is surely
1866 // not optimal way of doing it... improvements welcome!)
1867 wxString fmt
= format
;
1868 wxString replacement
= (wxChar
)-1;
1869 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
1871 replacement
<< (wxChar
)-1;
1874 wxString replacement2
= (wxChar
)-2;
1875 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
1877 replacement
<< (wxChar
)-2;
1880 // replace all occurences of year with it
1881 bool wasReplaced
= fmt
.Replace(strYear
, replacement
) > 0;
1883 wasReplaced
= fmt
.Replace(strYear2
, replacement2
) > 0;
1885 // use strftime() to format the same date but in supported
1888 // NB: we assume that strftime() doesn't check for the
1889 // date validity and will happily format the date
1890 // corresponding to Feb 29 of a non leap year (which
1891 // may happen if yearReal was leap and year is not)
1892 struct tm tmAdjusted
;
1894 tmAdjusted
.tm_hour
= tm
.hour
;
1895 tmAdjusted
.tm_min
= tm
.min
;
1896 tmAdjusted
.tm_sec
= tm
.sec
;
1897 tmAdjusted
.tm_wday
= tm
.GetWeekDay();
1898 tmAdjusted
.tm_yday
= GetDayOfYear();
1899 tmAdjusted
.tm_mday
= tm
.mday
;
1900 tmAdjusted
.tm_mon
= tm
.mon
;
1901 tmAdjusted
.tm_year
= year
- 1900;
1902 tmAdjusted
.tm_isdst
= 0; // no DST, already adjusted
1903 wxString str
= CallStrftime(*p
== _T('c') ? _T("%c")
1907 // now replace the occurence of 1999 with the real year
1908 wxString strYearReal
, strYearReal2
;
1909 strYearReal
.Printf(_T("%04d"), yearReal
);
1910 strYearReal2
.Printf(_T("%02d"), yearReal
% 100);
1911 str
.Replace(strYear
, strYearReal
);
1912 str
.Replace(strYear2
, strYearReal2
);
1914 // and replace back all occurences of replacement string
1917 str
.Replace(replacement2
, strYear2
);
1918 str
.Replace(replacement
, strYear
);
1925 case _T('d'): // day of a month (01-31)
1926 res
+= wxString::Format(fmt
, tm
.mday
);
1929 case _T('H'): // hour in 24h format (00-23)
1930 res
+= wxString::Format(fmt
, tm
.hour
);
1933 case _T('I'): // hour in 12h format (01-12)
1935 // 24h -> 12h, 0h -> 12h too
1936 int hour12
= tm
.hour
> 12 ? tm
.hour
- 12
1937 : tm
.hour
? tm
.hour
: 12;
1938 res
+= wxString::Format(fmt
, hour12
);
1942 case _T('j'): // day of the year
1943 res
+= wxString::Format(fmt
, GetDayOfYear(tz
));
1946 case _T('m'): // month as a number (01-12)
1947 res
+= wxString::Format(fmt
, tm
.mon
+ 1);
1950 case _T('M'): // minute as a decimal number (00-59)
1951 res
+= wxString::Format(fmt
, tm
.min
);
1954 case _T('p'): // AM or PM string
1955 res
+= CallStrftime(_T("%p"), &tmTimeOnly
);
1958 case _T('S'): // second as a decimal number (00-61)
1959 res
+= wxString::Format(fmt
, tm
.sec
);
1962 case _T('U'): // week number in the year (Sunday 1st week day)
1963 res
+= wxString::Format(fmt
, GetWeekOfYear(Sunday_First
, tz
));
1966 case _T('W'): // week number in the year (Monday 1st week day)
1967 res
+= wxString::Format(fmt
, GetWeekOfYear(Monday_First
, tz
));
1970 case _T('w'): // weekday as a number (0-6), Sunday = 0
1971 res
+= wxString::Format(fmt
, tm
.GetWeekDay());
1974 // case _T('x'): -- handled with "%c"
1976 case _T('X'): // locale default time representation
1977 // just use strftime() to format the time for us
1978 res
+= CallStrftime(_T("%X"), &tmTimeOnly
);
1981 case _T('y'): // year without century (00-99)
1982 res
+= wxString::Format(fmt
, tm
.year
% 100);
1985 case _T('Y'): // year with century
1986 res
+= wxString::Format(fmt
, tm
.year
);
1989 case _T('Z'): // timezone name
1990 res
+= CallStrftime(_T("%Z"), &tmTimeOnly
);
1994 // is it the format width?
1996 while ( *p
== _T('-') || *p
== _T('+') ||
1997 *p
== _T(' ') || wxIsdigit(*p
) )
2002 if ( !fmt
.IsEmpty() )
2004 // we've only got the flags and width so far in fmt
2005 fmt
.Prepend(_T('%'));
2006 fmt
.Append(_T('d'));
2011 // no, it wasn't the width
2012 wxFAIL_MSG(_T("unknown format specificator"));
2014 // fall through and just copy it nevertheless
2016 case _T('%'): // a percent sign
2020 case 0: // the end of string
2021 wxFAIL_MSG(_T("missing format at the end of string"));
2023 // just put the '%' which was the last char in format
2032 // this function parses a string in (strict) RFC 822 format: see the section 5
2033 // of the RFC for the detailed description, but briefly it's something of the
2034 // form "Sat, 18 Dec 1999 00:48:30 +0100"
2036 // this function is "strict" by design - it must reject anything except true
2037 // RFC822 time specs.
2039 // TODO a great candidate for using reg exps
2040 const wxChar
*wxDateTime::ParseRfc822Date(const wxChar
* date
)
2042 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2044 const wxChar
*p
= date
;
2045 const wxChar
*comma
= wxStrchr(p
, _T(','));
2048 // the part before comma is the weekday
2050 // skip it for now - we don't use but might check that it really
2051 // corresponds to the specfied date
2054 if ( *p
!= _T(' ') )
2056 wxLogDebug(_T("no space after weekday in RFC822 time spec"));
2058 return (wxChar
*)NULL
;
2064 // the following 1 or 2 digits are the day number
2065 if ( !wxIsdigit(*p
) )
2067 wxLogDebug(_T("day number expected in RFC822 time spec, none found"));
2069 return (wxChar
*)NULL
;
2072 wxDateTime_t day
= *p
++ - _T('0');
2073 if ( wxIsdigit(*p
) )
2076 day
+= *p
++ - _T('0');
2079 if ( *p
++ != _T(' ') )
2081 return (wxChar
*)NULL
;
2084 // the following 3 letters specify the month
2085 wxString
monName(p
, 3);
2087 if ( monName
== _T("Jan") )
2089 else if ( monName
== _T("Feb") )
2091 else if ( monName
== _T("Mar") )
2093 else if ( monName
== _T("Apr") )
2095 else if ( monName
== _T("May") )
2097 else if ( monName
== _T("Jun") )
2099 else if ( monName
== _T("Jul") )
2101 else if ( monName
== _T("Aug") )
2103 else if ( monName
== _T("Sep") )
2105 else if ( monName
== _T("Oct") )
2107 else if ( monName
== _T("Nov") )
2109 else if ( monName
== _T("Dec") )
2113 wxLogDebug(_T("Invalid RFC 822 month name '%s'"), monName
.c_str());
2115 return (wxChar
*)NULL
;
2120 if ( *p
++ != _T(' ') )
2122 return (wxChar
*)NULL
;
2126 if ( !wxIsdigit(*p
) )
2129 return (wxChar
*)NULL
;
2132 int year
= *p
++ - _T('0');
2134 if ( !wxIsdigit(*p
) )
2136 // should have at least 2 digits in the year
2137 return (wxChar
*)NULL
;
2141 year
+= *p
++ - _T('0');
2143 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
2144 if ( wxIsdigit(*p
) )
2147 year
+= *p
++ - _T('0');
2149 if ( !wxIsdigit(*p
) )
2151 // no 3 digit years please
2152 return (wxChar
*)NULL
;
2156 year
+= *p
++ - _T('0');
2159 if ( *p
++ != _T(' ') )
2161 return (wxChar
*)NULL
;
2164 // time is in the format hh:mm:ss and seconds are optional
2165 if ( !wxIsdigit(*p
) )
2167 return (wxChar
*)NULL
;
2170 wxDateTime_t hour
= *p
++ - _T('0');
2172 if ( !wxIsdigit(*p
) )
2174 return (wxChar
*)NULL
;
2178 hour
+= *p
++ - _T('0');
2180 if ( *p
++ != _T(':') )
2182 return (wxChar
*)NULL
;
2185 if ( !wxIsdigit(*p
) )
2187 return (wxChar
*)NULL
;
2190 wxDateTime_t min
= *p
++ - _T('0');
2192 if ( !wxIsdigit(*p
) )
2194 return (wxChar
*)NULL
;
2198 min
+= *p
++ - _T('0');
2200 wxDateTime_t sec
= 0;
2201 if ( *p
++ == _T(':') )
2203 if ( !wxIsdigit(*p
) )
2205 return (wxChar
*)NULL
;
2208 sec
= *p
++ - _T('0');
2210 if ( !wxIsdigit(*p
) )
2212 return (wxChar
*)NULL
;
2216 sec
+= *p
++ - _T('0');
2219 if ( *p
++ != _T(' ') )
2221 return (wxChar
*)NULL
;
2224 // and now the interesting part: the timezone
2226 if ( *p
== _T('-') || *p
== _T('+') )
2228 // the explicit offset given: it has the form of hhmm
2229 bool plus
= *p
++ == _T('+');
2231 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2233 return (wxChar
*)NULL
;
2237 offset
= 60*(10*(*p
- _T('0')) + (*(p
+ 1) - _T('0')));
2241 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2243 return (wxChar
*)NULL
;
2247 offset
+= 10*(*p
- _T('0')) + (*(p
+ 1) - _T('0'));
2258 // the symbolic timezone given: may be either military timezone or one
2259 // of standard abbreviations
2262 // military: Z = UTC, J unused, A = -1, ..., Y = +12
2263 static const int offsets
[26] =
2265 //A B C D E F G H I J K L M
2266 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
2267 //N O P R Q S T U V W Z Y Z
2268 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
2271 if ( *p
< _T('A') || *p
> _T('Z') || *p
== _T('J') )
2273 wxLogDebug(_T("Invalid militaty timezone '%c'"), *p
);
2275 return (wxChar
*)NULL
;
2278 offset
= offsets
[*p
++ - _T('A')];
2284 if ( tz
== _T("UT") || tz
== _T("UTC") || tz
== _T("GMT") )
2286 else if ( tz
== _T("AST") )
2287 offset
= AST
- GMT0
;
2288 else if ( tz
== _T("ADT") )
2289 offset
= ADT
- GMT0
;
2290 else if ( tz
== _T("EST") )
2291 offset
= EST
- GMT0
;
2292 else if ( tz
== _T("EDT") )
2293 offset
= EDT
- GMT0
;
2294 else if ( tz
== _T("CST") )
2295 offset
= CST
- GMT0
;
2296 else if ( tz
== _T("CDT") )
2297 offset
= CDT
- GMT0
;
2298 else if ( tz
== _T("MST") )
2299 offset
= MST
- GMT0
;
2300 else if ( tz
== _T("MDT") )
2301 offset
= MDT
- GMT0
;
2302 else if ( tz
== _T("PST") )
2303 offset
= PST
- GMT0
;
2304 else if ( tz
== _T("PDT") )
2305 offset
= PDT
- GMT0
;
2308 wxLogDebug(_T("Unknown RFC 822 timezone '%s'"), p
);
2310 return (wxChar
*)NULL
;
2320 // the spec was correct
2321 Set(day
, mon
, year
, hour
, min
, sec
);
2322 MakeTimezone((wxDateTime_t
)(60*offset
));
2327 const wxChar
*wxDateTime::ParseFormat(const wxChar
*date
,
2328 const wxChar
*format
,
2329 const wxDateTime
& dateDef
)
2331 wxCHECK_MSG( date
&& format
, (wxChar
*)NULL
,
2332 _T("NULL pointer in wxDateTime::ParseFormat()") );
2337 // what fields have we found?
2338 bool haveWDay
= FALSE
,
2347 bool hourIsIn12hFormat
= FALSE
, // or in 24h one?
2348 isPM
= FALSE
; // AM by default
2350 // and the value of the items we have (init them to get rid of warnings)
2351 wxDateTime_t sec
= 0,
2354 WeekDay wday
= Inv_WeekDay
;
2355 wxDateTime_t yday
= 0,
2357 wxDateTime::Month mon
= Inv_Month
;
2360 const wxChar
*input
= date
;
2361 for ( const wxChar
*fmt
= format
; *fmt
; fmt
++ )
2363 if ( *fmt
!= _T('%') )
2365 if ( wxIsspace(*fmt
) )
2367 // a white space in the format string matches 0 or more white
2368 // spaces in the input
2369 while ( wxIsspace(*input
) )
2376 // any other character (not whitespace, not '%') must be
2377 // matched by itself in the input
2378 if ( *input
++ != *fmt
)
2381 return (wxChar
*)NULL
;
2385 // done with this format char
2389 // start of a format specification
2392 case _T('a'): // a weekday name
2395 int flag
= *fmt
== _T('a') ? Name_Abbr
: Name_Full
;
2396 wday
= GetWeekDayFromName(GetAlphaToken(input
), flag
);
2397 if ( wday
== Inv_WeekDay
)
2400 return (wxChar
*)NULL
;
2406 case _T('b'): // a month name
2409 int flag
= *fmt
== _T('b') ? Name_Abbr
: Name_Full
;
2410 mon
= GetMonthFromName(GetAlphaToken(input
), flag
);
2411 if ( mon
== Inv_Month
)
2414 return (wxChar
*)NULL
;
2420 case _T('c'): // locale default date and time representation
2424 // this is the format which corresponds to ctime() output
2425 // and strptime("%c") should parse it, so try it first
2426 static const wxChar
*fmtCtime
= _T("%a %b %d %H:%M:%S %Y");
2428 const wxChar
*result
= dt
.ParseFormat(input
, fmtCtime
);
2431 result
= dt
.ParseFormat(input
, _T("%x %X"));
2436 result
= dt
.ParseFormat(input
, _T("%X %x"));
2441 // we've tried everything and still no match
2442 return (wxChar
*)NULL
;
2447 haveDay
= haveMon
= haveYear
=
2448 haveHour
= haveMin
= haveSec
= TRUE
;
2462 case _T('d'): // day of a month (01-31)
2463 if ( !GetNumericToken(input
, &num
) || (num
> 31) )
2466 return (wxChar
*)NULL
;
2469 // we can't check whether the day range is correct yet, will
2470 // do it later - assume ok for now
2472 mday
= (wxDateTime_t
)num
;
2475 case _T('H'): // hour in 24h format (00-23)
2476 if ( !GetNumericToken(input
, &num
) || (num
> 23) )
2479 return (wxChar
*)NULL
;
2483 hour
= (wxDateTime_t
)num
;
2486 case _T('I'): // hour in 12h format (01-12)
2487 if ( !GetNumericToken(input
, &num
) || !num
|| (num
> 12) )
2490 return (wxChar
*)NULL
;
2494 hourIsIn12hFormat
= TRUE
;
2495 hour
= num
% 12; // 12 should be 0
2498 case _T('j'): // day of the year
2499 if ( !GetNumericToken(input
, &num
) || !num
|| (num
> 366) )
2502 return (wxChar
*)NULL
;
2506 yday
= (wxDateTime_t
)num
;
2509 case _T('m'): // month as a number (01-12)
2510 if ( !GetNumericToken(input
, &num
) || !num
|| (num
> 12) )
2513 return (wxChar
*)NULL
;
2517 mon
= (Month
)(num
- 1);
2520 case _T('M'): // minute as a decimal number (00-59)
2521 if ( !GetNumericToken(input
, &num
) || (num
> 59) )
2524 return (wxChar
*)NULL
;
2528 min
= (wxDateTime_t
)num
;
2531 case _T('p'): // AM or PM string
2533 wxString am
, pm
, token
= GetAlphaToken(input
);
2535 GetAmPmStrings(&am
, &pm
);
2536 if ( token
.CmpNoCase(pm
) == 0 )
2540 else if ( token
.CmpNoCase(am
) != 0 )
2543 return (wxChar
*)NULL
;
2548 case _T('r'): // time as %I:%M:%S %p
2551 input
= dt
.ParseFormat(input
, _T("%I:%M:%S %p"));
2555 return (wxChar
*)NULL
;
2558 haveHour
= haveMin
= haveSec
= TRUE
;
2567 case _T('R'): // time as %H:%M
2570 input
= dt
.ParseFormat(input
, _T("%H:%M"));
2574 return (wxChar
*)NULL
;
2577 haveHour
= haveMin
= TRUE
;
2584 case _T('S'): // second as a decimal number (00-61)
2585 if ( !GetNumericToken(input
, &num
) || (num
> 61) )
2588 return (wxChar
*)NULL
;
2592 sec
= (wxDateTime_t
)num
;
2595 case _T('T'): // time as %H:%M:%S
2598 input
= dt
.ParseFormat(input
, _T("%H:%M:%S"));
2602 return (wxChar
*)NULL
;
2605 haveHour
= haveMin
= haveSec
= TRUE
;
2614 case _T('w'): // weekday as a number (0-6), Sunday = 0
2615 if ( !GetNumericToken(input
, &num
) || (wday
> 6) )
2618 return (wxChar
*)NULL
;
2622 wday
= (WeekDay
)num
;
2625 case _T('x'): // locale default date representation
2626 #ifdef HAVE_STRPTIME
2627 // try using strptime() - it may fail even if the input is
2628 // correct but the date is out of range, so we will fall back
2629 // to our generic code anyhow (FIXME !Unicode friendly)
2632 const wxChar
*result
= strptime(input
, "%x", &tm
);
2637 haveDay
= haveMon
= haveYear
= TRUE
;
2639 year
= 1900 + tm
.tm_year
;
2640 mon
= (Month
)tm
.tm_mon
;
2646 #endif // HAVE_STRPTIME
2648 // TODO query the LOCALE_IDATE setting under Win32
2652 wxString fmtDate
, fmtDateAlt
;
2653 if ( IsWestEuropeanCountry(GetCountry()) ||
2654 GetCountry() == Russia
)
2656 fmtDate
= _T("%d/%m/%y");
2657 fmtDateAlt
= _T("%m/%d/%y");
2661 fmtDate
= _T("%m/%d/%y");
2662 fmtDateAlt
= _T("%d/%m/%y");
2665 const wxChar
*result
= dt
.ParseFormat(input
, fmtDate
);
2669 // ok, be nice and try another one
2670 result
= dt
.ParseFormat(input
, fmtDateAlt
);
2676 return (wxChar
*)NULL
;
2681 haveDay
= haveMon
= haveYear
= TRUE
;
2692 case _T('X'): // locale default time representation
2693 #ifdef HAVE_STRPTIME
2695 // use strptime() to do it for us (FIXME !Unicode friendly)
2697 input
= strptime(input
, "%X", &tm
);
2700 return (wxChar
*)NULL
;
2703 haveHour
= haveMin
= haveSec
= TRUE
;
2709 #else // !HAVE_STRPTIME
2710 // TODO under Win32 we can query the LOCALE_ITIME system
2711 // setting which says whether the default time format is
2714 // try to parse what follows as "%H:%M:%S" and, if this
2715 // fails, as "%I:%M:%S %p" - this should catch the most
2719 const wxChar
*result
= dt
.ParseFormat(input
, _T("%T"));
2722 result
= dt
.ParseFormat(input
, _T("%r"));
2728 return (wxChar
*)NULL
;
2731 haveHour
= haveMin
= haveSec
= TRUE
;
2740 #endif // HAVE_STRPTIME/!HAVE_STRPTIME
2743 case _T('y'): // year without century (00-99)
2744 if ( !GetNumericToken(input
, &num
) || (num
> 99) )
2747 return (wxChar
*)NULL
;
2754 case _T('Y'): // year with century
2755 if ( !GetNumericToken(input
, &num
) )
2758 return (wxChar
*)NULL
;
2762 year
= (wxDateTime_t
)num
;
2765 case _T('Z'): // timezone name
2766 wxFAIL_MSG(_T("TODO"));
2769 case _T('%'): // a percent sign
2770 if ( *input
++ != _T('%') )
2773 return (wxChar
*)NULL
;
2777 case 0: // the end of string
2778 wxFAIL_MSG(_T("unexpected format end"));
2782 default: // not a known format spec
2783 return (wxChar
*)NULL
;
2787 // format matched, try to construct a date from what we have now
2789 if ( dateDef
.IsValid() )
2791 // take this date as default
2792 tmDef
= dateDef
.GetTm();
2794 else if ( m_time
!= 0 )
2796 // if this date is valid, don't change it
2801 // no default and this date is invalid - fall back to Today()
2802 tmDef
= Today().GetTm();
2813 // TODO we don't check here that the values are consistent, if both year
2814 // day and month/day were found, we just ignore the year day and we
2815 // also always ignore the week day
2816 if ( haveMon
&& haveDay
)
2818 if ( mday
> GetNumOfDaysInMonth(tm
.year
, mon
) )
2820 wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
2822 return (wxChar
*)NULL
;
2828 else if ( haveYDay
)
2830 if ( yday
> GetNumberOfDays(tm
.year
) )
2832 wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
2834 return (wxChar
*)NULL
;
2837 Tm tm2
= wxDateTime(1, Jan
, tm
.year
).SetToYearDay(yday
).GetTm();
2844 if ( haveHour
&& hourIsIn12hFormat
&& isPM
)
2846 // translate to 24hour format
2849 //else: either already in 24h format or no translation needed
2872 const wxChar
*wxDateTime::ParseDateTime(const wxChar
*date
)
2874 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2876 // there is a public domain version of getdate.y, but it only works for
2878 wxFAIL_MSG(_T("TODO"));
2880 return (wxChar
*)NULL
;
2883 const wxChar
*wxDateTime::ParseDate(const wxChar
*date
)
2885 // this is a simplified version of ParseDateTime() which understands only
2886 // "today" (for wxDate compatibility) and digits only otherwise (and not
2887 // all esoteric constructions ParseDateTime() knows about)
2889 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2891 const wxChar
*p
= date
;
2892 while ( wxIsspace(*p
) )
2895 wxString today
= _T("today");
2896 size_t len
= today
.length();
2897 if ( wxString(p
, len
).CmpNoCase(today
) == 0 )
2899 // nothing can follow this, so stop here
2908 bool haveDay
= FALSE
, // the months day?
2909 haveWDay
= FALSE
, // the day of week?
2910 haveMon
= FALSE
, // the month?
2911 haveYear
= FALSE
; // the year?
2913 // and the value of the items we have (init them to get rid of warnings)
2914 WeekDay wday
= Inv_WeekDay
;
2915 wxDateTime_t day
= 0;
2916 wxDateTime::Month mon
= Inv_Month
;
2919 // tokenize the string
2920 wxStringTokenizer
tok(p
, _T(",/-\t\n "));
2921 while ( tok
.HasMoreTokens() )
2923 wxString token
= tok
.GetNextToken();
2927 if ( token
.ToULong(&val
) )
2929 // guess what this number is
2933 // only years are counted from 0
2934 isYear
= (val
== 0) || (val
> 31);
2937 // may be the month or month day or the year, assume the
2938 // month day by default and fallback to month if the range
2939 // allow it or to the year if our assumption doesn't work
2942 // we already have the day, so may only be a month or year
2952 else // it may be day
2959 if ( val
> GetNumOfDaysInMonth(haveYear
? year
2963 // oops, it can't be a day finally
2979 // remember that we have this and stop the scan if it's the second
2980 // time we find this, except for the day logic (see there)
2990 // no roll over - 99 means 99, not 1999 for us
3002 mon
= (wxDateTime::Month
)val
;
3006 wxASSERT_MSG( isDay
, _T("logic error") );
3010 // may be were mistaken when we found it for the first
3011 // time? may be it was a month or year instead?
3013 // this ability to "backtrack" allows us to correctly parse
3014 // both things like 01/13 and 13/01 - but, of course, we
3015 // still can't resolve the ambiguity in 01/02 (it will be
3016 // Feb 1 for us, not Jan 2 as americans might expect!)
3017 if ( (day
<= 12) && !haveMon
)
3019 // exchange day and month
3020 mon
= (wxDateTime::Month
)day
;
3024 else if ( !haveYear
)
3026 // exchange day and year
3038 else // not a number
3040 mon
= GetMonthFromName(token
, Name_Full
| Name_Abbr
);
3041 if ( mon
!= Inv_Month
)
3053 wday
= GetWeekDayFromName(token
, Name_Full
| Name_Abbr
);
3054 if ( wday
!= Inv_WeekDay
)
3067 static const wxChar
*ordinals
[] =
3069 wxTRANSLATE("first"),
3070 wxTRANSLATE("second"),
3071 wxTRANSLATE("third"),
3072 wxTRANSLATE("fourth"),
3073 wxTRANSLATE("fifth"),
3074 wxTRANSLATE("sixth"),
3075 wxTRANSLATE("seventh"),
3076 wxTRANSLATE("eighth"),
3077 wxTRANSLATE("ninth"),
3078 wxTRANSLATE("tenth"),
3079 wxTRANSLATE("eleventh"),
3080 wxTRANSLATE("twelfth"),
3081 wxTRANSLATE("thirteenth"),
3082 wxTRANSLATE("fourteenth"),
3083 wxTRANSLATE("fifteenth"),
3084 wxTRANSLATE("sixteenth"),
3085 wxTRANSLATE("seventeenth"),
3086 wxTRANSLATE("eighteenth"),
3087 wxTRANSLATE("nineteenth"),
3088 wxTRANSLATE("twentieth"),
3089 // that's enough - otherwise we'd have problems with
3090 // composite (or not) ordinals otherwise
3094 for ( n
= 0; n
< WXSIZEOF(ordinals
); n
++ )
3096 if ( token
.CmpNoCase(ordinals
[n
]) == 0 )
3102 if ( n
== WXSIZEOF(ordinals
) )
3104 // stop here - something unknown
3111 // don't try anything here (as in case of numeric day
3112 // above) - the symbolic day spec should always
3113 // precede the month/year
3125 // either no more tokens or the scan was stopped by something we couldn't
3126 // parse - in any case, see if we can construct a date from what we have
3127 if ( !haveDay
&& !haveWDay
)
3129 wxLogDebug(_T("no day, no weekday hence no date."));
3131 return (wxChar
*)NULL
;
3134 if ( haveWDay
&& (haveMon
|| haveYear
|| haveDay
) &&
3135 !(haveMon
&& haveMon
&& haveYear
) )
3137 // without adjectives (which we don't support here) the week day only
3138 // makes sense completely separately or with the full date
3139 // specification (what would "Wed 1999" mean?)
3140 return (wxChar
*)NULL
;
3145 mon
= GetCurrentMonth();
3150 year
= GetCurrentYear();
3155 Set(day
, mon
, year
);
3159 // check that it is really the same
3160 if ( GetWeekDay() != wday
)
3162 // inconsistency detected
3163 return (wxChar
*)NULL
;
3171 SetToWeekDayInSameWeek(wday
);
3174 // return the pointer to the next char
3175 return p
+ wxStrlen(p
) - wxStrlen(tok
.GetString());
3178 const wxChar
*wxDateTime::ParseTime(const wxChar
*time
)
3180 wxCHECK_MSG( time
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3182 // first try some extra things
3189 { wxTRANSLATE("noon"), 12 },
3190 { wxTRANSLATE("midnight"), 00 },
3194 for ( size_t n
= 0; n
< WXSIZEOF(stdTimes
); n
++ )
3196 wxString timeString
= wxGetTranslation(stdTimes
[n
].name
);
3197 size_t len
= timeString
.length();
3198 if ( timeString
.CmpNoCase(wxString(time
, len
)) == 0 )
3200 Set(stdTimes
[n
].hour
, 0, 0);
3206 // try all time formats we may think about starting with the standard one
3207 const wxChar
*result
= ParseFormat(time
, _T("%X"));
3210 // normally, it's the same, but why not try it?
3211 result
= ParseFormat(time
, _T("%H:%M:%S"));
3216 // 12hour with AM/PM?
3217 result
= ParseFormat(time
, _T("%I:%M:%S %p"));
3223 result
= ParseFormat(time
, _T("%H:%M"));
3228 // 12hour with AM/PM but without seconds?
3229 result
= ParseFormat(time
, _T("%I:%M %p"));
3235 result
= ParseFormat(time
, _T("%H"));
3240 // just the hour and AM/PM?
3241 result
= ParseFormat(time
, _T("%I %p"));
3244 // TODO: parse timezones
3249 // ============================================================================
3251 // ============================================================================
3253 // not all strftime(3) format specifiers make sense here because, for example,
3254 // a time span doesn't have a year nor a timezone
3256 // Here are the ones which are supported (all of them are supported by strftime
3258 // %H hour in 24 hour format
3259 // %M minute (00 - 59)
3260 // %S second (00 - 59)
3263 // Also, for MFC CTimeSpan compatibility, we support
3264 // %D number of days
3266 // And, to be better than MFC :-), we also have
3267 // %E number of wEeks
3268 // %l milliseconds (000 - 999)
3269 wxString
wxTimeSpan::Format(const wxChar
*format
) const
3271 wxCHECK_MSG( format
, _T(""), _T("NULL format in wxTimeSpan::Format") );
3274 str
.Alloc(strlen(format
));
3276 for ( const wxChar
*pch
= format
; pch
; pch
++ )
3288 wxFAIL_MSG( _T("invalid format character") );
3292 // will get to str << ch below
3296 tmp
.Printf(_T("%d"), GetDays());
3300 tmp
.Printf(_T("%d"), GetWeeks());
3304 tmp
.Printf(_T("%02d"), GetHours());
3308 tmp
.Printf(_T("%03ld"), GetMilliseconds().ToLong());
3312 tmp
.Printf(_T("%02d"), GetMinutes());
3316 tmp
.Printf(_T("%02ld"), GetSeconds().ToLong());
3324 // skip str += ch below