1/*
2 * Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3 * Copyright (C) 2006-2018 Apple Inc. All rights reserved.
4 * Copyright (C) 2009 Google Inc. All rights reserved.
5 * Copyright (C) 2007-2009 Torch Mobile, Inc.
6 * Copyright (C) 2010 &yet, LLC. (nate@andyet.net)
7 *
8 * The Original Code is Mozilla Communicator client code, released
9 * March 31, 1998.
10 *
11 * The Initial Developer of the Original Code is
12 * Netscape Communications Corporation.
13 * Portions created by the Initial Developer are Copyright (C) 1998
14 * the Initial Developer. All Rights Reserved.
15 *
16 * This library is free software; you can redistribute it and/or
17 * modify it under the terms of the GNU Lesser General Public
18 * License as published by the Free Software Foundation; either
19 * version 2.1 of the License, or (at your option) any later version.
20 *
21 * This library is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 * Lesser General Public License for more details.
25 *
26 * You should have received a copy of the GNU Lesser General Public
27 * License along with this library; if not, write to the Free Software
28 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29 *
30 * Alternatively, the contents of this file may be used under the terms
31 * of either the Mozilla Public License Version 1.1, found at
32 * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
33 * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
34 * (the "GPL"), in which case the provisions of the MPL or the GPL are
35 * applicable instead of those above. If you wish to allow use of your
36 * version of this file only under the terms of one of those two
37 * licenses (the MPL or the GPL) and not to allow others to use your
38 * version of this file under the LGPL, indicate your decision by
39 * deletingthe provisions above and replace them with the notice and
40 * other provisions required by the MPL or the GPL, as the case may be.
41 * If you do not delete the provisions above, a recipient may use your
42 * version of this file under any of the LGPL, the MPL or the GPL.
43
44 * Copyright 2006-2008 the V8 project authors. All rights reserved.
45 * Redistribution and use in source and binary forms, with or without
46 * modification, are permitted provided that the following conditions are
47 * met:
48 *
49 * * Redistributions of source code must retain the above copyright
50 * notice, this list of conditions and the following disclaimer.
51 * * Redistributions in binary form must reproduce the above
52 * copyright notice, this list of conditions and the following
53 * disclaimer in the documentation and/or other materials provided
54 * with the distribution.
55 * * Neither the name of Google Inc. nor the names of its
56 * contributors may be used to endorse or promote products derived
57 * from this software without specific prior written permission.
58 *
59 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
60 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
61 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
62 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
63 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
64 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
65 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
66 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
67 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
68 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
69 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
70 */
71
72#include "config.h"
73#include "JSDateMath.h"
74
75#include "JSObject.h"
76#include "JSScope.h"
77#include "JSCInlines.h"
78
79#include <algorithm>
80#include <limits.h>
81#include <limits>
82#include <stdint.h>
83#include <time.h>
84#include <wtf/ASCIICType.h>
85#include <wtf/Assertions.h>
86#include <wtf/MathExtras.h>
87#include <wtf/StdLibExtras.h>
88
89#if HAVE(ERRNO_H)
90#include <errno.h>
91#endif
92
93#if HAVE(SYS_TIME_H)
94#include <sys/time.h>
95#endif
96
97#if HAVE(SYS_TIMEB_H)
98#include <sys/timeb.h>
99#endif
100
101namespace JSC {
102
103using namespace WTF;
104
105static inline double timeToMS(double hour, double min, double sec, double ms)
106{
107 return (((hour * minutesPerHour + min) * secondsPerMinute + sec) * msPerSecond + ms);
108}
109
110static inline int msToSeconds(double ms)
111{
112 double result = fmod(floor(ms / msPerSecond), secondsPerMinute);
113 if (result < 0)
114 result += secondsPerMinute;
115 return static_cast<int>(result);
116}
117
118// 0: Sunday, 1: Monday, etc.
119static inline int msToWeekDay(double ms)
120{
121 int wd = (static_cast<int>(msToDays(ms)) + 4) % 7;
122 if (wd < 0)
123 wd += 7;
124 return wd;
125}
126
127// Get the combined UTC + DST offset for the time passed in.
128//
129// NOTE: The implementation relies on the fact that no time zones have
130// more than one daylight savings offset change per month.
131// If this function is called with NaN it returns NaN.
132static LocalTimeOffset localTimeOffset(VM& vm, double ms, WTF::TimeType inputTimeType = WTF::UTCTime)
133{
134 LocalTimeOffsetCache& cache = vm.localTimeOffsetCache;
135 double start = cache.start;
136 double end = cache.end;
137 WTF::TimeType cachedTimeType = cache.timeType;
138
139 if (cachedTimeType == inputTimeType && start <= ms) {
140 // If the time fits in the cached interval, return the cached offset.
141 if (ms <= end) return cache.offset;
142
143 // Compute a possible new interval end.
144 double newEnd = end + cache.increment;
145
146 if (ms <= newEnd) {
147 LocalTimeOffset endOffset = calculateLocalTimeOffset(newEnd, inputTimeType);
148 if (cache.offset == endOffset) {
149 // If the offset at the end of the new interval still matches
150 // the offset in the cache, we grow the cached time interval
151 // and return the offset.
152 cache.end = newEnd;
153 cache.increment = msPerMonth;
154 return endOffset;
155 }
156 LocalTimeOffset offset = calculateLocalTimeOffset(ms, inputTimeType);
157 if (offset == endOffset) {
158 // The offset at the given time is equal to the offset at the
159 // new end of the interval, so that means that we've just skipped
160 // the point in time where the DST offset change occurred. Updated
161 // the interval to reflect this and reset the increment.
162 cache.start = ms;
163 cache.end = newEnd;
164 cache.increment = msPerMonth;
165 } else {
166 // The interval contains a DST offset change and the given time is
167 // before it. Adjust the increment to avoid a linear search for
168 // the offset change point and change the end of the interval.
169 cache.increment /= 3;
170 cache.end = ms;
171 }
172 // Update the offset in the cache and return it.
173 cache.offset = offset;
174 return offset;
175 }
176 }
177
178 // Compute the DST offset for the time and shrink the cache interval
179 // to only contain the time. This allows fast repeated DST offset
180 // computations for the same time.
181 LocalTimeOffset offset = calculateLocalTimeOffset(ms, inputTimeType);
182 cache.offset = offset;
183 cache.start = ms;
184 cache.end = ms;
185 cache.increment = msPerMonth;
186 cache.timeType = inputTimeType;
187 return offset;
188}
189
190double gregorianDateTimeToMS(VM& vm, const GregorianDateTime& t, double milliSeconds, WTF::TimeType inputTimeType)
191{
192 double day = dateToDaysFrom1970(t.year(), t.month(), t.monthDay());
193 double ms = timeToMS(t.hour(), t.minute(), t.second(), milliSeconds);
194 double localTimeResult = (day * WTF::msPerDay) + ms;
195 double localToUTCTimeOffset = inputTimeType == LocalTime
196 ? localTimeOffset(vm, localTimeResult, inputTimeType).offset : 0;
197
198 return localTimeResult - localToUTCTimeOffset;
199}
200
201// input is UTC
202void msToGregorianDateTime(VM& vm, double ms, WTF::TimeType outputTimeType, GregorianDateTime& tm)
203{
204 LocalTimeOffset localTime;
205 if (outputTimeType == WTF::LocalTime) {
206 localTime = localTimeOffset(vm, ms);
207 ms += localTime.offset;
208 }
209
210 const int year = msToYear(ms);
211 tm.setSecond(msToSeconds(ms));
212 tm.setMinute(msToMinutes(ms));
213 tm.setHour(msToHours(ms));
214 tm.setWeekDay(msToWeekDay(ms));
215 tm.setYearDay(dayInYear(ms, year));
216 tm.setMonthDay(dayInMonthFromDayInYear(tm.yearDay(), isLeapYear(year)));
217 tm.setMonth(monthFromDayInYear(tm.yearDay(), isLeapYear(year)));
218 tm.setYear(year);
219 tm.setIsDST(localTime.isDST);
220 tm.setUtcOffset(localTime.offset / WTF::msPerSecond);
221}
222
223double parseDateFromNullTerminatedCharacters(VM& vm, const char* dateString)
224{
225 bool haveTZ;
226 int offset;
227 double localTimeMS = WTF::parseDateFromNullTerminatedCharacters(dateString, haveTZ, offset);
228 if (std::isnan(localTimeMS))
229 return std::numeric_limits<double>::quiet_NaN();
230
231 // fall back to local timezone.
232 if (!haveTZ)
233 offset = localTimeOffset(vm, localTimeMS, WTF::LocalTime).offset / WTF::msPerMinute;
234
235 return localTimeMS - (offset * WTF::msPerMinute);
236}
237
238double parseDate(ExecState* exec, VM& vm, const String& date)
239{
240 auto scope = DECLARE_THROW_SCOPE(vm);
241
242 if (date == vm.cachedDateString)
243 return vm.cachedDateStringValue;
244 auto expectedString = date.tryGetUtf8();
245 if (!expectedString) {
246 if (expectedString.error() == UTF8ConversionError::OutOfMemory)
247 throwOutOfMemoryError(exec, scope);
248 // https://tc39.github.io/ecma262/#sec-date-objects section 20.3.3.2 states that:
249 // "Unrecognizable Strings or dates containing illegal element values in the
250 // format String shall cause Date.parse to return NaN."
251 return std::numeric_limits<double>::quiet_NaN();
252 }
253
254 auto dateUtf8 = expectedString.value();
255 double value = parseES5DateFromNullTerminatedCharacters(dateUtf8.data());
256 if (std::isnan(value))
257 value = parseDateFromNullTerminatedCharacters(vm, dateUtf8.data());
258 vm.cachedDateString = date;
259 vm.cachedDateStringValue = value;
260 return value;
261}
262
263} // namespace JSC
264