Source code

Revision control

Copy as Markdown

Other Tools

/* -*- 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/. */
#include "builtin/temporal/ToString.h"
#include "mozilla/Assertions.h"
#include <cstdlib>
#include <stddef.h>
#include <stdint.h>
#include <type_traits>
#include <utility>
#include "builtin/temporal/Calendar.h"
#include "builtin/temporal/Instant.h"
#include "builtin/temporal/PlainDate.h"
#include "builtin/temporal/PlainMonthDay.h"
#include "builtin/temporal/PlainYearMonth.h"
#include "builtin/temporal/Temporal.h"
#include "builtin/temporal/TemporalRoundingMode.h"
#include "builtin/temporal/TemporalTypes.h"
#include "builtin/temporal/TemporalUnit.h"
#include "builtin/temporal/TimeZone.h"
#include "builtin/temporal/ZonedDateTime.h"
#include "gc/Policy.h"
#include "js/RootingAPI.h"
#include "util/StringBuffer.h"
#include "vm/StringType.h"
using namespace js;
using namespace js::temporal;
enum class TemporalStringFormat {
None,
Date,
Time,
DateTime,
YearMonth,
MonthDay,
ZonedDateTime,
Instant,
};
class TemporalStringBuilder {
JSStringBuilder sb_;
TemporalStringFormat kind_ = TemporalStringFormat::None;
#ifdef DEBUG
bool reserved_ = false;
#endif
static constexpr size_t reserveAmount(TemporalStringFormat format) {
// Note: This doesn't reserve too much space, because the string builder
// already internally reserves space for 64 characters.
constexpr size_t datePart = 1 + 6 + 1 + 2 + 1 + 2; // 13
constexpr size_t timePart = 2 + 1 + 2 + 1 + 2 + 1 + 9; // 18
constexpr size_t dateTimePart = datePart + 1 + timePart; // including 'T'
constexpr size_t timeZoneOffsetPart = 1 + 2 + 1 + 2; // 6
switch (format) {
case TemporalStringFormat::Date:
case TemporalStringFormat::YearMonth:
case TemporalStringFormat::MonthDay:
return datePart;
case TemporalStringFormat::Time:
return timePart;
case TemporalStringFormat::DateTime:
return dateTimePart;
case TemporalStringFormat::ZonedDateTime:
return dateTimePart + timeZoneOffsetPart;
case TemporalStringFormat::Instant:
return dateTimePart + timeZoneOffsetPart;
case TemporalStringFormat::None:
break;
}
MOZ_CRASH("invalid reserve amount");
}
public:
TemporalStringBuilder(JSContext* cx, TemporalStringFormat kind)
: sb_(cx), kind_(kind) {
MOZ_ASSERT(kind != TemporalStringFormat::None);
}
bool reserve() {
MOZ_ASSERT(!reserved_);
if (!sb_.reserve(reserveAmount(kind_))) {
return false;
}
#ifdef DEBUG
reserved_ = true;
#endif
return true;
}
void append(char value) {
MOZ_ASSERT(reserved_);
sb_.infallibleAppend(value);
}
void appendTwoDigit(int32_t value) {
MOZ_ASSERT(0 <= value && value <= 99);
MOZ_ASSERT(reserved_);
sb_.infallibleAppend(char('0' + (value / 10)));
sb_.infallibleAppend(char('0' + (value % 10)));
}
void appendFourDigit(int32_t value) {
MOZ_ASSERT(0 <= value && value <= 9999);
MOZ_ASSERT(reserved_);
sb_.infallibleAppend(char('0' + (value / 1000)));
sb_.infallibleAppend(char('0' + (value % 1000) / 100));
sb_.infallibleAppend(char('0' + (value % 100) / 10));
sb_.infallibleAppend(char('0' + (value % 10)));
}
void appendSixDigit(int32_t value) {
MOZ_ASSERT(0 <= value && value <= 999999);
MOZ_ASSERT(reserved_);
sb_.infallibleAppend(char('0' + (value / 100000)));
sb_.infallibleAppend(char('0' + (value % 100000) / 10000));
sb_.infallibleAppend(char('0' + (value % 10000) / 1000));
sb_.infallibleAppend(char('0' + (value % 1000) / 100));
sb_.infallibleAppend(char('0' + (value % 100) / 10));
sb_.infallibleAppend(char('0' + (value % 10)));
}
void appendYear(int32_t year) {
if (0 <= year && year <= 9999) {
appendFourDigit(year);
} else {
append(year < 0 ? '-' : '+');
appendSixDigit(std::abs(year));
}
}
auto* finishString() { return sb_.finishString(); }
auto& builder() { return sb_; }
};
/**
* FormatFractionalSeconds ( subSecondNanoseconds, precision )
*/
static void FormatFractionalSeconds(TemporalStringBuilder& result,
int32_t subSecondNanoseconds,
Precision precision) {
MOZ_ASSERT(0 <= subSecondNanoseconds && subSecondNanoseconds < 1'000'000'000);
MOZ_ASSERT(precision != Precision::Minute());
// Steps 1-2.
if (precision == Precision::Auto()) {
// Step 1.a.
if (subSecondNanoseconds == 0) {
return;
}
// Step 3. (Reordered)
result.append('.');
// Steps 1.b-c.
uint32_t k = 100'000'000;
do {
result.append(char('0' + (subSecondNanoseconds / k)));
subSecondNanoseconds %= k;
k /= 10;
} while (subSecondNanoseconds);
} else {
// Step 2.a.
uint8_t p = precision.value();
if (p == 0) {
return;
}
// Step 3. (Reordered)
result.append('.');
// Steps 2.b-c.
uint32_t k = 100'000'000;
for (uint8_t i = 0; i < p; i++) {
result.append(char('0' + (subSecondNanoseconds / k)));
subSecondNanoseconds %= k;
k /= 10;
}
}
}
/**
* FormatTimeString ( hour, minute, second, subSecondNanoseconds, precision )
*/
static void FormatTimeString(TemporalStringBuilder& result,
const PlainTime& time, Precision precision) {
// Step 1.
result.appendTwoDigit(time.hour);
// Step 2.
result.append(':');
result.appendTwoDigit(time.minute);
// Steps 4-7.
if (precision != Precision::Minute()) {
result.append(':');
result.appendTwoDigit(time.second);
int32_t subSecondNanoseconds = time.millisecond * 1'000'000 +
time.microsecond * 1'000 + time.nanosecond;
FormatFractionalSeconds(result, subSecondNanoseconds, precision);
}
}
static void FormatDateString(TemporalStringBuilder& result,
const PlainDate& date) {
result.appendYear(date.year);
result.append('-');
result.appendTwoDigit(date.month);
result.append('-');
result.appendTwoDigit(date.day);
}
static void FormatDateTimeString(TemporalStringBuilder& result,
const PlainDateTime& dateTime,
Precision precision) {
FormatDateString(result, dateTime.date);
result.append('T');
FormatTimeString(result, dateTime.time, precision);
}
/**
* FormatOffsetTimeZoneIdentifier ( offsetMinutes [ , style ] )
*/
static void FormatOffsetTimeZoneIdentifier(TemporalStringBuilder& result,
int32_t offsetMinutes) {
MOZ_ASSERT(std::abs(offsetMinutes) < UnitsPerDay(TemporalUnit::Minute),
"time zone offset mustn't exceed 24-hours");
// Step 1.
char sign = offsetMinutes >= 0 ? '+' : '-';
// Step 2.
int32_t absoluteMinutes = std::abs(offsetMinutes);
// Step 3.
int32_t hours = absoluteMinutes / 60;
// Step 4.
int32_t minutes = absoluteMinutes % 60;
// Steps 5-6. (Inlined FormatTimeString)
result.append(sign);
result.appendTwoDigit(hours);
result.append(':');
result.appendTwoDigit(minutes);
}
// Returns |RoundNumberToIncrement(offsetNanoseconds, 60 × 10^9, "halfExpand")|
// divided by |60 × 10^9|.
static int32_t RoundNanosecondsToMinutes(int64_t offsetNanoseconds) {
MOZ_ASSERT(std::abs(offsetNanoseconds) < ToNanoseconds(TemporalUnit::Day));
constexpr int64_t increment = ToNanoseconds(TemporalUnit::Minute);
int64_t quotient = offsetNanoseconds / increment;
int64_t remainder = offsetNanoseconds % increment;
if (std::abs(remainder * 2) >= increment) {
quotient += (offsetNanoseconds > 0 ? 1 : -1);
}
return quotient;
}
/**
* FormatDateTimeUTCOffsetRounded ( offsetNanoseconds )
*/
static void FormatDateTimeUTCOffsetRounded(TemporalStringBuilder& result,
int64_t offsetNanoseconds) {
MOZ_ASSERT(std::abs(offsetNanoseconds) < ToNanoseconds(TemporalUnit::Day));
// Steps 1-3.
int32_t offsetMinutes = RoundNanosecondsToMinutes(offsetNanoseconds);
// Step 4.
FormatOffsetTimeZoneIdentifier(result, offsetMinutes);
}
/**
* FormatCalendarAnnotation ( id, showCalendar )
*/
static bool FormatCalendarAnnotation(TemporalStringBuilder& result,
JSLinearString* id,
CalendarOption showCalendar) {
switch (showCalendar) {
case CalendarOption::Never:
return true;
case CalendarOption::Auto: {
if (StringEqualsLiteral(id, "iso8601")) {
return true;
}
[[fallthrough]];
}
case CalendarOption::Always: {
auto& sb = result.builder();
return sb.append("[u-ca=") && sb.append(id) && sb.append(']');
}
case CalendarOption::Critical: {
auto& sb = result.builder();
return sb.append("[!u-ca=") && sb.append(id) && sb.append(']');
}
}
MOZ_CRASH("bad calendar option");
}
/**
* MaybeFormatCalendarAnnotation ( calendar, showCalendar )
*/
static bool MaybeFormatCalendarAnnotation(JSContext* cx,
TemporalStringBuilder& result,
Handle<CalendarValue> calendar,
CalendarOption showCalendar) {
// Step 1.
if (showCalendar == CalendarOption::Never) {
return true;
}
// Step 2.
JSString* calendarIdentifier = ToTemporalCalendarIdentifier(cx, calendar);
if (!calendarIdentifier) {
return false;
}
JSLinearString* linearCalendarId = calendarIdentifier->ensureLinear(cx);
if (!linearCalendarId) {
return false;
}
// Step 3.
return FormatCalendarAnnotation(result, linearCalendarId, showCalendar);
}
static bool FormatTimeZoneAnnotation(TemporalStringBuilder& result,
JSLinearString* id,
TimeZoneNameOption showTimeZone) {
switch (showTimeZone) {
case TimeZoneNameOption::Never:
return true;
case TimeZoneNameOption::Auto: {
auto& sb = result.builder();
return sb.append("[") && sb.append(id) && sb.append(']');
}
case TimeZoneNameOption::Critical: {
auto& sb = result.builder();
return sb.append("[!") && sb.append(id) && sb.append(']');
}
}
MOZ_CRASH("bad time zone option");
}
static bool MaybeFormatTimeZoneAnnotation(JSContext* cx,
TemporalStringBuilder& result,
Handle<TimeZoneValue> timeZone,
TimeZoneNameOption showTimeZone) {
if (showTimeZone == TimeZoneNameOption::Never) {
return true;
}
JSString* timeZoneIdentifier = ToTemporalTimeZoneIdentifier(cx, timeZone);
if (!timeZoneIdentifier) {
return false;
}
JSLinearString* linearTimeZoneId = timeZoneIdentifier->ensureLinear(cx);
if (!linearTimeZoneId) {
return false;
}
return FormatTimeZoneAnnotation(result, linearTimeZoneId, showTimeZone);
}
/**
* TemporalInstantToString ( instant, timeZone, precision )
*/
JSString* js::temporal::TemporalInstantToString(JSContext* cx,
Handle<InstantObject*> instant,
Handle<TimeZoneValue> timeZone,
Precision precision) {
TemporalStringBuilder result(cx, TemporalStringFormat::Instant);
if (!result.reserve()) {
return nullptr;
}
// Steps 1-2. (Not applicable in our implementation.)
// Steps 3-6.
int64_t offsetNanoseconds = 0;
if (timeZone) {
// Steps 3-4. (Not applicable)
// Steps 5-6.
if (!GetOffsetNanosecondsFor(cx, timeZone, instant, &offsetNanoseconds)) {
return nullptr;
}
MOZ_ASSERT(std::abs(offsetNanoseconds) < ToNanoseconds(TemporalUnit::Day));
}
// Step 7.
auto dateTime = GetPlainDateTimeFor(ToInstant(instant), offsetNanoseconds);
// Step 8. (Inlined TemporalDateTimeToString)
FormatDateTimeString(result, dateTime, precision);
// Steps 9-10.
Rooted<JSString*> timeZoneString(cx);
if (!timeZone) {
// Step 9.a.
result.append('Z');
} else {
// Step 10.a.
FormatDateTimeUTCOffsetRounded(result, offsetNanoseconds);
}
// Step 11.
return result.finishString();
}
/**
* TemporalDateToString ( temporalDate, showCalendar )
*/
JSString* js::temporal::TemporalDateToString(
JSContext* cx, Handle<PlainDateObject*> temporalDate,
CalendarOption showCalendar) {
auto date = ToPlainDate(temporalDate);
// Steps 1-2. (Not applicable in our implementation.)
TemporalStringBuilder result(cx, TemporalStringFormat::Date);
if (!result.reserve()) {
return nullptr;
}
// Steps 3-5.
FormatDateString(result, date);
// Step 6.
Rooted<CalendarValue> calendar(cx, temporalDate->calendar());
if (!MaybeFormatCalendarAnnotation(cx, result, calendar, showCalendar)) {
return nullptr;
}
// Step 7.
return result.finishString();
}
/**
* TemporalDateTimeToString ( isoYear, isoMonth, isoDay, hour, minute, second,
* millisecond, microsecond, nanosecond, calendar, precision, showCalendar )
*/
JSString* js::temporal::TemporalDateTimeToString(JSContext* cx,
const PlainDateTime& dateTime,
Handle<CalendarValue> calendar,
Precision precision,
CalendarOption showCalendar) {
TemporalStringBuilder result(cx, TemporalStringFormat::DateTime);
if (!result.reserve()) {
return nullptr;
}
// Step 1. (Not applicable in our implementation.)
// Steps 2-6.
FormatDateTimeString(result, dateTime, precision);
// Step 7.
if (!MaybeFormatCalendarAnnotation(cx, result, calendar, showCalendar)) {
return nullptr;
}
// Step 8.
return result.finishString();
}
/**
* TemporalTimeToString ( hour, minute, second, millisecond, microsecond,
* nanosecond, precision )
*/
JSString* js::temporal::TemporalTimeToString(JSContext* cx,
const PlainTime& time,
Precision precision) {
// Step 1. (Not applicable in our implementation.)
TemporalStringBuilder result(cx, TemporalStringFormat::Time);
if (!result.reserve()) {
return nullptr;
}
// Steps 2-3.
FormatTimeString(result, time, precision);
return result.finishString();
}
/**
* TemporalMonthDayToString ( monthDay, showCalendar )
*/
JSString* js::temporal::TemporalMonthDayToString(
JSContext* cx, Handle<PlainMonthDayObject*> monthDay,
CalendarOption showCalendar) {
// Steps 1-2. (Not applicable in our implementation.)
TemporalStringBuilder result(cx, TemporalStringFormat::MonthDay);
if (!result.reserve()) {
return nullptr;
}
// Step 6. (Reordered)
Rooted<CalendarValue> calendar(cx, monthDay->calendar());
JSString* str = ToTemporalCalendarIdentifier(cx, calendar);
if (!str) {
return nullptr;
}
Rooted<JSLinearString*> calendarIdentifier(cx, str->ensureLinear(cx));
if (!calendarIdentifier) {
return nullptr;
}
// Steps 3-5 and 7.
auto date = ToPlainDate(monthDay);
if (showCalendar == CalendarOption::Always ||
showCalendar == CalendarOption::Critical ||
!StringEqualsLiteral(calendarIdentifier, "iso8601")) {
// FIXME: spec issue - don't print "year" part when showCalendar is "never".
//
// ```js
// let cal = new Proxy({id: "cal"}, {has(t, pk) { return true; }});
// let pmd = new Temporal.PlainMonthDay(8, 1, cal);
// pmd.toString({calendarName: "never"})
// ```
FormatDateString(result, date);
} else {
result.appendTwoDigit(date.month);
result.append('-');
result.appendTwoDigit(date.day);
}
// Steps 8-9.
if (!FormatCalendarAnnotation(result, calendarIdentifier, showCalendar)) {
return nullptr;
}
// Step 10.
return result.finishString();
}
/**
* TemporalYearMonthToString ( yearMonth, showCalendar )
*/
JSString* js::temporal::TemporalYearMonthToString(
JSContext* cx, Handle<PlainYearMonthObject*> yearMonth,
CalendarOption showCalendar) {
// Steps 1-2. (Not applicable in our implementation.)
TemporalStringBuilder result(cx, TemporalStringFormat::YearMonth);
if (!result.reserve()) {
return nullptr;
}
// Step 6. (Reordered)
Rooted<CalendarValue> calendar(cx, yearMonth->calendar());
JSString* str = ToTemporalCalendarIdentifier(cx, calendar);
if (!str) {
return nullptr;
}
Rooted<JSLinearString*> calendarIdentifier(cx, str->ensureLinear(cx));
if (!calendarIdentifier) {
return nullptr;
}
// Steps 3-5 and 7.
auto date = ToPlainDate(yearMonth);
if (showCalendar == CalendarOption::Always ||
showCalendar == CalendarOption::Critical ||
!StringEqualsLiteral(calendarIdentifier, "iso8601")) {
// FIXME: spec issue - don't print "day" part when showCalendar is "never".
//
// ```js
// let cal = new Proxy({id: "cal"}, {has(t, pk) { return true; }});
// let pym = new Temporal.PlainYearMonth(2023, 8, cal);
// pym.toString({calendarName: "never"})
// ```
FormatDateString(result, date);
} else {
result.appendYear(date.year);
result.append('-');
result.appendTwoDigit(date.month);
}
// Steps 8-9.
if (!FormatCalendarAnnotation(result, calendarIdentifier, showCalendar)) {
return nullptr;
}
// Step 10.
return result.finishString();
}
/**
* TemporalZonedDateTimeToString ( zonedDateTime, precision, showCalendar,
* showTimeZone, showOffset [ , increment, unit, roundingMode ] )
*/
JSString* js::temporal::TemporalZonedDateTimeToString(
JSContext* cx, Handle<ZonedDateTime> zonedDateTime, Precision precision,
CalendarOption showCalendar, TimeZoneNameOption showTimeZone,
ShowOffsetOption showOffset, Increment increment, TemporalUnit unit,
TemporalRoundingMode roundingMode) {
TemporalStringBuilder result(cx, TemporalStringFormat::ZonedDateTime);
if (!result.reserve()) {
return nullptr;
}
// Steps 1-3. (Not applicable in our implementation.)
// Step 4.
Instant ns;
if (!RoundTemporalInstant(cx, zonedDateTime.instant(), increment, unit,
roundingMode, &ns)) {
return nullptr;
}
// Step 5.
auto timeZone = zonedDateTime.timeZone();
// Steps 6-8.
int64_t offsetNanoseconds;
if (!GetOffsetNanosecondsFor(cx, timeZone, ns, &offsetNanoseconds)) {
return nullptr;
}
MOZ_ASSERT(std::abs(offsetNanoseconds) < ToNanoseconds(TemporalUnit::Day));
// Step 9.
auto temporalDateTime = GetPlainDateTimeFor(ns, offsetNanoseconds);
// Step 10. (Inlined TemporalDateTimeToString)
FormatDateTimeString(result, temporalDateTime, precision);
// Steps 11-12.
if (showOffset != ShowOffsetOption::Never) {
FormatDateTimeUTCOffsetRounded(result, offsetNanoseconds);
}
// Steps 13-14.
if (!MaybeFormatTimeZoneAnnotation(cx, result, timeZone, showTimeZone)) {
return nullptr;
}
// Step 15.
if (!MaybeFormatCalendarAnnotation(cx, result, zonedDateTime.calendar(),
showCalendar)) {
return nullptr;
}
// Step 16.
return result.finishString();
}