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