1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 * vim: set ts=8 sts=2 et sw=2 tw=80:
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
10 * "For example, OS/360 devotes 26 bytes of the permanently
11 * resident date-turnover routine to the proper handling of
12 * December 31 on leap years (when it is Day 366). That
13 * might have been left to the operator."
15 * Frederick Brooks, 'The Second-System Effect'.
20 #include "mozilla/Atomics.h"
21 #include "mozilla/Casting.h"
22 #include "mozilla/FloatingPoint.h"
23 #include "mozilla/Sprintf.h"
24 #include "mozilla/TextUtils.h"
33 #include "jsfriendapi.h"
37 #ifdef JS_HAS_TEMPORAL_API
38 # include "builtin/temporal/Instant.h"
40 #include "js/CallAndConstruct.h" // JS::IsCallable
41 #include "js/Conversions.h"
43 #include "js/friend/ErrorMessages.h" // js::GetErrorMessage, JSMSG_*
44 #include "js/LocaleSensitive.h"
45 #include "js/Object.h" // JS::GetBuiltinClass
46 #include "js/PropertySpec.h"
47 #include "js/Wrapper.h"
48 #include "util/DifferentialTesting.h"
49 #include "util/StringBuffer.h"
50 #include "util/Text.h"
51 #include "vm/DateObject.h"
52 #include "vm/DateTime.h"
53 #include "vm/GlobalObject.h"
54 #include "vm/Interpreter.h"
55 #include "vm/JSContext.h"
56 #include "vm/JSObject.h"
57 #include "vm/StringType.h"
60 #include "vm/Compartment-inl.h" // For js::UnwrapAndTypeCheckThis
61 #include "vm/GeckoProfiler-inl.h"
62 #include "vm/JSObject-inl.h"
66 using mozilla::Atomic
;
67 using mozilla::BitwiseCast
;
68 using mozilla::IsAsciiAlpha
;
69 using mozilla::IsAsciiDigit
;
70 using mozilla::IsAsciiLowercaseAlpha
;
71 using mozilla::NumbersAreIdentical
;
72 using mozilla::Relaxed
;
74 using JS::AutoCheckCannotGC
;
75 using JS::ClippedTime
;
77 using JS::GetBuiltinClass
;
81 // When this value is non-zero, we'll round the time by this resolution.
82 static Atomic
<uint32_t, Relaxed
> sResolutionUsec
;
83 // This is not implemented yet, but we will use this to know to jitter the time
85 static Atomic
<bool, Relaxed
> sJitter
;
86 // The callback we will use for the Gecko implementation of Timer
88 static Atomic
<JS::ReduceMicrosecondTimePrecisionCallback
, Relaxed
>
89 sReduceMicrosecondTimePrecisionCallback
;
92 * The JS 'Date' object is patterned after the Java 'Date' object.
97 * print(today.toLocaleString());
99 * weekDay = today.getDay();
102 * These Java (and ECMA-262) methods are supported:
105 * getDate (getUTCDate)
107 * getHours (getUTCHours)
108 * getMinutes (getUTCMinutes)
109 * getMonth (getUTCMonth)
110 * getSeconds (getUTCSeconds)
111 * getMilliseconds (getUTCMilliseconds)
115 * getFullYear (getUTCFullYear)
117 * setDate (setUTCDate)
118 * setHours (setUTCHours)
119 * setMinutes (setUTCMinutes)
120 * setMonth (setUTCMonth)
121 * setSeconds (setUTCSeconds)
122 * setMilliseconds (setUTCMilliseconds)
124 * setYear (setFullYear, setUTCFullYear)
125 * toGMTString (toUTCString)
130 * These Java methods are not supported
141 class DateTimeHelper
{
144 static double localTZA(DateTimeInfo::ForceUTC forceUTC
, double t
,
145 DateTimeInfo::TimeZoneOffset offset
);
147 static int equivalentYearForDST(int year
);
148 static bool isRepresentableAsTime32(double t
);
149 static double daylightSavingTA(DateTimeInfo::ForceUTC forceUTC
, double t
);
150 static double adjustTime(DateTimeInfo::ForceUTC forceUTC
, double date
);
151 static PRMJTime
toPRMJTime(DateTimeInfo::ForceUTC forceUTC
, double localTime
,
156 static double localTime(DateTimeInfo::ForceUTC forceUTC
, double t
);
157 static double UTC(DateTimeInfo::ForceUTC forceUTC
, double t
);
158 static JSString
* timeZoneComment(JSContext
* cx
,
159 DateTimeInfo::ForceUTC forceUTC
,
160 const char* locale
, double utcTime
,
163 static size_t formatTime(DateTimeInfo::ForceUTC forceUTC
, char* buf
,
164 size_t buflen
, const char* fmt
, double utcTime
,
171 static DateTimeInfo::ForceUTC
ForceUTC(const Realm
* realm
) {
172 return realm
->creationOptions().forceUTC() ? DateTimeInfo::ForceUTC::Yes
173 : DateTimeInfo::ForceUTC::No
;
176 // ES2019 draft rev 0ceb728a1adbffe42b26972a6541fd7f398b1557
177 // 5.2.5 Mathematical Operations
178 static inline double PositiveModulo(double dividend
, double divisor
) {
179 MOZ_ASSERT(divisor
> 0);
180 MOZ_ASSERT(std::isfinite(divisor
));
182 double result
= fmod(dividend
, divisor
);
186 return result
+ (+0.0);
189 static inline double Day(double t
) { return floor(t
/ msPerDay
); }
191 static double TimeWithinDay(double t
) { return PositiveModulo(t
, msPerDay
); }
194 static inline bool IsLeapYear(double year
) {
195 MOZ_ASSERT(ToInteger(year
) == year
);
196 return fmod(year
, 4) == 0 && (fmod(year
, 100) != 0 || fmod(year
, 400) == 0);
199 static inline double DayFromYear(double y
) {
200 return 365 * (y
- 1970) + floor((y
- 1969) / 4.0) -
201 floor((y
- 1901) / 100.0) + floor((y
- 1601) / 400.0);
204 static inline double TimeFromYear(double y
) {
205 return DayFromYear(y
) * msPerDay
;
209 struct YearMonthDay
{
217 * This function returns the year, month and day corresponding to a given
218 * time value. The implementation closely follows (w.r.t. types and variable
219 * names) the algorithm shown in Figure 12 of [1].
221 * A key point of the algorithm is that it works on the so called
222 * Computational calendar where years run from March to February -- this
223 * largely avoids complications with leap years. The algorithm finds the
224 * date in the Computation calendar and then maps it to the Gregorian
227 * [1] Neri C, Schneider L., "Euclidean affine functions and their
228 * application to calendar algorithms."
229 * Softw Pract Exper. 2023;53(4):937-970. doi: 10.1002/spe.3172
230 * https://onlinelibrary.wiley.com/doi/full/10.1002/spe.3172
232 static YearMonthDay
ToYearMonthDay(double t
) {
233 MOZ_ASSERT(ToInteger(t
) == t
);
235 // Calendar cycles repeat every 400 years in the Gregorian calendar: a
236 // leap day is added every 4 years, removed every 100 years and added
237 // every 400 years. The number of days in 400 years is cycleInDays.
238 constexpr uint32_t cycleInYears
= 400;
239 constexpr uint32_t cycleInDays
= cycleInYears
* 365 + (cycleInYears
/ 4) -
240 (cycleInYears
/ 100) + (cycleInYears
/ 400);
241 static_assert(cycleInDays
== 146097, "Wrong calculation of cycleInDays.");
243 // The natural epoch for the Computational calendar is 0000/Mar/01 and
244 // there are rataDie1970Jan1 = 719468 days from this date to 1970/Jan/01,
245 // the epoch used by ES2024, 21.4.1.1.
246 constexpr uint32_t rataDie1970Jan1
= 719468;
248 constexpr uint32_t maxU32
= std::numeric_limits
<uint32_t>::max();
250 // Let N_U be the number of days since the 1970/Jan/01. This function sets
251 // N = N_U + K, where K = rataDie1970Jan1 + s * cycleInDays and s is an
252 // integer number (to be chosen). Then, it evaluates 4 * N + 3 on uint32_t
253 // operands so that N must be positive and, to prevent overflow,
254 // 4 * N + 3 <= maxU32 <=> N <= (maxU32 - 3) / 4.
255 // Therefore, we must have 0 <= N_U + K <= (maxU32 - 3) / 4 or, in other
256 // words, N_U must be in [minDays, maxDays] = [-K, (maxU32 - 3) / 4 - K].
257 // Notice that this interval moves cycleInDays positions to the left when
258 // s is incremented. We chose s to get the interval's mid-point as close
259 // as possible to 0. For this, we wish to have:
260 // K ~= (maxU32 - 3) / 4 - K <=> 2 * K ~= (maxU32 - 3) / 4 <=>
261 // K ~= (maxU32 - 3) / 8 <=>
262 // rataDie1970Jan1 + s * cycleInDays ~= (maxU32 - 3) / 8 <=>
263 // s ~= ((maxU32 - 3) / 8 - rataDie1970Jan1) / cycleInDays ~= 3669.8.
264 // Therefore, we chose s = 3670. The shift and correction constants
265 // (see [1]) are then:
266 constexpr uint32_t s
= 3670;
267 constexpr uint32_t K
= rataDie1970Jan1
+ s
* cycleInDays
;
268 constexpr uint32_t L
= s
* cycleInYears
;
270 // [minDays, maxDays] correspond to a date range from -1'468'000/Mar/01 to
272 constexpr int32_t minDays
= -int32_t(K
);
273 constexpr int32_t maxDays
= (maxU32
- 3) / 4 - K
;
274 static_assert(minDays
== -536'895'458, "Wrong calculation of minDays or K.");
275 static_assert(maxDays
== 536'846'365, "Wrong calculation of maxDays or K.");
277 // These are hard limits for the algorithm and far greater than the
278 // range [-8.64e15, 8.64e15] required by ES2024 21.4.1.1. Callers must
279 // ensure this function is not called out of the hard limits and,
280 // preferably, not outside the ES2024 limits.
281 constexpr int64_t minTime
= minDays
* int64_t(msPerDay
);
282 [[maybe_unused
]] constexpr int64_t maxTime
= maxDays
* int64_t(msPerDay
);
283 MOZ_ASSERT(double(minTime
) <= t
&& t
<= double(maxTime
));
284 const int64_t time
= int64_t(t
);
286 // Since time is the number of milliseconds since the epoch, 1970/Jan/01,
287 // one might expect N_U = time / uint64_t(msPerDay) is the number of days
288 // since epoch. There's a catch tough. Consider, for instance, half day
289 // before the epoch, that is, t = -0.5 * msPerDay. This falls on
290 // 1969/Dec/31 and should correspond to N_U = -1 but the above gives
291 // N_U = 0. Indeed, t / msPerDay = -0.5 but integer division truncates
292 // towards 0 (C++ [expr.mul]/4) and not towards -infinity as needed, so
293 // that time / uint64_t(msPerDay) = 0. To workaround this issue we perform
294 // the division on positive operands so that truncations towards 0 and
295 // -infinity are equivalent. For this, set u = time - minTime, which is
296 // positive as asserted above. Then, perform the division u / msPerDay and
297 // to the result add minTime / msPerDay = minDays to cancel the
298 // subtraction of minTime.
299 const uint64_t u
= uint64_t(time
- minTime
);
300 const int32_t N_U
= int32_t(u
/ uint64_t(msPerDay
)) + minDays
;
301 MOZ_ASSERT(minDays
<= N_U
&& N_U
<= maxDays
);
303 const uint32_t N
= uint32_t(N_U
) + K
;
305 // Some magic numbers have been explained above but, unfortunately,
306 // others with no precise interpretation do appear. They mostly come
307 // from numerical approximations of Euclidean affine functions (see [1])
308 // which are faster for the CPU to calculate. Unfortunately, no compiler
309 // can do these optimizations.
311 // Century C and year of the century N_C:
312 const uint32_t N_1
= 4 * N
+ 3;
313 const uint32_t C
= N_1
/ 146097;
314 const uint32_t N_C
= N_1
% 146097 / 4;
316 // Year of the century Z and day of the year N_Y:
317 const uint32_t N_2
= 4 * N_C
+ 3;
318 const uint64_t P_2
= uint64_t(2939745) * N_2
;
319 const uint32_t Z
= uint32_t(P_2
/ 4294967296);
320 const uint32_t N_Y
= uint32_t(P_2
% 4294967296) / 2939745 / 4;
323 const uint32_t Y
= 100 * C
+ Z
;
325 // Month M and day D.
326 // The expression for N_3 has been adapted to account for the difference
327 // between month numbers in ES5 15.9.1.4 (from 0 to 11) and [1] (from 1
328 // to 12). This is done by subtracting 65536 from the original
329 // expression so that M decreases by 1 and so does M_G further down.
330 const uint32_t N_3
= 2141 * N_Y
+ 132377; // 132377 = 197913 - 65536
331 const uint32_t M
= N_3
/ 65536;
332 const uint32_t D
= N_3
% 65536 / 2141;
334 // Map from Computational to Gregorian calendar. Notice also the year
335 // correction and the type change and that Jan/01 is day 306 of the
336 // Computational calendar, cf. Table 1. [1]
337 constexpr uint32_t daysFromMar01ToJan01
= 306;
338 const uint32_t J
= N_Y
>= daysFromMar01ToJan01
;
339 const int32_t Y_G
= int32_t((Y
- L
) + J
);
340 const uint32_t M_G
= J
? M
- 12 : M
;
341 const uint32_t D_G
= D
+ 1;
343 return {Y_G
, M_G
, D_G
};
346 static double YearFromTime(double t
) {
347 if (!std::isfinite(t
)) {
350 auto const year
= ToYearMonthDay(t
).year
;
355 static double DayWithinYear(double t
, double year
) {
356 MOZ_ASSERT_IF(std::isfinite(t
), YearFromTime(t
) == year
);
357 return Day(t
) - DayFromYear(year
);
360 static double MonthFromTime(double t
) {
361 if (!std::isfinite(t
)) {
364 const auto month
= ToYearMonthDay(t
).month
;
365 return double(month
);
369 static double DateFromTime(double t
) {
370 if (!std::isfinite(t
)) {
373 const auto day
= ToYearMonthDay(t
).day
;
378 static int WeekDay(double t
) {
380 * We can't assert TimeClip(t) == t because we call this function with
381 * local times, which can be offset outside TimeClip's permitted range.
383 MOZ_ASSERT(ToInteger(t
) == t
);
384 int result
= (int(Day(t
)) + 4) % 7;
391 static inline int DayFromMonth(int month
, bool isLeapYear
) {
393 * The following array contains the day of year for the first day of
394 * each month, where index 0 is January, and day 0 is January 1.
396 static const int firstDayOfMonth
[2][13] = {
397 {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
398 {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}};
400 MOZ_ASSERT(0 <= month
&& month
<= 12);
401 return firstDayOfMonth
[isLeapYear
][month
];
404 template <typename T
>
405 static inline int DayFromMonth(T month
, bool isLeapYear
) = delete;
407 /* ES5 15.9.1.12 (out of order to accommodate DaylightSavingTA). */
408 static double MakeDay(double year
, double month
, double date
) {
410 if (!std::isfinite(year
) || !std::isfinite(month
) || !std::isfinite(date
)) {
415 double y
= ToInteger(year
);
416 double m
= ToInteger(month
);
417 double dt
= ToInteger(date
);
420 double ym
= y
+ floor(m
/ 12);
423 int mn
= int(PositiveModulo(m
, 12));
426 bool leap
= IsLeapYear(ym
);
428 double yearday
= floor(TimeFromYear(ym
) / msPerDay
);
429 double monthday
= DayFromMonth(mn
, leap
);
431 return yearday
+ monthday
+ dt
- 1;
434 /* ES5 15.9.1.13 (out of order to accommodate DaylightSavingTA). */
435 static inline double MakeDate(double day
, double time
) {
437 if (!std::isfinite(day
) || !std::isfinite(time
)) {
442 return day
* msPerDay
+ time
;
445 JS_PUBLIC_API
double JS::MakeDate(double year
, unsigned month
, unsigned day
) {
446 MOZ_ASSERT(month
<= 11);
447 MOZ_ASSERT(day
>= 1 && day
<= 31);
449 return ::MakeDate(MakeDay(year
, month
, day
), 0);
452 JS_PUBLIC_API
double JS::MakeDate(double year
, unsigned month
, unsigned day
,
454 MOZ_ASSERT(month
<= 11);
455 MOZ_ASSERT(day
>= 1 && day
<= 31);
457 return ::MakeDate(MakeDay(year
, month
, day
), time
);
460 JS_PUBLIC_API
double JS::YearFromTime(double time
) {
461 const auto clipped
= TimeClip(time
);
462 if (!clipped
.isValid()) {
465 return ::YearFromTime(clipped
.toDouble());
468 JS_PUBLIC_API
double JS::MonthFromTime(double time
) {
469 const auto clipped
= TimeClip(time
);
470 if (!clipped
.isValid()) {
473 return ::MonthFromTime(clipped
.toDouble());
476 JS_PUBLIC_API
double JS::DayFromTime(double time
) {
477 const auto clipped
= TimeClip(time
);
478 if (!clipped
.isValid()) {
481 return DateFromTime(clipped
.toDouble());
484 JS_PUBLIC_API
double JS::DayFromYear(double year
) {
485 return ::DayFromYear(year
);
488 JS_PUBLIC_API
double JS::DayWithinYear(double time
, double year
) {
489 const auto clipped
= TimeClip(time
);
490 if (!clipped
.isValid()) {
493 return ::DayWithinYear(clipped
.toDouble(), year
);
496 JS_PUBLIC_API
void JS::SetReduceMicrosecondTimePrecisionCallback(
497 JS::ReduceMicrosecondTimePrecisionCallback callback
) {
498 sReduceMicrosecondTimePrecisionCallback
= callback
;
501 JS_PUBLIC_API
void JS::SetTimeResolutionUsec(uint32_t resolution
, bool jitter
) {
502 sResolutionUsec
= resolution
;
507 // ES2019 draft rev 0ceb728a1adbffe42b26972a6541fd7f398b1557
508 // 20.3.1.7 LocalTZA ( t, isUTC )
509 double DateTimeHelper::localTZA(DateTimeInfo::ForceUTC forceUTC
, double t
,
510 DateTimeInfo::TimeZoneOffset offset
) {
511 MOZ_ASSERT(std::isfinite(t
));
513 int64_t milliseconds
= static_cast<int64_t>(t
);
514 int32_t offsetMilliseconds
=
515 DateTimeInfo::getOffsetMilliseconds(forceUTC
, milliseconds
, offset
);
516 return static_cast<double>(offsetMilliseconds
);
519 // ES2019 draft rev 0ceb728a1adbffe42b26972a6541fd7f398b1557
520 // 20.3.1.8 LocalTime ( t )
521 double DateTimeHelper::localTime(DateTimeInfo::ForceUTC forceUTC
, double t
) {
522 if (!std::isfinite(t
)) {
526 MOZ_ASSERT(StartOfTime
<= t
&& t
<= EndOfTime
);
527 return t
+ localTZA(forceUTC
, t
, DateTimeInfo::TimeZoneOffset::UTC
);
530 // ES2019 draft rev 0ceb728a1adbffe42b26972a6541fd7f398b1557
531 // 20.3.1.9 UTC ( t )
532 double DateTimeHelper::UTC(DateTimeInfo::ForceUTC forceUTC
, double t
) {
533 if (!std::isfinite(t
)) {
537 if (t
< (StartOfTime
- msPerDay
) || t
> (EndOfTime
+ msPerDay
)) {
541 return t
- localTZA(forceUTC
, t
, DateTimeInfo::TimeZoneOffset::Local
);
545 * Find a year for which any given date will fall on the same weekday.
547 * This function should be used with caution when used other than
548 * for determining DST; it hasn't been proven not to produce an
549 * incorrect year for times near year boundaries.
551 int DateTimeHelper::equivalentYearForDST(int year
) {
553 * Years and leap years on which Jan 1 is a Sunday, Monday, etc.
555 * yearStartingWith[0][i] is an example non-leap year where
556 * Jan 1 appears on Sunday (i == 0), Monday (i == 1), etc.
558 * yearStartingWith[1][i] is an example leap year where
559 * Jan 1 appears on Sunday (i == 0), Monday (i == 1), etc.
561 * Keep two different mappings, one for past years (< 1970), and a
562 * different one for future years (> 2037).
564 static const int pastYearStartingWith
[2][7] = {
565 {1978, 1973, 1974, 1975, 1981, 1971, 1977},
566 {1984, 1996, 1980, 1992, 1976, 1988, 1972}};
567 static const int futureYearStartingWith
[2][7] = {
568 {2034, 2035, 2030, 2031, 2037, 2027, 2033},
569 {2012, 2024, 2036, 2020, 2032, 2016, 2028}};
571 int day
= int(DayFromYear(year
) + 4) % 7;
576 const auto& yearStartingWith
=
577 year
< 1970 ? pastYearStartingWith
: futureYearStartingWith
;
578 return yearStartingWith
[IsLeapYear(year
)][day
];
581 // Return true if |t| is representable as a 32-bit time_t variable, that means
582 // the year is in [1970, 2038).
583 bool DateTimeHelper::isRepresentableAsTime32(double t
) {
584 return 0.0 <= t
&& t
< 2145916800000.0;
588 double DateTimeHelper::daylightSavingTA(DateTimeInfo::ForceUTC forceUTC
,
590 if (!std::isfinite(t
)) {
595 * If earlier than 1970 or after 2038, potentially beyond the ken of
596 * many OSes, map it to an equivalent year before asking.
598 if (!isRepresentableAsTime32(t
)) {
599 int year
= equivalentYearForDST(int(YearFromTime(t
)));
600 double day
= MakeDay(year
, MonthFromTime(t
), DateFromTime(t
));
601 t
= MakeDate(day
, TimeWithinDay(t
));
604 int64_t utcMilliseconds
= static_cast<int64_t>(t
);
605 int32_t offsetMilliseconds
=
606 DateTimeInfo::getDSTOffsetMilliseconds(forceUTC
, utcMilliseconds
);
607 return static_cast<double>(offsetMilliseconds
);
610 double DateTimeHelper::adjustTime(DateTimeInfo::ForceUTC forceUTC
,
612 double localTZA
= DateTimeInfo::localTZA(forceUTC
);
613 double t
= daylightSavingTA(forceUTC
, date
) + localTZA
;
614 t
= (localTZA
>= 0) ? fmod(t
, msPerDay
) : -fmod(msPerDay
- t
, msPerDay
);
619 double DateTimeHelper::localTime(DateTimeInfo::ForceUTC forceUTC
, double t
) {
620 return t
+ adjustTime(forceUTC
, t
);
623 double DateTimeHelper::UTC(DateTimeInfo::ForceUTC forceUTC
, double t
) {
624 // Following the ES2017 specification creates undesirable results at DST
625 // transitions. For example when transitioning from PST to PDT,
626 // |new Date(2016,2,13,2,0,0).toTimeString()| returns the string value
627 // "01:00:00 GMT-0800 (PST)" instead of "03:00:00 GMT-0700 (PDT)". Follow
628 // V8 and subtract one hour before computing the offset.
629 // Spec bug: https://bugs.ecmascript.org/show_bug.cgi?id=4007
632 adjustTime(forceUTC
, t
- DateTimeInfo::localTZA(forceUTC
) - msPerHour
);
634 #endif /* JS_HAS_INTL_API */
636 static double LocalTime(DateTimeInfo::ForceUTC forceUTC
, double t
) {
637 return DateTimeHelper::localTime(forceUTC
, t
);
640 static double UTC(DateTimeInfo::ForceUTC forceUTC
, double t
) {
641 return DateTimeHelper::UTC(forceUTC
, t
);
645 static double HourFromTime(double t
) {
646 return PositiveModulo(floor(t
/ msPerHour
), HoursPerDay
);
649 static double MinFromTime(double t
) {
650 return PositiveModulo(floor(t
/ msPerMinute
), MinutesPerHour
);
653 static double SecFromTime(double t
) {
654 return PositiveModulo(floor(t
/ msPerSecond
), SecondsPerMinute
);
657 static double msFromTime(double t
) { return PositiveModulo(t
, msPerSecond
); }
660 static double MakeTime(double hour
, double min
, double sec
, double ms
) {
662 if (!std::isfinite(hour
) || !std::isfinite(min
) || !std::isfinite(sec
) ||
663 !std::isfinite(ms
)) {
668 double h
= ToInteger(hour
);
671 double m
= ToInteger(min
);
674 double s
= ToInteger(sec
);
677 double milli
= ToInteger(ms
);
680 return h
* msPerHour
+ m
* msPerMinute
+ s
* msPerSecond
+ milli
;
684 * end of ECMA 'support' functions
687 // ES2017 draft rev (TODO: Add git hash when PR 642 is merged.)
689 // Date.UTC(year [, month [, date [, hours [, minutes [, seconds [, ms]]]]]])
690 static bool date_UTC(JSContext
* cx
, unsigned argc
, Value
* vp
) {
691 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date", "UTC");
692 CallArgs args
= CallArgsFromVp(argc
, vp
);
696 if (!ToNumber(cx
, args
.get(0), &y
)) {
702 if (args
.length() >= 2) {
703 if (!ToNumber(cx
, args
[1], &m
)) {
712 if (args
.length() >= 3) {
713 if (!ToNumber(cx
, args
[2], &dt
)) {
722 if (args
.length() >= 4) {
723 if (!ToNumber(cx
, args
[3], &h
)) {
732 if (args
.length() >= 5) {
733 if (!ToNumber(cx
, args
[4], &min
)) {
742 if (args
.length() >= 6) {
743 if (!ToNumber(cx
, args
[5], &s
)) {
752 if (args
.length() >= 7) {
753 if (!ToNumber(cx
, args
[6], &milli
)) {
762 if (!std::isnan(y
)) {
763 double yint
= ToInteger(y
);
764 if (0 <= yint
&& yint
<= 99) {
771 TimeClip(MakeDate(MakeDay(yr
, m
, dt
), MakeTime(h
, min
, s
, milli
)));
772 args
.rval().set(TimeValue(time
));
777 * Read and convert decimal digits from s[*i] into *result
780 * Succeed if any digits are converted. Advance *i only
781 * as digits are consumed.
783 template <typename CharT
>
784 static bool ParseDigits(size_t* result
, const CharT
* s
, size_t* i
,
788 while (*i
< limit
&& ('0' <= s
[*i
] && s
[*i
] <= '9')) {
790 *result
+= (s
[*i
] - '0');
797 * Read and convert decimal digits to the right of a decimal point,
798 * representing a fractional integer, from s[*i] into *result
801 * Succeed if any digits are converted. Advance *i only
802 * as digits are consumed.
804 template <typename CharT
>
805 static bool ParseFractional(double* result
, const CharT
* s
, size_t* i
,
810 while (*i
< limit
&& ('0' <= s
[*i
] && s
[*i
] <= '9')) {
811 *result
+= (s
[*i
] - '0') * factor
;
819 * Read and convert exactly n decimal digits from s[*i]
820 * to s[min(*i+n,limit)] into *result.
822 * Succeed if exactly n digits are converted. Advance *i only
825 template <typename CharT
>
826 static bool ParseDigitsN(size_t n
, size_t* result
, const CharT
* s
, size_t* i
,
830 if (ParseDigits(result
, s
, i
, std::min(limit
, init
+ n
))) {
831 return (*i
- init
) == n
;
839 * Read and convert n or less decimal digits from s[*i]
840 * to s[min(*i+n,limit)] into *result.
842 * Succeed only if greater than zero but less than or equal to n digits are
843 * converted. Advance *i only on success.
845 template <typename CharT
>
846 static bool ParseDigitsNOrLess(size_t n
, size_t* result
, const CharT
* s
,
847 size_t* i
, size_t limit
) {
850 if (ParseDigits(result
, s
, i
, std::min(limit
, init
+ n
))) {
851 return ((*i
- init
) > 0) && ((*i
- init
) <= n
);
858 static int DaysInMonth(int year
, int month
) {
859 bool leap
= IsLeapYear(year
);
860 int result
= int(DayFromMonth(month
, leap
) - DayFromMonth(month
- 1, leap
));
865 * Parse a string according to the formats specified in section 20.3.1.16
866 * of the ECMAScript standard. These formats are based upon a simplification
867 * of the ISO 8601 Extended Format. As per the spec omitted month and day
868 * values are defaulted to '01', omitted HH:mm:ss values are defaulted to '00'
869 * and an omitted sss field is defaulted to '000'.
871 * For cross compatibility we allow the following extensions.
875 * Standalone time part:
876 * Any of the time formats below can be parsed without a date part.
877 * E.g. "T19:00:00Z" will parse successfully. The date part will then
878 * default to 1970-01-01.
880 * 'T' from the time part may be replaced with a space character:
881 * "1970-01-01 12:00:00Z" will parse successfully. Note that only a single
882 * space is permitted and this is not permitted in the standalone
885 * One or more decimal digits for milliseconds:
886 * The specification requires exactly three decimal digits for
887 * the fractional part but we allow for one or more digits.
889 * Time zone specifier without ':':
890 * We allow the time zone to be specified without a ':' character.
891 * E.g. "T19:00:00+0700" is equivalent to "T19:00:00+07:00".
893 * One or two digits for months, days, hours, minutes and seconds:
894 * The specification requires exactly two decimal digits for the fields
895 * above. We allow for one or two decimal digits. I.e. "1970-1-1" is
896 * equivalent to "1970-01-01".
904 * YYYY-MM (eg 1997-07)
907 * YYYY-MM-DD (eg 1997-07-16)
912 * Thh:mmTZD (eg T19:20+01:00)
914 * Hours, minutes and seconds:
915 * Thh:mm:ssTZD (eg T19:20:30+01:00)
917 * Hours, minutes, seconds and a decimal fraction of a second:
918 * Thh:mm:ss.sTZD (eg T19:20:30.45+01:00)
922 * YYYY = four-digit year or six digit year as +YYYYYY or -YYYYYY
923 * MM = one or two-digit month (01=January, etc.)
924 * DD = one or two-digit day of month (01 through 31)
925 * hh = one or two digits of hour (00 through 23) (am/pm NOT allowed)
926 * mm = one or two digits of minute (00 through 59)
927 * ss = one or two digits of second (00 through 59)
928 * sss = one or more digits representing a decimal fraction of a second
929 * TZD = time zone designator (Z or +hh:mm or -hh:mm or missing for local)
931 template <typename CharT
>
932 static bool ParseISOStyleDate(DateTimeInfo::ForceUTC forceUTC
, const CharT
* s
,
933 size_t length
, ClippedTime
* result
) {
945 bool isLocalTime
= false;
948 bool isPermissive
= false;
949 bool isStrict
= false;
951 #define PEEK(ch) (i < length && s[i] == ch)
954 if (i >= length || s[i] != ch) { \
960 #define DONE_DATE_UNLESS(ch) \
961 if (i >= length || s[i] != ch) { \
967 #define DONE_UNLESS(ch) \
968 if (i >= length || s[i] != ch) { \
974 #define NEED_NDIGITS(n, field) \
975 if (!ParseDigitsN(n, &field, s, &i, length)) { \
979 #define NEED_NDIGITS_OR_LESS(n, field) \
981 if (!ParseDigitsNOrLess(n, &field, s, &i, length)) { \
984 if (i < pre + (n)) { \
988 isPermissive = true; \
992 if (PEEK('+') || PEEK('-')) {
997 NEED_NDIGITS(6, year
);
999 // https://tc39.es/ecma262/#sec-expanded-years
1000 // -000000 is not a valid expanded year.
1001 if (year
== 0 && dateMul
== -1) {
1005 NEED_NDIGITS(4, year
);
1007 DONE_DATE_UNLESS('-');
1008 NEED_NDIGITS_OR_LESS(2, month
);
1009 DONE_DATE_UNLESS('-');
1010 NEED_NDIGITS_OR_LESS(2, day
);
1015 // Require standard format "[+00]1970-01-01" if a time part marker "T"
1021 } else if (PEEK(' ')) {
1027 NEED_NDIGITS_OR_LESS(2, hour
);
1029 NEED_NDIGITS_OR_LESS(2, min
);
1033 NEED_NDIGITS_OR_LESS(2, sec
);
1036 if (!ParseFractional(&frac
, s
, &i
, length
)) {
1044 } else if (PEEK('+') || PEEK('-')) {
1049 NEED_NDIGITS(2, tzHour
);
1051 * Non-standard extension to the ISO date format:
1052 * allow two digits for the time zone offset.
1054 if (i
>= length
&& !isStrict
) {
1058 * Non-standard extension to the ISO date format (permitted by ES5):
1059 * allow "-0700" as a time zone offset, not just "-07:00".
1064 NEED_NDIGITS(2, tzMin
);
1070 if (year
> 275943 // ceil(1e8/365) + 1970
1071 || (month
== 0 || month
> 12) ||
1072 (day
== 0 || day
> size_t(DaysInMonth(year
, month
))) || hour
> 24 ||
1073 ((hour
== 24) && (min
> 0 || sec
> 0 || frac
> 0)) || min
> 59 ||
1074 sec
> 59 || tzHour
> 23 || tzMin
> 59) {
1082 month
-= 1; /* convert month to 0-based */
1084 double msec
= MakeDate(MakeDay(dateMul
* double(year
), month
, day
),
1085 MakeTime(hour
, min
, sec
, frac
* 1000.0));
1088 msec
= UTC(forceUTC
, msec
);
1090 msec
-= tzMul
* (tzHour
* msPerHour
+ tzMin
* msPerMinute
);
1093 *result
= TimeClip(msec
);
1094 return NumbersAreIdentical(msec
, result
->toDouble());
1100 #undef NEED_NDIGITS_OR_LESS
1103 int FixupNonFullYear(int year
) {
1106 } else if (year
>= 50 && year
< 100) {
1112 template <typename CharT
>
1113 bool IsPrefixOfKeyword(const CharT
* s
, size_t len
, const char* keyword
) {
1114 while (len
> 0 && *keyword
) {
1115 MOZ_ASSERT(IsAsciiAlpha(*s
));
1116 MOZ_ASSERT(IsAsciiLowercaseAlpha(*keyword
));
1118 if (unicode::ToLowerCase(static_cast<Latin1Char
>(*s
)) != *keyword
) {
1129 static constexpr const char* const months_names
[] = {
1130 "january", "february", "march", "april", "may", "june",
1131 "july", "august", "september", "october", "november", "december",
1134 // Try to parse the following date format:
1140 // Returns true and fills all out parameters when successfully parsed
1141 // dashed-date. Otherwise returns false and leaves out parameters untouched.
1142 template <typename CharT
>
1143 static bool TryParseDashedDatePrefix(const CharT
* s
, size_t length
,
1144 size_t* indexOut
, int* yearOut
,
1145 int* monOut
, int* mdayOut
) {
1149 if (!ParseDigitsNOrLess(4, &mday
, s
, &i
, length
)) {
1152 size_t mdayDigits
= i
;
1154 if (i
>= length
|| s
[i
] != '-') {
1160 for (; i
< length
; i
++) {
1161 if (!IsAsciiAlpha(s
[i
])) {
1166 // The shortest month is "may".
1167 static constexpr size_t ShortestMonthNameLength
= 3;
1168 if (i
- start
< ShortestMonthNameLength
) {
1173 for (size_t m
= 0; m
< std::size(months_names
); ++m
) {
1174 // If the field isn't a prefix of the month (an exact match is *not*
1175 // required), try the next one.
1176 if (IsPrefixOfKeyword(s
+ start
, i
- start
, months_names
[m
])) {
1177 // Use numeric value.
1186 if (i
>= length
|| s
[i
] != '-') {
1193 if (!ParseDigitsNOrLess(4, &year
, s
, &i
, length
)) {
1196 size_t yearDigits
= i
- pre
;
1198 if (i
< length
&& IsAsciiDigit(s
[i
])) {
1202 // Swap the mday and year iff the year wasn't specified in full.
1203 if (mday
> 31 && year
<= 31 && yearDigits
< 4) {
1204 std::swap(mday
, year
);
1205 std::swap(mdayDigits
, yearDigits
);
1208 if (mday
> 31 || mdayDigits
> 2) {
1212 if (yearDigits
< 4) {
1213 year
= FixupNonFullYear(year
);
1223 struct CharsAndAction
{
1228 static constexpr CharsAndAction keywords
[] = {
1254 // Time zone abbreviations.
1255 { "gmt", 10000 + 0 },
1257 { "ut", 10000 + 0 },
1258 { "utc", 10000 + 0 },
1259 { "est", 10000 + 5 * 60 },
1260 { "edt", 10000 + 4 * 60 },
1261 { "cst", 10000 + 6 * 60 },
1262 { "cdt", 10000 + 5 * 60 },
1263 { "mst", 10000 + 7 * 60 },
1264 { "mdt", 10000 + 6 * 60 },
1265 { "pst", 10000 + 8 * 60 },
1266 { "pdt", 10000 + 7 * 60 },
1271 constexpr size_t MinKeywordLength(const CharsAndAction (&keywords
)[N
]) {
1272 size_t min
= size_t(-1);
1273 for (const CharsAndAction
& keyword
: keywords
) {
1274 min
= std::min(min
, std::char_traits
<char>::length(keyword
.chars
));
1279 template <typename CharT
>
1280 static bool ParseDate(DateTimeInfo::ForceUTC forceUTC
, const CharT
* s
,
1281 size_t length
, ClippedTime
* result
) {
1282 if (ParseISOStyleDate(forceUTC
, s
, length
, result
)) {
1298 // One of '+', '-', ':', '/', or 0 (the default value).
1301 bool seenPlusMinus
= false;
1302 bool seenMonthName
= false;
1303 bool seenFullYear
= false;
1304 bool negativeYear
= false;
1308 // Try parsing the leading dashed-date.
1310 // If successfully parsed, index is updated to the end of the date part,
1311 // and year, mon, mday are set to the date.
1312 // Continue parsing optional time + tzOffset parts.
1314 // Otherwise, this is no-op.
1316 TryParseDashedDatePrefix(s
, length
, &index
, &year
, &mon
, &mday
);
1318 while (index
< length
) {
1322 // Normalize U+202F (NARROW NO-BREAK SPACE). This character appears between
1323 // the AM/PM markers for |date.toLocaleString("en")|. We have to normalize
1324 // it for backward compatibility reasons.
1329 // Spaces, ASCII control characters, periods, and commas are simply ignored.
1330 if (c
<= ' ' || c
== '.' || c
== ',') {
1334 // Parse delimiter characters. Save them to the side for future use.
1335 if (c
== '/' || c
== ':' || c
== '+') {
1340 // Dashes are delimiters if they're immediately followed by a number field.
1341 // If they're not followed by a number field, they're simply ignored.
1343 if (index
< length
&& IsAsciiDigit(s
[index
])) {
1349 // Skip over comments -- text inside matching parentheses. (Comments
1350 // themselves may contain comments as long as all the parentheses properly
1351 // match up. And apparently comments, including nested ones, may validly be
1352 // terminated by end of input...)
1355 while (index
< length
) {
1360 } else if (c
== ')') {
1369 // Parse a number field.
1370 if (IsAsciiDigit(c
)) {
1371 size_t partStart
= index
- 1;
1372 uint32_t u
= c
- '0';
1373 while (index
< length
) {
1375 if (!IsAsciiDigit(c
)) {
1378 u
= u
* 10 + (c
- '0');
1381 size_t partLength
= index
- partStart
;
1383 // See above for why we have to normalize U+202F.
1391 * Allow TZA before the year, so 'Wed Nov 05 21:49:11 GMT-0800 1997'
1394 * Uses of seenPlusMinus allow ':' in TZA, so Java no-timezone style
1395 * of GMT+4:30 works.
1398 if (prevc
== '-' && (tzOffset
!= 0 || seenPlusMinus
) && partLength
>= 4 &&
1400 // Parse as a negative, possibly zero-padded year if
1401 // 1. the preceding character is '-',
1402 // 2. the TZA is not 'GMT' (tested by |tzOffset != 0|),
1403 // 3. or a TZA was already parsed |seenPlusMinus == true|,
1404 // 4. the part length is at least 4 (to parse '-08' as a TZA),
1405 // 5. and we did not already parse a year |year < 0|.
1407 seenFullYear
= true;
1408 negativeYear
= true;
1409 } else if ((prevc
== '+' || prevc
== '-') /* && year>=0 */) {
1410 /* Make ':' case below change tzOffset. */
1411 seenPlusMinus
= true;
1414 if (n
< 24 && partLength
<= 2) {
1415 n
= n
* 60; /* EG. "GMT-3" */
1417 n
= n
% 100 + n
/ 100 * 60; /* eg "GMT-0430" */
1420 if (prevc
== '+') /* plus means east of GMT */
1423 // Reject if not preceded by 'GMT' or if a time zone offset
1424 // was already parsed.
1425 if (tzOffset
!= 0 && tzOffset
!= -1) {
1430 } else if (prevc
== '/' && mon
>= 0 && mday
>= 0 && year
< 0) {
1431 if (c
<= ' ' || c
== ',' || c
== '/' || index
>= length
) {
1436 } else if (c
== ':') {
1439 } else if (min
< 0) {
1444 } else if (c
== '/') {
1446 * Until it is determined that mon is the actual month, keep
1447 * it as 1-based rather than 0-based.
1451 } else if (mday
< 0) {
1456 } else if (index
< length
&& c
!= ',' && c
> ' ' && c
!= '-' &&
1458 // Allow zulu time e.g. "09/26/1995 16:00Z"
1459 !(hour
!= -1 && strchr("Zz", c
)) &&
1460 // Allow '.' after day of month i.e. DD.Mon.YYYY/Mon.DD.YYYY,
1461 // or after year/month in YYYY/MM/DD
1462 (c
!= '.' || mday
!= -1) &&
1463 // Allow month or AM/PM directly after a number
1464 (!IsAsciiAlpha(c
) ||
1465 (mon
!= -1 && !(strchr("AaPp", c
) && index
< length
- 1 &&
1466 strchr("Mm", s
[index
+ 1]))))) {
1468 } else if (seenPlusMinus
&& n
< 60) { /* handle GMT-3:30 */
1474 } else if (hour
>= 0 && min
< 0) {
1476 } else if (prevc
== ':' && min
>= 0 && sec
< 0) {
1478 } else if (mon
< 0) {
1480 } else if (mon
>= 0 && mday
< 0) {
1482 } else if (mon
>= 0 && mday
>= 0 && year
< 0) {
1484 seenFullYear
= partLength
>= 4;
1493 // Parse fields that are words: ASCII letters spelling out in English AM/PM,
1494 // day of week, month, or an extremely limited set of legacy time zone
1496 if (IsAsciiAlpha(c
)) {
1497 size_t start
= index
- 1;
1498 while (index
< length
) {
1500 if (!IsAsciiAlpha(c
)) {
1506 // There must be at least as many letters as in the shortest keyword.
1507 constexpr size_t MinLength
= MinKeywordLength(keywords
);
1508 if (index
- start
< MinLength
) {
1512 size_t k
= std::size(keywords
);
1514 const CharsAndAction
& keyword
= keywords
[k
];
1516 // If the field isn't a prefix of the keyword (an exact match is *not*
1517 // required), try the next one.
1518 if (!IsPrefixOfKeyword(s
+ start
, index
- start
, keyword
.chars
)) {
1522 int action
= keyword
.action
;
1524 // Completely ignore days of the week, and don't derive any semantics
1530 // Perform action tests from smallest action values to largest.
1532 // Adjust a previously-specified hour for AM/PM accordingly (taking care
1533 // to treat 12:xx AM as 00:xx, 12:xx PM as 12:xx).
1535 MOZ_ASSERT(action
== -1 || action
== -2);
1536 if (hour
> 12 || hour
< 0) {
1540 if (action
== -1 && hour
== 12) {
1542 } else if (action
== -2 && hour
!= 12) {
1549 // Record a month if none has been seen before. (Note that some numbers
1550 // are initially treated as months; if a numeric field has already been
1551 // interpreted as a month, store that value to the actually appropriate
1552 // date component and set the month here.
1554 if (seenMonthName
) {
1558 seenMonthName
= true;
1562 } else if (mday
< 0) {
1565 } else if (year
< 0) {
1567 // If the date is of the form f l month, then when month is
1568 // reached we have f in mon and l in mday. In order to be
1569 // consistent with the f month l and month f l forms, we need to
1570 // swap so that f is in mday and l is in year.
1584 // Finally, record a time zone offset.
1585 MOZ_ASSERT(action
>= 10000);
1586 tzOffset
= action
- 10000;
1590 if (k
== size_t(-1)) {
1598 // Any other character fails to parse.
1602 if (year
< 0 || mon
< 0 || mday
< 0) {
1606 if (!isDashedDate
) {
1607 // NOTE: TryParseDashedDatePrefix already handles the following fixup.
1610 * Case 1. The input string contains an English month name.
1611 * The form of the string can be month f l, or f month l, or
1612 * f l month which each evaluate to the same date.
1613 * If f and l are both greater than or equal to 100 the date
1616 * The year is taken to be either l, f if f > 31, or whichever
1619 * Case 2. The input string is of the form "f/m/l" where f, m and l are
1620 * integers, e.g. 7/16/45. mon, mday and year values are adjusted
1621 * to achieve Chrome compatibility.
1623 * a. If 0 < f <= 12 and 0 < l <= 31, f/m/l is interpreted as
1625 * b. If 31 < f and 0 < m <= 12 and 0 < l <= 31 f/m/l is
1626 * interpreted as year/month/day
1628 if (seenMonthName
) {
1629 if (mday
>= 100 && mon
>= 100) {
1633 if (year
> 0 && (mday
== 0 || mday
> 31) && !seenFullYear
) {
1639 if (mday
<= 0 || mday
> 31) {
1643 } else if (0 < mon
&& mon
<= 12 && 0 < mday
&& mday
<= 31) {
1644 /* (a) month/day/year */
1646 /* (b) year/month/day */
1647 if (mon
> 31 && mday
<= 12 && year
<= 31 && !seenFullYear
) {
1657 // If the year is greater than or equal to 50 and less than 100, it is
1658 // considered to be the number of years after 1900. If the year is less
1659 // than 50 it is considered to be the number of years after 2000,
1660 // otherwise it is considered to be the number of years after 0.
1661 if (!seenFullYear
) {
1662 year
= FixupNonFullYear(year
);
1670 mon
-= 1; /* convert month to 0-based */
1681 double msec
= MakeDate(MakeDay(year
, mon
, mday
), MakeTime(hour
, min
, sec
, 0));
1683 if (tzOffset
== -1) { /* no time zone specified, have to use local */
1684 msec
= UTC(forceUTC
, msec
);
1686 msec
+= tzOffset
* msPerMinute
;
1689 *result
= TimeClip(msec
);
1693 static bool ParseDate(DateTimeInfo::ForceUTC forceUTC
, JSLinearString
* s
,
1694 ClippedTime
* result
) {
1695 AutoCheckCannotGC nogc
;
1696 return s
->hasLatin1Chars()
1697 ? ParseDate(forceUTC
, s
->latin1Chars(nogc
), s
->length(), result
)
1698 : ParseDate(forceUTC
, s
->twoByteChars(nogc
), s
->length(), result
);
1701 static bool date_parse(JSContext
* cx
, unsigned argc
, Value
* vp
) {
1702 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date", "parse");
1703 CallArgs args
= CallArgsFromVp(argc
, vp
);
1704 if (args
.length() == 0) {
1705 args
.rval().setNaN();
1709 JSString
* str
= ToString
<CanGC
>(cx
, args
[0]);
1714 JSLinearString
* linearStr
= str
->ensureLinear(cx
);
1720 if (!ParseDate(ForceUTC(cx
->realm()), linearStr
, &result
)) {
1721 args
.rval().setNaN();
1725 args
.rval().set(TimeValue(result
));
1729 static ClippedTime
NowAsMillis(JSContext
* cx
) {
1730 if (js::SupportDifferentialTesting()) {
1734 double now
= PRMJ_Now();
1735 bool clampAndJitter
= cx
->realm()->behaviors().clampAndJitterTime();
1736 if (clampAndJitter
&& sReduceMicrosecondTimePrecisionCallback
) {
1737 now
= sReduceMicrosecondTimePrecisionCallback(now
, cx
);
1738 } else if (clampAndJitter
&& sResolutionUsec
) {
1739 double clamped
= floor(now
/ sResolutionUsec
) * sResolutionUsec
;
1742 // Calculate a random midpoint for jittering. In the browser, we are
1743 // adversarial: Web Content may try to calculate the midpoint themselves
1744 // and use that to bypass it's security. In the JS Shell, we are not
1745 // adversarial, we want to jitter the time to recreate the operating
1746 // environment, but we do not concern ourselves with trying to prevent an
1747 // attacker from calculating the midpoint themselves. So we use a very
1748 // simple, very fast CRC with a hardcoded seed.
1750 uint64_t midpoint
= BitwiseCast
<uint64_t>(clamped
);
1751 midpoint
^= 0x0F00DD1E2BAD2DED; // XOR in a 'secret'
1752 // MurmurHash3 internal component from
1753 // https://searchfox.org/mozilla-central/rev/61d400da1c692453c2dc2c1cf37b616ce13dea5b/dom/canvas/MurmurHash3.cpp#85
1754 midpoint
^= midpoint
>> 33;
1755 midpoint
*= uint64_t{0xFF51AFD7ED558CCD};
1756 midpoint
^= midpoint
>> 33;
1757 midpoint
*= uint64_t{0xC4CEB9FE1A85EC53};
1758 midpoint
^= midpoint
>> 33;
1759 midpoint
%= sResolutionUsec
;
1761 if (now
> clamped
+ midpoint
) { // We're jittering up to the next step
1762 now
= clamped
+ sResolutionUsec
;
1763 } else { // We're staying at the clamped value
1766 } else { // No jitter, only clamping
1771 return TimeClip(now
/ PRMJ_USEC_PER_MSEC
);
1774 JS::ClippedTime
js::DateNow(JSContext
* cx
) { return NowAsMillis(cx
); }
1776 bool js::date_now(JSContext
* cx
, unsigned argc
, Value
* vp
) {
1777 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date", "now");
1778 CallArgs args
= CallArgsFromVp(argc
, vp
);
1779 args
.rval().set(TimeValue(NowAsMillis(cx
)));
1783 DateTimeInfo::ForceUTC
DateObject::forceUTC() const {
1784 return ForceUTC(realm());
1787 void DateObject::setUTCTime(ClippedTime t
) {
1788 for (size_t ind
= COMPONENTS_START_SLOT
; ind
< RESERVED_SLOTS
; ind
++) {
1789 setReservedSlot(ind
, UndefinedValue());
1792 setFixedSlot(UTC_TIME_SLOT
, TimeValue(t
));
1795 void DateObject::setUTCTime(ClippedTime t
, MutableHandleValue vp
) {
1797 vp
.set(TimeValue(t
));
1800 void DateObject::fillLocalTimeSlots() {
1801 const int32_t utcTZOffset
=
1802 DateTimeInfo::utcToLocalStandardOffsetSeconds(forceUTC());
1804 /* Check if the cache is already populated. */
1805 if (!getReservedSlot(LOCAL_TIME_SLOT
).isUndefined() &&
1806 getReservedSlot(UTC_TIME_ZONE_OFFSET_SLOT
).toInt32() == utcTZOffset
) {
1810 /* Remember time zone used to generate the local cache. */
1811 setReservedSlot(UTC_TIME_ZONE_OFFSET_SLOT
, Int32Value(utcTZOffset
));
1813 double utcTime
= UTCTime().toNumber();
1815 if (!std::isfinite(utcTime
)) {
1816 for (size_t ind
= COMPONENTS_START_SLOT
; ind
< RESERVED_SLOTS
; ind
++) {
1817 setReservedSlot(ind
, DoubleValue(utcTime
));
1822 double localTime
= LocalTime(forceUTC(), utcTime
);
1824 setReservedSlot(LOCAL_TIME_SLOT
, DoubleValue(localTime
));
1826 const auto [year
, month
, day
] = ToYearMonthDay(localTime
);
1828 setReservedSlot(LOCAL_YEAR_SLOT
, Int32Value(year
));
1829 setReservedSlot(LOCAL_MONTH_SLOT
, Int32Value(int32_t(month
)));
1830 setReservedSlot(LOCAL_DATE_SLOT
, Int32Value(int32_t(day
)));
1832 int weekday
= WeekDay(localTime
);
1833 setReservedSlot(LOCAL_DAY_SLOT
, Int32Value(weekday
));
1835 double yearStartTime
= TimeFromYear(year
);
1836 uint64_t yearTime
= uint64_t(localTime
- yearStartTime
);
1837 int32_t yearSeconds
= int32_t(yearTime
/ 1000);
1838 setReservedSlot(LOCAL_SECONDS_INTO_YEAR_SLOT
, Int32Value(yearSeconds
));
1841 MOZ_ALWAYS_INLINE
bool IsDate(HandleValue v
) {
1842 return v
.isObject() && v
.toObject().is
<DateObject
>();
1846 * See ECMA 15.9.5.4 thru 15.9.5.23
1849 static bool date_getTime(JSContext
* cx
, unsigned argc
, Value
* vp
) {
1850 CallArgs args
= CallArgsFromVp(argc
, vp
);
1852 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getTime");
1857 args
.rval().set(unwrapped
->UTCTime());
1861 static bool date_getYear(JSContext
* cx
, unsigned argc
, Value
* vp
) {
1862 CallArgs args
= CallArgsFromVp(argc
, vp
);
1864 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getYear");
1869 unwrapped
->fillLocalTimeSlots();
1871 Value yearVal
= unwrapped
->localYear();
1872 if (yearVal
.isInt32()) {
1873 /* Follow ECMA-262 to the letter, contrary to IE JScript. */
1874 int year
= yearVal
.toInt32() - 1900;
1875 args
.rval().setInt32(year
);
1877 args
.rval().set(yearVal
);
1882 static bool date_getFullYear(JSContext
* cx
, unsigned argc
, Value
* vp
) {
1883 CallArgs args
= CallArgsFromVp(argc
, vp
);
1885 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getFullYear");
1890 unwrapped
->fillLocalTimeSlots();
1891 args
.rval().set(unwrapped
->localYear());
1895 static bool date_getUTCFullYear(JSContext
* cx
, unsigned argc
, Value
* vp
) {
1896 CallArgs args
= CallArgsFromVp(argc
, vp
);
1899 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getUTCFullYear");
1904 double result
= unwrapped
->UTCTime().toNumber();
1905 if (std::isfinite(result
)) {
1906 result
= YearFromTime(result
);
1909 args
.rval().setNumber(result
);
1913 static bool date_getMonth(JSContext
* cx
, unsigned argc
, Value
* vp
) {
1914 CallArgs args
= CallArgsFromVp(argc
, vp
);
1916 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getMonth");
1921 unwrapped
->fillLocalTimeSlots();
1922 args
.rval().set(unwrapped
->localMonth());
1926 static bool date_getUTCMonth(JSContext
* cx
, unsigned argc
, Value
* vp
) {
1927 CallArgs args
= CallArgsFromVp(argc
, vp
);
1929 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getUTCMonth");
1934 double d
= unwrapped
->UTCTime().toNumber();
1935 args
.rval().setNumber(MonthFromTime(d
));
1939 static bool date_getDate(JSContext
* cx
, unsigned argc
, Value
* vp
) {
1940 CallArgs args
= CallArgsFromVp(argc
, vp
);
1942 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getDate");
1947 unwrapped
->fillLocalTimeSlots();
1949 args
.rval().set(unwrapped
->localDate());
1953 static bool date_getUTCDate(JSContext
* cx
, unsigned argc
, Value
* vp
) {
1954 CallArgs args
= CallArgsFromVp(argc
, vp
);
1956 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getUTCDate");
1961 double result
= unwrapped
->UTCTime().toNumber();
1962 if (std::isfinite(result
)) {
1963 result
= DateFromTime(result
);
1966 args
.rval().setNumber(result
);
1970 static bool date_getDay(JSContext
* cx
, unsigned argc
, Value
* vp
) {
1971 CallArgs args
= CallArgsFromVp(argc
, vp
);
1973 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getDay");
1978 unwrapped
->fillLocalTimeSlots();
1979 args
.rval().set(unwrapped
->localDay());
1983 static bool date_getUTCDay(JSContext
* cx
, unsigned argc
, Value
* vp
) {
1984 CallArgs args
= CallArgsFromVp(argc
, vp
);
1986 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getUTCDay");
1991 double result
= unwrapped
->UTCTime().toNumber();
1992 if (std::isfinite(result
)) {
1993 result
= WeekDay(result
);
1996 args
.rval().setNumber(result
);
2000 static bool date_getHours(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2001 CallArgs args
= CallArgsFromVp(argc
, vp
);
2003 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getHours");
2008 unwrapped
->fillLocalTimeSlots();
2010 // Note: localSecondsIntoYear is guaranteed to return an
2011 // int32 or NaN after the call to fillLocalTimeSlots.
2012 Value yearSeconds
= unwrapped
->localSecondsIntoYear();
2013 if (yearSeconds
.isDouble()) {
2014 MOZ_ASSERT(std::isnan(yearSeconds
.toDouble()));
2015 args
.rval().set(yearSeconds
);
2017 args
.rval().setInt32((yearSeconds
.toInt32() / int(SecondsPerHour
)) %
2023 static bool date_getUTCHours(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2024 CallArgs args
= CallArgsFromVp(argc
, vp
);
2026 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getUTCHours");
2031 double result
= unwrapped
->UTCTime().toNumber();
2032 if (std::isfinite(result
)) {
2033 result
= HourFromTime(result
);
2036 args
.rval().setNumber(result
);
2040 static bool date_getMinutes(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2041 CallArgs args
= CallArgsFromVp(argc
, vp
);
2043 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getMinutes");
2048 unwrapped
->fillLocalTimeSlots();
2050 // Note: localSecondsIntoYear is guaranteed to return an
2051 // int32 or NaN after the call to fillLocalTimeSlots.
2052 Value yearSeconds
= unwrapped
->localSecondsIntoYear();
2053 if (yearSeconds
.isDouble()) {
2054 MOZ_ASSERT(std::isnan(yearSeconds
.toDouble()));
2055 args
.rval().set(yearSeconds
);
2057 args
.rval().setInt32((yearSeconds
.toInt32() / int(SecondsPerMinute
)) %
2058 int(MinutesPerHour
));
2063 static bool date_getUTCMinutes(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2064 CallArgs args
= CallArgsFromVp(argc
, vp
);
2067 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getUTCMinutes");
2072 double result
= unwrapped
->UTCTime().toNumber();
2073 if (std::isfinite(result
)) {
2074 result
= MinFromTime(result
);
2077 args
.rval().setNumber(result
);
2081 static bool date_getSeconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2082 CallArgs args
= CallArgsFromVp(argc
, vp
);
2084 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getSeconds");
2089 unwrapped
->fillLocalTimeSlots();
2091 // Note: localSecondsIntoYear is guaranteed to return an
2092 // int32 or NaN after the call to fillLocalTimeSlots.
2093 Value yearSeconds
= unwrapped
->localSecondsIntoYear();
2094 if (yearSeconds
.isDouble()) {
2095 MOZ_ASSERT(std::isnan(yearSeconds
.toDouble()));
2096 args
.rval().set(yearSeconds
);
2098 args
.rval().setInt32(yearSeconds
.toInt32() % int(SecondsPerMinute
));
2103 static bool date_getUTCSeconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2104 CallArgs args
= CallArgsFromVp(argc
, vp
);
2107 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getUTCSeconds");
2112 double result
= unwrapped
->UTCTime().toNumber();
2113 if (std::isfinite(result
)) {
2114 result
= SecFromTime(result
);
2117 args
.rval().setNumber(result
);
2122 * Date.getMilliseconds is mapped to getUTCMilliseconds. As long as no
2123 * supported time zone has a fractional-second component, the differences in
2124 * their specifications aren't observable.
2126 * The 'tz' database explicitly does not support fractional-second time zones.
2127 * For example the Netherlands observed Amsterdam Mean Time, estimated to be
2128 * UT +00:19:32.13, from 1909 to 1937, but in tzdata AMT is defined as exactly
2132 static bool getMilliseconds(JSContext
* cx
, unsigned argc
, Value
* vp
,
2133 const char* methodName
) {
2134 CallArgs args
= CallArgsFromVp(argc
, vp
);
2136 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, methodName
);
2141 double result
= unwrapped
->UTCTime().toNumber();
2142 if (std::isfinite(result
)) {
2143 result
= msFromTime(result
);
2146 args
.rval().setNumber(result
);
2150 static bool date_getMilliseconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2151 return getMilliseconds(cx
, argc
, vp
, "getMilliseconds");
2154 static bool date_getUTCMilliseconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2155 return getMilliseconds(cx
, argc
, vp
, "getUTCMilliseconds");
2158 static bool date_getTimezoneOffset(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2159 CallArgs args
= CallArgsFromVp(argc
, vp
);
2162 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getTimezoneOffset");
2167 unwrapped
->fillLocalTimeSlots();
2169 double utctime
= unwrapped
->UTCTime().toNumber();
2170 double localtime
= unwrapped
->localTime().toDouble();
2173 * Return the time zone offset in minutes for the current locale that is
2174 * appropriate for this time. This value would be a constant except for
2175 * daylight savings time.
2177 double result
= (utctime
- localtime
) / msPerMinute
;
2178 args
.rval().setNumber(result
);
2182 static bool date_setTime(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2183 CallArgs args
= CallArgsFromVp(argc
, vp
);
2185 Rooted
<DateObject
*> unwrapped(
2186 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setTime"));
2191 if (args
.length() == 0) {
2192 unwrapped
->setUTCTime(ClippedTime::invalid(), args
.rval());
2197 if (!ToNumber(cx
, args
[0], &result
)) {
2201 unwrapped
->setUTCTime(TimeClip(result
), args
.rval());
2205 static bool GetMsecsOrDefault(JSContext
* cx
, const CallArgs
& args
, unsigned i
,
2206 double t
, double* millis
) {
2207 if (args
.length() <= i
) {
2208 *millis
= msFromTime(t
);
2211 return ToNumber(cx
, args
[i
], millis
);
2214 static bool GetSecsOrDefault(JSContext
* cx
, const CallArgs
& args
, unsigned i
,
2215 double t
, double* sec
) {
2216 if (args
.length() <= i
) {
2217 *sec
= SecFromTime(t
);
2220 return ToNumber(cx
, args
[i
], sec
);
2223 static bool GetMinsOrDefault(JSContext
* cx
, const CallArgs
& args
, unsigned i
,
2224 double t
, double* mins
) {
2225 if (args
.length() <= i
) {
2226 *mins
= MinFromTime(t
);
2229 return ToNumber(cx
, args
[i
], mins
);
2232 /* ES6 20.3.4.23. */
2233 static bool date_setMilliseconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2234 CallArgs args
= CallArgsFromVp(argc
, vp
);
2237 Rooted
<DateObject
*> unwrapped(
2238 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setMilliseconds"));
2242 double t
= LocalTime(unwrapped
->forceUTC(), unwrapped
->UTCTime().toNumber());
2246 if (!ToNumber(cx
, args
.get(0), &ms
)) {
2251 double time
= MakeTime(HourFromTime(t
), MinFromTime(t
), SecFromTime(t
), ms
);
2254 ClippedTime u
= TimeClip(UTC(unwrapped
->forceUTC(), MakeDate(Day(t
), time
)));
2257 unwrapped
->setUTCTime(u
, args
.rval());
2261 /* ES5 15.9.5.29. */
2262 static bool date_setUTCMilliseconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2263 CallArgs args
= CallArgsFromVp(argc
, vp
);
2265 Rooted
<DateObject
*> unwrapped(
2266 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setUTCMilliseconds"));
2272 double t
= unwrapped
->UTCTime().toNumber();
2276 if (!ToNumber(cx
, args
.get(0), &milli
)) {
2280 MakeTime(HourFromTime(t
), MinFromTime(t
), SecFromTime(t
), milli
);
2283 ClippedTime v
= TimeClip(MakeDate(Day(t
), time
));
2286 unwrapped
->setUTCTime(v
, args
.rval());
2290 /* ES6 20.3.4.26. */
2291 static bool date_setSeconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2292 CallArgs args
= CallArgsFromVp(argc
, vp
);
2294 Rooted
<DateObject
*> unwrapped(
2295 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setSeconds"));
2301 double t
= LocalTime(unwrapped
->forceUTC(), unwrapped
->UTCTime().toNumber());
2305 if (!ToNumber(cx
, args
.get(0), &s
)) {
2311 if (!GetMsecsOrDefault(cx
, args
, 1, t
, &milli
)) {
2317 MakeDate(Day(t
), MakeTime(HourFromTime(t
), MinFromTime(t
), s
, milli
));
2320 ClippedTime u
= TimeClip(UTC(unwrapped
->forceUTC(), date
));
2323 unwrapped
->setUTCTime(u
, args
.rval());
2327 /* ES5 15.9.5.32. */
2328 static bool date_setUTCSeconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2329 CallArgs args
= CallArgsFromVp(argc
, vp
);
2331 Rooted
<DateObject
*> unwrapped(
2332 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setUTCSeconds"));
2338 double t
= unwrapped
->UTCTime().toNumber();
2342 if (!ToNumber(cx
, args
.get(0), &s
)) {
2348 if (!GetMsecsOrDefault(cx
, args
, 1, t
, &milli
)) {
2354 MakeDate(Day(t
), MakeTime(HourFromTime(t
), MinFromTime(t
), s
, milli
));
2357 ClippedTime v
= TimeClip(date
);
2360 unwrapped
->setUTCTime(v
, args
.rval());
2364 /* ES6 20.3.4.24. */
2365 static bool date_setMinutes(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2366 CallArgs args
= CallArgsFromVp(argc
, vp
);
2368 Rooted
<DateObject
*> unwrapped(
2369 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setMinutes"));
2375 double t
= LocalTime(unwrapped
->forceUTC(), unwrapped
->UTCTime().toNumber());
2379 if (!ToNumber(cx
, args
.get(0), &m
)) {
2385 if (!GetSecsOrDefault(cx
, args
, 1, t
, &s
)) {
2391 if (!GetMsecsOrDefault(cx
, args
, 2, t
, &milli
)) {
2396 double date
= MakeDate(Day(t
), MakeTime(HourFromTime(t
), m
, s
, milli
));
2399 ClippedTime u
= TimeClip(UTC(unwrapped
->forceUTC(), date
));
2402 unwrapped
->setUTCTime(u
, args
.rval());
2406 /* ES5 15.9.5.34. */
2407 static bool date_setUTCMinutes(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2408 CallArgs args
= CallArgsFromVp(argc
, vp
);
2410 Rooted
<DateObject
*> unwrapped(
2411 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setUTCMinutes"));
2417 double t
= unwrapped
->UTCTime().toNumber();
2421 if (!ToNumber(cx
, args
.get(0), &m
)) {
2427 if (!GetSecsOrDefault(cx
, args
, 1, t
, &s
)) {
2433 if (!GetMsecsOrDefault(cx
, args
, 2, t
, &milli
)) {
2438 double date
= MakeDate(Day(t
), MakeTime(HourFromTime(t
), m
, s
, milli
));
2441 ClippedTime v
= TimeClip(date
);
2444 unwrapped
->setUTCTime(v
, args
.rval());
2448 /* ES5 15.9.5.35. */
2449 static bool date_setHours(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2450 CallArgs args
= CallArgsFromVp(argc
, vp
);
2452 Rooted
<DateObject
*> unwrapped(
2453 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setHours"));
2459 double t
= LocalTime(unwrapped
->forceUTC(), unwrapped
->UTCTime().toNumber());
2463 if (!ToNumber(cx
, args
.get(0), &h
)) {
2469 if (!GetMinsOrDefault(cx
, args
, 1, t
, &m
)) {
2475 if (!GetSecsOrDefault(cx
, args
, 2, t
, &s
)) {
2481 if (!GetMsecsOrDefault(cx
, args
, 3, t
, &milli
)) {
2486 double date
= MakeDate(Day(t
), MakeTime(h
, m
, s
, milli
));
2489 ClippedTime u
= TimeClip(UTC(unwrapped
->forceUTC(), date
));
2492 unwrapped
->setUTCTime(u
, args
.rval());
2496 /* ES5 15.9.5.36. */
2497 static bool date_setUTCHours(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2498 CallArgs args
= CallArgsFromVp(argc
, vp
);
2500 Rooted
<DateObject
*> unwrapped(
2501 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setUTCHours"));
2507 double t
= unwrapped
->UTCTime().toNumber();
2511 if (!ToNumber(cx
, args
.get(0), &h
)) {
2517 if (!GetMinsOrDefault(cx
, args
, 1, t
, &m
)) {
2523 if (!GetSecsOrDefault(cx
, args
, 2, t
, &s
)) {
2529 if (!GetMsecsOrDefault(cx
, args
, 3, t
, &milli
)) {
2534 double newDate
= MakeDate(Day(t
), MakeTime(h
, m
, s
, milli
));
2537 ClippedTime v
= TimeClip(newDate
);
2540 unwrapped
->setUTCTime(v
, args
.rval());
2544 /* ES5 15.9.5.37. */
2545 static bool date_setDate(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2546 CallArgs args
= CallArgsFromVp(argc
, vp
);
2548 Rooted
<DateObject
*> unwrapped(
2549 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setDate"));
2555 double t
= LocalTime(unwrapped
->forceUTC(), unwrapped
->UTCTime().toNumber());
2559 if (!ToNumber(cx
, args
.get(0), &date
)) {
2564 double newDate
= MakeDate(MakeDay(YearFromTime(t
), MonthFromTime(t
), date
),
2568 ClippedTime u
= TimeClip(UTC(unwrapped
->forceUTC(), newDate
));
2571 unwrapped
->setUTCTime(u
, args
.rval());
2575 static bool date_setUTCDate(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2576 CallArgs args
= CallArgsFromVp(argc
, vp
);
2578 Rooted
<DateObject
*> unwrapped(
2579 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setUTCDate"));
2585 double t
= unwrapped
->UTCTime().toNumber();
2589 if (!ToNumber(cx
, args
.get(0), &date
)) {
2594 double newDate
= MakeDate(MakeDay(YearFromTime(t
), MonthFromTime(t
), date
),
2598 ClippedTime v
= TimeClip(newDate
);
2601 unwrapped
->setUTCTime(v
, args
.rval());
2605 static bool GetDateOrDefault(JSContext
* cx
, const CallArgs
& args
, unsigned i
,
2606 double t
, double* date
) {
2607 if (args
.length() <= i
) {
2608 *date
= DateFromTime(t
);
2611 return ToNumber(cx
, args
[i
], date
);
2614 static bool GetMonthOrDefault(JSContext
* cx
, const CallArgs
& args
, unsigned i
,
2615 double t
, double* month
) {
2616 if (args
.length() <= i
) {
2617 *month
= MonthFromTime(t
);
2620 return ToNumber(cx
, args
[i
], month
);
2623 /* ES5 15.9.5.38. */
2624 static bool date_setMonth(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2625 CallArgs args
= CallArgsFromVp(argc
, vp
);
2627 Rooted
<DateObject
*> unwrapped(
2628 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setMonth"));
2634 double t
= LocalTime(unwrapped
->forceUTC(), unwrapped
->UTCTime().toNumber());
2638 if (!ToNumber(cx
, args
.get(0), &m
)) {
2644 if (!GetDateOrDefault(cx
, args
, 1, t
, &date
)) {
2650 MakeDate(MakeDay(YearFromTime(t
), m
, date
), TimeWithinDay(t
));
2653 ClippedTime u
= TimeClip(UTC(unwrapped
->forceUTC(), newDate
));
2656 unwrapped
->setUTCTime(u
, args
.rval());
2660 /* ES5 15.9.5.39. */
2661 static bool date_setUTCMonth(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2662 CallArgs args
= CallArgsFromVp(argc
, vp
);
2664 Rooted
<DateObject
*> unwrapped(
2665 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setUTCMonth"));
2671 double t
= unwrapped
->UTCTime().toNumber();
2675 if (!ToNumber(cx
, args
.get(0), &m
)) {
2681 if (!GetDateOrDefault(cx
, args
, 1, t
, &date
)) {
2687 MakeDate(MakeDay(YearFromTime(t
), m
, date
), TimeWithinDay(t
));
2690 ClippedTime v
= TimeClip(newDate
);
2693 unwrapped
->setUTCTime(v
, args
.rval());
2697 static double ThisLocalTimeOrZero(DateTimeInfo::ForceUTC forceUTC
,
2698 Handle
<DateObject
*> dateObj
) {
2699 double t
= dateObj
->UTCTime().toNumber();
2700 if (std::isnan(t
)) {
2703 return LocalTime(forceUTC
, t
);
2706 static double ThisUTCTimeOrZero(Handle
<DateObject
*> dateObj
) {
2707 double t
= dateObj
->as
<DateObject
>().UTCTime().toNumber();
2708 return std::isnan(t
) ? +0 : t
;
2711 /* ES5 15.9.5.40. */
2712 static bool date_setFullYear(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2713 CallArgs args
= CallArgsFromVp(argc
, vp
);
2715 Rooted
<DateObject
*> unwrapped(
2716 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setFullYear"));
2722 double t
= ThisLocalTimeOrZero(unwrapped
->forceUTC(), unwrapped
);
2726 if (!ToNumber(cx
, args
.get(0), &y
)) {
2732 if (!GetMonthOrDefault(cx
, args
, 1, t
, &m
)) {
2738 if (!GetDateOrDefault(cx
, args
, 2, t
, &date
)) {
2743 double newDate
= MakeDate(MakeDay(y
, m
, date
), TimeWithinDay(t
));
2746 ClippedTime u
= TimeClip(UTC(unwrapped
->forceUTC(), newDate
));
2749 unwrapped
->setUTCTime(u
, args
.rval());
2753 /* ES5 15.9.5.41. */
2754 static bool date_setUTCFullYear(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2755 CallArgs args
= CallArgsFromVp(argc
, vp
);
2757 Rooted
<DateObject
*> unwrapped(
2758 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setUTCFullYear"));
2764 double t
= ThisUTCTimeOrZero(unwrapped
);
2768 if (!ToNumber(cx
, args
.get(0), &y
)) {
2774 if (!GetMonthOrDefault(cx
, args
, 1, t
, &m
)) {
2780 if (!GetDateOrDefault(cx
, args
, 2, t
, &date
)) {
2785 double newDate
= MakeDate(MakeDay(y
, m
, date
), TimeWithinDay(t
));
2788 ClippedTime v
= TimeClip(newDate
);
2791 unwrapped
->setUTCTime(v
, args
.rval());
2795 /* ES5 Annex B.2.5. */
2796 static bool date_setYear(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2797 CallArgs args
= CallArgsFromVp(argc
, vp
);
2799 Rooted
<DateObject
*> unwrapped(
2800 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setYear"));
2806 double t
= ThisLocalTimeOrZero(unwrapped
->forceUTC(), unwrapped
);
2810 if (!ToNumber(cx
, args
.get(0), &y
)) {
2815 if (std::isnan(y
)) {
2816 unwrapped
->setUTCTime(ClippedTime::invalid(), args
.rval());
2821 double yint
= ToInteger(y
);
2822 if (0 <= yint
&& yint
<= 99) {
2827 double day
= MakeDay(yint
, MonthFromTime(t
), DateFromTime(t
));
2830 double u
= UTC(unwrapped
->forceUTC(), MakeDate(day
, TimeWithinDay(t
)));
2833 unwrapped
->setUTCTime(TimeClip(u
), args
.rval());
2837 /* constants for toString, toUTCString */
2838 static const char* const days
[] = {"Sun", "Mon", "Tue", "Wed",
2839 "Thu", "Fri", "Sat"};
2840 static const char* const months
[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
2841 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
2844 static bool date_toUTCString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2845 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toUTCString");
2846 CallArgs args
= CallArgsFromVp(argc
, vp
);
2848 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toUTCString");
2853 double utctime
= unwrapped
->UTCTime().toNumber();
2854 if (!std::isfinite(utctime
)) {
2855 args
.rval().setString(cx
->names().Invalid_Date_
);
2860 SprintfLiteral(buf
, "%s, %.2d %s %.4d %.2d:%.2d:%.2d GMT",
2861 days
[int(WeekDay(utctime
))], int(DateFromTime(utctime
)),
2862 months
[int(MonthFromTime(utctime
))],
2863 int(YearFromTime(utctime
)), int(HourFromTime(utctime
)),
2864 int(MinFromTime(utctime
)), int(SecFromTime(utctime
)));
2866 JSString
* str
= NewStringCopyZ
<CanGC
>(cx
, buf
);
2871 args
.rval().setString(str
);
2875 /* ES6 draft 2015-01-15 20.3.4.36. */
2876 static bool date_toISOString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2877 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toISOString");
2878 CallArgs args
= CallArgsFromVp(argc
, vp
);
2880 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toISOString");
2885 double utctime
= unwrapped
->UTCTime().toNumber();
2886 if (!std::isfinite(utctime
)) {
2887 JS_ReportErrorNumberASCII(cx
, js::GetErrorMessage
, nullptr,
2888 JSMSG_INVALID_DATE
);
2893 int year
= int(YearFromTime(utctime
));
2894 if (year
< 0 || year
> 9999) {
2895 SprintfLiteral(buf
, "%+.6d-%.2d-%.2dT%.2d:%.2d:%.2d.%.3dZ",
2896 int(YearFromTime(utctime
)), int(MonthFromTime(utctime
)) + 1,
2897 int(DateFromTime(utctime
)), int(HourFromTime(utctime
)),
2898 int(MinFromTime(utctime
)), int(SecFromTime(utctime
)),
2899 int(msFromTime(utctime
)));
2901 SprintfLiteral(buf
, "%.4d-%.2d-%.2dT%.2d:%.2d:%.2d.%.3dZ",
2902 int(YearFromTime(utctime
)), int(MonthFromTime(utctime
)) + 1,
2903 int(DateFromTime(utctime
)), int(HourFromTime(utctime
)),
2904 int(MinFromTime(utctime
)), int(SecFromTime(utctime
)),
2905 int(msFromTime(utctime
)));
2908 JSString
* str
= NewStringCopyZ
<CanGC
>(cx
, buf
);
2912 args
.rval().setString(str
);
2916 /* ES5 15.9.5.44. */
2917 static bool date_toJSON(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2918 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toJSON");
2919 CallArgs args
= CallArgsFromVp(argc
, vp
);
2922 RootedObject
obj(cx
, ToObject(cx
, args
.thisv()));
2928 RootedValue
tv(cx
, ObjectValue(*obj
));
2929 if (!ToPrimitive(cx
, JSTYPE_NUMBER
, &tv
)) {
2934 if (tv
.isDouble() && !std::isfinite(tv
.toDouble())) {
2935 args
.rval().setNull();
2940 RootedValue
toISO(cx
);
2941 if (!GetProperty(cx
, obj
, obj
, cx
->names().toISOString
, &toISO
)) {
2946 if (!IsCallable(toISO
)) {
2947 JS_ReportErrorNumberASCII(cx
, js::GetErrorMessage
, nullptr,
2948 JSMSG_BAD_TOISOSTRING_PROP
);
2953 return Call(cx
, toISO
, obj
, args
.rval());
2957 JSString
* DateTimeHelper::timeZoneComment(JSContext
* cx
,
2958 DateTimeInfo::ForceUTC forceUTC
,
2959 const char* locale
, double utcTime
,
2962 JS_ReportErrorNumberASCII(cx
, GetErrorMessage
, nullptr,
2963 JSMSG_DEFAULT_LOCALE_ERROR
);
2967 char16_t tzbuf
[100];
2971 char16_t
* timeZoneStart
= tzbuf
+ 2;
2972 constexpr size_t remainingSpace
=
2973 std::size(tzbuf
) - 2 - 1; // for the trailing ')'
2975 int64_t utcMilliseconds
= static_cast<int64_t>(utcTime
);
2976 if (!DateTimeInfo::timeZoneDisplayName(
2977 forceUTC
, timeZoneStart
, remainingSpace
, utcMilliseconds
, locale
)) {
2978 JS_ReportOutOfMemory(cx
);
2982 // Reject if the result string is empty.
2983 size_t len
= js_strlen(timeZoneStart
);
2985 return cx
->names().empty_
;
2988 // Parenthesize the returned display name.
2989 timeZoneStart
[len
] = ')';
2991 return NewStringCopyN
<CanGC
>(cx
, tzbuf
, 2 + len
+ 1);
2994 /* Interface to PRMJTime date struct. */
2995 PRMJTime
DateTimeHelper::toPRMJTime(DateTimeInfo::ForceUTC forceUTC
,
2996 double localTime
, double utcTime
) {
2997 double year
= YearFromTime(localTime
);
3000 prtm
.tm_usec
= int32_t(msFromTime(localTime
)) * 1000;
3001 prtm
.tm_sec
= int8_t(SecFromTime(localTime
));
3002 prtm
.tm_min
= int8_t(MinFromTime(localTime
));
3003 prtm
.tm_hour
= int8_t(HourFromTime(localTime
));
3004 prtm
.tm_mday
= int8_t(DateFromTime(localTime
));
3005 prtm
.tm_mon
= int8_t(MonthFromTime(localTime
));
3006 prtm
.tm_wday
= int8_t(WeekDay(localTime
));
3007 prtm
.tm_year
= year
;
3008 prtm
.tm_yday
= int16_t(DayWithinYear(localTime
, year
));
3009 prtm
.tm_isdst
= (daylightSavingTA(forceUTC
, utcTime
) != 0);
3014 size_t DateTimeHelper::formatTime(DateTimeInfo::ForceUTC forceUTC
, char* buf
,
3015 size_t buflen
, const char* fmt
,
3016 double utcTime
, double localTime
) {
3017 PRMJTime prtm
= toPRMJTime(forceUTC
, localTime
, utcTime
);
3019 // If an equivalent year was used to compute the date/time components, use
3020 // the same equivalent year to determine the time zone name and offset in
3021 // PRMJ_FormatTime(...).
3022 int timeZoneYear
= isRepresentableAsTime32(utcTime
)
3024 : equivalentYearForDST(prtm
.tm_year
);
3025 int offsetInSeconds
= (int)floor((localTime
- utcTime
) / msPerSecond
);
3027 return PRMJ_FormatTime(buf
, buflen
, fmt
, &prtm
, timeZoneYear
,
3031 JSString
* DateTimeHelper::timeZoneComment(JSContext
* cx
,
3032 DateTimeInfo::ForceUTC forceUTC
,
3033 const char* locale
, double utcTime
,
3038 formatTime(forceUTC
, tzbuf
, sizeof tzbuf
, " (%Z)", utcTime
, localTime
);
3040 // Decide whether to use the resulting time zone string.
3042 // Reject it if it contains any non-ASCII or non-printable characters.
3043 // It's then likely in some other character encoding, and we probably
3044 // won't display it correctly.
3046 for (size_t i
= 0; i
< tzlen
; i
++) {
3047 char16_t c
= tzbuf
[i
];
3048 if (!IsAsciiPrintable(c
)) {
3054 // Also reject it if it's not parenthesized or if it's ' ()'.
3055 if (tzbuf
[0] != ' ' || tzbuf
[1] != '(' || tzbuf
[2] == ')') {
3060 return NewStringCopyN
<CanGC
>(cx
, tzbuf
, tzlen
);
3064 return cx
->names().empty_
;
3066 #endif /* JS_HAS_INTL_API */
3068 enum class FormatSpec
{ DateTime
, Date
, Time
};
3070 static bool FormatDate(JSContext
* cx
, DateTimeInfo::ForceUTC forceUTC
,
3071 const char* locale
, double utcTime
, FormatSpec format
,
3072 MutableHandleValue rval
) {
3073 if (!std::isfinite(utcTime
)) {
3074 rval
.setString(cx
->names().Invalid_Date_
);
3078 MOZ_ASSERT(NumbersAreIdentical(TimeClip(utcTime
).toDouble(), utcTime
));
3080 double localTime
= LocalTime(forceUTC
, utcTime
);
3083 RootedString
timeZoneComment(cx
);
3084 if (format
== FormatSpec::DateTime
|| format
== FormatSpec::Time
) {
3085 // Offset from GMT in minutes. The offset includes daylight savings,
3087 int minutes
= (int)trunc((localTime
- utcTime
) / msPerMinute
);
3089 // Map 510 minutes to 0830 hours.
3090 offset
= (minutes
/ 60) * 100 + minutes
% 60;
3092 // Print as "Wed Nov 05 1997 19:38:03 GMT-0800 (PST)".
3094 // The TZA is printed as 'GMT-0800' rather than as 'PST' to avoid
3095 // operating-system dependence on strftime (which PRMJ_FormatTime
3096 // calls, for %Z only.) win32 prints PST as 'Pacific Standard Time.'
3097 // This way we always know what we're getting, and can parse it if
3098 // we produce it. The OS time zone string is included as a comment.
3100 // When ICU is used to retrieve the time zone string, the localized
3101 // 'long' name format from CLDR is used. For example when the default
3102 // locale is "en-US", PST is displayed as 'Pacific Standard Time', but
3103 // when it is "ru", 'Тихоокеанское стандартное время' is used. This
3104 // also means the time zone string may not fit into Latin-1.
3106 // Get a time zone string from the OS or ICU to include as a comment.
3107 timeZoneComment
= DateTimeHelper::timeZoneComment(cx
, forceUTC
, locale
,
3108 utcTime
, localTime
);
3109 if (!timeZoneComment
) {
3116 case FormatSpec::DateTime
:
3117 /* Tue Oct 31 2000 09:41:40 GMT-0800 */
3118 SprintfLiteral(buf
, "%s %s %.2d %.4d %.2d:%.2d:%.2d GMT%+.4d",
3119 days
[int(WeekDay(localTime
))],
3120 months
[int(MonthFromTime(localTime
))],
3121 int(DateFromTime(localTime
)), int(YearFromTime(localTime
)),
3122 int(HourFromTime(localTime
)), int(MinFromTime(localTime
)),
3123 int(SecFromTime(localTime
)), offset
);
3125 case FormatSpec::Date
:
3126 /* Tue Oct 31 2000 */
3127 SprintfLiteral(buf
, "%s %s %.2d %.4d", days
[int(WeekDay(localTime
))],
3128 months
[int(MonthFromTime(localTime
))],
3129 int(DateFromTime(localTime
)),
3130 int(YearFromTime(localTime
)));
3132 case FormatSpec::Time
:
3133 /* 09:41:40 GMT-0800 */
3134 SprintfLiteral(buf
, "%.2d:%.2d:%.2d GMT%+.4d",
3135 int(HourFromTime(localTime
)), int(MinFromTime(localTime
)),
3136 int(SecFromTime(localTime
)), offset
);
3140 RootedString
str(cx
, NewStringCopyZ
<CanGC
>(cx
, buf
));
3145 // Append the time zone string if present.
3146 if (timeZoneComment
&& !timeZoneComment
->empty()) {
3147 str
= js::ConcatStrings
<CanGC
>(cx
, str
, timeZoneComment
);
3153 rval
.setString(str
);
3157 #if !JS_HAS_INTL_API
3158 static bool ToLocaleFormatHelper(JSContext
* cx
, DateObject
* unwrapped
,
3159 const char* format
, MutableHandleValue rval
) {
3160 DateTimeInfo::ForceUTC forceUTC
= unwrapped
->forceUTC();
3161 const char* locale
= unwrapped
->realm()->getLocale();
3162 double utcTime
= unwrapped
->UTCTime().toNumber();
3165 if (!std::isfinite(utcTime
)) {
3166 strcpy(buf
, "InvalidDate");
3168 double localTime
= LocalTime(forceUTC
, utcTime
);
3170 /* Let PRMJTime format it. */
3171 size_t result_len
= DateTimeHelper::formatTime(forceUTC
, buf
, sizeof buf
,
3172 format
, utcTime
, localTime
);
3174 /* If it failed, default to toString. */
3175 if (result_len
== 0) {
3176 return FormatDate(cx
, forceUTC
, locale
, utcTime
, FormatSpec::DateTime
,
3180 /* Hacked check against undesired 2-digit year 00/00/00 form. */
3181 if (strcmp(format
, "%x") == 0 && result_len
>= 6 &&
3182 /* Format %x means use OS settings, which may have 2-digit yr, so
3183 hack end of 3/11/22 or 11.03.22 or 11Mar22 to use 4-digit yr...*/
3184 !IsAsciiDigit(buf
[result_len
- 3]) &&
3185 IsAsciiDigit(buf
[result_len
- 2]) &&
3186 IsAsciiDigit(buf
[result_len
- 1]) &&
3187 /* ...but not if starts with 4-digit year, like 2022/3/11. */
3188 !(IsAsciiDigit(buf
[0]) && IsAsciiDigit(buf
[1]) &&
3189 IsAsciiDigit(buf
[2]) && IsAsciiDigit(buf
[3]))) {
3190 int year
= int(YearFromTime(localTime
));
3191 snprintf(buf
+ (result_len
- 2), (sizeof buf
) - (result_len
- 2), "%d",
3196 if (cx
->runtime()->localeCallbacks
&&
3197 cx
->runtime()->localeCallbacks
->localeToUnicode
) {
3198 return cx
->runtime()->localeCallbacks
->localeToUnicode(cx
, buf
, rval
);
3201 JSString
* str
= NewStringCopyZ
<CanGC
>(cx
, buf
);
3205 rval
.setString(str
);
3210 static bool date_toLocaleString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3211 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toLocaleString");
3212 CallArgs args
= CallArgsFromVp(argc
, vp
);
3215 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toLocaleString");
3221 * Use '%#c' for windows, because '%c' is backward-compatible and non-y2k
3222 * with msvc; '%#c' requests that a full year be used in the result string.
3224 static const char format
[] =
3225 # if defined(_WIN32)
3232 return ToLocaleFormatHelper(cx
, unwrapped
, format
, args
.rval());
3235 static bool date_toLocaleDateString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3236 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype",
3237 "toLocaleDateString");
3238 CallArgs args
= CallArgsFromVp(argc
, vp
);
3241 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toLocaleDateString");
3247 * Use '%#x' for windows, because '%x' is backward-compatible and non-y2k
3248 * with msvc; '%#x' requests that a full year be used in the result string.
3250 static const char format
[] =
3251 # if defined(_WIN32)
3258 return ToLocaleFormatHelper(cx
, unwrapped
, format
, args
.rval());
3261 static bool date_toLocaleTimeString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3262 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype",
3263 "toLocaleTimeString");
3264 CallArgs args
= CallArgsFromVp(argc
, vp
);
3267 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toLocaleTimeString");
3272 return ToLocaleFormatHelper(cx
, unwrapped
, "%X", args
.rval());
3274 #endif /* !JS_HAS_INTL_API */
3276 static bool date_toTimeString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3277 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toTimeString");
3278 CallArgs args
= CallArgsFromVp(argc
, vp
);
3281 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toTimeString");
3286 return FormatDate(cx
, unwrapped
->forceUTC(), unwrapped
->realm()->getLocale(),
3287 unwrapped
->UTCTime().toNumber(), FormatSpec::Time
,
3291 static bool date_toDateString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3292 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toDateString");
3293 CallArgs args
= CallArgsFromVp(argc
, vp
);
3296 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toDateString");
3301 return FormatDate(cx
, unwrapped
->forceUTC(), unwrapped
->realm()->getLocale(),
3302 unwrapped
->UTCTime().toNumber(), FormatSpec::Date
,
3306 static bool date_toSource(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3307 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toSource");
3308 CallArgs args
= CallArgsFromVp(argc
, vp
);
3310 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toSource");
3315 JSStringBuilder
sb(cx
);
3316 if (!sb
.append("(new Date(") ||
3317 !NumberValueToStringBuffer(unwrapped
->UTCTime(), sb
) ||
3322 JSString
* str
= sb
.finishString();
3326 args
.rval().setString(str
);
3330 bool date_toString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3331 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toString");
3332 CallArgs args
= CallArgsFromVp(argc
, vp
);
3334 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toString");
3339 return FormatDate(cx
, unwrapped
->forceUTC(), unwrapped
->realm()->getLocale(),
3340 unwrapped
->UTCTime().toNumber(), FormatSpec::DateTime
,
3344 bool js::date_valueOf(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3345 CallArgs args
= CallArgsFromVp(argc
, vp
);
3347 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "valueOf");
3352 args
.rval().set(unwrapped
->UTCTime());
3356 // ES6 20.3.4.45 Date.prototype[@@toPrimitive]
3357 static bool date_toPrimitive(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3358 CallArgs args
= CallArgsFromVp(argc
, vp
);
3361 if (!args
.thisv().isObject()) {
3362 ReportIncompatible(cx
, args
);
3368 if (!GetFirstArgumentAsTypeHint(cx
, args
, &hint
)) {
3371 if (hint
== JSTYPE_UNDEFINED
) {
3372 hint
= JSTYPE_STRING
;
3375 args
.rval().set(args
.thisv());
3376 RootedObject
obj(cx
, &args
.thisv().toObject());
3377 return OrdinaryToPrimitive(cx
, obj
, hint
, args
.rval());
3380 #if JS_HAS_TEMPORAL_API
3382 * Date.prototype.toTemporalInstant ( )
3384 static bool date_toTemporalInstant(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3385 CallArgs args
= CallArgsFromVp(argc
, vp
);
3389 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toTemporalInstant");
3395 double utctime
= unwrapped
->UTCTime().toNumber();
3396 if (!std::isfinite(utctime
)) {
3397 JS_ReportErrorNumberASCII(cx
, js::GetErrorMessage
, nullptr,
3398 JSMSG_INVALID_DATE
);
3401 MOZ_ASSERT(IsInteger(utctime
));
3403 auto instant
= temporal::Instant::fromMilliseconds(int64_t(utctime
));
3404 MOZ_ASSERT(temporal::IsValidEpochInstant(instant
));
3407 auto* result
= temporal::CreateTemporalInstant(cx
, instant
);
3411 args
.rval().setObject(*result
);
3414 #endif /* JS_HAS_TEMPORAL_API */
3416 static const JSFunctionSpec date_static_methods
[] = {
3417 JS_FN("UTC", date_UTC
, 7, 0), JS_FN("parse", date_parse
, 1, 0),
3418 JS_FN("now", date_now
, 0, 0), JS_FS_END
};
3420 static const JSFunctionSpec date_methods
[] = {
3421 JS_FN("getTime", date_getTime
, 0, 0),
3422 JS_FN("getTimezoneOffset", date_getTimezoneOffset
, 0, 0),
3423 JS_FN("getYear", date_getYear
, 0, 0),
3424 JS_FN("getFullYear", date_getFullYear
, 0, 0),
3425 JS_FN("getUTCFullYear", date_getUTCFullYear
, 0, 0),
3426 JS_FN("getMonth", date_getMonth
, 0, 0),
3427 JS_FN("getUTCMonth", date_getUTCMonth
, 0, 0),
3428 JS_FN("getDate", date_getDate
, 0, 0),
3429 JS_FN("getUTCDate", date_getUTCDate
, 0, 0),
3430 JS_FN("getDay", date_getDay
, 0, 0),
3431 JS_FN("getUTCDay", date_getUTCDay
, 0, 0),
3432 JS_FN("getHours", date_getHours
, 0, 0),
3433 JS_FN("getUTCHours", date_getUTCHours
, 0, 0),
3434 JS_FN("getMinutes", date_getMinutes
, 0, 0),
3435 JS_FN("getUTCMinutes", date_getUTCMinutes
, 0, 0),
3436 JS_FN("getSeconds", date_getSeconds
, 0, 0),
3437 JS_FN("getUTCSeconds", date_getUTCSeconds
, 0, 0),
3438 JS_FN("getMilliseconds", date_getMilliseconds
, 0, 0),
3439 JS_FN("getUTCMilliseconds", date_getUTCMilliseconds
, 0, 0),
3440 JS_FN("setTime", date_setTime
, 1, 0),
3441 JS_FN("setYear", date_setYear
, 1, 0),
3442 JS_FN("setFullYear", date_setFullYear
, 3, 0),
3443 JS_FN("setUTCFullYear", date_setUTCFullYear
, 3, 0),
3444 JS_FN("setMonth", date_setMonth
, 2, 0),
3445 JS_FN("setUTCMonth", date_setUTCMonth
, 2, 0),
3446 JS_FN("setDate", date_setDate
, 1, 0),
3447 JS_FN("setUTCDate", date_setUTCDate
, 1, 0),
3448 JS_FN("setHours", date_setHours
, 4, 0),
3449 JS_FN("setUTCHours", date_setUTCHours
, 4, 0),
3450 JS_FN("setMinutes", date_setMinutes
, 3, 0),
3451 JS_FN("setUTCMinutes", date_setUTCMinutes
, 3, 0),
3452 JS_FN("setSeconds", date_setSeconds
, 2, 0),
3453 JS_FN("setUTCSeconds", date_setUTCSeconds
, 2, 0),
3454 JS_FN("setMilliseconds", date_setMilliseconds
, 1, 0),
3455 JS_FN("setUTCMilliseconds", date_setUTCMilliseconds
, 1, 0),
3456 JS_FN("toUTCString", date_toUTCString
, 0, 0),
3457 #if JS_HAS_TEMPORAL_API
3458 JS_FN("toTemporalInstant", date_toTemporalInstant
, 0, 0),
3461 JS_SELF_HOSTED_FN("toLocaleString", "Date_toLocaleString", 0, 0),
3462 JS_SELF_HOSTED_FN("toLocaleDateString", "Date_toLocaleDateString", 0, 0),
3463 JS_SELF_HOSTED_FN("toLocaleTimeString", "Date_toLocaleTimeString", 0, 0),
3465 JS_FN("toLocaleString", date_toLocaleString
, 0, 0),
3466 JS_FN("toLocaleDateString", date_toLocaleDateString
, 0, 0),
3467 JS_FN("toLocaleTimeString", date_toLocaleTimeString
, 0, 0),
3469 JS_FN("toDateString", date_toDateString
, 0, 0),
3470 JS_FN("toTimeString", date_toTimeString
, 0, 0),
3471 JS_FN("toISOString", date_toISOString
, 0, 0),
3472 JS_FN("toJSON", date_toJSON
, 1, 0),
3473 JS_FN("toSource", date_toSource
, 0, 0),
3474 JS_FN("toString", date_toString
, 0, 0),
3475 JS_FN("valueOf", date_valueOf
, 0, 0),
3476 JS_SYM_FN(toPrimitive
, date_toPrimitive
, 1, JSPROP_READONLY
),
3479 static bool NewDateObject(JSContext
* cx
, const CallArgs
& args
, ClippedTime t
) {
3480 MOZ_ASSERT(args
.isConstructing());
3482 RootedObject
proto(cx
);
3483 if (!GetPrototypeFromBuiltinConstructor(cx
, args
, JSProto_Date
, &proto
)) {
3487 JSObject
* obj
= NewDateObjectMsec(cx
, t
, proto
);
3492 args
.rval().setObject(*obj
);
3496 static bool ToDateString(JSContext
* cx
, const CallArgs
& args
, ClippedTime t
) {
3497 return FormatDate(cx
, ForceUTC(cx
->realm()), cx
->realm()->getLocale(),
3498 t
.toDouble(), FormatSpec::DateTime
, args
.rval());
3501 static bool DateNoArguments(JSContext
* cx
, const CallArgs
& args
) {
3502 MOZ_ASSERT(args
.length() == 0);
3504 ClippedTime now
= NowAsMillis(cx
);
3506 if (args
.isConstructing()) {
3507 return NewDateObject(cx
, args
, now
);
3510 return ToDateString(cx
, args
, now
);
3513 static bool DateOneArgument(JSContext
* cx
, const CallArgs
& args
) {
3514 MOZ_ASSERT(args
.length() == 1);
3516 if (args
.isConstructing()) {
3517 if (args
[0].isObject()) {
3518 RootedObject
obj(cx
, &args
[0].toObject());
3521 if (!GetBuiltinClass(cx
, obj
, &cls
)) {
3525 if (cls
== ESClass::Date
) {
3526 RootedValue
unboxed(cx
);
3527 if (!Unbox(cx
, obj
, &unboxed
)) {
3531 return NewDateObject(cx
, args
, TimeClip(unboxed
.toNumber()));
3535 if (!ToPrimitive(cx
, args
[0])) {
3540 if (args
[0].isString()) {
3541 JSLinearString
* linearStr
= args
[0].toString()->ensureLinear(cx
);
3546 if (!ParseDate(ForceUTC(cx
->realm()), linearStr
, &t
)) {
3547 t
= ClippedTime::invalid();
3551 if (!ToNumber(cx
, args
[0], &d
)) {
3557 return NewDateObject(cx
, args
, t
);
3560 return ToDateString(cx
, args
, NowAsMillis(cx
));
3563 static bool DateMultipleArguments(JSContext
* cx
, const CallArgs
& args
) {
3564 MOZ_ASSERT(args
.length() >= 2);
3567 if (args
.isConstructing()) {
3570 if (!ToNumber(cx
, args
[0], &y
)) {
3576 if (!ToNumber(cx
, args
[1], &m
)) {
3582 if (args
.length() >= 3) {
3583 if (!ToNumber(cx
, args
[2], &dt
)) {
3592 if (args
.length() >= 4) {
3593 if (!ToNumber(cx
, args
[3], &h
)) {
3602 if (args
.length() >= 5) {
3603 if (!ToNumber(cx
, args
[4], &min
)) {
3612 if (args
.length() >= 6) {
3613 if (!ToNumber(cx
, args
[5], &s
)) {
3622 if (args
.length() >= 7) {
3623 if (!ToNumber(cx
, args
[6], &milli
)) {
3632 if (!std::isnan(y
)) {
3633 double yint
= ToInteger(y
);
3634 if (0 <= yint
&& yint
<= 99) {
3640 double finalDate
= MakeDate(MakeDay(yr
, m
, dt
), MakeTime(h
, min
, s
, milli
));
3643 return NewDateObject(cx
, args
,
3644 TimeClip(UTC(ForceUTC(cx
->realm()), finalDate
)));
3647 return ToDateString(cx
, args
, NowAsMillis(cx
));
3650 static bool DateConstructor(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3651 AutoJSConstructorProfilerEntry
pseudoFrame(cx
, "Date");
3652 CallArgs args
= CallArgsFromVp(argc
, vp
);
3654 if (args
.length() == 0) {
3655 return DateNoArguments(cx
, args
);
3658 if (args
.length() == 1) {
3659 return DateOneArgument(cx
, args
);
3662 return DateMultipleArguments(cx
, args
);
3665 static bool FinishDateClassInit(JSContext
* cx
, HandleObject ctor
,
3666 HandleObject proto
) {
3668 * Date.prototype.toGMTString has the same initial value as
3669 * Date.prototype.toUTCString.
3671 RootedValue
toUTCStringFun(cx
);
3672 RootedId
toUTCStringId(cx
, NameToId(cx
->names().toUTCString
));
3673 RootedId
toGMTStringId(cx
, NameToId(cx
->names().toGMTString
));
3674 return NativeGetProperty(cx
, proto
.as
<NativeObject
>(), toUTCStringId
,
3676 NativeDefineDataProperty(cx
, proto
.as
<NativeObject
>(), toGMTStringId
,
3680 static const ClassSpec DateObjectClassSpec
= {
3681 GenericCreateConstructor
<DateConstructor
, 7, gc::AllocKind::FUNCTION
>,
3682 GenericCreatePrototype
<DateObject
>,
3683 date_static_methods
,
3687 FinishDateClassInit
};
3689 const JSClass
DateObject::class_
= {"Date",
3690 JSCLASS_HAS_RESERVED_SLOTS(RESERVED_SLOTS
) |
3691 JSCLASS_HAS_CACHED_PROTO(JSProto_Date
),
3692 JS_NULL_CLASS_OPS
, &DateObjectClassSpec
};
3694 const JSClass
DateObject::protoClass_
= {
3695 "Date.prototype", JSCLASS_HAS_CACHED_PROTO(JSProto_Date
), JS_NULL_CLASS_OPS
,
3696 &DateObjectClassSpec
};
3698 JSObject
* js::NewDateObjectMsec(JSContext
* cx
, ClippedTime t
,
3699 HandleObject proto
/* = nullptr */) {
3700 DateObject
* obj
= NewObjectWithClassProto
<DateObject
>(cx
, proto
);
3708 JS_PUBLIC_API JSObject
* JS::NewDateObject(JSContext
* cx
, ClippedTime time
) {
3711 return NewDateObjectMsec(cx
, time
);
3714 JS_PUBLIC_API JSObject
* js::NewDateObject(JSContext
* cx
, int year
, int mon
,
3715 int mday
, int hour
, int min
,
3717 MOZ_ASSERT(mon
< 12);
3719 MakeDate(MakeDay(year
, mon
, mday
), MakeTime(hour
, min
, sec
, 0.0));
3720 return NewDateObjectMsec(cx
, TimeClip(UTC(ForceUTC(cx
->realm()), msec_time
)));
3723 JS_PUBLIC_API
bool js::DateIsValid(JSContext
* cx
, HandleObject obj
,
3726 if (!GetBuiltinClass(cx
, obj
, &cls
)) {
3730 if (cls
!= ESClass::Date
) {
3735 RootedValue
unboxed(cx
);
3736 if (!Unbox(cx
, obj
, &unboxed
)) {
3740 *isValid
= !std::isnan(unboxed
.toNumber());
3744 JS_PUBLIC_API JSObject
* JS::NewDateObject(JSContext
* cx
, int year
, int mon
,
3745 int mday
, int hour
, int min
,
3749 return js::NewDateObject(cx
, year
, mon
, mday
, hour
, min
, sec
);
3752 JS_PUBLIC_API
bool JS::ObjectIsDate(JSContext
* cx
, Handle
<JSObject
*> obj
,
3757 if (!GetBuiltinClass(cx
, obj
, &cls
)) {
3761 *isDate
= cls
== ESClass::Date
;
3765 JS_PUBLIC_API
bool js::DateGetMsecSinceEpoch(JSContext
* cx
, HandleObject obj
,
3766 double* msecsSinceEpoch
) {
3768 if (!GetBuiltinClass(cx
, obj
, &cls
)) {
3772 if (cls
!= ESClass::Date
) {
3773 *msecsSinceEpoch
= 0;
3777 RootedValue
unboxed(cx
);
3778 if (!Unbox(cx
, obj
, &unboxed
)) {
3782 *msecsSinceEpoch
= unboxed
.toNumber();