v8::internal::DateCache Class Reference

#include <date.h>

Collaboration diagram for v8::internal::DateCache:

Classes
struct	DST

Public Member Functions
	DateCache ()
virtual	~DateCache ()
void	ResetDateCache ()
int	Weekday (int days)
bool	IsLeap (int year)
int	LocalOffsetInMs ()
const char *	LocalTimezone (int64_t time_ms)
int	TimezoneOffset (int64_t time_ms)
int64_t	ToLocal (int64_t time_ms)
int64_t	ToUTC (int64_t time_ms)
int64_t	EquivalentTime (int64_t time_ms)
int	EquivalentYear (int year)
void	YearMonthDayFromDays (int days, int *year, int *month, int *day)
int	DaysFromYearMonth (int year, int month)
Smi *	stamp ()
void *	stamp_address ()
virtual int	GetDaylightSavingsOffsetFromOS (int64_t time_sec)
virtual int	GetLocalOffsetFromOS ()

Static Public Member Functions
static int	DaysFromTime (int64_t time_ms)
static int	TimeInDay (int64_t time_ms, int days)

Static Public Attributes
static const int	kMsPerMin = 60 * 1000
static const int	kSecPerDay = 24 * 60 * 60
static const int64_t	kMsPerDay = kSecPerDay * 1000
static const int	kMaxEpochTimeInSec = kMaxInt
static const int64_t	kMaxEpochTimeInMs
static const int64_t	kMaxTimeInMs
static const int64_t	kMaxTimeBeforeUTCInMs
static const int	kInvalidLocalOffsetInMs = kMaxInt
static const int	kInvalidStamp = -1

Private Member Functions
int	DaylightSavingsOffsetInMs (int64_t time_ms)
void	ProbeDST (int time_sec)
DST *	LeastRecentlyUsedDST (DST *skip)
void	ExtendTheAfterSegment (int time_sec, int offset_ms)
void	ClearSegment (DST *segment)
bool	InvalidSegment (DST *segment)

Private Attributes
Smi *	stamp_
DST	dst_ [kDSTSize]
int	dst_usage_counter_
DST *	before_
DST *	after_
int	local_offset_ms_
bool	ymd_valid_
int	ymd_days_
int	ymd_year_
int	ymd_month_
int	ymd_day_
base::TimezoneCache *	tz_cache_

Static Private Attributes
static const int	kDefaultDSTDeltaInSec = 19 * kSecPerDay
static const int	kDSTSize = 32

Detailed Description

Definition at line 16 of file date.h.

Constructor & Destructor Documentation

DateCache()

v8::internal::DateCache::DateCache ( )

inline

Definition at line 42 of file date.h.

              : stamp_(0), tz_cache_(base::OS::CreateTimezoneCache()) {
    ResetDateCache();
  }

References ResetDateCache().

Here is the call graph for this function:

~DateCache()

virtual v8::internal::DateCache::~DateCache ( )

inlinevirtual

Definition at line 46 of file date.h.

                       {
    base::OS::DisposeTimezoneCache(tz_cache_);
    tz_cache_ = NULL;
  }

References v8::base::OS::DisposeTimezoneCache(), NULL, and tz_cache_.

Here is the call graph for this function:

Member Function Documentation

ClearSegment()

void v8::internal::DateCache::ClearSegment ( DST *  segment )

inlineprivate

Definition at line 47 of file date.cc.

                                         {
  segment->start_sec = kMaxEpochTimeInSec;
  segment->end_sec = -kMaxEpochTimeInSec;
  segment->offset_ms = 0;
  segment->last_used = 0;
}

References v8::internal::DateCache::DST::end_sec, kMaxEpochTimeInSec, v8::internal::DateCache::DST::last_used, v8::internal::DateCache::DST::offset_ms, and v8::internal::DateCache::DST::start_sec.

Referenced by DaylightSavingsOffsetInMs(), LeastRecentlyUsedDST(), and ResetDateCache().

Here is the caller graph for this function:

DaylightSavingsOffsetInMs()

int v8::internal::DateCache::DaylightSavingsOffsetInMs ( int64_t  time_ms )

private

Definition at line 200 of file date.cc.

                                                        {
  int time_sec = (time_ms >= 0 && time_ms <= kMaxEpochTimeInMs)
      ? static_cast<int>(time_ms / 1000)
      : static_cast<int>(EquivalentTime(time_ms) / 1000);
 
  // Invalidate cache if the usage counter is close to overflow.
  // Note that dst_usage_counter is incremented less than ten times
  // in this function.
  if (dst_usage_counter_ >= kMaxInt - 10) {
    dst_usage_counter_ = 0;
    for (int i = 0; i < kDSTSize; ++i) {
      ClearSegment(&dst_[i]);
    }
  }
 
  // Optimistic fast check.
  if (before_->start_sec <= time_sec &&
      time_sec <= before_->end_sec) {
    // Cache hit.
    before_->last_used = ++dst_usage_counter_;
    return before_->offset_ms;
  }
 
  ProbeDST(time_sec);
 
  DCHECK(InvalidSegment(before_) || before_->start_sec <= time_sec);
  DCHECK(InvalidSegment(after_) || time_sec < after_->start_sec);
 
  if (InvalidSegment(before_)) {
    // Cache miss.
    before_->start_sec = time_sec;
    before_->end_sec = time_sec;
    before_->offset_ms = GetDaylightSavingsOffsetFromOS(time_sec);
    before_->last_used = ++dst_usage_counter_;
    return before_->offset_ms;
  }
 
  if (time_sec <= before_->end_sec) {
    // Cache hit.
    before_->last_used = ++dst_usage_counter_;
    return before_->offset_ms;
  }
 
  if (time_sec > before_->end_sec + kDefaultDSTDeltaInSec) {
    // If the before_ segment ends too early, then just
    // query for the offset of the time_sec
    int offset_ms = GetDaylightSavingsOffsetFromOS(time_sec);
    ExtendTheAfterSegment(time_sec, offset_ms);
    // This swap helps the optimistic fast check in subsequent invocations.
    DST* temp = before_;
    before_ = after_;
    after_ = temp;
    return offset_ms;
  }
 
  // Now the time_sec is between
  // before_->end_sec and before_->end_sec + default DST delta.
  // Update the usage counter of before_ since it is going to be used.
  before_->last_used = ++dst_usage_counter_;
 
  // Check if after_ segment is invalid or starts too late.
  // Note that start_sec of invalid segments is kMaxEpochTimeInSec.
  if (before_->end_sec + kDefaultDSTDeltaInSec <= after_->start_sec) {
    int new_after_start_sec = before_->end_sec + kDefaultDSTDeltaInSec;
    int new_offset_ms = GetDaylightSavingsOffsetFromOS(new_after_start_sec);
    ExtendTheAfterSegment(new_after_start_sec, new_offset_ms);
  } else {
    DCHECK(!InvalidSegment(after_));
    // Update the usage counter of after_ since it is going to be used.
    after_->last_used = ++dst_usage_counter_;
  }
 
  // Now the time_sec is between before_->end_sec and after_->start_sec.
  // Only one daylight savings offset change can occur in this interval.
 
  if (before_->offset_ms == after_->offset_ms) {
    // Merge two segments if they have the same offset.
    before_->end_sec = after_->end_sec;
    ClearSegment(after_);
    return before_->offset_ms;
  }
 
  // Binary search for daylight savings offset change point,
  // but give up if we don't find it in four iterations.
  for (int i = 4; i >= 0; --i) {
    int delta = after_->start_sec - before_->end_sec;
    int middle_sec = (i == 0) ? time_sec : before_->end_sec + delta / 2;
    int offset_ms = GetDaylightSavingsOffsetFromOS(middle_sec);
    if (before_->offset_ms == offset_ms) {
      before_->end_sec = middle_sec;
      if (time_sec <= before_->end_sec) {
        return offset_ms;
      }
    } else {
      DCHECK(after_->offset_ms == offset_ms);
      after_->start_sec = middle_sec;
      if (time_sec >= after_->start_sec) {
        // This swap helps the optimistic fast check in subsequent invocations.
        DST* temp = before_;
        before_ = after_;
        after_ = temp;
        return offset_ms;
      }
    }
  }
  UNREACHABLE();
  return 0;
}

References after_, before_, ClearSegment(), DCHECK, dst_, dst_usage_counter_, v8::internal::DateCache::DST::end_sec, EquivalentTime(), ExtendTheAfterSegment(), GetDaylightSavingsOffsetFromOS(), InvalidSegment(), kDefaultDSTDeltaInSec, kDSTSize, kMaxEpochTimeInMs, v8::internal::kMaxInt, v8::internal::DateCache::DST::last_used, v8::internal::DateCache::DST::offset_ms, ProbeDST(), v8::internal::DateCache::DST::start_sec, and UNREACHABLE.

Referenced by ToLocal(), and ToUTC().

Here is the call graph for this function:

Here is the caller graph for this function:

DaysFromTime()

static int v8::internal::DateCache::DaysFromTime ( int64_t  time_ms )

inlinestatic

Definition at line 57 of file date.h.

                                           {
    if (time_ms < 0) time_ms -= (kMsPerDay - 1);
    return static_cast<int>(time_ms / kMsPerDay);
  }

References kMsPerDay.

Referenced by v8::internal::JSDate::DoGetField(), EquivalentTime(), v8::internal::JSDate::GetUTCField(), and v8::internal::JSDate::SetCachedFields().

Here is the caller graph for this function:

DaysFromYearMonth()

int v8::internal::DateCache::DaysFromYearMonth	(	int	year,
		int	month
	)

Definition at line 136 of file date.cc.

                                                    {
  static const int day_from_month[] = {0, 31, 59, 90, 120, 151,
                                       181, 212, 243, 273, 304, 334};
  static const int day_from_month_leap[] = {0, 31, 60, 91, 121, 152,
                                            182, 213, 244, 274, 305, 335};
 
  year += month / 12;
  month %= 12;
  if (month < 0) {
    year--;
    month += 12;
  }
 
  DCHECK(month >= 0);
  DCHECK(month < 12);
 
  // year_delta is an arbitrary number such that:
  // a) year_delta = -1 (mod 400)
  // b) year + year_delta > 0 for years in the range defined by
  //    ECMA 262 - 15.9.1.1, i.e. upto 100,000,000 days on either side of
  //    Jan 1 1970. This is required so that we don't run into integer
  //    division of negative numbers.
  // c) there shouldn't be an overflow for 32-bit integers in the following
  //    operations.
  static const int year_delta = 399999;
  static const int base_day = 365 * (1970 + year_delta) +
                              (1970 + year_delta) / 4 -
                              (1970 + year_delta) / 100 +
                              (1970 + year_delta) / 400;
 
  int year1 = year + year_delta;
  int day_from_year = 365 * year1 +
                      year1 / 4 -
                      year1 / 100 +
                      year1 / 400 -
                      base_day;
 
  if ((year % 4 != 0) || (year % 100 == 0 && year % 400 != 0)) {
    return day_from_year + day_from_month[month];
  }
  return day_from_year + day_from_month_leap[month];
}

References DCHECK.

Referenced by EquivalentTime(), EquivalentYear(), and YearMonthDayFromDays().

Here is the caller graph for this function:

EquivalentTime()

int64_t v8::internal::DateCache::EquivalentTime ( int64_t  time_ms )

inline

Definition at line 134 of file date.h.

                                          {
    int days = DaysFromTime(time_ms);
    int time_within_day_ms = static_cast<int>(time_ms - days * kMsPerDay);
    int year, month, day;
    YearMonthDayFromDays(days, &year, &month, &day);
    int new_days = DaysFromYearMonth(EquivalentYear(year), month) + day - 1;
    return static_cast<int64_t>(new_days) * kMsPerDay + time_within_day_ms;
  }

References DaysFromTime(), DaysFromYearMonth(), EquivalentYear(), kMsPerDay, and YearMonthDayFromDays().

Referenced by DaylightSavingsOffsetInMs(), and LocalTimezone().

Here is the call graph for this function:

Here is the caller graph for this function:

EquivalentYear()

int v8::internal::DateCache::EquivalentYear ( int  year )

inline

Definition at line 147 of file date.h.

                               {
    int week_day = Weekday(DaysFromYearMonth(year, 0));
    int recent_year = (IsLeap(year) ? 1956 : 1967) + (week_day * 12) % 28;
    // Find the year in the range 2008..2037 that is equivalent mod 28.
    // Add 3*28 to give a positive argument to the modulus operator.
    return 2008 + (recent_year + 3 * 28 - 2008) % 28;
  }

References DaysFromYearMonth(), IsLeap(), and Weekday().

Referenced by EquivalentTime().

Here is the call graph for this function:

Here is the caller graph for this function:

ExtendTheAfterSegment()

void v8::internal::DateCache::ExtendTheAfterSegment ( int  time_sec, int  offset_ms  )

inlineprivate

Definition at line 180 of file date.cc.

                                                                 {
  if (after_->offset_ms == offset_ms &&
      after_->start_sec <= time_sec + kDefaultDSTDeltaInSec &&
      time_sec <= after_->end_sec) {
    // Extend the after_ segment.
    after_->start_sec = time_sec;
  } else {
    // The after_ segment is either invalid or starts too late.
    if (after_->start_sec <= after_->end_sec) {
      // If the after_ segment is valid, replace it with a new segment.
      after_ = LeastRecentlyUsedDST(before_);
    }
    after_->start_sec = time_sec;
    after_->end_sec = time_sec;
    after_->offset_ms = offset_ms;
    after_->last_used = ++dst_usage_counter_;
  }
}

References after_, before_, dst_usage_counter_, v8::internal::DateCache::DST::end_sec, kDefaultDSTDeltaInSec, v8::internal::DateCache::DST::last_used, LeastRecentlyUsedDST(), v8::internal::DateCache::DST::offset_ms, and v8::internal::DateCache::DST::start_sec.

Referenced by DaylightSavingsOffsetInMs().

Here is the call graph for this function:

Here is the caller graph for this function:

GetDaylightSavingsOffsetFromOS()

virtual int v8::internal::DateCache::GetDaylightSavingsOffsetFromOS ( int64_t  time_sec )

inlinevirtual

Definition at line 171 of file date.h.

                                                               {
    double time_ms = static_cast<double>(time_sec * 1000);
    return static_cast<int>(
        base::OS::DaylightSavingsOffset(time_ms, tz_cache_));
  }

References v8::base::OS::DaylightSavingsOffset(), and tz_cache_.

Referenced by DaylightSavingsOffsetInMs().

Here is the call graph for this function:

Here is the caller graph for this function:

GetLocalOffsetFromOS()

virtual int v8::internal::DateCache::GetLocalOffsetFromOS ( )

inlinevirtual

Definition at line 177 of file date.h.

                                     {
    double offset = base::OS::LocalTimeOffset(tz_cache_);
    DCHECK(offset < kInvalidLocalOffsetInMs);
    return static_cast<int>(offset);
  }

References DCHECK, kInvalidLocalOffsetInMs, v8::base::OS::LocalTimeOffset(), and tz_cache_.

Referenced by LocalOffsetInMs().

Here is the call graph for this function:

Here is the caller graph for this function:

InvalidSegment()

bool v8::internal::DateCache::InvalidSegment ( DST *  segment )

inlineprivate

Definition at line 225 of file date.h.

                                    {
    return segment->start_sec > segment->end_sec;
  }

References v8::internal::DateCache::DST::end_sec, and v8::internal::DateCache::DST::start_sec.

Referenced by DaylightSavingsOffsetInMs(), and ProbeDST().

Here is the caller graph for this function:

IsLeap()

bool v8::internal::DateCache::IsLeap ( int  year )

inline

Definition at line 78 of file date.h.

                        {
    return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
  }

Referenced by EquivalentYear().

Here is the caller graph for this function:

LeastRecentlyUsedDST()

DateCache::DST * v8::internal::DateCache::LeastRecentlyUsedDST ( DST *  skip )

private

Definition at line 350 of file date.cc.

                                                       {
  DST* result = NULL;
  for (int i = 0; i < kDSTSize; ++i) {
    if (&dst_[i] == skip) continue;
    if (result == NULL || result->last_used > dst_[i].last_used) {
      result = &dst_[i];
    }
  }
  ClearSegment(result);
  return result;
}

References ClearSegment(), dst_, kDSTSize, v8::internal::DateCache::DST::last_used, and NULL.

Referenced by ExtendTheAfterSegment(), and ProbeDST().

Here is the call graph for this function:

Here is the caller graph for this function:

LocalOffsetInMs()

int v8::internal::DateCache::LocalOffsetInMs ( )

inline

Definition at line 84 of file date.h.

                        {
    if (local_offset_ms_ == kInvalidLocalOffsetInMs)  {
      local_offset_ms_ = GetLocalOffsetFromOS();
    }
    return local_offset_ms_;
  }

References GetLocalOffsetFromOS(), kInvalidLocalOffsetInMs, and local_offset_ms_.

Referenced by ToLocal(), and ToUTC().

Here is the call graph for this function:

Here is the caller graph for this function:

LocalTimezone()

const char* v8::internal::DateCache::LocalTimezone ( int64_t  time_ms )

inline

Definition at line 92 of file date.h.

                                             {
    if (time_ms < 0 || time_ms > kMaxEpochTimeInMs) {
      time_ms = EquivalentTime(time_ms);
    }
    return base::OS::LocalTimezone(static_cast<double>(time_ms), tz_cache_);
  }

References EquivalentTime(), kMaxEpochTimeInMs, v8::base::OS::LocalTimezone(), and tz_cache_.

Here is the call graph for this function:

ProbeDST()

void v8::internal::DateCache::ProbeDST ( int  time_sec )

private

Definition at line 310 of file date.cc.

                                     {
  DST* before = NULL;
  DST* after = NULL;
  DCHECK(before_ != after_);
 
  for (int i = 0; i < kDSTSize; ++i) {
    if (dst_[i].start_sec <= time_sec) {
      if (before == NULL || before->start_sec < dst_[i].start_sec) {
        before = &dst_[i];
      }
    } else if (time_sec < dst_[i].end_sec) {
      if (after == NULL || after->end_sec > dst_[i].end_sec) {
        after = &dst_[i];
      }
    }
  }
 
  // If before or after segments were not found,
  // then set them to any invalid segment.
  if (before == NULL) {
    before = InvalidSegment(before_) ? before_ : LeastRecentlyUsedDST(after);
  }
  if (after == NULL) {
    after = InvalidSegment(after_) && before != after_
            ? after_ : LeastRecentlyUsedDST(before);
  }
 
  DCHECK(before != NULL);
  DCHECK(after != NULL);
  DCHECK(before != after);
  DCHECK(InvalidSegment(before) || before->start_sec <= time_sec);
  DCHECK(InvalidSegment(after) || time_sec < after->start_sec);
  DCHECK(InvalidSegment(before) || InvalidSegment(after) ||
         before->end_sec < after->start_sec);
 
  before_ = before;
  after_ = after;
}

References after_, before_, DCHECK, dst_, v8::internal::DateCache::DST::end_sec, InvalidSegment(), kDSTSize, LeastRecentlyUsedDST(), NULL, and v8::internal::DateCache::DST::start_sec.

Referenced by DaylightSavingsOffsetInMs().

Here is the call graph for this function:

Here is the caller graph for this function:

ResetDateCache()

void v8::internal::DateCache::ResetDateCache

(

)

Definition at line 27 of file date.cc.

                               {
  static const int kMaxStamp = Smi::kMaxValue;
  if (stamp_->value() >= kMaxStamp) {
    stamp_ = Smi::FromInt(0);
  } else {
    stamp_ = Smi::FromInt(stamp_->value() + 1);
  }
  DCHECK(stamp_ != Smi::FromInt(kInvalidStamp));
  for (int i = 0; i < kDSTSize; ++i) {
    ClearSegment(&dst_[i]);
  }
  dst_usage_counter_ = 0;
  before_ = &dst_[0];
  after_ = &dst_[1];
  local_offset_ms_ = kInvalidLocalOffsetInMs;
  ymd_valid_ = false;
  base::OS::ClearTimezoneCache(tz_cache_);
}

References after_, before_, ClearSegment(), v8::base::OS::ClearTimezoneCache(), DCHECK, dst_, dst_usage_counter_, v8::internal::Smi::FromInt(), kDSTSize, kInvalidLocalOffsetInMs, kInvalidStamp, v8::internal::Smi::kMaxValue, local_offset_ms_, stamp_, tz_cache_, v8::internal::Smi::value(), and ymd_valid_.

Referenced by DateCache(), and v8::Date::DateTimeConfigurationChangeNotification().

Here is the call graph for this function:

Here is the caller graph for this function:

stamp()

Smi* v8::internal::DateCache::stamp ( )

inline

Definition at line 167 of file date.h.

{ return stamp_; }

References stamp_.

Referenced by v8::internal::JSDate::DoGetField(), and v8::internal::JSDate::SetCachedFields().

Here is the caller graph for this function:

stamp_address()

void* v8::internal::DateCache::stamp_address ( )

inline

Definition at line 168 of file date.h.

{ return &stamp_; }

References stamp_.

TimeInDay()

static int v8::internal::DateCache::TimeInDay ( int64_t  time_ms, int  days  )

inlinestatic

Definition at line 65 of file date.h.

                                                  {
    return static_cast<int>(time_ms - days * kMsPerDay);
  }

References kMsPerDay.

Referenced by v8::internal::JSDate::DoGetField(), v8::internal::JSDate::GetUTCField(), and v8::internal::JSDate::SetCachedFields().

Here is the caller graph for this function:

TimezoneOffset()

int v8::internal::DateCache::TimezoneOffset ( int64_t  time_ms )

inline

Definition at line 100 of file date.h.

                                      {
    int64_t local_ms = ToLocal(time_ms);
    return static_cast<int>((time_ms - local_ms) / kMsPerMin);
  }

References kMsPerMin, and ToLocal().

Referenced by v8::internal::JSDate::GetUTCField().

Here is the call graph for this function:

Here is the caller graph for this function:

ToLocal()

int64_t v8::internal::DateCache::ToLocal ( int64_t  time_ms )

inline

Definition at line 110 of file date.h.

                                   {
    time_ms += LocalOffsetInMs();
    return time_ms + DaylightSavingsOffsetInMs(time_ms);
  }

References DaylightSavingsOffsetInMs(), and LocalOffsetInMs().

Referenced by v8::internal::JSDate::DoGetField(), and TimezoneOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

ToUTC()

int64_t v8::internal::DateCache::ToUTC ( int64_t  time_ms )

inline

Definition at line 120 of file date.h.

                                 {
    return time_ms - LocalOffsetInMs() - DaylightSavingsOffsetInMs(time_ms);
  }

References DaylightSavingsOffsetInMs(), and LocalOffsetInMs().

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

Weekday()

int v8::internal::DateCache::Weekday ( int  days )

inline

Definition at line 72 of file date.h.

                        {
    int result = (days + 4) % 7;
    return result >= 0 ? result : result + 7;
  }

Referenced by EquivalentYear(), v8::internal::JSDate::GetUTCField(), and v8::internal::JSDate::SetCachedFields().

Here is the caller graph for this function:

YearMonthDayFromDays()

void v8::internal::DateCache::YearMonthDayFromDays	(	int	days,
		int *	year,
		int *	month,
		int *	day
	)

Definition at line 55 of file date.cc.

                                               {
  if (ymd_valid_) {
    // Check conservatively if the given 'days' has
    // the same year and month as the cached 'days'.
    int new_day = ymd_day_ + (days - ymd_days_);
    if (new_day >= 1 && new_day <= 28) {
      ymd_day_ = new_day;
      ymd_days_ = days;
      *year = ymd_year_;
      *month = ymd_month_;
      *day = new_day;
      return;
    }
  }
  int save_days = days;
 
  days += kDaysOffset;
  *year = 400 * (days / kDaysIn400Years) - kYearsOffset;
  days %= kDaysIn400Years;
 
  DCHECK(DaysFromYearMonth(*year, 0) + days == save_days);
 
  days--;
  int yd1 = days / kDaysIn100Years;
  days %= kDaysIn100Years;
  *year += 100 * yd1;
 
  days++;
  int yd2 = days / kDaysIn4Years;
  days %= kDaysIn4Years;
  *year += 4 * yd2;
 
  days--;
  int yd3 = days / 365;
  days %= 365;
  *year += yd3;
 
 
  bool is_leap = (!yd1 || yd2) && !yd3;
 
  DCHECK(days >= -1);
  DCHECK(is_leap || (days >= 0));
  DCHECK((days < 365) || (is_leap && (days < 366)));
  DCHECK(is_leap == ((*year % 4 == 0) && (*year % 100 || (*year % 400 == 0))));
  DCHECK(is_leap || ((DaysFromYearMonth(*year, 0) + days) == save_days));
  DCHECK(!is_leap || ((DaysFromYearMonth(*year, 0) + days + 1) == save_days));
 
  days += is_leap;
 
  // Check if the date is after February.
  if (days >= 31 + 28 + is_leap) {
    days -= 31 + 28 + is_leap;
    // Find the date starting from March.
    for (int i = 2; i < 12; i++) {
      if (days < kDaysInMonths[i]) {
        *month = i;
        *day = days + 1;
        break;
      }
      days -= kDaysInMonths[i];
    }
  } else {
    // Check January and February.
    if (days < 31) {
      *month = 0;
      *day = days + 1;
    } else {
      *month = 1;
      *day = days - 31 + 1;
    }
  }
  DCHECK(DaysFromYearMonth(*year, *month) + *day - 1 == save_days);
  ymd_valid_ = true;
  ymd_year_ = *year;
  ymd_month_ = *month;
  ymd_day_ = *day;
  ymd_days_ = save_days;
}

References DaysFromYearMonth(), DCHECK, v8::internal::kDaysIn100Years, v8::internal::kDaysIn400Years, v8::internal::kDaysIn4Years, v8::internal::kDaysInMonths, v8::internal::kDaysOffset, v8::internal::kYearsOffset, ymd_day_, ymd_days_, ymd_month_, ymd_valid_, and ymd_year_.

Referenced by EquivalentTime(), v8::internal::JSDate::GetUTCField(), and v8::internal::JSDate::SetCachedFields().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

after_

DST* v8::internal::DateCache::after_

private

Definition at line 235 of file date.h.

Referenced by DaylightSavingsOffsetInMs(), ExtendTheAfterSegment(), ProbeDST(), and ResetDateCache().

before_

DST* v8::internal::DateCache::before_

private

Definition at line 234 of file date.h.

Referenced by DaylightSavingsOffsetInMs(), ExtendTheAfterSegment(), ProbeDST(), and ResetDateCache().

dst_

DST v8::internal::DateCache::dst_[kDSTSize]

private

Definition at line 232 of file date.h.

Referenced by DaylightSavingsOffsetInMs(), LeastRecentlyUsedDST(), ProbeDST(), and ResetDateCache().

dst_usage_counter_

int v8::internal::DateCache::dst_usage_counter_

private

Definition at line 233 of file date.h.

Referenced by DaylightSavingsOffsetInMs(), ExtendTheAfterSegment(), and ResetDateCache().

kDefaultDSTDeltaInSec

const int v8::internal::DateCache::kDefaultDSTDeltaInSec = 19 * kSecPerDay

staticprivate

Definition at line 189 of file date.h.

Referenced by DaylightSavingsOffsetInMs(), and ExtendTheAfterSegment().

kDSTSize

const int v8::internal::DateCache::kDSTSize = 32

staticprivate

Definition at line 192 of file date.h.

Referenced by DaylightSavingsOffsetInMs(), LeastRecentlyUsedDST(), ProbeDST(), and ResetDateCache().

kInvalidLocalOffsetInMs

const int v8::internal::DateCache::kInvalidLocalOffsetInMs = kMaxInt

static

Definition at line 37 of file date.h.

Referenced by GetLocalOffsetFromOS(), LocalOffsetInMs(), and ResetDateCache().

kInvalidStamp

const int v8::internal::DateCache::kInvalidStamp = -1

static

Definition at line 40 of file date.h.

Referenced by ResetDateCache(), and v8::internal::JSDate::SetValue().

kMaxEpochTimeInMs

const int64_t v8::internal::DateCache::kMaxEpochTimeInMs

static

Initial value:

=
      static_cast<int64_t>(kMaxInt) * 1000

Definition at line 24 of file date.h.

Referenced by DaylightSavingsOffsetInMs(), and LocalTimezone().

kMaxEpochTimeInSec

const int v8::internal::DateCache::kMaxEpochTimeInSec = kMaxInt

static

Definition at line 23 of file date.h.

Referenced by ClearSegment().

kMaxTimeBeforeUTCInMs

const int64_t v8::internal::DateCache::kMaxTimeBeforeUTCInMs

static

Initial value:

=
      kMaxTimeInMs + 10 * kMsPerDay

Definition at line 33 of file date.h.

Referenced by v8::internal::RUNTIME_FUNCTION().

kMaxTimeInMs

const int64_t v8::internal::DateCache::kMaxTimeInMs

static

Initial value:

=
      static_cast<int64_t>(864000000) * 10000000

Definition at line 28 of file date.h.

Referenced by v8::internal::RUNTIME_FUNCTION().

kMsPerDay

const int64_t v8::internal::DateCache::kMsPerDay = kSecPerDay * 1000

static

Definition at line 20 of file date.h.

Referenced by DaysFromTime(), EquivalentTime(), and TimeInDay().

kMsPerMin

const int v8::internal::DateCache::kMsPerMin = 60 * 1000

static

Definition at line 18 of file date.h.

Referenced by TimezoneOffset().

kSecPerDay

const int v8::internal::DateCache::kSecPerDay = 24 * 60 * 60

static

Definition at line 19 of file date.h.

local_offset_ms_

int v8::internal::DateCache::local_offset_ms_

private

Definition at line 237 of file date.h.

Referenced by LocalOffsetInMs(), and ResetDateCache().

stamp_

Smi* v8::internal::DateCache::stamp_

private

Definition at line 229 of file date.h.

Referenced by ResetDateCache(), stamp(), and stamp_address().

tz_cache_

base::TimezoneCache* v8::internal::DateCache::tz_cache_

private

Definition at line 246 of file date.h.

Referenced by GetDaylightSavingsOffsetFromOS(), GetLocalOffsetFromOS(), LocalTimezone(), ResetDateCache(), and ~DateCache().

ymd_day_

int v8::internal::DateCache::ymd_day_

private

Definition at line 244 of file date.h.

Referenced by YearMonthDayFromDays().

ymd_days_

int v8::internal::DateCache::ymd_days_

private

Definition at line 241 of file date.h.

Referenced by YearMonthDayFromDays().

ymd_month_

int v8::internal::DateCache::ymd_month_

private

Definition at line 243 of file date.h.

Referenced by YearMonthDayFromDays().

ymd_valid_

bool v8::internal::DateCache::ymd_valid_

private

Definition at line 240 of file date.h.

Referenced by ResetDateCache(), and YearMonthDayFromDays().

ymd_year_

int v8::internal::DateCache::ymd_year_

private

Definition at line 242 of file date.h.

Referenced by YearMonthDayFromDays().

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/date.h
• /mnt/V8SourceCode/src/date.cc