From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- js/src/jsdate.cpp | 3767 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 3767 insertions(+) create mode 100644 js/src/jsdate.cpp (limited to 'js/src/jsdate.cpp') diff --git a/js/src/jsdate.cpp b/js/src/jsdate.cpp new file mode 100644 index 0000000000..c17aeb828c --- /dev/null +++ b/js/src/jsdate.cpp @@ -0,0 +1,3767 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* + * JS date methods. + * + * "For example, OS/360 devotes 26 bytes of the permanently + * resident date-turnover routine to the proper handling of + * December 31 on leap years (when it is Day 366). That + * might have been left to the operator." + * + * Frederick Brooks, 'The Second-System Effect'. + */ + +#include "jsdate.h" + +#include "mozilla/Atomics.h" +#include "mozilla/Casting.h" +#include "mozilla/FloatingPoint.h" +#include "mozilla/Sprintf.h" +#include "mozilla/TextUtils.h" + +#include +#include +#include +#include + +#include "jsapi.h" +#include "jsfriendapi.h" +#include "jsnum.h" +#include "jstypes.h" + +#include "js/CallAndConstruct.h" // JS::IsCallable +#include "js/Conversions.h" +#include "js/Date.h" +#include "js/friend/ErrorMessages.h" // js::GetErrorMessage, JSMSG_* +#include "js/LocaleSensitive.h" +#include "js/Object.h" // JS::GetBuiltinClass +#include "js/PropertySpec.h" +#include "js/Wrapper.h" +#include "util/DifferentialTesting.h" +#include "util/StringBuffer.h" +#include "util/Text.h" +#include "vm/DateObject.h" +#include "vm/DateTime.h" +#include "vm/GlobalObject.h" +#include "vm/Interpreter.h" +#include "vm/JSContext.h" +#include "vm/JSObject.h" +#include "vm/StringType.h" +#include "vm/Time.h" +#include "vm/WellKnownAtom.h" // js_*_str + +#include "vm/Compartment-inl.h" // For js::UnwrapAndTypeCheckThis +#include "vm/GeckoProfiler-inl.h" +#include "vm/JSObject-inl.h" + +using namespace js; + +using mozilla::Atomic; +using mozilla::BitwiseCast; +using mozilla::IsAsciiAlpha; +using mozilla::IsAsciiDigit; +using mozilla::IsAsciiLowercaseAlpha; +using mozilla::NumbersAreIdentical; +using mozilla::Relaxed; + +using JS::AutoCheckCannotGC; +using JS::ClippedTime; +using JS::GenericNaN; +using JS::GetBuiltinClass; +using JS::TimeClip; +using JS::ToInteger; + +// When this value is non-zero, we'll round the time by this resolution. +static Atomic sResolutionUsec; +// This is not implemented yet, but we will use this to know to jitter the time +// in the JS shell +static Atomic sJitter; +// The callback we will use for the Gecko implementation of Timer +// Clamping/Jittering +static Atomic + sReduceMicrosecondTimePrecisionCallback; + +/* + * The JS 'Date' object is patterned after the Java 'Date' object. + * Here is a script: + * + * today = new Date(); + * + * print(today.toLocaleString()); + * + * weekDay = today.getDay(); + * + * + * These Java (and ECMA-262) methods are supported: + * + * UTC + * getDate (getUTCDate) + * getDay (getUTCDay) + * getHours (getUTCHours) + * getMinutes (getUTCMinutes) + * getMonth (getUTCMonth) + * getSeconds (getUTCSeconds) + * getMilliseconds (getUTCMilliseconds) + * getTime + * getTimezoneOffset + * getYear + * getFullYear (getUTCFullYear) + * parse + * setDate (setUTCDate) + * setHours (setUTCHours) + * setMinutes (setUTCMinutes) + * setMonth (setUTCMonth) + * setSeconds (setUTCSeconds) + * setMilliseconds (setUTCMilliseconds) + * setTime + * setYear (setFullYear, setUTCFullYear) + * toGMTString (toUTCString) + * toLocaleString + * toString + * + * + * These Java methods are not supported + * + * setDay + * before + * after + * equals + * hashCode + */ + +namespace { + +class DateTimeHelper { + private: +#if JS_HAS_INTL_API + static double localTZA(DateTimeInfo::ShouldRFP shouldRFP, double t, + DateTimeInfo::TimeZoneOffset offset); +#else + static int equivalentYearForDST(int year); + static bool isRepresentableAsTime32(double t); + static double daylightSavingTA(DateTimeInfo::ShouldRFP shouldRFP, double t); + static double adjustTime(DateTimeInfo::ShouldRFP shouldRFP, double date); + static PRMJTime toPRMJTime(DateTimeInfo::ShouldRFP shouldRFP, + double localTime, double utcTime); +#endif + + public: + static double localTime(DateTimeInfo::ShouldRFP shouldRFP, double t); + static double UTC(DateTimeInfo::ShouldRFP shouldRFP, double t); + static JSString* timeZoneComment(JSContext* cx, + DateTimeInfo::ShouldRFP shouldRFP, + double utcTime, double localTime); +#if !JS_HAS_INTL_API + static size_t formatTime(DateTimeInfo::ShouldRFP shouldRFP, char* buf, + size_t buflen, const char* fmt, double utcTime, + double localTime); +#endif +}; + +} // namespace + +static DateTimeInfo::ShouldRFP ShouldRFP(const Realm* realm) { + return realm->behaviors().shouldResistFingerprinting() + ? DateTimeInfo::ShouldRFP::Yes + : DateTimeInfo::ShouldRFP::No; +} + +// ES2019 draft rev 0ceb728a1adbffe42b26972a6541fd7f398b1557 +// 5.2.5 Mathematical Operations +static inline double PositiveModulo(double dividend, double divisor) { + MOZ_ASSERT(divisor > 0); + MOZ_ASSERT(std::isfinite(divisor)); + + double result = fmod(dividend, divisor); + if (result < 0) { + result += divisor; + } + return result + (+0.0); +} + +static inline double Day(double t) { return floor(t / msPerDay); } + +static double TimeWithinDay(double t) { return PositiveModulo(t, msPerDay); } + +/* ES5 15.9.1.3. */ +static inline bool IsLeapYear(double year) { + MOZ_ASSERT(ToInteger(year) == year); + return fmod(year, 4) == 0 && (fmod(year, 100) != 0 || fmod(year, 400) == 0); +} + +static inline double DaysInYear(double year) { + if (!std::isfinite(year)) { + return GenericNaN(); + } + return IsLeapYear(year) ? 366 : 365; +} + +static inline double DayFromYear(double y) { + return 365 * (y - 1970) + floor((y - 1969) / 4.0) - + floor((y - 1901) / 100.0) + floor((y - 1601) / 400.0); +} + +static inline double TimeFromYear(double y) { + return DayFromYear(y) * msPerDay; +} + +static double YearFromTime(double t) { + if (!std::isfinite(t)) { + return GenericNaN(); + } + + MOZ_ASSERT(ToInteger(t) == t); + + double y = floor(t / (msPerDay * 365.2425)) + 1970; + double t2 = TimeFromYear(y); + + /* + * Adjust the year if the approximation was wrong. Since the year was + * computed using the average number of ms per year, it will usually + * be wrong for dates within several hours of a year transition. + */ + if (t2 > t) { + y--; + } else { + if (t2 + msPerDay * DaysInYear(y) <= t) { + y++; + } + } + return y; +} + +static inline int DaysInFebruary(double year) { + return IsLeapYear(year) ? 29 : 28; +} + +/* ES5 15.9.1.4. */ +static inline double DayWithinYear(double t, double year) { + MOZ_ASSERT_IF(std::isfinite(t), YearFromTime(t) == year); + return Day(t) - DayFromYear(year); +} + +static double MonthFromTime(double t) { + if (!std::isfinite(t)) { + return GenericNaN(); + } + + double year = YearFromTime(t); + double d = DayWithinYear(t, year); + + int step; + if (d < (step = 31)) { + return 0; + } + if (d < (step += DaysInFebruary(year))) { + return 1; + } + if (d < (step += 31)) { + return 2; + } + if (d < (step += 30)) { + return 3; + } + if (d < (step += 31)) { + return 4; + } + if (d < (step += 30)) { + return 5; + } + if (d < (step += 31)) { + return 6; + } + if (d < (step += 31)) { + return 7; + } + if (d < (step += 30)) { + return 8; + } + if (d < (step += 31)) { + return 9; + } + if (d < (step += 30)) { + return 10; + } + return 11; +} + +/* ES5 15.9.1.5. */ +static double DateFromTime(double t) { + if (!std::isfinite(t)) { + return GenericNaN(); + } + + double year = YearFromTime(t); + double d = DayWithinYear(t, year); + + int next; + if (d <= (next = 30)) { + return d + 1; + } + int step = next; + if (d <= (next += DaysInFebruary(year))) { + return d - step; + } + step = next; + if (d <= (next += 31)) { + return d - step; + } + step = next; + if (d <= (next += 30)) { + return d - step; + } + step = next; + if (d <= (next += 31)) { + return d - step; + } + step = next; + if (d <= (next += 30)) { + return d - step; + } + step = next; + if (d <= (next += 31)) { + return d - step; + } + step = next; + if (d <= (next += 31)) { + return d - step; + } + step = next; + if (d <= (next += 30)) { + return d - step; + } + step = next; + if (d <= (next += 31)) { + return d - step; + } + step = next; + if (d <= (next += 30)) { + return d - step; + } + step = next; + return d - step; +} + +/* ES5 15.9.1.6. */ +static int WeekDay(double t) { + /* + * We can't assert TimeClip(t) == t because we call this function with + * local times, which can be offset outside TimeClip's permitted range. + */ + MOZ_ASSERT(ToInteger(t) == t); + int result = (int(Day(t)) + 4) % 7; + if (result < 0) { + result += 7; + } + return result; +} + +static inline int DayFromMonth(int month, bool isLeapYear) { + /* + * The following array contains the day of year for the first day of + * each month, where index 0 is January, and day 0 is January 1. + */ + static const int firstDayOfMonth[2][13] = { + {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365}, + {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}}; + + MOZ_ASSERT(0 <= month && month <= 12); + return firstDayOfMonth[isLeapYear][month]; +} + +template +static inline int DayFromMonth(T month, bool isLeapYear) = delete; + +/* ES5 15.9.1.12 (out of order to accommodate DaylightSavingTA). */ +static double MakeDay(double year, double month, double date) { + /* Step 1. */ + if (!std::isfinite(year) || !std::isfinite(month) || !std::isfinite(date)) { + return GenericNaN(); + } + + /* Steps 2-4. */ + double y = ToInteger(year); + double m = ToInteger(month); + double dt = ToInteger(date); + + /* Step 5. */ + double ym = y + floor(m / 12); + + /* Step 6. */ + int mn = int(PositiveModulo(m, 12)); + + /* Steps 7-8. */ + bool leap = IsLeapYear(ym); + + double yearday = floor(TimeFromYear(ym) / msPerDay); + double monthday = DayFromMonth(mn, leap); + + return yearday + monthday + dt - 1; +} + +/* ES5 15.9.1.13 (out of order to accommodate DaylightSavingTA). */ +static inline double MakeDate(double day, double time) { + /* Step 1. */ + if (!std::isfinite(day) || !std::isfinite(time)) { + return GenericNaN(); + } + + /* Step 2. */ + return day * msPerDay + time; +} + +JS_PUBLIC_API double JS::MakeDate(double year, unsigned month, unsigned day) { + MOZ_ASSERT(month <= 11); + MOZ_ASSERT(day >= 1 && day <= 31); + + return ::MakeDate(MakeDay(year, month, day), 0); +} + +JS_PUBLIC_API double JS::MakeDate(double year, unsigned month, unsigned day, + double time) { + MOZ_ASSERT(month <= 11); + MOZ_ASSERT(day >= 1 && day <= 31); + + return ::MakeDate(MakeDay(year, month, day), time); +} + +JS_PUBLIC_API double JS::YearFromTime(double time) { + return ::YearFromTime(time); +} + +JS_PUBLIC_API double JS::MonthFromTime(double time) { + return ::MonthFromTime(time); +} + +JS_PUBLIC_API double JS::DayFromTime(double time) { return DateFromTime(time); } + +JS_PUBLIC_API double JS::DayFromYear(double year) { + return ::DayFromYear(year); +} + +JS_PUBLIC_API double JS::DayWithinYear(double time, double year) { + return ::DayWithinYear(time, year); +} + +JS_PUBLIC_API void JS::SetReduceMicrosecondTimePrecisionCallback( + JS::ReduceMicrosecondTimePrecisionCallback callback) { + sReduceMicrosecondTimePrecisionCallback = callback; +} + +JS_PUBLIC_API void JS::SetTimeResolutionUsec(uint32_t resolution, bool jitter) { + sResolutionUsec = resolution; + sJitter = jitter; +} + +#if JS_HAS_INTL_API +// ES2019 draft rev 0ceb728a1adbffe42b26972a6541fd7f398b1557 +// 20.3.1.7 LocalTZA ( t, isUTC ) +double DateTimeHelper::localTZA(DateTimeInfo::ShouldRFP shouldRFP, double t, + DateTimeInfo::TimeZoneOffset offset) { + MOZ_ASSERT(std::isfinite(t)); + + int64_t milliseconds = static_cast(t); + int32_t offsetMilliseconds = + DateTimeInfo::getOffsetMilliseconds(shouldRFP, milliseconds, offset); + return static_cast(offsetMilliseconds); +} + +// ES2019 draft rev 0ceb728a1adbffe42b26972a6541fd7f398b1557 +// 20.3.1.8 LocalTime ( t ) +double DateTimeHelper::localTime(DateTimeInfo::ShouldRFP shouldRFP, double t) { + if (!std::isfinite(t)) { + return GenericNaN(); + } + + MOZ_ASSERT(StartOfTime <= t && t <= EndOfTime); + return t + localTZA(shouldRFP, t, DateTimeInfo::TimeZoneOffset::UTC); +} + +// ES2019 draft rev 0ceb728a1adbffe42b26972a6541fd7f398b1557 +// 20.3.1.9 UTC ( t ) +double DateTimeHelper::UTC(DateTimeInfo::ShouldRFP shouldRFP, double t) { + if (!std::isfinite(t)) { + return GenericNaN(); + } + + if (t < (StartOfTime - msPerDay) || t > (EndOfTime + msPerDay)) { + return GenericNaN(); + } + + return t - localTZA(shouldRFP, t, DateTimeInfo::TimeZoneOffset::Local); +} +#else +/* + * Find a year for which any given date will fall on the same weekday. + * + * This function should be used with caution when used other than + * for determining DST; it hasn't been proven not to produce an + * incorrect year for times near year boundaries. + */ +int DateTimeHelper::equivalentYearForDST(int year) { + /* + * Years and leap years on which Jan 1 is a Sunday, Monday, etc. + * + * yearStartingWith[0][i] is an example non-leap year where + * Jan 1 appears on Sunday (i == 0), Monday (i == 1), etc. + * + * yearStartingWith[1][i] is an example leap year where + * Jan 1 appears on Sunday (i == 0), Monday (i == 1), etc. + * + * Keep two different mappings, one for past years (< 1970), and a + * different one for future years (> 2037). + */ + static const int pastYearStartingWith[2][7] = { + {1978, 1973, 1974, 1975, 1981, 1971, 1977}, + {1984, 1996, 1980, 1992, 1976, 1988, 1972}}; + static const int futureYearStartingWith[2][7] = { + {2034, 2035, 2030, 2031, 2037, 2027, 2033}, + {2012, 2024, 2036, 2020, 2032, 2016, 2028}}; + + int day = int(DayFromYear(year) + 4) % 7; + if (day < 0) { + day += 7; + } + + const auto& yearStartingWith = + year < 1970 ? pastYearStartingWith : futureYearStartingWith; + return yearStartingWith[IsLeapYear(year)][day]; +} + +// Return true if |t| is representable as a 32-bit time_t variable, that means +// the year is in [1970, 2038). +bool DateTimeHelper::isRepresentableAsTime32(double t) { + return 0.0 <= t && t < 2145916800000.0; +} + +/* ES5 15.9.1.8. */ +double DateTimeHelper::daylightSavingTA(DateTimeInfo::ShouldRFP shouldRFP, + double t) { + if (!std::isfinite(t)) { + return GenericNaN(); + } + + /* + * If earlier than 1970 or after 2038, potentially beyond the ken of + * many OSes, map it to an equivalent year before asking. + */ + if (!isRepresentableAsTime32(t)) { + int year = equivalentYearForDST(int(YearFromTime(t))); + double day = MakeDay(year, MonthFromTime(t), DateFromTime(t)); + t = MakeDate(day, TimeWithinDay(t)); + } + + int64_t utcMilliseconds = static_cast(t); + int32_t offsetMilliseconds = + DateTimeInfo::getDSTOffsetMilliseconds(shouldRFP, utcMilliseconds); + return static_cast(offsetMilliseconds); +} + +double DateTimeHelper::adjustTime(DateTimeInfo::ShouldRFP shouldRFP, + double date) { + double localTZA = DateTimeInfo::localTZA(shouldRFP); + double t = daylightSavingTA(shouldRFP, date) + localTZA; + t = (localTZA >= 0) ? fmod(t, msPerDay) : -fmod(msPerDay - t, msPerDay); + return t; +} + +/* ES5 15.9.1.9. */ +double DateTimeHelper::localTime(DateTimeInfo::ShouldRFP shouldRFP, double t) { + return t + adjustTime(shouldRFP, t); +} + +double DateTimeHelper::UTC(DateTimeInfo::ShouldRFP shouldRFP, double t) { + // Following the ES2017 specification creates undesirable results at DST + // transitions. For example when transitioning from PST to PDT, + // |new Date(2016,2,13,2,0,0).toTimeString()| returns the string value + // "01:00:00 GMT-0800 (PST)" instead of "03:00:00 GMT-0700 (PDT)". Follow + // V8 and subtract one hour before computing the offset. + // Spec bug: https://bugs.ecmascript.org/show_bug.cgi?id=4007 + + return t - adjustTime(shouldRFP, + t - DateTimeInfo::localTZA(shouldRFP) - msPerHour); +} +#endif /* JS_HAS_INTL_API */ + +static double LocalTime(DateTimeInfo::ShouldRFP shouldRFP, double t) { + return DateTimeHelper::localTime(shouldRFP, t); +} + +static double UTC(DateTimeInfo::ShouldRFP shouldRFP, double t) { + return DateTimeHelper::UTC(shouldRFP, t); +} + +/* ES5 15.9.1.10. */ +static double HourFromTime(double t) { + return PositiveModulo(floor(t / msPerHour), HoursPerDay); +} + +static double MinFromTime(double t) { + return PositiveModulo(floor(t / msPerMinute), MinutesPerHour); +} + +static double SecFromTime(double t) { + return PositiveModulo(floor(t / msPerSecond), SecondsPerMinute); +} + +static double msFromTime(double t) { return PositiveModulo(t, msPerSecond); } + +/* ES5 15.9.1.11. */ +static double MakeTime(double hour, double min, double sec, double ms) { + /* Step 1. */ + if (!std::isfinite(hour) || !std::isfinite(min) || !std::isfinite(sec) || + !std::isfinite(ms)) { + return GenericNaN(); + } + + /* Step 2. */ + double h = ToInteger(hour); + + /* Step 3. */ + double m = ToInteger(min); + + /* Step 4. */ + double s = ToInteger(sec); + + /* Step 5. */ + double milli = ToInteger(ms); + + /* Steps 6-7. */ + return h * msPerHour + m * msPerMinute + s * msPerSecond + milli; +} + +/** + * end of ECMA 'support' functions + */ + +// ES2017 draft rev (TODO: Add git hash when PR 642 is merged.) +// 20.3.3.4 +// Date.UTC(year [, month [, date [, hours [, minutes [, seconds [, ms]]]]]]) +static bool date_UTC(JSContext* cx, unsigned argc, Value* vp) { + AutoJSMethodProfilerEntry pseudoFrame(cx, "Date", "UTC"); + CallArgs args = CallArgsFromVp(argc, vp); + + // Step 1. + double y; + if (!ToNumber(cx, args.get(0), &y)) { + return false; + } + + // Step 2. + double m; + if (args.length() >= 2) { + if (!ToNumber(cx, args[1], &m)) { + return false; + } + } else { + m = 0; + } + + // Step 3. + double dt; + if (args.length() >= 3) { + if (!ToNumber(cx, args[2], &dt)) { + return false; + } + } else { + dt = 1; + } + + // Step 4. + double h; + if (args.length() >= 4) { + if (!ToNumber(cx, args[3], &h)) { + return false; + } + } else { + h = 0; + } + + // Step 5. + double min; + if (args.length() >= 5) { + if (!ToNumber(cx, args[4], &min)) { + return false; + } + } else { + min = 0; + } + + // Step 6. + double s; + if (args.length() >= 6) { + if (!ToNumber(cx, args[5], &s)) { + return false; + } + } else { + s = 0; + } + + // Step 7. + double milli; + if (args.length() >= 7) { + if (!ToNumber(cx, args[6], &milli)) { + return false; + } + } else { + milli = 0; + } + + // Step 8. + double yr = y; + if (!std::isnan(y)) { + double yint = ToInteger(y); + if (0 <= yint && yint <= 99) { + yr = 1900 + yint; + } + } + + // Step 9. + ClippedTime time = + TimeClip(MakeDate(MakeDay(yr, m, dt), MakeTime(h, min, s, milli))); + args.rval().set(TimeValue(time)); + return true; +} + +/* + * Read and convert decimal digits from s[*i] into *result + * while *i < limit. + * + * Succeed if any digits are converted. Advance *i only + * as digits are consumed. + */ +template +static bool ParseDigits(size_t* result, const CharT* s, size_t* i, + size_t limit) { + size_t init = *i; + *result = 0; + while (*i < limit && ('0' <= s[*i] && s[*i] <= '9')) { + *result *= 10; + *result += (s[*i] - '0'); + ++(*i); + } + return *i != init; +} + +/* + * Read and convert decimal digits to the right of a decimal point, + * representing a fractional integer, from s[*i] into *result + * while *i < limit. + * + * Succeed if any digits are converted. Advance *i only + * as digits are consumed. + */ +template +static bool ParseFractional(double* result, const CharT* s, size_t* i, + size_t limit) { + double factor = 0.1; + size_t init = *i; + *result = 0.0; + while (*i < limit && ('0' <= s[*i] && s[*i] <= '9')) { + *result += (s[*i] - '0') * factor; + factor *= 0.1; + ++(*i); + } + return *i != init; +} + +/* + * Read and convert exactly n decimal digits from s[*i] + * to s[min(*i+n,limit)] into *result. + * + * Succeed if exactly n digits are converted. Advance *i only + * on success. + */ +template +static bool ParseDigitsN(size_t n, size_t* result, const CharT* s, size_t* i, + size_t limit) { + size_t init = *i; + + if (ParseDigits(result, s, i, std::min(limit, init + n))) { + return (*i - init) == n; + } + + *i = init; + return false; +} + +/* + * Read and convert n or less decimal digits from s[*i] + * to s[min(*i+n,limit)] into *result. + * + * Succeed only if greater than zero but less than or equal to n digits are + * converted. Advance *i only on success. + */ +template +static bool ParseDigitsNOrLess(size_t n, size_t* result, const CharT* s, + size_t* i, size_t limit) { + size_t init = *i; + + if (ParseDigits(result, s, i, std::min(limit, init + n))) { + return ((*i - init) > 0) && ((*i - init) <= n); + } + + *i = init; + return false; +} + +static int DaysInMonth(int year, int month) { + bool leap = IsLeapYear(year); + int result = int(DayFromMonth(month, leap) - DayFromMonth(month - 1, leap)); + return result; +} + +/* + * Parse a string according to the formats specified in section 20.3.1.16 + * of the ECMAScript standard. These formats are based upon a simplification + * of the ISO 8601 Extended Format. As per the spec omitted month and day + * values are defaulted to '01', omitted HH:mm:ss values are defaulted to '00' + * and an omitted sss field is defaulted to '000'. + * + * For cross compatibility we allow the following extensions. + * + * These are: + * + * Standalone time part: + * Any of the time formats below can be parsed without a date part. + * E.g. "T19:00:00Z" will parse successfully. The date part will then + * default to 1970-01-01. + * + * 'T' from the time part may be replaced with a space character: + * "1970-01-01 12:00:00Z" will parse successfully. Note that only a single + * space is permitted and this is not permitted in the standalone + * version above. + * + * One or more decimal digits for milliseconds: + * The specification requires exactly three decimal digits for + * the fractional part but we allow for one or more digits. + * + * Time zone specifier without ':': + * We allow the time zone to be specified without a ':' character. + * E.g. "T19:00:00+0700" is equivalent to "T19:00:00+07:00". + * + * One or two digits for months, days, hours, minutes and seconds: + * The specification requires exactly two decimal digits for the fields + * above. We allow for one or two decimal digits. I.e. "1970-1-1" is + * equivalent to "1970-01-01". + * + * Date part: + * + * Year: + * YYYY (eg 1997) + * + * Year and month: + * YYYY-MM (eg 1997-07) + * + * Complete date: + * YYYY-MM-DD (eg 1997-07-16) + * + * Time part: + * + * Hours and minutes: + * Thh:mmTZD (eg T19:20+01:00) + * + * Hours, minutes and seconds: + * Thh:mm:ssTZD (eg T19:20:30+01:00) + * + * Hours, minutes, seconds and a decimal fraction of a second: + * Thh:mm:ss.sTZD (eg T19:20:30.45+01:00) + * + * where: + * + * YYYY = four-digit year or six digit year as +YYYYYY or -YYYYYY + * MM = one or two-digit month (01=January, etc.) + * DD = one or two-digit day of month (01 through 31) + * hh = one or two digits of hour (00 through 23) (am/pm NOT allowed) + * mm = one or two digits of minute (00 through 59) + * ss = one or two digits of second (00 through 59) + * sss = one or more digits representing a decimal fraction of a second + * TZD = time zone designator (Z or +hh:mm or -hh:mm or missing for local) + */ +template +static bool ParseISOStyleDate(DateTimeInfo::ShouldRFP shouldRFP, const CharT* s, + size_t length, ClippedTime* result) { + size_t i = 0; + size_t pre = 0; + int tzMul = 1; + int dateMul = 1; + size_t year = 1970; + size_t month = 1; + size_t day = 1; + size_t hour = 0; + size_t min = 0; + size_t sec = 0; + double frac = 0; + bool isLocalTime = false; + size_t tzHour = 0; + size_t tzMin = 0; + bool isPermissive = false; + bool isStrict = false; + +#define PEEK(ch) (i < length && s[i] == ch) + +#define NEED(ch) \ + if (i >= length || s[i] != ch) { \ + return false; \ + } else { \ + ++i; \ + } + +#define DONE_DATE_UNLESS(ch) \ + if (i >= length || s[i] != ch) { \ + goto done_date; \ + } else { \ + ++i; \ + } + +#define DONE_UNLESS(ch) \ + if (i >= length || s[i] != ch) { \ + goto done; \ + } else { \ + ++i; \ + } + +#define NEED_NDIGITS(n, field) \ + if (!ParseDigitsN(n, &field, s, &i, length)) { \ + return false; \ + } + +#define NEED_NDIGITS_OR_LESS(n, field) \ + pre = i; \ + if (!ParseDigitsNOrLess(n, &field, s, &i, length)) { \ + return false; \ + } \ + if (i < pre + (n)) { \ + if (isStrict) { \ + return false; \ + } else { \ + isPermissive = true; \ + } \ + } + + if (PEEK('+') || PEEK('-')) { + if (PEEK('-')) { + dateMul = -1; + } + ++i; + NEED_NDIGITS(6, year); + } else { + NEED_NDIGITS(4, year); + } + DONE_DATE_UNLESS('-'); + NEED_NDIGITS_OR_LESS(2, month); + DONE_DATE_UNLESS('-'); + NEED_NDIGITS_OR_LESS(2, day); + +done_date: + if (PEEK('T')) { + if (isPermissive) { + // Require standard format "[+00]1970-01-01" if a time part marker "T" + // exists + return false; + } + isStrict = true; + i++; + } else if (PEEK(' ')) { + i++; + } else { + goto done; + } + + NEED_NDIGITS_OR_LESS(2, hour); + NEED(':'); + NEED_NDIGITS_OR_LESS(2, min); + + if (PEEK(':')) { + ++i; + NEED_NDIGITS_OR_LESS(2, sec); + if (PEEK('.')) { + ++i; + if (!ParseFractional(&frac, s, &i, length)) { + return false; + } + } + } + + if (PEEK('Z')) { + ++i; + } else if (PEEK('+') || PEEK('-')) { + if (PEEK('-')) { + tzMul = -1; + } + ++i; + NEED_NDIGITS(2, tzHour); + /* + * Non-standard extension to the ISO date format: + * allow two digits for the time zone offset. + */ + if (i >= length && !isStrict) { + goto done; + } + /* + * Non-standard extension to the ISO date format (permitted by ES5): + * allow "-0700" as a time zone offset, not just "-07:00". + */ + if (PEEK(':')) { + ++i; + } + NEED_NDIGITS(2, tzMin); + } else { + isLocalTime = true; + } + +done: + if (year > 275943 // ceil(1e8/365) + 1970 + || (month == 0 || month > 12) || + (day == 0 || day > size_t(DaysInMonth(year, month))) || hour > 24 || + ((hour == 24) && (min > 0 || sec > 0 || frac > 0)) || min > 59 || + sec > 59 || tzHour > 23 || tzMin > 59) { + return false; + } + + if (i != length) { + return false; + } + + month -= 1; /* convert month to 0-based */ + + double msec = MakeDate(MakeDay(dateMul * double(year), month, day), + MakeTime(hour, min, sec, frac * 1000.0)); + + if (isLocalTime) { + msec = UTC(shouldRFP, msec); + } else { + msec -= tzMul * (tzHour * msPerHour + tzMin * msPerMinute); + } + + *result = TimeClip(msec); + return NumbersAreIdentical(msec, result->toDouble()); + +#undef PEEK +#undef NEED +#undef DONE_UNLESS +#undef NEED_NDIGITS +#undef NEED_NDIGITS_OR_LESS +} + +int FixupNonFullYear(int year) { + if (year < 50) { + year += 2000; + } else if (year >= 50 && year < 100) { + year += 1900; + } + return year; +} + +template +bool IsPrefixOfKeyword(const CharT* s, size_t len, const char* keyword) { + while (len > 0 && *keyword) { + MOZ_ASSERT(IsAsciiAlpha(*s)); + MOZ_ASSERT(IsAsciiLowercaseAlpha(*keyword)); + + if (unicode::ToLowerCase(static_cast(*s)) != *keyword) { + break; + } + + s++, keyword++; + len--; + } + + return len == 0; +} + +static constexpr const char* const months_names[] = { + "january", "february", "march", "april", "may", "june", + "july", "august", "september", "october", "november", "december", +}; + +// Try to parse the following date format: +// dd-MMM-yyyy +// dd-MMM-yy +// yyyy-MMM-dd +// yy-MMM-dd +// +// Returns true and fills all out parameters when successfully parsed +// dashed-date. Otherwise returns false and leaves out parameters untouched. +template +static bool TryParseDashedDatePrefix(const CharT* s, size_t length, + size_t* indexOut, int* yearOut, + int* monOut, int* mdayOut) { + size_t i = 0; + + size_t mday; + if (!ParseDigitsNOrLess(4, &mday, s, &i, length)) { + return false; + } + size_t mdayDigits = i; + + if (i >= length || s[i] != '-') { + return false; + } + ++i; + + size_t start = i; + for (; i < length; i++) { + if (!IsAsciiAlpha(s[i])) { + break; + } + } + + // The shortest month is "may". + static constexpr size_t ShortestMonthNameLength = 3; + if (i - start < ShortestMonthNameLength) { + return false; + } + + size_t mon = 0; + for (size_t m = 0; m < std::size(months_names); ++m) { + // If the field isn't a prefix of the month (an exact match is *not* + // required), try the next one. + if (IsPrefixOfKeyword(s + start, i - start, months_names[m])) { + // Use numeric value. + mon = m + 1; + break; + } + } + if (mon == 0) { + return false; + } + + if (i >= length || s[i] != '-') { + return false; + } + ++i; + + size_t pre = i; + size_t year; + if (!ParseDigitsNOrLess(4, &year, s, &i, length)) { + return false; + } + size_t yearDigits = i - pre; + + if (i < length && IsAsciiDigit(s[i])) { + return false; + } + + // Swap the mday and year iff the year wasn't specified in full. + if (mday > 31 && year <= 31 && yearDigits < 4) { + std::swap(mday, year); + std::swap(mdayDigits, yearDigits); + } + + if (mday > 31 || mdayDigits > 2) { + return false; + } + + if (yearDigits < 4) { + year = FixupNonFullYear(year); + } + + *indexOut = i; + *yearOut = year; + *monOut = mon; + *mdayOut = mday; + return true; +} + +struct CharsAndAction { + const char* chars; + int action; +}; + +static constexpr CharsAndAction keywords[] = { + // clang-format off + // AM/PM + { "am", -1 }, + { "pm", -2 }, + // Days of week. + { "monday", 0 }, + { "tuesday", 0 }, + { "wednesday", 0 }, + { "thursday", 0 }, + { "friday", 0 }, + { "saturday", 0 }, + { "sunday", 0 }, + // Months. + { "january", 1 }, + { "february", 2 }, + { "march", 3 }, + { "april", 4, }, + { "may", 5 }, + { "june", 6 }, + { "july", 7 }, + { "august", 8 }, + { "september", 9 }, + { "october", 10 }, + { "november", 11 }, + { "december", 12 }, + // Time zone abbreviations. + { "gmt", 10000 + 0 }, + { "ut", 10000 + 0 }, + { "utc", 10000 + 0 }, + { "est", 10000 + 5 * 60 }, + { "edt", 10000 + 4 * 60 }, + { "cst", 10000 + 6 * 60 }, + { "cdt", 10000 + 5 * 60 }, + { "mst", 10000 + 7 * 60 }, + { "mdt", 10000 + 6 * 60 }, + { "pst", 10000 + 8 * 60 }, + { "pdt", 10000 + 7 * 60 }, + // clang-format on +}; + +template +constexpr size_t MinKeywordLength(const CharsAndAction (&keywords)[N]) { + size_t min = size_t(-1); + for (const CharsAndAction& keyword : keywords) { + min = std::min(min, std::char_traits::length(keyword.chars)); + } + return min; +} + +template +static bool ParseDate(DateTimeInfo::ShouldRFP shouldRFP, const CharT* s, + size_t length, ClippedTime* result) { + if (ParseISOStyleDate(shouldRFP, s, length, result)) { + return true; + } + + if (length == 0) { + return false; + } + + int year = -1; + int mon = -1; + int mday = -1; + int hour = -1; + int min = -1; + int sec = -1; + int tzOffset = -1; + + // One of '+', '-', ':', '/', or 0 (the default value). + int prevc = 0; + + bool seenPlusMinus = false; + bool seenMonthName = false; + bool seenFullYear = false; + bool negativeYear = false; + + size_t index = 0; + + // Try parsing the leading dashed-date. + // + // If successfully parsed, index is updated to the end of the date part, + // and year, mon, mday are set to the date. + // Continue parsing optional time + tzOffset parts. + // + // Otherwise, this is no-op. + bool isDashedDate = + TryParseDashedDatePrefix(s, length, &index, &year, &mon, &mday); + + while (index < length) { + int c = s[index]; + index++; + + // Normalize U+202F (NARROW NO-BREAK SPACE). This character appears between + // the AM/PM markers for |date.toLocaleString("en")|. We have to normalize + // it for backward compatibility reasons. + if (c == 0x202F) { + c = ' '; + } + + // Spaces, ASCII control characters, and commas are simply ignored. + if (c <= ' ' || c == ',') { + continue; + } + + // Parse delimiter characters. Save them to the side for future use. + if (c == '/' || c == ':' || c == '+') { + prevc = c; + continue; + } + + // Dashes are delimiters if they're immediately followed by a number field. + // If they're not followed by a number field, they're simply ignored. + if (c == '-') { + if (index < length && IsAsciiDigit(s[index])) { + prevc = c; + } + continue; + } + + // Skip over comments -- text inside matching parentheses. (Comments + // themselves may contain comments as long as all the parentheses properly + // match up. And apparently comments, including nested ones, may validly be + // terminated by end of input...) + if (c == '(') { + int depth = 1; + while (index < length) { + c = s[index]; + index++; + if (c == '(') { + depth++; + } else if (c == ')') { + if (--depth <= 0) { + break; + } + } + } + continue; + } + + // Parse a number field. + if (IsAsciiDigit(c)) { + size_t partStart = index - 1; + uint32_t u = c - '0'; + while (index < length) { + c = s[index]; + if (!IsAsciiDigit(c)) { + break; + } + u = u * 10 + (c - '0'); + index++; + } + size_t partLength = index - partStart; + + // See above for why we have to normalize U+202F. + if (c == 0x202F) { + c = ' '; + } + + int n = int(u); + + /* + * Allow TZA before the year, so 'Wed Nov 05 21:49:11 GMT-0800 1997' + * works. + * + * Uses of seenPlusMinus allow ':' in TZA, so Java no-timezone style + * of GMT+4:30 works. + */ + + if (prevc == '-' && (tzOffset != 0 || seenPlusMinus) && partLength >= 4 && + year < 0) { + // Parse as a negative, possibly zero-padded year if + // 1. the preceding character is '-', + // 2. the TZA is not 'GMT' (tested by |tzOffset != 0|), + // 3. or a TZA was already parsed |seenPlusMinus == true|, + // 4. the part length is at least 4 (to parse '-08' as a TZA), + // 5. and we did not already parse a year |year < 0|. + year = n; + seenFullYear = true; + negativeYear = true; + } else if ((prevc == '+' || prevc == '-') /* && year>=0 */) { + /* Make ':' case below change tzOffset. */ + seenPlusMinus = true; + + /* offset */ + if (n < 24 && partLength <= 2) { + n = n * 60; /* EG. "GMT-3" */ + } else { + n = n % 100 + n / 100 * 60; /* eg "GMT-0430" */ + } + + if (prevc == '+') /* plus means east of GMT */ + n = -n; + + // Reject if not preceded by 'GMT' or if a time zone offset + // was already parsed. + if (tzOffset != 0 && tzOffset != -1) { + return false; + } + + tzOffset = n; + } else if (prevc == '/' && mon >= 0 && mday >= 0 && year < 0) { + if (c <= ' ' || c == ',' || c == '/' || index >= length) { + year = n; + } else { + return false; + } + } else if (c == ':') { + if (hour < 0) { + hour = /*byte*/ n; + } else if (min < 0) { + min = /*byte*/ n; + } else { + return false; + } + } else if (c == '/') { + /* + * Until it is determined that mon is the actual month, keep + * it as 1-based rather than 0-based. + */ + if (mon < 0) { + mon = /*byte*/ n; + } else if (mday < 0) { + mday = /*byte*/ n; + } else { + return false; + } + } else if (index < length && c != ',' && c > ' ' && c != '-' && + c != '(') { + return false; + } else if (seenPlusMinus && n < 60) { /* handle GMT-3:30 */ + if (tzOffset < 0) { + tzOffset -= n; + } else { + tzOffset += n; + } + } else if (hour >= 0 && min < 0) { + min = /*byte*/ n; + } else if (prevc == ':' && min >= 0 && sec < 0) { + sec = /*byte*/ n; + } else if (mon < 0) { + mon = /*byte*/ n; + } else if (mon >= 0 && mday < 0) { + mday = /*byte*/ n; + } else if (mon >= 0 && mday >= 0 && year < 0) { + year = n; + seenFullYear = partLength >= 4; + } else { + return false; + } + + prevc = 0; + continue; + } + + // Parse fields that are words: ASCII letters spelling out in English AM/PM, + // day of week, month, or an extremely limited set of legacy time zone + // abbreviations. + if (IsAsciiAlpha(c)) { + size_t start = index - 1; + while (index < length) { + c = s[index]; + if (!IsAsciiAlpha(c)) { + break; + } + index++; + } + + // There must be at least as many letters as in the shortest keyword. + constexpr size_t MinLength = MinKeywordLength(keywords); + if (index - start < MinLength) { + return false; + } + + size_t k = std::size(keywords); + while (k-- > 0) { + const CharsAndAction& keyword = keywords[k]; + + // If the field isn't a prefix of the keyword (an exact match is *not* + // required), try the next one. + if (!IsPrefixOfKeyword(s + start, index - start, keyword.chars)) { + continue; + } + + int action = keyword.action; + + // Completely ignore days of the week, and don't derive any semantics + // from them. + if (action == 0) { + break; + } + + // Perform action tests from smallest action values to largest. + + // Adjust a previously-specified hour for AM/PM accordingly (taking care + // to treat 12:xx AM as 00:xx, 12:xx PM as 12:xx). + if (action < 0) { + MOZ_ASSERT(action == -1 || action == -2); + if (hour > 12 || hour < 0) { + return false; + } + + if (action == -1 && hour == 12) { + hour = 0; + } else if (action == -2 && hour != 12) { + hour += 12; + } + + break; + } + + // Record a month if none has been seen before. (Note that some numbers + // are initially treated as months; if a numeric field has already been + // interpreted as a month, store that value to the actually appropriate + // date component and set the month here. + if (action <= 12) { + if (seenMonthName) { + return false; + } + + seenMonthName = true; + + if (mon < 0) { + mon = action; + } else if (mday < 0) { + mday = mon; + mon = action; + } else if (year < 0) { + if (mday > 0) { + // If the date is of the form f l month, then when month is + // reached we have f in mon and l in mday. In order to be + // consistent with the f month l and month f l forms, we need to + // swap so that f is in mday and l is in year. + year = mday; + mday = mon; + } else { + year = mon; + } + mon = action; + } else { + return false; + } + + break; + } + + // Finally, record a time zone offset. + MOZ_ASSERT(action >= 10000); + tzOffset = action - 10000; + break; + } + + if (k == size_t(-1)) { + return false; + } + + prevc = 0; + continue; + } + + // Any other character fails to parse. + return false; + } + + if (year < 0 || mon < 0 || mday < 0) { + return false; + } + + if (!isDashedDate) { + // NOTE: TryParseDashedDatePrefix already handles the following fixup. + + /* + * Case 1. The input string contains an English month name. + * The form of the string can be month f l, or f month l, or + * f l month which each evaluate to the same date. + * If f and l are both greater than or equal to 100 the date + * is invalid. + * + * The year is taken to be either l, f if f > 31, or whichever + * is set to zero. + * + * Case 2. The input string is of the form "f/m/l" where f, m and l are + * integers, e.g. 7/16/45. mon, mday and year values are adjusted + * to achieve Chrome compatibility. + * + * a. If 0 < f <= 12 and 0 < l <= 31, f/m/l is interpreted as + * month/day/year. + * b. If 31 < f and 0 < m <= 12 and 0 < l <= 31 f/m/l is + * interpreted as year/month/day + */ + if (seenMonthName) { + if (mday >= 100 && mon >= 100) { + return false; + } + + if (year > 0 && (mday == 0 || mday > 31) && !seenFullYear) { + int temp = year; + year = mday; + mday = temp; + } + + if (mday <= 0 || mday > 31) { + return false; + } + + } else if (0 < mon && mon <= 12 && 0 < mday && mday <= 31) { + /* (a) month/day/year */ + } else { + /* (b) year/month/day */ + if (mon > 31 && mday <= 12 && year <= 31 && !seenFullYear) { + int temp = year; + year = mon; + mon = mday; + mday = temp; + } else { + return false; + } + } + + // If the year is greater than or equal to 50 and less than 100, it is + // considered to be the number of years after 1900. If the year is less + // than 50 it is considered to be the number of years after 2000, + // otherwise it is considered to be the number of years after 0. + if (!seenFullYear) { + year = FixupNonFullYear(year); + } + + if (negativeYear) { + year = -year; + } + } + + mon -= 1; /* convert month to 0-based */ + if (sec < 0) { + sec = 0; + } + if (min < 0) { + min = 0; + } + if (hour < 0) { + hour = 0; + } + + double msec = MakeDate(MakeDay(year, mon, mday), MakeTime(hour, min, sec, 0)); + + if (tzOffset == -1) { /* no time zone specified, have to use local */ + msec = UTC(shouldRFP, msec); + } else { + msec += tzOffset * msPerMinute; + } + + *result = TimeClip(msec); + return true; +} + +static bool ParseDate(DateTimeInfo::ShouldRFP shouldRFP, JSLinearString* s, + ClippedTime* result) { + AutoCheckCannotGC nogc; + return s->hasLatin1Chars() + ? ParseDate(shouldRFP, s->latin1Chars(nogc), s->length(), result) + : ParseDate(shouldRFP, s->twoByteChars(nogc), s->length(), result); +} + +static bool date_parse(JSContext* cx, unsigned argc, Value* vp) { + AutoJSMethodProfilerEntry pseudoFrame(cx, "Date", "parse"); + CallArgs args = CallArgsFromVp(argc, vp); + if (args.length() == 0) { + args.rval().setNaN(); + return true; + } + + JSString* str = ToString(cx, args[0]); + if (!str) { + return false; + } + + JSLinearString* linearStr = str->ensureLinear(cx); + if (!linearStr) { + return false; + } + + ClippedTime result; + if (!ParseDate(ShouldRFP(cx->realm()), linearStr, &result)) { + args.rval().setNaN(); + return true; + } + + args.rval().set(TimeValue(result)); + return true; +} + +static ClippedTime NowAsMillis(JSContext* cx) { + if (js::SupportDifferentialTesting()) { + return TimeClip(0); + } + + double now = PRMJ_Now(); + bool clampAndJitter = cx->realm()->behaviors().clampAndJitterTime(); + bool shouldResistFingerprinting = + cx->realm()->behaviors().shouldResistFingerprinting(); + if (clampAndJitter && sReduceMicrosecondTimePrecisionCallback) { + now = sReduceMicrosecondTimePrecisionCallback( + now, shouldResistFingerprinting, cx); + } else if (clampAndJitter && sResolutionUsec) { + double clamped = floor(now / sResolutionUsec) * sResolutionUsec; + + if (sJitter) { + // Calculate a random midpoint for jittering. In the browser, we are + // adversarial: Web Content may try to calculate the midpoint themselves + // and use that to bypass it's security. In the JS Shell, we are not + // adversarial, we want to jitter the time to recreate the operating + // environment, but we do not concern ourselves with trying to prevent an + // attacker from calculating the midpoint themselves. So we use a very + // simple, very fast CRC with a hardcoded seed. + + uint64_t midpoint = BitwiseCast(clamped); + midpoint ^= 0x0F00DD1E2BAD2DED; // XOR in a 'secret' + // MurmurHash3 internal component from + // https://searchfox.org/mozilla-central/rev/61d400da1c692453c2dc2c1cf37b616ce13dea5b/dom/canvas/MurmurHash3.cpp#85 + midpoint ^= midpoint >> 33; + midpoint *= uint64_t{0xFF51AFD7ED558CCD}; + midpoint ^= midpoint >> 33; + midpoint *= uint64_t{0xC4CEB9FE1A85EC53}; + midpoint ^= midpoint >> 33; + midpoint %= sResolutionUsec; + + if (now > clamped + midpoint) { // We're jittering up to the next step + now = clamped + sResolutionUsec; + } else { // We're staying at the clamped value + now = clamped; + } + } else { // No jitter, only clamping + now = clamped; + } + } + + return TimeClip(now / PRMJ_USEC_PER_MSEC); +} + +bool js::date_now(JSContext* cx, unsigned argc, Value* vp) { + AutoJSMethodProfilerEntry pseudoFrame(cx, "Date", "now"); + CallArgs args = CallArgsFromVp(argc, vp); + args.rval().set(TimeValue(NowAsMillis(cx))); + return true; +} + +DateTimeInfo::ShouldRFP DateObject::shouldRFP() const { + return ShouldRFP(realm()); +} + +void DateObject::setUTCTime(ClippedTime t) { + for (size_t ind = COMPONENTS_START_SLOT; ind < RESERVED_SLOTS; ind++) { + setReservedSlot(ind, UndefinedValue()); + } + + setFixedSlot(UTC_TIME_SLOT, TimeValue(t)); +} + +void DateObject::setUTCTime(ClippedTime t, MutableHandleValue vp) { + setUTCTime(t); + vp.set(TimeValue(t)); +} + +void DateObject::fillLocalTimeSlots() { + const int32_t utcTZOffset = + DateTimeInfo::utcToLocalStandardOffsetSeconds(shouldRFP()); + + /* Check if the cache is already populated. */ + if (!getReservedSlot(LOCAL_TIME_SLOT).isUndefined() && + getReservedSlot(UTC_TIME_ZONE_OFFSET_SLOT).toInt32() == utcTZOffset) { + return; + } + + /* Remember time zone used to generate the local cache. */ + setReservedSlot(UTC_TIME_ZONE_OFFSET_SLOT, Int32Value(utcTZOffset)); + + double utcTime = UTCTime().toNumber(); + + if (!std::isfinite(utcTime)) { + for (size_t ind = COMPONENTS_START_SLOT; ind < RESERVED_SLOTS; ind++) { + setReservedSlot(ind, DoubleValue(utcTime)); + } + return; + } + + double localTime = LocalTime(shouldRFP(), utcTime); + + setReservedSlot(LOCAL_TIME_SLOT, DoubleValue(localTime)); + + int year = (int)floor(localTime / (msPerDay * 365.2425)) + 1970; + double yearStartTime = TimeFromYear(year); + + /* Adjust the year in case the approximation was wrong, as in YearFromTime. */ + int yearDays; + if (yearStartTime > localTime) { + year--; + yearStartTime -= (msPerDay * DaysInYear(year)); + yearDays = DaysInYear(year); + } else { + yearDays = DaysInYear(year); + double nextStart = yearStartTime + (msPerDay * yearDays); + if (nextStart <= localTime) { + year++; + yearStartTime = nextStart; + yearDays = DaysInYear(year); + } + } + + setReservedSlot(LOCAL_YEAR_SLOT, Int32Value(year)); + + uint64_t yearTime = uint64_t(localTime - yearStartTime); + int yearSeconds = uint32_t(yearTime / 1000); + + int day = yearSeconds / int(SecondsPerDay); + + int step = -1, next = 30; + int month; + + do { + if (day <= next) { + month = 0; + break; + } + step = next; + next += ((yearDays == 366) ? 29 : 28); + if (day <= next) { + month = 1; + break; + } + step = next; + if (day <= (next += 31)) { + month = 2; + break; + } + step = next; + if (day <= (next += 30)) { + month = 3; + break; + } + step = next; + if (day <= (next += 31)) { + month = 4; + break; + } + step = next; + if (day <= (next += 30)) { + month = 5; + break; + } + step = next; + if (day <= (next += 31)) { + month = 6; + break; + } + step = next; + if (day <= (next += 31)) { + month = 7; + break; + } + step = next; + if (day <= (next += 30)) { + month = 8; + break; + } + step = next; + if (day <= (next += 31)) { + month = 9; + break; + } + step = next; + if (day <= (next += 30)) { + month = 10; + break; + } + step = next; + month = 11; + } while (0); + + setReservedSlot(LOCAL_MONTH_SLOT, Int32Value(month)); + setReservedSlot(LOCAL_DATE_SLOT, Int32Value(day - step)); + + int weekday = WeekDay(localTime); + setReservedSlot(LOCAL_DAY_SLOT, Int32Value(weekday)); + + setReservedSlot(LOCAL_SECONDS_INTO_YEAR_SLOT, Int32Value(yearSeconds)); +} + +MOZ_ALWAYS_INLINE bool IsDate(HandleValue v) { + return v.isObject() && v.toObject().is(); +} + +/* + * See ECMA 15.9.5.4 thru 15.9.5.23 + */ + +static bool date_getTime(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "getTime"); + if (!unwrapped) { + return false; + } + + args.rval().set(unwrapped->UTCTime()); + return true; +} + +static bool date_getYear(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "getYear"); + if (!unwrapped) { + return false; + } + + unwrapped->fillLocalTimeSlots(); + + Value yearVal = unwrapped->localYear(); + if (yearVal.isInt32()) { + /* Follow ECMA-262 to the letter, contrary to IE JScript. */ + int year = yearVal.toInt32() - 1900; + args.rval().setInt32(year); + } else { + args.rval().set(yearVal); + } + return true; +} + +static bool date_getFullYear(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "getFullYear"); + if (!unwrapped) { + return false; + } + + unwrapped->fillLocalTimeSlots(); + args.rval().set(unwrapped->localYear()); + return true; +} + +static bool date_getUTCFullYear(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = + UnwrapAndTypeCheckThis(cx, args, "getUTCFullYear"); + if (!unwrapped) { + return false; + } + + double result = unwrapped->UTCTime().toNumber(); + if (std::isfinite(result)) { + result = YearFromTime(result); + } + + args.rval().setNumber(result); + return true; +} + +static bool date_getMonth(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "getMonth"); + if (!unwrapped) { + return false; + } + + unwrapped->fillLocalTimeSlots(); + args.rval().set(unwrapped->localMonth()); + return true; +} + +static bool date_getUTCMonth(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "getUTCMonth"); + if (!unwrapped) { + return false; + } + + double d = unwrapped->UTCTime().toNumber(); + args.rval().setNumber(MonthFromTime(d)); + return true; +} + +static bool date_getDate(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "getDate"); + if (!unwrapped) { + return false; + } + + unwrapped->fillLocalTimeSlots(); + + args.rval().set(unwrapped->localDate()); + return true; +} + +static bool date_getUTCDate(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "getUTCDate"); + if (!unwrapped) { + return false; + } + + double result = unwrapped->UTCTime().toNumber(); + if (std::isfinite(result)) { + result = DateFromTime(result); + } + + args.rval().setNumber(result); + return true; +} + +static bool date_getDay(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "getDay"); + if (!unwrapped) { + return false; + } + + unwrapped->fillLocalTimeSlots(); + args.rval().set(unwrapped->localDay()); + return true; +} + +static bool date_getUTCDay(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "getUTCDay"); + if (!unwrapped) { + return false; + } + + double result = unwrapped->UTCTime().toNumber(); + if (std::isfinite(result)) { + result = WeekDay(result); + } + + args.rval().setNumber(result); + return true; +} + +static bool date_getHours(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "getHours"); + if (!unwrapped) { + return false; + } + + unwrapped->fillLocalTimeSlots(); + + // Note: localSecondsIntoYear is guaranteed to return an + // int32 or NaN after the call to fillLocalTimeSlots. + Value yearSeconds = unwrapped->localSecondsIntoYear(); + if (yearSeconds.isDouble()) { + MOZ_ASSERT(std::isnan(yearSeconds.toDouble())); + args.rval().set(yearSeconds); + } else { + args.rval().setInt32((yearSeconds.toInt32() / int(SecondsPerHour)) % + int(HoursPerDay)); + } + return true; +} + +static bool date_getUTCHours(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "getUTCHours"); + if (!unwrapped) { + return false; + } + + double result = unwrapped->UTCTime().toNumber(); + if (std::isfinite(result)) { + result = HourFromTime(result); + } + + args.rval().setNumber(result); + return true; +} + +static bool date_getMinutes(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "getMinutes"); + if (!unwrapped) { + return false; + } + + unwrapped->fillLocalTimeSlots(); + + // Note: localSecondsIntoYear is guaranteed to return an + // int32 or NaN after the call to fillLocalTimeSlots. + Value yearSeconds = unwrapped->localSecondsIntoYear(); + if (yearSeconds.isDouble()) { + MOZ_ASSERT(std::isnan(yearSeconds.toDouble())); + args.rval().set(yearSeconds); + } else { + args.rval().setInt32((yearSeconds.toInt32() / int(SecondsPerMinute)) % + int(MinutesPerHour)); + } + return true; +} + +static bool date_getUTCMinutes(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = + UnwrapAndTypeCheckThis(cx, args, "getUTCMinutes"); + if (!unwrapped) { + return false; + } + + double result = unwrapped->UTCTime().toNumber(); + if (std::isfinite(result)) { + result = MinFromTime(result); + } + + args.rval().setNumber(result); + return true; +} + +static bool date_getSeconds(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "getSeconds"); + if (!unwrapped) { + return false; + } + + unwrapped->fillLocalTimeSlots(); + + // Note: localSecondsIntoYear is guaranteed to return an + // int32 or NaN after the call to fillLocalTimeSlots. + Value yearSeconds = unwrapped->localSecondsIntoYear(); + if (yearSeconds.isDouble()) { + MOZ_ASSERT(std::isnan(yearSeconds.toDouble())); + args.rval().set(yearSeconds); + } else { + args.rval().setInt32(yearSeconds.toInt32() % int(SecondsPerMinute)); + } + return true; +} + +static bool date_getUTCSeconds(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = + UnwrapAndTypeCheckThis(cx, args, "getUTCSeconds"); + if (!unwrapped) { + return false; + } + + double result = unwrapped->UTCTime().toNumber(); + if (std::isfinite(result)) { + result = SecFromTime(result); + } + + args.rval().setNumber(result); + return true; +} + +/* + * Date.getMilliseconds is mapped to getUTCMilliseconds. As long as no + * supported time zone has a fractional-second component, the differences in + * their specifications aren't observable. + * + * The 'tz' database explicitly does not support fractional-second time zones. + * For example the Netherlands observed Amsterdam Mean Time, estimated to be + * UT +00:19:32.13, from 1909 to 1937, but in tzdata AMT is defined as exactly + * UT +00:19:32. + */ + +static bool getMilliseconds(JSContext* cx, unsigned argc, Value* vp, + const char* methodName) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, methodName); + if (!unwrapped) { + return false; + } + + double result = unwrapped->UTCTime().toNumber(); + if (std::isfinite(result)) { + result = msFromTime(result); + } + + args.rval().setNumber(result); + return true; +} + +static bool date_getMilliseconds(JSContext* cx, unsigned argc, Value* vp) { + return getMilliseconds(cx, argc, vp, "getMilliseconds"); +} + +static bool date_getUTCMilliseconds(JSContext* cx, unsigned argc, Value* vp) { + return getMilliseconds(cx, argc, vp, "getUTCMilliseconds"); +} + +static bool date_getTimezoneOffset(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = + UnwrapAndTypeCheckThis(cx, args, "getTimezoneOffset"); + if (!unwrapped) { + return false; + } + + unwrapped->fillLocalTimeSlots(); + + double utctime = unwrapped->UTCTime().toNumber(); + double localtime = unwrapped->localTime().toDouble(); + + /* + * Return the time zone offset in minutes for the current locale that is + * appropriate for this time. This value would be a constant except for + * daylight savings time. + */ + double result = (utctime - localtime) / msPerMinute; + args.rval().setNumber(result); + return true; +} + +static bool date_setTime(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setTime")); + if (!unwrapped) { + return false; + } + + if (args.length() == 0) { + unwrapped->setUTCTime(ClippedTime::invalid(), args.rval()); + return true; + } + + double result; + if (!ToNumber(cx, args[0], &result)) { + return false; + } + + unwrapped->setUTCTime(TimeClip(result), args.rval()); + return true; +} + +static bool GetMsecsOrDefault(JSContext* cx, const CallArgs& args, unsigned i, + double t, double* millis) { + if (args.length() <= i) { + *millis = msFromTime(t); + return true; + } + return ToNumber(cx, args[i], millis); +} + +static bool GetSecsOrDefault(JSContext* cx, const CallArgs& args, unsigned i, + double t, double* sec) { + if (args.length() <= i) { + *sec = SecFromTime(t); + return true; + } + return ToNumber(cx, args[i], sec); +} + +static bool GetMinsOrDefault(JSContext* cx, const CallArgs& args, unsigned i, + double t, double* mins) { + if (args.length() <= i) { + *mins = MinFromTime(t); + return true; + } + return ToNumber(cx, args[i], mins); +} + +/* ES6 20.3.4.23. */ +static bool date_setMilliseconds(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + // Step 1. + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setMilliseconds")); + if (!unwrapped) { + return false; + } + double t = LocalTime(unwrapped->shouldRFP(), unwrapped->UTCTime().toNumber()); + + // Step 2. + double ms; + if (!ToNumber(cx, args.get(0), &ms)) { + return false; + } + + // Step 3. + double time = MakeTime(HourFromTime(t), MinFromTime(t), SecFromTime(t), ms); + + // Step 4. + ClippedTime u = TimeClip(UTC(unwrapped->shouldRFP(), MakeDate(Day(t), time))); + + // Steps 5-6. + unwrapped->setUTCTime(u, args.rval()); + return true; +} + +/* ES5 15.9.5.29. */ +static bool date_setUTCMilliseconds(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setUTCMilliseconds")); + if (!unwrapped) { + return false; + } + + /* Step 1. */ + double t = unwrapped->UTCTime().toNumber(); + + /* Step 2. */ + double milli; + if (!ToNumber(cx, args.get(0), &milli)) { + return false; + } + double time = + MakeTime(HourFromTime(t), MinFromTime(t), SecFromTime(t), milli); + + /* Step 3. */ + ClippedTime v = TimeClip(MakeDate(Day(t), time)); + + /* Steps 4-5. */ + unwrapped->setUTCTime(v, args.rval()); + return true; +} + +/* ES6 20.3.4.26. */ +static bool date_setSeconds(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setSeconds")); + if (!unwrapped) { + return false; + } + + // Steps 1-2. + double t = LocalTime(unwrapped->shouldRFP(), unwrapped->UTCTime().toNumber()); + + // Steps 3-4. + double s; + if (!ToNumber(cx, args.get(0), &s)) { + return false; + } + + // Steps 5-6. + double milli; + if (!GetMsecsOrDefault(cx, args, 1, t, &milli)) { + return false; + } + + // Step 7. + double date = + MakeDate(Day(t), MakeTime(HourFromTime(t), MinFromTime(t), s, milli)); + + // Step 8. + ClippedTime u = TimeClip(UTC(unwrapped->shouldRFP(), date)); + + // Step 9. + unwrapped->setUTCTime(u, args.rval()); + return true; +} + +/* ES5 15.9.5.32. */ +static bool date_setUTCSeconds(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setUTCSeconds")); + if (!unwrapped) { + return false; + } + + /* Step 1. */ + double t = unwrapped->UTCTime().toNumber(); + + /* Step 2. */ + double s; + if (!ToNumber(cx, args.get(0), &s)) { + return false; + } + + /* Step 3. */ + double milli; + if (!GetMsecsOrDefault(cx, args, 1, t, &milli)) { + return false; + } + + /* Step 4. */ + double date = + MakeDate(Day(t), MakeTime(HourFromTime(t), MinFromTime(t), s, milli)); + + /* Step 5. */ + ClippedTime v = TimeClip(date); + + /* Steps 6-7. */ + unwrapped->setUTCTime(v, args.rval()); + return true; +} + +/* ES6 20.3.4.24. */ +static bool date_setMinutes(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setMinutes")); + if (!unwrapped) { + return false; + } + + // Steps 1-2. + double t = LocalTime(unwrapped->shouldRFP(), unwrapped->UTCTime().toNumber()); + + // Steps 3-4. + double m; + if (!ToNumber(cx, args.get(0), &m)) { + return false; + } + + // Steps 5-6. + double s; + if (!GetSecsOrDefault(cx, args, 1, t, &s)) { + return false; + } + + // Steps 7-8. + double milli; + if (!GetMsecsOrDefault(cx, args, 2, t, &milli)) { + return false; + } + + // Step 9. + double date = MakeDate(Day(t), MakeTime(HourFromTime(t), m, s, milli)); + + // Step 10. + ClippedTime u = TimeClip(UTC(unwrapped->shouldRFP(), date)); + + // Steps 11-12. + unwrapped->setUTCTime(u, args.rval()); + return true; +} + +/* ES5 15.9.5.34. */ +static bool date_setUTCMinutes(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setUTCMinutes")); + if (!unwrapped) { + return false; + } + + /* Step 1. */ + double t = unwrapped->UTCTime().toNumber(); + + /* Step 2. */ + double m; + if (!ToNumber(cx, args.get(0), &m)) { + return false; + } + + /* Step 3. */ + double s; + if (!GetSecsOrDefault(cx, args, 1, t, &s)) { + return false; + } + + /* Step 4. */ + double milli; + if (!GetMsecsOrDefault(cx, args, 2, t, &milli)) { + return false; + } + + /* Step 5. */ + double date = MakeDate(Day(t), MakeTime(HourFromTime(t), m, s, milli)); + + /* Step 6. */ + ClippedTime v = TimeClip(date); + + /* Steps 7-8. */ + unwrapped->setUTCTime(v, args.rval()); + return true; +} + +/* ES5 15.9.5.35. */ +static bool date_setHours(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setHours")); + if (!unwrapped) { + return false; + } + + // Steps 1-2. + double t = LocalTime(unwrapped->shouldRFP(), unwrapped->UTCTime().toNumber()); + + // Steps 3-4. + double h; + if (!ToNumber(cx, args.get(0), &h)) { + return false; + } + + // Steps 5-6. + double m; + if (!GetMinsOrDefault(cx, args, 1, t, &m)) { + return false; + } + + // Steps 7-8. + double s; + if (!GetSecsOrDefault(cx, args, 2, t, &s)) { + return false; + } + + // Steps 9-10. + double milli; + if (!GetMsecsOrDefault(cx, args, 3, t, &milli)) { + return false; + } + + // Step 11. + double date = MakeDate(Day(t), MakeTime(h, m, s, milli)); + + // Step 12. + ClippedTime u = TimeClip(UTC(unwrapped->shouldRFP(), date)); + + // Steps 13-14. + unwrapped->setUTCTime(u, args.rval()); + return true; +} + +/* ES5 15.9.5.36. */ +static bool date_setUTCHours(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setUTCHours")); + if (!unwrapped) { + return false; + } + + /* Step 1. */ + double t = unwrapped->UTCTime().toNumber(); + + /* Step 2. */ + double h; + if (!ToNumber(cx, args.get(0), &h)) { + return false; + } + + /* Step 3. */ + double m; + if (!GetMinsOrDefault(cx, args, 1, t, &m)) { + return false; + } + + /* Step 4. */ + double s; + if (!GetSecsOrDefault(cx, args, 2, t, &s)) { + return false; + } + + /* Step 5. */ + double milli; + if (!GetMsecsOrDefault(cx, args, 3, t, &milli)) { + return false; + } + + /* Step 6. */ + double newDate = MakeDate(Day(t), MakeTime(h, m, s, milli)); + + /* Step 7. */ + ClippedTime v = TimeClip(newDate); + + /* Steps 8-9. */ + unwrapped->setUTCTime(v, args.rval()); + return true; +} + +/* ES5 15.9.5.37. */ +static bool date_setDate(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setDate")); + if (!unwrapped) { + return false; + } + + /* Step 1. */ + double t = LocalTime(unwrapped->shouldRFP(), unwrapped->UTCTime().toNumber()); + + /* Step 2. */ + double date; + if (!ToNumber(cx, args.get(0), &date)) { + return false; + } + + /* Step 3. */ + double newDate = MakeDate(MakeDay(YearFromTime(t), MonthFromTime(t), date), + TimeWithinDay(t)); + + /* Step 4. */ + ClippedTime u = TimeClip(UTC(unwrapped->shouldRFP(), newDate)); + + /* Steps 5-6. */ + unwrapped->setUTCTime(u, args.rval()); + return true; +} + +static bool date_setUTCDate(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setUTCDate")); + if (!unwrapped) { + return false; + } + + /* Step 1. */ + double t = unwrapped->UTCTime().toNumber(); + + /* Step 2. */ + double date; + if (!ToNumber(cx, args.get(0), &date)) { + return false; + } + + /* Step 3. */ + double newDate = MakeDate(MakeDay(YearFromTime(t), MonthFromTime(t), date), + TimeWithinDay(t)); + + /* Step 4. */ + ClippedTime v = TimeClip(newDate); + + /* Steps 5-6. */ + unwrapped->setUTCTime(v, args.rval()); + return true; +} + +static bool GetDateOrDefault(JSContext* cx, const CallArgs& args, unsigned i, + double t, double* date) { + if (args.length() <= i) { + *date = DateFromTime(t); + return true; + } + return ToNumber(cx, args[i], date); +} + +static bool GetMonthOrDefault(JSContext* cx, const CallArgs& args, unsigned i, + double t, double* month) { + if (args.length() <= i) { + *month = MonthFromTime(t); + return true; + } + return ToNumber(cx, args[i], month); +} + +/* ES5 15.9.5.38. */ +static bool date_setMonth(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setMonth")); + if (!unwrapped) { + return false; + } + + /* Step 1. */ + double t = LocalTime(unwrapped->shouldRFP(), unwrapped->UTCTime().toNumber()); + + /* Step 2. */ + double m; + if (!ToNumber(cx, args.get(0), &m)) { + return false; + } + + /* Step 3. */ + double date; + if (!GetDateOrDefault(cx, args, 1, t, &date)) { + return false; + } + + /* Step 4. */ + double newDate = + MakeDate(MakeDay(YearFromTime(t), m, date), TimeWithinDay(t)); + + /* Step 5. */ + ClippedTime u = TimeClip(UTC(unwrapped->shouldRFP(), newDate)); + + /* Steps 6-7. */ + unwrapped->setUTCTime(u, args.rval()); + return true; +} + +/* ES5 15.9.5.39. */ +static bool date_setUTCMonth(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setUTCMonth")); + if (!unwrapped) { + return false; + } + + /* Step 1. */ + double t = unwrapped->UTCTime().toNumber(); + + /* Step 2. */ + double m; + if (!ToNumber(cx, args.get(0), &m)) { + return false; + } + + /* Step 3. */ + double date; + if (!GetDateOrDefault(cx, args, 1, t, &date)) { + return false; + } + + /* Step 4. */ + double newDate = + MakeDate(MakeDay(YearFromTime(t), m, date), TimeWithinDay(t)); + + /* Step 5. */ + ClippedTime v = TimeClip(newDate); + + /* Steps 6-7. */ + unwrapped->setUTCTime(v, args.rval()); + return true; +} + +static double ThisLocalTimeOrZero(DateTimeInfo::ShouldRFP shouldRFP, + Handle dateObj) { + double t = dateObj->UTCTime().toNumber(); + if (std::isnan(t)) { + return +0; + } + return LocalTime(shouldRFP, t); +} + +static double ThisUTCTimeOrZero(Handle dateObj) { + double t = dateObj->as().UTCTime().toNumber(); + return std::isnan(t) ? +0 : t; +} + +/* ES5 15.9.5.40. */ +static bool date_setFullYear(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setFullYear")); + if (!unwrapped) { + return false; + } + + /* Step 1. */ + double t = ThisLocalTimeOrZero(unwrapped->shouldRFP(), unwrapped); + + /* Step 2. */ + double y; + if (!ToNumber(cx, args.get(0), &y)) { + return false; + } + + /* Step 3. */ + double m; + if (!GetMonthOrDefault(cx, args, 1, t, &m)) { + return false; + } + + /* Step 4. */ + double date; + if (!GetDateOrDefault(cx, args, 2, t, &date)) { + return false; + } + + /* Step 5. */ + double newDate = MakeDate(MakeDay(y, m, date), TimeWithinDay(t)); + + /* Step 6. */ + ClippedTime u = TimeClip(UTC(unwrapped->shouldRFP(), newDate)); + + /* Steps 7-8. */ + unwrapped->setUTCTime(u, args.rval()); + return true; +} + +/* ES5 15.9.5.41. */ +static bool date_setUTCFullYear(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setUTCFullYear")); + if (!unwrapped) { + return false; + } + + /* Step 1. */ + double t = ThisUTCTimeOrZero(unwrapped); + + /* Step 2. */ + double y; + if (!ToNumber(cx, args.get(0), &y)) { + return false; + } + + /* Step 3. */ + double m; + if (!GetMonthOrDefault(cx, args, 1, t, &m)) { + return false; + } + + /* Step 4. */ + double date; + if (!GetDateOrDefault(cx, args, 2, t, &date)) { + return false; + } + + /* Step 5. */ + double newDate = MakeDate(MakeDay(y, m, date), TimeWithinDay(t)); + + /* Step 6. */ + ClippedTime v = TimeClip(newDate); + + /* Steps 7-8. */ + unwrapped->setUTCTime(v, args.rval()); + return true; +} + +/* ES5 Annex B.2.5. */ +static bool date_setYear(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + Rooted unwrapped( + cx, UnwrapAndTypeCheckThis(cx, args, "setYear")); + if (!unwrapped) { + return false; + } + + /* Step 1. */ + double t = ThisLocalTimeOrZero(unwrapped->shouldRFP(), unwrapped); + + /* Step 2. */ + double y; + if (!ToNumber(cx, args.get(0), &y)) { + return false; + } + + /* Step 3. */ + if (std::isnan(y)) { + unwrapped->setUTCTime(ClippedTime::invalid(), args.rval()); + return true; + } + + /* Step 4. */ + double yint = ToInteger(y); + if (0 <= yint && yint <= 99) { + yint += 1900; + } + + /* Step 5. */ + double day = MakeDay(yint, MonthFromTime(t), DateFromTime(t)); + + /* Step 6. */ + double u = UTC(unwrapped->shouldRFP(), MakeDate(day, TimeWithinDay(t))); + + /* Steps 7-8. */ + unwrapped->setUTCTime(TimeClip(u), args.rval()); + return true; +} + +/* constants for toString, toUTCString */ +static const char* const days[] = {"Sun", "Mon", "Tue", "Wed", + "Thu", "Fri", "Sat"}; +static const char* const months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; + +/* ES5 B.2.6. */ +static bool date_toUTCString(JSContext* cx, unsigned argc, Value* vp) { + AutoJSMethodProfilerEntry pseudoFrame(cx, "Date.prototype", "toUTCString"); + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "toUTCString"); + if (!unwrapped) { + return false; + } + + double utctime = unwrapped->UTCTime().toNumber(); + if (!std::isfinite(utctime)) { + args.rval().setString(cx->names().InvalidDate); + return true; + } + + char buf[100]; + SprintfLiteral(buf, "%s, %.2d %s %.4d %.2d:%.2d:%.2d GMT", + days[int(WeekDay(utctime))], int(DateFromTime(utctime)), + months[int(MonthFromTime(utctime))], + int(YearFromTime(utctime)), int(HourFromTime(utctime)), + int(MinFromTime(utctime)), int(SecFromTime(utctime))); + + JSString* str = NewStringCopyZ(cx, buf); + if (!str) { + return false; + } + + args.rval().setString(str); + return true; +} + +/* ES6 draft 2015-01-15 20.3.4.36. */ +static bool date_toISOString(JSContext* cx, unsigned argc, Value* vp) { + AutoJSMethodProfilerEntry pseudoFrame(cx, "Date.prototype", "toISOString"); + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "toISOString"); + if (!unwrapped) { + return false; + } + + double utctime = unwrapped->UTCTime().toNumber(); + if (!std::isfinite(utctime)) { + JS_ReportErrorNumberASCII(cx, js::GetErrorMessage, nullptr, + JSMSG_INVALID_DATE); + return false; + } + + char buf[100]; + int year = int(YearFromTime(utctime)); + if (year < 0 || year > 9999) { + SprintfLiteral(buf, "%+.6d-%.2d-%.2dT%.2d:%.2d:%.2d.%.3dZ", + int(YearFromTime(utctime)), int(MonthFromTime(utctime)) + 1, + int(DateFromTime(utctime)), int(HourFromTime(utctime)), + int(MinFromTime(utctime)), int(SecFromTime(utctime)), + int(msFromTime(utctime))); + } else { + SprintfLiteral(buf, "%.4d-%.2d-%.2dT%.2d:%.2d:%.2d.%.3dZ", + int(YearFromTime(utctime)), int(MonthFromTime(utctime)) + 1, + int(DateFromTime(utctime)), int(HourFromTime(utctime)), + int(MinFromTime(utctime)), int(SecFromTime(utctime)), + int(msFromTime(utctime))); + } + + JSString* str = NewStringCopyZ(cx, buf); + if (!str) { + return false; + } + args.rval().setString(str); + return true; +} + +/* ES5 15.9.5.44. */ +static bool date_toJSON(JSContext* cx, unsigned argc, Value* vp) { + AutoJSMethodProfilerEntry pseudoFrame(cx, "Date.prototype", "toJSON"); + CallArgs args = CallArgsFromVp(argc, vp); + + /* Step 1. */ + RootedObject obj(cx, ToObject(cx, args.thisv())); + if (!obj) { + return false; + } + + /* Step 2. */ + RootedValue tv(cx, ObjectValue(*obj)); + if (!ToPrimitive(cx, JSTYPE_NUMBER, &tv)) { + return false; + } + + /* Step 3. */ + if (tv.isDouble() && !std::isfinite(tv.toDouble())) { + args.rval().setNull(); + return true; + } + + /* Step 4. */ + RootedValue toISO(cx); + if (!GetProperty(cx, obj, obj, cx->names().toISOString, &toISO)) { + return false; + } + + /* Step 5. */ + if (!IsCallable(toISO)) { + JS_ReportErrorNumberASCII(cx, js::GetErrorMessage, nullptr, + JSMSG_BAD_TOISOSTRING_PROP); + return false; + } + + /* Step 6. */ + return Call(cx, toISO, obj, args.rval()); +} + +#if JS_HAS_INTL_API +JSString* DateTimeHelper::timeZoneComment(JSContext* cx, + DateTimeInfo::ShouldRFP shouldRFP, + double utcTime, double localTime) { + const char* locale = cx->runtime()->getDefaultLocale(); + if (!locale) { + JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, + JSMSG_DEFAULT_LOCALE_ERROR); + return nullptr; + } + + char16_t tzbuf[100]; + tzbuf[0] = ' '; + tzbuf[1] = '('; + + char16_t* timeZoneStart = tzbuf + 2; + constexpr size_t remainingSpace = + std::size(tzbuf) - 2 - 1; // for the trailing ')' + + int64_t utcMilliseconds = static_cast(utcTime); + if (!DateTimeInfo::timeZoneDisplayName( + shouldRFP, timeZoneStart, remainingSpace, utcMilliseconds, locale)) { + JS_ReportOutOfMemory(cx); + return nullptr; + } + + // Reject if the result string is empty. + size_t len = js_strlen(timeZoneStart); + if (len == 0) { + return cx->names().empty; + } + + // Parenthesize the returned display name. + timeZoneStart[len] = ')'; + + return NewStringCopyN(cx, tzbuf, 2 + len + 1); +} +#else +/* Interface to PRMJTime date struct. */ +PRMJTime DateTimeHelper::toPRMJTime(DateTimeInfo::ShouldRFP shouldRFP, + double localTime, double utcTime) { + double year = YearFromTime(localTime); + + PRMJTime prtm; + prtm.tm_usec = int32_t(msFromTime(localTime)) * 1000; + prtm.tm_sec = int8_t(SecFromTime(localTime)); + prtm.tm_min = int8_t(MinFromTime(localTime)); + prtm.tm_hour = int8_t(HourFromTime(localTime)); + prtm.tm_mday = int8_t(DateFromTime(localTime)); + prtm.tm_mon = int8_t(MonthFromTime(localTime)); + prtm.tm_wday = int8_t(WeekDay(localTime)); + prtm.tm_year = year; + prtm.tm_yday = int16_t(DayWithinYear(localTime, year)); + prtm.tm_isdst = (daylightSavingTA(shouldRFP, utcTime) != 0); + + return prtm; +} + +size_t DateTimeHelper::formatTime(DateTimeInfo::ShouldRFP shouldRFP, char* buf, + size_t buflen, const char* fmt, + double utcTime, double localTime) { + PRMJTime prtm = toPRMJTime(shouldRFP, localTime, utcTime); + + // If an equivalent year was used to compute the date/time components, use + // the same equivalent year to determine the time zone name and offset in + // PRMJ_FormatTime(...). + int timeZoneYear = isRepresentableAsTime32(utcTime) + ? prtm.tm_year + : equivalentYearForDST(prtm.tm_year); + int offsetInSeconds = (int)floor((localTime - utcTime) / msPerSecond); + + return PRMJ_FormatTime(buf, buflen, fmt, &prtm, timeZoneYear, + offsetInSeconds); +} + +JSString* DateTimeHelper::timeZoneComment(JSContext* cx, + DateTimeInfo::ShouldRFP shouldRFP, + double utcTime, double localTime) { + char tzbuf[100]; + + size_t tzlen = + formatTime(shouldRFP, tzbuf, sizeof tzbuf, " (%Z)", utcTime, localTime); + if (tzlen != 0) { + // Decide whether to use the resulting time zone string. + // + // Reject it if it contains any non-ASCII or non-printable characters. + // It's then likely in some other character encoding, and we probably + // won't display it correctly. + bool usetz = true; + for (size_t i = 0; i < tzlen; i++) { + char16_t c = tzbuf[i]; + if (!IsAsciiPrintable(c)) { + usetz = false; + break; + } + } + + // Also reject it if it's not parenthesized or if it's ' ()'. + if (tzbuf[0] != ' ' || tzbuf[1] != '(' || tzbuf[2] == ')') { + usetz = false; + } + + if (usetz) { + return NewStringCopyN(cx, tzbuf, tzlen); + } + } + + return cx->names().empty; +} +#endif /* JS_HAS_INTL_API */ + +enum class FormatSpec { DateTime, Date, Time }; + +static bool FormatDate(JSContext* cx, DateTimeInfo::ShouldRFP shouldRFP, + double utcTime, FormatSpec format, + MutableHandleValue rval) { + if (!std::isfinite(utcTime)) { + rval.setString(cx->names().InvalidDate); + return true; + } + + MOZ_ASSERT(NumbersAreIdentical(TimeClip(utcTime).toDouble(), utcTime)); + + double localTime = LocalTime(shouldRFP, utcTime); + + int offset = 0; + RootedString timeZoneComment(cx); + if (format == FormatSpec::DateTime || format == FormatSpec::Time) { + // Offset from GMT in minutes. The offset includes daylight savings, + // if it applies. + int minutes = (int)trunc((localTime - utcTime) / msPerMinute); + + // Map 510 minutes to 0830 hours. + offset = (minutes / 60) * 100 + minutes % 60; + + // Print as "Wed Nov 05 1997 19:38:03 GMT-0800 (PST)". + // + // The TZA is printed as 'GMT-0800' rather than as 'PST' to avoid + // operating-system dependence on strftime (which PRMJ_FormatTime + // calls, for %Z only.) win32 prints PST as 'Pacific Standard Time.' + // This way we always know what we're getting, and can parse it if + // we produce it. The OS time zone string is included as a comment. + // + // When ICU is used to retrieve the time zone string, the localized + // 'long' name format from CLDR is used. For example when the default + // locale is "en-US", PST is displayed as 'Pacific Standard Time', but + // when it is "ru", 'Тихоокеанское стандартное время' is used. This + // also means the time zone string may not fit into Latin-1. + + // Get a time zone string from the OS or ICU to include as a comment. + timeZoneComment = + DateTimeHelper::timeZoneComment(cx, shouldRFP, utcTime, localTime); + if (!timeZoneComment) { + return false; + } + } + + char buf[100]; + switch (format) { + case FormatSpec::DateTime: + /* Tue Oct 31 2000 09:41:40 GMT-0800 */ + SprintfLiteral(buf, "%s %s %.2d %.4d %.2d:%.2d:%.2d GMT%+.4d", + days[int(WeekDay(localTime))], + months[int(MonthFromTime(localTime))], + int(DateFromTime(localTime)), int(YearFromTime(localTime)), + int(HourFromTime(localTime)), int(MinFromTime(localTime)), + int(SecFromTime(localTime)), offset); + break; + case FormatSpec::Date: + /* Tue Oct 31 2000 */ + SprintfLiteral(buf, "%s %s %.2d %.4d", days[int(WeekDay(localTime))], + months[int(MonthFromTime(localTime))], + int(DateFromTime(localTime)), + int(YearFromTime(localTime))); + break; + case FormatSpec::Time: + /* 09:41:40 GMT-0800 */ + SprintfLiteral(buf, "%.2d:%.2d:%.2d GMT%+.4d", + int(HourFromTime(localTime)), int(MinFromTime(localTime)), + int(SecFromTime(localTime)), offset); + break; + } + + RootedString str(cx, NewStringCopyZ(cx, buf)); + if (!str) { + return false; + } + + // Append the time zone string if present. + if (timeZoneComment && !timeZoneComment->empty()) { + str = js::ConcatStrings(cx, str, timeZoneComment); + if (!str) { + return false; + } + } + + rval.setString(str); + return true; +} + +#if !JS_HAS_INTL_API +static bool ToLocaleFormatHelper(JSContext* cx, + DateTimeInfo::ShouldRFP shouldRFP, + double utcTime, const char* format, + MutableHandleValue rval) { + char buf[100]; + if (!std::isfinite(utcTime)) { + strcpy(buf, js_InvalidDate_str); + } else { + double localTime = LocalTime(shouldRFP, utcTime); + + /* Let PRMJTime format it. */ + size_t result_len = DateTimeHelper::formatTime(shouldRFP, buf, sizeof buf, + format, utcTime, localTime); + + /* If it failed, default to toString. */ + if (result_len == 0) { + return FormatDate(cx, shouldRFP, utcTime, FormatSpec::DateTime, rval); + } + + /* Hacked check against undesired 2-digit year 00/00/00 form. */ + if (strcmp(format, "%x") == 0 && result_len >= 6 && + /* Format %x means use OS settings, which may have 2-digit yr, so + hack end of 3/11/22 or 11.03.22 or 11Mar22 to use 4-digit yr...*/ + !IsAsciiDigit(buf[result_len - 3]) && + IsAsciiDigit(buf[result_len - 2]) && + IsAsciiDigit(buf[result_len - 1]) && + /* ...but not if starts with 4-digit year, like 2022/3/11. */ + !(IsAsciiDigit(buf[0]) && IsAsciiDigit(buf[1]) && + IsAsciiDigit(buf[2]) && IsAsciiDigit(buf[3]))) { + int year = int(YearFromTime(localTime)); + snprintf(buf + (result_len - 2), (sizeof buf) - (result_len - 2), "%d", + year); + } + } + + if (cx->runtime()->localeCallbacks && + cx->runtime()->localeCallbacks->localeToUnicode) { + return cx->runtime()->localeCallbacks->localeToUnicode(cx, buf, rval); + } + + JSString* str = NewStringCopyZ(cx, buf); + if (!str) { + return false; + } + rval.setString(str); + return true; +} + +/* ES5 15.9.5.5. */ +static bool date_toLocaleString(JSContext* cx, unsigned argc, Value* vp) { + AutoJSMethodProfilerEntry pseudoFrame(cx, "Date.prototype", "toLocaleString"); + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = + UnwrapAndTypeCheckThis(cx, args, "toLocaleString"); + if (!unwrapped) { + return false; + } + + /* + * Use '%#c' for windows, because '%c' is backward-compatible and non-y2k + * with msvc; '%#c' requests that a full year be used in the result string. + */ + static const char format[] = +# if defined(_WIN32) + "%#c" +# else + "%c" +# endif + ; + + return ToLocaleFormatHelper(cx, unwrapped->shouldRFP(), + unwrapped->UTCTime().toNumber(), format, + args.rval()); +} + +static bool date_toLocaleDateString(JSContext* cx, unsigned argc, Value* vp) { + AutoJSMethodProfilerEntry pseudoFrame(cx, "Date.prototype", + "toLocaleDateString"); + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = + UnwrapAndTypeCheckThis(cx, args, "toLocaleDateString"); + if (!unwrapped) { + return false; + } + + /* + * Use '%#x' for windows, because '%x' is backward-compatible and non-y2k + * with msvc; '%#x' requests that a full year be used in the result string. + */ + static const char format[] = +# if defined(_WIN32) + "%#x" +# else + "%x" +# endif + ; + + return ToLocaleFormatHelper(cx, unwrapped->shouldRFP(), + unwrapped->UTCTime().toNumber(), format, + args.rval()); +} + +static bool date_toLocaleTimeString(JSContext* cx, unsigned argc, Value* vp) { + AutoJSMethodProfilerEntry pseudoFrame(cx, "Date.prototype", + "toLocaleTimeString"); + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = + UnwrapAndTypeCheckThis(cx, args, "toLocaleTimeString"); + if (!unwrapped) { + return false; + } + + return ToLocaleFormatHelper(cx, unwrapped->shouldRFP(), + unwrapped->UTCTime().toNumber(), "%X", + args.rval()); +} +#endif /* !JS_HAS_INTL_API */ + +static bool date_toTimeString(JSContext* cx, unsigned argc, Value* vp) { + AutoJSMethodProfilerEntry pseudoFrame(cx, "Date.prototype", "toTimeString"); + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = + UnwrapAndTypeCheckThis(cx, args, "toTimeString"); + if (!unwrapped) { + return false; + } + + return FormatDate(cx, unwrapped->shouldRFP(), unwrapped->UTCTime().toNumber(), + FormatSpec::Time, args.rval()); +} + +static bool date_toDateString(JSContext* cx, unsigned argc, Value* vp) { + AutoJSMethodProfilerEntry pseudoFrame(cx, "Date.prototype", "toDateString"); + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = + UnwrapAndTypeCheckThis(cx, args, "toDateString"); + if (!unwrapped) { + return false; + } + + return FormatDate(cx, unwrapped->shouldRFP(), unwrapped->UTCTime().toNumber(), + FormatSpec::Date, args.rval()); +} + +static bool date_toSource(JSContext* cx, unsigned argc, Value* vp) { + AutoJSMethodProfilerEntry pseudoFrame(cx, "Date.prototype", "toSource"); + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "toSource"); + if (!unwrapped) { + return false; + } + + JSStringBuilder sb(cx); + if (!sb.append("(new Date(") || + !NumberValueToStringBuffer(unwrapped->UTCTime(), sb) || + !sb.append("))")) { + return false; + } + + JSString* str = sb.finishString(); + if (!str) { + return false; + } + args.rval().setString(str); + return true; +} + +bool date_toString(JSContext* cx, unsigned argc, Value* vp) { + AutoJSMethodProfilerEntry pseudoFrame(cx, "Date.prototype", "toString"); + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "toString"); + if (!unwrapped) { + return false; + } + + return FormatDate(cx, unwrapped->shouldRFP(), unwrapped->UTCTime().toNumber(), + FormatSpec::DateTime, args.rval()); +} + +bool js::date_valueOf(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + auto* unwrapped = UnwrapAndTypeCheckThis(cx, args, "valueOf"); + if (!unwrapped) { + return false; + } + + args.rval().set(unwrapped->UTCTime()); + return true; +} + +// ES6 20.3.4.45 Date.prototype[@@toPrimitive] +static bool date_toPrimitive(JSContext* cx, unsigned argc, Value* vp) { + CallArgs args = CallArgsFromVp(argc, vp); + + // Steps 1-2. + if (!args.thisv().isObject()) { + ReportIncompatible(cx, args); + return false; + } + + // Steps 3-5. + JSType hint; + if (!GetFirstArgumentAsTypeHint(cx, args, &hint)) { + return false; + } + if (hint == JSTYPE_UNDEFINED) { + hint = JSTYPE_STRING; + } + + args.rval().set(args.thisv()); + RootedObject obj(cx, &args.thisv().toObject()); + return OrdinaryToPrimitive(cx, obj, hint, args.rval()); +} + +static const JSFunctionSpec date_static_methods[] = { + JS_FN("UTC", date_UTC, 7, 0), JS_FN("parse", date_parse, 1, 0), + JS_FN("now", date_now, 0, 0), JS_FS_END}; + +static const JSFunctionSpec date_methods[] = { + JS_FN("getTime", date_getTime, 0, 0), + JS_FN("getTimezoneOffset", date_getTimezoneOffset, 0, 0), + JS_FN("getYear", date_getYear, 0, 0), + JS_FN("getFullYear", date_getFullYear, 0, 0), + JS_FN("getUTCFullYear", date_getUTCFullYear, 0, 0), + JS_FN("getMonth", date_getMonth, 0, 0), + JS_FN("getUTCMonth", date_getUTCMonth, 0, 0), + JS_FN("getDate", date_getDate, 0, 0), + JS_FN("getUTCDate", date_getUTCDate, 0, 0), + JS_FN("getDay", date_getDay, 0, 0), + JS_FN("getUTCDay", date_getUTCDay, 0, 0), + JS_FN("getHours", date_getHours, 0, 0), + JS_FN("getUTCHours", date_getUTCHours, 0, 0), + JS_FN("getMinutes", date_getMinutes, 0, 0), + JS_FN("getUTCMinutes", date_getUTCMinutes, 0, 0), + JS_FN("getSeconds", date_getSeconds, 0, 0), + JS_FN("getUTCSeconds", date_getUTCSeconds, 0, 0), + JS_FN("getMilliseconds", date_getMilliseconds, 0, 0), + JS_FN("getUTCMilliseconds", date_getUTCMilliseconds, 0, 0), + JS_FN("setTime", date_setTime, 1, 0), + JS_FN("setYear", date_setYear, 1, 0), + JS_FN("setFullYear", date_setFullYear, 3, 0), + JS_FN("setUTCFullYear", date_setUTCFullYear, 3, 0), + JS_FN("setMonth", date_setMonth, 2, 0), + JS_FN("setUTCMonth", date_setUTCMonth, 2, 0), + JS_FN("setDate", date_setDate, 1, 0), + JS_FN("setUTCDate", date_setUTCDate, 1, 0), + JS_FN("setHours", date_setHours, 4, 0), + JS_FN("setUTCHours", date_setUTCHours, 4, 0), + JS_FN("setMinutes", date_setMinutes, 3, 0), + JS_FN("setUTCMinutes", date_setUTCMinutes, 3, 0), + JS_FN("setSeconds", date_setSeconds, 2, 0), + JS_FN("setUTCSeconds", date_setUTCSeconds, 2, 0), + JS_FN("setMilliseconds", date_setMilliseconds, 1, 0), + JS_FN("setUTCMilliseconds", date_setUTCMilliseconds, 1, 0), + JS_FN("toUTCString", date_toUTCString, 0, 0), +#if JS_HAS_INTL_API + JS_SELF_HOSTED_FN(js_toLocaleString_str, "Date_toLocaleString", 0, 0), + JS_SELF_HOSTED_FN("toLocaleDateString", "Date_toLocaleDateString", 0, 0), + JS_SELF_HOSTED_FN("toLocaleTimeString", "Date_toLocaleTimeString", 0, 0), +#else + JS_FN(js_toLocaleString_str, date_toLocaleString, 0, 0), + JS_FN("toLocaleDateString", date_toLocaleDateString, 0, 0), + JS_FN("toLocaleTimeString", date_toLocaleTimeString, 0, 0), +#endif + JS_FN("toDateString", date_toDateString, 0, 0), + JS_FN("toTimeString", date_toTimeString, 0, 0), + JS_FN("toISOString", date_toISOString, 0, 0), + JS_FN(js_toJSON_str, date_toJSON, 1, 0), + JS_FN(js_toSource_str, date_toSource, 0, 0), + JS_FN(js_toString_str, date_toString, 0, 0), + JS_FN(js_valueOf_str, date_valueOf, 0, 0), + JS_SYM_FN(toPrimitive, date_toPrimitive, 1, JSPROP_READONLY), + JS_FS_END}; + +static bool NewDateObject(JSContext* cx, const CallArgs& args, ClippedTime t) { + MOZ_ASSERT(args.isConstructing()); + + RootedObject proto(cx); + if (!GetPrototypeFromBuiltinConstructor(cx, args, JSProto_Date, &proto)) { + return false; + } + + JSObject* obj = NewDateObjectMsec(cx, t, proto); + if (!obj) { + return false; + } + + args.rval().setObject(*obj); + return true; +} + +static bool ToDateString(JSContext* cx, const CallArgs& args, ClippedTime t) { + return FormatDate(cx, ShouldRFP(cx->realm()), t.toDouble(), + FormatSpec::DateTime, args.rval()); +} + +static bool DateNoArguments(JSContext* cx, const CallArgs& args) { + MOZ_ASSERT(args.length() == 0); + + ClippedTime now = NowAsMillis(cx); + + if (args.isConstructing()) { + return NewDateObject(cx, args, now); + } + + return ToDateString(cx, args, now); +} + +static bool DateOneArgument(JSContext* cx, const CallArgs& args) { + MOZ_ASSERT(args.length() == 1); + + if (args.isConstructing()) { + if (args[0].isObject()) { + RootedObject obj(cx, &args[0].toObject()); + + ESClass cls; + if (!GetBuiltinClass(cx, obj, &cls)) { + return false; + } + + if (cls == ESClass::Date) { + RootedValue unboxed(cx); + if (!Unbox(cx, obj, &unboxed)) { + return false; + } + + return NewDateObject(cx, args, TimeClip(unboxed.toNumber())); + } + } + + if (!ToPrimitive(cx, args[0])) { + return false; + } + + ClippedTime t; + if (args[0].isString()) { + JSLinearString* linearStr = args[0].toString()->ensureLinear(cx); + if (!linearStr) { + return false; + } + + if (!ParseDate(ShouldRFP(cx->realm()), linearStr, &t)) { + t = ClippedTime::invalid(); + } + } else { + double d; + if (!ToNumber(cx, args[0], &d)) { + return false; + } + t = TimeClip(d); + } + + return NewDateObject(cx, args, t); + } + + return ToDateString(cx, args, NowAsMillis(cx)); +} + +static bool DateMultipleArguments(JSContext* cx, const CallArgs& args) { + MOZ_ASSERT(args.length() >= 2); + + // Step 3. + if (args.isConstructing()) { + // Steps 3a-b. + double y; + if (!ToNumber(cx, args[0], &y)) { + return false; + } + + // Steps 3c-d. + double m; + if (!ToNumber(cx, args[1], &m)) { + return false; + } + + // Steps 3e-f. + double dt; + if (args.length() >= 3) { + if (!ToNumber(cx, args[2], &dt)) { + return false; + } + } else { + dt = 1; + } + + // Steps 3g-h. + double h; + if (args.length() >= 4) { + if (!ToNumber(cx, args[3], &h)) { + return false; + } + } else { + h = 0; + } + + // Steps 3i-j. + double min; + if (args.length() >= 5) { + if (!ToNumber(cx, args[4], &min)) { + return false; + } + } else { + min = 0; + } + + // Steps 3k-l. + double s; + if (args.length() >= 6) { + if (!ToNumber(cx, args[5], &s)) { + return false; + } + } else { + s = 0; + } + + // Steps 3m-n. + double milli; + if (args.length() >= 7) { + if (!ToNumber(cx, args[6], &milli)) { + return false; + } + } else { + milli = 0; + } + + // Step 3o. + double yr = y; + if (!std::isnan(y)) { + double yint = ToInteger(y); + if (0 <= yint && yint <= 99) { + yr = 1900 + yint; + } + } + + // Step 3p. + double finalDate = MakeDate(MakeDay(yr, m, dt), MakeTime(h, min, s, milli)); + + // Steps 3q-t. + return NewDateObject(cx, args, + TimeClip(UTC(ShouldRFP(cx->realm()), finalDate))); + } + + return ToDateString(cx, args, NowAsMillis(cx)); +} + +static bool DateConstructor(JSContext* cx, unsigned argc, Value* vp) { + AutoJSConstructorProfilerEntry pseudoFrame(cx, "Date"); + CallArgs args = CallArgsFromVp(argc, vp); + + if (args.length() == 0) { + return DateNoArguments(cx, args); + } + + if (args.length() == 1) { + return DateOneArgument(cx, args); + } + + return DateMultipleArguments(cx, args); +} + +static bool FinishDateClassInit(JSContext* cx, HandleObject ctor, + HandleObject proto) { + /* + * Date.prototype.toGMTString has the same initial value as + * Date.prototype.toUTCString. + */ + RootedValue toUTCStringFun(cx); + RootedId toUTCStringId(cx, NameToId(cx->names().toUTCString)); + RootedId toGMTStringId(cx, NameToId(cx->names().toGMTString)); + return NativeGetProperty(cx, proto.as(), toUTCStringId, + &toUTCStringFun) && + NativeDefineDataProperty(cx, proto.as(), toGMTStringId, + toUTCStringFun, 0); +} + +static const ClassSpec DateObjectClassSpec = { + GenericCreateConstructor, + GenericCreatePrototype, + date_static_methods, + nullptr, + date_methods, + nullptr, + FinishDateClassInit}; + +const JSClass DateObject::class_ = {js_Date_str, + JSCLASS_HAS_RESERVED_SLOTS(RESERVED_SLOTS) | + JSCLASS_HAS_CACHED_PROTO(JSProto_Date), + JS_NULL_CLASS_OPS, &DateObjectClassSpec}; + +const JSClass DateObject::protoClass_ = { + "Date.prototype", JSCLASS_HAS_CACHED_PROTO(JSProto_Date), JS_NULL_CLASS_OPS, + &DateObjectClassSpec}; + +JSObject* js::NewDateObjectMsec(JSContext* cx, ClippedTime t, + HandleObject proto /* = nullptr */) { + DateObject* obj = NewObjectWithClassProto(cx, proto); + if (!obj) { + return nullptr; + } + obj->setUTCTime(t); + return obj; +} + +JS_PUBLIC_API JSObject* JS::NewDateObject(JSContext* cx, ClippedTime time) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return NewDateObjectMsec(cx, time); +} + +JS_PUBLIC_API JSObject* js::NewDateObject(JSContext* cx, int year, int mon, + int mday, int hour, int min, + int sec) { + MOZ_ASSERT(mon < 12); + double msec_time = + MakeDate(MakeDay(year, mon, mday), MakeTime(hour, min, sec, 0.0)); + return NewDateObjectMsec(cx, + TimeClip(UTC(ShouldRFP(cx->realm()), msec_time))); +} + +JS_PUBLIC_API bool js::DateIsValid(JSContext* cx, HandleObject obj, + bool* isValid) { + ESClass cls; + if (!GetBuiltinClass(cx, obj, &cls)) { + return false; + } + + if (cls != ESClass::Date) { + *isValid = false; + return true; + } + + RootedValue unboxed(cx); + if (!Unbox(cx, obj, &unboxed)) { + return false; + } + + *isValid = !std::isnan(unboxed.toNumber()); + return true; +} + +JS_PUBLIC_API JSObject* JS::NewDateObject(JSContext* cx, int year, int mon, + int mday, int hour, int min, + int sec) { + AssertHeapIsIdle(); + CHECK_THREAD(cx); + return js::NewDateObject(cx, year, mon, mday, hour, min, sec); +} + +JS_PUBLIC_API bool JS::ObjectIsDate(JSContext* cx, Handle obj, + bool* isDate) { + cx->check(obj); + + ESClass cls; + if (!GetBuiltinClass(cx, obj, &cls)) { + return false; + } + + *isDate = cls == ESClass::Date; + return true; +} + +JS_PUBLIC_API bool js::DateGetMsecSinceEpoch(JSContext* cx, HandleObject obj, + double* msecsSinceEpoch) { + ESClass cls; + if (!GetBuiltinClass(cx, obj, &cls)) { + return false; + } + + if (cls != ESClass::Date) { + *msecsSinceEpoch = 0; + return true; + } + + RootedValue unboxed(cx); + if (!Unbox(cx, obj, &unboxed)) { + return false; + } + + *msecsSinceEpoch = unboxed.toNumber(); + return true; +} -- cgit v1.2.3