runtime/JSDateMath.cpp

   1 /*
   2  * Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
   3  * Copyright (C) 2006, 2007, 2012 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/CurrentTime.h>
  87 #include <wtf/MathExtras.h>
  88 #include <wtf/StdLibExtras.h>
  89 #include <wtf/StringExtras.h>
  90 #include <wtf/text/StringBuilder.h>
  91
  92 #if HAVE(ERRNO_H)
  93 #include <errno.h>
  94 #endif
  95
  96 #if HAVE(SYS_TIME_H)
  97 #include <sys/time.h>
  98 #endif
  99
 100 #if HAVE(SYS_TIMEB_H)
 101 #include <sys/timeb.h>
 102 #endif
 103
 104 using namespace WTF;
 105
 106 namespace JSC {
 107
 108 static inline double timeToMS(double hour, double min, double sec, double ms)
 109 {
 110     return (((hour * minutesPerHour + min) * secondsPerMinute + sec) * msPerSecond + ms);
 111 }
 112
 113 static inline int msToSeconds(double ms)
 114 {
 115     double result = fmod(floor(ms / msPerSecond), secondsPerMinute);
 116     if (result < 0)
 117         result += secondsPerMinute;
 118     return static_cast<int>(result);
 119 }
 120
 121 // 0: Sunday, 1: Monday, etc.
 122 static inline int msToWeekDay(double ms)
 123 {
 124     int wd = (static_cast<int>(msToDays(ms)) + 4) % 7;
 125     if (wd < 0)
 126         wd += 7;
 127     return wd;
 128 }
 129
 130 // Get the combined UTC + DST offset for the time passed in.
 131 //
 132 // NOTE: The implementation relies on the fact that no time zones have
 133 // more than one daylight savings offset change per month.
 134 // If this function is called with NaN it returns NaN.
 135 static LocalTimeOffset localTimeOffset(VM& vm, double ms)
 136 {
 137     LocalTimeOffsetCache& cache = vm.localTimeOffsetCache;
 138     double start = cache.start;
 139     double end = cache.end;
 140
 141     if (start <= ms) {
 142         // If the time fits in the cached interval, return the cached offset.
 143         if (ms <= end) return cache.offset;
 144
 145         // Compute a possible new interval end.
 146         double newEnd = end + cache.increment;
 147
 148         if (ms <= newEnd) {
 149             LocalTimeOffset endOffset = calculateLocalTimeOffset(newEnd);
 150             if (cache.offset == endOffset) {
 151                 // If the offset at the end of the new interval still matches
 152                 // the offset in the cache, we grow the cached time interval
 153                 // and return the offset.
 154                 cache.end = newEnd;
 155                 cache.increment = msPerMonth;
 156                 return endOffset;
 157             }
 158             LocalTimeOffset offset = calculateLocalTimeOffset(ms);
 159             if (offset == endOffset) {
 160                 // The offset at the given time is equal to the offset at the
 161                 // new end of the interval, so that means that we've just skipped
 162                 // the point in time where the DST offset change occurred. Updated
 163                 // the interval to reflect this and reset the increment.
 164                 cache.start = ms;
 165                 cache.end = newEnd;
 166                 cache.increment = msPerMonth;
 167             } else {
 168                 // The interval contains a DST offset change and the given time is
 169                 // before it. Adjust the increment to avoid a linear search for
 170                 // the offset change point and change the end of the interval.
 171                 cache.increment /= 3;
 172                 cache.end = ms;
 173             }
 174             // Update the offset in the cache and return it.
 175             cache.offset = offset;
 176             return offset;
 177         }
 178     }
 179
 180     // Compute the DST offset for the time and shrink the cache interval
 181     // to only contain the time. This allows fast repeated DST offset
 182     // computations for the same time.
 183     LocalTimeOffset offset = calculateLocalTimeOffset(ms);
 184     cache.offset = offset;
 185     cache.start = ms;
 186     cache.end = ms;
 187     cache.increment = msPerMonth;
 188     return offset;
 189 }
 190
 191 double gregorianDateTimeToMS(VM& vm, const GregorianDateTime& t, double milliSeconds, bool inputIsUTC)
 192 {
 193     double day = dateToDaysFrom1970(t.year(), t.month(), t.monthDay());
 194     double ms = timeToMS(t.hour(), t.minute(), t.second(), milliSeconds);
 195     double result = (day * WTF::msPerDay) + ms;
 196
 197     if (!inputIsUTC)
 198         result -= localTimeOffset(vm, result).offset;
 199
 200     return result;
 201 }
 202
 203 // input is UTC
 204 void msToGregorianDateTime(VM& vm, double ms, bool outputIsUTC, GregorianDateTime& tm)
 205 {
 206     LocalTimeOffset localTime;
 207     if (!outputIsUTC) {
 208         localTime = localTimeOffset(vm, ms);
 209         ms += localTime.offset;
 210     }
 211
 212     const int year = msToYear(ms);
 213     tm.setSecond(msToSeconds(ms));
 214     tm.setMinute(msToMinutes(ms));
 215     tm.setHour(msToHours(ms));
 216     tm.setWeekDay(msToWeekDay(ms));
 217     tm.setYearDay(dayInYear(ms, year));
 218     tm.setMonthDay(dayInMonthFromDayInYear(tm.yearDay(), isLeapYear(year)));
 219     tm.setMonth(monthFromDayInYear(tm.yearDay(), isLeapYear(year)));
 220     tm.setYear(year);
 221     tm.setIsDST(localTime.isDST);
 222     tm.setUtcOffset(localTime.offset / WTF::msPerSecond);
 223 }
 224
 225 double parseDateFromNullTerminatedCharacters(VM& vm, const char* dateString)
 226 {
 227     bool haveTZ;
 228     int offset;
 229     double ms = WTF::parseDateFromNullTerminatedCharacters(dateString, haveTZ, offset);
 230     if (std::isnan(ms))
 231         return std::numeric_limits<double>::quiet_NaN();
 232
 233     // fall back to local timezone
 234     if (!haveTZ)
 235         offset = localTimeOffset(vm, ms).offset / WTF::msPerMinute;
 236
 237     return ms - (offset * WTF::msPerMinute);
 238 }
 239
 240 double parseDate(VM& vm, const String& date)
 241 {
 242     if (date == vm.cachedDateString)
 243         return vm.cachedDateStringValue;
 244     double value = parseES5DateFromNullTerminatedCharacters(date.utf8().data());
 245     if (std::isnan(value))
 246         value = parseDateFromNullTerminatedCharacters(vm, date.utf8().data());
 247     vm.cachedDateString = date;
 248     vm.cachedDateStringValue = value;
 249     return value;
 250 }
 251
 252 } // namespace JSC