JavaScriptCore/kjs/DateMath.cpp

   1 /*
   2  * Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
   3  * Copyright (C) 2006 Apple Computer
   4  *
   5  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   6  *
   7  * The contents of this file are subject to the Mozilla Public License Version
   8  * 1.1 (the "License"); you may not use this file except in compliance with
   9  * the License. You may obtain a copy of the License at
  10  * http://www.mozilla.org/MPL/
  11  *
  12  * Software distributed under the License is distributed on an "AS IS" basis,
  13  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  14  * for the specific language governing rights and limitations under the
  15  * License.
  16  *
  17  * The Original Code is Mozilla Communicator client code, released
  18  * March 31, 1998.
  19  *
  20  * The Initial Developer of the Original Code is
  21  * Netscape Communications Corporation.
  22  * Portions created by the Initial Developer are Copyright (C) 1998
  23  * the Initial Developer. All Rights Reserved.
  24  *
  25  * Contributor(s):
  26  *
  27  * Alternatively, the contents of this file may be used under the terms of
  28  * either of the GNU General Public License Version 2 or later (the "GPL"),
  29  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30  * in which case the provisions of the GPL or the LGPL are applicable instead
  31  * of those above. If you wish to allow use of your version of this file only
  32  * under the terms of either the GPL or the LGPL, and not to allow others to
  33  * use your version of this file under the terms of the MPL, indicate your
  34  * decision by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL or the LGPL. If you do not delete
  36  * the provisions above, a recipient may use your version of this file under
  37  * the terms of any one of the MPL, the GPL or the LGPL.
  38  *
  39  */
  40
  41 #include <DateMath.h>
  42
  43 #include <math.h>
  44 #include <stdint.h>
  45 #include <wtf/OwnPtr.h>
  46
  47 namespace KJS {
  48
  49 /* Constants */
  50
  51 static const double secondsPerHour = 60.0 * 60.0;
  52 static const double minutesPerDay = 24.0 * 60.0;
  53 static const double secondsPerDay = 24.0 * 60.0 * 60.0;
  54 static const double secondsPerYear = 24.0 * 60.0 * 60.0 * 365.0;
  55
  56
  57 static const double usecPerMsec = 1000.0;
  58 static const double usecPerSec = 1000000.0;
  59
  60 static const double maxUnixTime = 2145859200.0; /*equivalent to 12/31/2037 */
  61
  62 /*
  63  * The following array contains the day of year for the first day of
  64  * each month, where index 0 is January, and day 0 is January 1.
  65  */
  66 static int firstDayOfMonth[2][12] = {
  67     {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334},
  68     {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335}
  69 };
  70
  71
  72 /*
  73  * Years and leap years on which Jan 1 is a Sunday, Monday, etc.
  74  *
  75  * yearStartingWith[0][i] is an example non-leap year where
  76  * Jan 1 appears on Sunday (i == 0), Monday (i == 1), etc.
  77  *
  78  * yearStartingWith[1][i] is an example leap year where
  79  * Jan 1 appears on Sunday (i == 0), Monday (i == 1), etc.
  80  */
  81 static int yearStartingWith[2][7] = {
  82     {1978, 1973, 1974, 1975, 1981, 1971, 1977},
  83     {1984, 1996, 1980, 1992, 1976, 1988, 1972}
  84 };
  85
  86
  87 static inline int daysInYear(int year)
  88 {
  89     if (year % 4 != 0)
  90         return 365;
  91     if (year % 400 == 0)
  92         return 366;
  93     if (year % 100 == 0)
  94         return 365;
  95     return 366;
  96 }
  97
  98 static inline double daysFrom1970ToYear(int year)
  99 {
 100     return 365.0 * (year - 1970)
 101         + floor((year - 1969) / 4.0)
 102         - floor((year - 1901) / 100.0)
 103         + floor((year - 1601) / 400.0);
 104 }
 105
 106 static inline double msFrom1970ToYear(int year)
 107 {
 108     return msPerDay * daysFrom1970ToYear(year);
 109 }
 110
 111 static inline double msToDays(double ms)
 112 {
 113     return floor(ms / msPerDay);
 114 }
 115
 116 static inline int msToYear(double ms)
 117 {
 118     int y = static_cast<int>(floor(ms /(msPerDay*365.2425)) + 1970);
 119     double t2 = msFrom1970ToYear(y);
 120
 121     if (t2 > ms) {
 122         y--;
 123     } else {
 124         if (t2 + msPerDay * daysInYear(y) <= ms)
 125             y++;
 126     }
 127     return y;
 128 }
 129
 130 static inline bool isLeapYear(int year)
 131 {
 132     if (year % 4 != 0)
 133         return false;
 134     if (year % 400 == 0)
 135         return true;
 136     if (year % 100 == 0)
 137         return false;
 138     return true;
 139 }
 140
 141 static inline bool isInLeapYear(double ms)
 142 {
 143     return isLeapYear(msToYear(ms));
 144 }
 145
 146 static inline int dayInYear(double ms, int year)
 147 {
 148     return static_cast<int>(msToDays(ms) - daysFrom1970ToYear(year));
 149 }
 150
 151 static inline double msToMilliseconds(double ms)
 152 {
 153     double result;
 154     result = fmod(ms, msPerDay);
 155     if (result < 0)
 156         result += msPerDay;
 157     return result;
 158 }
 159
 160 // 0: Sunday, 1: Monday, etc.
 161 static inline int msToWeekDay(double ms)
 162 {
 163     int wd = ((int)msToDays(ms) + 4) % 7;
 164     if (wd < 0)
 165         wd += 7;
 166     return wd;
 167 }
 168
 169 static inline int msToSeconds(double ms)
 170 {
 171     int result = (int) fmod(floor(ms / msPerSecond), secondsPerMinute);
 172     if (result < 0)
 173         result += (int)secondsPerMinute;
 174     return result;
 175 }
 176
 177 static inline int msToMinutes(double ms)
 178 {
 179     int result = (int) fmod(floor(ms / msPerMinute), minutesPerHour);
 180     if (result < 0)
 181         result += (int)minutesPerHour;
 182     return result;
 183 }
 184
 185 static inline int msToHours(double ms)
 186 {
 187     int result = (int) fmod(floor(ms/msPerHour), hoursPerDay);
 188     if (result < 0)
 189         result += (int)hoursPerDay;
 190     return result;
 191 }
 192
 193 static inline int msToMonth(double ms)
 194 {
 195     int d, step;
 196     int year = msToYear(ms);
 197     d = dayInYear(ms, year);
 198
 199     if (d < (step = 31))
 200         return 0;
 201     step += (isInLeapYear(ms) ? 29 : 28);
 202     if (d < step)
 203         return 1;
 204     if (d < (step += 31))
 205         return 2;
 206     if (d < (step += 30))
 207         return 3;
 208     if (d < (step += 31))
 209         return 4;
 210     if (d < (step += 30))
 211         return 5;
 212     if (d < (step += 31))
 213         return 6;
 214     if (d < (step += 31))
 215         return 7;
 216     if (d < (step += 30))
 217         return 8;
 218     if (d < (step += 31))
 219         return 9;
 220     if (d < (step += 30))
 221         return 10;
 222     return 11;
 223 }
 224
 225 static inline int msToDayInMonth(double ms)
 226 {
 227     int d, step, next;
 228     int year = msToYear(ms);
 229     d = dayInYear(ms, year);
 230
 231     if (d <= (next = 30))
 232         return d + 1;
 233     step = next;
 234     next += (isInLeapYear(ms) ? 29 : 28);
 235     if (d <= next)
 236         return d - step;
 237     step = next;
 238     if (d <= (next += 31))
 239         return d - step;
 240     step = next;
 241     if (d <= (next += 30))
 242         return d - step;
 243     step = next;
 244     if (d <= (next += 31))
 245         return d - step;
 246     step = next;
 247     if (d <= (next += 30))
 248         return d - step;
 249     step = next;
 250     if (d <= (next += 31))
 251         return d - step;
 252     step = next;
 253     if (d <= (next += 31))
 254         return d - step;
 255     step = next;
 256     if (d <= (next += 30))
 257         return d - step;
 258     step = next;
 259     if (d <= (next += 31))
 260         return d - step;
 261     step = next;
 262     if (d <= (next += 30))
 263         return d - step;
 264     step = next;
 265     return d - step;
 266 }
 267
 268 static inline int monthToDayInYear(int month, bool isLeapYear)
 269 {
 270     return firstDayOfMonth[isLeapYear][month];
 271 }
 272
 273 static inline double timeToMseconds(double hour, double min, double sec, double ms)
 274 {
 275     return (((hour * minutesPerHour + min) * secondsPerMinute + sec) * msPerSecond + ms);
 276 }
 277
 278 static int dateToDayInYear(int year, int month, int day)
 279 {
 280     year += static_cast<int>(floor(month / 12.0));
 281
 282     month = static_cast<int>(fmod(month, 12.0));
 283     if (month < 0)
 284         month += 12;
 285
 286     int yearday = static_cast<int>(floor(msFrom1970ToYear(year) / msPerDay));
 287     int monthday = monthToDayInYear(month, isLeapYear(year));
 288
 289     return yearday + monthday + day - 1;
 290 }
 291
 292 /*
 293  * Find a year for which any given date will fall on the same weekday.
 294  *
 295  * This function should be used with caution when used other than
 296  * for determining DST; it hasn't been proven not to produce an
 297  * incorrect year for times near year boundaries.
 298  */
 299 static inline int equivalentYearForDST(int year)
 300 {
 301     int day;
 302
 303     day = (int) daysFrom1970ToYear(year) + 4;
 304     day = day % 7;
 305
 306     if (day < 0)
 307         day += 7;
 308
 309     return yearStartingWith[isLeapYear(year)][day];
 310 }
 311
 312 /*
 313  * Get the difference in milliseconds between this time zone and UTC (GMT)
 314  * NOT including DST.
 315  */
 316 double getUTCOffset() {
 317     static double utcOffset;
 318     static bool utcOffsetInitialized = false;
 319     if (!utcOffsetInitialized) {
 320         struct tm ltime;
 321
 322         ltime.tm_sec = 0;
 323         ltime.tm_min = 0;
 324         ltime.tm_hour = 0;
 325         ltime.tm_mon = 0;
 326         ltime.tm_wday = 0;
 327         ltime.tm_yday = 0;
 328         ltime.tm_isdst = 0;
 329
 330         /* get the difference between this time zone and GMT */
 331         ltime.tm_mday = 2;
 332         ltime.tm_year = 70;
 333
 334         #if !PLATFORM(WIN_OS)
 335         ltime.tm_zone = 0;
 336         ltime.tm_gmtoff = 0;
 337         #endif
 338
 339         utcOffset = mktime(&ltime) - (hoursPerDay * secondsPerHour);
 340         utcOffset *= -msPerSecond;
 341
 342         utcOffsetInitialized = true;
 343     }
 344     return utcOffset;
 345 }
 346
 347 /*
 348  * Get the DST offset for the time passed in.  Takes
 349  * seconds (not milliseconds) and cannot handle dates before 1970
 350  * on some OS'
 351  */
 352 static double getDSTOffsetSimple(double localTimeSeconds)
 353 {
 354     if(localTimeSeconds > maxUnixTime)
 355         localTimeSeconds = maxUnixTime;
 356     else if(localTimeSeconds < 0) /*go ahead a day to make localtime work (does not work with 0) */
 357         localTimeSeconds = secondsPerDay;
 358
 359     double offsetTime = (localTimeSeconds * usecPerMsec) + getUTCOffset() ;
 360
 361     struct tm prtm;
 362     prtm.tm_min   =  msToMinutes(offsetTime);
 363     prtm.tm_hour  =  msToHours(offsetTime);
 364
 365     // FIXME: time_t has a potential problem in 2038
 366     time_t localTime = static_cast<time_t>(localTimeSeconds);
 367
 368     struct tm tm;
 369     #if PLATFORM(WIN_OS)
 370     localtime_s(&tm, &localTime);
 371     #else
 372     localtime_r(&localTime, &tm);
 373     #endif
 374
 375     double diff = ((tm.tm_hour - prtm.tm_hour) * secondsPerHour) + ((tm.tm_min - prtm.tm_min) * 60);
 376
 377     if(diff < 0)
 378         diff += secondsPerDay;
 379
 380     return (diff * usecPerMsec);
 381 }
 382
 383 // get the DST offset the time passed in
 384 static double getDSTOffset(double ms)
 385 {
 386     /*
 387      * If earlier than 1970 or after 2038, potentially beyond the ken of
 388      * many OSes, map it to an equivalent year before asking.
 389      */
 390     if (ms < 0.0 || ms > 2145916800000.0) {
 391         int year;
 392         int day;
 393
 394         year = equivalentYearForDST(msToYear(ms));
 395         day = dateToDayInYear(year, msToMonth(ms), msToDayInMonth(ms));
 396         ms = (day * msPerDay) + msToMilliseconds(ms);
 397     }
 398
 399     /* put our ms in an LL, and map it to usec for prtime */
 400     return getDSTOffsetSimple(ms / usecPerMsec);
 401 }
 402
 403 static inline double localTimeToUTC(double ms)
 404 {
 405     ms -= getUTCOffset();
 406     ms -= getDSTOffset(ms);
 407     return ms;
 408 }
 409
 410 static inline double UTCToLocalTime(double ms)
 411 {
 412     ms += getUTCOffset();
 413     ms += getDSTOffset(ms);
 414     return ms;
 415 }
 416
 417 double dateToMseconds(tm* t, double ms, bool inputIsUTC)
 418 {
 419     int day = dateToDayInYear(t->tm_year + 1900, t->tm_mon, t->tm_mday);
 420     double msec_time = timeToMseconds(t->tm_hour, t->tm_min, t->tm_sec, ms);
 421     double result = (day * msPerDay) + msec_time;
 422
 423     if(!inputIsUTC)
 424         result = localTimeToUTC(result);
 425
 426     return result;
 427 }
 428
 429 void msToTM(double ms, bool outputIsUTC, struct tm& tm)
 430 {
 431     //input is UTC
 432     if(!outputIsUTC)
 433         ms = UTCToLocalTime(ms);
 434
 435     tm.tm_sec   =  msToSeconds(ms);
 436     tm.tm_min   =  msToMinutes(ms);
 437     tm.tm_hour  =  msToHours(ms);
 438     tm.tm_wday  =  msToWeekDay(ms);
 439     tm.tm_mday  =  msToDayInMonth(ms);
 440     tm.tm_yday  =  dayInYear(ms, msToYear(ms));
 441     tm.tm_mon   =  msToMonth(ms);
 442     tm.tm_year  =  msToYear(ms) - 1900;
 443     tm.tm_isdst =  isDST(ms);
 444
 445     //everyone else seems to have these fields
 446     #if !PLATFORM(WIN_OS)
 447     struct tm xtm;
 448     // FIXME: time_t has a potential problem in 2038
 449     time_t seconds = static_cast<time_t>(ms/usecPerMsec);
 450     localtime_r(&seconds, &xtm);
 451     tm.tm_gmtoff = xtm.tm_gmtoff;
 452     tm.tm_zone = xtm.tm_zone;
 453     #endif
 454 }
 455
 456 bool isDST(const double& ms)
 457 {
 458     return getDSTOffset(ms) != 0;
 459 }
 460
 461 }   //namespace KJS
 462