Updated wxvc_dll.dsp and memory.h to make VC++ compile in DLL mode again

[wxWidgets.git] / src / common / datetime.cpp

diff --git a/src/common/datetime.cpp b/src/common/datetime.cpp
index 10e5877e5ab1abdc5cf4a228b972599506f22a38..eae9bc33bfc3701125f5aa14ceaf2bdf636b8961 100644 (file)
--- a/src/common/datetime.cpp
+++ b/src/common/datetime.cpp
@@ -92,7 +92,7 @@
 #endif // broken strptime()
 
 #ifndef WX_TIMEZONE
 #endif // broken strptime()
 
 #ifndef WX_TIMEZONE

-    #if defined(__MINGW32__) || defined(__VISAGECPP__)
+    #if defined(__BORLANDC__) || defined(__MINGW32__) || defined(__VISAGECPP__)

         #define WX_TIMEZONE _timezone
     #else // unknown platform - try timezone
         #define WX_TIMEZONE timezone
         #define WX_TIMEZONE _timezone
     #else // unknown platform - try timezone
         #define WX_TIMEZONE timezone


@@ -137,13 +137,23 @@ static const wxDateTime::wxDateTime_t gs_cumulatedDays[2][MONTHS_IN_YEAR] =
 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------

-// globals
+// global data
+// ----------------------------------------------------------------------------
+
+static wxDateTime gs_dtDefault;
+
+wxDateTime& wxDefaultDateTime = gs_dtDefault;
+
+wxDateTime::Country wxDateTime::ms_country = wxDateTime::Country_Unknown;
+
+// ----------------------------------------------------------------------------
+// private globals

 // ----------------------------------------------------------------------------
 
 // a critical section is needed to protect GetTimeZone() static
 // variable in MT case
 #if wxUSE_THREADS
 // ----------------------------------------------------------------------------
 
 // a critical section is needed to protect GetTimeZone() static
 // variable in MT case
 #if wxUSE_THREADS

-    wxCriticalSection gs_critsectTimezone;
+    static wxCriticalSection gs_critsectTimezone;

 #endif // wxUSE_THREADS
 
 // ----------------------------------------------------------------------------
 #endif // wxUSE_THREADS
 
 // ----------------------------------------------------------------------------


@@ -364,13 +374,6 @@ static wxString GetAlphaToken(const wxChar*& p)
 // implementation of wxDateTime
 // ============================================================================
 
 // implementation of wxDateTime
 // ============================================================================
 

-// ----------------------------------------------------------------------------
-// static data
-// ----------------------------------------------------------------------------
-
-wxDateTime::Country wxDateTime::ms_country = wxDateTime::Country_Unknown;
-wxDateTime wxDateTime::ms_InvDateTime;
-

 // ----------------------------------------------------------------------------
 // struct Tm
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // struct Tm
 // ----------------------------------------------------------------------------


@@ -424,7 +427,7 @@ void wxDateTime::Tm::AddMonths(int monDiff)
         monDiff += MONTHS_IN_YEAR;
     }
 
         monDiff += MONTHS_IN_YEAR;
     }
 

-    while ( monDiff + mon > MONTHS_IN_YEAR )
+    while ( monDiff + mon >= MONTHS_IN_YEAR )

     {
         year++;
 
     {
         year++;
 


@@ -439,14 +442,14 @@ void wxDateTime::Tm::AddMonths(int monDiff)
 void wxDateTime::Tm::AddDays(int dayDiff)
 {
     // normalize the days field
 void wxDateTime::Tm::AddDays(int dayDiff)
 {
     // normalize the days field

-    mday += dayDiff;
-    while ( mday < 1 )
+    while ( dayDiff + mday < 1 )

     {
         AddMonths(-1);
 
     {
         AddMonths(-1);
 

-        mday += GetNumOfDaysInMonth(year, mon);
+        dayDiff += GetNumOfDaysInMonth(year, mon);

     }
 
     }
 

+    mday += dayDiff;

     while ( mday > GetNumOfDaysInMonth(year, mon) )
     {
         mday -= GetNumOfDaysInMonth(year, mon);
     while ( mday > GetNumOfDaysInMonth(year, mon) )
     {
         mday -= GetNumOfDaysInMonth(year, mon);


@@ -584,7 +587,6 @@ wxDateTime::Month wxDateTime::GetCurrentMonth(wxDateTime::Calendar cal)
     {
         case Gregorian:
             return Now().GetMonth();
     {
         case Gregorian:
             return Now().GetMonth();

-            break;

 
         case Julian:
             wxFAIL_MSG(_T("TODO"));
 
         case Julian:
             wxFAIL_MSG(_T("TODO"));


@@ -612,7 +614,6 @@ wxDateTime::wxDateTime_t wxDateTime::GetNumberOfDays(int year, Calendar cal)
         case Gregorian:
         case Julian:
             return IsLeapYear(year) ? 366 : 365;
         case Gregorian:
         case Julian:
             return IsLeapYear(year) ? 366 : 365;

-            break;

 
         default:
             wxFAIL_MSG(_T("unsupported calendar"));
 
         default:
             wxFAIL_MSG(_T("unsupported calendar"));


@@ -819,7 +820,7 @@ wxDateTime wxDateTime::GetBeginDST(int year, Country country)
 
     if ( !IsDSTApplicable(year, country) )
     {
 
     if ( !IsDSTApplicable(year, country) )
     {

-        return ms_InvDateTime;
+        return wxInvalidDateTime;

     }
 
     wxDateTime dt;
     }
 
     wxDateTime dt;


@@ -835,7 +836,8 @@ wxDateTime wxDateTime::GetBeginDST(int year, Country country)
 
         dt += wxTimeSpan::Hours(1);
 
 
         dt += wxTimeSpan::Hours(1);
 

-        dt.MakeGMT();
+        // disable DST tests because it could result in an infinite recursion!
+        dt.MakeGMT(TRUE);

     }
     else switch ( country )
     {
     }
     else switch ( country )
     {


@@ -919,7 +921,7 @@ wxDateTime wxDateTime::GetEndDST(int year, Country country)
 
     if ( !IsDSTApplicable(year, country) )
     {
 
     if ( !IsDSTApplicable(year, country) )
     {

-        return ms_InvDateTime;
+        return wxInvalidDateTime;

     }
 
     wxDateTime dt;
     }
 
     wxDateTime dt;


@@ -935,7 +937,8 @@ wxDateTime wxDateTime::GetEndDST(int year, Country country)
 
         dt += wxTimeSpan::Hours(1);
 
 
         dt += wxTimeSpan::Hours(1);
 

-        dt.MakeGMT();
+        // disable DST tests because it could result in an infinite recursion!
+        dt.MakeGMT(TRUE);

     }
     else switch ( country )
     {
     }
     else switch ( country )
     {


@@ -1010,7 +1013,7 @@ wxDateTime& wxDateTime::Set(const struct tm& tm)
 
         wxFAIL_MSG( _T("mktime() failed") );
 
 
         wxFAIL_MSG( _T("mktime() failed") );
 

-        return ms_InvDateTime;
+        return wxInvalidDateTime;

     }
     else
     {
     }
     else
     {


@@ -1028,14 +1031,13 @@ wxDateTime& wxDateTime::Set(wxDateTime_t hour,
     // we allow seconds to be 61 to account for the leap seconds, even if we
     // don't use them really
     wxCHECK_MSG( hour < 24 && second < 62 && minute < 60 && millisec < 1000,
     // we allow seconds to be 61 to account for the leap seconds, even if we
     // don't use them really
     wxCHECK_MSG( hour < 24 && second < 62 && minute < 60 && millisec < 1000,

-                 ms_InvDateTime,
+                 wxInvalidDateTime,

                  _T("Invalid time in wxDateTime::Set()") );
 
     // get the current date from system
                  _T("Invalid time in wxDateTime::Set()") );
 
     // get the current date from system

-    time_t timet = GetTimeNow();
-    struct tm *tm = localtime(&timet);
+    struct tm *tm = GetTmNow();

 
 

-    wxCHECK_MSG( tm, ms_InvDateTime, _T("localtime() failed") );
+    wxCHECK_MSG( tm, wxInvalidDateTime, _T("localtime() failed") );

 
     // adjust the time
     tm->tm_hour = hour;
 
     // adjust the time
     tm->tm_hour = hour;


@@ -1059,13 +1061,13 @@ wxDateTime& wxDateTime::Set(wxDateTime_t day,
     wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
 
     wxCHECK_MSG( hour < 24 && second < 62 && minute < 60 && millisec < 1000,
     wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
 
     wxCHECK_MSG( hour < 24 && second < 62 && minute < 60 && millisec < 1000,

-                 ms_InvDateTime,
+                 wxInvalidDateTime,

                  _T("Invalid time in wxDateTime::Set()") );
 
     ReplaceDefaultYearMonthWithCurrent(&year, &month);
 
     wxCHECK_MSG( (0 < day) && (day <= GetNumberOfDays(month, year)),
                  _T("Invalid time in wxDateTime::Set()") );
 
     ReplaceDefaultYearMonthWithCurrent(&year, &month);
 
     wxCHECK_MSG( (0 < day) && (day <= GetNumberOfDays(month, year)),

-                 ms_InvDateTime,
+                 wxInvalidDateTime,

                  _T("Invalid date in wxDateTime::Set()") );
 
     // the range of time_t type (inclusive)
                  _T("Invalid date in wxDateTime::Set()") );
 
     // the range of time_t type (inclusive)


@@ -1117,7 +1119,24 @@ wxDateTime& wxDateTime::Set(double jdn)
 
     jdn *= MILLISECONDS_PER_DAY;
 
 
     jdn *= MILLISECONDS_PER_DAY;
 

-    m_time = jdn;
+    m_time.Assign(jdn);
+
+    return *this;
+}
+
+wxDateTime& wxDateTime::ResetTime()
+{
+    Tm tm = GetTm();
+
+    if ( tm.hour || tm.min || tm.sec || tm.msec )
+    {
+        tm.msec =
+        tm.sec =
+        tm.min =
+        tm.hour = 0;
+
+        Set(tm);
+    }

 
     return *this;
 }
 
     return *this;
 }


@@ -1128,9 +1147,6 @@ wxDateTime& wxDateTime::Set(double jdn)
 
 wxDateTime::Tm wxDateTime::GetTm(const TimeZone& tz) const
 {
 
 wxDateTime::Tm wxDateTime::GetTm(const TimeZone& tz) const
 {

-#ifdef __VMS__
-   int time2;
-#endif

     wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
 
     time_t time = GetTicks();
     wxASSERT_MSG( IsValid(), _T("invalid wxDateTime") );
 
     time_t time = GetTicks();


@@ -1148,12 +1164,12 @@ wxDateTime::Tm wxDateTime::GetTm(const TimeZone& tz) const
         }
         else
         {
         }
         else
         {

-            time += tz.GetOffset();
-#ifdef __VMS__ /* time is unsigned so VMS gives a warning on the original */
-          time2 = (int) time;
-          if ( time2 >= 0 )
+            time += (time_t)tz.GetOffset();
+#ifdef __VMS__ // time is unsigned so avoid warning
+            int time2 = (int) time;
+            if ( time2 >= 0 )

 #else
 #else

-          if ( time >= 0 )
+            if ( time >= 0 )

 #endif
             {
                 tm = gmtime(&time);
 #endif
             {
                 tm = gmtime(&time);


@@ -1346,6 +1362,9 @@ wxDateTime& wxDateTime::Add(const wxDateSpan& diff)
 
     Set(tm);
 
 
     Set(tm);
 

+    wxASSERT_MSG( IsSameTime(tm),
+                  _T("Add(wxDateSpan) shouldn't modify time") );
+

     return *this;
 }
 
     return *this;
 }
 


@@ -1357,14 +1376,17 @@ wxDateTime& wxDateTime::SetToLastMonthDay(Month month,
                                           int year)
 {
     // take the current month/year if none specified
                                           int year)
 {
     // take the current month/year if none specified

-    ReplaceDefaultYearMonthWithCurrent(&year, &month);
+    if ( year == Inv_Year )
+        year = GetYear();
+    if ( month == Inv_Month )
+        month = GetMonth();

 
     return Set(GetNumOfDaysInMonth(year, month), month, year);
 }
 
 wxDateTime& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday)
 {
 
     return Set(GetNumOfDaysInMonth(year, month), month, year);
 }
 
 wxDateTime& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday)
 {

-    wxCHECK_MSG( weekday != Inv_WeekDay, ms_InvDateTime, _T("invalid weekday") );
+    wxCHECK_MSG( weekday != Inv_WeekDay, wxInvalidDateTime, _T("invalid weekday") );

 
     WeekDay wdayThis = GetWeekDay();
     if ( weekday == wdayThis )
 
     WeekDay wdayThis = GetWeekDay();
     if ( weekday == wdayThis )


@@ -1384,7 +1406,7 @@ wxDateTime& wxDateTime::SetToWeekDayInSameWeek(WeekDay weekday)
 
 wxDateTime& wxDateTime::SetToNextWeekDay(WeekDay weekday)
 {
 
 wxDateTime& wxDateTime::SetToNextWeekDay(WeekDay weekday)
 {

-    wxCHECK_MSG( weekday != Inv_WeekDay, ms_InvDateTime, _T("invalid weekday") );
+    wxCHECK_MSG( weekday != Inv_WeekDay, wxInvalidDateTime, _T("invalid weekday") );

 
     int diff;
     WeekDay wdayThis = GetWeekDay();
 
     int diff;
     WeekDay wdayThis = GetWeekDay();


@@ -1408,7 +1430,7 @@ wxDateTime& wxDateTime::SetToNextWeekDay(WeekDay weekday)
 
 wxDateTime& wxDateTime::SetToPrevWeekDay(WeekDay weekday)
 {
 
 wxDateTime& wxDateTime::SetToPrevWeekDay(WeekDay weekday)
 {

-    wxCHECK_MSG( weekday != Inv_WeekDay, ms_InvDateTime, _T("invalid weekday") );
+    wxCHECK_MSG( weekday != Inv_WeekDay, wxInvalidDateTime, _T("invalid weekday") );

 
     int diff;
     WeekDay wdayThis = GetWeekDay();
 
     int diff;
     WeekDay wdayThis = GetWeekDay();


@@ -1505,47 +1527,50 @@ wxDateTime::wxDateTime_t wxDateTime::GetDayOfYear(const TimeZone& tz) const
     return gs_cumulatedDays[IsLeapYear(tm.year)][tm.mon] + tm.mday;
 }
 
     return gs_cumulatedDays[IsLeapYear(tm.year)][tm.mon] + tm.mday;
 }
 

-wxDateTime::wxDateTime_t wxDateTime::GetWeekOfYear(const TimeZone& tz) const
+wxDateTime::wxDateTime_t wxDateTime::GetWeekOfYear(wxDateTime::WeekFlags flags,
+                                                   const TimeZone& tz) const

 {
 {

-#if 0
-    // the first week of the year is the one which contains Jan, 4 (according
-    // to ISO standard rule), so the year day N0 = 4 + 7*W always lies in the
-    // week W+1. As any day N = 7*W + 4 + (N - 4)%7, it lies in the same week
-    // as N0 or in the next one.
-
-    // TODO this surely may be optimized - I got confused while writing it
+    if ( flags == Default_First )
+    {
+        flags = GetCountry() == USA ? Sunday_First : Monday_First;
+    }

 
     wxDateTime_t nDayInYear = GetDayOfYear(tz);
 
     wxDateTime_t nDayInYear = GetDayOfYear(tz);

+    wxDateTime_t week;

 
 

-    // the week day of the day lying in the first week
-    WeekDay wdayStart = wxDateTime(4, Jan, GetYear()).GetWeekDay();
-
-    wxDateTime_t week = (nDayInYear - 4) / 7 + 1;
+    WeekDay wd = GetWeekDay(tz);
+    if ( flags == Sunday_First )
+    {
+        week = (nDayInYear - wd + 7) / 7;
+    }
+    else
+    {
+        // have to shift the week days values
+        week = (nDayInYear - (wd - 1 + 7) % 7 + 7) / 7;
+    }

 
 

-    // notice that Sunday shoould be counted as 7, not 0 here!
-    if ( ((nDayInYear - 4) % 7) + (!wdayStart ? 7 : wdayStart) > 7 )
+    // FIXME some more elegant way??
+    WeekDay wdYearStart = wxDateTime(1, Jan, GetYear()).GetWeekDay();
+    if ( wdYearStart == Wed || wdYearStart == Thu )

     {
         week++;
     }
 
     return week;
     {
         week++;
     }
 
     return week;

-#else // this seems to be a bit simpler and I believe is also correct
-    return (WeekDay)((GetDayOfYear() - (GetWeekDay() - 1 + 7) % 7 + 7) / 7);
-#endif // 0/1

 }
 
 }
 

-wxDateTime::wxDateTime_t wxDateTime::GetWeekOfMonth(const TimeZone& tz) const
+wxDateTime::wxDateTime_t wxDateTime::GetWeekOfMonth(wxDateTime::WeekFlags flags,
+                                                    const TimeZone& tz) const

 {
 {

-    size_t nWeek = 0;
-
-    wxDateTime dt(*this);
-    do
+    Tm tm = GetTm(tz);
+    wxDateTime dtMonthStart = wxDateTime(1, tm.mon, tm.year);
+    size_t nWeek = GetWeekOfYear(flags) - dtMonthStart.GetWeekOfYear(flags) + 1;
+    if ( nWeek < 0 )

     {
     {

-        nWeek++;
-
-        dt -= wxTimeSpan::Week();
+        // this may happen for January when Jan, 1 is the last week of the
+        // previous year
+        nWeek += IsLeapYear(tm.year - 1) ? 53 : 52;

     }
     }

-    while ( dt.GetMonth(tz) == GetMonth(tz) );

 
     return nWeek;
 }
 
     return nWeek;
 }


@@ -1554,7 +1579,7 @@ wxDateTime& wxDateTime::SetToYearDay(wxDateTime::wxDateTime_t yday)
 {
     int year = GetYear();
     wxCHECK_MSG( (0 < yday) && (yday <= GetNumberOfDays(year)),
 {
     int year = GetYear();
     wxCHECK_MSG( (0 < yday) && (yday <= GetNumberOfDays(year)),

-                 ms_InvDateTime, _T("invalid year day") );
+                 wxInvalidDateTime, _T("invalid year day") );

 
     bool isLeap = IsLeapYear(year);
     for ( Month mon = Jan; mon < Inv_Month; wxNextMonth(mon) )
 
     bool isLeap = IsLeapYear(year);
     for ( Month mon = Jan; mon < Inv_Month; wxNextMonth(mon) )


@@ -1630,12 +1655,13 @@ int wxDateTime::IsDST(wxDateTime::Country country) const
     }
 }
 
     }
 }
 

-wxDateTime& wxDateTime::MakeTimezone(const TimeZone& tz)
+wxDateTime& wxDateTime::MakeTimezone(const TimeZone& tz, bool noDST)

 {
     int secDiff = GetTimeZone() + tz.GetOffset();
 
 {
     int secDiff = GetTimeZone() + tz.GetOffset();
 

-    // we need to know whether DST is or not in effect for this date
-    if ( IsDST() == 1 )
+    // we need to know whether DST is or not in effect for this date unless
+    // the test disabled by the caller
+    if ( !noDST && (IsDST() == 1) )

     {
         // FIXME we assume that the DST is always shifted by 1 hour
         secDiff -= 3600;
     {
         // FIXME we assume that the DST is always shifted by 1 hour
         secDiff -= 3600;


@@ -1650,9 +1676,6 @@ wxDateTime& wxDateTime::MakeTimezone(const TimeZone& tz)
 
 wxString wxDateTime::Format(const wxChar *format, const TimeZone& tz) const
 {
 
 wxString wxDateTime::Format(const wxChar *format, const TimeZone& tz) const
 {

-#ifdef __VMS__
-   int time2;
-#endif

     wxCHECK_MSG( format, _T(""), _T("NULL format in wxDateTime::Format") );
 
     time_t time = GetTicks();
     wxCHECK_MSG( format, _T(""), _T("NULL format in wxDateTime::Format") );
 
     time_t time = GetTicks();


@@ -1672,11 +1695,11 @@ wxString wxDateTime::Format(const wxChar *format, const TimeZone& tz) const
         {
             time += tz.GetOffset();
 
         {
             time += tz.GetOffset();
 

-#ifdef __VMS__ /* time is unsigned so VMS gives a warning on the original */
-          time2 = (int) time;
-          if ( time2 >= 0 )
+#ifdef __VMS__ // time is unsigned so avoid the warning
+            int time2 = (int) time;
+            if ( time2 >= 0 )

 #else
 #else

-          if ( time >= 0 )
+            if ( time >= 0 )

 #endif
             {
                 tm = gmtime(&time);
 #endif
             {
                 tm = gmtime(&time);


@@ -1931,14 +1954,11 @@ restart:
                 break;
 
             case _T('U'):       // week number in the year (Sunday 1st week day)
                 break;
 
             case _T('U'):       // week number in the year (Sunday 1st week day)

-                {
-                    int week = (GetDayOfYear(tz) - tm.GetWeekDay() + 7) / 7;
-                    res += wxString::Format(fmt, week);
-                }
+                res += wxString::Format(fmt, GetWeekOfYear(Sunday_First, tz));

                 break;
 
             case _T('W'):       // week number in the year (Monday 1st week day)
                 break;
 
             case _T('W'):       // week number in the year (Monday 1st week day)

-                res += wxString::Format(fmt, GetWeekOfYear(tz));
+                res += wxString::Format(fmt, GetWeekOfYear(Monday_First, tz));

                 break;
 
             case _T('w'):       // weekday as a number (0-6), Sunday = 0
                 break;
 
             case _T('w'):       // weekday as a number (0-6), Sunday = 0


@@ -2293,7 +2313,7 @@ const wxChar *wxDateTime::ParseRfc822Date(const wxChar* date)
 
     // the spec was correct
     Set(day, mon, year, hour, min, sec);
 
     // the spec was correct
     Set(day, mon, year, hour, min, sec);

-    MakeTimezone(60*offset);
+    MakeTimezone((wxDateTime_t)(60*offset));

 
     return p;
 }
 
     return p;
 }


@@ -2397,7 +2417,7 @@ const wxChar *wxDateTime::ParseFormat(const wxChar *date,
 
                     // this is the format which corresponds to ctime() output
                     // and strptime("%c") should parse it, so try it first
 
                     // 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 %e %H:%M:%S %Y");
+                    static const wxChar *fmtCtime = _T("%a %b %d %H:%M:%S %Y");

 
                     const wxChar *result = dt.ParseFormat(input, fmtCtime);
                     if ( !result )
 
                     const wxChar *result = dt.ParseFormat(input, fmtCtime);
                     if ( !result )


@@ -2623,18 +2643,27 @@ const wxChar *wxDateTime::ParseFormat(const wxChar *date,
                 {
                     wxDateTime dt;
 
                 {
                     wxDateTime dt;
 

-                    wxString fmtDate;
+                    wxString fmtDate, fmtDateAlt;

                     if ( IsWestEuropeanCountry(GetCountry()) ||
                          GetCountry() == Russia )
                     {
                         fmtDate = _T("%d/%m/%y");
                     if ( IsWestEuropeanCountry(GetCountry()) ||
                          GetCountry() == Russia )
                     {
                         fmtDate = _T("%d/%m/%y");

+                        fmtDateAlt = _T("%m/%d/%y");

                     }
                     else // assume USA
                     {
                         fmtDate = _T("%m/%d/%y");
                     }
                     else // assume USA
                     {
                         fmtDate = _T("%m/%d/%y");

+                        fmtDateAlt = _T("%d/%m/%y");

                     }
 
                     const wxChar *result = dt.ParseFormat(input, fmtDate);
                     }
 
                     const wxChar *result = dt.ParseFormat(input, fmtDate);

+
+                    if ( !result )
+                    {
+                        // ok, be nice and try another one
+                        result = dt.ParseFormat(input, fmtDateAlt);
+                    }
+

                     if ( !result )
                     {
                         // bad luck
                     if ( !result )
                     {
                         // bad luck


@@ -2882,7 +2911,7 @@ const wxChar *wxDateTime::ParseDate(const wxChar *date)
     int year = 0;
 
     // tokenize the string
     int year = 0;
 
     // tokenize the string

-    wxStringTokenizer tok(p, _T(",/-\t "));
+    wxStringTokenizer tok(p, _T(",/-\t\n "));

     while ( tok.HasMoreTokens() )
     {
         wxString token = tok.GetNextToken();
     while ( tok.HasMoreTokens() )
     {
         wxString token = tok.GetNextToken();