+ // this is the format which corresponds to ctime() output
+ // and strptime("%c") should parse it, so try it first
+ static const wxChar *fmtCtime = _T("%a %b %d %H:%M:%S %Y");
+
+ const wxChar *result = dt.ParseFormat(input, fmtCtime);
+ if ( !result )
+ {
+ result = dt.ParseFormat(input, _T("%x %X"));
+ }
+
+ if ( !result )
+ {
+ result = dt.ParseFormat(input, _T("%X %x"));
+ }
+
+ if ( !result )
+ {
+ // we've tried everything and still no match
+ return (wxChar *)NULL;
+ }
+
+ Tm tm = dt.GetTm();
+
+ haveDay = haveMon = haveYear =
+ haveHour = haveMin = haveSec = true;
+
+ hour = tm.hour;
+ min = tm.min;
+ sec = tm.sec;
+
+ year = tm.year;
+ mon = tm.mon;
+ mday = tm.mday;
+
+ input = result;
+ }
+ break;
+
+ case _T('d'): // day of a month (01-31)
+ if ( !GetNumericToken(width, input, &num) ||
+ (num > 31) || (num < 1) )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+
+ // we can't check whether the day range is correct yet, will
+ // do it later - assume ok for now
+ haveDay = true;
+ mday = (wxDateTime_t)num;
+ break;
+
+ case _T('H'): // hour in 24h format (00-23)
+ if ( !GetNumericToken(width, input, &num) || (num > 23) )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+
+ haveHour = true;
+ hour = (wxDateTime_t)num;
+ break;
+
+ case _T('I'): // hour in 12h format (01-12)
+ if ( !GetNumericToken(width, input, &num) || !num || (num > 12) )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+
+ haveHour = true;
+ hourIsIn12hFormat = true;
+ hour = (wxDateTime_t)(num % 12); // 12 should be 0
+ break;
+
+ case _T('j'): // day of the year
+ if ( !GetNumericToken(width, input, &num) || !num || (num > 366) )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+
+ haveYDay = true;
+ yday = (wxDateTime_t)num;
+ break;
+
+ case _T('m'): // month as a number (01-12)
+ if ( !GetNumericToken(width, input, &num) || !num || (num > 12) )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+
+ haveMon = true;
+ mon = (Month)(num - 1);
+ break;
+
+ case _T('M'): // minute as a decimal number (00-59)
+ if ( !GetNumericToken(width, input, &num) || (num > 59) )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+
+ haveMin = true;
+ min = (wxDateTime_t)num;
+ break;
+
+ case _T('p'): // AM or PM string
+ {
+ wxString am, pm, token = GetAlphaToken(input);
+
+ GetAmPmStrings(&am, &pm);
+ if (am.empty() && pm.empty())
+ return (wxChar *)NULL; // no am/pm strings defined
+ if ( token.CmpNoCase(pm) == 0 )
+ {
+ isPM = true;
+ }
+ else if ( token.CmpNoCase(am) != 0 )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+ }
+ break;
+
+ case _T('r'): // time as %I:%M:%S %p
+ {
+ wxDateTime dt;
+ input = dt.ParseFormat(input, _T("%I:%M:%S %p"));
+ if ( !input )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+
+ haveHour = haveMin = haveSec = true;
+
+ Tm tm = dt.GetTm();
+ hour = tm.hour;
+ min = tm.min;
+ sec = tm.sec;
+ }
+ break;
+
+ case _T('R'): // time as %H:%M
+ {
+ wxDateTime dt;
+ input = dt.ParseFormat(input, _T("%H:%M"));
+ if ( !input )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+
+ haveHour = haveMin = true;
+
+ Tm tm = dt.GetTm();
+ hour = tm.hour;
+ min = tm.min;
+ }
+ break;
+
+ case _T('S'): // second as a decimal number (00-61)
+ if ( !GetNumericToken(width, input, &num) || (num > 61) )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+
+ haveSec = true;
+ sec = (wxDateTime_t)num;
+ break;
+
+ case _T('T'): // time as %H:%M:%S
+ {
+ wxDateTime dt;
+ input = dt.ParseFormat(input, _T("%H:%M:%S"));
+ if ( !input )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+
+ haveHour = haveMin = haveSec = true;
+
+ Tm tm = dt.GetTm();
+ hour = tm.hour;
+ min = tm.min;
+ sec = tm.sec;
+ }
+ break;
+
+ case _T('w'): // weekday as a number (0-6), Sunday = 0
+ if ( !GetNumericToken(width, input, &num) || (wday > 6) )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+
+ haveWDay = true;
+ wday = (WeekDay)num;
+ break;
+
+ case _T('x'): // locale default date representation
+#ifdef HAVE_STRPTIME
+ // try using strptime() -- it may fail even if the input is
+ // correct but the date is out of range, so we will fall back
+ // to our generic code anyhow
+ {
+ struct tm tm;
+
+ const wxChar *result = CallStrptime(input, "%x", &tm);
+ if ( result )
+ {
+ input = result;
+
+ haveDay = haveMon = haveYear = true;
+
+ year = 1900 + tm.tm_year;
+ mon = (Month)tm.tm_mon;
+ mday = tm.tm_mday;
+
+ break;
+ }
+ }
+#endif // HAVE_STRPTIME
+
+ {
+ wxDateTime dt;
+ wxString fmtDate,
+ fmtDateAlt;
+
+#ifdef __WINDOWS__
+ // The above doesn't work for all locales, try to query
+ // Windows for the right way of formatting the date:
+ fmtDate = GetLocaleDateFormat();
+ if ( fmtDate.empty() )
+#endif
+ {
+ if ( IsWestEuropeanCountry(GetCountry()) ||
+ GetCountry() == Russia )
+ {
+ fmtDate = _T("%d/%m/%y");
+ fmtDateAlt = _T("%m/%d/%y");
+ }
+ else // assume USA
+ {
+ fmtDate = _T("%m/%d/%y");
+ fmtDateAlt = _T("%d/%m/%y");
+ }
+ }
+
+ const wxChar *result = dt.ParseFormat(input, fmtDate);
+
+ if ( !result && !fmtDateAlt.empty() )
+ {
+ // ok, be nice and try another one
+ result = dt.ParseFormat(input, fmtDateAlt);
+ }
+
+ if ( !result )
+ {
+ // bad luck
+ return (wxChar *)NULL;
+ }
+
+ Tm tm = dt.GetTm();
+
+ haveDay = haveMon = haveYear = true;
+
+ year = tm.year;
+ mon = tm.mon;
+ mday = tm.mday;
+
+ input = result;
+ }
+
+ break;
+
+ case _T('X'): // locale default time representation
+#ifdef HAVE_STRPTIME
+ {
+ // use strptime() to do it for us (FIXME !Unicode friendly)
+ struct tm tm;
+ input = CallStrptime(input, "%X", &tm);
+ if ( !input )
+ {
+ return (wxChar *)NULL;
+ }
+
+ haveHour = haveMin = haveSec = true;
+
+ hour = tm.tm_hour;
+ min = tm.tm_min;
+ sec = tm.tm_sec;
+ }
+#else // !HAVE_STRPTIME
+ // TODO under Win32 we can query the LOCALE_ITIME system
+ // setting which says whether the default time format is
+ // 24 or 12 hour
+ {
+ // try to parse what follows as "%H:%M:%S" and, if this
+ // fails, as "%I:%M:%S %p" - this should catch the most
+ // common cases
+ wxDateTime dt;
+
+ const wxChar *result = dt.ParseFormat(input, _T("%T"));
+ if ( !result )
+ {
+ result = dt.ParseFormat(input, _T("%r"));
+ }
+
+ if ( !result )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+
+ haveHour = haveMin = haveSec = true;
+
+ Tm tm = dt.GetTm();
+ hour = tm.hour;
+ min = tm.min;
+ sec = tm.sec;
+
+ input = result;
+ }
+#endif // HAVE_STRPTIME/!HAVE_STRPTIME
+ break;
+
+ case _T('y'): // year without century (00-99)
+ if ( !GetNumericToken(width, input, &num) || (num > 99) )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+
+ haveYear = true;
+
+ // TODO should have an option for roll over date instead of
+ // hard coding it here
+ year = (num > 30 ? 1900 : 2000) + (wxDateTime_t)num;
+ break;
+
+ case _T('Y'): // year with century
+ if ( !GetNumericToken(width, input, &num) )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+
+ haveYear = true;
+ year = (wxDateTime_t)num;
+ break;
+
+ case _T('Z'): // timezone name
+ wxFAIL_MSG(_T("TODO"));
+ break;
+
+ case _T('%'): // a percent sign
+ if ( *input++ != _T('%') )
+ {
+ // no match
+ return (wxChar *)NULL;
+ }
+ break;
+
+ case 0: // the end of string
+ wxFAIL_MSG(_T("unexpected format end"));
+
+ // fall through
+
+ default: // not a known format spec
+ return (wxChar *)NULL;
+ }
+ }
+
+ // format matched, try to construct a date from what we have now
+ Tm tmDef;
+ if ( dateDef.IsValid() )
+ {
+ // take this date as default
+ tmDef = dateDef.GetTm();
+ }
+ else if ( IsValid() )
+ {
+ // if this date is valid, don't change it
+ tmDef = GetTm();
+ }
+ else
+ {
+ // no default and this date is invalid - fall back to Today()
+ tmDef = Today().GetTm();
+ }
+
+ Tm tm = tmDef;
+
+ // set the date
+ if ( haveYear )
+ {
+ tm.year = year;
+ }
+
+ // TODO we don't check here that the values are consistent, if both year
+ // day and month/day were found, we just ignore the year day and we
+ // also always ignore the week day
+ if ( haveMon && haveDay )
+ {
+ if ( mday > GetNumOfDaysInMonth(tm.year, mon) )
+ {
+ wxLogDebug(_T("bad month day in wxDateTime::ParseFormat"));
+
+ return (wxChar *)NULL;
+ }
+
+ tm.mon = mon;
+ tm.mday = mday;
+ }
+ else if ( haveYDay )
+ {
+ if ( yday > GetNumberOfDays(tm.year) )
+ {
+ wxLogDebug(_T("bad year day in wxDateTime::ParseFormat"));
+
+ return (wxChar *)NULL;
+ }
+
+ Tm tm2 = wxDateTime(1, Jan, tm.year).SetToYearDay(yday).GetTm();
+
+ tm.mon = tm2.mon;
+ tm.mday = tm2.mday;
+ }
+
+ // deal with AM/PM
+ if ( haveHour && hourIsIn12hFormat && isPM )
+ {
+ // translate to 24hour format
+ hour += 12;
+ }
+ //else: either already in 24h format or no translation needed
+
+ // set the time
+ if ( haveHour )
+ {
+ tm.hour = hour;
+ }
+
+ if ( haveMin )
+ {
+ tm.min = min;
+ }
+
+ if ( haveSec )
+ {
+ tm.sec = sec;
+ }
+
+ Set(tm);
+
+ // finally check that the week day is consistent -- if we had it
+ if ( haveWDay && GetWeekDay() != wday )
+ {
+ wxLogDebug(_T("inconsistsnet week day in wxDateTime::ParseFormat()"));
+
+ return NULL;
+ }
+
+ return input;
+}
+
+const wxChar *wxDateTime::ParseDateTime(const wxChar *date)
+{
+ wxCHECK_MSG( date, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
+
+ // Set to current day and hour, so strings like '14:00' becomes today at
+ // 14, not some other random date
+ wxDateTime dtDate = wxDateTime::Today();
+ wxDateTime dtTime = wxDateTime::Today();
+
+ const wxChar* pchTime;
+
+ // Try to parse the beginning of the string as a date
+ const wxChar* pchDate = dtDate.ParseDate(date);
+
+ // We got a date in the beginning, see if there is a time specified after the date
+ if ( pchDate )
+ {
+ // Skip spaces, as the ParseTime() function fails on spaces
+ while ( wxIsspace(*pchDate) )
+ pchDate++;
+
+ pchTime = dtTime.ParseTime(pchDate);
+ }
+ else // no date in the beginning
+ {
+ // check and see if we have a time followed by a date
+ pchTime = dtTime.ParseTime(date);
+ if ( pchTime )
+ {
+ while ( wxIsspace(*pchTime) )
+ pchTime++;
+
+ pchDate = dtDate.ParseDate(pchTime);
+ }
+ }
+
+ // If we have a date specified, set our own data to the same date
+ if ( !pchDate || !pchTime )
+ return NULL;
+
+ Set(dtDate.GetDay(), dtDate.GetMonth(), dtDate.GetYear(),
+ dtTime.GetHour(), dtTime.GetMinute(), dtTime.GetSecond(),
+ dtTime.GetMillisecond());
+
+ // Return endpoint of scan
+ return pchDate > pchTime ? pchDate : pchTime;
+}
+
+const wxChar *wxDateTime::ParseDate(const wxChar *date)
+{
+ // this is a simplified version of ParseDateTime() which understands only
+ // "today" (for wxDate compatibility) and digits only otherwise (and not
+ // all esoteric constructions ParseDateTime() knows about)
+
+ wxCHECK_MSG( date, (wxChar *)NULL, _T("NULL pointer in wxDateTime::Parse") );
+
+ const wxChar *p = date;
+ while ( wxIsspace(*p) )
+ p++;
+
+ // some special cases
+ static struct
+ {
+ const wxChar *str;
+ int dayDiffFromToday;
+ } literalDates[] =
+ {
+ { wxTRANSLATE("today"), 0 },
+ { wxTRANSLATE("yesterday"), -1 },
+ { wxTRANSLATE("tomorrow"), 1 },
+ };
+
+ for ( size_t n = 0; n < WXSIZEOF(literalDates); n++ )
+ {
+ const wxString dateStr = wxGetTranslation(literalDates[n].str);
+ size_t len = dateStr.length();
+ if ( wxStrlen(p) >= len )
+ {
+ wxString str(p, len);
+ if ( str.CmpNoCase(dateStr) == 0 )
+ {
+ // nothing can follow this, so stop here
+ p += len;
+
+ int dayDiffFromToday = literalDates[n].dayDiffFromToday;
+ *this = Today();
+ if ( dayDiffFromToday )
+ {
+ *this += wxDateSpan::Days(dayDiffFromToday);
+ }
+
+ return p;
+ }
+ }
+ }
+
+ // We try to guess what we have here: for each new (numeric) token, we
+ // determine if it can be a month, day or a year. Of course, there is an
+ // ambiguity as some numbers may be days as well as months, so we also
+ // have the ability to back track.
+
+ // what do we have?
+ bool haveDay = false, // the months day?
+ haveWDay = false, // the day of week?
+ haveMon = false, // the month?
+ haveYear = false; // the year?
+
+ // and the value of the items we have (init them to get rid of warnings)
+ WeekDay wday = Inv_WeekDay;
+ wxDateTime_t day = 0;
+ wxDateTime::Month mon = Inv_Month;
+ int year = 0;
+
+ // tokenize the string
+ size_t nPosCur = 0;
+ static const wxChar *dateDelimiters = _T(".,/-\t\r\n ");
+ wxStringTokenizer tok(p, dateDelimiters);
+ while ( tok.HasMoreTokens() )
+ {
+ wxString token = tok.GetNextToken();
+ if ( !token )
+ continue;
+
+ // is it a number?
+ unsigned long val;
+ if ( token.ToULong(&val) )
+ {
+ // guess what this number is
+
+ bool isDay = false,
+ isMonth = false,
+ isYear = false;
+
+ if ( !haveMon && val > 0 && val <= 12 )
+ {
+ // assume it is month
+ isMonth = true;
+ }
+ else // not the month
+ {
+ if ( haveDay )
+ {
+ // this can only be the year
+ isYear = true;
+ }
+ else // may be either day or year
+ {
+ // use a leap year if we don't have the year yet to allow
+ // dates like 2/29/1976 which would be rejected otherwise
+ wxDateTime_t max_days = (wxDateTime_t)(
+ haveMon
+ ? GetNumOfDaysInMonth(haveYear ? year : 1976, mon)
+ : 31
+ );
+
+ // can it be day?
+ if ( (val == 0) || (val > (unsigned long)max_days) )
+ {
+ // no
+ isYear = true;
+ }
+ else // yes, suppose it's the day
+ {
+ isDay = true;
+ }
+ }
+ }
+
+ if ( isYear )
+ {
+ if ( haveYear )
+ break;
+
+ haveYear = true;
+
+ year = (wxDateTime_t)val;
+ }
+ else if ( isDay )
+ {
+ if ( haveDay )
+ break;
+
+ haveDay = true;
+
+ day = (wxDateTime_t)val;
+ }
+ else if ( isMonth )
+ {
+ haveMon = true;
+
+ mon = (Month)(val - 1);
+ }
projects / wxWidgets.git / blobdiff