]> git.saurik.com Git - wxWidgets.git/blame - src/common/datetime.cpp
really fixed the DST test by using explicit country in it
[wxWidgets.git] / src / common / datetime.cpp
CommitLineData
1ef54dcf 1///////////////////////////////////////////////////////////////////////////////
96531a71 2// Name: src/common/datetime.cpp
0979c962
VZ
3// Purpose: implementation of time/date related classes
4// Author: Vadim Zeitlin
5// Modified by:
6// Created: 11.05.99
7// RCS-ID: $Id$
1ef54dcf
VZ
8// Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9// parts of code taken from sndcal library by Scott E. Lee:
10//
11// Copyright 1993-1995, Scott E. Lee, all rights reserved.
12// Permission granted to use, copy, modify, distribute and sell
13// so long as the above copyright and this permission statement
14// are retained in all copies.
15//
65571936 16// Licence: wxWindows licence
1ef54dcf
VZ
17///////////////////////////////////////////////////////////////////////////////
18
19/*
20 * Implementation notes:
21 *
22 * 1. the time is stored as a 64bit integer containing the signed number of
299fcbfe
VZ
23 * milliseconds since Jan 1. 1970 (the Unix Epoch) - so it is always
24 * expressed in GMT.
1ef54dcf
VZ
25 *
26 * 2. the range is thus something about 580 million years, but due to current
27 * algorithms limitations, only dates from Nov 24, 4714BC are handled
28 *
29 * 3. standard ANSI C functions are used to do time calculations whenever
30 * possible, i.e. when the date is in the range Jan 1, 1970 to 2038
31 *
32 * 4. otherwise, the calculations are done by converting the date to/from JDN
33 * first (the range limitation mentioned above comes from here: the
34 * algorithm used by Scott E. Lee's code only works for positive JDNs, more
35 * or less)
36 *
299fcbfe
VZ
37 * 5. the object constructed for the given DD-MM-YYYY HH:MM:SS corresponds to
38 * this moment in local time and may be converted to the object
39 * corresponding to the same date/time in another time zone by using
40 * ToTimezone()
41 *
42 * 6. the conversions to the current (or any other) timezone are done when the
43 * internal time representation is converted to the broken-down one in
44 * wxDateTime::Tm.
1ef54dcf 45 */
0979c962
VZ
46
47// ============================================================================
48// declarations
49// ============================================================================
50
51// ----------------------------------------------------------------------------
52// headers
53// ----------------------------------------------------------------------------
54
0979c962
VZ
55// For compilers that support precompilation, includes "wx.h".
56#include "wx/wxprec.h"
57
58#ifdef __BORLANDC__
59 #pragma hdrstop
60#endif
61
1e6feb95
VZ
62#if !defined(wxUSE_DATETIME) || wxUSE_DATETIME
63
0979c962 64#ifndef WX_PRECOMP
57bd4c60
WS
65 #ifdef __WXMSW__
66 #include "wx/msw/wrapwin.h"
67 #endif
0979c962 68 #include "wx/string.h"
0979c962 69 #include "wx/log.h"
88a7a4e1 70 #include "wx/intl.h"
bb90a3e6 71 #include "wx/stopwatch.h" // for wxGetLocalTimeMillis()
02761f6c 72 #include "wx/module.h"
0bf751e7 73 #include "wx/crt.h"
0979c962
VZ
74#endif // WX_PRECOMP
75
fcc3d7cb 76#include "wx/thread.h"
cd0b1709 77#include "wx/tokenzr.h"
fcc3d7cb 78
ff0ea71c
GT
79#include <ctype.h>
80
64f9c100 81#ifdef __WINDOWS__
64f9c100 82 #include <winnls.h>
74b99d0f
WS
83 #ifndef __WXWINCE__
84 #include <locale.h>
85 #endif
64f9c100
VS
86#endif
87
0979c962
VZ
88#include "wx/datetime.h"
89
bd4a25bc
JS
90const long wxDateTime::TIME_T_FACTOR = 1000l;
91
cb73e600
SC
92#if wxUSE_EXTENDED_RTTI
93
94template<> void wxStringReadValue(const wxString &s , wxDateTime &data )
95{
96 data.ParseFormat(s,wxT("%Y-%m-%d %H:%M:%S")) ;
97}
98
99template<> void wxStringWriteValue(wxString &s , const wxDateTime &data )
100{
101 s = data.Format(wxT("%Y-%m-%d %H:%M:%S")) ;
102}
103
8805dbab 104wxCUSTOM_TYPE_INFO(wxDateTime, wxToStringConverter<wxDateTime> , wxFromStringConverter<wxDateTime>)
cb73e600
SC
105
106#endif
107
108//
f0f951fa
VZ
109// ----------------------------------------------------------------------------
110// conditional compilation
111// ----------------------------------------------------------------------------
6de20863 112
2423ef22
VZ
113#if defined(HAVE_STRPTIME) && defined(__GLIBC__) && \
114 ((__GLIBC__ == 2) && (__GLIBC_MINOR__ == 0))
f0f951fa
VZ
115 // glibc 2.0.7 strptime() is broken - the following snippet causes it to
116 // crash (instead of just failing):
117 //
118 // strncpy(buf, "Tue Dec 21 20:25:40 1999", 128);
119 // strptime(buf, "%x", &tm);
120 //
121 // so don't use it
122 #undef HAVE_STRPTIME
123#endif // broken strptime()
124
dcbd3762
DE
125#if defined(HAVE_STRPTIME) && defined(__DARWIN__) && defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
126 // configure detects strptime as linkable because it's in the OS X
127 // System library but MSL headers don't declare it.
7347d453
DE
128
129// char *strptime(const char *, const char *, struct tm *);
130 // However, we DON'T want to just provide it here because we would
131 // crash and/or overwrite data when strptime from OS X tries
132 // to fill in MW's struct tm which is two fields shorter (no TZ stuff)
133 // So for now let's just say we don't have strptime
134 #undef HAVE_STRPTIME
dcbd3762
DE
135#endif
136
31907d03
SC
137#if defined(__MWERKS__) && wxUSE_UNICODE
138 #include <wtime.h>
139#endif
140
e09080ec
VZ
141// define a special symbol for VC8 instead of writing tests for 1400 repeatedly
142#ifdef __VISUALC__
143 #if __VISUALC__ >= 1400
144 #define __VISUALC8__
145 #endif
146#endif
147
0779cc9a 148#if !defined(WX_TIMEZONE) && !defined(WX_GMTOFF_IN_TM)
6a27c749
WS
149 #if defined(__WXPALMOS__)
150 #define WX_GMTOFF_IN_TM
151 #elif defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)
f0f951fa 152 #define WX_TIMEZONE _timezone
8208e181 153 #elif defined(__MWERKS__)
f6bcfd97 154 long wxmw_timezone = 28800;
c4e1b7f2 155 #define WX_TIMEZONE wxmw_timezone
5283098e 156 #elif defined(__DJGPP__) || defined(__WINE__)
713a0efc 157 #include <sys/timeb.h>
c4e1b7f2 158 #include <values.h>
713a0efc
VS
159 static long wxGetTimeZone()
160 {
c4e1b7f2
VS
161 static long timezone = MAXLONG; // invalid timezone
162 if (timezone == MAXLONG)
163 {
164 struct timeb tb;
165 ftime(&tb);
166 timezone = tb.timezone;
167 }
168 return timezone;
713a0efc
VS
169 }
170 #define WX_TIMEZONE wxGetTimeZone()
0779cc9a
GD
171 #elif defined(__DARWIN__)
172 #define WX_GMTOFF_IN_TM
e09080ec 173 #elif defined(__WXWINCE__) && defined(__VISUALC8__)
44061d36 174 // _timezone is not present in dynamic run-time library
b667edae 175 #if 0
791b07a3
JS
176 // Solution (1): use the function equivalent of _timezone
177 static long wxGetTimeZone()
178 {
179 static long s_Timezone = MAXLONG; // invalid timezone
180 if (s_Timezone == MAXLONG)
181 {
182 int t;
183 _get_timezone(& t);
184 s_Timezone = (long) t;
185 }
186 return s_Timezone;
187 }
188 #define WX_TIMEZONE wxGetTimeZone()
b667edae 189 #elif 1
791b07a3 190 // Solution (2): using GetTimeZoneInformation
44061d36
JS
191 static long wxGetTimeZone()
192 {
193 static long timezone = MAXLONG; // invalid timezone
194 if (timezone == MAXLONG)
195 {
196 TIME_ZONE_INFORMATION tzi;
197 ::GetTimeZoneInformation(&tzi);
198 timezone = tzi.Bias;
199 }
200 return timezone;
201 }
202 #define WX_TIMEZONE wxGetTimeZone()
203 #else
791b07a3 204 // Old method using _timezone: this symbol doesn't exist in the dynamic run-time library (i.e. using /MD)
e09080ec 205 #define WX_TIMEZONE _timezone
44061d36 206 #endif
f0f951fa
VZ
207 #else // unknown platform - try timezone
208 #define WX_TIMEZONE timezone
209 #endif
0779cc9a 210#endif // !WX_TIMEZONE && !WX_GMTOFF_IN_TM
c25a510b 211
bb7afa49
VZ
212// everyone has strftime except Win CE unless VC8 is used
213#if !defined(__WXWINCE__) || defined(__VISUALC8__)
214 #define HAVE_STRFTIME
215#endif
216
e09080ec
VZ
217// NB: VC8 safe time functions could/should be used for wxMSW as well probably
218#if defined(__WXWINCE__) && defined(__VISUALC8__)
219
220struct tm *wxLocaltime_r(const time_t *t, struct tm* tm)
221{
222 __time64_t t64 = *t;
223 return _localtime64_s(tm, &t64) == 0 ? tm : NULL;
224}
225
226struct tm *wxGmtime_r(const time_t* t, struct tm* tm)
227{
228 __time64_t t64 = *t;
229 return _gmtime64_s(tm, &t64) == 0 ? tm : NULL;
230}
231
232#else // !wxWinCE with VC8
233
5b52a684 234#if (!defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)) && wxUSE_THREADS && !defined(__WINDOWS__)
cf44a61c
SN
235static wxMutex timeLock;
236#endif
237
238#ifndef HAVE_LOCALTIME_R
239struct tm *wxLocaltime_r(const time_t* ticks, struct tm* temp)
240{
241#if wxUSE_THREADS && !defined(__WINDOWS__)
242 // No need to waste time with a mutex on windows since it's using
243 // thread local storage for localtime anyway.
6f721331 244 wxMutexLocker locker(timeLock);
cf44a61c 245#endif
55809d13
VZ
246
247 // Borland CRT crashes when passed 0 ticks for some reason, see SF bug 1704438
248#ifdef __BORLANDC__
249 if ( !*ticks )
250 return NULL;
251#endif
252
253 const tm * const t = localtime(ticks);
254 if ( !t )
255 return NULL;
256
257 memcpy(temp, t, sizeof(struct tm));
cf44a61c
SN
258 return temp;
259}
e09080ec 260#endif // !HAVE_LOCALTIME_R
cf44a61c
SN
261
262#ifndef HAVE_GMTIME_R
263struct tm *wxGmtime_r(const time_t* ticks, struct tm* temp)
264{
265#if wxUSE_THREADS && !defined(__WINDOWS__)
266 // No need to waste time with a mutex on windows since it's
267 // using thread local storage for gmtime anyway.
6f721331 268 wxMutexLocker locker(timeLock);
cf44a61c 269#endif
55809d13
VZ
270
271#ifdef __BORLANDC__
272 if ( !*ticks )
273 return NULL;
274#endif
275
276 const tm * const t = gmtime(ticks);
277 if ( !t )
278 return NULL;
279
cf44a61c
SN
280 memcpy(temp, gmtime(ticks), sizeof(struct tm));
281 return temp;
282}
e09080ec
VZ
283#endif // !HAVE_GMTIME_R
284
285#endif // wxWinCE with VC8/other platforms
cf44a61c 286
384223b3
VZ
287// ----------------------------------------------------------------------------
288// macros
289// ----------------------------------------------------------------------------
290
291// debugging helper: just a convenient replacement of wxCHECK()
637b7e4f
VZ
292#define wxDATETIME_CHECK(expr, msg) \
293 wxCHECK2_MSG(expr, *this = wxInvalidDateTime; return *this, msg)
384223b3 294
4f6aed9c
VZ
295// ----------------------------------------------------------------------------
296// private classes
297// ----------------------------------------------------------------------------
298
299class wxDateTimeHolidaysModule : public wxModule
300{
301public:
302 virtual bool OnInit()
303 {
304 wxDateTimeHolidayAuthority::AddAuthority(new wxDateTimeWorkDays);
305
68379eaf 306 return true;
4f6aed9c
VZ
307 }
308
309 virtual void OnExit()
310 {
311 wxDateTimeHolidayAuthority::ClearAllAuthorities();
df5168c4 312 wxDateTimeHolidayAuthority::ms_authorities.clear();
4f6aed9c
VZ
313 }
314
315private:
316 DECLARE_DYNAMIC_CLASS(wxDateTimeHolidaysModule)
317};
318
319IMPLEMENT_DYNAMIC_CLASS(wxDateTimeHolidaysModule, wxModule)
320
b76b015e
VZ
321// ----------------------------------------------------------------------------
322// constants
323// ----------------------------------------------------------------------------
324
e6ec579c 325// some trivial ones
fcc3d7cb
VZ
326static const int MONTHS_IN_YEAR = 12;
327
df05cdc5
VZ
328static const int SEC_PER_MIN = 60;
329
330static const int MIN_PER_HOUR = 60;
331
332static const int HOURS_PER_DAY = 24;
fcc3d7cb 333
e6ec579c
VZ
334static const long SECONDS_PER_DAY = 86400l;
335
df05cdc5
VZ
336static const int DAYS_PER_WEEK = 7;
337
e6ec579c
VZ
338static const long MILLISECONDS_PER_DAY = 86400000l;
339
340// this is the integral part of JDN of the midnight of Jan 1, 1970
341// (i.e. JDN(Jan 1, 1970) = 2440587.5)
cd0b1709 342static const long EPOCH_JDN = 2440587l;
b76b015e 343
9ffaedfc
VZ
344// used only in asserts
345#ifdef __WXDEBUG__
1ef54dcf
VZ
346// the date of JDN -0.5 (as we don't work with fractional parts, this is the
347// reference date for us) is Nov 24, 4714BC
348static const int JDN_0_YEAR = -4713;
349static const int JDN_0_MONTH = wxDateTime::Nov;
350static const int JDN_0_DAY = 24;
9ffaedfc 351#endif // __WXDEBUG__
1ef54dcf
VZ
352
353// the constants used for JDN calculations
cd0b1709
VZ
354static const long JDN_OFFSET = 32046l;
355static const long DAYS_PER_5_MONTHS = 153l;
356static const long DAYS_PER_4_YEARS = 1461l;
357static const long DAYS_PER_400_YEARS = 146097l;
1ef54dcf 358
f0f951fa
VZ
359// this array contains the cumulated number of days in all previous months for
360// normal and leap years
361static const wxDateTime::wxDateTime_t gs_cumulatedDays[2][MONTHS_IN_YEAR] =
362{
363 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
364 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
365};
366
fcc3d7cb 367// ----------------------------------------------------------------------------
2ef31e80
VZ
368// global data
369// ----------------------------------------------------------------------------
370
1aaf88d2
WS
371const wxChar * wxDefaultDateTimeFormat = wxT("%c");
372const wxChar * wxDefaultTimeSpanFormat = wxT("%H:%M:%S");
373
384223b3
VZ
374// in the fine tradition of ANSI C we use our equivalent of (time_t)-1 to
375// indicate an invalid wxDateTime object
56d0c5a6 376const wxDateTime wxDefaultDateTime;
2ef31e80
VZ
377
378wxDateTime::Country wxDateTime::ms_country = wxDateTime::Country_Unknown;
379
b76b015e
VZ
380// ----------------------------------------------------------------------------
381// private functions
382// ----------------------------------------------------------------------------
383
4f6aed9c
VZ
384// debugger helper: shows what the date really is
385#ifdef __WXDEBUG__
386extern const wxChar *wxDumpDate(const wxDateTime* dt)
387{
0de868d9 388 static wxChar buf[128];
4f6aed9c
VZ
389
390 wxStrcpy(buf, dt->Format(_T("%Y-%m-%d (%a) %H:%M:%S")));
391
392 return buf;
393}
394#endif // Debug
395
fcc3d7cb
VZ
396// get the number of days in the given month of the given year
397static inline
398wxDateTime::wxDateTime_t GetNumOfDaysInMonth(int year, wxDateTime::Month month)
399{
e6ec579c
VZ
400 // the number of days in month in Julian/Gregorian calendar: the first line
401 // is for normal years, the second one is for the leap ones
402 static wxDateTime::wxDateTime_t daysInMonth[2][MONTHS_IN_YEAR] =
403 {
404 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
405 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
406 };
407
408 return daysInMonth[wxDateTime::IsLeapYear(year)][month];
fcc3d7cb
VZ
409}
410
c5432233
VZ
411// returns the time zone in the C sense, i.e. the difference UTC - local
412// (in seconds)
fcc3d7cb
VZ
413static int GetTimeZone()
414{
68379eaf
WS
415 // set to true when the timezone is set
416 static bool s_timezoneSet = false;
0779cc9a 417 static long gmtoffset = LONG_MAX; // invalid timezone
c5432233 418
a452689b 419 // ensure that the timezone variable is set by calling wxLocaltime_r
fcc3d7cb
VZ
420 if ( !s_timezoneSet )
421 {
a452689b
SN
422 // just call wxLocaltime_r() instead of figuring out whether this
423 // system supports tzset(), _tzset() or something else
c5432233 424 time_t t = 0;
3d561414 425 struct tm tm;
fcc3d7cb 426
3d561414 427 wxLocaltime_r(&t, &tm);
68379eaf 428 s_timezoneSet = true;
c5432233 429
44c930eb 430#ifdef WX_GMTOFF_IN_TM
c5432233
VZ
431 // note that GMT offset is the opposite of time zone and so to return
432 // consistent results in both WX_GMTOFF_IN_TM and !WX_GMTOFF_IN_TM
433 // cases we have to negate it
3d561414 434 gmtoffset = -tm.tm_gmtoff;
44c930eb
JG
435#else // !WX_GMTOFF_IN_TM
436 gmtoffset = WX_TIMEZONE;
437#endif // WX_GMTOFF_IN_TM/!WX_GMTOFF_IN_TM
fcc3d7cb
VZ
438 }
439
0779cc9a 440 return (int)gmtoffset;
fcc3d7cb
VZ
441}
442
e6ec579c 443// return the integral part of the JDN for the midnight of the given date (to
1ef54dcf
VZ
444// get the real JDN you need to add 0.5, this is, in fact, JDN of the
445// noon of the previous day)
e6ec579c
VZ
446static long GetTruncatedJDN(wxDateTime::wxDateTime_t day,
447 wxDateTime::Month mon,
448 int year)
449{
1ef54dcf
VZ
450 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
451
452 // check the date validity
453 wxASSERT_MSG(
454 (year > JDN_0_YEAR) ||
455 ((year == JDN_0_YEAR) && (mon > JDN_0_MONTH)) ||
456 ((year == JDN_0_YEAR) && (mon == JDN_0_MONTH) && (day >= JDN_0_DAY)),
457 _T("date out of range - can't convert to JDN")
458 );
459
460 // make the year positive to avoid problems with negative numbers division
461 year += 4800;
462
463 // months are counted from March here
464 int month;
465 if ( mon >= wxDateTime::Mar )
e6ec579c 466 {
1ef54dcf 467 month = mon - 2;
e6ec579c 468 }
1ef54dcf 469 else
e6ec579c 470 {
1ef54dcf
VZ
471 month = mon + 10;
472 year--;
473 }
e6ec579c 474
1ef54dcf
VZ
475 // now we can simply add all the contributions together
476 return ((year / 100) * DAYS_PER_400_YEARS) / 4
477 + ((year % 100) * DAYS_PER_4_YEARS) / 4
478 + (month * DAYS_PER_5_MONTHS + 2) / 5
479 + day
480 - JDN_OFFSET;
e6ec579c
VZ
481}
482
bb7afa49
VZ
483#ifdef HAVE_STRFTIME
484
2423ef22 485// this function is a wrapper around strftime(3) adding error checking
12e82477 486static wxString CallStrftime(const wxString& format, const tm* tm)
b76b015e 487{
68ee7c47 488 wxChar buf[4096];
594588aa
MW
489 // Create temp wxString here to work around mingw/cygwin bug 1046059
490 // http://sourceforge.net/tracker/?func=detail&atid=102435&aid=1046059&group_id=2435
491 wxString s;
492
ba9bbf13 493 if ( !wxStrftime(buf, WXSIZEOF(buf), format, tm) )
b76b015e 494 {
68ee7c47 495 // buffer is too small?
b76b015e
VZ
496 wxFAIL_MSG(_T("strftime() failed"));
497 }
498
594588aa
MW
499 s = buf;
500 return s;
b76b015e 501}
bb7afa49
VZ
502
503#endif // HAVE_STRFTIME
b76b015e 504
2423ef22
VZ
505#ifdef HAVE_STRPTIME
506
f536f005
VZ
507#if wxUSE_UNIX && !defined(HAVE_STRPTIME_DECL)
508 // configure detected that we had strptime() but not its declaration,
509 // provide it ourselves
e2620fda
VZ
510 extern "C" char *strptime(const char *, const char *, struct tm *);
511#endif
512
2423ef22
VZ
513// Unicode-friendly strptime() wrapper
514static const wxChar *
515CallStrptime(const wxChar *input, const char *fmt, tm *tm)
516{
517 // the problem here is that strptime() returns pointer into the string we
518 // passed to it while we're really interested in the pointer into the
519 // original, Unicode, string so we try to transform the pointer back
520#if wxUSE_UNICODE
521 wxCharBuffer inputMB(wxConvertWX2MB(input));
522#else // ASCII
523 const char * const inputMB = input;
524#endif // Unicode/Ascii
525
526 const char *result = strptime(inputMB, fmt, tm);
527 if ( !result )
528 return NULL;
529
530#if wxUSE_UNICODE
531 // FIXME: this is wrong in presence of surrogates &c
532 return input + (result - inputMB.data());
533#else // ASCII
534 return result;
535#endif // Unicode/Ascii
536}
537
538#endif // HAVE_STRPTIME
539
2f02cb89
VZ
540// if year and/or month have invalid values, replace them with the current ones
541static void ReplaceDefaultYearMonthWithCurrent(int *year,
542 wxDateTime::Month *month)
543{
544 struct tm *tmNow = NULL;
a452689b 545 struct tm tmstruct;
2f02cb89
VZ
546
547 if ( *year == wxDateTime::Inv_Year )
548 {
a452689b 549 tmNow = wxDateTime::GetTmNow(&tmstruct);
2f02cb89
VZ
550
551 *year = 1900 + tmNow->tm_year;
552 }
553
554 if ( *month == wxDateTime::Inv_Month )
555 {
556 if ( !tmNow )
a452689b 557 tmNow = wxDateTime::GetTmNow(&tmstruct);
2f02cb89
VZ
558
559 *month = (wxDateTime::Month)tmNow->tm_mon;
560 }
561}
562
f0f951fa
VZ
563// fll the struct tm with default values
564static void InitTm(struct tm& tm)
565{
566 // struct tm may have etxra fields (undocumented and with unportable
567 // names) which, nevertheless, must be set to 0
568 memset(&tm, 0, sizeof(struct tm));
569
570 tm.tm_mday = 1; // mday 0 is invalid
571 tm.tm_year = 76; // any valid year
572 tm.tm_isdst = -1; // auto determine
573}
574
cd0b1709
VZ
575// parsing helpers
576// ---------------
577
578// return the month if the string is a month name or Inv_Month otherwise
f0f951fa 579static wxDateTime::Month GetMonthFromName(const wxString& name, int flags)
cd0b1709
VZ
580{
581 wxDateTime::Month mon;
582 for ( mon = wxDateTime::Jan; mon < wxDateTime::Inv_Month; wxNextMonth(mon) )
583 {
f0f951fa
VZ
584 // case-insensitive comparison either one of or with both abbreviated
585 // and not versions
586 if ( flags & wxDateTime::Name_Full )
cd0b1709 587 {
f0f951fa
VZ
588 if ( name.CmpNoCase(wxDateTime::
589 GetMonthName(mon, wxDateTime::Name_Full)) == 0 )
590 {
591 break;
592 }
593 }
594
595 if ( flags & wxDateTime::Name_Abbr )
596 {
597 if ( name.CmpNoCase(wxDateTime::
598 GetMonthName(mon, wxDateTime::Name_Abbr)) == 0 )
599 {
600 break;
601 }
cd0b1709
VZ
602 }
603 }
604
605 return mon;
606}
607
608// return the weekday if the string is a weekday name or Inv_WeekDay otherwise
f0f951fa 609static wxDateTime::WeekDay GetWeekDayFromName(const wxString& name, int flags)
cd0b1709
VZ
610{
611 wxDateTime::WeekDay wd;
612 for ( wd = wxDateTime::Sun; wd < wxDateTime::Inv_WeekDay; wxNextWDay(wd) )
613 {
f0f951fa
VZ
614 // case-insensitive comparison either one of or with both abbreviated
615 // and not versions
616 if ( flags & wxDateTime::Name_Full )
cd0b1709 617 {
f0f951fa
VZ
618 if ( name.CmpNoCase(wxDateTime::
619 GetWeekDayName(wd, wxDateTime::Name_Full)) == 0 )
620 {
621 break;
622 }
623 }
624
625 if ( flags & wxDateTime::Name_Abbr )
626 {
627 if ( name.CmpNoCase(wxDateTime::
628 GetWeekDayName(wd, wxDateTime::Name_Abbr)) == 0 )
629 {
630 break;
631 }
cd0b1709
VZ
632 }
633 }
634
635 return wd;
636}
637
a452689b
SN
638/* static */
639struct tm *wxDateTime::GetTmNow(struct tm *tmstruct)
640{
641 time_t t = GetTimeNow();
642 return wxLocaltime_r(&t, tmstruct);
643}
644
f6bcfd97
BP
645// scans all digits (but no more than len) and returns the resulting number
646static bool GetNumericToken(size_t len, const wxChar*& p, unsigned long *number)
f0f951fa 647{
f6bcfd97 648 size_t n = 1;
f0f951fa
VZ
649 wxString s;
650 while ( wxIsdigit(*p) )
651 {
652 s += *p++;
f6bcfd97
BP
653
654 if ( len && ++n > len )
655 break;
f0f951fa
VZ
656 }
657
bb8a8478 658 return !s.empty() && s.ToULong(number);
f0f951fa
VZ
659}
660
661// scans all alphabetic characters and returns the resulting string
662static wxString GetAlphaToken(const wxChar*& p)
663{
664 wxString s;
665 while ( wxIsalpha(*p) )
666 {
667 s += *p++;
668 }
669
670 return s;
671}
672
0979c962
VZ
673// ============================================================================
674// implementation of wxDateTime
675// ============================================================================
676
b76b015e
VZ
677// ----------------------------------------------------------------------------
678// struct Tm
679// ----------------------------------------------------------------------------
680
681wxDateTime::Tm::Tm()
682{
683 year = (wxDateTime_t)wxDateTime::Inv_Year;
684 mon = wxDateTime::Inv_Month;
685 mday = 0;
e6ec579c 686 hour = min = sec = msec = 0;
b76b015e
VZ
687 wday = wxDateTime::Inv_WeekDay;
688}
689
299fcbfe
VZ
690wxDateTime::Tm::Tm(const struct tm& tm, const TimeZone& tz)
691 : m_tz(tz)
b76b015e 692{
e6ec579c 693 msec = 0;
907173e5
WS
694 sec = (wxDateTime::wxDateTime_t)tm.tm_sec;
695 min = (wxDateTime::wxDateTime_t)tm.tm_min;
696 hour = (wxDateTime::wxDateTime_t)tm.tm_hour;
697 mday = (wxDateTime::wxDateTime_t)tm.tm_mday;
fcc3d7cb 698 mon = (wxDateTime::Month)tm.tm_mon;
b76b015e 699 year = 1900 + tm.tm_year;
bb8a8478
WS
700 wday = (wxDateTime::wxDateTime_t)tm.tm_wday;
701 yday = (wxDateTime::wxDateTime_t)tm.tm_yday;
b76b015e
VZ
702}
703
704bool wxDateTime::Tm::IsValid() const
705{
706 // we allow for the leap seconds, although we don't use them (yet)
fcc3d7cb 707 return (year != wxDateTime::Inv_Year) && (mon != wxDateTime::Inv_Month) &&
c5a1681b 708 (mday <= GetNumOfDaysInMonth(year, mon)) &&
e6ec579c 709 (hour < 24) && (min < 60) && (sec < 62) && (msec < 1000);
b76b015e
VZ
710}
711
712void wxDateTime::Tm::ComputeWeekDay()
713{
c5a1681b
VZ
714 // compute the week day from day/month/year: we use the dumbest algorithm
715 // possible: just compute our JDN and then use the (simple to derive)
716 // formula: weekday = (JDN + 1.5) % 7
5a572f6c 717 wday = (wxDateTime::wxDateTime_t)((GetTruncatedJDN(mday, mon, year) + 2) % 7);
b76b015e
VZ
718}
719
e6ec579c 720void wxDateTime::Tm::AddMonths(int monDiff)
fcc3d7cb
VZ
721{
722 // normalize the months field
723 while ( monDiff < -mon )
724 {
725 year--;
726
727 monDiff += MONTHS_IN_YEAR;
728 }
729
2ef31e80 730 while ( monDiff + mon >= MONTHS_IN_YEAR )
fcc3d7cb
VZ
731 {
732 year++;
239446b4
VZ
733
734 monDiff -= MONTHS_IN_YEAR;
fcc3d7cb
VZ
735 }
736
737 mon = (wxDateTime::Month)(mon + monDiff);
738
e6ec579c 739 wxASSERT_MSG( mon >= 0 && mon < MONTHS_IN_YEAR, _T("logic error") );
4f6aed9c
VZ
740
741 // NB: we don't check here that the resulting date is valid, this function
742 // is private and the caller must check it if needed
fcc3d7cb
VZ
743}
744
e6ec579c 745void wxDateTime::Tm::AddDays(int dayDiff)
fcc3d7cb
VZ
746{
747 // normalize the days field
9d9b7755 748 while ( dayDiff + mday < 1 )
fcc3d7cb
VZ
749 {
750 AddMonths(-1);
751
9d9b7755 752 dayDiff += GetNumOfDaysInMonth(year, mon);
fcc3d7cb
VZ
753 }
754
907173e5 755 mday = (wxDateTime::wxDateTime_t)( mday + dayDiff );
fcc3d7cb
VZ
756 while ( mday > GetNumOfDaysInMonth(year, mon) )
757 {
758 mday -= GetNumOfDaysInMonth(year, mon);
759
760 AddMonths(1);
761 }
762
763 wxASSERT_MSG( mday > 0 && mday <= GetNumOfDaysInMonth(year, mon),
764 _T("logic error") );
765}
766
767// ----------------------------------------------------------------------------
768// class TimeZone
769// ----------------------------------------------------------------------------
770
771wxDateTime::TimeZone::TimeZone(wxDateTime::TZ tz)
772{
773 switch ( tz )
774 {
775 case wxDateTime::Local:
299fcbfe
VZ
776 // get the offset from C RTL: it returns the difference GMT-local
777 // while we want to have the offset _from_ GMT, hence the '-'
778 m_offset = -GetTimeZone();
fcc3d7cb
VZ
779 break;
780
781 case wxDateTime::GMT_12:
782 case wxDateTime::GMT_11:
783 case wxDateTime::GMT_10:
784 case wxDateTime::GMT_9:
785 case wxDateTime::GMT_8:
786 case wxDateTime::GMT_7:
787 case wxDateTime::GMT_6:
788 case wxDateTime::GMT_5:
789 case wxDateTime::GMT_4:
790 case wxDateTime::GMT_3:
791 case wxDateTime::GMT_2:
792 case wxDateTime::GMT_1:
299fcbfe 793 m_offset = -3600*(wxDateTime::GMT0 - tz);
fcc3d7cb
VZ
794 break;
795
796 case wxDateTime::GMT0:
797 case wxDateTime::GMT1:
798 case wxDateTime::GMT2:
799 case wxDateTime::GMT3:
800 case wxDateTime::GMT4:
801 case wxDateTime::GMT5:
802 case wxDateTime::GMT6:
803 case wxDateTime::GMT7:
804 case wxDateTime::GMT8:
805 case wxDateTime::GMT9:
806 case wxDateTime::GMT10:
807 case wxDateTime::GMT11:
808 case wxDateTime::GMT12:
34f90a1c 809 case wxDateTime::GMT13:
299fcbfe 810 m_offset = 3600*(tz - wxDateTime::GMT0);
fcc3d7cb
VZ
811 break;
812
813 case wxDateTime::A_CST:
814 // Central Standard Time in use in Australia = UTC + 9.5
d26adb9d 815 m_offset = 60l*(9*MIN_PER_HOUR + MIN_PER_HOUR/2);
fcc3d7cb
VZ
816 break;
817
818 default:
819 wxFAIL_MSG( _T("unknown time zone") );
820 }
821}
822
b76b015e
VZ
823// ----------------------------------------------------------------------------
824// static functions
825// ----------------------------------------------------------------------------
826
827/* static */
828bool wxDateTime::IsLeapYear(int year, wxDateTime::Calendar cal)
829{
2f02cb89
VZ
830 if ( year == Inv_Year )
831 year = GetCurrentYear();
832
b76b015e
VZ
833 if ( cal == Gregorian )
834 {
835 // in Gregorian calendar leap years are those divisible by 4 except
836 // those divisible by 100 unless they're also divisible by 400
837 // (in some countries, like Russia and Greece, additional corrections
838 // exist, but they won't manifest themselves until 2700)
839 return (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0));
840 }
841 else if ( cal == Julian )
842 {
843 // in Julian calendar the rule is simpler
844 return year % 4 == 0;
845 }
846 else
847 {
848 wxFAIL_MSG(_T("unknown calendar"));
849
68379eaf 850 return false;
b76b015e
VZ
851 }
852}
853
fcc3d7cb
VZ
854/* static */
855int wxDateTime::GetCentury(int year)
856{
857 return year > 0 ? year / 100 : year / 100 - 1;
858}
859
b76b015e
VZ
860/* static */
861int wxDateTime::ConvertYearToBC(int year)
862{
863 // year 0 is BC 1
864 return year > 0 ? year : year - 1;
865}
866
867/* static */
868int wxDateTime::GetCurrentYear(wxDateTime::Calendar cal)
869{
870 switch ( cal )
871 {
872 case Gregorian:
873 return Now().GetYear();
874
875 case Julian:
876 wxFAIL_MSG(_T("TODO"));
877 break;
878
879 default:
880 wxFAIL_MSG(_T("unsupported calendar"));
881 break;
882 }
883
884 return Inv_Year;
885}
886
887/* static */
888wxDateTime::Month wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal)
889{
890 switch ( cal )
891 {
892 case Gregorian:
893 return Now().GetMonth();
b76b015e
VZ
894
895 case Julian:
896 wxFAIL_MSG(_T("TODO"));
897 break;
898
899 default:
900 wxFAIL_MSG(_T("unsupported calendar"));
901 break;
902 }
903
904 return Inv_Month;
905}
906
2f02cb89
VZ
907/* static */
908wxDateTime::wxDateTime_t wxDateTime::GetNumberOfDays(int year, Calendar cal)
909{
910 if ( year == Inv_Year )
911 {
912 // take the current year if none given
913 year = GetCurrentYear();
914 }
915
916 switch ( cal )
917 {
918 case Gregorian:
919 case Julian:
920 return IsLeapYear(year) ? 366 : 365;
2f02cb89
VZ
921
922 default:
923 wxFAIL_MSG(_T("unsupported calendar"));
924 break;
925 }
926
927 return 0;
928}
929
b76b015e
VZ
930/* static */
931wxDateTime::wxDateTime_t wxDateTime::GetNumberOfDays(wxDateTime::Month month,
932 int year,
933 wxDateTime::Calendar cal)
934{
fcc3d7cb 935 wxCHECK_MSG( month < MONTHS_IN_YEAR, 0, _T("invalid month") );
b76b015e
VZ
936
937 if ( cal == Gregorian || cal == Julian )
938 {
939 if ( year == Inv_Year )
940 {
941 // take the current year if none given
942 year = GetCurrentYear();
943 }
944
fcc3d7cb 945 return GetNumOfDaysInMonth(year, month);
b76b015e
VZ
946 }
947 else
948 {
949 wxFAIL_MSG(_T("unsupported calendar"));
950
951 return 0;
952 }
953}
954
955/* static */
f0f951fa
VZ
956wxString wxDateTime::GetMonthName(wxDateTime::Month month,
957 wxDateTime::NameFlags flags)
b76b015e 958{
525d8583 959 wxCHECK_MSG( month != Inv_Month, wxEmptyString, _T("invalid month") );
bb7afa49 960#ifdef HAVE_STRFTIME
68ee7c47
VZ
961 // notice that we must set all the fields to avoid confusing libc (GNU one
962 // gets confused to a crash if we don't do this)
cd0b1709 963 tm tm;
f0f951fa 964 InitTm(tm);
cd0b1709 965 tm.tm_mon = month;
b76b015e 966
f0f951fa 967 return CallStrftime(flags == Name_Abbr ? _T("%b") : _T("%B"), &tm);
bb7afa49 968#else // !HAVE_STRFTIME
ba9bbf13
WS
969 wxString ret;
970 switch(month)
971 {
972 case Jan:
973 ret = (flags == Name_Abbr ? wxT("Jan"): wxT("January"));
974 break;
975 case Feb:
976 ret = (flags == Name_Abbr ? wxT("Feb"): wxT("Febuary"));
977 break;
978 case Mar:
979 ret = (flags == Name_Abbr ? wxT("Mar"): wxT("March"));
980 break;
981 case Apr:
982 ret = (flags == Name_Abbr ? wxT("Apr"): wxT("April"));
983 break;
984 case May:
985 ret = (flags == Name_Abbr ? wxT("May"): wxT("May"));
986 break;
987 case Jun:
988 ret = (flags == Name_Abbr ? wxT("Jun"): wxT("June"));
989 break;
990 case Jul:
991 ret = (flags == Name_Abbr ? wxT("Jul"): wxT("July"));
992 break;
993 case Aug:
994 ret = (flags == Name_Abbr ? wxT("Aug"): wxT("August"));
995 break;
996 case Sep:
997 ret = (flags == Name_Abbr ? wxT("Sep"): wxT("September"));
998 break;
999 case Oct:
1000 ret = (flags == Name_Abbr ? wxT("Oct"): wxT("October"));
1001 break;
1002 case Nov:
1003 ret = (flags == Name_Abbr ? wxT("Nov"): wxT("November"));
1004 break;
1005 case Dec:
1006 ret = (flags == Name_Abbr ? wxT("Dec"): wxT("December"));
1007 break;
1008 }
1009 return ret;
bb7afa49 1010#endif // HAVE_STRFTIME/!HAVE_STRFTIME
b76b015e
VZ
1011}
1012
1013/* static */
f0f951fa
VZ
1014wxString wxDateTime::GetWeekDayName(wxDateTime::WeekDay wday,
1015 wxDateTime::NameFlags flags)
b76b015e 1016{
525d8583 1017 wxCHECK_MSG( wday != Inv_WeekDay, wxEmptyString, _T("invalid weekday") );
bb7afa49 1018#ifdef HAVE_STRFTIME
2c622d71
VZ
1019 // take some arbitrary Sunday (but notice that the day should be such that
1020 // after adding wday to it below we still have a valid date, e.g. don't
1021 // take 28 here!)
f0f951fa
VZ
1022 tm tm;
1023 InitTm(tm);
2c622d71 1024 tm.tm_mday = 21;
f0f951fa
VZ
1025 tm.tm_mon = Nov;
1026 tm.tm_year = 99;
b76b015e 1027
1ef54dcf 1028 // and offset it by the number of days needed to get the correct wday
b76b015e
VZ
1029 tm.tm_mday += wday;
1030
c5a1681b
VZ
1031 // call mktime() to normalize it...
1032 (void)mktime(&tm);
1033
1034 // ... and call strftime()
f0f951fa 1035 return CallStrftime(flags == Name_Abbr ? _T("%a") : _T("%A"), &tm);
bb7afa49 1036#else // !HAVE_STRFTIME
ba9bbf13
WS
1037 wxString ret;
1038 switch(wday)
1039 {
1040 case Sun:
1041 ret = (flags == Name_Abbr ? wxT("Sun") : wxT("Sunday"));
1042 break;
1043 case Mon:
1044 ret = (flags == Name_Abbr ? wxT("Mon") : wxT("Monday"));
1045 break;
1046 case Tue:
1047 ret = (flags == Name_Abbr ? wxT("Tue") : wxT("Tuesday"));
1048 break;
1049 case Wed:
1050 ret = (flags == Name_Abbr ? wxT("Wed") : wxT("Wednesday"));
1051 break;
1052 case Thu:
1053 ret = (flags == Name_Abbr ? wxT("Thu") : wxT("Thursday"));
1054 break;
1055 case Fri:
1056 ret = (flags == Name_Abbr ? wxT("Fri") : wxT("Friday"));
1057 break;
1058 case Sat:
1059 ret = (flags == Name_Abbr ? wxT("Sat") : wxT("Saturday"));
1060 break;
1061 }
1062 return ret;
bb7afa49 1063#endif // HAVE_STRFTIME/!HAVE_STRFTIME
f0f951fa
VZ
1064}
1065
1066/* static */
1067void wxDateTime::GetAmPmStrings(wxString *am, wxString *pm)
1068{
1069 tm tm;
1070 InitTm(tm);
653567bb 1071 wxChar buffer[64];
0308fd61
JS
1072 // @Note: Do not call 'CallStrftime' here! CallStrftime checks the return code
1073 // and causes an assertion failed if the buffer is to small (which is good) - OR -
1074 // if strftime does not return anything because the format string is invalid - OR -
1075 // if there are no 'am' / 'pm' tokens defined for the current locale (which is not good).
1076 // wxDateTime::ParseTime will try several different formats to parse the time.
1077 // As a result, GetAmPmStrings might get called, even if the current locale
1078 // does not define any 'am' / 'pm' tokens. In this case, wxStrftime would
1079 // assert, even though it is a perfectly legal use.
f0f951fa
VZ
1080 if ( am )
1081 {
10a2749b 1082 if (wxStrftime(buffer, sizeof(buffer)/sizeof(wxChar), _T("%p"), &tm) > 0)
0308fd61
JS
1083 *am = wxString(buffer);
1084 else
1085 *am = wxString();
f0f951fa
VZ
1086 }
1087 if ( pm )
1088 {
1089 tm.tm_hour = 13;
10a2749b 1090 if (wxStrftime(buffer, sizeof(buffer)/sizeof(wxChar), _T("%p"), &tm) > 0)
0308fd61
JS
1091 *pm = wxString(buffer);
1092 else
1093 *pm = wxString();
f0f951fa 1094 }
b76b015e
VZ
1095}
1096
239446b4
VZ
1097// ----------------------------------------------------------------------------
1098// Country stuff: date calculations depend on the country (DST, work days,
1099// ...), so we need to know which rules to follow.
1100// ----------------------------------------------------------------------------
1101
1102/* static */
1103wxDateTime::Country wxDateTime::GetCountry()
1104{
f0f951fa 1105 // TODO use LOCALE_ICOUNTRY setting under Win32
77b88df2 1106#ifndef __WXWINCE__
239446b4
VZ
1107 if ( ms_country == Country_Unknown )
1108 {
1109 // try to guess from the time zone name
1110 time_t t = time(NULL);
a452689b
SN
1111 struct tm tmstruct;
1112 struct tm *tm = wxLocaltime_r(&t, &tmstruct);
239446b4
VZ
1113
1114 wxString tz = CallStrftime(_T("%Z"), tm);
1115 if ( tz == _T("WET") || tz == _T("WEST") )
1116 {
1117 ms_country = UK;
1118 }
1119 else if ( tz == _T("CET") || tz == _T("CEST") )
1120 {
1121 ms_country = Country_EEC;
1122 }
1123 else if ( tz == _T("MSK") || tz == _T("MSD") )
1124 {
1125 ms_country = Russia;
1126 }
1127 else if ( tz == _T("AST") || tz == _T("ADT") ||
1128 tz == _T("EST") || tz == _T("EDT") ||
1129 tz == _T("CST") || tz == _T("CDT") ||
1130 tz == _T("MST") || tz == _T("MDT") ||
1131 tz == _T("PST") || tz == _T("PDT") )
1132 {
1133 ms_country = USA;
1134 }
1135 else
1136 {
1137 // well, choose a default one
1138 ms_country = USA;
1139 }
1140 }
bb7afa49 1141#else // __WXWINCE__
77b88df2 1142 ms_country = USA;
bb7afa49 1143#endif // !__WXWINCE__/__WXWINCE__
239446b4
VZ
1144
1145 return ms_country;
1146}
1147
1148/* static */
1149void wxDateTime::SetCountry(wxDateTime::Country country)
1150{
1151 ms_country = country;
1152}
1153
1154/* static */
1155bool wxDateTime::IsWestEuropeanCountry(Country country)
1156{
1157 if ( country == Country_Default )
1158 {
1159 country = GetCountry();
1160 }
1161
1162 return (Country_WesternEurope_Start <= country) &&
1163 (country <= Country_WesternEurope_End);
1164}
1165
1166// ----------------------------------------------------------------------------
1167// DST calculations: we use 3 different rules for the West European countries,
1168// USA and for the rest of the world. This is undoubtedly false for many
1169// countries, but I lack the necessary info (and the time to gather it),
1170// please add the other rules here!
1171// ----------------------------------------------------------------------------
1172
1173/* static */
1174bool wxDateTime::IsDSTApplicable(int year, Country country)
1175{
1176 if ( year == Inv_Year )
1177 {
1178 // take the current year if none given
1179 year = GetCurrentYear();
1180 }
1181
1182 if ( country == Country_Default )
1183 {
1184 country = GetCountry();
1185 }
1186
1187 switch ( country )
1188 {
1189 case USA:
1190 case UK:
1191 // DST was first observed in the US and UK during WWI, reused
1192 // during WWII and used again since 1966
1193 return year >= 1966 ||
1194 (year >= 1942 && year <= 1945) ||
1195 (year == 1918 || year == 1919);
1196
1197 default:
1198 // assume that it started after WWII
1199 return year > 1950;
1200 }
1201}
1202
1203/* static */
1204wxDateTime wxDateTime::GetBeginDST(int year, Country country)
1205{
1206 if ( year == Inv_Year )
1207 {
1208 // take the current year if none given
1209 year = GetCurrentYear();
1210 }
1211
1212 if ( country == Country_Default )
1213 {
1214 country = GetCountry();
1215 }
1216
1217 if ( !IsDSTApplicable(year, country) )
1218 {
2ef31e80 1219 return wxInvalidDateTime;
239446b4
VZ
1220 }
1221
1222 wxDateTime dt;
1223
1224 if ( IsWestEuropeanCountry(country) || (country == Russia) )
1225 {
1226 // DST begins at 1 a.m. GMT on the last Sunday of March
1227 if ( !dt.SetToLastWeekDay(Sun, Mar, year) )
1228 {
1229 // weird...
1230 wxFAIL_MSG( _T("no last Sunday in March?") );
1231 }
1232
1233 dt += wxTimeSpan::Hours(1);
239446b4
VZ
1234 }
1235 else switch ( country )
1236 {
1237 case USA:
1238 switch ( year )
1239 {
1240 case 1918:
1241 case 1919:
1242 // don't know for sure - assume it was in effect all year
1243
1244 case 1943:
1245 case 1944:
1246 case 1945:
1247 dt.Set(1, Jan, year);
1248 break;
1249
1250 case 1942:
1251 // DST was installed Feb 2, 1942 by the Congress
1252 dt.Set(2, Feb, year);
1253 break;
1254
1255 // Oil embargo changed the DST period in the US
1256 case 1974:
1257 dt.Set(6, Jan, 1974);
1258 break;
1259
1260 case 1975:
1261 dt.Set(23, Feb, 1975);
1262 break;
1263
1264 default:
1265 // before 1986, DST begun on the last Sunday of April, but
1266 // in 1986 Reagan changed it to begin at 2 a.m. of the
1267 // first Sunday in April
1268 if ( year < 1986 )
1269 {
1270 if ( !dt.SetToLastWeekDay(Sun, Apr, year) )
1271 {
1272 // weird...
1273 wxFAIL_MSG( _T("no first Sunday in April?") );
1274 }
1275 }
1276 else
1277 {
1278 if ( !dt.SetToWeekDay(Sun, 1, Apr, year) )
1279 {
1280 // weird...
1281 wxFAIL_MSG( _T("no first Sunday in April?") );
1282 }
1283 }
1284
1285 dt += wxTimeSpan::Hours(2);
1286
1287 // TODO what about timezone??
1288 }
1289
1290 break;
1291
1292 default:
1293 // assume Mar 30 as the start of the DST for the rest of the world
1294 // - totally bogus, of course
1295 dt.Set(30, Mar, year);
1296 }
1297
1298 return dt;
1299}
1300
1301/* static */
1302wxDateTime wxDateTime::GetEndDST(int year, Country country)
1303{
1304 if ( year == Inv_Year )
1305 {
1306 // take the current year if none given
1307 year = GetCurrentYear();
1308 }
1309
1310 if ( country == Country_Default )
1311 {
1312 country = GetCountry();
1313 }
1314
1315 if ( !IsDSTApplicable(year, country) )
1316 {
2ef31e80 1317 return wxInvalidDateTime;
239446b4
VZ
1318 }
1319
1320 wxDateTime dt;
1321
1322 if ( IsWestEuropeanCountry(country) || (country == Russia) )
1323 {
5f287370 1324 // DST ends at 1 a.m. GMT on the last Sunday of October
239446b4
VZ
1325 if ( !dt.SetToLastWeekDay(Sun, Oct, year) )
1326 {
1327 // weirder and weirder...
1328 wxFAIL_MSG( _T("no last Sunday in October?") );
1329 }
1330
1331 dt += wxTimeSpan::Hours(1);
239446b4
VZ
1332 }
1333 else switch ( country )
1334 {
1335 case USA:
1336 switch ( year )
1337 {
1338 case 1918:
1339 case 1919:
1340 // don't know for sure - assume it was in effect all year
1341
1342 case 1943:
1343 case 1944:
1344 dt.Set(31, Dec, year);
1345 break;
1346
1347 case 1945:
1348 // the time was reset after the end of the WWII
1349 dt.Set(30, Sep, year);
1350 break;
1351
1352 default:
5f287370 1353 // DST ends at 2 a.m. on the last Sunday of October
239446b4
VZ
1354 if ( !dt.SetToLastWeekDay(Sun, Oct, year) )
1355 {
1356 // weirder and weirder...
1357 wxFAIL_MSG( _T("no last Sunday in October?") );
1358 }
1359
1360 dt += wxTimeSpan::Hours(2);
1361
1362 // TODO what about timezone??
1363 }
1364 break;
1365
1366 default:
1367 // assume October 26th as the end of the DST - totally bogus too
1368 dt.Set(26, Oct, year);
1369 }
1370
1371 return dt;
1372}
1373
0979c962
VZ
1374// ----------------------------------------------------------------------------
1375// constructors and assignment operators
1376// ----------------------------------------------------------------------------
1377
f6bcfd97
BP
1378// return the current time with ms precision
1379/* static */ wxDateTime wxDateTime::UNow()
1380{
1381 return wxDateTime(wxGetLocalTimeMillis());
1382}
1383
299fcbfe
VZ
1384// the values in the tm structure contain the local time
1385wxDateTime& wxDateTime::Set(const struct tm& tm)
0979c962 1386{
299fcbfe 1387 struct tm tm2(tm);
b76b015e 1388 time_t timet = mktime(&tm2);
1ef54dcf 1389
4afd7529 1390 if ( timet == (time_t)-1 )
0979c962 1391 {
4afd7529
VZ
1392 // mktime() rather unintuitively fails for Jan 1, 1970 if the hour is
1393 // less than timezone - try to make it work for this case
1394 if ( tm2.tm_year == 70 && tm2.tm_mon == 0 && tm2.tm_mday == 1 )
1395 {
3d78a532
RD
1396 return Set((time_t)(
1397 GetTimeZone() +
1398 tm2.tm_hour * MIN_PER_HOUR * SEC_PER_MIN +
1399 tm2.tm_min * SEC_PER_MIN +
1400 tm2.tm_sec));
4afd7529
VZ
1401 }
1402
1403 wxFAIL_MSG( _T("mktime() failed") );
0979c962 1404
384223b3
VZ
1405 *this = wxInvalidDateTime;
1406
1407 return *this;
0979c962
VZ
1408 }
1409 else
1410 {
1411 return Set(timet);
1412 }
1413}
1414
1415wxDateTime& wxDateTime::Set(wxDateTime_t hour,
1416 wxDateTime_t minute,
1417 wxDateTime_t second,
1418 wxDateTime_t millisec)
1419{
1420 // we allow seconds to be 61 to account for the leap seconds, even if we
1421 // don't use them really
384223b3
VZ
1422 wxDATETIME_CHECK( hour < 24 &&
1423 second < 62 &&
1424 minute < 60 &&
1425 millisec < 1000,
1426 _T("Invalid time in wxDateTime::Set()") );
0979c962
VZ
1427
1428 // get the current date from system
a452689b
SN
1429 struct tm tmstruct;
1430 struct tm *tm = GetTmNow(&tmstruct);
299fcbfe 1431
a452689b 1432 wxDATETIME_CHECK( tm, _T("wxLocaltime_r() failed") );
0979c962 1433
456639ac
VZ
1434 // make a copy so it isn't clobbered by the call to mktime() below
1435 struct tm tm1(*tm);
1436
0979c962 1437 // adjust the time
456639ac
VZ
1438 tm1.tm_hour = hour;
1439 tm1.tm_min = minute;
1440 tm1.tm_sec = second;
0979c962 1441
9cc311d3 1442 // and the DST in case it changes on this date
456639ac 1443 struct tm tm2(tm1);
9cc311d3 1444 mktime(&tm2);
456639ac
VZ
1445 if ( tm2.tm_isdst != tm1.tm_isdst )
1446 tm1.tm_isdst = tm2.tm_isdst;
9cc311d3 1447
456639ac 1448 (void)Set(tm1);
0979c962
VZ
1449
1450 // and finally adjust milliseconds
1451 return SetMillisecond(millisec);
1452}
1453
1454wxDateTime& wxDateTime::Set(wxDateTime_t day,
1455 Month month,
1456 int year,
1457 wxDateTime_t hour,
1458 wxDateTime_t minute,
1459 wxDateTime_t second,
1460 wxDateTime_t millisec)
1461{
384223b3
VZ
1462 wxDATETIME_CHECK( hour < 24 &&
1463 second < 62 &&
1464 minute < 60 &&
1465 millisec < 1000,
1466 _T("Invalid time in wxDateTime::Set()") );
0979c962 1467
2f02cb89 1468 ReplaceDefaultYearMonthWithCurrent(&year, &month);
0979c962 1469
384223b3
VZ
1470 wxDATETIME_CHECK( (0 < day) && (day <= GetNumberOfDays(month, year)),
1471 _T("Invalid date in wxDateTime::Set()") );
0979c962
VZ
1472
1473 // the range of time_t type (inclusive)
1474 static const int yearMinInRange = 1970;
1475 static const int yearMaxInRange = 2037;
1476
1477 // test only the year instead of testing for the exact end of the Unix
1478 // time_t range - it doesn't bring anything to do more precise checks
2f02cb89 1479 if ( year >= yearMinInRange && year <= yearMaxInRange )
0979c962
VZ
1480 {
1481 // use the standard library version if the date is in range - this is
b76b015e 1482 // probably more efficient than our code
0979c962 1483 struct tm tm;
b76b015e 1484 tm.tm_year = year - 1900;
0979c962
VZ
1485 tm.tm_mon = month;
1486 tm.tm_mday = day;
1487 tm.tm_hour = hour;
1488 tm.tm_min = minute;
1489 tm.tm_sec = second;
299fcbfe 1490 tm.tm_isdst = -1; // mktime() will guess it
0979c962
VZ
1491
1492 (void)Set(tm);
1493
1494 // and finally adjust milliseconds
3d78a532
RD
1495 if (IsValid())
1496 SetMillisecond(millisec);
1497
1498 return *this;
0979c962
VZ
1499 }
1500 else
1501 {
1502 // do time calculations ourselves: we want to calculate the number of
fcc3d7cb 1503 // milliseconds between the given date and the epoch
e6ec579c
VZ
1504
1505 // get the JDN for the midnight of this day
1506 m_time = GetTruncatedJDN(day, month, year);
1507 m_time -= EPOCH_JDN;
1508 m_time *= SECONDS_PER_DAY * TIME_T_FACTOR;
1509
299fcbfe
VZ
1510 // JDN corresponds to GMT, we take localtime
1511 Add(wxTimeSpan(hour, minute, second + GetTimeZone(), millisec));
b76b015e
VZ
1512 }
1513
1514 return *this;
1515}
1516
e6ec579c
VZ
1517wxDateTime& wxDateTime::Set(double jdn)
1518{
1ef54dcf
VZ
1519 // so that m_time will be 0 for the midnight of Jan 1, 1970 which is jdn
1520 // EPOCH_JDN + 0.5
1521 jdn -= EPOCH_JDN + 0.5;
1522
d26adb9d 1523 m_time.Assign(jdn*MILLISECONDS_PER_DAY);
cd0b1709 1524
d26adb9d 1525 // JDNs always are in UTC, so we don't need any adjustments for time zone
e6ec579c
VZ
1526
1527 return *this;
1528}
1529
9d9b7755
VZ
1530wxDateTime& wxDateTime::ResetTime()
1531{
1532 Tm tm = GetTm();
1533
1534 if ( tm.hour || tm.min || tm.sec || tm.msec )
1535 {
1536 tm.msec =
1537 tm.sec =
1538 tm.min =
1539 tm.hour = 0;
1540
1541 Set(tm);
1542 }
1543
1544 return *this;
1545}
1546
fb96cf85
VZ
1547wxDateTime wxDateTime::GetDateOnly() const
1548{
1549 Tm tm = GetTm();
1550 tm.msec =
1551 tm.sec =
1552 tm.min =
1553 tm.hour = 0;
1554 return wxDateTime(tm);
1555}
1556
2b5f62a0
VZ
1557// ----------------------------------------------------------------------------
1558// DOS Date and Time Format functions
1559// ----------------------------------------------------------------------------
1560// the dos date and time value is an unsigned 32 bit value in the format:
1561// YYYYYYYMMMMDDDDDhhhhhmmmmmmsssss
1562//
1563// Y = year offset from 1980 (0-127)
1564// M = month (1-12)
1565// D = day of month (1-31)
1566// h = hour (0-23)
1567// m = minute (0-59)
1568// s = bisecond (0-29) each bisecond indicates two seconds
1569// ----------------------------------------------------------------------------
1570
1571wxDateTime& wxDateTime::SetFromDOS(unsigned long ddt)
1572{
1573 struct tm tm;
4739346e 1574 InitTm(tm);
2b5f62a0
VZ
1575
1576 long year = ddt & 0xFE000000;
1577 year >>= 25;
1578 year += 80;
1579 tm.tm_year = year;
1580
1581 long month = ddt & 0x1E00000;
1582 month >>= 21;
1583 month -= 1;
1584 tm.tm_mon = month;
1585
1586 long day = ddt & 0x1F0000;
1587 day >>= 16;
1588 tm.tm_mday = day;
1589
1590 long hour = ddt & 0xF800;
1591 hour >>= 11;
1592 tm.tm_hour = hour;
1593
1594 long minute = ddt & 0x7E0;
1595 minute >>= 5;
1596 tm.tm_min = minute;
1597
1598 long second = ddt & 0x1F;
1599 tm.tm_sec = second * 2;
1600
1601 return Set(mktime(&tm));
1602}
1603
1604unsigned long wxDateTime::GetAsDOS() const
1605{
1606 unsigned long ddt;
1607 time_t ticks = GetTicks();
a452689b
SN
1608 struct tm tmstruct;
1609 struct tm *tm = wxLocaltime_r(&ticks, &tmstruct);
2b5f62a0
VZ
1610
1611 long year = tm->tm_year;
1612 year -= 80;
1613 year <<= 25;
1614
1615 long month = tm->tm_mon;
1616 month += 1;
1617 month <<= 21;
1618
1619 long day = tm->tm_mday;
1620 day <<= 16;
1621
1622 long hour = tm->tm_hour;
1623 hour <<= 11;
1624
1625 long minute = tm->tm_min;
1626 minute <<= 5;
1627
1628 long second = tm->tm_sec;
1629 second /= 2;
1630
1631 ddt = year | month | day | hour | minute | second;
1632 return ddt;
1633}
1634
b76b015e
VZ
1635// ----------------------------------------------------------------------------
1636// time_t <-> broken down time conversions
1637// ----------------------------------------------------------------------------
1638
299fcbfe 1639wxDateTime::Tm wxDateTime::GetTm(const TimeZone& tz) const
b76b015e
VZ
1640{
1641 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1642
1643 time_t time = GetTicks();
1644 if ( time != (time_t)-1 )
1645 {
1646 // use C RTL functions
a452689b 1647 struct tm tmstruct;
299fcbfe
VZ
1648 tm *tm;
1649 if ( tz.GetOffset() == -GetTimeZone() )
1650 {
1651 // we are working with local time
a452689b 1652 tm = wxLocaltime_r(&time, &tmstruct);
c5a1681b
VZ
1653
1654 // should never happen
a452689b 1655 wxCHECK_MSG( tm, Tm(), _T("wxLocaltime_r() failed") );
299fcbfe
VZ
1656 }
1657 else
1658 {
13111b2a 1659 time += (time_t)tz.GetOffset();
33ac7e6f 1660#if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
13111b2a 1661 int time2 = (int) time;
9d9b7755 1662 if ( time2 >= 0 )
fb10f04c 1663#else
9d9b7755 1664 if ( time >= 0 )
fb10f04c 1665#endif
c5a1681b 1666 {
a452689b 1667 tm = wxGmtime_r(&time, &tmstruct);
b76b015e 1668
c5a1681b 1669 // should never happen
a452689b 1670 wxCHECK_MSG( tm, Tm(), _T("wxGmtime_r() failed") );
c5a1681b
VZ
1671 }
1672 else
1673 {
1674 tm = (struct tm *)NULL;
1675 }
1676 }
b76b015e 1677
c5a1681b
VZ
1678 if ( tm )
1679 {
f6bcfd97
BP
1680 // adjust the milliseconds
1681 Tm tm2(*tm, tz);
1682 long timeOnly = (m_time % MILLISECONDS_PER_DAY).ToLong();
1683 tm2.msec = (wxDateTime_t)(timeOnly % 1000);
1684 return tm2;
c5a1681b
VZ
1685 }
1686 //else: use generic code below
b76b015e 1687 }
e6ec579c 1688
c5a1681b
VZ
1689 // remember the time and do the calculations with the date only - this
1690 // eliminates rounding errors of the floating point arithmetics
299fcbfe 1691
c5a1681b 1692 wxLongLong timeMidnight = m_time + tz.GetOffset() * 1000;
1ef54dcf 1693
c5a1681b 1694 long timeOnly = (timeMidnight % MILLISECONDS_PER_DAY).ToLong();
1ef54dcf 1695
c5a1681b
VZ
1696 // we want to always have positive time and timeMidnight to be really
1697 // the midnight before it
1698 if ( timeOnly < 0 )
1699 {
1700 timeOnly = MILLISECONDS_PER_DAY + timeOnly;
1701 }
e6ec579c 1702
c5a1681b 1703 timeMidnight -= timeOnly;
1ef54dcf 1704
c5a1681b
VZ
1705 // calculate the Gregorian date from JDN for the midnight of our date:
1706 // this will yield day, month (in 1..12 range) and year
1ef54dcf 1707
c5a1681b
VZ
1708 // actually, this is the JDN for the noon of the previous day
1709 long jdn = (timeMidnight / MILLISECONDS_PER_DAY).ToLong() + EPOCH_JDN;
1ef54dcf 1710
c5a1681b 1711 // CREDIT: code below is by Scott E. Lee (but bugs are mine)
1ef54dcf 1712
c5a1681b 1713 wxASSERT_MSG( jdn > -2, _T("JDN out of range") );
1ef54dcf 1714
c5a1681b 1715 // calculate the century
479cd5de
VZ
1716 long temp = (jdn + JDN_OFFSET) * 4 - 1;
1717 long century = temp / DAYS_PER_400_YEARS;
1ef54dcf 1718
c5a1681b
VZ
1719 // then the year and day of year (1 <= dayOfYear <= 366)
1720 temp = ((temp % DAYS_PER_400_YEARS) / 4) * 4 + 3;
479cd5de
VZ
1721 long year = (century * 100) + (temp / DAYS_PER_4_YEARS);
1722 long dayOfYear = (temp % DAYS_PER_4_YEARS) / 4 + 1;
1ef54dcf 1723
c5a1681b
VZ
1724 // and finally the month and day of the month
1725 temp = dayOfYear * 5 - 3;
479cd5de
VZ
1726 long month = temp / DAYS_PER_5_MONTHS;
1727 long day = (temp % DAYS_PER_5_MONTHS) / 5 + 1;
c5a1681b
VZ
1728
1729 // month is counted from March - convert to normal
1730 if ( month < 10 )
1731 {
1732 month += 3;
1733 }
1734 else
1735 {
1736 year += 1;
1737 month -= 9;
1738 }
1ef54dcf 1739
c5a1681b
VZ
1740 // year is offset by 4800
1741 year -= 4800;
1ef54dcf 1742
c5a1681b
VZ
1743 // check that the algorithm gave us something reasonable
1744 wxASSERT_MSG( (0 < month) && (month <= 12), _T("invalid month") );
1745 wxASSERT_MSG( (1 <= day) && (day < 32), _T("invalid day") );
e6ec579c 1746
c5a1681b
VZ
1747 // construct Tm from these values
1748 Tm tm;
1749 tm.year = (int)year;
1750 tm.mon = (Month)(month - 1); // algorithm yields 1 for January, not 0
1751 tm.mday = (wxDateTime_t)day;
479cd5de 1752 tm.msec = (wxDateTime_t)(timeOnly % 1000);
c5a1681b
VZ
1753 timeOnly -= tm.msec;
1754 timeOnly /= 1000; // now we have time in seconds
e6ec579c 1755
d26adb9d 1756 tm.sec = (wxDateTime_t)(timeOnly % SEC_PER_MIN);
c5a1681b 1757 timeOnly -= tm.sec;
d26adb9d 1758 timeOnly /= SEC_PER_MIN; // now we have time in minutes
e6ec579c 1759
d26adb9d 1760 tm.min = (wxDateTime_t)(timeOnly % MIN_PER_HOUR);
c5a1681b 1761 timeOnly -= tm.min;
e6ec579c 1762
d26adb9d 1763 tm.hour = (wxDateTime_t)(timeOnly / MIN_PER_HOUR);
b76b015e 1764
c5a1681b 1765 return tm;
b76b015e
VZ
1766}
1767
1768wxDateTime& wxDateTime::SetYear(int year)
1769{
1770 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1771
1772 Tm tm(GetTm());
1773 tm.year = year;
1774 Set(tm);
1775
1776 return *this;
1777}
1778
1779wxDateTime& wxDateTime::SetMonth(Month month)
1780{
1781 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1782
1783 Tm tm(GetTm());
1784 tm.mon = month;
1785 Set(tm);
1786
1787 return *this;
1788}
1789
1790wxDateTime& wxDateTime::SetDay(wxDateTime_t mday)
1791{
1792 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1793
1794 Tm tm(GetTm());
1795 tm.mday = mday;
1796 Set(tm);
1797
1798 return *this;
1799}
1800
1801wxDateTime& wxDateTime::SetHour(wxDateTime_t hour)
1802{
1803 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1804
1805 Tm tm(GetTm());
1806 tm.hour = hour;
1807 Set(tm);
1808
1809 return *this;
1810}
1811
1812wxDateTime& wxDateTime::SetMinute(wxDateTime_t min)
1813{
1814 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1815
1816 Tm tm(GetTm());
1817 tm.min = min;
1818 Set(tm);
1819
1820 return *this;
1821}
1822
1823wxDateTime& wxDateTime::SetSecond(wxDateTime_t sec)
1824{
1825 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1826
1827 Tm tm(GetTm());
1828 tm.sec = sec;
1829 Set(tm);
0979c962
VZ
1830
1831 return *this;
1832}
b76b015e
VZ
1833
1834wxDateTime& wxDateTime::SetMillisecond(wxDateTime_t millisecond)
1835{
1836 wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
1837
1838 // we don't need to use GetTm() for this one
1839 m_time -= m_time % 1000l;
1840 m_time += millisecond;
1841
1842 return *this;
1843}
1844
1845// ----------------------------------------------------------------------------
1846// wxDateTime arithmetics
1847// ----------------------------------------------------------------------------
1848
1849wxDateTime& wxDateTime::Add(const wxDateSpan& diff)
1850{
1851 Tm tm(GetTm());
1852
1853 tm.year += diff.GetYears();
fcc3d7cb 1854 tm.AddMonths(diff.GetMonths());
4f6aed9c
VZ
1855
1856 // check that the resulting date is valid
1857 if ( tm.mday > GetNumOfDaysInMonth(tm.year, tm.mon) )
1858 {
1859 // We suppose that when adding one month to Jan 31 we want to get Feb
1860 // 28 (or 29), i.e. adding a month to the last day of the month should
1861 // give the last day of the next month which is quite logical.
1862 //
1863 // Unfortunately, there is no logic way to understand what should
1864 // Jan 30 + 1 month be - Feb 28 too or Feb 27 (assuming non leap year)?
1865 // We make it Feb 28 (last day too), but it is highly questionable.
1866 tm.mday = GetNumOfDaysInMonth(tm.year, tm.mon);
1867 }
1868
fcc3d7cb 1869 tm.AddDays(diff.GetTotalDays());
b76b015e
VZ
1870
1871 Set(tm);
1872
9d9b7755
VZ
1873 wxASSERT_MSG( IsSameTime(tm),
1874 _T("Add(wxDateSpan) shouldn't modify time") );
1875
b76b015e
VZ
1876 return *this;
1877}
1878
2f02cb89
VZ
1879// ----------------------------------------------------------------------------
1880// Weekday and monthday stuff
1881// ----------------------------------------------------------------------------
1882
4c27e2fa
VZ
1883// convert Sun, Mon, ..., Sat into 6, 0, ..., 5
1884static inline int ConvertWeekDayToMondayBase(int wd)
1885{
1886 return wd == wxDateTime::Sun ? 6 : wd - 1;
1887}
1888
1889/* static */
1890wxDateTime
1891wxDateTime::SetToWeekOfYear(int year, wxDateTime_t numWeek, WeekDay wd)
4f6aed9c 1892{
2b5f62a0
VZ
1893 wxASSERT_MSG( numWeek > 0,
1894 _T("invalid week number: weeks are counted from 1") );
1895
4c27e2fa
VZ
1896 // Jan 4 always lies in the 1st week of the year
1897 wxDateTime dt(4, Jan, year);
1898 dt.SetToWeekDayInSameWeek(wd);
1899 dt += wxDateSpan::Weeks(numWeek - 1);
1900
1901 return dt;
1902}
4f6aed9c 1903
ca3e85cf 1904#if WXWIN_COMPATIBILITY_2_6
4c27e2fa
VZ
1905// use a separate function to avoid warnings about using deprecated
1906// SetToTheWeek in GetWeek below
1907static wxDateTime
1908SetToTheWeek(int year,
1909 wxDateTime::wxDateTime_t numWeek,
1910 wxDateTime::WeekDay weekday,
1911 wxDateTime::WeekFlags flags)
1912{
4f6aed9c 1913 // Jan 4 always lies in the 1st week of the year
4c27e2fa
VZ
1914 wxDateTime dt(4, wxDateTime::Jan, year);
1915 dt.SetToWeekDayInSameWeek(weekday, flags);
1916 dt += wxDateSpan::Weeks(numWeek - 1);
4f6aed9c 1917
4c27e2fa
VZ
1918 return dt;
1919}
1920
1921bool wxDateTime::SetToTheWeek(wxDateTime_t numWeek,
1922 WeekDay weekday,
1923 WeekFlags flags)
1924{
1925 int year = GetYear();
1926 *this = ::SetToTheWeek(year, numWeek, weekday, flags);
4f6aed9c
VZ
1927 if ( GetYear() != year )
1928 {
1929 // oops... numWeek was too big
68379eaf 1930 return false;
4f6aed9c
VZ
1931 }
1932
68379eaf 1933 return true;
4f6aed9c
VZ
1934}
1935
4c27e2fa
VZ
1936wxDateTime wxDateTime::GetWeek(wxDateTime_t numWeek,
1937 WeekDay weekday,
1938 WeekFlags flags) const
1939{
1940 return ::SetToTheWeek(GetYear(), numWeek, weekday, flags);
1941}
ca3e85cf 1942#endif // WXWIN_COMPATIBILITY_2_6
4c27e2fa 1943
2f02cb89
VZ
1944wxDateTime& wxDateTime::SetToLastMonthDay(Month month,
1945 int year)
1946{
1947 // take the current month/year if none specified
1a8557b1
VZ
1948 if ( year == Inv_Year )
1949 year = GetYear();
1950 if ( month == Inv_Month )
1951 month = GetMonth();
2f02cb89 1952
fcc3d7cb 1953 return Set(GetNumOfDaysInMonth(year, month), month, year);
2f02cb89
VZ
1954}
1955
2b5f62a0 1956wxDateTime& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday, WeekFlags flags)
cd0b1709 1957{
384223b3 1958 wxDATETIME_CHECK( weekday != Inv_WeekDay, _T("invalid weekday") );
cd0b1709 1959
af80bc92
VZ
1960 int wdayDst = weekday,
1961 wdayThis = GetWeekDay();
1962 if ( wdayDst == wdayThis )
cd0b1709
VZ
1963 {
1964 // nothing to do
1965 return *this;
1966 }
2b5f62a0
VZ
1967
1968 if ( flags == Default_First )
1969 {
1970 flags = GetCountry() == USA ? Sunday_First : Monday_First;
1971 }
1972
1973 // the logic below based on comparing weekday and wdayThis works if Sun (0)
1974 // is the first day in the week, but breaks down for Monday_First case so
1975 // we adjust the week days in this case
af80bc92 1976 if ( flags == Monday_First )
2b5f62a0
VZ
1977 {
1978 if ( wdayThis == Sun )
1979 wdayThis += 7;
af80bc92
VZ
1980 if ( wdayDst == Sun )
1981 wdayDst += 7;
2b5f62a0
VZ
1982 }
1983 //else: Sunday_First, nothing to do
1984
1985 // go forward or back in time to the day we want
af80bc92 1986 if ( wdayDst < wdayThis )
cd0b1709 1987 {
af80bc92 1988 return Subtract(wxDateSpan::Days(wdayThis - wdayDst));
cd0b1709
VZ
1989 }
1990 else // weekday > wdayThis
1991 {
af80bc92 1992 return Add(wxDateSpan::Days(wdayDst - wdayThis));
cd0b1709
VZ
1993 }
1994}
1995
1996wxDateTime& wxDateTime::SetToNextWeekDay(WeekDay weekday)
1997{
384223b3 1998 wxDATETIME_CHECK( weekday != Inv_WeekDay, _T("invalid weekday") );
cd0b1709
VZ
1999
2000 int diff;
2001 WeekDay wdayThis = GetWeekDay();
2002 if ( weekday == wdayThis )
2003 {
2004 // nothing to do
2005 return *this;
2006 }
2007 else if ( weekday < wdayThis )
2008 {
2009 // need to advance a week
2010 diff = 7 - (wdayThis - weekday);
2011 }
2012 else // weekday > wdayThis
2013 {
2014 diff = weekday - wdayThis;
2015 }
2016
4f6aed9c 2017 return Add(wxDateSpan::Days(diff));
cd0b1709
VZ
2018}
2019
2020wxDateTime& wxDateTime::SetToPrevWeekDay(WeekDay weekday)
2021{
384223b3 2022 wxDATETIME_CHECK( weekday != Inv_WeekDay, _T("invalid weekday") );
cd0b1709
VZ
2023
2024 int diff;
2025 WeekDay wdayThis = GetWeekDay();
2026 if ( weekday == wdayThis )
2027 {
2028 // nothing to do
2029 return *this;
2030 }
2031 else if ( weekday > wdayThis )
2032 {
2033 // need to go to previous week
2034 diff = 7 - (weekday - wdayThis);
2035 }
2036 else // weekday < wdayThis
2037 {
2038 diff = wdayThis - weekday;
2039 }
2040
f6bcfd97 2041 return Subtract(wxDateSpan::Days(diff));
cd0b1709
VZ
2042}
2043
2f02cb89
VZ
2044bool wxDateTime::SetToWeekDay(WeekDay weekday,
2045 int n,
2046 Month month,
2047 int year)
2048{
68379eaf 2049 wxCHECK_MSG( weekday != Inv_WeekDay, false, _T("invalid weekday") );
2f02cb89 2050
68379eaf 2051 // we don't check explicitly that -5 <= n <= 5 because we will return false
2f02cb89
VZ
2052 // anyhow in such case - but may be should still give an assert for it?
2053
2054 // take the current month/year if none specified
2055 ReplaceDefaultYearMonthWithCurrent(&year, &month);
2056
2057 wxDateTime dt;
2058
2059 // TODO this probably could be optimised somehow...
2060
2061 if ( n > 0 )
2062 {
2063 // get the first day of the month
2064 dt.Set(1, month, year);
2065
2066 // get its wday
2067 WeekDay wdayFirst = dt.GetWeekDay();
2068
2069 // go to the first weekday of the month
2070 int diff = weekday - wdayFirst;
2071 if ( diff < 0 )
2072 diff += 7;
2073
2074 // add advance n-1 weeks more
2075 diff += 7*(n - 1);
2076
239446b4 2077 dt += wxDateSpan::Days(diff);
2f02cb89 2078 }
239446b4 2079 else // count from the end of the month
2f02cb89
VZ
2080 {
2081 // get the last day of the month
2082 dt.SetToLastMonthDay(month, year);
2083
2084 // get its wday
2085 WeekDay wdayLast = dt.GetWeekDay();
2086
2087 // go to the last weekday of the month
2088 int diff = wdayLast - weekday;
2089 if ( diff < 0 )
2090 diff += 7;
2091
2092 // and rewind n-1 weeks from there
239446b4 2093 diff += 7*(-n - 1);
2f02cb89
VZ
2094
2095 dt -= wxDateSpan::Days(diff);
2096 }
2097
2098 // check that it is still in the same month
2099 if ( dt.GetMonth() == month )
2100 {
2101 *this = dt;
2102
68379eaf 2103 return true;
2f02cb89
VZ
2104 }
2105 else
2106 {
2107 // no such day in this month
68379eaf 2108 return false;
2f02cb89
VZ
2109 }
2110}
2111
1c5d27e2
VZ
2112static inline
2113wxDateTime::wxDateTime_t GetDayOfYearFromTm(const wxDateTime::Tm& tm)
2114{
907173e5 2115 return (wxDateTime::wxDateTime_t)(gs_cumulatedDays[wxDateTime::IsLeapYear(tm.year)][tm.mon] + tm.mday);
1c5d27e2
VZ
2116}
2117
239446b4
VZ
2118wxDateTime::wxDateTime_t wxDateTime::GetDayOfYear(const TimeZone& tz) const
2119{
1c5d27e2
VZ
2120 return GetDayOfYearFromTm(GetTm(tz));
2121}
239446b4 2122
1c5d27e2
VZ
2123wxDateTime::wxDateTime_t
2124wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags, const TimeZone& tz) const
239446b4 2125{
9d9b7755
VZ
2126 if ( flags == Default_First )
2127 {
2128 flags = GetCountry() == USA ? Sunday_First : Monday_First;
2129 }
239446b4 2130
1c5d27e2
VZ
2131 Tm tm(GetTm(tz));
2132 wxDateTime_t nDayInYear = GetDayOfYearFromTm(tm);
239446b4 2133
1c5d27e2
VZ
2134 int wdTarget = GetWeekDay(tz);
2135 int wdYearStart = wxDateTime(1, Jan, GetYear()).GetWeekDay();
2136 int week;
9d9b7755
VZ
2137 if ( flags == Sunday_First )
2138 {
1c5d27e2
VZ
2139 // FIXME: First week is not calculated correctly.
2140 week = (nDayInYear - wdTarget + 7) / 7;
2141 if ( wdYearStart == Wed || wdYearStart == Thu )
2142 week++;
9d9b7755 2143 }
1c5d27e2 2144 else // week starts with monday
9d9b7755 2145 {
1c5d27e2
VZ
2146 // adjust the weekdays to non-US style.
2147 wdYearStart = ConvertWeekDayToMondayBase(wdYearStart);
2148 wdTarget = ConvertWeekDayToMondayBase(wdTarget);
239446b4 2149
1c5d27e2
VZ
2150 // quoting from http://www.cl.cam.ac.uk/~mgk25/iso-time.html:
2151 //
2152 // Week 01 of a year is per definition the first week that has the
2153 // Thursday in this year, which is equivalent to the week that
2154 // contains the fourth day of January. In other words, the first
2155 // week of a new year is the week that has the majority of its
2156 // days in the new year. Week 01 might also contain days from the
2157 // previous year and the week before week 01 of a year is the last
2158 // week (52 or 53) of the previous year even if it contains days
2159 // from the new year. A week starts with Monday (day 1) and ends
2160 // with Sunday (day 7).
2161 //
2162
2163 // if Jan 1 is Thursday or less, it is in the first week of this year
2164 if ( wdYearStart < 4 )
2165 {
2166 // count the number of entire weeks between Jan 1 and this date
2167 week = (nDayInYear + wdYearStart + 6 - wdTarget)/7;
2168
2169 // be careful to check for overflow in the next year
2170 if ( week == 53 && tm.mday - wdTarget > 28 )
2171 week = 1;
2172 }
2173 else // Jan 1 is in the last week of the previous year
2174 {
2175 // check if we happen to be at the last week of previous year:
2176 if ( tm.mon == Jan && tm.mday < 8 - wdYearStart )
2177 week = wxDateTime(31, Dec, GetYear()-1).GetWeekOfYear();
2178 else
2179 week = (nDayInYear + wdYearStart - 1 - wdTarget)/7;
2180 }
239446b4
VZ
2181 }
2182
907173e5 2183 return (wxDateTime::wxDateTime_t)week;
68ee7c47
VZ
2184}
2185
9d9b7755
VZ
2186wxDateTime::wxDateTime_t wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags,
2187 const TimeZone& tz) const
68ee7c47 2188{
9d9b7755
VZ
2189 Tm tm = GetTm(tz);
2190 wxDateTime dtMonthStart = wxDateTime(1, tm.mon, tm.year);
6dc6fda6 2191 int nWeek = GetWeekOfYear(flags) - dtMonthStart.GetWeekOfYear(flags) + 1;
9d9b7755 2192 if ( nWeek < 0 )
68ee7c47 2193 {
9d9b7755
VZ
2194 // this may happen for January when Jan, 1 is the last week of the
2195 // previous year
2196 nWeek += IsLeapYear(tm.year - 1) ? 53 : 52;
68ee7c47 2197 }
68ee7c47 2198
6dc6fda6 2199 return (wxDateTime::wxDateTime_t)nWeek;
239446b4
VZ
2200}
2201
f0f951fa
VZ
2202wxDateTime& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday)
2203{
2204 int year = GetYear();
384223b3
VZ
2205 wxDATETIME_CHECK( (0 < yday) && (yday <= GetNumberOfDays(year)),
2206 _T("invalid year day") );
f0f951fa
VZ
2207
2208 bool isLeap = IsLeapYear(year);
2209 for ( Month mon = Jan; mon < Inv_Month; wxNextMonth(mon) )
2210 {
2211 // for Dec, we can't compare with gs_cumulatedDays[mon + 1], but we
2212 // don't need it neither - because of the CHECK above we know that
2213 // yday lies in December then
f49d731f 2214 if ( (mon == Dec) || (yday <= gs_cumulatedDays[isLeap][mon + 1]) )
f0f951fa 2215 {
42841dfc 2216 Set((wxDateTime::wxDateTime_t)(yday - gs_cumulatedDays[isLeap][mon]), mon, year);
f0f951fa
VZ
2217
2218 break;
2219 }
2220 }
2221
2222 return *this;
2223}
2224
e6ec579c
VZ
2225// ----------------------------------------------------------------------------
2226// Julian day number conversion and related stuff
2227// ----------------------------------------------------------------------------
2228
2229double wxDateTime::GetJulianDayNumber() const
2230{
d26adb9d 2231 return m_time.ToDouble() / MILLISECONDS_PER_DAY + EPOCH_JDN + 0.5;
e6ec579c
VZ
2232}
2233
2234double wxDateTime::GetRataDie() const
2235{
2236 // March 1 of the year 0 is Rata Die day -306 and JDN 1721119.5
2237 return GetJulianDayNumber() - 1721119.5 - 306;
2238}
2239
fcc3d7cb 2240// ----------------------------------------------------------------------------
299fcbfe 2241// timezone and DST stuff
fcc3d7cb
VZ
2242// ----------------------------------------------------------------------------
2243
299fcbfe 2244int wxDateTime::IsDST(wxDateTime::Country country) const
fcc3d7cb 2245{
299fcbfe
VZ
2246 wxCHECK_MSG( country == Country_Default, -1,
2247 _T("country support not implemented") );
2248
2249 // use the C RTL for the dates in the standard range
2250 time_t timet = GetTicks();
2251 if ( timet != (time_t)-1 )
2252 {
a452689b
SN
2253 struct tm tmstruct;
2254 tm *tm = wxLocaltime_r(&timet, &tmstruct);
299fcbfe 2255
a452689b 2256 wxCHECK_MSG( tm, -1, _T("wxLocaltime_r() failed") );
299fcbfe
VZ
2257
2258 return tm->tm_isdst;
2259 }
2260 else
2261 {
239446b4
VZ
2262 int year = GetYear();
2263
2264 if ( !IsDSTApplicable(year, country) )
2265 {
2266 // no DST time in this year in this country
2267 return -1;
2268 }
299fcbfe 2269
239446b4 2270 return IsBetween(GetBeginDST(year, country), GetEndDST(year, country));
299fcbfe 2271 }
fcc3d7cb
VZ
2272}
2273
41acf5c0 2274wxDateTime& wxDateTime::MakeTimezone(const TimeZone& tz, bool noDST)
fcc3d7cb 2275{
479cd5de 2276 long secDiff = GetTimeZone() + tz.GetOffset();
fcc3d7cb 2277
41acf5c0
VZ
2278 // we need to know whether DST is or not in effect for this date unless
2279 // the test disabled by the caller
2280 if ( !noDST && (IsDST() == 1) )
299fcbfe
VZ
2281 {
2282 // FIXME we assume that the DST is always shifted by 1 hour
2283 secDiff -= 3600;
2284 }
2285
d26adb9d
VZ
2286 return Add(wxTimeSpan::Seconds(secDiff));
2287}
2288
2289wxDateTime& wxDateTime::MakeFromTimezone(const TimeZone& tz, bool noDST)
2290{
2291 long secDiff = GetTimeZone() + tz.GetOffset();
2292
2293 // we need to know whether DST is or not in effect for this date unless
2294 // the test disabled by the caller
2295 if ( !noDST && (IsDST() == 1) )
2296 {
2297 // FIXME we assume that the DST is always shifted by 1 hour
2298 secDiff -= 3600;
2299 }
2300
f6bcfd97 2301 return Subtract(wxTimeSpan::Seconds(secDiff));
fcc3d7cb
VZ
2302}
2303
b76b015e
VZ
2304// ----------------------------------------------------------------------------
2305// wxDateTime to/from text representations
2306// ----------------------------------------------------------------------------
2307
12e82477 2308wxString wxDateTime::Format(const wxString& format, const TimeZone& tz) const
b76b015e 2309{
12e82477
VS
2310 wxCHECK_MSG( !format.empty(), wxEmptyString,
2311 _T("NULL format in wxDateTime::Format") );
e6ec579c 2312
f6bcfd97
BP
2313 // we have to use our own implementation if the date is out of range of
2314 // strftime() or if we use non standard specificators
bb7afa49 2315#ifdef HAVE_STRFTIME
b5085b02
WS
2316 time_t time = GetTicks();
2317
f6bcfd97 2318 if ( (time != (time_t)-1) && !wxStrstr(format, _T("%l")) )
b76b015e
VZ
2319 {
2320 // use strftime()
a452689b
SN
2321 struct tm tmstruct;
2322 struct tm *tm;
299fcbfe
VZ
2323 if ( tz.GetOffset() == -GetTimeZone() )
2324 {
2325 // we are working with local time
a452689b 2326 tm = wxLocaltime_r(&time, &tmstruct);
c5a1681b
VZ
2327
2328 // should never happen
a452689b 2329 wxCHECK_MSG( tm, wxEmptyString, _T("wxLocaltime_r() failed") );
299fcbfe
VZ
2330 }
2331 else
2332 {
479cd5de 2333 time += (int)tz.GetOffset();
299fcbfe 2334
33ac7e6f 2335#if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
13111b2a 2336 int time2 = (int) time;
9c2882d9 2337 if ( time2 >= 0 )
fb10f04c 2338#else
9c2882d9 2339 if ( time >= 0 )
fb10f04c 2340#endif
c5a1681b 2341 {
a452689b 2342 tm = wxGmtime_r(&time, &tmstruct);
b76b015e 2343
c5a1681b 2344 // should never happen
a452689b 2345 wxCHECK_MSG( tm, wxEmptyString, _T("wxGmtime_r() failed") );
c5a1681b
VZ
2346 }
2347 else
2348 {
2349 tm = (struct tm *)NULL;
2350 }
2351 }
bb7afa49 2352
c5a1681b 2353 if ( tm )
e6ec579c 2354 {
c5a1681b 2355 return CallStrftime(format, tm);
e6ec579c 2356 }
c5a1681b 2357 }
bb7afa49
VZ
2358 //else: use generic code below
2359#endif // HAVE_STRFTIME
c5a1681b 2360
68ee7c47 2361 // we only parse ANSI C format specifications here, no POSIX 2
f6bcfd97
BP
2362 // complications, no GNU extensions but we do add support for a "%l" format
2363 // specifier allowing to get the number of milliseconds
68ee7c47 2364 Tm tm = GetTm(tz);
e6ec579c 2365
68ee7c47
VZ
2366 // used for calls to strftime() when we only deal with time
2367 struct tm tmTimeOnly;
2368 tmTimeOnly.tm_hour = tm.hour;
2369 tmTimeOnly.tm_min = tm.min;
2370 tmTimeOnly.tm_sec = tm.sec;
2371 tmTimeOnly.tm_wday = 0;
2372 tmTimeOnly.tm_yday = 0;
2373 tmTimeOnly.tm_mday = 1; // any date will do
2374 tmTimeOnly.tm_mon = 0;
2375 tmTimeOnly.tm_year = 76;
2376 tmTimeOnly.tm_isdst = 0; // no DST, we adjust for tz ourselves
e6ec579c 2377
77c3e48a 2378 wxString tmp, res, fmt;
12e82477 2379 for ( wxString::const_iterator p = format.begin(); p != format.end(); ++p )
68ee7c47
VZ
2380 {
2381 if ( *p != _T('%') )
2382 {
2383 // copy as is
2384 res += *p;
b76b015e 2385
68ee7c47
VZ
2386 continue;
2387 }
e6ec579c 2388
77c3e48a 2389 // set the default format
12e82477 2390 switch ( (*++p).GetValue() )
77c3e48a
VZ
2391 {
2392 case _T('Y'): // year has 4 digits
2393 fmt = _T("%04d");
2394 break;
2395
2396 case _T('j'): // day of year has 3 digits
f6bcfd97 2397 case _T('l'): // milliseconds have 3 digits
77c3e48a
VZ
2398 fmt = _T("%03d");
2399 break;
2400
59d04dff
VZ
2401 case _T('w'): // week day as number has only one
2402 fmt = _T("%d");
2403 break;
2404
77c3e48a
VZ
2405 default:
2406 // it's either another valid format specifier in which case
2407 // the format is "%02d" (for all the rest) or we have the
2408 // field width preceding the format in which case it will
2409 // override the default format anyhow
2410 fmt = _T("%02d");
2411 }
2412
68379eaf 2413 bool restart = true;
fc3398f8 2414 while ( restart )
68ee7c47 2415 {
68379eaf 2416 restart = false;
68ee7c47 2417
fc3398f8 2418 // start of the format specification
12e82477 2419 switch ( (*p).GetValue() )
fc3398f8
VZ
2420 {
2421 case _T('a'): // a weekday name
2422 case _T('A'):
68379eaf 2423 // second parameter should be true for abbreviated names
fc3398f8
VZ
2424 res += GetWeekDayName(tm.GetWeekDay(),
2425 *p == _T('a') ? Name_Abbr : Name_Full);
2426 break;
68ee7c47 2427
fc3398f8
VZ
2428 case _T('b'): // a month name
2429 case _T('B'):
2430 res += GetMonthName(tm.mon,
2431 *p == _T('b') ? Name_Abbr : Name_Full);
2432 break;
2433
2434 case _T('c'): // locale default date and time representation
2435 case _T('x'): // locale default date representation
bb7afa49 2436#ifdef HAVE_STRFTIME
fc3398f8
VZ
2437 //
2438 // the problem: there is no way to know what do these format
2439 // specifications correspond to for the current locale.
2440 //
2441 // the solution: use a hack and still use strftime(): first
2442 // find the YEAR which is a year in the strftime() range (1970
2443 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
2444 // of the real year. Then make a copy of the format and
3103e8a9 2445 // replace all occurrences of YEAR in it with some unique
fc3398f8
VZ
2446 // string not appearing anywhere else in it, then use
2447 // strftime() to format the date in year YEAR and then replace
2448 // YEAR back by the real year and the unique replacement
3103e8a9
JS
2449 // string back with YEAR. Notice that "all occurrences of YEAR"
2450 // means all occurrences of 4 digit as well as 2 digit form!
fc3398f8
VZ
2451 //
2452 // the bugs: we assume that neither of %c nor %x contains any
2453 // fields which may change between the YEAR and real year. For
2454 // example, the week number (%U, %W) and the day number (%j)
2455 // will change if one of these years is leap and the other one
2456 // is not!
68ee7c47 2457 {
8888d971 2458 // find the YEAR: normally, for any year X, Jan 1 of the
fc3398f8
VZ
2459 // year X + 28 is the same weekday as Jan 1 of X (because
2460 // the weekday advances by 1 for each normal X and by 2
2461 // for each leap X, hence by 5 every 4 years or by 35
2462 // which is 0 mod 7 every 28 years) but this rule breaks
2463 // down if there are years between X and Y which are
2464 // divisible by 4 but not leap (i.e. divisible by 100 but
2465 // not 400), hence the correction.
2466
2467 int yearReal = GetYear(tz);
2468 int mod28 = yearReal % 28;
2469
2470 // be careful to not go too far - we risk to leave the
2471 // supported range
2472 int year;
2473 if ( mod28 < 10 )
2474 {
2475 year = 1988 + mod28; // 1988 == 0 (mod 28)
2476 }
2477 else
2478 {
2479 year = 1970 + mod28 - 10; // 1970 == 10 (mod 28)
2480 }
e6ec579c 2481
fc3398f8
VZ
2482 int nCentury = year / 100,
2483 nCenturyReal = yearReal / 100;
c5a1681b 2484
fc3398f8
VZ
2485 // need to adjust for the years divisble by 400 which are
2486 // not leap but are counted like leap ones if we just take
2487 // the number of centuries in between for nLostWeekDays
2488 int nLostWeekDays = (nCentury - nCenturyReal) -
2489 (nCentury / 4 - nCenturyReal / 4);
c5a1681b 2490
fc3398f8
VZ
2491 // we have to gain back the "lost" weekdays: note that the
2492 // effect of this loop is to not do anything to
2493 // nLostWeekDays (which we won't use any more), but to
2494 // (indirectly) set the year correctly
2495 while ( (nLostWeekDays % 7) != 0 )
2496 {
2497 nLostWeekDays += year++ % 4 ? 1 : 2;
2498 }
88a7a4e1 2499
8888d971
VZ
2500 // finally move the year below 2000 so that the 2-digit
2501 // year number can never match the month or day of the
2502 // month when we do the replacements below
2503 if ( year >= 2000 )
2504 year -= 28;
c5a1681b 2505
8888d971
VZ
2506 wxASSERT_MSG( year >= 1970 && year < 2000,
2507 _T("logic error in wxDateTime::Format") );
88a7a4e1 2508
fc3398f8
VZ
2509
2510 // use strftime() to format the same date but in supported
2511 // year
2512 //
2513 // NB: we assume that strftime() doesn't check for the
2514 // date validity and will happily format the date
2515 // corresponding to Feb 29 of a non leap year (which
2516 // may happen if yearReal was leap and year is not)
2517 struct tm tmAdjusted;
2518 InitTm(tmAdjusted);
2519 tmAdjusted.tm_hour = tm.hour;
2520 tmAdjusted.tm_min = tm.min;
2521 tmAdjusted.tm_sec = tm.sec;
2522 tmAdjusted.tm_wday = tm.GetWeekDay();
2523 tmAdjusted.tm_yday = GetDayOfYear();
2524 tmAdjusted.tm_mday = tm.mday;
2525 tmAdjusted.tm_mon = tm.mon;
2526 tmAdjusted.tm_year = year - 1900;
2527 tmAdjusted.tm_isdst = 0; // no DST, already adjusted
2528 wxString str = CallStrftime(*p == _T('c') ? _T("%c")
2529 : _T("%x"),
2530 &tmAdjusted);
2531
8888d971
VZ
2532 // now replace the replacement year with the real year:
2533 // notice that we have to replace the 4 digit year with
2534 // a unique string not appearing in strftime() output
2535 // first to prevent the 2 digit year from matching any
2536 // substring of the 4 digit year (but any day, month,
2537 // hours or minutes components should be safe because
2538 // they are never in 70-99 range)
2539 wxString replacement("|");
2540 while ( str.find(replacement) != wxString::npos )
2541 replacement += '|';
2542
2543 str.Replace(wxString::Format("%d", year),
2544 replacement);
2545 str.Replace(wxString::Format("%d", year % 100),
2546 wxString::Format("%d", yearReal % 100));
2547 str.Replace(replacement,
2548 wxString::Format("%d", yearReal));
fc3398f8
VZ
2549
2550 res += str;
68ee7c47 2551 }
bb7afa49
VZ
2552#else // !HAVE_STRFTIME
2553 // Use "%m/%d/%y %H:%M:%S" format instead
ba9bbf13
WS
2554 res += wxString::Format(wxT("%02d/%02d/%04d %02d:%02d:%02d"),
2555 tm.mon+1,tm.mday, tm.year, tm.hour, tm.min, tm.sec);
bb7afa49 2556#endif // HAVE_STRFTIME/!HAVE_STRFTIME
fc3398f8 2557 break;
c5a1681b 2558
fc3398f8
VZ
2559 case _T('d'): // day of a month (01-31)
2560 res += wxString::Format(fmt, tm.mday);
2561 break;
68ee7c47 2562
fc3398f8
VZ
2563 case _T('H'): // hour in 24h format (00-23)
2564 res += wxString::Format(fmt, tm.hour);
2565 break;
2566
2567 case _T('I'): // hour in 12h format (01-12)
68ee7c47 2568 {
fc3398f8
VZ
2569 // 24h -> 12h, 0h -> 12h too
2570 int hour12 = tm.hour > 12 ? tm.hour - 12
2571 : tm.hour ? tm.hour : 12;
2572 res += wxString::Format(fmt, hour12);
68ee7c47 2573 }
fc3398f8 2574 break;
c5a1681b 2575
fc3398f8
VZ
2576 case _T('j'): // day of the year
2577 res += wxString::Format(fmt, GetDayOfYear(tz));
2578 break;
68ee7c47 2579
f6bcfd97
BP
2580 case _T('l'): // milliseconds (NOT STANDARD)
2581 res += wxString::Format(fmt, GetMillisecond(tz));
2582 break;
2583
fc3398f8
VZ
2584 case _T('m'): // month as a number (01-12)
2585 res += wxString::Format(fmt, tm.mon + 1);
2586 break;
68ee7c47 2587
fc3398f8
VZ
2588 case _T('M'): // minute as a decimal number (00-59)
2589 res += wxString::Format(fmt, tm.min);
2590 break;
68ee7c47 2591
fc3398f8 2592 case _T('p'): // AM or PM string
bb7afa49 2593#ifdef HAVE_STRFTIME
fc3398f8 2594 res += CallStrftime(_T("%p"), &tmTimeOnly);
bb7afa49 2595#else // !HAVE_STRFTIME
ba9bbf13 2596 res += (tmTimeOnly.tm_hour > 12) ? wxT("pm") : wxT("am");
bb7afa49 2597#endif // HAVE_STRFTIME/!HAVE_STRFTIME
fc3398f8 2598 break;
68ee7c47 2599
fc3398f8
VZ
2600 case _T('S'): // second as a decimal number (00-61)
2601 res += wxString::Format(fmt, tm.sec);
2602 break;
68ee7c47 2603
fc3398f8
VZ
2604 case _T('U'): // week number in the year (Sunday 1st week day)
2605 res += wxString::Format(fmt, GetWeekOfYear(Sunday_First, tz));
2606 break;
68ee7c47 2607
fc3398f8
VZ
2608 case _T('W'): // week number in the year (Monday 1st week day)
2609 res += wxString::Format(fmt, GetWeekOfYear(Monday_First, tz));
2610 break;
68ee7c47 2611
fc3398f8
VZ
2612 case _T('w'): // weekday as a number (0-6), Sunday = 0
2613 res += wxString::Format(fmt, tm.GetWeekDay());
2614 break;
68ee7c47 2615
fc3398f8 2616 // case _T('x'): -- handled with "%c"
68ee7c47 2617
fc3398f8
VZ
2618 case _T('X'): // locale default time representation
2619 // just use strftime() to format the time for us
bb7afa49 2620#ifdef HAVE_STRFTIME
fc3398f8 2621 res += CallStrftime(_T("%X"), &tmTimeOnly);
bb7afa49 2622#else // !HAVE_STRFTIME
ba9bbf13 2623 res += wxString::Format(wxT("%02d:%02d:%02d"),tm.hour, tm.min, tm.sec);
bb7afa49 2624#endif // HAVE_STRFTIME/!HAVE_STRFTIME
fc3398f8 2625 break;
68ee7c47 2626
fc3398f8
VZ
2627 case _T('y'): // year without century (00-99)
2628 res += wxString::Format(fmt, tm.year % 100);
2629 break;
68ee7c47 2630
fc3398f8
VZ
2631 case _T('Y'): // year with century
2632 res += wxString::Format(fmt, tm.year);
2633 break;
68ee7c47 2634
fc3398f8 2635 case _T('Z'): // timezone name
bb7afa49 2636#ifdef HAVE_STRFTIME
fc3398f8 2637 res += CallStrftime(_T("%Z"), &tmTimeOnly);
77b88df2 2638#endif
fc3398f8 2639 break;
68ee7c47 2640
fc3398f8
VZ
2641 default:
2642 // is it the format width?
2643 fmt.Empty();
2644 while ( *p == _T('-') || *p == _T('+') ||
2645 *p == _T(' ') || wxIsdigit(*p) )
2646 {
2647 fmt += *p;
2648 }
68ee7c47 2649
bb8a8478 2650 if ( !fmt.empty() )
fc3398f8
VZ
2651 {
2652 // we've only got the flags and width so far in fmt
2653 fmt.Prepend(_T('%'));
2654 fmt.Append(_T('d'));
68ee7c47 2655
68379eaf 2656 restart = true;
68ee7c47 2657
fc3398f8
VZ
2658 break;
2659 }
68ee7c47 2660
fc3398f8
VZ
2661 // no, it wasn't the width
2662 wxFAIL_MSG(_T("unknown format specificator"));
68ee7c47 2663
fc3398f8 2664 // fall through and just copy it nevertheless
68ee7c47 2665
fc3398f8
VZ
2666 case _T('%'): // a percent sign
2667 res += *p;
2668 break;
2669
2670 case 0: // the end of string
2671 wxFAIL_MSG(_T("missing format at the end of string"));
2672
2673 // just put the '%' which was the last char in format
2674 res += _T('%');
2675 break;
2676 }
68ee7c47 2677 }
c5a1681b
VZ
2678 }
2679
68ee7c47 2680 return res;
b76b015e 2681}
fcc3d7cb 2682
cd0b1709
VZ
2683// this function parses a string in (strict) RFC 822 format: see the section 5
2684// of the RFC for the detailed description, but briefly it's something of the
2685// form "Sat, 18 Dec 1999 00:48:30 +0100"
2686//
2687// this function is "strict" by design - it must reject anything except true
2688// RFC822 time specs.
2689//
2690// TODO a great candidate for using reg exps
2691const wxChar *wxDateTime::ParseRfc822Date(const wxChar* date)
2692{
2693 wxCHECK_MSG( date, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
2694
2695 const wxChar *p = date;
2696 const wxChar *comma = wxStrchr(p, _T(','));
2697 if ( comma )
2698 {
2699 // the part before comma is the weekday
2700
2701 // skip it for now - we don't use but might check that it really
2702 // corresponds to the specfied date
2703 p = comma + 1;
2704
2705 if ( *p != _T(' ') )
2706 {
2707 wxLogDebug(_T("no space after weekday in RFC822 time spec"));
2708
2709 return (wxChar *)NULL;
2710 }
2711
2712 p++; // skip space
2713 }
2714
2715 // the following 1 or 2 digits are the day number
2716 if ( !wxIsdigit(*p) )
2717 {
2718 wxLogDebug(_T("day number expected in RFC822 time spec, none found"));
2719
2720 return (wxChar *)NULL;
2721 }
2722
907173e5 2723 wxDateTime_t day = (wxDateTime_t)(*p++ - _T('0'));
cd0b1709
VZ
2724 if ( wxIsdigit(*p) )
2725 {
2726 day *= 10;
907173e5 2727 day = (wxDateTime_t)(day + (*p++ - _T('0')));
cd0b1709
VZ
2728 }
2729
2730 if ( *p++ != _T(' ') )
2731 {
2732 return (wxChar *)NULL;
2733 }
2734
2735 // the following 3 letters specify the month
2736 wxString monName(p, 3);
2737 Month mon;
2738 if ( monName == _T("Jan") )
2739 mon = Jan;
2740 else if ( monName == _T("Feb") )
2741 mon = Feb;
2742 else if ( monName == _T("Mar") )
2743 mon = Mar;
2744 else if ( monName == _T("Apr") )
2745 mon = Apr;
2746 else if ( monName == _T("May") )
2747 mon = May;
2748 else if ( monName == _T("Jun") )
2749 mon = Jun;
2750 else if ( monName == _T("Jul") )
2751 mon = Jul;
2752 else if ( monName == _T("Aug") )
2753 mon = Aug;
2754 else if ( monName == _T("Sep") )
2755 mon = Sep;
2756 else if ( monName == _T("Oct") )
2757 mon = Oct;
2758 else if ( monName == _T("Nov") )
2759 mon = Nov;
2760 else if ( monName == _T("Dec") )
2761 mon = Dec;
2762 else
2763 {
2764 wxLogDebug(_T("Invalid RFC 822 month name '%s'"), monName.c_str());
2765
2766 return (wxChar *)NULL;
2767 }
2768
2769 p += 3;
2770
2771 if ( *p++ != _T(' ') )
2772 {
2773 return (wxChar *)NULL;
2774 }
2775
2776 // next is the year
2777 if ( !wxIsdigit(*p) )
2778 {
2779 // no year?
2780 return (wxChar *)NULL;
2781 }
2782
2783 int year = *p++ - _T('0');
2784
2785 if ( !wxIsdigit(*p) )
2786 {
2787 // should have at least 2 digits in the year
2788 return (wxChar *)NULL;
2789 }
2790
2791 year *= 10;
2792 year += *p++ - _T('0');
2793
2794 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
2795 if ( wxIsdigit(*p) )
2796 {
2797 year *= 10;
2798 year += *p++ - _T('0');
2799
2800 if ( !wxIsdigit(*p) )
2801 {
2802 // no 3 digit years please
2803 return (wxChar *)NULL;
2804 }
2805
2806 year *= 10;
2807 year += *p++ - _T('0');
2808 }
2809
2810 if ( *p++ != _T(' ') )
2811 {
2812 return (wxChar *)NULL;
2813 }
2814
2815 // time is in the format hh:mm:ss and seconds are optional
2816 if ( !wxIsdigit(*p) )
2817 {
2818 return (wxChar *)NULL;
2819 }
2820
42841dfc 2821 wxDateTime_t hour = (wxDateTime_t)(*p++ - _T('0'));
cd0b1709
VZ
2822
2823 if ( !wxIsdigit(*p) )
2824 {
2825 return (wxChar *)NULL;
2826 }
2827
2828 hour *= 10;
42841dfc 2829 hour = (wxDateTime_t)(hour + (*p++ - _T('0')));
cd0b1709
VZ
2830
2831 if ( *p++ != _T(':') )
2832 {
2833 return (wxChar *)NULL;
2834 }
2835
2836 if ( !wxIsdigit(*p) )
2837 {
2838 return (wxChar *)NULL;
2839 }
2840
42841dfc 2841 wxDateTime_t min = (wxDateTime_t)(*p++ - _T('0'));
cd0b1709
VZ
2842
2843 if ( !wxIsdigit(*p) )
2844 {
2845 return (wxChar *)NULL;
2846 }
2847
2848 min *= 10;
42841dfc 2849 min = (wxDateTime_t)(min + *p++ - _T('0'));
cd0b1709
VZ
2850
2851 wxDateTime_t sec = 0;
2852 if ( *p++ == _T(':') )
2853 {
2854 if ( !wxIsdigit(*p) )
2855 {
2856 return (wxChar *)NULL;
2857 }
2858
42841dfc 2859 sec = (wxDateTime_t)(*p++ - _T('0'));
cd0b1709
VZ
2860
2861 if ( !wxIsdigit(*p) )
2862 {
2863 return (wxChar *)NULL;
2864 }
2865
2866 sec *= 10;
42841dfc 2867 sec = (wxDateTime_t)(sec + *p++ - _T('0'));
cd0b1709
VZ
2868 }
2869
2870 if ( *p++ != _T(' ') )
2871 {
2872 return (wxChar *)NULL;
2873 }
2874
2875 // and now the interesting part: the timezone
ba9bbf13 2876 int offset wxDUMMY_INITIALIZE(0);
cd0b1709
VZ
2877 if ( *p == _T('-') || *p == _T('+') )
2878 {
2879 // the explicit offset given: it has the form of hhmm
2880 bool plus = *p++ == _T('+');
2881
2882 if ( !wxIsdigit(*p) || !wxIsdigit(*(p + 1)) )
2883 {
2884 return (wxChar *)NULL;
2885 }
2886
2887 // hours
d26adb9d 2888 offset = MIN_PER_HOUR*(10*(*p - _T('0')) + (*(p + 1) - _T('0')));
cd0b1709
VZ
2889
2890 p += 2;
2891
2892 if ( !wxIsdigit(*p) || !wxIsdigit(*(p + 1)) )
2893 {
2894 return (wxChar *)NULL;
2895 }
2896
2897 // minutes
2898 offset += 10*(*p - _T('0')) + (*(p + 1) - _T('0'));
2899
2900 if ( !plus )
2901 {
2902 offset = -offset;
2903 }
2904
2905 p += 2;
2906 }
2907 else
2908 {
2909 // the symbolic timezone given: may be either military timezone or one
2910 // of standard abbreviations
2911 if ( !*(p + 1) )
2912 {
2913 // military: Z = UTC, J unused, A = -1, ..., Y = +12
2914 static const int offsets[26] =
2915 {
2916 //A B C D E F G H I J K L M
2917 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
2918 //N O P R Q S T U V W Z Y Z
2919 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
2920 };
2921
2922 if ( *p < _T('A') || *p > _T('Z') || *p == _T('J') )
2923 {
2924 wxLogDebug(_T("Invalid militaty timezone '%c'"), *p);
2925
2926 return (wxChar *)NULL;
2927 }
2928
2929 offset = offsets[*p++ - _T('A')];
2930 }
2931 else
2932 {
2933 // abbreviation
2934 wxString tz = p;
2935 if ( tz == _T("UT") || tz == _T("UTC") || tz == _T("GMT") )
2936 offset = 0;
2937 else if ( tz == _T("AST") )
2938 offset = AST - GMT0;
2939 else if ( tz == _T("ADT") )
2940 offset = ADT - GMT0;
2941 else if ( tz == _T("EST") )
2942 offset = EST - GMT0;
2943 else if ( tz == _T("EDT") )
2944 offset = EDT - GMT0;
2945 else if ( tz == _T("CST") )
2946 offset = CST - GMT0;
2947 else if ( tz == _T("CDT") )
2948 offset = CDT - GMT0;
2949 else if ( tz == _T("MST") )
2950 offset = MST - GMT0;
2951 else if ( tz == _T("MDT") )
2952 offset = MDT - GMT0;
2953 else if ( tz == _T("PST") )
2954 offset = PST - GMT0;
2955 else if ( tz == _T("PDT") )
2956 offset = PDT - GMT0;
2957 else
2958 {
2959 wxLogDebug(_T("Unknown RFC 822 timezone '%s'"), p);
2960
2961 return (wxChar *)NULL;
2962 }
2963
2964 p += tz.length();
2965 }
96531a71 2966
cd0b1709 2967 // make it minutes
d26adb9d 2968 offset *= MIN_PER_HOUR;
cd0b1709
VZ
2969 }
2970
d26adb9d 2971 // the spec was correct, construct the date from the values we found
cd0b1709 2972 Set(day, mon, year, hour, min, sec);
18c9aebe 2973 MakeFromTimezone(TimeZone((wxDateTime_t)(offset*SEC_PER_MIN)));
cd0b1709
VZ
2974
2975 return p;
2976}
2977
64f9c100 2978#ifdef __WINDOWS__
e44501a0 2979
be4e7abf
VZ
2980// returns the string containing strftime() format used for short dates in the
2981// current locale or an empty string
2982static wxString GetLocaleDateFormat()
64f9c100 2983{
be4e7abf
VZ
2984 wxString fmtWX;
2985
05eb2d40
VZ
2986 // there is no setlocale() under Windows CE, so just always query the
2987 // system there
2988#ifndef __WXWINCE__
64f9c100 2989 if ( strcmp(setlocale(LC_ALL, NULL), "C") != 0 )
e44501a0 2990#endif
64f9c100
VS
2991 {
2992 // The locale was programatically set to non-C. We assume that this was
2993 // done using wxLocale, in which case thread's current locale is also
2994 // set to correct LCID value and we can use GetLocaleInfo to determine
2995 // the correct formatting string:
c5fe22f8
JS
2996#ifdef __WXWINCE__
2997 LCID lcid = LOCALE_USER_DEFAULT;
2998#else
64f9c100 2999 LCID lcid = GetThreadLocale();
c5fe22f8 3000#endif
be4e7abf
VZ
3001 // according to MSDN 80 chars is max allowed for short date format
3002 wxChar fmt[81];
3003 if ( ::GetLocaleInfo(lcid, LOCALE_SSHORTDATE, fmt, WXSIZEOF(fmt)) )
64f9c100 3004 {
be4e7abf
VZ
3005 wxChar chLast = _T('\0');
3006 size_t lastCount = 0;
3007 for ( const wxChar *p = fmt; /* NUL handled inside */; p++ )
64f9c100 3008 {
be4e7abf 3009 if ( *p == chLast )
64f9c100 3010 {
be4e7abf
VZ
3011 lastCount++;
3012 continue;
64f9c100 3013 }
be4e7abf
VZ
3014
3015 switch ( *p )
64f9c100 3016 {
be4e7abf
VZ
3017 // these characters come in groups, start counting them
3018 case _T('d'):
3019 case _T('M'):
3020 case _T('y'):
3021 case _T('g'):
3022 chLast = *p;
3023 lastCount = 1;
3024 break;
3025
3026 default:
3027 // first deal with any special characters we have had
3028 if ( lastCount )
3029 {
3030 switch ( chLast )
3031 {
3032 case _T('d'):
3033 switch ( lastCount )
3034 {
3035 case 1: // d
3036 case 2: // dd
3037 // these two are the same as we
3038 // don't distinguish between 1 and
3039 // 2 digits for days
3040 fmtWX += _T("%d");
3041 break;
3042
3043 case 3: // ddd
3044 fmtWX += _T("%a");
3045 break;
3046
3047 case 4: // dddd
3048 fmtWX += _T("%A");
3049 break;
3050
3051 default:
3052 wxFAIL_MSG( _T("too many 'd's") );
3053 }
3054 break;
3055
3056 case _T('M'):
3057 switch ( lastCount )
3058 {
3059 case 1: // M
3060 case 2: // MM
3061 // as for 'd' and 'dd' above
3062 fmtWX += _T("%m");
3063 break;
3064
3065 case 3:
3066 fmtWX += _T("%b");
3067 break;
3068
3069 case 4:
3070 fmtWX += _T("%B");
3071 break;
3072
3073 default:
3074 wxFAIL_MSG( _T("too many 'M's") );
3075 }
3076 break;
3077
3078 case _T('y'):
3079 switch ( lastCount )
3080 {
3081 case 1: // y
3082 case 2: // yy
3083 fmtWX += _T("%y");
3084 break;
3085
3086 case 4: // yyyy
3087 fmtWX += _T("%Y");
3088 break;
3089
3090 default:
3091 wxFAIL_MSG( _T("wrong number of 'y's") );
3092 }
3093 break;
3094
3095 case _T('g'):
3096 // strftime() doesn't have era string,
3097 // ignore this format
3098 wxASSERT_MSG( lastCount <= 2,
3099 _T("too many 'g's") );
3100 break;
3101
3102 default:
3103 wxFAIL_MSG( _T("unreachable") );
3104 }
3105
3106 chLast = _T('\0');
3107 lastCount = 0;
3108 }
3109
3110 // not a special character so must be just a separator,
3111 // treat as is
3112 if ( *p != _T('\0') )
3113 {
3114 if ( *p == _T('%') )
3115 {
3116 // this one needs to be escaped
3117 fmtWX += _T('%');
3118 }
3119
3120 fmtWX += *p;
3121 }
64f9c100 3122 }
be4e7abf
VZ
3123
3124 if ( *p == _T('\0') )
3125 break;
64f9c100
VS
3126 }
3127 }
be4e7abf
VZ
3128 //else: GetLocaleInfo() failed, leave fmtDate value unchanged and
3129 // try our luck with the default formats
64f9c100 3130 }
be4e7abf
VZ
3131 //else: default C locale, default formats should work
3132
3133 return fmtWX;
64f9c100 3134}
e44501a0 3135
64f9c100
VS
3136#endif // __WINDOWS__
3137
f0f951fa 3138const wxChar *wxDateTime::ParseFormat(const wxChar *date,
12e82477 3139 const wxString& format,
f0f951fa 3140 const wxDateTime& dateDef)
cd0b1709 3141{
12e82477 3142 wxCHECK_MSG( date && !format.empty(), (wxChar *)NULL,
f0f951fa 3143 _T("NULL pointer in wxDateTime::ParseFormat()") );
cd0b1709 3144
f0f951fa
VZ
3145 wxString str;
3146 unsigned long num;
cd0b1709 3147
f0f951fa 3148 // what fields have we found?
68379eaf
WS
3149 bool haveWDay = false,
3150 haveYDay = false,
3151 haveDay = false,
3152 haveMon = false,
3153 haveYear = false,
3154 haveHour = false,
3155 haveMin = false,
3156 haveSec = false;
3157
3158 bool hourIsIn12hFormat = false, // or in 24h one?
3159 isPM = false; // AM by default
f0f951fa
VZ
3160
3161 // and the value of the items we have (init them to get rid of warnings)
3162 wxDateTime_t sec = 0,
3163 min = 0,
3164 hour = 0;
3165 WeekDay wday = Inv_WeekDay;
3166 wxDateTime_t yday = 0,
3167 mday = 0;
3168 wxDateTime::Month mon = Inv_Month;
3169 int year = 0;
3170
3171 const wxChar *input = date;
12e82477 3172 for ( wxString::const_iterator fmt = format.begin(); fmt != format.end(); ++fmt )
f0f951fa
VZ
3173 {
3174 if ( *fmt != _T('%') )
3175 {
3176 if ( wxIsspace(*fmt) )
3177 {
3178 // a white space in the format string matches 0 or more white
3179 // spaces in the input
3180 while ( wxIsspace(*input) )
3181 {
3182 input++;
3183 }
3184 }
3185 else // !space
3186 {
3187 // any other character (not whitespace, not '%') must be
3188 // matched by itself in the input
3189 if ( *input++ != *fmt )
3190 {
3191 // no match
3192 return (wxChar *)NULL;
3193 }
3194 }
3195
3196 // done with this format char
3197 continue;
3198 }
3199
3200 // start of a format specification
f6bcfd97
BP
3201
3202 // parse the optional width
3203 size_t width = 0;
1c193821 3204 while ( wxIsdigit(*++fmt) )
f6bcfd97
BP
3205 {
3206 width *= 10;
3207 width += *fmt - _T('0');
3208 }
3209
4147efe9
VZ
3210 // the default widths for the various fields
3211 if ( !width )
3212 {
12e82477 3213 switch ( (*fmt).GetValue() )
4147efe9
VZ
3214 {
3215 case _T('Y'): // year has 4 digits
3216 width = 4;
3217 break;
3218
3219 case _T('j'): // day of year has 3 digits
3220 case _T('l'): // milliseconds have 3 digits
3221 width = 3;
3222 break;
3223
3224 case _T('w'): // week day as number has only one
3225 width = 1;
3226 break;
3227
3228 default:
3229 // default for all other fields
3230 width = 2;
3231 }
3232 }
3233
f6bcfd97 3234 // then the format itself
12e82477 3235 switch ( (*fmt).GetValue() )
f0f951fa
VZ
3236 {
3237 case _T('a'): // a weekday name
3238 case _T('A'):
3239 {
3240 int flag = *fmt == _T('a') ? Name_Abbr : Name_Full;
3241 wday = GetWeekDayFromName(GetAlphaToken(input), flag);
3242 if ( wday == Inv_WeekDay )
3243 {
3244 // no match
3245 return (wxChar *)NULL;
3246 }
3247 }
68379eaf 3248 haveWDay = true;
f0f951fa
VZ
3249 break;
3250
3251 case _T('b'): // a month name
3252 case _T('B'):
3253 {
3254 int flag = *fmt == _T('b') ? Name_Abbr : Name_Full;
3255 mon = GetMonthFromName(GetAlphaToken(input), flag);
3256 if ( mon == Inv_Month )
3257 {
3258 // no match
3259 return (wxChar *)NULL;
3260 }
3261 }
68379eaf 3262 haveMon = true;
f0f951fa
VZ
3263 break;
3264
3265 case _T('c'): // locale default date and time representation
3266 {
3267 wxDateTime dt;
3268
3269 // this is the format which corresponds to ctime() output
3270 // and strptime("%c") should parse it, so try it first
41acf5c0 3271 static const wxChar *fmtCtime = _T("%a %b %d %H:%M:%S %Y");
f0f951fa
VZ
3272
3273 const wxChar *result = dt.ParseFormat(input, fmtCtime);
3274 if ( !result )
3275 {
3276 result = dt.ParseFormat(input, _T("%x %X"));
3277 }
3278
3279 if ( !result )
3280 {
3281 result = dt.ParseFormat(input, _T("%X %x"));
3282 }
3283
3284 if ( !result )
3285 {
3286 // we've tried everything and still no match
3287 return (wxChar *)NULL;
3288 }
3289
be4017f8
VZ
3290 Tm tm = dt.GetTm();
3291
3292 haveDay = haveMon = haveYear =
68379eaf 3293 haveHour = haveMin = haveSec = true;
be4017f8
VZ
3294
3295 hour = tm.hour;
3296 min = tm.min;
3297 sec = tm.sec;
3298
3299 year = tm.year;
3300 mon = tm.mon;
3301 mday = tm.mday;
3302
f0f951fa
VZ
3303 input = result;
3304 }
3305 break;
3306
3307 case _T('d'): // day of a month (01-31)
f6bcfd97
BP
3308 if ( !GetNumericToken(width, input, &num) ||
3309 (num > 31) || (num < 1) )
f0f951fa
VZ
3310 {
3311 // no match
3312 return (wxChar *)NULL;
3313 }
3314
3315 // we can't check whether the day range is correct yet, will
3316 // do it later - assume ok for now
68379eaf 3317 haveDay = true;
f0f951fa
VZ
3318 mday = (wxDateTime_t)num;
3319 break;
5f287370 3320
f0f951fa 3321 case _T('H'): // hour in 24h format (00-23)
f6bcfd97 3322 if ( !GetNumericToken(width, input, &num) || (num > 23) )
f0f951fa
VZ
3323 {
3324 // no match
3325 return (wxChar *)NULL;
3326 }
3327
68379eaf 3328 haveHour = true;
f0f951fa
VZ
3329 hour = (wxDateTime_t)num;
3330 break;
3331
3332 case _T('I'): // hour in 12h format (01-12)
f6bcfd97 3333 if ( !GetNumericToken(width, input, &num) || !num || (num > 12) )
f0f951fa
VZ
3334 {
3335 // no match
3336 return (wxChar *)NULL;
3337 }
3338
68379eaf
WS
3339 haveHour = true;
3340 hourIsIn12hFormat = true;
479cd5de 3341 hour = (wxDateTime_t)(num % 12); // 12 should be 0
f0f951fa
VZ
3342 break;
3343
3344 case _T('j'): // day of the year
f6bcfd97 3345 if ( !GetNumericToken(width, input, &num) || !num || (num > 366) )
f0f951fa
VZ
3346 {
3347 // no match
3348 return (wxChar *)NULL;
3349 }
3350
68379eaf 3351 haveYDay = true;
f0f951fa
VZ
3352 yday = (wxDateTime_t)num;
3353 break;
3354
3355 case _T('m'): // month as a number (01-12)
f6bcfd97 3356 if ( !GetNumericToken(width, input, &num) || !num || (num > 12) )
f0f951fa
VZ
3357 {
3358 // no match
3359 return (wxChar *)NULL;
3360 }
3361
68379eaf 3362 haveMon = true;
be4017f8 3363 mon = (Month)(num - 1);
f0f951fa
VZ
3364 break;
3365
3366 case _T('M'): // minute as a decimal number (00-59)
f6bcfd97 3367 if ( !GetNumericToken(width, input, &num) || (num > 59) )
f0f951fa
VZ
3368 {
3369 // no match
3370 return (wxChar *)NULL;
3371 }
3372
68379eaf 3373 haveMin = true;
f0f951fa
VZ
3374 min = (wxDateTime_t)num;
3375 break;
3376
3377 case _T('p'): // AM or PM string
3378 {
3379 wxString am, pm, token = GetAlphaToken(input);
3380
3381 GetAmPmStrings(&am, &pm);
bb8a8478 3382 if (am.empty() && pm.empty())
0308fd61 3383 return (wxChar *)NULL; // no am/pm strings defined
f0f951fa
VZ
3384 if ( token.CmpNoCase(pm) == 0 )
3385 {
68379eaf 3386 isPM = true;
f0f951fa
VZ
3387 }
3388 else if ( token.CmpNoCase(am) != 0 )
3389 {
3390 // no match
3391 return (wxChar *)NULL;
3392 }
3393 }
3394 break;
3395
3396 case _T('r'): // time as %I:%M:%S %p
3397 {
3398 wxDateTime dt;
3399 input = dt.ParseFormat(input, _T("%I:%M:%S %p"));
3400 if ( !input )
3401 {
3402 // no match
3403 return (wxChar *)NULL;
3404 }
3405
68379eaf 3406 haveHour = haveMin = haveSec = true;
f0f951fa
VZ
3407
3408 Tm tm = dt.GetTm();
3409 hour = tm.hour;
3410 min = tm.min;
3411 sec = tm.sec;
3412 }
3413 break;
3414
3415 case _T('R'): // time as %H:%M
3416 {
3417 wxDateTime dt;
3418 input = dt.ParseFormat(input, _T("%H:%M"));
3419 if ( !input )
3420 {
3421 // no match
3422 return (wxChar *)NULL;
3423 }
3424
68379eaf 3425 haveHour = haveMin = true;
f0f951fa
VZ
3426
3427 Tm tm = dt.GetTm();
3428 hour = tm.hour;
3429 min = tm.min;
3430 }
7d3e806d 3431 break;
f0f951fa
VZ
3432
3433 case _T('S'): // second as a decimal number (00-61)
f6bcfd97 3434 if ( !GetNumericToken(width, input, &num) || (num > 61) )
f0f951fa
VZ
3435 {
3436 // no match
3437 return (wxChar *)NULL;
3438 }
3439
68379eaf 3440 haveSec = true;
f0f951fa
VZ
3441 sec = (wxDateTime_t)num;
3442 break;
3443
3444 case _T('T'): // time as %H:%M:%S
3445 {
3446 wxDateTime dt;
3447 input = dt.ParseFormat(input, _T("%H:%M:%S"));
3448 if ( !input )
3449 {
3450 // no match
3451 return (wxChar *)NULL;
3452 }
3453
68379eaf 3454 haveHour = haveMin = haveSec = true;
f0f951fa
VZ
3455
3456 Tm tm = dt.GetTm();
3457 hour = tm.hour;
3458 min = tm.min;
3459 sec = tm.sec;
3460 }
be4017f8 3461 break;
f0f951fa
VZ
3462
3463 case _T('w'): // weekday as a number (0-6), Sunday = 0
f6bcfd97 3464 if ( !GetNumericToken(width, input, &num) || (wday > 6) )
f0f951fa
VZ
3465 {
3466 // no match
3467 return (wxChar *)NULL;
3468 }
3469
68379eaf 3470 haveWDay = true;
f0f951fa
VZ
3471 wday = (WeekDay)num;
3472 break;
3473
3474 case _T('x'): // locale default date representation
3475#ifdef HAVE_STRPTIME
2423ef22 3476 // try using strptime() -- it may fail even if the input is
f0f951fa 3477 // correct but the date is out of range, so we will fall back
2423ef22 3478 // to our generic code anyhow
f0f951fa
VZ
3479 {
3480 struct tm tm;
2423ef22
VZ
3481
3482 const wxChar *result = CallStrptime(input, "%x", &tm);
f0f951fa
VZ
3483 if ( result )
3484 {
3485 input = result;
3486
68379eaf 3487 haveDay = haveMon = haveYear = true;
f0f951fa
VZ
3488
3489 year = 1900 + tm.tm_year;
3490 mon = (Month)tm.tm_mon;
3491 mday = tm.tm_mday;
3492
3493 break;
3494 }
3495 }
3496#endif // HAVE_STRPTIME
3497
f0f951fa
VZ
3498 {
3499 wxDateTime dt;
be4e7abf
VZ
3500 wxString fmtDate,
3501 fmtDateAlt;
f0f951fa 3502
64f9c100
VS
3503#ifdef __WINDOWS__
3504 // The above doesn't work for all locales, try to query
3505 // Windows for the right way of formatting the date:
be4e7abf
VZ
3506 fmtDate = GetLocaleDateFormat();
3507 if ( fmtDate.empty() )
64f9c100 3508#endif
be4e7abf
VZ
3509 {
3510 if ( IsWestEuropeanCountry(GetCountry()) ||
3511 GetCountry() == Russia )
3512 {
3513 fmtDate = _T("%d/%m/%y");
3514 fmtDateAlt = _T("%m/%d/%y");
3515 }
3516 else // assume USA
3517 {
3518 fmtDate = _T("%m/%d/%y");
3519 fmtDateAlt = _T("%d/%m/%y");
3520 }
3521 }
64f9c100 3522
f0f951fa 3523 const wxChar *result = dt.ParseFormat(input, fmtDate);
41acf5c0 3524
be4e7abf 3525 if ( !result && !fmtDateAlt.empty() )
41acf5c0
VZ
3526 {
3527 // ok, be nice and try another one
3528 result = dt.ParseFormat(input, fmtDateAlt);
3529 }
3530
f0f951fa
VZ
3531 if ( !result )
3532 {
3533 // bad luck
3534 return (wxChar *)NULL;
3535 }
3536
3537 Tm tm = dt.GetTm();
3538
68379eaf 3539 haveDay = haveMon = haveYear = true;
f0f951fa
VZ
3540
3541 year = tm.year;
3542 mon = tm.mon;
3543 mday = tm.mday;
3544
3545 input = result;
3546 }
3547
3548 break;
3549
3550 case _T('X'): // locale default time representation
3551#ifdef HAVE_STRPTIME
3552 {
3553 // use strptime() to do it for us (FIXME !Unicode friendly)
3554 struct tm tm;
2423ef22 3555 input = CallStrptime(input, "%X", &tm);
f0f951fa
VZ
3556 if ( !input )
3557 {
3558 return (wxChar *)NULL;
3559 }
3560
68379eaf 3561 haveHour = haveMin = haveSec = true;
f0f951fa
VZ
3562
3563 hour = tm.tm_hour;
3564 min = tm.tm_min;
3565 sec = tm.tm_sec;
3566 }
3567#else // !HAVE_STRPTIME
3568 // TODO under Win32 we can query the LOCALE_ITIME system
3569 // setting which says whether the default time format is
3570 // 24 or 12 hour
3571 {
3572 // try to parse what follows as "%H:%M:%S" and, if this
3573 // fails, as "%I:%M:%S %p" - this should catch the most
3574 // common cases
3575 wxDateTime dt;
3576
3577 const wxChar *result = dt.ParseFormat(input, _T("%T"));
3578 if ( !result )
3579 {
3580 result = dt.ParseFormat(input, _T("%r"));
3581 }
3582
3583 if ( !result )
3584 {
3585 // no match
3586 return (wxChar *)NULL;
3587 }
3588
68379eaf 3589 haveHour = haveMin = haveSec = true;
f0f951fa
VZ
3590
3591 Tm tm = dt.GetTm();
3592 hour = tm.hour;
3593 min = tm.min;
3594 sec = tm.sec;
3595
3596 input = result;
3597 }
3598#endif // HAVE_STRPTIME/!HAVE_STRPTIME
3599 break;
3600
3601 case _T('y'): // year without century (00-99)
f6bcfd97 3602 if ( !GetNumericToken(width, input, &num) || (num > 99) )
f0f951fa
VZ
3603 {
3604 // no match
3605 return (wxChar *)NULL;
3606 }
3607
68379eaf 3608 haveYear = true;
f6bcfd97
BP
3609
3610 // TODO should have an option for roll over date instead of
3611 // hard coding it here
3612 year = (num > 30 ? 1900 : 2000) + (wxDateTime_t)num;
f0f951fa
VZ
3613 break;
3614
3615 case _T('Y'): // year with century
f6bcfd97 3616 if ( !GetNumericToken(width, input, &num) )
f0f951fa
VZ
3617 {
3618 // no match
3619 return (wxChar *)NULL;
3620 }
3621
68379eaf 3622 haveYear = true;
be4017f8 3623 year = (wxDateTime_t)num;
f0f951fa
VZ
3624 break;
3625
3626 case _T('Z'): // timezone name
3627 wxFAIL_MSG(_T("TODO"));
3628 break;
3629
3630 case _T('%'): // a percent sign
3631 if ( *input++ != _T('%') )
3632 {
3633 // no match
3634 return (wxChar *)NULL;
3635 }
3636 break;
3637
3638 case 0: // the end of string
3639 wxFAIL_MSG(_T("unexpected format end"));
3640
3641 // fall through
3642
3643 default: // not a known format spec
3644 return (wxChar *)NULL;
3645 }
3646 }
3647
3648 // format matched, try to construct a date from what we have now
3649 Tm tmDef;
3650 if ( dateDef.IsValid() )
3651 {
3652 // take this date as default
3653 tmDef = dateDef.GetTm();
3654 }
c3302e7e 3655 else if ( IsValid() )
f0f951fa
VZ
3656 {
3657 // if this date is valid, don't change it
3658 tmDef = GetTm();
3659 }
3660 else
3661 {
3662 // no default and this date is invalid - fall back to Today()
3663 tmDef = Today().GetTm();
3664 }
3665
3666 Tm tm = tmDef;
3667
3668 // set the date
3669 if ( haveYear )
3670 {
3671 tm.year = year;
3672 }
3673
3674 // TODO we don't check here that the values are consistent, if both year
3675 // day and month/day were found, we just ignore the year day and we
3676 // also always ignore the week day
3677 if ( haveMon && haveDay )
3678 {
be4017f8
VZ
3679 if ( mday > GetNumOfDaysInMonth(tm.year, mon) )
3680 {
3681 wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
3682
3683 return (wxChar *)NULL;
3684 }
3685
f0f951fa
VZ
3686 tm.mon = mon;
3687 tm.mday = mday;
3688 }
3689 else if ( haveYDay )
3690 {
be4017f8
VZ
3691 if ( yday > GetNumberOfDays(tm.year) )
3692 {
3693 wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
3694
3695 return (wxChar *)NULL;
3696 }
3697
f0f951fa
VZ
3698 Tm tm2 = wxDateTime(1, Jan, tm.year).SetToYearDay(yday).GetTm();
3699
3700 tm.mon = tm2.mon;
3701 tm.mday = tm2.mday;
3702 }
3703
3704 // deal with AM/PM
3705 if ( haveHour && hourIsIn12hFormat && isPM )
3706 {
3707 // translate to 24hour format
3708 hour += 12;
3709 }
3710 //else: either already in 24h format or no translation needed
3711
3712 // set the time
3713 if ( haveHour )
3714 {
5f287370 3715 tm.hour = hour;
f0f951fa
VZ
3716 }
3717
3718 if ( haveMin )
3719 {
3720 tm.min = min;
3721 }
3722
3723 if ( haveSec )
3724 {
3725 tm.sec = sec;
3726 }
3727
3728 Set(tm);
3729
88a036ce
VZ
3730 // finally check that the week day is consistent -- if we had it
3731 if ( haveWDay && GetWeekDay() != wday )
3732 {
3733 wxLogDebug(_T("inconsistsnet week day in wxDateTime::ParseFormat()"));
3734
3735 return NULL;
3736 }
3737
f0f951fa 3738 return input;
cd0b1709
VZ
3739}
3740
3741const wxChar *wxDateTime::ParseDateTime(const wxChar *date)
3742{
3743 wxCHECK_MSG( date, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
3744
de07d200
VZ
3745 // Set to current day and hour, so strings like '14:00' becomes today at
3746 // 14, not some other random date
3747 wxDateTime dtDate = wxDateTime::Today();
3748 wxDateTime dtTime = wxDateTime::Today();
cd0b1709 3749
de07d200
VZ
3750 const wxChar* pchTime;
3751
3752 // Try to parse the beginning of the string as a date
3753 const wxChar* pchDate = dtDate.ParseDate(date);
3754
3755 // We got a date in the beginning, see if there is a time specified after the date
3756 if ( pchDate )
3757 {
3758 // Skip spaces, as the ParseTime() function fails on spaces
3759 while ( wxIsspace(*pchDate) )
3760 pchDate++;
3761
3762 pchTime = dtTime.ParseTime(pchDate);
3763 }
3764 else // no date in the beginning
3765 {
3766 // check and see if we have a time followed by a date
3767 pchTime = dtTime.ParseTime(date);
3768 if ( pchTime )
3769 {
3770 while ( wxIsspace(*pchTime) )
3771 pchTime++;
3772
3773 pchDate = dtDate.ParseDate(pchTime);
3774 }
3775 }
3776
3777 // If we have a date specified, set our own data to the same date
3778 if ( !pchDate || !pchTime )
3779 return NULL;
3780
3781 Set(dtDate.GetDay(), dtDate.GetMonth(), dtDate.GetYear(),
3782 dtTime.GetHour(), dtTime.GetMinute(), dtTime.GetSecond(),
3783 dtTime.GetMillisecond());
3784
3785 // Return endpoint of scan
3786 return pchDate > pchTime ? pchDate : pchTime;
cd0b1709
VZ
3787}
3788
3789const wxChar *wxDateTime::ParseDate(const wxChar *date)
3790{
3791 // this is a simplified version of ParseDateTime() which understands only
3792 // "today" (for wxDate compatibility) and digits only otherwise (and not
3793 // all esoteric constructions ParseDateTime() knows about)
3794
3795 wxCHECK_MSG( date, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
3796
3797 const wxChar *p = date;
3798 while ( wxIsspace(*p) )
3799 p++;
3800
fd9f9f4c
VZ
3801 // some special cases
3802 static struct
cd0b1709 3803 {
e6d4038a 3804 const char *str;
fd9f9f4c
VZ
3805 int dayDiffFromToday;
3806 } literalDates[] =
3807 {
3808 { wxTRANSLATE("today"), 0 },
3809 { wxTRANSLATE("yesterday"), -1 },
3810 { wxTRANSLATE("tomorrow"), 1 },
3811 };
3812
3813 for ( size_t n = 0; n < WXSIZEOF(literalDates); n++ )
3814 {
7a7bd38a
VZ
3815 const wxString dateStr = wxGetTranslation(literalDates[n].str);
3816 size_t len = dateStr.length();
907173e5 3817 if ( wxStrlen(p) >= len )
fd9f9f4c 3818 {
907173e5 3819 wxString str(p, len);
7a7bd38a 3820 if ( str.CmpNoCase(dateStr) == 0 )
fd9f9f4c 3821 {
907173e5
WS
3822 // nothing can follow this, so stop here
3823 p += len;
3824
3825 int dayDiffFromToday = literalDates[n].dayDiffFromToday;
3826 *this = Today();
3827 if ( dayDiffFromToday )
3828 {
3829 *this += wxDateSpan::Days(dayDiffFromToday);
3830 }
cd0b1709 3831
907173e5
WS
3832 return p;
3833 }
fd9f9f4c 3834 }
cd0b1709
VZ
3835 }
3836
3ca6a5f0
BP
3837 // We try to guess what we have here: for each new (numeric) token, we
3838 // determine if it can be a month, day or a year. Of course, there is an
3839 // ambiguity as some numbers may be days as well as months, so we also
3840 // have the ability to back track.
3841
cd0b1709 3842 // what do we have?
68379eaf
WS
3843 bool haveDay = false, // the months day?
3844 haveWDay = false, // the day of week?
3845 haveMon = false, // the month?
3846 haveYear = false; // the year?
cd0b1709
VZ
3847
3848 // and the value of the items we have (init them to get rid of warnings)
3849 WeekDay wday = Inv_WeekDay;
3850 wxDateTime_t day = 0;
3851 wxDateTime::Month mon = Inv_Month;
3852 int year = 0;
3853
3854 // tokenize the string
f6bcfd97 3855 size_t nPosCur = 0;
62ae2780 3856 static const wxChar *dateDelimiters = _T(".,/-\t\r\n ");
f6bcfd97 3857 wxStringTokenizer tok(p, dateDelimiters);
cd0b1709
VZ
3858 while ( tok.HasMoreTokens() )
3859 {
3860 wxString token = tok.GetNextToken();
3ca6a5f0
BP
3861 if ( !token )
3862 continue;
cd0b1709
VZ
3863
3864 // is it a number?
3865 unsigned long val;
fde5a86b 3866 if ( token.ToULong(&val) )
cd0b1709
VZ
3867 {
3868 // guess what this number is
3869
68379eaf
WS
3870 bool isDay = false,
3871 isMonth = false,
3872 isYear = false;
3ca6a5f0
BP
3873
3874 if ( !haveMon && val > 0 && val <= 12 )
cd0b1709 3875 {
3ca6a5f0 3876 // assume it is month
68379eaf 3877 isMonth = true;
3ca6a5f0
BP
3878 }
3879 else // not the month
3880 {
560e2916 3881 if ( haveDay )
cd0b1709 3882 {
560e2916 3883 // this can only be the year
68379eaf 3884 isYear = true;
cd0b1709 3885 }
560e2916 3886 else // may be either day or year
cd0b1709 3887 {
eca0692c
VZ
3888 // use a leap year if we don't have the year yet to allow
3889 // dates like 2/29/1976 which would be rejected otherwise
6a27c749 3890 wxDateTime_t max_days = (wxDateTime_t)(
42841dfc 3891 haveMon
eca0692c 3892 ? GetNumOfDaysInMonth(haveYear ? year : 1976, mon)
42841dfc
WS
3893 : 31
3894 );
560e2916
VZ
3895
3896 // can it be day?
6a27c749 3897 if ( (val == 0) || (val > (unsigned long)max_days) )
560e2916
VZ
3898 {
3899 // no
68379eaf 3900 isYear = true;
560e2916
VZ
3901 }
3902 else // yes, suppose it's the day
3903 {
68379eaf 3904 isDay = true;
560e2916 3905 }
cd0b1709
VZ
3906 }
3907 }
3908
cd0b1709
VZ
3909 if ( isYear )
3910 {
3911 if ( haveYear )
cd0b1709 3912 break;
cd0b1709 3913
68379eaf 3914 haveYear = true;
cd0b1709 3915
479cd5de 3916 year = (wxDateTime_t)val;
cd0b1709 3917 }
3ca6a5f0 3918 else if ( isDay )
cd0b1709 3919 {
3ca6a5f0 3920 if ( haveDay )
cd0b1709 3921 break;
cd0b1709 3922
68379eaf 3923 haveDay = true;
cd0b1709 3924
3ca6a5f0 3925 day = (wxDateTime_t)val;
cd0b1709 3926 }
3ca6a5f0 3927 else if ( isMonth )
cd0b1709 3928 {
68379eaf 3929 haveMon = true;
cd0b1709 3930
3ca6a5f0 3931 mon = (Month)(val - 1);
cd0b1709
VZ
3932 }
3933 }
3934 else // not a number
3935 {
f6bcfd97
BP
3936 // be careful not to overwrite the current mon value
3937 Month mon2 = GetMonthFromName(token, Name_Full | Name_Abbr);
3938 if ( mon2 != Inv_Month )
cd0b1709
VZ
3939 {
3940 // it's a month
3941 if ( haveMon )
3942 {
6411a32c
VZ
3943 // but we already have a month - maybe we guessed wrong?
3944 if ( !haveDay )
3945 {
f5cd9787 3946 // no need to check in month range as always < 12, but
6411a32c 3947 // the days are counted from 1 unlike the months
42841dfc 3948 day = (wxDateTime_t)(mon + 1);
68379eaf 3949 haveDay = true;
6411a32c
VZ
3950 }
3951 else
3952 {
3953 // could possible be the year (doesn't the year come
3954 // before the month in the japanese format?) (FIXME)
3955 break;
f5cd9787 3956 }
cd0b1709
VZ
3957 }
3958
f6bcfd97
BP
3959 mon = mon2;
3960
68379eaf 3961 haveMon = true;
cd0b1709 3962 }
6411a32c 3963 else // not a valid month name
cd0b1709 3964 {
f0f951fa 3965 wday = GetWeekDayFromName(token, Name_Full | Name_Abbr);
cd0b1709
VZ
3966 if ( wday != Inv_WeekDay )
3967 {
3968 // a week day
3969 if ( haveWDay )
3970 {
3971 break;
3972 }
3973
68379eaf 3974 haveWDay = true;
cd0b1709 3975 }
6411a32c 3976 else // not a valid weekday name
cd0b1709
VZ
3977 {
3978 // try the ordinals
e6d4038a 3979 static const char *ordinals[] =
cd0b1709
VZ
3980 {
3981 wxTRANSLATE("first"),
3982 wxTRANSLATE("second"),
3983 wxTRANSLATE("third"),
3984 wxTRANSLATE("fourth"),
3985 wxTRANSLATE("fifth"),
3986 wxTRANSLATE("sixth"),
3987 wxTRANSLATE("seventh"),
3988 wxTRANSLATE("eighth"),
3989 wxTRANSLATE("ninth"),
3990 wxTRANSLATE("tenth"),
3991 wxTRANSLATE("eleventh"),
3992 wxTRANSLATE("twelfth"),
3993 wxTRANSLATE("thirteenth"),
3994 wxTRANSLATE("fourteenth"),
3995 wxTRANSLATE("fifteenth"),
3996 wxTRANSLATE("sixteenth"),
3997 wxTRANSLATE("seventeenth"),
3998 wxTRANSLATE("eighteenth"),
3999 wxTRANSLATE("nineteenth"),
4000 wxTRANSLATE("twentieth"),
4001 // that's enough - otherwise we'd have problems with
6411a32c 4002 // composite (or not) ordinals
cd0b1709
VZ
4003 };
4004
4005 size_t n;
4006 for ( n = 0; n < WXSIZEOF(ordinals); n++ )
4007 {
4008 if ( token.CmpNoCase(ordinals[n]) == 0 )
4009 {
4010 break;
4011 }
4012 }
4013
4014 if ( n == WXSIZEOF(ordinals) )
4015 {
4016 // stop here - something unknown
4017 break;
4018 }
4019
4020 // it's a day
4021 if ( haveDay )
4022 {
4023 // don't try anything here (as in case of numeric day
4024 // above) - the symbolic day spec should always
4025 // precede the month/year
4026 break;
4027 }
4028
68379eaf 4029 haveDay = true;
cd0b1709 4030
33ac7e6f 4031 day = (wxDateTime_t)(n + 1);
cd0b1709
VZ
4032 }
4033 }
4034 }
f6bcfd97
BP
4035
4036 nPosCur = tok.GetPosition();
cd0b1709
VZ
4037 }
4038
4039 // either no more tokens or the scan was stopped by something we couldn't
4040 // parse - in any case, see if we can construct a date from what we have
4041 if ( !haveDay && !haveWDay )
4042 {
f6bcfd97 4043 wxLogDebug(_T("ParseDate: no day, no weekday hence no date."));
cd0b1709 4044
eca0692c 4045 return NULL;
cd0b1709
VZ
4046 }
4047
4048 if ( haveWDay && (haveMon || haveYear || haveDay) &&
f6bcfd97 4049 !(haveDay && haveMon && haveYear) )
cd0b1709
VZ
4050 {
4051 // without adjectives (which we don't support here) the week day only
4052 // makes sense completely separately or with the full date
4053 // specification (what would "Wed 1999" mean?)
eca0692c 4054 return NULL;
cd0b1709
VZ
4055 }
4056
f6bcfd97
BP
4057 if ( !haveWDay && haveYear && !(haveDay && haveMon) )
4058 {
4059 // may be we have month and day instead of day and year?
4060 if ( haveDay && !haveMon )
4061 {
4062 if ( day <= 12 )
4063 {
4064 // exchange day and month
4065 mon = (wxDateTime::Month)(day - 1);
4066
4067 // we're in the current year then
196be0f1 4068 if ( (year > 0) && (year <= (int)GetNumOfDaysInMonth(Inv_Year, mon)) )
f6bcfd97 4069 {
42841dfc 4070 day = (wxDateTime_t)year;
f6bcfd97 4071
68379eaf
WS
4072 haveMon = true;
4073 haveYear = false;
f6bcfd97 4074 }
68379eaf 4075 //else: no, can't exchange, leave haveMon == false
f6bcfd97
BP
4076 }
4077 }
4078
4079 if ( !haveMon )
4080 {
4081 // if we give the year, month and day must be given too
4082 wxLogDebug(_T("ParseDate: day and month should be specified if year is."));
4083
eca0692c 4084 return NULL;
f6bcfd97
BP
4085 }
4086 }
4087
cd0b1709
VZ
4088 if ( !haveMon )
4089 {
4090 mon = GetCurrentMonth();
4091 }
4092
4093 if ( !haveYear )
4094 {
4095 year = GetCurrentYear();
4096 }
4097
4098 if ( haveDay )
4099 {
eca0692c
VZ
4100 // normally we check the day above but the check is optimistic in case
4101 // we find the day before its month/year so we have to redo it now
4102 if ( day > GetNumOfDaysInMonth(year, mon) )
4103 return NULL;
4104
cd0b1709
VZ
4105 Set(day, mon, year);
4106
4107 if ( haveWDay )
4108 {
4109 // check that it is really the same
4110 if ( GetWeekDay() != wday )
4111 {
4112 // inconsistency detected
f6bcfd97
BP
4113 wxLogDebug(_T("ParseDate: inconsistent day/weekday."));
4114
cd0b1709
VZ
4115 return (wxChar *)NULL;
4116 }
4117 }
4118 }
4119 else // haveWDay
4120 {
4121 *this = Today();
4122
4123 SetToWeekDayInSameWeek(wday);
4124 }
4125
f6bcfd97
BP
4126 // return the pointer to the first unparsed char
4127 p += nPosCur;
4128 if ( nPosCur && wxStrchr(dateDelimiters, *(p - 1)) )
4129 {
4130 // if we couldn't parse the token after the delimiter, put back the
4131 // delimiter as well
4132 p--;
4133 }
4134
4135 return p;
cd0b1709
VZ
4136}
4137
4138const wxChar *wxDateTime::ParseTime(const wxChar *time)
4139{
4140 wxCHECK_MSG( time, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
4141
f0f951fa
VZ
4142 // first try some extra things
4143 static const struct
4144 {
e6d4038a 4145 const char *name;
f0f951fa
VZ
4146 wxDateTime_t hour;
4147 } stdTimes[] =
4148 {
4149 { wxTRANSLATE("noon"), 12 },
4150 { wxTRANSLATE("midnight"), 00 },
4151 // anything else?
4152 };
cd0b1709 4153
f0f951fa
VZ
4154 for ( size_t n = 0; n < WXSIZEOF(stdTimes); n++ )
4155 {
4156 wxString timeString = wxGetTranslation(stdTimes[n].name);
4157 size_t len = timeString.length();
4158 if ( timeString.CmpNoCase(wxString(time, len)) == 0 )
4159 {
4ded51f2
CE
4160 // casts required by DigitalMars
4161 Set(stdTimes[n].hour, wxDateTime_t(0), wxDateTime_t(0));
f0f951fa
VZ
4162
4163 return time + len;
4164 }
4165 }
4166
c7f9a482
VZ
4167 // try all time formats we may think about in the order from longest to
4168 // shortest
4169
4170 // 12hour with AM/PM?
4171 const wxChar *result = ParseFormat(time, _T("%I:%M:%S %p"));
4172
f0f951fa
VZ
4173 if ( !result )
4174 {
4175 // normally, it's the same, but why not try it?
4176 result = ParseFormat(time, _T("%H:%M:%S"));
4177 }
4178
4179 if ( !result )
4180 {
c7f9a482
VZ
4181 // 12hour with AM/PM but without seconds?
4182 result = ParseFormat(time, _T("%I:%M %p"));
f0f951fa
VZ
4183 }
4184
4185 if ( !result )
4186 {
4187 // without seconds?
4188 result = ParseFormat(time, _T("%H:%M"));
4189 }
4190
4191 if ( !result )
4192 {
c7f9a482
VZ
4193 // just the hour and AM/PM?
4194 result = ParseFormat(time, _T("%I %p"));
f0f951fa
VZ
4195 }
4196
4197 if ( !result )
4198 {
4199 // just the hour?
4200 result = ParseFormat(time, _T("%H"));
4201 }
4202
4203 if ( !result )
4204 {
c7f9a482
VZ
4205 // parse the standard format: normally it is one of the formats above
4206 // but it may be set to something completely different by the user
4207 result = ParseFormat(time, _T("%X"));
f0f951fa
VZ
4208 }
4209
4210 // TODO: parse timezones
4211
4212 return result;
cd0b1709
VZ
4213}
4214
4f6aed9c
VZ
4215// ----------------------------------------------------------------------------
4216// Workdays and holidays support
4217// ----------------------------------------------------------------------------
4218
4219bool wxDateTime::IsWorkDay(Country WXUNUSED(country)) const
4220{
4221 return !wxDateTimeHolidayAuthority::IsHoliday(*this);
4222}
4223
26364344
WS
4224// ============================================================================
4225// wxDateSpan
4226// ============================================================================
4227
4228wxDateSpan WXDLLIMPEXP_BASE operator*(int n, const wxDateSpan& ds)
4229{
4230 wxDateSpan ds1(ds);
4231 return ds1.Multiply(n);
4232}
4233
fcc3d7cb
VZ
4234// ============================================================================
4235// wxTimeSpan
4236// ============================================================================
4237
26364344
WS
4238wxTimeSpan WXDLLIMPEXP_BASE operator*(int n, const wxTimeSpan& ts)
4239{
4240 return wxTimeSpan(ts).Multiply(n);
4241}
4242
033400eb
VZ
4243// this enum is only used in wxTimeSpan::Format() below but we can't declare
4244// it locally to the method as it provokes an internal compiler error in egcs
4245// 2.91.60 when building with -O2
4246enum TimeSpanPart
4247{
4248 Part_Week,
4249 Part_Day,
4250 Part_Hour,
4251 Part_Min,
4252 Part_Sec,
4253 Part_MSec
4254};
4255
e6ec579c
VZ
4256// not all strftime(3) format specifiers make sense here because, for example,
4257// a time span doesn't have a year nor a timezone
4258//
4259// Here are the ones which are supported (all of them are supported by strftime
4260// as well):
4261// %H hour in 24 hour format
4262// %M minute (00 - 59)
4263// %S second (00 - 59)
4264// %% percent sign
4265//
4266// Also, for MFC CTimeSpan compatibility, we support
4267// %D number of days
4268//
4269// And, to be better than MFC :-), we also have
4270// %E number of wEeks
4271// %l milliseconds (000 - 999)
12e82477 4272wxString wxTimeSpan::Format(const wxString& format) const
fcc3d7cb 4273{
12e82477
VS
4274 wxCHECK_MSG( !format.empty(), wxEmptyString,
4275 _T("NULL format in wxTimeSpan::Format") );
fcc3d7cb
VZ
4276
4277 wxString str;
12e82477 4278 str.Alloc(format.length());
e6ec579c 4279
df05cdc5
VZ
4280 // Suppose we have wxTimeSpan ts(1 /* hour */, 2 /* min */, 3 /* sec */)
4281 //
4282 // Then, of course, ts.Format("%H:%M:%S") must return "01:02:03", but the
4283 // question is what should ts.Format("%S") do? The code here returns "3273"
4284 // in this case (i.e. the total number of seconds, not just seconds % 60)
4285 // because, for me, this call means "give me entire time interval in
4286 // seconds" and not "give me the seconds part of the time interval"
4287 //
4288 // If we agree that it should behave like this, it is clear that the
4289 // interpretation of each format specifier depends on the presence of the
4290 // other format specs in the string: if there was "%H" before "%M", we
4291 // should use GetMinutes() % 60, otherwise just GetMinutes() &c
4292
4293 // we remember the most important unit found so far
033400eb 4294 TimeSpanPart partBiggest = Part_MSec;
df05cdc5 4295
12e82477 4296 for ( wxString::const_iterator pch = format.begin(); pch != format.end(); ++pch )
e6ec579c
VZ
4297 {
4298 wxChar ch = *pch;
4299
f6bcfd97 4300 if ( ch == _T('%') )
e6ec579c 4301 {
df05cdc5 4302 // the start of the format specification of the printf() below
e566ccf1 4303 wxString fmtPrefix(_T('%'));
df05cdc5
VZ
4304
4305 // the number
4306 long n;
e6ec579c 4307
e566ccf1
VZ
4308 // the number of digits for the format string, 0 if unused
4309 unsigned digits = 0;
4310
f6bcfd97 4311 ch = *++pch; // get the format spec char
e6ec579c
VZ
4312 switch ( ch )
4313 {
4314 default:
4315 wxFAIL_MSG( _T("invalid format character") );
4316 // fall through
4317
f6bcfd97 4318 case _T('%'):
df05cdc5
VZ
4319 str += ch;
4320
4321 // skip the part below switch
4322 continue;
e6ec579c 4323
f6bcfd97 4324 case _T('D'):
df05cdc5
VZ
4325 n = GetDays();
4326 if ( partBiggest < Part_Day )
4327 {
4328 n %= DAYS_PER_WEEK;
4329 }
4330 else
4331 {
4332 partBiggest = Part_Day;
4333 }
e6ec579c
VZ
4334 break;
4335
f6bcfd97 4336 case _T('E'):
df05cdc5
VZ
4337 partBiggest = Part_Week;
4338 n = GetWeeks();
e6ec579c
VZ
4339 break;
4340
f6bcfd97 4341 case _T('H'):
df05cdc5
VZ
4342 n = GetHours();
4343 if ( partBiggest < Part_Hour )
4344 {
e566ccf1
VZ
4345 if ( n < 0 )
4346 {
4347 // the sign has already been taken into account
4348 // when outputting the biggest part
4349 n = -n;
4350 }
4351
df05cdc5
VZ
4352 n %= HOURS_PER_DAY;
4353 }
4354 else
4355 {
4356 partBiggest = Part_Hour;
4357 }
4358
e566ccf1 4359 digits = 2;
e6ec579c
VZ
4360 break;
4361
f6bcfd97 4362 case _T('l'):
df05cdc5
VZ
4363 n = GetMilliseconds().ToLong();
4364 if ( partBiggest < Part_MSec )
4365 {
e566ccf1
VZ
4366 if ( n < 0 )
4367 n = -n;
4368
df05cdc5
VZ
4369 n %= 1000;
4370 }
4371 //else: no need to reset partBiggest to Part_MSec, it is
4372 // the least significant one anyhow
4373
e566ccf1 4374 digits = 3;
e6ec579c
VZ
4375 break;
4376
f6bcfd97 4377 case _T('M'):
df05cdc5
VZ
4378 n = GetMinutes();
4379 if ( partBiggest < Part_Min )
4380 {
e566ccf1
VZ
4381 if ( n < 0 )
4382 n = -n;
4383
df05cdc5
VZ
4384 n %= MIN_PER_HOUR;
4385 }
4386 else
4387 {
4388 partBiggest = Part_Min;
4389 }
4390
e566ccf1 4391 digits = 2;
e6ec579c
VZ
4392 break;
4393
f6bcfd97 4394 case _T('S'):
df05cdc5
VZ
4395 n = GetSeconds().ToLong();
4396 if ( partBiggest < Part_Sec )
4397 {
e566ccf1
VZ
4398 if ( n < 0 )
4399 n = -n;
4400
df05cdc5
VZ
4401 n %= SEC_PER_MIN;
4402 }
4403 else
4404 {
4405 partBiggest = Part_Sec;
4406 }
4407
e566ccf1 4408 digits = 2;
e6ec579c
VZ
4409 break;
4410 }
4411
e566ccf1
VZ
4412 if ( digits )
4413 {
4414 // negative numbers need one extra position for '-' display
4415 if ( n < 0 )
4416 digits++;
4417
4418 fmtPrefix << _T("0") << digits;
4419 }
4420
df05cdc5
VZ
4421 str += wxString::Format(fmtPrefix + _T("ld"), n);
4422 }
4423 else
4424 {
4425 // normal character, just copy
4426 str += ch;
e6ec579c 4427 }
e6ec579c 4428 }
fcc3d7cb
VZ
4429
4430 return str;
4431}
4f6aed9c
VZ
4432
4433// ============================================================================
4434// wxDateTimeHolidayAuthority and related classes
4435// ============================================================================
4436
4437#include "wx/arrimpl.cpp"
4438
4115960d 4439WX_DEFINE_OBJARRAY(wxDateTimeArray)
4f6aed9c
VZ
4440
4441static int wxCMPFUNC_CONV
4442wxDateTimeCompareFunc(wxDateTime **first, wxDateTime **second)
4443{
4444 wxDateTime dt1 = **first,
4445 dt2 = **second;
4446
4447 return dt1 == dt2 ? 0 : dt1 < dt2 ? -1 : +1;
4448}
4449
4450// ----------------------------------------------------------------------------
4451// wxDateTimeHolidayAuthority
4452// ----------------------------------------------------------------------------
4453
4454wxHolidayAuthoritiesArray wxDateTimeHolidayAuthority::ms_authorities;
4455
4456/* static */
4457bool wxDateTimeHolidayAuthority::IsHoliday(const wxDateTime& dt)
4458{
df5168c4 4459 size_t count = ms_authorities.size();
4f6aed9c
VZ
4460 for ( size_t n = 0; n < count; n++ )
4461 {
4462 if ( ms_authorities[n]->DoIsHoliday(dt) )
4463 {
68379eaf 4464 return true;
4f6aed9c
VZ
4465 }
4466 }
4467
68379eaf 4468 return false;
4f6aed9c
VZ
4469}
4470
4471/* static */
4472size_t
4473wxDateTimeHolidayAuthority::GetHolidaysInRange(const wxDateTime& dtStart,
4474 const wxDateTime& dtEnd,
4475 wxDateTimeArray& holidays)
4476{
4477 wxDateTimeArray hol;
4478
df5168c4 4479 holidays.Clear();
4f6aed9c 4480
7a7bd38a
VZ
4481 const size_t countAuth = ms_authorities.size();
4482 for ( size_t nAuth = 0; nAuth < countAuth; nAuth++ )
4f6aed9c 4483 {
6dc6fda6 4484 ms_authorities[nAuth]->DoGetHolidaysInRange(dtStart, dtEnd, hol);
4f6aed9c
VZ
4485
4486 WX_APPEND_ARRAY(holidays, hol);
4487 }
4488
4489 holidays.Sort(wxDateTimeCompareFunc);
4490
df5168c4 4491 return holidays.size();
4f6aed9c
VZ
4492}
4493
4494/* static */
4495void wxDateTimeHolidayAuthority::ClearAllAuthorities()
4496{
4497 WX_CLEAR_ARRAY(ms_authorities);
4498}
4499
4500/* static */
4501void wxDateTimeHolidayAuthority::AddAuthority(wxDateTimeHolidayAuthority *auth)
4502{
df5168c4 4503 ms_authorities.push_back(auth);
4f6aed9c
VZ
4504}
4505
5e233068
WS
4506wxDateTimeHolidayAuthority::~wxDateTimeHolidayAuthority()
4507{
4508 // required here for Darwin
4509}
4510
4f6aed9c
VZ
4511// ----------------------------------------------------------------------------
4512// wxDateTimeWorkDays
4513// ----------------------------------------------------------------------------
4514
4515bool wxDateTimeWorkDays::DoIsHoliday(const wxDateTime& dt) const
4516{
4517 wxDateTime::WeekDay wd = dt.GetWeekDay();
4518
4519 return (wd == wxDateTime::Sun) || (wd == wxDateTime::Sat);
4520}
4521
4522size_t wxDateTimeWorkDays::DoGetHolidaysInRange(const wxDateTime& dtStart,
4523 const wxDateTime& dtEnd,
4524 wxDateTimeArray& holidays) const
4525{
4526 if ( dtStart > dtEnd )
4527 {
4528 wxFAIL_MSG( _T("invalid date range in GetHolidaysInRange") );
4529
4530 return 0u;
4531 }
4532
4533 holidays.Empty();
4534
4535 // instead of checking all days, start with the first Sat after dtStart and
4536 // end with the last Sun before dtEnd
4537 wxDateTime dtSatFirst = dtStart.GetNextWeekDay(wxDateTime::Sat),
4538 dtSatLast = dtEnd.GetPrevWeekDay(wxDateTime::Sat),
4539 dtSunFirst = dtStart.GetNextWeekDay(wxDateTime::Sun),
4540 dtSunLast = dtEnd.GetPrevWeekDay(wxDateTime::Sun),
4541 dt;
4542
4543 for ( dt = dtSatFirst; dt <= dtSatLast; dt += wxDateSpan::Week() )
4544 {
4545 holidays.Add(dt);
4546 }
4547
4548 for ( dt = dtSunFirst; dt <= dtSunLast; dt += wxDateSpan::Week() )
4549 {
4550 holidays.Add(dt);
4551 }
4552
4553 return holidays.GetCount();
4554}
3e0b743f 4555
26364344
WS
4556// ============================================================================
4557// other helper functions
4558// ============================================================================
4559
4560// ----------------------------------------------------------------------------
4561// iteration helpers: can be used to write a for loop over enum variable like
4562// this:
4563// for ( m = wxDateTime::Jan; m < wxDateTime::Inv_Month; wxNextMonth(m) )
4564// ----------------------------------------------------------------------------
4565
4566WXDLLIMPEXP_BASE void wxNextMonth(wxDateTime::Month& m)
4567{
4568 wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") );
4569
4570 // no wrapping or the for loop above would never end!
4571 m = (wxDateTime::Month)(m + 1);
4572}
4573
4574WXDLLIMPEXP_BASE void wxPrevMonth(wxDateTime::Month& m)
4575{
4576 wxASSERT_MSG( m < wxDateTime::Inv_Month, _T("invalid month") );
4577
4578 m = m == wxDateTime::Jan ? wxDateTime::Inv_Month
4579 : (wxDateTime::Month)(m - 1);
4580}
4581
4582WXDLLIMPEXP_BASE void wxNextWDay(wxDateTime::WeekDay& wd)
4583{
4584 wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") );
4585
4586 // no wrapping or the for loop above would never end!
4587 wd = (wxDateTime::WeekDay)(wd + 1);
4588}
4589
4590WXDLLIMPEXP_BASE void wxPrevWDay(wxDateTime::WeekDay& wd)
4591{
4592 wxASSERT_MSG( wd < wxDateTime::Inv_WeekDay, _T("invalid week day") );
4593
4594 wd = wd == wxDateTime::Sun ? wxDateTime::Inv_WeekDay
4595 : (wxDateTime::WeekDay)(wd - 1);
4596}
4597
1e6feb95 4598#endif // wxUSE_DATETIME