src/msw/wince/time.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/wince/time.cpp
   3 // Purpose:     Implements missing time functionality for WinCE
   4 // Author:      Marco Cavallini (MCK) - wx@koansoftware.com
   5 // Modified by: Vadim Zeitlin for VC8 support
   6 // Created:     31-08-2003
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Marco Cavallini
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ===========================================================================
  13 // declarations
  14 // ===========================================================================
  15
  16 // ---------------------------------------------------------------------------
  17 // headers
  18 // ---------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/msw/wrapwin.h"
  29 #endif
  30
  31 #include "wx/msw/wince/time.h"
  32
  33 #if defined(__VISUALC__) && (__VISUALC__ >= 1400)
  34
  35 // VC8 does provide the time functions but not the standard ones
  36 #include <altcecrt.h>
  37
  38 time_t __cdecl time(time_t *t)
  39 {
  40     __time64_t t64;
  41     if ( !_time64(&t64) )
  42         return (time_t)-1;
  43
  44     if ( t )
  45         *t = (time_t)t64;
  46
  47     return (time_t)t64;
  48 }
  49
  50 time_t __cdecl mktime(struct tm *t)
  51 {
  52     return (time_t)_mktime64(t);
  53 }
  54
  55 #else // !VC8
  56
  57 /////////////////////////////////////////////////////////////////////////////////////////////
  58 //                                                                                         //
  59 //                             strftime() - taken from OpenBSD                             //
  60 //                                                                                         //
  61 /////////////////////////////////////////////////////////////////////////////////////////////
  62
  63 #define IN_NONE 0
  64 #define IN_SOME 1
  65 #define IN_THIS 2
  66 #define IN_ALL  3
  67 #define CHAR_BIT      8
  68
  69 #define TYPE_BIT(type)  (sizeof (type) * CHAR_BIT)
  70 #define TYPE_SIGNED(type) (((type) -1) < 0)
  71
  72 #define INT_STRLEN_MAXIMUM(type) \
  73     ((TYPE_BIT(type) - TYPE_SIGNED(type)) * 302 / 1000 + 1 + TYPE_SIGNED(type))
  74
  75 #define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))
  76
  77 #define MONSPERYEAR     12
  78 #define DAYSPERWEEK     7
  79 #define TM_YEAR_BASE    1900
  80 #define HOURSPERDAY     24
  81 #define DAYSPERNYEAR    365
  82 #define DAYSPERLYEAR    366
  83
  84 static char             wildabbr[] = "WILDABBR";
  85
  86 char *                  tzname[2] = {
  87         wildabbr,
  88         wildabbr
  89 };
  90
  91
  92 #define Locale  (&C_time_locale)
  93
  94 struct lc_time_T {
  95         const char *    mon[MONSPERYEAR];
  96         const char *    month[MONSPERYEAR];
  97         const char *    wday[DAYSPERWEEK];
  98         const char *    weekday[DAYSPERWEEK];
  99         const char *    X_fmt;
 100         const char *    x_fmt;
 101         const char *    c_fmt;
 102         const char *    am;
 103         const char *    pm;
 104         const char *    date_fmt;
 105 };
 106
 107 static const struct lc_time_T   C_time_locale = {
 108         {
 109                 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 110                 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
 111         }, {
 112                 "January", "February", "March", "April", "May", "June",
 113                 "July", "August", "September", "October", "November", "December"
 114         }, {
 115                 "Sun", "Mon", "Tue", "Wed",
 116                 "Thu", "Fri", "Sat"
 117         }, {
 118                 "Sunday", "Monday", "Tuesday", "Wednesday",
 119                 "Thursday", "Friday", "Saturday"
 120         },
 121
 122         /* X_fmt */
 123         "%H:%M:%S",
 124
 125         /*
 126         ** x_fmt
 127         ** C99 requires this format.
 128         ** Using just numbers (as here) makes Quakers happier;
 129         ** it's also compatible with SVR4.
 130         */
 131         "%m/%d/%y",
 132
 133         /*
 134         ** c_fmt
 135         ** C99 requires this format.
 136         ** Previously this code used "%D %X", but we now conform to C99.
 137         ** Note that
 138         **      "%a %b %d %H:%M:%S %Y"
 139         ** is used by Solaris 2.3.
 140         */
 141         "%a %b %e %T %Y",
 142
 143         /* am */
 144         "AM",
 145
 146         /* pm */
 147         "PM",
 148
 149         /* date_fmt */
 150         "%a %b %e %H:%M:%S %Z %Y"
 151 };
 152
 153
 154 static char *
 155 _add(const char * str, char * pt, const char * const ptlim)
 156 {
 157         while (pt < ptlim && (*pt = *str++) != '\0')
 158                 ++pt;
 159         return pt;
 160 }
 161
 162
 163 static char *
 164 _conv(const int n, const char * const format, char * const pt, const char * const ptlim)
 165 {
 166         char    buf[INT_STRLEN_MAXIMUM(int) + 1];
 167
 168         (void) _snprintf(buf, sizeof buf, format, n);
 169         return _add(buf, pt, ptlim);
 170 }
 171
 172
 173 static char *
 174 _fmt(const char * format, const struct tm * const t, char * pt, const char * const ptlim, int * warnp)
 175 {
 176         for ( ; *format; ++format) {
 177                 if (*format == '%') {
 178 label:
 179                         switch (*++format) {
 180                         case '\0':
 181                                 --format;
 182                                 break;
 183                         case 'A':
 184                                 pt = _add((t->tm_wday < 0 ||
 185                                         t->tm_wday >= DAYSPERWEEK) ?
 186                                         "?" : Locale->weekday[t->tm_wday],
 187                                         pt, ptlim);
 188                                 continue;
 189                         case 'a':
 190                                 pt = _add((t->tm_wday < 0 ||
 191                                         t->tm_wday >= DAYSPERWEEK) ?
 192                                         "?" : Locale->wday[t->tm_wday],
 193                                         pt, ptlim);
 194                                 continue;
 195                         case 'B':
 196                                 pt = _add((t->tm_mon < 0 ||
 197                                         t->tm_mon >= MONSPERYEAR) ?
 198                                         "?" : Locale->month[t->tm_mon],
 199                                         pt, ptlim);
 200                                 continue;
 201                         case 'b':
 202                         case 'h':
 203                                 pt = _add((t->tm_mon < 0 ||
 204                                         t->tm_mon >= MONSPERYEAR) ?
 205                                         "?" : Locale->mon[t->tm_mon],
 206                                         pt, ptlim);
 207                                 continue;
 208                         case 'C':
 209                                 /*
 210                                 ** %C used to do a...
 211                                 **      _fmt("%a %b %e %X %Y", t);
 212                                 ** ...whereas now POSIX 1003.2 calls for
 213                                 ** something completely different.
 214                                 ** (ado, 1993-05-24)
 215                                 */
 216                                 pt = _conv((t->tm_year + TM_YEAR_BASE) / 100,
 217                                         "%02d", pt, ptlim);
 218                                 continue;
 219                         case 'c':
 220                                 {
 221                                 int warn2 = IN_SOME;
 222
 223                                 pt = _fmt(Locale->c_fmt, t, pt, ptlim, warnp);
 224                                 if (warn2 == IN_ALL)
 225                                         warn2 = IN_THIS;
 226                                 if (warn2 > *warnp)
 227                                         *warnp = warn2;
 228                                 }
 229                                 continue;
 230                         case 'D':
 231                                 pt = _fmt("%m/%d/%y", t, pt, ptlim, warnp);
 232                                 continue;
 233                         case 'd':
 234                                 pt = _conv(t->tm_mday, "%02d", pt, ptlim);
 235                                 continue;
 236                         case 'E':
 237                         case 'O':
 238                                 /*
 239                                 ** C99 locale modifiers.
 240                                 ** The sequences
 241                                 **      %Ec %EC %Ex %EX %Ey %EY
 242                                 **      %Od %oe %OH %OI %Om %OM
 243                                 **      %OS %Ou %OU %OV %Ow %OW %Oy
 244                                 ** are supposed to provide alternate
 245                                 ** representations.
 246                                 */
 247                                 goto label;
 248                         case 'e':
 249                                 pt = _conv(t->tm_mday, "%2d", pt, ptlim);
 250                                 continue;
 251                         case 'F':
 252                                 pt = _fmt("%Y-%m-%d", t, pt, ptlim, warnp);
 253                                 continue;
 254                         case 'H':
 255                                 pt = _conv(t->tm_hour, "%02d", pt, ptlim);
 256                                 continue;
 257                         case 'I':
 258                                 pt = _conv((t->tm_hour % 12) ?
 259                                         (t->tm_hour % 12) : 12,
 260                                         "%02d", pt, ptlim);
 261                                 continue;
 262                         case 'j':
 263                                 pt = _conv(t->tm_yday + 1, "%03d", pt, ptlim);
 264                                 continue;
 265                         case 'k':
 266                                 /*
 267                                 ** This used to be...
 268                                 **      _conv(t->tm_hour % 12 ?
 269                                 **              t->tm_hour % 12 : 12, 2, ' ');
 270                                 ** ...and has been changed to the below to
 271                                 ** match SunOS 4.1.1 and Arnold Robbins'
 272                                 ** strftime version 3.0.  That is, "%k" and
 273                                 ** "%l" have been swapped.
 274                                 ** (ado, 1993-05-24)
 275                                 */
 276                                 pt = _conv(t->tm_hour, "%2d", pt, ptlim);
 277                                 continue;
 278 #ifdef KITCHEN_SINK
 279                         case 'K':
 280                                 /*
 281                                 ** After all this time, still unclaimed!
 282                                 */
 283                                 pt = _add("kitchen sink", pt, ptlim);
 284                                 continue;
 285 #endif /* defined KITCHEN_SINK */
 286                         case 'l':
 287                                 /*
 288                                 ** This used to be...
 289                                 **      _conv(t->tm_hour, 2, ' ');
 290                                 ** ...and has been changed to the below to
 291                                 ** match SunOS 4.1.1 and Arnold Robbin's
 292                                 ** strftime version 3.0.  That is, "%k" and
 293                                 ** "%l" have been swapped.
 294                                 ** (ado, 1993-05-24)
 295                                 */
 296                                 pt = _conv((t->tm_hour % 12) ?
 297                                         (t->tm_hour % 12) : 12,
 298                                         "%2d", pt, ptlim);
 299                                 continue;
 300                         case 'M':
 301                                 pt = _conv(t->tm_min, "%02d", pt, ptlim);
 302                                 continue;
 303                         case 'm':
 304                                 pt = _conv(t->tm_mon + 1, "%02d", pt, ptlim);
 305                                 continue;
 306                         case 'n':
 307                                 pt = _add("\n", pt, ptlim);
 308                                 continue;
 309                         case 'p':
 310                                 pt = _add((t->tm_hour >= (HOURSPERDAY / 2)) ?
 311                                         Locale->pm :
 312                                         Locale->am,
 313                                         pt, ptlim);
 314                                 continue;
 315                         case 'R':
 316                                 pt = _fmt("%H:%M", t, pt, ptlim, warnp);
 317                                 continue;
 318                         case 'r':
 319                                 pt = _fmt("%I:%M:%S %p", t, pt, ptlim, warnp);
 320                                 continue;
 321                         case 'S':
 322                                 pt = _conv(t->tm_sec, "%02d", pt, ptlim);
 323                                 continue;
 324                         case 's':
 325                                 {
 326                                         struct tm       tm;
 327                                         char            buf[INT_STRLEN_MAXIMUM(
 328                                                                 time_t) + 1];
 329                                         time_t          mkt;
 330
 331                                         tm = *t;
 332                                         mkt = mktime(&tm);
 333                                         if (TYPE_SIGNED(time_t))
 334                                                 (void) _snprintf(buf, sizeof buf,
 335                                                     "%ld", (long) mkt);
 336                                         else    (void) _snprintf(buf, sizeof buf,
 337                                                     "%lu", (unsigned long) mkt);
 338                                         pt = _add(buf, pt, ptlim);
 339                                 }
 340                                 continue;
 341                         case 'T':
 342                                 pt = _fmt("%H:%M:%S", t, pt, ptlim, warnp);
 343                                 continue;
 344                         case 't':
 345                                 pt = _add("\t", pt, ptlim);
 346                                 continue;
 347                         case 'U':
 348                                 pt = _conv((t->tm_yday + DAYSPERWEEK -
 349                                         t->tm_wday) / DAYSPERWEEK,
 350                                         "%02d", pt, ptlim);
 351                                 continue;
 352                         case 'u':
 353                                 /*
 354                                 ** From Arnold Robbins' strftime version 3.0:
 355                                 ** "ISO 8601: Weekday as a decimal number
 356                                 ** [1 (Monday) - 7]"
 357                                 ** (ado, 1993-05-24)
 358                                 */
 359                                 pt = _conv((t->tm_wday == 0) ?
 360                                         DAYSPERWEEK : t->tm_wday,
 361                                         "%d", pt, ptlim);
 362                                 continue;
 363                         case 'V':       /* ISO 8601 week number */
 364                         case 'G':       /* ISO 8601 year (four digits) */
 365                         case 'g':       /* ISO 8601 year (two digits) */
 366                                 {
 367                                         int     year;
 368                                         int     yday;
 369                                         int     wday;
 370                                         int     w;
 371
 372                                         year = t->tm_year + TM_YEAR_BASE;
 373                                         yday = t->tm_yday;
 374                                         wday = t->tm_wday;
 375                                         for ( ; ; ) {
 376                                                 int     len;
 377                                                 int     bot;
 378                                                 int     top;
 379
 380                                                 len = isleap(year) ?
 381                                                         DAYSPERLYEAR :
 382                                                         DAYSPERNYEAR;
 383                                                 /*
 384                                                 ** What yday (-3 ... 3) does
 385                                                 ** the ISO year begin on?
 386                                                 */
 387                                                 bot = ((yday + 11 - wday) %
 388                                                         DAYSPERWEEK) - 3;
 389                                                 /*
 390                                                 ** What yday does the NEXT
 391                                                 ** ISO year begin on?
 392                                                 */
 393                                                 top = bot -
 394                                                         (len % DAYSPERWEEK);
 395                                                 if (top < -3)
 396                                                         top += DAYSPERWEEK;
 397                                                 top += len;
 398                                                 if (yday >= top) {
 399                                                         ++year;
 400                                                         w = 1;
 401                                                         break;
 402                                                 }
 403                                                 if (yday >= bot) {
 404                                                         w = 1 + ((yday - bot) /
 405                                                                 DAYSPERWEEK);
 406                                                         break;
 407                                                 }
 408                                                 --year;
 409                                                 yday += isleap(year) ?
 410                                                         DAYSPERLYEAR :
 411                                                         DAYSPERNYEAR;
 412                                         }
 413                                         if (*format == 'V')
 414                                                 pt = _conv(w, "%02d",
 415                                                         pt, ptlim);
 416                                         else if (*format == 'g') {
 417                                                 *warnp = IN_ALL;
 418                                                 pt = _conv(year % 100, "%02d",
 419                                                         pt, ptlim);
 420                                         } else  pt = _conv(year, "%04d",
 421                                                         pt, ptlim);
 422                                 }
 423                                 continue;
 424                         case 'v':
 425                                 pt = _fmt("%e-%b-%Y", t, pt, ptlim, warnp);
 426                                 continue;
 427                         case 'W':
 428                                 pt = _conv((t->tm_yday + DAYSPERWEEK -
 429                                         (t->tm_wday ?
 430                                         (t->tm_wday - 1) :
 431                                         (DAYSPERWEEK - 1))) / DAYSPERWEEK,
 432                                         "%02d", pt, ptlim);
 433                                 continue;
 434                         case 'w':
 435                                 pt = _conv(t->tm_wday, "%d", pt, ptlim);
 436                                 continue;
 437                         case 'X':
 438                                 pt = _fmt(Locale->X_fmt, t, pt, ptlim, warnp);
 439                                 continue;
 440                         case 'x':
 441                                 {
 442                                 int     warn2 = IN_SOME;
 443
 444                                 pt = _fmt(Locale->x_fmt, t, pt, ptlim, &warn2);
 445                                 if (warn2 == IN_ALL)
 446                                         warn2 = IN_THIS;
 447                                 if (warn2 > *warnp)
 448                                         *warnp = warn2;
 449                                 }
 450                                 continue;
 451                         case 'y':
 452                                 *warnp = IN_ALL;
 453                                 pt = _conv((t->tm_year + TM_YEAR_BASE) % 100,
 454                                         "%02d", pt, ptlim);
 455                                 continue;
 456                         case 'Y':
 457                                 pt = _conv(t->tm_year + TM_YEAR_BASE, "%04d",
 458                                         pt, ptlim);
 459                                 continue;
 460                         case 'Z':
 461                                 if (t->tm_isdst >= 0)
 462                                         pt = _add(tzname[t->tm_isdst != 0],
 463                                                 pt, ptlim);
 464                                 /*
 465                                 ** C99 says that %Z must be replaced by the
 466                                 ** empty string if the time zone is not
 467                                 ** determinable.
 468                                 */
 469                                 continue;
 470                         case 'z':
 471                                 {
 472                                 int             diff = -timezone;
 473                                 char const *    sign;
 474
 475                                 if (diff < 0) {
 476                                         sign = "-";
 477                                         diff = -diff;
 478                                 } else  sign = "+";
 479                                 pt = _add(sign, pt, ptlim);
 480                                 diff /= 60;
 481                                 pt = _conv((diff/60)*100 + diff%60,
 482                                         "%04d", pt, ptlim);
 483                                 }
 484                                 continue;
 485                         case '+':
 486                                 pt = _fmt(Locale->date_fmt, t, pt, ptlim,
 487                                         warnp);
 488                                 continue;
 489                         case '%':
 490                         default:
 491                                 break;
 492                         }
 493                 }
 494                 if (pt == ptlim)
 495                         break;
 496                 *pt++ = *format;
 497         }
 498         return pt;
 499 }
 500
 501 size_t
 502 strftime(char * const s, const size_t maxsize, const char *format, const struct tm * const t)
 503 {
 504         char *  p;
 505         int     warn;
 506
 507         //tzset();
 508
 509         warn = IN_NONE;
 510         p = _fmt(((format == NULL) ? "%c" : format), t, s, s + maxsize, &warn);
 511
 512         if (p == s + maxsize) {
 513                 if (maxsize > 0)
 514                         s[maxsize - 1] = '\0';
 515                 return 0;
 516         }
 517         *p = '\0';
 518         return p - s;
 519 }
 520
 521 extern "C"
 522 {
 523
 524 /* Not needed in VS Studio 2005 */
 525
 526 size_t wcsftime(wchar_t *s,
 527                 const size_t maxsize,
 528                 const wchar_t *format,
 529                 const struct tm *t)
 530 {
 531     wxCharBuffer sBuf(maxsize/sizeof(wchar_t));
 532
 533     wxString formatStr(format);
 534     wxCharBuffer bufFormatStr(formatStr.mb_str());
 535
 536     size_t sz = strftime(sBuf.data(), maxsize/sizeof(wchar_t), bufFormatStr, t);
 537
 538     wxMB2WC(s, sBuf, maxsize);
 539
 540     return sz;
 541 }
 542
 543 } /* extern "C" */
 544
 545 #define is_leap(y)   (y % 4 == 0 && (y % 100 != 0 || y % 400 == 0))
 546 #define SECONDS_IN_ONE_MINUTE      60
 547 #define DAYS_IN_ONE_YEAR          365
 548 #define SECONDS_IN_ONE_MIN         60
 549 #define SECONDS_IN_ONE_HOUR      3600
 550 #define SECONDS_IN_ONE_DAY      86400
 551 #define DEFAULT_TIMEZONE        28800
 552 #define DO_GMTIME                   0
 553 #define DO_LOCALTIME                1
 554
 555
 556 long timezone ; // global variable
 557
 558
 559 ////////////////////////////////////////////////////////////////////////
 560 // Common code for localtime and gmtime (static)
 561 ////////////////////////////////////////////////////////////////////////
 562
 563 static struct tm * __cdecl common_localtime(const time_t *t, BOOL bLocal)
 564 {
 565     wxLongLong i64;
 566     FILETIME   ft;
 567     wxString str ;
 568     SYSTEMTIME SystemTime;
 569     TIME_ZONE_INFORMATION pTz;
 570     static struct tm st_res ;             // data holder
 571     static struct tm * res = &st_res ;    // data pointer
 572     int iLeap;
 573     const unsigned short int __mon_yday[2][13] =
 574     {
 575         // Normal years
 576         { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
 577         // Leap years
 578         { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
 579     };
 580
 581     if (!*t)
 582         ::GetLocalTime(&SystemTime);
 583     else
 584     {
 585         i64 = *t;
 586         i64 = i64 * 10000000 + 116444736000000000;
 587
 588         ft.dwLowDateTime  = i64.GetLo();
 589         ft.dwHighDateTime = i64.GetHi();
 590
 591         ::FileTimeToSystemTime(&ft, &SystemTime);
 592     }
 593
 594     ::GetTimeZoneInformation(&pTz);
 595
 596     ///////////////////////////////////////////////
 597     // Set timezone
 598     timezone = pTz.Bias * SECONDS_IN_ONE_MINUTE ;
 599     ///////////////////////////////////////////////
 600
 601     iLeap = is_leap(SystemTime.wYear) ;
 602
 603     res->tm_hour = SystemTime.wHour;
 604     res->tm_min  = SystemTime.wMinute;
 605     res->tm_sec  = SystemTime.wSecond;
 606
 607     res->tm_mday = SystemTime.wDay;
 608     res->tm_mon = SystemTime.wMonth - 1; // this the correct month but localtime returns month aligned to zero
 609     res->tm_year = SystemTime.wYear;     // this the correct year
 610     res->tm_year = res->tm_year - 1900;  // but localtime returns the value starting at the 1900
 611
 612     res->tm_wday = SystemTime.wDayOfWeek;
 613     res->tm_yday = __mon_yday[iLeap][res->tm_mon] + SystemTime.wDay - 1; // localtime returns year-day aligned to zero
 614
 615     // if localtime behavior and daylight saving
 616     if (bLocal && pTz.DaylightBias != 0)
 617         res->tm_isdst = 1;
 618     else
 619         res->tm_isdst = 0; // without daylight saving or gmtime
 620
 621     return res;
 622 }
 623
 624 extern "C"
 625 {
 626
 627 ////////////////////////////////////////////////////////////////////////
 628 // Receive the number of seconds elapsed since midnight(00:00:00)
 629 // and convert a time value and corrects for the local time zone
 630 ////////////////////////////////////////////////////////////////////////
 631 struct tm * __cdecl localtime(const time_t * t)
 632 {
 633     return common_localtime(t, DO_LOCALTIME) ;
 634 }
 635
 636 ////////////////////////////////////////////////////////////////////////
 637 // Receives the number of seconds elapsed since midnight(00:00:00)
 638 // and converts a time value WITHOUT correcting for the local time zone
 639 ////////////////////////////////////////////////////////////////////////
 640 struct tm * __cdecl gmtime(const time_t *t)
 641 {
 642     return common_localtime(t, DO_GMTIME) ;
 643 }
 644
 645 }
 646
 647 ////////////////////////////////////////////////////////////////////////
 648 // Common code for conversion of struct tm into time_t   (static)
 649 ////////////////////////////////////////////////////////////////////////
 650 static time_t __cdecl common_tm_to_time(int day, int month, int year, int hour, int minute, int second)
 651 {
 652 #if 1
 653     // Use mktime since it seems less broken
 654     tm t;
 655     t.tm_isdst = -1;
 656     t.tm_hour = hour;
 657     t.tm_mday = day;
 658     t.tm_min = minute;
 659     t.tm_mon = month-1;
 660     t.tm_sec = second;
 661     t.tm_wday = -1;
 662     t.tm_yday = -1;
 663     t.tm_year = year - 1900;
 664     return mktime(& t);
 665 #else
 666     time_t prog = 0 ;
 667     static int mdays[12] = { 31,28,31,30,31,30,31,31,30,31,30,31 } ;
 668
 669     while (--month)
 670     {
 671         prog += mdays[month - 1] ;
 672         if (month == 2 && is_leap(year))
 673             prog++ ;
 674     }
 675
 676     // Calculate seconds in elapsed days
 677     prog = day - 1 ;        // align first day of the year to zero
 678     prog += (DAYS_IN_ONE_YEAR * (year - 1970) + (year - 1901) / 4 - 19) ;
 679     prog *= SECONDS_IN_ONE_DAY ;
 680
 681     // Add Calculated elapsed seconds in the current day
 682     prog += (hour * SECONDS_IN_ONE_HOUR + minute *
 683                                SECONDS_IN_ONE_MIN + second) ;
 684
 685     return prog ;
 686 #endif
 687 }
 688
 689 extern "C"
 690 {
 691
 692 ////////////////////////////////////////////////////////////////////////
 693 // Returns the number of seconds elapsed since
 694 // midnight(00:00:00) of 1 January 1970
 695 ////////////////////////////////////////////////////////////////////////
 696 time_t __cdecl time(time_t *t)
 697 {
 698     time_t prog = 0 ;
 699
 700     if (t != NULL)
 701     {
 702         SYSTEMTIME SystemTime;
 703
 704         ::GetLocalTime(&SystemTime) ;
 705         prog = common_tm_to_time(SystemTime.wDay, SystemTime.wMonth, SystemTime.wYear,
 706                                  SystemTime.wHour, SystemTime.wMinute, SystemTime.wSecond) ;
 707         *t = prog ;
 708     }
 709
 710     return prog ;
 711 }
 712
 713 ////////////////////////////////////////////////////////////////////////
 714 // Converts the local time provided by struct tm
 715 // into a time_t calendar value
 716 // Implementation from OpenBSD
 717 ////////////////////////////////////////////////////////////////////////
 718
 719 #if 1
 720 int month_to_day[12] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
 721
 722 time_t mktime(struct tm *t)
 723 {
 724         short  month, year;
 725         time_t result;
 726
 727         month = t->tm_mon;
 728         year = t->tm_year + month / 12 + 1900;
 729         month %= 12;
 730         if (month < 0)
 731         {
 732                 year -= 1;
 733                 month += 12;
 734         }
 735         result = (year - 1970) * 365 + (year - 1969) / 4 + month_to_day[month];
 736         result = (year - 1970) * 365 + month_to_day[month];
 737         if (month <= 1)
 738                 year -= 1;
 739         result += (year - 1968) / 4;
 740         result -= (year - 1900) / 100;
 741         result += (year - 1600) / 400;
 742         result += t->tm_mday;
 743         result -= 1;
 744         result *= 24;
 745         result += t->tm_hour;
 746         result *= 60;
 747         result += t->tm_min;
 748         result *= 60;
 749         result += t->tm_sec;
 750         return(result);
 751 }
 752
 753 #else
 754 time_t __cdecl mktime(struct tm *t)
 755 {
 756     return (common_tm_to_time(t->tm_mday, t->tm_mon+1, t->tm_year+1900, t->tm_hour, t->tm_min, t->tm_sec)) ;
 757 }
 758 #endif
 759
 760 } // extern "C"
 761
 762 #endif // VC8/!VC8