From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- js/src/builtin/temporal/PlainDate.h | 292 ++++++++++++++++++++++++++++++++++++ 1 file changed, 292 insertions(+) create mode 100644 js/src/builtin/temporal/PlainDate.h (limited to 'js/src/builtin/temporal/PlainDate.h') diff --git a/js/src/builtin/temporal/PlainDate.h b/js/src/builtin/temporal/PlainDate.h new file mode 100644 index 0000000000..75a3a3f2a1 --- /dev/null +++ b/js/src/builtin/temporal/PlainDate.h @@ -0,0 +1,292 @@ +/* -*- 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/. */ + +#ifndef builtin_temporal_PlainDate_h +#define builtin_temporal_PlainDate_h + +#include "mozilla/Assertions.h" + +#include +#include + +#include "builtin/temporal/Calendar.h" +#include "builtin/temporal/PlainDateTime.h" +#include "builtin/temporal/TemporalTypes.h" +#include "builtin/temporal/Wrapped.h" +#include "js/RootingAPI.h" +#include "js/TypeDecls.h" +#include "js/Value.h" +#include "vm/NativeObject.h" + +class JS_PUBLIC_API JSTracer; + +namespace js { +struct ClassSpec; +class PlainObject; +} // namespace js + +namespace js::temporal { + +class PlainDateObject : public NativeObject { + public: + static const JSClass class_; + static const JSClass& protoClass_; + + // TODO: Consider compacting fields to reduce object size. + // + // ceil(log2(271821)) + ceil(log2(12)) + ceil(log2(31)) = 28 bits are + // needed to store a date value in a single int32. + + static constexpr uint32_t ISO_YEAR_SLOT = 0; + static constexpr uint32_t ISO_MONTH_SLOT = 1; + static constexpr uint32_t ISO_DAY_SLOT = 2; + static constexpr uint32_t CALENDAR_SLOT = 3; + static constexpr uint32_t SLOT_COUNT = 4; + + int32_t isoYear() const { return getFixedSlot(ISO_YEAR_SLOT).toInt32(); } + + int32_t isoMonth() const { return getFixedSlot(ISO_MONTH_SLOT).toInt32(); } + + int32_t isoDay() const { return getFixedSlot(ISO_DAY_SLOT).toInt32(); } + + CalendarValue calendar() const { + return CalendarValue(getFixedSlot(CALENDAR_SLOT)); + } + + private: + static const ClassSpec classSpec_; +}; + +class PlainDateWithCalendar { + PlainDate date_; + CalendarValue calendar_; + + public: + PlainDateWithCalendar() = default; + + PlainDateWithCalendar(const PlainDate& date, const CalendarValue& calendar) + : date_(date), calendar_(calendar) { + MOZ_ASSERT(ISODateTimeWithinLimits(date)); + } + + const auto& date() const { return date_; } + const auto& calendar() const { return calendar_; } + + // Allow implicit conversion to a calendar-less PlainDate. + operator const PlainDate&() const { return date(); } + + void trace(JSTracer* trc) { calendar_.trace(trc); } + + const auto* calendarDoNotUse() const { return &calendar_; } +}; + +/** + * Extract the date fields from the PlainDate object. + */ +inline PlainDate ToPlainDate(const PlainDateObject* date) { + return {date->isoYear(), date->isoMonth(), date->isoDay()}; +} + +enum class TemporalOverflow; +enum class TemporalUnit; +class DurationObject; +class ZonedDateTimeObject; + +#ifdef DEBUG +/** + * IsValidISODate ( year, month, day ) + */ +bool IsValidISODate(const PlainDate& date); + +/** + * IsValidISODate ( year, month, day ) + */ +bool IsValidISODate(double year, double month, double day); +#endif + +/** + * IsValidISODate ( year, month, day ) + */ +bool ThrowIfInvalidISODate(JSContext* cx, const PlainDate& date); + +/** + * IsValidISODate ( year, month, day ) + */ +bool ThrowIfInvalidISODate(JSContext* cx, double year, double month, + double day); + +/** + * ToTemporalDate ( item [ , options ] ) + */ +bool ToTemporalDate(JSContext* cx, JS::Handle item, + PlainDate* result); + +/** + * ToTemporalDate ( item [ , options ] ) + */ +bool ToTemporalDate(JSContext* cx, JS::Handle item, + JS::MutableHandle result); + +/** + * CreateTemporalDate ( isoYear, isoMonth, isoDay, calendar [ , newTarget ] ) + */ +PlainDateObject* CreateTemporalDate(JSContext* cx, const PlainDate& date, + JS::Handle calendar); + +/** + * CreateTemporalDate ( isoYear, isoMonth, isoDay, calendar [ , newTarget ] ) + */ +bool CreateTemporalDate(JSContext* cx, const PlainDate& date, + JS::Handle calendar, + JS::MutableHandle result); + +/** + * RegulateISODate ( year, month, day, overflow ) + */ +bool RegulateISODate(JSContext* cx, const PlainDate& date, + TemporalOverflow overflow, PlainDate* result); + +struct RegulatedISODate final { + double year; + int32_t month; + int32_t day; +}; + +/** + * RegulateISODate ( year, month, day, overflow ) + */ +bool RegulateISODate(JSContext* cx, double year, double month, double day, + TemporalOverflow overflow, RegulatedISODate* result); + +/** + * AddISODate ( year, month, day, years, months, weeks, days, overflow ) + */ +bool AddISODate(JSContext* cx, const PlainDate& date, const Duration& duration, + TemporalOverflow overflow, PlainDate* result); + +/** + * AddDate ( calendarRec, plainDate, duration [ , options ] ) + */ +Wrapped AddDate(JSContext* cx, + JS::Handle calendar, + JS::Handle> date, + const Duration& duration, + JS::Handle options); + +/** + * AddDate ( calendarRec, plainDate, duration [ , options ] ) + */ +Wrapped AddDate(JSContext* cx, + JS::Handle calendar, + JS::Handle> date, + const Duration& duration); + +/** + * AddDate ( calendarRec, plainDate, duration [ , options ] ) + */ +Wrapped AddDate( + JSContext* cx, JS::Handle calendar, + JS::Handle> date, + JS::Handle> durationObj, + JS::Handle options); + +/** + * AddDate ( calendarRec, plainDate, duration [ , options ] ) + */ +Wrapped AddDate( + JSContext* cx, JS::Handle calendar, + JS::Handle> date, + JS::Handle> durationObj); + +/** + * AddDate ( calendarRec, plainDate, duration [ , options ] ) + */ +bool AddDate(JSContext* cx, JS::Handle calendar, + const PlainDate& date, const Duration& duration, + JS::Handle options, PlainDate* result); + +/** + * AddDate ( calendarRec, plainDate, duration [ , options ] ) + */ +bool AddDate(JSContext* cx, JS::Handle calendar, + JS::Handle> date, + const Duration& duration, PlainDate* result); + +/** + * DifferenceISODate ( y1, m1, d1, y2, m2, d2, largestUnit ) + */ +DateDuration DifferenceISODate(const PlainDate& start, const PlainDate& end, + TemporalUnit largestUnit); + +/** + * DifferenceDate ( calendarRec, one, two, options ) + */ +bool DifferenceDate(JSContext* cx, JS::Handle calendar, + JS::Handle> one, + JS::Handle> two, + JS::Handle options, Duration* result); + +/** + * DifferenceDate ( calendarRec, one, two, options ) + */ +bool DifferenceDate(JSContext* cx, JS::Handle calendar, + JS::Handle> one, + JS::Handle> two, + TemporalUnit largestUnit, Duration* result); + +/** + * CompareISODate ( y1, m1, d1, y2, m2, d2 ) + */ +int32_t CompareISODate(const PlainDate& one, const PlainDate& two); + +/** + * BalanceISODate ( year, month, day ) + */ +bool BalanceISODate(JSContext* cx, int32_t year, int32_t month, int64_t day, + PlainDate* result); + +/** + * BalanceISODate ( year, month, day ) + */ +PlainDate BalanceISODate(int32_t year, int32_t month, int32_t day); + +/** + * BalanceISODate ( year, month, day ) + */ +PlainDate BalanceISODateNew(int32_t year, int32_t month, int32_t day); + +/** + * Return true when accessing the calendar fields |fieldNames| can be optimized. + * Otherwise returns false. + */ +bool IsBuiltinAccess(JSContext* cx, JS::Handle date, + std::initializer_list fieldNames); + +} /* namespace js::temporal */ + +namespace js { + +template +class WrappedPtrOperations { + const auto& container() const { + return static_cast(this)->get(); + } + + public: + const auto& date() const { return container().date(); } + + JS::Handle calendar() const { + return JS::Handle::fromMarkedLocation( + container().calendarDoNotUse()); + } + + // Allow implicit conversion to a calendar-less PlainDate. + operator const temporal::PlainDate&() const { return date(); } +}; + +} // namespace js + +#endif /* builtin_temporal_PlainDate_h */ -- cgit v1.2.3