icuSources/i18n/timezone.cpp

   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