svenpanne@chromium.org | 4efbdb1 | 2012-03-12 08:18:42 +0000 | [diff] [blame] | 1 | // Copyright 2012 the V8 project authors. All rights reserved. |
| 2 | // Redistribution and use in source and binary forms, with or without |
| 3 | // modification, are permitted provided that the following conditions are |
| 4 | // met: |
| 5 | // |
| 6 | // * Redistributions of source code must retain the above copyright |
| 7 | // notice, this list of conditions and the following disclaimer. |
| 8 | // * Redistributions in binary form must reproduce the above |
| 9 | // copyright notice, this list of conditions and the following |
| 10 | // disclaimer in the documentation and/or other materials provided |
| 11 | // with the distribution. |
| 12 | // * Neither the name of Google Inc. nor the names of its |
| 13 | // contributors may be used to endorse or promote products derived |
| 14 | // from this software without specific prior written permission. |
| 15 | // |
| 16 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 17 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 18 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 19 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 20 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 21 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 22 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 23 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 24 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 25 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 26 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 27 | |
| 28 | #ifndef V8_DATE_H_ |
| 29 | #define V8_DATE_H_ |
| 30 | |
| 31 | #include "allocation.h" |
| 32 | #include "globals.h" |
| 33 | #include "platform.h" |
| 34 | |
| 35 | |
| 36 | namespace v8 { |
| 37 | namespace internal { |
| 38 | |
| 39 | class DateCache { |
| 40 | public: |
| 41 | static const int kMsPerMin = 60 * 1000; |
| 42 | static const int kSecPerDay = 24 * 60 * 60; |
| 43 | static const int64_t kMsPerDay = kSecPerDay * 1000; |
| 44 | |
| 45 | // The largest time that can be passed to OS date-time library functions. |
| 46 | static const int kMaxEpochTimeInSec = kMaxInt; |
| 47 | static const int64_t kMaxEpochTimeInMs = |
| 48 | static_cast<int64_t>(kMaxInt) * 1000; |
| 49 | |
| 50 | // The largest time that can be stored in JSDate. |
| 51 | static const int64_t kMaxTimeInMs = |
| 52 | static_cast<int64_t>(864000000) * 10000000; |
| 53 | |
| 54 | // Conservative upper bound on time that can be stored in JSDate |
| 55 | // before UTC conversion. |
| 56 | static const int64_t kMaxTimeBeforeUTCInMs = |
| 57 | kMaxTimeInMs + 10 * kMsPerDay; |
| 58 | |
| 59 | // Sentinel that denotes an invalid local offset. |
| 60 | static const int kInvalidLocalOffsetInMs = kMaxInt; |
| 61 | // Sentinel that denotes an invalid cache stamp. |
| 62 | // It is an invariant of DateCache that cache stamp is non-negative. |
| 63 | static const int kInvalidStamp = -1; |
| 64 | |
| 65 | DateCache() : stamp_(0) { |
| 66 | ResetDateCache(); |
| 67 | } |
| 68 | |
| 69 | virtual ~DateCache() {} |
| 70 | |
| 71 | |
| 72 | // Clears cached timezone information and increments the cache stamp. |
| 73 | void ResetDateCache(); |
| 74 | |
| 75 | |
| 76 | // Computes floor(time_ms / kMsPerDay). |
| 77 | static int DaysFromTime(int64_t time_ms) { |
| 78 | if (time_ms < 0) time_ms -= (kMsPerDay - 1); |
| 79 | return static_cast<int>(time_ms / kMsPerDay); |
| 80 | } |
| 81 | |
| 82 | |
| 83 | // Computes modulo(time_ms, kMsPerDay) given that |
| 84 | // days = floor(time_ms / kMsPerDay). |
| 85 | static int TimeInDay(int64_t time_ms, int days) { |
| 86 | return static_cast<int>(time_ms - days * kMsPerDay); |
| 87 | } |
| 88 | |
| 89 | |
| 90 | // Given the number of days since the epoch, computes the weekday. |
| 91 | // ECMA 262 - 15.9.1.6. |
| 92 | int Weekday(int days) { |
| 93 | int result = (days + 4) % 7; |
| 94 | return result >= 0 ? result : result + 7; |
| 95 | } |
| 96 | |
| 97 | |
| 98 | bool IsLeap(int year) { |
| 99 | return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0); |
| 100 | } |
| 101 | |
| 102 | |
| 103 | // ECMA 262 - 15.9.1.7. |
| 104 | int LocalOffsetInMs() { |
| 105 | if (local_offset_ms_ == kInvalidLocalOffsetInMs) { |
| 106 | local_offset_ms_ = GetLocalOffsetFromOS(); |
| 107 | } |
| 108 | return local_offset_ms_; |
| 109 | } |
| 110 | |
| 111 | |
| 112 | const char* LocalTimezone(int64_t time_ms) { |
| 113 | if (time_ms < 0 || time_ms > kMaxEpochTimeInMs) { |
| 114 | time_ms = EquivalentTime(time_ms); |
| 115 | } |
| 116 | return OS::LocalTimezone(static_cast<double>(time_ms)); |
| 117 | } |
| 118 | |
| 119 | // ECMA 262 - 15.9.5.26 |
| 120 | int TimezoneOffset(int64_t time_ms) { |
| 121 | int64_t local_ms = ToLocal(time_ms); |
| 122 | return static_cast<int>((time_ms - local_ms) / kMsPerMin); |
| 123 | } |
| 124 | |
| 125 | // ECMA 262 - 15.9.1.9 |
| 126 | int64_t ToLocal(int64_t time_ms) { |
| 127 | return time_ms + LocalOffsetInMs() + DaylightSavingsOffsetInMs(time_ms); |
| 128 | } |
| 129 | |
| 130 | // ECMA 262 - 15.9.1.9 |
| 131 | int64_t ToUTC(int64_t time_ms) { |
| 132 | time_ms -= LocalOffsetInMs(); |
| 133 | return time_ms - DaylightSavingsOffsetInMs(time_ms); |
| 134 | } |
| 135 | |
| 136 | |
| 137 | // Computes a time equivalent to the given time according |
| 138 | // to ECMA 262 - 15.9.1.9. |
| 139 | // The issue here is that some library calls don't work right for dates |
| 140 | // that cannot be represented using a non-negative signed 32 bit integer |
| 141 | // (measured in whole seconds based on the 1970 epoch). |
| 142 | // We solve this by mapping the time to a year with same leap-year-ness |
| 143 | // and same starting day for the year. The ECMAscript specification says |
| 144 | // we must do this, but for compatibility with other browsers, we use |
| 145 | // the actual year if it is in the range 1970..2037 |
| 146 | int64_t EquivalentTime(int64_t time_ms) { |
| 147 | int days = DaysFromTime(time_ms); |
| 148 | int time_within_day_ms = static_cast<int>(time_ms - days * kMsPerDay); |
| 149 | int year, month, day; |
| 150 | YearMonthDayFromDays(days, &year, &month, &day); |
| 151 | int new_days = DaysFromYearMonth(EquivalentYear(year), month) + day - 1; |
| 152 | return static_cast<int64_t>(new_days) * kMsPerDay + time_within_day_ms; |
| 153 | } |
| 154 | |
| 155 | // Returns an equivalent year in the range [2008-2035] matching |
| 156 | // - leap year, |
| 157 | // - week day of first day. |
| 158 | // ECMA 262 - 15.9.1.9. |
| 159 | int EquivalentYear(int year) { |
| 160 | int week_day = Weekday(DaysFromYearMonth(year, 0)); |
| 161 | int recent_year = (IsLeap(year) ? 1956 : 1967) + (week_day * 12) % 28; |
| 162 | // Find the year in the range 2008..2037 that is equivalent mod 28. |
| 163 | // Add 3*28 to give a positive argument to the modulus operator. |
| 164 | return 2008 + (recent_year + 3 * 28 - 2008) % 28; |
| 165 | } |
| 166 | |
| 167 | // Given the number of days since the epoch, computes |
| 168 | // the corresponding year, month, and day. |
| 169 | void YearMonthDayFromDays(int days, int* year, int* month, int* day); |
| 170 | |
| 171 | // Computes the number of days since the epoch for |
| 172 | // the first day of the given month in the given year. |
| 173 | int DaysFromYearMonth(int year, int month); |
| 174 | |
| 175 | // Cache stamp is used for invalidating caches in JSDate. |
| 176 | // We increment the stamp each time when the timezone information changes. |
| 177 | // JSDate objects perform stamp check and invalidate their caches if |
| 178 | // their saved stamp is not equal to the current stamp. |
| 179 | Smi* stamp() { return stamp_; } |
| 180 | void* stamp_address() { return &stamp_; } |
| 181 | |
| 182 | // These functions are virtual so that we can override them when testing. |
| 183 | virtual int GetDaylightSavingsOffsetFromOS(int64_t time_sec) { |
| 184 | double time_ms = static_cast<double>(time_sec * 1000); |
| 185 | return static_cast<int>(OS::DaylightSavingsOffset(time_ms)); |
| 186 | } |
| 187 | |
| 188 | virtual int GetLocalOffsetFromOS() { |
| 189 | double offset = OS::LocalTimeOffset(); |
| 190 | ASSERT(offset < kInvalidLocalOffsetInMs); |
| 191 | return static_cast<int>(offset); |
| 192 | } |
| 193 | |
| 194 | private: |
| 195 | // The implementation relies on the fact that no time zones have |
| 196 | // more than one daylight savings offset change per 19 days. |
| 197 | // In Egypt in 2010 they decided to suspend DST during Ramadan. This |
| 198 | // led to a short interval where DST is in effect from September 10 to |
| 199 | // September 30. |
| 200 | static const int kDefaultDSTDeltaInSec = 19 * kSecPerDay; |
| 201 | |
| 202 | // Size of the Daylight Savings Time cache. |
| 203 | static const int kDSTSize = 32; |
| 204 | |
| 205 | // Daylight Savings Time segment stores a segment of time where |
| 206 | // daylight savings offset does not change. |
| 207 | struct DST { |
| 208 | int start_sec; |
| 209 | int end_sec; |
| 210 | int offset_ms; |
| 211 | int last_used; |
| 212 | }; |
| 213 | |
| 214 | // Computes the daylight savings offset for the given time. |
| 215 | // ECMA 262 - 15.9.1.8 |
| 216 | int DaylightSavingsOffsetInMs(int64_t time_ms); |
| 217 | |
| 218 | // Sets the before_ and the after_ segments from the DST cache such that |
| 219 | // the before_ segment starts earlier than the given time and |
| 220 | // the after_ segment start later than the given time. |
| 221 | // Both segments might be invalid. |
| 222 | // The last_used counters of the before_ and after_ are updated. |
| 223 | void ProbeDST(int time_sec); |
| 224 | |
| 225 | // Finds the least recently used segment from the DST cache that is not |
| 226 | // equal to the given 'skip' segment. |
| 227 | DST* LeastRecentlyUsedDST(DST* skip); |
| 228 | |
| 229 | // Extends the after_ segment with the given point or resets it |
| 230 | // if it starts later than the given time + kDefaultDSTDeltaInSec. |
| 231 | inline void ExtendTheAfterSegment(int time_sec, int offset_ms); |
| 232 | |
| 233 | // Makes the given segment invalid. |
| 234 | inline void ClearSegment(DST* segment); |
| 235 | |
| 236 | bool InvalidSegment(DST* segment) { |
| 237 | return segment->start_sec > segment->end_sec; |
| 238 | } |
| 239 | |
| 240 | Smi* stamp_; |
| 241 | |
| 242 | // Daylight Saving Time cache. |
| 243 | DST dst_[kDSTSize]; |
| 244 | int dst_usage_counter_; |
| 245 | DST* before_; |
| 246 | DST* after_; |
| 247 | |
| 248 | int local_offset_ms_; |
| 249 | |
| 250 | // Year/Month/Day cache. |
| 251 | bool ymd_valid_; |
| 252 | int ymd_days_; |
| 253 | int ymd_year_; |
| 254 | int ymd_month_; |
| 255 | int ymd_day_; |
| 256 | }; |
| 257 | |
| 258 | } } // namespace v8::internal |
| 259 | |
| 260 | #endif |