--- /dev/null
+/*
+*******************************************************************************
+* Copyright (C) 2011-2012, 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/uchar.h"
+#include "unicode/udat.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"
+
+U_NAMESPACE_BEGIN
+
+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 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, 0x0048, 0x003A, 0x006D, 0x006D, 0}; // +HH:mm
+static const UChar DEFAULT_GMT_POSITIVE_HMS[] = {0x002B, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0}; // +HH:mm:ss
+static const UChar DEFAULT_GMT_NEGATIVE_HM[] = {0x002D, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0}; // -HH:mm
+static const UChar DEFAULT_GMT_NEGATIVE_HMS[] = {0x002D, 0x0048, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0}; // -HH:mm:ss
+
+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 int 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,
+ -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_SPECIFIC_NAME_TYPES = UTZNM_LONG_STANDARD | UTZNM_LONG_DAYLIGHT | UTZNM_SHORT_STANDARD | UTZNM_SHORT_DAYLIGHT;
+static const int32_t ALL_GENERIC_NAME_TYPES = UTZGNM_LOCATION | UTZGNM_LONG | UTZGNM_SHORT;
+
+#define STYLE_FLAG(c) (1 << (c))
+#define DIGIT_VAL(c) (0x0030 <= (c) && (c) <= 0x0039 ? (c) - 0x0030 : -1)
+#define MAX_OFFSET_DIGITS 6
+
+
+// ------------------------------------------------------------------
+// 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:
+ U_ASSERT(FALSE);
+ }
+ 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<GMTOffsetField *>(obj);
+}
+U_CDECL_END
+
+
+// ------------------------------------------------------------------
+// TimeZoneFormat
+// ------------------------------------------------------------------
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TimeZoneFormat)
+
+TimeZoneFormat::TimeZoneFormat(const Locale& locale, UErrorCode& status)
+: fLock(NULL),fLocale(locale), fTimeZoneNames(NULL), fTimeZoneGenericNames(NULL), fDefParseOptionFlags(0) {
+
+ for (int32_t i = 0; i <= UTZFMT_PAT_NEGATIVE_HMS; i++) {
+ fGMTOffsetPatternItems[i] = NULL;
+ }
+
+ const char* region = fLocale.getCountry();
+ int32_t regionLen = 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
+
+ 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(gmtPattern, -1), status);
+
+ UBool useDefHourFmt = TRUE;
+ if (hourFormats) {
+ UChar *sep = u_strchr(hourFormats, (UChar)0x003B /* ';' */);
+ if (sep != NULL) {
+ 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]);
+ expandOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HMS]);
+ useDefHourFmt = FALSE;
+ }
+ }
+ if (useDefHourFmt) {
+ 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_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) {
+
+ for (int32_t i = 0; i <= UTZFMT_PAT_NEGATIVE_HMS; i++) {
+ fGMTOffsetPatternItems[i] = NULL;
+ }
+ *this = other;
+}
+
+
+TimeZoneFormat::~TimeZoneFormat() {
+ delete fTimeZoneNames;
+ delete fTimeZoneGenericNames;
+ for (int32_t i = 0; i <= UTZFMT_PAT_NEGATIVE_HMS; i++) {
+ delete fGMTOffsetPatternItems[i];
+ }
+ umtx_destroy(&fLock);
+}
+
+TimeZoneFormat&
+TimeZoneFormat::operator=(const TimeZoneFormat& other) {
+ if (this == &other) {
+ return *this;
+ }
+
+ delete fTimeZoneNames;
+ delete fTimeZoneGenericNames;
+ fTimeZoneGenericNames = NULL;
+
+ fLocale = other.fLocale;
+ uprv_memcpy(fTargetRegion, other.fTargetRegion, sizeof(fTargetRegion));
+
+ fTimeZoneNames = other.fTimeZoneNames->clone();
+ if (other.fTimeZoneGenericNames) {
+ 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_NEGATIVE_HMS; i++) {
+ fGMTOffsetPatterns[i] = other.fGMTOffsetPatterns[i];
+ delete fGMTOffsetPatternItems[i];
+ }
+ 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_NEGATIVE_HMS && 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(int32_t flags) {
+ fDefParseOptionFlags = flags;
+}
+
+int32_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 = (type == UTZFMT_PAT_POSITIVE_HMS || type == UTZFMT_PAT_NEGATIVE_HMS) ? FIELDS_HMS : FIELDS_HM;
+
+ UVector* patternItems = parseOffsetPattern(pattern, required, status);
+ if (patternItems == NULL) {
+ return;
+ }
+
+ fGMTOffsetPatterns[type].setTo(pattern);
+ delete fGMTOffsetPatternItems[type];
+ fGMTOffsetPatternItems[type] = patternItems;
+}
+
+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;
+ }
+ 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_RFC822:
+ case UTZFMT_STYLE_ISO8601:
+ case UTZFMT_STYLE_LOCALIZED_GMT:
+ // will be handled below
+ break;
+ }
+
+ if (name.isEmpty()) {
+ UErrorCode status = U_ZERO_ERROR;
+ int32_t rawOffset, dstOffset;
+ tz.getOffset(date, FALSE, rawOffset, dstOffset, status);
+ if (U_SUCCESS(status)) {
+ switch (style) {
+ case UTZFMT_STYLE_RFC822:
+ formatOffsetRFC822(rawOffset + dstOffset, name, status);
+ break;
+ case UTZFMT_STYLE_ISO8601:
+ formatOffsetISO8601(rawOffset + dstOffset, name, status);
+ break;
+ default:
+ formatOffsetLocalizedGMT(rawOffset + dstOffset, name, status);
+ break;
+ }
+ if (timeType) {
+ *timeType = (dstOffset != 0) ? UTZFMT_TIME_TYPE_DAYLIGHT : UTZFMT_TIME_TYPE_STANDARD;
+ }
+ }
+ U_ASSERT(U_SUCCESS(status));
+ }
+
+ 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<const TimeZone*>(formatObj);
+ if (tz == NULL) {
+ const Calendar* cal = dynamic_cast<const Calendar*>(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);
+ UnicodeString result;
+ 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;
+
+ UBool fallbackLocalizedGMT = FALSE;
+ if (style == UTZFMT_STYLE_SPECIFIC_LONG || style == UTZFMT_STYLE_SPECIFIC_SHORT
+ || style == UTZFMT_STYLE_GENERIC_LONG || style == UTZFMT_STYLE_GENERIC_SHORT || style == UTZFMT_STYLE_GENERIC_LOCATION) {
+ // above styles may use localized gmt format as fallback
+ fallbackLocalizedGMT = TRUE;
+ }
+
+ int32_t evaluated = 0;
+ 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) {
+ UBool hasDigitOffset = FALSE;
+ offset = parseOffsetLocalizedGMT(text, tmpPos, &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();
+ }
+ evaluated |= STYLE_FLAG(UTZFMT_STYLE_LOCALIZED_GMT);
+
+ tmpPos.setIndex(startIdx);
+ tmpPos.setErrorIndex(-1);
+ }
+
+ UErrorCode status = U_ZERO_ERROR;
+ UnicodeString tzID;
+ UTimeZoneFormatTimeType parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
+
+ // Try the specified style
+ switch (style) {
+ case UTZFMT_STYLE_RFC822:
+ {
+ offset = parseOffsetRFC822(text, tmpPos);
+ if (tmpPos.getErrorIndex() == -1) {
+ pos.setIndex(tmpPos.getIndex());
+ return createTimeZoneForOffset(offset);
+ }
+ }
+ break;
+
+ case UTZFMT_STYLE_LOCALIZED_GMT:
+ {
+ offset = parseOffsetLocalizedGMT(text, tmpPos);
+ if (tmpPos.getErrorIndex() == -1) {
+ pos.setIndex(tmpPos.getIndex());
+ return createTimeZoneForOffset(offset);
+ }
+ }
+ break;
+
+ case UTZFMT_STYLE_ISO8601:
+ {
+ offset = parseOffsetISO8601(text, tmpPos);
+ if (tmpPos.getErrorIndex() == -1) {
+ pos.setIndex(tmpPos.getIndex());
+ return createTimeZoneForOffset(offset);
+ }
+ // Note: ISO 8601 parser also support basic format (without ':'),
+ // which is same with RFC 822 format.
+ evaluated |= STYLE_FLAG(UTZFMT_STYLE_RFC822);
+ }
+ 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<TimeZoneNames::MatchInfoCollection> 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);
+ }
+ }
+ }
+ 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:
+ U_ASSERT(FALSE);
+ }
+
+ int32_t len = 0;
+ const TimeZoneGenericNames *gnames = getTimeZoneGenericNames(status);
+ if (U_SUCCESS(status)) {
+ len = gnames->findBestMatch(text, startIdx, genericNameTypes, tzID, parsedTimeType, status);
+ }
+ if (U_FAILURE(status)) {
+ pos.setErrorIndex(startIdx);
+ return NULL;
+ }
+ if (len > 0) {
+ // Found a match
+ if (timeType) {
+ *timeType = parsedTimeType;
+ }
+ pos.setIndex(startIdx + len);
+ U_ASSERT(!tzID.isEmpty());
+ return TimeZone::createTimeZone(tzID);
+ }
+ }
+ break;
+ }
+ evaluated |= STYLE_FLAG(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.
+ U_ASSERT(parsedPos < 0);
+ U_ASSERT(parsedOffset == UNKNOWN_OFFSET);
+ tmpPos.setIndex(startIdx);
+ tmpPos.setErrorIndex(-1);
+
+ // ISO 8601
+ if ((evaluated & STYLE_FLAG(UTZFMT_STYLE_ISO8601)) == 0) {
+ 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 (except RFC 822, which is compatible with
+ // ISO 8601 basic format). However, ISO 8601 UTC format "Z" (single letter)
+ // may collide with other names. In this case, we need to evaluate other
+ // names.
+ parsedOffset = offset;
+ parsedPos = tmpPos.getIndex();
+ U_ASSERT(parsedPos == startIdx + 1); // only when "Z" is used
+ }
+ tmpPos.setIndex(startIdx);
+ tmpPos.setErrorIndex(-1);
+ }
+
+ // RFC 822
+ // Note: ISO 8601 parser supports RFC 822 format. So we do not need to parse
+ // it as RFC 822 here. This might be changed in future when we support
+ // strict format option for ISO 8601 or RFC 822.
+
+ //if ((evaluated & STYLE_FLAG(UTZFMT_STYLE_RFC822)) == 0) {
+ // offset = parseOffsetRFC822(text, tmpPos);
+ // if (tmpPos.getErrorIndex() == -1) {
+ // pos.setIndex(tmpPos.getIndex());
+ // return createTimeZoneForOffset(offset);
+ // }
+ // tmpPos.setIndex(startIdx);
+ // tmpPos.setErrorIndex(-1);
+ //}
+
+ // Localized GMT format
+ if ((evaluated & STYLE_FLAG(UTZFMT_STYLE_LOCALIZED_GMT)) == 0) {
+ UBool hasDigitOffset = FALSE;
+ offset = parseOffsetLocalizedGMT(text, tmpPos, &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.
+ parsedOffset = offset;
+ parsedPos = tmpPos.getIndex();
+ }
+ }
+
+ // When ParseOption.ALL_STYLES is available, we also try to look all possible display names.
+ // 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 first
+ LocalPointer<TimeZoneNames::MatchInfoCollection> spAllMatches(fTimeZoneNames->find(text, startIdx, ALL_SPECIFIC_NAME_TYPES, status));
+ if (U_FAILURE(status)) {
+ pos.setErrorIndex(startIdx);
+ return NULL;
+ }
+ int32_t spMatchIdx = -1;
+ if (!spAllMatches.isNull()) {
+ int32_t matchPos = -1;
+ for (int32_t i = 0; i < spAllMatches->size(); i++) {
+ matchPos = startIdx + spAllMatches->getMatchLengthAt(i);
+ if (matchPos > parsedPos) {
+ spMatchIdx = i;
+ parsedPos = matchPos;
+ }
+ }
+ }
+ int32_t genMatchLen = -1;
+ if (parsedPos < maxPos) {
+ const TimeZoneGenericNames *gnames = getTimeZoneGenericNames(status);
+ if (U_SUCCESS(status)) {
+ genMatchLen = gnames->findBestMatch(text, startIdx, ALL_GENERIC_NAME_TYPES, tzID, parsedTimeType, status);
+ }
+ if (U_FAILURE(status)) {
+ pos.setErrorIndex(startIdx);
+ return NULL;
+ }
+ }
+ // Pick up better match
+ if (startIdx + genMatchLen > parsedPos) {
+ // use generic name match
+ parsedPos = startIdx + genMatchLen;
+ if (timeType) {
+ *timeType = parsedTimeType;
+ }
+ pos.setIndex(parsedPos);
+ U_ASSERT(!tzID.isEmpty());
+ return TimeZone::createTimeZone(tzID);
+ } else if (spMatchIdx >= 0) {
+ // use specific name match
+ if (timeType) {
+ *timeType = getTimeType(spAllMatches->getNameTypeAt(spMatchIdx));
+ }
+ pos.setIndex(parsedPos);
+ getTimeZoneID(spAllMatches.getAlias(), spMatchIdx, tzID);
+ U_ASSERT(!tzID.isEmpty());
+ return TimeZone::createTimeZone(tzID);
+ }
+ }
+
+ if (parsedPos > startIdx) {
+ // Parsed successfully as one of 'offset' format
+ U_ASSERT(parsedOffset != UNKNOWN_OFFSET);
+ pos.setIndex(parsedPos);
+ return createTimeZoneForOffset(parsedOffset);
+ }
+
+ 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(canonicalID), 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(canonicalID), dstType, date, name);
+ } else {
+ fTimeZoneNames->getDisplayName(UnicodeString(canonicalID), 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;
+ }
+
+ UBool create;
+ UMTX_CHECK(&gZoneMetaLock, (fTimeZoneGenericNames == NULL), create);
+ if (create) {
+ TimeZoneFormat *nonConstThis = const_cast<TimeZoneFormat *>(this);
+ umtx_lock(&nonConstThis->fLock);
+ {
+ if (fTimeZoneGenericNames == NULL) {
+ nonConstThis->fTimeZoneGenericNames = TimeZoneGenericNames::createInstance(fLocale, status);
+ }
+ }
+ umtx_unlock(&nonConstThis->fLock);
+ }
+
+ return fTimeZoneGenericNames;
+}
+
+// ------------------------------------------------------------------
+// Zone offset format and parse
+
+UnicodeString&
+TimeZoneFormat::formatOffsetRFC822(int32_t offset, 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;
+ }
+
+ // Note: FIELDS_HMS as maxFields is an ICU extension. RFC822 specification
+ // defines exactly 4 digits for the offset field in HHss format.
+ return formatOffsetWithAsciiDigits(offset, 0, FIELDS_HM, FIELDS_HMS, result);
+}
+
+UnicodeString&
+TimeZoneFormat::formatOffsetISO8601(int32_t offset, 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(ISO8601_UTC);
+ return result;
+ }
+ return formatOffsetWithAsciiDigits(offset, ISO8601_SEP, FIELDS_HM, FIELDS_HMS, result);
+}
+
+UnicodeString&
+TimeZoneFormat::formatOffsetLocalizedGMT(int32_t offset, 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) {
+ offsetPatternItems = (offsetS == 0) ?
+ fGMTOffsetPatternItems[UTZFMT_PAT_POSITIVE_HM] :
+ fGMTOffsetPatternItems[UTZFMT_PAT_POSITIVE_HMS];
+ } else {
+ offsetPatternItems = (offsetS == 0) ?
+ fGMTOffsetPatternItems[UTZFMT_PAT_NEGATIVE_HM] :
+ fGMTOffsetPatternItems[UTZFMT_PAT_NEGATIVE_HMS];
+ }
+
+ 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, item->getWidth());
+ break;
+
+ case GMTOffsetField::MINUTE:
+ appendOffsetDigits(result, offsetM, item->getWidth());
+ break;
+
+ case GMTOffsetField::SECOND:
+ appendOffsetDigits(result, offsetS, item->getWidth());
+ break;
+ }
+ }
+
+ result.append(fGMTPatternSuffix);
+ return result;
+}
+
+int32_t
+TimeZoneFormat::parseOffsetRFC822(const UnicodeString& text, ParsePosition& pos) const {
+ int32_t start = pos.getIndex();
+ if (start >= text.length()) {
+ pos.setErrorIndex(start);
+ return 0;
+ }
+
+ int32_t sign = 1;
+ UChar signChar = text.charAt(start);
+ if (signChar == PLUS) {
+ sign = 1;
+ } else if (signChar == MINUS) {
+ sign = -1;
+ } else {
+ // Not an RFC822 offset string
+ pos.setErrorIndex(start);
+ return 0;
+ }
+
+ // Parse digits
+ pos.setIndex(start + 1);
+ int32_t offset = parseAbuttingAsciiOffsetFields(text, pos, FIELDS_H, FIELDS_HMS, false);
+
+ if (pos.getErrorIndex() != -1) {
+ pos.setIndex(start); // reset
+ pos.setErrorIndex(start);
+ return 0;
+ }
+
+ return sign * offset;
+}
+
+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, NULL);
+}
+
+
+
+// ------------------------------------------------------------------
+// Private zone offset format/parse implementation
+
+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, FALSE);
+ 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* hasDigitOffset) const {
+ int32_t start = pos.getIndex();
+ int32_t idx = start;
+ UBool parsed = FALSE;
+ int32_t offset = 0;
+
+ if (hasDigitOffset) {
+ *hasDigitOffset = 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;
+
+ // Suffix part
+ len = fGMTPatternSuffix.length();
+ if (len > 0 && text.caseCompare(idx, len, fGMTPatternSuffix, 0) != 0) {
+ // no suffix match
+ break;
+ }
+ idx += len;
+ parsed = TRUE;
+
+ } while (false);
+
+ if (parsed) {
+ if (hasDigitOffset) {
+ *hasDigitOffset = TRUE;
+ }
+ pos.setIndex(idx);
+ return offset;
+ }
+
+ // Try the default patterns
+ int32_t parsedLength = 0;
+ 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::parseOffsetFields(const UnicodeString& text, int32_t start, UBool minimumHourWidth, int32_t& parsedLen) const {
+ int32_t offset = 0;
+ UBool sawVarHourAndAbuttingField = FALSE;
+
+ parsedLen = 0;
+
+ for (int32_t patidx = 0; PARSE_GMT_OFFSET_TYPES[patidx] >= 0; patidx++) {
+ int32_t gmtPatType = PARSE_GMT_OFFSET_TYPES[patidx];
+ int32_t offsetH = 0, offsetM = 0, offsetS = 0;
+ int32_t idx = start;
+ UVector* items = fGMTOffsetPatternItems[gmtPatType];
+ U_ASSERT(items != NULL);
+
+ UBool failed = FALSE;
+ for (int32_t i = 0; i < items->size(); i++) {
+ int32_t tmpParsedLen = 0;
+ const GMTOffsetField* field = (const GMTOffsetField*)items->elementAt(i);
+ GMTOffsetField::FieldType fieldType = field->getType();
+ if (fieldType == GMTOffsetField::TEXT) {
+ const UChar* patStr = field->getPatternText();
+ tmpParsedLen = u_strlen(patStr);
+ if (text.caseCompare(idx, tmpParsedLen, patStr, 0) != 0) {
+ failed = TRUE;
+ break;
+ }
+ idx += tmpParsedLen;
+ } else {
+ if (fieldType == GMTOffsetField::HOUR) {
+ uint8_t minDigits = 1;
+ uint8_t maxDigits = minimumHourWidth ? 1 : 2;
+ if (!minimumHourWidth && !sawVarHourAndAbuttingField) {
+ if (i + 1 < items->size()) {
+ const GMTOffsetField* nextField = (const GMTOffsetField*)items->elementAt(i + 1);
+ if (nextField->getType() != GMTOffsetField::TEXT) {
+ sawVarHourAndAbuttingField = true;
+ }
+ }
+ }
+ offsetH = parseOffsetFieldWithLocalizedDigits(text, idx, minDigits, maxDigits, 0, MAX_OFFSET_HOUR, tmpParsedLen);
+ } else if (fieldType == GMTOffsetField::MINUTE) {
+ offsetM = parseOffsetFieldWithLocalizedDigits(text, idx, 2, 2, 0, MAX_OFFSET_MINUTE, tmpParsedLen);
+ } else if (fieldType == GMTOffsetField::SECOND) {
+ offsetS = parseOffsetFieldWithLocalizedDigits(text, idx, 2, 2, 0, MAX_OFFSET_SECOND, tmpParsedLen);
+ }
+
+ if (tmpParsedLen == 0) {
+ failed = TRUE;
+ break;
+ }
+ idx += tmpParsedLen;
+ }
+ }
+ if (!failed) {
+ int32_t sign = (gmtPatType == UTZFMT_PAT_POSITIVE_HM || gmtPatType == UTZFMT_PAT_POSITIVE_HMS) ? 1 : -1;
+ offset = ((((offsetH * 60) + offsetM) * 60) + offsetS) * 1000 * sign;
+ parsedLen = idx - start;
+ break;
+ }
+ }
+
+ if (parsedLen == 0 && sawVarHourAndAbuttingField && !minimumHourWidth) {
+ // When hour field is variable width and another non-literal pattern
+ // field follows, the parse loop above might eat up the digit from
+ // the abutting field. For example, with pattern "-Hmm" and input "-100",
+ // the hour is parsed as -10 and fails to parse minute field.
+ //
+ // If this is the case, try parsing the text one more time with the arg
+ // minimumHourWidth = true
+ //
+ // Note: This fallback is not applicable when quitAtHourField is true, because
+ // the option is designed for supporting the case like "GMT+5". In this case,
+ // we should get better result for parsing hour digits as much as possible.
+
+ return parseOffsetFields(text, start, true, parsedLen);
+ }
+
+ return offset;
+}
+
+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, UBool fixedHourWidth) {
+ 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 (fieldLen[fieldIdx] < 0) {
+ // next field - expected
+ fieldLen[fieldIdx] = 0;
+ } else if (fieldIdx == 0 && !fixedHourWidth) {
+ // 1 digit hour, move to next field
+ fieldIdx++;
+ fieldLen[fieldIdx] = 0;
+ } else {
+ // otherwise, premature field
+ break;
+ }
+ continue;
+ }
+ 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 || (fieldLen[0] == 1 && fixedHourWidth)) {
+ break;
+ }
+ if (fieldVal[0] > MAX_OFFSET_HOUR) {
+ if (fixedHourWidth) {
+ break;
+ }
+ 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;
+ UnicodeString text;
+ 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, (uint8_t)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, 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, 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, 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) {
+ 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) {
+ // we cannot do anything with this...
+ result.setTo(offsetHM);
+ result.append(DEFAULT_GMT_OFFSET_SEP);
+ result.append(DEFAULT_GMT_OFFSET_SECOND_PATTERN, -1);
+ return result;
+ }
+
+ UnicodeString sep;
+ int32_t idx_H = offsetHM.tempSubString(0, idx_mm).lastIndexOf(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;
+}
+
+void
+TimeZoneFormat::initGMTOffsetPatterns(UErrorCode& status) {
+ for (int32_t type = 0; type <= UTZFMT_PAT_NEGATIVE_HMS; type++) {
+ switch (type) {
+ 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;
+ }
+ }
+}
+
+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(TZID_GMT));
+ }
+ 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:
+ U_ASSERT(FALSE);
+ }
+ return UTZFMT_TIME_TYPE_UNKNOWN;
+}
+
+UnicodeString&
+TimeZoneFormat::getTimeZoneID(const TimeZoneNames::MatchInfoCollection* matches, int32_t idx, UnicodeString& tzID) const {
+ if (!matches->getTimeZoneIDAt(idx, tzID)) {
+ UnicodeString mzID;
+ if (matches->getMetaZoneIDAt(idx, mzID)) {
+ fTimeZoneNames->getReferenceZoneID(mzID, fTargetRegion, tzID);
+ }
+ }
+ return tzID;
+}
+
+U_NAMESPACE_END
+
+#endif
projects / apple / icu.git / blobdiff