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
|
