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 2778
