Home | History | Annotate | Download | only in src 
      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   static const int64_t kMsPerMonth = kMsPerDay * 30;
     22 
     23   // The largest time that can be passed to OS date-time library functions.
     24   static const int kMaxEpochTimeInSec = kMaxInt;
     25   static const int64_t kMaxEpochTimeInMs =
     26       static_cast<int64_t>(kMaxInt) * 1000;
     27 
     28   // The largest time that can be stored in JSDate.
     29   static const int64_t kMaxTimeInMs =
     30       static_cast<int64_t>(864000000) * 10000000;
     31 
     32   // Conservative upper bound on time that can be stored in JSDate
     33   // before UTC conversion.
     34   static const int64_t kMaxTimeBeforeUTCInMs = kMaxTimeInMs + kMsPerMonth;
     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   // Breaks down the time value.
    194   void BreakDownTime(int64_t time_ms, int* year, int* month, int* day,
    195                      int* weekday, int* hour, int* min, int* sec, int* ms);
    196 
    197   // Cache stamp is used for invalidating caches in JSDate.
    198   // We increment the stamp each time when the timezone information changes.
    199   // JSDate objects perform stamp check and invalidate their caches if
    200   // their saved stamp is not equal to the current stamp.
    201   Smi* stamp() { return stamp_; }
    202   void* stamp_address() { return &stamp_; }
    203 
    204   // These functions are virtual so that we can override them when testing.
    205   virtual int GetDaylightSavingsOffsetFromOS(int64_t time_sec) {
    206     double time_ms = static_cast<double>(time_sec * 1000);
    207     return static_cast<int>(
    208         base::OS::DaylightSavingsOffset(time_ms, tz_cache_));
    209   }
    210 
    211   virtual int GetLocalOffsetFromOS() {
    212     double offset = base::OS::LocalTimeOffset(tz_cache_);
    213     DCHECK(offset < kInvalidLocalOffsetInMs);
    214     return static_cast<int>(offset);
    215   }
    216 
    217  private:
    218   // The implementation relies on the fact that no time zones have
    219   // more than one daylight savings offset change per 19 days.
    220   // In Egypt in 2010 they decided to suspend DST during Ramadan. This
    221   // led to a short interval where DST is in effect from September 10 to
    222   // September 30.
    223   static const int kDefaultDSTDeltaInSec = 19 * kSecPerDay;
    224 
    225   // Size of the Daylight Savings Time cache.
    226   static const int kDSTSize = 32;
    227 
    228   // Daylight Savings Time segment stores a segment of time where
    229   // daylight savings offset does not change.
    230   struct DST {
    231     int start_sec;
    232     int end_sec;
    233     int offset_ms;
    234     int last_used;
    235   };
    236 
    237   // Computes the daylight savings offset for the given time.
    238   // ECMA 262 - 15.9.1.8
    239   int DaylightSavingsOffsetInMs(int64_t time_ms);
    240 
    241   // Sets the before_ and the after_ segments from the DST cache such that
    242   // the before_ segment starts earlier than the given time and
    243   // the after_ segment start later than the given time.
    244   // Both segments might be invalid.
    245   // The last_used counters of the before_ and after_ are updated.
    246   void ProbeDST(int time_sec);
    247 
    248   // Finds the least recently used segment from the DST cache that is not
    249   // equal to the given 'skip' segment.
    250   DST* LeastRecentlyUsedDST(DST* skip);
    251 
    252   // Extends the after_ segment with the given point or resets it
    253   // if it starts later than the given time + kDefaultDSTDeltaInSec.
    254   inline void ExtendTheAfterSegment(int time_sec, int offset_ms);
    255 
    256   // Makes the given segment invalid.
    257   inline void ClearSegment(DST* segment);
    258 
    259   bool InvalidSegment(DST* segment) {
    260     return segment->start_sec > segment->end_sec;
    261   }
    262 
    263   Smi* stamp_;
    264 
    265   // Daylight Saving Time cache.
    266   DST dst_[kDSTSize];
    267   int dst_usage_counter_;
    268   DST* before_;
    269   DST* after_;
    270 
    271   int local_offset_ms_;
    272 
    273   // Year/Month/Day cache.
    274   bool ymd_valid_;
    275   int ymd_days_;
    276   int ymd_year_;
    277   int ymd_month_;
    278   int ymd_day_;
    279 
    280   base::TimezoneCache* tz_cache_;
    281 };
    282 
    283 }  // namespace internal
    284 }  // namespace v8
    285 
    286 #endif
    287