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 53984 : const double kMaxYear = -kMinYear;
25 : const double kMinMonth = -10000000.0;
26 53984 : 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 150196 : if (std::isfinite(day) && std::isfinite(time)) {
39 65676 : 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 67619 : double MakeDay(double year, double month, double date) {
46 134369 : if ((kMinYear <= year && year <= kMaxYear) &&
47 199264 : (kMinMonth <= month && month <= kMaxMonth) && std::isfinite(date)) {
48 : int y = FastD2I(year);
49 : int m = FastD2I(month);
50 65519 : y += m / 12;
51 65519 : m %= 12;
52 65519 : if (m < 0) {
53 9 : m += 12;
54 9 : 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 131038 : int day_from_year = 365 * (y + kYearDelta) + (y + kYearDelta) / 4 -
72 131038 : (y + kYearDelta) / 100 + (y + kYearDelta) / 400 -
73 65519 : kBaseDay;
74 65519 : 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 46877 : 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 18642 : day_from_year += kDayFromMonth[m];
82 : }
83 65519 : 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 73876 : double MakeTime(double hour, double min, double sec, double ms) {
90 276036 : if (std::isfinite(hour) && std::isfinite(min) && std::isfinite(sec) &&
91 : std::isfinite(ms)) {
92 65504 : double const h = DoubleToInteger(hour);
93 65504 : double const m = DoubleToInteger(min);
94 65504 : double const s = DoubleToInteger(sec);
95 65504 : double const milli = DoubleToInteger(ms);
96 65504 : 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 11421 : if (-DateCache::kMaxTimeInMs <= time && time <= DateCache::kMaxTimeInMs) {
104 652 : 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 64619 : double ParseDateTimeString(Handle<String> str) {
116 529 : Isolate* const isolate = str->GetIsolate();
117 64619 : str = String::Flatten(str);
118 : // TODO(bmeurer): Change DateParser to not use the FixedArray.
119 : Handle<FixedArray> tmp =
120 64619 : isolate->factory()->NewFixedArray(DateParser::OUTPUT_SIZE);
121 : DisallowHeapAllocation no_gc;
122 64619 : String::FlatContent str_content = str->GetFlatContent();
123 : bool result;
124 64619 : if (str_content.IsOneByte()) {
125 64619 : result = DateParser::Parse(isolate, str_content.ToOneByteVector(), *tmp);
126 : } else {
127 0 : result = DateParser::Parse(isolate, str_content.ToUC16Vector(), *tmp);
128 : }
129 64619 : if (!result) return std::numeric_limits<double>::quiet_NaN();
130 : double const day = MakeDay(tmp->get(0)->Number(), tmp->get(1)->Number(),
131 64079 : tmp->get(2)->Number());
132 : double const time = MakeTime(tmp->get(3)->Number(), tmp->get(4)->Number(),
133 64079 : tmp->get(5)->Number(), tmp->get(6)->Number());
134 : double date = MakeDate(day, time);
135 64079 : if (tmp->get(7)->IsNull(isolate)) {
136 539 : if (!std::isnan(date)) {
137 1058 : date = isolate->date_cache()->ToUTC(static_cast<int64_t>(date));
138 : }
139 : } else {
140 63540 : date -= tmp->get(7)->Number() * 1000.0;
141 : }
142 64079 : return date;
143 : }
144 :
145 : enum ToDateStringMode { kDateOnly, kTimeOnly, kDateAndTime };
146 :
147 : // ES6 section 20.3.4.41.1 ToDateString(tv)
148 59264 : void ToDateString(double time_val, Vector<char> str, DateCache* date_cache,
149 : ToDateStringMode mode = kDateAndTime) {
150 59264 : if (std::isnan(time_val)) {
151 70 : SNPrintF(str, "Invalid Date");
152 70 : return;
153 : }
154 59194 : int64_t time_ms = static_cast<int64_t>(time_val);
155 59194 : 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 59194 : &min, &sec, &ms);
159 59194 : int timezone_offset = -date_cache->TimezoneOffset(time_ms);
160 59194 : int timezone_hour = std::abs(timezone_offset) / 60;
161 59194 : int timezone_min = std::abs(timezone_offset) % 60;
162 59194 : const char* local_timezone = date_cache->LocalTimezone(time_ms);
163 59194 : switch (mode) {
164 : case kDateOnly:
165 : SNPrintF(str, "%s %s %02d %04d", kShortWeekDays[weekday],
166 19 : kShortMonths[month], day, year);
167 19 : 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 9 : local_timezone);
172 9 : return;
173 : case kDateAndTime:
174 : SNPrintF(str, "%s %s %02d %04d %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 59166 : timezone_min, local_timezone);
178 59166 : return;
179 : }
180 0 : UNREACHABLE();
181 : }
182 :
183 5836 : Object* SetLocalDateValue(Handle<JSDate> date, double time_val) {
184 5836 : if (time_val >= -DateCache::kMaxTimeBeforeUTCInMs &&
185 : time_val <= DateCache::kMaxTimeBeforeUTCInMs) {
186 350 : Isolate* const isolate = date->GetIsolate();
187 700 : 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 11672 : 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 172 : BUILTIN(DateConstructor) {
198 : HandleScope scope(isolate);
199 43 : double const time_val = JSDate::CurrentTimeValue(isolate);
200 : char buffer[128];
201 43 : ToDateString(time_val, ArrayVector(buffer), isolate->date_cache());
202 129 : 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 470023 : BUILTIN(DateConstructor_ConstructStub) {
208 : HandleScope scope(isolate);
209 156385 : int const argc = args.length() - 1;
210 156385 : Handle<JSFunction> target = args.target();
211 156385 : Handle<JSReceiver> new_target = Handle<JSReceiver>::cast(args.new_target());
212 : double time_val;
213 156385 : if (argc == 0) {
214 95900 : time_val = JSDate::CurrentTimeValue(isolate);
215 60485 : } else if (argc == 1) {
216 : Handle<Object> value = args.at(1);
217 59437 : if (value->IsJSDate()) {
218 : time_val = Handle<JSDate>::cast(value)->value()->Number();
219 : } else {
220 118566 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, value,
221 : Object::ToPrimitive(value));
222 59273 : if (value->IsString()) {
223 392 : time_val = ParseDateTimeString(Handle<String>::cast(value));
224 : } else {
225 117762 : 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 2096 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, year_object,
233 : Object::ToNumber(args.at(1)));
234 : Handle<Object> month_object;
235 2096 : 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 1048 : if (argc >= 3) {
241 : Handle<Object> date_object;
242 1928 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date_object,
243 : Object::ToNumber(args.at(3)));
244 : date = date_object->Number();
245 964 : if (argc >= 4) {
246 : Handle<Object> hours_object;
247 1592 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, hours_object,
248 : Object::ToNumber(args.at(4)));
249 : hours = hours_object->Number();
250 796 : if (argc >= 5) {
251 : Handle<Object> minutes_object;
252 1436 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, minutes_object,
253 : Object::ToNumber(args.at(5)));
254 : minutes = minutes_object->Number();
255 718 : if (argc >= 6) {
256 : Handle<Object> seconds_object;
257 458 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, seconds_object,
258 : Object::ToNumber(args.at(6)));
259 : seconds = seconds_object->Number();
260 229 : if (argc >= 7) {
261 : Handle<Object> ms_object;
262 404 : 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 1048 : if (!std::isnan(year)) {
271 1029 : double const y = DoubleToInteger(year);
272 1029 : if (0.0 <= y && y <= 99) year = 1900 + y;
273 : }
274 1048 : double const day = MakeDay(year, month, date);
275 1048 : double const time = MakeTime(hours, minutes, seconds, ms);
276 : time_val = MakeDate(day, time);
277 1048 : if (time_val >= -DateCache::kMaxTimeBeforeUTCInMs &&
278 : time_val <= DateCache::kMaxTimeBeforeUTCInMs) {
279 1736 : 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 469125 : RETURN_RESULT_OR_FAILURE(isolate, JSDate::New(target, new_target, time_val));
285 : }
286 :
287 : // ES6 section 20.3.3.1 Date.now ( )
288 189717 : BUILTIN(DateNow) {
289 : HandleScope scope(isolate);
290 189717 : return *isolate->factory()->NewNumber(JSDate::CurrentTimeValue(isolate));
291 : }
292 :
293 : // ES6 section 20.3.3.2 Date.parse ( string )
294 192681 : BUILTIN(DateParse) {
295 : HandleScope scope(isolate);
296 : Handle<String> string;
297 128454 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
298 : isolate, string,
299 : Object::ToString(isolate, args.atOrUndefined(isolate, 1)));
300 128454 : 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 660 : BUILTIN(DateUTC) {
305 : HandleScope scope(isolate);
306 220 : 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 220 : if (argc >= 1) {
311 : Handle<Object> year_object;
312 440 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, year_object,
313 : Object::ToNumber(args.at(1)));
314 : year = year_object->Number();
315 220 : if (argc >= 2) {
316 : Handle<Object> month_object;
317 440 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, month_object,
318 : Object::ToNumber(args.at(2)));
319 : month = month_object->Number();
320 220 : if (argc >= 3) {
321 : Handle<Object> date_object;
322 440 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date_object,
323 : Object::ToNumber(args.at(3)));
324 : date = date_object->Number();
325 220 : if (argc >= 4) {
326 : Handle<Object> hours_object;
327 286 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, hours_object,
328 : Object::ToNumber(args.at(4)));
329 : hours = hours_object->Number();
330 143 : if (argc >= 5) {
331 : Handle<Object> minutes_object;
332 246 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, minutes_object,
333 : Object::ToNumber(args.at(5)));
334 : minutes = minutes_object->Number();
335 123 : if (argc >= 6) {
336 : Handle<Object> seconds_object;
337 246 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, seconds_object,
338 : Object::ToNumber(args.at(6)));
339 : seconds = seconds_object->Number();
340 123 : if (argc >= 7) {
341 : Handle<Object> ms_object;
342 208 : 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 220 : if (!std::isnan(year)) {
353 220 : double const y = DoubleToInteger(year);
354 220 : if (0.0 <= y && y <= 99) year = 1900 + y;
355 : }
356 220 : double const day = MakeDay(year, month, date);
357 220 : double const time = MakeTime(hours, minutes, seconds, ms);
358 440 : return *isolate->factory()->NewNumber(TimeClip(MakeDate(day, time)));
359 : }
360 :
361 : // ES6 section 20.3.4.20 Date.prototype.setDate ( date )
362 1007 : BUILTIN(DatePrototypeSetDate) {
363 : HandleScope scope(isolate);
364 855 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setDate");
365 : Handle<Object> value = args.atOrUndefined(isolate, 1);
366 190 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, value, Object::ToNumber(value));
367 : double time_val = date->value()->Number();
368 95 : if (!std::isnan(time_val)) {
369 76 : int64_t const time_ms = static_cast<int64_t>(time_val);
370 76 : 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 76 : isolate->date_cache()->YearMonthDayFromDays(days, &year, &month, &day);
375 152 : time_val = MakeDate(MakeDay(year, month, value->Number()), time_within_day);
376 : }
377 95 : return SetLocalDateValue(date, time_val);
378 : }
379 :
380 : // ES6 section 20.3.4.21 Date.prototype.setFullYear (year, month, date)
381 4437 : BUILTIN(DatePrototypeSetFullYear) {
382 : HandleScope scope(isolate);
383 1507 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setFullYear");
384 787 : int const argc = args.length() - 1;
385 : Handle<Object> year = args.atOrUndefined(isolate, 1);
386 1574 : 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 787 : if (!std::isnan(date->value()->Number())) {
390 768 : int64_t const time_ms = static_cast<int64_t>(date->value()->Number());
391 768 : 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 768 : isolate->date_cache()->YearMonthDayFromDays(days, &year, &month, &day);
396 768 : m = month;
397 768 : dt = day;
398 : }
399 787 : if (argc >= 2) {
400 : Handle<Object> month = args.at(2);
401 1424 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, month, Object::ToNumber(month));
402 : m = month->Number();
403 712 : if (argc >= 3) {
404 : Handle<Object> date = args.at(3);
405 1154 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date, Object::ToNumber(date));
406 : dt = date->Number();
407 : }
408 : }
409 787 : double time_val = MakeDate(MakeDay(y, m, dt), time_within_day);
410 787 : return SetLocalDateValue(date, time_val);
411 : }
412 :
413 : // ES6 section 20.3.4.22 Date.prototype.setHours(hour, min, sec, ms)
414 13068 : BUILTIN(DatePrototypeSetHours) {
415 : HandleScope scope(isolate);
416 3896 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setHours");
417 3136 : int const argc = args.length() - 1;
418 : Handle<Object> hour = args.atOrUndefined(isolate, 1);
419 6272 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, hour, Object::ToNumber(hour));
420 : double h = hour->Number();
421 : double time_val = date->value()->Number();
422 3136 : if (!std::isnan(time_val)) {
423 3090 : int64_t const time_ms = static_cast<int64_t>(time_val);
424 3090 : 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 3090 : double m = (time_within_day / (60 * 1000)) % 60;
428 3090 : double s = (time_within_day / 1000) % 60;
429 3090 : double milli = time_within_day % 1000;
430 3090 : if (argc >= 2) {
431 : Handle<Object> min = args.at(2);
432 6050 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, min, Object::ToNumber(min));
433 : m = min->Number();
434 3025 : if (argc >= 3) {
435 : Handle<Object> sec = args.at(3);
436 5762 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, sec, Object::ToNumber(sec));
437 : s = sec->Number();
438 2881 : if (argc >= 4) {
439 : Handle<Object> ms = args.at(4);
440 4610 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
441 : milli = ms->Number();
442 : }
443 : }
444 : }
445 3090 : time_val = MakeDate(day, MakeTime(h, m, s, milli));
446 : }
447 3136 : return SetLocalDateValue(date, time_val);
448 : }
449 :
450 : // ES6 section 20.3.4.23 Date.prototype.setMilliseconds(ms)
451 1977 : BUILTIN(DatePrototypeSetMilliseconds) {
452 : HandleScope scope(isolate);
453 1084 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setMilliseconds");
454 : Handle<Object> ms = args.atOrUndefined(isolate, 1);
455 728 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
456 : double time_val = date->value()->Number();
457 364 : if (!std::isnan(time_val)) {
458 345 : int64_t const time_ms = static_cast<int64_t>(time_val);
459 345 : 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 345 : int h = time_within_day / (60 * 60 * 1000);
463 345 : int m = (time_within_day / (60 * 1000)) % 60;
464 345 : int s = (time_within_day / 1000) % 60;
465 345 : time_val = MakeDate(day, MakeTime(h, m, s, ms->Number()));
466 : }
467 364 : return SetLocalDateValue(date, time_val);
468 : }
469 :
470 : // ES6 section 20.3.4.24 Date.prototype.setMinutes ( min, sec, ms )
471 3795 : BUILTIN(DatePrototypeSetMinutes) {
472 : HandleScope scope(isolate);
473 1543 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setMinutes");
474 823 : int const argc = args.length() - 1;
475 : Handle<Object> min = args.atOrUndefined(isolate, 1);
476 1646 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, min, Object::ToNumber(min));
477 : double time_val = date->value()->Number();
478 823 : if (!std::isnan(time_val)) {
479 786 : int64_t const time_ms = static_cast<int64_t>(time_val);
480 786 : 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 786 : int h = time_within_day / (60 * 60 * 1000);
484 : double m = min->Number();
485 786 : double s = (time_within_day / 1000) % 60;
486 786 : double milli = time_within_day % 1000;
487 786 : if (argc >= 2) {
488 : Handle<Object> sec = args.at(2);
489 1442 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, sec, Object::ToNumber(sec));
490 : s = sec->Number();
491 721 : if (argc >= 3) {
492 : Handle<Object> ms = args.at(3);
493 1154 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
494 : milli = ms->Number();
495 : }
496 : }
497 786 : time_val = MakeDate(day, MakeTime(h, m, s, milli));
498 : }
499 823 : return SetLocalDateValue(date, time_val);
500 : }
501 :
502 : // ES6 section 20.3.4.25 Date.prototype.setMonth ( month, date )
503 1719 : BUILTIN(DatePrototypeSetMonth) {
504 : HandleScope scope(isolate);
505 967 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setMonth");
506 : int const argc = args.length() - 1;
507 : Handle<Object> month = args.atOrUndefined(isolate, 1);
508 494 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, month, Object::ToNumber(month));
509 : double time_val = date->value()->Number();
510 247 : if (!std::isnan(time_val)) {
511 219 : int64_t const time_ms = static_cast<int64_t>(time_val);
512 219 : 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 219 : isolate->date_cache()->YearMonthDayFromDays(days, &year, &unused, &day);
517 : double m = month->Number();
518 219 : double dt = day;
519 219 : if (argc >= 2) {
520 : Handle<Object> date = args.at(2);
521 290 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date, Object::ToNumber(date));
522 : dt = date->Number();
523 : }
524 219 : time_val = MakeDate(MakeDay(year, m, dt), time_within_day);
525 : }
526 247 : return SetLocalDateValue(date, time_val);
527 : }
528 :
529 : // ES6 section 20.3.4.26 Date.prototype.setSeconds ( sec, ms )
530 1504 : BUILTIN(DatePrototypeSetSeconds) {
531 : HandleScope scope(isolate);
532 968 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setSeconds");
533 : int const argc = args.length() - 1;
534 : Handle<Object> sec = args.atOrUndefined(isolate, 1);
535 496 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, sec, Object::ToNumber(sec));
536 : double time_val = date->value()->Number();
537 248 : if (!std::isnan(time_val)) {
538 220 : int64_t const time_ms = static_cast<int64_t>(time_val);
539 220 : 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 220 : int h = time_within_day / (60 * 60 * 1000);
543 220 : double m = (time_within_day / (60 * 1000)) % 60;
544 : double s = sec->Number();
545 220 : double milli = time_within_day % 1000;
546 220 : if (argc >= 2) {
547 : Handle<Object> ms = args.at(2);
548 310 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
549 : milli = ms->Number();
550 : }
551 220 : time_val = MakeDate(day, MakeTime(h, m, s, milli));
552 : }
553 248 : return SetLocalDateValue(date, time_val);
554 : }
555 :
556 : // ES6 section 20.3.4.27 Date.prototype.setTime ( time )
557 765 : BUILTIN(DatePrototypeSetTime) {
558 : HandleScope scope(isolate);
559 825 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setTime");
560 : Handle<Object> value = args.atOrUndefined(isolate, 1);
561 130 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, value, Object::ToNumber(value));
562 130 : return *JSDate::SetValue(date, TimeClip(value->Number()));
563 : }
564 :
565 : // ES6 section 20.3.4.28 Date.prototype.setUTCDate ( date )
566 861 : BUILTIN(DatePrototypeSetUTCDate) {
567 : HandleScope scope(isolate);
568 805 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCDate");
569 : Handle<Object> value = args.atOrUndefined(isolate, 1);
570 170 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, value, Object::ToNumber(value));
571 85 : if (std::isnan(date->value()->Number())) return date->value();
572 66 : 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 66 : isolate->date_cache()->YearMonthDayFromDays(days, &year, &month, &day);
577 : double const time_val =
578 132 : MakeDate(MakeDay(year, month, value->Number()), time_within_day);
579 132 : return *JSDate::SetValue(date, TimeClip(time_val));
580 : }
581 :
582 : // ES6 section 20.3.4.29 Date.prototype.setUTCFullYear (year, month, date)
583 3669 : BUILTIN(DatePrototypeSetUTCFullYear) {
584 : HandleScope scope(isolate);
585 1507 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCFullYear");
586 787 : int const argc = args.length() - 1;
587 : Handle<Object> year = args.atOrUndefined(isolate, 1);
588 1574 : 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 787 : if (!std::isnan(date->value()->Number())) {
592 768 : 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 768 : isolate->date_cache()->YearMonthDayFromDays(days, &year, &month, &day);
597 768 : m = month;
598 768 : dt = day;
599 : }
600 787 : if (argc >= 2) {
601 : Handle<Object> month = args.at(2);
602 1424 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, month, Object::ToNumber(month));
603 : m = month->Number();
604 712 : if (argc >= 3) {
605 : Handle<Object> date = args.at(3);
606 1154 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date, Object::ToNumber(date));
607 : dt = date->Number();
608 : }
609 : }
610 787 : double const time_val = MakeDate(MakeDay(y, m, dt), time_within_day);
611 1574 : return *JSDate::SetValue(date, TimeClip(time_val));
612 : }
613 :
614 : // ES6 section 20.3.4.30 Date.prototype.setUTCHours(hour, min, sec, ms)
615 9927 : BUILTIN(DatePrototypeSetUTCHours) {
616 : HandleScope scope(isolate);
617 3849 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCHours");
618 3129 : int const argc = args.length() - 1;
619 : Handle<Object> hour = args.atOrUndefined(isolate, 1);
620 6258 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, hour, Object::ToNumber(hour));
621 : double h = hour->Number();
622 : double time_val = date->value()->Number();
623 3129 : if (!std::isnan(time_val)) {
624 3073 : 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 3073 : double m = (time_within_day / (60 * 1000)) % 60;
628 3073 : double s = (time_within_day / 1000) % 60;
629 3073 : double milli = time_within_day % 1000;
630 3073 : if (argc >= 2) {
631 : Handle<Object> min = args.at(2);
632 6014 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, min, Object::ToNumber(min));
633 : m = min->Number();
634 3007 : if (argc >= 3) {
635 : Handle<Object> sec = args.at(3);
636 5744 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, sec, Object::ToNumber(sec));
637 : s = sec->Number();
638 2872 : if (argc >= 4) {
639 : Handle<Object> ms = args.at(4);
640 4610 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
641 : milli = ms->Number();
642 : }
643 : }
644 : }
645 3073 : time_val = MakeDate(day, MakeTime(h, m, s, milli));
646 : }
647 6258 : return *JSDate::SetValue(date, TimeClip(time_val));
648 : }
649 :
650 : // ES6 section 20.3.4.31 Date.prototype.setUTCMilliseconds(ms)
651 765 : BUILTIN(DatePrototypeSetUTCMilliseconds) {
652 : HandleScope scope(isolate);
653 795 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCMilliseconds");
654 : Handle<Object> ms = args.atOrUndefined(isolate, 1);
655 150 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
656 : double time_val = date->value()->Number();
657 75 : if (!std::isnan(time_val)) {
658 56 : 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 56 : int h = time_within_day / (60 * 60 * 1000);
662 56 : int m = (time_within_day / (60 * 1000)) % 60;
663 56 : int s = (time_within_day / 1000) % 60;
664 56 : time_val = MakeDate(day, MakeTime(h, m, s, ms->Number()));
665 : }
666 150 : return *JSDate::SetValue(date, TimeClip(time_val));
667 : }
668 :
669 : // ES6 section 20.3.4.32 Date.prototype.setUTCMinutes ( min, sec, ms )
670 2895 : BUILTIN(DatePrototypeSetUTCMinutes) {
671 : HandleScope scope(isolate);
672 1505 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCMinutes");
673 785 : int const argc = args.length() - 1;
674 : Handle<Object> min = args.atOrUndefined(isolate, 1);
675 1570 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, min, Object::ToNumber(min));
676 : double time_val = date->value()->Number();
677 785 : if (!std::isnan(time_val)) {
678 758 : 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 758 : int h = time_within_day / (60 * 60 * 1000);
682 : double m = min->Number();
683 758 : double s = (time_within_day / 1000) % 60;
684 758 : double milli = time_within_day % 1000;
685 758 : if (argc >= 2) {
686 : Handle<Object> sec = args.at(2);
687 1424 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, sec, Object::ToNumber(sec));
688 : s = sec->Number();
689 712 : if (argc >= 3) {
690 : Handle<Object> ms = args.at(3);
691 1154 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
692 : milli = ms->Number();
693 : }
694 : }
695 758 : time_val = MakeDate(day, MakeTime(h, m, s, milli));
696 : }
697 1570 : return *JSDate::SetValue(date, TimeClip(time_val));
698 : }
699 :
700 : // ES6 section 20.3.4.31 Date.prototype.setUTCMonth ( month, date )
701 1428 : BUILTIN(DatePrototypeSetUTCMonth) {
702 : HandleScope scope(isolate);
703 949 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCMonth");
704 : int const argc = args.length() - 1;
705 : Handle<Object> month = args.atOrUndefined(isolate, 1);
706 458 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, month, Object::ToNumber(month));
707 : double time_val = date->value()->Number();
708 229 : if (!std::isnan(time_val)) {
709 201 : 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 201 : isolate->date_cache()->YearMonthDayFromDays(days, &year, &unused, &day);
714 : double m = month->Number();
715 201 : double dt = day;
716 201 : if (argc >= 2) {
717 : Handle<Object> date = args.at(2);
718 290 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date, Object::ToNumber(date));
719 : dt = date->Number();
720 : }
721 201 : time_val = MakeDate(MakeDay(year, m, dt), time_within_day);
722 : }
723 458 : return *JSDate::SetValue(date, TimeClip(time_val));
724 : }
725 :
726 : // ES6 section 20.3.4.34 Date.prototype.setUTCSeconds ( sec, ms )
727 1227 : BUILTIN(DatePrototypeSetUTCSeconds) {
728 : HandleScope scope(isolate);
729 949 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCSeconds");
730 : int const argc = args.length() - 1;
731 : Handle<Object> sec = args.atOrUndefined(isolate, 1);
732 458 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, sec, Object::ToNumber(sec));
733 : double time_val = date->value()->Number();
734 229 : if (!std::isnan(time_val)) {
735 201 : 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 201 : int h = time_within_day / (60 * 60 * 1000);
739 201 : double m = (time_within_day / (60 * 1000)) % 60;
740 : double s = sec->Number();
741 201 : double milli = time_within_day % 1000;
742 201 : if (argc >= 2) {
743 : Handle<Object> ms = args.at(2);
744 290 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
745 : milli = ms->Number();
746 : }
747 201 : time_val = MakeDate(day, MakeTime(h, m, s, milli));
748 : }
749 458 : return *JSDate::SetValue(date, TimeClip(time_val));
750 : }
751 :
752 : // ES6 section 20.3.4.35 Date.prototype.toDateString ( )
753 616 : BUILTIN(DatePrototypeToDateString) {
754 : HandleScope scope(isolate);
755 739 : CHECK_RECEIVER(JSDate, date, "Date.prototype.toDateString");
756 : char buffer[128];
757 : ToDateString(date->value()->Number(), ArrayVector(buffer),
758 19 : isolate->date_cache(), kDateOnly);
759 57 : RETURN_RESULT_OR_FAILURE(
760 : isolate, isolate->factory()->NewStringFromUtf8(CStrVector(buffer)));
761 : }
762 :
763 : // ES6 section 20.3.4.36 Date.prototype.toISOString ( )
764 1078 : BUILTIN(DatePrototypeToISOString) {
765 : HandleScope scope(isolate);
766 859 : CHECK_RECEIVER(JSDate, date, "Date.prototype.toISOString");
767 : double const time_val = date->value()->Number();
768 139 : if (std::isnan(time_val)) {
769 36 : THROW_NEW_ERROR_RETURN_FAILURE(
770 : isolate, NewRangeError(MessageTemplate::kInvalidTimeValue));
771 : }
772 121 : 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 121 : &hour, &min, &sec, &ms);
776 : char buffer[128];
777 121 : if (year >= 0 && year <= 9999) {
778 : SNPrintF(ArrayVector(buffer), "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", year,
779 112 : month + 1, day, hour, min, sec, ms);
780 9 : } 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 9 : month + 1, day, hour, min, sec, ms);
786 : }
787 242 : return *isolate->factory()->NewStringFromAsciiChecked(buffer);
788 : }
789 :
790 : // ES6 section 20.3.4.41 Date.prototype.toString ( )
791 237342 : BUILTIN(DatePrototypeToString) {
792 : HandleScope scope(isolate);
793 59953 : CHECK_RECEIVER(JSDate, date, "Date.prototype.toString");
794 : char buffer[128];
795 : ToDateString(date->value()->Number(), ArrayVector(buffer),
796 59193 : isolate->date_cache());
797 177579 : RETURN_RESULT_OR_FAILURE(
798 : isolate, isolate->factory()->NewStringFromUtf8(CStrVector(buffer)));
799 : }
800 :
801 : // ES6 section 20.3.4.42 Date.prototype.toTimeString ( )
802 576 : BUILTIN(DatePrototypeToTimeString) {
803 : HandleScope scope(isolate);
804 729 : CHECK_RECEIVER(JSDate, date, "Date.prototype.toTimeString");
805 : char buffer[128];
806 : ToDateString(date->value()->Number(), ArrayVector(buffer),
807 9 : isolate->date_cache(), kTimeOnly);
808 27 : RETURN_RESULT_OR_FAILURE(
809 : isolate, isolate->factory()->NewStringFromUtf8(CStrVector(buffer)));
810 : }
811 :
812 : // ES6 section 20.3.4.43 Date.prototype.toUTCString ( )
813 1612 : BUILTIN(DatePrototypeToUTCString) {
814 : HandleScope scope(isolate);
815 988 : CHECK_RECEIVER(JSDate, date, "Date.prototype.toUTCString");
816 : double const time_val = date->value()->Number();
817 268 : if (std::isnan(time_val)) {
818 0 : return *isolate->factory()->NewStringFromAsciiChecked("Invalid Date");
819 : }
820 : char buffer[128];
821 268 : 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 268 : &hour, &min, &sec, &ms);
825 : SNPrintF(ArrayVector(buffer), "%s, %02d %s %04d %02d:%02d:%02d GMT",
826 : kShortWeekDays[weekday], day, kShortMonths[month], year, hour, min,
827 268 : sec);
828 536 : return *isolate->factory()->NewStringFromAsciiChecked(buffer);
829 : }
830 :
831 : // ES6 section B.2.4.1 Date.prototype.getYear ( )
832 593 : BUILTIN(DatePrototypeGetYear) {
833 : HandleScope scope(isolate);
834 201 : CHECK_RECEIVER(JSDate, date, "Date.prototype.getYear");
835 : double time_val = date->value()->Number();
836 121 : if (std::isnan(time_val)) return date->value();
837 85 : int64_t time_ms = static_cast<int64_t>(time_val);
838 85 : 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 85 : isolate->date_cache()->YearMonthDayFromDays(days, &year, &month, &day);
842 170 : return Smi::FromInt(year - 1900);
843 : }
844 :
845 : // ES6 section B.2.4.2 Date.prototype.setYear ( year )
846 672 : BUILTIN(DatePrototypeSetYear) {
847 : HandleScope scope(isolate);
848 176 : CHECK_RECEIVER(JSDate, date, "Date.prototype.setYear");
849 : Handle<Object> year = args.atOrUndefined(isolate, 1);
850 272 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, year, Object::ToNumber(year));
851 : double m = 0.0, dt = 1.0, y = year->Number();
852 136 : if (0.0 <= y && y <= 99.0) {
853 27 : y = 1900.0 + DoubleToInteger(y);
854 : }
855 : int time_within_day = 0;
856 136 : if (!std::isnan(date->value()->Number())) {
857 117 : int64_t const time_ms = static_cast<int64_t>(date->value()->Number());
858 117 : 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 117 : isolate->date_cache()->YearMonthDayFromDays(days, &year, &month, &day);
863 117 : m = month;
864 117 : dt = day;
865 : }
866 136 : double time_val = MakeDate(MakeDay(y, m, dt), time_within_day);
867 136 : return SetLocalDateValue(date, time_val);
868 : }
869 :
870 : // ES6 section 20.3.4.37 Date.prototype.toJSON ( key )
871 957 : BUILTIN(DatePrototypeToJson) {
872 : HandleScope scope(isolate);
873 319 : Handle<Object> receiver = args.atOrUndefined(isolate, 0);
874 : Handle<JSReceiver> receiver_obj;
875 638 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver_obj,
876 : Object::ToObject(isolate, receiver));
877 : Handle<Object> primitive;
878 278 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
879 : isolate, primitive,
880 : Object::ToPrimitive(receiver_obj, ToPrimitiveHint::kNumber));
881 218 : if (primitive->IsNumber() && !std::isfinite(primitive->Number())) {
882 20 : return isolate->heap()->null_value();
883 : } else {
884 : Handle<String> name =
885 109 : isolate->factory()->NewStringFromAsciiChecked("toISOString");
886 : Handle<Object> function;
887 218 : ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, function,
888 : Object::GetProperty(receiver_obj, name));
889 109 : if (!function->IsCallable()) {
890 40 : THROW_NEW_ERROR_RETURN_FAILURE(
891 : isolate, NewTypeError(MessageTemplate::kCalledNonCallable, name));
892 : }
893 267 : RETURN_RESULT_OR_FAILURE(
894 : isolate, Execution::Call(isolate, function, receiver_obj, 0, nullptr));
895 : }
896 : }
897 :
898 : } // namespace internal
899 107968 : } // namespace v8
|
