src/v8/src/date.h

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_DATE_H_
   6 #define V8_DATE_H_
   7
   8 #include "src/allocation.h"
   9 #include "src/base/platform/platform.h"
  10 #include "src/globals.h"
  11
  12
  13 namespace v8 {
  14 namespace internal {
  15
  16 class DateCache {
  17  public:
  18   static const int kMsPerMin = 60 * 1000;
  19   static const int kSecPerDay = 24 * 60 * 60;
  20   static const int64_t kMsPerDay = kSecPerDay * 1000;
  21
  22   // The largest time that can be passed to OS date-time library functions.
  23   static const int kMaxEpochTimeInSec = kMaxInt;
  24   static const int64_t kMaxEpochTimeInMs =
  25       static_cast<int64_t>(kMaxInt) * 1000;
  26
  27   // The largest time that can be stored in JSDate.
  28   static const int64_t kMaxTimeInMs =
  29       static_cast<int64_t>(864000000) * 10000000;
  30
  31   // Conservative upper bound on time that can be stored in JSDate
  32   // before UTC conversion.
  33   static const int64_t kMaxTimeBeforeUTCInMs =
  34       kMaxTimeInMs + 10 * kMsPerDay;
  35
  36   // Sentinel that denotes an invalid local offset.
  37   static const int kInvalidLocalOffsetInMs = kMaxInt;
  38   // Sentinel that denotes an invalid cache stamp.
  39   // It is an invariant of DateCache that cache stamp is non-negative.
  40   static const int kInvalidStamp = -1;
  41
  42   DateCache() : stamp_(0), tz_cache_(base::OS::CreateTimezoneCache()) {
  43     ResetDateCache();
  44   }
  45
  46   virtual ~DateCache() {
  47     base::OS::DisposeTimezoneCache(tz_cache_);
  48     tz_cache_ = NULL;
  49   }
  50
  51
  52   // Clears cached timezone information and increments the cache stamp.
  53   void ResetDateCache();
  54
  55
  56   // Computes floor(time_ms / kMsPerDay).
  57   static int DaysFromTime(int64_t time_ms) {
  58     if (time_ms < 0) time_ms -= (kMsPerDay - 1);
  59     return static_cast<int>(time_ms / kMsPerDay);
  60   }
  61
  62
  63   // Computes modulo(time_ms, kMsPerDay) given that
  64   // days = floor(time_ms / kMsPerDay).
  65   static int TimeInDay(int64_t time_ms, int days) {
  66     return static_cast<int>(time_ms - days * kMsPerDay);
  67   }
  68
  69
  70   // Given the number of days since the epoch, computes the weekday.
  71   // ECMA 262 - 15.9.1.6.
  72   int Weekday(int days) {
  73     int result = (days + 4) % 7;
  74     return result >= 0 ? result : result + 7;
  75   }
  76
  77
  78   bool IsLeap(int year) {
  79     return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
  80   }
  81
  82
  83   // ECMA 262 - 15.9.1.7.
  84   int LocalOffsetInMs() {
  85     if (local_offset_ms_ == kInvalidLocalOffsetInMs)  {
  86       local_offset_ms_ = GetLocalOffsetFromOS();
  87     }
  88     return local_offset_ms_;
  89   }
  90
  91
  92   const char* LocalTimezone(int64_t time_ms) {
  93     if (time_ms < 0 || time_ms > kMaxEpochTimeInMs) {
  94       time_ms = EquivalentTime(time_ms);
  95     }
  96     return base::OS::LocalTimezone(static_cast<double>(time_ms), tz_cache_);
  97   }
  98
  99   // ECMA 262 - 15.9.5.26
 100   int TimezoneOffset(int64_t time_ms) {
 101     int64_t local_ms = ToLocal(time_ms);
 102     return static_cast<int>((time_ms - local_ms) / kMsPerMin);
 103   }
 104
 105   // ECMA 262 - 15.9.1.9
 106   // LocalTime(t) = t + LocalTZA + DaylightSavingTA(t)
 107   int64_t ToLocal(int64_t time_ms) {
 108     return time_ms + LocalOffsetInMs() + DaylightSavingsOffsetInMs(time_ms);
 109   }
 110
 111   // ECMA 262 - 15.9.1.9
 112   // UTC(t) = t - LocalTZA - DaylightSavingTA(t - LocalTZA)
 113   int64_t ToUTC(int64_t time_ms) {
 114     // We need to compute UTC time that corresponds to the given local time.
 115     // Literally following spec here leads to incorrect time computation at
 116     // the points were we transition to and from DST.
 117     //
 118     // The following shows that using DST for (t - LocalTZA - hour) produces
 119     // correct conversion.
 120     //
 121     // Consider transition to DST at local time L1.
 122     // Let L0 = L1 - hour, L2 = L1 + hour,
 123     //     U1 = UTC time that corresponds to L1,
 124     //     U0 = U1 - hour.
 125     // Transitioning to DST moves local clock one hour forward L1 => L2, so
 126     // U0 = UTC time that corresponds to L0 = L0 - LocalTZA,
 127     // U1 = UTC time that corresponds to L1 = L1 - LocalTZA,
 128     // U1 = UTC time that corresponds to L2 = L2 - LocalTZA - hour.
 129     // Note that DST(U0 - hour) = 0, DST(U0) = 0, DST(U1) = 1.
 130     // U0 = L0 - LocalTZA - DST(L0 - LocalTZA - hour),
 131     // U1 = L1 - LocalTZA - DST(L1 - LocalTZA - hour),
 132     // U1 = L2 - LocalTZA - DST(L2 - LocalTZA - hour).
 133     //
 134     // Consider transition from DST at local time L1.
 135     // Let L0 = L1 - hour,
 136     //     U1 = UTC time that corresponds to L1,
 137     //     U0 = U1 - hour, U2 = U1 + hour.
 138     // Transitioning from DST moves local clock one hour back L1 => L0, so
 139     // U0 = UTC time that corresponds to L0 (before transition)
 140     //    = L0 - LocalTZA - hour.
 141     // U1 = UTC time that corresponds to L0 (after transition)
 142     //    = L0 - LocalTZA = L1 - LocalTZA - hour
 143     // U2 = UTC time that corresponds to L1 = L1 - LocalTZA.
 144     // Note that DST(U0) = 1, DST(U1) = 0, DST(U2) = 0.
 145     // U0 = L0 - LocalTZA - DST(L0 - LocalTZA - hour) = L0 - LocalTZA - DST(U0).
 146     // U2 = L1 - LocalTZA - DST(L1 - LocalTZA - hour) = L1 - LocalTZA - DST(U1).
 147     // It is impossible to get U1 from local time.
 148
 149     const int kMsPerHour = 3600 * 1000;
 150     time_ms -= LocalOffsetInMs();
 151     return time_ms - DaylightSavingsOffsetInMs(time_ms - kMsPerHour);
 152   }
 153
 154
 155   // Computes a time equivalent to the given time according
 156   // to ECMA 262 - 15.9.1.9.
 157   // The issue here is that some library calls don't work right for dates
 158   // that cannot be represented using a non-negative signed 32 bit integer
 159   // (measured in whole seconds based on the 1970 epoch).
 160   // We solve this by mapping the time to a year with same leap-year-ness
 161   // and same starting day for the year. The ECMAscript specification says
 162   // we must do this, but for compatibility with other browsers, we use
 163   // the actual year if it is in the range 1970..2037
 164   int64_t EquivalentTime(int64_t time_ms) {
 165     int days = DaysFromTime(time_ms);
 166     int time_within_day_ms = static_cast<int>(time_ms - days * kMsPerDay);
 167     int year, month, day;
 168     YearMonthDayFromDays(days, &year, &month, &day);
 169     int new_days = DaysFromYearMonth(EquivalentYear(year), month) + day - 1;
 170     return static_cast<int64_t>(new_days) * kMsPerDay + time_within_day_ms;
 171   }
 172
 173   // Returns an equivalent year in the range [2008-2035] matching
 174   // - leap year,
 175   // - week day of first day.
 176   // ECMA 262 - 15.9.1.9.
 177   int EquivalentYear(int year) {
 178     int week_day = Weekday(DaysFromYearMonth(year, 0));
 179     int recent_year = (IsLeap(year) ? 1956 : 1967) + (week_day * 12) % 28;
 180     // Find the year in the range 2008..2037 that is equivalent mod 28.
 181     // Add 3*28 to give a positive argument to the modulus operator.
 182     return 2008 + (recent_year + 3 * 28 - 2008) % 28;
 183   }
 184
 185   // Given the number of days since the epoch, computes
 186   // the corresponding year, month, and day.
 187   void YearMonthDayFromDays(int days, int* year, int* month, int* day);
 188
 189   // Computes the number of days since the epoch for
 190   // the first day of the given month in the given year.
 191   int DaysFromYearMonth(int year, int month);
 192
 193   // Cache stamp is used for invalidating caches in JSDate.
 194   // We increment the stamp each time when the timezone information changes.
 195   // JSDate objects perform stamp check and invalidate their caches if
 196   // their saved stamp is not equal to the current stamp.
 197   Smi* stamp() { return stamp_; }
 198   void* stamp_address() { return &stamp_; }
 199
 200   // These functions are virtual so that we can override them when testing.
 201   virtual int GetDaylightSavingsOffsetFromOS(int64_t time_sec) {
 202     double time_ms = static_cast<double>(time_sec * 1000);
 203     return static_cast<int>(
 204         base::OS::DaylightSavingsOffset(time_ms, tz_cache_));
 205   }
 206
 207   virtual int GetLocalOffsetFromOS() {
 208     double offset = base::OS::LocalTimeOffset(tz_cache_);
 209     DCHECK(offset < kInvalidLocalOffsetInMs);
 210     return static_cast<int>(offset);
 211   }
 212
 213  private:
 214   // The implementation relies on the fact that no time zones have
 215   // more than one daylight savings offset change per 19 days.
 216   // In Egypt in 2010 they decided to suspend DST during Ramadan. This
 217   // led to a short interval where DST is in effect from September 10 to
 218   // September 30.
 219   static const int kDefaultDSTDeltaInSec = 19 * kSecPerDay;
 220
 221   // Size of the Daylight Savings Time cache.
 222   static const int kDSTSize = 32;
 223
 224   // Daylight Savings Time segment stores a segment of time where
 225   // daylight savings offset does not change.
 226   struct DST {
 227     int start_sec;
 228     int end_sec;
 229     int offset_ms;
 230     int last_used;
 231   };
 232
 233   // Computes the daylight savings offset for the given time.
 234   // ECMA 262 - 15.9.1.8
 235   int DaylightSavingsOffsetInMs(int64_t time_ms);
 236
 237   // Sets the before_ and the after_ segments from the DST cache such that
 238   // the before_ segment starts earlier than the given time and
 239   // the after_ segment start later than the given time.
 240   // Both segments might be invalid.
 241   // The last_used counters of the before_ and after_ are updated.
 242   void ProbeDST(int time_sec);
 243
 244   // Finds the least recently used segment from the DST cache that is not
 245   // equal to the given 'skip' segment.
 246   DST* LeastRecentlyUsedDST(DST* skip);
 247
 248   // Extends the after_ segment with the given point or resets it
 249   // if it starts later than the given time + kDefaultDSTDeltaInSec.
 250   inline void ExtendTheAfterSegment(int time_sec, int offset_ms);
 251
 252   // Makes the given segment invalid.
 253   inline void ClearSegment(DST* segment);
 254
 255   bool InvalidSegment(DST* segment) {
 256     return segment->start_sec > segment->end_sec;
 257   }
 258
 259   Smi* stamp_;
 260
 261   // Daylight Saving Time cache.
 262   DST dst_[kDSTSize];
 263   int dst_usage_counter_;
 264   DST* before_;
 265   DST* after_;
 266
 267   int local_offset_ms_;
 268
 269   // Year/Month/Day cache.
 270   bool ymd_valid_;
 271   int ymd_days_;
 272   int ymd_year_;
 273   int ymd_month_;
 274   int ymd_day_;
 275
 276   base::TimezoneCache* tz_cache_;
 277 };
 278
 279 } }   // namespace v8::internal
 280
 281 #endif