src/third_party/icu/source/i18n/vtzone.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2007-2013, International Business Machines Corporation and
   4 * others. All Rights Reserved.
   5 *******************************************************************************
   6 */
   7
   8 #include "utypeinfo.h"  // for 'typeid' to work
   9
  10 #include "unicode/utypes.h"
  11
  12 #if !UCONFIG_NO_FORMATTING
  13
  14 #include "unicode/vtzone.h"
  15 #include "unicode/rbtz.h"
  16 #include "unicode/ucal.h"
  17 #include "unicode/ures.h"
  18 #include "cmemory.h"
  19 #include "uvector.h"
  20 #include "gregoimp.h"
  21 #include "uassert.h"
  22
  23 U_NAMESPACE_BEGIN
  24
  25 // This is the deleter that will be use to remove TimeZoneRule
  26 U_CDECL_BEGIN
  27 static void U_CALLCONV
  28 deleteTimeZoneRule(void* obj) {
  29     delete (TimeZoneRule*) obj;
  30 }
  31 U_CDECL_END
  32
  33 // Smybol characters used by RFC2445 VTIMEZONE
  34 static const UChar COLON = 0x3A; /* : */
  35 static const UChar SEMICOLON = 0x3B; /* ; */
  36 static const UChar EQUALS_SIGN = 0x3D; /* = */
  37 static const UChar COMMA = 0x2C; /* , */
  38 static const UChar PLUS = 0x2B; /* + */
  39 static const UChar MINUS = 0x2D; /* - */
  40
  41 // RFC2445 VTIMEZONE tokens
  42 static const UChar ICAL_BEGIN_VTIMEZONE[] = {0x42, 0x45, 0x47, 0x49, 0x4E, 0x3A, 0x56, 0x54, 0x49, 0x4D, 0x45, 0x5A, 0x4F, 0x4E, 0x45, 0}; /* "BEGIN:VTIMEZONE" */
  43 static const UChar ICAL_END_VTIMEZONE[] = {0x45, 0x4E, 0x44, 0x3A, 0x56, 0x54, 0x49, 0x4D, 0x45, 0x5A, 0x4F, 0x4E, 0x45, 0}; /* "END:VTIMEZONE" */
  44 static const UChar ICAL_BEGIN[] = {0x42, 0x45, 0x47, 0x49, 0x4E, 0}; /* "BEGIN" */
  45 static const UChar ICAL_END[] = {0x45, 0x4E, 0x44, 0}; /* "END" */
  46 static const UChar ICAL_VTIMEZONE[] = {0x56, 0x54, 0x49, 0x4D, 0x45, 0x5A, 0x4F, 0x4E, 0x45, 0}; /* "VTIMEZONE" */
  47 static const UChar ICAL_TZID[] = {0x54, 0x5A, 0x49, 0x44, 0}; /* "TZID" */
  48 static const UChar ICAL_STANDARD[] = {0x53, 0x54, 0x41, 0x4E, 0x44, 0x41, 0x52, 0x44, 0}; /* "STANDARD" */
  49 static const UChar ICAL_DAYLIGHT[] = {0x44, 0x41, 0x59, 0x4C, 0x49, 0x47, 0x48, 0x54, 0}; /* "DAYLIGHT" */
  50 static const UChar ICAL_DTSTART[] = {0x44, 0x54, 0x53, 0x54, 0x41, 0x52, 0x54, 0}; /* "DTSTART" */
  51 static const UChar ICAL_TZOFFSETFROM[] = {0x54, 0x5A, 0x4F, 0x46, 0x46, 0x53, 0x45, 0x54, 0x46, 0x52, 0x4F, 0x4D, 0}; /* "TZOFFSETFROM" */
  52 static const UChar ICAL_TZOFFSETTO[] = {0x54, 0x5A, 0x4F, 0x46, 0x46, 0x53, 0x45, 0x54, 0x54, 0x4F, 0}; /* "TZOFFSETTO" */
  53 static const UChar ICAL_RDATE[] = {0x52, 0x44, 0x41, 0x54, 0x45, 0}; /* "RDATE" */
  54 static const UChar ICAL_RRULE[] = {0x52, 0x52, 0x55, 0x4C, 0x45, 0}; /* "RRULE" */
  55 static const UChar ICAL_TZNAME[] = {0x54, 0x5A, 0x4E, 0x41, 0x4D, 0x45, 0}; /* "TZNAME" */
  56 static const UChar ICAL_TZURL[] = {0x54, 0x5A, 0x55, 0x52, 0x4C, 0}; /* "TZURL" */
  57 static const UChar ICAL_LASTMOD[] = {0x4C, 0x41, 0x53, 0x54, 0x2D, 0x4D, 0x4F, 0x44, 0x49, 0x46, 0x49, 0x45, 0x44, 0}; /* "LAST-MODIFIED" */
  58
  59 static const UChar ICAL_FREQ[] = {0x46, 0x52, 0x45, 0x51, 0}; /* "FREQ" */
  60 static const UChar ICAL_UNTIL[] = {0x55, 0x4E, 0x54, 0x49, 0x4C, 0}; /* "UNTIL" */
  61 static const UChar ICAL_YEARLY[] = {0x59, 0x45, 0x41, 0x52, 0x4C, 0x59, 0}; /* "YEARLY" */
  62 static const UChar ICAL_BYMONTH[] = {0x42, 0x59, 0x4D, 0x4F, 0x4E, 0x54, 0x48, 0}; /* "BYMONTH" */
  63 static const UChar ICAL_BYDAY[] = {0x42, 0x59, 0x44, 0x41, 0x59, 0}; /* "BYDAY" */
  64 static const UChar ICAL_BYMONTHDAY[] = {0x42, 0x59, 0x4D, 0x4F, 0x4E, 0x54, 0x48, 0x44, 0x41, 0x59, 0}; /* "BYMONTHDAY" */
  65
  66 static const UChar ICAL_NEWLINE[] = {0x0D, 0x0A, 0}; /* CRLF */
  67
  68 static const UChar ICAL_DOW_NAMES[7][3] = {
  69     {0x53, 0x55, 0}, /* "SU" */
  70     {0x4D, 0x4F, 0}, /* "MO" */
  71     {0x54, 0x55, 0}, /* "TU" */
  72     {0x57, 0x45, 0}, /* "WE" */
  73     {0x54, 0x48, 0}, /* "TH" */
  74     {0x46, 0x52, 0}, /* "FR" */
  75     {0x53, 0x41, 0}  /* "SA" */};
  76
  77 // Month length for non-leap year
  78 static const int32_t MONTHLENGTH[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  79
  80 // ICU custom property
  81 static const UChar ICU_TZINFO_PROP[] = {0x58, 0x2D, 0x54, 0x5A, 0x49, 0x4E, 0x46, 0x4F, 0x3A, 0}; /* "X-TZINFO:" */
  82 static const UChar ICU_TZINFO_PARTIAL[] = {0x2F, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6C, 0x40, 0}; /* "/Partial@" */
  83 static const UChar ICU_TZINFO_SIMPLE[] = {0x2F, 0x53, 0x69, 0x6D, 0x70, 0x6C, 0x65, 0x40, 0}; /* "/Simple@" */
  84
  85
  86 /*
  87  * Simple fixed digit ASCII number to integer converter
  88  */
  89 static int32_t parseAsciiDigits(const UnicodeString& str, int32_t start, int32_t length, UErrorCode& status) {
  90     if (U_FAILURE(status)) {
  91         return 0;
  92     }
  93     if (length <= 0 || str.length() < start || (start + length) > str.length()) {
  94         status = U_INVALID_FORMAT_ERROR;
  95         return 0;
  96     }
  97     int32_t sign = 1;
  98     if (str.charAt(start) == PLUS) {
  99         start++;
 100         length--;
 101     } else if (str.charAt(start) == MINUS) {
 102         sign = -1;
 103         start++;
 104         length--;
 105     }
 106     int32_t num = 0;
 107     for (int32_t i = 0; i < length; i++) {
 108         int32_t digit = str.charAt(start + i) - 0x0030;
 109         if (digit < 0 || digit > 9) {
 110             status = U_INVALID_FORMAT_ERROR;
 111             return 0;
 112         }
 113         num = 10 * num + digit;
 114     }
 115     return sign * num;
 116 }
 117
 118 static UnicodeString& appendAsciiDigits(int32_t number, uint8_t length, UnicodeString& str) {
 119     UBool negative = FALSE;
 120     int32_t digits[10]; // max int32_t is 10 decimal digits
 121     int32_t i;
 122
 123     if (number < 0) {
 124         negative = TRUE;
 125         number *= -1;
 126     }
 127
 128     length = length > 10 ? 10 : length;
 129     if (length == 0) {
 130         // variable length
 131         i = 0;
 132         do {
 133             digits[i++] = number % 10;
 134             number /= 10;
 135         } while (number != 0);
 136         length = i;
 137     } else {
 138         // fixed digits
 139         for (i = 0; i < length; i++) {
 140            digits[i] = number % 10;
 141            number /= 10;
 142         }
 143     }
 144     if (negative) {
 145         str.append(MINUS);
 146     }
 147     for (i = length - 1; i >= 0; i--) {
 148         str.append((UChar)(digits[i] + 0x0030));
 149     }
 150     return str;
 151 }
 152
 153 static UnicodeString& appendMillis(UDate date, UnicodeString& str) {
 154     UBool negative = FALSE;
 155     int32_t digits[20]; // max int64_t is 20 decimal digits
 156     int32_t i;
 157     int64_t number;
 158
 159     if (date < MIN_MILLIS) {
 160         number = (int64_t)MIN_MILLIS;
 161     } else if (date > MAX_MILLIS) {
 162         number = (int64_t)MAX_MILLIS;
 163     } else {
 164         number = (int64_t)date;
 165     }
 166     if (number < 0) {
 167         negative = TRUE;
 168         number *= -1;
 169     }
 170     i = 0;
 171     do {
 172         digits[i++] = (int32_t)(number % 10);
 173         number /= 10;
 174     } while (number != 0);
 175
 176     if (negative) {
 177         str.append(MINUS);
 178     }
 179     i--;
 180     while (i >= 0) {
 181         str.append((UChar)(digits[i--] + 0x0030));
 182     }
 183     return str;
 184 }
 185
 186 /*
 187  * Convert date/time to RFC2445 Date-Time form #1 DATE WITH LOCAL TIME
 188  */
 189 static UnicodeString& getDateTimeString(UDate time, UnicodeString& str) {
 190     int32_t year, month, dom, dow, doy, mid;
 191     Grego::timeToFields(time, year, month, dom, dow, doy, mid);
 192
 193     str.remove();
 194     appendAsciiDigits(year, 4, str);
 195     appendAsciiDigits(month + 1, 2, str);
 196     appendAsciiDigits(dom, 2, str);
 197     str.append((UChar)0x0054 /*'T'*/);
 198
 199     int32_t t = mid;
 200     int32_t hour = t / U_MILLIS_PER_HOUR;
 201     t %= U_MILLIS_PER_HOUR;
 202     int32_t min = t / U_MILLIS_PER_MINUTE;
 203     t %= U_MILLIS_PER_MINUTE;
 204     int32_t sec = t / U_MILLIS_PER_SECOND;
 205
 206     appendAsciiDigits(hour, 2, str);
 207     appendAsciiDigits(min, 2, str);
 208     appendAsciiDigits(sec, 2, str);
 209     return str;
 210 }
 211
 212 /*
 213  * Convert date/time to RFC2445 Date-Time form #2 DATE WITH UTC TIME
 214  */
 215 static UnicodeString& getUTCDateTimeString(UDate time, UnicodeString& str) {
 216     getDateTimeString(time, str);
 217     str.append((UChar)0x005A /*'Z'*/);
 218     return str;
 219 }
 220
 221 /*
 222  * Parse RFC2445 Date-Time form #1 DATE WITH LOCAL TIME and
 223  * #2 DATE WITH UTC TIME
 224  */
 225 static UDate parseDateTimeString(const UnicodeString& str, int32_t offset, UErrorCode& status) {
 226     if (U_FAILURE(status)) {
 227         return 0.0;
 228     }
 229
 230     int32_t year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0;
 231     UBool isUTC = FALSE;
 232     UBool isValid = FALSE;
 233     do {
 234         int length = str.length();
 235         if (length != 15 && length != 16) {
 236             // FORM#1 15 characters, such as "20060317T142115"
 237             // FORM#2 16 characters, such as "20060317T142115Z"
 238             break;
 239         }
 240         if (str.charAt(8) != 0x0054) {
 241             // charcter "T" must be used for separating date and time
 242             break;
 243         }
 244         if (length == 16) {
 245             if (str.charAt(15) != 0x005A) {
 246                 // invalid format
 247                 break;
 248             }
 249             isUTC = TRUE;
 250         }
 251
 252         year = parseAsciiDigits(str, 0, 4, status);
 253         month = parseAsciiDigits(str, 4, 2, status) - 1;  // 0-based
 254         day = parseAsciiDigits(str, 6, 2, status);
 255         hour = parseAsciiDigits(str, 9, 2, status);
 256         min = parseAsciiDigits(str, 11, 2, status);
 257         sec = parseAsciiDigits(str, 13, 2, status);
 258
 259         if (U_FAILURE(status)) {
 260             break;
 261         }
 262
 263         // check valid range
 264         int32_t maxDayOfMonth = Grego::monthLength(year, month);
 265         if (year < 0 || month < 0 || month > 11 || day < 1 || day > maxDayOfMonth ||
 266                 hour < 0 || hour >= 24 || min < 0 || min >= 60 || sec < 0 || sec >= 60) {
 267             break;
 268         }
 269
 270         isValid = TRUE;
 271     } while(false);
 272
 273     if (!isValid) {
 274         status = U_INVALID_FORMAT_ERROR;
 275         return 0.0;
 276     }
 277     // Calculate the time
 278     UDate time = Grego::fieldsToDay(year, month, day) * U_MILLIS_PER_DAY;
 279     time += (hour * U_MILLIS_PER_HOUR + min * U_MILLIS_PER_MINUTE + sec * U_MILLIS_PER_SECOND);
 280     if (!isUTC) {
 281         time -= offset;
 282     }
 283     return time;
 284 }
 285
 286 /*
 287  * Convert RFC2445 utc-offset string to milliseconds
 288  */
 289 static int32_t offsetStrToMillis(const UnicodeString& str, UErrorCode& status) {
 290     if (U_FAILURE(status)) {
 291         return 0;
 292     }
 293
 294     UBool isValid = FALSE;
 295     int32_t sign = 0, hour = 0, min = 0, sec = 0;
 296
 297     do {
 298         int length = str.length();
 299         if (length != 5 && length != 7) {
 300             // utf-offset must be 5 or 7 characters
 301             break;
 302         }
 303         // sign
 304         UChar s = str.charAt(0);
 305         if (s == PLUS) {
 306             sign = 1;
 307         } else if (s == MINUS) {
 308             sign = -1;
 309         } else {
 310             // utf-offset must start with "+" or "-"
 311             break;
 312         }
 313         hour = parseAsciiDigits(str, 1, 2, status);
 314         min = parseAsciiDigits(str, 3, 2, status);
 315         if (length == 7) {
 316             sec = parseAsciiDigits(str, 5, 2, status);
 317         }
 318         if (U_FAILURE(status)) {
 319             break;
 320         }
 321         isValid = true;
 322     } while(false);
 323
 324     if (!isValid) {
 325         status = U_INVALID_FORMAT_ERROR;
 326         return 0;
 327     }
 328     int32_t millis = sign * ((hour * 60 + min) * 60 + sec) * 1000;
 329     return millis;
 330 }
 331
 332 /*
 333  * Convert milliseconds to RFC2445 utc-offset string
 334  */
 335 static void millisToOffset(int32_t millis, UnicodeString& str) {
 336     str.remove();
 337     if (millis >= 0) {
 338         str.append(PLUS);
 339     } else {
 340         str.append(MINUS);
 341         millis = -millis;
 342     }
 343     int32_t hour, min, sec;
 344     int32_t t = millis / 1000;
 345
 346     sec = t % 60;
 347     t = (t - sec) / 60;
 348     min = t % 60;
 349     hour = t / 60;
 350
 351     appendAsciiDigits(hour, 2, str);
 352     appendAsciiDigits(min, 2, str);
 353     appendAsciiDigits(sec, 2, str);
 354 }
 355
 356 /*
 357  * Create a default TZNAME from TZID
 358  */
 359 static void getDefaultTZName(const UnicodeString tzid, UBool isDST, UnicodeString& zonename) {
 360     zonename = tzid;
 361     if (isDST) {
 362         zonename += UNICODE_STRING_SIMPLE("(DST)");
 363     } else {
 364         zonename += UNICODE_STRING_SIMPLE("(STD)");
 365     }
 366 }
 367
 368 /*
 369  * Parse individual RRULE
 370  *
 371  * On return -
 372  *
 373  * month    calculated by BYMONTH-1, or -1 when not found
 374  * dow      day of week in BYDAY, or 0 when not found
 375  * wim      day of week ordinal number in BYDAY, or 0 when not found
 376  * dom      an array of day of month
 377  * domCount number of availble days in dom (domCount is specifying the size of dom on input)
 378  * until    time defined by UNTIL attribute or MIN_MILLIS if not available
 379  */
 380 static void parseRRULE(const UnicodeString& rrule, int32_t& month, int32_t& dow, int32_t& wim,
 381                        int32_t* dom, int32_t& domCount, UDate& until, UErrorCode& status) {
 382     if (U_FAILURE(status)) {
 383         return;
 384     }
 385     int32_t numDom = 0;
 386
 387     month = -1;
 388     dow = 0;
 389     wim = 0;
 390     until = MIN_MILLIS;
 391
 392     UBool yearly = FALSE;
 393     //UBool parseError = FALSE;
 394
 395     int32_t prop_start = 0;
 396     int32_t prop_end;
 397     UnicodeString prop, attr, value;
 398     UBool nextProp = TRUE;
 399
 400     while (nextProp) {
 401         prop_end = rrule.indexOf(SEMICOLON, prop_start);
 402         if (prop_end == -1) {
 403             prop.setTo(rrule, prop_start);
 404             nextProp = FALSE;
 405         } else {
 406             prop.setTo(rrule, prop_start, prop_end - prop_start);
 407             prop_start = prop_end + 1;
 408         }
 409         int32_t eql = prop.indexOf(EQUALS_SIGN);
 410         if (eql != -1) {
 411             attr.setTo(prop, 0, eql);
 412             value.setTo(prop, eql + 1);
 413         } else {
 414             goto rruleParseError;
 415         }
 416
 417         if (attr.compare(ICAL_FREQ, -1) == 0) {
 418             // only support YEARLY frequency type
 419             if (value.compare(ICAL_YEARLY, -1) == 0) {
 420                 yearly = TRUE;
 421             } else {
 422                 goto rruleParseError;
 423             }
 424         } else if (attr.compare(ICAL_UNTIL, -1) == 0) {
 425             // ISO8601 UTC format, for example, "20060315T020000Z"
 426             until = parseDateTimeString(value, 0, status);
 427             if (U_FAILURE(status)) {
 428                 goto rruleParseError;
 429             }
 430         } else if (attr.compare(ICAL_BYMONTH, -1) == 0) {
 431             // Note: BYMONTH may contain multiple months, but only single month make sense for
 432             // VTIMEZONE property.
 433             if (value.length() > 2) {
 434                 goto rruleParseError;
 435             }
 436             month = parseAsciiDigits(value, 0, value.length(), status) - 1;
 437             if (U_FAILURE(status) || month < 0 || month >= 12) {
 438                 goto rruleParseError;
 439             }
 440         } else if (attr.compare(ICAL_BYDAY, -1) == 0) {
 441             // Note: BYDAY may contain multiple day of week separated by comma.  It is unlikely used for
 442             // VTIMEZONE property.  We do not support the case.
 443
 444             // 2-letter format is used just for representing a day of week, for example, "SU" for Sunday
 445             // 3 or 4-letter format is used for represeinging Nth day of week, for example, "-1SA" for last Saturday
 446             int32_t length = value.length();
 447             if (length < 2 || length > 4) {
 448                 goto rruleParseError;
 449             }
 450             if (length > 2) {
 451                 // Nth day of week
 452                 int32_t sign = 1;
 453                 if (value.charAt(0) == PLUS) {
 454                     sign = 1;
 455                 } else if (value.charAt(0) == MINUS) {
 456                     sign = -1;
 457                 } else if (length == 4) {
 458                     goto rruleParseError;
 459                 }
 460                 int32_t n = parseAsciiDigits(value, length - 3, 1, status);
 461                 if (U_FAILURE(status) || n == 0 || n > 4) {
 462                     goto rruleParseError;
 463                 }
 464                 wim = n * sign;
 465                 value.remove(0, length - 2);
 466             }
 467             int32_t wday;
 468             for (wday = 0; wday < 7; wday++) {
 469                 if (value.compare(ICAL_DOW_NAMES[wday], 2) == 0) {
 470                     break;
 471                 }
 472             }
 473             if (wday < 7) {
 474                 // Sunday(1) - Saturday(7)
 475                 dow = wday + 1;
 476             } else {
 477                 goto rruleParseError;
 478             }
 479         } else if (attr.compare(ICAL_BYMONTHDAY, -1) == 0) {
 480             // Note: BYMONTHDAY may contain multiple days delimitted by comma
 481             //
 482             // A value of BYMONTHDAY could be negative, for example, -1 means
 483             // the last day in a month
 484             int32_t dom_idx = 0;
 485             int32_t dom_start = 0;
 486             int32_t dom_end;
 487             UBool nextDOM = TRUE;
 488             while (nextDOM) {
 489                 dom_end = value.indexOf(COMMA, dom_start);
 490                 if (dom_end == -1) {
 491                     dom_end = value.length();
 492                     nextDOM = FALSE;
 493                 }
 494                 if (dom_idx < domCount) {
 495                     dom[dom_idx] = parseAsciiDigits(value, dom_start, dom_end - dom_start, status);
 496                     if (U_FAILURE(status)) {
 497                         goto rruleParseError;
 498                     }
 499                     dom_idx++;
 500                 } else {
 501                     status = U_BUFFER_OVERFLOW_ERROR;
 502                     goto rruleParseError;
 503                 }
 504                 dom_start = dom_end + 1;
 505             }
 506             numDom = dom_idx;
 507         }
 508     }
 509     if (!yearly) {
 510         // FREQ=YEARLY must be set
 511         goto rruleParseError;
 512     }
 513     // Set actual number of parsed DOM (ICAL_BYMONTHDAY)
 514     domCount = numDom;
 515     return;
 516
 517 rruleParseError:
 518     if (U_SUCCESS(status)) {
 519         // Set error status
 520         status = U_INVALID_FORMAT_ERROR;
 521     }
 522 }
 523
 524 static TimeZoneRule* createRuleByRRULE(const UnicodeString& zonename, int rawOffset, int dstSavings, UDate start,
 525                                        UVector* dates, int fromOffset, UErrorCode& status) {
 526     if (U_FAILURE(status)) {
 527         return NULL;
 528     }
 529     if (dates == NULL || dates->size() == 0) {
 530         status = U_ILLEGAL_ARGUMENT_ERROR;
 531         return NULL;
 532     }
 533
 534     int32_t i, j;
 535     DateTimeRule *adtr = NULL;
 536
 537     // Parse the first rule
 538     UnicodeString rrule = *((UnicodeString*)dates->elementAt(0));
 539     int32_t month, dayOfWeek, nthDayOfWeek, dayOfMonth = 0;
 540     int32_t days[7];
 541     int32_t daysCount = sizeof(days)/sizeof(days[0]);
 542     UDate until;
 543
 544     parseRRULE(rrule, month, dayOfWeek, nthDayOfWeek, days, daysCount, until, status);
 545     if (U_FAILURE(status)) {
 546         return NULL;
 547     }
 548
 549     if (dates->size() == 1) {
 550         // No more rules
 551         if (daysCount > 1) {
 552             // Multiple BYMONTHDAY values
 553             if (daysCount != 7 || month == -1 || dayOfWeek == 0) {
 554                 // Only support the rule using 7 continuous days
 555                 // BYMONTH and BYDAY must be set at the same time
 556                 goto unsupportedRRule;
 557             }
 558             int32_t firstDay = 31; // max possible number of dates in a month
 559             for (i = 0; i < 7; i++) {
 560                 // Resolve negative day numbers.  A negative day number should
 561                 // not be used in February, but if we see such case, we use 28
 562                 // as the base.
 563                 if (days[i] < 0) {
 564                     days[i] = MONTHLENGTH[month] + days[i] + 1;
 565                 }
 566                 if (days[i] < firstDay) {
 567                     firstDay = days[i];
 568                 }
 569             }
 570             // Make sure days are continuous
 571             for (i = 1; i < 7; i++) {
 572                 UBool found = FALSE;
 573                 for (j = 0; j < 7; j++) {
 574                     if (days[j] == firstDay + i) {
 575                         found = TRUE;
 576                         break;
 577                     }
 578                 }
 579                 if (!found) {
 580                     // days are not continuous
 581                     goto unsupportedRRule;
 582                 }
 583             }
 584             // Use DOW_GEQ_DOM rule with firstDay as the start date
 585             dayOfMonth = firstDay;
 586         }
 587     } else {
 588         // Check if BYMONTH + BYMONTHDAY + BYDAY rule with multiple RRULE lines.
 589         // Otherwise, not supported.
 590         if (month == -1 || dayOfWeek == 0 || daysCount == 0) {
 591             // This is not the case
 592             goto unsupportedRRule;
 593         }
 594         // Parse the rest of rules if number of rules is not exceeding 7.
 595         // We can only support 7 continuous days starting from a day of month.
 596         if (dates->size() > 7) {
 597             goto unsupportedRRule;
 598         }
 599
 600         // Note: To check valid date range across multiple rule is a little
 601         // bit complicated.  For now, this code is not doing strict range
 602         // checking across month boundary
 603
 604         int32_t earliestMonth = month;
 605         int32_t earliestDay = 31;
 606         for (i = 0; i < daysCount; i++) {
 607             int32_t dom = days[i];
 608             dom = dom > 0 ? dom : MONTHLENGTH[month] + dom + 1;
 609             earliestDay = dom < earliestDay ? dom : earliestDay;
 610         }
 611
 612         int32_t anotherMonth = -1;
 613         for (i = 1; i < dates->size(); i++) {
 614             rrule = *((UnicodeString*)dates->elementAt(i));
 615             UDate tmp_until;
 616             int32_t tmp_month, tmp_dayOfWeek, tmp_nthDayOfWeek;
 617             int32_t tmp_days[7];
 618             int32_t tmp_daysCount = sizeof(tmp_days)/sizeof(tmp_days[0]);
 619             parseRRULE(rrule, tmp_month, tmp_dayOfWeek, tmp_nthDayOfWeek, tmp_days, tmp_daysCount, tmp_until, status);
 620             if (U_FAILURE(status)) {
 621                 return NULL;
 622             }
 623             // If UNTIL is newer than previous one, use the one
 624             if (tmp_until > until) {
 625                 until = tmp_until;
 626             }
 627
 628             // Check if BYMONTH + BYMONTHDAY + BYDAY rule
 629             if (tmp_month == -1 || tmp_dayOfWeek == 0 || tmp_daysCount == 0) {
 630                 goto unsupportedRRule;
 631             }
 632             // Count number of BYMONTHDAY
 633             if (daysCount + tmp_daysCount > 7) {
 634                 // We cannot support BYMONTHDAY more than 7
 635                 goto unsupportedRRule;
 636             }
 637             // Check if the same BYDAY is used.  Otherwise, we cannot
 638             // support the rule
 639             if (tmp_dayOfWeek != dayOfWeek) {
 640                 goto unsupportedRRule;
 641             }
 642             // Check if the month is same or right next to the primary month
 643             if (tmp_month != month) {
 644                 if (anotherMonth == -1) {
 645                     int32_t diff = tmp_month - month;
 646                     if (diff == -11 || diff == -1) {
 647                         // Previous month
 648                         anotherMonth = tmp_month;
 649                         earliestMonth = anotherMonth;
 650                         // Reset earliest day
 651                         earliestDay = 31;
 652                     } else if (diff == 11 || diff == 1) {
 653                         // Next month
 654                         anotherMonth = tmp_month;
 655                     } else {
 656                         // The day range cannot exceed more than 2 months
 657                         goto unsupportedRRule;
 658                     }
 659                 } else if (tmp_month != month && tmp_month != anotherMonth) {
 660                     // The day range cannot exceed more than 2 months
 661                     goto unsupportedRRule;
 662                 }
 663             }
 664             // If ealier month, go through days to find the earliest day
 665             if (tmp_month == earliestMonth) {
 666                 for (j = 0; j < tmp_daysCount; j++) {
 667                     tmp_days[j] = tmp_days[j] > 0 ? tmp_days[j] : MONTHLENGTH[tmp_month] + tmp_days[j] + 1;
 668                     earliestDay = tmp_days[j] < earliestDay ? tmp_days[j] : earliestDay;
 669                 }
 670             }
 671             daysCount += tmp_daysCount;
 672         }
 673         if (daysCount != 7) {
 674             // Number of BYMONTHDAY entries must be 7
 675             goto unsupportedRRule;
 676         }
 677         month = earliestMonth;
 678         dayOfMonth = earliestDay;
 679     }
 680
 681     // Calculate start/end year and missing fields
 682     int32_t startYear, startMonth, startDOM, startDOW, startDOY, startMID;
 683     Grego::timeToFields(start + fromOffset, startYear, startMonth, startDOM,
 684         startDOW, startDOY, startMID);
 685     if (month == -1) {
 686         // If BYMONTH is not set, use the month of DTSTART
 687         month = startMonth;
 688     }
 689     if (dayOfWeek == 0 && nthDayOfWeek == 0 && dayOfMonth == 0) {
 690         // If only YEARLY is set, use the day of DTSTART as BYMONTHDAY
 691         dayOfMonth = startDOM;
 692     }
 693
 694     int32_t endYear;
 695     if (until != MIN_MILLIS) {
 696         int32_t endMonth, endDOM, endDOW, endDOY, endMID;
 697         Grego::timeToFields(until, endYear, endMonth, endDOM, endDOW, endDOY, endMID);
 698     } else {
 699         endYear = AnnualTimeZoneRule::MAX_YEAR;
 700     }
 701
 702     // Create the AnnualDateTimeRule
 703     if (dayOfWeek == 0 && nthDayOfWeek == 0 && dayOfMonth != 0) {
 704         // Day in month rule, for example, 15th day in the month
 705         adtr = new DateTimeRule(month, dayOfMonth, startMID, DateTimeRule::WALL_TIME);
 706     } else if (dayOfWeek != 0 && nthDayOfWeek != 0 && dayOfMonth == 0) {
 707         // Nth day of week rule, for example, last Sunday
 708         adtr = new DateTimeRule(month, nthDayOfWeek, dayOfWeek, startMID, DateTimeRule::WALL_TIME);
 709     } else if (dayOfWeek != 0 && nthDayOfWeek == 0 && dayOfMonth != 0) {
 710         // First day of week after day of month rule, for example,
 711         // first Sunday after 15th day in the month
 712         adtr = new DateTimeRule(month, dayOfMonth, dayOfWeek, TRUE, startMID, DateTimeRule::WALL_TIME);
 713     }
 714     if (adtr == NULL) {
 715         goto unsupportedRRule;
 716     }
 717     return new AnnualTimeZoneRule(zonename, rawOffset, dstSavings, adtr, startYear, endYear);
 718
 719 unsupportedRRule:
 720     status = U_INVALID_STATE_ERROR;
 721     return NULL;
 722 }
 723
 724 /*
 725  * Create a TimeZoneRule by the RDATE definition
 726  */
 727 static TimeZoneRule* createRuleByRDATE(const UnicodeString& zonename, int32_t rawOffset, int32_t dstSavings,
 728                                        UDate start, UVector* dates, int32_t fromOffset, UErrorCode& status) {
 729     if (U_FAILURE(status)) {
 730         return NULL;
 731     }
 732     TimeArrayTimeZoneRule *retVal = NULL;
 733     if (dates == NULL || dates->size() == 0) {
 734         // When no RDATE line is provided, use start (DTSTART)
 735         // as the transition time
 736         retVal = new TimeArrayTimeZoneRule(zonename, rawOffset, dstSavings,
 737             &start, 1, DateTimeRule::UTC_TIME);
 738     } else {
 739         // Create an array of transition times
 740         int32_t size = dates->size();
 741         UDate* times = (UDate*)uprv_malloc(sizeof(UDate) * size);
 742         if (times == NULL) {
 743             status = U_MEMORY_ALLOCATION_ERROR;
 744             return NULL;
 745         }
 746         for (int32_t i = 0; i < size; i++) {
 747             UnicodeString *datestr = (UnicodeString*)dates->elementAt(i);
 748             times[i] = parseDateTimeString(*datestr, fromOffset, status);
 749             if (U_FAILURE(status)) {
 750                 uprv_free(times);
 751                 return NULL;
 752             }
 753         }
 754         retVal = new TimeArrayTimeZoneRule(zonename, rawOffset, dstSavings,
 755             times, size, DateTimeRule::UTC_TIME);
 756         uprv_free(times);
 757     }
 758     return retVal;
 759 }
 760
 761 /*
 762  * Check if the DOW rule specified by month, weekInMonth and dayOfWeek is equivalent
 763  * to the DateTimerule.
 764  */
 765 static UBool isEquivalentDateRule(int32_t month, int32_t weekInMonth, int32_t dayOfWeek, const DateTimeRule *dtrule) {
 766     if (month != dtrule->getRuleMonth() || dayOfWeek != dtrule->getRuleDayOfWeek()) {
 767         return FALSE;
 768     }
 769     if (dtrule->getTimeRuleType() != DateTimeRule::WALL_TIME) {
 770         // Do not try to do more intelligent comparison for now.
 771         return FALSE;
 772     }
 773     if (dtrule->getDateRuleType() == DateTimeRule::DOW
 774             && dtrule->getRuleWeekInMonth() == weekInMonth) {
 775         return TRUE;
 776     }
 777     int32_t ruleDOM = dtrule->getRuleDayOfMonth();
 778     if (dtrule->getDateRuleType() == DateTimeRule::DOW_GEQ_DOM) {
 779         if (ruleDOM%7 == 1 && (ruleDOM + 6)/7 == weekInMonth) {
 780             return TRUE;
 781         }
 782         if (month != UCAL_FEBRUARY && (MONTHLENGTH[month] - ruleDOM)%7 == 6
 783                 && weekInMonth == -1*((MONTHLENGTH[month]-ruleDOM+1)/7)) {
 784             return TRUE;
 785         }
 786     }
 787     if (dtrule->getDateRuleType() == DateTimeRule::DOW_LEQ_DOM) {
 788         if (ruleDOM%7 == 0 && ruleDOM/7 == weekInMonth) {
 789             return TRUE;
 790         }
 791         if (month != UCAL_FEBRUARY && (MONTHLENGTH[month] - ruleDOM)%7 == 0
 792                 && weekInMonth == -1*((MONTHLENGTH[month] - ruleDOM)/7 + 1)) {
 793             return TRUE;
 794         }
 795     }
 796     return FALSE;
 797 }
 798
 799 /*
 800  * Convert the rule to its equivalent rule using WALL_TIME mode.
 801  * This function returns NULL when the specified DateTimeRule is already
 802  * using WALL_TIME mode.
 803  */
 804 static DateTimeRule* toWallTimeRule(const DateTimeRule* rule, int32_t rawOffset, int32_t dstSavings) {
 805     if (rule->getTimeRuleType() == DateTimeRule::WALL_TIME) {
 806         return NULL;
 807     }
 808     int32_t wallt = rule->getRuleMillisInDay();
 809     if (rule->getTimeRuleType() == DateTimeRule::UTC_TIME) {
 810         wallt += (rawOffset + dstSavings);
 811     } else if (rule->getTimeRuleType() == DateTimeRule::STANDARD_TIME) {
 812         wallt += dstSavings;
 813     }
 814
 815     int32_t month = -1, dom = 0, dow = 0;
 816     DateTimeRule::DateRuleType dtype;
 817     int32_t dshift = 0;
 818     if (wallt < 0) {
 819         dshift = -1;
 820         wallt += U_MILLIS_PER_DAY;
 821     } else if (wallt >= U_MILLIS_PER_DAY) {
 822         dshift = 1;
 823         wallt -= U_MILLIS_PER_DAY;
 824     }
 825
 826     month = rule->getRuleMonth();
 827     dom = rule->getRuleDayOfMonth();
 828     dow = rule->getRuleDayOfWeek();
 829     dtype = rule->getDateRuleType();
 830
 831     if (dshift != 0) {
 832         if (dtype == DateTimeRule::DOW) {
 833             // Convert to DOW_GEW_DOM or DOW_LEQ_DOM rule first
 834             int32_t wim = rule->getRuleWeekInMonth();
 835             if (wim > 0) {
 836                 dtype = DateTimeRule::DOW_GEQ_DOM;
 837                 dom = 7 * (wim - 1) + 1;
 838             } else {
 839                 dtype = DateTimeRule::DOW_LEQ_DOM;
 840                 dom = MONTHLENGTH[month] + 7 * (wim + 1);
 841             }
 842         }
 843         // Shift one day before or after
 844         dom += dshift;
 845         if (dom == 0) {
 846             month--;
 847             month = month < UCAL_JANUARY ? UCAL_DECEMBER : month;
 848             dom = MONTHLENGTH[month];
 849         } else if (dom > MONTHLENGTH[month]) {
 850             month++;
 851             month = month > UCAL_DECEMBER ? UCAL_JANUARY : month;
 852             dom = 1;
 853         }
 854         if (dtype != DateTimeRule::DOM) {
 855             // Adjust day of week
 856             dow += dshift;
 857             if (dow < UCAL_SUNDAY) {
 858                 dow = UCAL_SATURDAY;
 859             } else if (dow > UCAL_SATURDAY) {
 860                 dow = UCAL_SUNDAY;
 861             }
 862         }
 863     }
 864     // Create a new rule
 865     DateTimeRule *modifiedRule;
 866     if (dtype == DateTimeRule::DOM) {
 867         modifiedRule = new DateTimeRule(month, dom, wallt, DateTimeRule::WALL_TIME);
 868     } else {
 869         modifiedRule = new DateTimeRule(month, dom, dow,
 870             (dtype == DateTimeRule::DOW_GEQ_DOM), wallt, DateTimeRule::WALL_TIME);
 871     }
 872     return modifiedRule;
 873 }
 874
 875 /*
 876  * Minumum implementations of stream writer/reader, writing/reading
 877  * UnicodeString.  For now, we do not want to introduce the dependency
 878  * on the ICU I/O stream in this module.  But we want to keep the code
 879  * equivalent to the ICU4J implementation, which utilizes java.io.Writer/
 880  * Reader.
 881  */
 882 class VTZWriter {
 883 public:
 884     VTZWriter(UnicodeString& out);
 885     ~VTZWriter();
 886
 887     void write(const UnicodeString& str);
 888     void write(UChar ch);
 889     void write(const UChar* str);
 890     //void write(const UChar* str, int32_t length);
 891 private:
 892     UnicodeString* out;
 893 };
 894
 895 VTZWriter::VTZWriter(UnicodeString& output) {
 896     out = &output;
 897 }
 898
 899 VTZWriter::~VTZWriter() {
 900 }
 901
 902 void
 903 VTZWriter::write(const UnicodeString& str) {
 904     out->append(str);
 905 }
 906
 907 void
 908 VTZWriter::write(UChar ch) {
 909     out->append(ch);
 910 }
 911
 912 void
 913 VTZWriter::write(const UChar* str) {
 914     out->append(str, -1);
 915 }
 916
 917 /*
 918 void
 919 VTZWriter::write(const UChar* str, int32_t length) {
 920     out->append(str, length);
 921 }
 922 */
 923
 924 class VTZReader {
 925 public:
 926     VTZReader(const UnicodeString& input);
 927     ~VTZReader();
 928
 929     UChar read(void);
 930 private:
 931     const UnicodeString* in;
 932     int32_t index;
 933 };
 934
 935 VTZReader::VTZReader(const UnicodeString& input) {
 936     in = &input;
 937     index = 0;
 938 }
 939
 940 VTZReader::~VTZReader() {
 941 }
 942
 943 UChar
 944 VTZReader::read(void) {
 945     UChar ch = 0xFFFF;
 946     if (index < in->length()) {
 947         ch = in->charAt(index);
 948     }
 949     index++;
 950     return ch;
 951 }
 952
 953
 954 UOBJECT_DEFINE_RTTI_IMPLEMENTATION(VTimeZone)
 955
 956 VTimeZone::VTimeZone()
 957 :   BasicTimeZone(), tz(NULL), vtzlines(NULL),
 958     lastmod(MAX_MILLIS) {
 959 }
 960
 961 VTimeZone::VTimeZone(const VTimeZone& source)
 962 :   BasicTimeZone(source), tz(NULL), vtzlines(NULL),
 963     tzurl(source.tzurl), lastmod(source.lastmod),
 964     olsonzid(source.olsonzid), icutzver(source.icutzver) {
 965     if (source.tz != NULL) {
 966         tz = (BasicTimeZone*)source.tz->clone();
 967     }
 968     if (source.vtzlines != NULL) {
 969         UErrorCode status = U_ZERO_ERROR;
 970         int32_t size = source.vtzlines->size();
 971         vtzlines = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, size, status);
 972         if (U_SUCCESS(status)) {
 973             for (int32_t i = 0; i < size; i++) {
 974                 UnicodeString *line = (UnicodeString*)source.vtzlines->elementAt(i);
 975                 vtzlines->addElement(line->clone(), status);
 976                 if (U_FAILURE(status)) {
 977                     break;
 978                 }
 979             }
 980         }
 981         if (U_FAILURE(status) && vtzlines != NULL) {
 982             delete vtzlines;
 983         }
 984     }
 985 }
 986
 987 VTimeZone::~VTimeZone() {
 988     if (tz != NULL) {
 989         delete tz;
 990     }
 991     if (vtzlines != NULL) {
 992         delete vtzlines;
 993     }
 994 }
 995
 996 VTimeZone&
 997 VTimeZone::operator=(const VTimeZone& right) {
 998     if (this == &right) {
 999         return *this;
1000     }
1001     if (*this != right) {
1002         BasicTimeZone::operator=(right);
1003         if (tz != NULL) {
1004             delete tz;
1005             tz = NULL;
1006         }
1007         if (right.tz != NULL) {
1008             tz = (BasicTimeZone*)right.tz->clone();
1009         }
1010         if (vtzlines != NULL) {
1011             delete vtzlines;
1012         }
1013         if (right.vtzlines != NULL) {
1014             UErrorCode status = U_ZERO_ERROR;
1015             int32_t size = right.vtzlines->size();
1016             vtzlines = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, size, status);
1017             if (U_SUCCESS(status)) {
1018                 for (int32_t i = 0; i < size; i++) {
1019                     UnicodeString *line = (UnicodeString*)right.vtzlines->elementAt(i);
1020                     vtzlines->addElement(line->clone(), status);
1021                     if (U_FAILURE(status)) {
1022                         break;
1023                     }
1024                 }
1025             }
1026             if (U_FAILURE(status) && vtzlines != NULL) {
1027                 delete vtzlines;
1028                 vtzlines = NULL;
1029             }
1030         }
1031         tzurl = right.tzurl;
1032         lastmod = right.lastmod;
1033         olsonzid = right.olsonzid;
1034         icutzver = right.icutzver;
1035     }
1036     return *this;
1037 }
1038
1039 UBool
1040 VTimeZone::operator==(const TimeZone& that) const {
1041     if (this == &that) {
1042         return TRUE;
1043     }
1044     if (typeid(*this) != typeid(that) || !BasicTimeZone::operator==(that)) {
1045         return FALSE;
1046     }
1047     VTimeZone *vtz = (VTimeZone*)&that;
1048     if (*tz == *(vtz->tz)
1049         && tzurl == vtz->tzurl
1050         && lastmod == vtz->lastmod
1051         /* && olsonzid = that.olsonzid */
1052         /* && icutzver = that.icutzver */) {
1053         return TRUE;
1054     }
1055     return FALSE;
1056 }
1057
1058 UBool
1059 VTimeZone::operator!=(const TimeZone& that) const {
1060     return !operator==(that);
1061 }
1062
1063 VTimeZone*
1064 VTimeZone::createVTimeZoneByID(const UnicodeString& ID) {
1065     VTimeZone *vtz = new VTimeZone();
1066     vtz->tz = (BasicTimeZone*)TimeZone::createTimeZone(ID);
1067     vtz->tz->getID(vtz->olsonzid);
1068
1069     // Set ICU tzdata version
1070     UErrorCode status = U_ZERO_ERROR;
1071     UResourceBundle *bundle = NULL;
1072     const UChar* versionStr = NULL;
1073     int32_t len = 0;
1074     bundle = ures_openDirect(NULL, "zoneinfo64", &status);
1075     versionStr = ures_getStringByKey(bundle, "TZVersion", &len, &status);
1076     if (U_SUCCESS(status)) {
1077         vtz->icutzver.setTo(versionStr, len);
1078     }
1079     ures_close(bundle);
1080     return vtz;
1081 }
1082
1083 VTimeZone*
1084 VTimeZone::createVTimeZoneFromBasicTimeZone(const BasicTimeZone& basic_time_zone, UErrorCode &status) {
1085     if (U_FAILURE(status)) {
1086         return NULL;
1087     }
1088     VTimeZone *vtz = new VTimeZone();
1089     if (vtz == NULL) {
1090         status = U_MEMORY_ALLOCATION_ERROR;
1091         return NULL;
1092     }
1093     vtz->tz = (BasicTimeZone *)basic_time_zone.clone();
1094     if (vtz->tz == NULL) {
1095         status = U_MEMORY_ALLOCATION_ERROR;
1096         delete vtz;
1097         return NULL;
1098     }
1099     vtz->tz->getID(vtz->olsonzid);
1100
1101     // Set ICU tzdata version
1102     UResourceBundle *bundle = NULL;
1103     const UChar* versionStr = NULL;
1104     int32_t len = 0;
1105     bundle = ures_openDirect(NULL, "zoneinfo64", &status);
1106     versionStr = ures_getStringByKey(bundle, "TZVersion", &len, &status);
1107     if (U_SUCCESS(status)) {
1108         vtz->icutzver.setTo(versionStr, len);
1109     }
1110     ures_close(bundle);
1111     return vtz;
1112 }
1113
1114 VTimeZone*
1115 VTimeZone::createVTimeZone(const UnicodeString& vtzdata, UErrorCode& status) {
1116     if (U_FAILURE(status)) {
1117         return NULL;
1118     }
1119     VTZReader reader(vtzdata);
1120     VTimeZone *vtz = new VTimeZone();
1121     vtz->load(reader, status);
1122     if (U_FAILURE(status)) {
1123         delete vtz;
1124         return NULL;
1125     }
1126     return vtz;
1127 }
1128
1129 UBool
1130 VTimeZone::getTZURL(UnicodeString& url) const {
1131     if (tzurl.length() > 0) {
1132         url = tzurl;
1133         return TRUE;
1134     }
1135     return FALSE;
1136 }
1137
1138 void
1139 VTimeZone::setTZURL(const UnicodeString& url) {
1140     tzurl = url;
1141 }
1142
1143 UBool
1144 VTimeZone::getLastModified(UDate& lastModified) const {
1145     if (lastmod != MAX_MILLIS) {
1146         lastModified = lastmod;
1147         return TRUE;
1148     }
1149     return FALSE;
1150 }
1151
1152 void
1153 VTimeZone::setLastModified(UDate lastModified) {
1154     lastmod = lastModified;
1155 }
1156
1157 void
1158 VTimeZone::write(UnicodeString& result, UErrorCode& status) const {
1159     result.remove();
1160     VTZWriter writer(result);
1161     write(writer, status);
1162 }
1163
1164 void
1165 VTimeZone::write(UDate start, UnicodeString& result, UErrorCode& status) const {
1166     result.remove();
1167     VTZWriter writer(result);
1168     write(start, writer, status);
1169 }
1170
1171 void
1172 VTimeZone::writeSimple(UDate time, UnicodeString& result, UErrorCode& status) const {
1173     result.remove();
1174     VTZWriter writer(result);
1175     writeSimple(time, writer, status);
1176 }
1177
1178 TimeZone*
1179 VTimeZone::clone(void) const {
1180     return new VTimeZone(*this);
1181 }
1182
1183 int32_t
1184 VTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
1185                      uint8_t dayOfWeek, int32_t millis, UErrorCode& status) const {
1186     return tz->getOffset(era, year, month, day, dayOfWeek, millis, status);
1187 }
1188
1189 int32_t
1190 VTimeZone::getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
1191                      uint8_t dayOfWeek, int32_t millis,
1192                      int32_t monthLength, UErrorCode& status) const {
1193     return tz->getOffset(era, year, month, day, dayOfWeek, millis, monthLength, status);
1194 }
1195
1196 void
1197 VTimeZone::getOffset(UDate date, UBool local, int32_t& rawOffset,
1198                      int32_t& dstOffset, UErrorCode& status) const {
1199     return tz->getOffset(date, local, rawOffset, dstOffset, status);
1200 }
1201
1202 void
1203 VTimeZone::setRawOffset(int32_t offsetMillis) {
1204     tz->setRawOffset(offsetMillis);
1205 }
1206
1207 int32_t
1208 VTimeZone::getRawOffset(void) const {
1209     return tz->getRawOffset();
1210 }
1211
1212 UBool
1213 VTimeZone::useDaylightTime(void) const {
1214     return tz->useDaylightTime();
1215 }
1216
1217 UBool
1218 VTimeZone::inDaylightTime(UDate date, UErrorCode& status) const {
1219     return tz->inDaylightTime(date, status);
1220 }
1221
1222 UBool
1223 VTimeZone::hasSameRules(const TimeZone& other) const {
1224     return tz->hasSameRules(other);
1225 }
1226
1227 UBool
1228 VTimeZone::getNextTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const {
1229     return tz->getNextTransition(base, inclusive, result);
1230 }
1231
1232 UBool
1233 VTimeZone::getPreviousTransition(UDate base, UBool inclusive, TimeZoneTransition& result) const {
1234     return tz->getPreviousTransition(base, inclusive, result);
1235 }
1236
1237 int32_t
1238 VTimeZone::countTransitionRules(UErrorCode& status) const {
1239     return tz->countTransitionRules(status);
1240 }
1241
1242 void
1243 VTimeZone::getTimeZoneRules(const InitialTimeZoneRule*& initial,
1244                             const TimeZoneRule* trsrules[], int32_t& trscount,
1245                             UErrorCode& status) const {
1246     tz->getTimeZoneRules(initial, trsrules, trscount, status);
1247 }
1248
1249 void
1250 VTimeZone::load(VTZReader& reader, UErrorCode& status) {
1251     vtzlines = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, DEFAULT_VTIMEZONE_LINES, status);
1252     if (U_FAILURE(status)) {
1253         return;
1254     }
1255     UBool eol = FALSE;
1256     UBool start = FALSE;
1257     UBool success = FALSE;
1258     UnicodeString line;
1259
1260     while (TRUE) {
1261         UChar ch = reader.read();
1262         if (ch == 0xFFFF) {
1263             // end of file
1264             if (start && line.startsWith(ICAL_END_VTIMEZONE, -1)) {
1265                 vtzlines->addElement(new UnicodeString(line), status);
1266                 if (U_FAILURE(status)) {
1267                     goto cleanupVtzlines;
1268                 }
1269                 success = TRUE;
1270             }
1271             break;
1272         }
1273         if (ch == 0x000D) {
1274             // CR, must be followed by LF according to the definition in RFC2445
1275             continue;
1276         }
1277         if (eol) {
1278             if (ch != 0x0009 && ch != 0x0020) {
1279                 // NOT followed by TAB/SP -> new line
1280                 if (start) {
1281                     if (line.length() > 0) {
1282                         vtzlines->addElement(new UnicodeString(line), status);
1283                         if (U_FAILURE(status)) {
1284                             goto cleanupVtzlines;
1285                         }
1286                     }
1287                 }
1288                 line.remove();
1289                 if (ch != 0x000A) {
1290                     line.append(ch);
1291                 }
1292             }
1293             eol = FALSE;
1294         } else {
1295             if (ch == 0x000A) {
1296                 // LF
1297                 eol = TRUE;
1298                 if (start) {
1299                     if (line.startsWith(ICAL_END_VTIMEZONE, -1)) {
1300                         vtzlines->addElement(new UnicodeString(line), status);
1301                         if (U_FAILURE(status)) {
1302                             goto cleanupVtzlines;
1303                         }
1304                         success = TRUE;
1305                         break;
1306                     }
1307                 } else {
1308                     if (line.startsWith(ICAL_BEGIN_VTIMEZONE, -1)) {
1309                         vtzlines->addElement(new UnicodeString(line), status);
1310                         if (U_FAILURE(status)) {
1311                             goto cleanupVtzlines;
1312                         }
1313                         line.remove();
1314                         start = TRUE;
1315                         eol = FALSE;
1316                     }
1317                 }
1318             } else {
1319                 line.append(ch);
1320             }
1321         }
1322     }
1323     if (!success) {
1324         if (U_SUCCESS(status)) {
1325             status = U_INVALID_STATE_ERROR;
1326         }
1327         goto cleanupVtzlines;
1328     }
1329     parse(status);
1330     return;
1331
1332 cleanupVtzlines:
1333     delete vtzlines;
1334     vtzlines = NULL;
1335 }
1336
1337 // parser state
1338 #define INI 0   // Initial state
1339 #define VTZ 1   // In VTIMEZONE
1340 #define TZI 2   // In STANDARD or DAYLIGHT
1341
1342 #define DEF_DSTSAVINGS (60*60*1000)
1343 #define DEF_TZSTARTTIME (0.0)
1344
1345 void
1346 VTimeZone::parse(UErrorCode& status) {
1347     if (U_FAILURE(status)) {
1348         return;
1349     }
1350     if (vtzlines == NULL || vtzlines->size() == 0) {
1351         status = U_INVALID_STATE_ERROR;
1352         return;
1353     }
1354     InitialTimeZoneRule *initialRule = NULL;
1355     RuleBasedTimeZone *rbtz = NULL;
1356
1357     // timezone ID
1358     UnicodeString tzid;
1359
1360     int32_t state = INI;
1361     int32_t n = 0;
1362     UBool dst = FALSE;      // current zone type
1363     UnicodeString from;     // current zone from offset
1364     UnicodeString to;       // current zone offset
1365     UnicodeString zonename;   // current zone name
1366     UnicodeString dtstart;  // current zone starts
1367     UBool isRRULE = FALSE;  // true if the rule is described by RRULE
1368     int32_t initialRawOffset = 0;   // initial offset
1369     int32_t initialDSTSavings = 0;  // initial offset
1370     UDate firstStart = MAX_MILLIS;  // the earliest rule start time
1371     UnicodeString name;     // RFC2445 prop name
1372     UnicodeString value;    // RFC2445 prop value
1373
1374     UVector *dates = NULL;  // list of RDATE or RRULE strings
1375     UVector *rules = NULL;  // list of TimeZoneRule instances
1376
1377     int32_t finalRuleIdx = -1;
1378     int32_t finalRuleCount = 0;
1379
1380     rules = new UVector(status);
1381     if (U_FAILURE(status)) {
1382         goto cleanupParse;
1383     }
1384      // Set the deleter to remove TimeZoneRule vectors to avoid memory leaks due to unowned TimeZoneRules.
1385     rules->setDeleter(deleteTimeZoneRule);
1386
1387     dates = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status);
1388     if (U_FAILURE(status)) {
1389         goto cleanupParse;
1390     }
1391     if (rules == NULL || dates == NULL) {
1392         status = U_MEMORY_ALLOCATION_ERROR;
1393         goto cleanupParse;
1394     }
1395
1396     for (n = 0; n < vtzlines->size(); n++) {
1397         UnicodeString *line = (UnicodeString*)vtzlines->elementAt(n);
1398         int32_t valueSep = line->indexOf(COLON);
1399         if (valueSep < 0) {
1400             continue;
1401         }
1402         name.setTo(*line, 0, valueSep);
1403         value.setTo(*line, valueSep + 1);
1404
1405         switch (state) {
1406         case INI:
1407             if (name.compare(ICAL_BEGIN, -1) == 0
1408                 && value.compare(ICAL_VTIMEZONE, -1) == 0) {
1409                 state = VTZ;
1410             }
1411             break;
1412
1413         case VTZ:
1414             if (name.compare(ICAL_TZID, -1) == 0) {
1415                 tzid = value;
1416             } else if (name.compare(ICAL_TZURL, -1) == 0) {
1417                 tzurl = value;
1418             } else if (name.compare(ICAL_LASTMOD, -1) == 0) {
1419                 // Always in 'Z' format, so the offset argument for the parse method
1420                 // can be any value.
1421                 lastmod = parseDateTimeString(value, 0, status);
1422                 if (U_FAILURE(status)) {
1423                     goto cleanupParse;
1424                 }
1425             } else if (name.compare(ICAL_BEGIN, -1) == 0) {
1426                 UBool isDST = (value.compare(ICAL_DAYLIGHT, -1) == 0);
1427                 if (value.compare(ICAL_STANDARD, -1) == 0 || isDST) {
1428                     // tzid must be ready at this point
1429                     if (tzid.length() == 0) {
1430                         goto cleanupParse;
1431                     }
1432                     // initialize current zone properties
1433                     if (dates->size() != 0) {
1434                         dates->removeAllElements();
1435                     }
1436                     isRRULE = FALSE;
1437                     from.remove();
1438                     to.remove();
1439                     zonename.remove();
1440                     dst = isDST;
1441                     state = TZI;
1442                 } else {
1443                     // BEGIN property other than STANDARD/DAYLIGHT
1444                     // must not be there.
1445                     goto cleanupParse;
1446                 }
1447             } else if (name.compare(ICAL_END, -1) == 0) {
1448                 break;
1449             }
1450             break;
1451         case TZI:
1452             if (name.compare(ICAL_DTSTART, -1) == 0) {
1453                 dtstart = value;
1454             } else if (name.compare(ICAL_TZNAME, -1) == 0) {
1455                 zonename = value;
1456             } else if (name.compare(ICAL_TZOFFSETFROM, -1) == 0) {
1457                 from = value;
1458             } else if (name.compare(ICAL_TZOFFSETTO, -1) == 0) {
1459                 to = value;
1460             } else if (name.compare(ICAL_RDATE, -1) == 0) {
1461                 // RDATE mixed with RRULE is not supported
1462                 if (isRRULE) {
1463                     goto cleanupParse;
1464                 }
1465                 // RDATE value may contain multiple date delimited
1466                 // by comma
1467                 UBool nextDate = TRUE;
1468                 int32_t dstart = 0;
1469                 UnicodeString *dstr;
1470                 while (nextDate) {
1471                     int32_t dend = value.indexOf(COMMA, dstart);
1472                     if (dend == -1) {
1473                         dstr = new UnicodeString(value, dstart);
1474                         nextDate = FALSE;
1475                     } else {
1476                         dstr = new UnicodeString(value, dstart, dend - dstart);
1477                     }
1478                     dates->addElement(dstr, status);
1479                     if (U_FAILURE(status)) {
1480                         goto cleanupParse;
1481                     }
1482                     dstart = dend + 1;
1483                 }
1484             } else if (name.compare(ICAL_RRULE, -1) == 0) {
1485                 // RRULE mixed with RDATE is not supported
1486                 if (!isRRULE && dates->size() != 0) {
1487                     goto cleanupParse;
1488                 }
1489                 isRRULE = true;
1490                 dates->addElement(new UnicodeString(value), status);
1491                 if (U_FAILURE(status)) {
1492                     goto cleanupParse;
1493                 }
1494             } else if (name.compare(ICAL_END, -1) == 0) {
1495                 // Mandatory properties
1496                 if (dtstart.length() == 0 || from.length() == 0 || to.length() == 0) {
1497                     goto cleanupParse;
1498                 }
1499                 // if zonename is not available, create one from tzid
1500                 if (zonename.length() == 0) {
1501                     getDefaultTZName(tzid, dst, zonename);
1502                 }
1503
1504                 // create a time zone rule
1505                 TimeZoneRule *rule = NULL;
1506                 int32_t fromOffset = 0;
1507                 int32_t toOffset = 0;
1508                 int32_t rawOffset = 0;
1509                 int32_t dstSavings = 0;
1510                 UDate start = 0;
1511
1512                 // Parse TZOFFSETFROM/TZOFFSETTO
1513                 fromOffset = offsetStrToMillis(from, status);
1514                 toOffset = offsetStrToMillis(to, status);
1515                 if (U_FAILURE(status)) {
1516                     goto cleanupParse;
1517                 }
1518
1519                 if (dst) {
1520                     // If daylight, use the previous offset as rawoffset if positive
1521                     if (toOffset - fromOffset > 0) {
1522                         rawOffset = fromOffset;
1523                         dstSavings = toOffset - fromOffset;
1524                     } else {
1525                         // This is rare case..  just use 1 hour DST savings
1526                         rawOffset = toOffset - DEF_DSTSAVINGS;
1527                         dstSavings = DEF_DSTSAVINGS;
1528                     }
1529                 } else {
1530                     rawOffset = toOffset;
1531                     dstSavings = 0;
1532                 }
1533
1534                 // start time
1535                 start = parseDateTimeString(dtstart, fromOffset, status);
1536                 if (U_FAILURE(status)) {
1537                     goto cleanupParse;
1538                 }
1539
1540                 // Create the rule
1541                 UDate actualStart = MAX_MILLIS;
1542                 if (isRRULE) {
1543                     rule = createRuleByRRULE(zonename, rawOffset, dstSavings, start, dates, fromOffset, status);
1544                 } else {
1545                     rule = createRuleByRDATE(zonename, rawOffset, dstSavings, start, dates, fromOffset, status);
1546                 }
1547                 if (U_FAILURE(status) || rule == NULL) {
1548                     goto cleanupParse;
1549                 } else {
1550                     UBool startAvail = rule->getFirstStart(fromOffset, 0, actualStart);
1551                     if (startAvail && actualStart < firstStart) {
1552                         // save from offset information for the earliest rule
1553                         firstStart = actualStart;
1554                         // If this is STD, assume the time before this transtion
1555                         // is DST when the difference is 1 hour.  This might not be
1556                         // accurate, but VTIMEZONE data does not have such info.
1557                         if (dstSavings > 0) {
1558                             initialRawOffset = fromOffset;
1559                             initialDSTSavings = 0;
1560                         } else {
1561                             if (fromOffset - toOffset == DEF_DSTSAVINGS) {
1562                                 initialRawOffset = fromOffset - DEF_DSTSAVINGS;
1563                                 initialDSTSavings = DEF_DSTSAVINGS;
1564                             } else {
1565                                 initialRawOffset = fromOffset;
1566                                 initialDSTSavings = 0;
1567                             }
1568                         }
1569                     }
1570                 }
1571                 rules->addElement(rule, status);
1572                 if (U_FAILURE(status)) {
1573                     goto cleanupParse;
1574                 }
1575                 state = VTZ;
1576             }
1577             break;
1578         }
1579     }
1580     // Must have at least one rule
1581     if (rules->size() == 0) {
1582         goto cleanupParse;
1583     }
1584
1585     // Create a initial rule
1586     getDefaultTZName(tzid, FALSE, zonename);
1587     initialRule = new InitialTimeZoneRule(zonename,
1588         initialRawOffset, initialDSTSavings);
1589     if (initialRule == NULL) {
1590         status = U_MEMORY_ALLOCATION_ERROR;
1591         goto cleanupParse;
1592     }
1593
1594     // Finally, create the RuleBasedTimeZone
1595     rbtz = new RuleBasedTimeZone(tzid, initialRule);
1596     if (rbtz == NULL) {
1597         status = U_MEMORY_ALLOCATION_ERROR;
1598         goto cleanupParse;
1599     }
1600     initialRule = NULL; // already adopted by RBTZ, no need to delete
1601
1602     for (n = 0; n < rules->size(); n++) {
1603         TimeZoneRule *r = (TimeZoneRule*)rules->elementAt(n);
1604         AnnualTimeZoneRule *atzrule = dynamic_cast<AnnualTimeZoneRule *>(r);
1605         if (atzrule != NULL) {
1606             if (atzrule->getEndYear() == AnnualTimeZoneRule::MAX_YEAR) {
1607                 finalRuleCount++;
1608                 finalRuleIdx = n;
1609             }
1610         }
1611     }
1612     if (finalRuleCount > 2) {
1613         // Too many final rules
1614         status = U_ILLEGAL_ARGUMENT_ERROR;
1615         goto cleanupParse;
1616     }
1617
1618     if (finalRuleCount == 1) {
1619         if (rules->size() == 1) {
1620             // Only one final rule, only governs the initial rule,
1621             // which is already initialized, thus, we do not need to
1622             // add this transition rule
1623             rules->removeAllElements();
1624         } else {
1625             // Normalize the final rule
1626             AnnualTimeZoneRule *finalRule = (AnnualTimeZoneRule*)rules->elementAt(finalRuleIdx);
1627             int32_t tmpRaw = finalRule->getRawOffset();
1628             int32_t tmpDST = finalRule->getDSTSavings();
1629
1630             // Find the last non-final rule
1631             UDate finalStart, start;
1632             finalRule->getFirstStart(initialRawOffset, initialDSTSavings, finalStart);
1633             start = finalStart;
1634             for (n = 0; n < rules->size(); n++) {
1635                 if (finalRuleIdx == n) {
1636                     continue;
1637                 }
1638                 TimeZoneRule *r = (TimeZoneRule*)rules->elementAt(n);
1639                 UDate lastStart;
1640                 r->getFinalStart(tmpRaw, tmpDST, lastStart);
1641                 if (lastStart > start) {
1642                     finalRule->getNextStart(lastStart,
1643                         r->getRawOffset(),
1644                         r->getDSTSavings(),
1645                         FALSE,
1646                         start);
1647                 }
1648             }
1649
1650             TimeZoneRule *newRule;
1651             UnicodeString tznam;
1652             if (start == finalStart) {
1653                 // Transform this into a single transition
1654                 newRule = new TimeArrayTimeZoneRule(
1655                         finalRule->getName(tznam),
1656                         finalRule->getRawOffset(),
1657                         finalRule->getDSTSavings(),
1658                         &finalStart,
1659                         1,
1660                         DateTimeRule::UTC_TIME);
1661             } else {
1662                 // Update the end year
1663                 int32_t y, m, d, dow, doy, mid;
1664                 Grego::timeToFields(start, y, m, d, dow, doy, mid);
1665                 newRule = new AnnualTimeZoneRule(
1666                         finalRule->getName(tznam),
1667                         finalRule->getRawOffset(),
1668                         finalRule->getDSTSavings(),
1669                         *(finalRule->getRule()),
1670                         finalRule->getStartYear(),
1671                         y);
1672             }
1673             if (newRule == NULL) {
1674                 status = U_MEMORY_ALLOCATION_ERROR;
1675                 goto cleanupParse;
1676             }
1677             rules->removeElementAt(finalRuleIdx);
1678             rules->addElement(newRule, status);
1679             if (U_FAILURE(status)) {
1680                 delete newRule;
1681                 goto cleanupParse;
1682             }
1683         }
1684     }
1685
1686     while (!rules->isEmpty()) {
1687         TimeZoneRule *tzr = (TimeZoneRule*)rules->orphanElementAt(0);
1688         rbtz->addTransitionRule(tzr, status);
1689         if (U_FAILURE(status)) {
1690             goto cleanupParse;
1691         }
1692     }
1693     rbtz->complete(status);
1694     if (U_FAILURE(status)) {
1695         goto cleanupParse;
1696     }
1697     delete rules;
1698     delete dates;
1699
1700     tz = rbtz;
1701     setID(tzid);
1702     return;
1703
1704 cleanupParse:
1705     if (rules != NULL) {
1706         while (!rules->isEmpty()) {
1707             TimeZoneRule *r = (TimeZoneRule*)rules->orphanElementAt(0);
1708             delete r;
1709         }
1710         delete rules;
1711     }
1712     if (dates != NULL) {
1713         delete dates;
1714     }
1715     if (initialRule != NULL) {
1716         delete initialRule;
1717     }
1718     if (rbtz != NULL) {
1719         delete rbtz;
1720     }
1721     return;
1722 }
1723
1724 void
1725 VTimeZone::write(VTZWriter& writer, UErrorCode& status) const {
1726     if (vtzlines != NULL) {
1727         for (int32_t i = 0; i < vtzlines->size(); i++) {
1728             UnicodeString *line = (UnicodeString*)vtzlines->elementAt(i);
1729             if (line->startsWith(ICAL_TZURL, -1)
1730                 && line->charAt(u_strlen(ICAL_TZURL)) == COLON) {
1731                 writer.write(ICAL_TZURL);
1732                 writer.write(COLON);
1733                 writer.write(tzurl);
1734                 writer.write(ICAL_NEWLINE);
1735             } else if (line->startsWith(ICAL_LASTMOD, -1)
1736                 && line->charAt(u_strlen(ICAL_LASTMOD)) == COLON) {
1737                 UnicodeString utcString;
1738                 writer.write(ICAL_LASTMOD);
1739                 writer.write(COLON);
1740                 writer.write(getUTCDateTimeString(lastmod, utcString));
1741                 writer.write(ICAL_NEWLINE);
1742             } else {
1743                 writer.write(*line);
1744                 writer.write(ICAL_NEWLINE);
1745             }
1746         }
1747     } else {
1748         UVector *customProps = NULL;
1749         if (olsonzid.length() > 0 && icutzver.length() > 0) {
1750             customProps = new UVector(uprv_deleteUObject, uhash_compareUnicodeString, status);
1751             if (U_FAILURE(status)) {
1752                 return;
1753             }
1754             UnicodeString *icutzprop = new UnicodeString(ICU_TZINFO_PROP);
1755             icutzprop->append(olsonzid);
1756             icutzprop->append((UChar)0x005B/*'['*/);
1757             icutzprop->append(icutzver);
1758             icutzprop->append((UChar)0x005D/*']'*/);
1759             customProps->addElement(icutzprop, status);
1760             if (U_FAILURE(status)) {
1761                 delete icutzprop;
1762                 delete customProps;
1763                 return;
1764             }
1765         }
1766         writeZone(writer, *tz, customProps, status);
1767         delete customProps;
1768     }
1769 }
1770
1771 void
1772 VTimeZone::write(UDate start, VTZWriter& writer, UErrorCode& status) const {
1773     if (U_FAILURE(status)) {
1774         return;
1775     }
1776     InitialTimeZoneRule *initial = NULL;
1777     UVector *transitionRules = NULL;
1778     UVector customProps(uprv_deleteUObject, uhash_compareUnicodeString, status);
1779     UnicodeString tzid;
1780
1781     // Extract rules applicable to dates after the start time
1782     getTimeZoneRulesAfter(start, initial, transitionRules, status);
1783     if (U_FAILURE(status)) {
1784         return;
1785     }
1786
1787     // Create a RuleBasedTimeZone with the subset rule
1788     getID(tzid);
1789     RuleBasedTimeZone rbtz(tzid, initial);
1790     if (transitionRules != NULL) {
1791         while (!transitionRules->isEmpty()) {
1792             TimeZoneRule *tr = (TimeZoneRule*)transitionRules->orphanElementAt(0);
1793             rbtz.addTransitionRule(tr, status);
1794             if (U_FAILURE(status)) {
1795                 goto cleanupWritePartial;
1796             }
1797         }
1798         delete transitionRules;
1799         transitionRules = NULL;
1800     }
1801     rbtz.complete(status);
1802     if (U_FAILURE(status)) {
1803         goto cleanupWritePartial;
1804     }
1805
1806     if (olsonzid.length() > 0 && icutzver.length() > 0) {
1807         UnicodeString *icutzprop = new UnicodeString(ICU_TZINFO_PROP);
1808         icutzprop->append(olsonzid);
1809         icutzprop->append((UChar)0x005B/*'['*/);
1810         icutzprop->append(icutzver);
1811         icutzprop->append(ICU_TZINFO_PARTIAL, -1);
1812         appendMillis(start, *icutzprop);
1813         icutzprop->append((UChar)0x005D/*']'*/);
1814         customProps.addElement(icutzprop, status);
1815         if (U_FAILURE(status)) {
1816             delete icutzprop;
1817             goto cleanupWritePartial;
1818         }
1819     }
1820     writeZone(writer, rbtz, &customProps, status);
1821     return;
1822
1823 cleanupWritePartial:
1824     if (initial != NULL) {
1825         delete initial;
1826     }
1827     if (transitionRules != NULL) {
1828         while (!transitionRules->isEmpty()) {
1829             TimeZoneRule *tr = (TimeZoneRule*)transitionRules->orphanElementAt(0);
1830             delete tr;
1831         }
1832         delete transitionRules;
1833     }
1834 }
1835
1836 void
1837 VTimeZone::writeSimple(UDate time, VTZWriter& writer, UErrorCode& status) const {
1838     if (U_FAILURE(status)) {
1839         return;
1840     }
1841
1842     UVector customProps(uprv_deleteUObject, uhash_compareUnicodeString, status);
1843     UnicodeString tzid;
1844
1845     // Extract simple rules
1846     InitialTimeZoneRule *initial = NULL;
1847     AnnualTimeZoneRule *std = NULL, *dst = NULL;
1848     getSimpleRulesNear(time, initial, std, dst, status);
1849     if (U_SUCCESS(status)) {
1850         // Create a RuleBasedTimeZone with the subset rule
1851         getID(tzid);
1852         RuleBasedTimeZone rbtz(tzid, initial);
1853         if (std != NULL && dst != NULL) {
1854             rbtz.addTransitionRule(std, status);
1855             rbtz.addTransitionRule(dst, status);
1856         }
1857         if (U_FAILURE(status)) {
1858             goto cleanupWriteSimple;
1859         }
1860
1861         if (olsonzid.length() > 0 && icutzver.length() > 0) {
1862             UnicodeString *icutzprop = new UnicodeString(ICU_TZINFO_PROP);
1863             icutzprop->append(olsonzid);
1864             icutzprop->append((UChar)0x005B/*'['*/);
1865             icutzprop->append(icutzver);
1866             icutzprop->append(ICU_TZINFO_SIMPLE, -1);
1867             appendMillis(time, *icutzprop);
1868             icutzprop->append((UChar)0x005D/*']'*/);
1869             customProps.addElement(icutzprop, status);
1870             if (U_FAILURE(status)) {
1871                 delete icutzprop;
1872                 goto cleanupWriteSimple;
1873             }
1874         }
1875         writeZone(writer, rbtz, &customProps, status);
1876     }
1877     return;
1878
1879 cleanupWriteSimple:
1880     if (initial != NULL) {
1881         delete initial;
1882     }
1883     if (std != NULL) {
1884         delete std;
1885     }
1886     if (dst != NULL) {
1887         delete dst;
1888     }
1889 }
1890
1891 void
1892 VTimeZone::writeZone(VTZWriter& w, BasicTimeZone& basictz,
1893                      UVector* customProps, UErrorCode& status) const {
1894     if (U_FAILURE(status)) {
1895         return;
1896     }
1897     writeHeaders(w, status);
1898     if (U_FAILURE(status)) {
1899         return;
1900     }
1901
1902     if (customProps != NULL) {
1903         for (int32_t i = 0; i < customProps->size(); i++) {
1904             UnicodeString *custprop = (UnicodeString*)customProps->elementAt(i);
1905             w.write(*custprop);
1906             w.write(ICAL_NEWLINE);
1907         }
1908     }
1909
1910     UDate t = MIN_MILLIS;
1911     UnicodeString dstName;
1912     int32_t dstFromOffset = 0;
1913     int32_t dstFromDSTSavings = 0;
1914     int32_t dstToOffset = 0;
1915     int32_t dstStartYear = 0;
1916     int32_t dstMonth = 0;
1917     int32_t dstDayOfWeek = 0;
1918     int32_t dstWeekInMonth = 0;
1919     int32_t dstMillisInDay = 0;
1920     UDate dstStartTime = 0.0;
1921     UDate dstUntilTime = 0.0;
1922     int32_t dstCount = 0;
1923     AnnualTimeZoneRule *finalDstRule = NULL;
1924
1925     UnicodeString stdName;
1926     int32_t stdFromOffset = 0;
1927     int32_t stdFromDSTSavings = 0;
1928     int32_t stdToOffset = 0;
1929     int32_t stdStartYear = 0;
1930     int32_t stdMonth = 0;
1931     int32_t stdDayOfWeek = 0;
1932     int32_t stdWeekInMonth = 0;
1933     int32_t stdMillisInDay = 0;
1934     UDate stdStartTime = 0.0;
1935     UDate stdUntilTime = 0.0;
1936     int32_t stdCount = 0;
1937     AnnualTimeZoneRule *finalStdRule = NULL;
1938
1939     int32_t year, month, dom, dow, doy, mid;
1940     UBool hasTransitions = FALSE;
1941     TimeZoneTransition tzt;
1942     UBool tztAvail;
1943     UnicodeString name;
1944     UBool isDst;
1945
1946     // Going through all transitions
1947     while (TRUE) {
1948         tztAvail = basictz.getNextTransition(t, FALSE, tzt);
1949         if (!tztAvail) {
1950             break;
1951         }
1952         hasTransitions = TRUE;
1953         t = tzt.getTime();
1954         tzt.getTo()->getName(name);
1955         isDst = (tzt.getTo()->getDSTSavings() != 0);
1956         int32_t fromOffset = tzt.getFrom()->getRawOffset() + tzt.getFrom()->getDSTSavings();
1957         int32_t fromDSTSavings = tzt.getFrom()->getDSTSavings();
1958         int32_t toOffset = tzt.getTo()->getRawOffset() + tzt.getTo()->getDSTSavings();
1959         Grego::timeToFields(tzt.getTime() + fromOffset, year, month, dom, dow, doy, mid);
1960         int32_t weekInMonth = Grego::dayOfWeekInMonth(year, month, dom);
1961         UBool sameRule = FALSE;
1962         const AnnualTimeZoneRule *atzrule;
1963         if (isDst) {
1964             if (finalDstRule == NULL
1965                 && (atzrule = dynamic_cast<const AnnualTimeZoneRule *>(tzt.getTo())) != NULL
1966                 && atzrule->getEndYear() == AnnualTimeZoneRule::MAX_YEAR
1967             ) {
1968                 finalDstRule = (AnnualTimeZoneRule*)tzt.getTo()->clone();
1969             }
1970             if (dstCount > 0) {
1971                 if (year == dstStartYear + dstCount
1972                         && name.compare(dstName) == 0
1973                         && dstFromOffset == fromOffset
1974                         && dstToOffset == toOffset
1975                         && dstMonth == month
1976                         && dstDayOfWeek == dow
1977                         && dstWeekInMonth == weekInMonth
1978                         && dstMillisInDay == mid) {
1979                     // Update until time
1980                     dstUntilTime = t;
1981                     dstCount++;
1982                     sameRule = TRUE;
1983                 }
1984                 if (!sameRule) {
1985                     if (dstCount == 1) {
1986                         writeZonePropsByTime(w, TRUE, dstName, dstFromOffset, dstToOffset, dstStartTime,
1987                                 TRUE, status);
1988                     } else {
1989                         writeZonePropsByDOW(w, TRUE, dstName, dstFromOffset, dstToOffset,
1990                                 dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, dstUntilTime, status);
1991                     }
1992                     if (U_FAILURE(status)) {
1993                         goto cleanupWriteZone;
1994                     }
1995                 }
1996             }
1997             if (!sameRule) {
1998                 // Reset this DST information
1999                 dstName = name;
2000                 dstFromOffset = fromOffset;
2001                 dstFromDSTSavings = fromDSTSavings;
2002                 dstToOffset = toOffset;
2003                 dstStartYear = year;
2004                 dstMonth = month;
2005                 dstDayOfWeek = dow;
2006                 dstWeekInMonth = weekInMonth;
2007                 dstMillisInDay = mid;
2008                 dstStartTime = dstUntilTime = t;
2009                 dstCount = 1;
2010             }
2011             if (finalStdRule != NULL && finalDstRule != NULL) {
2012                 break;
2013             }
2014         } else {
2015             if (finalStdRule == NULL
2016                 && (atzrule = dynamic_cast<const AnnualTimeZoneRule *>(tzt.getTo())) != NULL
2017                 && atzrule->getEndYear() == AnnualTimeZoneRule::MAX_YEAR
2018             ) {
2019                 finalStdRule = (AnnualTimeZoneRule*)tzt.getTo()->clone();
2020             }
2021             if (stdCount > 0) {
2022                 if (year == stdStartYear + stdCount
2023                         && name.compare(stdName) == 0
2024                         && stdFromOffset == fromOffset
2025                         && stdToOffset == toOffset
2026                         && stdMonth == month
2027                         && stdDayOfWeek == dow
2028                         && stdWeekInMonth == weekInMonth
2029                         && stdMillisInDay == mid) {
2030                     // Update until time
2031                     stdUntilTime = t;
2032                     stdCount++;
2033                     sameRule = TRUE;
2034                 }
2035                 if (!sameRule) {
2036                     if (stdCount == 1) {
2037                         writeZonePropsByTime(w, FALSE, stdName, stdFromOffset, stdToOffset, stdStartTime,
2038                                 TRUE, status);
2039                     } else {
2040                         writeZonePropsByDOW(w, FALSE, stdName, stdFromOffset, stdToOffset,
2041                                 stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, stdUntilTime, status);
2042                     }
2043                     if (U_FAILURE(status)) {
2044                         goto cleanupWriteZone;
2045                     }
2046                 }
2047             }
2048             if (!sameRule) {
2049                 // Reset this STD information
2050                 stdName = name;
2051                 stdFromOffset = fromOffset;
2052                 stdFromDSTSavings = fromDSTSavings;
2053                 stdToOffset = toOffset;
2054                 stdStartYear = year;
2055                 stdMonth = month;
2056                 stdDayOfWeek = dow;
2057                 stdWeekInMonth = weekInMonth;
2058                 stdMillisInDay = mid;
2059                 stdStartTime = stdUntilTime = t;
2060                 stdCount = 1;
2061             }
2062             if (finalStdRule != NULL && finalDstRule != NULL) {
2063                 break;
2064             }
2065         }
2066     }
2067     if (!hasTransitions) {
2068         // No transition - put a single non transition RDATE
2069         int32_t raw, dst, offset;
2070         basictz.getOffset(0.0/*any time*/, FALSE, raw, dst, status);
2071         if (U_FAILURE(status)) {
2072             goto cleanupWriteZone;
2073         }
2074         offset = raw + dst;
2075         isDst = (dst != 0);
2076         UnicodeString tzid;
2077         basictz.getID(tzid);
2078         getDefaultTZName(tzid, isDst, name);
2079         writeZonePropsByTime(w, isDst, name,
2080                 offset, offset, DEF_TZSTARTTIME - offset, FALSE, status);
2081         if (U_FAILURE(status)) {
2082             goto cleanupWriteZone;
2083         }
2084     } else {
2085         if (dstCount > 0) {
2086             if (finalDstRule == NULL) {
2087                 if (dstCount == 1) {
2088                     writeZonePropsByTime(w, TRUE, dstName, dstFromOffset, dstToOffset, dstStartTime,
2089                             TRUE, status);
2090                 } else {
2091                     writeZonePropsByDOW(w, TRUE, dstName, dstFromOffset, dstToOffset,
2092                             dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, dstUntilTime, status);
2093                 }
2094                 if (U_FAILURE(status)) {
2095                     goto cleanupWriteZone;
2096                 }
2097             } else {
2098                 if (dstCount == 1) {
2099                     writeFinalRule(w, TRUE, finalDstRule,
2100                             dstFromOffset - dstFromDSTSavings, dstFromDSTSavings, dstStartTime, status);
2101                 } else {
2102                     // Use a single rule if possible
2103                     if (isEquivalentDateRule(dstMonth, dstWeekInMonth, dstDayOfWeek, finalDstRule->getRule())) {
2104                         writeZonePropsByDOW(w, TRUE, dstName, dstFromOffset, dstToOffset,
2105                                 dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, MAX_MILLIS, status);
2106                     } else {
2107                         // Not equivalent rule - write out two different rules
2108                         writeZonePropsByDOW(w, TRUE, dstName, dstFromOffset, dstToOffset,
2109                                 dstMonth, dstWeekInMonth, dstDayOfWeek, dstStartTime, dstUntilTime, status);
2110                         if (U_FAILURE(status)) {
2111                             goto cleanupWriteZone;
2112                         }
2113                         UDate nextStart;
2114                         UBool nextStartAvail = finalDstRule->getNextStart(dstUntilTime, dstFromOffset - dstFromDSTSavings, dstFromDSTSavings, false, nextStart);
2115                         U_ASSERT(nextStartAvail);
2116                         if (nextStartAvail) {
2117                             writeFinalRule(w, TRUE, finalDstRule,
2118                                     dstFromOffset - dstFromDSTSavings, dstFromDSTSavings, nextStart, status);
2119                         }
2120                     }
2121                 }
2122                 if (U_FAILURE(status)) {
2123                     goto cleanupWriteZone;
2124                 }
2125             }
2126         }
2127         if (stdCount > 0) {
2128             if (finalStdRule == NULL) {
2129                 if (stdCount == 1) {
2130                     writeZonePropsByTime(w, FALSE, stdName, stdFromOffset, stdToOffset, stdStartTime,
2131                             TRUE, status);
2132                 } else {
2133                     writeZonePropsByDOW(w, FALSE, stdName, stdFromOffset, stdToOffset,
2134                             stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, stdUntilTime, status);
2135                 }
2136                 if (U_FAILURE(status)) {
2137                     goto cleanupWriteZone;
2138                 }
2139             } else {
2140                 if (stdCount == 1) {
2141                     writeFinalRule(w, FALSE, finalStdRule,
2142                             stdFromOffset - stdFromDSTSavings, stdFromDSTSavings, stdStartTime, status);
2143                 } else {
2144                     // Use a single rule if possible
2145                     if (isEquivalentDateRule(stdMonth, stdWeekInMonth, stdDayOfWeek, finalStdRule->getRule())) {
2146                         writeZonePropsByDOW(w, FALSE, stdName, stdFromOffset, stdToOffset,
2147                                 stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, MAX_MILLIS, status);
2148                     } else {
2149                         // Not equivalent rule - write out two different rules
2150                         writeZonePropsByDOW(w, FALSE, stdName, stdFromOffset, stdToOffset,
2151                                 stdMonth, stdWeekInMonth, stdDayOfWeek, stdStartTime, stdUntilTime, status);
2152                         if (U_FAILURE(status)) {
2153                             goto cleanupWriteZone;
2154                         }
2155                         UDate nextStart;
2156                         UBool nextStartAvail = finalStdRule->getNextStart(stdUntilTime, stdFromOffset - stdFromDSTSavings, stdFromDSTSavings, false, nextStart);
2157                         U_ASSERT(nextStartAvail);
2158                         if (nextStartAvail) {
2159                             writeFinalRule(w, FALSE, finalStdRule,
2160                                     stdFromOffset - stdFromDSTSavings, stdFromDSTSavings, nextStart, status);
2161                         }
2162                     }
2163                 }
2164                 if (U_FAILURE(status)) {
2165                     goto cleanupWriteZone;
2166                 }
2167             }
2168         }
2169     }
2170     writeFooter(w, status);
2171
2172 cleanupWriteZone:
2173
2174     if (finalStdRule != NULL) {
2175         delete finalStdRule;
2176     }
2177     if (finalDstRule != NULL) {
2178         delete finalDstRule;
2179     }
2180 }
2181
2182 void
2183 VTimeZone::writeHeaders(VTZWriter& writer, UErrorCode& status) const {
2184     if (U_FAILURE(status)) {
2185         return;
2186     }
2187     UnicodeString tzid;
2188     tz->getID(tzid);
2189
2190     writer.write(ICAL_BEGIN);
2191     writer.write(COLON);
2192     writer.write(ICAL_VTIMEZONE);
2193     writer.write(ICAL_NEWLINE);
2194     writer.write(ICAL_TZID);
2195     writer.write(COLON);
2196     writer.write(tzid);
2197     writer.write(ICAL_NEWLINE);
2198     if (tzurl.length() != 0) {
2199         writer.write(ICAL_TZURL);
2200         writer.write(COLON);
2201         writer.write(tzurl);
2202         writer.write(ICAL_NEWLINE);
2203     }
2204     if (lastmod != MAX_MILLIS) {
2205         UnicodeString lastmodStr;
2206         writer.write(ICAL_LASTMOD);
2207         writer.write(COLON);
2208         writer.write(getUTCDateTimeString(lastmod, lastmodStr));
2209         writer.write(ICAL_NEWLINE);
2210     }
2211 }
2212
2213 /*
2214  * Write the closing section of the VTIMEZONE definition block
2215  */
2216 void
2217 VTimeZone::writeFooter(VTZWriter& writer, UErrorCode& status) const {
2218     if (U_FAILURE(status)) {
2219         return;
2220     }
2221     writer.write(ICAL_END);
2222     writer.write(COLON);
2223     writer.write(ICAL_VTIMEZONE);
2224     writer.write(ICAL_NEWLINE);
2225 }
2226
2227 /*
2228  * Write a single start time
2229  */
2230 void
2231 VTimeZone::writeZonePropsByTime(VTZWriter& writer, UBool isDst, const UnicodeString& zonename,
2232                                 int32_t fromOffset, int32_t toOffset, UDate time, UBool withRDATE,
2233                                 UErrorCode& status) const {
2234     if (U_FAILURE(status)) {
2235         return;
2236     }
2237     beginZoneProps(writer, isDst, zonename, fromOffset, toOffset, time, status);
2238     if (U_FAILURE(status)) {
2239         return;
2240     }
2241     if (withRDATE) {
2242         writer.write(ICAL_RDATE);
2243         writer.write(COLON);
2244         UnicodeString timestr;
2245         writer.write(getDateTimeString(time + fromOffset, timestr));
2246         writer.write(ICAL_NEWLINE);
2247     }
2248     endZoneProps(writer, isDst, status);
2249     if (U_FAILURE(status)) {
2250         return;
2251     }
2252 }
2253
2254 /*
2255  * Write start times defined by a DOM rule using VTIMEZONE RRULE
2256  */
2257 void
2258 VTimeZone::writeZonePropsByDOM(VTZWriter& writer, UBool isDst, const UnicodeString& zonename,
2259                                int32_t fromOffset, int32_t toOffset,
2260                                int32_t month, int32_t dayOfMonth, UDate startTime, UDate untilTime,
2261                                UErrorCode& status) const {
2262     if (U_FAILURE(status)) {
2263         return;
2264     }
2265     beginZoneProps(writer, isDst, zonename, fromOffset, toOffset, startTime, status);
2266     if (U_FAILURE(status)) {
2267         return;
2268     }
2269     beginRRULE(writer, month, status);
2270     if (U_FAILURE(status)) {
2271         return;
2272     }
2273     writer.write(ICAL_BYMONTHDAY);
2274     writer.write(EQUALS_SIGN);
2275     UnicodeString dstr;
2276     appendAsciiDigits(dayOfMonth, 0, dstr);
2277     writer.write(dstr);
2278     if (untilTime != MAX_MILLIS) {
2279         appendUNTIL(writer, getDateTimeString(untilTime + fromOffset, dstr), status);
2280         if (U_FAILURE(status)) {
2281             return;
2282         }
2283     }
2284     writer.write(ICAL_NEWLINE);
2285     endZoneProps(writer, isDst, status);
2286 }
2287
2288 /*
2289  * Write start times defined by a DOW rule using VTIMEZONE RRULE
2290  */
2291 void
2292 VTimeZone::writeZonePropsByDOW(VTZWriter& writer, UBool isDst, const UnicodeString& zonename,
2293                                int32_t fromOffset, int32_t toOffset,
2294                                int32_t month, int32_t weekInMonth, int32_t dayOfWeek,
2295                                UDate startTime, UDate untilTime, UErrorCode& status) const {
2296     if (U_FAILURE(status)) {
2297         return;
2298     }
2299     beginZoneProps(writer, isDst, zonename, fromOffset, toOffset, startTime, status);
2300     if (U_FAILURE(status)) {
2301         return;
2302     }
2303     beginRRULE(writer, month, status);
2304     if (U_FAILURE(status)) {
2305         return;
2306     }
2307     writer.write(ICAL_BYDAY);
2308     writer.write(EQUALS_SIGN);
2309     UnicodeString dstr;
2310     appendAsciiDigits(weekInMonth, 0, dstr);
2311     writer.write(dstr);    // -4, -3, -2, -1, 1, 2, 3, 4
2312     writer.write(ICAL_DOW_NAMES[dayOfWeek - 1]);    // SU, MO, TU...
2313
2314     if (untilTime != MAX_MILLIS) {
2315         appendUNTIL(writer, getDateTimeString(untilTime + fromOffset, dstr), status);
2316         if (U_FAILURE(status)) {
2317             return;
2318         }
2319     }
2320     writer.write(ICAL_NEWLINE);
2321     endZoneProps(writer, isDst, status);
2322 }
2323
2324 /*
2325  * Write start times defined by a DOW_GEQ_DOM rule using VTIMEZONE RRULE
2326  */
2327 void
2328 VTimeZone::writeZonePropsByDOW_GEQ_DOM(VTZWriter& writer, UBool isDst, const UnicodeString& zonename,
2329                                        int32_t fromOffset, int32_t toOffset,
2330                                        int32_t month, int32_t dayOfMonth, int32_t dayOfWeek,
2331                                        UDate startTime, UDate untilTime, UErrorCode& status) const {
2332     if (U_FAILURE(status)) {
2333         return;
2334     }
2335     // Check if this rule can be converted to DOW rule
2336     if (dayOfMonth%7 == 1) {
2337         // Can be represented by DOW rule
2338         writeZonePropsByDOW(writer, isDst, zonename, fromOffset, toOffset,
2339                 month, (dayOfMonth + 6)/7, dayOfWeek, startTime, untilTime, status);
2340         if (U_FAILURE(status)) {
2341             return;
2342         }
2343     } else if (month != UCAL_FEBRUARY && (MONTHLENGTH[month] - dayOfMonth)%7 == 6) {
2344         // Can be represented by DOW rule with negative week number
2345         writeZonePropsByDOW(writer, isDst, zonename, fromOffset, toOffset,
2346                 month, -1*((MONTHLENGTH[month] - dayOfMonth + 1)/7), dayOfWeek, startTime, untilTime, status);
2347         if (U_FAILURE(status)) {
2348             return;
2349         }
2350     } else {
2351         // Otherwise, use BYMONTHDAY to include all possible dates
2352         beginZoneProps(writer, isDst, zonename, fromOffset, toOffset, startTime, status);
2353         if (U_FAILURE(status)) {
2354             return;
2355         }
2356         // Check if all days are in the same month
2357         int32_t startDay = dayOfMonth;
2358         int32_t currentMonthDays = 7;
2359
2360         if (dayOfMonth <= 0) {
2361             // The start day is in previous month
2362             int32_t prevMonthDays = 1 - dayOfMonth;
2363             currentMonthDays -= prevMonthDays;
2364
2365             int32_t prevMonth = (month - 1) < 0 ? 11 : month - 1;
2366
2367             // Note: When a rule is separated into two, UNTIL attribute needs to be
2368             // calculated for each of them.  For now, we skip this, because we basically use this method
2369             // only for final rules, which does not have the UNTIL attribute
2370             writeZonePropsByDOW_GEQ_DOM_sub(writer, prevMonth, -prevMonthDays, dayOfWeek, prevMonthDays,
2371                 MAX_MILLIS /* Do not use UNTIL */, fromOffset, status);
2372             if (U_FAILURE(status)) {
2373                 return;
2374             }
2375
2376             // Start from 1 for the rest
2377             startDay = 1;
2378         } else if (dayOfMonth + 6 > MONTHLENGTH[month]) {
2379             // Note: This code does not actually work well in February.  For now, days in month in
2380             // non-leap year.
2381             int32_t nextMonthDays = dayOfMonth + 6 - MONTHLENGTH[month];
2382             currentMonthDays -= nextMonthDays;
2383
2384             int32_t nextMonth = (month + 1) > 11 ? 0 : month + 1;
2385
2386             writeZonePropsByDOW_GEQ_DOM_sub(writer, nextMonth, 1, dayOfWeek, nextMonthDays,
2387                 MAX_MILLIS /* Do not use UNTIL */, fromOffset, status);
2388             if (U_FAILURE(status)) {
2389                 return;
2390             }
2391         }
2392         writeZonePropsByDOW_GEQ_DOM_sub(writer, month, startDay, dayOfWeek, currentMonthDays,
2393             untilTime, fromOffset, status);
2394         if (U_FAILURE(status)) {
2395             return;
2396         }
2397         endZoneProps(writer, isDst, status);
2398     }
2399 }
2400
2401 /*
2402  * Called from writeZonePropsByDOW_GEQ_DOM
2403  */
2404 void
2405 VTimeZone::writeZonePropsByDOW_GEQ_DOM_sub(VTZWriter& writer, int32_t month, int32_t dayOfMonth,
2406                                            int32_t dayOfWeek, int32_t numDays,
2407                                            UDate untilTime, int32_t fromOffset, UErrorCode& status) const {
2408
2409     if (U_FAILURE(status)) {
2410         return;
2411     }
2412     int32_t startDayNum = dayOfMonth;
2413     UBool isFeb = (month == UCAL_FEBRUARY);
2414     if (dayOfMonth < 0 && !isFeb) {
2415         // Use positive number if possible
2416         startDayNum = MONTHLENGTH[month] + dayOfMonth + 1;
2417     }
2418     beginRRULE(writer, month, status);
2419     if (U_FAILURE(status)) {
2420         return;
2421     }
2422     writer.write(ICAL_BYDAY);
2423     writer.write(EQUALS_SIGN);
2424     writer.write(ICAL_DOW_NAMES[dayOfWeek - 1]);    // SU, MO, TU...
2425     writer.write(SEMICOLON);
2426     writer.write(ICAL_BYMONTHDAY);
2427     writer.write(EQUALS_SIGN);
2428
2429     UnicodeString dstr;
2430     appendAsciiDigits(startDayNum, 0, dstr);
2431     writer.write(dstr);
2432     for (int32_t i = 1; i < numDays; i++) {
2433         writer.write(COMMA);
2434         dstr.remove();
2435         appendAsciiDigits(startDayNum + i, 0, dstr);
2436         writer.write(dstr);
2437     }
2438
2439     if (untilTime != MAX_MILLIS) {
2440         appendUNTIL(writer, getDateTimeString(untilTime + fromOffset, dstr), status);
2441         if (U_FAILURE(status)) {
2442             return;
2443         }
2444     }
2445     writer.write(ICAL_NEWLINE);
2446 }
2447
2448 /*
2449  * Write start times defined by a DOW_LEQ_DOM rule using VTIMEZONE RRULE
2450  */
2451 void
2452 VTimeZone::writeZonePropsByDOW_LEQ_DOM(VTZWriter& writer, UBool isDst, const UnicodeString& zonename,
2453                                        int32_t fromOffset, int32_t toOffset,
2454                                        int32_t month, int32_t dayOfMonth, int32_t dayOfWeek,
2455                                        UDate startTime, UDate untilTime, UErrorCode& status) const {
2456     if (U_FAILURE(status)) {
2457         return;
2458     }
2459     // Check if this rule can be converted to DOW rule
2460     if (dayOfMonth%7 == 0) {
2461         // Can be represented by DOW rule
2462         writeZonePropsByDOW(writer, isDst, zonename, fromOffset, toOffset,
2463                 month, dayOfMonth/7, dayOfWeek, startTime, untilTime, status);
2464     } else if (month != UCAL_FEBRUARY && (MONTHLENGTH[month] - dayOfMonth)%7 == 0){
2465         // Can be represented by DOW rule with negative week number
2466         writeZonePropsByDOW(writer, isDst, zonename, fromOffset, toOffset,
2467                 month, -1*((MONTHLENGTH[month] - dayOfMonth)/7 + 1), dayOfWeek, startTime, untilTime, status);
2468     } else if (month == UCAL_FEBRUARY && dayOfMonth == 29) {
2469         // Specical case for February
2470         writeZonePropsByDOW(writer, isDst, zonename, fromOffset, toOffset,
2471                 UCAL_FEBRUARY, -1, dayOfWeek, startTime, untilTime, status);
2472     } else {
2473         // Otherwise, convert this to DOW_GEQ_DOM rule
2474         writeZonePropsByDOW_GEQ_DOM(writer, isDst, zonename, fromOffset, toOffset,
2475                 month, dayOfMonth - 6, dayOfWeek, startTime, untilTime, status);
2476     }
2477 }
2478
2479 /*
2480  * Write the final time zone rule using RRULE, with no UNTIL attribute
2481  */
2482 void
2483 VTimeZone::writeFinalRule(VTZWriter& writer, UBool isDst, const AnnualTimeZoneRule* rule,
2484                           int32_t fromRawOffset, int32_t fromDSTSavings,
2485                           UDate startTime, UErrorCode& status) const {
2486     if (U_FAILURE(status)) {
2487         return;
2488     }
2489     UBool modifiedRule = TRUE;
2490     const DateTimeRule *dtrule = toWallTimeRule(rule->getRule(), fromRawOffset, fromDSTSavings);
2491     if (dtrule == NULL) {
2492         modifiedRule = FALSE;
2493         dtrule = rule->getRule();
2494     }
2495
2496     // If the rule's mills in a day is out of range, adjust start time.
2497     // Olson tzdata supports 24:00 of a day, but VTIMEZONE does not.
2498     // See ticket#7008/#7518
2499
2500     int32_t timeInDay = dtrule->getRuleMillisInDay();
2501     if (timeInDay < 0) {
2502         startTime = startTime + (0 - timeInDay);
2503     } else if (timeInDay >= U_MILLIS_PER_DAY) {
2504         startTime = startTime - (timeInDay - (U_MILLIS_PER_DAY - 1));
2505     }
2506
2507     int32_t toOffset = rule->getRawOffset() + rule->getDSTSavings();
2508     UnicodeString name;
2509     rule->getName(name);
2510     switch (dtrule->getDateRuleType()) {
2511     case DateTimeRule::DOM:
2512         writeZonePropsByDOM(writer, isDst, name, fromRawOffset + fromDSTSavings, toOffset,
2513                 dtrule->getRuleMonth(), dtrule->getRuleDayOfMonth(), startTime, MAX_MILLIS, status);
2514         break;
2515     case DateTimeRule::DOW:
2516         writeZonePropsByDOW(writer, isDst, name, fromRawOffset + fromDSTSavings, toOffset,
2517                 dtrule->getRuleMonth(), dtrule->getRuleWeekInMonth(), dtrule->getRuleDayOfWeek(), startTime, MAX_MILLIS, status);
2518         break;
2519     case DateTimeRule::DOW_GEQ_DOM:
2520         writeZonePropsByDOW_GEQ_DOM(writer, isDst, name, fromRawOffset + fromDSTSavings, toOffset,
2521                 dtrule->getRuleMonth(), dtrule->getRuleDayOfMonth(), dtrule->getRuleDayOfWeek(), startTime, MAX_MILLIS, status);
2522         break;
2523     case DateTimeRule::DOW_LEQ_DOM:
2524         writeZonePropsByDOW_LEQ_DOM(writer, isDst, name, fromRawOffset + fromDSTSavings, toOffset,
2525                 dtrule->getRuleMonth(), dtrule->getRuleDayOfMonth(), dtrule->getRuleDayOfWeek(), startTime, MAX_MILLIS, status);
2526         break;
2527     }
2528     if (modifiedRule) {
2529         delete dtrule;
2530     }
2531 }
2532
2533 /*
2534  * Write the opening section of zone properties
2535  */
2536 void
2537 VTimeZone::beginZoneProps(VTZWriter& writer, UBool isDst, const UnicodeString& zonename,
2538                           int32_t fromOffset, int32_t toOffset, UDate startTime, UErrorCode& status) const {
2539     if (U_FAILURE(status)) {
2540         return;
2541     }
2542     writer.write(ICAL_BEGIN);
2543     writer.write(COLON);
2544     if (isDst) {
2545         writer.write(ICAL_DAYLIGHT);
2546     } else {
2547         writer.write(ICAL_STANDARD);
2548     }
2549     writer.write(ICAL_NEWLINE);
2550
2551     UnicodeString dstr;
2552
2553     // TZOFFSETTO
2554     writer.write(ICAL_TZOFFSETTO);
2555     writer.write(COLON);
2556     millisToOffset(toOffset, dstr);
2557     writer.write(dstr);
2558     writer.write(ICAL_NEWLINE);
2559
2560     // TZOFFSETFROM
2561     writer.write(ICAL_TZOFFSETFROM);
2562     writer.write(COLON);
2563     millisToOffset(fromOffset, dstr);
2564     writer.write(dstr);
2565     writer.write(ICAL_NEWLINE);
2566
2567     // TZNAME
2568     writer.write(ICAL_TZNAME);
2569     writer.write(COLON);
2570     writer.write(zonename);
2571     writer.write(ICAL_NEWLINE);
2572
2573     // DTSTART
2574     writer.write(ICAL_DTSTART);
2575     writer.write(COLON);
2576     writer.write(getDateTimeString(startTime + fromOffset, dstr));
2577     writer.write(ICAL_NEWLINE);
2578 }
2579
2580 /*
2581  * Writes the closing section of zone properties
2582  */
2583 void
2584 VTimeZone::endZoneProps(VTZWriter& writer, UBool isDst, UErrorCode& status) const {
2585     if (U_FAILURE(status)) {
2586         return;
2587     }
2588     // END:STANDARD or END:DAYLIGHT
2589     writer.write(ICAL_END);
2590     writer.write(COLON);
2591     if (isDst) {
2592         writer.write(ICAL_DAYLIGHT);
2593     } else {
2594         writer.write(ICAL_STANDARD);
2595     }
2596     writer.write(ICAL_NEWLINE);
2597 }
2598
2599 /*
2600  * Write the beggining part of RRULE line
2601  */
2602 void
2603 VTimeZone::beginRRULE(VTZWriter& writer, int32_t month, UErrorCode& status) const {
2604     if (U_FAILURE(status)) {
2605         return;
2606     }
2607     UnicodeString dstr;
2608     writer.write(ICAL_RRULE);
2609     writer.write(COLON);
2610     writer.write(ICAL_FREQ);
2611     writer.write(EQUALS_SIGN);
2612     writer.write(ICAL_YEARLY);
2613     writer.write(SEMICOLON);
2614     writer.write(ICAL_BYMONTH);
2615     writer.write(EQUALS_SIGN);
2616     appendAsciiDigits(month + 1, 0, dstr);
2617     writer.write(dstr);
2618     writer.write(SEMICOLON);
2619 }
2620
2621 /*
2622  * Append the UNTIL attribute after RRULE line
2623  */
2624 void
2625 VTimeZone::appendUNTIL(VTZWriter& writer, const UnicodeString& until,  UErrorCode& status) const {
2626     if (U_FAILURE(status)) {
2627         return;
2628     }
2629     if (until.length() > 0) {
2630         writer.write(SEMICOLON);
2631         writer.write(ICAL_UNTIL);
2632         writer.write(EQUALS_SIGN);
2633         writer.write(until);
2634     }
2635 }
2636
2637 U_NAMESPACE_END
2638
2639 #endif /* #if !UCONFIG_NO_FORMATTING */
2640
2641 //eof