// © 2016 and later: Unicode, Inc. and others.

// License & terms of use: http://www.unicode.org/copyright.html

/*

*******************************************************************************

* Copyright (C) 1997-2016, International Business Machines Corporation and    *

* others. All Rights Reserved.                                                *

*******************************************************************************

*

* File SMPDTFMT.CPP

*

* Modification History:

*

*   Date        Name        Description

*   02/19/97    aliu        Converted from java.

*   03/31/97    aliu        Modified extensively to work with 50 locales.

*   04/01/97    aliu        Added support for centuries.

*   07/09/97    helena      Made ParsePosition into a class.

*   07/21/98    stephen     Added initializeDefaultCentury.

*                             Removed getZoneIndex (added in DateFormatSymbols)

*                             Removed subParseLong

*                             Removed chk

*   02/22/99    stephen     Removed character literals for EBCDIC safety

*   10/14/99    aliu        Updated 2-digit year parsing so that only "00" thru

*                           "99" are recognized. {j28 4182066}

*   11/15/99    weiv        Added support for week of year/day of week format

********************************************************************************

*/

#define ZID_KEY_MAX 128

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "unicode/smpdtfmt.h"

#include "unicode/dtfmtsym.h"

#include "unicode/ures.h"

#include "unicode/msgfmt.h"

#include "unicode/calendar.h"

#include "unicode/gregocal.h"

#include "unicode/timezone.h"

#include "unicode/decimfmt.h"

#include "unicode/dcfmtsym.h"

#include "unicode/uchar.h"

#include "unicode/uniset.h"

#include "unicode/ustring.h"

#include "unicode/basictz.h"

#include "unicode/simpleformatter.h"

#include "unicode/simplenumberformatter.h"

#include "unicode/simpletz.h"

#include "unicode/rbtz.h"

#include "unicode/tzfmt.h"

#include "unicode/ucasemap.h"

#include "unicode/utf16.h"

#include "unicode/vtzone.h"

#include "unicode/udisplaycontext.h"

#include "unicode/brkiter.h"

#include "unicode/rbnf.h"

#include "unicode/dtptngen.h"

#include "uresimp.h"

#include "olsontz.h"

#include "patternprops.h"

#include "fphdlimp.h"

#include "hebrwcal.h"

#include "cstring.h"

#include "uassert.h"

#include "cmemory.h"

#include "umutex.h"

#include "mutex.h"

#include <float.h>

#include "smpdtfst.h"

#include "sharednumberformat.h"

#include "ucasemap_imp.h"

#include "ustr_imp.h"

#include "charstr.h"

#include "uvector.h"

#include "cstr.h"

#include "dayperiodrules.h"

#include "tznames_impl.h"   // ZONE_NAME_U16_MAX

#include "number_utypes.h"

#include "chnsecal.h"

#include "dangical.h"

#include "japancal.h"

#include <typeinfo>

#if defined( U_DEBUG_CALSVC ) || defined (U_DEBUG_CAL)

#include <stdio.h>

#endif

// *****************************************************************************

// class SimpleDateFormat

// *****************************************************************************

U_NAMESPACE_BEGIN

/**

 * Last-resort string to use for "GMT" when constructing time zone strings.

 */

// For time zones that have no names, use strings GMT+minutes and

// GMT-minutes. For instance, in France the time zone is GMT+60.

// Also accepted are GMT+H:MM or GMT-H:MM.

// Currently not being used

//static const char16_t gGmt[]      = {0x0047, 0x004D, 0x0054, 0x0000};         // "GMT"

//static const char16_t gGmtPlus[]  = {0x0047, 0x004D, 0x0054, 0x002B, 0x0000}; // "GMT+"

//static const char16_t gGmtMinus[] = {0x0047, 0x004D, 0x0054, 0x002D, 0x0000}; // "GMT-"

//static const char16_t gDefGmtPat[]       = {0x0047, 0x004D, 0x0054, 0x007B, 0x0030, 0x007D, 0x0000}; /* GMT{0} */

//static const char16_t gDefGmtNegHmsPat[] = {0x002D, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0x0000}; /* -HH:mm:ss */

//static const char16_t gDefGmtNegHmPat[]  = {0x002D, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x0000}; /* -HH:mm */

//static const char16_t gDefGmtPosHmsPat[] = {0x002B, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0x0000}; /* +HH:mm:ss */

//static const char16_t gDefGmtPosHmPat[]  = {0x002B, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x0000}; /* +HH:mm */

//static const char16_t gUt[]       = {0x0055, 0x0054, 0x0000};  // "UT"

//static const char16_t gUtc[]      = {0x0055, 0x0054, 0x0043, 0x0000};  // "UT"

typedef enum GmtPatSize {

    kGmtLen = 3,

    kGmtPatLen = 6,

    kNegHmsLen = 9,

    kNegHmLen = 6,

    kPosHmsLen = 9,

    kPosHmLen = 6,

    kUtLen = 2,

    kUtcLen = 3

} GmtPatSize;

// Stuff needed for numbering system overrides

typedef enum OvrStrType {

    kOvrStrDate = 0,

    kOvrStrTime = 1,

    kOvrStrBoth = 2

} OvrStrType;

static const UDateFormatField kDateFields[] = {

    UDAT_YEAR_FIELD,

    UDAT_MONTH_FIELD,

    UDAT_DATE_FIELD,

    UDAT_DAY_OF_YEAR_FIELD,

    UDAT_DAY_OF_WEEK_IN_MONTH_FIELD,

    UDAT_WEEK_OF_YEAR_FIELD,

    UDAT_WEEK_OF_MONTH_FIELD,

    UDAT_YEAR_WOY_FIELD,

    UDAT_EXTENDED_YEAR_FIELD,

    UDAT_JULIAN_DAY_FIELD,

    UDAT_STANDALONE_DAY_FIELD,

    UDAT_STANDALONE_MONTH_FIELD,

    UDAT_QUARTER_FIELD,

    UDAT_STANDALONE_QUARTER_FIELD,

    UDAT_YEAR_NAME_FIELD,

    UDAT_RELATED_YEAR_FIELD };

static const int8_t kDateFieldsCount = 16;

static const UDateFormatField kTimeFields[] = {

    UDAT_HOUR_OF_DAY1_FIELD,

    UDAT_HOUR_OF_DAY0_FIELD,

    UDAT_MINUTE_FIELD,

    UDAT_SECOND_FIELD,

    UDAT_FRACTIONAL_SECOND_FIELD,

    UDAT_HOUR1_FIELD,

    UDAT_HOUR0_FIELD,

    UDAT_MILLISECONDS_IN_DAY_FIELD,

    UDAT_TIMEZONE_RFC_FIELD,

    UDAT_TIMEZONE_LOCALIZED_GMT_OFFSET_FIELD };

static const int8_t kTimeFieldsCount = 10;

// This is a pattern-of-last-resort used when we can't load a usable pattern out

// of a resource.

static const char16_t gDefaultPattern[] =

{

    0x79, 0x4D, 0x4D, 0x64, 0x64, 0x20, 0x68, 0x68, 0x3A, 0x6D, 0x6D, 0x20, 0x61, 0

};  /* "yMMdd hh:mm a" */

// This prefix is designed to NEVER MATCH real text, in order to

// suppress the parsing of negative numbers.  Adjust as needed (if

// this becomes valid Unicode).

static const char16_t SUPPRESS_NEGATIVE_PREFIX[] = {0xAB00, 0};

/**

 * These are the tags we expect to see in normal resource bundle files associated

 * with a locale.

 */

static const char16_t QUOTE = 0x27; // Single quote

/*

 * The field range check bias for each UDateFormatField.

 * The bias is added to the minimum and maximum values

 * before they are compared to the parsed number.

 * For example, the calendar stores zero-based month numbers

 * but the parsed month numbers start at 1, so the bias is 1.

 *

 * A value of -1 means that the value is not checked.

 */

static const int32_t gFieldRangeBias[] = {

    -1,  // 'G' - UDAT_ERA_FIELD

    -1,  // 'y' - UDAT_YEAR_FIELD

     1,  // 'M' - UDAT_MONTH_FIELD

     0,  // 'd' - UDAT_DATE_FIELD

    -1,  // 'k' - UDAT_HOUR_OF_DAY1_FIELD

    -1,  // 'H' - UDAT_HOUR_OF_DAY0_FIELD

     0,  // 'm' - UDAT_MINUTE_FIELD

     0,  // 's' - UDAT_SECOND_FIELD

    -1,  // 'S' - UDAT_FRACTIONAL_SECOND_FIELD (0-999?)

    -1,  // 'E' - UDAT_DAY_OF_WEEK_FIELD (1-7?)

    -1,  // 'D' - UDAT_DAY_OF_YEAR_FIELD (1 - 366?)

    -1,  // 'F' - UDAT_DAY_OF_WEEK_IN_MONTH_FIELD (1-5?)

    -1,  // 'w' - UDAT_WEEK_OF_YEAR_FIELD (1-52?)

    -1,  // 'W' - UDAT_WEEK_OF_MONTH_FIELD (1-5?)

    -1,  // 'a' - UDAT_AM_PM_FIELD

    -1,  // 'h' - UDAT_HOUR1_FIELD

    -1,  // 'K' - UDAT_HOUR0_FIELD

    -1,  // 'z' - UDAT_TIMEZONE_FIELD

    -1,  // 'Y' - UDAT_YEAR_WOY_FIELD

    -1,  // 'e' - UDAT_DOW_LOCAL_FIELD

    -1,  // 'u' - UDAT_EXTENDED_YEAR_FIELD

    -1,  // 'g' - UDAT_JULIAN_DAY_FIELD

    -1,  // 'A' - UDAT_MILLISECONDS_IN_DAY_FIELD

    -1,  // 'Z' - UDAT_TIMEZONE_RFC_FIELD

    -1,  // 'v' - UDAT_TIMEZONE_GENERIC_FIELD

     0,  // 'c' - UDAT_STANDALONE_DAY_FIELD

     1,  // 'L' - UDAT_STANDALONE_MONTH_FIELD

    -1,  // 'Q' - UDAT_QUARTER_FIELD (1-4?)

    -1,  // 'q' - UDAT_STANDALONE_QUARTER_FIELD

    -1,  // 'V' - UDAT_TIMEZONE_SPECIAL_FIELD

    -1,  // 'U' - UDAT_YEAR_NAME_FIELD

    -1,  // 'O' - UDAT_TIMEZONE_LOCALIZED_GMT_OFFSET_FIELD

    -1,  // 'X' - UDAT_TIMEZONE_ISO_FIELD

    -1,  // 'x' - UDAT_TIMEZONE_ISO_LOCAL_FIELD

    -1,  // 'r' - UDAT_RELATED_YEAR_FIELD

#if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR

    -1,  // ':' - UDAT_TIME_SEPARATOR_FIELD

#else

    -1,  // (no pattern character currently) - UDAT_TIME_SEPARATOR_FIELD

#endif

};

// When calendar uses hebr numbering (i.e. he@calendar=hebrew),

// offset the years within the current millennium down to 1-999

static const int32_t HEBREW_CAL_CUR_MILLENIUM_START_YEAR = 5000;

static const int32_t HEBREW_CAL_CUR_MILLENIUM_END_YEAR = 6000;

static constexpr const char16_t HEBREW_CALENDAR_VALUE[] = u"hebr";

/**

 * Maximum range for detecting daylight offset of a time zone when parsed time zone

 * string indicates it's daylight saving time, but the detected time zone does not

 * observe daylight saving time at the parsed date.

 */

static const double MAX_DAYLIGHT_DETECTION_RANGE = 30*365*24*60*60*1000.0;

static UMutex LOCK;

UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SimpleDateFormat)

SimpleDateFormat::NSOverride::~NSOverride() {

    if (snf != nullptr) {

        snf->removeRef();

    }

}

void SimpleDateFormat::NSOverride::free() {

    NSOverride *cur = this;

    while (cur) {

        NSOverride *next_temp = cur->next;

        delete cur;

        cur = next_temp;

    }

}

// no matter what the locale's default number format looked like, we want

// to modify it so that it doesn't use thousands separators, doesn't always

// show the decimal point, and recognizes integers only when parsing

static void fixNumberFormatForDates(NumberFormat &nf) {

    nf.setGroupingUsed(false);

    DecimalFormat* decfmt = dynamic_cast<DecimalFormat*>(&nf);

    if (decfmt != nullptr) {

        decfmt->setDecimalSeparatorAlwaysShown(false);

    }

    nf.setParseIntegerOnly(true);

    nf.setMinimumFractionDigits(0); // To prevent "Jan 1.00, 1997.00"

}

static const SharedNumberFormat *createSharedNumberFormat(

        NumberFormat *nfToAdopt) {

    fixNumberFormatForDates(*nfToAdopt);

    const SharedNumberFormat *result = new SharedNumberFormat(nfToAdopt);

    if (result == nullptr) {

        delete nfToAdopt;

    }

    return result;

}

static const SharedNumberFormat *createSharedNumberFormat(

        const Locale &loc, UErrorCode &status) {

    NumberFormat *nf = NumberFormat::createInstance(loc, status);

    if (U_FAILURE(status)) {

        return nullptr;

    }

    const SharedNumberFormat *result = createSharedNumberFormat(nf);

    if (result == nullptr) {

        status = U_MEMORY_ALLOCATION_ERROR;

    }

    return result;

}

static const SharedNumberFormat **allocSharedNumberFormatters() {

    const SharedNumberFormat** result = static_cast<const SharedNumberFormat**>(

            uprv_malloc(UDAT_FIELD_COUNT * sizeof(const SharedNumberFormat*)));

    if (result == nullptr) {

        return nullptr;

    }

    for (int32_t i = 0; i < UDAT_FIELD_COUNT; ++i) {

        result[i] = nullptr;

    }

    return result;

}

static void freeSharedNumberFormatters(const SharedNumberFormat ** list) {

    for (int32_t i = 0; i < UDAT_FIELD_COUNT; ++i) {

        SharedObject::clearPtr(list[i]);

    }

    uprv_free(list);

}

const NumberFormat *SimpleDateFormat::getNumberFormatByIndex(

        UDateFormatField index) const {

    if (fSharedNumberFormatters == nullptr ||

        fSharedNumberFormatters[index] == nullptr) {

        return fNumberFormat;

    }

    return &(**fSharedNumberFormatters[index]);

}

//----------------------------------------------------------------------

SimpleDateFormat::~SimpleDateFormat()

{

    delete fSymbols;

    if (fSharedNumberFormatters) {

        freeSharedNumberFormatters(fSharedNumberFormatters);

    }

    delete fTimeZoneFormat;

    delete fSimpleNumberFormatter;

#if !UCONFIG_NO_BREAK_ITERATION

    delete fCapitalizationBrkIter;

#endif

}

//----------------------------------------------------------------------

SimpleDateFormat::SimpleDateFormat(UErrorCode& status)

  :   fLocale(Locale::getDefault())

{

    initializeBooleanAttributes();

    construct(kShort, static_cast<EStyle>(kShort + kDateOffset), fLocale, status);

    initializeDefaultCentury();

}

//----------------------------------------------------------------------

SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern,

                                   UErrorCode &status)

:   fPattern(pattern),

    fLocale(Locale::getDefault())

{

    fDateOverride.setToBogus();

    fTimeOverride.setToBogus();

    initializeBooleanAttributes();

    initializeCalendar(nullptr,fLocale,status);

    fSymbols = DateFormatSymbols::createForLocale(fLocale, status);

    initialize(fLocale, status);

    initializeDefaultCentury();

}

//----------------------------------------------------------------------

SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern,

                                   const UnicodeString& override,

                                   UErrorCode &status)

:   fPattern(pattern),

    fLocale(Locale::getDefault())

{

    fDateOverride.setTo(override);

    fTimeOverride.setToBogus();

    initializeBooleanAttributes();

    initializeCalendar(nullptr,fLocale,status);

    fSymbols = DateFormatSymbols::createForLocale(fLocale, status);

    initialize(fLocale, status);

    initializeDefaultCentury();

    processOverrideString(fLocale,override,kOvrStrBoth,status);

}

//----------------------------------------------------------------------

SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern,

                                   const Locale& locale,

                                   UErrorCode& status)

:   fPattern(pattern),

    fLocale(locale)

{

    fDateOverride.setToBogus();

    fTimeOverride.setToBogus();

    initializeBooleanAttributes();

    initializeCalendar(nullptr,fLocale,status);

    fSymbols = DateFormatSymbols::createForLocale(fLocale, status);

    initialize(fLocale, status);

    initializeDefaultCentury();

}

//----------------------------------------------------------------------

SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern,

                                   const UnicodeString& override,

                                   const Locale& locale,

                                   UErrorCode& status)

:   fPattern(pattern),

    fLocale(locale)

{

    fDateOverride.setTo(override);

    fTimeOverride.setToBogus();

    initializeBooleanAttributes();

    initializeCalendar(nullptr,fLocale,status);

    fSymbols = DateFormatSymbols::createForLocale(fLocale, status);

    initialize(fLocale, status);

    initializeDefaultCentury();

    processOverrideString(locale,override,kOvrStrBoth,status);

}

//----------------------------------------------------------------------

SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern,

                                   DateFormatSymbols* symbolsToAdopt,

                                   UErrorCode& status)

:   fPattern(pattern),

    fLocale(Locale::getDefault()),

    fSymbols(symbolsToAdopt)

{

    fDateOverride.setToBogus();

    fTimeOverride.setToBogus();

    initializeBooleanAttributes();

    initializeCalendar(nullptr,fLocale,status);

    initialize(fLocale, status);

    initializeDefaultCentury();

}

//----------------------------------------------------------------------

SimpleDateFormat::SimpleDateFormat(const UnicodeString& pattern,

                                   const DateFormatSymbols& symbols,

                                   UErrorCode& status)

:   fPattern(pattern),

    fLocale(Locale::getDefault()),

    fSymbols(new DateFormatSymbols(symbols))

{

    fDateOverride.setToBogus();

    fTimeOverride.setToBogus();

    initializeBooleanAttributes();

    initializeCalendar(nullptr, fLocale, status);

    initialize(fLocale, status);

    initializeDefaultCentury();

}

//----------------------------------------------------------------------

// Not for public consumption; used by DateFormat

SimpleDateFormat::SimpleDateFormat(EStyle timeStyle,

                                   EStyle dateStyle,

                                   const Locale& locale,

                                   UErrorCode& status)

:   fLocale(locale)

{

    initializeBooleanAttributes();

    construct(timeStyle, dateStyle, fLocale, status);

    if(U_SUCCESS(status)) {

      initializeDefaultCentury();

    }

}

//----------------------------------------------------------------------

/**

 * Not for public consumption; used by DateFormat.  This constructor

 * never fails.  If the resource data is not available, it uses the

 * the last resort symbols.

 */

SimpleDateFormat::SimpleDateFormat(const Locale& locale,

                                   UErrorCode& status)

:   fPattern(gDefaultPattern),

    fLocale(locale)

{

    if (U_FAILURE(status)) return;

    initializeBooleanAttributes();

    initializeCalendar(nullptr, fLocale, status);

    fSymbols = DateFormatSymbols::createForLocale(fLocale, status);

    if (U_FAILURE(status))

    {

        status = U_ZERO_ERROR;

        delete fSymbols;

        // This constructor doesn't fail; it uses last resort data

        fSymbols = new DateFormatSymbols(status);

        /* test for nullptr */

        if (fSymbols == nullptr) {

            status = U_MEMORY_ALLOCATION_ERROR;

            return;

        }

    }

    fDateOverride.setToBogus();

    fTimeOverride.setToBogus();

    initialize(fLocale, status);

    if(U_SUCCESS(status)) {

      initializeDefaultCentury();

    }

}

//----------------------------------------------------------------------

SimpleDateFormat::SimpleDateFormat(const SimpleDateFormat& other)

:   DateFormat(other),

    fLocale(other.fLocale)

{

    initializeBooleanAttributes();

    *this = other;

}

//----------------------------------------------------------------------

SimpleDateFormat& SimpleDateFormat::operator=(const SimpleDateFormat& other)

{

    if (this == &other) {

        return *this;

    }

    // fSimpleNumberFormatter references fNumberFormatter, delete it

    // before we call the = operator which may invalidate fNumberFormatter

    delete fSimpleNumberFormatter;

    fSimpleNumberFormatter = nullptr;

    DateFormat::operator=(other);

    fDateOverride = other.fDateOverride;

    fTimeOverride = other.fTimeOverride;

    delete fSymbols;

    fSymbols = nullptr;

    if (other.fSymbols)

        fSymbols = new DateFormatSymbols(*other.fSymbols);

    fDefaultCenturyStart         = other.fDefaultCenturyStart;

    fDefaultCenturyStartYear     = other.fDefaultCenturyStartYear;

    fHaveDefaultCentury          = other.fHaveDefaultCentury;

    fPattern = other.fPattern;

    fHasMinute = other.fHasMinute;

    fHasSecond = other.fHasSecond;

    fLocale = other.fLocale;

    // TimeZoneFormat can now be set independently via setter.

    // If it is nullptr, it will be lazily initialized from locale.

    delete fTimeZoneFormat;

    fTimeZoneFormat = nullptr;

    TimeZoneFormat *otherTZFormat;

    {

        // Synchronization is required here, when accessing other.fTimeZoneFormat,

        // because another thread may be concurrently executing other.tzFormat(),

        // a logically const function that lazily creates other.fTimeZoneFormat.

        //

        // Without synchronization, reordered memory writes could allow us

        // to see a non-null fTimeZoneFormat before the object itself was

        // fully initialized. In case of a race, it doesn't matter whether

        // we see a null or a fully initialized other.fTimeZoneFormat,

        // only that we avoid seeing a partially initialized object.

        //

        // Once initialized, no const function can modify fTimeZoneFormat,

        // meaning that once we have safely grabbed the other.fTimeZoneFormat

        // pointer, continued synchronization is not required to use it.

        Mutex m(&LOCK);

        otherTZFormat = other.fTimeZoneFormat;

    }

    if (otherTZFormat) {

        fTimeZoneFormat = new TimeZoneFormat(*otherTZFormat);

    }

#if !UCONFIG_NO_BREAK_ITERATION

    if (other.fCapitalizationBrkIter != nullptr) {

        fCapitalizationBrkIter = (other.fCapitalizationBrkIter)->clone();

    }

#endif

    if (fSharedNumberFormatters != nullptr) {

        freeSharedNumberFormatters(fSharedNumberFormatters);

        fSharedNumberFormatters = nullptr;

    }

    if (other.fSharedNumberFormatters != nullptr) {

        fSharedNumberFormatters = allocSharedNumberFormatters();

        if (fSharedNumberFormatters) {

            for (int32_t i = 0; i < UDAT_FIELD_COUNT; ++i) {

                SharedObject::copyPtr(

                        other.fSharedNumberFormatters[i],

                        fSharedNumberFormatters[i]);

            }

        }

    }

    UErrorCode localStatus = U_ZERO_ERROR;

    // SimpleNumberFormatter does not have a copy constructor. Furthermore,

    // it references data from an internal field, fNumberFormatter,

    // so we must rematerialize that reference after copying over the number formatter.

    initSimpleNumberFormatter(localStatus);

    return *this;

}

//----------------------------------------------------------------------

SimpleDateFormat*

SimpleDateFormat::clone() const

{

    return new SimpleDateFormat(*this);

}

//----------------------------------------------------------------------

bool

SimpleDateFormat::operator==(const Format& other) const

{

    if (DateFormat::operator==(other)) {

        // The DateFormat::operator== check for fCapitalizationContext equality above

        //   is sufficient to check equality of all derived context-related data.

        // DateFormat::operator== guarantees following cast is safe

        SimpleDateFormat* that = (SimpleDateFormat*)&other;

        return (fPattern             == that->fPattern &&

                fSymbols             != nullptr && // Check for pathological object

                that->fSymbols       != nullptr && // Check for pathological object

                *fSymbols            == *that->fSymbols &&

                fHaveDefaultCentury  == that->fHaveDefaultCentury &&

                fDefaultCenturyStart == that->fDefaultCenturyStart);

    }

    return false;

}

//----------------------------------------------------------------------

static const char16_t* timeSkeletons[4] = {

    u"jmmsszzzz",   // kFull

    u"jmmssz",      // kLong

    u"jmmss",       // kMedium

    u"jmm",         // kShort

};

void SimpleDateFormat::construct(EStyle timeStyle,

                                 EStyle dateStyle,

                                 const Locale& locale,

                                 UErrorCode& status)

{

    // called by several constructors to load pattern data from the resources

    if (U_FAILURE(status)) return;

    // We will need the calendar to know what type of symbols to load.

    initializeCalendar(nullptr, locale, status);

    if (U_FAILURE(status)) return;

    // Load date time patterns directly from resources.

    const char* cType = fCalendar ? fCalendar->getType() : nullptr;

    LocalUResourceBundlePointer bundle(ures_open(nullptr, locale.getBaseName(), &status));

    if (U_FAILURE(status)) return;

    UBool cTypeIsGregorian = true;

    LocalUResourceBundlePointer dateTimePatterns;

    if (cType != nullptr && uprv_strcmp(cType, "gregorian") != 0) {

        CharString resourcePath("calendar/", status);

        resourcePath.append(cType, status).append("/DateTimePatterns", status);

        dateTimePatterns.adoptInstead(

            ures_getByKeyWithFallback(bundle.getAlias(), resourcePath.data(),

                                      (UResourceBundle*)nullptr, &status));

        cTypeIsGregorian = false;

    }

    // Check for "gregorian" fallback.

    if (cTypeIsGregorian || status == U_MISSING_RESOURCE_ERROR) {

        status = U_ZERO_ERROR;

        dateTimePatterns.adoptInstead(

            ures_getByKeyWithFallback(bundle.getAlias(),

                                      "calendar/gregorian/DateTimePatterns",

                                      (UResourceBundle*)nullptr, &status));

    }

    if (U_FAILURE(status)) return;

    LocalUResourceBundlePointer currentBundle;

    if (ures_getSize(dateTimePatterns.getAlias()) <= kDateTime)

    {

        status = U_INVALID_FORMAT_ERROR;

        return;

    }

    setLocaleIDs(ures_getLocaleByType(dateTimePatterns.getAlias(), ULOC_VALID_LOCALE, &status),

                 ures_getLocaleByType(dateTimePatterns.getAlias(), ULOC_ACTUAL_LOCALE, &status));

    // create a symbols object from the locale

    fSymbols = DateFormatSymbols::createForLocale(locale, status);

    if (U_FAILURE(status)) return;

    /* test for nullptr */

    if (fSymbols == nullptr) {

        status = U_MEMORY_ALLOCATION_ERROR;

        return;

    }

    const char16_t *resStr,*ovrStr;

    int32_t resStrLen,ovrStrLen = 0;

    fDateOverride.setToBogus();

    fTimeOverride.setToBogus();

    UnicodeString timePattern;

    if (timeStyle >= kFull && timeStyle <= kShort) {

        bool hasRgOrHcSubtag = false;

        // also use DTPG if the locale has the "rg" or "hc" ("hours") subtag-- even if the overriding region

        // or hour cycle is the same as the one we get by default, we go through the DateTimePatternGenerator

        UErrorCode dummyErr1 = U_ZERO_ERROR, dummyErr2 = U_ZERO_ERROR;

        if (locale.getKeywordValue("rg", nullptr, 0, dummyErr1) > 0 || locale.getKeywordValue("hours", nullptr, 0, dummyErr2) > 0) {

            hasRgOrHcSubtag = true;

        }

        const char* baseLocID = locale.getBaseName();

        if (baseLocID != nullptr && uprv_strcmp(baseLocID,"und")!=0) {

            UErrorCode useStatus = U_ZERO_ERROR;

            Locale baseLoc(baseLocID);

            Locale validLoc(getLocale(ULOC_VALID_LOCALE, useStatus));

            if (hasRgOrHcSubtag || (U_SUCCESS(useStatus) && validLoc!=baseLoc)) {

                bool useDTPG = hasRgOrHcSubtag;

                const char* baseReg = baseLoc.getCountry(); // empty string if no region

                if ((baseReg != nullptr && baseReg[0] != 0 &&

                     uprv_strncmp(baseReg,validLoc.getCountry(),ULOC_COUNTRY_CAPACITY)!=0)

                        || uprv_strncmp(baseLoc.getLanguage(),validLoc.getLanguage(),ULOC_LANG_CAPACITY)!=0) {

                    // use DTPG if

                    // * baseLoc has a region and validLoc does not have the same one (or has none), OR

                    // * validLoc has a different language code than baseLoc

                    // * the original locale has the rg or hc subtag

                    useDTPG = true;

                }

                if (useDTPG) {

                    // The standard time formats may have the wrong time cycle, because:

                    // the valid locale differs in important ways (region, language) from

                    // the base locale.

                    // We could *also* check whether they do actually have a mismatch with

                    // the time cycle preferences for the region, but that is a lot more

                    // work for little or no additional benefit, since just going ahead

                    // and always synthesizing the time format as per the following should

                    // create a locale-appropriate pattern with cycle that matches the

                    // region preferences anyway.

                    LocalPointer<DateTimePatternGenerator> dtpg(DateTimePatternGenerator::createInstanceNoStdPat(locale, useStatus));

                    if (U_SUCCESS(useStatus)) {

                        UnicodeString timeSkeleton(true, timeSkeletons[timeStyle], -1);

                        timePattern = dtpg->getBestPattern(timeSkeleton, useStatus);

                    }

                }

            }

        }

    }

    // if the pattern should include both date and time information, use the date/time

    // pattern string as a guide to tell use how to glue together the appropriate date

    // and time pattern strings.

    if ((timeStyle != kNone) && (dateStyle != kNone))

    {

        UnicodeString tempus1(timePattern);

        if (tempus1.length() == 0) {

            currentBundle.adoptInstead(

                    ures_getByIndex(dateTimePatterns.getAlias(), static_cast<int32_t>(timeStyle), nullptr, &status));

            if (U_FAILURE(status)) {

               status = U_INVALID_FORMAT_ERROR;

               return;

            }

            switch (ures_getType(currentBundle.getAlias())) {

                case URES_STRING: {

                   resStr = ures_getString(currentBundle.getAlias(), &resStrLen, &status);

                   break;

                }

                case URES_ARRAY: {

                   resStr = ures_getStringByIndex(currentBundle.getAlias(), 0, &resStrLen, &status);

                   ovrStr = ures_getStringByIndex(currentBundle.getAlias(), 1, &ovrStrLen, &status);

                   fTimeOverride.setTo(true, ovrStr, ovrStrLen);

                   break;

                }

                default: {

                   status = U_INVALID_FORMAT_ERROR;

                   return;

                }

            }

            tempus1.setTo(true, resStr, resStrLen);

        }

        currentBundle.adoptInstead(

                ures_getByIndex(dateTimePatterns.getAlias(), static_cast<int32_t>(dateStyle), nullptr, &status));

        if (U_FAILURE(status)) {

           status = U_INVALID_FORMAT_ERROR;

           return;

        }

        switch (ures_getType(currentBundle.getAlias())) {

            case URES_STRING: {

               resStr = ures_getString(currentBundle.getAlias(), &resStrLen, &status);

               break;

            }

            case URES_ARRAY: {

               resStr = ures_getStringByIndex(currentBundle.getAlias(), 0, &resStrLen, &status);

               ovrStr = ures_getStringByIndex(currentBundle.getAlias(), 1, &ovrStrLen, &status);

               fDateOverride.setTo(true, ovrStr, ovrStrLen);

               break;

            }

            default: {

               status = U_INVALID_FORMAT_ERROR;

               return;

            }

        }

        UnicodeString tempus2(true, resStr, resStrLen);

        // Currently, for compatibility with pre-CLDR-42 data, we default to the "atTime"

        // combining patterns. Depending on guidance in CLDR 42 spec and on DisplayOptions,

        // we may change this.

        LocalUResourceBundlePointer dateAtTimePatterns;

        if (!cTypeIsGregorian) {

            CharString resourcePath("calendar/", status);

            resourcePath.append(cType, status).append("/DateTimePatterns%atTime", status);

            dateAtTimePatterns.adoptInstead(

                ures_getByKeyWithFallback(bundle.getAlias(), resourcePath.data(),

                                          nullptr, &status));

        }

        if (cTypeIsGregorian || status == U_MISSING_RESOURCE_ERROR) {

            status = U_ZERO_ERROR;

            dateAtTimePatterns.adoptInstead(

                ures_getByKeyWithFallback(bundle.getAlias(),

                                          "calendar/gregorian/DateTimePatterns%atTime",

                                          nullptr, &status));

        }

        if (U_SUCCESS(status) && ures_getSize(dateAtTimePatterns.getAlias()) >= 4) {

            resStr = ures_getStringByIndex(dateAtTimePatterns.getAlias(), dateStyle - kDateOffset, &resStrLen, &status);

        } else {

            status = U_ZERO_ERROR;

            int32_t glueIndex = kDateTime;

            int32_t patternsSize = ures_getSize(dateTimePatterns.getAlias());

            if (patternsSize >= (kDateTimeOffset + kShort + 1)) {

                // Get proper date time format

                glueIndex = static_cast<int32_t>(kDateTimeOffset + (dateStyle - kDateOffset));

            }

            resStr = ures_getStringByIndex(dateTimePatterns.getAlias(), glueIndex, &resStrLen, &status);

        }

        SimpleFormatter(UnicodeString(true, resStr, resStrLen), 2, 2, status).

                format(tempus1, tempus2, fPattern, status);

    }

    // if the pattern includes just time data or just date date, load the appropriate

    // pattern string from the resources

    // setTo() - see DateFormatSymbols::assignArray comments

    else if (timeStyle != kNone) {

        fPattern.setTo(timePattern);

        if (fPattern.length() == 0) {

            currentBundle.adoptInstead(

                    ures_getByIndex(dateTimePatterns.getAlias(), static_cast<int32_t>(timeStyle), nullptr, &status));

            if (U_FAILURE(status)) {

               status = U_INVALID_FORMAT_ERROR;

               return;

            }

            switch (ures_getType(currentBundle.getAlias())) {

                case URES_STRING: {

                   resStr = ures_getString(currentBundle.getAlias(), &resStrLen, &status);

                   break;

                }

                case URES_ARRAY: {

                   resStr = ures_getStringByIndex(currentBundle.getAlias(), 0, &resStrLen, &status);

                   ovrStr = ures_getStringByIndex(currentBundle.getAlias(), 1, &ovrStrLen, &status);

                   fDateOverride.setTo(true, ovrStr, ovrStrLen);

                   break;

                }

                default: {

                   status = U_INVALID_FORMAT_ERROR;

                   return;

                }

            }

            fPattern.setTo(true, resStr, resStrLen);

        }

    }

    else if (dateStyle != kNone) {

        currentBundle.adoptInstead(

                ures_getByIndex(dateTimePatterns.getAlias(), static_cast<int32_t>(dateStyle), nullptr, &status));

        if (U_FAILURE(status)) {

           status = U_INVALID_FORMAT_ERROR;

           return;

        }

        switch (ures_getType(currentBundle.getAlias())) {

            case URES_STRING: {

               resStr = ures_getString(currentBundle.getAlias(), &resStrLen, &status);

               break;

            }

            case URES_ARRAY: {

               resStr = ures_getStringByIndex(currentBundle.getAlias(), 0, &resStrLen, &status);

               ovrStr = ures_getStringByIndex(currentBundle.getAlias(), 1, &ovrStrLen, &status);

               fDateOverride.setTo(true, ovrStr, ovrStrLen);

               break;

            }

            default: {

               status = U_INVALID_FORMAT_ERROR;

               return;

            }

        }

        fPattern.setTo(true, resStr, resStrLen);

    }

    // and if it includes _neither_, that's an error

    else

        status = U_INVALID_FORMAT_ERROR;

    // finally, finish initializing by creating a Calendar and a NumberFormat

    initialize(locale, status);

}

//----------------------------------------------------------------------

Calendar*

SimpleDateFormat::initializeCalendar(TimeZone* adoptZone, const Locale& locale, UErrorCode& status)

{

    if(!U_FAILURE(status)) {

        fCalendar = Calendar::createInstance(

            adoptZone ? adoptZone : TimeZone::forLocaleOrDefault(locale), locale, status);

    }

    return fCalendar;

}

void

SimpleDateFormat::initialize(const Locale& locale,

                             UErrorCode& status)

{

    if (U_FAILURE(status)) return;

    parsePattern(); // Need this before initNumberFormatters(), to set fHasHanYearChar

    // Simple-minded hack to force Gannen year numbering for ja@calendar=japanese

    // if format is non-numeric (includes 年) and fDateOverride is not already specified.

    // Now this does get updated if applyPattern subsequently changes the pattern type.

    if (fDateOverride.isBogus() && fHasHanYearChar &&

            fCalendar != nullptr &&

            typeid(*fCalendar) == typeid(JapaneseCalendar) &&

            uprv_strcmp(fLocale.getLanguage(),"ja") == 0) {

        fDateOverride.setTo(u"y=jpanyear", -1);

    }

    // We don't need to check that the row count is >= 1, since all 2d arrays have at

    // least one row

    fNumberFormat = NumberFormat::createInstance(locale, status);

    if (fNumberFormat != nullptr && U_SUCCESS(status))

    {

        fixNumberFormatForDates(*fNumberFormat);

        //fNumberFormat->setLenient(true); // Java uses a custom DateNumberFormat to format/parse

        initNumberFormatters(locale, status);

        initSimpleNumberFormatter(status);

    }

    else if (U_SUCCESS(status))

    {

        status = U_MISSING_RESOURCE_ERROR;

    }

}

/* Initialize the fields we use to disambiguate ambiguous years. Separate

 * so we can call it from readObject().

 */

void SimpleDateFormat::initializeDefaultCentury()

{

  if(fCalendar) {

    fHaveDefaultCentury = fCalendar->haveDefaultCentury();

    if(fHaveDefaultCentury) {

      fDefaultCenturyStart = fCalendar->defaultCenturyStart();

      fDefaultCenturyStartYear = fCalendar->defaultCenturyStartYear();

    } else {

      fDefaultCenturyStart = DBL_MIN;

      fDefaultCenturyStartYear = -1;

    }

  }

}

/*

 * Initialize the boolean attributes. Separate so we can call it from all constructors.

 */

void SimpleDateFormat::initializeBooleanAttributes()

{

    UErrorCode status = U_ZERO_ERROR;

    setBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, true, status);

    setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, true, status);

    setBooleanAttribute(UDAT_PARSE_PARTIAL_LITERAL_MATCH, true, status);

    setBooleanAttribute(UDAT_PARSE_MULTIPLE_PATTERNS_FOR_MATCH, true, status);

}

/* Define one-century window into which to disambiguate dates using

 * two-digit years. Make public in JDK 1.2.

 */

void SimpleDateFormat::parseAmbiguousDatesAsAfter(UDate startDate, UErrorCode& status)

{

    if(U_FAILURE(status)) {

        return;

    }

    if(!fCalendar) {

      status = U_ILLEGAL_ARGUMENT_ERROR;

      return;

    }

    fCalendar->setTime(startDate, status);

    if(U_SUCCESS(status)) {

        fHaveDefaultCentury = true;

        fDefaultCenturyStart = startDate;

        fDefaultCenturyStartYear = fCalendar->get(UCAL_YEAR, status);