date.cc

Go to the documentation of this file.

// Copyright 2012 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#include "src/date/date.h"
 
#include <limits>
 
#include "src/base/overflowing-math.h"
#include "src/date/dateparser-inl.h"
#include "src/numbers/conversions.h"
#include "src/objects/objects-inl.h"
#ifdef V8_INTL_SUPPORT
#include "src/objects/intl-objects.h"
#endif
#include "src/strings/string-stream.h"
 
namespace v8 {
namespace internal {
 
static const int kDaysIn4Years = 4 * 365 + 1;
static const int kDaysIn100Years = 25 * kDaysIn4Years - 1;
static const int kDaysIn400Years = 4 * kDaysIn100Years + 1;
static const int kDays1970to2000 = 30 * 365 + 7;
static const int kDaysOffset =
    1000 * kDaysIn400Years + 5 * kDaysIn400Years - kDays1970to2000;
static const int kYearsOffset = 400000;
static const char kDaysInMonths[] = {31, 28, 31, 30, 31, 30,
                                     31, 31, 30, 31, 30, 31};
 
DateCache::DateCache()
    : stamp_(kNullAddress),
      tz_cache_(
#ifdef V8_INTL_SUPPORT
          Intl::CreateTimeZoneCache()
#else
          base::OS::CreateTimezoneCache()
#endif
      ) {
  ResetDateCache(base::TimezoneCache::TimeZoneDetection::kSkip);
}
 
void DateCache::ResetDateCache(
    base::TimezoneCache::TimeZoneDetection time_zone_detection) {
  if (stamp_.value() >= Smi::kMaxValue) {
    stamp_ = Smi::zero();
  } else {
    stamp_ = Smi::FromInt(stamp_.value() + 1);
  }
  DCHECK(stamp_ != Smi::FromInt(kInvalidStamp));
  for (int i = 0; i < kCacheSize; ++i) {
    ClearSegment(&cache_[i]);
  }
  cache_usage_counter_ = 0;
  before_ = &cache_[0];
  after_ = &cache_[1];
  ymd_valid_ = false;
#ifdef V8_INTL_SUPPORT
  if (!v8_flags.icu_timezone_data) {
#endif
    local_offset_ms_ = kInvalidLocalOffsetInMs;
#ifdef V8_INTL_SUPPORT
  }
#endif
  tz_cache_->Clear(time_zone_detection);
  tz_name_ = nullptr;
  dst_tz_name_ = nullptr;
}
 
void DateCache::ClearSegment(CacheItem* segment) {
  segment->start_ms = 0;
  segment->end_ms = -1;
  segment->offset_ms = 0;
  segment->last_used = 0;
}
 
void DateCache::YearMonthDayFromDays(int days, int* year, int* month,
                                     int* day) {
  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_EQ(save_days, DaysFromYearMonth(*year, 0) + 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_GE(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 ? 1 : 0)) {
    days -= 31 + 28 + (is_leap ? 1 : 0);
    // 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;
}
 
int DateCache::DaysFromYearMonth(int year, int month) {
  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_GE(month, 0);
  DCHECK_LT(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];
}
 
void DateCache::BreakDownTime(int64_t time_ms, int* year, int* month, int* day,
                              int* weekday, int* hour, int* min, int* sec,
                              int* ms) {
  int const days = DaysFromTime(time_ms);
  int const time_in_day_ms = TimeInDay(time_ms, days);
  YearMonthDayFromDays(days, year, month, day);
  *weekday = Weekday(days);
  *hour = time_in_day_ms / (60 * 60 * 1000);
  *min = (time_in_day_ms / (60 * 1000)) % 60;
  *sec = (time_in_day_ms / 1000) % 60;
  *ms = time_in_day_ms % 1000;
}
 
// Implements LocalTimeZonedjustment(t, isUTC)
// ECMA 262 - ES#sec-local-time-zone-adjustment
int DateCache::GetLocalOffsetFromOS(int64_t time_ms, bool is_utc) {
  double offset;
#ifdef V8_INTL_SUPPORT
  if (v8_flags.icu_timezone_data) {
    offset = tz_cache_->LocalTimeOffset(static_cast<double>(time_ms), is_utc);
  } else {
#endif
    // When ICU timezone data is not used, we need to compute the timezone
    // offset for a given local time.
    //
    // The following shows that using DST for (t - LocalTZA - hour) produces
    // correct conversion where LocalTZA is the timezone offset in winter (no
    // DST) and the timezone offset is assumed to have no historical change.
    // Note that it does not work for the past and the future if LocalTZA (no
    // DST) is different from the current LocalTZA (no DST). For instance,
    // this will break for Europe/Moscow in 2012 ~ 2013 because LocalTZA was
    // 4h instead of the current 3h (as of 2018).
    //
    // Consider transition to DST at local time L1.
    // Let L0 = L1 - hour, L2 = L1 + hour,
    //     U1 = UTC time that corresponds to L1,
    //     U0 = U1 - hour.
    // Transitioning to DST moves local clock one hour forward L1 => L2, so
    // U0 = UTC time that corresponds to L0 = L0 - LocalTZA,
    // U1 = UTC time that corresponds to L1 = L1 - LocalTZA,
    // U1 = UTC time that corresponds to L2 = L2 - LocalTZA - hour.
    // Note that DST(U0 - hour) = 0, DST(U0) = 0, DST(U1) = 1.
    // U0 = L0 - LocalTZA - DST(L0 - LocalTZA - hour),
    // U1 = L1 - LocalTZA - DST(L1 - LocalTZA - hour),
    // U1 = L2 - LocalTZA - DST(L2 - LocalTZA - hour).
    //
    // Consider transition from DST at local time L1.
    // Let L0 = L1 - hour,
    //     U1 = UTC time that corresponds to L1,
    //     U0 = U1 - hour, U2 = U1 + hour.
    // Transitioning from DST moves local clock one hour back L1 => L0, so
    // U0 = UTC time that corresponds to L0 (before transition)
    //    = L0 - LocalTZA - hour.
    // U1 = UTC time that corresponds to L0 (after transition)
    //    = L0 - LocalTZA = L1 - LocalTZA - hour
    // U2 = UTC time that corresponds to L1 = L1 - LocalTZA.
    // Note that DST(U0) = 1, DST(U1) = 0, DST(U2) = 0.
    // U0 = L0 - LocalTZA - DST(L0 - LocalTZA - hour) = L0 - LocalTZA - DST(U0).
    // U2 = L1 - LocalTZA - DST(L1 - LocalTZA - hour) = L1 - LocalTZA - DST(U1).
    // It is impossible to get U1 from local time.
    if (local_offset_ms_ == kInvalidLocalOffsetInMs) {
      // This gets the constant LocalTZA (arguments are ignored).
      local_offset_ms_ =
          tz_cache_->LocalTimeOffset(static_cast<double>(time_ms), is_utc);
    }
    offset = local_offset_ms_;
    if (!is_utc) {
      const int kMsPerHour = 3600 * 1000;
      time_ms -= (offset + kMsPerHour);
    }
    offset += DaylightSavingsOffsetInMs(time_ms);
#ifdef V8_INTL_SUPPORT
  }
#endif
  DCHECK_LT(offset, kInvalidLocalOffsetInMs);
  return static_cast<int>(offset);
}
 
void DateCache::ExtendTheAfterSegment(int64_t time_ms, int offset_ms) {
  if (!InvalidSegment(after_) && after_->offset_ms == offset_ms &&
      after_->start_ms - kDefaultTimeZoneOffsetDeltaInMs <= time_ms &&
      time_ms <= after_->end_ms) {
    // Extend the after_ segment.
    after_->start_ms = time_ms;
  } else {
    // The after_ segment is either invalid or starts too late.
    if (!InvalidSegment(after_)) {
      // If the after_ segment is valid, replace it with a new segment.
      after_ = LeastRecentlyUsedCacheItem(before_);
    }
    after_->start_ms = time_ms;
    after_->end_ms = time_ms;
    after_->offset_ms = offset_ms;
    after_->last_used = ++cache_usage_counter_;
  }
}
 
int DateCache::LocalOffsetInMs(int64_t time_ms, bool is_utc) {
  if (!is_utc) {
    return GetLocalOffsetFromOS(time_ms, is_utc);
  }
#ifdef ENABLE_SLOW_DCHECKS
  int known_correct_result = 0;
  if (v8_flags.enable_slow_asserts) {
    // When slow DCHECKs are enabled, we always retrieve the known good result
    // (slow) and check that the result produced by the cache matches it.
    known_correct_result = GetLocalOffsetFromOS(time_ms, is_utc);
  }
#endif  // ENABLE_SLOW_DCHECKS
  // Invalidate cache if the usage counter is close to overflow.
  // Note that cache_usage_counter is incremented less than ten times
  // in this function.
  if (cache_usage_counter_ >= kMaxInt - 10) {
    cache_usage_counter_ = 0;
    for (int i = 0; i < kCacheSize; ++i) {
      ClearSegment(&cache_[i]);
    }
  }
 
  // Optimistic fast check.
  if (before_->start_ms <= time_ms && time_ms <= before_->end_ms) {
    // Cache hit.
    before_->last_used = ++cache_usage_counter_;
    SLOW_DCHECK(before_->offset_ms == known_correct_result);
    return before_->offset_ms;
  }
 
  ProbeCache(time_ms);
 
  DCHECK(InvalidSegment(before_) || before_->start_ms <= time_ms);
  DCHECK(InvalidSegment(after_) || time_ms < after_->start_ms);
 
  if (InvalidSegment(before_)) {
    // Cache miss.
    before_->start_ms = time_ms;
    before_->end_ms = time_ms;
    before_->offset_ms = GetLocalOffsetFromOS(time_ms, is_utc);
    before_->last_used = ++cache_usage_counter_;
    SLOW_DCHECK(before_->offset_ms == known_correct_result);
    return before_->offset_ms;
  }
 
  if (time_ms <= before_->end_ms) {
    // Cache hit.
    before_->last_used = ++cache_usage_counter_;
    SLOW_DCHECK(before_->offset_ms == known_correct_result);
    return before_->offset_ms;
  }
 
  if (time_ms - kDefaultTimeZoneOffsetDeltaInMs > before_->end_ms) {
    // If the before_ segment ends too early, then just
    // query for the offset of the time_ms
    int offset_ms = GetLocalOffsetFromOS(time_ms, is_utc);
    ExtendTheAfterSegment(time_ms, offset_ms);
    // This swap helps the optimistic fast check in subsequent invocations.
    CacheItem* temp = before_;
    before_ = after_;
    after_ = temp;
    SLOW_DCHECK(offset_ms == known_correct_result);
    return offset_ms;
  }
 
  // Now the time_ms is between
  // before_->end_ms and before_->end_ms + default time zone offset delta.
  // Update the usage counter of before_ since it is going to be used.
  before_->last_used = ++cache_usage_counter_;
 
  // Check if after_ segment is invalid or starts too late.
  int64_t new_after_start_ms =
      before_->end_ms + kDefaultTimeZoneOffsetDeltaInMs;
  if (InvalidSegment(after_) || new_after_start_ms <= after_->start_ms) {
    int new_offset_ms = GetLocalOffsetFromOS(new_after_start_ms, is_utc);
    ExtendTheAfterSegment(new_after_start_ms, new_offset_ms);
  } else {
    DCHECK(!InvalidSegment(after_));
    // Update the usage counter of after_ since it is going to be used.
    after_->last_used = ++cache_usage_counter_;
  }
 
  // Now the time_ms is between before_->end_ms and after_->start_ms.
  // 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_ms = after_->end_ms;
    ClearSegment(after_);
    SLOW_DCHECK(before_->offset_ms == known_correct_result);
    return before_->offset_ms;
  }
 
  // Binary search for time zone offset change point,
  // but give up if we don't find it in five iterations.
  for (int i = 4; i >= 0; --i) {
    int64_t delta = after_->start_ms - before_->end_ms;
    int64_t middle_sec = (i == 0) ? time_ms : before_->end_ms + delta / 2;
    int offset_ms = GetLocalOffsetFromOS(middle_sec, is_utc);
    if (before_->offset_ms == offset_ms) {
      before_->end_ms = middle_sec;
      if (time_ms <= before_->end_ms) {
        SLOW_DCHECK(offset_ms == known_correct_result);
        return offset_ms;
      }
      // If we didn't return, we can't be in the last iteration.
      DCHECK_GT(i, 0);
    } else {
      DCHECK(after_->offset_ms == offset_ms);
      after_->start_ms = middle_sec;
      if (time_ms >= after_->start_ms) {
        // This swap helps the optimistic fast check in subsequent invocations.
        CacheItem* temp = before_;
        before_ = after_;
        after_ = temp;
        SLOW_DCHECK(offset_ms == known_correct_result);
        return offset_ms;
      }
      // If we didn't return, we can't be in the last iteration.
      DCHECK_GT(i, 0);
    }
  }
  // During the last iteration, we set middle_sec = time_ms and return via one
  // of the two return statements above. Thus, we never end up here.
  UNREACHABLE();
}
 
void DateCache::ProbeCache(int64_t time_ms) {
  CacheItem* before = nullptr;
  CacheItem* after = nullptr;
  DCHECK(before_ != after_);
 
  for (int i = 0; i < kCacheSize; ++i) {
    if (InvalidSegment(&cache_[i])) {
      continue;
    }
    if (cache_[i].start_ms <= time_ms) {
      if (before == nullptr || before->start_ms < cache_[i].start_ms) {
        before = &cache_[i];
      }
    } else if (time_ms < cache_[i].end_ms) {
      if (after == nullptr || after->end_ms > cache_[i].end_ms) {
        after = &cache_[i];
      }
    }
  }
 
  // If before or after segments were not found,
  // then set them to any invalid segment.
  if (before == nullptr) {
    before =
        InvalidSegment(before_) ? before_ : LeastRecentlyUsedCacheItem(after);
  }
  if (after == nullptr) {
    after = InvalidSegment(after_) && before != after_
                ? after_
                : LeastRecentlyUsedCacheItem(before);
  }
 
  DCHECK_NOT_NULL(before);
  DCHECK_NOT_NULL(after);
  DCHECK(before != after);
  DCHECK(InvalidSegment(before) || before->start_ms <= time_ms);
  DCHECK(InvalidSegment(after) || time_ms < after->start_ms);
  DCHECK(InvalidSegment(before) || InvalidSegment(after) ||
         before->end_ms < after->start_ms);
 
  before_ = before;
  after_ = after;
}
 
DateCache::CacheItem* DateCache::LeastRecentlyUsedCacheItem(CacheItem* skip) {
  CacheItem* result = nullptr;
  for (int i = 0; i < kCacheSize; ++i) {
    if (&cache_[i] == skip) continue;
    if (result == nullptr || result->last_used > cache_[i].last_used) {
      result = &cache_[i];
    }
  }
  ClearSegment(result);
  return result;
}
 
namespace {
 
// ES6 section 20.3.1.1 Time Values and Time Range
const double kMinYear = -1000000.0;
const double kMaxYear = -kMinYear;
const double kMinMonth = -10000000.0;
const double kMaxMonth = -kMinMonth;
 
const double kMsPerDay = 86400000.0;
 
const double kMsPerSecond = 1000.0;
const double kMsPerMinute = 60000.0;
const double kMsPerHour = 3600000.0;
 
}  // namespace
 
double MakeDate(double day, double time) {
  if (std::isfinite(day) && std::isfinite(time)) {
    return time + day * kMsPerDay;
  }
  return std::numeric_limits<double>::quiet_NaN();
}
 
double MakeDay(double year, double month, double date) {
  if ((kMinYear <= year && year <= kMaxYear) &&
      (kMinMonth <= month && month <= kMaxMonth) && std::isfinite(date)) {
    int y = FastD2I(year);
    int m = FastD2I(month);
    y += m / 12;
    m %= 12;
    if (m < 0) {
      m += 12;
      y -= 1;
    }
    DCHECK_LE(0, m);
    DCHECK_LT(m, 12);
 
    // kYearDelta is an arbitrary number such that:
    // a) kYearDelta = -1 (mod 400)
    // b) year + kYearDelta > 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 kYearDelta = 399999;
    static const int kBaseDay =
        365 * (1970 + kYearDelta) + (1970 + kYearDelta) / 4 -
        (1970 + kYearDelta) / 100 + (1970 + kYearDelta) / 400;
    int day_from_year = 365 * (y + kYearDelta) + (y + kYearDelta) / 4 -
                        (y + kYearDelta) / 100 + (y + kYearDelta) / 400 -
                        kBaseDay;
    if ((y % 4 != 0) || (y % 100 == 0 && y % 400 != 0)) {
      static const int kDayFromMonth[] = {0,   31,  59,  90,  120, 151,
                                          181, 212, 243, 273, 304, 334};
      day_from_year += kDayFromMonth[m];
    } else {
      static const int kDayFromMonth[] = {0,   31,  60,  91,  121, 152,
                                          182, 213, 244, 274, 305, 335};
      day_from_year += kDayFromMonth[m];
    }
    return static_cast<double>(day_from_year - 1) + DoubleToInteger(date);
  }
  return std::numeric_limits<double>::quiet_NaN();
}
 
double MakeTime(double hour, double min, double sec, double ms) {
  if (std::isfinite(hour) && std::isfinite(min) && std::isfinite(sec) &&
      std::isfinite(ms)) {
    double const h = DoubleToInteger(hour);
    double const m = DoubleToInteger(min);
    double const s = DoubleToInteger(sec);
    double const milli = DoubleToInteger(ms);
    return h * kMsPerHour + m * kMsPerMinute + s * kMsPerSecond + milli;
  }
  return std::numeric_limits<double>::quiet_NaN();
}
 
namespace {
 
const char* kShortWeekDays[] = {"Sun", "Mon", "Tue", "Wed",
                                "Thu", "Fri", "Sat"};
const char* kShortMonths[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
                              "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
 
template <class... Args>
DateBuffer FormatDate(const char* format, Args... args) {
  DateBuffer buffer;
  SmallStringOptimizedAllocator<DateBuffer::kInlineSize> allocator(&buffer);
  StringStream sstream(&allocator);
  sstream.Add(format, args...);
  buffer.resize(sstream.length());
  return buffer;
}
 
}  // namespace
 
DateBuffer ToDateString(double time_val, DateCache* date_cache,
                        ToDateStringMode mode) {
  if (std::isnan(time_val)) {
    return FormatDate("Invalid Date");
  }
  int64_t time_ms = static_cast<int64_t>(time_val);
  int64_t local_time_ms = (mode == ToDateStringMode::kUTCDateAndTime ||
                           mode == ToDateStringMode::kISODateAndTime)
                              ? time_ms
                              : date_cache->ToLocal(time_ms);
  int year, month, day, weekday, hour, min, sec, ms;
  date_cache->BreakDownTime(local_time_ms, &year, &month, &day, &weekday, &hour,
                            &min, &sec, &ms);
  int timezone_offset = -date_cache->TimezoneOffset(time_ms);
  int timezone_hour = std::abs(timezone_offset) / 60;
  int timezone_min = std::abs(timezone_offset) % 60;
  const char* local_timezone = date_cache->LocalTimezone(time_ms);
  switch (mode) {
    case ToDateStringMode::kLocalDate:
      return FormatDate((year < 0) ? "%s %s %02d %05d" : "%s %s %02d %04d",
                        kShortWeekDays[weekday], kShortMonths[month], day,
                        year);
    case ToDateStringMode::kLocalTime:
      return FormatDate("%02d:%02d:%02d GMT%c%02d%02d (%s)", hour, min, sec,
                        (timezone_offset < 0) ? '-' : '+', timezone_hour,
                        timezone_min, local_timezone);
    case ToDateStringMode::kLocalDateAndTime:
      return FormatDate(
          (year < 0) ? "%s %s %02d %05d %02d:%02d:%02d GMT%c%02d%02d (%s)"
                     : "%s %s %02d %04d %02d:%02d:%02d GMT%c%02d%02d (%s)",
          kShortWeekDays[weekday], kShortMonths[month], day, year, hour, min,
          sec, (timezone_offset < 0) ? '-' : '+', timezone_hour, timezone_min,
          local_timezone);
    case ToDateStringMode::kUTCDateAndTime:
      return FormatDate((year < 0) ? "%s, %02d %s %05d %02d:%02d:%02d GMT"
                                   : "%s, %02d %s %04d %02d:%02d:%02d GMT",
                        kShortWeekDays[weekday], day, kShortMonths[month], year,
                        hour, min, sec);
    case ToDateStringMode::kISODateAndTime:
      if (year >= 0 && year <= 9999) {
        return FormatDate("%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", year,
                          month + 1, day, hour, min, sec, ms);
      } else if (year < 0) {
        return FormatDate("-%06d-%02d-%02dT%02d:%02d:%02d.%03dZ", -year,
                          month + 1, day, hour, min, sec, ms);
      } else {
        return FormatDate("+%06d-%02d-%02dT%02d:%02d:%02d.%03dZ", year,
                          month + 1, day, hour, min, sec, ms);
      }
  }
  UNREACHABLE();
}
 
// ES6 section 20.3.1.16 Date Time String Format
double ParseDateTimeString(Isolate* isolate, DirectHandle<String> str) {
  str = String::Flatten(isolate, str);
  double out[DateParser::OUTPUT_SIZE];
  DisallowGarbageCollection no_gc;
  String::FlatContent str_content = str->GetFlatContent(no_gc);
  bool result;
  if (str_content.IsOneByte()) {
    result = DateParser::Parse(isolate, str_content.ToOneByteVector(), out);
  } else {
    result = DateParser::Parse(isolate, str_content.ToUC16Vector(), out);
  }
  if (!result) return std::numeric_limits<double>::quiet_NaN();
  double const day = MakeDay(out[DateParser::YEAR], out[DateParser::MONTH],
                             out[DateParser::DAY]);
  double const time =
      MakeTime(out[DateParser::HOUR], out[DateParser::MINUTE],
               out[DateParser::SECOND], out[DateParser::MILLISECOND]);
  double date = MakeDate(day, time);
  if (std::isnan(out[DateParser::UTC_OFFSET])) {
    if (date >= -DateCache::kMaxTimeBeforeUTCInMs &&
        date <= DateCache::kMaxTimeBeforeUTCInMs) {
      date = isolate->date_cache()->ToUTC(static_cast<int64_t>(date));
    } else {
      return std::numeric_limits<double>::quiet_NaN();
    }
  } else {
    date -= out[DateParser::UTC_OFFSET] * 1000.0;
  }
  if (!DateCache::TryTimeClip(&date)) {
    return std::numeric_limits<double>::quiet_NaN();
  }
  return date;
}
 
}  // namespace internal
}  // namespace v8