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


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