src/third_party/icu/source/i18n/tzfmt.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2011-2013, International Business Machines Corporation and
   4 * others. All Rights Reserved.
   5 *******************************************************************************
   6 */
   7
   8 #include "unicode/utypes.h"
   9
  10 #if !UCONFIG_NO_FORMATTING
  11
  12 #include "unicode/calendar.h"
  13 #include "unicode/tzfmt.h"
  14 #include "unicode/numsys.h"
  15 #include "unicode/uchar.h"
  16 #include "unicode/udat.h"
  17 #include "tzgnames.h"
  18 #include "cmemory.h"
  19 #include "cstring.h"
  20 #include "putilimp.h"
  21 #include "uassert.h"
  22 #include "ucln_in.h"
  23 #include "umutex.h"
  24 #include "uresimp.h"
  25 #include "ureslocs.h"
  26 #include "uvector.h"
  27 #include "zonemeta.h"
  28 #include "tznames_impl.h"   // TextTrieMap
  29
  30 U_NAMESPACE_BEGIN
  31
  32 // Bit flags used by the parse method.
  33 // The order must match UTimeZoneFormatStyle enum.
  34 #define ISO_Z_STYLE_FLAG 0x0080
  35 #define ISO_LOCAL_STYLE_FLAG 0x0100
  36 static const int16_t STYLE_PARSE_FLAGS[] = {
  37     0x0001, // UTZFMT_STYLE_GENERIC_LOCATION,
  38     0x0002, // UTZFMT_STYLE_GENERIC_LONG,
  39     0x0004, // UTZFMT_STYLE_GENERIC_SHORT,
  40     0x0008, // UTZFMT_STYLE_SPECIFIC_LONG,
  41     0x0010, // UTZFMT_STYLE_SPECIFIC_SHORT,
  42     0x0020, // UTZFMT_STYLE_LOCALIZED_GMT,
  43     0x0040, // UTZFMT_STYLE_LOCALIZED_GMT_SHORT,
  44     ISO_Z_STYLE_FLAG,       // UTZFMT_STYLE_ISO_BASIC_SHORT,
  45     ISO_LOCAL_STYLE_FLAG,   // UTZFMT_STYLE_ISO_BASIC_LOCAL_SHORT,
  46     ISO_Z_STYLE_FLAG,       // UTZFMT_STYLE_ISO_BASIC_FIXED,
  47     ISO_LOCAL_STYLE_FLAG,   // UTZFMT_STYLE_ISO_BASIC_LOCAL_FIXED,
  48     ISO_Z_STYLE_FLAG,       // UTZFMT_STYLE_ISO_BASIC_FULL,
  49     ISO_LOCAL_STYLE_FLAG,   // UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL,
  50     ISO_Z_STYLE_FLAG,       // UTZFMT_STYLE_ISO_EXTENDED_FIXED,
  51     ISO_LOCAL_STYLE_FLAG,   // UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FIXED,
  52     ISO_Z_STYLE_FLAG,       // UTZFMT_STYLE_ISO_EXTENDED_FULL,
  53     ISO_LOCAL_STYLE_FLAG,   // UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL,
  54     0x0200, // UTZFMT_STYLE_ZONE_ID,
  55     0x0400, // UTZFMT_STYLE_ZONE_ID_SHORT,
  56     0x0800  // UTZFMT_STYLE_EXEMPLAR_LOCATION
  57 };
  58
  59 static const char gZoneStringsTag[] = "zoneStrings";
  60 static const char gGmtFormatTag[]= "gmtFormat";
  61 static const char gGmtZeroFormatTag[] = "gmtZeroFormat";
  62 static const char gHourFormatTag[]= "hourFormat";
  63
  64 static const UChar TZID_GMT[] = {0x0045, 0x0074, 0x0063, 0x002F, 0x0047, 0x004D, 0x0054, 0};    // Etc/GMT
  65 static const UChar UNKNOWN_ZONE_ID[] = {
  66     0x0045, 0x0074, 0x0063, 0x002F, 0x0055, 0x006E, 0x006B, 0x006E, 0x006F, 0x0077, 0x006E, 0}; // Etc/Unknown
  67 static const UChar UNKNOWN_SHORT_ZONE_ID[] = {0x0075, 0x006E, 0x006B, 0};   // unk
  68 static const UChar UNKNOWN_LOCATION[] = {0x0055, 0x006E, 0x006B, 0x006E, 0x006F, 0x0077, 0x006E, 0};    // Unknown
  69
  70 static const UChar DEFAULT_GMT_PATTERN[] = {0x0047, 0x004D, 0x0054, 0x007B, 0x0030, 0x007D, 0}; // GMT{0}
  71 //static const UChar DEFAULT_GMT_ZERO[] = {0x0047, 0x004D, 0x0054, 0}; // GMT
  72 static const UChar DEFAULT_GMT_POSITIVE_HM[] = {0x002B, 0x0048, 0x003A, 0x006D, 0x006D, 0}; // +H:mm
  73 static const UChar DEFAULT_GMT_POSITIVE_HMS[] = {0x002B, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0}; // +H:mm:ss
  74 static const UChar DEFAULT_GMT_NEGATIVE_HM[] = {0x002D, 0x0048, 0x003A, 0x006D, 0x006D, 0}; // -H:mm
  75 static const UChar DEFAULT_GMT_NEGATIVE_HMS[] = {0x002D, 0x0048, 0x003A, 0x006D, 0x006D, 0x003A, 0x0073, 0x0073, 0}; // -H:mm:ss
  76 static const UChar DEFAULT_GMT_POSITIVE_H[] = {0x002B, 0x0048, 0}; // +H
  77 static const UChar DEFAULT_GMT_NEGATIVE_H[] = {0x002D, 0x0048, 0}; // -H
  78
  79 static const UChar32 DEFAULT_GMT_DIGITS[] = {
  80     0x0030, 0x0031, 0x0032, 0x0033, 0x0034,
  81     0x0035, 0x0036, 0x0037, 0x0038, 0x0039
  82 };
  83
  84 static const UChar DEFAULT_GMT_OFFSET_SEP = 0x003A; // ':'
  85
  86 static const UChar ARG0[] = {0x007B, 0x0030, 0x007D};   // "{0}"
  87 static const int32_t ARG0_LEN = 3;
  88
  89 static const UChar DEFAULT_GMT_OFFSET_MINUTE_PATTERN[] = {0x006D, 0x006D, 0};   // "mm"
  90 static const UChar DEFAULT_GMT_OFFSET_SECOND_PATTERN[] = {0x0073, 0x0073, 0};   // "ss"
  91
  92 static const UChar ALT_GMT_STRINGS[][4] = {
  93     {0x0047, 0x004D, 0x0054, 0},    // GMT
  94     {0x0055, 0x0054, 0x0043, 0},    // UTC
  95     {0x0055, 0x0054, 0, 0},         // UT
  96     {0, 0, 0, 0}
  97 };
  98
  99 // Order of GMT offset pattern parsing, *_HMS must be evaluated first
 100 // because *_HM is most likely a substring of *_HMS
 101 static const int32_t PARSE_GMT_OFFSET_TYPES[] = {
 102     UTZFMT_PAT_POSITIVE_HMS,
 103     UTZFMT_PAT_NEGATIVE_HMS,
 104     UTZFMT_PAT_POSITIVE_HM,
 105     UTZFMT_PAT_NEGATIVE_HM,
 106     UTZFMT_PAT_POSITIVE_H,
 107     UTZFMT_PAT_NEGATIVE_H,
 108     -1
 109 };
 110
 111 static const UChar SINGLEQUOTE  = 0x0027;
 112 static const UChar PLUS         = 0x002B;
 113 static const UChar MINUS        = 0x002D;
 114 static const UChar ISO8601_UTC  = 0x005A;   // 'Z'
 115 static const UChar ISO8601_SEP  = 0x003A;   // ':'
 116
 117 static const int32_t MILLIS_PER_HOUR = 60 * 60 * 1000;
 118 static const int32_t MILLIS_PER_MINUTE = 60 * 1000;
 119 static const int32_t MILLIS_PER_SECOND = 1000;
 120
 121 // Maximum offset (exclusive) in millisecond supported by offset formats
 122 static int32_t MAX_OFFSET = 24 * MILLIS_PER_HOUR;
 123
 124 // Maximum values for GMT offset fields
 125 static const int32_t MAX_OFFSET_HOUR = 23;
 126 static const int32_t MAX_OFFSET_MINUTE = 59;
 127 static const int32_t MAX_OFFSET_SECOND = 59;
 128
 129 static const int32_t UNKNOWN_OFFSET = 0x7FFFFFFF;
 130
 131 static const int32_t ALL_SIMPLE_NAME_TYPES = UTZNM_LONG_STANDARD | UTZNM_LONG_DAYLIGHT | UTZNM_SHORT_STANDARD | UTZNM_SHORT_DAYLIGHT | UTZNM_EXEMPLAR_LOCATION;
 132 static const int32_t ALL_GENERIC_NAME_TYPES = UTZGNM_LOCATION | UTZGNM_LONG | UTZGNM_SHORT;
 133
 134 #define DIGIT_VAL(c) (0x0030 <= (c) && (c) <= 0x0039 ? (c) - 0x0030 : -1)
 135 #define MAX_OFFSET_DIGITS 6
 136
 137 // Time Zone ID/Short ID trie
 138 static TextTrieMap *gZoneIdTrie = NULL;
 139 static icu::UInitOnce gZoneIdTrieInitOnce = U_INITONCE_INITIALIZER;
 140
 141 static TextTrieMap *gShortZoneIdTrie = NULL;
 142 static icu::UInitOnce gShortZoneIdTrieInitOnce = U_INITONCE_INITIALIZER;
 143
 144 static UMutex gLock = U_MUTEX_INITIALIZER;
 145
 146 U_CDECL_BEGIN
 147 /**
 148  * Cleanup callback func
 149  */
 150 static UBool U_CALLCONV tzfmt_cleanup(void)
 151 {
 152     if (gZoneIdTrie != NULL) {
 153         delete gZoneIdTrie;
 154     }
 155     gZoneIdTrie = NULL;
 156     gZoneIdTrieInitOnce.reset();
 157
 158     if (gShortZoneIdTrie != NULL) {
 159         delete gShortZoneIdTrie;
 160     }
 161     gShortZoneIdTrie = NULL;
 162     gShortZoneIdTrieInitOnce.reset();
 163
 164     return TRUE;
 165 }
 166 U_CDECL_END
 167
 168 // ------------------------------------------------------------------
 169 // GMTOffsetField
 170 //
 171 // This class represents a localized GMT offset pattern
 172 // item and used by TimeZoneFormat
 173 // ------------------------------------------------------------------
 174 class GMTOffsetField : public UMemory {
 175 public:
 176     enum FieldType {
 177         TEXT = 0,
 178         HOUR = 1,
 179         MINUTE = 2,
 180         SECOND = 4
 181     };
 182
 183     virtual ~GMTOffsetField();
 184
 185     static GMTOffsetField* createText(const UnicodeString& text, UErrorCode& status);
 186     static GMTOffsetField* createTimeField(FieldType type, uint8_t width, UErrorCode& status);
 187     static UBool isValid(FieldType type, int32_t width);
 188     static FieldType getTypeByLetter(UChar ch);
 189
 190     FieldType getType() const;
 191     uint8_t getWidth() const;
 192     const UChar* getPatternText(void) const;
 193
 194 private:
 195     UChar* fText;
 196     FieldType fType;
 197     uint8_t fWidth;
 198
 199     GMTOffsetField();
 200 };
 201
 202 GMTOffsetField::GMTOffsetField()
 203 : fText(NULL), fType(TEXT), fWidth(0) {
 204 }
 205
 206 GMTOffsetField::~GMTOffsetField() {
 207     if (fText) {
 208         uprv_free(fText);
 209     }
 210 }
 211
 212 GMTOffsetField*
 213 GMTOffsetField::createText(const UnicodeString& text, UErrorCode& status) {
 214     if (U_FAILURE(status)) {
 215         return NULL;
 216     }
 217     GMTOffsetField* result = new GMTOffsetField();
 218     if (result == NULL) {
 219         status = U_MEMORY_ALLOCATION_ERROR;
 220         return NULL;
 221     }
 222
 223     int32_t len = text.length();
 224     result->fText = (UChar*)uprv_malloc((len + 1) * sizeof(UChar));
 225     if (result->fText == NULL) {
 226         status = U_MEMORY_ALLOCATION_ERROR;
 227         delete result;
 228         return NULL;
 229     }
 230     u_strncpy(result->fText, text.getBuffer(), len);
 231     result->fText[len] = 0;
 232     result->fType = TEXT;
 233
 234     return result;
 235 }
 236
 237 GMTOffsetField*
 238 GMTOffsetField::createTimeField(FieldType type, uint8_t width, UErrorCode& status) {
 239     U_ASSERT(type != TEXT);
 240     if (U_FAILURE(status)) {
 241         return NULL;
 242     }
 243     GMTOffsetField* result = new GMTOffsetField();
 244     if (result == NULL) {
 245         status = U_MEMORY_ALLOCATION_ERROR;
 246         return NULL;
 247     }
 248
 249     result->fType = type;
 250     result->fWidth = width;
 251
 252     return result;
 253 }
 254
 255 UBool
 256 GMTOffsetField::isValid(FieldType type, int32_t width) {
 257     switch (type) {
 258     case HOUR:
 259         return (width == 1 || width == 2);
 260     case MINUTE:
 261     case SECOND:
 262         return (width == 2);
 263     default:
 264         U_ASSERT(FALSE);
 265     }
 266     return (width > 0);
 267 }
 268
 269 GMTOffsetField::FieldType
 270 GMTOffsetField::getTypeByLetter(UChar ch) {
 271     if (ch == 0x0048 /* H */) {
 272         return HOUR;
 273     } else if (ch == 0x006D /* m */) {
 274         return MINUTE;
 275     } else if (ch == 0x0073 /* s */) {
 276         return SECOND;
 277     }
 278     return TEXT;
 279 }
 280
 281 inline GMTOffsetField::FieldType
 282 GMTOffsetField::getType() const {
 283      return fType;
 284  }
 285
 286 inline uint8_t
 287 GMTOffsetField::getWidth() const {
 288     return fWidth;
 289 }
 290
 291 inline const UChar*
 292 GMTOffsetField::getPatternText(void) const {
 293     return fText;
 294 }
 295
 296
 297 U_CDECL_BEGIN
 298 static void U_CALLCONV
 299 deleteGMTOffsetField(void *obj) {
 300     delete static_cast<GMTOffsetField *>(obj);
 301 }
 302 U_CDECL_END
 303
 304
 305 // ------------------------------------------------------------------
 306 // TimeZoneFormat
 307 // ------------------------------------------------------------------
 308 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TimeZoneFormat)
 309
 310 TimeZoneFormat::TimeZoneFormat(const Locale& locale, UErrorCode& status)
 311 : fLocale(locale), fTimeZoneNames(NULL), fTimeZoneGenericNames(NULL), fDefParseOptionFlags(0) {
 312
 313     for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) {
 314         fGMTOffsetPatternItems[i] = NULL;
 315     }
 316
 317     const char* region = fLocale.getCountry();
 318     int32_t regionLen = uprv_strlen(region);
 319     if (regionLen == 0) {
 320         char loc[ULOC_FULLNAME_CAPACITY];
 321         uloc_addLikelySubtags(fLocale.getName(), loc, sizeof(loc), &status);
 322
 323         regionLen = uloc_getCountry(loc, fTargetRegion, sizeof(fTargetRegion), &status);
 324         if (U_SUCCESS(status)) {
 325             fTargetRegion[regionLen] = 0;
 326         } else {
 327             return;
 328         }
 329     } else if (regionLen < (int32_t)sizeof(fTargetRegion)) {
 330         uprv_strcpy(fTargetRegion, region);
 331     } else {
 332         fTargetRegion[0] = 0;
 333     }
 334
 335     fTimeZoneNames = TimeZoneNames::createInstance(locale, status);
 336     // fTimeZoneGenericNames is lazily instantiated
 337     if (U_FAILURE(status)) {
 338         return;
 339     }
 340
 341     const UChar* gmtPattern = NULL;
 342     const UChar* hourFormats = NULL;
 343
 344     UResourceBundle *zoneBundle = ures_open(U_ICUDATA_ZONE, locale.getName(), &status);
 345     UResourceBundle *zoneStringsArray = ures_getByKeyWithFallback(zoneBundle, gZoneStringsTag, NULL, &status);
 346     if (U_SUCCESS(status)) {
 347         const UChar* resStr;
 348         int32_t len;
 349         resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gGmtFormatTag, &len, &status);
 350         if (len > 0) {
 351             gmtPattern = resStr;
 352         }
 353         resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gGmtZeroFormatTag, &len, &status);
 354         if (len > 0) {
 355             fGMTZeroFormat.setTo(TRUE, resStr, len);
 356         }
 357         resStr = ures_getStringByKeyWithFallback(zoneStringsArray, gHourFormatTag, &len, &status);
 358         if (len > 0) {
 359             hourFormats = resStr;
 360         }
 361         ures_close(zoneStringsArray);
 362         ures_close(zoneBundle);
 363     }
 364
 365     if (gmtPattern == NULL) {
 366         gmtPattern = DEFAULT_GMT_PATTERN;
 367     }
 368     initGMTPattern(UnicodeString(gmtPattern, -1), status);
 369
 370     UBool useDefaultOffsetPatterns = TRUE;
 371     if (hourFormats) {
 372         UChar *sep = u_strchr(hourFormats, (UChar)0x003B /* ';' */);
 373         if (sep != NULL) {
 374             UErrorCode tmpStatus = U_ZERO_ERROR;
 375             fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM].setTo(FALSE, hourFormats, (int32_t)(sep - hourFormats));
 376             fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM].setTo(TRUE, sep + 1, -1);
 377             expandOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HMS], tmpStatus);
 378             expandOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HMS], tmpStatus);
 379             truncateOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_H], tmpStatus);
 380             truncateOffsetPattern(fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM], fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_H], tmpStatus);
 381             if (U_SUCCESS(tmpStatus)) {
 382                 useDefaultOffsetPatterns = FALSE;
 383             }
 384         }
 385     }
 386     if (useDefaultOffsetPatterns) {
 387         fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_H].setTo(TRUE, DEFAULT_GMT_POSITIVE_H, -1);
 388         fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HM].setTo(TRUE, DEFAULT_GMT_POSITIVE_HM, -1);
 389         fGMTOffsetPatterns[UTZFMT_PAT_POSITIVE_HMS].setTo(TRUE, DEFAULT_GMT_POSITIVE_HMS, -1);
 390         fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_H].setTo(TRUE, DEFAULT_GMT_NEGATIVE_H, -1);
 391         fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HM].setTo(TRUE, DEFAULT_GMT_NEGATIVE_HM, -1);
 392         fGMTOffsetPatterns[UTZFMT_PAT_NEGATIVE_HMS].setTo(TRUE, DEFAULT_GMT_NEGATIVE_HMS, -1);
 393     }
 394     initGMTOffsetPatterns(status);
 395
 396     NumberingSystem* ns = NumberingSystem::createInstance(locale, status);
 397     UBool useDefDigits = TRUE;
 398     if (ns && !ns->isAlgorithmic()) {
 399         UnicodeString digits = ns->getDescription();
 400         useDefDigits = !toCodePoints(digits, fGMTOffsetDigits, 10);
 401     }
 402     if (useDefDigits) {
 403         uprv_memcpy(fGMTOffsetDigits, DEFAULT_GMT_DIGITS, sizeof(UChar32) * 10);
 404     }
 405     delete ns;
 406 }
 407
 408 TimeZoneFormat::TimeZoneFormat(const TimeZoneFormat& other)
 409 : Format(other), fTimeZoneNames(NULL), fTimeZoneGenericNames(NULL) {
 410
 411     for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) {
 412         fGMTOffsetPatternItems[i] = NULL;
 413     }
 414     *this = other;
 415 }
 416
 417
 418 TimeZoneFormat::~TimeZoneFormat() {
 419     delete fTimeZoneNames;
 420     delete fTimeZoneGenericNames;
 421     for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) {
 422         delete fGMTOffsetPatternItems[i];
 423     }
 424 }
 425
 426 TimeZoneFormat&
 427 TimeZoneFormat::operator=(const TimeZoneFormat& other) {
 428     if (this == &other) {
 429         return *this;
 430     }
 431
 432     delete fTimeZoneNames;
 433     delete fTimeZoneGenericNames;
 434     fTimeZoneGenericNames = NULL;
 435
 436     fLocale = other.fLocale;
 437     uprv_memcpy(fTargetRegion, other.fTargetRegion, sizeof(fTargetRegion));
 438
 439     fTimeZoneNames = other.fTimeZoneNames->clone();
 440     if (other.fTimeZoneGenericNames) {
 441         // TODO: this test has dubious thread safety.
 442         fTimeZoneGenericNames = other.fTimeZoneGenericNames->clone();
 443     }
 444
 445     fGMTPattern = other.fGMTPattern;
 446     fGMTPatternPrefix = other.fGMTPatternPrefix;
 447     fGMTPatternSuffix = other.fGMTPatternSuffix;
 448
 449     UErrorCode status = U_ZERO_ERROR;
 450     for (int32_t i = 0; i < UTZFMT_PAT_COUNT; i++) {
 451         fGMTOffsetPatterns[i] = other.fGMTOffsetPatterns[i];
 452         delete fGMTOffsetPatternItems[i];
 453     }
 454     initGMTOffsetPatterns(status);
 455     U_ASSERT(U_SUCCESS(status));
 456
 457     fGMTZeroFormat = other.fGMTZeroFormat;
 458
 459     uprv_memcpy(fGMTOffsetDigits, other.fGMTOffsetDigits, sizeof(fGMTOffsetDigits));
 460
 461     fDefParseOptionFlags = other.fDefParseOptionFlags;
 462
 463     return *this;
 464 }
 465
 466
 467 UBool
 468 TimeZoneFormat::operator==(const Format& other) const {
 469     TimeZoneFormat* tzfmt = (TimeZoneFormat*)&other;
 470
 471     UBool isEqual =
 472             fLocale == tzfmt->fLocale
 473             && fGMTPattern == tzfmt->fGMTPattern
 474             && fGMTZeroFormat == tzfmt->fGMTZeroFormat
 475             && *fTimeZoneNames == *tzfmt->fTimeZoneNames;
 476
 477     for (int32_t i = 0; i < UTZFMT_PAT_COUNT && isEqual; i++) {
 478         isEqual = fGMTOffsetPatterns[i] == tzfmt->fGMTOffsetPatterns[i];
 479     }
 480     for (int32_t i = 0; i < 10 && isEqual; i++) {
 481         isEqual = fGMTOffsetDigits[i] == tzfmt->fGMTOffsetDigits[i];
 482     }
 483     // TODO
 484     // Check fTimeZoneGenericNames. For now,
 485     // if fTimeZoneNames is same, fTimeZoneGenericNames should
 486     // be also equivalent.
 487     return isEqual;
 488 }
 489
 490 Format*
 491 TimeZoneFormat::clone() const {
 492     return new TimeZoneFormat(*this);
 493 }
 494
 495 TimeZoneFormat* U_EXPORT2
 496 TimeZoneFormat::createInstance(const Locale& locale, UErrorCode& status) {
 497     TimeZoneFormat* tzfmt = new TimeZoneFormat(locale, status);
 498     if (U_SUCCESS(status)) {
 499         return tzfmt;
 500     }
 501     delete tzfmt;
 502     return NULL;
 503 }
 504
 505 // ------------------------------------------------------------------
 506 // Setter and Getter
 507
 508 const TimeZoneNames*
 509 TimeZoneFormat::getTimeZoneNames() const {
 510     return (const TimeZoneNames*)fTimeZoneNames;
 511 }
 512
 513 void
 514 TimeZoneFormat::adoptTimeZoneNames(TimeZoneNames *tznames) {
 515     delete fTimeZoneNames;
 516     fTimeZoneNames = tznames;
 517
 518     // TODO - We should also update fTimeZoneGenericNames
 519 }
 520
 521 void
 522 TimeZoneFormat::setTimeZoneNames(const TimeZoneNames &tznames) {
 523     delete fTimeZoneNames;
 524     fTimeZoneNames = tznames.clone();
 525
 526     // TODO - We should also update fTimeZoneGenericNames
 527 }
 528
 529 void
 530 TimeZoneFormat::setDefaultParseOptions(uint32_t flags) {
 531     fDefParseOptionFlags = flags;
 532 }
 533
 534 uint32_t
 535 TimeZoneFormat::getDefaultParseOptions(void) const {
 536     return fDefParseOptionFlags;
 537 }
 538
 539
 540 UnicodeString&
 541 TimeZoneFormat::getGMTPattern(UnicodeString& pattern) const {
 542     return pattern.setTo(fGMTPattern);
 543 }
 544
 545 void
 546 TimeZoneFormat::setGMTPattern(const UnicodeString& pattern, UErrorCode& status) {
 547     initGMTPattern(pattern, status);
 548 }
 549
 550 UnicodeString&
 551 TimeZoneFormat::getGMTOffsetPattern(UTimeZoneFormatGMTOffsetPatternType type, UnicodeString& pattern) const {
 552     return pattern.setTo(fGMTOffsetPatterns[type]);
 553 }
 554
 555 void
 556 TimeZoneFormat::setGMTOffsetPattern(UTimeZoneFormatGMTOffsetPatternType type, const UnicodeString& pattern, UErrorCode& status) {
 557     if (U_FAILURE(status)) {
 558         return;
 559     }
 560     if (pattern == fGMTOffsetPatterns[type]) {
 561         // No need to reset
 562         return;
 563     }
 564
 565     OffsetFields required = FIELDS_HM;
 566     switch (type) {
 567     case UTZFMT_PAT_POSITIVE_H:
 568     case UTZFMT_PAT_NEGATIVE_H:
 569         required = FIELDS_H;
 570         break;
 571     case UTZFMT_PAT_POSITIVE_HM:
 572     case UTZFMT_PAT_NEGATIVE_HM:
 573         required = FIELDS_HM;
 574         break;
 575     case UTZFMT_PAT_POSITIVE_HMS:
 576     case UTZFMT_PAT_NEGATIVE_HMS:
 577         required = FIELDS_HMS;
 578         break;
 579     default:
 580         U_ASSERT(FALSE);
 581         break;
 582     }
 583
 584     UVector* patternItems = parseOffsetPattern(pattern, required, status);
 585     if (patternItems == NULL) {
 586         return;
 587     }
 588
 589     fGMTOffsetPatterns[type].setTo(pattern);
 590     delete fGMTOffsetPatternItems[type];
 591     fGMTOffsetPatternItems[type] = patternItems;
 592     checkAbuttingHoursAndMinutes();
 593 }
 594
 595 UnicodeString&
 596 TimeZoneFormat::getGMTOffsetDigits(UnicodeString& digits) const {
 597     digits.remove();
 598     for (int32_t i = 0; i < 10; i++) {
 599         digits.append(fGMTOffsetDigits[i]);
 600     }
 601     return digits;
 602 }
 603
 604 void
 605 TimeZoneFormat::setGMTOffsetDigits(const UnicodeString& digits, UErrorCode& status) {
 606     if (U_FAILURE(status)) {
 607         return;
 608     }
 609     UChar32 digitArray[10];
 610     if (!toCodePoints(digits, digitArray, 10)) {
 611         status = U_ILLEGAL_ARGUMENT_ERROR;
 612         return;
 613     }
 614     uprv_memcpy(fGMTOffsetDigits, digitArray, sizeof(UChar32)*10);
 615 }
 616
 617 UnicodeString&
 618 TimeZoneFormat::getGMTZeroFormat(UnicodeString& gmtZeroFormat) const {
 619     return gmtZeroFormat.setTo(fGMTZeroFormat);
 620 }
 621
 622 void
 623 TimeZoneFormat::setGMTZeroFormat(const UnicodeString& gmtZeroFormat, UErrorCode& status) {
 624     if (U_SUCCESS(status)) {
 625         if (gmtZeroFormat.isEmpty()) {
 626             status = U_ILLEGAL_ARGUMENT_ERROR;
 627         } else if (gmtZeroFormat != fGMTZeroFormat) {
 628             fGMTZeroFormat.setTo(gmtZeroFormat);
 629         }
 630     }
 631 }
 632
 633 // ------------------------------------------------------------------
 634 // Format and Parse
 635
 636 UnicodeString&
 637 TimeZoneFormat::format(UTimeZoneFormatStyle style, const TimeZone& tz, UDate date,
 638         UnicodeString& name, UTimeZoneFormatTimeType* timeType /* = NULL */) const {
 639     if (timeType) {
 640         *timeType = UTZFMT_TIME_TYPE_UNKNOWN;
 641     }
 642
 643     UBool noOffsetFormatFallback = FALSE;
 644
 645     switch (style) {
 646     case UTZFMT_STYLE_GENERIC_LOCATION:
 647         formatGeneric(tz, UTZGNM_LOCATION, date, name);
 648         break;
 649     case UTZFMT_STYLE_GENERIC_LONG:
 650         formatGeneric(tz, UTZGNM_LONG, date, name);
 651         break;
 652     case UTZFMT_STYLE_GENERIC_SHORT:
 653         formatGeneric(tz, UTZGNM_SHORT, date, name);
 654         break;
 655     case UTZFMT_STYLE_SPECIFIC_LONG:
 656         formatSpecific(tz, UTZNM_LONG_STANDARD, UTZNM_LONG_DAYLIGHT, date, name, timeType);
 657         break;
 658     case UTZFMT_STYLE_SPECIFIC_SHORT:
 659         formatSpecific(tz, UTZNM_SHORT_STANDARD, UTZNM_SHORT_DAYLIGHT, date, name, timeType);
 660         break;
 661
 662     case UTZFMT_STYLE_ZONE_ID:
 663         tz.getID(name);
 664         noOffsetFormatFallback = TRUE;
 665         break;
 666     case UTZFMT_STYLE_ZONE_ID_SHORT:
 667         {
 668             const UChar* shortID = ZoneMeta::getShortID(tz);
 669             if (shortID == NULL) {
 670                 shortID = UNKNOWN_SHORT_ZONE_ID;
 671             }
 672             name.setTo(shortID, -1);
 673         }
 674         noOffsetFormatFallback = TRUE;
 675         break;
 676
 677     case UTZFMT_STYLE_EXEMPLAR_LOCATION:
 678         formatExemplarLocation(tz, name);
 679         noOffsetFormatFallback = TRUE;
 680         break;
 681
 682     default:
 683         // will be handled below
 684         break;
 685     }
 686
 687     if (name.isEmpty() && !noOffsetFormatFallback) {
 688         UErrorCode status = U_ZERO_ERROR;
 689         int32_t rawOffset, dstOffset;
 690         tz.getOffset(date, FALSE, rawOffset, dstOffset, status);
 691         int32_t offset = rawOffset + dstOffset;
 692         if (U_SUCCESS(status)) {
 693             switch (style) {
 694             case UTZFMT_STYLE_GENERIC_LOCATION:
 695             case UTZFMT_STYLE_GENERIC_LONG:
 696             case UTZFMT_STYLE_SPECIFIC_LONG:
 697             case UTZFMT_STYLE_LOCALIZED_GMT:
 698                 formatOffsetLocalizedGMT(offset, name, status);
 699                 break;
 700
 701             case UTZFMT_STYLE_GENERIC_SHORT:
 702             case UTZFMT_STYLE_SPECIFIC_SHORT:
 703             case UTZFMT_STYLE_LOCALIZED_GMT_SHORT:
 704                 formatOffsetShortLocalizedGMT(offset, name, status);
 705                 break;
 706
 707             case UTZFMT_STYLE_ISO_BASIC_SHORT:
 708                 formatOffsetISO8601Basic(offset, TRUE, TRUE, TRUE, name, status);
 709                 break;
 710
 711             case UTZFMT_STYLE_ISO_BASIC_LOCAL_SHORT:
 712                 formatOffsetISO8601Basic(offset, FALSE, TRUE, TRUE, name, status);
 713                 break;
 714
 715             case UTZFMT_STYLE_ISO_BASIC_FIXED:
 716                 formatOffsetISO8601Basic(offset, TRUE, FALSE, TRUE, name, status);
 717                 break;
 718
 719             case UTZFMT_STYLE_ISO_BASIC_LOCAL_FIXED:
 720                 formatOffsetISO8601Basic(offset, FALSE, FALSE, TRUE, name, status);
 721                 break;
 722
 723             case UTZFMT_STYLE_ISO_EXTENDED_FIXED:
 724                 formatOffsetISO8601Extended(offset, TRUE, FALSE, TRUE, name, status);
 725                 break;
 726
 727             case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FIXED:
 728                 formatOffsetISO8601Extended(offset, FALSE, FALSE, TRUE, name, status);
 729                 break;
 730
 731             case UTZFMT_STYLE_ISO_BASIC_FULL:
 732                 formatOffsetISO8601Basic(offset, TRUE, FALSE, FALSE, name, status);
 733                 break;
 734
 735             case UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL:
 736                 formatOffsetISO8601Basic(offset, FALSE, FALSE, FALSE, name, status);
 737                 break;
 738
 739             case UTZFMT_STYLE_ISO_EXTENDED_FULL:
 740                 formatOffsetISO8601Extended(offset, TRUE, FALSE, FALSE, name, status);
 741                 break;
 742
 743             case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL:
 744                 formatOffsetISO8601Extended(offset, FALSE, FALSE, FALSE, name, status);
 745                 break;
 746
 747             default:
 748               // UTZFMT_STYLE_ZONE_ID, UTZFMT_STYLE_ZONE_ID_SHORT, UTZFMT_STYLE_EXEMPLAR_LOCATION
 749               break;
 750             }
 751
 752             if (timeType) {
 753                 *timeType = (dstOffset != 0) ? UTZFMT_TIME_TYPE_DAYLIGHT : UTZFMT_TIME_TYPE_STANDARD;
 754             }
 755         }
 756     }
 757
 758     return name;
 759 }
 760
 761 UnicodeString&
 762 TimeZoneFormat::format(const Formattable& obj, UnicodeString& appendTo,
 763         FieldPosition& pos, UErrorCode& status) const {
 764     if (U_FAILURE(status)) {
 765         return appendTo;
 766     }
 767     UDate date = Calendar::getNow();
 768     if (obj.getType() == Formattable::kObject) {
 769         const UObject* formatObj = obj.getObject();
 770         const TimeZone* tz = dynamic_cast<const TimeZone*>(formatObj);
 771         if (tz == NULL) {
 772             const Calendar* cal = dynamic_cast<const Calendar*>(formatObj);
 773             if (cal != NULL) {
 774                 tz = &cal->getTimeZone();
 775                 date = cal->getTime(status);
 776             }
 777         }
 778         if (tz != NULL) {
 779             int32_t rawOffset, dstOffset;
 780             tz->getOffset(date, FALSE, rawOffset, dstOffset, status);
 781             UnicodeString result;
 782             formatOffsetLocalizedGMT(rawOffset + dstOffset, result, status);
 783             if (U_SUCCESS(status)) {
 784                 appendTo.append(result);
 785                 if (pos.getField() == UDAT_TIMEZONE_FIELD) {
 786                     pos.setBeginIndex(0);
 787                     pos.setEndIndex(result.length());
 788                 }
 789             }
 790         }
 791     }
 792     return appendTo;
 793 }
 794
 795 TimeZone*
 796 TimeZoneFormat::parse(UTimeZoneFormatStyle style, const UnicodeString& text, ParsePosition& pos,
 797         UTimeZoneFormatTimeType* timeType /*= NULL*/) const {
 798     return parse(style, text, pos, getDefaultParseOptions(), timeType);
 799 }
 800
 801 TimeZone*
 802 TimeZoneFormat::parse(UTimeZoneFormatStyle style, const UnicodeString& text, ParsePosition& pos,
 803         int32_t parseOptions, UTimeZoneFormatTimeType* timeType /* = NULL */) const {
 804     if (timeType) {
 805         *timeType = UTZFMT_TIME_TYPE_UNKNOWN;
 806     }
 807
 808     int32_t startIdx = pos.getIndex();
 809     int32_t maxPos = text.length();
 810     int32_t offset;
 811
 812     // Styles using localized GMT format as fallback
 813     UBool fallbackLocalizedGMT =
 814         (style == UTZFMT_STYLE_SPECIFIC_LONG || style == UTZFMT_STYLE_GENERIC_LONG || style == UTZFMT_STYLE_GENERIC_LOCATION);
 815     UBool fallbackShortLocalizedGMT =
 816         (style == UTZFMT_STYLE_SPECIFIC_SHORT || style == UTZFMT_STYLE_GENERIC_SHORT);
 817
 818     int32_t evaluated = 0;  // bit flags representing already evaluated styles
 819     ParsePosition tmpPos(startIdx);
 820
 821     int32_t parsedOffset = UNKNOWN_OFFSET;  // stores successfully parsed offset for later use
 822     int32_t parsedPos = -1;                 // stores successfully parsed offset position for later use
 823
 824     // Try localized GMT format first if necessary
 825     if (fallbackLocalizedGMT || fallbackShortLocalizedGMT) {
 826         UBool hasDigitOffset = FALSE;
 827         offset = parseOffsetLocalizedGMT(text, tmpPos, fallbackShortLocalizedGMT, &hasDigitOffset);
 828         if (tmpPos.getErrorIndex() == -1) {
 829             // Even when the input text was successfully parsed as a localized GMT format text,
 830             // we may still need to evaluate the specified style if -
 831             //   1) GMT zero format was used, and
 832             //   2) The input text was not completely processed
 833             if (tmpPos.getIndex() == maxPos || hasDigitOffset) {
 834                 pos.setIndex(tmpPos.getIndex());
 835                 return createTimeZoneForOffset(offset);
 836             }
 837             parsedOffset = offset;
 838             parsedPos = tmpPos.getIndex();
 839         }
 840         // Note: For now, no distinction between long/short localized GMT format in the parser.
 841         // This might be changed in future.
 842         // evaluated |= (fallbackLocalizedGMT ? STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT] : STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT]);
 843         evaluated |= STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT] | STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT];
 844     }
 845
 846     UErrorCode status = U_ZERO_ERROR;
 847     UnicodeString tzID;
 848
 849     // Try the specified style
 850     switch (style) {
 851     case UTZFMT_STYLE_LOCALIZED_GMT:
 852         {
 853             tmpPos.setIndex(startIdx);
 854             tmpPos.setErrorIndex(-1);
 855
 856             offset = parseOffsetLocalizedGMT(text, tmpPos);
 857             if (tmpPos.getErrorIndex() == -1) {
 858                 pos.setIndex(tmpPos.getIndex());
 859                 return createTimeZoneForOffset(offset);
 860             }
 861
 862             // Note: For now, no distinction between long/short localized GMT format in the parser.
 863             // This might be changed in future.
 864             evaluated |= STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT];
 865
 866             break;
 867         }
 868     case UTZFMT_STYLE_LOCALIZED_GMT_SHORT:
 869         {
 870             tmpPos.setIndex(startIdx);
 871             tmpPos.setErrorIndex(-1);
 872
 873             offset = parseOffsetShortLocalizedGMT(text, tmpPos);
 874             if (tmpPos.getErrorIndex() == -1) {
 875                 pos.setIndex(tmpPos.getIndex());
 876                 return createTimeZoneForOffset(offset);
 877             }
 878
 879             // Note: For now, no distinction between long/short localized GMT format in the parser.
 880             // This might be changed in future.
 881             evaluated |= STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT];
 882
 883             break;
 884         }
 885     case UTZFMT_STYLE_ISO_BASIC_SHORT:
 886     case UTZFMT_STYLE_ISO_BASIC_FIXED:
 887     case UTZFMT_STYLE_ISO_BASIC_FULL:
 888     case UTZFMT_STYLE_ISO_EXTENDED_FIXED:
 889     case UTZFMT_STYLE_ISO_EXTENDED_FULL:
 890         {
 891             tmpPos.setIndex(startIdx);
 892             tmpPos.setErrorIndex(-1);
 893
 894             offset = parseOffsetISO8601(text, tmpPos);
 895             if (tmpPos.getErrorIndex() == -1) {
 896                 pos.setIndex(tmpPos.getIndex());
 897                 return createTimeZoneForOffset(offset);
 898             }
 899
 900             break;
 901         }
 902
 903     case UTZFMT_STYLE_ISO_BASIC_LOCAL_SHORT:
 904     case UTZFMT_STYLE_ISO_BASIC_LOCAL_FIXED:
 905     case UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL:
 906     case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FIXED:
 907     case UTZFMT_STYLE_ISO_EXTENDED_LOCAL_FULL:
 908         {
 909             tmpPos.setIndex(startIdx);
 910             tmpPos.setErrorIndex(-1);
 911
 912             // Exclude the case of UTC Indicator "Z" here
 913             UBool hasDigitOffset = FALSE;
 914             offset = parseOffsetISO8601(text, tmpPos, FALSE, &hasDigitOffset);
 915             if (tmpPos.getErrorIndex() == -1 && hasDigitOffset) {
 916                 pos.setIndex(tmpPos.getIndex());
 917                 return createTimeZoneForOffset(offset);
 918             }
 919
 920             break;
 921         }
 922
 923     case UTZFMT_STYLE_SPECIFIC_LONG:
 924     case UTZFMT_STYLE_SPECIFIC_SHORT:
 925         {
 926             // Specific styles
 927             int32_t nameTypes = 0;
 928             if (style == UTZFMT_STYLE_SPECIFIC_LONG) {
 929                 nameTypes = (UTZNM_LONG_STANDARD | UTZNM_LONG_DAYLIGHT);
 930             } else {
 931                 U_ASSERT(style == UTZFMT_STYLE_SPECIFIC_SHORT);
 932                 nameTypes = (UTZNM_SHORT_STANDARD | UTZNM_SHORT_DAYLIGHT);
 933             }
 934             LocalPointer<TimeZoneNames::MatchInfoCollection> specificMatches(fTimeZoneNames->find(text, startIdx, nameTypes, status));
 935             if (U_FAILURE(status)) {
 936                 pos.setErrorIndex(startIdx);
 937                 return NULL;
 938             }
 939             if (!specificMatches.isNull()) {
 940                 int32_t matchIdx = -1;
 941                 int32_t matchPos = -1;
 942                 for (int32_t i = 0; i < specificMatches->size(); i++) {
 943                     matchPos  = startIdx + specificMatches->getMatchLengthAt(i);
 944                     if (matchPos > parsedPos) {
 945                         matchIdx = i;
 946                         parsedPos = matchPos;
 947                     }
 948                 }
 949                 if (matchIdx >= 0) {
 950                     if (timeType) {
 951                         *timeType = getTimeType(specificMatches->getNameTypeAt(matchIdx));
 952                     }
 953                     pos.setIndex(matchPos);
 954                     getTimeZoneID(specificMatches.getAlias(), matchIdx, tzID);
 955                     U_ASSERT(!tzID.isEmpty());
 956                     return TimeZone::createTimeZone(tzID);
 957                 }
 958             }
 959             break;
 960         }
 961     case UTZFMT_STYLE_GENERIC_LONG:
 962     case UTZFMT_STYLE_GENERIC_SHORT:
 963     case UTZFMT_STYLE_GENERIC_LOCATION:
 964         {
 965             int32_t genericNameTypes = 0;
 966             switch (style) {
 967             case UTZFMT_STYLE_GENERIC_LOCATION:
 968                 genericNameTypes = UTZGNM_LOCATION;
 969                 break;
 970
 971             case UTZFMT_STYLE_GENERIC_LONG:
 972                 genericNameTypes = UTZGNM_LONG | UTZGNM_LOCATION;
 973                 break;
 974
 975             case UTZFMT_STYLE_GENERIC_SHORT:
 976                 genericNameTypes = UTZGNM_SHORT | UTZGNM_LOCATION;
 977                 break;
 978
 979             default:
 980                 U_ASSERT(FALSE);
 981             }
 982
 983             int32_t len = 0;
 984             UTimeZoneFormatTimeType tt = UTZFMT_TIME_TYPE_UNKNOWN;
 985             const TimeZoneGenericNames *gnames = getTimeZoneGenericNames(status);
 986             if (U_SUCCESS(status)) {
 987                 len = gnames->findBestMatch(text, startIdx, genericNameTypes, tzID, tt, status);
 988             }
 989             if (U_FAILURE(status)) {
 990                 pos.setErrorIndex(startIdx);
 991                 return NULL;
 992             }
 993             if (len > 0) {
 994                 // Found a match
 995                 if (timeType) {
 996                     *timeType = tt;
 997                 }
 998                 pos.setIndex(startIdx + len);
 999                 U_ASSERT(!tzID.isEmpty());
1000                 return TimeZone::createTimeZone(tzID);
1001             }
1002
1003             break;
1004         }
1005     case UTZFMT_STYLE_ZONE_ID:
1006         {
1007             tmpPos.setIndex(startIdx);
1008             tmpPos.setErrorIndex(-1);
1009
1010             parseZoneID(text, tmpPos, tzID);
1011             if (tmpPos.getErrorIndex() == -1) {
1012                 pos.setIndex(tmpPos.getIndex());
1013                 return TimeZone::createTimeZone(tzID);
1014             }
1015             break;
1016         }
1017     case UTZFMT_STYLE_ZONE_ID_SHORT:
1018         {
1019             tmpPos.setIndex(startIdx);
1020             tmpPos.setErrorIndex(-1);
1021
1022             parseShortZoneID(text, tmpPos, tzID);
1023             if (tmpPos.getErrorIndex() == -1) {
1024                 pos.setIndex(tmpPos.getIndex());
1025                 return TimeZone::createTimeZone(tzID);
1026             }
1027             break;
1028         }
1029     case UTZFMT_STYLE_EXEMPLAR_LOCATION:
1030         {
1031             tmpPos.setIndex(startIdx);
1032             tmpPos.setErrorIndex(-1);
1033
1034             parseExemplarLocation(text, tmpPos, tzID);
1035             if (tmpPos.getErrorIndex() == -1) {
1036                 pos.setIndex(tmpPos.getIndex());
1037                 return TimeZone::createTimeZone(tzID);
1038             }
1039             break;
1040         }
1041     }
1042     evaluated |= STYLE_PARSE_FLAGS[style];
1043
1044
1045     if (parsedPos > startIdx) {
1046         // When the specified style is one of SPECIFIC_XXX or GENERIC_XXX, we tried to parse the input
1047         // as localized GMT format earlier. If parsedOffset is positive, it means it was successfully
1048         // parsed as localized GMT format, but offset digits were not detected (more specifically, GMT
1049         // zero format). Then, it tried to find a match within the set of display names, but could not
1050         // find a match. At this point, we can safely assume the input text contains the localized
1051         // GMT format.
1052         U_ASSERT(parsedOffset != UNKNOWN_OFFSET);
1053         pos.setIndex(parsedPos);
1054         return createTimeZoneForOffset(parsedOffset);
1055     }
1056
1057     // Failed to parse the input text as the time zone format in the specified style.
1058     // Check the longest match among other styles below.
1059     UnicodeString parsedID;
1060     UTimeZoneFormatTimeType parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1061
1062     U_ASSERT(parsedPos < 0);
1063     U_ASSERT(parsedOffset == UNKNOWN_OFFSET);
1064
1065     // ISO 8601
1066     if (parsedPos < maxPos &&
1067         ((evaluated & ISO_Z_STYLE_FLAG) == 0 || (evaluated & ISO_LOCAL_STYLE_FLAG) == 0)) {
1068         tmpPos.setIndex(startIdx);
1069         tmpPos.setErrorIndex(-1);
1070
1071         UBool hasDigitOffset = FALSE;
1072         offset = parseOffsetISO8601(text, tmpPos, FALSE, &hasDigitOffset);
1073         if (tmpPos.getErrorIndex() == -1) {
1074             if (tmpPos.getIndex() == maxPos || hasDigitOffset) {
1075                 pos.setIndex(tmpPos.getIndex());
1076                 return createTimeZoneForOffset(offset);
1077             }
1078             // Note: When ISO 8601 format contains offset digits, it should not
1079             // collide with other formats. However, ISO 8601 UTC format "Z" (single letter)
1080             // may collide with other names. In this case, we need to evaluate other names.
1081             if (parsedPos < tmpPos.getIndex()) {
1082                 parsedOffset = offset;
1083                 parsedID.setToBogus();
1084                 parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1085                 parsedPos = tmpPos.getIndex();
1086                 U_ASSERT(parsedPos == startIdx + 1);    // only when "Z" is used
1087             }
1088         }
1089     }
1090
1091     // Localized GMT format
1092     if (parsedPos < maxPos &&
1093         (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT]) == 0) {
1094         tmpPos.setIndex(startIdx);
1095         tmpPos.setErrorIndex(-1);
1096
1097         UBool hasDigitOffset = FALSE;
1098         offset = parseOffsetLocalizedGMT(text, tmpPos, FALSE, &hasDigitOffset);
1099         if (tmpPos.getErrorIndex() == -1) {
1100             if (tmpPos.getIndex() == maxPos || hasDigitOffset) {
1101                 pos.setIndex(tmpPos.getIndex());
1102                 return createTimeZoneForOffset(offset);
1103             }
1104             // Evaluate other names - see the comment earlier in this method.
1105             if (parsedPos < tmpPos.getIndex()) {
1106                 parsedOffset = offset;
1107                 parsedID.setToBogus();
1108                 parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1109                 parsedPos = tmpPos.getIndex();
1110             }
1111         }
1112     }
1113
1114     if (parsedPos < maxPos &&
1115         (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_LOCALIZED_GMT_SHORT]) == 0) {
1116         tmpPos.setIndex(startIdx);
1117         tmpPos.setErrorIndex(-1);
1118
1119         UBool hasDigitOffset = FALSE;
1120         offset = parseOffsetLocalizedGMT(text, tmpPos, TRUE, &hasDigitOffset);
1121         if (tmpPos.getErrorIndex() == -1) {
1122             if (tmpPos.getIndex() == maxPos || hasDigitOffset) {
1123                 pos.setIndex(tmpPos.getIndex());
1124                 return createTimeZoneForOffset(offset);
1125             }
1126             // Evaluate other names - see the comment earlier in this method.
1127             if (parsedPos < tmpPos.getIndex()) {
1128                 parsedOffset = offset;
1129                 parsedID.setToBogus();
1130                 parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1131                 parsedPos = tmpPos.getIndex();
1132             }
1133         }
1134     }
1135
1136     // When ParseOption.ALL_STYLES is available, we also try to look all possible display names and IDs.
1137     // For example, when style is GENERIC_LONG, "EST" (SPECIFIC_SHORT) is never
1138     // used for America/New_York. With parseAllStyles true, this code parses "EST"
1139     // as America/New_York.
1140
1141     // Note: Adding all possible names into the trie used by the implementation is quite heavy operation,
1142     // which we want to avoid normally (note that we cache the trie, so this is applicable to the
1143     // first time only as long as the cache does not expire).
1144
1145     if (parseOptions & UTZFMT_PARSE_OPTION_ALL_STYLES) {
1146         // Try all specific names and exemplar location names
1147         if (parsedPos < maxPos) {
1148             LocalPointer<TimeZoneNames::MatchInfoCollection> specificMatches(fTimeZoneNames->find(text, startIdx, ALL_SIMPLE_NAME_TYPES, status));
1149             if (U_FAILURE(status)) {
1150                 pos.setErrorIndex(startIdx);
1151                 return NULL;
1152             }
1153             int32_t specificMatchIdx = -1;
1154             int32_t matchPos = -1;
1155             if (!specificMatches.isNull()) {
1156                 for (int32_t i = 0; i < specificMatches->size(); i++) {
1157                     if (startIdx + specificMatches->getMatchLengthAt(i) > matchPos) {
1158                         specificMatchIdx = i;
1159                         matchPos = startIdx + specificMatches->getMatchLengthAt(i);
1160                     }
1161                 }
1162             }
1163             if (parsedPos < matchPos) {
1164                 U_ASSERT(specificMatchIdx >= 0);
1165                 parsedPos = matchPos;
1166                 getTimeZoneID(specificMatches.getAlias(), specificMatchIdx, parsedID);
1167                 parsedTimeType = getTimeType(specificMatches->getNameTypeAt(specificMatchIdx));
1168                 parsedOffset = UNKNOWN_OFFSET;
1169             }
1170         }
1171         // Try generic names
1172         if (parsedPos < maxPos) {
1173             int32_t genMatchLen = -1;
1174             UTimeZoneFormatTimeType tt = UTZFMT_TIME_TYPE_UNKNOWN;
1175
1176             const TimeZoneGenericNames *gnames = getTimeZoneGenericNames(status);
1177             if (U_SUCCESS(status)) {
1178                 genMatchLen = gnames->findBestMatch(text, startIdx, ALL_GENERIC_NAME_TYPES, tzID, tt, status);
1179             }
1180             if (U_FAILURE(status)) {
1181                 pos.setErrorIndex(startIdx);
1182                 return NULL;
1183             }
1184
1185             if (parsedPos < startIdx + genMatchLen) {
1186                 parsedPos = startIdx + genMatchLen;
1187                 parsedID.setTo(tzID);
1188                 parsedTimeType = tt;
1189                 parsedOffset = UNKNOWN_OFFSET;
1190             }
1191         }
1192
1193         // Try time zone ID
1194         if (parsedPos < maxPos && (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_ZONE_ID]) == 0) {
1195             tmpPos.setIndex(startIdx);
1196             tmpPos.setErrorIndex(-1);
1197
1198             parseZoneID(text, tmpPos, tzID);
1199             if (tmpPos.getErrorIndex() == -1 && parsedPos < tmpPos.getIndex()) {
1200                 parsedPos = tmpPos.getIndex();
1201                 parsedID.setTo(tzID);
1202                 parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1203                 parsedOffset = UNKNOWN_OFFSET;
1204             }
1205         }
1206         // Try short time zone ID
1207         if (parsedPos < maxPos && (evaluated & STYLE_PARSE_FLAGS[UTZFMT_STYLE_ZONE_ID]) == 0) {
1208             tmpPos.setIndex(startIdx);
1209             tmpPos.setErrorIndex(-1);
1210
1211             parseShortZoneID(text, tmpPos, tzID);
1212             if (tmpPos.getErrorIndex() == -1 && parsedPos < tmpPos.getIndex()) {
1213                 parsedPos = tmpPos.getIndex();
1214                 parsedID.setTo(tzID);
1215                 parsedTimeType = UTZFMT_TIME_TYPE_UNKNOWN;
1216                 parsedOffset = UNKNOWN_OFFSET;
1217             }
1218         }
1219     }
1220
1221     if (parsedPos > startIdx) {
1222         // Parsed successfully
1223         TimeZone* parsedTZ;
1224         if (parsedID.length() > 0) {
1225             parsedTZ = TimeZone::createTimeZone(parsedID);
1226         } else {
1227             U_ASSERT(parsedOffset != UNKNOWN_OFFSET);
1228             parsedTZ = createTimeZoneForOffset(parsedOffset);
1229         }
1230         if (timeType) {
1231             *timeType = parsedTimeType;
1232         }
1233         pos.setIndex(parsedPos);
1234         return parsedTZ;
1235     }
1236
1237     pos.setErrorIndex(startIdx);
1238     return NULL;
1239 }
1240
1241 void
1242 TimeZoneFormat::parseObject(const UnicodeString& source, Formattable& result,
1243         ParsePosition& parse_pos) const {
1244     result.adoptObject(parse(UTZFMT_STYLE_GENERIC_LOCATION, source, parse_pos, UTZFMT_PARSE_OPTION_ALL_STYLES));
1245 }
1246
1247
1248 // ------------------------------------------------------------------
1249 // Private zone name format/parse implementation
1250
1251 UnicodeString&
1252 TimeZoneFormat::formatGeneric(const TimeZone& tz, int32_t genType, UDate date, UnicodeString& name) const {
1253     UErrorCode status = U_ZERO_ERROR;
1254     const TimeZoneGenericNames* gnames = getTimeZoneGenericNames(status);
1255     if (U_FAILURE(status)) {
1256         name.setToBogus();
1257         return name;
1258     }
1259
1260     if (genType == UTZGNM_LOCATION) {
1261         const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(tz);
1262         if (canonicalID == NULL) {
1263             name.setToBogus();
1264             return name;
1265         }
1266         return gnames->getGenericLocationName(UnicodeString(canonicalID), name);
1267     }
1268     return gnames->getDisplayName(tz, (UTimeZoneGenericNameType)genType, date, name);
1269 }
1270
1271 UnicodeString&
1272 TimeZoneFormat::formatSpecific(const TimeZone& tz, UTimeZoneNameType stdType, UTimeZoneNameType dstType,
1273         UDate date, UnicodeString& name, UTimeZoneFormatTimeType *timeType) const {
1274     if (fTimeZoneNames == NULL) {
1275         name.setToBogus();
1276         return name;
1277     }
1278
1279     UErrorCode status = U_ZERO_ERROR;
1280     UBool isDaylight = tz.inDaylightTime(date, status);
1281     const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(tz);
1282
1283     if (U_FAILURE(status) || canonicalID == NULL) {
1284         name.setToBogus();
1285         return name;
1286     }
1287
1288     if (isDaylight) {
1289         fTimeZoneNames->getDisplayName(UnicodeString(canonicalID), dstType, date, name);
1290     } else {
1291         fTimeZoneNames->getDisplayName(UnicodeString(canonicalID), stdType, date, name);
1292     }
1293
1294     if (timeType && !name.isEmpty()) {
1295         *timeType = isDaylight ? UTZFMT_TIME_TYPE_DAYLIGHT : UTZFMT_TIME_TYPE_STANDARD;
1296     }
1297     return name;
1298 }
1299
1300 const TimeZoneGenericNames*
1301 TimeZoneFormat::getTimeZoneGenericNames(UErrorCode& status) const {
1302     if (U_FAILURE(status)) {
1303         return NULL;
1304     }
1305
1306     umtx_lock(&gLock);
1307     if (fTimeZoneGenericNames == NULL) {
1308         TimeZoneFormat *nonConstThis = const_cast<TimeZoneFormat *>(this);
1309         nonConstThis->fTimeZoneGenericNames = TimeZoneGenericNames::createInstance(fLocale, status);
1310     }
1311     umtx_unlock(&gLock);
1312
1313     return fTimeZoneGenericNames;
1314 }
1315
1316 UnicodeString&
1317 TimeZoneFormat::formatExemplarLocation(const TimeZone& tz, UnicodeString& name) const {
1318     UnicodeString location;
1319     const UChar* canonicalID = ZoneMeta::getCanonicalCLDRID(tz);
1320
1321     if (canonicalID) {
1322         fTimeZoneNames->getExemplarLocationName(UnicodeString(canonicalID), location);
1323     }
1324     if (location.length() > 0) {
1325         name.setTo(location);
1326     } else {
1327         // Use "unknown" location
1328         fTimeZoneNames->getExemplarLocationName(UnicodeString(UNKNOWN_ZONE_ID), location);
1329         if (location.length() > 0) {
1330             name.setTo(location);
1331         } else {
1332             // last resort
1333             name.setTo(UNKNOWN_LOCATION, -1);
1334         }
1335     }
1336     return name;
1337 }
1338
1339
1340 // ------------------------------------------------------------------
1341 // Zone offset format and parse
1342
1343 UnicodeString&
1344 TimeZoneFormat::formatOffsetISO8601Basic(int32_t offset, UBool useUtcIndicator, UBool isShort, UBool ignoreSeconds,
1345         UnicodeString& result, UErrorCode& status) const {
1346     return formatOffsetISO8601(offset, TRUE, useUtcIndicator, isShort, ignoreSeconds, result, status);
1347 }
1348
1349 UnicodeString&
1350 TimeZoneFormat::formatOffsetISO8601Extended(int32_t offset, UBool useUtcIndicator, UBool isShort, UBool ignoreSeconds,
1351         UnicodeString& result, UErrorCode& status) const {
1352     return formatOffsetISO8601(offset, FALSE, useUtcIndicator, isShort, ignoreSeconds, result, status);
1353 }
1354
1355 UnicodeString&
1356 TimeZoneFormat::formatOffsetLocalizedGMT(int32_t offset, UnicodeString& result, UErrorCode& status) const {
1357     return formatOffsetLocalizedGMT(offset, FALSE, result, status);
1358 }
1359
1360 UnicodeString&
1361 TimeZoneFormat::formatOffsetShortLocalizedGMT(int32_t offset, UnicodeString& result, UErrorCode& status) const {
1362     return formatOffsetLocalizedGMT(offset, TRUE, result, status);
1363 }
1364
1365 int32_t
1366 TimeZoneFormat::parseOffsetISO8601(const UnicodeString& text, ParsePosition& pos) const {
1367     return parseOffsetISO8601(text, pos, FALSE);
1368 }
1369
1370 int32_t
1371 TimeZoneFormat::parseOffsetLocalizedGMT(const UnicodeString& text, ParsePosition& pos) const {
1372     return parseOffsetLocalizedGMT(text, pos, FALSE, NULL);
1373 }
1374
1375 int32_t
1376 TimeZoneFormat::parseOffsetShortLocalizedGMT(const UnicodeString& text, ParsePosition& pos) const {
1377     return parseOffsetLocalizedGMT(text, pos, TRUE, NULL);
1378 }
1379
1380 // ------------------------------------------------------------------
1381 // Private zone offset format/parse implementation
1382
1383 UnicodeString&
1384 TimeZoneFormat::formatOffsetISO8601(int32_t offset, UBool isBasic, UBool useUtcIndicator,
1385         UBool isShort, UBool ignoreSeconds, UnicodeString& result, UErrorCode& status) const {
1386     if (U_FAILURE(status)) {
1387         result.setToBogus();
1388         return result;
1389     }
1390     int32_t absOffset = offset < 0 ? -offset : offset;
1391     if (useUtcIndicator && (absOffset < MILLIS_PER_SECOND || (ignoreSeconds && absOffset < MILLIS_PER_MINUTE))) {
1392         result.setTo(ISO8601_UTC);
1393         return result;
1394     }
1395
1396     OffsetFields minFields = isShort ? FIELDS_H : FIELDS_HM;
1397     OffsetFields maxFields = ignoreSeconds ? FIELDS_HM : FIELDS_HMS;
1398     UChar sep = isBasic ? 0 : ISO8601_SEP;
1399
1400     // Note: FIELDS_HMS as maxFields is a CLDR/ICU extension. ISO 8601 specification does
1401     // not support seconds field.
1402
1403     if (absOffset >= MAX_OFFSET) {
1404         result.setToBogus();
1405         status = U_ILLEGAL_ARGUMENT_ERROR;
1406         return result;
1407     }
1408
1409     int fields[3];
1410     fields[0] = absOffset / MILLIS_PER_HOUR;
1411     absOffset = absOffset % MILLIS_PER_HOUR;
1412     fields[1] = absOffset / MILLIS_PER_MINUTE;
1413     absOffset = absOffset % MILLIS_PER_MINUTE;
1414     fields[2] = absOffset / MILLIS_PER_SECOND;
1415
1416     U_ASSERT(fields[0] >= 0 && fields[0] <= MAX_OFFSET_HOUR);
1417     U_ASSERT(fields[1] >= 0 && fields[1] <= MAX_OFFSET_MINUTE);
1418     U_ASSERT(fields[2] >= 0 && fields[2] <= MAX_OFFSET_SECOND);
1419
1420     int32_t lastIdx = maxFields;
1421     while (lastIdx > minFields) {
1422         if (fields[lastIdx] != 0) {
1423             break;
1424         }
1425         lastIdx--;
1426     }
1427
1428     UChar sign = PLUS;
1429     if (offset < 0) {
1430         // if all output fields are 0s, do not use negative sign
1431         for (int32_t idx = 0; idx <= lastIdx; idx++) {
1432             if (fields[idx] != 0) {
1433                 sign = MINUS;
1434                 break;
1435             }
1436         }
1437     }
1438     result.setTo(sign);
1439
1440     for (int32_t idx = 0; idx <= lastIdx; idx++) {
1441         if (sep && idx != 0) {
1442             result.append(sep);
1443         }
1444         result.append((UChar)(0x0030 + fields[idx]/10));
1445         result.append((UChar)(0x0030 + fields[idx]%10));
1446     }
1447
1448     return result;
1449 }
1450
1451 UnicodeString&
1452 TimeZoneFormat::formatOffsetLocalizedGMT(int32_t offset, UBool isShort, UnicodeString& result, UErrorCode& status) const {
1453     if (U_FAILURE(status)) {
1454         result.setToBogus();
1455         return result;
1456     }
1457     if (offset <= -MAX_OFFSET || offset >= MAX_OFFSET) {
1458         result.setToBogus();
1459         status = U_ILLEGAL_ARGUMENT_ERROR;
1460         return result;
1461     }
1462
1463     if (offset == 0) {
1464         result.setTo(fGMTZeroFormat);
1465         return result;
1466     }
1467
1468     UBool positive = TRUE;
1469     if (offset < 0) {
1470         offset = -offset;
1471         positive = FALSE;
1472     }
1473
1474     int32_t offsetH = offset / MILLIS_PER_HOUR;
1475     offset = offset % MILLIS_PER_HOUR;
1476     int32_t offsetM = offset / MILLIS_PER_MINUTE;
1477     offset = offset % MILLIS_PER_MINUTE;
1478     int32_t offsetS = offset / MILLIS_PER_SECOND;
1479
1480     U_ASSERT(offsetH <= MAX_OFFSET_HOUR && offsetM <= MAX_OFFSET_MINUTE && offsetS <= MAX_OFFSET_SECOND);
1481
1482     const UVector* offsetPatternItems = NULL;
1483     if (positive) {
1484         if (offsetS != 0) {
1485             offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_POSITIVE_HMS];
1486         } else if (offsetM != 0 || !isShort) {
1487             offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_POSITIVE_HM];
1488         } else {
1489             offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_POSITIVE_H];
1490         }
1491     } else {
1492         if (offsetS != 0) {
1493             offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_NEGATIVE_HMS];
1494         } else if (offsetM != 0 || !isShort) {
1495             offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_NEGATIVE_HM];
1496         } else {
1497             offsetPatternItems = fGMTOffsetPatternItems[UTZFMT_PAT_NEGATIVE_H];
1498         }
1499     }
1500
1501     U_ASSERT(offsetPatternItems != NULL);
1502
1503     // Building the GMT format string
1504     result.setTo(fGMTPatternPrefix);
1505
1506     for (int32_t i = 0; i < offsetPatternItems->size(); i++) {
1507         const GMTOffsetField* item = (GMTOffsetField*)offsetPatternItems->elementAt(i);
1508         GMTOffsetField::FieldType type = item->getType();
1509
1510         switch (type) {
1511         case GMTOffsetField::TEXT:
1512             result.append(item->getPatternText(), -1);
1513             break;
1514
1515         case GMTOffsetField::HOUR:
1516             appendOffsetDigits(result, offsetH, (isShort ? 1 : 2));
1517             break;
1518
1519         case GMTOffsetField::MINUTE:
1520             appendOffsetDigits(result, offsetM, 2);
1521             break;
1522
1523         case GMTOffsetField::SECOND:
1524             appendOffsetDigits(result, offsetS, 2);
1525             break;
1526         }
1527     }
1528
1529     result.append(fGMTPatternSuffix);
1530     return result;
1531 }
1532
1533 int32_t
1534 TimeZoneFormat::parseOffsetISO8601(const UnicodeString& text, ParsePosition& pos, UBool extendedOnly, UBool* hasDigitOffset /* = NULL */) const {
1535     if (hasDigitOffset) {
1536         *hasDigitOffset = FALSE;
1537     }
1538     int32_t start = pos.getIndex();
1539     if (start >= text.length()) {
1540         pos.setErrorIndex(start);
1541         return 0;
1542     }
1543
1544     UChar firstChar = text.charAt(start);
1545     if (firstChar == ISO8601_UTC || firstChar == (UChar)(ISO8601_UTC + 0x20)) {
1546         // "Z" (or "z") - indicates UTC
1547         pos.setIndex(start + 1);
1548         return 0;
1549     }
1550
1551     int32_t sign = 1;
1552     if (firstChar == PLUS) {
1553         sign = 1;
1554     } else if (firstChar == MINUS) {
1555         sign = -1;
1556     } else {
1557         // Not an ISO 8601 offset string
1558         pos.setErrorIndex(start);
1559         return 0;
1560     }
1561     ParsePosition posOffset(start + 1);
1562     int32_t offset = parseAsciiOffsetFields(text, posOffset, ISO8601_SEP, FIELDS_H, FIELDS_HMS);
1563     if (posOffset.getErrorIndex() == -1 && !extendedOnly && (posOffset.getIndex() - start <= 3)) {
1564         // If the text is successfully parsed as extended format with the options above, it can be also parsed
1565         // as basic format. For example, "0230" can be parsed as offset 2:00 (only first digits are valid for
1566         // extended format), but it can be parsed as offset 2:30 with basic format. We use longer result.
1567         ParsePosition posBasic(start + 1);
1568         int32_t tmpOffset = parseAbuttingAsciiOffsetFields(text, posBasic, FIELDS_H, FIELDS_HMS, FALSE);
1569         if (posBasic.getErrorIndex() == -1 && posBasic.getIndex() > posOffset.getIndex()) {
1570             offset = tmpOffset;
1571             posOffset.setIndex(posBasic.getIndex());
1572         }
1573     }
1574
1575     if (posOffset.getErrorIndex() != -1) {
1576         pos.setErrorIndex(start);
1577         return 0;
1578     }
1579
1580     pos.setIndex(posOffset.getIndex());
1581     if (hasDigitOffset) {
1582         *hasDigitOffset = TRUE;
1583     }
1584     return sign * offset;
1585 }
1586
1587 int32_t
1588 TimeZoneFormat::parseOffsetLocalizedGMT(const UnicodeString& text, ParsePosition& pos, UBool isShort, UBool* hasDigitOffset) const {
1589     int32_t start = pos.getIndex();
1590     int32_t offset = 0;
1591     int32_t parsedLength = 0;
1592
1593     if (hasDigitOffset) {
1594         *hasDigitOffset = FALSE;
1595     }
1596
1597     offset = parseOffsetLocalizedGMTPattern(text, start, isShort, parsedLength);
1598
1599     // For now, parseOffsetLocalizedGMTPattern handles both long and short
1600     // formats, no matter isShort is true or false. This might be changed in future
1601     // when strict parsing is necessary, or different set of patterns are used for
1602     // short/long formats.
1603 #if 0
1604     if (parsedLength == 0) {
1605         offset = parseOffsetLocalizedGMTPattern(text, start, !isShort, parsedLength);
1606     }
1607 #endif
1608
1609     if (parsedLength > 0) {
1610         if (hasDigitOffset) {
1611             *hasDigitOffset = TRUE;
1612         }
1613         pos.setIndex(start + parsedLength);
1614         return offset;
1615     }
1616
1617     // Try the default patterns
1618     offset = parseOffsetDefaultLocalizedGMT(text, start, parsedLength);
1619     if (parsedLength > 0) {
1620         if (hasDigitOffset) {
1621             *hasDigitOffset = TRUE;
1622         }
1623         pos.setIndex(start + parsedLength);
1624         return offset;
1625     }
1626
1627     // Check if this is a GMT zero format
1628     if (text.caseCompare(start, fGMTZeroFormat.length(), fGMTZeroFormat, 0) == 0) {
1629         pos.setIndex(start + fGMTZeroFormat.length());
1630         return 0;
1631     }
1632
1633     // Check if this is a default GMT zero format
1634     for (int32_t i = 0; ALT_GMT_STRINGS[i][0] != 0; i++) {
1635         const UChar* defGMTZero = ALT_GMT_STRINGS[i];
1636         int32_t defGMTZeroLen = u_strlen(defGMTZero);
1637         if (text.caseCompare(start, defGMTZeroLen, defGMTZero, 0) == 0) {
1638             pos.setIndex(start + defGMTZeroLen);
1639             return 0;
1640         }
1641     }
1642
1643     // Nothing matched
1644     pos.setErrorIndex(start);
1645     return 0;
1646 }
1647
1648 int32_t
1649 TimeZoneFormat::parseOffsetLocalizedGMTPattern(const UnicodeString& text, int32_t start, UBool /*isShort*/, int32_t& parsedLen) const {
1650     int32_t idx = start;
1651     int32_t offset = 0;
1652     UBool parsed = FALSE;
1653
1654     do {
1655         // Prefix part
1656         int32_t len = fGMTPatternPrefix.length();
1657         if (len > 0 && text.caseCompare(idx, len, fGMTPatternPrefix, 0) != 0) {
1658             // prefix match failed
1659             break;
1660         }
1661         idx += len;
1662
1663         // Offset part
1664         offset = parseOffsetFields(text, idx, FALSE, len);
1665         if (len == 0) {
1666             // offset field match failed
1667             break;
1668         }
1669         idx += len;
1670
1671         len = fGMTPatternSuffix.length();
1672         if (len > 0 && text.caseCompare(idx, len, fGMTPatternSuffix, 0) != 0) {
1673             // no suffix match
1674             break;
1675         }
1676         idx += len;
1677         parsed = TRUE;
1678     } while (FALSE);
1679
1680     parsedLen = parsed ? idx - start : 0;
1681     return offset;
1682 }
1683
1684 int32_t
1685 TimeZoneFormat::parseOffsetFields(const UnicodeString& text, int32_t start, UBool /*isShort*/, int32_t& parsedLen) const {
1686     int32_t outLen = 0;
1687     int32_t offset = 0;
1688     int32_t sign = 1;
1689
1690     parsedLen = 0;
1691
1692     int32_t offsetH, offsetM, offsetS;
1693     offsetH = offsetM = offsetS = 0;
1694
1695     for (int32_t patidx = 0; PARSE_GMT_OFFSET_TYPES[patidx] >= 0; patidx++) {
1696         int32_t gmtPatType = PARSE_GMT_OFFSET_TYPES[patidx];
1697         UVector* items = fGMTOffsetPatternItems[gmtPatType];
1698         U_ASSERT(items != NULL);
1699
1700         outLen = parseOffsetFieldsWithPattern(text, start, items, FALSE, offsetH, offsetM, offsetS);
1701         if (outLen > 0) {
1702             sign = (gmtPatType == UTZFMT_PAT_POSITIVE_H || gmtPatType == UTZFMT_PAT_POSITIVE_HM || gmtPatType == UTZFMT_PAT_POSITIVE_HMS) ?
1703                 1 : -1;
1704             break;
1705         }
1706     }
1707
1708     if (outLen > 0 && fAbuttingOffsetHoursAndMinutes) {
1709         // When hours field is sabutting minutes field,
1710         // the parse result above may not be appropriate.
1711         // For example, "01020" is parsed as 01:02: above,
1712         // but it should be parsed as 00:10:20.
1713         int32_t tmpLen = 0;
1714         int32_t tmpSign = 1;
1715         int32_t tmpH, tmpM, tmpS;
1716
1717         for (int32_t patidx = 0; PARSE_GMT_OFFSET_TYPES[patidx] >= 0; patidx++) {
1718             int32_t gmtPatType = PARSE_GMT_OFFSET_TYPES[patidx];
1719             UVector* items = fGMTOffsetPatternItems[gmtPatType];
1720             U_ASSERT(items != NULL);
1721
1722             // forcing parse to use single hour digit
1723             tmpLen = parseOffsetFieldsWithPattern(text, start, items, TRUE, tmpH, tmpM, tmpS);
1724             if (tmpLen > 0) {
1725                 tmpSign = (gmtPatType == UTZFMT_PAT_POSITIVE_H || gmtPatType == UTZFMT_PAT_POSITIVE_HM || gmtPatType == UTZFMT_PAT_POSITIVE_HMS) ?
1726                     1 : -1;
1727                 break;
1728             }
1729         }
1730         if (tmpLen > outLen) {
1731             // Better parse result with single hour digit
1732             outLen = tmpLen;
1733             sign = tmpSign;
1734             offsetH = tmpH;
1735             offsetM = tmpM;
1736             offsetS = tmpS;
1737         }
1738     }
1739
1740     if (outLen > 0) {
1741         offset = ((((offsetH * 60) + offsetM) * 60) + offsetS) * 1000 * sign;
1742         parsedLen = outLen;
1743     }
1744
1745     return offset;
1746 }
1747
1748 int32_t
1749 TimeZoneFormat::parseOffsetFieldsWithPattern(const UnicodeString& text, int32_t start,
1750         UVector* patternItems, UBool forceSingleHourDigit, int32_t& hour, int32_t& min, int32_t& sec) const {
1751     UBool failed = FALSE;
1752     int32_t offsetH, offsetM, offsetS;
1753     offsetH = offsetM = offsetS = 0;
1754     int32_t idx = start;
1755
1756     for (int32_t i = 0; i < patternItems->size(); i++) {
1757         int32_t len = 0;
1758         const GMTOffsetField* field = (const GMTOffsetField*)patternItems->elementAt(i);
1759         GMTOffsetField::FieldType fieldType = field->getType();
1760         if (fieldType == GMTOffsetField::TEXT) {
1761             const UChar* patStr = field->getPatternText();
1762             len = u_strlen(patStr);
1763             if (text.caseCompare(idx, len, patStr, 0) != 0) {
1764                 failed = TRUE;
1765                 break;
1766             }
1767             idx += len;
1768         } else {
1769             if (fieldType == GMTOffsetField::HOUR) {
1770                 uint8_t maxDigits = forceSingleHourDigit ? 1 : 2;
1771                 offsetH = parseOffsetFieldWithLocalizedDigits(text, idx, 1, maxDigits, 0, MAX_OFFSET_HOUR, len);
1772             } else if (fieldType == GMTOffsetField::MINUTE) {
1773                 offsetM = parseOffsetFieldWithLocalizedDigits(text, idx, 2, 2, 0, MAX_OFFSET_MINUTE, len);
1774             } else if (fieldType == GMTOffsetField::SECOND) {
1775                 offsetS = parseOffsetFieldWithLocalizedDigits(text, idx, 2, 2, 0, MAX_OFFSET_SECOND, len);
1776             }
1777
1778             if (len == 0) {
1779                 failed = TRUE;
1780                 break;
1781             }
1782             idx += len;
1783         }
1784     }
1785
1786     if (failed) {
1787         hour = min = sec = 0;
1788         return 0;
1789     }
1790
1791     hour = offsetH;
1792     min = offsetM;
1793     sec = offsetS;
1794
1795     return idx - start;
1796 }
1797
1798 int32_t
1799 TimeZoneFormat::parseAbuttingOffsetFields(const UnicodeString& text, int32_t start, int32_t& parsedLen) const {
1800     int32_t digits[MAX_OFFSET_DIGITS];
1801     int32_t parsed[MAX_OFFSET_DIGITS];  // accumulative offsets
1802
1803     // Parse digits into int[]
1804     int32_t idx = start;
1805     int32_t len = 0;
1806     int32_t numDigits = 0;
1807     for (int32_t i = 0; i < MAX_OFFSET_DIGITS; i++) {
1808         digits[i] = parseSingleLocalizedDigit(text, idx, len);
1809         if (digits[i] < 0) {
1810             break;
1811         }
1812         idx += len;
1813         parsed[i] = idx - start;
1814         numDigits++;
1815     }
1816
1817     if (numDigits == 0) {
1818         parsedLen = 0;
1819         return 0;
1820     }
1821
1822     int32_t offset = 0;
1823     while (numDigits > 0) {
1824         int32_t hour = 0;
1825         int32_t min = 0;
1826         int32_t sec = 0;
1827
1828         U_ASSERT(numDigits > 0 && numDigits <= MAX_OFFSET_DIGITS);
1829         switch (numDigits) {
1830         case 1: // H
1831             hour = digits[0];
1832             break;
1833         case 2: // HH
1834             hour = digits[0] * 10 + digits[1];
1835             break;
1836         case 3: // Hmm
1837             hour = digits[0];
1838             min = digits[1] * 10 + digits[2];
1839             break;
1840         case 4: // HHmm
1841             hour = digits[0] * 10 + digits[1];
1842             min = digits[2] * 10 + digits[3];
1843             break;
1844         case 5: // Hmmss
1845             hour = digits[0];
1846             min = digits[1] * 10 + digits[2];
1847             sec = digits[3] * 10 + digits[4];
1848             break;
1849         case 6: // HHmmss
1850             hour = digits[0] * 10 + digits[1];
1851             min = digits[2] * 10 + digits[3];
1852             sec = digits[4] * 10 + digits[5];
1853             break;
1854         }
1855         if (hour <= MAX_OFFSET_HOUR && min <= MAX_OFFSET_MINUTE && sec <= MAX_OFFSET_SECOND) {
1856             // found a valid combination
1857             offset = hour * MILLIS_PER_HOUR + min * MILLIS_PER_MINUTE + sec * MILLIS_PER_SECOND;
1858             parsedLen = parsed[numDigits - 1];
1859             break;
1860         }
1861         numDigits--;
1862     }
1863     return offset;
1864 }
1865
1866 int32_t
1867 TimeZoneFormat::parseOffsetDefaultLocalizedGMT(const UnicodeString& text, int start, int32_t& parsedLen) const {
1868     int32_t idx = start;
1869     int32_t offset = 0;
1870     int32_t parsed = 0;
1871
1872     do {
1873         // check global default GMT alternatives
1874         int32_t gmtLen = 0;
1875
1876         for (int32_t i = 0; ALT_GMT_STRINGS[i][0] != 0; i++) {
1877             const UChar* gmt = ALT_GMT_STRINGS[i];
1878             int32_t len = u_strlen(gmt);
1879             if (text.caseCompare(start, len, gmt, 0) == 0) {
1880                 gmtLen = len;
1881                 break;
1882             }
1883         }
1884         if (gmtLen == 0) {
1885             break;
1886         }
1887         idx += gmtLen;
1888
1889         // offset needs a sign char and a digit at minimum
1890         if (idx + 1 >= text.length()) {
1891             break;
1892         }
1893
1894         // parse sign
1895         int32_t sign = 1;
1896         UChar c = text.charAt(idx);
1897         if (c == PLUS) {
1898             sign = 1;
1899         } else if (c == MINUS) {
1900             sign = -1;
1901         } else {
1902             break;
1903         }
1904         idx++;
1905
1906         // offset part
1907         // try the default pattern with the separator first
1908         int32_t lenWithSep = 0;
1909         int32_t offsetWithSep = parseDefaultOffsetFields(text, idx, DEFAULT_GMT_OFFSET_SEP, lenWithSep);
1910         if (lenWithSep == text.length() - idx) {
1911             // maximum match
1912             offset = offsetWithSep * sign;
1913             idx += lenWithSep;
1914         } else {
1915             // try abutting field pattern
1916             int32_t lenAbut = 0;
1917             int32_t offsetAbut = parseAbuttingOffsetFields(text, idx, lenAbut);
1918
1919             if (lenWithSep > lenAbut) {
1920                 offset = offsetWithSep * sign;
1921                 idx += lenWithSep;
1922             } else {
1923                 offset = offsetAbut * sign;
1924                 idx += lenAbut;
1925             }
1926         }
1927         parsed = idx - start;
1928     } while (false);
1929
1930     parsedLen = parsed;
1931     return offset;
1932 }
1933
1934 int32_t
1935 TimeZoneFormat::parseDefaultOffsetFields(const UnicodeString& text, int32_t start, UChar separator, int32_t& parsedLen) const {
1936     int32_t max = text.length();
1937     int32_t idx = start;
1938     int32_t len = 0;
1939     int32_t hour = 0, min = 0, sec = 0;
1940
1941     parsedLen = 0;
1942
1943     do {
1944         hour = parseOffsetFieldWithLocalizedDigits(text, idx, 1, 2, 0, MAX_OFFSET_HOUR, len);
1945         if (len == 0) {
1946             break;
1947         }
1948         idx += len;
1949
1950         if (idx + 1 < max && text.charAt(idx) == separator) {
1951             min = parseOffsetFieldWithLocalizedDigits(text, idx + 1, 2, 2, 0, MAX_OFFSET_MINUTE, len);
1952             if (len == 0) {
1953                 break;
1954             }
1955             idx += (1 + len);
1956
1957             if (idx + 1 < max && text.charAt(idx) == separator) {
1958                 sec = parseOffsetFieldWithLocalizedDigits(text, idx + 1, 2, 2, 0, MAX_OFFSET_SECOND, len);
1959                 if (len == 0) {
1960                     break;
1961                 }
1962                 idx += (1 + len);
1963             }
1964         }
1965     } while (FALSE);
1966
1967     if (idx == start) {
1968         return 0;
1969     }
1970
1971     parsedLen = idx - start;
1972     return hour * MILLIS_PER_HOUR + min * MILLIS_PER_MINUTE + sec * MILLIS_PER_SECOND;
1973 }
1974
1975 int32_t
1976 TimeZoneFormat::parseOffsetFieldWithLocalizedDigits(const UnicodeString& text, int32_t start, uint8_t minDigits, uint8_t maxDigits, uint16_t minVal, uint16_t maxVal, int32_t& parsedLen) const {
1977     parsedLen = 0;
1978
1979     int32_t decVal = 0;
1980     int32_t numDigits = 0;
1981     int32_t idx = start;
1982     int32_t digitLen = 0;
1983
1984     while (idx < text.length() && numDigits < maxDigits) {
1985         int32_t digit = parseSingleLocalizedDigit(text, idx, digitLen);
1986         if (digit < 0) {
1987             break;
1988         }
1989         int32_t tmpVal = decVal * 10 + digit;
1990         if (tmpVal > maxVal) {
1991             break;
1992         }
1993         decVal = tmpVal;
1994         numDigits++;
1995         idx += digitLen;
1996     }
1997
1998     // Note: maxVal is checked in the while loop
1999     if (numDigits < minDigits || decVal < minVal) {
2000         decVal = -1;
2001         numDigits = 0;
2002     } else {
2003         parsedLen = idx - start;
2004     }
2005
2006     return decVal;
2007 }
2008
2009 int32_t
2010 TimeZoneFormat::parseSingleLocalizedDigit(const UnicodeString& text, int32_t start, int32_t& len) const {
2011     int32_t digit = -1;
2012     len = 0;
2013     if (start < text.length()) {
2014         UChar32 cp = text.char32At(start);
2015
2016         // First, try digits configured for this instance
2017         for (int32_t i = 0; i < 10; i++) {
2018             if (cp == fGMTOffsetDigits[i]) {
2019                 digit = i;
2020                 break;
2021             }
2022         }
2023         // If failed, check if this is a Unicode digit
2024         if (digit < 0) {
2025             int32_t tmp = u_charDigitValue(cp);
2026             digit = (tmp >= 0 && tmp <= 9) ? tmp : -1;
2027         }
2028
2029         if (digit >= 0) {
2030             int32_t next = text.moveIndex32(start, 1);
2031             len = next - start;
2032         }
2033     }
2034     return digit;
2035 }
2036
2037 UnicodeString&
2038 TimeZoneFormat::formatOffsetWithAsciiDigits(int32_t offset, UChar sep, OffsetFields minFields, OffsetFields maxFields, UnicodeString& result) {
2039     U_ASSERT(maxFields >= minFields);
2040     U_ASSERT(offset > -MAX_OFFSET && offset < MAX_OFFSET);
2041
2042     UChar sign = PLUS;
2043     if (offset < 0) {
2044         sign = MINUS;
2045         offset = -offset;
2046     }
2047     result.setTo(sign);
2048
2049     int fields[3];
2050     fields[0] = offset / MILLIS_PER_HOUR;
2051     offset = offset % MILLIS_PER_HOUR;
2052     fields[1] = offset / MILLIS_PER_MINUTE;
2053     offset = offset % MILLIS_PER_MINUTE;
2054     fields[2] = offset / MILLIS_PER_SECOND;
2055
2056     U_ASSERT(fields[0] >= 0 && fields[0] <= MAX_OFFSET_HOUR);
2057     U_ASSERT(fields[1] >= 0 && fields[1] <= MAX_OFFSET_MINUTE);
2058     U_ASSERT(fields[2] >= 0 && fields[2] <= MAX_OFFSET_SECOND);
2059
2060     int32_t lastIdx = maxFields;
2061     while (lastIdx > minFields) {
2062         if (fields[lastIdx] != 0) {
2063             break;
2064         }
2065         lastIdx--;
2066     }
2067
2068     for (int32_t idx = 0; idx <= lastIdx; idx++) {
2069         if (sep && idx != 0) {
2070             result.append(sep);
2071         }
2072         result.append((UChar)(0x0030 + fields[idx]/10));
2073         result.append((UChar)(0x0030 + fields[idx]%10));
2074     }
2075
2076     return result;
2077 }
2078
2079 int32_t
2080 TimeZoneFormat::parseAbuttingAsciiOffsetFields(const UnicodeString& text, ParsePosition& pos, OffsetFields minFields, OffsetFields maxFields, UBool fixedHourWidth) {
2081     int32_t start = pos.getIndex();
2082
2083     int32_t minDigits = 2 * (minFields + 1) - (fixedHourWidth ? 0 : 1);
2084     int32_t maxDigits = 2 * (maxFields + 1);
2085
2086     U_ASSERT(maxDigits <= MAX_OFFSET_DIGITS);
2087
2088     int32_t digits[MAX_OFFSET_DIGITS] = {};
2089     int32_t numDigits = 0;
2090     int32_t idx = start;
2091     while (numDigits < maxDigits && idx < text.length()) {
2092         UChar uch = text.charAt(idx);
2093         int32_t digit = DIGIT_VAL(uch);
2094         if (digit < 0) {
2095             break;
2096         }
2097         digits[numDigits] = digit;
2098         numDigits++;
2099         idx++;
2100     }
2101
2102     if (fixedHourWidth && (numDigits & 1)) {
2103         // Fixed digits, so the number of digits must be even number. Truncating.
2104         numDigits--;
2105     }
2106
2107     if (numDigits < minDigits) {
2108         pos.setErrorIndex(start);
2109         return 0;
2110     }
2111
2112     int32_t hour = 0, min = 0, sec = 0;
2113     UBool bParsed = FALSE;
2114     while (numDigits >= minDigits) {
2115         switch (numDigits) {
2116         case 1: //H
2117             hour = digits[0];
2118             break;
2119         case 2: //HH
2120             hour = digits[0] * 10 + digits[1];
2121             break;
2122         case 3: //Hmm
2123             hour = digits[0];
2124             min = digits[1] * 10 + digits[2];
2125             break;
2126         case 4: //HHmm
2127             hour = digits[0] * 10 + digits[1];
2128             min = digits[2] * 10 + digits[3];
2129             break;
2130         case 5: //Hmmss
2131             hour = digits[0];
2132             min = digits[1] * 10 + digits[2];
2133             sec = digits[3] * 10 + digits[4];
2134             break;
2135         case 6: //HHmmss
2136             hour = digits[0] * 10 + digits[1];
2137             min = digits[2] * 10 + digits[3];
2138             sec = digits[4] * 10 + digits[5];
2139             break;
2140         }
2141
2142         if (hour <= MAX_OFFSET_HOUR && min <= MAX_OFFSET_MINUTE && sec <= MAX_OFFSET_SECOND) {
2143             // Successfully parsed
2144             bParsed = true;
2145             break;
2146         }
2147
2148         // Truncating
2149         numDigits -= (fixedHourWidth ? 2 : 1);
2150         hour = min = sec = 0;
2151     }
2152
2153     if (!bParsed) {
2154         pos.setErrorIndex(start);
2155         return 0;
2156     }
2157     pos.setIndex(start + numDigits);
2158     return ((((hour * 60) + min) * 60) + sec) * 1000;
2159 }
2160
2161 int32_t
2162 TimeZoneFormat::parseAsciiOffsetFields(const UnicodeString& text, ParsePosition& pos, UChar sep, OffsetFields minFields, OffsetFields maxFields) {
2163     int32_t start = pos.getIndex();
2164     int32_t fieldVal[] = {0, 0, 0};
2165     int32_t fieldLen[] = {0, -1, -1};
2166     for (int32_t idx = start, fieldIdx = 0; idx < text.length() && fieldIdx <= maxFields; idx++) {
2167         UChar c = text.charAt(idx);
2168         if (c == sep) {
2169             if (fieldIdx == 0) {
2170                 if (fieldLen[0] == 0) {
2171                     // no hours field
2172                     break;
2173                 }
2174                 // 1 digit hour, move to next field
2175             } else {
2176                 if (fieldLen[fieldIdx] != -1) {
2177                     // premature minute or seconds field
2178                     break;
2179                 }
2180                 fieldLen[fieldIdx] = 0;
2181             }
2182             continue;
2183         } else if (fieldLen[fieldIdx] == -1) {
2184             // no separator after 2 digit field
2185             break;
2186         }
2187         int32_t digit = DIGIT_VAL(c);
2188         if (digit < 0) {
2189             // not a digit
2190             break;
2191         }
2192         fieldVal[fieldIdx] = fieldVal[fieldIdx] * 10 + digit;
2193         fieldLen[fieldIdx]++;
2194         if (fieldLen[fieldIdx] >= 2) {
2195             // parsed 2 digits, move to next field
2196             fieldIdx++;
2197         }
2198     }
2199
2200     int32_t offset = 0;
2201     int32_t parsedLen = 0;
2202     int32_t parsedFields = -1;
2203     do {
2204         // hour
2205         if (fieldLen[0] == 0) {
2206             break;
2207         }
2208         if (fieldVal[0] > MAX_OFFSET_HOUR) {
2209             offset = (fieldVal[0] / 10) * MILLIS_PER_HOUR;
2210             parsedFields = FIELDS_H;
2211             parsedLen = 1;
2212             break;
2213         }
2214         offset = fieldVal[0] * MILLIS_PER_HOUR;
2215         parsedLen = fieldLen[0];
2216         parsedFields = FIELDS_H;
2217
2218         // minute
2219         if (fieldLen[1] != 2 || fieldVal[1] > MAX_OFFSET_MINUTE) {
2220             break;
2221         }
2222         offset += fieldVal[1] * MILLIS_PER_MINUTE;
2223         parsedLen += (1 + fieldLen[1]);
2224         parsedFields = FIELDS_HM;
2225
2226         // second
2227         if (fieldLen[2] != 2 || fieldVal[2] > MAX_OFFSET_SECOND) {
2228             break;
2229         }
2230         offset += fieldVal[2] * MILLIS_PER_SECOND;
2231         parsedLen += (1 + fieldLen[2]);
2232         parsedFields = FIELDS_HMS;
2233     } while (false);
2234
2235     if (parsedFields < minFields) {
2236         pos.setErrorIndex(start);
2237         return 0;
2238     }
2239
2240     pos.setIndex(start + parsedLen);
2241     return offset;
2242 }
2243
2244 void
2245 TimeZoneFormat::appendOffsetDigits(UnicodeString& buf, int32_t n, uint8_t minDigits) const {
2246     U_ASSERT(n >= 0 && n < 60);
2247     int32_t numDigits = n >= 10 ? 2 : 1;
2248     for (int32_t i = 0; i < minDigits - numDigits; i++) {
2249         buf.append(fGMTOffsetDigits[0]);
2250     }
2251     if (numDigits == 2) {
2252         buf.append(fGMTOffsetDigits[n / 10]);
2253     }
2254     buf.append(fGMTOffsetDigits[n % 10]);
2255 }
2256
2257 // ------------------------------------------------------------------
2258 // Private misc
2259 void
2260 TimeZoneFormat::initGMTPattern(const UnicodeString& gmtPattern, UErrorCode& status) {
2261     if (U_FAILURE(status)) {
2262         return;
2263     }
2264     // This implementation not perfect, but sufficient practically.
2265     int32_t idx = gmtPattern.indexOf(ARG0, ARG0_LEN, 0);
2266     if (idx < 0) {
2267         status = U_ILLEGAL_ARGUMENT_ERROR;
2268         return;
2269     }
2270     fGMTPattern.setTo(gmtPattern);
2271     unquote(gmtPattern.tempSubString(0, idx), fGMTPatternPrefix);
2272     unquote(gmtPattern.tempSubString(idx + ARG0_LEN), fGMTPatternSuffix);
2273 }
2274
2275 UnicodeString&
2276 TimeZoneFormat::unquote(const UnicodeString& pattern, UnicodeString& result) {
2277     if (pattern.indexOf(SINGLEQUOTE) < 0) {
2278         result.setTo(pattern);
2279         return result;
2280     }
2281     result.remove();
2282     UBool isPrevQuote = FALSE;
2283     UBool inQuote = FALSE;
2284     for (int32_t i = 0; i < pattern.length(); i++) {
2285         UChar c = pattern.charAt(i);
2286         if (c == SINGLEQUOTE) {
2287             if (isPrevQuote) {
2288                 result.append(c);
2289                 isPrevQuote = FALSE;
2290             } else {
2291                 isPrevQuote = TRUE;
2292             }
2293             inQuote = !inQuote;
2294         } else {
2295             isPrevQuote = FALSE;
2296             result.append(c);
2297         }
2298     }
2299     return result;
2300 }
2301
2302 UVector*
2303 TimeZoneFormat::parseOffsetPattern(const UnicodeString& pattern, OffsetFields required, UErrorCode& status) {
2304     if (U_FAILURE(status)) {
2305         return NULL;
2306     }
2307     UVector* result = new UVector(deleteGMTOffsetField, NULL, status);
2308     if (result == NULL) {
2309         status = U_MEMORY_ALLOCATION_ERROR;
2310         return NULL;
2311     }
2312
2313     int32_t checkBits = 0;
2314     UBool isPrevQuote = FALSE;
2315     UBool inQuote = FALSE;
2316     UnicodeString text;
2317     GMTOffsetField::FieldType itemType = GMTOffsetField::TEXT;
2318     int32_t itemLength = 1;
2319
2320     for (int32_t i = 0; i < pattern.length(); i++) {
2321         UChar ch = pattern.charAt(i);
2322         if (ch == SINGLEQUOTE) {
2323             if (isPrevQuote) {
2324                 text.append(SINGLEQUOTE);
2325                 isPrevQuote = FALSE;
2326             } else {
2327                 isPrevQuote = TRUE;
2328                 if (itemType != GMTOffsetField::TEXT) {
2329                     if (GMTOffsetField::isValid(itemType, itemLength)) {
2330                         GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, (uint8_t)itemLength, status);
2331                         result->addElement(fld, status);
2332                         if (U_FAILURE(status)) {
2333                             break;
2334                         }
2335                     } else {
2336                         status = U_ILLEGAL_ARGUMENT_ERROR;
2337                         break;
2338                     }
2339                     itemType = GMTOffsetField::TEXT;
2340                 }
2341             }
2342             inQuote = !inQuote;
2343         } else {
2344             isPrevQuote = FALSE;
2345             if (inQuote) {
2346                 text.append(ch);
2347             } else {
2348                 GMTOffsetField::FieldType tmpType = GMTOffsetField::getTypeByLetter(ch);
2349                 if (tmpType != GMTOffsetField::TEXT) {
2350                     // an offset time pattern character
2351                     if (tmpType == itemType) {
2352                         itemLength++;
2353                     } else {
2354                         if (itemType == GMTOffsetField::TEXT) {
2355                             if (text.length() > 0) {
2356                                 GMTOffsetField* textfld = GMTOffsetField::createText(text, status);
2357                                 result->addElement(textfld, status);
2358                                 if (U_FAILURE(status)) {
2359                                     break;
2360                                 }
2361                                 text.remove();
2362                             }
2363                         } else {
2364                             if (GMTOffsetField::isValid(itemType, itemLength)) {
2365                                 GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, itemLength, status);
2366                                 result->addElement(fld, status);
2367                                 if (U_FAILURE(status)) {
2368                                     break;
2369                                 }
2370                             } else {
2371                                 status = U_ILLEGAL_ARGUMENT_ERROR;
2372                                 break;
2373                             }
2374                         }
2375                         itemType = tmpType;
2376                         itemLength = 1;
2377                         checkBits |= tmpType;
2378                     }
2379                 } else {
2380                     // a string literal
2381                     if (itemType != GMTOffsetField::TEXT) {
2382                         if (GMTOffsetField::isValid(itemType, itemLength)) {
2383                             GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, itemLength, status);
2384                             result->addElement(fld, status);
2385                             if (U_FAILURE(status)) {
2386                                 break;
2387                             }
2388                         } else {
2389                             status = U_ILLEGAL_ARGUMENT_ERROR;
2390                             break;
2391                         }
2392                         itemType = GMTOffsetField::TEXT;
2393                     }
2394                     text.append(ch);
2395                 }
2396             }
2397         }
2398     }
2399     // handle last item
2400     if (U_SUCCESS(status)) {
2401         if (itemType == GMTOffsetField::TEXT) {
2402             if (text.length() > 0) {
2403                 GMTOffsetField* tfld = GMTOffsetField::createText(text, status);
2404                 result->addElement(tfld, status);
2405             }
2406         } else {
2407             if (GMTOffsetField::isValid(itemType, itemLength)) {
2408                 GMTOffsetField* fld = GMTOffsetField::createTimeField(itemType, itemLength, status);
2409                 result->addElement(fld, status);
2410             } else {
2411                 status = U_ILLEGAL_ARGUMENT_ERROR;
2412             }
2413         }
2414
2415         // Check all required fields are set
2416         if (U_SUCCESS(status)) {
2417             int32_t reqBits = 0;
2418             switch (required) {
2419             case FIELDS_H:
2420                 reqBits = GMTOffsetField::HOUR;
2421                 break;
2422             case FIELDS_HM:
2423                 reqBits = GMTOffsetField::HOUR | GMTOffsetField::MINUTE;
2424                 break;
2425             case FIELDS_HMS:
2426                 reqBits = GMTOffsetField::HOUR | GMTOffsetField::MINUTE | GMTOffsetField::SECOND;
2427                 break;
2428             }
2429             if (checkBits == reqBits) {
2430                 // all required fields are set, no extra fields
2431                 return result;
2432             }
2433         }
2434     }
2435
2436     // error
2437     delete result;
2438     return NULL;
2439 }
2440
2441 UnicodeString&
2442 TimeZoneFormat::expandOffsetPattern(const UnicodeString& offsetHM, UnicodeString& result, UErrorCode& status) {
2443     result.setToBogus();
2444     if (U_FAILURE(status)) {
2445         return result;
2446     }
2447     U_ASSERT(u_strlen(DEFAULT_GMT_OFFSET_MINUTE_PATTERN) == 2);
2448
2449     int32_t idx_mm = offsetHM.indexOf(DEFAULT_GMT_OFFSET_MINUTE_PATTERN, 2, 0);
2450     if (idx_mm < 0) {
2451         // Bad time zone hour pattern data
2452         status = U_ILLEGAL_ARGUMENT_ERROR;
2453         return result;
2454     }
2455
2456     UnicodeString sep;
2457     int32_t idx_H = offsetHM.tempSubString(0, idx_mm).lastIndexOf((UChar)0x0048 /* H */);
2458     if (idx_H >= 0) {
2459         sep = offsetHM.tempSubString(idx_H + 1, idx_mm - (idx_H + 1));
2460     }
2461     result.setTo(offsetHM.tempSubString(0, idx_mm + 2));
2462     result.append(sep);
2463     result.append(DEFAULT_GMT_OFFSET_SECOND_PATTERN, -1);
2464     result.append(offsetHM.tempSubString(idx_mm + 2));
2465     return result;
2466 }
2467
2468 UnicodeString&
2469 TimeZoneFormat::truncateOffsetPattern(const UnicodeString& offsetHM, UnicodeString& result, UErrorCode& status) {
2470     result.setToBogus();
2471     if (U_FAILURE(status)) {
2472         return result;
2473     }
2474     U_ASSERT(u_strlen(DEFAULT_GMT_OFFSET_MINUTE_PATTERN) == 2);
2475
2476     int32_t idx_mm = offsetHM.indexOf(DEFAULT_GMT_OFFSET_MINUTE_PATTERN, 2, 0);
2477     if (idx_mm < 0) {
2478         // Bad time zone hour pattern data
2479         status = U_ILLEGAL_ARGUMENT_ERROR;
2480         return result;
2481     }
2482     UChar HH[] = {0x0048, 0x0048};
2483     int32_t idx_HH = offsetHM.tempSubString(0, idx_mm).lastIndexOf(HH, 2, 0);
2484     if (idx_HH >= 0) {
2485         return result.setTo(offsetHM.tempSubString(0, idx_HH + 2));
2486     }
2487     int32_t idx_H = offsetHM.tempSubString(0, idx_mm).lastIndexOf((UChar)0x0048, 0);
2488     if (idx_H >= 0) {
2489         return result.setTo(offsetHM.tempSubString(0, idx_H + 1));
2490     }
2491     // Bad time zone hour pattern data
2492     status = U_ILLEGAL_ARGUMENT_ERROR;
2493     return result;
2494 }
2495
2496 void
2497 TimeZoneFormat::initGMTOffsetPatterns(UErrorCode& status) {
2498     for (int32_t type = 0; type < UTZFMT_PAT_COUNT; type++) {
2499         switch (type) {
2500         case UTZFMT_PAT_POSITIVE_H:
2501         case UTZFMT_PAT_NEGATIVE_H:
2502             fGMTOffsetPatternItems[type] = parseOffsetPattern(fGMTOffsetPatterns[type], FIELDS_H, status);
2503             break;
2504         case UTZFMT_PAT_POSITIVE_HM:
2505         case UTZFMT_PAT_NEGATIVE_HM:
2506             fGMTOffsetPatternItems[type] = parseOffsetPattern(fGMTOffsetPatterns[type], FIELDS_HM, status);
2507             break;
2508         case UTZFMT_PAT_POSITIVE_HMS:
2509         case UTZFMT_PAT_NEGATIVE_HMS:
2510             fGMTOffsetPatternItems[type] = parseOffsetPattern(fGMTOffsetPatterns[type], FIELDS_HMS, status);
2511             break;
2512         }
2513     }
2514     checkAbuttingHoursAndMinutes();
2515 }
2516
2517 void
2518 TimeZoneFormat::checkAbuttingHoursAndMinutes() {
2519     fAbuttingOffsetHoursAndMinutes= FALSE;
2520     for (int32_t type = 0; type < UTZFMT_PAT_COUNT; type++) {
2521         UBool afterH = FALSE;
2522         UVector *items = fGMTOffsetPatternItems[type];
2523         for (int32_t i = 0; i < items->size(); i++) {
2524             const GMTOffsetField* item = (GMTOffsetField*)items->elementAt(i);
2525             GMTOffsetField::FieldType type = item->getType();
2526             if (type != GMTOffsetField::TEXT) {
2527                 if (afterH) {
2528                     fAbuttingOffsetHoursAndMinutes = TRUE;
2529                     break;
2530                 } else if (type == GMTOffsetField::HOUR) {
2531                     afterH = TRUE;
2532                 }
2533             } else if (afterH) {
2534                 break;
2535             }
2536         }
2537         if (fAbuttingOffsetHoursAndMinutes) {
2538             break;
2539         }
2540     }
2541 }
2542
2543 UBool
2544 TimeZoneFormat::toCodePoints(const UnicodeString& str, UChar32* codeArray, int32_t size) {
2545     int32_t count = str.countChar32();
2546     if (count != size) {
2547         return FALSE;
2548     }
2549
2550     for (int32_t idx = 0, start = 0; idx < size; idx++) {
2551         codeArray[idx] = str.char32At(start);
2552         start = str.moveIndex32(start, 1);
2553     }
2554
2555     return TRUE;
2556 }
2557
2558 TimeZone*
2559 TimeZoneFormat::createTimeZoneForOffset(int32_t offset) const {
2560     if (offset == 0) {
2561         // when offset is 0, we should use "Etc/GMT"
2562         return TimeZone::createTimeZone(UnicodeString(TZID_GMT));
2563     }
2564     return ZoneMeta::createCustomTimeZone(offset);
2565 }
2566
2567 UTimeZoneFormatTimeType
2568 TimeZoneFormat::getTimeType(UTimeZoneNameType nameType) {
2569     switch (nameType) {
2570     case UTZNM_LONG_STANDARD:
2571     case UTZNM_SHORT_STANDARD:
2572         return UTZFMT_TIME_TYPE_STANDARD;
2573
2574     case UTZNM_LONG_DAYLIGHT:
2575     case UTZNM_SHORT_DAYLIGHT:
2576         return UTZFMT_TIME_TYPE_DAYLIGHT;
2577
2578     default:
2579         U_ASSERT(FALSE);
2580     }
2581     return UTZFMT_TIME_TYPE_UNKNOWN;
2582 }
2583
2584 UnicodeString&
2585 TimeZoneFormat::getTimeZoneID(const TimeZoneNames::MatchInfoCollection* matches, int32_t idx, UnicodeString& tzID) const {
2586     if (!matches->getTimeZoneIDAt(idx, tzID)) {
2587         UnicodeString mzID;
2588         if (matches->getMetaZoneIDAt(idx, mzID)) {
2589             fTimeZoneNames->getReferenceZoneID(mzID, fTargetRegion, tzID);
2590         }
2591     }
2592     return tzID;
2593 }
2594
2595
2596 class ZoneIdMatchHandler : public TextTrieMapSearchResultHandler {
2597 public:
2598     ZoneIdMatchHandler();
2599     virtual ~ZoneIdMatchHandler();
2600
2601     UBool handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status);
2602     const UChar* getID();
2603     int32_t getMatchLen();
2604 private:
2605     int32_t fLen;
2606     const UChar* fID;
2607 };
2608
2609 ZoneIdMatchHandler::ZoneIdMatchHandler()
2610 : fLen(0), fID(NULL) {
2611 }
2612
2613 ZoneIdMatchHandler::~ZoneIdMatchHandler() {
2614 }
2615
2616 UBool
2617 ZoneIdMatchHandler::handleMatch(int32_t matchLength, const CharacterNode *node, UErrorCode &status) {
2618     if (U_FAILURE(status)) {
2619         return FALSE;
2620     }
2621     if (node->hasValues()) {
2622         const UChar* id = (const UChar*)node->getValue(0);
2623         if (id != NULL) {
2624             if (fLen < matchLength) {
2625                 fID = id;
2626                 fLen = matchLength;
2627             }
2628         }
2629     }
2630     return TRUE;
2631 }
2632
2633 const UChar*
2634 ZoneIdMatchHandler::getID() {
2635     return fID;
2636 }
2637
2638 int32_t
2639 ZoneIdMatchHandler::getMatchLen() {
2640     return fLen;
2641 }
2642
2643
2644 static void U_CALLCONV initZoneIdTrie(UErrorCode &status) {
2645     U_ASSERT(gZoneIdTrie == NULL);
2646     ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONEFORMAT, tzfmt_cleanup);
2647     gZoneIdTrie = new TextTrieMap(TRUE, NULL);    // No deleter, because values are pooled by ZoneMeta
2648     if (gZoneIdTrie == NULL) {
2649         status = U_MEMORY_ALLOCATION_ERROR;
2650         return;
2651     }
2652     StringEnumeration *tzenum = TimeZone::createEnumeration();
2653     const UnicodeString *id;
2654     while ((id = tzenum->snext(status))) {
2655         const UChar* uid = ZoneMeta::findTimeZoneID(*id);
2656         if (uid) {
2657             gZoneIdTrie->put(uid, const_cast<UChar *>(uid), status);
2658         }
2659     }
2660     delete tzenum;
2661 }
2662
2663
2664 UnicodeString&
2665 TimeZoneFormat::parseZoneID(const UnicodeString& text, ParsePosition& pos, UnicodeString& tzID) const {
2666     UErrorCode status = U_ZERO_ERROR;
2667     umtx_initOnce(gZoneIdTrieInitOnce, &initZoneIdTrie, status);
2668
2669     int32_t start = pos.getIndex();
2670     int32_t len = 0;
2671     tzID.setToBogus();
2672
2673     if (U_SUCCESS(status)) {
2674         LocalPointer<ZoneIdMatchHandler> handler(new ZoneIdMatchHandler());
2675         gZoneIdTrie->search(text, start, handler.getAlias(), status);
2676         len = handler->getMatchLen();
2677         if (len > 0) {
2678             tzID.setTo(handler->getID(), -1);
2679         }
2680     }
2681
2682     if (len > 0) {
2683         pos.setIndex(start + len);
2684     } else {
2685         pos.setErrorIndex(start);
2686     }
2687
2688     return tzID;
2689 }
2690
2691 static void U_CALLCONV initShortZoneIdTrie(UErrorCode &status) {
2692     U_ASSERT(gShortZoneIdTrie == NULL);
2693     ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONEFORMAT, tzfmt_cleanup);
2694     StringEnumeration *tzenum = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL, NULL, NULL, status);
2695     if (U_SUCCESS(status)) {
2696         gShortZoneIdTrie = new TextTrieMap(TRUE, NULL);    // No deleter, because values are pooled by ZoneMeta
2697         if (gShortZoneIdTrie == NULL) {
2698             status = U_MEMORY_ALLOCATION_ERROR;
2699         } else {
2700             const UnicodeString *id;
2701             while ((id = tzenum->snext(status))) {
2702                 const UChar* uID = ZoneMeta::findTimeZoneID(*id);
2703                 const UChar* shortID = ZoneMeta::getShortID(*id);
2704                 if (shortID && uID) {
2705                     gShortZoneIdTrie->put(shortID, const_cast<UChar *>(uID), status);
2706                 }
2707             }
2708         }
2709     }
2710     delete tzenum;
2711 }
2712
2713
2714 UnicodeString&
2715 TimeZoneFormat::parseShortZoneID(const UnicodeString& text, ParsePosition& pos, UnicodeString& tzID) const {
2716     UErrorCode status = U_ZERO_ERROR;
2717     umtx_initOnce(gShortZoneIdTrieInitOnce, &initShortZoneIdTrie, status);
2718
2719     int32_t start = pos.getIndex();
2720     int32_t len = 0;
2721     tzID.setToBogus();
2722
2723     if (U_SUCCESS(status)) {
2724         LocalPointer<ZoneIdMatchHandler> handler(new ZoneIdMatchHandler());
2725         gShortZoneIdTrie->search(text, start, handler.getAlias(), status);
2726         len = handler->getMatchLen();
2727         if (len > 0) {
2728             tzID.setTo(handler->getID(), -1);
2729         }
2730     }
2731
2732     if (len > 0) {
2733         pos.setIndex(start + len);
2734     } else {
2735         pos.setErrorIndex(start);
2736     }
2737
2738     return tzID;
2739 }
2740
2741
2742 UnicodeString&
2743 TimeZoneFormat::parseExemplarLocation(const UnicodeString& text, ParsePosition& pos, UnicodeString& tzID) const {
2744     int32_t startIdx = pos.getIndex();
2745     int32_t parsedPos = -1;
2746     tzID.setToBogus();
2747
2748     UErrorCode status = U_ZERO_ERROR;
2749     LocalPointer<TimeZoneNames::MatchInfoCollection> exemplarMatches(fTimeZoneNames->find(text, startIdx, UTZNM_EXEMPLAR_LOCATION, status));
2750     if (U_FAILURE(status)) {
2751         pos.setErrorIndex(startIdx);
2752         return tzID;
2753     }
2754     int32_t matchIdx = -1;
2755     if (!exemplarMatches.isNull()) {
2756         for (int32_t i = 0; i < exemplarMatches->size(); i++) {
2757             if (startIdx + exemplarMatches->getMatchLengthAt(i) > parsedPos) {
2758                 matchIdx = i;
2759                 parsedPos = startIdx + exemplarMatches->getMatchLengthAt(i);
2760             }
2761         }
2762         if (parsedPos > 0) {
2763             pos.setIndex(parsedPos);
2764             getTimeZoneID(exemplarMatches.getAlias(), matchIdx, tzID);
2765         }
2766     }
2767
2768     if (tzID.length() == 0) {
2769         pos.setErrorIndex(startIdx);
2770     }
2771
2772     return tzID;
2773 }
2774
2775 U_NAMESPACE_END
2776
2777 #endif