icuSources/i18n/timezone.cpp

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