]> git.saurik.com Git - wxWidgets.git/blob - src/common/datetimefmt.cpp
projects / wxWidgets.git / blob
? search:


9f81e2d83c07a62a3b6ba3ccd0a01a8b7b2b754a
[wxWidgets.git] / src / common / datetimefmt.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/datetimefmt.cpp
3 // Purpose: wxDateTime formatting & parsing code
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 11.05.99
7 // RCS-ID: $Id$
8 // Copyright: (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // parts of code taken from sndcal library by Scott E. Lee:
10 //
11 // Copyright 1993-1995, Scott E. Lee, all rights reserved.
12 // Permission granted to use, copy, modify, distribute and sell
13 // so long as the above copyright and this permission statement
14 // are retained in all copies.
15 //
16 // Licence: wxWindows licence
17 ///////////////////////////////////////////////////////////////////////////////
18
19 // ============================================================================
20 // declarations
21 // ============================================================================
22
23 // ----------------------------------------------------------------------------
24 // headers
25 // ----------------------------------------------------------------------------
26
27 // For compilers that support precompilation, includes "wx.h".
28 #include "wx/wxprec.h"
29
30 #ifdef __BORLANDC__
31 #pragma hdrstop
32 #endif
33
34 #if !defined(wxUSE_DATETIME) || wxUSE_DATETIME
35
36 #ifndef WX_PRECOMP
37 #ifdef __WXMSW__
38 #include "wx/msw/wrapwin.h"
39 #endif
40 #include "wx/string.h"
41 #include "wx/log.h"
42 #include "wx/intl.h"
43 #include "wx/stopwatch.h" // for wxGetLocalTimeMillis()
44 #include "wx/module.h"
45 #include "wx/crt.h"
46 #endif // WX_PRECOMP
47
48 #include "wx/thread.h"
49 #include "wx/tokenzr.h"
50
51 #include <ctype.h>
52
53 #ifdef __WINDOWS__
54 #include <winnls.h>
55 #ifndef __WXWINCE__
56 #include <locale.h>
57 #endif
58 #endif
59
60 #include "wx/datetime.h"
61
62 // ============================================================================
63 // implementation of wxDateTime
64 // ============================================================================
65
66 // ----------------------------------------------------------------------------
67 // helpers shared between datetime.cpp and datetimefmt.cpp
68 // ----------------------------------------------------------------------------
69
70 extern void InitTm(struct tm& tm);
71
72 extern int GetTimeZone();
73
74 extern wxString CallStrftime(const wxString& format, const tm* tm);
75
76 // ----------------------------------------------------------------------------
77 // constants (see also datetime.cpp)
78 // ----------------------------------------------------------------------------
79
80 static const int DAYS_PER_WEEK = 7;
81
82 static const int HOURS_PER_DAY = 24;
83
84 static const int SEC_PER_MIN = 60;
85
86 static const int MIN_PER_HOUR = 60;
87
88 // ----------------------------------------------------------------------------
89 // parsing helpers
90 // ----------------------------------------------------------------------------
91
92 namespace
93 {
94
95 enum
96 {
97 DateLang_English = 1,
98 DateLang_Local = 2
99 };
100
101 // return the month if the string is a month name or Inv_Month otherwise
102 //
103 // flags can contain wxDateTime::Name_Abbr/Name_Full or both of them and lang
104 // can be either DateLang_Local (default) to interpret string as a localized
105 // month name or DateLang_English to parse it as a standard English name or
106 // their combination to interpret it in any way
107 wxDateTime::Month
108 GetMonthFromName(const wxString& name, int flags, int lang)
109 {
110 wxDateTime::Month mon;
111 for ( mon = wxDateTime::Jan; mon < wxDateTime::Inv_Month; wxNextMonth(mon) )
112 {
113 // case-insensitive comparison either one of or with both abbreviated
114 // and not versions
115 if ( flags & wxDateTime::Name_Full )
116 {
117 if ( lang & DateLang_English )
118 {
119 if ( name.CmpNoCase(wxDateTime::GetEnglishMonthName(mon,
120 wxDateTime::Name_Full)) == 0 )
121 break;
122 }
123
124 if ( lang & DateLang_Local )
125 {
126 if ( name.CmpNoCase(wxDateTime::GetMonthName(mon,
127 wxDateTime::Name_Full)) == 0 )
128 break;
129 }
130 }
131
132 if ( flags & wxDateTime::Name_Abbr )
133 {
134 if ( lang & DateLang_English )
135 {
136 if ( name.CmpNoCase(wxDateTime::GetEnglishMonthName(mon,
137 wxDateTime::Name_Abbr)) == 0 )
138 break;
139 }
140
141 if ( lang & DateLang_Local )
142 {
143 if ( name.CmpNoCase(wxDateTime::GetMonthName(mon,
144 wxDateTime::Name_Abbr)) == 0 )
145 break;
146 }
147 }
148 }
149
150 return mon;
151 }
152
153 // return the weekday if the string is a weekday name or Inv_WeekDay otherwise
154 //
155 // flags and lang parameters have the same meaning as for GetMonthFromName()
156 // above
157 wxDateTime::WeekDay
158 GetWeekDayFromName(const wxString& name, int flags, int lang)
159 {
160 wxDateTime::WeekDay wd;
161 for ( wd = wxDateTime::Sun; wd < wxDateTime::Inv_WeekDay; wxNextWDay(wd) )
162 {
163 if ( flags & wxDateTime::Name_Full )
164 {
165 if ( lang & DateLang_English )
166 {
167 if ( name.CmpNoCase(wxDateTime::GetEnglishWeekDayName(wd,
168 wxDateTime::Name_Full)) == 0 )
169 break;
170 }
171
172 if ( lang & DateLang_Local )
173 {
174 if ( name.CmpNoCase(wxDateTime::GetWeekDayName(wd,
175 wxDateTime::Name_Full)) == 0 )
176 break;
177 }
178 }
179
180 if ( flags & wxDateTime::Name_Abbr )
181 {
182 if ( lang & DateLang_English )
183 {
184 if ( name.CmpNoCase(wxDateTime::GetEnglishWeekDayName(wd,
185 wxDateTime::Name_Abbr)) == 0 )
186 break;
187 }
188
189 if ( lang & DateLang_Local )
190 {
191 if ( name.CmpNoCase(wxDateTime::GetWeekDayName(wd,
192 wxDateTime::Name_Abbr)) == 0 )
193 break;
194 }
195 }
196 }
197
198 return wd;
199 }
200
201 // scans all digits (but no more than len) and returns the resulting number
202 bool GetNumericToken(size_t len,
203 wxString::const_iterator& p,
204 const wxString::const_iterator& end,
205 unsigned long *number)
206 {
207 size_t n = 1;
208 wxString s;
209 while ( p != end && wxIsdigit(*p) )
210 {
211 s += *p++;
212
213 if ( len && ++n > len )
214 break;
215 }
216
217 return !s.empty() && s.ToULong(number);
218 }
219
220 // scans all alphabetic characters and returns the resulting string
221 wxString
222 GetAlphaToken(wxString::const_iterator& p,
223 const wxString::const_iterator& end)
224 {
225 wxString s;
226 while ( p != end && wxIsalpha(*p) )
227 {
228 s += *p++;
229 }
230
231 return s;
232 }
233
234 // parses string starting at given iterator using the specified format and,
235 // optionally, a fall back format (and optionally another one... but it stops
236 // there, really)
237 //
238 // if unsuccessful, returns invalid wxDateTime without changing p; otherwise
239 // advance p to the end of the match and returns wxDateTime containing the
240 // results of the parsing
241 wxDateTime
242 ParseFormatAt(wxString::const_iterator& p,
243 const wxString::const_iterator& end,
244 const wxString& fmt,
245 // FIXME-VC6: using wxString() instead of wxEmptyString in the
246 // line below results in error C2062: type 'class
247 // wxString (__cdecl *)(void)' unexpected
248 const wxString& fmtAlt = wxEmptyString)
249 {
250 const wxString str(p, end);
251 wxString::const_iterator endParse;
252 wxDateTime dt;
253 if ( dt.ParseFormat(str, fmt, &endParse) ||
254 (!fmtAlt.empty() && dt.ParseFormat(str, fmtAlt, &endParse)) )
255 {
256 p += endParse - str.begin();
257 }
258 //else: all formats failed
259
260 return dt;
261 }
262
263 } // anonymous namespace
264
265 // ----------------------------------------------------------------------------
266 // wxDateTime to/from text representations
267 // ----------------------------------------------------------------------------
268
269 wxString wxDateTime::Format(const wxString& formatp, const TimeZone& tz) const
270 {
271 wxCHECK_MSG( !formatp.empty(), wxEmptyString,
272 _T("NULL format in wxDateTime::Format") );
273
274 wxString format = formatp;
275 #ifdef __WXOSX__
276 format.Replace("%c",wxLocale::GetInfo(wxLOCALE_DATE_TIME_FMT));
277 format.Replace("%x",wxLocale::GetInfo(wxLOCALE_SHORT_DATE_FMT));
278 format.Replace("%X",wxLocale::GetInfo(wxLOCALE_TIME_FMT));
279 #endif
280 // we have to use our own implementation if the date is out of range of
281 // strftime() or if we use non standard specificators
282 #ifdef HAVE_STRFTIME
283 time_t time = GetTicks();
284
285 if ( (time != (time_t)-1) && !wxStrstr(format, _T("%l")) )
286 {
287 // use strftime()
288 struct tm tmstruct;
289 struct tm *tm;
290 if ( tz.GetOffset() == -GetTimeZone() )
291 {
292 // we are working with local time
293 tm = wxLocaltime_r(&time, &tmstruct);
294
295 // should never happen
296 wxCHECK_MSG( tm, wxEmptyString, _T("wxLocaltime_r() failed") );
297 }
298 else
299 {
300 time += (int)tz.GetOffset();
301
302 #if defined(__VMS__) || defined(__WATCOMC__) // time is unsigned so avoid warning
303 int time2 = (int) time;
304 if ( time2 >= 0 )
305 #else
306 if ( time >= 0 )
307 #endif
308 {
309 tm = wxGmtime_r(&time, &tmstruct);
310
311 // should never happen
312 wxCHECK_MSG( tm, wxEmptyString, _T("wxGmtime_r() failed") );
313 }
314 else
315 {
316 tm = (struct tm *)NULL;
317 }
318 }
319
320 if ( tm )
321 {
322 return CallStrftime(format, tm);
323 }
324 }
325 //else: use generic code below
326 #endif // HAVE_STRFTIME
327
328 // we only parse ANSI C format specifications here, no POSIX 2
329 // complications, no GNU extensions but we do add support for a "%l" format
330 // specifier allowing to get the number of milliseconds
331 Tm tm = GetTm(tz);
332
333 // used for calls to strftime() when we only deal with time
334 struct tm tmTimeOnly;
335 tmTimeOnly.tm_hour = tm.hour;
336 tmTimeOnly.tm_min = tm.min;
337 tmTimeOnly.tm_sec = tm.sec;
338 tmTimeOnly.tm_wday = 0;
339 tmTimeOnly.tm_yday = 0;
340 tmTimeOnly.tm_mday = 1; // any date will do
341 tmTimeOnly.tm_mon = 0;
342 tmTimeOnly.tm_year = 76;
343 tmTimeOnly.tm_isdst = 0; // no DST, we adjust for tz ourselves
344
345 wxString tmp, res, fmt;
346 for ( wxString::const_iterator p = format.begin(); p != format.end(); ++p )
347 {
348 if ( *p != _T('%') )
349 {
350 // copy as is
351 res += *p;
352
353 continue;
354 }
355
356 // set the default format
357 switch ( (*++p).GetValue() )
358 {
359 case _T('Y'): // year has 4 digits
360 fmt = _T("%04d");
361 break;
362
363 case _T('j'): // day of year has 3 digits
364 case _T('l'): // milliseconds have 3 digits
365 fmt = _T("%03d");
366 break;
367
368 case _T('w'): // week day as number has only one
369 fmt = _T("%d");
370 break;
371
372 default:
373 // it's either another valid format specifier in which case
374 // the format is "%02d" (for all the rest) or we have the
375 // field width preceding the format in which case it will
376 // override the default format anyhow
377 fmt = _T("%02d");
378 }
379
380 bool restart = true;
381 while ( restart )
382 {
383 restart = false;
384
385 // start of the format specification
386 switch ( (*p).GetValue() )
387 {
388 case _T('a'): // a weekday name
389 case _T('A'):
390 // second parameter should be true for abbreviated names
391 res += GetWeekDayName(tm.GetWeekDay(),
392 *p == _T('a') ? Name_Abbr : Name_Full);
393 break;
394
395 case _T('b'): // a month name
396 case _T('B'):
397 res += GetMonthName(tm.mon,
398 *p == _T('b') ? Name_Abbr : Name_Full);
399 break;
400
401 case _T('c'): // locale default date and time representation
402 case _T('x'): // locale default date representation
403 #ifdef HAVE_STRFTIME
404 //
405 // the problem: there is no way to know what do these format
406 // specifications correspond to for the current locale.
407 //
408 // the solution: use a hack and still use strftime(): first
409 // find the YEAR which is a year in the strftime() range (1970
410 // - 2038) whose Jan 1 falls on the same week day as the Jan 1
411 // of the real year. Then make a copy of the format and
412 // replace all occurrences of YEAR in it with some unique
413 // string not appearing anywhere else in it, then use
414 // strftime() to format the date in year YEAR and then replace
415 // YEAR back by the real year and the unique replacement
416 // string back with YEAR. Notice that "all occurrences of YEAR"
417 // means all occurrences of 4 digit as well as 2 digit form!
418 //
419 // the bugs: we assume that neither of %c nor %x contains any
420 // fields which may change between the YEAR and real year. For
421 // example, the week number (%U, %W) and the day number (%j)
422 // will change if one of these years is leap and the other one
423 // is not!
424 {
425 // find the YEAR: normally, for any year X, Jan 1 of the
426 // year X + 28 is the same weekday as Jan 1 of X (because
427 // the weekday advances by 1 for each normal X and by 2
428 // for each leap X, hence by 5 every 4 years or by 35
429 // which is 0 mod 7 every 28 years) but this rule breaks
430 // down if there are years between X and Y which are
431 // divisible by 4 but not leap (i.e. divisible by 100 but
432 // not 400), hence the correction.
433
434 int yearReal = GetYear(tz);
435 int mod28 = yearReal % 28;
436
437 // be careful to not go too far - we risk to leave the
438 // supported range
439 int year;
440 if ( mod28 < 10 )
441 {
442 year = 1988 + mod28; // 1988 == 0 (mod 28)
443 }
444 else
445 {
446 year = 1970 + mod28 - 10; // 1970 == 10 (mod 28)
447 }
448
449 int nCentury = year / 100,
450 nCenturyReal = yearReal / 100;
451
452 // need to adjust for the years divisble by 400 which are
453 // not leap but are counted like leap ones if we just take
454 // the number of centuries in between for nLostWeekDays
455 int nLostWeekDays = (nCentury - nCenturyReal) -
456 (nCentury / 4 - nCenturyReal / 4);
457
458 // we have to gain back the "lost" weekdays: note that the
459 // effect of this loop is to not do anything to
460 // nLostWeekDays (which we won't use any more), but to
461 // (indirectly) set the year correctly
462 while ( (nLostWeekDays % 7) != 0 )
463 {
464 nLostWeekDays += year++ % 4 ? 1 : 2;
465 }
466
467 // finally move the year below 2000 so that the 2-digit
468 // year number can never match the month or day of the
469 // month when we do the replacements below
470 if ( year >= 2000 )
471 year -= 28;
472
473 wxASSERT_MSG( year >= 1970 && year < 2000,
474 _T("logic error in wxDateTime::Format") );
475
476
477 // use strftime() to format the same date but in supported
478 // year
479 //
480 // NB: we assume that strftime() doesn't check for the
481 // date validity and will happily format the date
482 // corresponding to Feb 29 of a non leap year (which
483 // may happen if yearReal was leap and year is not)
484 struct tm tmAdjusted;
485 InitTm(tmAdjusted);
486 tmAdjusted.tm_hour = tm.hour;
487 tmAdjusted.tm_min = tm.min;
488 tmAdjusted.tm_sec = tm.sec;
489 tmAdjusted.tm_wday = tm.GetWeekDay();
490 tmAdjusted.tm_yday = GetDayOfYear();
491 tmAdjusted.tm_mday = tm.mday;
492 tmAdjusted.tm_mon = tm.mon;
493 tmAdjusted.tm_year = year - 1900;
494 tmAdjusted.tm_isdst = 0; // no DST, already adjusted
495 wxString str = CallStrftime(*p == _T('c') ? _T("%c")
496 : _T("%x"),
497 &tmAdjusted);
498
499 // now replace the replacement year with the real year:
500 // notice that we have to replace the 4 digit year with
501 // a unique string not appearing in strftime() output
502 // first to prevent the 2 digit year from matching any
503 // substring of the 4 digit year (but any day, month,
504 // hours or minutes components should be safe because
505 // they are never in 70-99 range)
506 wxString replacement("|");
507 while ( str.find(replacement) != wxString::npos )
508 replacement += '|';
509
510 str.Replace(wxString::Format("%d", year),
511 replacement);
512 str.Replace(wxString::Format("%d", year % 100),
513 wxString::Format("%d", yearReal % 100));
514 str.Replace(replacement,
515 wxString::Format("%d", yearReal));
516
517 res += str;
518 }
519 #else // !HAVE_STRFTIME
520 // Use "%m/%d/%y %H:%M:%S" format instead
521 res += wxString::Format(wxT("%02d/%02d/%04d %02d:%02d:%02d"),
522 tm.mon+1,tm.mday, tm.year, tm.hour, tm.min, tm.sec);
523 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
524 break;
525
526 case _T('d'): // day of a month (01-31)
527 res += wxString::Format(fmt, tm.mday);
528 break;
529
530 case _T('H'): // hour in 24h format (00-23)
531 res += wxString::Format(fmt, tm.hour);
532 break;
533
534 case _T('I'): // hour in 12h format (01-12)
535 {
536 // 24h -> 12h, 0h -> 12h too
537 int hour12 = tm.hour > 12 ? tm.hour - 12
538 : tm.hour ? tm.hour : 12;
539 res += wxString::Format(fmt, hour12);
540 }
541 break;
542
543 case _T('j'): // day of the year
544 res += wxString::Format(fmt, GetDayOfYear(tz));
545 break;
546
547 case _T('l'): // milliseconds (NOT STANDARD)
548 res += wxString::Format(fmt, GetMillisecond(tz));
549 break;
550
551 case _T('m'): // month as a number (01-12)
552 res += wxString::Format(fmt, tm.mon + 1);
553 break;
554
555 case _T('M'): // minute as a decimal number (00-59)
556 res += wxString::Format(fmt, tm.min);
557 break;
558
559 case _T('p'): // AM or PM string
560 #ifdef HAVE_STRFTIME
561 res += CallStrftime(_T("%p"), &tmTimeOnly);
562 #else // !HAVE_STRFTIME
563 res += (tmTimeOnly.tm_hour > 12) ? wxT("pm") : wxT("am");
564 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
565 break;
566
567 case _T('S'): // second as a decimal number (00-61)
568 res += wxString::Format(fmt, tm.sec);
569 break;
570
571 case _T('U'): // week number in the year (Sunday 1st week day)
572 res += wxString::Format(fmt, GetWeekOfYear(Sunday_First, tz));
573 break;
574
575 case _T('W'): // week number in the year (Monday 1st week day)
576 res += wxString::Format(fmt, GetWeekOfYear(Monday_First, tz));
577 break;
578
579 case _T('w'): // weekday as a number (0-6), Sunday = 0
580 res += wxString::Format(fmt, tm.GetWeekDay());
581 break;
582
583 // case _T('x'): -- handled with "%c"
584
585 case _T('X'): // locale default time representation
586 // just use strftime() to format the time for us
587 #ifdef HAVE_STRFTIME
588 res += CallStrftime(_T("%X"), &tmTimeOnly);
589 #else // !HAVE_STRFTIME
590 res += wxString::Format(wxT("%02d:%02d:%02d"),tm.hour, tm.min, tm.sec);
591 #endif // HAVE_STRFTIME/!HAVE_STRFTIME
592 break;
593
594 case _T('y'): // year without century (00-99)
595 res += wxString::Format(fmt, tm.year % 100);
596 break;
597
598 case _T('Y'): // year with century
599 res += wxString::Format(fmt, tm.year);
600 break;
601
602 case _T('Z'): // timezone name
603 #ifdef HAVE_STRFTIME
604 res += CallStrftime(_T("%Z"), &tmTimeOnly);
605 #endif
606 break;
607
608 default:
609 // is it the format width?
610 fmt.Empty();
611 while ( *p == _T('-') || *p == _T('+') ||
612 *p == _T(' ') || wxIsdigit(*p) )
613 {
614 fmt += *p;
615 }
616
617 if ( !fmt.empty() )
618 {
619 // we've only got the flags and width so far in fmt
620 fmt.Prepend(_T('%'));
621 fmt.Append(_T('d'));
622
623 restart = true;
624
625 break;
626 }
627
628 // no, it wasn't the width
629 wxFAIL_MSG(_T("unknown format specificator"));
630
631 // fall through and just copy it nevertheless
632
633 case _T('%'): // a percent sign
634 res += *p;
635 break;
636
637 case 0: // the end of string
638 wxFAIL_MSG(_T("missing format at the end of string"));
639
640 // just put the '%' which was the last char in format
641 res += _T('%');
642 break;
643 }
644 }
645 }
646
647 return res;
648 }
649
650 // this function parses a string in (strict) RFC 822 format: see the section 5
651 // of the RFC for the detailed description, but briefly it's something of the
652 // form "Sat, 18 Dec 1999 00:48:30 +0100"
653 //
654 // this function is "strict" by design - it must reject anything except true
655 // RFC822 time specs.
656 bool
657 wxDateTime::ParseRfc822Date(const wxString& date, wxString::const_iterator *end)
658 {
659 wxString::const_iterator p = date.begin();
660
661 // 1. week day
662 static const int WDAY_LEN = 3;
663 const wxString::const_iterator endWday = p + WDAY_LEN;
664 const wxString wday(p, endWday);
665 if ( GetWeekDayFromName(wday, Name_Abbr, DateLang_English) == Inv_WeekDay )
666 return false;
667 //else: ignore week day for now, we could also check that it really
668 // corresponds to the specified date
669
670 p = endWday;
671
672 // 2. separating comma
673 if ( *p++ != ',' || *p++ != ' ' )
674 return false;
675
676 // 3. day number
677 if ( !wxIsdigit(*p) )
678 return false;
679
680 wxDateTime_t day = (wxDateTime_t)(*p++ - '0');
681 if ( wxIsdigit(*p) )
682 {
683 day *= 10;
684 day = (wxDateTime_t)(day + (*p++ - '0'));
685 }
686
687 if ( *p++ != ' ' )
688 return false;
689
690 // 4. month name
691 static const int MONTH_LEN = 3;
692 const wxString::const_iterator endMonth = p + MONTH_LEN;
693 const wxString monName(p, endMonth);
694 Month mon = GetMonthFromName(monName, Name_Abbr, DateLang_English);
695 if ( mon == Inv_Month )
696 return false;
697
698 p = endMonth;
699
700 if ( *p++ != ' ' )
701 return false;
702
703 // 5. year
704 if ( !wxIsdigit(*p) )
705 return false;
706
707 int year = *p++ - '0';
708 if ( !wxIsdigit(*p) ) // should have at least 2 digits in the year
709 return false;
710
711 year *= 10;
712 year += *p++ - '0';
713
714 // is it a 2 digit year (as per original RFC 822) or a 4 digit one?
715 if ( wxIsdigit(*p) )
716 {
717 year *= 10;
718 year += *p++ - '0';
719
720 if ( !wxIsdigit(*p) )
721 {
722 // no 3 digit years please
723 return false;
724 }
725
726 year *= 10;
727 year += *p++ - '0';
728 }
729
730 if ( *p++ != ' ' )
731 return false;
732
733 // 6. time in hh:mm:ss format with seconds being optional
734 if ( !wxIsdigit(*p) )
735 return false;
736
737 wxDateTime_t hour = (wxDateTime_t)(*p++ - '0');
738
739 if ( !wxIsdigit(*p) )
740 return false;
741
742 hour *= 10;
743 hour = (wxDateTime_t)(hour + (*p++ - '0'));
744
745 if ( *p++ != ':' )
746 return false;
747
748 if ( !wxIsdigit(*p) )
749 return false;
750
751 wxDateTime_t min = (wxDateTime_t)(*p++ - '0');
752
753 if ( !wxIsdigit(*p) )
754 return false;
755
756 min *= 10;
757 min += (wxDateTime_t)(*p++ - '0');
758
759 wxDateTime_t sec = 0;
760 if ( *p == ':' )
761 {
762 p++;
763 if ( !wxIsdigit(*p) )
764 return false;
765
766 sec = (wxDateTime_t)(*p++ - '0');
767
768 if ( !wxIsdigit(*p) )
769 return false;
770
771 sec *= 10;
772 sec += (wxDateTime_t)(*p++ - '0');
773 }
774
775 if ( *p++ != ' ' )
776 return false;
777
778 // 7. now the interesting part: the timezone
779 int offset wxDUMMY_INITIALIZE(0);
780 if ( *p == '-' || *p == '+' )
781 {
782 // the explicit offset given: it has the form of hhmm
783 bool plus = *p++ == '+';
784
785 if ( !wxIsdigit(*p) || !wxIsdigit(*(p + 1)) )
786 return false;
787
788
789 // hours
790 offset = MIN_PER_HOUR*(10*(*p - '0') + (*(p + 1) - '0'));
791
792 p += 2;
793
794 if ( !wxIsdigit(*p) || !wxIsdigit(*(p + 1)) )
795 return false;
796
797 // minutes
798 offset += 10*(*p - '0') + (*(p + 1) - '0');
799
800 if ( !plus )
801 offset = -offset;
802
803 p += 2;
804 }
805 else // not numeric
806 {
807 // the symbolic timezone given: may be either military timezone or one
808 // of standard abbreviations
809 if ( !*(p + 1) )
810 {
811 // military: Z = UTC, J unused, A = -1, ..., Y = +12
812 static const int offsets[26] =
813 {
814 //A B C D E F G H I J K L M
815 -1, -2, -3, -4, -5, -6, -7, -8, -9, 0, -10, -11, -12,
816 //N O P R Q S T U V W Z Y Z
817 +1, +2, +3, +4, +5, +6, +7, +8, +9, +10, +11, +12, 0
818 };
819
820 if ( *p < _T('A') || *p > _T('Z') || *p == _T('J') )
821 return false;
822
823 offset = offsets[*p++ - 'A'];
824 }
825 else
826 {
827 // abbreviation
828 const wxString tz(p, date.end());
829 if ( tz == _T("UT") || tz == _T("UTC") || tz == _T("GMT") )
830 offset = 0;
831 else if ( tz == _T("AST") )
832 offset = AST - GMT0;
833 else if ( tz == _T("ADT") )
834 offset = ADT - GMT0;
835 else if ( tz == _T("EST") )
836 offset = EST - GMT0;
837 else if ( tz == _T("EDT") )
838 offset = EDT - GMT0;
839 else if ( tz == _T("CST") )
840 offset = CST - GMT0;
841 else if ( tz == _T("CDT") )
842 offset = CDT - GMT0;
843 else if ( tz == _T("MST") )
844 offset = MST - GMT0;
845 else if ( tz == _T("MDT") )
846 offset = MDT - GMT0;
847 else if ( tz == _T("PST") )
848 offset = PST - GMT0;
849 else if ( tz == _T("PDT") )
850 offset = PDT - GMT0;
851 else
852 return false;
853
854 p += tz.length();
855 }
856
857 // make it minutes
858 offset *= MIN_PER_HOUR;
859 }
860
861
862 // the spec was correct, construct the date from the values we found
863 Set(day, mon, year, hour, min, sec);
864 MakeFromTimezone(TimeZone::Make(offset*SEC_PER_MIN));
865
866 if ( end )
867 *end = p;
868
869 return true;
870 }
871
872 bool
873 wxDateTime::ParseFormat(const wxString& date,
874 const wxString& format,
875 const wxDateTime& dateDef,
876 wxString::const_iterator *endParse)
877 {
878 wxCHECK_MSG( !format.empty(), false, "format can't be empty" );
879 wxCHECK_MSG( endParse, false, "end iterator pointer must be specified" );
880
881 wxString str;
882 unsigned long num;
883
884 // what fields have we found?
885 bool haveWDay = false,
886 haveYDay = false,
887 haveDay = false,
888 haveMon = false,
889 haveYear = false,
890 haveHour = false,
891 haveMin = false,
892 haveSec = false,
893 haveMsec = false;
894
895 bool hourIsIn12hFormat = false, // or in 24h one?
896 isPM = false; // AM by default
897
898 // and the value of the items we have (init them to get rid of warnings)
899 wxDateTime_t msec = 0,
900 sec = 0,
901 min = 0,
902 hour = 0;
903 WeekDay wday = Inv_WeekDay;
904 wxDateTime_t yday = 0,
905 mday = 0;
906 wxDateTime::Month mon = Inv_Month;
907 int year = 0;
908
909 wxString::const_iterator input = date.begin();
910 const wxString::const_iterator end = date.end();
911 for ( wxString::const_iterator fmt = format.begin(); fmt != format.end(); ++fmt )
912 {
913 if ( *fmt != _T('%') )
914 {
915 if ( wxIsspace(*fmt) )
916 {
917 // a white space in the format string matches 0 or more white
918 // spaces in the input
919 while ( input != end && wxIsspace(*input) )
920 {
921 input++;
922 }
923 }
924 else // !space
925 {
926 // any other character (not whitespace, not '%') must be
927 // matched by itself in the input
928 if ( input == end || *input++ != *fmt )
929 {
930 // no match
931 return false;
932 }
933 }
934
935 // done with this format char
936 continue;
937 }
938
939 // start of a format specification
940
941 // parse the optional width
942 size_t width = 0;
943 while ( wxIsdigit(*++fmt) )
944 {
945 width *= 10;
946 width += *fmt - '0';
947 }
948
949 // the default widths for the various fields
950 if ( !width )
951 {
952 switch ( (*fmt).GetValue() )
953 {
954 case _T('Y'): // year has 4 digits
955 width = 4;
956 break;
957
958 case _T('j'): // day of year has 3 digits
959 case _T('l'): // milliseconds have 3 digits
960 width = 3;
961 break;
962
963 case _T('w'): // week day as number has only one
964 width = 1;
965 break;
966
967 default:
968 // default for all other fields
969 width = 2;
970 }
971 }
972
973 // then the format itself
974 switch ( (*fmt).GetValue() )
975 {
976 case _T('a'): // a weekday name
977 case _T('A'):
978 {
979 wday = GetWeekDayFromName
980 (
981 GetAlphaToken(input, end),
982 *fmt == 'a' ? Name_Abbr : Name_Full,
983 DateLang_Local
984 );
985 if ( wday == Inv_WeekDay )
986 {
987 // no match
988 return false;
989 }
990 }
991 haveWDay = true;
992 break;
993
994 case _T('b'): // a month name
995 case _T('B'):
996 {
997 mon = GetMonthFromName
998 (
999 GetAlphaToken(input, end),
1000 *fmt == 'b' ? Name_Abbr : Name_Full,
1001 DateLang_Local
1002 );
1003 if ( mon == Inv_Month )
1004 {
1005 // no match
1006 return false;
1007 }
1008 }
1009 haveMon = true;
1010 break;
1011
1012 case _T('c'): // locale default date and time representation
1013 {
1014 wxDateTime dt;
1015
1016 const wxString
1017 fmtDateTime = wxLocale::GetInfo(wxLOCALE_DATE_TIME_FMT);
1018 if ( !fmtDateTime.empty() )
1019 dt = ParseFormatAt(input, end, fmtDateTime);
1020
1021 if ( !dt.IsValid() )
1022 {
1023 // also try the format which corresponds to ctime()
1024 // output (i.e. the "C" locale default)
1025 dt = ParseFormatAt(input, end, wxS("%a %b %d %H:%M:%S %Y"));
1026 }
1027
1028 if ( !dt.IsValid() )
1029 {
1030 // and finally also the two generic date/time formats
1031 dt = ParseFormatAt(input, end, wxS("%x %X"), wxS("%X %x"));
1032 }
1033
1034 if ( !dt.IsValid() )
1035 return false;
1036
1037 const Tm tm = dt.GetTm();
1038
1039 hour = tm.hour;
1040 min = tm.min;
1041 sec = tm.sec;
1042
1043 year = tm.year;
1044 mon = tm.mon;
1045 mday = tm.mday;
1046
1047 haveDay = haveMon = haveYear =
1048 haveHour = haveMin = haveSec = true;
1049 }
1050 break;
1051
1052 case _T('d'): // day of a month (01-31)
1053 if ( !GetNumericToken(width, input, end, &num) ||
1054 (num > 31) || (num < 1) )
1055 {
1056 // no match
1057 return false;
1058 }
1059
1060 // we can't check whether the day range is correct yet, will
1061 // do it later - assume ok for now
1062 haveDay = true;
1063 mday = (wxDateTime_t)num;
1064 break;
1065
1066 case _T('H'): // hour in 24h format (00-23)
1067 if ( !GetNumericToken(width, input, end, &num) || (num > 23) )
1068 {
1069 // no match
1070 return false;
1071 }
1072
1073 haveHour = true;
1074 hour = (wxDateTime_t)num;
1075 break;
1076
1077 case _T('I'): // hour in 12h format (01-12)
1078 if ( !GetNumericToken(width, input, end, &num) ||
1079 !num || (num > 12) )
1080 {
1081 // no match
1082 return false;
1083 }
1084
1085 haveHour = true;
1086 hourIsIn12hFormat = true;
1087 hour = (wxDateTime_t)(num % 12); // 12 should be 0
1088 break;
1089
1090 case _T('j'): // day of the year
1091 if ( !GetNumericToken(width, input, end, &num) ||
1092 !num || (num > 366) )
1093 {
1094 // no match
1095 return false;
1096 }
1097
1098 haveYDay = true;
1099 yday = (wxDateTime_t)num;
1100 break;
1101
1102 case _T('l'): // milliseconds (0-999)
1103 if ( !GetNumericToken(width, input, end, &num) )
1104 return false;
1105
1106 haveMsec = true;
1107 msec = (wxDateTime_t)num;
1108 break;
1109
1110 case _T('m'): // month as a number (01-12)
1111 if ( !GetNumericToken(width, input, end, &num) ||
1112 !num || (num > 12) )
1113 {
1114 // no match
1115 return false;
1116 }
1117
1118 haveMon = true;
1119 mon = (Month)(num - 1);
1120 break;
1121
1122 case _T('M'): // minute as a decimal number (00-59)
1123 if ( !GetNumericToken(width, input, end, &num) ||
1124 (num > 59) )
1125 {
1126 // no match
1127 return false;
1128 }
1129
1130 haveMin = true;
1131 min = (wxDateTime_t)num;
1132 break;
1133
1134 case _T('p'): // AM or PM string
1135 {
1136 wxString am, pm, token = GetAlphaToken(input, end);
1137
1138 // some locales have empty AM/PM tokens and thus when formatting
1139 // dates with the %p specifier nothing is generated; when trying to
1140 // parse them back, we get an empty token here... but that's not
1141 // an error.
1142 if (token.empty())
1143 break;
1144
1145 GetAmPmStrings(&am, &pm);
1146 if (am.empty() && pm.empty())
1147 return false; // no am/pm strings defined
1148 if ( token.CmpNoCase(pm) == 0 )
1149 {
1150 isPM = true;
1151 }
1152 else if ( token.CmpNoCase(am) != 0 )
1153 {
1154 // no match
1155 return false;
1156 }
1157 }
1158 break;
1159
1160 case _T('r'): // time as %I:%M:%S %p
1161 {
1162 wxDateTime dt;
1163 if ( !dt.ParseFormat(wxString(input, end),
1164 wxS("%I:%M:%S %p"), &input) )
1165 return false;
1166
1167 haveHour = haveMin = haveSec = true;
1168
1169 const Tm tm = dt.GetTm();
1170 hour = tm.hour;
1171 min = tm.min;
1172 sec = tm.sec;
1173 }
1174 break;
1175
1176 case _T('R'): // time as %H:%M
1177 {
1178 const wxDateTime
1179 dt = ParseFormatAt(input, end, wxS("%H:%M"));
1180 if ( !dt.IsValid() )
1181 return false;
1182
1183 haveHour =
1184 haveMin = true;
1185
1186 const Tm tm = dt.GetTm();
1187 hour = tm.hour;
1188 min = tm.min;
1189 }
1190 break;
1191
1192 case _T('S'): // second as a decimal number (00-61)
1193 if ( !GetNumericToken(width, input, end, &num) ||
1194 (num > 61) )
1195 {
1196 // no match
1197 return false;
1198 }
1199
1200 haveSec = true;
1201 sec = (wxDateTime_t)num;
1202 break;
1203
1204 case _T('T'): // time as %H:%M:%S
1205 {
1206 const wxDateTime
1207 dt = ParseFormatAt(input, end, wxS("%H:%M:%S"));
1208 if ( !dt.IsValid() )
1209 return false;
1210
1211 haveHour =
1212 haveMin =
1213 haveSec = true;
1214
1215 const Tm tm = dt.GetTm();
1216 hour = tm.hour;
1217 min = tm.min;
1218 sec = tm.sec;
1219 }
1220 break;
1221
1222 case _T('w'): // weekday as a number (0-6), Sunday = 0
1223 if ( !GetNumericToken(width, input, end, &num) ||
1224 (wday > 6) )
1225 {
1226 // no match
1227 return false;
1228 }
1229
1230 haveWDay = true;
1231 wday = (WeekDay)num;
1232 break;
1233
1234 case _T('x'): // locale default date representation
1235 {
1236 wxString
1237 fmtDate = wxLocale::GetInfo(wxLOCALE_SHORT_DATE_FMT),
1238 fmtDateAlt = wxLocale::GetInfo(wxLOCALE_LONG_DATE_FMT);
1239
1240 if ( fmtDate.empty() )
1241 {
1242 if ( IsWestEuropeanCountry(GetCountry()) ||
1243 GetCountry() == Russia )
1244 {
1245 fmtDate = wxS("%d/%m/%Y");
1246 fmtDateAlt = wxS("%m/%d/%Y");
1247 }
1248 else // assume USA
1249 {
1250 fmtDate = wxS("%m/%d/%Y");
1251 fmtDateAlt = wxS("%d/%m/%Y");
1252 }
1253 }
1254
1255 wxDateTime
1256 dt = ParseFormatAt(input, end, fmtDate, fmtDateAlt);
1257
1258 if ( !dt.IsValid() )
1259 {
1260 // try with short years too
1261 fmtDate.Replace("%Y","%y");
1262 fmtDateAlt.Replace("%Y","%y");
1263 dt = ParseFormatAt(input, end, fmtDate, fmtDateAlt);
1264
1265 if ( !dt.IsValid() )
1266 return false;
1267 }
1268
1269 const Tm tm = dt.GetTm();
1270
1271 haveDay =
1272 haveMon =
1273 haveYear = true;
1274
1275 year = tm.year;
1276 mon = tm.mon;
1277 mday = tm.mday;
1278 }
1279
1280 break;
1281
1282 case _T('X'): // locale default time representation
1283 {
1284 wxString fmtTime = wxLocale::GetInfo(wxLOCALE_TIME_FMT),
1285 fmtTimeAlt;
1286
1287 if ( fmtTime.empty() )
1288 {
1289 // try to parse what follows as "%H:%M:%S" and, if this
1290 // fails, as "%I:%M:%S %p" - this should catch the most
1291 // common cases
1292 fmtTime = "%T";
1293 fmtTimeAlt = "%r";
1294 }
1295
1296 const wxDateTime
1297 dt = ParseFormatAt(input, end, fmtTime, fmtTimeAlt);
1298 if ( !dt.IsValid() )
1299 return false;
1300
1301 haveHour =
1302 haveMin =
1303 haveSec = true;
1304
1305 const Tm tm = dt.GetTm();
1306 hour = tm.hour;
1307 min = tm.min;
1308 sec = tm.sec;
1309 }
1310 break;
1311
1312 case _T('y'): // year without century (00-99)
1313 if ( !GetNumericToken(width, input, end, &num) ||
1314 (num > 99) )
1315 {
1316 // no match
1317 return false;
1318 }
1319
1320 haveYear = true;
1321
1322 // TODO should have an option for roll over date instead of
1323 // hard coding it here
1324 year = (num > 30 ? 1900 : 2000) + (wxDateTime_t)num;
1325 break;
1326
1327 case _T('Y'): // year with century
1328 if ( !GetNumericToken(width, input, end, &num) )
1329 {
1330 // no match
1331 return false;
1332 }
1333
1334 haveYear = true;
1335 year = (wxDateTime_t)num;
1336 break;
1337
1338 case _T('Z'): // timezone name
1339 // FIXME: currently we just ignore everything that looks like a
1340 // time zone here
1341 GetAlphaToken(input, end);
1342 break;
1343
1344 case _T('%'): // a percent sign
1345 if ( *input++ != _T('%') )
1346 {
1347 // no match
1348 return false;
1349 }
1350 break;
1351
1352 case 0: // the end of string
1353 wxFAIL_MSG(_T("unexpected format end"));
1354
1355 // fall through
1356
1357 default: // not a known format spec
1358 return false;
1359 }
1360 }
1361
1362 // format matched, try to construct a date from what we have now
1363 Tm tmDef;
1364 if ( dateDef.IsValid() )
1365 {
1366 // take this date as default
1367 tmDef = dateDef.GetTm();
1368 }
1369 else if ( IsValid() )
1370 {
1371 // if this date is valid, don't change it
1372 tmDef = GetTm();
1373 }
1374 else
1375 {
1376 // no default and this date is invalid - fall back to Today()
1377 tmDef = Today().GetTm();
1378 }
1379
1380 Tm tm = tmDef;
1381
1382 // set the date
1383 if ( haveMon )
1384 {
1385 tm.mon = mon;
1386 }
1387
1388 if ( haveYear )
1389 {
1390 tm.year = year;
1391 }
1392
1393 // TODO we don't check here that the values are consistent, if both year
1394 // day and month/day were found, we just ignore the year day and we
1395 // also always ignore the week day
1396 if ( haveDay )
1397 {
1398 if ( mday > GetNumberOfDays(tm.mon, tm.year) )
1399 return false;
1400
1401 tm.mday = mday;
1402 }
1403 else if ( haveYDay )
1404 {
1405 if ( yday > GetNumberOfDays(tm.year) )
1406 return false;
1407
1408 Tm tm2 = wxDateTime(1, Jan, tm.year).SetToYearDay(yday).GetTm();
1409
1410 tm.mon = tm2.mon;
1411 tm.mday = tm2.mday;
1412 }
1413
1414 // deal with AM/PM
1415 if ( haveHour && hourIsIn12hFormat && isPM )
1416 {
1417 // translate to 24hour format
1418 hour += 12;
1419 }
1420 //else: either already in 24h format or no translation needed
1421
1422 // set the time
1423 if ( haveHour )
1424 {
1425 tm.hour = hour;
1426 }
1427
1428 if ( haveMin )
1429 {
1430 tm.min = min;
1431 }
1432
1433 if ( haveSec )
1434 {
1435 tm.sec = sec;
1436 }
1437
1438 if ( haveMsec )
1439 tm.msec = msec;
1440
1441 Set(tm);
1442
1443 // finally check that the week day is consistent -- if we had it
1444 if ( haveWDay && GetWeekDay() != wday )
1445 return false;
1446
1447 *endParse = input;
1448
1449 return true;
1450 }
1451
1452 bool
1453 wxDateTime::ParseDateTime(const wxString& date, wxString::const_iterator *end)
1454 {
1455 wxCHECK_MSG( end, false, "end iterator pointer must be specified" );
1456
1457 // Set to current day and hour, so strings like '14:00' becomes today at
1458 // 14, not some other random date
1459 wxDateTime dtDate = wxDateTime::Today();
1460 wxDateTime dtTime = wxDateTime::Today();
1461
1462 wxString::const_iterator
1463 endTime,
1464 endDate,
1465 endBoth;
1466
1467 // If we got a date in the beginning, see if there is a time specified
1468 // after the date
1469 if ( dtDate.ParseDate(date, &endDate) )
1470 {
1471 // Skip spaces, as the ParseTime() function fails on spaces
1472 while ( endDate != date.end() && wxIsspace(*endDate) )
1473 ++endDate;
1474
1475 const wxString timestr(endDate, date.end());
1476 if ( !dtTime.ParseTime(timestr, &endTime) )
1477 return false;
1478
1479 endBoth = endDate + (endTime - timestr.begin());
1480 }
1481 else // no date in the beginning
1482 {
1483 // check if we have a time followed by a date
1484 if ( !dtTime.ParseTime(date, &endTime) )
1485 return false;
1486
1487 while ( endTime != date.end() && wxIsspace(*endTime) )
1488 ++endTime;
1489
1490 const wxString datestr(endTime, date.end());
1491 if ( !dtDate.ParseDate(datestr, &endDate) )
1492 return false;
1493
1494 endBoth = endTime + (endDate - datestr.begin());
1495 }
1496
1497 Set(dtDate.GetDay(), dtDate.GetMonth(), dtDate.GetYear(),
1498 dtTime.GetHour(), dtTime.GetMinute(), dtTime.GetSecond(),
1499 dtTime.GetMillisecond());
1500
1501 *end = endBoth;
1502
1503 return true;
1504 }
1505
1506 bool
1507 wxDateTime::ParseDate(const wxString& date, wxString::const_iterator *end)
1508 {
1509 wxCHECK_MSG( end, false, "end iterator pointer must be specified" );
1510
1511 // this is a simplified version of ParseDateTime() which understands only
1512 // "today" (for wxDate compatibility) and digits only otherwise (and not
1513 // all esoteric constructions ParseDateTime() knows about)
1514
1515 const wxString::const_iterator pBegin = date.begin();
1516
1517 wxString::const_iterator p = pBegin;
1518 while ( wxIsspace(*p) )
1519 p++;
1520
1521 // some special cases
1522 static struct
1523 {
1524 const char *str;
1525 int dayDiffFromToday;
1526 } literalDates[] =
1527 {
1528 { wxTRANSLATE("today"), 0 },
1529 { wxTRANSLATE("yesterday"), -1 },
1530 { wxTRANSLATE("tomorrow"), 1 },
1531 };
1532
1533 const size_t lenRest = date.end() - p;
1534 for ( size_t n = 0; n < WXSIZEOF(literalDates); n++ )
1535 {
1536 const wxString dateStr = wxGetTranslation(literalDates[n].str);
1537 size_t len = dateStr.length();
1538
1539 if ( len > lenRest )
1540 continue;
1541
1542 const wxString::const_iterator pEnd = p + len;
1543 if ( wxString(p, pEnd).CmpNoCase(dateStr) == 0 )
1544 {
1545 // nothing can follow this, so stop here
1546
1547 p = pEnd;
1548
1549 int dayDiffFromToday = literalDates[n].dayDiffFromToday;
1550 *this = Today();
1551 if ( dayDiffFromToday )
1552 {
1553 *this += wxDateSpan::Days(dayDiffFromToday);
1554 }
1555
1556 *end = pEnd;
1557
1558 return true;
1559 }
1560 }
1561
1562 // We try to guess what we have here: for each new (numeric) token, we
1563 // determine if it can be a month, day or a year. Of course, there is an
1564 // ambiguity as some numbers may be days as well as months, so we also
1565 // have the ability to back track.
1566
1567 // what do we have?
1568 bool haveDay = false, // the months day?
1569 haveWDay = false, // the day of week?
1570 haveMon = false, // the month?
1571 haveYear = false; // the year?
1572
1573 // and the value of the items we have (init them to get rid of warnings)
1574 WeekDay wday = Inv_WeekDay;
1575 wxDateTime_t day = 0;
1576 wxDateTime::Month mon = Inv_Month;
1577 int year = 0;
1578
1579 // tokenize the string
1580 size_t nPosCur = 0;
1581 static const wxStringCharType *dateDelimiters = wxS(".,/-\t\r\n ");
1582 wxStringTokenizer tok(wxString(p, date.end()), dateDelimiters);
1583 while ( tok.HasMoreTokens() )
1584 {
1585 wxString token = tok.GetNextToken();
1586 if ( !token )
1587 continue;
1588
1589 // is it a number?
1590 unsigned long val;
1591 if ( token.ToULong(&val) )
1592 {
1593 // guess what this number is
1594
1595 bool isDay = false,
1596 isMonth = false,
1597 isYear = false;
1598
1599 if ( !haveMon && val > 0 && val <= 12 )
1600 {
1601 // assume it is month
1602 isMonth = true;
1603 }
1604 else // not the month
1605 {
1606 if ( haveDay )
1607 {
1608 // this can only be the year
1609 isYear = true;
1610 }
1611 else // may be either day or year
1612 {
1613 // use a leap year if we don't have the year yet to allow
1614 // dates like 2/29/1976 which would be rejected otherwise
1615 wxDateTime_t max_days = (wxDateTime_t)(
1616 haveMon
1617 ? GetNumberOfDays(mon, haveYear ? year : 1976)
1618 : 31
1619 );
1620
1621 // can it be day?
1622 if ( (val == 0) || (val > (unsigned long)max_days) )
1623 {
1624 // no
1625 isYear = true;
1626 }
1627 else // yes, suppose it's the day
1628 {
1629 isDay = true;
1630 }
1631 }
1632 }
1633
1634 if ( isYear )
1635 {
1636 if ( haveYear )
1637 break;
1638
1639 haveYear = true;
1640
1641 year = (wxDateTime_t)val;
1642 }
1643 else if ( isDay )
1644 {
1645 if ( haveDay )
1646 break;
1647
1648 haveDay = true;
1649
1650 day = (wxDateTime_t)val;
1651 }
1652 else if ( isMonth )
1653 {
1654 haveMon = true;
1655
1656 mon = (Month)(val - 1);
1657 }
1658 }
1659 else // not a number
1660 {
1661 // be careful not to overwrite the current mon value
1662 Month mon2 = GetMonthFromName
1663 (
1664 token,
1665 Name_Full | Name_Abbr,
1666 DateLang_Local | DateLang_English
1667 );
1668 if ( mon2 != Inv_Month )
1669 {
1670 // it's a month
1671 if ( haveMon )
1672 {
1673 // but we already have a month - maybe we guessed wrong?
1674 if ( !haveDay )
1675 {
1676 // no need to check in month range as always < 12, but
1677 // the days are counted from 1 unlike the months
1678 day = (wxDateTime_t)(mon + 1);
1679 haveDay = true;
1680 }
1681 else
1682 {
1683 // could possible be the year (doesn't the year come
1684 // before the month in the japanese format?) (FIXME)
1685 break;
1686 }
1687 }
1688
1689 mon = mon2;
1690
1691 haveMon = true;
1692 }
1693 else // not a valid month name
1694 {
1695 WeekDay wday2 = GetWeekDayFromName
1696 (
1697 token,
1698 Name_Full | Name_Abbr,
1699 DateLang_Local | DateLang_English
1700 );
1701 if ( wday2 != Inv_WeekDay )
1702 {
1703 // a week day
1704 if ( haveWDay )
1705 {
1706 break;
1707 }
1708
1709 wday = wday2;
1710
1711 haveWDay = true;
1712 }
1713 else // not a valid weekday name
1714 {
1715 // try the ordinals
1716 static const char *ordinals[] =
1717 {
1718 wxTRANSLATE("first"),
1719 wxTRANSLATE("second"),
1720 wxTRANSLATE("third"),
1721 wxTRANSLATE("fourth"),
1722 wxTRANSLATE("fifth"),
1723 wxTRANSLATE("sixth"),
1724 wxTRANSLATE("seventh"),
1725 wxTRANSLATE("eighth"),
1726 wxTRANSLATE("ninth"),
1727 wxTRANSLATE("tenth"),
1728 wxTRANSLATE("eleventh"),
1729 wxTRANSLATE("twelfth"),
1730 wxTRANSLATE("thirteenth"),
1731 wxTRANSLATE("fourteenth"),
1732 wxTRANSLATE("fifteenth"),
1733 wxTRANSLATE("sixteenth"),
1734 wxTRANSLATE("seventeenth"),
1735 wxTRANSLATE("eighteenth"),
1736 wxTRANSLATE("nineteenth"),
1737 wxTRANSLATE("twentieth"),
1738 // that's enough - otherwise we'd have problems with
1739 // composite (or not) ordinals
1740 };
1741
1742 size_t n;
1743 for ( n = 0; n < WXSIZEOF(ordinals); n++ )
1744 {
1745 if ( token.CmpNoCase(ordinals[n]) == 0 )
1746 {
1747 break;
1748 }
1749 }
1750
1751 if ( n == WXSIZEOF(ordinals) )
1752 {
1753 // stop here - something unknown
1754 break;
1755 }
1756
1757 // it's a day
1758 if ( haveDay )
1759 {
1760 // don't try anything here (as in case of numeric day
1761 // above) - the symbolic day spec should always
1762 // precede the month/year
1763 break;
1764 }
1765
1766 haveDay = true;
1767
1768 day = (wxDateTime_t)(n + 1);
1769 }
1770 }
1771 }
1772
1773 nPosCur = tok.GetPosition();
1774 }
1775
1776 // either no more tokens or the scan was stopped by something we couldn't
1777 // parse - in any case, see if we can construct a date from what we have
1778 if ( !haveDay && !haveWDay )
1779 return false;
1780
1781 if ( haveWDay && (haveMon || haveYear || haveDay) &&
1782 !(haveDay && haveMon && haveYear) )
1783 {
1784 // without adjectives (which we don't support here) the week day only
1785 // makes sense completely separately or with the full date
1786 // specification (what would "Wed 1999" mean?)
1787 return false;
1788 }
1789
1790 if ( !haveWDay && haveYear && !(haveDay && haveMon) )
1791 {
1792 // may be we have month and day instead of day and year?
1793 if ( haveDay && !haveMon )
1794 {
1795 if ( day <= 12 )
1796 {
1797 // exchange day and month
1798 mon = (wxDateTime::Month)(day - 1);
1799
1800 // we're in the current year then
1801 if ( (year > 0) && (year <= (int)GetNumberOfDays(mon, Inv_Year)) )
1802 {
1803 day = (wxDateTime_t)year;
1804
1805 haveMon = true;
1806 haveYear = false;
1807 }
1808 //else: no, can't exchange, leave haveMon == false
1809 }
1810 }
1811
1812 if ( !haveMon )
1813 return false;
1814 }
1815
1816 if ( !haveMon )
1817 {
1818 mon = GetCurrentMonth();
1819 }
1820
1821 if ( !haveYear )
1822 {
1823 year = GetCurrentYear();
1824 }
1825
1826 if ( haveDay )
1827 {
1828 // normally we check the day above but the check is optimistic in case
1829 // we find the day before its month/year so we have to redo it now
1830 if ( day > GetNumberOfDays(mon, year) )
1831 return false;
1832
1833 Set(day, mon, year);
1834
1835 if ( haveWDay )
1836 {
1837 // check that it is really the same
1838 if ( GetWeekDay() != wday )
1839 return false;
1840 }
1841 }
1842 else // haveWDay
1843 {
1844 *this = Today();
1845
1846 SetToWeekDayInSameWeek(wday);
1847 }
1848
1849 // return the pointer to the first unparsed char
1850 p += nPosCur;
1851 if ( nPosCur && wxStrchr(dateDelimiters, *(p - 1)) )
1852 {
1853 // if we couldn't parse the token after the delimiter, put back the
1854 // delimiter as well
1855 p--;
1856 }
1857
1858 *end = p;
1859
1860 return true;
1861 }
1862
1863 bool
1864 wxDateTime::ParseTime(const wxString& time, wxString::const_iterator *end)
1865 {
1866 wxCHECK_MSG( end, false, "end iterator pointer must be specified" );
1867
1868 // first try some extra things
1869 static const struct
1870 {
1871 const char *name;
1872 wxDateTime_t hour;
1873 } stdTimes[] =
1874 {
1875 { wxTRANSLATE("noon"), 12 },
1876 { wxTRANSLATE("midnight"), 00 },
1877 // anything else?
1878 };
1879
1880 for ( size_t n = 0; n < WXSIZEOF(stdTimes); n++ )
1881 {
1882 const wxString timeString = wxGetTranslation(stdTimes[n].name);
1883 const wxString::const_iterator p = time.begin() + timeString.length();
1884 if ( timeString.CmpNoCase(wxString(time.begin(), p)) == 0 )
1885 {
1886 // casts required by DigitalMars
1887 Set(stdTimes[n].hour, wxDateTime_t(0), wxDateTime_t(0));
1888
1889 if ( end )
1890 *end = p;
1891
1892 return true;
1893 }
1894 }
1895
1896 // try all time formats we may think about in the order from longest to
1897 // shortest
1898 static const char *timeFormats[] =
1899 {
1900 "%I:%M:%S %p", // 12hour with AM/PM
1901 "%H:%M:%S", // could be the same or 24 hour one so try it too
1902 "%I:%M %p", // 12hour with AM/PM but without seconds
1903 "%H:%M:%S", // and a possibly 24 hour version without seconds
1904 "%X", // possibly something from above or maybe something
1905 // completely different -- try it last
1906
1907 // TODO: parse timezones
1908 };
1909
1910 for ( size_t nFmt = 0; nFmt < WXSIZEOF(timeFormats); nFmt++ )
1911 {
1912 if ( ParseFormat(time, timeFormats[nFmt], end) )
1913 return true;
1914 }
1915
1916 return false;
1917 }
1918
1919 // ----------------------------------------------------------------------------
1920 // Workdays and holidays support
1921 // ----------------------------------------------------------------------------
1922
1923 bool wxDateTime::IsWorkDay(Country WXUNUSED(country)) const
1924 {
1925 return !wxDateTimeHolidayAuthority::IsHoliday(*this);
1926 }
1927
1928 // ============================================================================
1929 // wxDateSpan
1930 // ============================================================================
1931
1932 wxDateSpan WXDLLIMPEXP_BASE operator*(int n, const wxDateSpan& ds)
1933 {
1934 wxDateSpan ds1(ds);
1935 return ds1.Multiply(n);
1936 }
1937
1938 // ============================================================================
1939 // wxTimeSpan
1940 // ============================================================================
1941
1942 wxTimeSpan WXDLLIMPEXP_BASE operator*(int n, const wxTimeSpan& ts)
1943 {
1944 return wxTimeSpan(ts).Multiply(n);
1945 }
1946
1947 // this enum is only used in wxTimeSpan::Format() below but we can't declare
1948 // it locally to the method as it provokes an internal compiler error in egcs
1949 // 2.91.60 when building with -O2
1950 enum TimeSpanPart
1951 {
1952 Part_Week,
1953 Part_Day,
1954 Part_Hour,
1955 Part_Min,
1956 Part_Sec,
1957 Part_MSec
1958 };
1959
1960 // not all strftime(3) format specifiers make sense here because, for example,
1961 // a time span doesn't have a year nor a timezone
1962 //
1963 // Here are the ones which are supported (all of them are supported by strftime
1964 // as well):
1965 // %H hour in 24 hour format
1966 // %M minute (00 - 59)
1967 // %S second (00 - 59)
1968 // %% percent sign
1969 //
1970 // Also, for MFC CTimeSpan compatibility, we support
1971 // %D number of days
1972 //
1973 // And, to be better than MFC :-), we also have
1974 // %E number of wEeks
1975 // %l milliseconds (000 - 999)
1976 wxString wxTimeSpan::Format(const wxString& format) const
1977 {
1978 // we deal with only positive time spans here and just add the sign in
1979 // front for the negative ones
1980 if ( IsNegative() )
1981 {
1982 wxString str(Negate().Format(format));
1983 return "-" + str;
1984 }
1985
1986 wxCHECK_MSG( !format.empty(), wxEmptyString,
1987 _T("NULL format in wxTimeSpan::Format") );
1988
1989 wxString str;
1990 str.Alloc(format.length());
1991
1992 // Suppose we have wxTimeSpan ts(1 /* hour */, 2 /* min */, 3 /* sec */)
1993 //
1994 // Then, of course, ts.Format("%H:%M:%S") must return "01:02:03", but the
1995 // question is what should ts.Format("%S") do? The code here returns "3273"
1996 // in this case (i.e. the total number of seconds, not just seconds % 60)
1997 // because, for me, this call means "give me entire time interval in
1998 // seconds" and not "give me the seconds part of the time interval"
1999 //
2000 // If we agree that it should behave like this, it is clear that the
2001 // interpretation of each format specifier depends on the presence of the
2002 // other format specs in the string: if there was "%H" before "%M", we
2003 // should use GetMinutes() % 60, otherwise just GetMinutes() &c
2004
2005 // we remember the most important unit found so far
2006 TimeSpanPart partBiggest = Part_MSec;
2007
2008 for ( wxString::const_iterator pch = format.begin(); pch != format.end(); ++pch )
2009 {
2010 wxChar ch = *pch;
2011
2012 if ( ch == _T('%') )
2013 {
2014 // the start of the format specification of the printf() below
2015 wxString fmtPrefix(_T('%'));
2016
2017 // the number
2018 long n;
2019
2020 // the number of digits for the format string, 0 if unused
2021 unsigned digits = 0;
2022
2023 ch = *++pch; // get the format spec char
2024 switch ( ch )
2025 {
2026 default:
2027 wxFAIL_MSG( _T("invalid format character") );
2028 // fall through
2029
2030 case _T('%'):
2031 str += ch;
2032
2033 // skip the part below switch
2034 continue;
2035
2036 case _T('D'):
2037 n = GetDays();
2038 if ( partBiggest < Part_Day )
2039 {
2040 n %= DAYS_PER_WEEK;
2041 }
2042 else
2043 {
2044 partBiggest = Part_Day;
2045 }
2046 break;
2047
2048 case _T('E'):
2049 partBiggest = Part_Week;
2050 n = GetWeeks();
2051 break;
2052
2053 case _T('H'):
2054 n = GetHours();
2055 if ( partBiggest < Part_Hour )
2056 {
2057 n %= HOURS_PER_DAY;
2058 }
2059 else
2060 {
2061 partBiggest = Part_Hour;
2062 }
2063
2064 digits = 2;
2065 break;
2066
2067 case _T('l'):
2068 n = GetMilliseconds().ToLong();
2069 if ( partBiggest < Part_MSec )
2070 {
2071 n %= 1000;
2072 }
2073 //else: no need to reset partBiggest to Part_MSec, it is
2074 // the least significant one anyhow
2075
2076 digits = 3;
2077 break;
2078
2079 case _T('M'):
2080 n = GetMinutes();
2081 if ( partBiggest < Part_Min )
2082 {
2083 n %= MIN_PER_HOUR;
2084 }
2085 else
2086 {
2087 partBiggest = Part_Min;
2088 }
2089
2090 digits = 2;
2091 break;
2092
2093 case _T('S'):
2094 n = GetSeconds().ToLong();
2095 if ( partBiggest < Part_Sec )
2096 {
2097 n %= SEC_PER_MIN;
2098 }
2099 else
2100 {
2101 partBiggest = Part_Sec;
2102 }
2103
2104 digits = 2;
2105 break;
2106 }
2107
2108 if ( digits )
2109 {
2110 fmtPrefix << _T("0") << digits;
2111 }
2112
2113 str += wxString::Format(fmtPrefix + _T("ld"), n);
2114 }
2115 else
2116 {
2117 // normal character, just copy
2118 str += ch;
2119 }
2120 }
2121
2122 return str;
2123 }
2124
2125 #endif // wxUSE_DATETIME
wxWidgets (Impactor)