LCOV - code coverage report
Current view: top level - src/builtins - builtins-date.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 378 382 99.0 %
Date: 2017-04-26 Functions: 62 90 68.9 %

          Line data    Source code
       1             : // Copyright 2016 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             : #include "src/builtins/builtins-utils.h"
       6             : #include "src/builtins/builtins.h"
       7             : #include "src/code-factory.h"
       8             : #include "src/code-stub-assembler.h"
       9             : #include "src/conversions.h"
      10             : #include "src/counters.h"
      11             : #include "src/dateparser-inl.h"
      12             : #include "src/objects-inl.h"
      13             : 
      14             : namespace v8 {
      15             : namespace internal {
      16             : 
      17             : // -----------------------------------------------------------------------------
      18             : // ES6 section 20.3 Date Objects
      19             : 
      20             : namespace {
      21             : 
      22             : // ES6 section 20.3.1.1 Time Values and Time Range
      23             : const double kMinYear = -1000000.0;
      24       59467 : const double kMaxYear = -kMinYear;
      25             : const double kMinMonth = -10000000.0;
      26       59467 : const double kMaxMonth = -kMinMonth;
      27             : 
      28             : // 20.3.1.2 Day Number and Time within Day
      29             : const double kMsPerDay = 86400000.0;
      30             : 
      31             : // ES6 section 20.3.1.11 Hours, Minutes, Second, and Milliseconds
      32             : const double kMsPerSecond = 1000.0;
      33             : const double kMsPerMinute = 60000.0;
      34             : const double kMsPerHour = 3600000.0;
      35             : 
      36             : // ES6 section 20.3.1.14 MakeDate (day, time)
      37             : double MakeDate(double day, double time) {
      38      226402 :   if (std::isfinite(day) && std::isfinite(time)) {
      39       98554 :     return time + day * kMsPerDay;
      40             :   }
      41             :   return std::numeric_limits<double>::quiet_NaN();
      42             : }
      43             : 
      44             : // ES6 section 20.3.1.13 MakeDay (year, month, date)
      45      101577 : double MakeDay(double year, double month, double date) {
      46      201805 :   if ((kMinYear <= year && year <= kMaxYear) &&
      47      299153 :       (kMinMonth <= month && month <= kMaxMonth) && std::isfinite(date)) {
      48             :     int y = FastD2I(year);
      49             :     int m = FastD2I(month);
      50       98317 :     y += m / 12;
      51       98317 :     m %= 12;
      52       98317 :     if (m < 0) {
      53          14 :       m += 12;
      54          14 :       y -= 1;
      55             :     }
      56             :     DCHECK_LE(0, m);
      57             :     DCHECK_LT(m, 12);
      58             : 
      59             :     // kYearDelta is an arbitrary number such that:
      60             :     // a) kYearDelta = -1 (mod 400)
      61             :     // b) year + kYearDelta > 0 for years in the range defined by
      62             :     //    ECMA 262 - 15.9.1.1, i.e. upto 100,000,000 days on either side of
      63             :     //    Jan 1 1970. This is required so that we don't run into integer
      64             :     //    division of negative numbers.
      65             :     // c) there shouldn't be an overflow for 32-bit integers in the following
      66             :     //    operations.
      67             :     static const int kYearDelta = 399999;
      68             :     static const int kBaseDay =
      69             :         365 * (1970 + kYearDelta) + (1970 + kYearDelta) / 4 -
      70             :         (1970 + kYearDelta) / 100 + (1970 + kYearDelta) / 400;
      71      196634 :     int day_from_year = 365 * (y + kYearDelta) + (y + kYearDelta) / 4 -
      72      196634 :                         (y + kYearDelta) / 100 + (y + kYearDelta) / 400 -
      73       98317 :                         kBaseDay;
      74       98317 :     if ((y % 4 != 0) || (y % 100 == 0 && y % 400 != 0)) {
      75             :       static const int kDayFromMonth[] = {0,   31,  59,  90,  120, 151,
      76             :                                           181, 212, 243, 273, 304, 334};
      77       70394 :       day_from_year += kDayFromMonth[m];
      78             :     } else {
      79             :       static const int kDayFromMonth[] = {0,   31,  60,  91,  121, 152,
      80             :                                           182, 213, 244, 274, 305, 335};
      81       27923 :       day_from_year += kDayFromMonth[m];
      82             :     }
      83       98317 :     return static_cast<double>(day_from_year - 1) + date;
      84             :   }
      85             :   return std::numeric_limits<double>::quiet_NaN();
      86             : }
      87             : 
      88             : // ES6 section 20.3.1.12 MakeTime (hour, min, sec, ms)
      89      111309 : double MakeTime(double hour, double min, double sec, double ms) {
      90      414963 :   if (std::isfinite(hour) && std::isfinite(min) && std::isfinite(sec) &&
      91             :       std::isfinite(ms)) {
      92       98292 :     double const h = DoubleToInteger(hour);
      93       98292 :     double const m = DoubleToInteger(min);
      94       98292 :     double const s = DoubleToInteger(sec);
      95       98292 :     double const milli = DoubleToInteger(ms);
      96       98292 :     return h * kMsPerHour + m * kMsPerMinute + s * kMsPerSecond + milli;
      97             :   }
      98             :   return std::numeric_limits<double>::quiet_NaN();
      99             : }
     100             : 
     101             : // ES6 section 20.3.1.15 TimeClip (time)
     102             : double TimeClip(double time) {
     103       17712 :   if (-DateCache::kMaxTimeInMs <= time && time <= DateCache::kMaxTimeInMs) {
     104         978 :     return DoubleToInteger(time) + 0.0;
     105             :   }
     106             :   return std::numeric_limits<double>::quiet_NaN();
     107             : }
     108             : 
     109             : const char* kShortWeekDays[] = {"Sun", "Mon", "Tue", "Wed",
     110             :                                 "Thu", "Fri", "Sat"};
     111             : const char* kShortMonths[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
     112             :                               "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
     113             : 
     114             : // ES6 section 20.3.1.16 Date Time String Format
     115       96949 : double ParseDateTimeString(Handle<String> str) {
     116         806 :   Isolate* const isolate = str->GetIsolate();
     117       96949 :   str = String::Flatten(str);
     118             :   // TODO(bmeurer): Change DateParser to not use the FixedArray.
     119             :   Handle<FixedArray> tmp =
     120       96949 :       isolate->factory()->NewFixedArray(DateParser::OUTPUT_SIZE);
     121             :   DisallowHeapAllocation no_gc;
     122       96949 :   String::FlatContent str_content = str->GetFlatContent();
     123             :   bool result;
     124       96949 :   if (str_content.IsOneByte()) {
     125       96949 :     result = DateParser::Parse(isolate, str_content.ToOneByteVector(), *tmp);
     126             :   } else {
     127           0 :     result = DateParser::Parse(isolate, str_content.ToUC16Vector(), *tmp);
     128             :   }
     129       96949 :   if (!result) return std::numeric_limits<double>::quiet_NaN();
     130             :   double const day = MakeDay(tmp->get(0)->Number(), tmp->get(1)->Number(),
     131       96127 :                              tmp->get(2)->Number());
     132             :   double const time = MakeTime(tmp->get(3)->Number(), tmp->get(4)->Number(),
     133       96127 :                                tmp->get(5)->Number(), tmp->get(6)->Number());
     134             :   double date = MakeDate(day, time);
     135       96127 :   if (tmp->get(7)->IsNull(isolate)) {
     136         821 :     if (!std::isnan(date)) {
     137        1612 :       date = isolate->date_cache()->ToUTC(static_cast<int64_t>(date));
     138             :     }
     139             :   } else {
     140       95306 :     date -= tmp->get(7)->Number() * 1000.0;
     141             :   }
     142       96127 :   return date;
     143             : }
     144             : 
     145             : enum ToDateStringMode { kDateOnly, kTimeOnly, kDateAndTime };
     146             : 
     147             : // ES6 section 20.3.4.41.1 ToDateString(tv)
     148       88875 : void ToDateString(double time_val, Vector<char> str, DateCache* date_cache,
     149             :                   ToDateStringMode mode = kDateAndTime) {
     150       88875 :   if (std::isnan(time_val)) {
     151         105 :     SNPrintF(str, "Invalid Date");
     152         105 :     return;
     153             :   }
     154       88770 :   int64_t time_ms = static_cast<int64_t>(time_val);
     155       88770 :   int64_t local_time_ms = date_cache->ToLocal(time_ms);
     156             :   int year, month, day, weekday, hour, min, sec, ms;
     157             :   date_cache->BreakDownTime(local_time_ms, &year, &month, &day, &weekday, &hour,
     158       88770 :                             &min, &sec, &ms);
     159       88770 :   int timezone_offset = -date_cache->TimezoneOffset(time_ms);
     160       88770 :   int timezone_hour = std::abs(timezone_offset) / 60;
     161       88770 :   int timezone_min = std::abs(timezone_offset) % 60;
     162       88770 :   const char* local_timezone = date_cache->LocalTimezone(time_ms);
     163       88770 :   switch (mode) {
     164             :     case kDateOnly:
     165             :       SNPrintF(str, "%s %s %02d %4d", kShortWeekDays[weekday],
     166          14 :                kShortMonths[month], day, year);
     167          14 :       return;
     168             :     case kTimeOnly:
     169             :       SNPrintF(str, "%02d:%02d:%02d GMT%c%02d%02d (%s)", hour, min, sec,
     170             :                (timezone_offset < 0) ? '-' : '+', timezone_hour, timezone_min,
     171          14 :                local_timezone);
     172          14 :       return;
     173             :     case kDateAndTime:
     174             :       SNPrintF(str, "%s %s %02d %4d %02d:%02d:%02d GMT%c%02d%02d (%s)",
     175             :                kShortWeekDays[weekday], kShortMonths[month], day, year, hour,
     176             :                min, sec, (timezone_offset < 0) ? '-' : '+', timezone_hour,
     177       88742 :                timezone_min, local_timezone);
     178       88742 :       return;
     179             :   }
     180           0 :   UNREACHABLE();
     181             : }
     182             : 
     183        9061 : Object* SetLocalDateValue(Handle<JSDate> date, double time_val) {
     184        9061 :   if (time_val >= -DateCache::kMaxTimeBeforeUTCInMs &&
     185             :       time_val <= DateCache::kMaxTimeBeforeUTCInMs) {
     186         535 :     Isolate* const isolate = date->GetIsolate();
     187        1070 :     time_val = isolate->date_cache()->ToUTC(static_cast<int64_t>(time_val));
     188             :   } else {
     189             :     time_val = std::numeric_limits<double>::quiet_NaN();
     190             :   }
     191       18122 :   return *JSDate::SetValue(date, TimeClip(time_val));
     192             : }
     193             : 
     194             : }  // namespace
     195             : 
     196             : // ES6 section 20.3.2 The Date Constructor for the [[Call]] case.
     197         256 : BUILTIN(DateConstructor) {
     198             :   HandleScope scope(isolate);
     199          64 :   double const time_val = JSDate::CurrentTimeValue(isolate);
     200             :   char buffer[128];
     201          64 :   ToDateString(time_val, ArrayVector(buffer), isolate->date_cache());
     202         192 :   RETURN_RESULT_OR_FAILURE(
     203             :       isolate, isolate->factory()->NewStringFromUtf8(CStrVector(buffer)));
     204             : }
     205             : 
     206             : // ES6 section 20.3.2 The Date Constructor for the [[Construct]] case.
     207      688281 : BUILTIN(DateConstructor_ConstructStub) {
     208             :   HandleScope scope(isolate);
     209      228983 :   int const argc = args.length() - 1;
     210      228983 :   Handle<JSFunction> target = args.target();
     211      228983 :   Handle<JSReceiver> new_target = Handle<JSReceiver>::cast(args.new_target());
     212             :   double time_val;
     213      228983 :   if (argc == 0) {
     214      137678 :     time_val = JSDate::CurrentTimeValue(isolate);
     215       91305 :   } else if (argc == 1) {
     216             :     Handle<Object> value = args.at(1);
     217       89698 :     if (value->IsJSDate()) {
     218             :       time_val = Handle<JSDate>::cast(value)->value()->Number();
     219             :     } else {
     220      178918 :       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, value,
     221             :                                          Object::ToPrimitive(value));
     222       89444 :       if (value->IsString()) {
     223         547 :         time_val = ParseDateTimeString(Handle<String>::cast(value));
     224             :       } else {
     225      177794 :         ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, value,
     226             :                                            Object::ToNumber(value));
     227             :         time_val = value->Number();
     228             :       }
     229             :     }
     230             :   } else {
     231             :     Handle<Object> year_object;
     232        3214 :     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, year_object,
     233             :                                        Object::ToNumber(args.at(1)));
     234             :     Handle<Object> month_object;
     235        3214 :     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, month_object,
     236             :                                        Object::ToNumber(args.at(2)));
     237             :     double year = year_object->Number();
     238             :     double month = month_object->Number();
     239             :     double date = 1.0, hours = 0.0, minutes = 0.0, seconds = 0.0, ms = 0.0;
     240        1607 :     if (argc >= 3) {
     241             :       Handle<Object> date_object;
     242        2956 :       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date_object,
     243             :                                          Object::ToNumber(args.at(3)));
     244             :       date = date_object->Number();
     245        1478 :       if (argc >= 4) {
     246             :         Handle<Object> hours_object;
     247        2440 :         ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, hours_object,
     248             :                                            Object::ToNumber(args.at(4)));
     249             :         hours = hours_object->Number();
     250        1220 :         if (argc >= 5) {
     251             :           Handle<Object> minutes_object;
     252        2204 :           ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, minutes_object,
     253             :                                              Object::ToNumber(args.at(5)));
     254             :           minutes = minutes_object->Number();
     255        1102 :           if (argc >= 6) {
     256             :             Handle<Object> seconds_object;
     257         736 :             ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, seconds_object,
     258             :                                                Object::ToNumber(args.at(6)));
     259             :             seconds = seconds_object->Number();
     260         368 :             if (argc >= 7) {
     261             :               Handle<Object> ms_object;
     262         624 :               ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms_object,
     263             :                                                  Object::ToNumber(args.at(7)));
     264             :               ms = ms_object->Number();
     265             :             }
     266             :           }
     267             :         }
     268             :       }
     269             :     }
     270        1607 :     if (!std::isnan(year)) {
     271        1578 :       double const y = DoubleToInteger(year);
     272        1578 :       if (0.0 <= y && y <= 99) year = 1900 + y;
     273             :     }
     274        1607 :     double const day = MakeDay(year, month, date);
     275        1607 :     double const time = MakeTime(hours, minutes, seconds, ms);
     276             :     time_val = MakeDate(day, time);
     277        1607 :     if (time_val >= -DateCache::kMaxTimeBeforeUTCInMs &&
     278             :         time_val <= DateCache::kMaxTimeBeforeUTCInMs) {
     279        2664 :       time_val = isolate->date_cache()->ToUTC(static_cast<int64_t>(time_val));
     280             :     } else {
     281             :       time_val = std::numeric_limits<double>::quiet_NaN();
     282             :     }
     283             :   }
     284      686904 :   RETURN_RESULT_OR_FAILURE(isolate, JSDate::New(target, new_target, time_val));
     285             : }
     286             : 
     287             : // ES6 section 20.3.3.1 Date.now ( )
     288    83893701 : BUILTIN(DateNow) {
     289             :   HandleScope scope(isolate);
     290    83893701 :   return *isolate->factory()->NewNumber(JSDate::CurrentTimeValue(isolate));
     291             : }
     292             : 
     293             : // ES6 section 20.3.3.2 Date.parse ( string )
     294      289206 : BUILTIN(DateParse) {
     295             :   HandleScope scope(isolate);
     296             :   Handle<String> string;
     297      192804 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
     298             :       isolate, string,
     299             :       Object::ToString(isolate, args.atOrUndefined(isolate, 1)));
     300      192804 :   return *isolate->factory()->NewNumber(ParseDateTimeString(string));
     301             : }
     302             : 
     303             : // ES6 section 20.3.3.4 Date.UTC (year,month,date,hours,minutes,seconds,ms)
     304         963 : BUILTIN(DateUTC) {
     305             :   HandleScope scope(isolate);
     306         321 :   int const argc = args.length() - 1;
     307             :   double year = std::numeric_limits<double>::quiet_NaN();
     308             :   double month = 0.0, date = 1.0, hours = 0.0, minutes = 0.0, seconds = 0.0,
     309             :          ms = 0.0;
     310         321 :   if (argc >= 1) {
     311             :     Handle<Object> year_object;
     312         642 :     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, year_object,
     313             :                                        Object::ToNumber(args.at(1)));
     314             :     year = year_object->Number();
     315         321 :     if (argc >= 2) {
     316             :       Handle<Object> month_object;
     317         642 :       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, month_object,
     318             :                                          Object::ToNumber(args.at(2)));
     319             :       month = month_object->Number();
     320         321 :       if (argc >= 3) {
     321             :         Handle<Object> date_object;
     322         642 :         ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date_object,
     323             :                                            Object::ToNumber(args.at(3)));
     324             :         date = date_object->Number();
     325         321 :         if (argc >= 4) {
     326             :           Handle<Object> hours_object;
     327         408 :           ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, hours_object,
     328             :                                              Object::ToNumber(args.at(4)));
     329             :           hours = hours_object->Number();
     330         204 :           if (argc >= 5) {
     331             :             Handle<Object> minutes_object;
     332         348 :             ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, minutes_object,
     333             :                                                Object::ToNumber(args.at(5)));
     334             :             minutes = minutes_object->Number();
     335         174 :             if (argc >= 6) {
     336             :               Handle<Object> seconds_object;
     337         348 :               ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, seconds_object,
     338             :                                                  Object::ToNumber(args.at(6)));
     339             :               seconds = seconds_object->Number();
     340         174 :               if (argc >= 7) {
     341             :                 Handle<Object> ms_object;
     342         318 :                 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
     343             :                     isolate, ms_object, Object::ToNumber(args.at(7)));
     344             :                 ms = ms_object->Number();
     345             :               }
     346             :             }
     347             :           }
     348             :         }
     349             :       }
     350             :     }
     351             :   }
     352         321 :   if (!std::isnan(year)) {
     353         321 :     double const y = DoubleToInteger(year);
     354         321 :     if (0.0 <= y && y <= 99) year = 1900 + y;
     355             :   }
     356         321 :   double const day = MakeDay(year, month, date);
     357         321 :   double const time = MakeTime(hours, minutes, seconds, ms);
     358         642 :   return *isolate->factory()->NewNumber(TimeClip(MakeDate(day, time)));
     359             : }
     360             : 
     361             : // ES6 section 20.3.4.20 Date.prototype.setDate ( date )
     362        1522 : BUILTIN(DatePrototypeSetDate) {
     363             :   HandleScope scope(isolate);
     364        1285 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setDate");
     365             :   Handle<Object> value = args.atOrUndefined(isolate, 1);
     366         290 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, value, Object::ToNumber(value));
     367             :   double time_val = date->value()->Number();
     368         145 :   if (!std::isnan(time_val)) {
     369         116 :     int64_t const time_ms = static_cast<int64_t>(time_val);
     370         116 :     int64_t local_time_ms = isolate->date_cache()->ToLocal(time_ms);
     371             :     int const days = isolate->date_cache()->DaysFromTime(local_time_ms);
     372             :     int time_within_day = isolate->date_cache()->TimeInDay(local_time_ms, days);
     373             :     int year, month, day;
     374         116 :     isolate->date_cache()->YearMonthDayFromDays(days, &year, &month, &day);
     375         232 :     time_val = MakeDate(MakeDay(year, month, value->Number()), time_within_day);
     376             :   }
     377         145 :   return SetLocalDateValue(date, time_val);
     378             : }
     379             : 
     380             : // ES6 section 20.3.4.21 Date.prototype.setFullYear (year, month, date)
     381        6862 : BUILTIN(DatePrototypeSetFullYear) {
     382             :   HandleScope scope(isolate);
     383        2302 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setFullYear");
     384        1222 :   int const argc = args.length() - 1;
     385             :   Handle<Object> year = args.atOrUndefined(isolate, 1);
     386        2444 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, year, Object::ToNumber(year));
     387             :   double y = year->Number(), m = 0.0, dt = 1.0;
     388             :   int time_within_day = 0;
     389        1222 :   if (!std::isnan(date->value()->Number())) {
     390        1193 :     int64_t const time_ms = static_cast<int64_t>(date->value()->Number());
     391        1193 :     int64_t local_time_ms = isolate->date_cache()->ToLocal(time_ms);
     392             :     int const days = isolate->date_cache()->DaysFromTime(local_time_ms);
     393             :     time_within_day = isolate->date_cache()->TimeInDay(local_time_ms, days);
     394             :     int year, month, day;
     395        1193 :     isolate->date_cache()->YearMonthDayFromDays(days, &year, &month, &day);
     396        1193 :     m = month;
     397        1193 :     dt = day;
     398             :   }
     399        1222 :   if (argc >= 2) {
     400             :     Handle<Object> month = args.at(2);
     401        2214 :     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, month, Object::ToNumber(month));
     402             :     m = month->Number();
     403        1107 :     if (argc >= 3) {
     404             :       Handle<Object> date = args.at(3);
     405        1794 :       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date, Object::ToNumber(date));
     406             :       dt = date->Number();
     407             :     }
     408             :   }
     409        1222 :   double time_val = MakeDate(MakeDay(y, m, dt), time_within_day);
     410        1222 :   return SetLocalDateValue(date, time_val);
     411             : }
     412             : 
     413             : // ES6 section 20.3.4.22 Date.prototype.setHours(hour, min, sec, ms)
     414       20288 : BUILTIN(DatePrototypeSetHours) {
     415             :   HandleScope scope(isolate);
     416        6016 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setHours");
     417        4876 :   int const argc = args.length() - 1;
     418             :   Handle<Object> hour = args.atOrUndefined(isolate, 1);
     419        9752 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, hour, Object::ToNumber(hour));
     420             :   double h = hour->Number();
     421             :   double time_val = date->value()->Number();
     422        4876 :   if (!std::isnan(time_val)) {
     423        4805 :     int64_t const time_ms = static_cast<int64_t>(time_val);
     424        4805 :     int64_t local_time_ms = isolate->date_cache()->ToLocal(time_ms);
     425             :     int day = isolate->date_cache()->DaysFromTime(local_time_ms);
     426             :     int time_within_day = isolate->date_cache()->TimeInDay(local_time_ms, day);
     427        4805 :     double m = (time_within_day / (60 * 1000)) % 60;
     428        4805 :     double s = (time_within_day / 1000) % 60;
     429        4805 :     double milli = time_within_day % 1000;
     430        4805 :     if (argc >= 2) {
     431             :       Handle<Object> min = args.at(2);
     432        9410 :       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, min, Object::ToNumber(min));
     433             :       m = min->Number();
     434        4705 :       if (argc >= 3) {
     435             :         Handle<Object> sec = args.at(3);
     436        8962 :         ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, sec, Object::ToNumber(sec));
     437             :         s = sec->Number();
     438        4481 :         if (argc >= 4) {
     439             :           Handle<Object> ms = args.at(4);
     440        7170 :           ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
     441             :           milli = ms->Number();
     442             :         }
     443             :       }
     444             :     }
     445        4805 :     time_val = MakeDate(day, MakeTime(h, m, s, milli));
     446             :   }
     447        4876 :   return SetLocalDateValue(date, time_val);
     448             : }
     449             : 
     450             : // ES6 section 20.3.4.23 Date.prototype.setMilliseconds(ms)
     451        3037 : BUILTIN(DatePrototypeSetMilliseconds) {
     452             :   HandleScope scope(isolate);
     453        1644 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setMilliseconds");
     454             :   Handle<Object> ms = args.atOrUndefined(isolate, 1);
     455        1128 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
     456             :   double time_val = date->value()->Number();
     457         564 :   if (!std::isnan(time_val)) {
     458         535 :     int64_t const time_ms = static_cast<int64_t>(time_val);
     459         535 :     int64_t local_time_ms = isolate->date_cache()->ToLocal(time_ms);
     460             :     int day = isolate->date_cache()->DaysFromTime(local_time_ms);
     461             :     int time_within_day = isolate->date_cache()->TimeInDay(local_time_ms, day);
     462         535 :     int h = time_within_day / (60 * 60 * 1000);
     463         535 :     int m = (time_within_day / (60 * 1000)) % 60;
     464         535 :     int s = (time_within_day / 1000) % 60;
     465         535 :     time_val = MakeDate(day, MakeTime(h, m, s, ms->Number()));
     466             :   }
     467         564 :   return SetLocalDateValue(date, time_val);
     468             : }
     469             : 
     470             : // ES6 section 20.3.4.24 Date.prototype.setMinutes ( min, sec, ms )
     471        5865 : BUILTIN(DatePrototypeSetMinutes) {
     472             :   HandleScope scope(isolate);
     473        2358 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setMinutes");
     474        1278 :   int const argc = args.length() - 1;
     475             :   Handle<Object> min = args.atOrUndefined(isolate, 1);
     476        2556 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, min, Object::ToNumber(min));
     477             :   double time_val = date->value()->Number();
     478        1278 :   if (!std::isnan(time_val)) {
     479        1221 :     int64_t const time_ms = static_cast<int64_t>(time_val);
     480        1221 :     int64_t local_time_ms = isolate->date_cache()->ToLocal(time_ms);
     481             :     int day = isolate->date_cache()->DaysFromTime(local_time_ms);
     482             :     int time_within_day = isolate->date_cache()->TimeInDay(local_time_ms, day);
     483        1221 :     int h = time_within_day / (60 * 60 * 1000);
     484             :     double m = min->Number();
     485        1221 :     double s = (time_within_day / 1000) % 60;
     486        1221 :     double milli = time_within_day % 1000;
     487        1221 :     if (argc >= 2) {
     488             :       Handle<Object> sec = args.at(2);
     489        2242 :       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, sec, Object::ToNumber(sec));
     490             :       s = sec->Number();
     491        1121 :       if (argc >= 3) {
     492             :         Handle<Object> ms = args.at(3);
     493        1794 :         ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
     494             :         milli = ms->Number();
     495             :       }
     496             :     }
     497        1221 :     time_val = MakeDate(day, MakeTime(h, m, s, milli));
     498             :   }
     499        1278 :   return SetLocalDateValue(date, time_val);
     500             : }
     501             : 
     502             : // ES6 section 20.3.4.25 Date.prototype.setMonth ( month, date )
     503        2634 : BUILTIN(DatePrototypeSetMonth) {
     504             :   HandleScope scope(isolate);
     505        1462 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setMonth");
     506             :   int const argc = args.length() - 1;
     507             :   Handle<Object> month = args.atOrUndefined(isolate, 1);
     508         764 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, month, Object::ToNumber(month));
     509             :   double time_val = date->value()->Number();
     510         382 :   if (!std::isnan(time_val)) {
     511         339 :     int64_t const time_ms = static_cast<int64_t>(time_val);
     512         339 :     int64_t local_time_ms = isolate->date_cache()->ToLocal(time_ms);
     513             :     int days = isolate->date_cache()->DaysFromTime(local_time_ms);
     514             :     int time_within_day = isolate->date_cache()->TimeInDay(local_time_ms, days);
     515             :     int year, unused, day;
     516         339 :     isolate->date_cache()->YearMonthDayFromDays(days, &year, &unused, &day);
     517             :     double m = month->Number();
     518         339 :     double dt = day;
     519         339 :     if (argc >= 2) {
     520             :       Handle<Object> date = args.at(2);
     521         450 :       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date, Object::ToNumber(date));
     522             :       dt = date->Number();
     523             :     }
     524         339 :     time_val = MakeDate(MakeDay(year, m, dt), time_within_day);
     525             :   }
     526         382 :   return SetLocalDateValue(date, time_val);
     527             : }
     528             : 
     529             : // ES6 section 20.3.4.26 Date.prototype.setSeconds ( sec, ms )
     530        2299 : BUILTIN(DatePrototypeSetSeconds) {
     531             :   HandleScope scope(isolate);
     532        1463 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setSeconds");
     533             :   int const argc = args.length() - 1;
     534             :   Handle<Object> sec = args.atOrUndefined(isolate, 1);
     535         766 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, sec, Object::ToNumber(sec));
     536             :   double time_val = date->value()->Number();
     537         383 :   if (!std::isnan(time_val)) {
     538         340 :     int64_t const time_ms = static_cast<int64_t>(time_val);
     539         340 :     int64_t local_time_ms = isolate->date_cache()->ToLocal(time_ms);
     540             :     int day = isolate->date_cache()->DaysFromTime(local_time_ms);
     541             :     int time_within_day = isolate->date_cache()->TimeInDay(local_time_ms, day);
     542         340 :     int h = time_within_day / (60 * 60 * 1000);
     543         340 :     double m = (time_within_day / (60 * 1000)) % 60;
     544             :     double s = sec->Number();
     545         340 :     double milli = time_within_day % 1000;
     546         340 :     if (argc >= 2) {
     547             :       Handle<Object> ms = args.at(2);
     548         480 :       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
     549             :       milli = ms->Number();
     550             :     }
     551         340 :     time_val = MakeDate(day, MakeTime(h, m, s, milli));
     552             :   }
     553         383 :   return SetLocalDateValue(date, time_val);
     554             : }
     555             : 
     556             : // ES6 section 20.3.4.27 Date.prototype.setTime ( time )
     557        1155 : BUILTIN(DatePrototypeSetTime) {
     558             :   HandleScope scope(isolate);
     559        1240 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setTime");
     560             :   Handle<Object> value = args.atOrUndefined(isolate, 1);
     561         200 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, value, Object::ToNumber(value));
     562         200 :   return *JSDate::SetValue(date, TimeClip(value->Number()));
     563             : }
     564             : 
     565             : // ES6 section 20.3.4.28 Date.prototype.setUTCDate ( date )
     566        1301 : BUILTIN(DatePrototypeSetUTCDate) {
     567             :   HandleScope scope(isolate);
     568        1210 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCDate");
     569             :   Handle<Object> value = args.atOrUndefined(isolate, 1);
     570         260 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, value, Object::ToNumber(value));
     571         130 :   if (std::isnan(date->value()->Number())) return date->value();
     572         101 :   int64_t const time_ms = static_cast<int64_t>(date->value()->Number());
     573             :   int const days = isolate->date_cache()->DaysFromTime(time_ms);
     574             :   int const time_within_day = isolate->date_cache()->TimeInDay(time_ms, days);
     575             :   int year, month, day;
     576         101 :   isolate->date_cache()->YearMonthDayFromDays(days, &year, &month, &day);
     577             :   double const time_val =
     578         202 :       MakeDate(MakeDay(year, month, value->Number()), time_within_day);
     579         202 :   return *JSDate::SetValue(date, TimeClip(time_val));
     580             : }
     581             : 
     582             : // ES6 section 20.3.4.29 Date.prototype.setUTCFullYear (year, month, date)
     583        5669 : BUILTIN(DatePrototypeSetUTCFullYear) {
     584             :   HandleScope scope(isolate);
     585        2302 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCFullYear");
     586        1222 :   int const argc = args.length() - 1;
     587             :   Handle<Object> year = args.atOrUndefined(isolate, 1);
     588        2444 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, year, Object::ToNumber(year));
     589             :   double y = year->Number(), m = 0.0, dt = 1.0;
     590             :   int time_within_day = 0;
     591        1222 :   if (!std::isnan(date->value()->Number())) {
     592        1193 :     int64_t const time_ms = static_cast<int64_t>(date->value()->Number());
     593             :     int const days = isolate->date_cache()->DaysFromTime(time_ms);
     594             :     time_within_day = isolate->date_cache()->TimeInDay(time_ms, days);
     595             :     int year, month, day;
     596        1193 :     isolate->date_cache()->YearMonthDayFromDays(days, &year, &month, &day);
     597        1193 :     m = month;
     598        1193 :     dt = day;
     599             :   }
     600        1222 :   if (argc >= 2) {
     601             :     Handle<Object> month = args.at(2);
     602        2214 :     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, month, Object::ToNumber(month));
     603             :     m = month->Number();
     604        1107 :     if (argc >= 3) {
     605             :       Handle<Object> date = args.at(3);
     606        1794 :       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date, Object::ToNumber(date));
     607             :       dt = date->Number();
     608             :     }
     609             :   }
     610        1222 :   double const time_val = MakeDate(MakeDay(y, m, dt), time_within_day);
     611        2444 :   return *JSDate::SetValue(date, TimeClip(time_val));
     612             : }
     613             : 
     614             : // ES6 section 20.3.4.30 Date.prototype.setUTCHours(hour, min, sec, ms)
     615       15402 : BUILTIN(DatePrototypeSetUTCHours) {
     616             :   HandleScope scope(isolate);
     617        5944 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCHours");
     618        4864 :   int const argc = args.length() - 1;
     619             :   Handle<Object> hour = args.atOrUndefined(isolate, 1);
     620        9728 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, hour, Object::ToNumber(hour));
     621             :   double h = hour->Number();
     622             :   double time_val = date->value()->Number();
     623        4864 :   if (!std::isnan(time_val)) {
     624        4778 :     int64_t const time_ms = static_cast<int64_t>(time_val);
     625             :     int day = isolate->date_cache()->DaysFromTime(time_ms);
     626             :     int time_within_day = isolate->date_cache()->TimeInDay(time_ms, day);
     627        4778 :     double m = (time_within_day / (60 * 1000)) % 60;
     628        4778 :     double s = (time_within_day / 1000) % 60;
     629        4778 :     double milli = time_within_day % 1000;
     630        4778 :     if (argc >= 2) {
     631             :       Handle<Object> min = args.at(2);
     632        9354 :       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, min, Object::ToNumber(min));
     633             :       m = min->Number();
     634        4677 :       if (argc >= 3) {
     635             :         Handle<Object> sec = args.at(3);
     636        8934 :         ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, sec, Object::ToNumber(sec));
     637             :         s = sec->Number();
     638        4467 :         if (argc >= 4) {
     639             :           Handle<Object> ms = args.at(4);
     640        7170 :           ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
     641             :           milli = ms->Number();
     642             :         }
     643             :       }
     644             :     }
     645        4778 :     time_val = MakeDate(day, MakeTime(h, m, s, milli));
     646             :   }
     647        9728 :   return *JSDate::SetValue(date, TimeClip(time_val));
     648             : }
     649             : 
     650             : // ES6 section 20.3.4.31 Date.prototype.setUTCMilliseconds(ms)
     651        1155 : BUILTIN(DatePrototypeSetUTCMilliseconds) {
     652             :   HandleScope scope(isolate);
     653        1195 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCMilliseconds");
     654             :   Handle<Object> ms = args.atOrUndefined(isolate, 1);
     655         230 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
     656             :   double time_val = date->value()->Number();
     657         115 :   if (!std::isnan(time_val)) {
     658          86 :     int64_t const time_ms = static_cast<int64_t>(time_val);
     659             :     int day = isolate->date_cache()->DaysFromTime(time_ms);
     660             :     int time_within_day = isolate->date_cache()->TimeInDay(time_ms, day);
     661          86 :     int h = time_within_day / (60 * 60 * 1000);
     662          86 :     int m = (time_within_day / (60 * 1000)) % 60;
     663          86 :     int s = (time_within_day / 1000) % 60;
     664          86 :     time_val = MakeDate(day, MakeTime(h, m, s, ms->Number()));
     665             :   }
     666         230 :   return *JSDate::SetValue(date, TimeClip(time_val));
     667             : }
     668             : 
     669             : // ES6 section 20.3.4.32 Date.prototype.setUTCMinutes ( min, sec, ms )
     670        4470 : BUILTIN(DatePrototypeSetUTCMinutes) {
     671             :   HandleScope scope(isolate);
     672        2300 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCMinutes");
     673        1220 :   int const argc = args.length() - 1;
     674             :   Handle<Object> min = args.atOrUndefined(isolate, 1);
     675        2440 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, min, Object::ToNumber(min));
     676             :   double time_val = date->value()->Number();
     677        1220 :   if (!std::isnan(time_val)) {
     678        1178 :     int64_t const time_ms = static_cast<int64_t>(time_val);
     679             :     int day = isolate->date_cache()->DaysFromTime(time_ms);
     680             :     int time_within_day = isolate->date_cache()->TimeInDay(time_ms, day);
     681        1178 :     int h = time_within_day / (60 * 60 * 1000);
     682             :     double m = min->Number();
     683        1178 :     double s = (time_within_day / 1000) % 60;
     684        1178 :     double milli = time_within_day % 1000;
     685        1178 :     if (argc >= 2) {
     686             :       Handle<Object> sec = args.at(2);
     687        2214 :       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, sec, Object::ToNumber(sec));
     688             :       s = sec->Number();
     689        1107 :       if (argc >= 3) {
     690             :         Handle<Object> ms = args.at(3);
     691        1794 :         ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
     692             :         milli = ms->Number();
     693             :       }
     694             :     }
     695        1178 :     time_val = MakeDate(day, MakeTime(h, m, s, milli));
     696             :   }
     697        2440 :   return *JSDate::SetValue(date, TimeClip(time_val));
     698             : }
     699             : 
     700             : // ES6 section 20.3.4.31 Date.prototype.setUTCMonth ( month, date )
     701        2183 : BUILTIN(DatePrototypeSetUTCMonth) {
     702             :   HandleScope scope(isolate);
     703        1434 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCMonth");
     704             :   int const argc = args.length() - 1;
     705             :   Handle<Object> month = args.atOrUndefined(isolate, 1);
     706         708 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, month, Object::ToNumber(month));
     707             :   double time_val = date->value()->Number();
     708         354 :   if (!std::isnan(time_val)) {
     709         311 :     int64_t const time_ms = static_cast<int64_t>(time_val);
     710             :     int days = isolate->date_cache()->DaysFromTime(time_ms);
     711             :     int time_within_day = isolate->date_cache()->TimeInDay(time_ms, days);
     712             :     int year, unused, day;
     713         311 :     isolate->date_cache()->YearMonthDayFromDays(days, &year, &unused, &day);
     714             :     double m = month->Number();
     715         311 :     double dt = day;
     716         311 :     if (argc >= 2) {
     717             :       Handle<Object> date = args.at(2);
     718         450 :       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date, Object::ToNumber(date));
     719             :       dt = date->Number();
     720             :     }
     721         311 :     time_val = MakeDate(MakeDay(year, m, dt), time_within_day);
     722             :   }
     723         708 :   return *JSDate::SetValue(date, TimeClip(time_val));
     724             : }
     725             : 
     726             : // ES6 section 20.3.4.34 Date.prototype.setUTCSeconds ( sec, ms )
     727        1872 : BUILTIN(DatePrototypeSetUTCSeconds) {
     728             :   HandleScope scope(isolate);
     729        1434 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCSeconds");
     730             :   int const argc = args.length() - 1;
     731             :   Handle<Object> sec = args.atOrUndefined(isolate, 1);
     732         708 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, sec, Object::ToNumber(sec));
     733             :   double time_val = date->value()->Number();
     734         354 :   if (!std::isnan(time_val)) {
     735         311 :     int64_t const time_ms = static_cast<int64_t>(time_val);
     736             :     int day = isolate->date_cache()->DaysFromTime(time_ms);
     737             :     int time_within_day = isolate->date_cache()->TimeInDay(time_ms, day);
     738         311 :     int h = time_within_day / (60 * 60 * 1000);
     739         311 :     double m = (time_within_day / (60 * 1000)) % 60;
     740             :     double s = sec->Number();
     741         311 :     double milli = time_within_day % 1000;
     742         311 :     if (argc >= 2) {
     743             :       Handle<Object> ms = args.at(2);
     744         450 :       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
     745             :       milli = ms->Number();
     746             :     }
     747         311 :     time_val = MakeDate(day, MakeTime(h, m, s, milli));
     748             :   }
     749         708 :   return *JSDate::SetValue(date, TimeClip(time_val));
     750             : }
     751             : 
     752             : // ES6 section 20.3.4.35 Date.prototype.toDateString ( )
     753         866 : BUILTIN(DatePrototypeToDateString) {
     754             :   HandleScope scope(isolate);
     755        1094 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.toDateString");
     756             :   char buffer[128];
     757             :   ToDateString(date->value()->Number(), ArrayVector(buffer),
     758          14 :                isolate->date_cache(), kDateOnly);
     759          42 :   RETURN_RESULT_OR_FAILURE(
     760             :       isolate, isolate->factory()->NewStringFromUtf8(CStrVector(buffer)));
     761             : }
     762             : 
     763             : // ES6 section 20.3.4.36 Date.prototype.toISOString ( )
     764        1638 : BUILTIN(DatePrototypeToISOString) {
     765             :   HandleScope scope(isolate);
     766        1294 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.toISOString");
     767             :   double const time_val = date->value()->Number();
     768         214 :   if (std::isnan(time_val)) {
     769          56 :     THROW_NEW_ERROR_RETURN_FAILURE(
     770             :         isolate, NewRangeError(MessageTemplate::kInvalidTimeValue));
     771             :   }
     772         186 :   int64_t const time_ms = static_cast<int64_t>(time_val);
     773             :   int year, month, day, weekday, hour, min, sec, ms;
     774             :   isolate->date_cache()->BreakDownTime(time_ms, &year, &month, &day, &weekday,
     775         186 :                                        &hour, &min, &sec, &ms);
     776             :   char buffer[128];
     777         186 :   if (year >= 0 && year <= 9999) {
     778             :     SNPrintF(ArrayVector(buffer), "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", year,
     779         172 :              month + 1, day, hour, min, sec, ms);
     780          14 :   } else if (year < 0) {
     781             :     SNPrintF(ArrayVector(buffer), "-%06d-%02d-%02dT%02d:%02d:%02d.%03dZ", -year,
     782           0 :              month + 1, day, hour, min, sec, ms);
     783             :   } else {
     784             :     SNPrintF(ArrayVector(buffer), "+%06d-%02d-%02dT%02d:%02d:%02d.%03dZ", year,
     785          14 :              month + 1, day, hour, min, sec, ms);
     786             :   }
     787         372 :   return *isolate->factory()->NewStringFromAsciiChecked(buffer);
     788             : }
     789             : 
     790             : // ES6 section 20.3.4.41 Date.prototype.toString ( )
     791      355987 : BUILTIN(DatePrototypeToString) {
     792             :   HandleScope scope(isolate);
     793       89923 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.toString");
     794             :   char buffer[128];
     795             :   ToDateString(date->value()->Number(), ArrayVector(buffer),
     796       88783 :                isolate->date_cache());
     797      266349 :   RETURN_RESULT_OR_FAILURE(
     798             :       isolate, isolate->factory()->NewStringFromUtf8(CStrVector(buffer)));
     799             : }
     800             : 
     801             : // ES6 section 20.3.4.42 Date.prototype.toTimeString ( )
     802         866 : BUILTIN(DatePrototypeToTimeString) {
     803             :   HandleScope scope(isolate);
     804        1094 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.toTimeString");
     805             :   char buffer[128];
     806             :   ToDateString(date->value()->Number(), ArrayVector(buffer),
     807          14 :                isolate->date_cache(), kTimeOnly);
     808          42 :   RETURN_RESULT_OR_FAILURE(
     809             :       isolate, isolate->factory()->NewStringFromUtf8(CStrVector(buffer)));
     810             : }
     811             : 
     812             : // ES6 section 20.3.4.43 Date.prototype.toUTCString ( )
     813        2362 : BUILTIN(DatePrototypeToUTCString) {
     814             :   HandleScope scope(isolate);
     815        1468 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.toUTCString");
     816             :   double const time_val = date->value()->Number();
     817         388 :   if (std::isnan(time_val)) {
     818           0 :     return *isolate->factory()->NewStringFromAsciiChecked("Invalid Date");
     819             :   }
     820             :   char buffer[128];
     821         388 :   int64_t time_ms = static_cast<int64_t>(time_val);
     822             :   int year, month, day, weekday, hour, min, sec, ms;
     823             :   isolate->date_cache()->BreakDownTime(time_ms, &year, &month, &day, &weekday,
     824         388 :                                        &hour, &min, &sec, &ms);
     825             :   SNPrintF(ArrayVector(buffer), "%s, %02d %s %4d %02d:%02d:%02d GMT",
     826             :            kShortWeekDays[weekday], day, kShortMonths[month], year, hour, min,
     827         388 :            sec);
     828         776 :   return *isolate->factory()->NewStringFromAsciiChecked(buffer);
     829             : }
     830             : 
     831             : // ES6 section B.2.4.1 Date.prototype.getYear ( )
     832         908 : BUILTIN(DatePrototypeGetYear) {
     833             :   HandleScope scope(isolate);
     834         306 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.getYear");
     835             :   double time_val = date->value()->Number();
     836         186 :   if (std::isnan(time_val)) return date->value();
     837         130 :   int64_t time_ms = static_cast<int64_t>(time_val);
     838         130 :   int64_t local_time_ms = isolate->date_cache()->ToLocal(time_ms);
     839             :   int days = isolate->date_cache()->DaysFromTime(local_time_ms);
     840             :   int year, month, day;
     841         130 :   isolate->date_cache()->YearMonthDayFromDays(days, &year, &month, &day);
     842         260 :   return Smi::FromInt(year - 1900);
     843             : }
     844             : 
     845             : // ES6 section B.2.4.2 Date.prototype.setYear ( year )
     846        1042 : BUILTIN(DatePrototypeSetYear) {
     847             :   HandleScope scope(isolate);
     848         271 :   CHECK_RECEIVER(JSDate, date, "Date.prototype.setYear");
     849             :   Handle<Object> year = args.atOrUndefined(isolate, 1);
     850         422 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, year, Object::ToNumber(year));
     851             :   double m = 0.0, dt = 1.0, y = year->Number();
     852         211 :   if (0.0 <= y && y <= 99.0) {
     853          42 :     y = 1900.0 + DoubleToInteger(y);
     854             :   }
     855             :   int time_within_day = 0;
     856         211 :   if (!std::isnan(date->value()->Number())) {
     857         182 :     int64_t const time_ms = static_cast<int64_t>(date->value()->Number());
     858         182 :     int64_t local_time_ms = isolate->date_cache()->ToLocal(time_ms);
     859             :     int const days = isolate->date_cache()->DaysFromTime(local_time_ms);
     860             :     time_within_day = isolate->date_cache()->TimeInDay(local_time_ms, days);
     861             :     int year, month, day;
     862         182 :     isolate->date_cache()->YearMonthDayFromDays(days, &year, &month, &day);
     863         182 :     m = month;
     864         182 :     dt = day;
     865             :   }
     866         211 :   double time_val = MakeDate(MakeDay(y, m, dt), time_within_day);
     867         211 :   return SetLocalDateValue(date, time_val);
     868             : }
     869             : 
     870             : // ES6 section 20.3.4.37 Date.prototype.toJSON ( key )
     871        1437 : BUILTIN(DatePrototypeToJson) {
     872             :   HandleScope scope(isolate);
     873         479 :   Handle<Object> receiver = args.atOrUndefined(isolate, 0);
     874             :   Handle<JSReceiver> receiver_obj;
     875         958 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver_obj,
     876             :                                      Object::ToObject(isolate, receiver));
     877             :   Handle<Object> primitive;
     878         418 :   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
     879             :       isolate, primitive,
     880             :       Object::ToPrimitive(receiver_obj, ToPrimitiveHint::kNumber));
     881         328 :   if (primitive->IsNumber() && !std::isfinite(primitive->Number())) {
     882          30 :     return isolate->heap()->null_value();
     883             :   } else {
     884             :     Handle<String> name =
     885         164 :         isolate->factory()->NewStringFromAsciiChecked("toISOString");
     886             :     Handle<Object> function;
     887         328 :     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, function,
     888             :                                        Object::GetProperty(receiver_obj, name));
     889         164 :     if (!function->IsCallable()) {
     890          60 :       THROW_NEW_ERROR_RETURN_FAILURE(
     891             :           isolate, NewTypeError(MessageTemplate::kCalledNonCallable, name));
     892             :     }
     893         402 :     RETURN_RESULT_OR_FAILURE(
     894             :         isolate, Execution::Call(isolate, function, receiver_obj, 0, NULL));
     895             :   }
     896             : }
     897             : 
     898             : }  // namespace internal
     899      118934 : }  // namespace v8

Generated by: LCOV version 1.10