1 /* 2 ******************************************************************************* 3 * Copyright (C) 1997-2013, International Business Machines Corporation and * 4 * others. All Rights Reserved. * 5 ******************************************************************************* 6 * 7 * File TIMEZONE.CPP 8 * 9 * Modification History: 10 * 11 * Date Name Description 12 * 12/05/96 clhuang Creation. 13 * 04/21/97 aliu General clean-up and bug fixing. 14 * 05/08/97 aliu Fixed Hashtable code per code review. 15 * 07/09/97 helena Changed createInstance to createDefault. 16 * 07/29/97 aliu Updated with all-new list of 96 UNIX-derived 17 * TimeZones. Changed mechanism to load from static 18 * array rather than resource bundle. 19 * 07/07/1998 srl Bugfixes from the Java side: UTC GMT CAT NST 20 * Added getDisplayName API 21 * going to add custom parsing. 22 * 23 * ISSUES: 24 * - should getDisplayName cache something? 25 * - should custom time zones be cached? [probably] 26 * 08/10/98 stephen Brought getDisplayName() API in-line w/ conventions 27 * 08/19/98 stephen Changed createTimeZone() to never return 0 28 * 09/02/98 stephen Added getOffset(monthLen) and hasSameRules() 29 * 09/15/98 stephen Added getStaticClassID() 30 * 02/22/99 stephen Removed character literals for EBCDIC safety 31 * 05/04/99 stephen Changed initDefault() for Mutex issues 32 * 07/12/99 helena HPUX 11 CC Port. 33 * 12/03/99 aliu Moved data out of static table into icudata.dll. 34 * Substantial rewrite of zone lookup, default zone, and 35 * available IDs code. Misc. cleanup. 36 *********************************************************************************/ 37 38 #include "utypeinfo.h" // for 'typeid' to work 39 40 #include "unicode/utypes.h" 41 #include "unicode/ustring.h" 42 #include "ustr_imp.h" 43 44 #ifdef U_DEBUG_TZ 45 # include <stdio.h> 46 # include "uresimp.h" // for debugging 47 48 static void debug_tz_loc(const char *f, int32_t l) 49 { 50 fprintf(stderr, "%s:%d: ", f, l); 51 } 52 53 static void debug_tz_msg(const char *pat, ...) 54 { 55 va_list ap; 56 va_start(ap, pat); 57 vfprintf(stderr, pat, ap); 58 fflush(stderr); 59 } 60 static char gStrBuf[256]; 61 #define U_DEBUG_TZ_STR(x) u_austrncpy(gStrBuf,x,sizeof(gStrBuf)-1) 62 // must use double parens, i.e.: U_DEBUG_TZ_MSG(("four is: %d",4)); 63 #define U_DEBUG_TZ_MSG(x) {debug_tz_loc(__FILE__,__LINE__);debug_tz_msg x;} 64 #else 65 #define U_DEBUG_TZ_MSG(x) 66 #endif 67 68 #if !UCONFIG_NO_FORMATTING 69 70 #include "unicode/simpletz.h" 71 #include "unicode/calendar.h" 72 #include "unicode/gregocal.h" 73 #include "unicode/ures.h" 74 #include "unicode/tzfmt.h" 75 #include "unicode/numfmt.h" 76 #include "gregoimp.h" 77 #include "uresimp.h" // struct UResourceBundle 78 #include "olsontz.h" 79 #include "mutex.h" 80 #include "unicode/udata.h" 81 #include "ucln_in.h" 82 #include "cstring.h" 83 #include "cmemory.h" 84 #include "unicode/strenum.h" 85 #include "uassert.h" 86 #include "zonemeta.h" 87 88 #define kZONEINFO "zoneinfo64" 89 #define kREGIONS "Regions" 90 #define kZONES "Zones" 91 #define kRULES "Rules" 92 #define kNAMES "Names" 93 #define kTZVERSION "TZVersion" 94 #define kLINKS "links" 95 #define kMAX_CUSTOM_HOUR 23 96 #define kMAX_CUSTOM_MIN 59 97 #define kMAX_CUSTOM_SEC 59 98 #define MINUS 0x002D 99 #define PLUS 0x002B 100 #define ZERO_DIGIT 0x0030 101 #define COLON 0x003A 102 103 // Static data and constants 104 105 static const UChar WORLD[] = {0x30, 0x30, 0x31, 0x00}; /* "001" */ 106 107 static const UChar GMT_ID[] = {0x47, 0x4D, 0x54, 0x00}; /* "GMT" */ 108 static const UChar UNKNOWN_ZONE_ID[] = {0x45, 0x74, 0x63, 0x2F, 0x55, 0x6E, 0x6B, 0x6E, 0x6F, 0x77, 0x6E, 0x00}; /* "Etc/Unknown" */ 109 static const int32_t GMT_ID_LENGTH = 3; 110 static const int32_t UNKNOWN_ZONE_ID_LENGTH = 11; 111 112 static UMutex LOCK = U_MUTEX_INITIALIZER; 113 static UMutex TZSET_LOCK = U_MUTEX_INITIALIZER; 114 static icu::TimeZone* DEFAULT_ZONE = NULL; 115 static icu::TimeZone* _GMT = NULL; 116 static icu::TimeZone* _UNKNOWN_ZONE = NULL; 117 118 static char TZDATA_VERSION[16]; 119 static UBool TZDataVersionInitialized = FALSE; 120 121 static int32_t* MAP_SYSTEM_ZONES = NULL; 122 static int32_t* MAP_CANONICAL_SYSTEM_ZONES = NULL; 123 static int32_t* MAP_CANONICAL_SYSTEM_LOCATION_ZONES = NULL; 124 125 static int32_t LEN_SYSTEM_ZONES = 0; 126 static int32_t LEN_CANONICAL_SYSTEM_ZONES = 0; 127 static int32_t LEN_CANONICAL_SYSTEM_LOCATION_ZONES = 0; 128 129 U_CDECL_BEGIN 130 static UBool U_CALLCONV timeZone_cleanup(void) 131 { 132 delete DEFAULT_ZONE; 133 DEFAULT_ZONE = NULL; 134 135 delete _GMT; 136 _GMT = NULL; 137 138 delete _UNKNOWN_ZONE; 139 _UNKNOWN_ZONE = NULL; 140 141 uprv_memset(TZDATA_VERSION, 0, sizeof(TZDATA_VERSION)); 142 TZDataVersionInitialized = FALSE; 143 144 LEN_SYSTEM_ZONES = 0; 145 uprv_free(MAP_SYSTEM_ZONES); 146 MAP_SYSTEM_ZONES = 0; 147 148 LEN_CANONICAL_SYSTEM_ZONES = 0; 149 uprv_free(MAP_CANONICAL_SYSTEM_ZONES); 150 MAP_CANONICAL_SYSTEM_ZONES = 0; 151 152 LEN_CANONICAL_SYSTEM_LOCATION_ZONES = 0; 153 uprv_free(MAP_CANONICAL_SYSTEM_LOCATION_ZONES); 154 MAP_CANONICAL_SYSTEM_LOCATION_ZONES = 0; 155 156 return TRUE; 157 } 158 U_CDECL_END 159 160 U_NAMESPACE_BEGIN 161 162 static int32_t findInStringArray(UResourceBundle* array, const UnicodeString& id, UErrorCode &status) 163 { 164 UnicodeString copy; 165 const UChar *u; 166 int32_t len; 167 168 int32_t start = 0; 169 int32_t limit = ures_getSize(array); 170 int32_t mid; 171 int32_t lastMid = INT32_MAX; 172 if(U_FAILURE(status) || (limit < 1)) { 173 return -1; 174 } 175 U_DEBUG_TZ_MSG(("fisa: Looking for %s, between %d and %d\n", U_DEBUG_TZ_STR(UnicodeString(id).getTerminatedBuffer()), start, limit)); 176 177 for (;;) { 178 mid = (int32_t)((start + limit) / 2); 179 if (lastMid == mid) { /* Have we moved? */ 180 break; /* We haven't moved, and it wasn't found. */ 181 } 182 lastMid = mid; 183 u = ures_getStringByIndex(array, mid, &len, &status); 184 if (U_FAILURE(status)) { 185 break; 186 } 187 U_DEBUG_TZ_MSG(("tz: compare to %s, %d .. [%d] .. %d\n", U_DEBUG_TZ_STR(u), start, mid, limit)); 188 copy.setTo(TRUE, u, len); 189 int r = id.compare(copy); 190 if(r==0) { 191 U_DEBUG_TZ_MSG(("fisa: found at %d\n", mid)); 192 return mid; 193 } else if(r<0) { 194 limit = mid; 195 } else { 196 start = mid; 197 } 198 } 199 U_DEBUG_TZ_MSG(("fisa: not found\n")); 200 return -1; 201 } 202 203 /** 204 * Fetch a specific zone by name. Replaces the getByKey call. 205 * @param top Top timezone resource 206 * @param id Time zone ID 207 * @param oldbundle Bundle for reuse (or NULL). see 'ures_open()' 208 * @return the zone's bundle if found, or undefined if error. Reuses oldbundle. 209 */ 210 static UResourceBundle* getZoneByName(const UResourceBundle* top, const UnicodeString& id, UResourceBundle *oldbundle, UErrorCode& status) { 211 // load the Rules object 212 UResourceBundle *tmp = ures_getByKey(top, kNAMES, NULL, &status); 213 214 // search for the string 215 int32_t idx = findInStringArray(tmp, id, status); 216 217 if((idx == -1) && U_SUCCESS(status)) { 218 // not found 219 status = U_MISSING_RESOURCE_ERROR; 220 //ures_close(oldbundle); 221 //oldbundle = NULL; 222 } else { 223 U_DEBUG_TZ_MSG(("gzbn: oldbundle= size %d, type %d, %s\n", ures_getSize(tmp), ures_getType(tmp), u_errorName(status))); 224 tmp = ures_getByKey(top, kZONES, tmp, &status); // get Zones object from top 225 U_DEBUG_TZ_MSG(("gzbn: loaded ZONES, size %d, type %d, path %s %s\n", ures_getSize(tmp), ures_getType(tmp), ures_getPath(tmp), u_errorName(status))); 226 oldbundle = ures_getByIndex(tmp, idx, oldbundle, &status); // get nth Zone object 227 U_DEBUG_TZ_MSG(("gzbn: loaded z#%d, size %d, type %d, path %s, %s\n", idx, ures_getSize(oldbundle), ures_getType(oldbundle), ures_getPath(oldbundle), u_errorName(status))); 228 } 229 ures_close(tmp); 230 if(U_FAILURE(status)) { 231 //ures_close(oldbundle); 232 return NULL; 233 } else { 234 return oldbundle; 235 } 236 } 237 238 239 UResourceBundle* TimeZone::loadRule(const UResourceBundle* top, const UnicodeString& ruleid, UResourceBundle* oldbundle, UErrorCode& status) { 240 char key[64]; 241 ruleid.extract(0, sizeof(key)-1, key, (int32_t)sizeof(key)-1, US_INV); 242 U_DEBUG_TZ_MSG(("loadRule(%s)\n", key)); 243 UResourceBundle *r = ures_getByKey(top, kRULES, oldbundle, &status); 244 U_DEBUG_TZ_MSG(("loadRule(%s) -> kRULES [%s]\n", key, u_errorName(status))); 245 r = ures_getByKey(r, key, r, &status); 246 U_DEBUG_TZ_MSG(("loadRule(%s) -> item [%s]\n", key, u_errorName(status))); 247 return r; 248 } 249 250 /** 251 * Given an ID, open the appropriate resource for the given time zone. 252 * Dereference aliases if necessary. 253 * @param id zone id 254 * @param res resource, which must be ready for use (initialized but not open) 255 * @param ec input-output error code 256 * @return top-level resource bundle 257 */ 258 static UResourceBundle* openOlsonResource(const UnicodeString& id, 259 UResourceBundle& res, 260 UErrorCode& ec) 261 { 262 #if U_DEBUG_TZ 263 char buf[128]; 264 id.extract(0, sizeof(buf)-1, buf, sizeof(buf), ""); 265 #endif 266 UResourceBundle *top = ures_openDirect(0, kZONEINFO, &ec); 267 U_DEBUG_TZ_MSG(("pre: res sz=%d\n", ures_getSize(&res))); 268 /* &res = */ getZoneByName(top, id, &res, ec); 269 // Dereference if this is an alias. Docs say result should be 1 270 // but it is 0 in 2.8 (?). 271 U_DEBUG_TZ_MSG(("Loading zone '%s' (%s, size %d) - %s\n", buf, ures_getKey((UResourceBundle*)&res), ures_getSize(&res), u_errorName(ec))); 272 if (ures_getType(&res) == URES_INT) { 273 int32_t deref = ures_getInt(&res, &ec) + 0; 274 U_DEBUG_TZ_MSG(("getInt: %s - type is %d\n", u_errorName(ec), ures_getType(&res))); 275 UResourceBundle *ares = ures_getByKey(top, kZONES, NULL, &ec); // dereference Zones section 276 ures_getByIndex(ares, deref, &res, &ec); 277 ures_close(ares); 278 U_DEBUG_TZ_MSG(("alias to #%d (%s) - %s\n", deref, "??", u_errorName(ec))); 279 } else { 280 U_DEBUG_TZ_MSG(("not an alias - size %d\n", ures_getSize(&res))); 281 } 282 U_DEBUG_TZ_MSG(("%s - final status is %s\n", buf, u_errorName(ec))); 283 return top; 284 } 285 286 // ------------------------------------- 287 288 namespace { 289 290 void 291 ensureStaticTimeZones() { 292 UBool needsInit; 293 UMTX_CHECK(&LOCK, (_GMT == NULL), needsInit); /* This is here to prevent race conditions. */ 294 295 // Initialize _GMT independently of other static data; it should 296 // be valid even if we can't load the time zone UDataMemory. 297 if (needsInit) { 298 SimpleTimeZone *tmpUnknown = 299 new SimpleTimeZone(0, UnicodeString(TRUE, UNKNOWN_ZONE_ID, UNKNOWN_ZONE_ID_LENGTH)); 300 SimpleTimeZone *tmpGMT = new SimpleTimeZone(0, UnicodeString(TRUE, GMT_ID, GMT_ID_LENGTH)); 301 umtx_lock(&LOCK); 302 if (_UNKNOWN_ZONE == 0) { 303 _UNKNOWN_ZONE = tmpUnknown; 304 tmpUnknown = NULL; 305 } 306 if (_GMT == 0) { 307 _GMT = tmpGMT; 308 tmpGMT = NULL; 309 } 310 umtx_unlock(&LOCK); 311 ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONE, timeZone_cleanup); 312 delete tmpUnknown; 313 delete tmpGMT; 314 } 315 } 316 317 } // anonymous namespace 318 319 const TimeZone& U_EXPORT2 320 TimeZone::getUnknown() 321 { 322 ensureStaticTimeZones(); 323 return *_UNKNOWN_ZONE; 324 } 325 326 const TimeZone* U_EXPORT2 327 TimeZone::getGMT(void) 328 { 329 ensureStaticTimeZones(); 330 return _GMT; 331 } 332 333 // ***************************************************************************** 334 // class TimeZone 335 // ***************************************************************************** 336 337 UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(TimeZone) 338 339 TimeZone::TimeZone() 340 : UObject(), fID() 341 { 342 } 343 344 // ------------------------------------- 345 346 TimeZone::TimeZone(const UnicodeString &id) 347 : UObject(), fID(id) 348 { 349 } 350 351 // ------------------------------------- 352 353 TimeZone::~TimeZone() 354 { 355 } 356 357 // ------------------------------------- 358 359 TimeZone::TimeZone(const TimeZone &source) 360 : UObject(source), fID(source.fID) 361 { 362 } 363 364 // ------------------------------------- 365 366 TimeZone & 367 TimeZone::operator=(const TimeZone &right) 368 { 369 if (this != &right) fID = right.fID; 370 return *this; 371 } 372 373 // ------------------------------------- 374 375 UBool 376 TimeZone::operator==(const TimeZone& that) const 377 { 378 return typeid(*this) == typeid(that) && 379 fID == that.fID; 380 } 381 382 // ------------------------------------- 383 384 TimeZone* U_EXPORT2 385 TimeZone::createTimeZone(const UnicodeString& ID) 386 { 387 /* We first try to lookup the zone ID in our system list. If this 388 * fails, we try to parse it as a custom string GMT[+-]hh:mm. If 389 * all else fails, we return GMT, which is probably not what the 390 * user wants, but at least is a functioning TimeZone object. 391 * 392 * We cannot return NULL, because that would break compatibility 393 * with the JDK. 394 */ 395 TimeZone* result = createSystemTimeZone(ID); 396 397 if (result == 0) { 398 U_DEBUG_TZ_MSG(("failed to load system time zone with id - falling to custom")); 399 result = createCustomTimeZone(ID); 400 } 401 if (result == 0) { 402 U_DEBUG_TZ_MSG(("failed to load time zone with id - falling to Etc/Unknown(GMT)")); 403 result = getUnknown().clone(); 404 } 405 return result; 406 } 407 408 /** 409 * Lookup the given name in our system zone table. If found, 410 * instantiate a new zone of that name and return it. If not 411 * found, return 0. 412 */ 413 TimeZone* 414 TimeZone::createSystemTimeZone(const UnicodeString& id) { 415 UErrorCode ec = U_ZERO_ERROR; 416 return createSystemTimeZone(id, ec); 417 } 418 419 TimeZone* 420 TimeZone::createSystemTimeZone(const UnicodeString& id, UErrorCode& ec) { 421 if (U_FAILURE(ec)) { 422 return NULL; 423 } 424 TimeZone* z = 0; 425 UResourceBundle res; 426 ures_initStackObject(&res); 427 U_DEBUG_TZ_MSG(("pre-err=%s\n", u_errorName(ec))); 428 UResourceBundle *top = openOlsonResource(id, res, ec); 429 U_DEBUG_TZ_MSG(("post-err=%s\n", u_errorName(ec))); 430 if (U_SUCCESS(ec)) { 431 z = new OlsonTimeZone(top, &res, id, ec); 432 if (z == NULL) { 433 U_DEBUG_TZ_MSG(("cstz: olson time zone failed to initialize - err %s\n", u_errorName(ec))); 434 } 435 } 436 ures_close(&res); 437 ures_close(top); 438 if (U_FAILURE(ec)) { 439 U_DEBUG_TZ_MSG(("cstz: failed to create, err %s\n", u_errorName(ec))); 440 delete z; 441 z = 0; 442 } 443 return z; 444 } 445 446 // ------------------------------------- 447 448 /** 449 * Initialize DEFAULT_ZONE from the system default time zone. The 450 * caller should confirm that DEFAULT_ZONE is NULL before calling. 451 * Upon return, DEFAULT_ZONE will not be NULL, unless operator new() 452 * returns NULL. 453 * 454 * Must be called OUTSIDE mutex. 455 */ 456 void 457 TimeZone::initDefault() 458 { 459 // We access system timezone data through TPlatformUtilities, 460 // including tzset(), timezone, and tzname[]. 461 int32_t rawOffset = 0; 462 const char *hostID; 463 464 // First, try to create a system timezone, based 465 // on the string ID in tzname[0]. 466 { 467 // NOTE: Local mutex here. TimeZone mutex below 468 // mutexed to avoid threading issues in the platform functions. 469 // Some of the locale/timezone OS functions may not be thread safe, 470 // so the intent is that any setting from anywhere within ICU 471 // happens while the ICU mutex is held. 472 // The operating system might actually use ICU to implement timezones. 473 // So we may have ICU calling ICU here, like on AIX. 474 // In order to prevent a double lock of a non-reentrant mutex in a 475 // different part of ICU, we use TZSET_LOCK to allow only one instance 476 // of ICU to query these thread unsafe OS functions at any given time. 477 Mutex lock(&TZSET_LOCK); 478 479 ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONE, timeZone_cleanup); 480 uprv_tzset(); // Initialize tz... system data 481 482 // Get the timezone ID from the host. This function should do 483 // any required host-specific remapping; e.g., on Windows this 484 // function maps the Date and Time control panel setting to an 485 // ICU timezone ID. 486 hostID = uprv_tzname(0); 487 488 // Invert sign because UNIX semantics are backwards 489 rawOffset = uprv_timezone() * -U_MILLIS_PER_SECOND; 490 } 491 492 UBool initialized; 493 UMTX_CHECK(&LOCK, (DEFAULT_ZONE != NULL), initialized); 494 if (initialized) { 495 /* Hrmph? Either a race condition happened, or tzset initialized ICU. */ 496 return; 497 } 498 499 TimeZone* default_zone = NULL; 500 501 /* Make sure that the string is NULL terminated to prevent BoundsChecker/Purify warnings. */ 502 UnicodeString hostStrID(hostID, -1, US_INV); 503 hostStrID.append((UChar)0); 504 hostStrID.truncate(hostStrID.length()-1); 505 default_zone = createSystemTimeZone(hostStrID); 506 507 #if U_PLATFORM_USES_ONLY_WIN32_API 508 // hostID points to a heap-allocated location on Windows. 509 uprv_free(const_cast<char *>(hostID)); 510 #endif 511 512 int32_t hostIDLen = hostStrID.length(); 513 if (default_zone != NULL && rawOffset != default_zone->getRawOffset() 514 && (3 <= hostIDLen && hostIDLen <= 4)) 515 { 516 // Uh oh. This probably wasn't a good id. 517 // It was probably an ambiguous abbreviation 518 delete default_zone; 519 default_zone = NULL; 520 } 521 522 // Construct a fixed standard zone with the host's ID 523 // and raw offset. 524 if (default_zone == NULL) { 525 default_zone = new SimpleTimeZone(rawOffset, hostStrID); 526 } 527 528 // If we _still_ don't have a time zone, use GMT. 529 if (default_zone == NULL) { 530 const TimeZone* temptz = getGMT(); 531 // If we can't use GMT, get out. 532 if (temptz == NULL) { 533 return; 534 } 535 default_zone = temptz->clone(); 536 } 537 538 // If DEFAULT_ZONE is still NULL, set it up. 539 umtx_lock(&LOCK); 540 if (DEFAULT_ZONE == NULL) { 541 DEFAULT_ZONE = default_zone; 542 default_zone = NULL; 543 ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONE, timeZone_cleanup); 544 } 545 umtx_unlock(&LOCK); 546 547 delete default_zone; 548 } 549 550 // ------------------------------------- 551 552 TimeZone* U_EXPORT2 553 TimeZone::createDefault() 554 { 555 /* This is here to prevent race conditions. */ 556 UBool needsInit; 557 UMTX_CHECK(&LOCK, (DEFAULT_ZONE == NULL), needsInit); 558 if (needsInit) { 559 initDefault(); 560 } 561 562 Mutex lock(&LOCK); // In case adoptDefault is called 563 return (DEFAULT_ZONE != NULL) ? DEFAULT_ZONE->clone() : NULL; 564 } 565 566 // ------------------------------------- 567 568 void U_EXPORT2 569 TimeZone::adoptDefault(TimeZone* zone) 570 { 571 if (zone != NULL) 572 { 573 TimeZone* old = NULL; 574 575 umtx_lock(&LOCK); 576 old = DEFAULT_ZONE; 577 DEFAULT_ZONE = zone; 578 umtx_unlock(&LOCK); 579 580 delete old; 581 ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONE, timeZone_cleanup); 582 } 583 } 584 // ------------------------------------- 585 586 void U_EXPORT2 587 TimeZone::setDefault(const TimeZone& zone) 588 { 589 adoptDefault(zone.clone()); 590 } 591 592 //---------------------------------------------------------------------- 593 594 /** 595 * This is the default implementation for subclasses that do not 596 * override this method. This implementation calls through to the 597 * 8-argument getOffset() method after suitable computations, and 598 * correctly adjusts GMT millis to local millis when necessary. 599 */ 600 void TimeZone::getOffset(UDate date, UBool local, int32_t& rawOffset, 601 int32_t& dstOffset, UErrorCode& ec) const { 602 if (U_FAILURE(ec)) { 603 return; 604 } 605 606 rawOffset = getRawOffset(); 607 if (!local) { 608 date += rawOffset; // now in local standard millis 609 } 610 611 // When local == TRUE, date might not be in local standard 612 // millis. getOffset taking 7 parameters used here assume 613 // the given time in day is local standard time. 614 // At STD->DST transition, there is a range of time which 615 // does not exist. When 'date' is in this time range 616 // (and local == TRUE), this method interprets the specified 617 // local time as DST. At DST->STD transition, there is a 618 // range of time which occurs twice. In this case, this 619 // method interprets the specified local time as STD. 620 // To support the behavior above, we need to call getOffset 621 // (with 7 args) twice when local == true and DST is 622 // detected in the initial call. 623 for (int32_t pass=0; ; ++pass) { 624 int32_t year, month, dom, dow; 625 double day = uprv_floor(date / U_MILLIS_PER_DAY); 626 int32_t millis = (int32_t) (date - day * U_MILLIS_PER_DAY); 627 628 Grego::dayToFields(day, year, month, dom, dow); 629 630 dstOffset = getOffset(GregorianCalendar::AD, year, month, dom, 631 (uint8_t) dow, millis, 632 Grego::monthLength(year, month), 633 ec) - rawOffset; 634 635 // Recompute if local==TRUE, dstOffset!=0. 636 if (pass!=0 || !local || dstOffset == 0) { 637 break; 638 } 639 // adjust to local standard millis 640 date -= dstOffset; 641 } 642 } 643 644 // ------------------------------------- 645 646 // New available IDs API as of ICU 2.4. Uses StringEnumeration API. 647 648 class TZEnumeration : public StringEnumeration { 649 private: 650 651 // Map into to zones. Our results are zone[map[i]] for 652 // i=0..len-1, where zone[i] is the i-th Olson zone. If map==NULL 653 // then our results are zone[i] for i=0..len-1. Len will be zero 654 // if the zone data could not be loaded. 655 int32_t* map; 656 int32_t* localMap; 657 int32_t len; 658 int32_t pos; 659 660 TZEnumeration(int32_t* mapData, int32_t mapLen, UBool adoptMapData) : pos(0) { 661 map = mapData; 662 localMap = adoptMapData ? mapData : NULL; 663 len = mapLen; 664 } 665 666 UBool getID(int32_t i) { 667 UErrorCode ec = U_ZERO_ERROR; 668 int32_t idLen = 0; 669 const UChar* id = NULL; 670 UResourceBundle *top = ures_openDirect(0, kZONEINFO, &ec); 671 top = ures_getByKey(top, kNAMES, top, &ec); // dereference Zones section 672 id = ures_getStringByIndex(top, i, &idLen, &ec); 673 if(U_FAILURE(ec)) { 674 unistr.truncate(0); 675 } 676 else { 677 unistr.fastCopyFrom(UnicodeString(TRUE, id, idLen)); 678 } 679 ures_close(top); 680 return U_SUCCESS(ec); 681 } 682 683 static int32_t* getMap(USystemTimeZoneType type, int32_t& len, UErrorCode& ec) { 684 len = 0; 685 if (U_FAILURE(ec)) { 686 return NULL; 687 } 688 int32_t* m = NULL; 689 switch (type) { 690 case UCAL_ZONE_TYPE_ANY: 691 m = MAP_SYSTEM_ZONES; 692 len = LEN_SYSTEM_ZONES; 693 break; 694 case UCAL_ZONE_TYPE_CANONICAL: 695 m = MAP_CANONICAL_SYSTEM_ZONES; 696 len = LEN_CANONICAL_SYSTEM_ZONES; 697 break; 698 case UCAL_ZONE_TYPE_CANONICAL_LOCATION: 699 m = MAP_CANONICAL_SYSTEM_LOCATION_ZONES; 700 len = LEN_CANONICAL_SYSTEM_LOCATION_ZONES; 701 break; 702 } 703 UBool needsInit = FALSE; 704 UMTX_CHECK(&LOCK, (len == 0), needsInit); 705 if (needsInit) { 706 m = initMap(type, len, ec); 707 } 708 return m; 709 } 710 711 static int32_t* initMap(USystemTimeZoneType type, int32_t& len, UErrorCode& ec) { 712 len = 0; 713 if (U_FAILURE(ec)) { 714 return NULL; 715 } 716 717 int32_t *result = NULL; 718 719 UResourceBundle *res = ures_openDirect(0, kZONEINFO, &ec); 720 res = ures_getByKey(res, kNAMES, res, &ec); // dereference Zones section 721 if (U_SUCCESS(ec)) { 722 int32_t size = ures_getSize(res); 723 int32_t *m = (int32_t *)uprv_malloc(size * sizeof(int32_t)); 724 if (m == NULL) { 725 ec = U_MEMORY_ALLOCATION_ERROR; 726 } else { 727 int32_t numEntries = 0; 728 for (int32_t i = 0; i < size; i++) { 729 UnicodeString id = ures_getUnicodeStringByIndex(res, i, &ec); 730 if (U_FAILURE(ec)) { 731 break; 732 } 733 if (0 == id.compare(UNKNOWN_ZONE_ID, UNKNOWN_ZONE_ID_LENGTH)) { 734 // exclude Etc/Unknown 735 continue; 736 } 737 if (type == UCAL_ZONE_TYPE_CANONICAL || type == UCAL_ZONE_TYPE_CANONICAL_LOCATION) { 738 UnicodeString canonicalID; 739 ZoneMeta::getCanonicalCLDRID(id, canonicalID, ec); 740 if (U_FAILURE(ec)) { 741 break; 742 } 743 if (canonicalID != id) { 744 // exclude aliases 745 continue; 746 } 747 } 748 if (type == UCAL_ZONE_TYPE_CANONICAL_LOCATION) { 749 const UChar *region = TimeZone::getRegion(id, ec); 750 if (U_FAILURE(ec)) { 751 break; 752 } 753 if (u_strcmp(region, WORLD) == 0) { 754 // exclude non-location ("001") 755 continue; 756 } 757 } 758 m[numEntries++] = i; 759 } 760 if (U_SUCCESS(ec)) { 761 int32_t *tmp = m; 762 m = (int32_t *)uprv_realloc(tmp, numEntries * sizeof(int32_t)); 763 if (m == NULL) { 764 // realloc failed.. use the original one even it has unused 765 // area at the end 766 m = tmp; 767 } 768 769 umtx_lock(&LOCK); 770 { 771 switch(type) { 772 case UCAL_ZONE_TYPE_ANY: 773 if (MAP_SYSTEM_ZONES == NULL) { 774 MAP_SYSTEM_ZONES = m; 775 LEN_SYSTEM_ZONES = numEntries; 776 m = NULL; 777 ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONE, timeZone_cleanup); 778 } 779 result = MAP_SYSTEM_ZONES; 780 len = LEN_SYSTEM_ZONES; 781 break; 782 case UCAL_ZONE_TYPE_CANONICAL: 783 if (MAP_CANONICAL_SYSTEM_ZONES == NULL) { 784 MAP_CANONICAL_SYSTEM_ZONES = m; 785 LEN_CANONICAL_SYSTEM_ZONES = numEntries; 786 m = NULL; 787 ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONE, timeZone_cleanup); 788 } 789 result = MAP_CANONICAL_SYSTEM_ZONES; 790 len = LEN_CANONICAL_SYSTEM_ZONES; 791 break; 792 case UCAL_ZONE_TYPE_CANONICAL_LOCATION: 793 if (MAP_CANONICAL_SYSTEM_LOCATION_ZONES == NULL) { 794 MAP_CANONICAL_SYSTEM_LOCATION_ZONES = m; 795 LEN_CANONICAL_SYSTEM_LOCATION_ZONES = numEntries; 796 m = NULL; 797 ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONE, timeZone_cleanup); 798 } 799 result = MAP_CANONICAL_SYSTEM_LOCATION_ZONES; 800 len = LEN_CANONICAL_SYSTEM_LOCATION_ZONES; 801 break; 802 } 803 } 804 umtx_unlock(&LOCK); 805 } 806 uprv_free(m); 807 } 808 } 809 810 ures_close(res); 811 return result; 812 } 813 814 public: 815 816 #define DEFAULT_FILTERED_MAP_SIZE 8 817 #define MAP_INCREMENT_SIZE 8 818 819 static TZEnumeration* create(USystemTimeZoneType type, const char* region, const int32_t* rawOffset, UErrorCode& ec) { 820 if (U_FAILURE(ec)) { 821 return NULL; 822 } 823 824 int32_t baseLen; 825 int32_t *baseMap = getMap(type, baseLen, ec); 826 827 if (U_FAILURE(ec)) { 828 return NULL; 829 } 830 831 // If any additional conditions are available, 832 // create instance local map filtered by the conditions. 833 834 int32_t *filteredMap = NULL; 835 int32_t numEntries = 0; 836 837 if (region != NULL || rawOffset != NULL) { 838 int32_t filteredMapSize = DEFAULT_FILTERED_MAP_SIZE; 839 filteredMap = (int32_t *)uprv_malloc(filteredMapSize * sizeof(int32_t)); 840 if (filteredMap == NULL) { 841 ec = U_MEMORY_ALLOCATION_ERROR; 842 return NULL; 843 } 844 845 // Walk through the base map 846 UResourceBundle *res = ures_openDirect(0, kZONEINFO, &ec); 847 res = ures_getByKey(res, kNAMES, res, &ec); // dereference Zones section 848 for (int32_t i = 0; i < baseLen; i++) { 849 int32_t zidx = baseMap[i]; 850 UnicodeString id = ures_getUnicodeStringByIndex(res, zidx, &ec); 851 if (U_FAILURE(ec)) { 852 break; 853 } 854 if (region != NULL) { 855 // Filter by region 856 char tzregion[4]; // max 3 letters + null term 857 TimeZone::getRegion(id, tzregion, sizeof(tzregion), ec); 858 if (U_FAILURE(ec)) { 859 break; 860 } 861 if (uprv_stricmp(tzregion, region) != 0) { 862 // region does not match 863 continue; 864 } 865 } 866 if (rawOffset != NULL) { 867 // Filter by raw offset 868 // Note: This is VERY inefficient 869 TimeZone *z = TimeZone::createSystemTimeZone(id, ec); 870 if (U_FAILURE(ec)) { 871 break; 872 } 873 int32_t tzoffset = z->getRawOffset(); 874 delete z; 875 876 if (tzoffset != *rawOffset) { 877 continue; 878 } 879 } 880 881 if (filteredMapSize <= numEntries) { 882 filteredMapSize += MAP_INCREMENT_SIZE; 883 int32_t *tmp = (int32_t *)uprv_realloc(filteredMap, filteredMapSize * sizeof(int32_t)); 884 if (tmp == NULL) { 885 ec = U_MEMORY_ALLOCATION_ERROR; 886 break; 887 } else { 888 filteredMap = tmp; 889 } 890 } 891 892 filteredMap[numEntries++] = zidx; 893 } 894 895 if (U_FAILURE(ec)) { 896 uprv_free(filteredMap); 897 filteredMap = NULL; 898 } 899 900 ures_close(res); 901 } 902 903 TZEnumeration *result = NULL; 904 if (U_SUCCESS(ec)) { 905 // Finally, create a new enumeration instance 906 if (filteredMap == NULL) { 907 result = new TZEnumeration(baseMap, baseLen, FALSE); 908 } else { 909 result = new TZEnumeration(filteredMap, numEntries, TRUE); 910 filteredMap = NULL; 911 } 912 if (result == NULL) { 913 ec = U_MEMORY_ALLOCATION_ERROR; 914 } 915 } 916 917 if (filteredMap != NULL) { 918 uprv_free(filteredMap); 919 } 920 921 return result; 922 } 923 924 TZEnumeration(const TZEnumeration &other) : StringEnumeration(), map(NULL), localMap(NULL), len(0), pos(0) { 925 if (other.localMap != NULL) { 926 localMap = (int32_t *)uprv_malloc(other.len * sizeof(int32_t)); 927 if (localMap != NULL) { 928 len = other.len; 929 uprv_memcpy(localMap, other.localMap, len * sizeof(int32_t)); 930 pos = other.pos; 931 map = localMap; 932 } else { 933 len = 0; 934 pos = 0; 935 map = NULL; 936 } 937 } else { 938 map = other.map; 939 localMap = NULL; 940 len = other.len; 941 pos = other.pos; 942 } 943 } 944 945 virtual ~TZEnumeration(); 946 947 virtual StringEnumeration *clone() const { 948 return new TZEnumeration(*this); 949 } 950 951 virtual int32_t count(UErrorCode& status) const { 952 return U_FAILURE(status) ? 0 : len; 953 } 954 955 virtual const UnicodeString* snext(UErrorCode& status) { 956 if (U_SUCCESS(status) && map != NULL && pos < len) { 957 getID(map[pos]); 958 ++pos; 959 return &unistr; 960 } 961 return 0; 962 } 963 964 virtual void reset(UErrorCode& /*status*/) { 965 pos = 0; 966 } 967 968 public: 969 static UClassID U_EXPORT2 getStaticClassID(void); 970 virtual UClassID getDynamicClassID(void) const; 971 }; 972 973 TZEnumeration::~TZEnumeration() { 974 if (localMap != NULL) { 975 uprv_free(localMap); 976 } 977 } 978 979 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(TZEnumeration) 980 981 StringEnumeration* U_EXPORT2 982 TimeZone::createTimeZoneIDEnumeration( 983 USystemTimeZoneType zoneType, 984 const char* region, 985 const int32_t* rawOffset, 986 UErrorCode& ec) { 987 return TZEnumeration::create(zoneType, region, rawOffset, ec); 988 } 989 990 StringEnumeration* U_EXPORT2 991 TimeZone::createEnumeration() { 992 UErrorCode ec = U_ZERO_ERROR; 993 return TZEnumeration::create(UCAL_ZONE_TYPE_ANY, NULL, NULL, ec); 994 } 995 996 StringEnumeration* U_EXPORT2 997 TimeZone::createEnumeration(int32_t rawOffset) { 998 UErrorCode ec = U_ZERO_ERROR; 999 return TZEnumeration::create(UCAL_ZONE_TYPE_ANY, NULL, &rawOffset, ec); 1000 } 1001 1002 StringEnumeration* U_EXPORT2 1003 TimeZone::createEnumeration(const char* country) { 1004 UErrorCode ec = U_ZERO_ERROR; 1005 return TZEnumeration::create(UCAL_ZONE_TYPE_ANY, country, NULL, ec); 1006 } 1007 1008 // --------------------------------------- 1009 1010 int32_t U_EXPORT2 1011 TimeZone::countEquivalentIDs(const UnicodeString& id) { 1012 int32_t result = 0; 1013 UErrorCode ec = U_ZERO_ERROR; 1014 UResourceBundle res; 1015 ures_initStackObject(&res); 1016 U_DEBUG_TZ_MSG(("countEquivalentIDs..\n")); 1017 UResourceBundle *top = openOlsonResource(id, res, ec); 1018 if (U_SUCCESS(ec)) { 1019 UResourceBundle r; 1020 ures_initStackObject(&r); 1021 ures_getByKey(&res, kLINKS, &r, &ec); 1022 ures_getIntVector(&r, &result, &ec); 1023 ures_close(&r); 1024 } 1025 ures_close(&res); 1026 ures_close(top); 1027 return result; 1028 } 1029 1030 // --------------------------------------- 1031 1032 const UnicodeString U_EXPORT2 1033 TimeZone::getEquivalentID(const UnicodeString& id, int32_t index) { 1034 U_DEBUG_TZ_MSG(("gEI(%d)\n", index)); 1035 UnicodeString result; 1036 UErrorCode ec = U_ZERO_ERROR; 1037 UResourceBundle res; 1038 ures_initStackObject(&res); 1039 UResourceBundle *top = openOlsonResource(id, res, ec); 1040 int32_t zone = -1; 1041 if (U_SUCCESS(ec)) { 1042 UResourceBundle r; 1043 ures_initStackObject(&r); 1044 int32_t size; 1045 ures_getByKey(&res, kLINKS, &r, &ec); 1046 const int32_t* v = ures_getIntVector(&r, &size, &ec); 1047 if (U_SUCCESS(ec)) { 1048 if (index >= 0 && index < size) { 1049 zone = v[index]; 1050 } 1051 } 1052 ures_close(&r); 1053 } 1054 ures_close(&res); 1055 if (zone >= 0) { 1056 UResourceBundle *ares = ures_getByKey(top, kNAMES, NULL, &ec); // dereference Zones section 1057 if (U_SUCCESS(ec)) { 1058 int32_t idLen = 0; 1059 const UChar* id = ures_getStringByIndex(ares, zone, &idLen, &ec); 1060 result.fastCopyFrom(UnicodeString(TRUE, id, idLen)); 1061 U_DEBUG_TZ_MSG(("gei(%d) -> %d, len%d, %s\n", index, zone, result.length(), u_errorName(ec))); 1062 } 1063 ures_close(ares); 1064 } 1065 ures_close(top); 1066 #if defined(U_DEBUG_TZ) 1067 if(result.length() ==0) { 1068 U_DEBUG_TZ_MSG(("equiv [__, #%d] -> 0 (%s)\n", index, u_errorName(ec))); 1069 } 1070 #endif 1071 return result; 1072 } 1073 1074 // --------------------------------------- 1075 1076 // These methods are used by ZoneMeta class only. 1077 1078 const UChar* 1079 TimeZone::findID(const UnicodeString& id) { 1080 const UChar *result = NULL; 1081 UErrorCode ec = U_ZERO_ERROR; 1082 UResourceBundle *rb = ures_openDirect(NULL, kZONEINFO, &ec); 1083 1084 // resolve zone index by name 1085 UResourceBundle *names = ures_getByKey(rb, kNAMES, NULL, &ec); 1086 int32_t idx = findInStringArray(names, id, ec); 1087 result = ures_getStringByIndex(names, idx, NULL, &ec); 1088 if (U_FAILURE(ec)) { 1089 result = NULL; 1090 } 1091 ures_close(names); 1092 ures_close(rb); 1093 return result; 1094 } 1095 1096 1097 const UChar* 1098 TimeZone::dereferOlsonLink(const UnicodeString& id) { 1099 const UChar *result = NULL; 1100 UErrorCode ec = U_ZERO_ERROR; 1101 UResourceBundle *rb = ures_openDirect(NULL, kZONEINFO, &ec); 1102 1103 // resolve zone index by name 1104 UResourceBundle *names = ures_getByKey(rb, kNAMES, NULL, &ec); 1105 int32_t idx = findInStringArray(names, id, ec); 1106 result = ures_getStringByIndex(names, idx, NULL, &ec); 1107 1108 // open the zone bundle by index 1109 ures_getByKey(rb, kZONES, rb, &ec); 1110 ures_getByIndex(rb, idx, rb, &ec); 1111 1112 if (U_SUCCESS(ec)) { 1113 if (ures_getType(rb) == URES_INT) { 1114 // this is a link - dereference the link 1115 int32_t deref = ures_getInt(rb, &ec); 1116 const UChar* tmp = ures_getStringByIndex(names, deref, NULL, &ec); 1117 if (U_SUCCESS(ec)) { 1118 result = tmp; 1119 } 1120 } 1121 } 1122 1123 ures_close(names); 1124 ures_close(rb); 1125 1126 return result; 1127 } 1128 1129 const UChar* 1130 TimeZone::getRegion(const UnicodeString& id) { 1131 UErrorCode status = U_ZERO_ERROR; 1132 return getRegion(id, status); 1133 } 1134 1135 const UChar* 1136 TimeZone::getRegion(const UnicodeString& id, UErrorCode& status) { 1137 if (U_FAILURE(status)) { 1138 return NULL; 1139 } 1140 const UChar *result = NULL; 1141 UResourceBundle *rb = ures_openDirect(NULL, kZONEINFO, &status); 1142 1143 // resolve zone index by name 1144 UResourceBundle *res = ures_getByKey(rb, kNAMES, NULL, &status); 1145 int32_t idx = findInStringArray(res, id, status); 1146 1147 // get region mapping 1148 ures_getByKey(rb, kREGIONS, res, &status); 1149 const UChar *tmp = ures_getStringByIndex(res, idx, NULL, &status); 1150 if (U_SUCCESS(status)) { 1151 result = tmp; 1152 } 1153 1154 ures_close(res); 1155 ures_close(rb); 1156 1157 return result; 1158 } 1159 1160 1161 // --------------------------------------- 1162 int32_t 1163 TimeZone::getRegion(const UnicodeString& id, char *region, int32_t capacity, UErrorCode& status) 1164 { 1165 int32_t resultLen = 0; 1166 *region = 0; 1167 if (U_FAILURE(status)) { 1168 return 0; 1169 } 1170 1171 const UChar *uregion = NULL; 1172 // "Etc/Unknown" is not a system zone ID, 1173 // but in the zone data 1174 if (id.compare(UNKNOWN_ZONE_ID, UNKNOWN_ZONE_ID_LENGTH) != 0) { 1175 uregion = getRegion(id); 1176 } 1177 if (uregion == NULL) { 1178 status = U_ILLEGAL_ARGUMENT_ERROR; 1179 return 0; 1180 } 1181 resultLen = u_strlen(uregion); 1182 // A region code is represented by invariant characters 1183 u_UCharsToChars(uregion, region, uprv_min(resultLen, capacity)); 1184 1185 if (capacity < resultLen) { 1186 status = U_BUFFER_OVERFLOW_ERROR; 1187 return resultLen; 1188 } 1189 1190 return u_terminateChars(region, capacity, resultLen, &status); 1191 } 1192 1193 // --------------------------------------- 1194 1195 1196 UnicodeString& 1197 TimeZone::getDisplayName(UnicodeString& result) const 1198 { 1199 return getDisplayName(FALSE,LONG,Locale::getDefault(), result); 1200 } 1201 1202 UnicodeString& 1203 TimeZone::getDisplayName(const Locale& locale, UnicodeString& result) const 1204 { 1205 return getDisplayName(FALSE, LONG, locale, result); 1206 } 1207 1208 UnicodeString& 1209 TimeZone::getDisplayName(UBool daylight, EDisplayType style, UnicodeString& result) const 1210 { 1211 return getDisplayName(daylight,style, Locale::getDefault(), result); 1212 } 1213 //-------------------------------------- 1214 int32_t 1215 TimeZone::getDSTSavings()const { 1216 if (useDaylightTime()) { 1217 return 3600000; 1218 } 1219 return 0; 1220 } 1221 //--------------------------------------- 1222 UnicodeString& 1223 TimeZone::getDisplayName(UBool daylight, EDisplayType style, const Locale& locale, UnicodeString& result) const 1224 { 1225 UErrorCode status = U_ZERO_ERROR; 1226 UDate date = Calendar::getNow(); 1227 UTimeZoneFormatTimeType timeType; 1228 int32_t offset; 1229 1230 if (style == GENERIC_LOCATION || style == LONG_GENERIC || style == SHORT_GENERIC) { 1231 LocalPointer<TimeZoneFormat> tzfmt(TimeZoneFormat::createInstance(locale, status)); 1232 if (U_FAILURE(status)) { 1233 result.remove(); 1234 return result; 1235 } 1236 // Generic format 1237 switch (style) { 1238 case GENERIC_LOCATION: 1239 tzfmt->format(UTZFMT_STYLE_GENERIC_LOCATION, *this, date, result, &timeType); 1240 break; 1241 case LONG_GENERIC: 1242 tzfmt->format(UTZFMT_STYLE_GENERIC_LONG, *this, date, result, &timeType); 1243 break; 1244 case SHORT_GENERIC: 1245 tzfmt->format(UTZFMT_STYLE_GENERIC_SHORT, *this, date, result, &timeType); 1246 break; 1247 default: 1248 U_ASSERT(FALSE); 1249 } 1250 // Generic format many use Localized GMT as the final fallback. 1251 // When Localized GMT format is used, the result might not be 1252 // appropriate for the requested daylight value. 1253 if ((daylight && timeType == UTZFMT_TIME_TYPE_STANDARD) || (!daylight && timeType == UTZFMT_TIME_TYPE_DAYLIGHT)) { 1254 offset = daylight ? getRawOffset() + getDSTSavings() : getRawOffset(); 1255 if (style == SHORT_GENERIC) { 1256 tzfmt->formatOffsetShortLocalizedGMT(offset, result, status); 1257 } else { 1258 tzfmt->formatOffsetLocalizedGMT(offset, result, status); 1259 } 1260 } 1261 } else if (style == LONG_GMT || style == SHORT_GMT) { 1262 LocalPointer<TimeZoneFormat> tzfmt(TimeZoneFormat::createInstance(locale, status)); 1263 if (U_FAILURE(status)) { 1264 result.remove(); 1265 return result; 1266 } 1267 offset = daylight && useDaylightTime() ? getRawOffset() + getDSTSavings() : getRawOffset(); 1268 switch (style) { 1269 case LONG_GMT: 1270 tzfmt->formatOffsetLocalizedGMT(offset, result, status); 1271 break; 1272 case SHORT_GMT: 1273 tzfmt->formatOffsetISO8601Basic(offset, FALSE, FALSE, FALSE, result, status); 1274 break; 1275 default: 1276 U_ASSERT(FALSE); 1277 } 1278 1279 } else { 1280 U_ASSERT(style == LONG || style == SHORT || style == SHORT_COMMONLY_USED); 1281 UTimeZoneNameType nameType = UTZNM_UNKNOWN; 1282 switch (style) { 1283 case LONG: 1284 nameType = daylight ? UTZNM_LONG_DAYLIGHT : UTZNM_LONG_STANDARD; 1285 break; 1286 case SHORT: 1287 case SHORT_COMMONLY_USED: 1288 nameType = daylight ? UTZNM_SHORT_DAYLIGHT : UTZNM_SHORT_STANDARD; 1289 break; 1290 default: 1291 U_ASSERT(FALSE); 1292 } 1293 LocalPointer<TimeZoneNames> tznames(TimeZoneNames::createInstance(locale, status)); 1294 if (U_FAILURE(status)) { 1295 result.remove(); 1296 return result; 1297 } 1298 UnicodeString canonicalID(ZoneMeta::getCanonicalCLDRID(*this)); 1299 tznames->getDisplayName(canonicalID, nameType, date, result); 1300 if (result.isEmpty()) { 1301 // Fallback to localized GMT 1302 LocalPointer<TimeZoneFormat> tzfmt(TimeZoneFormat::createInstance(locale, status)); 1303 offset = daylight && useDaylightTime() ? getRawOffset() + getDSTSavings() : getRawOffset(); 1304 if (style == LONG) { 1305 tzfmt->formatOffsetLocalizedGMT(offset, result, status); 1306 } else { 1307 tzfmt->formatOffsetShortLocalizedGMT(offset, result, status); 1308 } 1309 } 1310 } 1311 if (U_FAILURE(status)) { 1312 result.remove(); 1313 } 1314 return result; 1315 } 1316 1317 /** 1318 * Parse a custom time zone identifier and return a corresponding zone. 1319 * @param id a string of the form GMT[+-]hh:mm, GMT[+-]hhmm, or 1320 * GMT[+-]hh. 1321 * @return a newly created SimpleTimeZone with the given offset and 1322 * no Daylight Savings Time, or null if the id cannot be parsed. 1323 */ 1324 TimeZone* 1325 TimeZone::createCustomTimeZone(const UnicodeString& id) 1326 { 1327 int32_t sign, hour, min, sec; 1328 if (parseCustomID(id, sign, hour, min, sec)) { 1329 UnicodeString customID; 1330 formatCustomID(hour, min, sec, (sign < 0), customID); 1331 int32_t offset = sign * ((hour * 60 + min) * 60 + sec) * 1000; 1332 return new SimpleTimeZone(offset, customID); 1333 } 1334 return NULL; 1335 } 1336 1337 UnicodeString& 1338 TimeZone::getCustomID(const UnicodeString& id, UnicodeString& normalized, UErrorCode& status) { 1339 normalized.remove(); 1340 if (U_FAILURE(status)) { 1341 return normalized; 1342 } 1343 int32_t sign, hour, min, sec; 1344 if (parseCustomID(id, sign, hour, min, sec)) { 1345 formatCustomID(hour, min, sec, (sign < 0), normalized); 1346 } 1347 return normalized; 1348 } 1349 1350 UBool 1351 TimeZone::parseCustomID(const UnicodeString& id, int32_t& sign, 1352 int32_t& hour, int32_t& min, int32_t& sec) { 1353 static const int32_t kParseFailed = -99999; 1354 1355 NumberFormat* numberFormat = 0; 1356 UnicodeString idUppercase = id; 1357 idUppercase.toUpper(""); 1358 1359 if (id.length() > GMT_ID_LENGTH && 1360 idUppercase.startsWith(GMT_ID, GMT_ID_LENGTH)) 1361 { 1362 ParsePosition pos(GMT_ID_LENGTH); 1363 sign = 1; 1364 hour = 0; 1365 min = 0; 1366 sec = 0; 1367 1368 if (id[pos.getIndex()] == MINUS /*'-'*/) { 1369 sign = -1; 1370 } else if (id[pos.getIndex()] != PLUS /*'+'*/) { 1371 return FALSE; 1372 } 1373 pos.setIndex(pos.getIndex() + 1); 1374 1375 UErrorCode success = U_ZERO_ERROR; 1376 numberFormat = NumberFormat::createInstance(success); 1377 if(U_FAILURE(success)){ 1378 return FALSE; 1379 } 1380 numberFormat->setParseIntegerOnly(TRUE); 1381 //numberFormat->setLenient(TRUE); // TODO: May need to set this, depends on latest timezone parsing 1382 1383 // Look for either hh:mm, hhmm, or hh 1384 int32_t start = pos.getIndex(); 1385 Formattable n(kParseFailed); 1386 numberFormat->parse(id, n, pos); 1387 if (pos.getIndex() == start) { 1388 delete numberFormat; 1389 return FALSE; 1390 } 1391 hour = n.getLong(); 1392 1393 if (pos.getIndex() < id.length()) { 1394 if (pos.getIndex() - start > 2 1395 || id[pos.getIndex()] != COLON) { 1396 delete numberFormat; 1397 return FALSE; 1398 } 1399 // hh:mm 1400 pos.setIndex(pos.getIndex() + 1); 1401 int32_t oldPos = pos.getIndex(); 1402 n.setLong(kParseFailed); 1403 numberFormat->parse(id, n, pos); 1404 if ((pos.getIndex() - oldPos) != 2) { 1405 // must be 2 digits 1406 delete numberFormat; 1407 return FALSE; 1408 } 1409 min = n.getLong(); 1410 if (pos.getIndex() < id.length()) { 1411 if (id[pos.getIndex()] != COLON) { 1412 delete numberFormat; 1413 return FALSE; 1414 } 1415 // [:ss] 1416 pos.setIndex(pos.getIndex() + 1); 1417 oldPos = pos.getIndex(); 1418 n.setLong(kParseFailed); 1419 numberFormat->parse(id, n, pos); 1420 if (pos.getIndex() != id.length() 1421 || (pos.getIndex() - oldPos) != 2) { 1422 delete numberFormat; 1423 return FALSE; 1424 } 1425 sec = n.getLong(); 1426 } 1427 } else { 1428 // Supported formats are below - 1429 // 1430 // HHmmss 1431 // Hmmss 1432 // HHmm 1433 // Hmm 1434 // HH 1435 // H 1436 1437 int32_t length = pos.getIndex() - start; 1438 if (length <= 0 || 6 < length) { 1439 // invalid length 1440 delete numberFormat; 1441 return FALSE; 1442 } 1443 switch (length) { 1444 case 1: 1445 case 2: 1446 // already set to hour 1447 break; 1448 case 3: 1449 case 4: 1450 min = hour % 100; 1451 hour /= 100; 1452 break; 1453 case 5: 1454 case 6: 1455 sec = hour % 100; 1456 min = (hour/100) % 100; 1457 hour /= 10000; 1458 break; 1459 } 1460 } 1461 1462 delete numberFormat; 1463 1464 if (hour > kMAX_CUSTOM_HOUR || min > kMAX_CUSTOM_MIN || sec > kMAX_CUSTOM_SEC) { 1465 return FALSE; 1466 } 1467 return TRUE; 1468 } 1469 return FALSE; 1470 } 1471 1472 UnicodeString& 1473 TimeZone::formatCustomID(int32_t hour, int32_t min, int32_t sec, 1474 UBool negative, UnicodeString& id) { 1475 // Create time zone ID - GMT[+|-]hhmm[ss] 1476 id.setTo(GMT_ID, GMT_ID_LENGTH); 1477 if (hour | min | sec) { 1478 if (negative) { 1479 id += (UChar)MINUS; 1480 } else { 1481 id += (UChar)PLUS; 1482 } 1483 1484 if (hour < 10) { 1485 id += (UChar)ZERO_DIGIT; 1486 } else { 1487 id += (UChar)(ZERO_DIGIT + hour/10); 1488 } 1489 id += (UChar)(ZERO_DIGIT + hour%10); 1490 id += (UChar)COLON; 1491 if (min < 10) { 1492 id += (UChar)ZERO_DIGIT; 1493 } else { 1494 id += (UChar)(ZERO_DIGIT + min/10); 1495 } 1496 id += (UChar)(ZERO_DIGIT + min%10); 1497 1498 if (sec) { 1499 id += (UChar)COLON; 1500 if (sec < 10) { 1501 id += (UChar)ZERO_DIGIT; 1502 } else { 1503 id += (UChar)(ZERO_DIGIT + sec/10); 1504 } 1505 id += (UChar)(ZERO_DIGIT + sec%10); 1506 } 1507 } 1508 return id; 1509 } 1510 1511 1512 UBool 1513 TimeZone::hasSameRules(const TimeZone& other) const 1514 { 1515 return (getRawOffset() == other.getRawOffset() && 1516 useDaylightTime() == other.useDaylightTime()); 1517 } 1518 1519 const char* 1520 TimeZone::getTZDataVersion(UErrorCode& status) 1521 { 1522 /* This is here to prevent race conditions. */ 1523 UBool needsInit; 1524 UMTX_CHECK(&LOCK, !TZDataVersionInitialized, needsInit); 1525 if (needsInit) { 1526 int32_t len = 0; 1527 UResourceBundle *bundle = ures_openDirect(NULL, kZONEINFO, &status); 1528 const UChar *tzver = ures_getStringByKey(bundle, kTZVERSION, 1529 &len, &status); 1530 1531 if (U_SUCCESS(status)) { 1532 if (len >= (int32_t)sizeof(TZDATA_VERSION)) { 1533 // Ensure that there is always space for a trailing nul in TZDATA_VERSION 1534 len = sizeof(TZDATA_VERSION) - 1; 1535 } 1536 umtx_lock(&LOCK); 1537 if (!TZDataVersionInitialized) { 1538 u_UCharsToChars(tzver, TZDATA_VERSION, len); 1539 TZDataVersionInitialized = TRUE; 1540 } 1541 umtx_unlock(&LOCK); 1542 ucln_i18n_registerCleanup(UCLN_I18N_TIMEZONE, timeZone_cleanup); 1543 } 1544 1545 ures_close(bundle); 1546 } 1547 if (U_FAILURE(status)) { 1548 return NULL; 1549 } 1550 return (const char*)TZDATA_VERSION; 1551 } 1552 1553 UnicodeString& 1554 TimeZone::getCanonicalID(const UnicodeString& id, UnicodeString& canonicalID, UErrorCode& status) 1555 { 1556 UBool isSystemID = FALSE; 1557 return getCanonicalID(id, canonicalID, isSystemID, status); 1558 } 1559 1560 UnicodeString& 1561 TimeZone::getCanonicalID(const UnicodeString& id, UnicodeString& canonicalID, UBool& isSystemID, 1562 UErrorCode& status) 1563 { 1564 canonicalID.remove(); 1565 isSystemID = FALSE; 1566 if (U_FAILURE(status)) { 1567 return canonicalID; 1568 } 1569 if (id.compare(UNKNOWN_ZONE_ID, UNKNOWN_ZONE_ID_LENGTH) == 0) { 1570 // special case - Etc/Unknown is a canonical ID, but not system ID 1571 canonicalID.fastCopyFrom(id); 1572 isSystemID = FALSE; 1573 } else { 1574 ZoneMeta::getCanonicalCLDRID(id, canonicalID, status); 1575 if (U_SUCCESS(status)) { 1576 isSystemID = TRUE; 1577 } else { 1578 // Not a system ID 1579 status = U_ZERO_ERROR; 1580 getCustomID(id, canonicalID, status); 1581 } 1582 } 1583 return canonicalID; 1584 } 1585 1586 U_NAMESPACE_END 1587 1588 #endif /* #if !UCONFIG_NO_FORMATTING */ 1589 1590 //eof 1591
