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
450 mday
+= 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 time_t timet
= GetTimeNow();
1039 struct tm
*tm
= localtime(&timet
);
1041 wxCHECK_MSG( tm
, wxInvalidDateTime
, _T("localtime() failed") );
1045 tm
->tm_min
= minute
;
1046 tm
->tm_sec
= second
;
1050 // and finally adjust milliseconds
1051 return SetMillisecond(millisec
);
1054 wxDateTime
& wxDateTime::Set(wxDateTime_t day
,
1058 wxDateTime_t minute
,
1059 wxDateTime_t second
,
1060 wxDateTime_t millisec
)
1062 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1064 wxCHECK_MSG( hour
< 24 && second
< 62 && minute
< 60 && millisec
< 1000,
1066 _T("Invalid time in wxDateTime::Set()") );
1068 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1070 wxCHECK_MSG( (0 < day
) && (day
<= GetNumberOfDays(month
, year
)),
1072 _T("Invalid date in wxDateTime::Set()") );
1074 // the range of time_t type (inclusive)
1075 static const int yearMinInRange
= 1970;
1076 static const int yearMaxInRange
= 2037;
1078 // test only the year instead of testing for the exact end of the Unix
1079 // time_t range - it doesn't bring anything to do more precise checks
1080 if ( year
>= yearMinInRange
&& year
<= yearMaxInRange
)
1082 // use the standard library version if the date is in range - this is
1083 // probably more efficient than our code
1085 tm
.tm_year
= year
- 1900;
1091 tm
.tm_isdst
= -1; // mktime() will guess it
1095 // and finally adjust milliseconds
1096 return SetMillisecond(millisec
);
1100 // do time calculations ourselves: we want to calculate the number of
1101 // milliseconds between the given date and the epoch
1103 // get the JDN for the midnight of this day
1104 m_time
= GetTruncatedJDN(day
, month
, year
);
1105 m_time
-= EPOCH_JDN
;
1106 m_time
*= SECONDS_PER_DAY
* TIME_T_FACTOR
;
1108 // JDN corresponds to GMT, we take localtime
1109 Add(wxTimeSpan(hour
, minute
, second
+ GetTimeZone(), millisec
));
1115 wxDateTime
& wxDateTime::Set(double jdn
)
1117 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1119 jdn
-= EPOCH_JDN
+ 0.5;
1121 jdn
*= MILLISECONDS_PER_DAY
;
1128 // ----------------------------------------------------------------------------
1129 // time_t <-> broken down time conversions
1130 // ----------------------------------------------------------------------------
1132 wxDateTime::Tm
wxDateTime::GetTm(const TimeZone
& tz
) const
1137 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1139 time_t time
= GetTicks();
1140 if ( time
!= (time_t)-1 )
1142 // use C RTL functions
1144 if ( tz
.GetOffset() == -GetTimeZone() )
1146 // we are working with local time
1147 tm
= localtime(&time
);
1149 // should never happen
1150 wxCHECK_MSG( tm
, Tm(), _T("gmtime() failed") );
1154 time
+= tz
.GetOffset();
1155 #ifdef __VMS__ /* time is unsigned so VMS gives a warning on the original */
1164 // should never happen
1165 wxCHECK_MSG( tm
, Tm(), _T("gmtime() failed") );
1169 tm
= (struct tm
*)NULL
;
1177 //else: use generic code below
1180 // remember the time and do the calculations with the date only - this
1181 // eliminates rounding errors of the floating point arithmetics
1183 wxLongLong timeMidnight
= m_time
+ tz
.GetOffset() * 1000;
1185 long timeOnly
= (timeMidnight
% MILLISECONDS_PER_DAY
).ToLong();
1187 // we want to always have positive time and timeMidnight to be really
1188 // the midnight before it
1191 timeOnly
= MILLISECONDS_PER_DAY
+ timeOnly
;
1194 timeMidnight
-= timeOnly
;
1196 // calculate the Gregorian date from JDN for the midnight of our date:
1197 // this will yield day, month (in 1..12 range) and year
1199 // actually, this is the JDN for the noon of the previous day
1200 long jdn
= (timeMidnight
/ MILLISECONDS_PER_DAY
).ToLong() + EPOCH_JDN
;
1202 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1204 wxASSERT_MSG( jdn
> -2, _T("JDN out of range") );
1206 // calculate the century
1207 int temp
= (jdn
+ JDN_OFFSET
) * 4 - 1;
1208 int century
= temp
/ DAYS_PER_400_YEARS
;
1210 // then the year and day of year (1 <= dayOfYear <= 366)
1211 temp
= ((temp
% DAYS_PER_400_YEARS
) / 4) * 4 + 3;
1212 int year
= (century
* 100) + (temp
/ DAYS_PER_4_YEARS
);
1213 int dayOfYear
= (temp
% DAYS_PER_4_YEARS
) / 4 + 1;
1215 // and finally the month and day of the month
1216 temp
= dayOfYear
* 5 - 3;
1217 int month
= temp
/ DAYS_PER_5_MONTHS
;
1218 int day
= (temp
% DAYS_PER_5_MONTHS
) / 5 + 1;
1220 // month is counted from March - convert to normal
1231 // year is offset by 4800
1234 // check that the algorithm gave us something reasonable
1235 wxASSERT_MSG( (0 < month
) && (month
<= 12), _T("invalid month") );
1236 wxASSERT_MSG( (1 <= day
) && (day
< 32), _T("invalid day") );
1237 wxASSERT_MSG( (INT_MIN
<= year
) && (year
<= INT_MAX
),
1238 _T("year range overflow") );
1240 // construct Tm from these values
1242 tm
.year
= (int)year
;
1243 tm
.mon
= (Month
)(month
- 1); // algorithm yields 1 for January, not 0
1244 tm
.mday
= (wxDateTime_t
)day
;
1245 tm
.msec
= timeOnly
% 1000;
1246 timeOnly
-= tm
.msec
;
1247 timeOnly
/= 1000; // now we have time in seconds
1249 tm
.sec
= timeOnly
% 60;
1251 timeOnly
/= 60; // now we have time in minutes
1253 tm
.min
= timeOnly
% 60;
1256 tm
.hour
= timeOnly
/ 60;
1261 wxDateTime
& wxDateTime::SetYear(int year
)
1263 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1272 wxDateTime
& wxDateTime::SetMonth(Month month
)
1274 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1283 wxDateTime
& wxDateTime::SetDay(wxDateTime_t mday
)
1285 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1294 wxDateTime
& wxDateTime::SetHour(wxDateTime_t hour
)
1296 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1305 wxDateTime
& wxDateTime::SetMinute(wxDateTime_t min
)
1307 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1316 wxDateTime
& wxDateTime::SetSecond(wxDateTime_t sec
)
1318 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1327 wxDateTime
& wxDateTime::SetMillisecond(wxDateTime_t millisecond
)
1329 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1331 // we don't need to use GetTm() for this one
1332 m_time
-= m_time
% 1000l;
1333 m_time
+= millisecond
;
1338 // ----------------------------------------------------------------------------
1339 // wxDateTime arithmetics
1340 // ----------------------------------------------------------------------------
1342 wxDateTime
& wxDateTime::Add(const wxDateSpan
& diff
)
1346 tm
.year
+= diff
.GetYears();
1347 tm
.AddMonths(diff
.GetMonths());
1348 tm
.AddDays(diff
.GetTotalDays());
1355 // ----------------------------------------------------------------------------
1356 // Weekday and monthday stuff
1357 // ----------------------------------------------------------------------------
1359 wxDateTime
& wxDateTime::SetToLastMonthDay(Month month
,
1362 // take the current month/year if none specified
1363 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1365 return Set(GetNumOfDaysInMonth(year
, month
), month
, year
);
1368 wxDateTime
& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday
)
1370 wxCHECK_MSG( weekday
!= Inv_WeekDay
, wxInvalidDateTime
, _T("invalid weekday") );
1372 WeekDay wdayThis
= GetWeekDay();
1373 if ( weekday
== wdayThis
)
1378 else if ( weekday
< wdayThis
)
1380 return Substract(wxTimeSpan::Days(wdayThis
- weekday
));
1382 else // weekday > wdayThis
1384 return Add(wxTimeSpan::Days(weekday
- wdayThis
));
1388 wxDateTime
& wxDateTime::SetToNextWeekDay(WeekDay weekday
)
1390 wxCHECK_MSG( weekday
!= Inv_WeekDay
, wxInvalidDateTime
, _T("invalid weekday") );
1393 WeekDay wdayThis
= GetWeekDay();
1394 if ( weekday
== wdayThis
)
1399 else if ( weekday
< wdayThis
)
1401 // need to advance a week
1402 diff
= 7 - (wdayThis
- weekday
);
1404 else // weekday > wdayThis
1406 diff
= weekday
- wdayThis
;
1409 return Add(wxTimeSpan::Days(diff
));
1412 wxDateTime
& wxDateTime::SetToPrevWeekDay(WeekDay weekday
)
1414 wxCHECK_MSG( weekday
!= Inv_WeekDay
, wxInvalidDateTime
, _T("invalid weekday") );
1417 WeekDay wdayThis
= GetWeekDay();
1418 if ( weekday
== wdayThis
)
1423 else if ( weekday
> wdayThis
)
1425 // need to go to previous week
1426 diff
= 7 - (weekday
- wdayThis
);
1428 else // weekday < wdayThis
1430 diff
= wdayThis
- weekday
;
1433 return Substract(wxTimeSpan::Days(diff
));
1436 bool wxDateTime::SetToWeekDay(WeekDay weekday
,
1441 wxCHECK_MSG( weekday
!= Inv_WeekDay
, FALSE
, _T("invalid weekday") );
1443 // we don't check explicitly that -5 <= n <= 5 because we will return FALSE
1444 // anyhow in such case - but may be should still give an assert for it?
1446 // take the current month/year if none specified
1447 ReplaceDefaultYearMonthWithCurrent(&year
, &month
);
1451 // TODO this probably could be optimised somehow...
1455 // get the first day of the month
1456 dt
.Set(1, month
, year
);
1459 WeekDay wdayFirst
= dt
.GetWeekDay();
1461 // go to the first weekday of the month
1462 int diff
= weekday
- wdayFirst
;
1466 // add advance n-1 weeks more
1469 dt
+= wxDateSpan::Days(diff
);
1471 else // count from the end of the month
1473 // get the last day of the month
1474 dt
.SetToLastMonthDay(month
, year
);
1477 WeekDay wdayLast
= dt
.GetWeekDay();
1479 // go to the last weekday of the month
1480 int diff
= wdayLast
- weekday
;
1484 // and rewind n-1 weeks from there
1487 dt
-= wxDateSpan::Days(diff
);
1490 // check that it is still in the same month
1491 if ( dt
.GetMonth() == month
)
1499 // no such day in this month
1504 wxDateTime::wxDateTime_t
wxDateTime::GetDayOfYear(const TimeZone
& tz
) const
1508 return gs_cumulatedDays
[IsLeapYear(tm
.year
)][tm
.mon
] + tm
.mday
;
1511 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfYear(const TimeZone
& tz
) const
1514 // the first week of the year is the one which contains Jan, 4 (according
1515 // to ISO standard rule), so the year day N0 = 4 + 7*W always lies in the
1516 // week W+1. As any day N = 7*W + 4 + (N - 4)%7, it lies in the same week
1517 // as N0 or in the next one.
1519 // TODO this surely may be optimized - I got confused while writing it
1521 wxDateTime_t nDayInYear
= GetDayOfYear(tz
);
1523 // the week day of the day lying in the first week
1524 WeekDay wdayStart
= wxDateTime(4, Jan
, GetYear()).GetWeekDay();
1526 wxDateTime_t week
= (nDayInYear
- 4) / 7 + 1;
1528 // notice that Sunday shoould be counted as 7, not 0 here!
1529 if ( ((nDayInYear
- 4) % 7) + (!wdayStart
? 7 : wdayStart
) > 7 )
1536 // an attempt at doing it simpler - but this doesn't quite work...
1537 return (WeekDay
)((GetDayOfYear(tz
) - (GetWeekDay(tz
) - 1 + 7) % 7 + 7) / 7);
1541 wxDateTime::wxDateTime_t
wxDateTime::GetWeekOfMonth(const TimeZone
& tz
) const
1545 wxDateTime
dt(*this);
1550 dt
-= wxTimeSpan::Week();
1552 while ( dt
.GetMonth(tz
) == GetMonth(tz
) );
1557 wxDateTime
& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday
)
1559 int year
= GetYear();
1560 wxCHECK_MSG( (0 < yday
) && (yday
<= GetNumberOfDays(year
)),
1561 wxInvalidDateTime
, _T("invalid year day") );
1563 bool isLeap
= IsLeapYear(year
);
1564 for ( Month mon
= Jan
; mon
< Inv_Month
; wxNextMonth(mon
) )
1566 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
1567 // don't need it neither - because of the CHECK above we know that
1568 // yday lies in December then
1569 if ( (mon
== Dec
) || (yday
< gs_cumulatedDays
[isLeap
][mon
+ 1]) )
1571 Set(yday
- gs_cumulatedDays
[isLeap
][mon
], mon
, year
);
1580 // ----------------------------------------------------------------------------
1581 // Julian day number conversion and related stuff
1582 // ----------------------------------------------------------------------------
1584 double wxDateTime::GetJulianDayNumber() const
1586 // JDN are always expressed for the GMT dates
1587 Tm
tm(ToTimezone(GMT0
).GetTm(GMT0
));
1589 double result
= GetTruncatedJDN(tm
.mday
, tm
.mon
, tm
.year
);
1591 // add the part GetTruncatedJDN() neglected
1594 // and now add the time: 86400 sec = 1 JDN
1595 return result
+ ((double)(60*(60*tm
.hour
+ tm
.min
) + tm
.sec
)) / 86400;
1598 double wxDateTime::GetRataDie() const
1600 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
1601 return GetJulianDayNumber() - 1721119.5 - 306;
1604 // ----------------------------------------------------------------------------
1605 // timezone and DST stuff
1606 // ----------------------------------------------------------------------------
1608 int wxDateTime::IsDST(wxDateTime::Country country
) const
1610 wxCHECK_MSG( country
== Country_Default
, -1,
1611 _T("country support not implemented") );
1613 // use the C RTL for the dates in the standard range
1614 time_t timet
= GetTicks();
1615 if ( timet
!= (time_t)-1 )
1617 tm
*tm
= localtime(&timet
);
1619 wxCHECK_MSG( tm
, -1, _T("localtime() failed") );
1621 return tm
->tm_isdst
;
1625 int year
= GetYear();
1627 if ( !IsDSTApplicable(year
, country
) )
1629 // no DST time in this year in this country
1633 return IsBetween(GetBeginDST(year
, country
), GetEndDST(year
, country
));
1637 wxDateTime
& wxDateTime::MakeTimezone(const TimeZone
& tz
, bool noDST
)
1639 int secDiff
= GetTimeZone() + tz
.GetOffset();
1641 // we need to know whether DST is or not in effect for this date unless
1642 // the test disabled by the caller
1643 if ( !noDST
&& (IsDST() == 1) )
1645 // FIXME we assume that the DST is always shifted by 1 hour
1649 return Substract(wxTimeSpan::Seconds(secDiff
));
1652 // ----------------------------------------------------------------------------
1653 // wxDateTime to/from text representations
1654 // ----------------------------------------------------------------------------
1656 wxString
wxDateTime::Format(const wxChar
*format
, const TimeZone
& tz
) const
1661 wxCHECK_MSG( format
, _T(""), _T("NULL format in wxDateTime::Format") );
1663 time_t time
= GetTicks();
1664 if ( time
!= (time_t)-1 )
1668 if ( tz
.GetOffset() == -GetTimeZone() )
1670 // we are working with local time
1671 tm
= localtime(&time
);
1673 // should never happen
1674 wxCHECK_MSG( tm
, wxEmptyString
, _T("localtime() failed") );
1678 time
+= tz
.GetOffset();
1680 #ifdef __VMS__ /* time is unsigned so VMS gives a warning on the original */
1689 // should never happen
1690 wxCHECK_MSG( tm
, wxEmptyString
, _T("gmtime() failed") );
1694 tm
= (struct tm
*)NULL
;
1700 return CallStrftime(format
, tm
);
1702 //else: use generic code below
1705 // we only parse ANSI C format specifications here, no POSIX 2
1706 // complications, no GNU extensions
1709 // used for calls to strftime() when we only deal with time
1710 struct tm tmTimeOnly
;
1711 tmTimeOnly
.tm_hour
= tm
.hour
;
1712 tmTimeOnly
.tm_min
= tm
.min
;
1713 tmTimeOnly
.tm_sec
= tm
.sec
;
1714 tmTimeOnly
.tm_wday
= 0;
1715 tmTimeOnly
.tm_yday
= 0;
1716 tmTimeOnly
.tm_mday
= 1; // any date will do
1717 tmTimeOnly
.tm_mon
= 0;
1718 tmTimeOnly
.tm_year
= 76;
1719 tmTimeOnly
.tm_isdst
= 0; // no DST, we adjust for tz ourselves
1721 wxString tmp
, res
, fmt
;
1722 for ( const wxChar
*p
= format
; *p
; p
++ )
1724 if ( *p
!= _T('%') )
1732 // set the default format
1735 case _T('Y'): // year has 4 digits
1739 case _T('j'): // day of year has 3 digits
1744 // it's either another valid format specifier in which case
1745 // the format is "%02d" (for all the rest) or we have the
1746 // field width preceding the format in which case it will
1747 // override the default format anyhow
1752 // start of the format specification
1755 case _T('a'): // a weekday name
1757 // second parameter should be TRUE for abbreviated names
1758 res
+= GetWeekDayName(tm
.GetWeekDay(),
1759 *p
== _T('a') ? Name_Abbr
: Name_Full
);
1762 case _T('b'): // a month name
1764 res
+= GetMonthName(tm
.mon
,
1765 *p
== _T('b') ? Name_Abbr
: Name_Full
);
1768 case _T('c'): // locale default date and time representation
1769 case _T('x'): // locale default date representation
1771 // the problem: there is no way to know what do these format
1772 // specifications correspond to for the current locale.
1774 // the solution: use a hack and still use strftime(): first
1775 // find the YEAR which is a year in the strftime() range (1970
1776 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
1777 // of the real year. Then make a copy of the format and
1778 // replace all occurences of YEAR in it with some unique
1779 // string not appearing anywhere else in it, then use
1780 // strftime() to format the date in year YEAR and then replace
1781 // YEAR back by the real year and the unique replacement
1782 // string back with YEAR. Notice that "all occurences of YEAR"
1783 // means all occurences of 4 digit as well as 2 digit form!
1785 // the bugs: we assume that neither of %c nor %x contains any
1786 // fields which may change between the YEAR and real year. For
1787 // example, the week number (%U, %W) and the day number (%j)
1788 // will change if one of these years is leap and the other one
1791 // find the YEAR: normally, for any year X, Jan 1 or the
1792 // year X + 28 is the same weekday as Jan 1 of X (because
1793 // the weekday advances by 1 for each normal X and by 2
1794 // for each leap X, hence by 5 every 4 years or by 35
1795 // which is 0 mod 7 every 28 years) but this rule breaks
1796 // down if there are years between X and Y which are
1797 // divisible by 4 but not leap (i.e. divisible by 100 but
1798 // not 400), hence the correction.
1800 int yearReal
= GetYear(tz
);
1801 int mod28
= yearReal
% 28;
1803 // be careful to not go too far - we risk to leave the
1808 year
= 1988 + mod28
; // 1988 == 0 (mod 28)
1812 year
= 1970 + mod28
- 10; // 1970 == 10 (mod 28)
1815 int nCentury
= year
/ 100,
1816 nCenturyReal
= yearReal
/ 100;
1818 // need to adjust for the years divisble by 400 which are
1819 // not leap but are counted like leap ones if we just take
1820 // the number of centuries in between for nLostWeekDays
1821 int nLostWeekDays
= (nCentury
- nCenturyReal
) -
1822 (nCentury
/ 4 - nCenturyReal
/ 4);
1824 // we have to gain back the "lost" weekdays: note that the
1825 // effect of this loop is to not do anything to
1826 // nLostWeekDays (which we won't use any more), but to
1827 // (indirectly) set the year correctly
1828 while ( (nLostWeekDays
% 7) != 0 )
1830 nLostWeekDays
+= year
++ % 4 ? 1 : 2;
1833 // at any rate, we couldn't go further than 1988 + 9 + 28!
1834 wxASSERT_MSG( year
< 2030,
1835 _T("logic error in wxDateTime::Format") );
1837 wxString strYear
, strYear2
;
1838 strYear
.Printf(_T("%d"), year
);
1839 strYear2
.Printf(_T("%d"), year
% 100);
1841 // find two strings not occuring in format (this is surely
1842 // not optimal way of doing it... improvements welcome!)
1843 wxString fmt
= format
;
1844 wxString replacement
= (wxChar
)-1;
1845 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
1847 replacement
<< (wxChar
)-1;
1850 wxString replacement2
= (wxChar
)-2;
1851 while ( fmt
.Find(replacement
) != wxNOT_FOUND
)
1853 replacement
<< (wxChar
)-2;
1856 // replace all occurences of year with it
1857 bool wasReplaced
= fmt
.Replace(strYear
, replacement
) > 0;
1859 wasReplaced
= fmt
.Replace(strYear2
, replacement2
) > 0;
1861 // use strftime() to format the same date but in supported
1864 // NB: we assume that strftime() doesn't check for the
1865 // date validity and will happily format the date
1866 // corresponding to Feb 29 of a non leap year (which
1867 // may happen if yearReal was leap and year is not)
1868 struct tm tmAdjusted
;
1870 tmAdjusted
.tm_hour
= tm
.hour
;
1871 tmAdjusted
.tm_min
= tm
.min
;
1872 tmAdjusted
.tm_sec
= tm
.sec
;
1873 tmAdjusted
.tm_wday
= tm
.GetWeekDay();
1874 tmAdjusted
.tm_yday
= GetDayOfYear();
1875 tmAdjusted
.tm_mday
= tm
.mday
;
1876 tmAdjusted
.tm_mon
= tm
.mon
;
1877 tmAdjusted
.tm_year
= year
- 1900;
1878 tmAdjusted
.tm_isdst
= 0; // no DST, already adjusted
1879 wxString str
= CallStrftime(*p
== _T('c') ? _T("%c")
1883 // now replace the occurence of 1999 with the real year
1884 wxString strYearReal
, strYearReal2
;
1885 strYearReal
.Printf(_T("%04d"), yearReal
);
1886 strYearReal2
.Printf(_T("%02d"), yearReal
% 100);
1887 str
.Replace(strYear
, strYearReal
);
1888 str
.Replace(strYear2
, strYearReal2
);
1890 // and replace back all occurences of replacement string
1893 str
.Replace(replacement2
, strYear2
);
1894 str
.Replace(replacement
, strYear
);
1901 case _T('d'): // day of a month (01-31)
1902 res
+= wxString::Format(fmt
, tm
.mday
);
1905 case _T('H'): // hour in 24h format (00-23)
1906 res
+= wxString::Format(fmt
, tm
.hour
);
1909 case _T('I'): // hour in 12h format (01-12)
1911 // 24h -> 12h, 0h -> 12h too
1912 int hour12
= tm
.hour
> 12 ? tm
.hour
- 12
1913 : tm
.hour
? tm
.hour
: 12;
1914 res
+= wxString::Format(fmt
, hour12
);
1918 case _T('j'): // day of the year
1919 res
+= wxString::Format(fmt
, GetDayOfYear(tz
));
1922 case _T('m'): // month as a number (01-12)
1923 res
+= wxString::Format(fmt
, tm
.mon
+ 1);
1926 case _T('M'): // minute as a decimal number (00-59)
1927 res
+= wxString::Format(fmt
, tm
.min
);
1930 case _T('p'): // AM or PM string
1931 res
+= CallStrftime(_T("%p"), &tmTimeOnly
);
1934 case _T('S'): // second as a decimal number (00-61)
1935 res
+= wxString::Format(fmt
, tm
.sec
);
1938 case _T('U'): // week number in the year (Sunday 1st week day)
1940 int week
= (GetDayOfYear(tz
) - tm
.GetWeekDay() + 7) / 7;
1941 res
+= wxString::Format(fmt
, week
);
1945 case _T('W'): // week number in the year (Monday 1st week day)
1946 res
+= wxString::Format(fmt
, GetWeekOfYear(tz
));
1949 case _T('w'): // weekday as a number (0-6), Sunday = 0
1950 res
+= wxString::Format(fmt
, tm
.GetWeekDay());
1953 // case _T('x'): -- handled with "%c"
1955 case _T('X'): // locale default time representation
1956 // just use strftime() to format the time for us
1957 res
+= CallStrftime(_T("%X"), &tmTimeOnly
);
1960 case _T('y'): // year without century (00-99)
1961 res
+= wxString::Format(fmt
, tm
.year
% 100);
1964 case _T('Y'): // year with century
1965 res
+= wxString::Format(fmt
, tm
.year
);
1968 case _T('Z'): // timezone name
1969 res
+= CallStrftime(_T("%Z"), &tmTimeOnly
);
1973 // is it the format width?
1975 while ( *p
== _T('-') || *p
== _T('+') ||
1976 *p
== _T(' ') || wxIsdigit(*p
) )
1981 if ( !fmt
.IsEmpty() )
1983 // we've only got the flags and width so far in fmt
1984 fmt
.Prepend(_T('%'));
1985 fmt
.Append(_T('d'));
1990 // no, it wasn't the width
1991 wxFAIL_MSG(_T("unknown format specificator"));
1993 // fall through and just copy it nevertheless
1995 case _T('%'): // a percent sign
1999 case 0: // the end of string
2000 wxFAIL_MSG(_T("missing format at the end of string"));
2002 // just put the '%' which was the last char in format
2011 // this function parses a string in (strict) RFC 822 format: see the section 5
2012 // of the RFC for the detailed description, but briefly it's something of the
2013 // form "Sat, 18 Dec 1999 00:48:30 +0100"
2015 // this function is "strict" by design - it must reject anything except true
2016 // RFC822 time specs.
2018 // TODO a great candidate for using reg exps
2019 const wxChar
*wxDateTime::ParseRfc822Date(const wxChar
* date
)
2021 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2023 const wxChar
*p
= date
;
2024 const wxChar
*comma
= wxStrchr(p
, _T(','));
2027 // the part before comma is the weekday
2029 // skip it for now - we don't use but might check that it really
2030 // corresponds to the specfied date
2033 if ( *p
!= _T(' ') )
2035 wxLogDebug(_T("no space after weekday in RFC822 time spec"));
2037 return (wxChar
*)NULL
;
2043 // the following 1 or 2 digits are the day number
2044 if ( !wxIsdigit(*p
) )
2046 wxLogDebug(_T("day number expected in RFC822 time spec, none found"));
2048 return (wxChar
*)NULL
;
2051 wxDateTime_t day
= *p
++ - _T('0');
2052 if ( wxIsdigit(*p
) )
2055 day
+= *p
++ - _T('0');
2058 if ( *p
++ != _T(' ') )
2060 return (wxChar
*)NULL
;
2063 // the following 3 letters specify the month
2064 wxString
monName(p
, 3);
2066 if ( monName
== _T("Jan") )
2068 else if ( monName
== _T("Feb") )
2070 else if ( monName
== _T("Mar") )
2072 else if ( monName
== _T("Apr") )
2074 else if ( monName
== _T("May") )
2076 else if ( monName
== _T("Jun") )
2078 else if ( monName
== _T("Jul") )
2080 else if ( monName
== _T("Aug") )
2082 else if ( monName
== _T("Sep") )
2084 else if ( monName
== _T("Oct") )
2086 else if ( monName
== _T("Nov") )
2088 else if ( monName
== _T("Dec") )
2092 wxLogDebug(_T("Invalid RFC 822 month name '%s'"), monName
.c_str());
2094 return (wxChar
*)NULL
;
2099 if ( *p
++ != _T(' ') )
2101 return (wxChar
*)NULL
;
2105 if ( !wxIsdigit(*p
) )
2108 return (wxChar
*)NULL
;
2111 int year
= *p
++ - _T('0');
2113 if ( !wxIsdigit(*p
) )
2115 // should have at least 2 digits in the year
2116 return (wxChar
*)NULL
;
2120 year
+= *p
++ - _T('0');
2122 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
2123 if ( wxIsdigit(*p
) )
2126 year
+= *p
++ - _T('0');
2128 if ( !wxIsdigit(*p
) )
2130 // no 3 digit years please
2131 return (wxChar
*)NULL
;
2135 year
+= *p
++ - _T('0');
2138 if ( *p
++ != _T(' ') )
2140 return (wxChar
*)NULL
;
2143 // time is in the format hh:mm:ss and seconds are optional
2144 if ( !wxIsdigit(*p
) )
2146 return (wxChar
*)NULL
;
2149 wxDateTime_t hour
= *p
++ - _T('0');
2151 if ( !wxIsdigit(*p
) )
2153 return (wxChar
*)NULL
;
2157 hour
+= *p
++ - _T('0');
2159 if ( *p
++ != _T(':') )
2161 return (wxChar
*)NULL
;
2164 if ( !wxIsdigit(*p
) )
2166 return (wxChar
*)NULL
;
2169 wxDateTime_t min
= *p
++ - _T('0');
2171 if ( !wxIsdigit(*p
) )
2173 return (wxChar
*)NULL
;
2177 min
+= *p
++ - _T('0');
2179 wxDateTime_t sec
= 0;
2180 if ( *p
++ == _T(':') )
2182 if ( !wxIsdigit(*p
) )
2184 return (wxChar
*)NULL
;
2187 sec
= *p
++ - _T('0');
2189 if ( !wxIsdigit(*p
) )
2191 return (wxChar
*)NULL
;
2195 sec
+= *p
++ - _T('0');
2198 if ( *p
++ != _T(' ') )
2200 return (wxChar
*)NULL
;
2203 // and now the interesting part: the timezone
2205 if ( *p
== _T('-') || *p
== _T('+') )
2207 // the explicit offset given: it has the form of hhmm
2208 bool plus
= *p
++ == _T('+');
2210 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2212 return (wxChar
*)NULL
;
2216 offset
= 60*(10*(*p
- _T('0')) + (*(p
+ 1) - _T('0')));
2220 if ( !wxIsdigit(*p
) || !wxIsdigit(*(p
+ 1)) )
2222 return (wxChar
*)NULL
;
2226 offset
+= 10*(*p
- _T('0')) + (*(p
+ 1) - _T('0'));
2237 // the symbolic timezone given: may be either military timezone or one
2238 // of standard abbreviations
2241 // military: Z = UTC, J unused, A = -1, ..., Y = +12
2242 static const int offsets
[26] =
2244 //A B C D E F G H I J K L M
2245 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
2246 //N O P R Q S T U V W Z Y Z
2247 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
2250 if ( *p
< _T('A') || *p
> _T('Z') || *p
== _T('J') )
2252 wxLogDebug(_T("Invalid militaty timezone '%c'"), *p
);
2254 return (wxChar
*)NULL
;
2257 offset
= offsets
[*p
++ - _T('A')];
2263 if ( tz
== _T("UT") || tz
== _T("UTC") || tz
== _T("GMT") )
2265 else if ( tz
== _T("AST") )
2266 offset
= AST
- GMT0
;
2267 else if ( tz
== _T("ADT") )
2268 offset
= ADT
- GMT0
;
2269 else if ( tz
== _T("EST") )
2270 offset
= EST
- GMT0
;
2271 else if ( tz
== _T("EDT") )
2272 offset
= EDT
- GMT0
;
2273 else if ( tz
== _T("CST") )
2274 offset
= CST
- GMT0
;
2275 else if ( tz
== _T("CDT") )
2276 offset
= CDT
- GMT0
;
2277 else if ( tz
== _T("MST") )
2278 offset
= MST
- GMT0
;
2279 else if ( tz
== _T("MDT") )
2280 offset
= MDT
- GMT0
;
2281 else if ( tz
== _T("PST") )
2282 offset
= PST
- GMT0
;
2283 else if ( tz
== _T("PDT") )
2284 offset
= PDT
- GMT0
;
2287 wxLogDebug(_T("Unknown RFC 822 timezone '%s'"), p
);
2289 return (wxChar
*)NULL
;
2299 // the spec was correct
2300 Set(day
, mon
, year
, hour
, min
, sec
);
2301 MakeTimezone((wxDateTime_t
)(60*offset
));
2306 const wxChar
*wxDateTime::ParseFormat(const wxChar
*date
,
2307 const wxChar
*format
,
2308 const wxDateTime
& dateDef
)
2310 wxCHECK_MSG( date
&& format
, (wxChar
*)NULL
,
2311 _T("NULL pointer in wxDateTime::ParseFormat()") );
2316 // what fields have we found?
2317 bool haveWDay
= FALSE
,
2326 bool hourIsIn12hFormat
= FALSE
, // or in 24h one?
2327 isPM
= FALSE
; // AM by default
2329 // and the value of the items we have (init them to get rid of warnings)
2330 wxDateTime_t sec
= 0,
2333 WeekDay wday
= Inv_WeekDay
;
2334 wxDateTime_t yday
= 0,
2336 wxDateTime::Month mon
= Inv_Month
;
2339 const wxChar
*input
= date
;
2340 for ( const wxChar
*fmt
= format
; *fmt
; fmt
++ )
2342 if ( *fmt
!= _T('%') )
2344 if ( wxIsspace(*fmt
) )
2346 // a white space in the format string matches 0 or more white
2347 // spaces in the input
2348 while ( wxIsspace(*input
) )
2355 // any other character (not whitespace, not '%') must be
2356 // matched by itself in the input
2357 if ( *input
++ != *fmt
)
2360 return (wxChar
*)NULL
;
2364 // done with this format char
2368 // start of a format specification
2371 case _T('a'): // a weekday name
2374 int flag
= *fmt
== _T('a') ? Name_Abbr
: Name_Full
;
2375 wday
= GetWeekDayFromName(GetAlphaToken(input
), flag
);
2376 if ( wday
== Inv_WeekDay
)
2379 return (wxChar
*)NULL
;
2385 case _T('b'): // a month name
2388 int flag
= *fmt
== _T('b') ? Name_Abbr
: Name_Full
;
2389 mon
= GetMonthFromName(GetAlphaToken(input
), flag
);
2390 if ( mon
== Inv_Month
)
2393 return (wxChar
*)NULL
;
2399 case _T('c'): // locale default date and time representation
2403 // this is the format which corresponds to ctime() output
2404 // and strptime("%c") should parse it, so try it first
2405 static const wxChar
*fmtCtime
= _T("%a %b %d %H:%M:%S %Y");
2407 const wxChar
*result
= dt
.ParseFormat(input
, fmtCtime
);
2410 result
= dt
.ParseFormat(input
, _T("%x %X"));
2415 result
= dt
.ParseFormat(input
, _T("%X %x"));
2420 // we've tried everything and still no match
2421 return (wxChar
*)NULL
;
2426 haveDay
= haveMon
= haveYear
=
2427 haveHour
= haveMin
= haveSec
= TRUE
;
2441 case _T('d'): // day of a month (01-31)
2442 if ( !GetNumericToken(input
, &num
) || (num
> 31) )
2445 return (wxChar
*)NULL
;
2448 // we can't check whether the day range is correct yet, will
2449 // do it later - assume ok for now
2451 mday
= (wxDateTime_t
)num
;
2454 case _T('H'): // hour in 24h format (00-23)
2455 if ( !GetNumericToken(input
, &num
) || (num
> 23) )
2458 return (wxChar
*)NULL
;
2462 hour
= (wxDateTime_t
)num
;
2465 case _T('I'): // hour in 12h format (01-12)
2466 if ( !GetNumericToken(input
, &num
) || !num
|| (num
> 12) )
2469 return (wxChar
*)NULL
;
2473 hourIsIn12hFormat
= TRUE
;
2474 hour
= num
% 12; // 12 should be 0
2477 case _T('j'): // day of the year
2478 if ( !GetNumericToken(input
, &num
) || !num
|| (num
> 366) )
2481 return (wxChar
*)NULL
;
2485 yday
= (wxDateTime_t
)num
;
2488 case _T('m'): // month as a number (01-12)
2489 if ( !GetNumericToken(input
, &num
) || !num
|| (num
> 12) )
2492 return (wxChar
*)NULL
;
2496 mon
= (Month
)(num
- 1);
2499 case _T('M'): // minute as a decimal number (00-59)
2500 if ( !GetNumericToken(input
, &num
) || (num
> 59) )
2503 return (wxChar
*)NULL
;
2507 min
= (wxDateTime_t
)num
;
2510 case _T('p'): // AM or PM string
2512 wxString am
, pm
, token
= GetAlphaToken(input
);
2514 GetAmPmStrings(&am
, &pm
);
2515 if ( token
.CmpNoCase(pm
) == 0 )
2519 else if ( token
.CmpNoCase(am
) != 0 )
2522 return (wxChar
*)NULL
;
2527 case _T('r'): // time as %I:%M:%S %p
2530 input
= dt
.ParseFormat(input
, _T("%I:%M:%S %p"));
2534 return (wxChar
*)NULL
;
2537 haveHour
= haveMin
= haveSec
= TRUE
;
2546 case _T('R'): // time as %H:%M
2549 input
= dt
.ParseFormat(input
, _T("%H:%M"));
2553 return (wxChar
*)NULL
;
2556 haveHour
= haveMin
= TRUE
;
2563 case _T('S'): // second as a decimal number (00-61)
2564 if ( !GetNumericToken(input
, &num
) || (num
> 61) )
2567 return (wxChar
*)NULL
;
2571 sec
= (wxDateTime_t
)num
;
2574 case _T('T'): // time as %H:%M:%S
2577 input
= dt
.ParseFormat(input
, _T("%H:%M:%S"));
2581 return (wxChar
*)NULL
;
2584 haveHour
= haveMin
= haveSec
= TRUE
;
2593 case _T('w'): // weekday as a number (0-6), Sunday = 0
2594 if ( !GetNumericToken(input
, &num
) || (wday
> 6) )
2597 return (wxChar
*)NULL
;
2601 wday
= (WeekDay
)num
;
2604 case _T('x'): // locale default date representation
2605 #ifdef HAVE_STRPTIME
2606 // try using strptime() - it may fail even if the input is
2607 // correct but the date is out of range, so we will fall back
2608 // to our generic code anyhow (FIXME !Unicode friendly)
2611 const wxChar
*result
= strptime(input
, "%x", &tm
);
2616 haveDay
= haveMon
= haveYear
= TRUE
;
2618 year
= 1900 + tm
.tm_year
;
2619 mon
= (Month
)tm
.tm_mon
;
2625 #endif // HAVE_STRPTIME
2627 // TODO query the LOCALE_IDATE setting under Win32
2631 wxString fmtDate
, fmtDateAlt
;
2632 if ( IsWestEuropeanCountry(GetCountry()) ||
2633 GetCountry() == Russia
)
2635 fmtDate
= _T("%d/%m/%y");
2636 fmtDateAlt
= _T("%m/%d/%y");
2640 fmtDate
= _T("%m/%d/%y");
2641 fmtDateAlt
= _T("%d/%m/%y");
2644 const wxChar
*result
= dt
.ParseFormat(input
, fmtDate
);
2648 // ok, be nice and try another one
2649 result
= dt
.ParseFormat(input
, fmtDateAlt
);
2655 return (wxChar
*)NULL
;
2660 haveDay
= haveMon
= haveYear
= TRUE
;
2671 case _T('X'): // locale default time representation
2672 #ifdef HAVE_STRPTIME
2674 // use strptime() to do it for us (FIXME !Unicode friendly)
2676 input
= strptime(input
, "%X", &tm
);
2679 return (wxChar
*)NULL
;
2682 haveHour
= haveMin
= haveSec
= TRUE
;
2688 #else // !HAVE_STRPTIME
2689 // TODO under Win32 we can query the LOCALE_ITIME system
2690 // setting which says whether the default time format is
2693 // try to parse what follows as "%H:%M:%S" and, if this
2694 // fails, as "%I:%M:%S %p" - this should catch the most
2698 const wxChar
*result
= dt
.ParseFormat(input
, _T("%T"));
2701 result
= dt
.ParseFormat(input
, _T("%r"));
2707 return (wxChar
*)NULL
;
2710 haveHour
= haveMin
= haveSec
= TRUE
;
2719 #endif // HAVE_STRPTIME/!HAVE_STRPTIME
2722 case _T('y'): // year without century (00-99)
2723 if ( !GetNumericToken(input
, &num
) || (num
> 99) )
2726 return (wxChar
*)NULL
;
2733 case _T('Y'): // year with century
2734 if ( !GetNumericToken(input
, &num
) )
2737 return (wxChar
*)NULL
;
2741 year
= (wxDateTime_t
)num
;
2744 case _T('Z'): // timezone name
2745 wxFAIL_MSG(_T("TODO"));
2748 case _T('%'): // a percent sign
2749 if ( *input
++ != _T('%') )
2752 return (wxChar
*)NULL
;
2756 case 0: // the end of string
2757 wxFAIL_MSG(_T("unexpected format end"));
2761 default: // not a known format spec
2762 return (wxChar
*)NULL
;
2766 // format matched, try to construct a date from what we have now
2768 if ( dateDef
.IsValid() )
2770 // take this date as default
2771 tmDef
= dateDef
.GetTm();
2773 else if ( m_time
!= 0 )
2775 // if this date is valid, don't change it
2780 // no default and this date is invalid - fall back to Today()
2781 tmDef
= Today().GetTm();
2792 // TODO we don't check here that the values are consistent, if both year
2793 // day and month/day were found, we just ignore the year day and we
2794 // also always ignore the week day
2795 if ( haveMon
&& haveDay
)
2797 if ( mday
> GetNumOfDaysInMonth(tm
.year
, mon
) )
2799 wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
2801 return (wxChar
*)NULL
;
2807 else if ( haveYDay
)
2809 if ( yday
> GetNumberOfDays(tm
.year
) )
2811 wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
2813 return (wxChar
*)NULL
;
2816 Tm tm2
= wxDateTime(1, Jan
, tm
.year
).SetToYearDay(yday
).GetTm();
2823 if ( haveHour
&& hourIsIn12hFormat
&& isPM
)
2825 // translate to 24hour format
2828 //else: either already in 24h format or no translation needed
2851 const wxChar
*wxDateTime::ParseDateTime(const wxChar
*date
)
2853 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2855 // there is a public domain version of getdate.y, but it only works for
2857 wxFAIL_MSG(_T("TODO"));
2859 return (wxChar
*)NULL
;
2862 const wxChar
*wxDateTime::ParseDate(const wxChar
*date
)
2864 // this is a simplified version of ParseDateTime() which understands only
2865 // "today" (for wxDate compatibility) and digits only otherwise (and not
2866 // all esoteric constructions ParseDateTime() knows about)
2868 wxCHECK_MSG( date
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
2870 const wxChar
*p
= date
;
2871 while ( wxIsspace(*p
) )
2874 wxString today
= _T("today");
2875 size_t len
= today
.length();
2876 if ( wxString(p
, len
).CmpNoCase(today
) == 0 )
2878 // nothing can follow this, so stop here
2887 bool haveDay
= FALSE
, // the months day?
2888 haveWDay
= FALSE
, // the day of week?
2889 haveMon
= FALSE
, // the month?
2890 haveYear
= FALSE
; // the year?
2892 // and the value of the items we have (init them to get rid of warnings)
2893 WeekDay wday
= Inv_WeekDay
;
2894 wxDateTime_t day
= 0;
2895 wxDateTime::Month mon
= Inv_Month
;
2898 // tokenize the string
2899 wxStringTokenizer
tok(p
, _T(",/-\t "));
2900 while ( tok
.HasMoreTokens() )
2902 wxString token
= tok
.GetNextToken();
2906 if ( token
.ToULong(&val
) )
2908 // guess what this number is
2912 // only years are counted from 0
2913 isYear
= (val
== 0) || (val
> 31);
2916 // may be the month or month day or the year, assume the
2917 // month day by default and fallback to month if the range
2918 // allow it or to the year if our assumption doesn't work
2921 // we already have the day, so may only be a month or year
2931 else // it may be day
2938 if ( val
> GetNumOfDaysInMonth(haveYear
? year
2942 // oops, it can't be a day finally
2958 // remember that we have this and stop the scan if it's the second
2959 // time we find this, except for the day logic (see there)
2969 // no roll over - 99 means 99, not 1999 for us
2981 mon
= (wxDateTime::Month
)val
;
2985 wxASSERT_MSG( isDay
, _T("logic error") );
2989 // may be were mistaken when we found it for the first
2990 // time? may be it was a month or year instead?
2992 // this ability to "backtrack" allows us to correctly parse
2993 // both things like 01/13 and 13/01 - but, of course, we
2994 // still can't resolve the ambiguity in 01/02 (it will be
2995 // Feb 1 for us, not Jan 2 as americans might expect!)
2996 if ( (day
<= 12) && !haveMon
)
2998 // exchange day and month
2999 mon
= (wxDateTime::Month
)day
;
3003 else if ( !haveYear
)
3005 // exchange day and year
3017 else // not a number
3019 mon
= GetMonthFromName(token
, Name_Full
| Name_Abbr
);
3020 if ( mon
!= Inv_Month
)
3032 wday
= GetWeekDayFromName(token
, Name_Full
| Name_Abbr
);
3033 if ( wday
!= Inv_WeekDay
)
3046 static const wxChar
*ordinals
[] =
3048 wxTRANSLATE("first"),
3049 wxTRANSLATE("second"),
3050 wxTRANSLATE("third"),
3051 wxTRANSLATE("fourth"),
3052 wxTRANSLATE("fifth"),
3053 wxTRANSLATE("sixth"),
3054 wxTRANSLATE("seventh"),
3055 wxTRANSLATE("eighth"),
3056 wxTRANSLATE("ninth"),
3057 wxTRANSLATE("tenth"),
3058 wxTRANSLATE("eleventh"),
3059 wxTRANSLATE("twelfth"),
3060 wxTRANSLATE("thirteenth"),
3061 wxTRANSLATE("fourteenth"),
3062 wxTRANSLATE("fifteenth"),
3063 wxTRANSLATE("sixteenth"),
3064 wxTRANSLATE("seventeenth"),
3065 wxTRANSLATE("eighteenth"),
3066 wxTRANSLATE("nineteenth"),
3067 wxTRANSLATE("twentieth"),
3068 // that's enough - otherwise we'd have problems with
3069 // composite (or not) ordinals otherwise
3073 for ( n
= 0; n
< WXSIZEOF(ordinals
); n
++ )
3075 if ( token
.CmpNoCase(ordinals
[n
]) == 0 )
3081 if ( n
== WXSIZEOF(ordinals
) )
3083 // stop here - something unknown
3090 // don't try anything here (as in case of numeric day
3091 // above) - the symbolic day spec should always
3092 // precede the month/year
3104 // either no more tokens or the scan was stopped by something we couldn't
3105 // parse - in any case, see if we can construct a date from what we have
3106 if ( !haveDay
&& !haveWDay
)
3108 wxLogDebug(_T("no day, no weekday hence no date."));
3110 return (wxChar
*)NULL
;
3113 if ( haveWDay
&& (haveMon
|| haveYear
|| haveDay
) &&
3114 !(haveMon
&& haveMon
&& haveYear
) )
3116 // without adjectives (which we don't support here) the week day only
3117 // makes sense completely separately or with the full date
3118 // specification (what would "Wed 1999" mean?)
3119 return (wxChar
*)NULL
;
3124 mon
= GetCurrentMonth();
3129 year
= GetCurrentYear();
3134 Set(day
, mon
, year
);
3138 // check that it is really the same
3139 if ( GetWeekDay() != wday
)
3141 // inconsistency detected
3142 return (wxChar
*)NULL
;
3150 SetToWeekDayInSameWeek(wday
);
3153 // return the pointer to the next char
3154 return p
+ wxStrlen(p
) - wxStrlen(tok
.GetString());
3157 const wxChar
*wxDateTime::ParseTime(const wxChar
*time
)
3159 wxCHECK_MSG( time
, (wxChar
*)NULL
, _T("NULL pointer in wxDateTime::Parse") );
3161 // first try some extra things
3168 { wxTRANSLATE("noon"), 12 },
3169 { wxTRANSLATE("midnight"), 00 },
3173 for ( size_t n
= 0; n
< WXSIZEOF(stdTimes
); n
++ )
3175 wxString timeString
= wxGetTranslation(stdTimes
[n
].name
);
3176 size_t len
= timeString
.length();
3177 if ( timeString
.CmpNoCase(wxString(time
, len
)) == 0 )
3179 Set(stdTimes
[n
].hour
, 0, 0);
3185 // try all time formats we may think about starting with the standard one
3186 const wxChar
*result
= ParseFormat(time
, _T("%X"));
3189 // normally, it's the same, but why not try it?
3190 result
= ParseFormat(time
, _T("%H:%M:%S"));
3195 // 12hour with AM/PM?
3196 result
= ParseFormat(time
, _T("%I:%M:%S %p"));
3202 result
= ParseFormat(time
, _T("%H:%M"));
3207 // 12hour with AM/PM but without seconds?
3208 result
= ParseFormat(time
, _T("%I:%M %p"));
3214 result
= ParseFormat(time
, _T("%H"));
3219 // just the hour and AM/PM?
3220 result
= ParseFormat(time
, _T("%I %p"));
3223 // TODO: parse timezones
3228 // ============================================================================
3230 // ============================================================================
3232 // not all strftime(3) format specifiers make sense here because, for example,
3233 // a time span doesn't have a year nor a timezone
3235 // Here are the ones which are supported (all of them are supported by strftime
3237 // %H hour in 24 hour format
3238 // %M minute (00 - 59)
3239 // %S second (00 - 59)
3242 // Also, for MFC CTimeSpan compatibility, we support
3243 // %D number of days
3245 // And, to be better than MFC :-), we also have
3246 // %E number of wEeks
3247 // %l milliseconds (000 - 999)
3248 wxString
wxTimeSpan::Format(const wxChar
*format
) const
3250 wxCHECK_MSG( format
, _T(""), _T("NULL format in wxTimeSpan::Format") );
3253 str
.Alloc(strlen(format
));
3255 for ( const wxChar
*pch
= format
; pch
; pch
++ )
3267 wxFAIL_MSG( _T("invalid format character") );
3271 // will get to str << ch below
3275 tmp
.Printf(_T("%d"), GetDays());
3279 tmp
.Printf(_T("%d"), GetWeeks());
3283 tmp
.Printf(_T("%02d"), GetHours());
3287 tmp
.Printf(_T("%03ld"), GetMilliseconds().ToLong());
3291 tmp
.Printf(_T("%02d"), GetMinutes());
3295 tmp
.Printf(_T("%02ld"), GetSeconds().ToLong());
3303 // skip str += ch below