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/StringBuilder.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
JS::ReduceMicrosecondTimePrecisionCallback
502 JS::GetReduceMicrosecondTimePrecisionCallback() {
503 return sReduceMicrosecondTimePrecisionCallback
;
506 JS_PUBLIC_API
void JS::SetTimeResolutionUsec(uint32_t resolution
, bool jitter
) {
507 sResolutionUsec
= resolution
;
512 // ES2019 draft rev 0ceb728a1adbffe42b26972a6541fd7f398b1557
513 // 20.3.1.7 LocalTZA ( t, isUTC )
514 double DateTimeHelper::localTZA(DateTimeInfo::ForceUTC forceUTC
, double t
,
515 DateTimeInfo::TimeZoneOffset offset
) {
516 MOZ_ASSERT(std::isfinite(t
));
518 int64_t milliseconds
= static_cast<int64_t>(t
);
519 int32_t offsetMilliseconds
=
520 DateTimeInfo::getOffsetMilliseconds(forceUTC
, milliseconds
, offset
);
521 return static_cast<double>(offsetMilliseconds
);
524 // ES2019 draft rev 0ceb728a1adbffe42b26972a6541fd7f398b1557
525 // 20.3.1.8 LocalTime ( t )
526 double DateTimeHelper::localTime(DateTimeInfo::ForceUTC forceUTC
, double t
) {
527 if (!std::isfinite(t
)) {
531 MOZ_ASSERT(StartOfTime
<= t
&& t
<= EndOfTime
);
532 return t
+ localTZA(forceUTC
, t
, DateTimeInfo::TimeZoneOffset::UTC
);
535 // ES2019 draft rev 0ceb728a1adbffe42b26972a6541fd7f398b1557
536 // 20.3.1.9 UTC ( t )
537 double DateTimeHelper::UTC(DateTimeInfo::ForceUTC forceUTC
, double t
) {
538 if (!std::isfinite(t
)) {
542 if (t
< (StartOfTime
- msPerDay
) || t
> (EndOfTime
+ msPerDay
)) {
546 return t
- localTZA(forceUTC
, t
, DateTimeInfo::TimeZoneOffset::Local
);
550 * Find a year for which any given date will fall on the same weekday.
552 * This function should be used with caution when used other than
553 * for determining DST; it hasn't been proven not to produce an
554 * incorrect year for times near year boundaries.
556 int DateTimeHelper::equivalentYearForDST(int year
) {
558 * Years and leap years on which Jan 1 is a Sunday, Monday, etc.
560 * yearStartingWith[0][i] is an example non-leap year where
561 * Jan 1 appears on Sunday (i == 0), Monday (i == 1), etc.
563 * yearStartingWith[1][i] is an example leap year where
564 * Jan 1 appears on Sunday (i == 0), Monday (i == 1), etc.
566 * Keep two different mappings, one for past years (< 1970), and a
567 * different one for future years (> 2037).
569 static const int pastYearStartingWith
[2][7] = {
570 {1978, 1973, 1974, 1975, 1981, 1971, 1977},
571 {1984, 1996, 1980, 1992, 1976, 1988, 1972}};
572 static const int futureYearStartingWith
[2][7] = {
573 {2034, 2035, 2030, 2031, 2037, 2027, 2033},
574 {2012, 2024, 2036, 2020, 2032, 2016, 2028}};
576 int day
= int(::DayFromYear(year
) + 4) % 7;
581 const auto& yearStartingWith
=
582 year
< 1970 ? pastYearStartingWith
: futureYearStartingWith
;
583 return yearStartingWith
[IsLeapYear(year
)][day
];
586 // Return true if |t| is representable as a 32-bit time_t variable, that means
587 // the year is in [1970, 2038).
588 bool DateTimeHelper::isRepresentableAsTime32(double t
) {
589 return 0.0 <= t
&& t
< 2145916800000.0;
593 double DateTimeHelper::daylightSavingTA(DateTimeInfo::ForceUTC forceUTC
,
595 if (!std::isfinite(t
)) {
600 * If earlier than 1970 or after 2038, potentially beyond the ken of
601 * many OSes, map it to an equivalent year before asking.
603 if (!isRepresentableAsTime32(t
)) {
604 int year
= equivalentYearForDST(int(::YearFromTime(t
)));
605 double day
= MakeDay(year
, ::MonthFromTime(t
), DateFromTime(t
));
606 t
= MakeDate(day
, TimeWithinDay(t
));
609 int64_t utcMilliseconds
= static_cast<int64_t>(t
);
610 int32_t offsetMilliseconds
=
611 DateTimeInfo::getDSTOffsetMilliseconds(forceUTC
, utcMilliseconds
);
612 return static_cast<double>(offsetMilliseconds
);
615 double DateTimeHelper::adjustTime(DateTimeInfo::ForceUTC forceUTC
,
617 double localTZA
= DateTimeInfo::localTZA(forceUTC
);
618 double t
= daylightSavingTA(forceUTC
, date
) + localTZA
;
619 t
= (localTZA
>= 0) ? fmod(t
, msPerDay
) : -fmod(msPerDay
- t
, msPerDay
);
624 double DateTimeHelper::localTime(DateTimeInfo::ForceUTC forceUTC
, double t
) {
625 return t
+ adjustTime(forceUTC
, t
);
628 double DateTimeHelper::UTC(DateTimeInfo::ForceUTC forceUTC
, double t
) {
629 // Following the ES2017 specification creates undesirable results at DST
630 // transitions. For example when transitioning from PST to PDT,
631 // |new Date(2016,2,13,2,0,0).toTimeString()| returns the string value
632 // "01:00:00 GMT-0800 (PST)" instead of "03:00:00 GMT-0700 (PDT)". Follow
633 // V8 and subtract one hour before computing the offset.
634 // Spec bug: https://bugs.ecmascript.org/show_bug.cgi?id=4007
637 adjustTime(forceUTC
, t
- DateTimeInfo::localTZA(forceUTC
) - msPerHour
);
639 #endif /* JS_HAS_INTL_API */
641 static double LocalTime(DateTimeInfo::ForceUTC forceUTC
, double t
) {
642 return DateTimeHelper::localTime(forceUTC
, t
);
645 static double UTC(DateTimeInfo::ForceUTC forceUTC
, double t
) {
646 return DateTimeHelper::UTC(forceUTC
, t
);
650 static double HourFromTime(double t
) {
651 return PositiveModulo(floor(t
/ msPerHour
), HoursPerDay
);
654 static double MinFromTime(double t
) {
655 return PositiveModulo(floor(t
/ msPerMinute
), MinutesPerHour
);
658 static double SecFromTime(double t
) {
659 return PositiveModulo(floor(t
/ msPerSecond
), SecondsPerMinute
);
662 static double msFromTime(double t
) { return PositiveModulo(t
, msPerSecond
); }
665 static double MakeTime(double hour
, double min
, double sec
, double ms
) {
667 if (!std::isfinite(hour
) || !std::isfinite(min
) || !std::isfinite(sec
) ||
668 !std::isfinite(ms
)) {
673 double h
= ToInteger(hour
);
676 double m
= ToInteger(min
);
679 double s
= ToInteger(sec
);
682 double milli
= ToInteger(ms
);
685 return h
* msPerHour
+ m
* msPerMinute
+ s
* msPerSecond
+ milli
;
689 * end of ECMA 'support' functions
692 // ES2017 draft rev (TODO: Add git hash when PR 642 is merged.)
694 // Date.UTC(year [, month [, date [, hours [, minutes [, seconds [, ms]]]]]])
695 static bool date_UTC(JSContext
* cx
, unsigned argc
, Value
* vp
) {
696 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date", "UTC");
697 CallArgs args
= CallArgsFromVp(argc
, vp
);
701 if (!ToNumber(cx
, args
.get(0), &y
)) {
707 if (args
.length() >= 2) {
708 if (!ToNumber(cx
, args
[1], &m
)) {
717 if (args
.length() >= 3) {
718 if (!ToNumber(cx
, args
[2], &dt
)) {
727 if (args
.length() >= 4) {
728 if (!ToNumber(cx
, args
[3], &h
)) {
737 if (args
.length() >= 5) {
738 if (!ToNumber(cx
, args
[4], &min
)) {
747 if (args
.length() >= 6) {
748 if (!ToNumber(cx
, args
[5], &s
)) {
757 if (args
.length() >= 7) {
758 if (!ToNumber(cx
, args
[6], &milli
)) {
767 if (!std::isnan(y
)) {
768 double yint
= ToInteger(y
);
769 if (0 <= yint
&& yint
<= 99) {
776 TimeClip(MakeDate(MakeDay(yr
, m
, dt
), MakeTime(h
, min
, s
, milli
)));
777 args
.rval().set(TimeValue(time
));
782 * Read and convert decimal digits from s[*i] into *result
785 * Succeed if any digits are converted. Advance *i only
786 * as digits are consumed.
788 template <typename CharT
>
789 static bool ParseDigits(size_t* result
, const CharT
* s
, size_t* i
,
793 while (*i
< limit
&& ('0' <= s
[*i
] && s
[*i
] <= '9')) {
795 *result
+= (s
[*i
] - '0');
802 * Read and convert decimal digits to the right of a decimal point,
803 * representing a fractional integer, from s[*i] into *result
804 * while *i < limit, up to 3 digits. Consumes any digits beyond 3
805 * without affecting the result.
807 * Succeed if any digits are converted. Advance *i only
808 * as digits are consumed.
810 template <typename CharT
>
811 static bool ParseFractional(int* result
, const CharT
* s
, size_t* i
,
816 for (; *i
< limit
&& ('0' <= s
[*i
] && s
[*i
] <= '9'); ++(*i
)) {
817 if (*i
- init
>= 3) {
818 // If we're past 3 digits, do nothing with it, but continue to
819 // consume the remainder of the digits
822 *result
+= (s
[*i
] - '0') * factor
;
829 * Read and convert exactly n decimal digits from s[*i]
830 * to s[min(*i+n,limit)] into *result.
832 * Succeed if exactly n digits are converted. Advance *i only
835 template <typename CharT
>
836 static bool ParseDigitsN(size_t n
, size_t* result
, const CharT
* s
, size_t* i
,
840 if (ParseDigits(result
, s
, i
, std::min(limit
, init
+ n
))) {
841 return (*i
- init
) == n
;
849 * Read and convert n or less decimal digits from s[*i]
850 * to s[min(*i+n,limit)] into *result.
852 * Succeed only if greater than zero but less than or equal to n digits are
853 * converted. Advance *i only on success.
855 template <typename CharT
>
856 static bool ParseDigitsNOrLess(size_t n
, size_t* result
, const CharT
* s
,
857 size_t* i
, size_t limit
) {
860 if (ParseDigits(result
, s
, i
, std::min(limit
, init
+ n
))) {
861 return ((*i
- init
) > 0) && ((*i
- init
) <= n
);
869 * Parse a string according to the formats specified in the standard:
871 * https://tc39.es/ecma262/#sec-date-time-string-format
872 * https://tc39.es/ecma262/#sec-expanded-years
874 * These formats are based upon a simplification of the ISO 8601 Extended
875 * Format. As per the spec omitted month and day values are defaulted to '01',
876 * omitted HH:mm:ss values are defaulted to '00' and an omitted sss field is
877 * defaulted to '000'.
879 * For cross compatibility we allow the following extensions.
883 * One or more decimal digits for milliseconds:
884 * The specification requires exactly three decimal digits for
885 * the fractional part but we allow for one or more digits.
887 * Time zone specifier without ':':
888 * We allow the time zone to be specified without a ':' character.
889 * E.g. "T19:00:00+0700" is equivalent to "T19:00:00+07:00".
897 * YYYY-MM (eg 1997-07)
900 * YYYY-MM-DD (eg 1997-07-16)
905 * Thh:mmTZD (eg T19:20+01:00)
907 * Hours, minutes and seconds:
908 * Thh:mm:ssTZD (eg T19:20:30+01:00)
910 * Hours, minutes, seconds and a decimal fraction of a second:
911 * Thh:mm:ss.sssTZD (eg T19:20:30.45+01:00)
915 * YYYY = four-digit year or six digit year as +YYYYYY or -YYYYYY
916 * MM = two-digit month (01=January, etc.)
917 * DD = two-digit day of month (01 through 31)
918 * hh = two digits of hour (00 through 24) (am/pm NOT allowed)
919 * mm = two digits of minute (00 through 59)
920 * ss = two digits of second (00 through 59)
921 * sss = one or more digits representing a decimal fraction of a second
922 * TZD = time zone designator (Z or +hh:mm or -hh:mm or missing for local)
924 template <typename CharT
>
925 static bool ParseISOStyleDate(DateTimeInfo::ForceUTC forceUTC
, const CharT
* s
,
926 size_t length
, ClippedTime
* result
) {
937 bool isLocalTime
= false;
941 #define PEEK(ch) (i < length && s[i] == ch)
944 if (i >= length || s[i] != ch) { \
950 #define DONE_DATE_UNLESS(ch) \
951 if (i >= length || s[i] != ch) { \
957 #define DONE_UNLESS(ch) \
958 if (i >= length || s[i] != ch) { \
964 #define NEED_NDIGITS(n, field) \
965 if (!ParseDigitsN(n, &field, s, &i, length)) { \
969 if (PEEK('+') || PEEK('-')) {
974 NEED_NDIGITS(6, year
);
976 // https://tc39.es/ecma262/#sec-expanded-years
977 // -000000 is not a valid expanded year.
978 if (year
== 0 && dateMul
== -1) {
982 NEED_NDIGITS(4, year
);
984 DONE_DATE_UNLESS('-');
985 NEED_NDIGITS(2, month
);
986 DONE_DATE_UNLESS('-');
987 NEED_NDIGITS(2, day
);
996 NEED_NDIGITS(2, hour
);
998 NEED_NDIGITS(2, min
);
1002 NEED_NDIGITS(2, sec
);
1005 if (!ParseFractional(&msec
, s
, &i
, length
)) {
1013 } else if (PEEK('+') || PEEK('-')) {
1018 NEED_NDIGITS(2, tzHour
);
1020 * Non-standard extension to the ISO date format (permitted by ES5):
1021 * allow "-0700" as a time zone offset, not just "-07:00".
1026 NEED_NDIGITS(2, tzMin
);
1032 if (year
> 275943 // ceil(1e8/365) + 1970
1033 || month
== 0 || month
> 12 || day
== 0 || day
> 31 || hour
> 24 ||
1034 (hour
== 24 && (min
> 0 || sec
> 0 || msec
> 0)) || min
> 59 ||
1035 sec
> 59 || tzHour
> 23 || tzMin
> 59) {
1043 month
-= 1; /* convert month to 0-based */
1045 double date
= MakeDate(MakeDay(dateMul
* double(year
), month
, day
),
1046 MakeTime(hour
, min
, sec
, msec
));
1049 date
= UTC(forceUTC
, date
);
1051 date
-= tzMul
* (tzHour
* msPerHour
+ tzMin
* msPerMinute
);
1054 *result
= TimeClip(date
);
1055 return NumbersAreIdentical(date
, result
->toDouble());
1064 * Non-ISO years < 100 get fixed up, to allow 2-digit year formats.
1065 * year < 50 becomes 2000-2049, 50-99 becomes 1950-1999.
1067 int FixupYear(int year
) {
1070 } else if (year
>= 50 && year
< 100) {
1076 template <typename CharT
>
1077 bool MatchesKeyword(const CharT
* s
, size_t len
, const char* keyword
) {
1079 MOZ_ASSERT(IsAsciiAlpha(*s
));
1080 MOZ_ASSERT(IsAsciiLowercaseAlpha(*keyword
) || *keyword
== '\0');
1082 if (unicode::ToLowerCase(static_cast<Latin1Char
>(*s
)) != *keyword
) {
1090 return *keyword
== '\0';
1093 static constexpr const char* const month_prefixes
[] = {
1094 "jan", "feb", "mar", "apr", "may", "jun",
1095 "jul", "aug", "sep", "oct", "nov", "dec",
1099 * Given a string s of length >= 3, checks if it begins,
1100 * case-insensitive, with the given lower case prefix.
1102 template <typename CharT
>
1103 bool StartsWithMonthPrefix(const CharT
* s
, const char* prefix
) {
1104 MOZ_ASSERT(strlen(prefix
) == 3);
1106 for (size_t i
= 0; i
< 3; ++i
) {
1107 MOZ_ASSERT(IsAsciiAlpha(*s
));
1108 MOZ_ASSERT(IsAsciiLowercaseAlpha(*prefix
));
1110 if (unicode::ToLowerCase(static_cast<Latin1Char
>(*s
)) != *prefix
) {
1120 template <typename CharT
>
1121 bool IsMonthName(const CharT
* s
, size_t len
, int* mon
) {
1122 // Month abbreviations < 3 chars are not accepted.
1127 for (size_t m
= 0; m
< std::size(month_prefixes
); ++m
) {
1128 if (StartsWithMonthPrefix(s
, month_prefixes
[m
])) {
1129 // Use numeric value.
1139 * Try to parse the following date formats:
1147 * Returns true and fills all out parameters when successfully parsed
1148 * dashed-date. Otherwise returns false and leaves out parameters untouched.
1150 template <typename CharT
>
1151 static bool TryParseDashedDatePrefix(const CharT
* s
, size_t length
,
1152 size_t* indexOut
, int* yearOut
,
1153 int* monOut
, int* mdayOut
) {
1154 size_t i
= *indexOut
;
1158 if (!ParseDigitsNOrLess(6, &mday
, s
, &i
, length
)) {
1161 size_t mdayDigits
= i
- pre
;
1163 if (i
>= length
|| s
[i
] != '-') {
1169 if (*monOut
== -1) {
1170 // If month wasn't already set by ParseDate, it must be in the middle of
1171 // this format, let's look for it
1173 for (; i
< length
; i
++) {
1174 if (!IsAsciiAlpha(s
[i
])) {
1179 if (!IsMonthName(s
+ start
, i
- start
, &mon
)) {
1183 if (i
>= length
|| s
[i
] != '-') {
1191 if (!ParseDigitsNOrLess(6, &year
, s
, &i
, length
)) {
1194 size_t yearDigits
= i
- pre
;
1196 if (i
< length
&& IsAsciiDigit(s
[i
])) {
1200 // Swap the mday and year if the year wasn't specified in full.
1201 if (mday
> 31 && year
<= 31 && yearDigits
< 4) {
1202 std::swap(mday
, year
);
1203 std::swap(mdayDigits
, yearDigits
);
1206 if (mday
> 31 || mdayDigits
> 2) {
1210 year
= FixupYear(year
);
1214 if (*monOut
== -1) {
1222 * Try to parse dates in the style of YYYY-MM-DD which do not conform to
1223 * the formal standard from ParseISOStyleDate. This includes cases such as
1225 * - Year does not have 4 digits
1226 * - Month or mday has 1 digit
1227 * - Space in between date and time, rather than a 'T'
1229 * Regarding the last case, this function only parses out the date, returning
1230 * to ParseDate to finish parsing the time and timezone, if present.
1232 * Returns true and fills all out parameters when successfully parsed
1233 * dashed-date. Otherwise returns false and leaves out parameters untouched.
1235 template <typename CharT
>
1236 static bool TryParseDashedNumericDatePrefix(const CharT
* s
, size_t length
,
1237 size_t* indexOut
, int* yearOut
,
1238 int* monOut
, int* mdayOut
) {
1239 size_t i
= *indexOut
;
1242 if (!ParseDigitsNOrLess(6, &first
, s
, &i
, length
)) {
1246 if (i
>= length
|| s
[i
] != '-') {
1252 if (!ParseDigitsNOrLess(2, &second
, s
, &i
, length
)) {
1256 if (i
>= length
|| s
[i
] != '-') {
1262 if (!ParseDigitsNOrLess(6, &third
, s
, &i
, length
)) {
1270 // 1 or 2 digits for the first number is tricky; 1-12 means it's a month, 0 or
1271 // >31 means it's a year, and 13-31 is invalid due to ambiguity.
1272 if (first
>= 1 && first
<= 12) {
1274 } else if (first
== 0 || first
> 31) {
1281 // If month hasn't been set yet, it's definitely the 2nd number
1284 // If it has, the next number is the mday
1289 // The third number is probably the mday...
1292 // But otherwise, it's the year
1296 if (mon
< 1 || mon
> 12 || mday
< 1 || mday
> 31) {
1300 year
= FixupYear(year
);
1309 struct CharsAndAction
{
1314 static constexpr CharsAndAction keywords
[] = {
1319 // Time zone abbreviations.
1320 { "gmt", 10000 + 0 },
1322 { "ut", 10000 + 0 },
1323 { "utc", 10000 + 0 },
1324 { "est", 10000 + 5 * 60 },
1325 { "edt", 10000 + 4 * 60 },
1326 { "cst", 10000 + 6 * 60 },
1327 { "cdt", 10000 + 5 * 60 },
1328 { "mst", 10000 + 7 * 60 },
1329 { "mdt", 10000 + 6 * 60 },
1330 { "pst", 10000 + 8 * 60 },
1331 { "pdt", 10000 + 7 * 60 },
1336 constexpr size_t MinKeywordLength(const CharsAndAction (&keywords
)[N
]) {
1337 size_t min
= size_t(-1);
1338 for (const CharsAndAction
& keyword
: keywords
) {
1339 min
= std::min(min
, std::char_traits
<char>::length(keyword
.chars
));
1344 template <typename CharT
>
1345 static bool ParseDate(DateTimeInfo::ForceUTC forceUTC
, const CharT
* s
,
1346 size_t length
, ClippedTime
* result
) {
1351 if (ParseISOStyleDate(forceUTC
, s
, length
, result
)) {
1357 bool seenMonthName
= false;
1359 // Before we begin, we need to scrub any words from the beginning of the
1360 // string up to the first number, recording the month if we encounter it
1361 for (; index
< length
; index
++) {
1364 if (strchr(" ,.-/", c
)) {
1367 if (!IsAsciiAlpha(c
)) {
1371 size_t start
= index
;
1373 for (; index
< length
; index
++) {
1374 if (!IsAsciiAlpha(s
[index
])) {
1379 if (index
>= length
) {
1383 if (IsMonthName(s
+ start
, index
- start
, &mon
)) {
1384 seenMonthName
= true;
1385 // If the next digit is a number, we need to break so it
1386 // gets parsed as mday
1387 if (IsAsciiDigit(s
[index
])) {
1390 } else if (!strchr(" ,.-/", s
[index
])) {
1391 // We're only allowing the above delimiters after the day of
1392 // week to prevent things such as "foo_1" from being parsed
1393 // as a date, which may break software which uses this function
1394 // to determine whether or not something is a date.
1407 // One of '+', '-', ':', '/', or 0 (the default value).
1410 bool seenPlusMinus
= false;
1411 bool seenFullYear
= false;
1412 bool negativeYear
= false;
1413 // Includes "GMT", "UTC", "UT", and "Z" timezone keywords
1414 bool seenGmtAbbr
= false;
1416 // Try parsing the leading dashed-date.
1418 // If successfully parsed, index is updated to the end of the date part,
1419 // and year, mon, mday are set to the date.
1420 // Continue parsing optional time + tzOffset parts.
1422 // Otherwise, this is no-op.
1424 TryParseDashedDatePrefix(s
, length
, &index
, &year
, &mon
, &mday
) ||
1425 TryParseDashedNumericDatePrefix(s
, length
, &index
, &year
, &mon
, &mday
);
1427 if (isDashedDate
&& index
< length
&& strchr("T:+", s
[index
])) {
1431 while (index
< length
) {
1435 // Normalize U+202F (NARROW NO-BREAK SPACE). This character appears between
1436 // the AM/PM markers for |date.toLocaleString("en")|. We have to normalize
1437 // it for backward compatibility reasons.
1442 if ((c
== '+' || c
== '-') &&
1443 // Reject + or - after timezone (still allowing for negative year)
1444 ((seenPlusMinus
&& year
!= -1) ||
1445 // Reject timezones like "1995-09-26 -04:30" (if the - is right up
1446 // against the previous number, it will get parsed as a time,
1447 // see the other comment below)
1448 (year
!= -1 && hour
== -1 && !seenGmtAbbr
&&
1449 !IsAsciiDigit(s
[index
- 2])))) {
1453 // Spaces, ASCII control characters, periods, and commas are simply ignored.
1454 if (c
<= ' ' || c
== '.' || c
== ',') {
1458 // Parse delimiter characters. Save them to the side for future use.
1459 if (c
== '/' || c
== ':' || c
== '+') {
1464 // Dashes are delimiters if they're immediately followed by a number field.
1465 // If they're not followed by a number field, they're simply ignored.
1467 if (index
< length
&& IsAsciiDigit(s
[index
])) {
1473 // Skip over comments -- text inside matching parentheses. (Comments
1474 // themselves may contain comments as long as all the parentheses properly
1475 // match up. And apparently comments, including nested ones, may validly be
1476 // terminated by end of input...)
1479 while (index
< length
) {
1484 } else if (c
== ')') {
1493 // Parse a number field.
1494 if (IsAsciiDigit(c
)) {
1495 size_t partStart
= index
- 1;
1496 uint32_t u
= c
- '0';
1497 while (index
< length
) {
1499 if (!IsAsciiDigit(c
)) {
1502 u
= u
* 10 + (c
- '0');
1505 size_t partLength
= index
- partStart
;
1507 // See above for why we have to normalize U+202F.
1515 * Allow TZA before the year, so 'Wed Nov 05 21:49:11 GMT-0800 1997'
1518 * Uses of seenPlusMinus allow ':' in TZA, so Java no-timezone style
1519 * of GMT+4:30 works.
1522 if (prevc
== '-' && (tzOffset
!= 0 || seenPlusMinus
) && partLength
>= 4 &&
1524 // Parse as a negative, possibly zero-padded year if
1525 // 1. the preceding character is '-',
1526 // 2. the TZA is not 'GMT' (tested by |tzOffset != 0|),
1527 // 3. or a TZA was already parsed |seenPlusMinus == true|,
1528 // 4. the part length is at least 4 (to parse '-08' as a TZA),
1529 // 5. and we did not already parse a year |year < 0|.
1531 seenFullYear
= true;
1532 negativeYear
= true;
1533 } else if ((prevc
== '+' || prevc
== '-') &&
1534 // "1995-09-26-04:30" needs to be parsed as a time,
1536 (seenGmtAbbr
|| hour
!= -1)) {
1537 /* Make ':' case below change tzOffset. */
1538 seenPlusMinus
= true;
1541 if (n
< 24 && partLength
<= 2) {
1542 n
= n
* 60; /* EG. "GMT-3" */
1544 n
= n
% 100 + n
/ 100 * 60; /* eg "GMT-0430" */
1547 if (prevc
== '+') /* plus means east of GMT */
1550 // Reject if not preceded by 'GMT' or if a time zone offset
1551 // was already parsed.
1552 if (tzOffset
!= 0 && tzOffset
!= -1) {
1557 } else if (prevc
== '/' && mon
>= 0 && mday
>= 0 && year
< 0) {
1558 if (c
<= ' ' || c
== ',' || c
== '/' || index
>= length
) {
1563 } else if (c
== ':') {
1566 } else if (min
< 0) {
1571 } else if (c
== '/') {
1573 * Until it is determined that mon is the actual month, keep
1574 * it as 1-based rather than 0-based.
1578 } else if (mday
< 0) {
1583 } else if (index
< length
&& c
!= ',' && c
> ' ' && c
!= '-' &&
1585 // Allow '.' as a delimiter until seconds have been parsed
1586 // (this allows the decimal for milliseconds)
1587 (c
!= '.' || sec
!= -1) &&
1588 // Allow zulu time e.g. "09/26/1995 16:00Z", or
1589 // '+' directly after time e.g. 00:00+0500
1590 !(hour
!= -1 && strchr("Zz+", c
)) &&
1591 // Allow month or AM/PM directly after a number
1592 (!IsAsciiAlpha(c
) ||
1593 (mon
!= -1 && !(strchr("AaPp", c
) && index
< length
- 1 &&
1594 strchr("Mm", s
[index
+ 1]))))) {
1596 } else if (seenPlusMinus
&& n
< 60) { /* handle GMT-3:30 */
1602 } else if (hour
>= 0 && min
< 0) {
1604 } else if (prevc
== ':' && min
>= 0 && sec
< 0) {
1608 if (!ParseFractional(&msec
, s
, &index
, length
)) {
1612 } else if (mon
< 0) {
1614 } else if (mon
>= 0 && mday
< 0) {
1616 } else if (mon
>= 0 && mday
>= 0 && year
< 0) {
1618 seenFullYear
= partLength
>= 4;
1627 // Parse fields that are words: ASCII letters spelling out in English AM/PM,
1628 // day of week, month, or an extremely limited set of legacy time zone
1630 if (IsAsciiAlpha(c
)) {
1631 size_t start
= index
- 1;
1632 while (index
< length
) {
1634 if (!IsAsciiAlpha(c
)) {
1640 // There must be at least as many letters as in the shortest keyword.
1641 constexpr size_t MinLength
= MinKeywordLength(keywords
);
1642 if (index
- start
< MinLength
) {
1646 // Record a month if it is a month name. Note that some numbers are
1647 // initially treated as months; if a numeric field has already been
1648 // interpreted as a month, store that value to the actually appropriate
1649 // date component and set the month here.
1651 if (IsMonthName(s
+ start
, index
- start
, &tryMonth
)) {
1652 if (seenMonthName
) {
1653 // Overwrite the previous month name
1659 seenMonthName
= true;
1663 } else if (mday
< 0) {
1666 } else if (year
< 0) {
1668 // If the date is of the form f l month, then when month is
1669 // reached we have f in mon and l in mday. In order to be
1670 // consistent with the f month l and month f l forms, we need to
1671 // swap so that f is in mday and l is in year.
1686 size_t k
= std::size(keywords
);
1688 const CharsAndAction
& keyword
= keywords
[k
];
1690 // If the field doesn't match the keyword, try the next one.
1691 if (!MatchesKeyword(s
+ start
, index
- start
, keyword
.chars
)) {
1695 int action
= keyword
.action
;
1697 if (action
== 10000) {
1701 // Perform action tests from smallest action values to largest.
1703 // Adjust a previously-specified hour for AM/PM accordingly (taking care
1704 // to treat 12:xx AM as 00:xx, 12:xx PM as 12:xx).
1706 MOZ_ASSERT(action
== -1 || action
== -2);
1707 if (hour
> 12 || hour
< 0) {
1711 if (action
== -1 && hour
== 12) {
1713 } else if (action
== -2 && hour
!= 12) {
1720 // Finally, record a time zone offset.
1721 MOZ_ASSERT(action
>= 10000);
1722 tzOffset
= action
- 10000;
1726 if (k
== size_t(-1)) {
1734 // Any other character fails to parse.
1738 // Handle cases where the input is a single number. Single numbers >= 1000
1739 // are handled by the spec (ParseISOStyleDate), so we don't need to account
1741 if (mon
!= -1 && year
< 0 && mday
< 0) {
1742 // Reject 13-31 for Chrome parity
1743 if (mon
>= 13 && mon
<= 31) {
1748 if (mon
>= 1 && mon
<= 12) {
1749 // 1-12 is parsed as a month with the year defaulted to 2001
1750 // (again, for Chrome parity)
1753 year
= FixupYear(mon
);
1758 if (year
< 0 || mon
< 0 || mday
< 0) {
1762 if (!isDashedDate
) {
1763 // NOTE: TryParseDashedDatePrefix already handles the following fixup.
1766 * Case 1. The input string contains an English month name.
1767 * The form of the string can be month f l, or f month l, or
1768 * f l month which each evaluate to the same date.
1769 * If f and l are both greater than or equal to 100 the date
1772 * The year is taken to be either l, f if f > 31, or whichever
1775 * Case 2. The input string is of the form "f/m/l" where f, m and l are
1776 * integers, e.g. 7/16/45. mon, mday and year values are adjusted
1777 * to achieve Chrome compatibility.
1779 * a. If 0 < f <= 12 and 0 < l <= 31, f/m/l is interpreted as
1781 * b. If 31 < f and 0 < m <= 12 and 0 < l <= 31 f/m/l is
1782 * interpreted as year/month/day
1784 if (seenMonthName
) {
1785 if (mday
>= 100 && mon
>= 100) {
1789 if (year
> 0 && (mday
== 0 || mday
> 31) && !seenFullYear
) {
1795 if (mday
<= 0 || mday
> 31) {
1799 } else if (0 < mon
&& mon
<= 12 && 0 < mday
&& mday
<= 31) {
1800 /* (a) month/day/year */
1802 /* (b) year/month/day */
1803 if (mon
> 31 && mday
<= 12 && year
<= 31 && !seenFullYear
) {
1813 year
= FixupYear(year
);
1820 mon
-= 1; /* convert month to 0-based */
1832 MakeDate(MakeDay(year
, mon
, mday
), MakeTime(hour
, min
, sec
, msec
));
1834 if (tzOffset
== -1) { /* no time zone specified, have to use local */
1835 date
= UTC(forceUTC
, date
);
1837 date
+= tzOffset
* msPerMinute
;
1840 *result
= TimeClip(date
);
1844 static bool ParseDate(DateTimeInfo::ForceUTC forceUTC
, const JSLinearString
* s
,
1845 ClippedTime
* result
) {
1846 AutoCheckCannotGC nogc
;
1847 return s
->hasLatin1Chars()
1848 ? ParseDate(forceUTC
, s
->latin1Chars(nogc
), s
->length(), result
)
1849 : ParseDate(forceUTC
, s
->twoByteChars(nogc
), s
->length(), result
);
1852 static bool date_parse(JSContext
* cx
, unsigned argc
, Value
* vp
) {
1853 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date", "parse");
1854 CallArgs args
= CallArgsFromVp(argc
, vp
);
1855 if (args
.length() == 0) {
1856 args
.rval().setNaN();
1860 JSString
* str
= ToString
<CanGC
>(cx
, args
[0]);
1865 JSLinearString
* linearStr
= str
->ensureLinear(cx
);
1871 if (!ParseDate(ForceUTC(cx
->realm()), linearStr
, &result
)) {
1872 args
.rval().setNaN();
1876 args
.rval().set(TimeValue(result
));
1880 static ClippedTime
NowAsMillis(JSContext
* cx
) {
1881 if (js::SupportDifferentialTesting()) {
1885 double now
= PRMJ_Now();
1886 bool clampAndJitter
= cx
->realm()->behaviors().clampAndJitterTime();
1887 if (clampAndJitter
&& sReduceMicrosecondTimePrecisionCallback
) {
1888 now
= sReduceMicrosecondTimePrecisionCallback(
1889 now
, cx
->realm()->behaviors().reduceTimerPrecisionCallerType().value(),
1891 } else if (clampAndJitter
&& sResolutionUsec
) {
1892 double clamped
= floor(now
/ sResolutionUsec
) * sResolutionUsec
;
1895 // Calculate a random midpoint for jittering. In the browser, we are
1896 // adversarial: Web Content may try to calculate the midpoint themselves
1897 // and use that to bypass it's security. In the JS Shell, we are not
1898 // adversarial, we want to jitter the time to recreate the operating
1899 // environment, but we do not concern ourselves with trying to prevent an
1900 // attacker from calculating the midpoint themselves. So we use a very
1901 // simple, very fast CRC with a hardcoded seed.
1903 uint64_t midpoint
= BitwiseCast
<uint64_t>(clamped
);
1904 midpoint
^= 0x0F00DD1E2BAD2DED; // XOR in a 'secret'
1905 // MurmurHash3 internal component from
1906 // https://searchfox.org/mozilla-central/rev/61d400da1c692453c2dc2c1cf37b616ce13dea5b/dom/canvas/MurmurHash3.cpp#85
1907 midpoint
^= midpoint
>> 33;
1908 midpoint
*= uint64_t{0xFF51AFD7ED558CCD};
1909 midpoint
^= midpoint
>> 33;
1910 midpoint
*= uint64_t{0xC4CEB9FE1A85EC53};
1911 midpoint
^= midpoint
>> 33;
1912 midpoint
%= sResolutionUsec
;
1914 if (now
> clamped
+ midpoint
) { // We're jittering up to the next step
1915 now
= clamped
+ sResolutionUsec
;
1916 } else { // We're staying at the clamped value
1919 } else { // No jitter, only clamping
1924 return TimeClip(now
/ PRMJ_USEC_PER_MSEC
);
1927 JS::ClippedTime
js::DateNow(JSContext
* cx
) { return NowAsMillis(cx
); }
1929 bool js::date_now(JSContext
* cx
, unsigned argc
, Value
* vp
) {
1930 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date", "now");
1931 CallArgs args
= CallArgsFromVp(argc
, vp
);
1932 args
.rval().set(TimeValue(NowAsMillis(cx
)));
1936 DateTimeInfo::ForceUTC
DateObject::forceUTC() const {
1937 return ForceUTC(realm());
1940 void DateObject::setUTCTime(ClippedTime t
) {
1941 for (size_t ind
= COMPONENTS_START_SLOT
; ind
< RESERVED_SLOTS
; ind
++) {
1942 setReservedSlot(ind
, UndefinedValue());
1945 setFixedSlot(UTC_TIME_SLOT
, TimeValue(t
));
1948 void DateObject::setUTCTime(ClippedTime t
, MutableHandleValue vp
) {
1950 vp
.set(TimeValue(t
));
1953 void DateObject::fillLocalTimeSlots() {
1954 const int32_t utcTZOffset
=
1955 DateTimeInfo::utcToLocalStandardOffsetSeconds(forceUTC());
1957 /* Check if the cache is already populated. */
1958 if (!getReservedSlot(LOCAL_TIME_SLOT
).isUndefined() &&
1959 getReservedSlot(UTC_TIME_ZONE_OFFSET_SLOT
).toInt32() == utcTZOffset
) {
1963 /* Remember time zone used to generate the local cache. */
1964 setReservedSlot(UTC_TIME_ZONE_OFFSET_SLOT
, Int32Value(utcTZOffset
));
1966 double utcTime
= UTCTime().toNumber();
1968 if (!std::isfinite(utcTime
)) {
1969 for (size_t ind
= COMPONENTS_START_SLOT
; ind
< RESERVED_SLOTS
; ind
++) {
1970 setReservedSlot(ind
, DoubleValue(utcTime
));
1975 double localTime
= LocalTime(forceUTC(), utcTime
);
1977 setReservedSlot(LOCAL_TIME_SLOT
, DoubleValue(localTime
));
1979 const auto [year
, month
, day
] = ToYearMonthDay(localTime
);
1981 setReservedSlot(LOCAL_YEAR_SLOT
, Int32Value(year
));
1982 setReservedSlot(LOCAL_MONTH_SLOT
, Int32Value(int32_t(month
)));
1983 setReservedSlot(LOCAL_DATE_SLOT
, Int32Value(int32_t(day
)));
1985 int weekday
= WeekDay(localTime
);
1986 setReservedSlot(LOCAL_DAY_SLOT
, Int32Value(weekday
));
1988 double yearStartTime
= TimeFromYear(year
);
1989 uint64_t yearTime
= uint64_t(localTime
- yearStartTime
);
1990 int32_t yearSeconds
= int32_t(yearTime
/ 1000);
1991 setReservedSlot(LOCAL_SECONDS_INTO_YEAR_SLOT
, Int32Value(yearSeconds
));
1994 MOZ_ALWAYS_INLINE
bool IsDate(HandleValue v
) {
1995 return v
.isObject() && v
.toObject().is
<DateObject
>();
1999 * See ECMA 15.9.5.4 thru 15.9.5.23
2002 static bool date_getTime(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2003 CallArgs args
= CallArgsFromVp(argc
, vp
);
2005 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getTime");
2010 args
.rval().set(unwrapped
->UTCTime());
2014 static bool date_getYear(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2015 CallArgs args
= CallArgsFromVp(argc
, vp
);
2017 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getYear");
2022 unwrapped
->fillLocalTimeSlots();
2024 Value yearVal
= unwrapped
->localYear();
2025 if (yearVal
.isInt32()) {
2026 /* Follow ECMA-262 to the letter, contrary to IE JScript. */
2027 int year
= yearVal
.toInt32() - 1900;
2028 args
.rval().setInt32(year
);
2030 args
.rval().set(yearVal
);
2035 static bool date_getFullYear(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2036 CallArgs args
= CallArgsFromVp(argc
, vp
);
2038 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getFullYear");
2043 unwrapped
->fillLocalTimeSlots();
2044 args
.rval().set(unwrapped
->localYear());
2048 static bool date_getUTCFullYear(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2049 CallArgs args
= CallArgsFromVp(argc
, vp
);
2052 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getUTCFullYear");
2057 double result
= unwrapped
->UTCTime().toNumber();
2058 if (std::isfinite(result
)) {
2059 result
= ::YearFromTime(result
);
2062 args
.rval().setNumber(result
);
2066 static bool date_getMonth(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2067 CallArgs args
= CallArgsFromVp(argc
, vp
);
2069 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getMonth");
2074 unwrapped
->fillLocalTimeSlots();
2075 args
.rval().set(unwrapped
->localMonth());
2079 static bool date_getUTCMonth(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2080 CallArgs args
= CallArgsFromVp(argc
, vp
);
2082 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getUTCMonth");
2087 double d
= unwrapped
->UTCTime().toNumber();
2088 args
.rval().setNumber(::MonthFromTime(d
));
2092 static bool date_getDate(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2093 CallArgs args
= CallArgsFromVp(argc
, vp
);
2095 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getDate");
2100 unwrapped
->fillLocalTimeSlots();
2102 args
.rval().set(unwrapped
->localDate());
2106 static bool date_getUTCDate(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2107 CallArgs args
= CallArgsFromVp(argc
, vp
);
2109 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getUTCDate");
2114 double result
= unwrapped
->UTCTime().toNumber();
2115 if (std::isfinite(result
)) {
2116 result
= DateFromTime(result
);
2119 args
.rval().setNumber(result
);
2123 static bool date_getDay(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2124 CallArgs args
= CallArgsFromVp(argc
, vp
);
2126 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getDay");
2131 unwrapped
->fillLocalTimeSlots();
2132 args
.rval().set(unwrapped
->localDay());
2136 static bool date_getUTCDay(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2137 CallArgs args
= CallArgsFromVp(argc
, vp
);
2139 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getUTCDay");
2144 double result
= unwrapped
->UTCTime().toNumber();
2145 if (std::isfinite(result
)) {
2146 result
= WeekDay(result
);
2149 args
.rval().setNumber(result
);
2153 static bool date_getHours(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2154 CallArgs args
= CallArgsFromVp(argc
, vp
);
2156 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getHours");
2161 unwrapped
->fillLocalTimeSlots();
2163 // Note: localSecondsIntoYear is guaranteed to return an
2164 // int32 or NaN after the call to fillLocalTimeSlots.
2165 Value yearSeconds
= unwrapped
->localSecondsIntoYear();
2166 if (yearSeconds
.isDouble()) {
2167 MOZ_ASSERT(std::isnan(yearSeconds
.toDouble()));
2168 args
.rval().set(yearSeconds
);
2170 args
.rval().setInt32((yearSeconds
.toInt32() / int(SecondsPerHour
)) %
2176 static bool date_getUTCHours(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2177 CallArgs args
= CallArgsFromVp(argc
, vp
);
2179 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getUTCHours");
2184 double result
= unwrapped
->UTCTime().toNumber();
2185 if (std::isfinite(result
)) {
2186 result
= HourFromTime(result
);
2189 args
.rval().setNumber(result
);
2193 static bool date_getMinutes(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2194 CallArgs args
= CallArgsFromVp(argc
, vp
);
2196 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getMinutes");
2201 unwrapped
->fillLocalTimeSlots();
2203 // Note: localSecondsIntoYear is guaranteed to return an
2204 // int32 or NaN after the call to fillLocalTimeSlots.
2205 Value yearSeconds
= unwrapped
->localSecondsIntoYear();
2206 if (yearSeconds
.isDouble()) {
2207 MOZ_ASSERT(std::isnan(yearSeconds
.toDouble()));
2208 args
.rval().set(yearSeconds
);
2210 args
.rval().setInt32((yearSeconds
.toInt32() / int(SecondsPerMinute
)) %
2211 int(MinutesPerHour
));
2216 static bool date_getUTCMinutes(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2217 CallArgs args
= CallArgsFromVp(argc
, vp
);
2220 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getUTCMinutes");
2225 double result
= unwrapped
->UTCTime().toNumber();
2226 if (std::isfinite(result
)) {
2227 result
= MinFromTime(result
);
2230 args
.rval().setNumber(result
);
2234 static bool date_getSeconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2235 CallArgs args
= CallArgsFromVp(argc
, vp
);
2237 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getSeconds");
2242 unwrapped
->fillLocalTimeSlots();
2244 // Note: localSecondsIntoYear is guaranteed to return an
2245 // int32 or NaN after the call to fillLocalTimeSlots.
2246 Value yearSeconds
= unwrapped
->localSecondsIntoYear();
2247 if (yearSeconds
.isDouble()) {
2248 MOZ_ASSERT(std::isnan(yearSeconds
.toDouble()));
2249 args
.rval().set(yearSeconds
);
2251 args
.rval().setInt32(yearSeconds
.toInt32() % int(SecondsPerMinute
));
2256 static bool date_getUTCSeconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2257 CallArgs args
= CallArgsFromVp(argc
, vp
);
2260 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getUTCSeconds");
2265 double result
= unwrapped
->UTCTime().toNumber();
2266 if (std::isfinite(result
)) {
2267 result
= SecFromTime(result
);
2270 args
.rval().setNumber(result
);
2275 * Date.getMilliseconds is mapped to getUTCMilliseconds. As long as no
2276 * supported time zone has a fractional-second component, the differences in
2277 * their specifications aren't observable.
2279 * The 'tz' database explicitly does not support fractional-second time zones.
2280 * For example the Netherlands observed Amsterdam Mean Time, estimated to be
2281 * UT +00:19:32.13, from 1909 to 1937, but in tzdata AMT is defined as exactly
2285 static bool getMilliseconds(JSContext
* cx
, unsigned argc
, Value
* vp
,
2286 const char* methodName
) {
2287 CallArgs args
= CallArgsFromVp(argc
, vp
);
2289 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, methodName
);
2294 double result
= unwrapped
->UTCTime().toNumber();
2295 if (std::isfinite(result
)) {
2296 result
= msFromTime(result
);
2299 args
.rval().setNumber(result
);
2303 static bool date_getMilliseconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2304 return getMilliseconds(cx
, argc
, vp
, "getMilliseconds");
2307 static bool date_getUTCMilliseconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2308 return getMilliseconds(cx
, argc
, vp
, "getUTCMilliseconds");
2311 static bool date_getTimezoneOffset(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2312 CallArgs args
= CallArgsFromVp(argc
, vp
);
2315 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "getTimezoneOffset");
2320 unwrapped
->fillLocalTimeSlots();
2322 double utctime
= unwrapped
->UTCTime().toNumber();
2323 double localtime
= unwrapped
->localTime().toDouble();
2326 * Return the time zone offset in minutes for the current locale that is
2327 * appropriate for this time. This value would be a constant except for
2328 * daylight savings time.
2330 double result
= (utctime
- localtime
) / msPerMinute
;
2331 args
.rval().setNumber(result
);
2335 static bool date_setTime(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2336 CallArgs args
= CallArgsFromVp(argc
, vp
);
2338 Rooted
<DateObject
*> unwrapped(
2339 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setTime"));
2344 if (args
.length() == 0) {
2345 unwrapped
->setUTCTime(ClippedTime::invalid(), args
.rval());
2350 if (!ToNumber(cx
, args
[0], &result
)) {
2354 unwrapped
->setUTCTime(TimeClip(result
), args
.rval());
2358 static bool GetMsecsOrDefault(JSContext
* cx
, const CallArgs
& args
, unsigned i
,
2359 double t
, double* millis
) {
2360 if (args
.length() <= i
) {
2361 *millis
= msFromTime(t
);
2364 return ToNumber(cx
, args
[i
], millis
);
2367 static bool GetSecsOrDefault(JSContext
* cx
, const CallArgs
& args
, unsigned i
,
2368 double t
, double* sec
) {
2369 if (args
.length() <= i
) {
2370 *sec
= SecFromTime(t
);
2373 return ToNumber(cx
, args
[i
], sec
);
2376 static bool GetMinsOrDefault(JSContext
* cx
, const CallArgs
& args
, unsigned i
,
2377 double t
, double* mins
) {
2378 if (args
.length() <= i
) {
2379 *mins
= MinFromTime(t
);
2382 return ToNumber(cx
, args
[i
], mins
);
2385 /* ES6 20.3.4.23. */
2386 static bool date_setMilliseconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2387 CallArgs args
= CallArgsFromVp(argc
, vp
);
2390 Rooted
<DateObject
*> unwrapped(
2391 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setMilliseconds"));
2395 double t
= LocalTime(unwrapped
->forceUTC(), unwrapped
->UTCTime().toNumber());
2399 if (!ToNumber(cx
, args
.get(0), &ms
)) {
2404 double time
= MakeTime(HourFromTime(t
), MinFromTime(t
), SecFromTime(t
), ms
);
2407 ClippedTime u
= TimeClip(UTC(unwrapped
->forceUTC(), MakeDate(Day(t
), time
)));
2410 unwrapped
->setUTCTime(u
, args
.rval());
2414 /* ES5 15.9.5.29. */
2415 static bool date_setUTCMilliseconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2416 CallArgs args
= CallArgsFromVp(argc
, vp
);
2418 Rooted
<DateObject
*> unwrapped(
2419 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setUTCMilliseconds"));
2425 double t
= unwrapped
->UTCTime().toNumber();
2429 if (!ToNumber(cx
, args
.get(0), &milli
)) {
2433 MakeTime(HourFromTime(t
), MinFromTime(t
), SecFromTime(t
), milli
);
2436 ClippedTime v
= TimeClip(MakeDate(Day(t
), time
));
2439 unwrapped
->setUTCTime(v
, args
.rval());
2443 /* ES6 20.3.4.26. */
2444 static bool date_setSeconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2445 CallArgs args
= CallArgsFromVp(argc
, vp
);
2447 Rooted
<DateObject
*> unwrapped(
2448 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setSeconds"));
2454 double t
= LocalTime(unwrapped
->forceUTC(), unwrapped
->UTCTime().toNumber());
2458 if (!ToNumber(cx
, args
.get(0), &s
)) {
2464 if (!GetMsecsOrDefault(cx
, args
, 1, t
, &milli
)) {
2470 MakeDate(Day(t
), MakeTime(HourFromTime(t
), MinFromTime(t
), s
, milli
));
2473 ClippedTime u
= TimeClip(UTC(unwrapped
->forceUTC(), date
));
2476 unwrapped
->setUTCTime(u
, args
.rval());
2480 /* ES5 15.9.5.32. */
2481 static bool date_setUTCSeconds(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2482 CallArgs args
= CallArgsFromVp(argc
, vp
);
2484 Rooted
<DateObject
*> unwrapped(
2485 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setUTCSeconds"));
2491 double t
= unwrapped
->UTCTime().toNumber();
2495 if (!ToNumber(cx
, args
.get(0), &s
)) {
2501 if (!GetMsecsOrDefault(cx
, args
, 1, t
, &milli
)) {
2507 MakeDate(Day(t
), MakeTime(HourFromTime(t
), MinFromTime(t
), s
, milli
));
2510 ClippedTime v
= TimeClip(date
);
2513 unwrapped
->setUTCTime(v
, args
.rval());
2517 /* ES6 20.3.4.24. */
2518 static bool date_setMinutes(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2519 CallArgs args
= CallArgsFromVp(argc
, vp
);
2521 Rooted
<DateObject
*> unwrapped(
2522 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setMinutes"));
2528 double t
= LocalTime(unwrapped
->forceUTC(), unwrapped
->UTCTime().toNumber());
2532 if (!ToNumber(cx
, args
.get(0), &m
)) {
2538 if (!GetSecsOrDefault(cx
, args
, 1, t
, &s
)) {
2544 if (!GetMsecsOrDefault(cx
, args
, 2, t
, &milli
)) {
2549 double date
= MakeDate(Day(t
), MakeTime(HourFromTime(t
), m
, s
, milli
));
2552 ClippedTime u
= TimeClip(UTC(unwrapped
->forceUTC(), date
));
2555 unwrapped
->setUTCTime(u
, args
.rval());
2559 /* ES5 15.9.5.34. */
2560 static bool date_setUTCMinutes(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2561 CallArgs args
= CallArgsFromVp(argc
, vp
);
2563 Rooted
<DateObject
*> unwrapped(
2564 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setUTCMinutes"));
2570 double t
= unwrapped
->UTCTime().toNumber();
2574 if (!ToNumber(cx
, args
.get(0), &m
)) {
2580 if (!GetSecsOrDefault(cx
, args
, 1, t
, &s
)) {
2586 if (!GetMsecsOrDefault(cx
, args
, 2, t
, &milli
)) {
2591 double date
= MakeDate(Day(t
), MakeTime(HourFromTime(t
), m
, s
, milli
));
2594 ClippedTime v
= TimeClip(date
);
2597 unwrapped
->setUTCTime(v
, args
.rval());
2601 /* ES5 15.9.5.35. */
2602 static bool date_setHours(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2603 CallArgs args
= CallArgsFromVp(argc
, vp
);
2605 Rooted
<DateObject
*> unwrapped(
2606 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setHours"));
2612 double t
= LocalTime(unwrapped
->forceUTC(), unwrapped
->UTCTime().toNumber());
2616 if (!ToNumber(cx
, args
.get(0), &h
)) {
2622 if (!GetMinsOrDefault(cx
, args
, 1, t
, &m
)) {
2628 if (!GetSecsOrDefault(cx
, args
, 2, t
, &s
)) {
2634 if (!GetMsecsOrDefault(cx
, args
, 3, t
, &milli
)) {
2639 double date
= MakeDate(Day(t
), MakeTime(h
, m
, s
, milli
));
2642 ClippedTime u
= TimeClip(UTC(unwrapped
->forceUTC(), date
));
2645 unwrapped
->setUTCTime(u
, args
.rval());
2649 /* ES5 15.9.5.36. */
2650 static bool date_setUTCHours(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2651 CallArgs args
= CallArgsFromVp(argc
, vp
);
2653 Rooted
<DateObject
*> unwrapped(
2654 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setUTCHours"));
2660 double t
= unwrapped
->UTCTime().toNumber();
2664 if (!ToNumber(cx
, args
.get(0), &h
)) {
2670 if (!GetMinsOrDefault(cx
, args
, 1, t
, &m
)) {
2676 if (!GetSecsOrDefault(cx
, args
, 2, t
, &s
)) {
2682 if (!GetMsecsOrDefault(cx
, args
, 3, t
, &milli
)) {
2687 double newDate
= MakeDate(Day(t
), MakeTime(h
, m
, s
, milli
));
2690 ClippedTime v
= TimeClip(newDate
);
2693 unwrapped
->setUTCTime(v
, args
.rval());
2697 /* ES5 15.9.5.37. */
2698 static bool date_setDate(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2699 CallArgs args
= CallArgsFromVp(argc
, vp
);
2701 Rooted
<DateObject
*> unwrapped(
2702 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setDate"));
2708 double t
= LocalTime(unwrapped
->forceUTC(), unwrapped
->UTCTime().toNumber());
2712 if (!ToNumber(cx
, args
.get(0), &date
)) {
2717 double newDate
= MakeDate(
2718 MakeDay(::YearFromTime(t
), ::MonthFromTime(t
), date
), TimeWithinDay(t
));
2721 ClippedTime u
= TimeClip(UTC(unwrapped
->forceUTC(), newDate
));
2724 unwrapped
->setUTCTime(u
, args
.rval());
2728 static bool date_setUTCDate(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2729 CallArgs args
= CallArgsFromVp(argc
, vp
);
2731 Rooted
<DateObject
*> unwrapped(
2732 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setUTCDate"));
2738 double t
= unwrapped
->UTCTime().toNumber();
2742 if (!ToNumber(cx
, args
.get(0), &date
)) {
2747 double newDate
= MakeDate(
2748 MakeDay(::YearFromTime(t
), ::MonthFromTime(t
), date
), TimeWithinDay(t
));
2751 ClippedTime v
= TimeClip(newDate
);
2754 unwrapped
->setUTCTime(v
, args
.rval());
2758 static bool GetDateOrDefault(JSContext
* cx
, const CallArgs
& args
, unsigned i
,
2759 double t
, double* date
) {
2760 if (args
.length() <= i
) {
2761 *date
= DateFromTime(t
);
2764 return ToNumber(cx
, args
[i
], date
);
2767 static bool GetMonthOrDefault(JSContext
* cx
, const CallArgs
& args
, unsigned i
,
2768 double t
, double* month
) {
2769 if (args
.length() <= i
) {
2770 *month
= ::MonthFromTime(t
);
2773 return ToNumber(cx
, args
[i
], month
);
2776 /* ES5 15.9.5.38. */
2777 static bool date_setMonth(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2778 CallArgs args
= CallArgsFromVp(argc
, vp
);
2780 Rooted
<DateObject
*> unwrapped(
2781 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setMonth"));
2787 double t
= LocalTime(unwrapped
->forceUTC(), unwrapped
->UTCTime().toNumber());
2791 if (!ToNumber(cx
, args
.get(0), &m
)) {
2797 if (!GetDateOrDefault(cx
, args
, 1, t
, &date
)) {
2803 MakeDate(MakeDay(::YearFromTime(t
), m
, date
), TimeWithinDay(t
));
2806 ClippedTime u
= TimeClip(UTC(unwrapped
->forceUTC(), newDate
));
2809 unwrapped
->setUTCTime(u
, args
.rval());
2813 /* ES5 15.9.5.39. */
2814 static bool date_setUTCMonth(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2815 CallArgs args
= CallArgsFromVp(argc
, vp
);
2817 Rooted
<DateObject
*> unwrapped(
2818 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setUTCMonth"));
2824 double t
= unwrapped
->UTCTime().toNumber();
2828 if (!ToNumber(cx
, args
.get(0), &m
)) {
2834 if (!GetDateOrDefault(cx
, args
, 1, t
, &date
)) {
2840 MakeDate(MakeDay(::YearFromTime(t
), m
, date
), TimeWithinDay(t
));
2843 ClippedTime v
= TimeClip(newDate
);
2846 unwrapped
->setUTCTime(v
, args
.rval());
2850 static double ThisLocalTimeOrZero(DateTimeInfo::ForceUTC forceUTC
,
2851 Handle
<DateObject
*> dateObj
) {
2852 double t
= dateObj
->UTCTime().toNumber();
2853 if (std::isnan(t
)) {
2856 return LocalTime(forceUTC
, t
);
2859 static double ThisUTCTimeOrZero(Handle
<DateObject
*> dateObj
) {
2860 double t
= dateObj
->as
<DateObject
>().UTCTime().toNumber();
2861 return std::isnan(t
) ? +0 : t
;
2864 /* ES5 15.9.5.40. */
2865 static bool date_setFullYear(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2866 CallArgs args
= CallArgsFromVp(argc
, vp
);
2868 Rooted
<DateObject
*> unwrapped(
2869 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setFullYear"));
2875 double t
= ThisLocalTimeOrZero(unwrapped
->forceUTC(), unwrapped
);
2879 if (!ToNumber(cx
, args
.get(0), &y
)) {
2885 if (!GetMonthOrDefault(cx
, args
, 1, t
, &m
)) {
2891 if (!GetDateOrDefault(cx
, args
, 2, t
, &date
)) {
2896 double newDate
= MakeDate(MakeDay(y
, m
, date
), TimeWithinDay(t
));
2899 ClippedTime u
= TimeClip(UTC(unwrapped
->forceUTC(), newDate
));
2902 unwrapped
->setUTCTime(u
, args
.rval());
2906 /* ES5 15.9.5.41. */
2907 static bool date_setUTCFullYear(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2908 CallArgs args
= CallArgsFromVp(argc
, vp
);
2910 Rooted
<DateObject
*> unwrapped(
2911 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setUTCFullYear"));
2917 double t
= ThisUTCTimeOrZero(unwrapped
);
2921 if (!ToNumber(cx
, args
.get(0), &y
)) {
2927 if (!GetMonthOrDefault(cx
, args
, 1, t
, &m
)) {
2933 if (!GetDateOrDefault(cx
, args
, 2, t
, &date
)) {
2938 double newDate
= MakeDate(MakeDay(y
, m
, date
), TimeWithinDay(t
));
2941 ClippedTime v
= TimeClip(newDate
);
2944 unwrapped
->setUTCTime(v
, args
.rval());
2948 /* ES5 Annex B.2.5. */
2949 static bool date_setYear(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2950 CallArgs args
= CallArgsFromVp(argc
, vp
);
2952 Rooted
<DateObject
*> unwrapped(
2953 cx
, UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "setYear"));
2959 double t
= ThisLocalTimeOrZero(unwrapped
->forceUTC(), unwrapped
);
2963 if (!ToNumber(cx
, args
.get(0), &y
)) {
2968 if (std::isnan(y
)) {
2969 unwrapped
->setUTCTime(ClippedTime::invalid(), args
.rval());
2974 double yint
= ToInteger(y
);
2975 if (0 <= yint
&& yint
<= 99) {
2980 double day
= MakeDay(yint
, ::MonthFromTime(t
), DateFromTime(t
));
2983 double u
= UTC(unwrapped
->forceUTC(), MakeDate(day
, TimeWithinDay(t
)));
2986 unwrapped
->setUTCTime(TimeClip(u
), args
.rval());
2990 /* constants for toString, toUTCString */
2991 static const char* const days
[] = {"Sun", "Mon", "Tue", "Wed",
2992 "Thu", "Fri", "Sat"};
2993 static const char* const months
[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
2994 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
2997 static bool date_toUTCString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
2998 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toUTCString");
2999 CallArgs args
= CallArgsFromVp(argc
, vp
);
3001 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toUTCString");
3006 double utctime
= unwrapped
->UTCTime().toNumber();
3007 if (!std::isfinite(utctime
)) {
3008 args
.rval().setString(cx
->names().Invalid_Date_
);
3013 SprintfLiteral(buf
, "%s, %.2d %s %.4d %.2d:%.2d:%.2d GMT",
3014 days
[int(WeekDay(utctime
))], int(DateFromTime(utctime
)),
3015 months
[int(::MonthFromTime(utctime
))],
3016 int(::YearFromTime(utctime
)), int(HourFromTime(utctime
)),
3017 int(MinFromTime(utctime
)), int(SecFromTime(utctime
)));
3019 JSString
* str
= NewStringCopyZ
<CanGC
>(cx
, buf
);
3024 args
.rval().setString(str
);
3028 /* ES6 draft 2015-01-15 20.3.4.36. */
3029 static bool date_toISOString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3030 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toISOString");
3031 CallArgs args
= CallArgsFromVp(argc
, vp
);
3033 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toISOString");
3038 double utctime
= unwrapped
->UTCTime().toNumber();
3039 if (!std::isfinite(utctime
)) {
3040 JS_ReportErrorNumberASCII(cx
, js::GetErrorMessage
, nullptr,
3041 JSMSG_INVALID_DATE
);
3046 int year
= int(::YearFromTime(utctime
));
3047 if (year
< 0 || year
> 9999) {
3048 SprintfLiteral(buf
, "%+.6d-%.2d-%.2dT%.2d:%.2d:%.2d.%.3dZ",
3049 int(::YearFromTime(utctime
)),
3050 int(::MonthFromTime(utctime
)) + 1,
3051 int(DateFromTime(utctime
)), int(HourFromTime(utctime
)),
3052 int(MinFromTime(utctime
)), int(SecFromTime(utctime
)),
3053 int(msFromTime(utctime
)));
3055 SprintfLiteral(buf
, "%.4d-%.2d-%.2dT%.2d:%.2d:%.2d.%.3dZ",
3056 int(::YearFromTime(utctime
)),
3057 int(::MonthFromTime(utctime
)) + 1,
3058 int(DateFromTime(utctime
)), int(HourFromTime(utctime
)),
3059 int(MinFromTime(utctime
)), int(SecFromTime(utctime
)),
3060 int(msFromTime(utctime
)));
3063 JSString
* str
= NewStringCopyZ
<CanGC
>(cx
, buf
);
3067 args
.rval().setString(str
);
3071 /* ES5 15.9.5.44. */
3072 static bool date_toJSON(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3073 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toJSON");
3074 CallArgs args
= CallArgsFromVp(argc
, vp
);
3077 RootedObject
obj(cx
, ToObject(cx
, args
.thisv()));
3083 RootedValue
tv(cx
, ObjectValue(*obj
));
3084 if (!ToPrimitive(cx
, JSTYPE_NUMBER
, &tv
)) {
3089 if (tv
.isDouble() && !std::isfinite(tv
.toDouble())) {
3090 args
.rval().setNull();
3095 RootedValue
toISO(cx
);
3096 if (!GetProperty(cx
, obj
, obj
, cx
->names().toISOString
, &toISO
)) {
3101 if (!IsCallable(toISO
)) {
3102 JS_ReportErrorNumberASCII(cx
, js::GetErrorMessage
, nullptr,
3103 JSMSG_BAD_TOISOSTRING_PROP
);
3108 return Call(cx
, toISO
, obj
, args
.rval());
3112 JSString
* DateTimeHelper::timeZoneComment(JSContext
* cx
,
3113 DateTimeInfo::ForceUTC forceUTC
,
3114 const char* locale
, double utcTime
,
3116 char16_t tzbuf
[100];
3120 char16_t
* timeZoneStart
= tzbuf
+ 2;
3121 constexpr size_t remainingSpace
=
3122 std::size(tzbuf
) - 2 - 1; // for the trailing ')'
3124 int64_t utcMilliseconds
= static_cast<int64_t>(utcTime
);
3125 if (!DateTimeInfo::timeZoneDisplayName(
3126 forceUTC
, timeZoneStart
, remainingSpace
, utcMilliseconds
, locale
)) {
3127 JS_ReportOutOfMemory(cx
);
3131 // Reject if the result string is empty.
3132 size_t len
= js_strlen(timeZoneStart
);
3134 return cx
->names().empty_
;
3137 // Parenthesize the returned display name.
3138 timeZoneStart
[len
] = ')';
3140 return NewStringCopyN
<CanGC
>(cx
, tzbuf
, 2 + len
+ 1);
3143 /* Interface to PRMJTime date struct. */
3144 PRMJTime
DateTimeHelper::toPRMJTime(DateTimeInfo::ForceUTC forceUTC
,
3145 double localTime
, double utcTime
) {
3146 double year
= ::YearFromTime(localTime
);
3149 prtm
.tm_usec
= int32_t(msFromTime(localTime
)) * 1000;
3150 prtm
.tm_sec
= int8_t(SecFromTime(localTime
));
3151 prtm
.tm_min
= int8_t(MinFromTime(localTime
));
3152 prtm
.tm_hour
= int8_t(HourFromTime(localTime
));
3153 prtm
.tm_mday
= int8_t(DateFromTime(localTime
));
3154 prtm
.tm_mon
= int8_t(::MonthFromTime(localTime
));
3155 prtm
.tm_wday
= int8_t(WeekDay(localTime
));
3156 prtm
.tm_year
= year
;
3157 prtm
.tm_yday
= int16_t(::DayWithinYear(localTime
, year
));
3158 prtm
.tm_isdst
= (daylightSavingTA(forceUTC
, utcTime
) != 0);
3163 size_t DateTimeHelper::formatTime(DateTimeInfo::ForceUTC forceUTC
, char* buf
,
3164 size_t buflen
, const char* fmt
,
3165 double utcTime
, double localTime
) {
3166 PRMJTime prtm
= toPRMJTime(forceUTC
, localTime
, utcTime
);
3168 // If an equivalent year was used to compute the date/time components, use
3169 // the same equivalent year to determine the time zone name and offset in
3170 // PRMJ_FormatTime(...).
3171 int timeZoneYear
= isRepresentableAsTime32(utcTime
)
3173 : equivalentYearForDST(prtm
.tm_year
);
3174 int offsetInSeconds
= (int)floor((localTime
- utcTime
) / msPerSecond
);
3176 return PRMJ_FormatTime(buf
, buflen
, fmt
, &prtm
, timeZoneYear
,
3180 JSString
* DateTimeHelper::timeZoneComment(JSContext
* cx
,
3181 DateTimeInfo::ForceUTC forceUTC
,
3182 const char* locale
, double utcTime
,
3187 formatTime(forceUTC
, tzbuf
, sizeof tzbuf
, " (%Z)", utcTime
, localTime
);
3189 // Decide whether to use the resulting time zone string.
3191 // Reject it if it contains any non-ASCII or non-printable characters.
3192 // It's then likely in some other character encoding, and we probably
3193 // won't display it correctly.
3195 for (size_t i
= 0; i
< tzlen
; i
++) {
3196 char16_t c
= tzbuf
[i
];
3197 if (!IsAsciiPrintable(c
)) {
3203 // Also reject it if it's not parenthesized or if it's ' ()'.
3204 if (tzbuf
[0] != ' ' || tzbuf
[1] != '(' || tzbuf
[2] == ')') {
3209 return NewStringCopyN
<CanGC
>(cx
, tzbuf
, tzlen
);
3213 return cx
->names().empty_
;
3215 #endif /* JS_HAS_INTL_API */
3217 enum class FormatSpec
{ DateTime
, Date
, Time
};
3219 static bool FormatDate(JSContext
* cx
, DateTimeInfo::ForceUTC forceUTC
,
3220 const char* locale
, double utcTime
, FormatSpec format
,
3221 MutableHandleValue rval
) {
3222 if (!std::isfinite(utcTime
)) {
3223 rval
.setString(cx
->names().Invalid_Date_
);
3227 MOZ_ASSERT(NumbersAreIdentical(TimeClip(utcTime
).toDouble(), utcTime
));
3229 double localTime
= LocalTime(forceUTC
, utcTime
);
3232 RootedString
timeZoneComment(cx
);
3233 if (format
== FormatSpec::DateTime
|| format
== FormatSpec::Time
) {
3234 // Offset from GMT in minutes. The offset includes daylight savings,
3236 int minutes
= (int)trunc((localTime
- utcTime
) / msPerMinute
);
3238 // Map 510 minutes to 0830 hours.
3239 offset
= (minutes
/ 60) * 100 + minutes
% 60;
3241 // Print as "Wed Nov 05 1997 19:38:03 GMT-0800 (PST)".
3243 // The TZA is printed as 'GMT-0800' rather than as 'PST' to avoid
3244 // operating-system dependence on strftime (which PRMJ_FormatTime
3245 // calls, for %Z only.) win32 prints PST as 'Pacific Standard Time.'
3246 // This way we always know what we're getting, and can parse it if
3247 // we produce it. The OS time zone string is included as a comment.
3249 // When ICU is used to retrieve the time zone string, the localized
3250 // 'long' name format from CLDR is used. For example when the default
3251 // locale is "en-US", PST is displayed as 'Pacific Standard Time', but
3252 // when it is "ru", 'Тихоокеанское стандартное время' is used. This
3253 // also means the time zone string may not fit into Latin-1.
3255 // Get a time zone string from the OS or ICU to include as a comment.
3256 timeZoneComment
= DateTimeHelper::timeZoneComment(cx
, forceUTC
, locale
,
3257 utcTime
, localTime
);
3258 if (!timeZoneComment
) {
3265 case FormatSpec::DateTime
:
3266 /* Tue Oct 31 2000 09:41:40 GMT-0800 */
3268 buf
, "%s %s %.2d %.4d %.2d:%.2d:%.2d GMT%+.4d",
3269 days
[int(WeekDay(localTime
))],
3270 months
[int(::MonthFromTime(localTime
))], int(DateFromTime(localTime
)),
3271 int(::YearFromTime(localTime
)), int(HourFromTime(localTime
)),
3272 int(MinFromTime(localTime
)), int(SecFromTime(localTime
)), offset
);
3274 case FormatSpec::Date
:
3275 /* Tue Oct 31 2000 */
3276 SprintfLiteral(buf
, "%s %s %.2d %.4d", days
[int(WeekDay(localTime
))],
3277 months
[int(::MonthFromTime(localTime
))],
3278 int(DateFromTime(localTime
)),
3279 int(::YearFromTime(localTime
)));
3281 case FormatSpec::Time
:
3282 /* 09:41:40 GMT-0800 */
3283 SprintfLiteral(buf
, "%.2d:%.2d:%.2d GMT%+.4d",
3284 int(HourFromTime(localTime
)), int(MinFromTime(localTime
)),
3285 int(SecFromTime(localTime
)), offset
);
3289 RootedString
str(cx
, NewStringCopyZ
<CanGC
>(cx
, buf
));
3294 // Append the time zone string if present.
3295 if (timeZoneComment
&& !timeZoneComment
->empty()) {
3296 str
= js::ConcatStrings
<CanGC
>(cx
, str
, timeZoneComment
);
3302 rval
.setString(str
);
3306 #if !JS_HAS_INTL_API
3307 static bool ToLocaleFormatHelper(JSContext
* cx
, DateObject
* unwrapped
,
3308 const char* format
, MutableHandleValue rval
) {
3309 DateTimeInfo::ForceUTC forceUTC
= unwrapped
->forceUTC();
3310 double utcTime
= unwrapped
->UTCTime().toNumber();
3312 const char* locale
= unwrapped
->realm()->getLocale();
3318 if (!std::isfinite(utcTime
)) {
3319 strcpy(buf
, "InvalidDate");
3321 double localTime
= LocalTime(forceUTC
, utcTime
);
3323 /* Let PRMJTime format it. */
3324 size_t result_len
= DateTimeHelper::formatTime(forceUTC
, buf
, sizeof buf
,
3325 format
, utcTime
, localTime
);
3327 /* If it failed, default to toString. */
3328 if (result_len
== 0) {
3329 return FormatDate(cx
, forceUTC
, locale
, utcTime
, FormatSpec::DateTime
,
3333 /* Hacked check against undesired 2-digit year 00/00/00 form. */
3334 if (strcmp(format
, "%x") == 0 && result_len
>= 6 &&
3335 /* Format %x means use OS settings, which may have 2-digit yr, so
3336 hack end of 3/11/22 or 11.03.22 or 11Mar22 to use 4-digit yr...*/
3337 !IsAsciiDigit(buf
[result_len
- 3]) &&
3338 IsAsciiDigit(buf
[result_len
- 2]) &&
3339 IsAsciiDigit(buf
[result_len
- 1]) &&
3340 /* ...but not if starts with 4-digit year, like 2022/3/11. */
3341 !(IsAsciiDigit(buf
[0]) && IsAsciiDigit(buf
[1]) &&
3342 IsAsciiDigit(buf
[2]) && IsAsciiDigit(buf
[3]))) {
3343 int year
= int(::YearFromTime(localTime
));
3344 snprintf(buf
+ (result_len
- 2), (sizeof buf
) - (result_len
- 2), "%d",
3349 if (cx
->runtime()->localeCallbacks
&&
3350 cx
->runtime()->localeCallbacks
->localeToUnicode
) {
3351 return cx
->runtime()->localeCallbacks
->localeToUnicode(cx
, buf
, rval
);
3354 JSString
* str
= NewStringCopyZ
<CanGC
>(cx
, buf
);
3358 rval
.setString(str
);
3363 static bool date_toLocaleString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3364 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toLocaleString");
3365 CallArgs args
= CallArgsFromVp(argc
, vp
);
3368 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toLocaleString");
3374 * Use '%#c' for windows, because '%c' is backward-compatible and non-y2k
3375 * with msvc; '%#c' requests that a full year be used in the result string.
3377 static const char format
[] =
3378 # if defined(_WIN32)
3385 return ToLocaleFormatHelper(cx
, unwrapped
, format
, args
.rval());
3388 static bool date_toLocaleDateString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3389 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype",
3390 "toLocaleDateString");
3391 CallArgs args
= CallArgsFromVp(argc
, vp
);
3394 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toLocaleDateString");
3400 * Use '%#x' for windows, because '%x' is backward-compatible and non-y2k
3401 * with msvc; '%#x' requests that a full year be used in the result string.
3403 static const char format
[] =
3404 # if defined(_WIN32)
3411 return ToLocaleFormatHelper(cx
, unwrapped
, format
, args
.rval());
3414 static bool date_toLocaleTimeString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3415 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype",
3416 "toLocaleTimeString");
3417 CallArgs args
= CallArgsFromVp(argc
, vp
);
3420 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toLocaleTimeString");
3425 return ToLocaleFormatHelper(cx
, unwrapped
, "%X", args
.rval());
3427 #endif /* !JS_HAS_INTL_API */
3429 static bool date_toTimeString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3430 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toTimeString");
3431 CallArgs args
= CallArgsFromVp(argc
, vp
);
3434 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toTimeString");
3439 const char* locale
= unwrapped
->realm()->getLocale();
3443 return FormatDate(cx
, unwrapped
->forceUTC(), locale
,
3444 unwrapped
->UTCTime().toNumber(), FormatSpec::Time
,
3448 static bool date_toDateString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3449 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toDateString");
3450 CallArgs args
= CallArgsFromVp(argc
, vp
);
3453 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toDateString");
3458 const char* locale
= unwrapped
->realm()->getLocale();
3462 return FormatDate(cx
, unwrapped
->forceUTC(), locale
,
3463 unwrapped
->UTCTime().toNumber(), FormatSpec::Date
,
3467 static bool date_toSource(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3468 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toSource");
3469 CallArgs args
= CallArgsFromVp(argc
, vp
);
3471 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toSource");
3476 JSStringBuilder
sb(cx
);
3477 if (!sb
.append("(new Date(") ||
3478 !NumberValueToStringBuilder(unwrapped
->UTCTime(), sb
) ||
3483 JSString
* str
= sb
.finishString();
3487 args
.rval().setString(str
);
3491 bool date_toString(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3492 AutoJSMethodProfilerEntry
pseudoFrame(cx
, "Date.prototype", "toString");
3493 CallArgs args
= CallArgsFromVp(argc
, vp
);
3495 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toString");
3500 const char* locale
= unwrapped
->realm()->getLocale();
3504 return FormatDate(cx
, unwrapped
->forceUTC(), locale
,
3505 unwrapped
->UTCTime().toNumber(), FormatSpec::DateTime
,
3509 bool js::date_valueOf(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3510 CallArgs args
= CallArgsFromVp(argc
, vp
);
3512 auto* unwrapped
= UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "valueOf");
3517 args
.rval().set(unwrapped
->UTCTime());
3521 // ES6 20.3.4.45 Date.prototype[@@toPrimitive]
3522 static bool date_toPrimitive(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3523 CallArgs args
= CallArgsFromVp(argc
, vp
);
3526 if (!args
.thisv().isObject()) {
3527 ReportIncompatible(cx
, args
);
3533 if (!GetFirstArgumentAsTypeHint(cx
, args
, &hint
)) {
3536 if (hint
== JSTYPE_UNDEFINED
) {
3537 hint
= JSTYPE_STRING
;
3540 args
.rval().set(args
.thisv());
3541 RootedObject
obj(cx
, &args
.thisv().toObject());
3542 return OrdinaryToPrimitive(cx
, obj
, hint
, args
.rval());
3545 #if JS_HAS_TEMPORAL_API
3547 * Date.prototype.toTemporalInstant ( )
3549 static bool date_toTemporalInstant(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3550 CallArgs args
= CallArgsFromVp(argc
, vp
);
3554 UnwrapAndTypeCheckThis
<DateObject
>(cx
, args
, "toTemporalInstant");
3560 double utctime
= unwrapped
->UTCTime().toNumber();
3561 if (!std::isfinite(utctime
)) {
3562 JS_ReportErrorNumberASCII(cx
, js::GetErrorMessage
, nullptr,
3563 JSMSG_INVALID_DATE
);
3566 MOZ_ASSERT(IsInteger(utctime
));
3568 auto instant
= temporal::Instant::fromMilliseconds(int64_t(utctime
));
3569 MOZ_ASSERT(temporal::IsValidEpochInstant(instant
));
3572 auto* result
= temporal::CreateTemporalInstant(cx
, instant
);
3576 args
.rval().setObject(*result
);
3579 #endif /* JS_HAS_TEMPORAL_API */
3581 static const JSFunctionSpec date_static_methods
[] = {
3582 JS_FN("UTC", date_UTC
, 7, 0),
3583 JS_FN("parse", date_parse
, 1, 0),
3584 JS_FN("now", date_now
, 0, 0),
3588 static const JSFunctionSpec date_methods
[] = {
3589 JS_FN("getTime", date_getTime
, 0, 0),
3590 JS_FN("getTimezoneOffset", date_getTimezoneOffset
, 0, 0),
3591 JS_FN("getYear", date_getYear
, 0, 0),
3592 JS_FN("getFullYear", date_getFullYear
, 0, 0),
3593 JS_FN("getUTCFullYear", date_getUTCFullYear
, 0, 0),
3594 JS_FN("getMonth", date_getMonth
, 0, 0),
3595 JS_FN("getUTCMonth", date_getUTCMonth
, 0, 0),
3596 JS_FN("getDate", date_getDate
, 0, 0),
3597 JS_FN("getUTCDate", date_getUTCDate
, 0, 0),
3598 JS_FN("getDay", date_getDay
, 0, 0),
3599 JS_FN("getUTCDay", date_getUTCDay
, 0, 0),
3600 JS_FN("getHours", date_getHours
, 0, 0),
3601 JS_FN("getUTCHours", date_getUTCHours
, 0, 0),
3602 JS_FN("getMinutes", date_getMinutes
, 0, 0),
3603 JS_FN("getUTCMinutes", date_getUTCMinutes
, 0, 0),
3604 JS_FN("getSeconds", date_getSeconds
, 0, 0),
3605 JS_FN("getUTCSeconds", date_getUTCSeconds
, 0, 0),
3606 JS_FN("getMilliseconds", date_getMilliseconds
, 0, 0),
3607 JS_FN("getUTCMilliseconds", date_getUTCMilliseconds
, 0, 0),
3608 JS_FN("setTime", date_setTime
, 1, 0),
3609 JS_FN("setYear", date_setYear
, 1, 0),
3610 JS_FN("setFullYear", date_setFullYear
, 3, 0),
3611 JS_FN("setUTCFullYear", date_setUTCFullYear
, 3, 0),
3612 JS_FN("setMonth", date_setMonth
, 2, 0),
3613 JS_FN("setUTCMonth", date_setUTCMonth
, 2, 0),
3614 JS_FN("setDate", date_setDate
, 1, 0),
3615 JS_FN("setUTCDate", date_setUTCDate
, 1, 0),
3616 JS_FN("setHours", date_setHours
, 4, 0),
3617 JS_FN("setUTCHours", date_setUTCHours
, 4, 0),
3618 JS_FN("setMinutes", date_setMinutes
, 3, 0),
3619 JS_FN("setUTCMinutes", date_setUTCMinutes
, 3, 0),
3620 JS_FN("setSeconds", date_setSeconds
, 2, 0),
3621 JS_FN("setUTCSeconds", date_setUTCSeconds
, 2, 0),
3622 JS_FN("setMilliseconds", date_setMilliseconds
, 1, 0),
3623 JS_FN("setUTCMilliseconds", date_setUTCMilliseconds
, 1, 0),
3624 JS_FN("toUTCString", date_toUTCString
, 0, 0),
3625 #if JS_HAS_TEMPORAL_API
3626 JS_FN("toTemporalInstant", date_toTemporalInstant
, 0, 0),
3629 JS_SELF_HOSTED_FN("toLocaleString", "Date_toLocaleString", 0, 0),
3630 JS_SELF_HOSTED_FN("toLocaleDateString", "Date_toLocaleDateString", 0, 0),
3631 JS_SELF_HOSTED_FN("toLocaleTimeString", "Date_toLocaleTimeString", 0, 0),
3633 JS_FN("toLocaleString", date_toLocaleString
, 0, 0),
3634 JS_FN("toLocaleDateString", date_toLocaleDateString
, 0, 0),
3635 JS_FN("toLocaleTimeString", date_toLocaleTimeString
, 0, 0),
3637 JS_FN("toDateString", date_toDateString
, 0, 0),
3638 JS_FN("toTimeString", date_toTimeString
, 0, 0),
3639 JS_FN("toISOString", date_toISOString
, 0, 0),
3640 JS_FN("toJSON", date_toJSON
, 1, 0),
3641 JS_FN("toSource", date_toSource
, 0, 0),
3642 JS_FN("toString", date_toString
, 0, 0),
3643 JS_FN("valueOf", date_valueOf
, 0, 0),
3644 JS_SYM_FN(toPrimitive
, date_toPrimitive
, 1, JSPROP_READONLY
),
3648 static bool NewDateObject(JSContext
* cx
, const CallArgs
& args
, ClippedTime t
) {
3649 MOZ_ASSERT(args
.isConstructing());
3651 RootedObject
proto(cx
);
3652 if (!GetPrototypeFromBuiltinConstructor(cx
, args
, JSProto_Date
, &proto
)) {
3656 JSObject
* obj
= NewDateObjectMsec(cx
, t
, proto
);
3661 args
.rval().setObject(*obj
);
3665 static bool ToDateString(JSContext
* cx
, const CallArgs
& args
, ClippedTime t
) {
3666 const char* locale
= cx
->realm()->getLocale();
3670 return FormatDate(cx
, ForceUTC(cx
->realm()), locale
, t
.toDouble(),
3671 FormatSpec::DateTime
, args
.rval());
3674 static bool DateNoArguments(JSContext
* cx
, const CallArgs
& args
) {
3675 MOZ_ASSERT(args
.length() == 0);
3677 ClippedTime now
= NowAsMillis(cx
);
3679 if (args
.isConstructing()) {
3680 return NewDateObject(cx
, args
, now
);
3683 return ToDateString(cx
, args
, now
);
3686 static bool DateOneArgument(JSContext
* cx
, const CallArgs
& args
) {
3687 MOZ_ASSERT(args
.length() == 1);
3689 if (args
.isConstructing()) {
3690 if (args
[0].isObject()) {
3691 RootedObject
obj(cx
, &args
[0].toObject());
3694 if (!GetBuiltinClass(cx
, obj
, &cls
)) {
3698 if (cls
== ESClass::Date
) {
3699 RootedValue
unboxed(cx
);
3700 if (!Unbox(cx
, obj
, &unboxed
)) {
3704 return NewDateObject(cx
, args
, TimeClip(unboxed
.toNumber()));
3708 if (!ToPrimitive(cx
, args
[0])) {
3713 if (args
[0].isString()) {
3714 JSLinearString
* linearStr
= args
[0].toString()->ensureLinear(cx
);
3719 if (!ParseDate(ForceUTC(cx
->realm()), linearStr
, &t
)) {
3720 t
= ClippedTime::invalid();
3724 if (!ToNumber(cx
, args
[0], &d
)) {
3730 return NewDateObject(cx
, args
, t
);
3733 return ToDateString(cx
, args
, NowAsMillis(cx
));
3736 static bool DateMultipleArguments(JSContext
* cx
, const CallArgs
& args
) {
3737 MOZ_ASSERT(args
.length() >= 2);
3740 if (args
.isConstructing()) {
3743 if (!ToNumber(cx
, args
[0], &y
)) {
3749 if (!ToNumber(cx
, args
[1], &m
)) {
3755 if (args
.length() >= 3) {
3756 if (!ToNumber(cx
, args
[2], &dt
)) {
3765 if (args
.length() >= 4) {
3766 if (!ToNumber(cx
, args
[3], &h
)) {
3775 if (args
.length() >= 5) {
3776 if (!ToNumber(cx
, args
[4], &min
)) {
3785 if (args
.length() >= 6) {
3786 if (!ToNumber(cx
, args
[5], &s
)) {
3795 if (args
.length() >= 7) {
3796 if (!ToNumber(cx
, args
[6], &milli
)) {
3805 if (!std::isnan(y
)) {
3806 double yint
= ToInteger(y
);
3807 if (0 <= yint
&& yint
<= 99) {
3813 double finalDate
= MakeDate(MakeDay(yr
, m
, dt
), MakeTime(h
, min
, s
, milli
));
3816 return NewDateObject(cx
, args
,
3817 TimeClip(UTC(ForceUTC(cx
->realm()), finalDate
)));
3820 return ToDateString(cx
, args
, NowAsMillis(cx
));
3823 static bool DateConstructor(JSContext
* cx
, unsigned argc
, Value
* vp
) {
3824 AutoJSConstructorProfilerEntry
pseudoFrame(cx
, "Date");
3825 CallArgs args
= CallArgsFromVp(argc
, vp
);
3827 if (args
.length() == 0) {
3828 return DateNoArguments(cx
, args
);
3831 if (args
.length() == 1) {
3832 return DateOneArgument(cx
, args
);
3835 return DateMultipleArguments(cx
, args
);
3838 static bool FinishDateClassInit(JSContext
* cx
, HandleObject ctor
,
3839 HandleObject proto
) {
3841 * Date.prototype.toGMTString has the same initial value as
3842 * Date.prototype.toUTCString.
3844 RootedValue
toUTCStringFun(cx
);
3845 RootedId
toUTCStringId(cx
, NameToId(cx
->names().toUTCString
));
3846 RootedId
toGMTStringId(cx
, NameToId(cx
->names().toGMTString
));
3847 return NativeGetProperty(cx
, proto
.as
<NativeObject
>(), toUTCStringId
,
3849 NativeDefineDataProperty(cx
, proto
.as
<NativeObject
>(), toGMTStringId
,
3853 static const ClassSpec DateObjectClassSpec
= {
3854 GenericCreateConstructor
<DateConstructor
, 7, gc::AllocKind::FUNCTION
>,
3855 GenericCreatePrototype
<DateObject
>,
3856 date_static_methods
,
3860 FinishDateClassInit
,
3863 const JSClass
DateObject::class_
= {
3865 JSCLASS_HAS_RESERVED_SLOTS(RESERVED_SLOTS
) |
3866 JSCLASS_HAS_CACHED_PROTO(JSProto_Date
),
3868 &DateObjectClassSpec
,
3871 const JSClass
DateObject::protoClass_
= {
3873 JSCLASS_HAS_CACHED_PROTO(JSProto_Date
),
3875 &DateObjectClassSpec
,
3878 JSObject
* js::NewDateObjectMsec(JSContext
* cx
, ClippedTime t
,
3879 HandleObject proto
/* = nullptr */) {
3880 DateObject
* obj
= NewObjectWithClassProto
<DateObject
>(cx
, proto
);
3888 JS_PUBLIC_API JSObject
* JS::NewDateObject(JSContext
* cx
, ClippedTime time
) {
3891 return NewDateObjectMsec(cx
, time
);
3894 JS_PUBLIC_API JSObject
* js::NewDateObject(JSContext
* cx
, int year
, int mon
,
3895 int mday
, int hour
, int min
,
3897 MOZ_ASSERT(mon
< 12);
3899 MakeDate(MakeDay(year
, mon
, mday
), MakeTime(hour
, min
, sec
, 0.0));
3900 return NewDateObjectMsec(cx
, TimeClip(UTC(ForceUTC(cx
->realm()), msec_time
)));
3903 JS_PUBLIC_API
bool js::DateIsValid(JSContext
* cx
, HandleObject obj
,
3906 if (!GetBuiltinClass(cx
, obj
, &cls
)) {
3910 if (cls
!= ESClass::Date
) {
3915 RootedValue
unboxed(cx
);
3916 if (!Unbox(cx
, obj
, &unboxed
)) {
3920 *isValid
= !std::isnan(unboxed
.toNumber());
3924 JS_PUBLIC_API JSObject
* JS::NewDateObject(JSContext
* cx
, int year
, int mon
,
3925 int mday
, int hour
, int min
,
3929 return js::NewDateObject(cx
, year
, mon
, mday
, hour
, min
, sec
);
3932 JS_PUBLIC_API
bool JS::ObjectIsDate(JSContext
* cx
, Handle
<JSObject
*> obj
,
3937 if (!GetBuiltinClass(cx
, obj
, &cls
)) {
3941 *isDate
= cls
== ESClass::Date
;
3945 JS_PUBLIC_API
bool js::DateGetMsecSinceEpoch(JSContext
* cx
, HandleObject obj
,
3946 double* msecsSinceEpoch
) {
3948 if (!GetBuiltinClass(cx
, obj
, &cls
)) {
3952 if (cls
!= ESClass::Date
) {
3953 *msecsSinceEpoch
= 0;
3957 RootedValue
unboxed(cx
);
3958 if (!Unbox(cx
, obj
, &unboxed
)) {
3962 *msecsSinceEpoch
= unboxed
.toNumber();
3966 JS_PUBLIC_API
bool JS::IsISOStyleDate(JSContext
* cx
,
3967 const JS::Latin1Chars
& str
) {
3969 return ParseISOStyleDate(ForceUTC(cx
->realm()), str
.begin().get(),
3970 str
.length(), &result
);