|
1 /* |
|
2 * Copyright (C) 1999-2000 Harri Porten (porten@kde.org) |
|
3 * Copyright (C) 2006, 2007 Apple Inc. All rights reserved. |
|
4 * Copyright (C) 2009 Google Inc. All rights reserved. |
|
5 * |
|
6 * Version: MPL 1.1/GPL 2.0/LGPL 2.1 |
|
7 * |
|
8 * The contents of this file are subject to the Mozilla Public License Version |
|
9 * 1.1 (the "License"); you may not use this file except in compliance with |
|
10 * the License. You may obtain a copy of the License at |
|
11 * http://www.mozilla.org/MPL/ |
|
12 * |
|
13 * Software distributed under the License is distributed on an "AS IS" basis, |
|
14 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License |
|
15 * for the specific language governing rights and limitations under the |
|
16 * License. |
|
17 * |
|
18 * The Original Code is Mozilla Communicator client code, released |
|
19 * March 31, 1998. |
|
20 * |
|
21 * The Initial Developer of the Original Code is |
|
22 * Netscape Communications Corporation. |
|
23 * Portions created by the Initial Developer are Copyright (C) 1998 |
|
24 * the Initial Developer. All Rights Reserved. |
|
25 * |
|
26 * Contributor(s): |
|
27 * |
|
28 * Alternatively, the contents of this file may be used under the terms of |
|
29 * either of the GNU General Public License Version 2 or later (the "GPL"), |
|
30 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), |
|
31 * in which case the provisions of the GPL or the LGPL are applicable instead |
|
32 * of those above. If you wish to allow use of your version of this file only |
|
33 * under the terms of either the GPL or the LGPL, and not to allow others to |
|
34 * use your version of this file under the terms of the MPL, indicate your |
|
35 * decision by deleting the provisions above and replace them with the notice |
|
36 * and other provisions required by the GPL or the LGPL. If you do not delete |
|
37 * the provisions above, a recipient may use your version of this file under |
|
38 * the terms of any one of the MPL, the GPL or the LGPL. |
|
39 * |
|
40 */ |
|
41 |
|
42 #ifndef DateMath_h |
|
43 #define DateMath_h |
|
44 |
|
45 #include <math.h> |
|
46 #include <string.h> |
|
47 #include <time.h> |
|
48 #include <wtf/CurrentTime.h> |
|
49 #include <wtf/Noncopyable.h> |
|
50 #include <wtf/UnusedParam.h> |
|
51 |
|
52 namespace WTF { |
|
53 void initializeDates(); |
|
54 int equivalentYearForDST(int year); |
|
55 |
|
56 // Not really math related, but this is currently the only shared place to put these. |
|
57 double parseDateFromNullTerminatedCharacters(const char* dateString); |
|
58 double timeClip(double); |
|
59 |
|
60 inline double jsCurrentTime() |
|
61 { |
|
62 // JavaScript doesn't recognize fractions of a millisecond. |
|
63 return floor(WTF::currentTimeMS()); |
|
64 } |
|
65 |
|
66 const char * const weekdayName[7] = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" }; |
|
67 const char * const monthName[12] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; |
|
68 |
|
69 const double hoursPerDay = 24.0; |
|
70 const double minutesPerHour = 60.0; |
|
71 const double secondsPerHour = 60.0 * 60.0; |
|
72 const double secondsPerMinute = 60.0; |
|
73 const double msPerSecond = 1000.0; |
|
74 const double msPerMinute = 60.0 * 1000.0; |
|
75 const double msPerHour = 60.0 * 60.0 * 1000.0; |
|
76 const double msPerDay = 24.0 * 60.0 * 60.0 * 1000.0; |
|
77 const double msPerMonth = 2592000000.0; |
|
78 |
|
79 // Returns the number of days from 1970-01-01 to the specified date. |
|
80 double dateToDaysFrom1970(int year, int month, int day); |
|
81 int msToYear(double ms); |
|
82 int dayInYear(double ms, int year); |
|
83 int monthFromDayInYear(int dayInYear, bool leapYear); |
|
84 int dayInMonthFromDayInYear(int dayInYear, bool leapYear); |
|
85 |
|
86 } // namespace WTF |
|
87 |
|
88 using WTF::dateToDaysFrom1970; |
|
89 using WTF::dayInMonthFromDayInYear; |
|
90 using WTF::dayInYear; |
|
91 using WTF::minutesPerHour; |
|
92 using WTF::monthFromDayInYear; |
|
93 using WTF::msPerDay; |
|
94 using WTF::msPerSecond; |
|
95 using WTF::msToYear; |
|
96 using WTF::secondsPerMinute; |
|
97 |
|
98 #if USE(JSC) |
|
99 namespace JSC { |
|
100 class ExecState; |
|
101 struct GregorianDateTime; |
|
102 |
|
103 void msToGregorianDateTime(ExecState*, double, bool outputIsUTC, GregorianDateTime&); |
|
104 double gregorianDateTimeToMS(ExecState*, const GregorianDateTime&, double, bool inputIsUTC); |
|
105 double getUTCOffset(ExecState*); |
|
106 double parseDateFromNullTerminatedCharacters(ExecState*, const char* dateString); |
|
107 |
|
108 // Intentionally overridding the default tm of the system. |
|
109 // The members of tm differ on various operating systems. |
|
110 struct GregorianDateTime : Noncopyable { |
|
111 GregorianDateTime() |
|
112 : second(0) |
|
113 , minute(0) |
|
114 , hour(0) |
|
115 , weekDay(0) |
|
116 , monthDay(0) |
|
117 , yearDay(0) |
|
118 , month(0) |
|
119 , year(0) |
|
120 , isDST(0) |
|
121 , utcOffset(0) |
|
122 , timeZone(0) |
|
123 { |
|
124 } |
|
125 |
|
126 ~GregorianDateTime() |
|
127 { |
|
128 delete [] timeZone; |
|
129 } |
|
130 |
|
131 GregorianDateTime(ExecState* exec, const tm& inTm) |
|
132 : second(inTm.tm_sec) |
|
133 , minute(inTm.tm_min) |
|
134 , hour(inTm.tm_hour) |
|
135 , weekDay(inTm.tm_wday) |
|
136 , monthDay(inTm.tm_mday) |
|
137 , yearDay(inTm.tm_yday) |
|
138 , month(inTm.tm_mon) |
|
139 , year(inTm.tm_year) |
|
140 , isDST(inTm.tm_isdst) |
|
141 { |
|
142 UNUSED_PARAM(exec); |
|
143 #if HAVE(TM_GMTOFF) |
|
144 utcOffset = static_cast<int>(inTm.tm_gmtoff); |
|
145 #else |
|
146 utcOffset = static_cast<int>(getUTCOffset(exec) / WTF::msPerSecond + (isDST ? WTF::secondsPerHour : 0)); |
|
147 #endif |
|
148 |
|
149 #if HAVE(TM_ZONE) |
|
150 int inZoneSize = strlen(inTm.tm_zone) + 1; |
|
151 timeZone = new char[inZoneSize]; |
|
152 strncpy(timeZone, inTm.tm_zone, inZoneSize); |
|
153 #else |
|
154 timeZone = 0; |
|
155 #endif |
|
156 } |
|
157 |
|
158 operator tm() const |
|
159 { |
|
160 tm ret; |
|
161 memset(&ret, 0, sizeof(ret)); |
|
162 |
|
163 ret.tm_sec = second; |
|
164 ret.tm_min = minute; |
|
165 ret.tm_hour = hour; |
|
166 ret.tm_wday = weekDay; |
|
167 ret.tm_mday = monthDay; |
|
168 ret.tm_yday = yearDay; |
|
169 ret.tm_mon = month; |
|
170 ret.tm_year = year; |
|
171 ret.tm_isdst = isDST; |
|
172 |
|
173 #if HAVE(TM_GMTOFF) |
|
174 ret.tm_gmtoff = static_cast<long>(utcOffset); |
|
175 #endif |
|
176 #if HAVE(TM_ZONE) |
|
177 ret.tm_zone = timeZone; |
|
178 #endif |
|
179 |
|
180 return ret; |
|
181 } |
|
182 |
|
183 void copyFrom(const GregorianDateTime& rhs) |
|
184 { |
|
185 second = rhs.second; |
|
186 minute = rhs.minute; |
|
187 hour = rhs.hour; |
|
188 weekDay = rhs.weekDay; |
|
189 monthDay = rhs.monthDay; |
|
190 yearDay = rhs.yearDay; |
|
191 month = rhs.month; |
|
192 year = rhs.year; |
|
193 isDST = rhs.isDST; |
|
194 utcOffset = rhs.utcOffset; |
|
195 if (rhs.timeZone) { |
|
196 int inZoneSize = strlen(rhs.timeZone) + 1; |
|
197 timeZone = new char[inZoneSize]; |
|
198 strncpy(timeZone, rhs.timeZone, inZoneSize); |
|
199 } else |
|
200 timeZone = 0; |
|
201 } |
|
202 |
|
203 int second; |
|
204 int minute; |
|
205 int hour; |
|
206 int weekDay; |
|
207 int monthDay; |
|
208 int yearDay; |
|
209 int month; |
|
210 int year; |
|
211 int isDST; |
|
212 int utcOffset; |
|
213 char* timeZone; |
|
214 }; |
|
215 |
|
216 static inline int gmtoffset(const GregorianDateTime& t) |
|
217 { |
|
218 return t.utcOffset; |
|
219 } |
|
220 } // namespace JSC |
|
221 #endif // USE(JSC) |
|
222 |
|
223 #endif // DateMath_h |