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
103// Get the combined UTC + DST offset for the time passed in.
104//
105// NOTE: The implementation relies on the fact that no time zones have
106// more than one daylight savings offset change per month.
107// If this function is called with NaN it returns NaN.
108static LocalTimeOffset localTimeOffset(VM& vm, double ms, WTF::TimeType inputTimeType = WTF::UTCTime)
109{
110 LocalTimeOffsetCache& cache = inputTimeType == WTF::LocalTime
111 ? vm.localTimeOffsetCache : vm.utcTimeOffsetCache;
112
113 double start = cache.start;
114 double end = cache.end;
115
116 if (start <= ms) {
117 // If the time fits in the cached interval, return the cached offset.
118 if (ms <= end)
119 return cache.offset;
120
121 // Compute a possible new interval end.
122 double newEnd = end + cache.increment;
123
124 if (ms <= newEnd) {
125 LocalTimeOffset endOffset = calculateLocalTimeOffset(newEnd, inputTimeType);
126 if (cache.offset == endOffset) {
127 // If the offset at the end of the new interval still matches
128 // the offset in the cache, we grow the cached time interval
129 // and return the offset.
130 cache.end = newEnd;
131 cache.increment = WTF::msPerMonth;
132 return endOffset;
133 }
134 LocalTimeOffset offset = calculateLocalTimeOffset(ms, inputTimeType);
135 if (offset == endOffset) {
136 // The offset at the given time is equal to the offset at the
137 // new end of the interval, so that means that we've just skipped
138 // the point in time where the DST offset change occurred. Updated
139 // the interval to reflect this and reset the increment.
140 cache.start = ms;
141 cache.end = newEnd;
142 cache.increment = WTF::msPerMonth;
143 } else {
144 // The interval contains a DST offset change and the given time is
145 // before it. Adjust the increment to avoid a linear search for
146 // the offset change point and change the end of the interval.
147 cache.increment /= 3;
148 cache.end = ms;
149 }
150 // Update the offset in the cache and return it.
151 cache.offset = offset;
152 return offset;
153 }
154 }
155
156 // Compute the DST offset for the time and shrink the cache interval
157 // to only contain the time. This allows fast repeated DST offset
158 // computations for the same time.
159 LocalTimeOffset offset = calculateLocalTimeOffset(ms, inputTimeType);
160 cache.offset = offset;
161 cache.start = ms;
162 cache.end = ms;
163 cache.increment = WTF::msPerMonth;
164 return offset;
165}
166
167static inline double timeToMS(double hour, double min, double sec, double ms)
168{
169 return (((hour * WTF::minutesPerHour + min) * WTF::secondsPerMinute + sec) * WTF::msPerSecond + ms);
170}
171
172double gregorianDateTimeToMS(VM& vm, const GregorianDateTime& t, double milliSeconds, WTF::TimeType inputTimeType)
173{
174 double day = dateToDaysFrom1970(t.year(), t.month(), t.monthDay());
175 double ms = timeToMS(t.hour(), t.minute(), t.second(), milliSeconds);
176 double localTimeResult = (day * WTF::msPerDay) + ms;
177
178 double localToUTCTimeOffset = inputTimeType == WTF::LocalTime
179 ? localTimeOffset(vm, localTimeResult, inputTimeType).offset : 0;
180
181 return localTimeResult - localToUTCTimeOffset;
182}
183
184// input is UTC
185void msToGregorianDateTime(VM& vm, double ms, WTF::TimeType outputTimeType, GregorianDateTime& tm)
186{
187 LocalTimeOffset localTime;
188 if (outputTimeType == WTF::LocalTime) {
189 localTime = localTimeOffset(vm, ms);
190 ms += localTime.offset;
191 }
192 tm = GregorianDateTime(ms, localTime);
193}
194
195double parseDateFromNullTerminatedCharacters(VM& vm, const char* dateString)
196{
197 bool haveTZ;
198 int offset;
199 double localTimeMS = WTF::parseDateFromNullTerminatedCharacters(dateString, haveTZ, offset);
200 if (std::isnan(localTimeMS))
201 return std::numeric_limits<double>::quiet_NaN();
202
203 // fall back to local timezone.
204 if (!haveTZ)
205 offset = localTimeOffset(vm, localTimeMS, WTF::LocalTime).offset / WTF::msPerMinute;
206
207 return localTimeMS - (offset * WTF::msPerMinute);
208}
209
210double parseDate(JSGlobalObject* globalObject, VM& vm, const String& date)
211{
212 auto scope = DECLARE_THROW_SCOPE(vm);
213
214 if (date == vm.cachedDateString)
215 return vm.cachedDateStringValue;
216 auto expectedString = date.tryGetUtf8();
217 if (!expectedString) {
218 if (expectedString.error() == UTF8ConversionError::OutOfMemory)
219 throwOutOfMemoryError(globalObject, scope);
220 // https://tc39.github.io/ecma262/#sec-date-objects section 20.3.3.2 states that:
221 // "Unrecognizable Strings or dates containing illegal element values in the
222 // format String shall cause Date.parse to return NaN."
223 return std::numeric_limits<double>::quiet_NaN();
224 }
225
226 auto dateUtf8 = expectedString.value();
227 double value = WTF::parseES5DateFromNullTerminatedCharacters(dateUtf8.data());
228 if (std::isnan(value))
229 value = parseDateFromNullTerminatedCharacters(vm, dateUtf8.data());
230 vm.cachedDateString = date;
231 vm.cachedDateStringValue = value;
232 return value;
233}
234
235} // namespace JSC
236