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 |
224 | |