Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2908 insertions, 0 deletions

diff --git a/intl/icu/source/i18n/tzfmt.cpp b/intl/icu/source/i18n/tzfmt.cpp
new file mode 100644
index 0000000000..f87f0f67b1
--- /dev/null
+++ b/intl/icu/source/i18n/tzfmt.cpp
@@ -0,0 +1,2908 @@
+// © 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 "bytesinkutil.h"
+#include "charstr.h"
+#include "tzgnames.h"
+#include "cmemory.h"
+#include "cstring.h"
+#include "putilimp.h"
+#include "uassert.h"
+#include "ucln_in.h"
+#include "ulocimp.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;
+
+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<GMTOffsetField *>(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<int32_t>(uprv_strlen(region));
+    if (regionLen == 0) {
+        CharString loc;
+        {
+            CharStringByteSink sink(&loc);
+            ulocimp_addLikelySubtags(fLocale.getName(), sink, &status);
+        }
+
+        regionLen = uloc_getCountry(loc.data(), 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;
+}
+
+TimeZoneFormat*
+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<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);
+            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<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);
+                }
+            }
+
+            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<TimeZoneNames::MatchInfoCollection> 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<TimeZoneNames::MatchInfoCollection> 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<TimeZoneNames::MatchInfoCollection> 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<TimeZoneFormat *>(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<TimeZoneFormat *>(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<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, static_cast<uint8_t>(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<uint8_t>(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<uint8_t>(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<UChar *>(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<ZoneIdMatchHandler> 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<UChar *>(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<ZoneIdMatchHandler> 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<TimeZoneNames::MatchInfoCollection> 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