Reviewed by Geoff.
[WebKit-https.git] / 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 timeToMS(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 += month / 12;
281
282     month %= 12;
283     if (month < 0) {
284         month += 12;
285         --year;
286     }
287
288     int yearday = static_cast<int>(floor(msFrom1970ToYear(year) / msPerDay));
289     int monthday = monthToDayInYear(month, isLeapYear(year));
290
291     return yearday + monthday + day - 1;
292 }
293
294 /*
295  * Find a year for which any given date will fall on the same weekday.
296  *
297  * This function should be used with caution when used other than
298  * for determining DST; it hasn't been proven not to produce an
299  * incorrect year for times near year boundaries.
300  */
301 static inline int equivalentYearForDST(int year)
302 {
303     int day;
304
305     day = (int) daysFrom1970ToYear(year) + 4;
306     day %= 7;
307
308     if (day < 0)
309         day += 7;
310
311     return yearStartingWith[isLeapYear(year)][day];
312 }
313
314 /*
315  * Get the difference in milliseconds between this time zone and UTC (GMT)
316  * NOT including DST.
317  */
318 double getUTCOffset() {
319     static double utcOffset;
320     static bool utcOffsetInitialized = false;
321     if (!utcOffsetInitialized) {
322         struct ::tm ltime;
323
324         memset(&ltime, 0, sizeof(ltime));
325         
326         // get the difference between this time zone and GMT 
327         ltime.tm_mday = 2;
328         ltime.tm_year = 70;
329
330         utcOffset = mktime(&ltime) - (hoursPerDay * secondsPerHour);
331         utcOffset *= -msPerSecond;
332
333         utcOffsetInitialized = true;
334     }
335     return utcOffset;
336 }
337
338 /*
339  * Get the DST offset for the time passed in.  Takes
340  * seconds (not milliseconds) and cannot handle dates before 1970
341  * on some OS'
342  */
343 static double getDSTOffsetSimple(double localTimeSeconds)
344 {
345     if(localTimeSeconds > maxUnixTime)
346         localTimeSeconds = maxUnixTime;
347     else if(localTimeSeconds < 0) // Go ahead a day to make localtime work (does not work with 0)
348         localTimeSeconds += secondsPerDay;
349
350     double offsetTime = (localTimeSeconds * usecPerMsec) + getUTCOffset() ;
351
352     // Offset from UTC but doesn't include DST obviously
353     int offsetHour =  msToHours(offsetTime);
354     int offsetMinute =  msToMinutes(offsetTime);
355
356     // FIXME: time_t has a potential problem in 2038
357     time_t localTime = static_cast<time_t>(localTimeSeconds);
358
359     struct ::tm tm;
360     #if PLATFORM(WIN_OS)
361     localtime_s(&tm, &localTime);
362     #else
363     localtime_r(&localTime, &tm);
364     #endif
365     
366     double diff = ((tm.tm_hour - offsetHour) * secondsPerHour) + ((tm.tm_min - offsetMinute) * 60);
367
368     if(diff < 0)
369         diff += secondsPerDay;
370
371     return (diff * usecPerMsec);
372 }
373
374 // Get the DST offset the time passed in
375 // ms is in UTC
376 static double getDSTOffset(double ms)
377 {
378     /*
379      * If earlier than 1970 or after 2038, potentially beyond the ken of
380      * many OSes, map it to an equivalent year before asking.
381      */
382     if (ms < 0.0 || ms > 2145916800000.0) {
383         int year;
384         int day;
385
386         year = equivalentYearForDST(msToYear(ms));
387         day = dateToDayInYear(year, msToMonth(ms), msToDayInMonth(ms));
388         ms = (day * msPerDay) + msToMilliseconds(ms);
389     }
390
391     return getDSTOffsetSimple(ms / usecPerMsec);
392 }
393
394 double dateToMS(const tm& t, double milliSeconds, bool inputIsUTC)
395 {
396
397     int day = dateToDayInYear(t.tm_year + 1900, t.tm_mon, t.tm_mday);
398     double ms = timeToMS(t.tm_hour, t.tm_min, t.tm_sec, milliSeconds);
399     double result = (day * msPerDay) + ms;
400
401     if(!inputIsUTC) { // convert to UTC
402         result -= getUTCOffset();       
403         result -= getDSTOffset(result);
404     }
405
406     return result;
407 }
408
409 void msToTM(double ms, bool outputIsUTC, struct tm& tm)
410 {
411     // input is UTC
412     double dstOff = 0.0;
413     
414     if(!outputIsUTC) {  // convert to local time
415         dstOff = getDSTOffset(ms);
416         ms += dstOff + getUTCOffset();
417     }
418
419     tm.tm_sec   =  msToSeconds(ms);
420     tm.tm_min   =  msToMinutes(ms);
421     tm.tm_hour  =  msToHours(ms);
422     tm.tm_wday  =  msToWeekDay(ms);
423     tm.tm_mday  =  msToDayInMonth(ms);
424     tm.tm_yday  =  dayInYear(ms, msToYear(ms));
425     tm.tm_mon   =  msToMonth(ms);
426     tm.tm_year  =  msToYear(ms) - 1900;
427     tm.tm_isdst =  dstOff != 0.0;
428
429     tm.tm_gmtoff = (dstOff + getUTCOffset()) / usecPerMsec;
430     tm.tm_zone = 0;
431 }
432
433 // converting between the two tm structures
434 tm tmToKJStm(const struct ::tm& inTm)
435 {
436     struct tm ret;
437     memset(&ret, 0, sizeof(ret));
438
439     ret.tm_sec   =  inTm.tm_sec;
440     ret.tm_min   =  inTm.tm_min;
441     ret.tm_hour  =  inTm.tm_hour;
442     ret.tm_wday  =  inTm.tm_wday;
443     ret.tm_mday  =  inTm.tm_mday;
444     ret.tm_yday  =  inTm.tm_yday;
445     ret.tm_mon   =  inTm.tm_mon;
446     ret.tm_year  =  inTm.tm_year;
447     ret.tm_isdst =  inTm.tm_isdst;
448
449 #if !PLATFORM(WIN_OS)
450     ret.tm_gmtoff = inTm.tm_gmtoff;
451     ret.tm_zone = inTm.tm_zone;
452 #endif
453
454     return ret;
455 }
456
457 ::tm KJStmToTm(const struct tm& inTm)
458 {
459     struct ::tm ret;
460     memset(&ret, 0, sizeof(ret));
461
462     ret.tm_sec   =  inTm.tm_sec;
463     ret.tm_min   =  inTm.tm_min;
464     ret.tm_hour  =  inTm.tm_hour;
465     ret.tm_wday  =  inTm.tm_wday;
466     ret.tm_mday  =  inTm.tm_mday;
467     ret.tm_yday  =  inTm.tm_yday;
468     ret.tm_mon   =  inTm.tm_mon;
469     ret.tm_year  =  inTm.tm_year;
470     ret.tm_isdst =  inTm.tm_isdst;
471
472 #if !PLATFORM(WIN_OS)
473     ret.tm_gmtoff = inTm.tm_gmtoff;
474     ret.tm_zone = inTm.tm_zone;
475 #endif
476
477     return ret;
478 }
479
480 }   // namespace KJS
481