// © 2016 and later: Unicode, Inc. and others. // License & terms of use: http://www.unicode.org/copyright.html /* ******************************************************************************* * Copyright (C) 2011-2015, International Business Machines Corporation and * others. All Rights Reserved. ******************************************************************************* */ #include "unicode/utypes.h" #if !UCONFIG_NO_FORMATTING #include "unicode/calendar.h" #include "unicode/tzfmt.h" #include "unicode/numsys.h" #include "unicode/strenum.h" #include "unicode/uchar.h" #include "unicode/udat.h" #include "unicode/ustring.h" #include "unicode/utf16.h" #include "tzgnames.h" #include "cmemory.h" #include "cstring.h" #include "putilimp.h" #include "uassert.h" #include "ucln_in.h" #include "umutex.h" #include "uresimp.h" #include "ureslocs.h" #include "uvector.h" #include "zonemeta.h" #include "tznames_impl.h" // TextTrieMap #include "patternprops.h" U_NAMESPACE_BEGIN // Bit flags used by the parse method. // The order must match UTimeZoneFormatStyle enum. #define ISO_Z_STYLE_FLAG 0x0080 #define ISO_LOCAL_STYLE_FLAG 0x0100 static const int16_t STYLE_PARSE_FLAGS[] = { 0x0001, // UTZFMT_STYLE_GENERIC_LOCATION, 0x0002, // UTZFMT_STYLE_GENERIC_LONG, 0x0004, // UTZFMT_STYLE_GENERIC_SHORT, 0x0008, // UTZFMT_STYLE_SPECIFIC_LONG, 0x0010, // UTZFMT_STYLE_SPECIFIC_SHORT, 0x0020, // UTZFMT_STYLE_LOCALIZED_GMT, 0x0040, // UTZFMT_STYLE_LOCALIZED_GMT_SHORT, ISO_Z_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_SHORT, ISO_LOCAL_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_LOCAL_SHORT, ISO_Z_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_FIXED, ISO_LOCAL_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_LOCAL_FIXED, ISO_Z_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_FULL, ISO_LOCAL_STYLE_FLAG, // UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL, ISO_Z_STYLE_FLAG, // UTZFMT_STYLE_ISO_EXTENDED_FIXED, ISO_LOCAL_STYLE_FLAG, // UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FIXED, ISO_Z_STYLE_FLAG, // UTZFMT_STYLE_ISO_EXTENDED_FULL, ISO_LOCAL_STYLE_FLAG, // UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL, 0x0200, // UTZFMT_STYLE_ZONE_ID, 0x0400, // UTZFMT_STYLE_ZONE_ID_SHORT, 0x0800 // UTZFMT_STYLE_EXEMPLAR_LOCATION }; static const char gZoneStringsTag[] = "zoneStrings"; static const char gGmtFormatTag[]= "gmtFormat"; static const char gGmtZeroFormatTag[] = "gmtZeroFormat"; static const char gHourFormatTag[]= "hourFormat"; static const UChar TZID_GMT[] = {0x0045, 0x0074, 0x0063, 0x002F, 0x0047, 0x004D, 0x0054, 0}; // Etc/GMT static const UChar UNKNOWN_ZONE_ID[] = { 0x0045, 0x0074, 0x0063, 0x002F, 0x0055, 0x006E, 0x006B, 0x006E, 0x006F, 0x0077, 0x006E, 0}; // Etc/Unknown static const UChar UNKNOWN_SHORT_ZONE_ID[] = {0x0075, 0x006E, 0x006B, 0}; // unk static const UChar UNKNOWN_LOCATION[] = {0x0055, 0x006E, 0x006B, 0x006E, 0x006F, 0x0077, 0x006E, 0}; // Unknown static const UChar DEFAULT_GMT_PATTERN[] = {0x0047, 0x004D, 0x0054, 0x007B, 0x0030, 0x007D, 0}; // GMT{0} //static const UChar DEFAULT_GMT_ZERO[] = {0x0047, 0x004D, 0x0054, 0}; // GMT static const UChar DEFAULT_GMT_POSITIVE_HM[] = {0x002B, 0x0048, 0x003A, 0x006D, 0x006D, 0}; // +H:mm static const UChar DEFAULT_GMT_POSITIVE_HMS[] = {0x002B, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0}; // +H:mm:ss static const UChar DEFAULT_GMT_NEGATIVE_HM[] = {0x002D, 0x0048, 0x003A, 0x006D, 0x006D, 0}; // -H:mm static const UChar DEFAULT_GMT_NEGATIVE_HMS[] = {0x002D, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0}; // -H:mm:ss static const UChar DEFAULT_GMT_POSITIVE_H[] = {0x002B, 0x0048, 0}; // +H static const UChar DEFAULT_GMT_NEGATIVE_H[] = {0x002D, 0x0048, 0}; // -H static const UChar32 DEFAULT_GMT_DIGITS[] = { 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039 }; static const UChar DEFAULT_GMT_OFFSET_SEP = 0x003A; // ':' static const UChar ARG0[] = {0x007B, 0x0030, 0x007D}; // "{0}" static const int32_t ARG0_LEN = 3; static const UChar DEFAULT_GMT_OFFSET_MINUTE_PATTERN[] = {0x006D, 0x006D, 0}; // "mm" static const UChar DEFAULT_GMT_OFFSET_SECOND_PATTERN[] = {0x0073, 0x0073, 0}; // "ss" static const UChar ALT_GMT_STRINGS[][4] = { {0x0047, 0x004D, 0x0054, 0}, // GMT {0x0055, 0x0054, 0x0043, 0}, // UTC {0x0055, 0x0054, 0, 0}, // UT {0, 0, 0, 0} }; // Order of GMT offset pattern parsing, *_HMS must be evaluated first // because *_HM is most likely a substring of *_HMS static const int32_t PARSE_GMT_OFFSET_TYPES[] = { UTZFMT_PAT_POSITIVE_HMS, UTZFMT_PAT_NEGATIVE_HMS, UTZFMT_PAT_POSITIVE_HM, UTZFMT_PAT_NEGATIVE_HM, UTZFMT_PAT_POSITIVE_H, UTZFMT_PAT_NEGATIVE_H, -1 }; static const UChar SINGLEQUOTE = 0x0027; static const UChar PLUS = 0x002B; static const UChar MINUS = 0x002D; static const UChar ISO8601_UTC = 0x005A; // 'Z' static const UChar ISO8601_SEP = 0x003A; // ':' static const int32_t MILLIS_PER_HOUR = 60 * 60 * 1000; static const int32_t MILLIS_PER_MINUTE = 60 * 1000; static const int32_t MILLIS_PER_SECOND = 1000; // Maximum offset (exclusive) in millisecond supported by offset formats static int32_t MAX_OFFSET = 24 * MILLIS_PER_HOUR; // Maximum values for GMT offset fields static const int32_t MAX_OFFSET_HOUR = 23; static const int32_t MAX_OFFSET_MINUTE = 59; static const int32_t MAX_OFFSET_SECOND = 59; static const int32_t UNKNOWN_OFFSET = 0x7FFFFFFF; static const int32_t ALL_SIMPLE_NAME_TYPES = UTZNM_LONG_STANDARD | UTZNM_LONG_DAYLIGHT | UTZNM_SHORT_STANDARD | UTZNM_SHORT_DAYLIGHT | UTZNM_EXEMPLAR_LOCATION; static const int32_t ALL_GENERIC_NAME_TYPES = UTZGNM_LOCATION | UTZGNM_LONG | UTZGNM_SHORT; #define DIGIT_VAL(c) (0x0030 <= (c) && (c) <= 0x0039 ? (c) - 0x0030 : -1) #define MAX_OFFSET_DIGITS 6 // Time Zone ID/Short ID trie static TextTrieMap *gZoneIdTrie = NULL; static icu::UInitOnce gZoneIdTrieInitOnce = U_INITONCE_INITIALIZER; static TextTrieMap *gShortZoneIdTrie = NULL; static icu::UInitOnce gShortZoneIdTrieInitOnce = U_INITONCE_INITIALIZER; static UMutex *gLock() { static UMutex m = U_MUTEX_INITIALIZER; return &m; } U_CDECL_BEGIN /** * Cleanup callback func */ static UBool U_CALLCONV tzfmt_cleanup(void) { if (gZoneIdTrie != NULL) { delete gZoneIdTrie; } gZoneIdTrie = NULL; gZoneIdTrieInitOnce.reset(); if (gShortZoneIdTrie != NULL) { delete gShortZoneIdTrie; } gShortZoneIdTrie = NULL; gShortZoneIdTrieInitOnce.reset(); return TRUE; } U_CDECL_END // ------------------------------------------------------------------ // GMTOffsetField // // This class represents a localized GMT offset pattern // item and used by TimeZoneFormat // ------------------------------------------------------------------ class GMTOffsetField : public UMemory { public: enum FieldType { TEXT = 0, HOUR = 1, MINUTE = 2, SECOND = 4 }; virtual ~GMTOffsetField(); static GMTOffsetField* createText(const UnicodeString& text, UErrorCode& status); static GMTOffsetField* createTimeField(FieldType type, uint8_t width, UErrorCode& status); static UBool isValid(FieldType type, int32_t width); static FieldType getTypeByLetter(UChar ch); FieldType getType() const; uint8_t getWidth() const; const UChar* getPatternText(void) const; private: UChar* fText; FieldType fType; uint8_t fWidth; GMTOffsetField(); }; GMTOffsetField::GMTOffsetField() : fText(NULL), fType(TEXT), fWidth(0) { } GMTOffsetField::~GMTOffsetField() { if (fText) { uprv_free(fText); } } GMTOffsetField* GMTOffsetField::createText(const UnicodeString& text, UErrorCode& status) { if (U_FAILURE(status)) { return NULL; } GMTOffsetField* result = new GMTOffsetField(); if (result == NULL) { status = U_MEMORY_ALLOCATION_ERROR; return NULL; } int32_t len = text.length(); result->fText = (UChar*)uprv_malloc((len + 1) * sizeof(UChar)); if (result->fText == NULL) { status = U_MEMORY_ALLOCATION_ERROR; delete result; return NULL; } u_strncpy(result->fText, text.getBuffer(), len); result->fText[len] = 0; result->fType = TEXT; return result; } GMTOffsetField* GMTOffsetField::createTimeField(FieldType type, uint8_t width, UErrorCode& status) { U_ASSERT(type != TEXT); if (U_FAILURE(status)) { return NULL; } GMTOffsetField* result = new GMTOffsetField(); if (result == NULL) { status = U_MEMORY_ALLOCATION_ERROR; return NULL; } result->fType = type; result->fWidth = width; return result; } UBool GMTOffsetField::isValid(FieldType type, int32_t width) { switch (type) { case HOUR: return (width == 1 || width == 2); case MINUTE: case SECOND: return (width == 2); default: UPRV_UNREACHABLE; } return (width > 0); } GMTOffsetField::FieldType GMTOffsetField::getTypeByLetter(UChar ch) { if (ch == 0x0048 /* H */) { return HOUR; } else if (ch == 0x006D /* m */) { return MINUTE; } else if (ch == 0x0073 /* s */) { return SECOND; } return TEXT; } inline GMTOffsetField::FieldType GMTOffsetField::getType() const { return fType; } inline uint8_t GMTOffsetField::getWidth() const { return fWidth; } inline const UChar* GMTOffsetField::getPatternText(void) const { return fText; } U_CDECL_BEGIN static void U_CALLCONV deleteGMTOffsetField(void *obj) { delete static_cast(obj); } U_CDECL_END // ------------------------------------------------------------------ // TimeZoneFormat // ------------------------------------------------------------------ UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TimeZoneFormat) TimeZoneFormat::TimeZoneFormat(const Locale& locale, UErrorCode& status) : fLocale(locale), fTimeZoneNames(NULL), fTimeZoneGenericNames(NULL), fDefParseOptionFlags(0), fTZDBTimeZoneNames(NULL) { for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) { fGMTOffsetPatternItems[i] = NULL; } const char* region = fLocale.getCountry(); int32_t regionLen = static_cast(uprv_strlen(region)); if (regionLen == 0) { char loc[ULOC_FULLNAME_CAPACITY]; uloc_addLikelySubtags(fLocale.getName(), loc, sizeof(loc), &status); regionLen = uloc_getCountry(loc, fTargetRegion, sizeof(fTargetRegion), &status); if (U_SUCCESS(status)) { fTargetRegion[regionLen] = 0; } else { return; } } else if (regionLen < (int32_t)sizeof(fTargetRegion)) { uprv_strcpy(fTargetRegion, region); } else { fTargetRegion[0] = 0; } fTimeZoneNames = TimeZoneNames::createInstance(locale, status); // fTimeZoneGenericNames is lazily instantiated if (U_FAILURE(status)) { return; } const UChar* gmtPattern = NULL; const UChar* hourFormats = NULL; UResourceBundle *zoneBundle = ures_open(U_ICUDATA_ZONE, locale.getName(), &status); UResourceBundle *zoneStringsArray = ures_getByKeyWithFallback(zoneBundle, gZoneStringsTag, NULL, &status); if (U_SUCCESS(status)) { const UChar* resStr; int32_t len; resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gGmtFormatTag, &len, &status); if (len > 0) { gmtPattern = resStr; } resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gGmtZeroFormatTag, &len, &status); if (len > 0) { fGMTZeroFormat.setTo(TRUE, resStr, len); } resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gHourFormatTag, &len, &status); if (len > 0) { hourFormats = resStr; } ures_close(zoneStringsArray); ures_close(zoneBundle); } if (gmtPattern == NULL) { gmtPattern = DEFAULT_GMT_PATTERN; } initGMTPattern(UnicodeString(TRUE, gmtPattern, -1), status); UBool useDefaultOffsetPatterns = TRUE; if (hourFormats) { UChar *sep = u_strchr(hourFormats, (UChar)0x003B /* ';' */); if (sep != NULL) { UErrorCode tmpStatus = U_ZERO_ERROR; fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM].setTo(FALSE, hourFormats, (int32_t)(sep - hourFormats)); fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM].setTo(TRUE, sep + 1, -1); expandOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HMS], tmpStatus); expandOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HMS], tmpStatus); truncateOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_H], tmpStatus); truncateOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_H], tmpStatus); if (U_SUCCESS(tmpStatus)) { useDefaultOffsetPatterns = FALSE; } } } if (useDefaultOffsetPatterns) { fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_H].setTo(TRUE, DEFAULT_GMT_POSITIVE_H, -1); fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM].setTo(TRUE, DEFAULT_GMT_POSITIVE_HM, -1); fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HMS].setTo(TRUE, DEFAULT_GMT_POSITIVE_HMS, -1); fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_H].setTo(TRUE, DEFAULT_GMT_NEGATIVE_H, -1); fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM].setTo(TRUE, DEFAULT_GMT_NEGATIVE_HM, -1); fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HMS].setTo(TRUE, DEFAULT_GMT_NEGATIVE_HMS, -1); } initGMTOffsetPatterns(status); NumberingSystem* ns = NumberingSystem::createInstance(locale, status); UBool useDefDigits = TRUE; if (ns && !ns->isAlgorithmic()) { UnicodeString digits = ns->getDescription(); useDefDigits = !toCodePoints(digits, fGMTOffsetDigits, 10); } if (useDefDigits) { uprv_memcpy(fGMTOffsetDigits, DEFAULT_GMT_DIGITS, sizeof(UChar32) * 10); } delete ns; } TimeZoneFormat::TimeZoneFormat(const TimeZoneFormat& other) : Format(other), fTimeZoneNames(NULL), fTimeZoneGenericNames(NULL), fTZDBTimeZoneNames(NULL) { for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) { fGMTOffsetPatternItems[i] = NULL; } *this = other; } TimeZoneFormat::~TimeZoneFormat() { delete fTimeZoneNames; delete fTimeZoneGenericNames; delete fTZDBTimeZoneNames; for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) { delete fGMTOffsetPatternItems[i]; } } TimeZoneFormat& TimeZoneFormat::operator=(const TimeZoneFormat& other) { if (this == &other) { return *this; } delete fTimeZoneNames; delete fTimeZoneGenericNames; fTimeZoneGenericNames = NULL; delete fTZDBTimeZoneNames; fTZDBTimeZoneNames = NULL; fLocale = other.fLocale; uprv_memcpy(fTargetRegion, other.fTargetRegion, sizeof(fTargetRegion)); fTimeZoneNames = other.fTimeZoneNames->clone(); if (other.fTimeZoneGenericNames) { // TODO: this test has dubious thread safety. fTimeZoneGenericNames = other.fTimeZoneGenericNames->clone(); } fGMTPattern = other.fGMTPattern; fGMTPatternPrefix = other.fGMTPatternPrefix; fGMTPatternSuffix = other.fGMTPatternSuffix; UErrorCode status = U_ZERO_ERROR; for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) { fGMTOffsetPatterns[i] = other.fGMTOffsetPatterns[i]; delete fGMTOffsetPatternItems[i]; fGMTOffsetPatternItems[i] = NULL; } initGMTOffsetPatterns(status); U_ASSERT(U_SUCCESS(status)); fGMTZeroFormat = other.fGMTZeroFormat; uprv_memcpy(fGMTOffsetDigits, other.fGMTOffsetDigits, sizeof(fGMTOffsetDigits)); fDefParseOptionFlags = other.fDefParseOptionFlags; return *this; } UBool TimeZoneFormat::operator==(const Format& other) const { TimeZoneFormat* tzfmt = (TimeZoneFormat*)&other; UBool isEqual = fLocale == tzfmt->fLocale && fGMTPattern == tzfmt->fGMTPattern && fGMTZeroFormat == tzfmt->fGMTZeroFormat && *fTimeZoneNames == *tzfmt->fTimeZoneNames; for (int32_t i = 0; i < UTZFMT_PAT_COUNT && isEqual; i++) { isEqual = fGMTOffsetPatterns[i] == tzfmt->fGMTOffsetPatterns[i]; } for (int32_t i = 0; i < 10 && isEqual; i++) { isEqual = fGMTOffsetDigits[i] == tzfmt->fGMTOffsetDigits[i]; } // TODO // Check fTimeZoneGenericNames. For now, // if fTimeZoneNames is same, fTimeZoneGenericNames should // be also equivalent. return isEqual; } Format* TimeZoneFormat::clone() const { return new TimeZoneFormat(*this); } TimeZoneFormat* U_EXPORT2 TimeZoneFormat::createInstance(const Locale& locale, UErrorCode& status) { TimeZoneFormat* tzfmt = new TimeZoneFormat(locale, status); if (U_SUCCESS(status)) { return tzfmt; } delete tzfmt; return NULL; } // ------------------------------------------------------------------ // Setter and Getter const TimeZoneNames* TimeZoneFormat::getTimeZoneNames() const { return (const TimeZoneNames*)fTimeZoneNames; } void TimeZoneFormat::adoptTimeZoneNames(TimeZoneNames *tznames) { delete fTimeZoneNames; fTimeZoneNames = tznames; // TODO - We should also update fTimeZoneGenericNames } void TimeZoneFormat::setTimeZoneNames(const TimeZoneNames &tznames) { delete fTimeZoneNames; fTimeZoneNames = tznames.clone(); // TODO - We should also update fTimeZoneGenericNames } void TimeZoneFormat::setDefaultParseOptions(uint32_t flags) { fDefParseOptionFlags = flags; } uint32_t TimeZoneFormat::getDefaultParseOptions(void) const { return fDefParseOptionFlags; } UnicodeString& TimeZoneFormat::getGMTPattern(UnicodeString& pattern) const { return pattern.setTo(fGMTPattern); } void TimeZoneFormat::setGMTPattern(const UnicodeString& pattern, UErrorCode& status) { initGMTPattern(pattern, status); } UnicodeString& TimeZoneFormat::getGMTOffsetPattern(UTimeZoneFormatGMTOffsetPatternType type, UnicodeString& pattern) const { return pattern.setTo(fGMTOffsetPatterns[type]); } void TimeZoneFormat::setGMTOffsetPattern(UTimeZoneFormatGMTOffsetPatternType type, const UnicodeString& pattern, UErrorCode& status) { if (U_FAILURE(status)) { return; } if (pattern == fGMTOffsetPatterns[type]) { // No need to reset return; } OffsetFields required = FIELDS_HM; switch (type) { case UTZFMT_PAT_POSITIVE_H: case UTZFMT_PAT_NEGATIVE_H: required = FIELDS_H; break; case UTZFMT_PAT_POSITIVE_HM: case UTZFMT_PAT_NEGATIVE_HM: required = FIELDS_HM; break; case UTZFMT_PAT_POSITIVE_HMS: case UTZFMT_PAT_NEGATIVE_HMS: required = FIELDS_HMS; break; default: UPRV_UNREACHABLE; } UVector* patternItems = parseOffsetPattern(pattern, required, status); if (patternItems == NULL) { return; } fGMTOffsetPatterns[type].setTo(pattern); delete fGMTOffsetPatternItems[type]; fGMTOffsetPatternItems[type] = patternItems; checkAbuttingHoursAndMinutes(); } UnicodeString& TimeZoneFormat::getGMTOffsetDigits(UnicodeString& digits) const { digits.remove(); for (int32_t i = 0; i < 10; i++) { digits.append(fGMTOffsetDigits[i]); } return digits; } void TimeZoneFormat::setGMTOffsetDigits(const UnicodeString& digits, UErrorCode& status) { if (U_FAILURE(status)) { return; } UChar32 digitArray[10]; if (!toCodePoints(digits, digitArray, 10)) { status = U_ILLEGAL_ARGUMENT_ERROR; return; } uprv_memcpy(fGMTOffsetDigits, digitArray, sizeof(UChar32)*10); } UnicodeString& TimeZoneFormat::getGMTZeroFormat(UnicodeString& gmtZeroFormat) const { return gmtZeroFormat.setTo(fGMTZeroFormat); } void TimeZoneFormat::setGMTZeroFormat(const UnicodeString& gmtZeroFormat, UErrorCode& status) { if (U_SUCCESS(status)) { if (gmtZeroFormat.isEmpty()) { status = U_ILLEGAL_ARGUMENT_ERROR; } else if (gmtZeroFormat != fGMTZeroFormat) { fGMTZeroFormat.setTo(gmtZeroFormat); } } } // ------------------------------------------------------------------ // Format and Parse UnicodeString& TimeZoneFormat::format(UTimeZoneFormatStyle style, const TimeZone& tz, UDate date, UnicodeString& name, UTimeZoneFormatTimeType* timeType /* = NULL */) const { if (timeType) { *timeType = UTZFMT_TIME_TYPE_UNKNOWN; } UBool noOffsetFormatFallback = FALSE; switch (style) { case UTZFMT_STYLE_GENERIC_LOCATION: formatGeneric(tz, UTZGNM_LOCATION, date, name); break; case UTZFMT_STYLE_GENERIC_LONG: formatGeneric(tz, UTZGNM_LONG, date, name); break; case UTZFMT_STYLE_GENERIC_SHORT: formatGeneric(tz, UTZGNM_SHORT, date, name); break; case UTZFMT_STYLE_SPECIFIC_LONG: formatSpecific(tz, UTZNM_LONG_STANDARD, UTZNM_LONG_DAYLIGHT, date, name, timeType); break; case UTZFMT_STYLE_SPECIFIC_SHORT: formatSpecific(tz, UTZNM_SHORT_STANDARD, UTZNM_SHORT_DAYLIGHT, date, name, timeType); break; case UTZFMT_STYLE_ZONE_ID: tz.getID(name); noOffsetFormatFallback = TRUE; break; case UTZFMT_STYLE_ZONE_ID_SHORT: { const UChar* shortID = ZoneMeta::getShortID(tz); if (shortID == NULL) { shortID = UNKNOWN_SHORT_ZONE_ID; } name.setTo(shortID, -1); } noOffsetFormatFallback = TRUE; break; case UTZFMT_STYLE_EXEMPLAR_LOCATION: formatExemplarLocation(tz, name); noOffsetFormatFallback = TRUE; break; default: // will be handled below break; } if (name.isEmpty() && !noOffsetFormatFallback) { UErrorCode status = U_ZERO_ERROR; int32_t rawOffset, dstOffset; tz.getOffset(date, FALSE, rawOffset, dstOffset, status); int32_t offset = rawOffset + dstOffset; if (U_SUCCESS(status)) { switch (style) { case UTZFMT_STYLE_GENERIC_LOCATION: case UTZFMT_STYLE_GENERIC_LONG: case UTZFMT_STYLE_SPECIFIC_LONG: case UTZFMT_STYLE_LOCALIZED_GMT: formatOffsetLocalizedGMT(offset, name, status); break; case UTZFMT_STYLE_GENERIC_SHORT: case UTZFMT_STYLE_SPECIFIC_SHORT: case UTZFMT_STYLE_LOCALIZED_GMT_SHORT: formatOffsetShortLocalizedGMT(offset, name, status); break; case UTZFMT_STYLE_ISO_BASIC_SHORT: formatOffsetISO8601Basic(offset, TRUE, TRUE, TRUE, name, status); break; case UTZFMT_STYLE_ISO_BASIC_LOCAL_SHORT: formatOffsetISO8601Basic(offset, FALSE, TRUE, TRUE, name, status); break; case UTZFMT_STYLE_ISO_BASIC_FIXED: formatOffsetISO8601Basic(offset, TRUE, FALSE, TRUE, name, status); break; case UTZFMT_STYLE_ISO_BASIC_LOCAL_FIXED: formatOffsetISO8601Basic(offset, FALSE, FALSE, TRUE, name, status); break; case UTZFMT_STYLE_ISO_EXTENDED_FIXED: formatOffsetISO8601Extended(offset, TRUE, FALSE, TRUE, name, status); break; case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FIXED: formatOffsetISO8601Extended(offset, FALSE, FALSE, TRUE, name, status); break; case UTZFMT_STYLE_ISO_BASIC_FULL: formatOffsetISO8601Basic(offset, TRUE, FALSE, FALSE, name, status); break; case UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL: formatOffsetISO8601Basic(offset, FALSE, FALSE, FALSE, name, status); break; case UTZFMT_STYLE_ISO_EXTENDED_FULL: formatOffsetISO8601Extended(offset, TRUE, FALSE, FALSE, name, status); break; case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL: formatOffsetISO8601Extended(offset, FALSE, FALSE, FALSE, name, status); break; default: // UTZFMT_STYLE_ZONE_ID, UTZFMT_STYLE_ZONE_ID_SHORT, UTZFMT_STYLE_EXEMPLAR_LOCATION break; } if (timeType) { *timeType = (dstOffset != 0) ? UTZFMT_TIME_TYPE_DAYLIGHT : UTZFMT_TIME_TYPE_STANDARD; } } } return name; } UnicodeString& TimeZoneFormat::format(const Formattable& obj, UnicodeString& appendTo, FieldPosition& pos, UErrorCode& status) const { if (U_FAILURE(status)) { return appendTo; } UDate date = Calendar::getNow(); if (obj.getType() == Formattable::kObject) { const UObject* formatObj = obj.getObject(); const TimeZone* tz = dynamic_cast(formatObj); if (tz == NULL) { const Calendar* cal = dynamic_cast(formatObj); if (cal != NULL) { tz = &cal->getTimeZone(); date = cal->getTime(status); } } if (tz != NULL) { int32_t rawOffset, dstOffset; tz->getOffset(date, FALSE, rawOffset, dstOffset, status); UChar buf[ZONE_NAME_U16_MAX]; UnicodeString result(buf, 0, UPRV_LENGTHOF(buf)); formatOffsetLocalizedGMT(rawOffset + dstOffset, result, status); if (U_SUCCESS(status)) { appendTo.append(result); if (pos.getField() == UDAT_TIMEZONE_FIELD) { pos.setBeginIndex(0); pos.setEndIndex(result.length()); } } } } return appendTo; } TimeZone* TimeZoneFormat::parse(UTimeZoneFormatStyle style, const UnicodeString& text, ParsePosition& pos, UTimeZoneFormatTimeType* timeType /*= NULL*/) const { return parse(style, text, pos, getDefaultParseOptions(), timeType); } TimeZone* TimeZoneFormat::parse(UTimeZoneFormatStyle style, const UnicodeString& text, ParsePosition& pos, int32_t parseOptions, UTimeZoneFormatTimeType* timeType /* = NULL */) const { if (timeType) { *timeType = UTZFMT_TIME_TYPE_UNKNOWN; } int32_t startIdx = pos.getIndex(); int32_t maxPos = text.length(); int32_t offset; // Styles using localized GMT format as fallback UBool fallbackLocalizedGMT = (style == UTZFMT_STYLE_SPECIFIC_LONG || style == UTZFMT_STYLE_GENERIC_LONG || style == UTZFMT_STYLE_GENERIC_LOCATION); UBool fallbackShortLocalizedGMT = (style == UTZFMT_STYLE_SPECIFIC_SHORT || style == UTZFMT_STYLE_GENERIC_SHORT); int32_t evaluated = 0; // bit flags representing already evaluated styles ParsePosition tmpPos(startIdx); int32_t parsedOffset = UNKNOWN_OFFSET; // stores successfully parsed offset for later use int32_t parsedPos = -1; // stores successfully parsed offset position for later use // Try localized GMT format first if necessary if (fallbackLocalizedGMT || fallbackShortLocalizedGMT) { UBool hasDigitOffset = FALSE; offset = parseOffsetLocalizedGMT(text, tmpPos, fallbackShortLocalizedGMT, &hasDigitOffset); if (tmpPos.getErrorIndex() == -1) { // Even when the input text was successfully parsed as a localized GMT format text, // we may still need to evaluate the specified style if - // 1) GMT zero format was used, and // 2) The input text was not completely processed if (tmpPos.getIndex() == maxPos || hasDigitOffset) { pos.setIndex(tmpPos.getIndex()); return createTimeZoneForOffset(offset); } parsedOffset = offset; parsedPos = tmpPos.getIndex(); } // Note: For now, no distinction between long/short localized GMT format in the parser. // This might be changed in future. // evaluated |= (fallbackLocalizedGMT ? STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT] : STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT]); evaluated |= STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT] | STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT]; } UErrorCode status = U_ZERO_ERROR; UChar tzIDBuf[32]; UnicodeString tzID(tzIDBuf, 0, UPRV_LENGTHOF(tzIDBuf)); UBool parseTZDBAbbrev = ((parseOptions & UTZFMT_PARSE_OPTION_TZ_DATABASE_ABBREVIATIONS) != 0); // Try the specified style switch (style) { case UTZFMT_STYLE_LOCALIZED_GMT: { tmpPos.setIndex(startIdx); tmpPos.setErrorIndex(-1); offset = parseOffsetLocalizedGMT(text, tmpPos); if (tmpPos.getErrorIndex() == -1) { pos.setIndex(tmpPos.getIndex()); return createTimeZoneForOffset(offset); } // Note: For now, no distinction between long/short localized GMT format in the parser. // This might be changed in future. evaluated |= STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT]; break; } case UTZFMT_STYLE_LOCALIZED_GMT_SHORT: { tmpPos.setIndex(startIdx); tmpPos.setErrorIndex(-1); offset = parseOffsetShortLocalizedGMT(text, tmpPos); if (tmpPos.getErrorIndex() == -1) { pos.setIndex(tmpPos.getIndex()); return createTimeZoneForOffset(offset); } // Note: For now, no distinction between long/short localized GMT format in the parser. // This might be changed in future. evaluated |= STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT]; break; } case UTZFMT_STYLE_ISO_BASIC_SHORT: case UTZFMT_STYLE_ISO_BASIC_FIXED: case UTZFMT_STYLE_ISO_BASIC_FULL: case UTZFMT_STYLE_ISO_EXTENDED_FIXED: case UTZFMT_STYLE_ISO_EXTENDED_FULL: { tmpPos.setIndex(startIdx); tmpPos.setErrorIndex(-1); offset = parseOffsetISO8601(text, tmpPos); if (tmpPos.getErrorIndex() == -1) { pos.setIndex(tmpPos.getIndex()); return createTimeZoneForOffset(offset); } break; } case UTZFMT_STYLE_ISO_BASIC_LOCAL_SHORT: case UTZFMT_STYLE_ISO_BASIC_LOCAL_FIXED: case UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL: case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FIXED: case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL: { tmpPos.setIndex(startIdx); tmpPos.setErrorIndex(-1); // Exclude the case of UTC Indicator "Z" here UBool hasDigitOffset = FALSE; offset = parseOffsetISO8601(text, tmpPos, FALSE, &hasDigitOffset); if (tmpPos.getErrorIndex() == -1 && hasDigitOffset) { pos.setIndex(tmpPos.getIndex()); return createTimeZoneForOffset(offset); } break; } case UTZFMT_STYLE_SPECIFIC_LONG: case UTZFMT_STYLE_SPECIFIC_SHORT: { // Specific styles int32_t nameTypes = 0; if (style == UTZFMT_STYLE_SPECIFIC_LONG) { nameTypes = (UTZNM_LONG_STANDARD | UTZNM_LONG_DAYLIGHT); } else { U_ASSERT(style == UTZFMT_STYLE_SPECIFIC_SHORT); nameTypes = (UTZNM_SHORT_STANDARD | UTZNM_SHORT_DAYLIGHT); } LocalPointer specificMatches(fTimeZoneNames->find(text, startIdx, nameTypes, status)); if (U_FAILURE(status)) { pos.setErrorIndex(startIdx); return NULL; } if (!specificMatches.isNull()) { int32_t matchIdx = -1; int32_t matchPos = -1; for (int32_t i = 0; i < specificMatches->size(); i++) { matchPos = startIdx + specificMatches->getMatchLengthAt(i); if (matchPos > parsedPos) { matchIdx = i; parsedPos = matchPos; } } if (matchIdx >= 0) { if (timeType) { *timeType = getTimeType(specificMatches->getNameTypeAt(matchIdx)); } pos.setIndex(matchPos); getTimeZoneID(specificMatches.getAlias(), matchIdx, tzID); U_ASSERT(!tzID.isEmpty()); return TimeZone::createTimeZone(tzID); } } if (parseTZDBAbbrev && style == UTZFMT_STYLE_SPECIFIC_SHORT) { U_ASSERT((nameTypes & UTZNM_SHORT_STANDARD) != 0); U_ASSERT((nameTypes & UTZNM_SHORT_DAYLIGHT) != 0); const TZDBTimeZoneNames *tzdbTimeZoneNames = getTZDBTimeZoneNames(status); if (U_SUCCESS(status)) { LocalPointer tzdbNameMatches( tzdbTimeZoneNames->find(text, startIdx, nameTypes, status)); if (U_FAILURE(status)) { pos.setErrorIndex(startIdx); return NULL; } if (!tzdbNameMatches.isNull()) { int32_t matchIdx = -1; int32_t matchPos = -1; for (int32_t i = 0; i < tzdbNameMatches->size(); i++) { matchPos = startIdx + tzdbNameMatches->getMatchLengthAt(i); if (matchPos > parsedPos) { matchIdx = i; parsedPos = matchPos; } } if (matchIdx >= 0) { if (timeType) { *timeType = getTimeType(tzdbNameMatches->getNameTypeAt(matchIdx)); } pos.setIndex(matchPos); getTimeZoneID(tzdbNameMatches.getAlias(), matchIdx, tzID); U_ASSERT(!tzID.isEmpty()); return TimeZone::createTimeZone(tzID); } } } } break; } case UTZFMT_STYLE_GENERIC_LONG: case UTZFMT_STYLE_GENERIC_SHORT: case UTZFMT_STYLE_GENERIC_LOCATION: { int32_t genericNameTypes = 0; switch (style) { case UTZFMT_STYLE_GENERIC_LOCATION: genericNameTypes = UTZGNM_LOCATION; break; case UTZFMT_STYLE_GENERIC_LONG: genericNameTypes = UTZGNM_LONG | UTZGNM_LOCATION; break; case UTZFMT_STYLE_GENERIC_SHORT: genericNameTypes = UTZGNM_SHORT | UTZGNM_LOCATION; break; default: UPRV_UNREACHABLE; } int32_t len = 0; UTimeZoneFormatTimeType tt = UTZFMT_TIME_TYPE_UNKNOWN; const TimeZoneGenericNames *gnames = getTimeZoneGenericNames(status); if (U_SUCCESS(status)) { len = gnames->findBestMatch(text, startIdx, genericNameTypes, tzID, tt, status); } if (U_FAILURE(status)) { pos.setErrorIndex(startIdx); return NULL; } if (len > 0) { // Found a match if (timeType) { *timeType = tt; } pos.setIndex(startIdx + len); U_ASSERT(!tzID.isEmpty()); return TimeZone::createTimeZone(tzID); } break; } case UTZFMT_STYLE_ZONE_ID: { tmpPos.setIndex(startIdx); tmpPos.setErrorIndex(-1); parseZoneID(text, tmpPos, tzID); if (tmpPos.getErrorIndex() == -1) { pos.setIndex(tmpPos.getIndex()); return TimeZone::createTimeZone(tzID); } break; } case UTZFMT_STYLE_ZONE_ID_SHORT: { tmpPos.setIndex(startIdx); tmpPos.setErrorIndex(-1); parseShortZoneID(text, tmpPos, tzID); if (tmpPos.getErrorIndex() == -1) { pos.setIndex(tmpPos.getIndex()); return TimeZone::createTimeZone(tzID); } break; } case UTZFMT_STYLE_EXEMPLAR_LOCATION: { tmpPos.setIndex(startIdx); tmpPos.setErrorIndex(-1); parseExemplarLocation(text, tmpPos, tzID); if (tmpPos.getErrorIndex() == -1) { pos.setIndex(tmpPos.getIndex()); return TimeZone::createTimeZone(tzID); } break; } } evaluated |= STYLE_PARSE_FLAGS[style]; if (parsedPos > startIdx) { // When the specified style is one of SPECIFIC_XXX or GENERIC_XXX, we tried to parse the input // as localized GMT format earlier. If parsedOffset is positive, it means it was successfully // parsed as localized GMT format, but offset digits were not detected (more specifically, GMT // zero format). Then, it tried to find a match within the set of display names, but could not // find a match. At this point, we can safely assume the input text contains the localized // GMT format. U_ASSERT(parsedOffset != UNKNOWN_OFFSET); pos.setIndex(parsedPos); return createTimeZoneForOffset(parsedOffset); } // Failed to parse the input text as the time zone format in the specified style. // Check the longest match among other styles below. UChar parsedIDBuf[32]; UnicodeString parsedID(parsedIDBuf, 0, UPRV_LENGTHOF(parsedIDBuf)); UTimeZoneFormatTimeType parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN; U_ASSERT(parsedPos < 0); U_ASSERT(parsedOffset == UNKNOWN_OFFSET); // ISO 8601 if (parsedPos < maxPos && ((evaluated & ISO_Z_STYLE_FLAG) == 0 || (evaluated & ISO_LOCAL_STYLE_FLAG) == 0)) { tmpPos.setIndex(startIdx); tmpPos.setErrorIndex(-1); UBool hasDigitOffset = FALSE; offset = parseOffsetISO8601(text, tmpPos, FALSE, &hasDigitOffset); if (tmpPos.getErrorIndex() == -1) { if (tmpPos.getIndex() == maxPos || hasDigitOffset) { pos.setIndex(tmpPos.getIndex()); return createTimeZoneForOffset(offset); } // Note: When ISO 8601 format contains offset digits, it should not // collide with other formats. However, ISO 8601 UTC format "Z" (single letter) // may collide with other names. In this case, we need to evaluate other names. if (parsedPos < tmpPos.getIndex()) { parsedOffset = offset; parsedID.setToBogus(); parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN; parsedPos = tmpPos.getIndex(); U_ASSERT(parsedPos == startIdx + 1); // only when "Z" is used } } } // Localized GMT format if (parsedPos < maxPos && (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT]) == 0) { tmpPos.setIndex(startIdx); tmpPos.setErrorIndex(-1); UBool hasDigitOffset = FALSE; offset = parseOffsetLocalizedGMT(text, tmpPos, FALSE, &hasDigitOffset); if (tmpPos.getErrorIndex() == -1) { if (tmpPos.getIndex() == maxPos || hasDigitOffset) { pos.setIndex(tmpPos.getIndex()); return createTimeZoneForOffset(offset); } // Evaluate other names - see the comment earlier in this method. if (parsedPos < tmpPos.getIndex()) { parsedOffset = offset; parsedID.setToBogus(); parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN; parsedPos = tmpPos.getIndex(); } } } if (parsedPos < maxPos && (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT]) == 0) { tmpPos.setIndex(startIdx); tmpPos.setErrorIndex(-1); UBool hasDigitOffset = FALSE; offset = parseOffsetLocalizedGMT(text, tmpPos, TRUE, &hasDigitOffset); if (tmpPos.getErrorIndex() == -1) { if (tmpPos.getIndex() == maxPos || hasDigitOffset) { pos.setIndex(tmpPos.getIndex()); return createTimeZoneForOffset(offset); } // Evaluate other names - see the comment earlier in this method. if (parsedPos < tmpPos.getIndex()) { parsedOffset = offset; parsedID.setToBogus(); parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN; parsedPos = tmpPos.getIndex(); } } } // When ParseOption.ALL_STYLES is available, we also try to look all possible display names and IDs. // For example, when style is GENERIC_LONG, "EST" (SPECIFIC_SHORT) is never // used for America/New_York. With parseAllStyles true, this code parses "EST" // as America/New_York. // Note: Adding all possible names into the trie used by the implementation is quite heavy operation, // which we want to avoid normally (note that we cache the trie, so this is applicable to the // first time only as long as the cache does not expire). if (parseOptions & UTZFMT_PARSE_OPTION_ALL_STYLES) { // Try all specific names and exemplar location names if (parsedPos < maxPos) { LocalPointer specificMatches(fTimeZoneNames->find(text, startIdx, ALL_SIMPLE_NAME_TYPES, status)); if (U_FAILURE(status)) { pos.setErrorIndex(startIdx); return NULL; } int32_t specificMatchIdx = -1; int32_t matchPos = -1; if (!specificMatches.isNull()) { for (int32_t i = 0; i < specificMatches->size(); i++) { if (startIdx + specificMatches->getMatchLengthAt(i) > matchPos) { specificMatchIdx = i; matchPos = startIdx + specificMatches->getMatchLengthAt(i); } } } if (parsedPos < matchPos) { U_ASSERT(specificMatchIdx >= 0); parsedPos = matchPos; getTimeZoneID(specificMatches.getAlias(), specificMatchIdx, parsedID); parsedTimeType = getTimeType(specificMatches->getNameTypeAt(specificMatchIdx)); parsedOffset = UNKNOWN_OFFSET; } } if (parseTZDBAbbrev && parsedPos < maxPos && (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_SPECIFIC_SHORT]) == 0) { const TZDBTimeZoneNames *tzdbTimeZoneNames = getTZDBTimeZoneNames(status); if (U_SUCCESS(status)) { LocalPointer tzdbNameMatches( tzdbTimeZoneNames->find(text, startIdx, ALL_SIMPLE_NAME_TYPES, status)); if (U_FAILURE(status)) { pos.setErrorIndex(startIdx); return NULL; } int32_t tzdbNameMatchIdx = -1; int32_t matchPos = -1; if (!tzdbNameMatches.isNull()) { for (int32_t i = 0; i < tzdbNameMatches->size(); i++) { if (startIdx + tzdbNameMatches->getMatchLengthAt(i) > matchPos) { tzdbNameMatchIdx = i; matchPos = startIdx + tzdbNameMatches->getMatchLengthAt(i); } } } if (parsedPos < matchPos) { U_ASSERT(tzdbNameMatchIdx >= 0); parsedPos = matchPos; getTimeZoneID(tzdbNameMatches.getAlias(), tzdbNameMatchIdx, parsedID); parsedTimeType = getTimeType(tzdbNameMatches->getNameTypeAt(tzdbNameMatchIdx)); parsedOffset = UNKNOWN_OFFSET; } } } // Try generic names if (parsedPos < maxPos) { int32_t genMatchLen = -1; UTimeZoneFormatTimeType tt = UTZFMT_TIME_TYPE_UNKNOWN; const TimeZoneGenericNames *gnames = getTimeZoneGenericNames(status); if (U_SUCCESS(status)) { genMatchLen = gnames->findBestMatch(text, startIdx, ALL_GENERIC_NAME_TYPES, tzID, tt, status); } if (U_FAILURE(status)) { pos.setErrorIndex(startIdx); return NULL; } if (genMatchLen > 0 && parsedPos < startIdx + genMatchLen) { parsedPos = startIdx + genMatchLen; parsedID.setTo(tzID); parsedTimeType = tt; parsedOffset = UNKNOWN_OFFSET; } } // Try time zone ID if (parsedPos < maxPos && (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_ZONE_ID]) == 0) { tmpPos.setIndex(startIdx); tmpPos.setErrorIndex(-1); parseZoneID(text, tmpPos, tzID); if (tmpPos.getErrorIndex() == -1 && parsedPos < tmpPos.getIndex()) { parsedPos = tmpPos.getIndex(); parsedID.setTo(tzID); parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN; parsedOffset = UNKNOWN_OFFSET; } } // Try short time zone ID if (parsedPos < maxPos && (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_ZONE_ID]) == 0) { tmpPos.setIndex(startIdx); tmpPos.setErrorIndex(-1); parseShortZoneID(text, tmpPos, tzID); if (tmpPos.getErrorIndex() == -1 && parsedPos < tmpPos.getIndex()) { parsedPos = tmpPos.getIndex(); parsedID.setTo(tzID); parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN; parsedOffset = UNKNOWN_OFFSET; } } } if (parsedPos > startIdx) { // Parsed successfully TimeZone* parsedTZ; if (parsedID.length() > 0) { parsedTZ = TimeZone::createTimeZone(parsedID); } else { U_ASSERT(parsedOffset != UNKNOWN_OFFSET); parsedTZ = createTimeZoneForOffset(parsedOffset); } if (timeType) { *timeType = parsedTimeType; } pos.setIndex(parsedPos); return parsedTZ; } pos.setErrorIndex(startIdx); return NULL; } void TimeZoneFormat::parseObject(const UnicodeString& source, Formattable& result, ParsePosition& parse_pos) const { result.adoptObject(parse(UTZFMT_STYLE_GENERIC_LOCATION, source, parse_pos, UTZFMT_PARSE_OPTION_ALL_STYLES)); } // ------------------------------------------------------------------ // Private zone name format/parse implementation UnicodeString& TimeZoneFormat::formatGeneric(const TimeZone& tz, int32_t genType, UDate date, UnicodeString& name) const { UErrorCode status = U_ZERO_ERROR; const TimeZoneGenericNames* gnames = getTimeZoneGenericNames(status); if (U_FAILURE(status)) { name.setToBogus(); return name; } if (genType == UTZGNM_LOCATION) { const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(tz); if (canonicalID == NULL) { name.setToBogus(); return name; } return gnames->getGenericLocationName(UnicodeString(TRUE, canonicalID, -1), name); } return gnames->getDisplayName(tz, (UTimeZoneGenericNameType)genType, date, name); } UnicodeString& TimeZoneFormat::formatSpecific(const TimeZone& tz, UTimeZoneNameType stdType, UTimeZoneNameType dstType, UDate date, UnicodeString& name, UTimeZoneFormatTimeType *timeType) const { if (fTimeZoneNames == NULL) { name.setToBogus(); return name; } UErrorCode status = U_ZERO_ERROR; UBool isDaylight = tz.inDaylightTime(date, status); const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(tz); if (U_FAILURE(status) || canonicalID == NULL) { name.setToBogus(); return name; } if (isDaylight) { fTimeZoneNames->getDisplayName(UnicodeString(TRUE, canonicalID, -1), dstType, date, name); } else { fTimeZoneNames->getDisplayName(UnicodeString(TRUE, canonicalID, -1), stdType, date, name); } if (timeType && !name.isEmpty()) { *timeType = isDaylight ? UTZFMT_TIME_TYPE_DAYLIGHT : UTZFMT_TIME_TYPE_STANDARD; } return name; } const TimeZoneGenericNames* TimeZoneFormat::getTimeZoneGenericNames(UErrorCode& status) const { if (U_FAILURE(status)) { return NULL; } umtx_lock(gLock()); if (fTimeZoneGenericNames == NULL) { TimeZoneFormat *nonConstThis = const_cast(this); nonConstThis->fTimeZoneGenericNames = TimeZoneGenericNames::createInstance(fLocale, status); } umtx_unlock(gLock()); return fTimeZoneGenericNames; } const TZDBTimeZoneNames* TimeZoneFormat::getTZDBTimeZoneNames(UErrorCode& status) const { if (U_FAILURE(status)) { return NULL; } umtx_lock(gLock()); if (fTZDBTimeZoneNames == NULL) { TZDBTimeZoneNames *tzdbNames = new TZDBTimeZoneNames(fLocale); if (tzdbNames == NULL) { status = U_MEMORY_ALLOCATION_ERROR; } else { TimeZoneFormat *nonConstThis = const_cast(this); nonConstThis->fTZDBTimeZoneNames = tzdbNames; } } umtx_unlock(gLock()); return fTZDBTimeZoneNames; } UnicodeString& TimeZoneFormat::formatExemplarLocation(const TimeZone& tz, UnicodeString& name) const { UChar locationBuf[ZONE_NAME_U16_MAX]; UnicodeString location(locationBuf, 0, UPRV_LENGTHOF(locationBuf)); const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(tz); if (canonicalID) { fTimeZoneNames->getExemplarLocationName(UnicodeString(TRUE, canonicalID, -1), location); } if (location.length() > 0) { name.setTo(location); } else { // Use "unknown" location fTimeZoneNames->getExemplarLocationName(UnicodeString(TRUE, UNKNOWN_ZONE_ID, -1), location); if (location.length() > 0) { name.setTo(location); } else { // last resort name.setTo(UNKNOWN_LOCATION, -1); } } return name; } // ------------------------------------------------------------------ // Zone offset format and parse UnicodeString& TimeZoneFormat::formatOffsetISO8601Basic(int32_t offset, UBool useUtcIndicator, UBool isShort, UBool ignoreSeconds, UnicodeString& result, UErrorCode& status) const { return formatOffsetISO8601(offset, TRUE, useUtcIndicator, isShort, ignoreSeconds, result, status); } UnicodeString& TimeZoneFormat::formatOffsetISO8601Extended(int32_t offset, UBool useUtcIndicator, UBool isShort, UBool ignoreSeconds, UnicodeString& result, UErrorCode& status) const { return formatOffsetISO8601(offset, FALSE, useUtcIndicator, isShort, ignoreSeconds, result, status); } UnicodeString& TimeZoneFormat::formatOffsetLocalizedGMT(int32_t offset, UnicodeString& result, UErrorCode& status) const { return formatOffsetLocalizedGMT(offset, FALSE, result, status); } UnicodeString& TimeZoneFormat::formatOffsetShortLocalizedGMT(int32_t offset, UnicodeString& result, UErrorCode& status) const { return formatOffsetLocalizedGMT(offset, TRUE, result, status); } int32_t TimeZoneFormat::parseOffsetISO8601(const UnicodeString& text, ParsePosition& pos) const { return parseOffsetISO8601(text, pos, FALSE); } int32_t TimeZoneFormat::parseOffsetLocalizedGMT(const UnicodeString& text, ParsePosition& pos) const { return parseOffsetLocalizedGMT(text, pos, FALSE, NULL); } int32_t TimeZoneFormat::parseOffsetShortLocalizedGMT(const UnicodeString& text, ParsePosition& pos) const { return parseOffsetLocalizedGMT(text, pos, TRUE, NULL); } // ------------------------------------------------------------------ // Private zone offset format/parse implementation UnicodeString& TimeZoneFormat::formatOffsetISO8601(int32_t offset, UBool isBasic, UBool useUtcIndicator, UBool isShort, UBool ignoreSeconds, UnicodeString& result, UErrorCode& status) const { if (U_FAILURE(status)) { result.setToBogus(); return result; } int32_t absOffset = offset < 0 ? -offset : offset; if (useUtcIndicator && (absOffset < MILLIS_PER_SECOND || (ignoreSeconds && absOffset < MILLIS_PER_MINUTE))) { result.setTo(ISO8601_UTC); return result; } OffsetFields minFields = isShort ? FIELDS_H : FIELDS_HM; OffsetFields maxFields = ignoreSeconds ? FIELDS_HM : FIELDS_HMS; UChar sep = isBasic ? 0 : ISO8601_SEP; // Note: FIELDS_HMS as maxFields is a CLDR/ICU extension. ISO 8601 specification does // not support seconds field. if (absOffset >= MAX_OFFSET) { result.setToBogus(); status = U_ILLEGAL_ARGUMENT_ERROR; return result; } int fields[3]; fields[0] = absOffset / MILLIS_PER_HOUR; absOffset = absOffset % MILLIS_PER_HOUR; fields[1] = absOffset / MILLIS_PER_MINUTE; absOffset = absOffset % MILLIS_PER_MINUTE; fields[2] = absOffset / MILLIS_PER_SECOND; U_ASSERT(fields[0] >= 0 && fields[0] <= MAX_OFFSET_HOUR); U_ASSERT(fields[1] >= 0 && fields[1] <= MAX_OFFSET_MINUTE); U_ASSERT(fields[2] >= 0 && fields[2] <= MAX_OFFSET_SECOND); int32_t lastIdx = maxFields; while (lastIdx > minFields) { if (fields[lastIdx] != 0) { break; } lastIdx--; } UChar sign = PLUS; if (offset < 0) { // if all output fields are 0s, do not use negative sign for (int32_t idx = 0; idx <= lastIdx; idx++) { if (fields[idx] != 0) { sign = MINUS; break; } } } result.setTo(sign); for (int32_t idx = 0; idx <= lastIdx; idx++) { if (sep && idx != 0) { result.append(sep); } result.append((UChar)(0x0030 + fields[idx]/10)); result.append((UChar)(0x0030 + fields[idx]%10)); } return result; } UnicodeString& TimeZoneFormat::formatOffsetLocalizedGMT(int32_t offset, UBool isShort, UnicodeString& result, UErrorCode& status) const { if (U_FAILURE(status)) { result.setToBogus(); return result; } if (offset <= -MAX_OFFSET || offset >= MAX_OFFSET) { result.setToBogus(); status = U_ILLEGAL_ARGUMENT_ERROR; return result; } if (offset == 0) { result.setTo(fGMTZeroFormat); return result; } UBool positive = TRUE; if (offset < 0) { offset = -offset; positive = FALSE; } int32_t offsetH = offset / MILLIS_PER_HOUR; offset = offset % MILLIS_PER_HOUR; int32_t offsetM = offset / MILLIS_PER_MINUTE; offset = offset % MILLIS_PER_MINUTE; int32_t offsetS = offset / MILLIS_PER_SECOND; U_ASSERT(offsetH <= MAX_OFFSET_HOUR && offsetM <= MAX_OFFSET_MINUTE && offsetS <= MAX_OFFSET_SECOND); const UVector* offsetPatternItems = NULL; if (positive) { if (offsetS != 0) { offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_POSITIVE_HMS]; } else if (offsetM != 0 || !isShort) { offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_POSITIVE_HM]; } else { offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_POSITIVE_H]; } } else { if (offsetS != 0) { offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_NEGATIVE_HMS]; } else if (offsetM != 0 || !isShort) { offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_NEGATIVE_HM]; } else { offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_NEGATIVE_H]; } } U_ASSERT(offsetPatternItems != NULL); // Building the GMT format string result.setTo(fGMTPatternPrefix); for (int32_t i = 0; i < offsetPatternItems->size(); i++) { const GMTOffsetField* item = (GMTOffsetField*)offsetPatternItems->elementAt(i); GMTOffsetField::FieldType type = item->getType(); switch (type) { case GMTOffsetField::TEXT: result.append(item->getPatternText(), -1); break; case GMTOffsetField::HOUR: appendOffsetDigits(result, offsetH, (isShort ? 1 : 2)); break; case GMTOffsetField::MINUTE: appendOffsetDigits(result, offsetM, 2); break; case GMTOffsetField::SECOND: appendOffsetDigits(result, offsetS, 2); break; } } result.append(fGMTPatternSuffix); return result; } int32_t TimeZoneFormat::parseOffsetISO8601(const UnicodeString& text, ParsePosition& pos, UBool extendedOnly, UBool* hasDigitOffset /* = NULL */) const { if (hasDigitOffset) { *hasDigitOffset = FALSE; } int32_t start = pos.getIndex(); if (start >= text.length()) { pos.setErrorIndex(start); return 0; } UChar firstChar = text.charAt(start); if (firstChar == ISO8601_UTC || firstChar == (UChar)(ISO8601_UTC + 0x20)) { // "Z" (or "z") - indicates UTC pos.setIndex(start + 1); return 0; } int32_t sign = 1; if (firstChar == PLUS) { sign = 1; } else if (firstChar == MINUS) { sign = -1; } else { // Not an ISO 8601 offset string pos.setErrorIndex(start); return 0; } ParsePosition posOffset(start + 1); int32_t offset = parseAsciiOffsetFields(text, posOffset, ISO8601_SEP, FIELDS_H, FIELDS_HMS); if (posOffset.getErrorIndex() == -1 && !extendedOnly && (posOffset.getIndex() - start <= 3)) { // If the text is successfully parsed as extended format with the options above, it can be also parsed // as basic format. For example, "0230" can be parsed as offset 2:00 (only first digits are valid for // extended format), but it can be parsed as offset 2:30 with basic format. We use longer result. ParsePosition posBasic(start + 1); int32_t tmpOffset = parseAbuttingAsciiOffsetFields(text, posBasic, FIELDS_H, FIELDS_HMS, FALSE); if (posBasic.getErrorIndex() == -1 && posBasic.getIndex() > posOffset.getIndex()) { offset = tmpOffset; posOffset.setIndex(posBasic.getIndex()); } } if (posOffset.getErrorIndex() != -1) { pos.setErrorIndex(start); return 0; } pos.setIndex(posOffset.getIndex()); if (hasDigitOffset) { *hasDigitOffset = TRUE; } return sign * offset; } int32_t TimeZoneFormat::parseOffsetLocalizedGMT(const UnicodeString& text, ParsePosition& pos, UBool isShort, UBool* hasDigitOffset) const { int32_t start = pos.getIndex(); int32_t offset = 0; int32_t parsedLength = 0; if (hasDigitOffset) { *hasDigitOffset = FALSE; } offset = parseOffsetLocalizedGMTPattern(text, start, isShort, parsedLength); // For now, parseOffsetLocalizedGMTPattern handles both long and short // formats, no matter isShort is true or false. This might be changed in future // when strict parsing is necessary, or different set of patterns are used for // short/long formats. #if 0 if (parsedLength == 0) { offset = parseOffsetLocalizedGMTPattern(text, start, !isShort, parsedLength); } #endif if (parsedLength > 0) { if (hasDigitOffset) { *hasDigitOffset = TRUE; } pos.setIndex(start + parsedLength); return offset; } // Try the default patterns offset = parseOffsetDefaultLocalizedGMT(text, start, parsedLength); if (parsedLength > 0) { if (hasDigitOffset) { *hasDigitOffset = TRUE; } pos.setIndex(start + parsedLength); return offset; } // Check if this is a GMT zero format if (text.caseCompare(start, fGMTZeroFormat.length(), fGMTZeroFormat, 0) == 0) { pos.setIndex(start + fGMTZeroFormat.length()); return 0; } // Check if this is a default GMT zero format for (int32_t i = 0; ALT_GMT_STRINGS[i][0] != 0; i++) { const UChar* defGMTZero = ALT_GMT_STRINGS[i]; int32_t defGMTZeroLen = u_strlen(defGMTZero); if (text.caseCompare(start, defGMTZeroLen, defGMTZero, 0) == 0) { pos.setIndex(start + defGMTZeroLen); return 0; } } // Nothing matched pos.setErrorIndex(start); return 0; } int32_t TimeZoneFormat::parseOffsetLocalizedGMTPattern(const UnicodeString& text, int32_t start, UBool /*isShort*/, int32_t& parsedLen) const { int32_t idx = start; int32_t offset = 0; UBool parsed = FALSE; do { // Prefix part int32_t len = fGMTPatternPrefix.length(); if (len > 0 && text.caseCompare(idx, len, fGMTPatternPrefix, 0) != 0) { // prefix match failed break; } idx += len; // Offset part offset = parseOffsetFields(text, idx, FALSE, len); if (len == 0) { // offset field match failed break; } idx += len; len = fGMTPatternSuffix.length(); if (len > 0 && text.caseCompare(idx, len, fGMTPatternSuffix, 0) != 0) { // no suffix match break; } idx += len; parsed = TRUE; } while (FALSE); parsedLen = parsed ? idx - start : 0; return offset; } int32_t TimeZoneFormat::parseOffsetFields(const UnicodeString& text, int32_t start, UBool /*isShort*/, int32_t& parsedLen) const { int32_t outLen = 0; int32_t offset = 0; int32_t sign = 1; parsedLen = 0; int32_t offsetH, offsetM, offsetS; offsetH = offsetM = offsetS = 0; for (int32_t patidx = 0; PARSE_GMT_OFFSET_TYPES[patidx] >= 0; patidx++) { int32_t gmtPatType = PARSE_GMT_OFFSET_TYPES[patidx]; UVector* items = fGMTOffsetPatternItems[gmtPatType]; U_ASSERT(items != NULL); outLen = parseOffsetFieldsWithPattern(text, start, items, FALSE, offsetH, offsetM, offsetS); if (outLen > 0) { sign = (gmtPatType == UTZFMT_PAT_POSITIVE_H || gmtPatType == UTZFMT_PAT_POSITIVE_HM || gmtPatType == UTZFMT_PAT_POSITIVE_HMS) ? 1 : -1; break; } } if (outLen > 0 && fAbuttingOffsetHoursAndMinutes) { // When hours field is sabutting minutes field, // the parse result above may not be appropriate. // For example, "01020" is parsed as 01:02: above, // but it should be parsed as 00:10:20. int32_t tmpLen = 0; int32_t tmpSign = 1; int32_t tmpH = 0; int32_t tmpM = 0; int32_t tmpS = 0; for (int32_t patidx = 0; PARSE_GMT_OFFSET_TYPES[patidx] >= 0; patidx++) { int32_t gmtPatType = PARSE_GMT_OFFSET_TYPES[patidx]; UVector* items = fGMTOffsetPatternItems[gmtPatType]; U_ASSERT(items != NULL); // forcing parse to use single hour digit tmpLen = parseOffsetFieldsWithPattern(text, start, items, TRUE, tmpH, tmpM, tmpS); if (tmpLen > 0) { tmpSign = (gmtPatType == UTZFMT_PAT_POSITIVE_H || gmtPatType == UTZFMT_PAT_POSITIVE_HM || gmtPatType == UTZFMT_PAT_POSITIVE_HMS) ? 1 : -1; break; } } if (tmpLen > outLen) { // Better parse result with single hour digit outLen = tmpLen; sign = tmpSign; offsetH = tmpH; offsetM = tmpM; offsetS = tmpS; } } if (outLen > 0) { offset = ((((offsetH * 60) + offsetM) * 60) + offsetS) * 1000 * sign; parsedLen = outLen; } return offset; } int32_t TimeZoneFormat::parseOffsetFieldsWithPattern(const UnicodeString& text, int32_t start, UVector* patternItems, UBool forceSingleHourDigit, int32_t& hour, int32_t& min, int32_t& sec) const { UBool failed = FALSE; int32_t offsetH, offsetM, offsetS; offsetH = offsetM = offsetS = 0; int32_t idx = start; for (int32_t i = 0; i < patternItems->size(); i++) { int32_t len = 0; const GMTOffsetField* field = (const GMTOffsetField*)patternItems->elementAt(i); GMTOffsetField::FieldType fieldType = field->getType(); if (fieldType == GMTOffsetField::TEXT) { const UChar* patStr = field->getPatternText(); len = u_strlen(patStr); if (i == 0) { // When TimeZoneFormat parse() is called from SimpleDateFormat, // leading space characters might be truncated. If the first pattern text // starts with such character (e.g. Bidi control), then we need to // skip the leading space charcters. if (idx < text.length() && !PatternProps::isWhiteSpace(text.char32At(idx))) { while (len > 0) { UChar32 ch; int32_t chLen; U16_GET(patStr, 0, 0, len, ch) if (PatternProps::isWhiteSpace(ch)) { chLen = U16_LENGTH(ch); len -= chLen; patStr += chLen; } else { break; } } } } if (text.caseCompare(idx, len, patStr, 0) != 0) { failed = TRUE; break; } idx += len; } else { if (fieldType == GMTOffsetField::HOUR) { uint8_t maxDigits = forceSingleHourDigit ? 1 : 2; offsetH = parseOffsetFieldWithLocalizedDigits(text, idx, 1, maxDigits, 0, MAX_OFFSET_HOUR, len); } else if (fieldType == GMTOffsetField::MINUTE) { offsetM = parseOffsetFieldWithLocalizedDigits(text, idx, 2, 2, 0, MAX_OFFSET_MINUTE, len); } else if (fieldType == GMTOffsetField::SECOND) { offsetS = parseOffsetFieldWithLocalizedDigits(text, idx, 2, 2, 0, MAX_OFFSET_SECOND, len); } if (len == 0) { failed = TRUE; break; } idx += len; } } if (failed) { hour = min = sec = 0; return 0; } hour = offsetH; min = offsetM; sec = offsetS; return idx - start; } int32_t TimeZoneFormat::parseAbuttingOffsetFields(const UnicodeString& text, int32_t start, int32_t& parsedLen) const { int32_t digits[MAX_OFFSET_DIGITS]; int32_t parsed[MAX_OFFSET_DIGITS]; // accumulative offsets // Parse digits into int[] int32_t idx = start; int32_t len = 0; int32_t numDigits = 0; for (int32_t i = 0; i < MAX_OFFSET_DIGITS; i++) { digits[i] = parseSingleLocalizedDigit(text, idx, len); if (digits[i] < 0) { break; } idx += len; parsed[i] = idx - start; numDigits++; } if (numDigits == 0) { parsedLen = 0; return 0; } int32_t offset = 0; while (numDigits > 0) { int32_t hour = 0; int32_t min = 0; int32_t sec = 0; U_ASSERT(numDigits > 0 && numDigits <= MAX_OFFSET_DIGITS); switch (numDigits) { case 1: // H hour = digits[0]; break; case 2: // HH hour = digits[0] * 10 + digits[1]; break; case 3: // Hmm hour = digits[0]; min = digits[1] * 10 + digits[2]; break; case 4: // HHmm hour = digits[0] * 10 + digits[1]; min = digits[2] * 10 + digits[3]; break; case 5: // Hmmss hour = digits[0]; min = digits[1] * 10 + digits[2]; sec = digits[3] * 10 + digits[4]; break; case 6: // HHmmss hour = digits[0] * 10 + digits[1]; min = digits[2] * 10 + digits[3]; sec = digits[4] * 10 + digits[5]; break; } if (hour <= MAX_OFFSET_HOUR && min <= MAX_OFFSET_MINUTE && sec <= MAX_OFFSET_SECOND) { // found a valid combination offset = hour * MILLIS_PER_HOUR + min * MILLIS_PER_MINUTE + sec * MILLIS_PER_SECOND; parsedLen = parsed[numDigits - 1]; break; } numDigits--; } return offset; } int32_t TimeZoneFormat::parseOffsetDefaultLocalizedGMT(const UnicodeString& text, int start, int32_t& parsedLen) const { int32_t idx = start; int32_t offset = 0; int32_t parsed = 0; do { // check global default GMT alternatives int32_t gmtLen = 0; for (int32_t i = 0; ALT_GMT_STRINGS[i][0] != 0; i++) { const UChar* gmt = ALT_GMT_STRINGS[i]; int32_t len = u_strlen(gmt); if (text.caseCompare(start, len, gmt, 0) == 0) { gmtLen = len; break; } } if (gmtLen == 0) { break; } idx += gmtLen; // offset needs a sign char and a digit at minimum if (idx + 1 >= text.length()) { break; } // parse sign int32_t sign = 1; UChar c = text.charAt(idx); if (c == PLUS) { sign = 1; } else if (c == MINUS) { sign = -1; } else { break; } idx++; // offset part // try the default pattern with the separator first int32_t lenWithSep = 0; int32_t offsetWithSep = parseDefaultOffsetFields(text, idx, DEFAULT_GMT_OFFSET_SEP, lenWithSep); if (lenWithSep == text.length() - idx) { // maximum match offset = offsetWithSep * sign; idx += lenWithSep; } else { // try abutting field pattern int32_t lenAbut = 0; int32_t offsetAbut = parseAbuttingOffsetFields(text, idx, lenAbut); if (lenWithSep > lenAbut) { offset = offsetWithSep * sign; idx += lenWithSep; } else { offset = offsetAbut * sign; idx += lenAbut; } } parsed = idx - start; } while (false); parsedLen = parsed; return offset; } int32_t TimeZoneFormat::parseDefaultOffsetFields(const UnicodeString& text, int32_t start, UChar separator, int32_t& parsedLen) const { int32_t max = text.length(); int32_t idx = start; int32_t len = 0; int32_t hour = 0, min = 0, sec = 0; parsedLen = 0; do { hour = parseOffsetFieldWithLocalizedDigits(text, idx, 1, 2, 0, MAX_OFFSET_HOUR, len); if (len == 0) { break; } idx += len; if (idx + 1 < max && text.charAt(idx) == separator) { min = parseOffsetFieldWithLocalizedDigits(text, idx + 1, 2, 2, 0, MAX_OFFSET_MINUTE, len); if (len == 0) { break; } idx += (1 + len); if (idx + 1 < max && text.charAt(idx) == separator) { sec = parseOffsetFieldWithLocalizedDigits(text, idx + 1, 2, 2, 0, MAX_OFFSET_SECOND, len); if (len == 0) { break; } idx += (1 + len); } } } while (FALSE); if (idx == start) { return 0; } parsedLen = idx - start; return hour * MILLIS_PER_HOUR + min * MILLIS_PER_MINUTE + sec * MILLIS_PER_SECOND; } int32_t TimeZoneFormat::parseOffsetFieldWithLocalizedDigits(const UnicodeString& text, int32_t start, uint8_t minDigits, uint8_t maxDigits, uint16_t minVal, uint16_t maxVal, int32_t& parsedLen) const { parsedLen = 0; int32_t decVal = 0; int32_t numDigits = 0; int32_t idx = start; int32_t digitLen = 0; while (idx < text.length() && numDigits < maxDigits) { int32_t digit = parseSingleLocalizedDigit(text, idx, digitLen); if (digit < 0) { break; } int32_t tmpVal = decVal * 10 + digit; if (tmpVal > maxVal) { break; } decVal = tmpVal; numDigits++; idx += digitLen; } // Note: maxVal is checked in the while loop if (numDigits < minDigits || decVal < minVal) { decVal = -1; numDigits = 0; } else { parsedLen = idx - start; } return decVal; } int32_t TimeZoneFormat::parseSingleLocalizedDigit(const UnicodeString& text, int32_t start, int32_t& len) const { int32_t digit = -1; len = 0; if (start < text.length()) { UChar32 cp = text.char32At(start); // First, try digits configured for this instance for (int32_t i = 0; i < 10; i++) { if (cp == fGMTOffsetDigits[i]) { digit = i; break; } } // If failed, check if this is a Unicode digit if (digit < 0) { int32_t tmp = u_charDigitValue(cp); digit = (tmp >= 0 && tmp <= 9) ? tmp : -1; } if (digit >= 0) { int32_t next = text.moveIndex32(start, 1); len = next - start; } } return digit; } UnicodeString& TimeZoneFormat::formatOffsetWithAsciiDigits(int32_t offset, UChar sep, OffsetFields minFields, OffsetFields maxFields, UnicodeString& result) { U_ASSERT(maxFields >= minFields); U_ASSERT(offset > -MAX_OFFSET && offset < MAX_OFFSET); UChar sign = PLUS; if (offset < 0) { sign = MINUS; offset = -offset; } result.setTo(sign); int fields[3]; fields[0] = offset / MILLIS_PER_HOUR; offset = offset % MILLIS_PER_HOUR; fields[1] = offset / MILLIS_PER_MINUTE; offset = offset % MILLIS_PER_MINUTE; fields[2] = offset / MILLIS_PER_SECOND; U_ASSERT(fields[0] >= 0 && fields[0] <= MAX_OFFSET_HOUR); U_ASSERT(fields[1] >= 0 && fields[1] <= MAX_OFFSET_MINUTE); U_ASSERT(fields[2] >= 0 && fields[2] <= MAX_OFFSET_SECOND); int32_t lastIdx = maxFields; while (lastIdx > minFields) { if (fields[lastIdx] != 0) { break; } lastIdx--; } for (int32_t idx = 0; idx <= lastIdx; idx++) { if (sep && idx != 0) { result.append(sep); } result.append((UChar)(0x0030 + fields[idx]/10)); result.append((UChar)(0x0030 + fields[idx]%10)); } return result; } int32_t TimeZoneFormat::parseAbuttingAsciiOffsetFields(const UnicodeString& text, ParsePosition& pos, OffsetFields minFields, OffsetFields maxFields, UBool fixedHourWidth) { int32_t start = pos.getIndex(); int32_t minDigits = 2 * (minFields + 1) - (fixedHourWidth ? 0 : 1); int32_t maxDigits = 2 * (maxFields + 1); U_ASSERT(maxDigits <= MAX_OFFSET_DIGITS); int32_t digits[MAX_OFFSET_DIGITS] = {}; int32_t numDigits = 0; int32_t idx = start; while (numDigits < maxDigits && idx < text.length()) { UChar uch = text.charAt(idx); int32_t digit = DIGIT_VAL(uch); if (digit < 0) { break; } digits[numDigits] = digit; numDigits++; idx++; } if (fixedHourWidth && (numDigits & 1)) { // Fixed digits, so the number of digits must be even number. Truncating. numDigits--; } if (numDigits < minDigits) { pos.setErrorIndex(start); return 0; } int32_t hour = 0, min = 0, sec = 0; UBool bParsed = FALSE; while (numDigits >= minDigits) { switch (numDigits) { case 1: //H hour = digits[0]; break; case 2: //HH hour = digits[0] * 10 + digits[1]; break; case 3: //Hmm hour = digits[0]; min = digits[1] * 10 + digits[2]; break; case 4: //HHmm hour = digits[0] * 10 + digits[1]; min = digits[2] * 10 + digits[3]; break; case 5: //Hmmss hour = digits[0]; min = digits[1] * 10 + digits[2]; sec = digits[3] * 10 + digits[4]; break; case 6: //HHmmss hour = digits[0] * 10 + digits[1]; min = digits[2] * 10 + digits[3]; sec = digits[4] * 10 + digits[5]; break; } if (hour <= MAX_OFFSET_HOUR && min <= MAX_OFFSET_MINUTE && sec <= MAX_OFFSET_SECOND) { // Successfully parsed bParsed = true; break; } // Truncating numDigits -= (fixedHourWidth ? 2 : 1); hour = min = sec = 0; } if (!bParsed) { pos.setErrorIndex(start); return 0; } pos.setIndex(start + numDigits); return ((((hour * 60) + min) * 60) + sec) * 1000; } int32_t TimeZoneFormat::parseAsciiOffsetFields(const UnicodeString& text, ParsePosition& pos, UChar sep, OffsetFields minFields, OffsetFields maxFields) { int32_t start = pos.getIndex(); int32_t fieldVal[] = {0, 0, 0}; int32_t fieldLen[] = {0, -1, -1}; for (int32_t idx = start, fieldIdx = 0; idx < text.length() && fieldIdx <= maxFields; idx++) { UChar c = text.charAt(idx); if (c == sep) { if (fieldIdx == 0) { if (fieldLen[0] == 0) { // no hours field break; } // 1 digit hour, move to next field } else { if (fieldLen[fieldIdx] != -1) { // premature minute or seconds field break; } fieldLen[fieldIdx] = 0; } continue; } else if (fieldLen[fieldIdx] == -1) { // no separator after 2 digit field break; } int32_t digit = DIGIT_VAL(c); if (digit < 0) { // not a digit break; } fieldVal[fieldIdx] = fieldVal[fieldIdx] * 10 + digit; fieldLen[fieldIdx]++; if (fieldLen[fieldIdx] >= 2) { // parsed 2 digits, move to next field fieldIdx++; } } int32_t offset = 0; int32_t parsedLen = 0; int32_t parsedFields = -1; do { // hour if (fieldLen[0] == 0) { break; } if (fieldVal[0] > MAX_OFFSET_HOUR) { offset = (fieldVal[0] / 10) * MILLIS_PER_HOUR; parsedFields = FIELDS_H; parsedLen = 1; break; } offset = fieldVal[0] * MILLIS_PER_HOUR; parsedLen = fieldLen[0]; parsedFields = FIELDS_H; // minute if (fieldLen[1] != 2 || fieldVal[1] > MAX_OFFSET_MINUTE) { break; } offset += fieldVal[1] * MILLIS_PER_MINUTE; parsedLen += (1 + fieldLen[1]); parsedFields = FIELDS_HM; // second if (fieldLen[2] != 2 || fieldVal[2] > MAX_OFFSET_SECOND) { break; } offset += fieldVal[2] * MILLIS_PER_SECOND; parsedLen += (1 + fieldLen[2]); parsedFields = FIELDS_HMS; } while (false); if (parsedFields < minFields) { pos.setErrorIndex(start); return 0; } pos.setIndex(start + parsedLen); return offset; } void TimeZoneFormat::appendOffsetDigits(UnicodeString& buf, int32_t n, uint8_t minDigits) const { U_ASSERT(n >= 0 && n < 60); int32_t numDigits = n >= 10 ? 2 : 1; for (int32_t i = 0; i < minDigits - numDigits; i++) { buf.append(fGMTOffsetDigits[0]); } if (numDigits == 2) { buf.append(fGMTOffsetDigits[n / 10]); } buf.append(fGMTOffsetDigits[n % 10]); } // ------------------------------------------------------------------ // Private misc void TimeZoneFormat::initGMTPattern(const UnicodeString& gmtPattern, UErrorCode& status) { if (U_FAILURE(status)) { return; } // This implementation not perfect, but sufficient practically. int32_t idx = gmtPattern.indexOf(ARG0, ARG0_LEN, 0); if (idx < 0) { status = U_ILLEGAL_ARGUMENT_ERROR; return; } fGMTPattern.setTo(gmtPattern); unquote(gmtPattern.tempSubString(0, idx), fGMTPatternPrefix); unquote(gmtPattern.tempSubString(idx + ARG0_LEN), fGMTPatternSuffix); } UnicodeString& TimeZoneFormat::unquote(const UnicodeString& pattern, UnicodeString& result) { if (pattern.indexOf(SINGLEQUOTE) < 0) { result.setTo(pattern); return result; } result.remove(); UBool isPrevQuote = FALSE; UBool inQuote = FALSE; for (int32_t i = 0; i < pattern.length(); i++) { UChar c = pattern.charAt(i); if (c == SINGLEQUOTE) { if (isPrevQuote) { result.append(c); isPrevQuote = FALSE; } else { isPrevQuote = TRUE; } inQuote = !inQuote; } else { isPrevQuote = FALSE; result.append(c); } } return result; } UVector* TimeZoneFormat::parseOffsetPattern(const UnicodeString& pattern, OffsetFields required, UErrorCode& status) { if (U_FAILURE(status)) { return NULL; } UVector* result = new UVector(deleteGMTOffsetField, NULL, status); if (result == NULL) { status = U_MEMORY_ALLOCATION_ERROR; return NULL; } int32_t checkBits = 0; UBool isPrevQuote = FALSE; UBool inQuote = FALSE; UChar textBuf[32]; UnicodeString text(textBuf, 0, UPRV_LENGTHOF(textBuf)); GMTOffsetField::FieldType itemType = GMTOffsetField::TEXT; int32_t itemLength = 1; for (int32_t i = 0; i < pattern.length(); i++) { UChar ch = pattern.charAt(i); if (ch == SINGLEQUOTE) { if (isPrevQuote) { text.append(SINGLEQUOTE); isPrevQuote = FALSE; } else { isPrevQuote = TRUE; if (itemType != GMTOffsetField::TEXT) { if (GMTOffsetField::isValid(itemType, itemLength)) { GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, static_cast(itemLength), status); result->addElement(fld, status); if (U_FAILURE(status)) { break; } } else { status = U_ILLEGAL_ARGUMENT_ERROR; break; } itemType = GMTOffsetField::TEXT; } } inQuote = !inQuote; } else { isPrevQuote = FALSE; if (inQuote) { text.append(ch); } else { GMTOffsetField::FieldType tmpType = GMTOffsetField::getTypeByLetter(ch); if (tmpType != GMTOffsetField::TEXT) { // an offset time pattern character if (tmpType == itemType) { itemLength++; } else { if (itemType == GMTOffsetField::TEXT) { if (text.length() > 0) { GMTOffsetField* textfld = GMTOffsetField::createText(text, status); result->addElement(textfld, status); if (U_FAILURE(status)) { break; } text.remove(); } } else { if (GMTOffsetField::isValid(itemType, itemLength)) { GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, static_cast(itemLength), status); result->addElement(fld, status); if (U_FAILURE(status)) { break; } } else { status = U_ILLEGAL_ARGUMENT_ERROR; break; } } itemType = tmpType; itemLength = 1; checkBits |= tmpType; } } else { // a string literal if (itemType != GMTOffsetField::TEXT) { if (GMTOffsetField::isValid(itemType, itemLength)) { GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, static_cast(itemLength), status); result->addElement(fld, status); if (U_FAILURE(status)) { break; } } else { status = U_ILLEGAL_ARGUMENT_ERROR; break; } itemType = GMTOffsetField::TEXT; } text.append(ch); } } } } // handle last item if (U_SUCCESS(status)) { if (itemType == GMTOffsetField::TEXT) { if (text.length() > 0) { GMTOffsetField* tfld = GMTOffsetField::createText(text, status); result->addElement(tfld, status); } } else { if (GMTOffsetField::isValid(itemType, itemLength)) { GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, static_cast(itemLength), status); result->addElement(fld, status); } else { status = U_ILLEGAL_ARGUMENT_ERROR; } } // Check all required fields are set if (U_SUCCESS(status)) { int32_t reqBits = 0; switch (required) { case FIELDS_H: reqBits = GMTOffsetField::HOUR; break; case FIELDS_HM: reqBits = GMTOffsetField::HOUR | GMTOffsetField::MINUTE; break; case FIELDS_HMS: reqBits = GMTOffsetField::HOUR | GMTOffsetField::MINUTE | GMTOffsetField::SECOND; break; } if (checkBits == reqBits) { // all required fields are set, no extra fields return result; } } } // error delete result; return NULL; } UnicodeString& TimeZoneFormat::expandOffsetPattern(const UnicodeString& offsetHM, UnicodeString& result, UErrorCode& status) { result.setToBogus(); if (U_FAILURE(status)) { return result; } U_ASSERT(u_strlen(DEFAULT_GMT_OFFSET_MINUTE_PATTERN) == 2); int32_t idx_mm = offsetHM.indexOf(DEFAULT_GMT_OFFSET_MINUTE_PATTERN, 2, 0); if (idx_mm < 0) { // Bad time zone hour pattern data status = U_ILLEGAL_ARGUMENT_ERROR; return result; } UnicodeString sep; int32_t idx_H = offsetHM.tempSubString(0, idx_mm).lastIndexOf((UChar)0x0048 /* H */); if (idx_H >= 0) { sep = offsetHM.tempSubString(idx_H + 1, idx_mm - (idx_H + 1)); } result.setTo(offsetHM.tempSubString(0, idx_mm + 2)); result.append(sep); result.append(DEFAULT_GMT_OFFSET_SECOND_PATTERN, -1); result.append(offsetHM.tempSubString(idx_mm + 2)); return result; } UnicodeString& TimeZoneFormat::truncateOffsetPattern(const UnicodeString& offsetHM, UnicodeString& result, UErrorCode& status) { result.setToBogus(); if (U_FAILURE(status)) { return result; } U_ASSERT(u_strlen(DEFAULT_GMT_OFFSET_MINUTE_PATTERN) == 2); int32_t idx_mm = offsetHM.indexOf(DEFAULT_GMT_OFFSET_MINUTE_PATTERN, 2, 0); if (idx_mm < 0) { // Bad time zone hour pattern data status = U_ILLEGAL_ARGUMENT_ERROR; return result; } UChar HH[] = {0x0048, 0x0048}; int32_t idx_HH = offsetHM.tempSubString(0, idx_mm).lastIndexOf(HH, 2, 0); if (idx_HH >= 0) { return result.setTo(offsetHM.tempSubString(0, idx_HH + 2)); } int32_t idx_H = offsetHM.tempSubString(0, idx_mm).lastIndexOf((UChar)0x0048, 0); if (idx_H >= 0) { return result.setTo(offsetHM.tempSubString(0, idx_H + 1)); } // Bad time zone hour pattern data status = U_ILLEGAL_ARGUMENT_ERROR; return result; } void TimeZoneFormat::initGMTOffsetPatterns(UErrorCode& status) { for (int32_t type = 0; type < UTZFMT_PAT_COUNT; type++) { switch (type) { case UTZFMT_PAT_POSITIVE_H: case UTZFMT_PAT_NEGATIVE_H: fGMTOffsetPatternItems[type] = parseOffsetPattern(fGMTOffsetPatterns[type], FIELDS_H, status); break; case UTZFMT_PAT_POSITIVE_HM: case UTZFMT_PAT_NEGATIVE_HM: fGMTOffsetPatternItems[type] = parseOffsetPattern(fGMTOffsetPatterns[type], FIELDS_HM, status); break; case UTZFMT_PAT_POSITIVE_HMS: case UTZFMT_PAT_NEGATIVE_HMS: fGMTOffsetPatternItems[type] = parseOffsetPattern(fGMTOffsetPatterns[type], FIELDS_HMS, status); break; } } checkAbuttingHoursAndMinutes(); } void TimeZoneFormat::checkAbuttingHoursAndMinutes() { fAbuttingOffsetHoursAndMinutes= FALSE; for (int32_t type = 0; type < UTZFMT_PAT_COUNT; type++) { UBool afterH = FALSE; UVector *items = fGMTOffsetPatternItems[type]; for (int32_t i = 0; i < items->size(); i++) { const GMTOffsetField* item = (GMTOffsetField*)items->elementAt(i); GMTOffsetField::FieldType fieldType = item->getType(); if (fieldType != GMTOffsetField::TEXT) { if (afterH) { fAbuttingOffsetHoursAndMinutes = TRUE; break; } else if (fieldType == GMTOffsetField::HOUR) { afterH = TRUE; } } else if (afterH) { break; } } if (fAbuttingOffsetHoursAndMinutes) { break; } } } UBool TimeZoneFormat::toCodePoints(const UnicodeString& str, UChar32* codeArray, int32_t size) { int32_t count = str.countChar32(); if (count != size) { return FALSE; } for (int32_t idx = 0, start = 0; idx < size; idx++) { codeArray[idx] = str.char32At(start); start = str.moveIndex32(start, 1); } return TRUE; } TimeZone* TimeZoneFormat::createTimeZoneForOffset(int32_t offset) const { if (offset == 0) { // when offset is 0, we should use "Etc/GMT" return TimeZone::createTimeZone(UnicodeString(TRUE, TZID_GMT, -1)); } return ZoneMeta::createCustomTimeZone(offset); } UTimeZoneFormatTimeType TimeZoneFormat::getTimeType(UTimeZoneNameType nameType) { switch (nameType) { case UTZNM_LONG_STANDARD: case UTZNM_SHORT_STANDARD: return UTZFMT_TIME_TYPE_STANDARD; case UTZNM_LONG_DAYLIGHT: case UTZNM_SHORT_DAYLIGHT: return UTZFMT_TIME_TYPE_DAYLIGHT; default: return UTZFMT_TIME_TYPE_UNKNOWN; } } UnicodeString& TimeZoneFormat::getTimeZoneID(const TimeZoneNames::MatchInfoCollection* matches, int32_t idx, UnicodeString& tzID) const { if (!matches->getTimeZoneIDAt(idx, tzID)) { UChar mzIDBuf[32]; UnicodeString mzID(mzIDBuf, 0, UPRV_LENGTHOF(mzIDBuf)); if (matches->getMetaZoneIDAt(idx, mzID)) { fTimeZoneNames->getReferenceZoneID(mzID, fTargetRegion, tzID); } } return tzID; } class ZoneIdMatchHandler : public TextTrieMapSearchResultHandler { public: ZoneIdMatchHandler(); virtual ~ZoneIdMatchHandler(); UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status); const UChar* getID(); int32_t getMatchLen(); private: int32_t fLen; const UChar* fID; }; ZoneIdMatchHandler::ZoneIdMatchHandler() : fLen(0), fID(NULL) { } ZoneIdMatchHandler::~ZoneIdMatchHandler() { } UBool ZoneIdMatchHandler::handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status) { if (U_FAILURE(status)) { return FALSE; } if (node->hasValues()) { const UChar* id = (const UChar*)node->getValue(0); if (id != NULL) { if (fLen < matchLength) { fID = id; fLen = matchLength; } } } return TRUE; } const UChar* ZoneIdMatchHandler::getID() { return fID; } int32_t ZoneIdMatchHandler::getMatchLen() { return fLen; } static void U_CALLCONV initZoneIdTrie(UErrorCode &status) { U_ASSERT(gZoneIdTrie == NULL); ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONEFORMAT, tzfmt_cleanup); gZoneIdTrie = new TextTrieMap(TRUE, NULL); // No deleter, because values are pooled by ZoneMeta if (gZoneIdTrie == NULL) { status = U_MEMORY_ALLOCATION_ERROR; return; } StringEnumeration *tzenum = TimeZone::createEnumeration(); const UnicodeString *id; while ((id = tzenum->snext(status)) != NULL) { const UChar* uid = ZoneMeta::findTimeZoneID(*id); if (uid) { gZoneIdTrie->put(uid, const_cast(uid), status); } } delete tzenum; } UnicodeString& TimeZoneFormat::parseZoneID(const UnicodeString& text, ParsePosition& pos, UnicodeString& tzID) const { UErrorCode status = U_ZERO_ERROR; umtx_initOnce(gZoneIdTrieInitOnce, &initZoneIdTrie, status); int32_t start = pos.getIndex(); int32_t len = 0; tzID.setToBogus(); if (U_SUCCESS(status)) { LocalPointer handler(new ZoneIdMatchHandler()); gZoneIdTrie->search(text, start, handler.getAlias(), status); len = handler->getMatchLen(); if (len > 0) { tzID.setTo(handler->getID(), -1); } } if (len > 0) { pos.setIndex(start + len); } else { pos.setErrorIndex(start); } return tzID; } static void U_CALLCONV initShortZoneIdTrie(UErrorCode &status) { U_ASSERT(gShortZoneIdTrie == NULL); ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONEFORMAT, tzfmt_cleanup); StringEnumeration *tzenum = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL, NULL, NULL, status); if (U_SUCCESS(status)) { gShortZoneIdTrie = new TextTrieMap(TRUE, NULL); // No deleter, because values are pooled by ZoneMeta if (gShortZoneIdTrie == NULL) { status = U_MEMORY_ALLOCATION_ERROR; } else { const UnicodeString *id; while ((id = tzenum->snext(status)) != NULL) { const UChar* uID = ZoneMeta::findTimeZoneID(*id); const UChar* shortID = ZoneMeta::getShortID(*id); if (shortID && uID) { gShortZoneIdTrie->put(shortID, const_cast(uID), status); } } } } delete tzenum; } UnicodeString& TimeZoneFormat::parseShortZoneID(const UnicodeString& text, ParsePosition& pos, UnicodeString& tzID) const { UErrorCode status = U_ZERO_ERROR; umtx_initOnce(gShortZoneIdTrieInitOnce, &initShortZoneIdTrie, status); int32_t start = pos.getIndex(); int32_t len = 0; tzID.setToBogus(); if (U_SUCCESS(status)) { LocalPointer handler(new ZoneIdMatchHandler()); gShortZoneIdTrie->search(text, start, handler.getAlias(), status); len = handler->getMatchLen(); if (len > 0) { tzID.setTo(handler->getID(), -1); } } if (len > 0) { pos.setIndex(start + len); } else { pos.setErrorIndex(start); } return tzID; } UnicodeString& TimeZoneFormat::parseExemplarLocation(const UnicodeString& text, ParsePosition& pos, UnicodeString& tzID) const { int32_t startIdx = pos.getIndex(); int32_t parsedPos = -1; tzID.setToBogus(); UErrorCode status = U_ZERO_ERROR; LocalPointer exemplarMatches(fTimeZoneNames->find(text, startIdx, UTZNM_EXEMPLAR_LOCATION, status)); if (U_FAILURE(status)) { pos.setErrorIndex(startIdx); return tzID; } int32_t matchIdx = -1; if (!exemplarMatches.isNull()) { for (int32_t i = 0; i < exemplarMatches->size(); i++) { if (startIdx + exemplarMatches->getMatchLengthAt(i) > parsedPos) { matchIdx = i; parsedPos = startIdx + exemplarMatches->getMatchLengthAt(i); } } if (parsedPos > 0) { pos.setIndex(parsedPos); getTimeZoneID(exemplarMatches.getAlias(), matchIdx, tzID); } } if (tzID.length() == 0) { pos.setErrorIndex(startIdx); } return tzID; } U_NAMESPACE_END #endif