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