1bd7f62d13PR-URL: https://github.com/nodejs/node/pull/60523 Reviewed-By: Michaël Zasso <targos@protonmail.com> Reviewed-By: Steven R Loomis <srl295@gmail.com>
378 lines
13 KiB
C++
378 lines
13 KiB
C++
// © 2018 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
|
|
#include <utility>
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_FORMATTING
|
|
|
|
#include <stdlib.h>
|
|
#include "unicode/ucal.h"
|
|
#include "unicode/ures.h"
|
|
#include "unicode/ustring.h"
|
|
#include "unicode/timezone.h"
|
|
#include "cmemory.h"
|
|
#include "cstring.h"
|
|
#include "erarules.h"
|
|
#include "gregoimp.h"
|
|
#include "uassert.h"
|
|
#include "uvectr32.h"
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
static const int32_t MAX_ENCODED_START_YEAR = 32767;
|
|
static const int32_t MIN_ENCODED_START_YEAR = -32768;
|
|
static const int32_t MIN_ENCODED_START = -2147483391; // encodeDate(MIN_ENCODED_START_YEAR, 1, 1, ...);
|
|
|
|
static const int32_t YEAR_MASK = 0xFFFF0000;
|
|
static const int32_t MONTH_MASK = 0x0000FF00;
|
|
static const int32_t DAY_MASK = 0x000000FF;
|
|
|
|
static const int32_t MAX_INT32 = 0x7FFFFFFF;
|
|
static const int32_t MIN_INT32 = 0xFFFFFFFF;
|
|
|
|
static const char16_t VAL_FALSE[] = {0x66, 0x61, 0x6c, 0x73, 0x65}; // "false"
|
|
static const char16_t VAL_FALSE_LEN = 5;
|
|
|
|
static UBool isSet(int startDate) {
|
|
return startDate != 0;
|
|
}
|
|
|
|
static UBool isValidRuleStartDate(int32_t year, int32_t month, int32_t day) {
|
|
return year >= MIN_ENCODED_START_YEAR && year <= MAX_ENCODED_START_YEAR
|
|
&& month >= 1 && month <= 12 && day >=1 && day <= 31;
|
|
}
|
|
|
|
/**
|
|
* Encode year/month/date to a single integer.
|
|
* year is high 16 bits (-32768 to 32767), month is
|
|
* next 8 bits and day of month is last 8 bits.
|
|
*
|
|
* @param year year
|
|
* @param month month (1-base)
|
|
* @param day day of month
|
|
* @return an encoded date.
|
|
*/
|
|
static int32_t encodeDate(int32_t year, int32_t month, int32_t day) {
|
|
return static_cast<int32_t>(static_cast<uint32_t>(year) << 16) | month << 8 | day;
|
|
}
|
|
|
|
static void decodeDate(int32_t encodedDate, int32_t (&fields)[3]) {
|
|
if (encodedDate == MIN_ENCODED_START) {
|
|
fields[0] = MIN_INT32;
|
|
fields[1] = 1;
|
|
fields[2] = 1;
|
|
} else {
|
|
fields[0] = (encodedDate & YEAR_MASK) >> 16;
|
|
fields[1] = (encodedDate & MONTH_MASK) >> 8;
|
|
fields[2] = encodedDate & DAY_MASK;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Compare an encoded date with another date specified by year/month/day.
|
|
* @param encoded An encoded date
|
|
* @param year Year of another date
|
|
* @param month Month of another date
|
|
* @param day Day of another date
|
|
* @return -1 when encoded date is earlier, 0 when two dates are same,
|
|
* and 1 when encoded date is later.
|
|
*/
|
|
static int32_t compareEncodedDateWithYMD(int encoded, int year, int month, int day) {
|
|
if (year < MIN_ENCODED_START_YEAR) {
|
|
if (encoded == MIN_ENCODED_START) {
|
|
if (year > MIN_INT32 || month > 1 || day > 1) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
} else {
|
|
return 1;
|
|
}
|
|
} else if (year > MAX_ENCODED_START_YEAR) {
|
|
return -1;
|
|
} else {
|
|
int tmp = encodeDate(year, month, day);
|
|
if (encoded < tmp) {
|
|
return -1;
|
|
} else if (encoded == tmp) {
|
|
return 0;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
EraRules::EraRules(LocalMemory<int32_t>& startDatesIn, int32_t startDatesLengthIn, int32_t minEraIn, int32_t numErasIn)
|
|
: startDatesLength(startDatesLengthIn), minEra(minEraIn), numEras(numErasIn) {
|
|
startDates = std::move(startDatesIn);
|
|
initCurrentEra();
|
|
}
|
|
|
|
EraRules::~EraRules() {
|
|
}
|
|
|
|
EraRules* EraRules::createInstance(const char *calType, UBool includeTentativeEra, UErrorCode& status) {
|
|
if(U_FAILURE(status)) {
|
|
return nullptr;
|
|
}
|
|
LocalUResourceBundlePointer rb(ures_openDirect(nullptr, "supplementalData", &status));
|
|
ures_getByKey(rb.getAlias(), "calendarData", rb.getAlias(), &status);
|
|
ures_getByKey(rb.getAlias(), calType, rb.getAlias(), &status);
|
|
ures_getByKey(rb.getAlias(), "eras", rb.getAlias(), &status);
|
|
|
|
if (U_FAILURE(status)) {
|
|
return nullptr;
|
|
}
|
|
|
|
int32_t numEras = ures_getSize(rb.getAlias());
|
|
int32_t firstTentativeIdx = MAX_INT32;
|
|
|
|
UVector32 eraStartDates(numEras, status);
|
|
if (U_FAILURE(status)) {
|
|
return nullptr;
|
|
}
|
|
|
|
while (ures_hasNext(rb.getAlias())) {
|
|
LocalUResourceBundlePointer eraRuleRes(ures_getNextResource(rb.getAlias(), nullptr, &status));
|
|
if (U_FAILURE(status)) {
|
|
return nullptr;
|
|
}
|
|
const char *eraIdxStr = ures_getKey(eraRuleRes.getAlias());
|
|
char *endp;
|
|
int32_t eraIdx = static_cast<int32_t>(uprv_strtol(eraIdxStr, &endp, 10));
|
|
if (static_cast<size_t>(endp - eraIdxStr) != uprv_strlen(eraIdxStr)) {
|
|
status = U_INVALID_FORMAT_ERROR;
|
|
return nullptr;
|
|
}
|
|
if (eraIdx < 0) {
|
|
status = U_INVALID_FORMAT_ERROR;
|
|
return nullptr;
|
|
}
|
|
if (eraIdx + 1 > eraStartDates.size()) {
|
|
eraStartDates.ensureCapacity(eraIdx + 1, status); // needed only to minimize expansions
|
|
// Fill in 0 for all added slots (else they are undefined)
|
|
while (eraStartDates.size() < eraIdx + 1) {
|
|
eraStartDates.addElement(0, status);
|
|
}
|
|
if (U_FAILURE(status)) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
// Now set the startDate that we just read
|
|
if (isSet(eraStartDates.elementAti(eraIdx))) {
|
|
// start date of the index was already set
|
|
status = U_INVALID_FORMAT_ERROR;
|
|
return nullptr;
|
|
}
|
|
|
|
UBool hasName = true;
|
|
UBool hasEnd = true;
|
|
int32_t len;
|
|
while (ures_hasNext(eraRuleRes.getAlias())) {
|
|
LocalUResourceBundlePointer res(ures_getNextResource(eraRuleRes.getAlias(), nullptr, &status));
|
|
if (U_FAILURE(status)) {
|
|
return nullptr;
|
|
}
|
|
const char *key = ures_getKey(res.getAlias());
|
|
if (uprv_strcmp(key, "start") == 0) {
|
|
const int32_t *fields = ures_getIntVector(res.getAlias(), &len, &status);
|
|
if (U_FAILURE(status)) {
|
|
return nullptr;
|
|
}
|
|
if (len != 3 || !isValidRuleStartDate(fields[0], fields[1], fields[2])) {
|
|
status = U_INVALID_FORMAT_ERROR;
|
|
return nullptr;
|
|
}
|
|
eraStartDates.setElementAt(encodeDate(fields[0], fields[1], fields[2]), eraIdx);
|
|
} else if (uprv_strcmp(key, "named") == 0) {
|
|
const char16_t *val = ures_getString(res.getAlias(), &len, &status);
|
|
if (u_strncmp(val, VAL_FALSE, VAL_FALSE_LEN) == 0) {
|
|
hasName = false;
|
|
}
|
|
} else if (uprv_strcmp(key, "end") == 0) {
|
|
hasEnd = true;
|
|
}
|
|
}
|
|
|
|
if (isSet(eraStartDates.elementAti(eraIdx))) {
|
|
if (hasEnd) {
|
|
// This implementation assumes either start or end is available, not both.
|
|
// For now, just ignore the end rule.
|
|
}
|
|
} else {
|
|
if (hasEnd) {
|
|
// The islamic calendars now have an end-only rule for the
|
|
// second (and final) entry; basically they are in reverse order.
|
|
eraStartDates.setElementAt(MIN_ENCODED_START, eraIdx);
|
|
} else {
|
|
status = U_INVALID_FORMAT_ERROR;
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
if (hasName) {
|
|
if (eraIdx >= firstTentativeIdx) {
|
|
status = U_INVALID_FORMAT_ERROR;
|
|
return nullptr;
|
|
}
|
|
} else {
|
|
if (eraIdx < firstTentativeIdx) {
|
|
firstTentativeIdx = eraIdx;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove from eraStartDates any tentative eras if they should not be included
|
|
// (these would be the last entries). Also reduce numEras appropriately.
|
|
if (!includeTentativeEra) {
|
|
while (firstTentativeIdx < eraStartDates.size()) {
|
|
int32_t lastEraIdx = eraStartDates.size() - 1;
|
|
if (isSet(eraStartDates.elementAti(lastEraIdx))) { // If there are multiple tentativeEras, some may be unset
|
|
numEras--;
|
|
}
|
|
eraStartDates.removeElementAt(lastEraIdx);
|
|
}
|
|
// Remove any remaining trailing unSet entries
|
|
// (can only have these if tentativeEras have been removed)
|
|
while (eraStartDates.size() > 0 && !isSet(eraStartDates.elementAti(eraStartDates.size() - 1))) {
|
|
eraStartDates.removeElementAt(eraStartDates.size() - 1);
|
|
}
|
|
}
|
|
// Remove from eraStartDates any initial 0 entries, keeping the original index (eraCode)
|
|
// of the first non-zero entry as minEra; then we can add that back to the offset in the
|
|
// compressed array to get the correct eraCode.
|
|
int32_t minEra = 0;
|
|
while (eraStartDates.size() > 0 && !isSet(eraStartDates.elementAti(0))) {
|
|
eraStartDates.removeElementAt(0);
|
|
minEra++;
|
|
}
|
|
// Convert eraStartDates to int32_t array startDates and pass to EraRules constructor,
|
|
// along with startDatesLength, minEra and numEras (which may be different from startDatesLength)
|
|
LocalMemory<int32_t> startDates(static_cast<int32_t *>(uprv_malloc(eraStartDates.size() * sizeof(int32_t))));
|
|
if (startDates.isNull()) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
return nullptr;
|
|
}
|
|
for (int32_t eraIdx = 0; eraIdx < eraStartDates.size(); eraIdx++) {
|
|
startDates[eraIdx] = eraStartDates.elementAti(eraIdx);
|
|
}
|
|
EraRules *result = new EraRules(startDates, eraStartDates.size(), minEra, numEras);
|
|
if (result == nullptr) {
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void EraRules::getStartDate(int32_t eraCode, int32_t (&fields)[3], UErrorCode& status) const {
|
|
if(U_FAILURE(status)) {
|
|
return;
|
|
}
|
|
int32_t startDate = 0;
|
|
if (eraCode >= minEra) {
|
|
int32_t startIdx = eraCode - minEra;
|
|
if (startIdx < startDatesLength) {
|
|
startDate = startDates[startIdx];
|
|
}
|
|
}
|
|
if (isSet(startDate)) {
|
|
decodeDate(startDate, fields);
|
|
return;
|
|
}
|
|
// We did not find the requested eraCode in our data
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return;
|
|
}
|
|
|
|
int32_t EraRules::getStartYear(int32_t eraCode, UErrorCode& status) const {
|
|
int year = MAX_INT32; // bogus value
|
|
if(U_FAILURE(status)) {
|
|
return year;
|
|
}
|
|
int32_t startDate = 0;
|
|
if (eraCode >= minEra) {
|
|
int32_t startIdx = eraCode - minEra;
|
|
if (startIdx < startDatesLength) {
|
|
startDate = startDates[startIdx];
|
|
}
|
|
}
|
|
if (isSet(startDate)) {
|
|
int fields[3];
|
|
decodeDate(startDate, fields);
|
|
year = fields[0];
|
|
return year;
|
|
}
|
|
// We did not find the requested eraCode in our data
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return year;
|
|
}
|
|
|
|
int32_t EraRules::getEraCode(int32_t year, int32_t month, int32_t day, UErrorCode& status) const {
|
|
if(U_FAILURE(status)) {
|
|
return -1;
|
|
}
|
|
|
|
if (month < 1 || month > 12 || day < 1 || day > 31) {
|
|
status = U_ILLEGAL_ARGUMENT_ERROR;
|
|
return -1;
|
|
}
|
|
if (numEras > 1 && startDates[startDatesLength-1] == MIN_ENCODED_START) {
|
|
// Multiple eras in reverse order, linear search from beginning.
|
|
// Currently only for islamic.
|
|
for (int startIdx = 0; startIdx < startDatesLength; startIdx++) {
|
|
if (!isSet(startDates[startIdx])) {
|
|
continue;
|
|
}
|
|
if (compareEncodedDateWithYMD(startDates[startIdx], year, month, day) <= 0) {
|
|
return minEra + startIdx;
|
|
}
|
|
}
|
|
}
|
|
// Linear search from the end, which should hit the most likely eras first.
|
|
// Also this is the most efficient for any era if we have < 8 or so eras, so only less
|
|
// efficient for early eras in Japanese calendar (while we still have them). Formerly
|
|
// this used binary search which would only be better for those early Japanese eras,
|
|
// but now that is much more difficult since there may be holes in the sorted list.
|
|
// Note with this change, this no longer uses or depends on currentEra.
|
|
for (int startIdx = startDatesLength; startIdx > 0;) {
|
|
if (!isSet(startDates[--startIdx])) {
|
|
continue;
|
|
}
|
|
if (compareEncodedDateWithYMD(startDates[startIdx], year, month, day) <= 0) {
|
|
return minEra + startIdx;
|
|
}
|
|
}
|
|
return minEra;
|
|
}
|
|
|
|
void EraRules::initCurrentEra() {
|
|
// Compute local wall time in millis using ICU's default time zone.
|
|
UErrorCode ec = U_ZERO_ERROR;
|
|
UDate localMillis = ucal_getNow();
|
|
|
|
int32_t rawOffset, dstOffset;
|
|
TimeZone* zone = TimeZone::createDefault();
|
|
// If we failed to create the default time zone, we are in a bad state and don't
|
|
// really have many options. Carry on using UTC millis as a fallback.
|
|
if (zone != nullptr) {
|
|
zone->getOffset(localMillis, false, rawOffset, dstOffset, ec);
|
|
delete zone;
|
|
localMillis += (rawOffset + dstOffset);
|
|
}
|
|
|
|
int32_t year, mid;
|
|
int8_t month0, dom;
|
|
Grego::timeToFields(localMillis, year, month0, dom, mid, ec);
|
|
currentEra = minEra;
|
|
if (U_FAILURE(ec)) { return; }
|
|
// Now that getEraCode no longer depends on currentEra, we can just do this:
|
|
currentEra = getEraCode(year, month0 + 1 /* changes to 1-base */, dom, ec);
|
|
if (U_FAILURE(ec)) {
|
|
currentEra = minEra;
|
|
}
|
|
}
|
|
|
|
U_NAMESPACE_END
|
|
#endif /* #if !UCONFIG_NO_FORMATTING */
|
|
|
|
|