Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-19 15:43:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibJS/Runtime/Date.cpp

404 lines
15 KiB
C++
Raw Normal View History

LibJS: Start implementing Date :^) This adds: - A global Date object (with `length` property and `now` function) - The Date constructor (no arguments yet) - The Date prototype (with `get*` functions)
2020-03-30 00:21:56 +01:00
/*
LibJS: Fix type confusion in msFromTime This is an editorial change in the ECMA-262 spec. See: https://github.com/tc39/ecma262/commit/8e572b6
2022-05-03 21:23:57 +02:00
* Copyright (c) 2020-2022, Linus Groh <linusg@serenityos.org>
Everywhere: Update copyrights with my new serenityos.org e-mail :^)
2022-01-31 13:07:22 -05:00
* Copyright (c) 2022, Tim Flynn <trflynn89@serenityos.org>
LibJS: Start implementing Date :^) This adds: - A global Date object (with `length` property and `now` function) - The Date constructor (no arguments yet) - The Date prototype (with `get*` functions)
2020-03-30 00:21:56 +01:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
LibJS: Start implementing Date :^) This adds: - A global Date object (with `length` property and `now` function) - The Date constructor (no arguments yet) - The Date prototype (with `get*` functions)
2020-03-30 00:21:56 +01:00
*/
LibJS: Protect YearFromTime against non-finite times
2022-01-15 17:37:36 -05:00
#include <AK/NumericLimits.h>
LibJS: Implement Date.prototype.toISOString()
2020-08-20 16:29:27 -04:00
#include <AK/StringBuilder.h>
LibJS: Use AK::Time to implement the MakeDay AO We currently use Core::DateTime create, which internally uses mktime(). This has the issues pointed out by the (now removed) FIXME, but also has an issue on macOS where years before 1900 are not supported.
2022-01-05 12:26:15 -05:00
#include <AK/Time.h>
LibJS: Fix incorrect use of "modulo" in {hour,min,sec,ms}_from_time() These all would return incorrect results for negative time values. Also adds a missing floor() in sec_from_time().
2021-11-16 19:40:03 +00:00
#include <LibJS/Runtime/AbstractOperations.h>
LibJS: Start implementing Date :^) This adds: - A global Date object (with `length` property and `now` function) - The Date constructor (no arguments yet) - The Date prototype (with `get*` functions)
2020-03-30 00:21:56 +01:00
#include <LibJS/Runtime/Date.h>
LibJS: Pass prototype to Date constructor
2020-04-17 19:07:59 +02:00
#include <LibJS/Runtime/GlobalObject.h>
LibJS: Partially implement the LocalTZA AO Intl.DateTimeFormat will invoke this AO with isUTC=true, so this only implements that branch in LocalTZA.
2022-01-11 23:27:05 -05:00
#include <LibTimeZone/TimeZone.h>
LibJS: Ignore arguments in Date's constructor when called as a function Since theres no way to drop the arguments before the call to the constructor (or to signal to the constructor that it was not called directly), we simply reuse the code for the no arguments provided special case. (And to prevent code duplication, the code was extracted into the separate static function Date::now(GlobalObject&).
2021-06-06 15:42:19 +03:00
#include <time.h>
LibJS: Start implementing Date :^) This adds: - A global Date object (with `length` property and `now` function) - The Date constructor (no arguments yet) - The Date prototype (with `get*` functions)
2020-03-30 00:21:56 +01:00
namespace JS {
LibJS+LibWeb: Replace GlobalObject with Realm in create() functions This is a continuation of the previous two commits. As allocating a JS cell already primarily involves a realm instead of a global object, and we'll need to pass one to the allocate() function itself eventually (it's bridged via the global object right now), the create() functions need to receive a realm as well. The plan is for this to be the highest-level function that actually receives a realm and passes it around, AOs on an even higher level will use the "current realm" concept via VM::current_realm() as that's what the spec assumes; passing around realms (or global objects, for that matter) on higher AO levels is pointless and unlike for allocating individual objects, which may happen outside of regular JS execution, we don't need control over the specific realm that is being used there.
2022-08-16 00:20:49 +01:00
Date* Date::create(Realm& realm, double date_value)
LibJS: Re-implement the Date constructor / prototype for spec compliance First, this adds a constructor to the Date object to be created from a plain double. This is a first step to removing Core::DateTime as the basis for the Date object. A subsequent commit will remove the now- unused data from the object. Next, this implements the constructor in accordance to the spec. The constructor when NewTarget is undefined no longer allocates a Date on the heap. The other constructor properly uses recently created AOs to handle time zone and ensure the created [[DateValue]] is valid. Other methods on the constructor (Date.now) have not been touched yet. Last, the prototype is reimplemented. Again, we use other AOs to handle time zones and time clipping. Not all prototypes are fixed; most of them are, but a few (e.g. Date.prototype.getTimezoneOffset) were not fixed, but left in a mostly unimplemented state for another commit. In all of the above, spec comments are added. This is a rather large change; but it's tough to do any of these parts individually without breaking everything else.
2022-01-14 17:42:42 -05:00
{
LibJS: Move intrinsics to the realm Intrinsics, i.e. mostly constructor and prototype objects, but also things like empty and new object shape now live on a new heap-allocated JS::Intrinsics object, thus completing the long journey of taking all the magic away from the global object. This represents the Realm's [[Intrinsics]] slot in the spec and matches its existing [[GlobalObject]] / [[GlobalEnv]] slots in terms of architecture. In the majority of cases it should now be possibly to fully allocate a regular object without the global object existing, and in fact that's what we do now - the realm is allocated before the global object, and the intrinsics between both :^)
2022-08-27 00:54:55 +01:00
return realm.heap().allocate<Date>(realm, date_value, *realm.intrinsics().date_prototype());
LibJS: Re-implement the Date constructor / prototype for spec compliance First, this adds a constructor to the Date object to be created from a plain double. This is a first step to removing Core::DateTime as the basis for the Date object. A subsequent commit will remove the now- unused data from the object. Next, this implements the constructor in accordance to the spec. The constructor when NewTarget is undefined no longer allocates a Date on the heap. The other constructor properly uses recently created AOs to handle time zone and ensure the created [[DateValue]] is valid. Other methods on the constructor (Date.now) have not been touched yet. Last, the prototype is reimplemented. Again, we use other AOs to handle time zones and time clipping. Not all prototypes are fixed; most of them are, but a few (e.g. Date.prototype.getTimezoneOffset) were not fixed, but left in a mostly unimplemented state for another commit. In all of the above, spec comments are added. This is a rather large change; but it's tough to do any of these parts individually without breaking everything else.
2022-01-14 17:42:42 -05:00
}
Date::Date(double date_value, Object& prototype)
: Object(prototype)
, m_date_value(date_value)
{
}
LibJS: Implement Date.getUTC* Test files created with: $ for f in Libraries/LibJS/Tests/builtins/Date/Date.prototype.get*js; do cp $f $(echo $f | sed -e 's/get/getUTC/') ; done $ rm Libraries/LibJS/Tests/builtins/Date/Date.prototype.getUTCTime.js $ git add Libraries/LibJS/Tests/builtins/Date/Date.prototype.getUTC*.js $ ls Libraries/LibJS/Tests/builtins/Date/Date.prototype.getUTC*.js | \ xargs sed -i -e 's/get/getUTC/g'
2020-08-23 13:30:18 -04:00
String Date::iso_date_string() const
{
LibJS: Re-implement the Date constructor / prototype for spec compliance First, this adds a constructor to the Date object to be created from a plain double. This is a first step to removing Core::DateTime as the basis for the Date object. A subsequent commit will remove the now- unused data from the object. Next, this implements the constructor in accordance to the spec. The constructor when NewTarget is undefined no longer allocates a Date on the heap. The other constructor properly uses recently created AOs to handle time zone and ensure the created [[DateValue]] is valid. Other methods on the constructor (Date.now) have not been touched yet. Last, the prototype is reimplemented. Again, we use other AOs to handle time zones and time clipping. Not all prototypes are fixed; most of them are, but a few (e.g. Date.prototype.getTimezoneOffset) were not fixed, but left in a mostly unimplemented state for another commit. In all of the above, spec comments are added. This is a rather large change; but it's tough to do any of these parts individually without breaking everything else.
2022-01-14 17:42:42 -05:00
int year = year_from_time(m_date_value);
LibJS: Implement Date.prototype.toISOString()
2020-08-20 16:29:27 -04:00
StringBuilder builder;
if (year < 0)
LibJS: Convert StringBuilder::appendf() => AK::Format
2021-05-07 11:51:57 +02:00
builder.appendff("-{:06}", -year);
LibJS: Implement Date.prototype.toISOString()
2020-08-20 16:29:27 -04:00
else if (year > 9999)
LibJS: Convert StringBuilder::appendf() => AK::Format
2021-05-07 11:51:57 +02:00
builder.appendff("+{:06}", year);
LibJS: Implement Date.prototype.toISOString()
2020-08-20 16:29:27 -04:00
else
LibJS: Convert StringBuilder::appendf() => AK::Format
2021-05-07 11:51:57 +02:00
builder.appendff("{:04}", year);
LibJS: Implement Date.prototype.toISOString()
2020-08-20 16:29:27 -04:00
builder.append('-');
LibJS: Re-implement the Date constructor / prototype for spec compliance First, this adds a constructor to the Date object to be created from a plain double. This is a first step to removing Core::DateTime as the basis for the Date object. A subsequent commit will remove the now- unused data from the object. Next, this implements the constructor in accordance to the spec. The constructor when NewTarget is undefined no longer allocates a Date on the heap. The other constructor properly uses recently created AOs to handle time zone and ensure the created [[DateValue]] is valid. Other methods on the constructor (Date.now) have not been touched yet. Last, the prototype is reimplemented. Again, we use other AOs to handle time zones and time clipping. Not all prototypes are fixed; most of them are, but a few (e.g. Date.prototype.getTimezoneOffset) were not fixed, but left in a mostly unimplemented state for another commit. In all of the above, spec comments are added. This is a rather large change; but it's tough to do any of these parts individually without breaking everything else.
2022-01-14 17:42:42 -05:00
builder.appendff("{:02}", month_from_time(m_date_value) + 1);
LibJS: Implement Date.prototype.toISOString()
2020-08-20 16:29:27 -04:00
builder.append('-');
LibJS: Re-implement the Date constructor / prototype for spec compliance First, this adds a constructor to the Date object to be created from a plain double. This is a first step to removing Core::DateTime as the basis for the Date object. A subsequent commit will remove the now- unused data from the object. Next, this implements the constructor in accordance to the spec. The constructor when NewTarget is undefined no longer allocates a Date on the heap. The other constructor properly uses recently created AOs to handle time zone and ensure the created [[DateValue]] is valid. Other methods on the constructor (Date.now) have not been touched yet. Last, the prototype is reimplemented. Again, we use other AOs to handle time zones and time clipping. Not all prototypes are fixed; most of them are, but a few (e.g. Date.prototype.getTimezoneOffset) were not fixed, but left in a mostly unimplemented state for another commit. In all of the above, spec comments are added. This is a rather large change; but it's tough to do any of these parts individually without breaking everything else.
2022-01-14 17:42:42 -05:00
builder.appendff("{:02}", date_from_time(m_date_value));
LibJS: Implement Date.prototype.toISOString()
2020-08-20 16:29:27 -04:00
builder.append('T');
LibJS: Re-implement the Date constructor / prototype for spec compliance First, this adds a constructor to the Date object to be created from a plain double. This is a first step to removing Core::DateTime as the basis for the Date object. A subsequent commit will remove the now- unused data from the object. Next, this implements the constructor in accordance to the spec. The constructor when NewTarget is undefined no longer allocates a Date on the heap. The other constructor properly uses recently created AOs to handle time zone and ensure the created [[DateValue]] is valid. Other methods on the constructor (Date.now) have not been touched yet. Last, the prototype is reimplemented. Again, we use other AOs to handle time zones and time clipping. Not all prototypes are fixed; most of them are, but a few (e.g. Date.prototype.getTimezoneOffset) were not fixed, but left in a mostly unimplemented state for another commit. In all of the above, spec comments are added. This is a rather large change; but it's tough to do any of these parts individually without breaking everything else.
2022-01-14 17:42:42 -05:00
builder.appendff("{:02}", hour_from_time(m_date_value));
LibJS: Implement Date.prototype.toISOString()
2020-08-20 16:29:27 -04:00
builder.append(':');
LibJS: Re-implement the Date constructor / prototype for spec compliance First, this adds a constructor to the Date object to be created from a plain double. This is a first step to removing Core::DateTime as the basis for the Date object. A subsequent commit will remove the now- unused data from the object. Next, this implements the constructor in accordance to the spec. The constructor when NewTarget is undefined no longer allocates a Date on the heap. The other constructor properly uses recently created AOs to handle time zone and ensure the created [[DateValue]] is valid. Other methods on the constructor (Date.now) have not been touched yet. Last, the prototype is reimplemented. Again, we use other AOs to handle time zones and time clipping. Not all prototypes are fixed; most of them are, but a few (e.g. Date.prototype.getTimezoneOffset) were not fixed, but left in a mostly unimplemented state for another commit. In all of the above, spec comments are added. This is a rather large change; but it's tough to do any of these parts individually without breaking everything else.
2022-01-14 17:42:42 -05:00
builder.appendff("{:02}", min_from_time(m_date_value));
LibJS: Implement Date.prototype.toISOString()
2020-08-20 16:29:27 -04:00
builder.append(':');
LibJS: Re-implement the Date constructor / prototype for spec compliance First, this adds a constructor to the Date object to be created from a plain double. This is a first step to removing Core::DateTime as the basis for the Date object. A subsequent commit will remove the now- unused data from the object. Next, this implements the constructor in accordance to the spec. The constructor when NewTarget is undefined no longer allocates a Date on the heap. The other constructor properly uses recently created AOs to handle time zone and ensure the created [[DateValue]] is valid. Other methods on the constructor (Date.now) have not been touched yet. Last, the prototype is reimplemented. Again, we use other AOs to handle time zones and time clipping. Not all prototypes are fixed; most of them are, but a few (e.g. Date.prototype.getTimezoneOffset) were not fixed, but left in a mostly unimplemented state for another commit. In all of the above, spec comments are added. This is a rather large change; but it's tough to do any of these parts individually without breaking everything else.
2022-01-14 17:42:42 -05:00
builder.appendff("{:02}", sec_from_time(m_date_value));
LibJS: Implement Date.prototype.toISOString()
2020-08-20 16:29:27 -04:00
builder.append('.');
LibJS: Re-implement the Date constructor / prototype for spec compliance First, this adds a constructor to the Date object to be created from a plain double. This is a first step to removing Core::DateTime as the basis for the Date object. A subsequent commit will remove the now- unused data from the object. Next, this implements the constructor in accordance to the spec. The constructor when NewTarget is undefined no longer allocates a Date on the heap. The other constructor properly uses recently created AOs to handle time zone and ensure the created [[DateValue]] is valid. Other methods on the constructor (Date.now) have not been touched yet. Last, the prototype is reimplemented. Again, we use other AOs to handle time zones and time clipping. Not all prototypes are fixed; most of them are, but a few (e.g. Date.prototype.getTimezoneOffset) were not fixed, but left in a mostly unimplemented state for another commit. In all of the above, spec comments are added. This is a rather large change; but it's tough to do any of these parts individually without breaking everything else.
2022-01-14 17:42:42 -05:00
builder.appendff("{:03}", ms_from_time(m_date_value));
LibJS: Implement Date.prototype.toISOString()
2020-08-20 16:29:27 -04:00
builder.append('Z');
return builder.build();
}
LibJS: Implement a bunch of time value related Date AOs We don't have these yet as our Date implementation doesn't use the time value algorithms and AOs from the spec, but Temporal will need these in various contexts.
2021-07-25 20:47:40 +01:00
// DayWithinYear(t), https://tc39.es/ecma262/#eqn-DayWithinYear
u16 day_within_year(double t)
{
LibJS: Protect DayWithinYear against non-finite times
2022-01-16 00:54:48 -05:00
if (!Value(t).is_finite_number())
return 0;
LibJS: Implement a bunch of time value related Date AOs We don't have these yet as our Date implementation doesn't use the time value algorithms and AOs from the spec, but Temporal will need these in various contexts.
2021-07-25 20:47:40 +01:00
// Day(t) - DayFromYear(YearFromTime(t))
return static_cast<u16>(day(t) - day_from_year(year_from_time(t)));
}
// DateFromTime(t), https://tc39.es/ecma262/#sec-date-number
u8 date_from_time(double t)
{
switch (month_from_time(t)) {
// DayWithinYear(t) + 1𝔽 if MonthFromTime(t) = +0𝔽
case 0:
return day_within_year(t) + 1;
// DayWithinYear(t) - 30𝔽 if MonthFromTime(t) = 1𝔽
case 1:
return day_within_year(t) - 30;
// DayWithinYear(t) - 58𝔽 - InLeapYear(t) if MonthFromTime(t) = 2𝔽
case 2:
return day_within_year(t) - 58 - in_leap_year(t);
// DayWithinYear(t) - 89𝔽 - InLeapYear(t) if MonthFromTime(t) = 3𝔽
case 3:
return day_within_year(t) - 89 - in_leap_year(t);
// DayWithinYear(t) - 119𝔽 - InLeapYear(t) if MonthFromTime(t) = 4𝔽
case 4:
return day_within_year(t) - 119 - in_leap_year(t);
// DayWithinYear(t) - 150𝔽 - InLeapYear(t) if MonthFromTime(t) = 5𝔽
case 5:
return day_within_year(t) - 150 - in_leap_year(t);
// DayWithinYear(t) - 180𝔽 - InLeapYear(t) if MonthFromTime(t) = 6𝔽
case 6:
return day_within_year(t) - 180 - in_leap_year(t);
// DayWithinYear(t) - 211𝔽 - InLeapYear(t) if MonthFromTime(t) = 7𝔽
case 7:
return day_within_year(t) - 211 - in_leap_year(t);
// DayWithinYear(t) - 242𝔽 - InLeapYear(t) if MonthFromTime(t) = 8𝔽
case 8:
return day_within_year(t) - 242 - in_leap_year(t);
// DayWithinYear(t) - 272𝔽 - InLeapYear(t) if MonthFromTime(t) = 9𝔽
case 9:
return day_within_year(t) - 272 - in_leap_year(t);
// DayWithinYear(t) - 303𝔽 - InLeapYear(t) if MonthFromTime(t) = 10𝔽
case 10:
return day_within_year(t) - 303 - in_leap_year(t);
// DayWithinYear(t) - 333𝔽 - InLeapYear(t) if MonthFromTime(t) = 11𝔽
case 11:
return day_within_year(t) - 333 - in_leap_year(t);
default:
VERIFY_NOT_REACHED();
}
}
// DaysInYear(y), https://tc39.es/ecma262/#eqn-DaysInYear
u16 days_in_year(i32 y)
{
// 365𝔽 if (ℝ(y) modulo 4) ≠ 0
if (y % 4 != 0)
return 365;
// 366𝔽 if (ℝ(y) modulo 4) = 0 and (ℝ(y) modulo 100) ≠ 0
if (y % 4 == 0 && y % 100 != 0)
return 366;
// 365𝔽 if (ℝ(y) modulo 100) = 0 and (ℝ(y) modulo 400) ≠ 0
if (y % 100 == 0 && y % 400 != 0)
return 365;
// 366𝔽 if (ℝ(y) modulo 400) = 0
if (y % 400 == 0)
return 366;
VERIFY_NOT_REACHED();
}
// DayFromYear(y), https://tc39.es/ecma262/#eqn-DaysFromYear
double day_from_year(i32 y)
{
// 𝔽(365 × (ℝ(y) - 1970) + floor((ℝ(y) - 1969) / 4) - floor((ℝ(y) - 1901) / 100) + floor((ℝ(y) - 1601) / 400))
LibJS: Ensure final computation in DayFromYear is performed on a double When we multiple by 365, ensure the result is a double (not an i32) to prevent overflow.
2022-01-15 17:36:25 -05:00
return 365.0 * (y - 1970) + floor((y - 1969) / 4.0) - floor((y - 1901) / 100.0) + floor((y - 1601) / 400.0);
LibJS: Implement a bunch of time value related Date AOs We don't have these yet as our Date implementation doesn't use the time value algorithms and AOs from the spec, but Temporal will need these in various contexts.
2021-07-25 20:47:40 +01:00
}
LibJS: Adjust approximated result in year_from_time() if necessary
2021-11-05 01:18:27 +01:00
// TimeFromYear(y), https://tc39.es/ecma262/#eqn-TimeFromYear
double time_from_year(i32 y)
{
// msPerDay × DayFromYear(y)
LibJS: Move Hours/Minutes/Seconds/ms constants out of the Date class They can remain in this header, but will be used outside the Date context in Temporal.
2022-05-06 19:10:34 +02:00
return ms_per_day * day_from_year(y);
LibJS: Adjust approximated result in year_from_time() if necessary
2021-11-05 01:18:27 +01:00
}
LibJS: Implement a bunch of time value related Date AOs We don't have these yet as our Date implementation doesn't use the time value algorithms and AOs from the spec, but Temporal will need these in various contexts.
2021-07-25 20:47:40 +01:00
// YearFromTime(t), https://tc39.es/ecma262/#eqn-YearFromTime
i32 year_from_time(double t)
{
// the largest integral Number y (closest to +∞) such that TimeFromYear(y) ≤ t
LibJS: Protect YearFromTime against non-finite times
2022-01-15 17:37:36 -05:00
if (!Value(t).is_finite_number())
return NumericLimits<i32>::max();
LibJS: Adjust approximated result in year_from_time() if necessary
2021-11-05 01:18:27 +01:00
// Approximation using average number of milliseconds per year. We might have to adjust this guess afterwards.
LibJS: Move Hours/Minutes/Seconds/ms constants out of the Date class They can remain in this header, but will be used outside the Date context in Temporal.
2022-05-06 19:10:34 +02:00
auto year = static_cast<i32>(t / (365.2425 * ms_per_day) + 1970);
LibJS: Adjust approximated result in year_from_time() if necessary
2021-11-05 01:18:27 +01:00
auto year_t = time_from_year(year);
if (year_t > t)
year--;
LibJS: Move Hours/Minutes/Seconds/ms constants out of the Date class They can remain in this header, but will be used outside the Date context in Temporal.
2022-05-06 19:10:34 +02:00
else if (year_t + days_in_year(year) * ms_per_day <= t)
LibJS: Adjust approximated result in year_from_time() if necessary
2021-11-05 01:18:27 +01:00
year++;
return year;
LibJS: Implement a bunch of time value related Date AOs We don't have these yet as our Date implementation doesn't use the time value algorithms and AOs from the spec, but Temporal will need these in various contexts.
2021-07-25 20:47:40 +01:00
}
// InLeapYear(t), https://tc39.es/ecma262/#eqn-InLeapYear
bool in_leap_year(double t)
{
// +0𝔽 if DaysInYear(YearFromTime(t)) = 365𝔽
// 1𝔽 if DaysInYear(YearFromTime(t)) = 366𝔽
return days_in_year(year_from_time(t)) == 366;
}
// MonthFromTime(t), https://tc39.es/ecma262/#eqn-MonthFromTime
u8 month_from_time(double t)
{
auto in_leap_year = JS::in_leap_year(t);
auto day_within_year = JS::day_within_year(t);
// +0𝔽 if +0𝔽 ≤ DayWithinYear(t) < 31𝔽
if (day_within_year < 31)
return 0;
// 1𝔽 if 31𝔽 ≤ DayWithinYear(t) < 59𝔽 + InLeapYear(t)
if (31 <= day_within_year && day_within_year < 59 + in_leap_year)
return 1;
// 2𝔽 if 59𝔽 + InLeapYear(t) ≤ DayWithinYear(t) < 90𝔽 + InLeapYear(t)
if (59 + in_leap_year <= day_within_year && day_within_year < 90 + in_leap_year)
return 2;
// 3𝔽 if 90𝔽 + InLeapYear(t) ≤ DayWithinYear(t) < 120𝔽 + InLeapYear(t)
if (90 + in_leap_year <= day_within_year && day_within_year < 120 + in_leap_year)
return 3;
// 4𝔽 if 120𝔽 + InLeapYear(t) ≤ DayWithinYear(t) < 151𝔽 + InLeapYear(t)
if (120 + in_leap_year <= day_within_year && day_within_year < 151 + in_leap_year)
return 4;
// 5𝔽 if 151𝔽 + InLeapYear(t) ≤ DayWithinYear(t) < 181𝔽 + InLeapYear(t)
if (151 + in_leap_year <= day_within_year && day_within_year < 181 + in_leap_year)
return 5;
// 6𝔽 if 181𝔽 + InLeapYear(t) ≤ DayWithinYear(t) < 212𝔽 + InLeapYear(t)
if (181 + in_leap_year <= day_within_year && day_within_year < 212 + in_leap_year)
return 6;
// 7𝔽 if 212𝔽 + InLeapYear(t) ≤ DayWithinYear(t) < 243𝔽 + InLeapYear(t)
if (212 + in_leap_year <= day_within_year && day_within_year < 243 + in_leap_year)
return 7;
// 8𝔽 if 243𝔽 + InLeapYear(t) ≤ DayWithinYear(t) < 273𝔽 + InLeapYear(t)
if (243 + in_leap_year <= day_within_year && day_within_year < 273 + in_leap_year)
return 8;
// 9𝔽 if 273𝔽 + InLeapYear(t) ≤ DayWithinYear(t) < 304𝔽 + InLeapYear(t)
if (273 + in_leap_year <= day_within_year && day_within_year < 304 + in_leap_year)
return 9;
// 10𝔽 if 304𝔽 + InLeapYear(t) ≤ DayWithinYear(t) < 334𝔽 + InLeapYear(t)
if (304 + in_leap_year <= day_within_year && day_within_year < 334 + in_leap_year)
return 10;
// 11𝔽 if 334𝔽 + InLeapYear(t) ≤ DayWithinYear(t) < 365𝔽 + InLeapYear(t)
if (334 + in_leap_year <= day_within_year && day_within_year < 365 + in_leap_year)
return 11;
VERIFY_NOT_REACHED();
}
// HourFromTime(t), https://tc39.es/ecma262/#eqn-HourFromTime
u8 hour_from_time(double t)
{
LibJS: Protect [TimeValue]FromTime from non-finite times Includes HourFromTime, MinFromTime, SecFromTime, msFromTime.
2022-01-16 01:15:46 -05:00
if (!Value(t).is_finite_number())
return 0;
LibJS: Implement a bunch of time value related Date AOs We don't have these yet as our Date implementation doesn't use the time value algorithms and AOs from the spec, but Temporal will need these in various contexts.
2021-07-25 20:47:40 +01:00
// 𝔽(floor(ℝ(t / msPerHour)) modulo HoursPerDay)
LibJS: Move Hours/Minutes/Seconds/ms constants out of the Date class They can remain in this header, but will be used outside the Date context in Temporal.
2022-05-06 19:10:34 +02:00
return static_cast<u8>(modulo(floor(t / ms_per_hour), hours_per_day));
LibJS: Implement a bunch of time value related Date AOs We don't have these yet as our Date implementation doesn't use the time value algorithms and AOs from the spec, but Temporal will need these in various contexts.
2021-07-25 20:47:40 +01:00
}
// MinFromTime(t), https://tc39.es/ecma262/#eqn-MinFromTime
u8 min_from_time(double t)
{
LibJS: Protect [TimeValue]FromTime from non-finite times Includes HourFromTime, MinFromTime, SecFromTime, msFromTime.
2022-01-16 01:15:46 -05:00
if (!Value(t).is_finite_number())
return 0;
LibJS: Implement a bunch of time value related Date AOs We don't have these yet as our Date implementation doesn't use the time value algorithms and AOs from the spec, but Temporal will need these in various contexts.
2021-07-25 20:47:40 +01:00
// 𝔽(floor(ℝ(t / msPerMinute)) modulo MinutesPerHour)
LibJS: Move Hours/Minutes/Seconds/ms constants out of the Date class They can remain in this header, but will be used outside the Date context in Temporal.
2022-05-06 19:10:34 +02:00
return static_cast<u8>(modulo(floor(t / ms_per_minute), minutes_per_hour));
LibJS: Implement a bunch of time value related Date AOs We don't have these yet as our Date implementation doesn't use the time value algorithms and AOs from the spec, but Temporal will need these in various contexts.
2021-07-25 20:47:40 +01:00
}
// SecFromTime(t), https://tc39.es/ecma262/#eqn-SecFromTime
u8 sec_from_time(double t)
{
LibJS: Protect [TimeValue]FromTime from non-finite times Includes HourFromTime, MinFromTime, SecFromTime, msFromTime.
2022-01-16 01:15:46 -05:00
if (!Value(t).is_finite_number())
return 0;
LibJS: Implement a bunch of time value related Date AOs We don't have these yet as our Date implementation doesn't use the time value algorithms and AOs from the spec, but Temporal will need these in various contexts.
2021-07-25 20:47:40 +01:00
// 𝔽(floor(ℝ(t / msPerSecond)) modulo SecondsPerMinute)
LibJS: Move Hours/Minutes/Seconds/ms constants out of the Date class They can remain in this header, but will be used outside the Date context in Temporal.
2022-05-06 19:10:34 +02:00
return static_cast<u8>(modulo(floor(t / ms_per_second), seconds_per_minute));
LibJS: Implement a bunch of time value related Date AOs We don't have these yet as our Date implementation doesn't use the time value algorithms and AOs from the spec, but Temporal will need these in various contexts.
2021-07-25 20:47:40 +01:00
}
// msFromTime(t), https://tc39.es/ecma262/#eqn-msFromTime
u16 ms_from_time(double t)
{
LibJS: Protect [TimeValue]FromTime from non-finite times Includes HourFromTime, MinFromTime, SecFromTime, msFromTime.
2022-01-16 01:15:46 -05:00
if (!Value(t).is_finite_number())
return 0;
LibJS: Fix type confusion in msFromTime This is an editorial change in the ECMA-262 spec. See: https://github.com/tc39/ecma262/commit/8e572b6
2022-05-03 21:23:57 +02:00
// 𝔽(ℝ(t) modulo ℝ(msPerSecond))
LibJS: Move Hours/Minutes/Seconds/ms constants out of the Date class They can remain in this header, but will be used outside the Date context in Temporal.
2022-05-06 19:10:34 +02:00
return static_cast<u16>(modulo(t, ms_per_second));
LibJS: Implement a bunch of time value related Date AOs We don't have these yet as our Date implementation doesn't use the time value algorithms and AOs from the spec, but Temporal will need these in various contexts.
2021-07-25 20:47:40 +01:00
}
LibJS: Implement Date's Week Day AO
2021-12-06 12:59:52 -05:00
// 21.4.1.6 Week Day, https://tc39.es/ecma262/#sec-week-day
u8 week_day(double t)
{
LibJS: Protect [TimeValue]FromTime from non-finite times Includes HourFromTime, MinFromTime, SecFromTime, msFromTime.
2022-01-16 01:15:46 -05:00
if (!Value(t).is_finite_number())
return 0;
LibJS: Implement Date's Week Day AO
2021-12-06 12:59:52 -05:00
// 𝔽(ℝ(Day(t) + 4𝔽) modulo 7)
LibJS: Support modulo(x, y) with different types It's a bit annoying having to add '.0' to y given that it's an integral number in most cases. This turns the single template parameter T into T and U to permit that.
2021-12-21 21:22:38 +01:00
return static_cast<u8>(modulo(day(t) + 4, 7));
LibJS: Implement Date's Week Day AO
2021-12-06 12:59:52 -05:00
}
LibJS: Partially implement the LocalTZA AO Intl.DateTimeFormat will invoke this AO with isUTC=true, so this only implements that branch in LocalTZA.
2022-01-11 23:27:05 -05:00
// 21.4.1.7 LocalTZA ( t, isUTC ), https://tc39.es/ecma262/#sec-local-time-zone-adjustment
LibJS: Do not negate offset in LocalTZA for isUTC=false In commmit 7d2834344a7635ec45aba28a0351feca8e5f1c17, I think I combined the definitions of the LocalTZA and UTC AOs in my head, and thought the offset should be negated within LocalTZA. Instead, the offset should be left untouched, and the UTC AO is responsible for doing the subtraction.
2022-01-14 17:33:54 -05:00
double local_tza(double time, [[maybe_unused]] bool is_utc, Optional<StringView> time_zone_override)
LibJS: Partially implement the LocalTZA AO Intl.DateTimeFormat will invoke this AO with isUTC=true, so this only implements that branch in LocalTZA.
2022-01-11 23:27:05 -05:00
{
// The time_zone_override parameter is non-standard, but allows callers to override the system
// time zone with a specific value without setting environment variables.
auto time_zone = time_zone_override.value_or(TimeZone::current_time_zone());
// When isUTC is true, LocalTZA( tUTC, true ) should return the offset of the local time zone from
// UTC measured in milliseconds at time represented by time value tUTC. When the result is added to
// tUTC, it should yield the corresponding Number tlocal.
// When isUTC is false, LocalTZA( tlocal, false ) should return the offset of the local time zone from
// UTC measured in milliseconds at local time represented by Number tlocal. When the result is subtracted
// from tlocal, it should yield the corresponding time value tUTC.
LibJS: Protect LocalTZA against non-finite times It is undefined behavior to cast from a double to an integer if the value does not fit in the limits of the integer.
2022-01-15 10:18:58 -05:00
auto time_since_epoch = Value(time).is_finite_number() ? AK::Time::from_milliseconds(time) : AK::Time::max();
auto maybe_offset = TimeZone::get_time_zone_offset(time_zone, time_since_epoch);
LibJS+LibTimeZone+LibUnicode: Indicate whether a time zone is in DST Return whether the time zone is in DST during the provided time from TimeZone::get_time_zone_offset,
2022-01-19 14:18:02 -05:00
return maybe_offset.has_value() ? static_cast<double>(maybe_offset->seconds) * 1000 : 0;
LibJS: Partially implement the LocalTZA AO Intl.DateTimeFormat will invoke this AO with isUTC=true, so this only implements that branch in LocalTZA.
2022-01-11 23:27:05 -05:00
}
LibJS: Implement the LocalTime, UTC, and TimeWithinDay AOs
2022-01-14 13:10:07 -05:00
// 21.4.1.8 LocalTime ( t ), https://tc39.es/ecma262/#sec-localtime
double local_time(double time)
{
// 1. Return t + LocalTZA(t, true).
return time + local_tza(time, true);
}
// 21.4.1.9 UTC ( t ), https://tc39.es/ecma262/#sec-utc-t
double utc_time(double time)
{
// 1. Return t - LocalTZA(t, false).
return time - local_tza(time, false);
}
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 21.4.1.11 MakeTime ( hour, min, sec, ms ), https://tc39.es/ecma262/#sec-maketime
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
double make_time(double hour, double min, double sec, double ms)
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
{
// 1. If hour is not finite or min is not finite or sec is not finite or ms is not finite, return NaN.
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
if (!isfinite(hour) || !isfinite(min) || !isfinite(sec) || !isfinite(ms))
return NAN;
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 2. Let h be 𝔽(! ToIntegerOrInfinity(hour)).
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
auto h = to_integer_or_infinity(hour);
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 3. Let m be 𝔽(! ToIntegerOrInfinity(min)).
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
auto m = to_integer_or_infinity(min);
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 4. Let s be 𝔽(! ToIntegerOrInfinity(sec)).
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
auto s = to_integer_or_infinity(sec);
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 5. Let milli be 𝔽(! ToIntegerOrInfinity(ms)).
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
auto milli = to_integer_or_infinity(ms);
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 6. Let t be ((h * msPerHour + m * msPerMinute) + s * msPerSecond) + milli, performing the arithmetic according to IEEE 754-2019 rules (that is, as if using the ECMAScript operators * and +).
// NOTE: C++ arithmetic abides by IEEE 754 rules
LibJS: Move Hours/Minutes/Seconds/ms constants out of the Date class They can remain in this header, but will be used outside the Date context in Temporal.
2022-05-06 19:10:34 +02:00
auto t = ((h * ms_per_hour + m * ms_per_minute) + s * ms_per_second) + milli;
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 7. Return t.
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
return t;
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
}
LibJS: Implement a bunch of time value related Date AOs We don't have these yet as our Date implementation doesn't use the time value algorithms and AOs from the spec, but Temporal will need these in various contexts.
2021-07-25 20:47:40 +01:00
// Day(t), https://tc39.es/ecma262/#eqn-Day
double day(double time_value)
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
{
LibJS: Move Hours/Minutes/Seconds/ms constants out of the Date class They can remain in this header, but will be used outside the Date context in Temporal.
2022-05-06 19:10:34 +02:00
return floor(time_value / ms_per_day);
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
}
LibJS: Implement the LocalTime, UTC, and TimeWithinDay AOs
2022-01-14 13:10:07 -05:00
// TimeWithinDay(t), https://tc39.es/ecma262/#eqn-TimeWithinDay
double time_within_day(double time)
{
// 𝔽(ℝ(t) modulo ℝ(msPerDay))
LibJS: Move Hours/Minutes/Seconds/ms constants out of the Date class They can remain in this header, but will be used outside the Date context in Temporal.
2022-05-06 19:10:34 +02:00
return modulo(time, ms_per_day);
LibJS: Implement the LocalTime, UTC, and TimeWithinDay AOs
2022-01-14 13:10:07 -05:00
}
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 21.4.1.12 MakeDay ( year, month, date ), https://tc39.es/ecma262/#sec-makeday
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
double make_day(double year, double month, double date)
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
{
// 1. If year is not finite or month is not finite or date is not finite, return NaN.
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
if (!isfinite(year) || !isfinite(month) || !isfinite(date))
return NAN;
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 2. Let y be 𝔽(! ToIntegerOrInfinity(year)).
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
auto y = to_integer_or_infinity(year);
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 3. Let m be 𝔽(! ToIntegerOrInfinity(month)).
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
auto m = to_integer_or_infinity(month);
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 4. Let dt be 𝔽(! ToIntegerOrInfinity(date)).
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
auto dt = to_integer_or_infinity(date);
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 5. Let ym be y + 𝔽(floor(ℝ(m) / 12)).
LibJS: Use AK::Time to implement the MakeDay AO We currently use Core::DateTime create, which internally uses mktime(). This has the issues pointed out by the (now removed) FIXME, but also has an issue on macOS where years before 1900 are not supported.
2022-01-05 12:26:15 -05:00
auto ym = y + floor(m / 12);
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 6. If ym is not finite, return NaN.
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
if (!isfinite(ym))
return NAN;
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 7. Let mn be 𝔽(ℝ(m) modulo 12).
LibJS: Use AK::Time to implement the MakeDay AO We currently use Core::DateTime create, which internally uses mktime(). This has the issues pointed out by the (now removed) FIXME, but also has an issue on macOS where years before 1900 are not supported.
2022-01-05 12:26:15 -05:00
auto mn = modulo(m, 12);
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 8. Find a finite time value t such that YearFromTime(t) is ym and MonthFromTime(t) is mn and DateFromTime(t) is 1𝔽; but if this is not possible (because some argument is out of range), return NaN.
LibJS: Use AK::Time to implement the MakeDay AO We currently use Core::DateTime create, which internally uses mktime(). This has the issues pointed out by the (now removed) FIXME, but also has an issue on macOS where years before 1900 are not supported.
2022-01-05 12:26:15 -05:00
if (!AK::is_within_range<int>(ym) || !AK::is_within_range<int>(mn + 1))
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
return NAN;
LibJS: Implement MakeDay without using AK::years_to_days_since_epoch Implementing years_to_days_since_epoch without a loop will be tricky. The TimeFromYear AO gives a good enough approximation for MakeDay until we figure that out.
2022-01-15 08:37:17 -05:00
// FIXME: We are avoiding AK::years_to_days_since_epoch here because it is implemented by looping over
// the range [1970, ym), which will spin for any time value with an extremely large year.
LibJS: Move Hours/Minutes/Seconds/ms constants out of the Date class They can remain in this header, but will be used outside the Date context in Temporal.
2022-05-06 19:10:34 +02:00
auto t = time_from_year(ym) + (day_of_year(static_cast<int>(ym), static_cast<int>(mn) + 1, 1) * ms_per_day);
LibJS: Use AK::Time to implement the MakeDay AO We currently use Core::DateTime create, which internally uses mktime(). This has the issues pointed out by the (now removed) FIXME, but also has an issue on macOS where years before 1900 are not supported.
2022-01-05 12:26:15 -05:00
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 9. Return Day(t) + dt - 1𝔽.
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
return day(static_cast<double>(t)) + dt - 1;
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
}
// 21.4.1.13 MakeDate ( day, time ), https://tc39.es/ecma262/#sec-makedate
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
double make_date(double day, double time)
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
{
// 1. If day is not finite or time is not finite, return NaN.
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
if (!isfinite(day) || !isfinite(time))
return NAN;
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 2. Let tv be day × msPerDay + time.
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
auto tv = day * ms_per_day + time;
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 3. If tv is not finite, return NaN.
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
if (!isfinite(tv))
return NAN;
LibJS: Add the ToTemporalInstant Abstract Operation & its requirements This is Abstract Operation is required for the majority of InstantConstructor's and InstantPrototype's methods. The implementation is not entirely complete, (specifically 2 of the underlying required abstract operations, ParseTemporalTimeZoneString and ParseISODateTime are missing the required lexing, and as such are TODO()-ed) but the majority of it is done.
2021-07-11 21:04:11 +03:00
// 4. Return tv.
return tv;
}
LibJS: Implement Date's TimeClip AO
2021-12-04 18:55:59 -05:00
// 21.4.1.14 TimeClip ( time ), https://tc39.es/ecma262/#sec-timeclip
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
double time_clip(double time)
LibJS: Implement Date's TimeClip AO
2021-12-04 18:55:59 -05:00
{
// 1. If time is not finite, return NaN.
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
if (!isfinite(time))
return NAN;
LibJS: Implement Date's TimeClip AO
2021-12-04 18:55:59 -05:00
// 2. If abs(ℝ(time)) > 8.64 × 10^15, return NaN.
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
if (fabs(time) > 8.64E15)
return NAN;
LibJS: Implement Date's TimeClip AO
2021-12-04 18:55:59 -05:00
// 3. Return 𝔽(! ToIntegerOrInfinity(time)).
LibJS: Convert remaining Date AOs using JS::Value as in/output to double There was an awful lot of JS::Value <-> double conversion going on, even through these AOs only work with number values anyway. They don't need a global object either as they won't allocate or throw, that was simply to pass it to infallible calls of ToIntegerOrInfinity.
2022-05-06 20:45:25 +02:00
return to_integer_or_infinity(time);
LibJS: Implement Date's TimeClip AO
2021-12-04 18:55:59 -05:00
}
LibJS: Start implementing Date :^) This adds: - A global Date object (with `length` property and `now` function) - The Date constructor (no arguments yet) - The Date prototype (with `get*` functions)
2020-03-30 00:21:56 +01:00
}
Reference in a new issue Copy permalink